/[gcl]/gcl/o/alloc.c
ViewVC logotype

Diff of /gcl/o/alloc.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.44 by camm, Sun Jan 16 02:30:00 2005 UTC revision 1.45 by camm, Fri Jun 10 15:13:53 2005 UTC
# Line 63  sbrk1(n) Line 63  sbrk1(n)
63  long real_maxpage = MAXPAGE;  long real_maxpage = MAXPAGE;
64  long new_holepage;  long new_holepage;
65    
66  #define available_pages \  /* #define      available_pages \ */
67          (real_maxpage-page(heap_end)-new_holepage-2*nrbpage-real_maxpage/32)  /*      ((long)((real_maxpage-page(heap_end)-new_holepage-nrbpage-real_maxpage/32))) */
68    /* #define      available_pages \ */
69    /*      ((long)((real_maxpage-page(heap_end)-new_holepage-2*nrbpage-real_maxpage/32))) */
70    
71    
72  /*  #ifdef UNIX */  /*  #ifdef UNIX */
# Line 83  struct rlimit data_rlimit; Line 85  struct rlimit data_rlimit;
85  int reserve_pages_for_signal_handler =30;  int reserve_pages_for_signal_handler =30;
86  int hole_overrun=0;  int hole_overrun=0;
87    
88    
89  /* If  (n >= 0 ) return pointer to n pages starting at heap end,  /* If  (n >= 0 ) return pointer to n pages starting at heap end,
90     These must come from the hole, so if that is exhausted you have     These must come from the hole, so if that is exhausted you have
91     to gc and move the hole.     to gc and move the hole.
# Line 117  alloc_page(long n) Line 120  alloc_page(long n)
120  Try to allocate more space to save for allocation during signals: \  Try to allocate more space to save for allocation during signals: \
121  eg to add 20 more do (si::set-hole-size %ld %d)\n...start over ", new_holepage, 20+ reserve_pages_for_signal_handler); fflush(stderr); exit(1);}  eg to add 20 more do (si::set-hole-size %ld %d)\n...start over ", new_holepage, 20+ reserve_pages_for_signal_handler); fflush(stderr); exit(1);}
122    
123                            hole_overrun=1;
124                          GBC(t_relocatable);                          GBC(t_relocatable);
125                            hole_overrun=0;
126  #ifdef SGC  #ifdef SGC
127                          if (in_sgc)                          if (in_sgc)
128                            {hole_overrun=1;sgc_start();hole_overrun=0;                            {hole_overrun=1;sgc_start();hole_overrun=0;
# Line 133  eg to add 20 more do (si::set-hole-size Line 138  eg to add 20 more do (si::set-hole-size
138                    /* can happen when mallocs occur before rel block set up..*/                    /* can happen when mallocs occur before rel block set up..*/
139                    { sbrk(PAGESIZE*n) ;                    { sbrk(PAGESIZE*n) ;
140                      core_end += PAGESIZE*n;                      core_end += PAGESIZE*n;
141                        {
142                          unsigned long old_new_holepage=new_holepage;
143                          new_holepage=CORE_PAGES/HOLEDIV;
144                          if (available_pages<1) new_holepage=old_new_holepage;
145                        }
146                    }                    }
147                  heap_end += PAGESIZE*n;                  heap_end += PAGESIZE*n;
148                  return(e);                  return(e);
# Line 153  eg to add 20 more do (si::set-hole-size Line 163  eg to add 20 more do (si::set-hole-size
163            make_writable(page(core_end),page(core_end)+n-m);            make_writable(page(core_end),page(core_end)+n-m);
164  #endif    #endif  
165          core_end += PAGESIZE*(n - m);          core_end += PAGESIZE*(n - m);
166            {
167              unsigned long old_new_holepage=new_holepage;
168              new_holepage=CORE_PAGES/HOLEDIV;
169              if (available_pages<1) new_holepage=old_new_holepage;
170            }
171          return(e);}          return(e);}
172  }  }
173    
174  void  void
175  add_page_to_freelist(char *p, struct typemanager *tm)  add_page_to_freelist(char *p, struct typemanager *tm)
176  {short t,size;  {short t,size;
177   long i=tm->tm_nppage,fw;   long i=tm->tm_nppage;
178     fixnum fw;
179   unsigned long np=page(p);   unsigned long np=page(p);
180   object x,f;   object x,f;
181   if (np>=MAXPAGE)   if (np>=MAXPAGE)
# Line 178  add_page_to_freelist(char *p, struct typ Line 194  add_page_to_freelist(char *p, struct typ
194   size=tm->tm_size;   size=tm->tm_size;
195   f=tm->tm_free;   f=tm->tm_free;
196   x= (object)p;   x= (object)p;
197   x->d.t=t;   set_type_of(x,t);
198   x->d.m=FREE;   make_free(x);
199  #ifdef SGC  #ifdef SGC
200   if (sgc_enabled && tm->tm_sgc)   if (sgc_enabled && tm->tm_sgc)
201     {x->d.s=SGC_RECENT;     {if (type_of(x)!=t_cons) x->d.s=SGC_RECENT; /*FIXME, can sgc mark cons on 64bit*/
202      sgc_type_map[np] = (SGC_PAGE_FLAG | SGC_TEMP_WRITABLE);}      sgc_type_map[np] = (SGC_PAGE_FLAG | SGC_TEMP_WRITABLE);}
203   else x->d.s = SGC_NORMAL;   else {if (type_of(x)!=t_cons) x->d.s = SGC_NORMAL;}
204    
205   /* array headers must be always writable, since a write to the   /* array headers must be always writable, since a write to the
206      body does not touch the header.   It may be desirable if there      body does not touch the header.   It may be desirable if there
# Line 195  add_page_to_freelist(char *p, struct typ Line 211  add_page_to_freelist(char *p, struct typ
211     sgc_type_map[np] |= SGC_PERM_WRITABLE;     sgc_type_map[np] |= SGC_PERM_WRITABLE;
212        
213  #endif  #endif
214   fw= *(int *)x;   fw=*(fixnum *)x;
215   while (--i >= 0)   while (--i >= 0)
216     { *(int *)x=fw;     { *(fixnum *)x=fw;
217       SET_LINK(x,f);       SET_LINK(x,f);
218       f=x;       f=x;
219       x= (object) ((char *)x + size);       x= (object) ((char *)x + size);
# Line 280  DEFVAR("*OPTIMIZE-MAXIMUM-PAGES*",sSAopt Line 296  DEFVAR("*OPTIMIZE-MAXIMUM-PAGES*",sSAopt
296  #define OPTIMIZE_MAX_PAGES (sSAoptimize_maximum_pagesA ==0 || sSAoptimize_maximum_pagesA->s.s_dbind !=sLnil)  #define OPTIMIZE_MAX_PAGES (sSAoptimize_maximum_pagesA ==0 || sSAoptimize_maximum_pagesA->s.s_dbind !=sLnil)
297  DEFVAR("*NOTIFY-OPTIMIZE-MAXIMUM-PAGES*",sSAnotify_optimize_maximum_pagesA,SI,sLnil,"");  DEFVAR("*NOTIFY-OPTIMIZE-MAXIMUM-PAGES*",sSAnotify_optimize_maximum_pagesA,SI,sLnil,"");
298  #define MMAX_PG(a_) ((a_)->tm_type == t_relocatable ? (a_)->tm_npage : (a_)->tm_maxpage)  #define MMAX_PG(a_) ((a_)->tm_type == t_relocatable ? (a_)->tm_npage : (a_)->tm_maxpage)
299  static long  long
300  opt_maxpage(struct typemanager *my_tm) {  opt_maxpage(struct typemanager *my_tm) {
301    
302    double x=0.0,y=0.0,z,r;    double x=0.0,y=0.0,z,r;
# Line 309  opt_maxpage(struct typemanager *my_tm) { Line 325  opt_maxpage(struct typemanager *my_tm) {
325    if (z<=mmax_page)    if (z<=mmax_page)
326      return 0;      return 0;
327    
328      /*FIXME: centralize with available pages */
329      if (real_maxpage - y - (z+mro-mmax_page) - new_holepage - nrbpage - real_maxpage/32 - real_maxpage/100<=0)
330        return 0;
331    
332    r=((x-my_tm->tm_adjgbccnt)+ my_tm->tm_adjgbccnt*mmax_page/z)*(y-mmax_page+z);    r=((x-my_tm->tm_adjgbccnt)+ my_tm->tm_adjgbccnt*mmax_page/z)*(y-mmax_page+z);
333    r/=x*y;    r/=x*y;
334    if (sSAnotify_optimize_maximum_pagesA->s.s_dbind!=sLnil)    if (sSAnotify_optimize_maximum_pagesA->s.s_dbind!=sLnil)
# Line 333  alloc_object(enum type t) Line 353  alloc_object(enum type t)
353           struct typemanager *tm;           struct typemanager *tm;
354           char *p;           char *p;
355           int must_have_more_pages;           int must_have_more_pages;
356             unsigned long i;
357    
358  ONCE_MORE:  ONCE_MORE:
359          tm = tm_of(t);          tm = tm_of(t);
# Line 358  ONCE_MORE: Line 379  ONCE_MORE:
379          tm->tm_free = OBJ_LINK(obj);          tm->tm_free = OBJ_LINK(obj);
380          --(tm->tm_nfree);          --(tm->tm_nfree);
381          (tm->tm_nused)++;          (tm->tm_nused)++;
382          obj->d.t = (short)t;          set_type_of(obj,t);
383          obj->d.m = FALSE;          make_unfree(obj);
384            if (((unsigned long)obj)&0x7) error("foo\n");
385          return(obj);          return(obj);
386  #ifdef SGC  #ifdef SGC
387  #define TOTAL_THIS_TYPE(tm) \  #define TOTAL_THIS_TYPE(tm) \
# Line 369  ONCE_MORE: Line 391  ONCE_MORE:
391          (tm->tm_nppage * tm->tm_npage)          (tm->tm_nppage * tm->tm_npage)
392  #endif  #endif
393  CALL_GBC:  CALL_GBC:
394            i=tm->tm_maxpage;
395          GBC(tm->tm_type);          GBC(tm->tm_type);
396          must_have_more_pages = (tm->tm_nfree == 0 ||          must_have_more_pages = (i==tm->tm_maxpage &&
397                            ((float)tm->tm_nfree)  <   (PERCENT_FREE(tm) * TOTAL_THIS_TYPE(tm))) ? 1 : 0;                                  (tm->tm_nfree == 0 ||
398                                     ((float)tm->tm_nfree)  <   (PERCENT_FREE(tm) * TOTAL_THIS_TYPE(tm)))) ? 1 : 0;
399          if (must_have_more_pages && !IGNORE_MAX_PAGES)          if (must_have_more_pages && !IGNORE_MAX_PAGES)
400            goto EXHAUSTED;            goto EXHAUSTED;
401          if (IGNORE_MAX_PAGES) {          if (IGNORE_MAX_PAGES) {
402            if ((!OPTIMIZE_MAX_PAGES || !opt_maxpage(tm)) && must_have_more_pages) {            if (/* (!OPTIMIZE_MAX_PAGES || !opt_maxpage(tm)) &&  */must_have_more_pages) {
403               int j;               int j;
404                            
405               tm->tm_maxpage=grow_linear((j=tm->tm_maxpage),tm->tm_growth_percent,               tm->tm_maxpage=grow_linear((j=tm->tm_maxpage),tm->tm_growth_percent,
# Line 409  make_cons(object a, object d) Line 433  make_cons(object a, object d)
433           char *p;           char *p;
434           struct typemanager *tm=(&tm_table[(int)t_cons]);           struct typemanager *tm=(&tm_table[(int)t_cons]);
435           int must_have_more_pages;           int must_have_more_pages;
436             unsigned long i;
437    
438  ONCE_MORE:  ONCE_MORE:
439          CHECK_INTERRUPT;          CHECK_INTERRUPT;
# Line 431  ONCE_MORE: Line 456  ONCE_MORE:
456          tm->tm_free = OBJ_LINK(obj);          tm->tm_free = OBJ_LINK(obj);
457          --(tm->tm_nfree);          --(tm->tm_nfree);
458          (tm->tm_nused)++;          (tm->tm_nused)++;
459          obj->c.t = (short)t_cons;          set_type_of(obj,t_cons);
460          obj->c.m = FALSE;          make_unfree(obj);
461          obj->c.c_car = a;          obj->c.c_car = a;
462          obj->c.c_cdr = d;          obj->c.c_cdr = d;
463            if (((unsigned long)obj)&0x7) error("foo\n");
464          return(obj);          return(obj);
465    
466  CALL_GBC:  CALL_GBC:
467            i=tm->tm_maxpage;
468          GBC(t_cons);          GBC(t_cons);
469          must_have_more_pages=(tm->tm_nfree == 0 ||          must_have_more_pages=(i==tm->tm_maxpage &&
470                               (float)tm->tm_nfree   <  PERCENT_FREE(tm) * TOTAL_THIS_TYPE(tm)) ? 1 : 0;                                (tm->tm_nfree == 0 ||
471                                   (float)tm->tm_nfree   <  PERCENT_FREE(tm) * TOTAL_THIS_TYPE(tm))) ? 1 : 0;
472          if (must_have_more_pages && !IGNORE_MAX_PAGES)          if (must_have_more_pages && !IGNORE_MAX_PAGES)
473            goto EXHAUSTED;            goto EXHAUSTED;
474          if (IGNORE_MAX_PAGES) {          if (IGNORE_MAX_PAGES) {
475            if ((!OPTIMIZE_MAX_PAGES || !opt_maxpage(tm)) && must_have_more_pages) {            if (/* (!OPTIMIZE_MAX_PAGES || !opt_maxpage(tm)) &&  */must_have_more_pages) {
476               int j;               int j;
477                            
478               tm->tm_maxpage=grow_linear((j=tm->tm_maxpage),tm->tm_growth_percent,               tm->tm_maxpage=grow_linear((j=tm->tm_maxpage),tm->tm_growth_percent,
# Line 473  Use ALLOCATE to expand the space.", Line 501  Use ALLOCATE to expand the space.",
501    
502  object on_stack_cons(object x, object y)  object on_stack_cons(object x, object y)
503  {object p = (object) alloca_val;  {object p = (object) alloca_val;
504   p->c.t= (short)t_cons;   set_type_of(p,t_cons);
505   p->c.m=FALSE;   make_unfree(p);
506   p->c.c_car=x;   p->c.c_car=x;
507   p->c.c_cdr=y;   p->c.c_cdr=y;
508     if (((unsigned long)p)&0x7) error("foo\n");
509   return p;   return p;
510  }  }
511    
# Line 578  ONCE_MORE: Line 607  ONCE_MORE:
607                    goto EXHAUSTED;                    goto EXHAUSTED;
608                  if (IGNORE_MAX_PAGES) {                  if (IGNORE_MAX_PAGES) {
609                    struct typemanager *tm = &tm_table[(int)t_contiguous];                    struct typemanager *tm = &tm_table[(int)t_contiguous];
610                    if ((!OPTIMIZE_MAX_PAGES || !opt_maxpage(tm)) && g) {                    if (/* (!OPTIMIZE_MAX_PAGES || !opt_maxpage(tm)) &&  */g && j==maxcbpage) {
611                      maxcbpage=grow_linear(maxcbpage,tm->tm_growth_percent,                      maxcbpage=grow_linear(maxcbpage,tm->tm_growth_percent,
612                                            tm->tm_min_grow, tm->tm_max_grow);                                            tm->tm_min_grow, tm->tm_max_grow);
613                      tm->tm_adjgbccnt*=(double)j/maxcbpage;                      tm->tm_adjgbccnt*=(double)j/maxcbpage;
# Line 707  alloc_relblock(size_t n) { Line 736  alloc_relblock(size_t n) {
736  ONCE_MORE:  ONCE_MORE:
737          CHECK_INTERRUPT;          CHECK_INTERRUPT;
738    
739          if (rb_limit - rb_pointer < n) {          i=page(rb_end)-page(heap_end)-holepage;
740            if (rb_limit - rb_pointer < n ||
741                i!=nrbpage) {
742            if (!g && in_signal_handler == 0) {            if (!g && in_signal_handler == 0) {
743              /*GMP_WRAPPERS:  Please see comments in gmp_wrappers.h 20040815 CM*/              /*GMP_WRAPPERS:  Please see comments in gmp_wrappers.h 20040815 CM*/
744              switch (jmp_gmp) {              switch (jmp_gmp) {
# Line 724  ONCE_MORE: Line 755  ONCE_MORE:
755                break;                break;
756              }              }
757            }            }
758            must_have_more_pages=((float)(rb_limit - rb_pointer) <            must_have_more_pages=(i==nrbpage &&
759                                  PERCENT_FREE(tm_of(t_relocatable)) * (float)(rb_limit - rb_start)) ? 1 : 0;                                  ((float)(rb_limit - rb_pointer) <
760                                     PERCENT_FREE(tm_of(t_relocatable)) * (float)(rb_limit - rb_start))) ? 1 : 0;
761            if ((must_have_more_pages || g) && !IGNORE_MAX_PAGES)            if ((must_have_more_pages || g) && !IGNORE_MAX_PAGES)
762              goto EXHAUSTED;              goto EXHAUSTED;
           i=nrbpage;  
763            if (IGNORE_MAX_PAGES) {            if (IGNORE_MAX_PAGES) {
764              struct typemanager *tm = &tm_table[(int)t_relocatable];              struct typemanager *tm = &tm_table[(int)t_relocatable];
765              if ((!OPTIMIZE_MAX_PAGES  || !opt_maxpage(tm)) && (g || must_have_more_pages)) {              if (/* (!OPTIMIZE_MAX_PAGES  || !opt_maxpage(tm)) &&  */(g || must_have_more_pages)) {
766                nrbpage=grow_linear(nrbpage,tm->tm_growth_percent,                nrbpage=grow_linear(nrbpage,tm->tm_growth_percent,
767                                    tm->tm_min_grow, tm->tm_max_grow);                                    tm->tm_min_grow, tm->tm_max_grow);
768                tm->tm_adjgbccnt*=(double)i/nrbpage;                tm->tm_adjgbccnt*=(double)i/nrbpage;
769              }              }
770              if (available_pages < 0) {              if (available_pages < 0) {
771                nrbpage = i;                nrbpage += available_pages;
772                goto EXHAUSTED;                if (nrbpage<=i) {
773                    nrbpage = i;
774                    goto EXHAUSTED;
775                  }
776              } else if (nrbpage != i) {              } else if (nrbpage != i) {
777                rb_end +=  (PAGESIZE* (nrbpage -i));                rb_end +=  (PAGESIZE* (nrbpage -i));
778                rb_limit = rb_end - 2*RB_GETA;                rb_limit = rb_end - 2*RB_GETA;
# Line 783  init_tm(enum type t, char *name, int els Line 817  init_tm(enum type t, char *name, int els
817    
818    int i, j;    int i, j;
819    int maxpage;    int maxpage;
820      fixnum lu;
821    /* round up to next number of pages */    /* round up to next number of pages */
822    
823      lu=elsize;
824      if (((object)&lu)->md.mf || type_of((object)&lu)!=t_cons)
825        error("structure size must allow for type, mark, and free bits");
826    
827    maxpage = (((nelts * elsize) + PAGESIZE -1)/PAGESIZE);    maxpage = (((nelts * elsize) + PAGESIZE -1)/PAGESIZE);
828    tm_table[(int)t].tm_name = name;    tm_table[(int)t].tm_name = name;
829    j=-1;    j=-1;
# Line 896  gcl_init_alloc(void) { Line 936  gcl_init_alloc(void) {
936    }    }
937  #endif    #endif  
938        
   holepage = INIT_HOLEPAGE;  
 #ifdef GCL_GPROF  
   if (holepage<textpage)  
      holepage=textpage;  
 #endif  
   
   new_holepage = HOLEPAGE;  
   nrbpage = INIT_NRBPAGE;  
     
939    set_maxpage();    set_maxpage();
940        
941  #ifdef __linux__  #ifdef __linux__
# Line 927  gcl_init_alloc(void) { Line 958  gcl_init_alloc(void) {
958    INIT_ALLOC;    INIT_ALLOC;
959  #endif    #endif  
960        
961      holepage = CORE_PAGES/INIT_HOLEDIV;
962    #ifdef GCL_GPROF
963      if (holepage<textpage)
964         holepage=textpage;
965    #endif
966    
967      new_holepage = CORE_PAGES/HOLEDIV;
968      nrbpage = CORE_PAGES/INIT_NRBDIV;
969      
970    alloc_page(-(holepage + nrbpage));    alloc_page(-(holepage + nrbpage));
971        
972    rb_start = rb_pointer = heap_end + PAGESIZE*holepage;    rb_start = rb_pointer = heap_end + PAGESIZE*holepage;
# Line 945  gcl_init_alloc(void) { Line 985  gcl_init_alloc(void) {
985       Gave each page type at least some sgc pages by default.  Of       Gave each page type at least some sgc pages by default.  Of
986       course changeable by allocate-sgc.  CM 20030827 */       course changeable by allocate-sgc.  CM 20030827 */
987    
988      init_tm(t_cons, ".CONS", sizeof(struct cons), 65536 ,50,0 );
989    init_tm(t_fixnum, "NFIXNUM",    init_tm(t_fixnum, "NFIXNUM",
990            sizeof(struct fixnum_struct), 8192,20,0);            sizeof(struct fixnum_struct), 8192,20,0);
   init_tm(t_cons, ".CONS", sizeof(struct cons), 65536 ,50,0 );  
991    init_tm(t_structure, "SSTRUCTURE", sizeof(struct structure), 5461,1,0 );    init_tm(t_structure, "SSTRUCTURE", sizeof(struct structure), 5461,1,0 );
992    init_tm(t_cfun, "fCFUN", sizeof(struct cfun), 4096,1,0  );    init_tm(t_cfun, "fCFUN", sizeof(struct cfun), 4096,1,0  );
993    init_tm(t_sfun, "gSFUN", sizeof(struct sfun),409,1,0 );    init_tm(t_sfun, "gSFUN", sizeof(struct sfun),409,1,0 );
# Line 976  gcl_init_alloc(void) { Line 1016  gcl_init_alloc(void) {
1016    init_tm(t_gfun, "gGFUN", sizeof(struct sfun), 0 ,1,0);    init_tm(t_gfun, "gGFUN", sizeof(struct sfun), 0 ,1,0);
1017    init_tm(t_afun, "AAFUN", sizeof(struct sfun), 0 ,1,0);    init_tm(t_afun, "AAFUN", sizeof(struct sfun), 0 ,1,0);
1018    init_tm(t_cfdata, "cCFDATA", sizeof(struct cfdata), 102 ,1,0);    init_tm(t_cfdata, "cCFDATA", sizeof(struct cfdata), 102 ,1,0);
1019    init_tm(t_spice, "!SPICE", sizeof(struct spice), 4096 ,1,0);    init_tm(t_spice, "!SPICE", sizeof(struct spice), PAGESIZE ,1,0);
1020    init_tm(t_relocatable, "%RELOCATABLE-BLOCKS", 1000,0,20,0);    init_tm(t_relocatable, "%RELOCATABLE-BLOCKS", 2*PAGESIZE,0,20,0);
1021    init_tm(t_contiguous, "_CONTIGUOUS-BLOCKS", 1001,0,20,0);    init_tm(t_contiguous, "_CONTIGUOUS-BLOCKS", 4*PAGESIZE,0,20,0);
1022    tm_table[t_relocatable].tm_nppage = PAGESIZE;    tm_table[t_relocatable].tm_nppage = PAGESIZE;
1023    tm_table[t_contiguous].tm_nppage = PAGESIZE;    tm_table[t_contiguous].tm_nppage = PAGESIZE;
1024        
# Line 1558  free(void *ptr) Line 1598  free(void *ptr)
1598  #endif    #endif  
1599                
1600  {  {
1601          object *p;          object *p,pp;
1602          if (ptr == 0)          if (ptr == 0)
1603            return;            return;
1604  #ifdef BABY_MALLOC_SIZE  #ifdef BABY_MALLOC_SIZE
1605          if ((void *)ptr < (void *) &baby_malloc_data[sizeof(baby_malloc_data)])          if ((void *)ptr < (void *) &baby_malloc_data[sizeof(baby_malloc_data)])
1606            return;            return;
1607  #endif    #endif  
1608          for (p = &malloc_list; *p && !endp(*p);  p = &((*p)->c.c_cdr))  /*      for (p = &malloc_list,pp=*p,((object)&pp)->md.mf=0; *p && !endp(pp);  p = &((pp)->c.c_cdr),pp=*p,((object)&pp)->md.mf=0) */
1609                  if ((*p)->c.c_car->st.st_self == ptr) {          for (p=&malloc_list,pp=*p; pp && !endp(pp);  p = &((pp)->c.c_cdr),pp=Scdr(pp))
1610                    if ((pp)->c.c_car->st.st_self == ptr) {
1611  /* SGC contblock pages: Its possible this is on an old page CM 20030827 */  /* SGC contblock pages: Its possible this is on an old page CM 20030827 */
1612  #ifdef SGC  #ifdef SGC
1613                          insert_maybe_sgc_contblock((*p)->c.c_car->st.st_self,                          insert_maybe_sgc_contblock((pp)->c.c_car->st.st_self,
1614                                                     (*p)->c.c_car->st.st_dim);                                                     (pp)->c.c_car->st.st_dim);
1615  #else  #else
1616                          insert_contblock((*p)->c.c_car->st.st_self,                          insert_contblock((pp)->c.c_car->st.st_self,
1617                                           (*p)->c.c_car->st.st_dim);                                           (pp)->c.c_car->st.st_dim);
1618  #endif  #endif
1619                          (*p)->c.c_car->st.st_self = NULL;                          (pp)->c.c_car->st.st_self = NULL;
1620                          *p = (*p)->c.c_cdr;                          *p = Scdr(pp);
1621  #ifdef GCL_GPROF  #ifdef GCL_GPROF
1622                          if (initial_monstartup_pointer==ptr) {                          if (initial_monstartup_pointer==ptr) {
1623                            initial_monstartup_pointer=NULL;                            initial_monstartup_pointer=NULL;

Legend:
Removed from v.1.44  
changed lines
  Added in v.1.45

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26