Changeset 9980


Ignore:
Timestamp:
Jul 10, 2008, 9:49:17 AM (11 years ago)
Author:
gb
Message:

Purify all ivectors (except MACPTRs.)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/working-0711/ccl/lisp-kernel/ppc-gc.c

    r7668 r9980  
    121121check_range(LispObj *start, LispObj *end, Boolean header_allowed)
    122122{
    123   LispObj node, *current = start, *prev;
     123  LispObj node, *current = start, *prev = NULL;
    124124  int tag;
    125125  natural elements;
     
    303303          ((hash_table_vector_header *) base)->cache_key = undefined;
    304304          ((hash_table_vector_header *) base)->cache_value = lisp_nil;
    305         }
    306         deref(ptr_to_lispobj(base),1) = GCweakvll;
    307         GCweakvll = n;
    308         return;
     305          mark_weak_htabv(n);
     306          return;
     307        }
    309308      }
    310309
     
    563562          ((hash_table_vector_header *) base)->cache_key = undefined;
    564563          ((hash_table_vector_header *) base)->cache_value = lisp_nil;
    565         }
    566         deref(ptr_to_lispobj(base),1) = GCweakvll;
    567         GCweakvll = n;
    568         return;
     564          mark_weak_htabv(n);
     565          return;
     566        }
    569567      }
    570568
     
    732730          ((hash_table_vector_header *) base)->cache_key = undefined;
    733731          ((hash_table_vector_header *) base)->cache_value = lisp_nil;
    734         }
    735 
    736         deref(ptr_to_lispobj(base),1) = GCweakvll;
    737         GCweakvll = this;
    738         goto Climb;
     732          dws_mark_weak_htabv(this);
     733          element_count = hash_table_vector_header_count;
     734        }
    739735      }
    740736
     
    990986          ((hash_table_vector_header *) start)->cache_key = undefined;
    991987          ((hash_table_vector_header *) start)->cache_value = lisp_nil;
    992         }
    993 
    994         start[1] = GCweakvll;
    995         GCweakvll = (LispObj) (((natural) start) + fulltag_misc);
    996       } else {
    997 
    998         if (subtag == subtag_pool) {
    999           start[1] = lisp_nil;
    1000         }
    1001 
    1002         if (subtag == subtag_weak) {
    1003           natural weak_type = (natural) start[2];
    1004           if (weak_type >> population_termination_bit)
    1005             element_count -= 2;
    1006           else
    1007             element_count -= 1;
    1008           start[1] = GCweakvll;
    1009           GCweakvll = (LispObj) (((natural) start) + fulltag_misc);   
    1010         }
    1011 
    1012         base = start + element_count + 1;
    1013         while(element_count--) {
    1014           mark_root(*--base);
    1015         }
    1016       }
     988          mark_weak_htabv((LispObj)start);
     989          element_count = 0;
     990        }
     991      }
     992      if (subtag == subtag_pool) {
     993        start[1] = lisp_nil;
     994      }
     995
     996      if (subtag == subtag_weak) {
     997        natural weak_type = (natural) start[2];
     998        if (weak_type >> population_termination_bit)
     999          element_count -= 2;
     1000        else
     1001          element_count -= 1;
     1002        start[1] = GCweakvll;
     1003        GCweakvll = (LispObj) (((natural) start) + fulltag_misc);   
     1004      }
     1005
     1006      base = start + element_count + 1;
     1007      while(element_count--) {
     1008        mark_root(*--base);
     1009      }   
    10171010      start += size;
    10181011    }
     
    17361729
    17371730  /*
    1738      This assumes that it's getting called with a simple-{base,general}-string
    1739      or code vector as an argument and that there's room for the object in the
     1731     This assumes that it's getting called with an ivector
     1732     argument and that there's room for the object in the
    17401733     destination area.
    17411734  */
    17421735
    17431736
     1737LispObj
     1738purify_displaced_object(LispObj obj, area *dest, natural disp)
     1739{
     1740  BytePtr
     1741    free = dest->active,
     1742    *old = (BytePtr *) ptr_from_lispobj(untag(obj));
     1743  LispObj
     1744    header = header_of(obj),
     1745    new;
     1746  natural
     1747    start = (natural)old,
     1748    physbytes;
     1749
     1750  physbytes = ((natural)(skip_over_ivector(start,header))) - start;
     1751  dest->active += physbytes;
     1752
     1753  new = ptr_to_lispobj(free)+disp;
     1754
     1755  memcpy(free, (BytePtr)old, physbytes);
     1756  /* Leave a trail of breadcrumbs.  Or maybe just one breadcrumb. */
     1757  /* Actually, it's best to always leave a trail, for two reasons.
     1758     a) We may be walking the same heap that we're leaving forwaring
     1759     pointers in, so we don't want garbage that we leave behind to
     1760     look like a header.
     1761     b) We'd like to be able to forward code-vector locatives, and
     1762     it's easiest to do so if we leave a {forward_marker, dnode_locative}
     1763     pair at every doubleword in the old vector.
     1764  */
     1765  while(physbytes) {
     1766    *old++ = (BytePtr) forward_marker;
     1767    *old++ = (BytePtr) free;
     1768    free += dnode_size;
     1769    physbytes -= dnode_size;
     1770  }
     1771  return new;
     1772}
     1773
     1774LispObj
     1775purify_object(LispObj obj, area *dest)
     1776{
     1777  return purify_displaced_object(obj, dest, fulltag_of(obj));
     1778}
     1779
     1780
     1781
     1782void
     1783copy_ivector_reference(LispObj *ref, BytePtr low, BytePtr high, area *dest)
     1784{
     1785  LispObj obj = *ref, header;
     1786  natural tag = fulltag_of(obj), header_tag;
     1787
     1788  if ((tag == fulltag_misc) &&
     1789      (((BytePtr)ptr_from_lispobj(obj)) > low) &&
     1790      (((BytePtr)ptr_from_lispobj(obj)) < high)) {
     1791    header = deref(obj, 0);
     1792    if (header == forward_marker) { /* already copied */
     1793      *ref = (untag(deref(obj,1)) + tag);
     1794    } else {
     1795      header_tag = fulltag_of(header);
     1796      if (immheader_tag_p(header_tag)) {
     1797        if (header_subtag(header) != subtag_macptr) {
     1798          *ref = purify_object(obj, dest);
     1799        }
     1800      }
     1801    }
     1802  }
     1803}
     1804
     1805void
     1806purify_locref(LispObj *locaddr, BytePtr low, BytePtr high, area *to)
     1807{
     1808#ifdef PPC
    17441809  LispObj
    1745     purify_displaced_object(LispObj obj, area *dest, natural disp)
    1746   {
    1747     BytePtr
    1748       free = dest->active,
    1749       *old = (BytePtr *) ptr_from_lispobj(untag(obj));
    1750     LispObj
    1751       header = header_of(obj),
    1752       new;
    1753     natural
    1754       subtag = header_subtag(header),
    1755       element_count = header_element_count(header),
    1756       physbytes;
    1757 
    1758     switch(subtag) {
    1759     case subtag_simple_base_string:
    1760       physbytes = node_size + (element_count << 2);
    1761       break;
    1762 
    1763     case subtag_code_vector:
    1764       physbytes = node_size + (element_count << 2);
    1765       break;
    1766 
    1767     default:
    1768       Bug(NULL, "Can't purify object at 0x%08x", obj);
    1769       return obj;
    1770     }
    1771     physbytes = (physbytes+(dnode_size-1))&~(dnode_size-1);
    1772     dest->active += physbytes;
    1773 
    1774     new = ptr_to_lispobj(free)+disp;
    1775 
    1776     memcpy(free, (BytePtr)old, physbytes);
    1777     /* Leave a trail of breadcrumbs.  Or maybe just one breadcrumb. */
    1778     /* Actually, it's best to always leave a trail, for two reasons.
    1779        a) We may be walking the same heap that we're leaving forwaring
    1780        pointers in, so we don't want garbage that we leave behind to
    1781        look like a header.
    1782        b) We'd like to be able to forward code-vector locatives, and
    1783        it's easiest to do so if we leave a {forward_marker, dnode_locative}
    1784        pair at every doubleword in the old vector.
    1785     */
    1786     while(physbytes) {
    1787       *old++ = (BytePtr) forward_marker;
    1788       *old++ = (BytePtr) free;
    1789       free += dnode_size;
    1790       physbytes -= dnode_size;
    1791     }
    1792     return new;
    1793   }
    1794 
    1795   LispObj
    1796     purify_object(LispObj obj, area *dest)
    1797   {
    1798     return purify_displaced_object(obj, dest, fulltag_of(obj));
    1799   }
    1800 
    1801 
    1802 #define FORWARD_ONLY 0
    1803 #define COPY_CODE (1<<0)
    1804 #define COPY_STRINGS (1<<1)
    1805 
    1806   void
    1807     copy_ivector_reference(LispObj *ref, BytePtr low, BytePtr high, area *dest, int what_to_copy)
    1808   {
    1809     LispObj obj = *ref, header;
    1810     natural tag = fulltag_of(obj), header_tag, header_subtag;
    1811 
    1812     if ((tag == fulltag_misc) &&
    1813         (((BytePtr)ptr_from_lispobj(obj)) > low) &&
    1814         (((BytePtr)ptr_from_lispobj(obj)) < high)) {
    1815       header = deref(obj, 0);
    1816       if (header == forward_marker) { /* already copied */
    1817         *ref = (untag(deref(obj,1)) + tag);
     1810    loc = *locaddr,
     1811    *headerP;
     1812  opcode
     1813    *p,
     1814    insn;
     1815  natural
     1816    tag = fulltag_of(loc);
     1817
     1818  if (((BytePtr)ptr_from_lispobj(loc) > low) &&
     1819      ((BytePtr)ptr_from_lispobj(loc) < high)) {
     1820
     1821    headerP = (LispObj *)ptr_from_lispobj(untag(loc));
     1822    switch (tag) {
     1823    case fulltag_even_fixnum:
     1824    case fulltag_odd_fixnum:
     1825#ifdef PPC64
     1826    case fulltag_cons:
     1827    case fulltag_misc:
     1828#endif
     1829      if (*headerP == forward_marker) {
     1830        *locaddr = (headerP[1]+tag);
    18181831      } else {
    1819         header_tag = fulltag_of(header);
    1820         if (immheader_tag_p(header_tag)) {
    1821           header_subtag = header_subtag(header);
    1822           if (((header_subtag == subtag_code_vector) && (what_to_copy & COPY_CODE)) ||
    1823               ((what_to_copy & COPY_STRINGS) &&
    1824                ((header_subtag == subtag_simple_base_string)))) {
    1825             *ref = purify_object(obj, dest);
    1826           }
    1827         }
    1828       }
    1829     }
    1830   }
    1831 
    1832   void
    1833     purify_locref(LispObj *locaddr, BytePtr low, BytePtr high, area *to, int what)
    1834   {
    1835 #ifdef PPC
    1836     LispObj
    1837       loc = *locaddr,
    1838       *headerP;
    1839     opcode
    1840       *p,
    1841       insn;
    1842     natural
    1843       tag = fulltag_of(loc);
    1844 
    1845     if (((BytePtr)ptr_from_lispobj(loc) > low) &&
    1846 
    1847         ((BytePtr)ptr_from_lispobj(loc) < high)) {
    1848 
    1849       headerP = (LispObj *)ptr_from_lispobj(untag(loc));
    1850       switch (tag) {
    1851       case fulltag_even_fixnum:
    1852       case fulltag_odd_fixnum:
     1832        /* Grovel backwards until the header's found; copy
     1833           the code vector to to space, then treat it as if it
     1834           hasn't already been copied. */
     1835        p = (opcode *)headerP;
     1836        do {
     1837          p -= 2;
     1838          tag += 8;
     1839          insn = *p;
    18531840#ifdef PPC64
    1854       case fulltag_cons:
    1855       case fulltag_misc:
    1856 #endif
    1857         if (*headerP == forward_marker) {
    1858           *locaddr = (headerP[1]+tag);
    1859         } else {
    1860           /* Grovel backwards until the header's found; copy
    1861              the code vector to to space, then treat it as if it
    1862              hasn't already been copied. */
    1863           p = (opcode *)headerP;
    1864           do {
    1865             p -= 2;
    1866             tag += 8;
    1867             insn = *p;
    1868 #ifdef PPC64
    1869           } while (insn != PPC64_CODE_VECTOR_PREFIX);
    1870           headerP = ((LispObj*)p)-1;
    1871           *locaddr = purify_displaced_object(((LispObj)headerP), to, tag);
     1841        } while (insn != PPC64_CODE_VECTOR_PREFIX);
     1842        headerP = ((LispObj*)p)-1;
     1843        *locaddr = purify_displaced_object(((LispObj)headerP), to, tag);
    18721844#else
    1873         } while ((insn & code_header_mask) != subtag_code_vector);
    1874         *locaddr = purify_displaced_object(ptr_to_lispobj(p), to, tag);
    1875 #endif
    1876       }
    1877       break;
     1845      } while ((insn & code_header_mask) != subtag_code_vector);
     1846      *locaddr = purify_displaced_object(ptr_to_lispobj(p), to, tag);
     1847#endif
     1848    }
     1849    break;
    18781850
    18791851#ifndef PPC64
    1880     case fulltag_misc:
    1881       copy_ivector_reference(locaddr, low, high, to, what);
    1882       break;
    1883 #endif
    1884     }
    1885   }
    1886 #endif
    1887 }
    1888 
    1889 void
    1890 purify_range(LispObj *start, LispObj *end, BytePtr low, BytePtr high, area *to, int what)
     1852  case fulltag_misc:
     1853    copy_ivector_reference(locaddr, low, high, to);
     1854    break;
     1855#endif
     1856  }
     1857}
     1858#endif
     1859}
     1860
     1861void
     1862purify_range(LispObj *start, LispObj *end, BytePtr low, BytePtr high, area *to)
    18911863{
    18921864  LispObj header;
     
    19031875      } else {
    19041876        if (!nodeheader_tag_p(tag)) {
    1905           copy_ivector_reference(start, low, high, to, what);
     1877          copy_ivector_reference(start, low, high, to);
    19061878        }
    19071879        start++;
    1908         copy_ivector_reference(start, low, high, to, what);
     1880        copy_ivector_reference(start, low, high, to);
    19091881        start++;
    19101882      }
     
    19151887/* Purify references from tstack areas */
    19161888void
    1917 purify_tstack_area(area *a, BytePtr low, BytePtr high, area *to, int what)
     1889purify_tstack_area(area *a, BytePtr low, BytePtr high, area *to)
    19181890{
    19191891  LispObj
     
    19301902    end = ((next >= start) && (next < limit)) ? next : limit;
    19311903    if (current[1] == 0) {
    1932       purify_range(current+2, end, low, high, to, what);
     1904      purify_range(current+2, end, low, high, to);
    19331905    }
    19341906  }
     
    19371909/* Purify a vstack area */
    19381910void
    1939 purify_vstack_area(area *a, BytePtr low, BytePtr high, area *to, int what)
     1911purify_vstack_area(area *a, BytePtr low, BytePtr high, area *to)
    19401912{
    19411913  LispObj
     
    19441916
    19451917  if (((natural)p) & sizeof(natural)) {
    1946     copy_ivector_reference(p, low, high, to, what);
     1918    copy_ivector_reference(p, low, high, to);
    19471919    p++;
    19481920  }
    1949   purify_range(p, q, low, high, to, what);
    1950 }
    1951 
    1952 #ifdef PPC
    1953 void
    1954 purify_cstack_area(area *a, BytePtr low, BytePtr high, area *to, int what)
     1921  purify_range(p, q, low, high, to);
     1922}
     1923
     1924
     1925void
     1926purify_cstack_area(area *a, BytePtr low, BytePtr high, area *to)
    19551927{
    19561928  BytePtr
     
    19651937        (((((lisp_frame *)current)->savefn) == 0) ||
    19661938         (fulltag_of(((lisp_frame *)current)->savefn) == fulltag_misc))) {
    1967       purify_locref(&((lisp_frame *) current)->savelr, low, high, to, what);
     1939      purify_locref(&((lisp_frame *) current)->savelr, low, high, to);
    19681940    } else {
    19691941      /* Clear low bits of "next", just in case */
     
    19721944  }
    19731945}
    1974 #endif
    1975 
    1976 void
    1977 purify_xp(ExceptionInformation *xp, BytePtr low, BytePtr high, area *to, int what)
     1946
     1947void
     1948purify_xp(ExceptionInformation *xp, BytePtr low, BytePtr high, area *to)
    19781949{
    19791950  unsigned long *regs = (unsigned long *) xpGPRvector(xp);
    19801951
    1981 #ifdef PPC
    19821952  int r;
    19831953
     
    19871957
    19881958  for (r = fn; r < 32; r++) {
    1989     copy_ivector_reference((LispObj*) (&(regs[r])), low, high, to, what);
     1959    copy_ivector_reference((LispObj*) (&(regs[r])), low, high, to);
    19901960  };
    19911961
    1992   purify_locref((LispObj*) (&(regs[loc_pc])), low, high, to, what);
    1993 
    1994   purify_locref((LispObj*) (&(xpPC(xp))), low, high, to, what);
    1995   purify_locref((LispObj*) (&(xpLR(xp))), low, high, to, what);
    1996   purify_locref((LispObj*) (&(xpCTR(xp))), low, high, to, what);
    1997 #endif
    1998 
    1999 }
    2000 
    2001 void
    2002 purify_tcr_tlb(TCR *tcr, BytePtr low, BytePtr high, area *to, int what)
     1962  purify_locref((LispObj*) (&(regs[loc_pc])), low, high, to);
     1963
     1964  purify_locref((LispObj*) (&(xpPC(xp))), low, high, to);
     1965  purify_locref((LispObj*) (&(xpLR(xp))), low, high, to);
     1966  purify_locref((LispObj*) (&(xpCTR(xp))), low, high, to);
     1967}
     1968
     1969void
     1970purify_tcr_tlb(TCR *tcr, BytePtr low, BytePtr high, area *to)
    20031971{
    20041972  natural n = tcr->tlb_limit;
    20051973  LispObj *start = tcr->tlb_pointer, *end = (LispObj *) ((BytePtr)start+n);
    20061974
    2007   purify_range(start, end, low, high, to, what);
    2008 }
    2009 
    2010 void
    2011 purify_tcr_xframes(TCR *tcr, BytePtr low, BytePtr high, area *to, int what)
     1975  purify_range(start, end, low, high, to);
     1976}
     1977
     1978void
     1979purify_tcr_xframes(TCR *tcr, BytePtr low, BytePtr high, area *to)
    20121980{
    20131981  xframe_list *xframes;
     
    20161984  xp = tcr->gc_context;
    20171985  if (xp) {
    2018     purify_xp(xp, low, high, to, what);
     1986    purify_xp(xp, low, high, to);
    20191987  }
    20201988
    20211989  for (xframes = tcr->xframe; xframes; xframes = xframes->prev) {
    2022     purify_xp(xframes->curr, low, high, to, what);
    2023   }
    2024 }
    2025 
    2026 
    2027 void
    2028 purify_areas(BytePtr low, BytePtr high, area *target, int what)
     1990    purify_xp(xframes->curr, low, high, to);
     1991  }
     1992}
     1993
     1994void
     1995purify_gcable_ptrs(BytePtr low, BytePtr high, area *to)
     1996{
     1997  LispObj *prev = &(lisp_global(GCABLE_POINTERS)), next;
     1998
     1999  while ((*prev) != (LispObj)NULL) {
     2000    copy_ivector_reference(prev, low, high, to);
     2001    next = *prev;
     2002    prev = &(((xmacptr *)ptr_from_lispobj(untag(next)))->link);
     2003  }
     2004}
     2005
     2006
     2007void
     2008purify_areas(BytePtr low, BytePtr high, area *target)
    20292009{
    20302010  area *next_area;
     
    20342014    switch (code) {
    20352015    case AREA_TSTACK:
    2036       purify_tstack_area(next_area, low, high, target, what);
     2016      purify_tstack_area(next_area, low, high, target);
    20372017      break;
    20382018     
    20392019    case AREA_VSTACK:
    2040       purify_vstack_area(next_area, low, high, target, what);
     2020      purify_vstack_area(next_area, low, high, target);
    20412021      break;
    20422022     
    20432023    case AREA_CSTACK:
    2044 #ifdef PPC
    2045       purify_cstack_area(next_area, low, high, target, what);
    2046 #endif
     2024      purify_cstack_area(next_area, low, high, target);
    20472025      break;
    20482026     
    20492027    case AREA_STATIC:
    20502028    case AREA_DYNAMIC:
    2051       purify_range((LispObj *) next_area->low, (LispObj *) next_area->active, low, high, target, what);
     2029      purify_range((LispObj *) next_area->low, (LispObj *) next_area->active, low, high, target);
    20522030      break;
    20532031     
     
    20762054  TCR  *other_tcr;
    20772055  natural max_pure_size;
    2078   OSErr err;
    20792056  BytePtr new_pure_start;
    20802057
     
    20872064    lisp_global(IN_GC) = (1<<fixnumshift);
    20882065
    2089     /*
    2090       First, loop thru *all-packages* and purify the pnames of all
    2091       interned symbols.  Then walk every place that could reference
    2092       a heap-allocated object (all_areas, the xframe_list) and
    2093       purify code_vectors (and update the odd case of a shared
    2094       reference to a pname.)
    2095        
    2096       Make the new_pure_area executable, just in case.
    2097 
    2098       Caller will typically GC again (and that should recover quite a bit of
    2099       the dynamic heap.)
    2100       */
    2101 
    2102     {
    2103       lispsymbol *rawsym = (lispsymbol *)(&(nrs_ALL_PACKAGES));
    2104       LispObj pkg_list = rawsym->vcell, htab, obj;
    2105       package *p;
    2106       cons *c;
    2107       natural elements, i;
    2108 
    2109       while (fulltag_of(pkg_list) == fulltag_cons) {
    2110         c = (cons *) ptr_from_lispobj(untag(pkg_list));
    2111         p = (package *) ptr_from_lispobj(untag(c->car));
    2112         pkg_list = c->cdr;
    2113         c = (cons *) ptr_from_lispobj(untag(p->itab));
    2114         htab = c->car;
    2115         elements = header_element_count(header_of(htab));
    2116         for (i = 1; i<= elements; i++) {
    2117           obj = deref(htab,i);
    2118           if (fulltag_of(obj) == fulltag_misc) {
    2119             rawsym = (lispsymbol *) ptr_from_lispobj(untag(obj));
    2120             copy_ivector_reference(&(rawsym->pname), a->low, a->active, new_pure_area, COPY_STRINGS);
    2121           }
    2122         }
    2123         c = (cons *) ptr_from_lispobj(untag(p->etab));
    2124         htab = c->car;
    2125         elements = header_element_count(header_of(htab));
    2126         for (i = 1; i<= elements; i++) {
    2127           obj = deref(htab,i);
    2128           if (fulltag_of(obj) == fulltag_misc) {
    2129             rawsym = (lispsymbol *) ptr_from_lispobj(untag(obj));
    2130             copy_ivector_reference(&(rawsym->pname), a->low, a->active, new_pure_area, COPY_STRINGS);
    2131           }
    2132         }
    2133       }
    2134     }
    21352066   
    2136     purify_areas(a->low, a->active, new_pure_area, COPY_CODE);
     2067    purify_areas(a->low, a->active, new_pure_area);
    21372068   
    21382069    other_tcr = tcr;
    21392070    do {
    2140       purify_tcr_xframes(other_tcr, a->low, a->active, new_pure_area, COPY_CODE);
    2141       purify_tcr_tlb(other_tcr, a->low, a->active, new_pure_area, COPY_CODE);
     2071      purify_tcr_xframes(other_tcr, a->low, a->active, new_pure_area);
     2072      purify_tcr_tlb(other_tcr, a->low, a->active, new_pure_area);
    21422073      other_tcr = other_tcr->next;
    21432074    } while (other_tcr != tcr);
    21442075
     2076    purify_gcable_ptrs(a->low, a->active, new_pure_area);
    21452077
    21462078    {
     
    23602292}
    23612293
     2294void
     2295impurify_gcable_ptrs(LispObj low, LispObj high, signed_natural delta)
     2296{
     2297  LispObj *prev = &(lisp_global(GCABLE_POINTERS)), next;
     2298
     2299  while ((*prev) != (LispObj)NULL) {
     2300    impurify_noderef(prev, low, high, delta);
     2301    next = *prev;
     2302    prev = &(((xmacptr *)ptr_from_lispobj(untag(next)))->link);
     2303  }
     2304}
     2305
    23622306int
    23632307impurify(TCR *tcr, signed_natural param)
    23642308{
    2365   area *r = find_readonly_area();
     2309  area *r = readonly_area;
    23662310
    23672311  if (r) {
     
    23952339        other_tcr = other_tcr->next;
    23962340      } while (other_tcr != tcr);
     2341
     2342      impurify_gcable_ptrs(ptr_to_lispobj(ro_base), ptr_to_lispobj(ro_limit), delta);
    23972343      lisp_global(IN_GC) = 0;
    23982344    }
Note: See TracChangeset for help on using the changeset viewer.