Changeset 15842


Ignore:
Timestamp:
Jun 17, 2013, 5:40:40 AM (7 years ago)
Author:
gb
Message:

(Finally) merge gb-egc branch. Changes:

  • area structure contains refidx slot, with one bit for every 256 bits in the area's refmap
  • write barrier code sets refidx bit when it sets refmap bit. (managed_static refmap - tracks refs from managed_static area to dynamic space - doesn't currently use a refidx.) Handle this in pc_luser_xp() and in check_refmap_consistency() on all architectures.
  • egc uses refidx to traverse (typically sparse) refmap
  • maintain heap_dirty_mark (highest heap address that's been written to since it was mapped, basically). Split new_heap_segment() into machine-dependent and -independent parts. Don't zero_dnodes in GC; zero them (if below heap_dirty_mark) in new_heap_segment().
  • try to ensure that pc_luser_xp() can reliablye find the effective address being written to in interrupted write barrier code. (In some cases, this involved ensuring that write barrier code observed constraints on register usage; in other cases, pc_luser_xp() was just wrong.)
Location:
trunk/source/lisp-kernel
Files:
23 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/lisp-kernel/area.h

    r15826 r15842  
    7676  natural static_dnodes;        /* for hash consing, maybe other things. */
    7777  natural *static_used;         /* bitvector */
     78  natural *refidx;              /* compressed refbits */
    7879} area;
    7980
  • trunk/source/lisp-kernel/arm-exceptions.c

    r15826 r15842  
    225225     without extending the heap.
    226226  */
    227   if (new_heap_segment(xp, bytes_needed, false, tcr)) {
     227  if (new_heap_segment(xp, bytes_needed, false, tcr, NULL)) {
    228228    xpGPR(xp, allocptr) += disp_from_allocptr;
    229229    return true;
     
    240240 
    241241  /* Try again, growing the heap if necessary */
    242   if (new_heap_segment(xp, bytes_needed, true, tcr)) {
     242  if (new_heap_segment(xp, bytes_needed, true, tcr, NULL)) {
    243243    xpGPR(xp, allocptr) += disp_from_allocptr;
    244244    return true;
     
    622622}
    623623
    624 /*
    625   This doesn't GC; it returns true if it made enough room, false
    626   otherwise.
    627   If "extend" is true, it can try to extend the dynamic area to
    628   satisfy the request.
    629 */
    630 
    631 Boolean
    632 new_heap_segment(ExceptionInformation *xp, natural need, Boolean extend, TCR *tcr)
    633 {
    634   area *a;
    635   natural newlimit, oldlimit;
    636   natural log2_allocation_quantum = tcr->log2_allocation_quantum;
    637 
    638   a  = active_dynamic_area;
    639   oldlimit = (natural) a->active;
    640   newlimit = (align_to_power_of_2(oldlimit, log2_allocation_quantum) +
    641               align_to_power_of_2(need, log2_allocation_quantum));
    642   if (newlimit > (natural) (a->high)) {
    643     if (extend) {
    644       signed_natural inhibit = (signed_natural)(lisp_global(GC_INHIBIT_COUNT));
    645       natural extend_by = inhibit ? 0 : lisp_heap_gc_threshold;
    646       do {
    647         if (resize_dynamic_heap(a->active, (newlimit-oldlimit)+extend_by)) {
    648           break;
    649         }
    650         extend_by = align_to_power_of_2(extend_by>>1, log2_allocation_quantum);
    651         if (extend_by < 4<<20) {
    652           return false;
    653         }
    654       } while (1);
    655     } else {
    656       return false;
    657     }
    658   }
    659   a->active = (BytePtr) newlimit;
    660   tcr->last_allocptr = (void *)newlimit;
    661   xpGPR(xp,allocptr) = (LispObj) newlimit;
    662   tcr->save_allocbase = (void*) oldlimit;
    663 
    664   return true;
    665 }
    666 
     624
     625
     626void
     627platform_new_heap_segment(ExceptionInformation *xp, TCR *tcr, BytePtr low, BytePtr high)
     628{
     629  tcr->last_allocptr = (void *)high;
     630  xpGPR(xp,allocptr) = (LispObj) high;
     631  tcr->save_allocbase = (void*) low;
     632}
    667633 
    668634void
     
    16341600      }
    16351601      root = xpGPR(xp,arg_x);
    1636       ea = (LispObj *) (root+xpGPR(xp,arg_y)+misc_data_offset);
     1602      ea = (LispObj *) (root+unbox_fixnum(xpGPR(xp,temp2)));
    16371603      need_memoize_root = true;
    16381604    } else if (program_counter >= &egc_store_node_conditional) {
     
    16441610        return;
    16451611      }
    1646       ea = (LispObj*)(xpGPR(xp,arg_x) + xpGPR(xp,imm0));
     1612      ea = (LispObj*)(xpGPR(xp,arg_x) + unbox_fixnum(xpGPR(xp,temp2)));
    16471613      xpGPR(xp,arg_z) = t_value;
    16481614    } else if (program_counter >= &egc_set_hash_key) {
     
    16781644          ((LispObj)ea < val)) {
    16791645        atomic_set_bit(refbits, bitnumber);
     1646        atomic_set_bit(global_refidx, bitnumber>>8);
    16801647        if (need_memoize_root) {
    16811648          bitnumber = area_dnode(root, lisp_global(REF_BASE));
    16821649          atomic_set_bit(refbits, bitnumber);
     1650          atomic_set_bit(global_refidx,bitnumber>>8);
    16831651        }
    16841652      }
  • trunk/source/lisp-kernel/arm-gc.c

    r15826 r15842  
    712712
    713713void
    714 check_refmap_consistency(LispObj *start, LispObj *end, bitvector refbits)
     714check_refmap_consistency(LispObj *start, LispObj *end, bitvector refbits, bitvector refidx)
    715715{
    716716  LispObj x1, *base = start, *prev = start;
     
    758758          Bug(NULL, "Missing memoization in doublenode at 0x" LISP "\n", start);
    759759          set_bit(refbits, ref_dnode);
     760          if (refidx) {
     761            set_bit(refidx,ref_dnode>>8);
     762          }
     763        } else {
     764          if (refidx) {
     765            if (!ref_bit(refidx, ref_dnode>>8)) {
     766              Bug(NULL, "Memoization for doublenode at 0x" LISP " not indexed\n", start);
     767              set_bit(refidx,ref_dnode>>8);
     768            }
     769          }
    760770        }
    761771      }
  • trunk/source/lisp-kernel/arm-spentry.s

    r15826 r15842  
    759759        __(mov imm1,imm1,lsr imm2)
    760760        __(mov imm0,imm0,lsr #bitmap_shift)
    761         __(ref_global(temp0,refbits))
    762         __(add temp0,temp0,imm0,lsl #word_shift)
    763         __(ldr imm2,[temp0])
     761        __(ref_global(temp1,refbits))
     762        __(add temp1,temp1,imm0,lsl #word_shift)
     763        __(ldr imm2,[temp1])
    764764        __(tst imm2,imm1)
    765765        __(bxne lr)
    766 0:      __(ldrex imm2,[temp0])
     7660:      __(ldrex imm2,[temp1])
    767767        __(orr imm2,imm2,imm1)
    768         __(strex imm0,imm2,[temp0])
     768        __(strex imm0,imm2,[temp1])
    769769        __(cmp imm0,#0)
    770         __(bne 0b)       
     770        __(bne 0b)
     771        __(sub imm0,arg_y,temp0)
     772        __(mov imm0,imm0,lsr #dnode_shift+8)
     773        __(and imm2,imm0,#31)
     774        __(mov imm1,#0x80000000)
     775        __(mov imm1,imm1,lsr imm2)
     776        __(mov imm0,imm0,lsr #bitmap_shift)
     777        __(ref_global(temp1,ephemeral_refidx))
     778        __(add temp1,temp1,imm0,lsl #word_shift)
     7791:      __(ldrex imm2,[temp1])
     780        __(orr imm2,imm2,imm1)
     781        __(strex imm0,imm2,[temp1])
     782        __(cmp imm0,#0)
     783        __(bne 1b)
    771784        __(bx lr)
    772785
     
    790803        __(mov imm1,imm1,lsr imm2)
    791804        __(mov imm0,imm0,lsr #bitmap_shift)
    792         __(ref_global(temp0,refbits))
    793         __(add temp0,temp0,imm0,lsl #word_shift)
    794         __(ldr imm2,[temp0])
     805        __(ref_global(temp1,refbits))
     806        __(add temp1,temp1,imm0,lsl #word_shift)
     807        __(ldr imm2,[temp1])
    795808        __(tst imm2,imm1)
    796809        __(bxne lr)
    797 0:      __(ldrex imm2,[temp0])
     8100:      __(ldrex imm2,[temp1])
    798811        __(orr imm2,imm2,imm1)
    799         __(strex imm0,imm2,[temp0])
     812        __(strex imm0,imm2,[temp1])
    800813        __(cmp imm0,#0)
    801814        __(bne 0b)       
     815        __(sub imm0,arg_y,temp0)
     816        __(mov imm0,imm0,lsr #dnode_shift+8)
     817        __(and imm2,imm0,#31)
     818        __(mov imm1,#0x80000000)
     819        __(mov imm1,imm1,lsr imm2)
     820        __(mov imm0,imm0,lsr #bitmap_shift)
     821        __(ref_global(temp1,ephemeral_refidx))
     822        __(add temp1,temp1,imm0,lsl #word_shift)
     8231:      __(ldrex imm2,[temp1])
     824        __(orr imm2,imm2,imm1)
     825        __(strex imm0,imm2,[temp1])
     826        __(cmp imm0,#0)
     827        __(bne 1b)
    802828        __(bx lr)
    803829       
     
    825851        __(mov imm1,imm1,lsr imm2)
    826852        __(mov imm0,imm0,lsr #bitmap_shift)
    827         __(ref_global(temp0,refbits))
    828         __(add temp0,temp0,imm0,lsl #word_shift)
    829         __(ldr imm2,[temp0])
     853        __(ref_global(temp1,refbits))
     854        __(add temp1,temp1,imm0,lsl #word_shift)
     855        __(ldr imm2,[temp1])
    830856        __(tst imm2,imm1)
    831857        __(bxne lr)     
    832 0:      __(ldrex imm2,[temp0])
     8580:      __(ldrex imm2,[temp1])
    833859        __(orr imm2,imm2,imm1)
    834         __(strex imm0,imm2,[temp0])
     860        __(strex imm0,imm2,[temp1])
    835861        __(cmp imm0,#0)
    836         __(bne 0b)       
     862        __(bne 0b)
     863        __(add imm0,arg_y,#misc_data_offset)
     864        __(add imm0,imm0,arg_x)
     865        __(sub imm0,imm0,temp0)
     866        __(mov imm0,imm0,lsr #dnode_shift+8)
     867        __(and imm2,imm0,#31)
     868        __(mov imm1,#0x80000000)
     869        __(mov imm1,imm1,lsr imm2)
     870        __(mov imm0,imm0,lsr #bitmap_shift)
     871        __(ref_global(temp1,ephemeral_refidx))
     872        __(add temp1,temp1,imm0,lsl #word_shift)
     8731:      __(ldrex imm2,[temp1])
     874        __(orr imm2,imm2,imm1)
     875        __(strex imm0,imm2,[temp1])
     876        __(cmp imm0,#0)
     877        __(bne 1b)   
    837878        __(bx lr)
    838879
     
    861902        __(mov imm1,imm1,lsr imm2)
    862903        __(mov imm0,imm0,lsr #bitmap_shift)
    863         __(ref_global(temp0,refbits))
    864         __(add temp0,temp0,imm0,lsl #word_shift)
    865         __(ldr imm2,[temp0])
     904        __(ref_global(temp1,refbits))
     905        __(add temp1,temp1,imm0,lsl #word_shift)
     906        __(ldr imm2,[temp1])
    866907        __(tst imm2,imm1)
    867908        __(bxne lr)
    868 0:      __(ldrex imm2,[temp0])
     9090:      __(ldrex imm2,[temp1])
    869910        __(orr imm2,imm2,imm1)
    870         __(strex imm0,imm2,[temp0])
     911        __(strex imm0,imm2,[temp1])
    871912        __(cmp imm0,#0)
    872         __(bne 0b)       
     913        __(bne 0b)
     914        __(add imm0,arg_y,#misc_data_offset)
     915        __(add imm0,imm0,arg_x)
     916        __(sub imm0,imm0,temp0)
     917        __(mov imm0,imm0,lsr #dnode_shift+8)
     918        __(and imm2,imm0,#31)
     919        __(mov imm1,#0x80000000)
     920        __(mov imm1,imm1,lsr imm2)
     921        __(mov imm0,imm0,lsr #bitmap_shift)
     922        __(ref_global(temp1,ephemeral_refidx))
     923        __(add temp1,temp1,imm0,lsl #word_shift)
     9241:      __(ldrex imm2,[temp1])
     925        __(orr imm2,imm2,imm1)
     926        __(strex imm0,imm2,[temp1])
     927        __(cmp imm0,#0)
     928        __(bne 1b)   
     929       
    873930/* Now need to ensure that the hash table itself is in the refmap; we
    874931   know that it's in bounds, etc. */
    875         __(ref_global(temp0,ref_base))
     932
    876933        __(sub imm0,arg_x,temp0)
    877934        __(mov imm0,imm0,lsr #dnode_shift)
     
    880937        __(mov imm1,imm1,lsr imm2)
    881938        __(mov imm0,imm0,lsr #bitmap_shift)
    882         __(ref_global(temp0,refbits))
    883         __(add temp0,temp0,imm0,lsl #word_shift)
    884         __(ldr imm2,[temp0])
     939        __(ref_global(temp1,refbits))
     940        __(add temp1,temp1,imm0,lsl #word_shift)
     941        __(ldr imm2,[temp1])
    885942        __(tst imm2,imm1)
    886943        __(bxne lr)
    887 1:      __(ldrex imm2,[temp0])
     9442:      __(ldrex imm2,[temp1])
    888945        __(orr imm2,imm2,imm1)
    889         __(strex imm0,imm2,[temp0])
     946        __(strex imm0,imm2,[temp1])
    890947        __(cmp imm0,#0)
    891         __(bne 1b)       
     948        __(bne 2b)       
     949        __(sub imm0,arg_x,temp0)
     950        __(mov imm0,imm0,lsr #dnode_shift+8)
     951        __(and imm2,imm0,#31)
     952        __(mov imm1,#0x80000000)
     953        __(mov imm1,imm1,lsr imm2)
     954        __(mov imm0,imm0,lsr #bitmap_shift)
     955        __(ref_global(temp1,ephemeral_refidx))
     956        __(add temp1,temp1,imm0,lsl #word_shift)
     9573:      __(ldrex imm2,[temp1])
     958        __(orr imm2,imm2,imm1)
     959        __(strex imm0,imm2,[temp1])
     960        __(cmp imm0,#0)
     961        __(bne 3b)       
    892962        __(bx lr)
    893963       
     
    915985_spentry(store_node_conditional)
    916986C(egc_store_node_conditional):
    917         __(vpop1(temp0))
     987        __(vpop1(temp2))
    918988         
    919 1:      __(unbox_fixnum(imm2,temp0))
     9891:      __(unbox_fixnum(imm2,temp2))
    920990        __(add imm2,imm2,arg_x)
    921991        __(ldrex temp1,[imm2])
    922992        __(cmp temp1,arg_y)
    923         __(bne 5f)
     993        __(bne 9f)
    924994        __(strex imm0,arg_z,[imm2])
    925995        .globl C(egc_store_node_conditional_test)
     
    928998        __(bne 1b)
    929999        __(cmp arg_z,arg_x)
    930         __(blo 4f)
    931 
    932         __(ref_global(imm0,ref_base))
     1000        __(blo 8f)
     1001
     1002        __(ref_global(temp0,ref_base))
    9331003        __(ref_global(imm1,oldspace_dnode_count))
    934         __(sub imm0,imm2,imm0)
     1004        __(sub imm0,imm2,temp0)
    9351005        __(mov imm0,imm0,lsr #dnode_shift)
    9361006        __(cmp imm0,imm1)
    937         __(bhs 4f)
    938         __(and imm1,imm0,#31)
    939         __(mov arg_x,#0x80000000)
    940         __(mov imm1,arg_x,lsr imm1)
    941         __(ref_global(temp0,refbits))
     1007        __(bhs 8f)
     1008        __(and imm2,imm0,#31)
     1009        __(mov imm1,#0x80000000)
     1010        __(mov imm1,imm1,lsr imm2)
     1011        __(ref_global(temp1,refbits))
    9421012        __(mov imm0,imm0,lsr #bitmap_shift)
    943         __(add temp0,temp0,imm0,lsl #word_shift)
    944         __(ldr imm2,[temp0])
     1013        __(add temp1,temp1,imm0,lsl #word_shift)
     1014        __(ldr imm2,[temp1])
    9451015        __(tst imm2,imm1)
    9461016        __(bxne lr)
    947 2:      __(ldrex imm2,[temp0])
     10172:      __(ldrex imm2,[temp1])
    9481018        __(orr imm2,imm2,imm1)
    949         __(strex imm0,imm2,[temp0])
    950         .globl C(egc_set_hash_key_conditional_test)
    951 C(egc_set_hash_key_conditional_test):
     1019        __(strex imm0,imm2,[temp1])
    9521020        __(cmp imm0,#0)
    9531021        __(bne 2b)
    954         __(b 4f)
     1022        __(add imm0,arg_x,temp2,asr #fixnumshift)
     1023        __(sub imm0,imm0,temp0)
     1024        __(mov imm0,imm0,lsr #dnode_shift+8)
     1025        __(mov imm1,#0x80000000)
     1026        __(and imm2,imm0,#31)
     1027        __(mov imm1,imm1,lsr imm2)
     1028        __(mov imm0,imm0,lsr #bitmap_shift)
     1029        __(ref_global(temp1,ephemeral_refidx))
     1030        __(add temp1,temp1,imm0,lsl #word_shift)
     10313:      __(ldrex imm2,[temp1])
     1032        __(orr imm2,imm2,imm1)
     1033        __(strex imm0,imm2,[temp1])
     1034        __(cmp imm0,#0)
     1035        __(bne 3b)
     1036        __(b 8f)
    9551037 
    9561038/* arg_z = new value, arg_y = expected old value, arg_x = hash-vector,
     
    9611043        .globl C(egc_set_hash_key_conditional)
    9621044C(egc_set_hash_key_conditional):
    963         __(vpop1(imm1))
    964         __(unbox_fixnum(imm1,imm1))
     1045        __(vpop1(temp2))
     1046        __(unbox_fixnum(imm1,temp2))
    96510470:      __(add imm2,arg_x,imm1)
    9661048        __(ldrex temp1,[imm2])
    9671049        __(cmp temp1,arg_y)
    968         __(bne 5f)
     1050        __(bne 9f)
    9691051        __(strex imm0,arg_z,[imm2])
     1052        .globl C(egc_set_hash_key_conditional_test)
     1053C(egc_set_hash_key_conditional_test):
    9701054        __(cmp imm0,#0)
    9711055        __(bne 0b)
    9721056        __(cmp arg_z,arg_x)
    973         __(blo 4f)
     1057        __(blo 8f)
    9741058        __(ref_global(temp0,ref_base))
    9751059        __(sub imm0,imm2,temp0)
     
    9771061        __(ref_global(imm1,oldspace_dnode_count))
    9781062        __(cmp imm0,imm1)
    979         __(bhs 4f)
     1063        __(bhs 8f)
    9801064        __(and imm2,imm0,#31)
    9811065        __(mov imm1,#0x80000000)
    9821066        __(mov imm1,imm1,lsr imm2)
    9831067        __(mov imm0,imm0,lsr #bitmap_shift)
    984         __(ref_global(temp0,refbits))
    985         __(add temp0,temp0,imm0,lsl #word_shift)
    986         __(ldr imm2,[temp0])
     1068        __(ref_global(temp1,refbits))
     1069        __(add temp1,temp1,imm0,lsl #word_shift)
     1070        __(ldr imm2,[temp1])
    9871071        __(tst imm2,imm1)
    9881072        __(bxne lr)
    989 1:      __(ldrex imm2,[temp0])
     10731:      __(ldrex imm2,[temp1])
    9901074        __(orr imm2,imm2,imm1)
    991         __(strex imm0,imm2,[temp0])
     1075        __(strex imm0,imm2,[temp1])
    9921076        __(cmp imm0,#0)
    993         __(bne 1b)       
     1077        __(bne 1b)
     1078        __(add imm0,arg_x,temp2,asr #fixnumshift)
     1079        __(sub imm0,imm0,temp0)
     1080        __(mov imm0,imm0,lsr #dnode_shift+8)
     1081        __(and imm2,imm0,#31)
     1082        __(mov imm1,#0x80000000)
     1083        __(mov imm1,imm1,lsr imm2)
     1084        __(mov imm0,imm0,lsr #bitmap_shift)
     1085        __(ref_global(temp1,ephemeral_refidx))
     1086        __(add temp1,temp1,imm0,lsl #word_shift)
     10872:      __(ldrex imm2,[temp1])
     1088        __(orr imm2,imm2,imm1)
     1089        __(strex imm0,imm2,[temp1])
     1090        __(cmp imm0,#0)
     1091        __(bne 2b)   
    9941092/* Now need to ensure that the hash table itself is in the refmap; we
    9951093   know that it's in bounds, etc. */
    996         __(ref_global(temp0,ref_base))
    9971094        __(sub imm0,arg_x,temp0)
    9981095        __(mov imm0,imm0,lsr #dnode_shift)
     
    10011098        __(mov imm1,imm1,lsr imm2)
    10021099        __(mov imm0,imm0,lsr #bitmap_shift)
    1003         __(ref_global(temp0,refbits))
    1004         __(add temp0,temp0,imm0,lsl #word_shift)
    1005         __(ldr imm2,[temp0])
     1100        __(ref_global(temp1,refbits))
     1101        __(add temp1,temp1,imm0,lsl #word_shift)
     1102        __(ldr imm2,[temp1])
    10061103        __(tst imm2,imm1)
    10071104        __(bxne lr)
    1008 1:      __(ldrex imm2,[temp0])
     11053:      __(ldrex imm2,[temp1])
    10091106        __(orr imm2,imm2,imm1)
    1010         __(strex imm0,imm2,[temp0])
     1107        __(strex imm0,imm2,[temp1])
    10111108        __(cmp imm0,#0)
    1012         __(bne 1b)       
     1109        __(bne 3b)
     1110        __(sub imm0,arg_x,temp0)
     1111        __(mov imm0,imm0,lsr #dnode_shift+8)
     1112        __(and imm2,imm0,#31)
     1113        __(mov imm1,#0x80000000)
     1114        __(mov imm1,imm1,lsr imm2)
     1115        __(mov imm0,imm0,lsr #bitmap_shift)
     1116        __(ref_global(temp1,ephemeral_refidx))
     1117        __(add temp1,temp1,imm0,lsl #word_shift)
     11184:      __(ldrex imm2,[temp1])
     1119        __(orr imm2,imm2,imm1)
     1120        __(strex imm0,imm2,[temp1])
     1121        __(cmp imm0,#0)
     1122        __(bne 4b)
     1123       
    10131124C(egc_write_barrier_end):
    1014 4:      __(mov arg_z,#nil_value)
     11258:      __(mov arg_z,#nil_value)
    10151126        __(add arg_z,arg_z,#t_offset)
    10161127        __(bx lr)
    1017 5:      __(_clrex(arg_z))
     11289:      __(_clrex(arg_z))
    10181129        __(mov arg_z,#nil_value)
    10191130        __(bx lr)
  • trunk/source/lisp-kernel/bits.c

    r15826 r15842  
    5454}
    5555
    56 /* Note that this zeros longwords */
     56/* Note that this zeros natural-sized words */
    5757void
    5858zero_bits(bitvector bits, natural nbits)
    5959{
    60   memset(bits, 0, ((sizeof(natural)*(((nbits+(nbits_in_word-1)))>>bitmap_shift))));
     60  natural i, n = (((nbits+(nbits_in_word-1)))>>bitmap_shift);
     61 
     62  for(i=0; i < n; i++) {
     63    bits[i]= 0;
     64  }
    6165}
    6266
  • trunk/source/lisp-kernel/constants.h

    r15826 r15842  
    179179#define gc_postgc_pending fixnum_bitmask(26)
    180180
     181typedef struct {
     182  natural w0;
     183  natural w1;
     184} dnode;
  • trunk/source/lisp-kernel/gc-common.c

    r15826 r15842  
    10901090}
    10911091
    1092 void
    1093 forward_memoized_area(area *a, natural num_memo_dnodes, bitvector refbits)
    1094 {
    1095   LispObj *p = (LispObj *) a->low, x1, x2, new;
     1092typedef struct {
     1093  bitvector refidx;
     1094  bitvector refbits;
     1095  bitvector idxp;
     1096  bitvector idxlimit;
     1097  bitvector rangelimit;
     1098  bitvector reflimit;
     1099  bitvector refp;
     1100  natural idx;
     1101  bitvector idxbase;
     1102} bitidx_state;
     1103
     1104natural *
     1105next_refbits(bitidx_state *s)
     1106{
     1107  bitvector p, limit;
     1108  natural idxbit, idx;
     1109
     1110  while (1) {
     1111    p = s->refp;
     1112    limit = s->rangelimit;
     1113    while (p < limit) {
     1114      if (*p) {
     1115        s->refp = p+1;
     1116        return p;
     1117      }
     1118      p++;
     1119    }
     1120    if (!s->refidx) {
     1121      return NULL;
     1122    }
     1123    idx = s->idx;
     1124    while (idx == 0) {
     1125      if (s->idxp == s->idxlimit) {
     1126        return NULL;
     1127      }
     1128      idx = *(s->idxp);
     1129      if (idx) {
     1130        s->idx = idx;
     1131        s->idxbase = s->refbits + ((s->idxp - s->refidx) * (WORD_SIZE * (256 / WORD_SIZE)));
     1132      }
     1133      s->idxp++;
     1134    }
     1135    idxbit = count_leading_zeros(idx);
     1136    s->idx &= ~(BIT0_MASK>>idxbit);
     1137    p = s->idxbase + (idxbit * (256/WORD_SIZE));
     1138    s->refp = p;
     1139    s->rangelimit = p + (256/WORD_SIZE);
     1140    if (s->reflimit < s->rangelimit) {
     1141      s->rangelimit = s->reflimit;
     1142    }
     1143  }
     1144}
     1145
     1146void
     1147init_bitidx_state(bitidx_state *s, bitvector refidx, bitvector refbits, natural ndnodes)
     1148{
     1149  s->refidx = refidx;
     1150  s->refbits = refbits;
     1151  s->idxp = refidx;
     1152  s->idx = 0;
     1153  s->refp = refbits;
     1154  s->reflimit = refbits + ((ndnodes + (WORD_SIZE-1)) >> bitmap_shift);
     1155  if (refidx == NULL) {
     1156    s->idxlimit = NULL;
     1157    s->rangelimit = s->reflimit;
     1158  } else {
     1159  s->idxlimit = refidx + ((((ndnodes + 255) >> 8) + (WORD_SIZE-1)) >> bitmap_shift);
     1160    s->rangelimit = s->idxbase = NULL;
     1161  }
     1162}
     1163
     1164
     1165void
     1166forward_memoized_area(area *a, natural num_memo_dnodes, bitvector refbits, bitvector refidx)
     1167{
     1168  LispObj *p = (LispObj *) a->low, *pbase = p, x1, x2, new;
    10961169#ifdef ARM
    10971170  LispObj *p0 = p;
    10981171#endif
    1099   natural bits, bitidx, *bitsp, nextbit, diff, memo_dnode = 0, hash_dnode_limit = 0;
     1172  natural bits, *bitsp, nextbit,  memo_dnode = 0, ref_dnode, hash_dnode_limit = 0;
    11001173  int tag_x1;
    11011174  hash_table_vector_header *hashp = NULL;
    11021175  Boolean header_p;
     1176  bitidx_state state;
     1177
    11031178
    11041179
    11051180
    11061181  if (num_memo_dnodes) {
     1182    init_bitidx_state(&state, refidx, refbits, num_memo_dnodes);
    11071183    if (GCDebug) {
    1108       check_refmap_consistency(p, p+(num_memo_dnodes << 1), refbits);
     1184      check_refmap_consistency(p, p+(num_memo_dnodes << 1), refbits, refidx);
    11091185    }
    11101186
     
    11121188       when we move a key in a hash table vector that wants
    11131189       us to tell it about that. */
    1114 
    1115     set_bitidx_vars(refbits, 0, bitsp, bits, bitidx);
    1116     while (memo_dnode < num_memo_dnodes) {
     1190   
     1191    bits = 0;
     1192    while (1) {
    11171193      if (bits == 0) {
    1118         int remain = nbits_in_word - bitidx;
    1119         memo_dnode += remain;
    1120         p += (remain+remain);
    1121         if (memo_dnode < num_memo_dnodes) {
    1122           bits = *++bitsp;
    1123         }
    1124         bitidx = 0;
    1125       } else {
    1126         nextbit = count_leading_zeros(bits);
    1127         if ((diff = (nextbit - bitidx)) != 0) {
    1128           memo_dnode += diff;
    1129           bitidx = nextbit;
    1130           p += (diff+diff);
    1131         }
    1132         x1 = p[0];
    1133         x2 = p[1];
    1134         tag_x1 = fulltag_of(x1);
    1135         bits &= ~(BIT0_MASK >> bitidx);
    1136         header_p = (nodeheader_tag_p(tag_x1));
    1137 
    1138         if (header_p &&
    1139             (header_subtag(x1) == subtag_hash_vector)) {
    1140           hashp = (hash_table_vector_header *) p;
    1141           if (hashp->flags & nhash_track_keys_mask) {
    1142             hash_dnode_limit = memo_dnode + ((header_element_count(x1)+2)>>1);
    1143           } else {
    1144             hashp = NULL;
    1145           }
    1146         }
    1147 
    1148 
    1149         if (! header_p) {
    1150           new = node_forwarding_address(x1);
    1151           if (new != x1) {
    1152             *p = new;
     1194        bitsp = next_refbits(&state);
     1195        if (bitsp == NULL) {
     1196          return;
     1197        }
     1198        bits = *bitsp;
     1199        ref_dnode = (bitsp-refbits)<<bitmap_shift;
     1200      }
     1201      nextbit = count_leading_zeros(bits);
     1202      bits &= ~(BIT0_MASK>>nextbit);
     1203      memo_dnode = ref_dnode + nextbit;
     1204      p = pbase+(memo_dnode*2);
     1205      x1 = p[0];
     1206      x2 = p[1];
     1207      tag_x1 = fulltag_of(x1);
     1208      header_p = (nodeheader_tag_p(tag_x1));
     1209
     1210      if (header_p &&
     1211          (header_subtag(x1) == subtag_hash_vector)) {
     1212        hashp = (hash_table_vector_header *) p;
     1213        if (hashp->flags & nhash_track_keys_mask) {
     1214          hash_dnode_limit = memo_dnode + ((header_element_count(x1)+2)>>1);
     1215        } else {
     1216          hashp = NULL;
     1217        }
     1218      }
     1219      if (! header_p) {
     1220        new = node_forwarding_address(x1);
     1221        if (new != x1) {
     1222          *p = new;
    11531223#ifdef ARM
    1154             if (p != p0) {
    1155               if(header_subtag(p[-2]) == subtag_function) {
    1156                 /* Just updated the code vector; fix the entrypoint */
    1157                 if (p[-1] == (untag(x1)+fulltag_odd_fixnum)) {
    1158                   p[-1] = (untag(new)+fulltag_odd_fixnum);
    1159                 }
     1224          /* This is heuristic: the two words before P might be immediate
     1225             data that just happens to look like a function header and
     1226             an unboxed reference to p[0].  That's extremely unlikely,
     1227             but close doesn't count ... Fix this. */
     1228          if (p != p0) {
     1229            if(header_subtag(p[-2]) == subtag_function) {
     1230              /* Just updated the code vector; fix the entrypoint */
     1231              if (p[-1] == (untag(x1)+fulltag_odd_fixnum)) {
     1232                p[-1] = (untag(new)+fulltag_odd_fixnum);
    11601233              }
    11611234            }
     1235          }
    11621236#endif
    1163           }
    1164         }
    1165         p++;
    1166 
    1167         new = node_forwarding_address(x2);
    1168         if (new != x2) {
    1169           *p = new;
    1170           if (memo_dnode < hash_dnode_limit) {
    1171             /* If this code is reached, 'hashp' is non-NULL and pointing
    1172                at the header of a hash_table_vector, and 'memo_dnode' identifies
    1173                a pair of words inside the hash_table_vector.  It may be
    1174                hard for program analysis tools to recognize that, but I
    1175                believe that warnings about 'hashp' being NULL here can
    1176                be safely ignored. */
    1177             hashp->flags |= nhash_key_moved_mask;
    1178             hash_dnode_limit = 0;
    1179             hashp = NULL;
    1180           }
    1181         }
    1182         p++;
    1183         memo_dnode++;
    1184         bitidx++;
    1185 
     1237        }
     1238      }
     1239      p++;
     1240     
     1241      new = node_forwarding_address(x2);
     1242      if (new != x2) {
     1243        *p = new;
     1244        if (memo_dnode < hash_dnode_limit) {
     1245          /* If this code is reached, 'hashp' is non-NULL and pointing
     1246             at the header of a hash_table_vector, and 'memo_dnode' identifies
     1247             a pair of words inside the hash_table_vector.  It may be
     1248             hard for program analysis tools to recognize that, but I
     1249             believe that warnings about 'hashp' being NULL here can
     1250             be safely ignored. */
     1251          hashp->flags |= nhash_key_moved_mask;
     1252          hash_dnode_limit = 0;
     1253          hashp = NULL;
     1254        }
    11861255      }
    11871256    }
     
    12961365}
    12971366
    1298 void
    1299 mark_managed_static_refs(area *a, BytePtr low_dynamic_address, natural ndynamic_dnodes)
     1367
     1368void
     1369mark_managed_static_refs(area *a, BytePtr low_dynamic_address, natural ndynamic_dnodes, bitvector refidx)
    13001370{
    13011371  bitvector refbits = managed_static_refbits;
     1372  dnode *dnodes = (dnode *)a->low, *d;
    13021373  LispObj *p = (LispObj *) a->low, x1, x2;
    1303   natural inbits, outbits, bits, bitidx, *bitsp, nextbit, diff, memo_dnode = 0,
    1304     num_memo_dnodes = a->ndnodes;
     1374  natural inbits, outbits, bits, *bitsp, nextbit, memo_dnode = 0,
     1375    num_memo_dnodes = a->ndnodes, ref_dnode;
    13051376  Boolean keep_x1, keep_x2;
     1377  bitidx_state state;
    13061378
    13071379  if (num_memo_dnodes) {
     1380    init_bitidx_state(&state, refidx, refbits, num_memo_dnodes);
     1381
    13081382    if (GCDebug) {
    1309       check_refmap_consistency(p, p+(num_memo_dnodes << 1), refbits);
     1383      check_refmap_consistency(p, p+(num_memo_dnodes << 1), refbits, refidx);
    13101384    }
    13111385
    13121386 
    1313     set_bitidx_vars(refbits, 0, bitsp, bits, bitidx);
    1314     inbits = outbits = bits;
    1315     while (memo_dnode < num_memo_dnodes) {
     1387
     1388
     1389    inbits = outbits = bits = 0;
     1390    while (1) {
    13161391      if (bits == 0) {
    1317         int remain = nbits_in_word - bitidx;
    1318         memo_dnode += remain;
    1319         p += (remain+remain);
    13201392        if (outbits != inbits) {
    13211393          *bitsp = outbits;
    13221394        }
    1323         if (memo_dnode < num_memo_dnodes) {
    1324           bits = *++bitsp;
    1325         }
    1326         inbits = outbits = bits;
    1327         bitidx = 0;
    1328       } else {
    1329         nextbit = count_leading_zeros(bits);
    1330         if ((diff = (nextbit - bitidx)) != 0) {
    1331           memo_dnode += diff;
    1332           bitidx = nextbit;
    1333           p += (diff+diff);
    1334         }
    1335         x1 = *p++;
    1336         x2 = *p++;
    1337         bits &= ~(BIT0_MASK >> bitidx);
    1338         keep_x1 = mark_static_ref(x1, low_dynamic_address, ndynamic_dnodes);
    1339         keep_x2 = mark_static_ref(x2, low_dynamic_address, ndynamic_dnodes);
    1340         if ((keep_x1 == false) &&
    1341             (keep_x2 == false)) {
    1342           outbits &= ~(BIT0_MASK >> bitidx);
    1343         }
    1344         memo_dnode++;
    1345         bitidx++;
     1395        bitsp = next_refbits(&state);
     1396        if (bitsp == NULL) {
     1397          break;
     1398        }
     1399        inbits = outbits = bits = *bitsp;
     1400        ref_dnode = (bitsp-refbits)<<bitmap_shift;
     1401      }
     1402      nextbit = count_leading_zeros(bits);
     1403      bits &= ~(BIT0_MASK>>nextbit);
     1404      memo_dnode = ref_dnode + nextbit;
     1405      d = dnodes+memo_dnode;
     1406      x1 = d->w0;
     1407      x2 = d->w1;
     1408      keep_x1 = mark_static_ref(x1, low_dynamic_address, ndynamic_dnodes);
     1409      keep_x2 = mark_static_ref(x2, low_dynamic_address, ndynamic_dnodes);
     1410      if ((keep_x1 == false) &&
     1411          (keep_x2 == false)) {
     1412        outbits &= ~(BIT0_MASK >> nextbit);
    13461413      }
    13471414    }
    13481415    if (GCDebug) {
    13491416      p = (LispObj *) a->low;
    1350       check_refmap_consistency(p, p+(num_memo_dnodes << 1), refbits);
    1351     }
    1352   }
    1353 }
    1354 
    1355 void
    1356 mark_memoized_area(area *a, natural num_memo_dnodes)
     1417      check_refmap_consistency(p, p+(num_memo_dnodes << 1), refbits, NULL);
     1418    }
     1419  }
     1420}
     1421
     1422
     1423void
     1424mark_memoized_area(area *a, natural num_memo_dnodes, bitvector refidx)
    13571425{
    13581426  bitvector refbits = a->refbits;
    1359   LispObj *p = (LispObj *) a->low, x1, x2;
    1360   natural inbits, outbits, bits, bitidx, *bitsp, nextbit, diff, memo_dnode = 0;
     1427  dnode *dnodes = (dnode *)a->low, *d;
     1428  LispObj *p = (LispObj *) a->low,x1, x2;
     1429  natural inbits, outbits, bits,  *bitsp, nextbit,  memo_dnode = 0, ref_dnode = 0;
    13611430  Boolean keep_x1, keep_x2;
    13621431  natural hash_dnode_limit = 0;
    13631432  hash_table_vector_header *hashp = NULL;
    13641433  int mark_method = 3;
     1434  bitidx_state state;
     1435
     1436
    13651437
    13661438  if (num_memo_dnodes) {
     1439    init_bitidx_state(&state, refidx, refbits, num_memo_dnodes);   
     1440   
    13671441    if (GCDebug) {
    1368       check_refmap_consistency(p, p+(num_memo_dnodes << 1), refbits);
     1442      check_refmap_consistency(p, p+(num_memo_dnodes << 1), refbits, refidx);
    13691443    }
    13701444
     
    13741448       or readonly areas is definitely uninteresting, but other cases are
    13751449       more complicated (and some of these cases are hard to detect.)
    1376 
    13771450       Some headers are "interesting", to the forwarder if not to us.
    13781451
     
    13971470      }
    13981471    }
    1399        
    1400     set_bitidx_vars(refbits, 0, bitsp, bits, bitidx);
    1401     inbits = outbits = bits;
    1402     while (memo_dnode < num_memo_dnodes) {
     1472     
     1473     
     1474
     1475    inbits = outbits = bits = 0;
     1476    while (1) {
    14031477      if (bits == 0) {
    1404         int remain = nbits_in_word - bitidx;
    1405         memo_dnode += remain;
    1406         p += (remain+remain);
    14071478        if (outbits != inbits) {
    14081479          *bitsp = outbits;
    14091480        }
    1410         if (memo_dnode < num_memo_dnodes) {
    1411           bits = *++bitsp;
    1412         }
    1413         inbits = outbits = bits;
    1414         bitidx = 0;
    1415       } else {
    1416         nextbit = count_leading_zeros(bits);
    1417         if ((diff = (nextbit - bitidx)) != 0) {
    1418           memo_dnode += diff;
    1419           bitidx = nextbit;
    1420           p += (diff+diff);
    1421         }
    1422         x1 = *p++;
    1423         x2 = *p++;
    1424         bits &= ~(BIT0_MASK >> bitidx);
    1425 
    1426 
    1427         if (hashp) {
    1428           Boolean force_x1 = false;
    1429           if ((memo_dnode >= hash_dnode_limit) && (mark_method == 3)) {
    1430             /* if vector_header_count is odd, x1 might be the last word of the header */
    1431             force_x1 = (hash_table_vector_header_count & 1) && (memo_dnode == hash_dnode_limit);
    1432             /* was marking header, switch to data */
    1433             hash_dnode_limit = area_dnode(((LispObj *)hashp)
    1434                                           + 1
    1435                                           + header_element_count(hashp->header),
    1436                                           a->low);
    1437             /* In traditional weak method, don't mark vector entries at all. */
    1438             /* Otherwise mark the non-weak elements only */
    1439             mark_method = ((lisp_global(WEAK_GC_METHOD) == 0) ? 0 :
    1440                            ((hashp->flags & nhash_weak_value_mask)
    1441                             ? (1 + (hash_table_vector_header_count & 1))
    1442                             : (2 - (hash_table_vector_header_count & 1))));
     1481        bitsp = next_refbits(&state);
     1482        if (bitsp == NULL) {
     1483          break;
     1484        }
     1485        inbits = outbits = bits = *bitsp;
     1486        ref_dnode = (bitsp-refbits)<<bitmap_shift;
     1487      }
     1488      nextbit = count_leading_zeros(bits);
     1489      bits &= ~(BIT0_MASK >> nextbit);
     1490      memo_dnode = ref_dnode + nextbit;
     1491      d = dnodes+memo_dnode;
     1492      x1 = d->w0;
     1493      x2 = d->w1;
     1494
     1495
     1496      if (hashp) {
     1497        Boolean force_x1 = false;
     1498        if ((memo_dnode >= hash_dnode_limit) && (mark_method == 3)) {
     1499          /* if vector_header_count is odd, x1 might be the last word of the header */
     1500          force_x1 = (hash_table_vector_header_count & 1) && (memo_dnode == hash_dnode_limit);
     1501          /* was marking header, switch to data */
     1502          hash_dnode_limit = area_dnode(((LispObj *)hashp)
     1503                                        + 1
     1504                                        + header_element_count(hashp->header),
     1505                                        a->low);
     1506          /* In traditional weak method, don't mark vector entries at all. */
     1507          /* Otherwise mark the non-weak elements only */
     1508          mark_method = ((lisp_global(WEAK_GC_METHOD) == 0) ? 0 :
     1509                         ((hashp->flags & nhash_weak_value_mask)
     1510                          ? (1 + (hash_table_vector_header_count & 1))
     1511                          : (2 - (hash_table_vector_header_count & 1))));
     1512        }
     1513       
     1514        if (memo_dnode < hash_dnode_limit) {
     1515          /* perhaps ignore one or both of the elements */
     1516          if (!force_x1 && !(mark_method & 1)) x1 = 0;
     1517          if (!(mark_method & 2)) x2 = 0;
     1518        } else {
     1519          hashp = NULL;
     1520        }
     1521      }
     1522
     1523      if (header_subtag(x1) == subtag_hash_vector) {
     1524        if (hashp) Bug(NULL, "header inside hash vector?");
     1525        hash_table_vector_header *hp = (hash_table_vector_header *)d;
     1526        if (hp->flags & nhash_weak_mask) {
     1527          /* Work around the issue that seems to cause ticket:817,
     1528             which is that tenured hash vectors that are weak on value
     1529             aren't always maintained on GCweakvll.  If they aren't and
     1530             we process them weakly here, nothing will delete the unreferenced
     1531             elements. */
     1532          if (!(hp->flags & nhash_weak_value_mask)) {
     1533            /* If header_count is odd, this cuts off the last header field */
     1534            /* That case is handled specially above */
     1535            hash_dnode_limit = memo_dnode + ((hash_table_vector_header_count) >>1);
     1536            hashp = hp;
     1537            mark_method = 3;
    14431538          }
    1444 
    1445           if (memo_dnode < hash_dnode_limit) {
    1446             /* perhaps ignore one or both of the elements */
    1447             if (!force_x1 && !(mark_method & 1)) x1 = 0;
    1448             if (!(mark_method & 2)) x2 = 0;
    1449           } else {
    1450             hashp = NULL;
    1451           }
    1452         }
    1453 
    1454         if (header_subtag(x1) == subtag_hash_vector) {
    1455           if (hashp) Bug(NULL, "header inside hash vector?");
    1456           hash_table_vector_header *hp = (hash_table_vector_header *)(p - 2);
    1457           if (hp->flags & nhash_weak_mask) {
    1458             /* Work around the issue that seems to cause ticket:817,
    1459                which is that tenured hash vectors that are weak on value
    1460                aren't always maintained on GCweakvll.  If they aren't and
    1461                we process them weakly here, nothing will delete the unreferenced
    1462                elements. */
    1463             if (!(hp->flags & nhash_weak_value_mask)) {
    1464               /* If header_count is odd, this cuts off the last header field */
    1465               /* That case is handled specially above */
    1466               hash_dnode_limit = memo_dnode + ((hash_table_vector_header_count) >>1);
    1467               hashp = hp;
    1468               mark_method = 3;
    1469             }
    1470           }
    1471         }
    1472 
    1473         keep_x1 = mark_ephemeral_root(x1);
    1474         keep_x2 = mark_ephemeral_root(x2);
    1475         if ((keep_x1 == false) &&
    1476             (keep_x2 == false) &&
    1477             (hashp == NULL)) {
    1478           outbits &= ~(BIT0_MASK >> bitidx);
    1479         }
    1480         memo_dnode++;
    1481         bitidx++;
     1539        }
     1540      }
     1541
     1542      keep_x1 = mark_ephemeral_root(x1);
     1543      keep_x2 = mark_ephemeral_root(x2);
     1544      if ((keep_x1 == false) &&
     1545          (keep_x2 == false) &&
     1546          (hashp == NULL)) {
     1547        outbits &= ~(BIT0_MASK >> nextbit);
    14821548      }
    14831549    }
    14841550    if (GCDebug) {
    14851551      p = (LispObj *) a->low;
    1486       check_refmap_consistency(p, p+(num_memo_dnodes << 1), refbits);
    1487     }
    1488   }
    1489 }
    1490 
    1491 extern void zero_dnodes(void *,natural);
     1552      check_refmap_consistency(p, p+(num_memo_dnodes << 1), refbits, a->refidx);
     1553    }
     1554  }
     1555}
     1556
    14921557
    14931558void
     
    15011566    pkg = 0,
    15021567    itabvec = 0;
    1503   BytePtr oldfree = a->active, last_zeroed_addr;
     1568  BytePtr oldfree = a->active;
    15041569  TCR *other_tcr;
    15051570  natural static_dnodes;
     
    16861751
    16871752    if (GCephemeral_low) {
    1688       mark_memoized_area(tenured_area, area_dnode(a->low,tenured_area->low));
    1689       mark_memoized_area(managed_static_area,managed_static_area->ndnodes);
     1753      mark_memoized_area(tenured_area, area_dnode(a->low,tenured_area->low), tenured_area->refidx);
     1754      mark_memoized_area(managed_static_area,managed_static_area->ndnodes, managed_static_area->refidx);
    16901755    } else {
    1691       mark_managed_static_refs(managed_static_area,low_markable_address,area_dnode(a->active,low_markable_address));
     1756      mark_managed_static_refs(managed_static_area,low_markable_address,area_dnode(a->active,low_markable_address), managed_static_refidx);
    16921757    }
    16931758    other_tcr = tcr;
     
    18221887
    18231888    if (GCephemeral_low) {
    1824       forward_memoized_area(tenured_area, area_dnode(a->low, tenured_area->low), tenured_area->refbits);
    1825       forward_memoized_area(managed_static_area,managed_static_area->ndnodes, managed_static_area->refbits);
     1889      forward_memoized_area(tenured_area, area_dnode(a->low, tenured_area->low), tenured_area->refbits, tenured_area->refidx);
     1890      forward_memoized_area(managed_static_area,managed_static_area->ndnodes, managed_static_area->refbits, managed_static_area->refidx);
    18261891    } else {
    1827       forward_memoized_area(managed_static_area,area_dnode(managed_static_area->active,managed_static_area->low),managed_static_refbits);
     1892      forward_memoized_area(managed_static_area,area_dnode(managed_static_area->active,managed_static_area->low),managed_static_refbits, NULL);
    18281893    }
    18291894    a->active = (BytePtr) ptr_from_lispobj(compact_dynamic_heap());
     
    18391904                        (GCephemeral_low == 0) ? lisp_heap_gc_threshold : 0);
    18401905
    1841     if (oldfree < a->high) {
    1842       last_zeroed_addr = oldfree;
    1843     } else {
    1844       last_zeroed_addr = a->high;
    1845     }
    1846     zero_dnodes(a->active, area_dnode(last_zeroed_addr,a->active));
    18471906
    18481907    /*
     
    19401999  }
    19412000}
     2001
     2002/*
     2003  This doesn't GC; it returns true if it made enough room, false
     2004  otherwise.
     2005  If "extend" is true, it can try to extend the dynamic area to
     2006  satisfy the request.
     2007*/
     2008
     2009Boolean
     2010new_heap_segment(ExceptionInformation *xp, natural need, Boolean extend, TCR *tcr, Boolean *crossed_threshold)
     2011{
     2012  area *a;
     2013  natural newlimit, oldlimit;
     2014  natural log2_allocation_quantum = TCR_AUX(tcr)->log2_allocation_quantum;
     2015
     2016  if (crossed_threshold) {
     2017    *crossed_threshold = false;
     2018  }
     2019
     2020  a  = active_dynamic_area;
     2021  oldlimit = (natural) a->active;
     2022  newlimit = (align_to_power_of_2(oldlimit, log2_allocation_quantum) +
     2023              align_to_power_of_2(need, log2_allocation_quantum));
     2024  if (newlimit > (natural) (a->high)) {
     2025    if (extend) {
     2026      signed_natural inhibit = (signed_natural)(lisp_global(GC_INHIBIT_COUNT));
     2027      natural extend_by = inhibit ? 0 : lisp_heap_gc_threshold;
     2028      do {
     2029        if (resize_dynamic_heap(a->active, (newlimit-oldlimit)+extend_by)) {
     2030          break;
     2031        }
     2032        extend_by = align_to_power_of_2(extend_by>>1,log2_allocation_quantum);
     2033        if (extend_by < 4<<20) {
     2034          return false;
     2035        }
     2036      } while (1);
     2037    } else {
     2038      return false;
     2039    }
     2040  }
     2041  a->active = (BytePtr) newlimit;
     2042  platform_new_heap_segment(xp, tcr, (BytePtr)oldlimit, (BytePtr)newlimit);
     2043  if ((BytePtr)oldlimit < heap_dirty_limit) {
     2044    if ((BytePtr)newlimit < heap_dirty_limit) {
     2045      zero_dnodes((void *)oldlimit,area_dnode(newlimit,oldlimit));
     2046    } else {
     2047      zero_dnodes((void *)oldlimit,area_dnode(heap_dirty_limit,oldlimit));
     2048    }
     2049  }
     2050  if ((BytePtr)newlimit > heap_dirty_limit) {
     2051    heap_dirty_limit = (BytePtr)newlimit;       
     2052  }
     2053
     2054  if (crossed_threshold && (!extend)) {
     2055    if (((a->high - (BytePtr)newlimit) < lisp_heap_notify_threshold)&&
     2056        ((a->high - (BytePtr)oldlimit) >= lisp_heap_notify_threshold)) {
     2057      *crossed_threshold = true;
     2058    }
     2059  }
     2060   
     2061
     2062  return true;
     2063}
  • trunk/source/lisp-kernel/gc.h

    r15826 r15842  
    6464extern LispObj GCarealow, GCareadynamiclow;
    6565extern natural GCndnodes_in_area, GCndynamic_dnodes_in_area;
    66 extern bitvector GCmarkbits, GCdynamic_markbits,managed_static_refbits;
     66extern bitvector GCmarkbits, GCdynamic_markbits,managed_static_refbits,global_refidx,dynamic_refidx,managed_static_refidx;
    6767LispObj *global_reloctab, *GCrelocptr;
    6868LispObj GCfirstunmarked;
     
    8787Boolean egc_control(Boolean, BytePtr);
    8888Boolean free_segments_zero_filled_by_OS;
    89 
     89Boolean new_heap_segment(ExceptionInformation *, natural, Boolean , TCR *, Boolean *);
     90void platform_new_heap_segment(ExceptionInformation *, TCR*, BytePtr, BytePtr);
    9091/* an type representing 1/4 of a natural word */
    9192#if WORD_SIZE == 64
     
    187188void update_locref(LispObj *);
    188189void forward_gcable_ptrs(void);
    189 void forward_memoized_area(area *, natural, bitvector);
     190void forward_memoized_area(area *, natural, bitvector, bitvector);
     191
    190192void forward_tcr_tlb(TCR *);
    191193void reclaim_static_dnodes(void);
     
    214216LispObj dnode_forwarding_address(natural, int);
    215217LispObj locative_forwarding_address(LispObj);
    216 void check_refmap_consistency(LispObj *, LispObj *, bitvector);
     218void check_refmap_consistency(LispObj *, LispObj *, bitvector, bitvector);
    217219void check_all_areas(TCR *);
    218220void mark_tstack_area(area *);
     
    220222void mark_cstack_area(area *);
    221223void mark_simple_area_range(LispObj *, LispObj *);
    222 void mark_memoized_area(area *, natural);
     224void mark_memoized_area(area *, natural, bitvector);
    223225LispObj calculate_relocation(void);
    224226void forward_range(LispObj *, LispObj *);
     
    253255did_gc_notification_since_last_full_gc;
    254256
     257extern BytePtr heap_dirty_limit;
     258extern void zero_dnodes(void *,natural);
     259
     260
    255261#endif                          /* __GC_H__ */
  • trunk/source/lisp-kernel/image.c

    r15826 r15842  
    282282                   fd)) {
    283283        return;
     284      }
     285      /* Should change image format and store this in the image */
     286      {
     287        natural ndnodes = area_dnode(a->active, a->low), i;
     288        if (!CommitMemory(managed_static_refidx,(((ndnodes +255)>>8)+7)>>3)) {
     289          return;
     290        }
     291        for (i=0; i < ndnodes; i++) {
     292          if (ref_bit(managed_static_refbits,i)) {
     293            set_bit(managed_static_refidx,i>>8);
     294          }
     295        }
    284296      }
    285297      advance += refbits_size;
  • trunk/source/lisp-kernel/lisp-debug.c

    r15606 r15842  
    311311  case REG_EBP: return 1<<5;
    312312  case REG_ESI: return 1<<6;
     313  default:                      /* stupid compiler */
    313314  case REG_EDI: return 1<<7;
    314315  }
  • trunk/source/lisp-kernel/lisp_globals.h

    r15826 r15842  
    7878#define MANAGED_STATIC_REFBITS (-50) /* refs from managed_static to dynamic */
    7979#define MANAGED_STATIC_DNODES (-51) /* ndnodes in managed_static_area */
     80#define EPHEMERAL_REFIDX      (-52) /* compressed refmap to ephmeral space */
     81#define MANAGED_STATIC_REFIDX (-53) /* compressed refmap from managed static to dynamic */
    8082
    81 
    82 
    83 #define MIN_KERNEL_GLOBAL MANAGED_STATIC_DNODES
     83#define MIN_KERNEL_GLOBAL MANAGED_STATIC_REFIDX
    8484
    8585/* These are only non-zero when an image is being saved or loaded */
  • trunk/source/lisp-kernel/lisp_globals.s

    r15826 r15842  
    212212         _rnode(managed_static_refbits) /* refs from managed_static to dynamic */
    213213         _rnode(managed_static_dnodes) /* ndnodes in managed_static_area */
     214         _rnode(ephemeral_refidx) /* index of refbits */
     215         _rnode(managed_static_refidx) /* index of managed_static_refbits */
    214216        _ends
    215217
  • trunk/source/lisp-kernel/mach-o-image.c

    r15826 r15842  
    712712  void *lib;
    713713  LispObj image_nil = 0;
     714  natural i;
    714715
    715716  /* Because of the way that we've reserved memory, we can only
     
    843844    CommitMemory(global_mark_ref_bits,align_to_power_of_2(nrefbytes, 12));
    844845    CommitMemory(managed_static_refbits,align_to_power_of_2(nrefbytes, 12));
     846    CommitMemory(managed_static_refidx,(managed_static_area->ndnodes+255)>>3);
    845847    memcpy(managed_static_refbits,ms_end,nrefbytes);
    846848    memset(ms_end,0,nrefbytes);
    847    
     849    for (i = 0; i < managed_static_area->ndnodes; i++) {
     850      if (ref_bit(managed_static_refbits,i)) {
     851        set_bit(managed_static_refidx,i>>8);
     852      }
     853    }
    848854    return image_nil;
    849855  }
  • trunk/source/lisp-kernel/memory.c

    r15826 r15842  
    406406}
    407407
     408void
     409zero_refbits(bitvector refidx, bitvector refbits, natural ndnodes)
     410{
     411  bitvector refbase = refbits, refword, limit = refbase + ((ndnodes + (WORD_SIZE-1)) >> node_shift), reflimit;
     412  natural i, n = (((ndnodes + 255) >> 8) + (WORD_SIZE-1)) >> bitmap_shift, bit, idx;
     413
     414  for (i = 0; i < n; i++, refbase += WORD_SIZE * (256 / WORD_SIZE)) {
     415    idx = *refidx;
     416   
     417    if (idx != 0) {
     418      *refidx = 0;
     419      while (idx) {
     420        bit = count_leading_zeros(idx);
     421        idx &= ~(BIT0_MASK>>bit);
     422        refword = refbase + bit * (256/WORD_SIZE);
     423        reflimit = refword + (256/WORD_SIZE);
     424        if (limit < reflimit) {
     425          reflimit = limit;
     426        }
     427        while (refword < reflimit) {
     428          *refword++ = 0;
     429        }
     430      }
     431    }
     432    refidx++;
     433  }
     434#if 0
     435  /* Check,slowly */
     436  for (i=0;i<ndnodes;i++) {
     437    if (ref_bit(refbits,i)) {
     438      Bug(NULL, "Bit 0x" LISP " set unexpectedly\n", i);
     439    }
     440  }
     441#endif
     442}
     443
    408444
    409445 
     
    432468      return true;
    433469    }
    434   }
     470  } 
    435471  return false;
    436472}
     
    654690 
    655691  if (target == tenured_area) {
     692    zero_refbits(global_refidx,managed_static_area->refbits, managed_static_area->ndnodes);
    656693    zero_bits(refbits, new_tenured_dnodes);
     694    zero_bits(dynamic_refidx,(new_tenured_dnodes+255)>>8);
    657695    lisp_global(OLDEST_EPHEMERAL) = ptr_to_lispobj(curfree);
    658696  } else {
     
    887925}
    888926
     927
     928   
     929
     930 
    889931#ifdef DARWIN
    890932/*
  • trunk/source/lisp-kernel/memprotect.h

    r15826 r15842  
    129129
    130130
     131void
     132initialize_refidx_from_refbits(bitvector, bitvector, natural);
    131133 
    132134#endif /* __memprotect_h__ */
  • trunk/source/lisp-kernel/pmcl-kernel.c

    r15826 r15842  
    136136
    137137LispObj lisp_nil = (LispObj) 0;
    138 bitvector global_mark_ref_bits = NULL, dynamic_mark_ref_bits = NULL, relocatable_mark_ref_bits = NULL;
     138bitvector global_mark_ref_bits = NULL, dynamic_mark_ref_bits = NULL, relocatable_mark_ref_bits = NULL, global_refidx = NULL, dynamic_refidx = NULL,managed_static_refidx = NULL;
    139139
    140140
     
    151151extern LispObj import_ptrs_base;
    152152
     153/* The highest heap address that's (probably) been written to. */
     154BytePtr heap_dirty_limit = NULL;
    153155
    154156
     
    290292    a->hardlimit = base+hardsize;
    291293    a->softlimit = base+hardsize+softsize;
    292     a->h = h;
    293294    a->softprot = soft_area;
    294295    a->hardprot = hard_area;
     
    526527{
    527528  Ptr h;
    528   natural base;
     529  natural base, refbits_size;
    529530  BytePtr
    530531    end,
     
    572573  end = lastbyte;
    573574  reserved_region_end = lastbyte;
    574   end = (BytePtr) ((natural)((((natural)end) - ((totalsize+63)>>6)) & ~4095));
     575  refbits_size = ((totalsize+63)>>6); /* word size! */
     576  end = (BytePtr) ((natural)((((natural)end) - refbits_size) & ~4095));
    575577
    576578  global_mark_ref_bits = (bitvector)end;
     579  end  = (BytePtr) ((natural)((((natural)end) - ((refbits_size+255) >> 8)) & ~4095));
     580  global_refidx = (bitvector)end;
     581  /* Don't really want to commit so much so soon */
     582  CommitMemory((BytePtr)global_refidx,(BytePtr)global_mark_ref_bits-(BytePtr)global_refidx);
     583   
    577584  end = (BytePtr) ((natural)((((natural)end) - ((totalsize+63) >> 6)) & ~4095));
    578585  global_reloctab = (LispObj *) end;
     
    592599      exit(1);
    593600    }
     601    managed_static_refidx = ReserveMemory(((((MANAGED_STATIC_SIZE>>dnode_shift)+255)>>8)+7)>>3);
     602    if (managed_static_refidx == NULL) {
     603#ifdef WINDOWS
     604      wperror("allocate refidx for managed static area");
     605#else
     606      perror("allocate refidx for managed static area");
     607#endif
     608      exit(1);
     609    }     
    594610  }
    595611#endif
     
    643659    prefix_size = (prefix_dnodes+7)>>3,
    644660    markbits_size = (3*sizeof(LispObj))+((ndnodes+7)>>3),
     661    prefix_index_bits,
    645662    n;
    646663  low_markable_address = low;
    647664  high_markable_address = high;
    648665  dynamic_mark_ref_bits = (bitvector)(((BytePtr)global_mark_ref_bits)+prefix_size);
     666  if (prefix_dnodes & 255) {
     667    fprintf(dbgout, "warning: prefix_dnodes not a multiple of 256\n");
     668  }
     669  prefix_index_bits = prefix_dnodes>>8;
     670  if (prefix_index_bits & (WORD_SIZE-1)) {
     671    fprintf(dbgout, "warning: prefix_index_bits not a multiple of %d\n", WORD_SIZE);
     672  }
     673  dynamic_refidx = (bitvector)(((BytePtr)global_refidx)+(prefix_index_bits>>3));
    649674  relocatable_mark_ref_bits = dynamic_mark_ref_bits;
    650675  n = align_to_power_of_2(markbits_size,log2_page_size);
     
    659684
    660685  if (new_dnodes) {
    661     natural n = (new_dnodes+7)>>3;
     686    natural n = (new_dnodes+7)>>3,
     687      nidx = ((((new_dnodes+255)>>8)+7)>>3)>>node_shift;
    662688
    663689    BytePtr old_markbits = (BytePtr)dynamic_mark_ref_bits,
     
    671697    a->ndnodes += new_dnodes;
    672698    a->low = new_low;
     699    a->refidx -= nidx;
    673700    low_markable_address = new_low;
    674701    lisp_global(HEAP_START) = (LispObj)new_low;
     
    722749  add_area_holding_area_lock(a);
    723750  CommitMemory(start, end-start);
    724   a->h = start;
    725751  a->softprot = NULL;
    726752  a->hardprot = NULL;
     
    775801  a->high -= delta;
    776802  a->ndnodes = area_dnode(a->high, a->low);
     803  if (heap_dirty_limit > a->high) {
     804    heap_dirty_limit = a->high;
     805  }
    777806  a->hardlimit = a->high;
    778807  uncommit_pages(a->high, delta);
     
    17481777    tenured_area->younger = g2_area;
    17491778    tenured_area->refbits = dynamic_mark_ref_bits;
     1779    tenured_area->refidx = dynamic_refidx;
    17501780    managed_static_area->refbits = global_mark_ref_bits;
     1781    managed_static_area->refidx = global_refidx;
    17511782    a->markbits = dynamic_mark_ref_bits;
    17521783    tenured_area->static_dnodes = a->static_dnodes;
     
    17571788    lisp_global(STATIC_CONS_AREA) = ptr_to_lispobj(static_cons_area);
    17581789    lisp_global(REFBITS) = ptr_to_lispobj(global_mark_ref_bits);
     1790    lisp_global(EPHEMERAL_REFIDX) = ptr_to_lispobj(global_refidx);
    17591791    g2_area->threshold = default_g2_threshold;
    17601792    g1_area->threshold = default_g1_threshold;
     
    20622094    lisp_global(OLDSPACE_DNODE_COUNT) = 0;
    20632095  }
     2096  heap_dirty_limit = active_dynamic_area->active;
    20642097  lisp_global(MANAGED_STATIC_REFBITS) = (LispObj)managed_static_refbits;
     2098  lisp_global(MANAGED_STATIC_REFIDX) = (LispObj)managed_static_refidx;
    20652099  lisp_global(MANAGED_STATIC_DNODES) = (LispObj)managed_static_area->ndnodes;
    20662100  atexit(lazarus);
  • trunk/source/lisp-kernel/ppc-exceptions.c

    r15826 r15842  
    250250     without extending the heap.
    251251  */
    252   if (new_heap_segment(xp, bytes_needed, false, tcr)) {
     252  if (new_heap_segment(xp, bytes_needed, false, tcr, NULL)) {
    253253    xpGPR(xp, allocptr) += disp_from_allocptr;
    254254#ifdef DEBUG
     
    269269 
    270270  /* Try again, growing the heap if necessary */
    271   if (new_heap_segment(xp, bytes_needed, true, tcr)) {
     271  if (new_heap_segment(xp, bytes_needed, true, tcr, NULL)) {
    272272    xpGPR(xp, allocptr) += disp_from_allocptr;
    273273#ifdef DEBUG
     
    632632}
    633633
    634 /*
    635   This doesn't GC; it returns true if it made enough room, false
    636   otherwise.
    637   If "extend" is true, it can try to extend the dynamic area to
    638   satisfy the request.
    639 */
    640 
    641 Boolean
    642 new_heap_segment(ExceptionInformation *xp, natural need, Boolean extend, TCR *tcr)
    643 {
    644   area *a;
    645   natural newlimit, oldlimit;
    646   natural log2_allocation_quantum = tcr->log2_allocation_quantum;
    647 
    648   a  = active_dynamic_area;
    649   oldlimit = (natural) a->active;
    650   newlimit = (align_to_power_of_2(oldlimit, log2_allocation_quantum) +
    651               align_to_power_of_2(need, log2_allocation_quantum));
    652   if (newlimit > (natural) (a->high)) {
    653     if (extend) {
    654       signed_natural inhibit = (signed_natural)(lisp_global(GC_INHIBIT_COUNT));
    655       natural extend_by = inhibit ? 0 : lisp_heap_gc_threshold;
    656       do {
    657         if (resize_dynamic_heap(a->active, (newlimit-oldlimit)+extend_by)) {
    658           break;
    659         }
    660         extend_by = align_to_power_of_2(extend_by>>1, log2_allocation_quantum);
    661         if (extend_by < 4<<20) {
    662           return false;
    663         }
    664       } while (1);
    665     } else {
    666       return false;
    667     }
    668   }
    669   a->active = (BytePtr) newlimit;
    670   tcr->last_allocptr = (void *)newlimit;
    671   xpGPR(xp,allocptr) = (LispObj) newlimit;
    672   xpGPR(xp,allocbase) = (LispObj) oldlimit;
    673 
    674   return true;
     634
     635void
     636platform_new_heap_segment(ExceptionInformation *xp, TCR *tcr, BytePtr low, BytePtr high)
     637{
     638  tcr->last_allocptr = (void *)high;
     639  xpGPR(xp,allocptr) = (LispObj) high;
     640  xpGPR(xp,allocbase) = (LispObj) low;
    675641}
    676642
     
    19551921      }
    19561922      root = xpGPR(xp,arg_x);
    1957       ea = (LispObj *) (root+xpGPR(xp,arg_y)+misc_data_offset);
     1923      ea = (LispObj*)(root + unbox_fixnum(xpGPR(xp,temp0)));
    19581924      need_memoize_root = true;
    19591925    } else if (program_counter >= &egc_store_node_conditional) {
     
    19651931        return;
    19661932      }
    1967       ea = (LispObj*)(xpGPR(xp,arg_x) + xpGPR(xp,imm4));
     1933      ea = (LispObj*)(xpGPR(xp,arg_x) + unbox_fixnum(xpGPR(xp,temp0)));
    19681934      xpGPR(xp,arg_z) = t_value;
    19691935    } else if (program_counter >= &egc_set_hash_key) {
     
    19991965          ((LispObj)ea < val)) {
    20001966        atomic_set_bit(refbits, bitnumber);
     1967        atomic_set_bit(global_refidx, bitnumber>>8);
    20011968        if (need_memoize_root) {
    20021969          bitnumber = area_dnode(root, lisp_global(REF_BASE));
    20031970          atomic_set_bit(refbits, bitnumber);
     1971          atomic_set_bit(global_refidx,bitnumber>>8);
    20041972        }
    20051973      }
  • trunk/source/lisp-kernel/ppc-gc.c

    r15826 r15842  
    832832
    833833void
    834 check_refmap_consistency(LispObj *start, LispObj *end, bitvector refbits)
     834check_refmap_consistency(LispObj *start, LispObj *end, bitvector refbits, bitvector refidx)
    835835{
    836836  LispObj x1, *base = start, *prev = start;
     
    841841  while (start < end) {
    842842    x1 = *start;
    843     prev = start;
    844843    tag = fulltag_of(x1);
    845844    if (immheader_tag_p(tag)) {
     845      prev = start;
    846846      start = skip_over_ivector(ptr_to_lispobj(start), x1);
    847847    } else {
     848      if (nodeheader_tag_p(tag)) {
     849        prev = start;
     850      }
    848851      intergen_ref = false;
    849       if (header_subtag(x1) == subtag_weak)
    850         lenient_next_dnode == true;
    851     }
    852     if ((tag == fulltag_misc) || (tag == fulltag_cons)) {       
    853       node_dnode = gc_area_dnode(x1);
    854       if (node_dnode < GCndnodes_in_area) {
    855         intergen_ref = true;
    856       }
    857     }
    858     if (lenient_this_dnode) {
    859       lenient_this_dnode = false;
    860     } else {
    861       if (intergen_ref == false) {       
    862         x1 = start[1];
    863         tag = fulltag_of(x1);
    864         if ((tag == fulltag_misc) || (tag == fulltag_cons)) {
    865           node_dnode = gc_area_dnode(x1);
    866           if (node_dnode < GCndnodes_in_area) {
    867             intergen_ref = true;
     852      if (header_subtag(x1) == subtag_weak) {       
     853        lenient_next_dnode = true;
     854      }
     855      if (is_node_fulltag(tag)) {       
     856        node_dnode = gc_area_dnode(x1);
     857        if (node_dnode < GCndnodes_in_area) {
     858          intergen_ref = true;
     859        }
     860      }
     861      if (lenient_this_dnode) {
     862        lenient_this_dnode = false;
     863      } else {
     864        if (intergen_ref == false) {       
     865          x1 = start[1];
     866          tag = fulltag_of(x1);
     867          if (is_node_fulltag(tag)) {
     868            node_dnode = gc_area_dnode(x1);
     869            if (node_dnode < GCndnodes_in_area) {
     870              intergen_ref = true;
     871            }
    868872          }
    869873        }
    870874      }
    871     }
    872     if (intergen_ref) {
    873       ref_dnode = area_dnode(start, base);
    874       if (!ref_bit(refbits, ref_dnode)) {
    875         Bug(NULL, "Missing memoization in doublenode at 0x" LISP "\n", start);
    876         set_bit(refbits, ref_dnode);
    877       }
    878     }
    879     start += 2;
    880     if (lenient_next_dnode) {
    881       lenient_this_dnode = true;
    882     }
    883     lenient_next_dnode = false;
     875      if (intergen_ref) {
     876        ref_dnode = area_dnode(start, base);
     877        if (!ref_bit(refbits, ref_dnode)) {
     878          Bug(NULL, "Missing memoization in doublenode at 0x" LISP "\n", start);
     879          set_bit(refbits, ref_dnode);
     880          if (refidx) {
     881            set_bit(refidx,ref_dnode>>8);
     882          }
     883        } else {
     884          if (refidx) {
     885            if (!ref_bit(refidx, ref_dnode>>8)) {
     886              Bug(NULL, "Memoization for doublenode at 0x" LISP " not indexed\n", start);
     887              set_bit(refidx,ref_dnode>>8);
     888            }
     889          }
     890        }
     891      }
     892      start += 2;
     893      if (lenient_next_dnode) {
     894        lenient_this_dnode = true;
     895      }
     896      lenient_next_dnode = false;
     897    }
    884898  }
    885899}
  • trunk/source/lisp-kernel/ppc-spentry.s

    r15826 r15842  
    481481        __(sub imm0,arg_y,imm2)
    482482        __(load_highbit(imm3))
    483         __(srri(imm0,imm0,dnode_shift))       
     483        __(srri(imm0,imm0,dnode_shift))
     484        __(srri(imm2,imm0,8))       
    484485        __(ref_global(imm1,oldspace_dnode_count))
    485486        __(extract_bit_shift_count(imm4,imm0))
     
    487488        __(srr(imm3,imm3,imm4))
    488489        __(srri(imm0,imm0,bitmap_shift))       
    489         __(ref_global(imm2,refbits))
     490        __(ref_global(temp0,refbits))
    490491        __(bgelr)
    491492        __(slri(imm0,imm0,word_shift))
    492         __(ldrx(imm1,imm2,imm0))
     493        __(ldrx(imm1,temp0,imm0))
    493494        __(and. imm1,imm1,imm3)
    494495        __(bnelr)
    495 1:      __(lrarx(imm1,imm2,imm0))
     4961:      __(lrarx(imm1,temp0,imm0))
    496497        __(or imm1,imm1,imm3)
    497         __(strcx(imm1,imm2,imm0))
     498        __(strcx(imm1,temp0,imm0))
    498499        __(bne- 1b)
    499500        __(isync)
     501        __(extract_bit_shift_count(imm4,imm2))
     502        __(srri(imm2,imm2,bitmap_shift))
     503        __(load_highbit(imm3))
     504        __(ref_global(temp0,ephemeral_refidx))
     505        __(slri(imm2,imm2,word_shift))
     506        __(srr(imm3,imm3,imm4))
     5072:      __(lrarx(imm1,temp0,imm2))
     508        __(or imm1,imm1,imm3)
     509        __(strcx(imm1,temp0,imm2))
     510        __(bne 2b)
     511        __(isync)       
    500512        __(blr)
    501513
     
    515527        __(extract_bit_shift_count(imm4,imm0))
    516528        __(cmplr(imm0,imm1))
     529        __(srri(imm2,imm0,8))
    517530        __(srr(imm3,imm3,imm4))
    518531        __(srri(imm0,imm0,bitmap_shift))       
    519         __(ref_global(imm2,refbits))
     532        __(ref_global(temp0,refbits))
    520533        __(bgelr)
    521534        __(slri(imm0,imm0,word_shift))
    522         __(ldrx(imm1,imm2,imm0))
     535        __(ldrx(imm1,temp0,imm0))
    523536        __(and. imm1,imm1,imm3)
    524537        __(bnelr)       
    525 1:      __(lrarx(imm1,imm2,imm0))
     5381:      __(lrarx(imm1,temp0,imm0))
    526539        __(or imm1,imm1,imm3)
    527         __(strcx(imm1,imm2,imm0))
     540        __(strcx(imm1,temp0,imm0))
    528541        __(bne- 1b)
    529542        __(isync)
     543        __(extract_bit_shift_count(imm4,imm2))
     544        __(srri(imm2,imm2,bitmap_shift))
     545        __(load_highbit(imm3))
     546        __(ref_global(temp0,ephemeral_refidx))
     547        __(slri(imm2,imm2,word_shift))
     548        __(srr(imm3,imm3,imm4))
     5492:      __(lrarx(imm1,temp0,imm2))
     550        __(or imm1,imm1,imm3)
     551        __(strcx(imm1,temp0,imm2))
     552        __(bne 2b)
     553        __(isync)       
    530554        __(blr)
    531555
     
    548572        __(srri(imm0,imm0,dnode_shift))       
    549573        __(cmplr(imm0,imm1))
     574        __(srri(imm2,imm0,8))
    550575        __(extract_bit_shift_count(imm4,imm0))
    551576        __(srri(imm0,imm0,bitmap_shift))       
    552577        __(srr(imm3,imm3,imm4))
    553         __(ref_global(imm2,refbits))
     578        __(ref_global(temp0,refbits))
    554579        __(bgelr)
    555580        __(slri(imm0,imm0,word_shift))
    556         __(ldrx(imm1,imm2,imm0))
     581        __(ldrx(imm1,temp0,imm0))
    557582        __(and. imm1,imm1,imm3)
    558583        __(bnelr)       
    559 1:      __(lrarx(imm1,imm2,imm0))
     5841:      __(lrarx(imm1,temp0,imm0))
    560585        __(or imm1,imm1,imm3)
    561         __(strcx(imm1,imm2,imm0))
     586        __(strcx(imm1,temp0,imm0))
    562587        __(bne- 1b)
    563588        __(isync)
     589        __(extract_bit_shift_count(imm4,imm2))
     590        __(srri(imm2,imm2,bitmap_shift))
     591        __(load_highbit(imm3))
     592        __(ref_global(temp0,ephemeral_refidx))
     593        __(slri(imm2,imm2,word_shift))
     594        __(srr(imm3,imm3,imm4))
     5952:      __(lrarx(imm1,temp0,imm2))
     596        __(or imm1,imm1,imm3)
     597        __(strcx(imm1,temp0,imm2))
     598        __(bne 2b)
     599        __(isync)       
    564600        __(blr)
    565601
     
    583619        __(srri(imm0,imm0,dnode_shift))       
    584620        __(cmplr(imm0,imm1))
     621        __(srri(imm2,imm0,8))
    585622        __(extract_bit_shift_count(imm4,imm0))
    586623        __(srri(imm0,imm0,bitmap_shift))       
    587624        __(srr(imm3,imm3,imm4))
    588         __(ref_global(imm2,refbits))
     625        __(ref_global(temp0,refbits))
     626        __(ref_global(temp1,ephemeral_refidx))
    589627        __(bgelr)
    590628        __(slri(imm0,imm0,word_shift))
    591         __(ldrx(imm1,imm2,imm0))
     629        __(ldrx(imm1,temp0,imm0))
    592630        __(and. imm1,imm1,imm3)
    593         __(bne 2f)       
    594 1:      __(lrarx(imm1,imm2,imm0))
     631        __(bne 3f)       
     6321:      __(lrarx(imm1,temp0,imm0))
    595633        __(or imm1,imm1,imm3)
    596         __(strcx(imm1,imm2,imm0))
     634        __(strcx(imm1,temp0,imm0))
    597635        __(bne- 1b)
    598636        __(isync)
    599 2:             
     637        __(load_highbit(imm3))
     638        __(extract_bit_shift_count(imm4,imm2))
     639        __(srri(imm2,imm2,bitmap_shift))
     640        __(srr(imm3,imm3,imm4))
     641        __(slri(imm2,imm2,word_shift))
     6422:      __(lrarx(imm1,temp1,imm2))
     643        __(or imm1,imm1,imm3)
     644        __(strcx(imm1,temp1,imm2))
     645        __(bne 2b)
     646        __(isync)       
     6473:             
    600648        __(ref_global(imm1,ref_base))
    601649        __(sub imm0,arg_x,imm1)
    602650        __(srri(imm0,imm0,dnode_shift))
     651        __(srri(imm2,imm0,8))
    603652        __(load_highbit(imm3))
    604653        __(extract_bit_shift_count(imm4,imm0))
     
    606655        __(srr(imm3,imm3,imm4))
    607656        __(slri(imm0,imm0,word_shift))
    608         __(ldrx(imm1,imm2,imm0))
     657        __(ldrx(imm1,temp0,imm0))
    609658        __(and. imm1,imm1,imm3)
    610659        __(bnelr)
    611 3:      __(lrarx(imm1,imm2,imm0))
     6604:      __(lrarx(imm1,temp0,imm0))
    612661        __(or imm1,imm1,imm3)
    613         __(strcx(imm1,imm2,imm0))
    614         __(bne- 3b)
     662        __(strcx(imm1,temp0,imm0))
     663        __(bne- 4b)
    615664        __(isync)
     665        __(load_highbit(imm3))
     666        __(extract_bit_shift_count(imm4,imm2))
     667        __(srri(imm2,imm2,bitmap_shift))
     668        __(srr(imm3,imm3,imm4))
     669        __(slri(imm2,imm2,word_shift))
     6705:      __(lrarx(imm1,temp1,imm2))
     671        __(or imm1,imm1,imm3)
     672        __(strcx(imm1,temp1,imm2))
     673        __(bne 5b)
     674        __(isync)       
    616675        __(blr)
    617676       
     
    6437021:      __(lrarx(temp1,arg_x,imm4))
    644703        __(cmpr(cr1,temp1,arg_y))
    645         __(bne cr1,5f)
     704        __(bne cr1,9f)
    646705        __(strcx(arg_z,arg_x,imm4))
    647706        .globl C(egc_store_node_conditional_test)
     
    656715        __(srri(imm0,imm0,dnode_shift))       
    657716        __(cmplr(imm0,imm1))
    658         __(extract_bit_shift_count(imm2,imm0))
     717        __(srri(imm2,imm0,8))
     718        __(extract_bit_shift_count(imm4,imm0))
    659719        __(srri(imm0,imm0,bitmap_shift))       
    660         __(srr(imm3,imm3,imm2))
    661         __(ref_global(imm2,refbits))
    662         __(bge 4f)
     720        __(srr(imm3,imm3,imm4))
     721        __(ref_global(temp1,refbits))
     722        __(bge 8f)
    663723        __(slri(imm0,imm0,word_shift))
    664 2:      __(lrarx(imm1,imm2,imm0))
     7242:      __(lrarx(imm1,temp1,imm0))
    665725        __(or imm1,imm1,imm3)
    666         __(strcx( imm1,imm2,imm0))
     726        __(strcx(imm1,temp1,imm0))
    667727        __(bne- 2b)
    668728        __(isync)
    669         __(b 4f)
     729        __(load_highbit(imm3))
     730        __(extract_bit_shift_count(imm4,imm2))
     731        __(srri(imm2,imm2,bitmap_shift))
     732        __(ref_global(temp1,ephemeral_refidx))
     733        __(srr(imm3,imm3,imm4))
     734        __(slri(imm2,imm2,word_shift))
     7353:      __(lrarx(imm1,temp1,imm2))
     736        __(or imm1,imm1,imm3)
     737        __(strcx(imm1,temp1,imm2))
     738        __(bne 3b)
     739        __(isync)       
     740        __(b 8f)
    670741
    671742/* arg_z = new value, arg_y = expected old value, arg_x = hash-vector,
     
    677748C(egc_set_hash_key_conditional):
    678749        __(cmplr(cr2,arg_z,arg_x))
    679         __(vpop(imm4))
    680         __(unbox_fixnum(imm4,imm4))
     750        __(vpop(temp0))
     751        __(unbox_fixnum(imm4,temp0))
    6817521:      __(lrarx(temp1,arg_x,imm4))
    682753        __(cmpr(cr1,temp1,arg_y))
    683         __(bne cr1,5f)
     754        __(bne cr1,9f)
    684755        __(strcx(arg_z,arg_x,imm4))
    685756        .globl C(egc_set_hash_key_conditional_test)
     
    694765        __(srri(imm0,imm0,dnode_shift))
    695766        __(cmplr(imm0,imm1))
    696         __(extract_bit_shift_count(imm2,imm0))
    697         __(srri(imm0,imm0,bitmap_shift))
    698         __(srr(imm3,imm3,imm2))
    699         __(ref_global(imm2,refbits))
    700         __(bge 4f)
     767        __(srri(imm2,imm0,8))
     768        __(extract_bit_shift_count(imm4,imm0))
     769        __(srri(imm0,imm0,bitmap_shift))       
     770        __(srr(imm3,imm3,imm4))
     771        __(ref_global(temp2,refbits))
     772        __(ref_global(temp1,ephemeral_refidx))
     773        __(bge 8f)
    701774        __(slri(imm0,imm0,word_shift))
    702 2:      __(lrarx(imm1,imm2,imm0))
     7752:      __(lrarx(imm1,temp2,imm0))
    703776        __(or imm1,imm1,imm3)
    704         __(strcx(imm1,imm2,imm0))
     777        __(strcx(imm1,temp2,imm0))
    705778        __(bne- 2b)
    706779        __(isync)
    707         /* Memoize hash table header */         
     780        __(load_highbit(imm3))
     781        __(extract_bit_shift_count(imm4,imm2))
     782        __(srri(imm2,imm2,bitmap_shift))
     783        __(srr(imm3,imm3,imm4))
     784        __(slri(imm2,imm2,word_shift))
     7853:      __(lrarx(imm1,temp1,imm2))
     786        __(or imm1,imm1,imm3)
     787        __(strcx(imm1,temp1,imm2))
     788        __(bne 3b)
     789        __(isync)       
     790       
     791        /* Memoize hash table header */
     792        __(ref_global(temp1,refbits))   
    708793        __(ref_global(imm1,ref_base))
    709794        __(sub imm0,arg_x,imm1)
    710795        __(srri(imm0,imm0,dnode_shift))
    711796        __(load_highbit(imm3))
     797        __(srri(imm2,imm0,8))
    712798        __(extract_bit_shift_count(imm4,imm0))
    713799        __(srri(imm0,imm0,bitmap_shift))
    714800        __(srr(imm3,imm3,imm4))
    715801        __(slri(imm0,imm0,word_shift))
    716         __(ldrx(imm1,imm2,imm0))
     802        __(ldrx(imm1,temp1,imm0))
    717803        __(and. imm1,imm1,imm3)
    718         __(bne 4f)
    719 3:      __(lrarx(imm1,imm2,imm0))
     804        __(bne 8f)
     8054:      __(lrarx(imm1,temp1,imm0))
    720806        __(or imm1,imm1,imm3)
    721         __(strcx(imm1,imm2,imm0))
    722         __(bne- 3b)
     807        __(strcx(imm1,temp1,imm0))
     808        __(bne- 4b)
     809        __(isync)
     810        __(ref_global(temp1,ephemeral_refidx))
     811        __(load_highbit(imm3))
     812        __(extract_bit_shift_count(imm4,imm2))
     813        __(srri(imm2,imm2,bitmap_shift))
     814        __(srr(imm3,imm3,imm4))
     815        __(slri(imm2,imm2,word_shift))
     8165:      __(lrarx(imm1,temp1,imm2))
     817        __(or imm1,imm1,imm3)
     818        __(strcx(imm1,temp1,imm2))
     819        __(bne 5b)
    723820        __(isync)
    724821C(egc_write_barrier_end):
    725 4:      __(li arg_z,t_value)
    726         __(blr)
    727 5:      __(li imm0,RESERVATION_DISCHARGE)
     8228:      __(li arg_z,t_value)
     823        __(blr)
     8249:      __(li imm0,RESERVATION_DISCHARGE)
    728825        __(strcx(rzero,0,imm0))
    729826        __(li arg_z,nil_value)
  • trunk/source/lisp-kernel/x86-exceptions.c

    r15826 r15842  
    141141
    142142
    143 Boolean
    144 new_heap_segment(ExceptionInformation *xp, natural need, Boolean extend, TCR *tcr, Boolean *crossed_threshold)
    145 {
    146   area *a;
    147   natural newlimit, oldlimit;
    148   natural log2_allocation_quantum = TCR_AUX(tcr)->log2_allocation_quantum;
    149 
    150   if (crossed_threshold) {
    151     *crossed_threshold = false;
    152   }
    153 
    154   a  = active_dynamic_area;
    155   oldlimit = (natural) a->active;
    156   newlimit = (align_to_power_of_2(oldlimit, log2_allocation_quantum) +
    157               align_to_power_of_2(need, log2_allocation_quantum));
    158   if (newlimit > (natural) (a->high)) {
    159     if (extend) {
    160       signed_natural inhibit = (signed_natural)(lisp_global(GC_INHIBIT_COUNT));
    161       natural extend_by = inhibit ? 0 : lisp_heap_gc_threshold;
    162       do {
    163         if (resize_dynamic_heap(a->active, (newlimit-oldlimit)+extend_by)) {
    164           break;
    165         }
    166         extend_by = align_to_power_of_2(extend_by>>1,log2_allocation_quantum);
    167         if (extend_by < 4<<20) {
    168           return false;
    169         }
    170       } while (1);
    171     } else {
    172       return false;
    173     }
    174   }
    175   a->active = (BytePtr) newlimit;
    176   tcr->last_allocptr = (void *)newlimit;
    177   tcr->save_allocptr = (void *)newlimit;
    178   xpGPR(xp,Iallocptr) = (LispObj) newlimit;
    179   tcr->save_allocbase = (void *) oldlimit;
    180 
    181   if (crossed_threshold && (!extend)) {
    182     if (((a->high - (BytePtr)newlimit) < lisp_heap_notify_threshold)&&
    183         ((a->high - (BytePtr)oldlimit) >= lisp_heap_notify_threshold)) {
    184       *crossed_threshold = true;
    185     }
    186   }
    187    
    188 
    189   return true;
     143
     144void
     145platform_new_heap_segment(ExceptionInformation *xp, TCR *tcr, BytePtr low, BytePtr high)
     146{
     147  tcr->last_allocptr = (void *)high;
     148  tcr->save_allocptr = (void *)high;
     149  xpGPR(xp,Iallocptr) = (LispObj) high;
     150  tcr->save_allocbase = (void *) low;
    190151}
    191152
     
    27602721        if ((bitnumber < lisp_global(OLDSPACE_DNODE_COUNT))) {
    27612722          atomic_set_bit(refbits, bitnumber);
     2723          atomic_set_bit(global_refidx,bitnumber>>8);
    27622724          if (need_memoize_root) {
    27632725            atomic_set_bit(refbits, rootbitnumber);
     2726            atomic_set_bit(global_refidx,rootbitnumber>>8);
    27642727          }
    27652728        }
    27662729        if (bitnumber < lisp_global(MANAGED_STATIC_DNODES)) {
    27672730          atomic_set_bit(managed_static_refbits,bitnumber);
     2731          atomic_set_bit(managed_static_refidx,bitnumber>>8);
    27682732          if (need_memoize_root) {
    27692733            atomic_set_bit(managed_static_refbits, rootbitnumber);
     2734            atomic_set_bit(managed_static_refidx,rootbitnumber>>8);
    27702735          }
    27712736        }
  • trunk/source/lisp-kernel/x86-gc.c

    r15826 r15842  
    12161216
    12171217void
    1218 check_refmap_consistency(LispObj *start, LispObj *end, bitvector refbits)
     1218check_refmap_consistency(LispObj *start, LispObj *end, bitvector refbits, bitvector refidx)
    12191219{
    12201220  LispObj x1, *base = start, *prev = start;
     
    12731273          Bug(NULL, "Missing memoization in doublenode at 0x" LISP "\n", start);
    12741274          set_bit(refbits, ref_dnode);
     1275          if (refidx) {
     1276            set_bit(refidx, ref_dnode>>8);
     1277          }
     1278        } else {
     1279          if (refidx) {
     1280            if (!ref_bit(refidx, ref_dnode>>8)) {
     1281              Bug(NULL, "Memoization for doublenode at 0x" LISP " not indexed\n", start);
     1282              set_bit(refidx,ref_dnode>>8);
     1283            }
     1284          }
    12751285        }
    12761286      }
     
    26782688    *base = start, *prev = start;
    26792689  int tag;
    2680   bitvector refbits = managed_static_refbits;
     2690  bitvector refbits = managed_static_refbits, refidx = managed_static_refidx;
    26812691  natural ref_dnode, node_dnode;
    26822692  Boolean intergen_ref;
     
    27222732        ref_dnode = area_dnode(start, base);
    27232733        set_bit(refbits, ref_dnode);
     2734        set_bit(refidx, ref_dnode>>8);
    27242735      }
    27252736      start += 2;
     
    28282839        CommitMemory(managed_static_area->refbits, refbytes); /* zeros them */
    28292840        CommitMemory(managed_static_refbits,refbytes); /* zeroes them, too */
     2841        CommitMemory(managed_static_refidx,((managed_dnodes+255)>>8)>>3);
    28302842        update_managed_refs(managed_static_area, low_markable_address, area_dnode(a->active,low_markable_address));
    28312843      }
  • trunk/source/lisp-kernel/x86-spentry32.s

    r15826 r15842  
    17321732        __(cmpl lisp_global(oldspace_dnode_count),%imm0)
    17331733        __(jae 2f)
     1734        __(movd %imm0,%mm0)
    17341735        __(ref_global(refbits,%temp0))
    17351736        __(xorb $31,%imm0_b)
    17361737        __(lock)
    17371738        __(btsl %imm0,(%temp0))
     1739        __(shrl $8,%imm0)
    17381740        __(xorb $31,%imm0_b)
     1741        __(ref_global(ephemeral_refidx,%temp0))
     1742        __(lock)
     1743        __(btsl %imm0,(%temp0))
     1744        __(movd %mm0,%imm0)
    173917452:      __(cmpl lisp_global(managed_static_dnodes),%imm0)
    17401746        __(jae 0b)
    17411747        __(ref_global(managed_static_refbits,%temp0))
     1748        __(xorb $31,%imm0_b)
     1749        __(lock)
     1750        __(btsl %imm0,(%temp0))
     1751        __(ref_global(managed_static_refidx,%temp0))
     1752        __(shrl $8,%imm0)
    17421753        __(xorb $31,%imm0_b)
    17431754        __(lock)
     
    17591770        __(cmpl lisp_global(oldspace_dnode_count),%imm0)
    17601771        __(jae 2f)
     1772        __(movd %imm0,%mm0)
    17611773        __(ref_global(refbits,%temp0))
    17621774        __(xorb $31,%imm0_b)
    17631775        __(lock)
    17641776        __(btsl %imm0,(%temp0))
    1765         __(xorb $31,%imm0_b)       
     1777        __(shrl $8,%imm0)
     1778        __(xorb $31,%imm0_b)
     1779        __(ref_global(ephemeral_refidx,%temp0))
     1780        __(lock)
     1781        __(btsl %imm0,(%temp0))
     1782        __(movd %mm0,%imm0)
    176617832:      __(cmpl lisp_global(managed_static_dnodes),%imm0)
    17671784        __(jae 0b)
     
    17701787        __(lock)
    17711788        __(btsl %imm0,(%temp0))       
     1789        __(ref_global(managed_static_refidx,%temp0))
     1790        __(shrl $8,%imm0)
     1791        __(xorb $31,%imm0_b)
     1792        __(lock)
     1793        __(btsl %imm0,(%temp0))       
    17721794        __(ret)
    17731795_endsubp(rplacd)
     
    17881810        __(cmpl lisp_global(oldspace_dnode_count),%imm0)
    17891811        __(jae 2f)
     1812        __(movd %imm0,%mm0)
    17901813        __(ref_global(refbits,%temp1))
    17911814        __(xorb $31,%imm0_b)
    17921815        __(lock)
    17931816        __(btsl %imm0,(%temp1))
     1817        __(shrl $8,%imm0)
    17941818        __(xorb $31,%imm0_b)
     1819        __(ref_global(ephemeral_refidx,%temp1))
     1820        __(lock)
     1821        __(btsl %imm0,(%temp1))
     1822        __(movd %mm0,%imm0)
    179518232:      __(cmpl lisp_global(managed_static_dnodes),%imm0)
    17961824        __(jae 0b)
     
    17991827        __(lock)
    18001828        __(btsl %imm0,(%temp1))
     1829        __(ref_global(managed_static_refidx,%temp1))
     1830        __(shrl $8,%imm0)
     1831        __(xorb $31,%imm0_b)
     1832        __(lock)
     1833        __(btsl %imm0,(%temp1))       
    18011834        __(ret)
    18021835_endsubp(gvset)
     
    18231856        __(lock)
    18241857        __(btsl %imm0,(%temp1))
     1858        __(shrl $8,%imm0)
     1859        __(xorb $31,%imm0_b)
     1860        __(ref_global(ephemeral_refidx,%temp1))
     1861        __(lock)
     1862        __(btsl %imm0,(%temp1))
    18251863        /* Now memoize the address of the hash vector */
     1864        __(ref_global(refbits,%temp1))
    18261865        __(movl %temp0,%imm0)
    18271866        __(subl lisp_global(ref_base),%imm0)
     
    18301869        __(lock)
    18311870        __(btsl %imm0,(%temp1))
     1871        __(shrl $8,%imm0)
     1872        __(xorb $31,%imm0_b)
     1873        __(ref_global(ephemeral_refidx,%temp1))
     1874        __(lock)
     1875        __(btsl %imm0,(%temp1))
    18321876        __(lea misc_data_offset(%temp0,%arg_y),%imm0)
    18331877        __(subl lisp_global(ref_base),%imm0)
     
    18391883        __(lock)
    18401884        __(btsl %imm0,(%temp1))
     1885        __(ref_global(managed_static_refidx,%temp1))
     1886        __(shrl $8,%imm0)
     1887        __(xorb $31,%imm0_b)
     1888        __(lock)
     1889        __(btsl %imm0,(%temp1))
    18411890        /* Now memoize the address of the hash vector */
     1891        __(ref_global(managed_static_refbits,%temp1))
    18421892        __(movl %temp0,%imm0)
    18431893        __(subl lisp_global(ref_base),%imm0)
     
    18461896        __(lock)
    18471897        __(btsl %imm0,(%temp1))               
     1898        __(ref_global(managed_static_refidx,%temp1))
     1899        __(shrl $8,%imm0)
     1900        __(xorb $31,%imm0_b)
     1901        __(lock)
     1902        __(btsl %imm0,(%temp1))
    18481903        __(ret)
    18491904_endsubp(set_hash_key)
     
    18751930        __(cmpl lisp_global(oldspace_dnode_count),%imm0)
    18761931        __(jae 2f)
     1932        __(movd %imm0,%mm0)
    18771933        __(ref_global(refbits,%arg_y))
    18781934        __(xorb $31,%imm0_b)
    18791935        __(lock)
    18801936        __(btsl %imm0,(%arg_y))
     1937        __(shrl $8,%imm0)
    18811938        __(xorb $31,%imm0_b)
     1939        __(ref_global(ephemeral_refidx,%arg_y))
     1940        __(lock)
     1941        __(btsl %imm0,(%arg_y))
     1942        __(movd %mm0,%imm0)
    188219432:      __(cmpl lisp_global(managed_static_dnodes),%imm0)
    18831944        __(jae 8f)
    18841945        __(ref_global(managed_static_refbits,%arg_y))
     1946        __(xorb $31,%imm0_b)
     1947        __(lock)
     1948        __(btsl %imm0,(%arg_y))
     1949        __(ref_global(managed_static_refidx,%arg_y))
     1950        __(shrl $8,%imm0)
    18851951        __(xorb $31,%imm0_b)
    18861952        __(lock)
     
    19171983        __(lock)
    19181984        __(btsl %imm0,(%arg_y))
     1985        __(shrl $8,%imm0)
     1986        __(xorb $31,%imm0_b)
     1987        __(ref_global(ephemeral_refidx,%arg_y))
     1988        __(lock)
     1989        __(btsl %imm0,(%arg_y))
    19191990        /* Now memoize the address of the hash vector */
     1991        __(ref_global(refbits,%arg_y))
    19201992        __(movl %temp1,%imm0)
    19211993        __(subl lisp_global(ref_base),%imm0)
     
    19241996        __(lock)
    19251997        __(btsl %imm0,(%arg_y))
     1998        __(ref_global(ephemeral_refidx,%arg_y))
     1999        __(shrl $8,%imm0)
     2000        __(xorb $31,%imm0_b)
     2001        __(lock)
     2002        __(btsl %imm0,(%arg_y))
    19262003        __(leal misc_data_offset(%temp1,%temp0),%imm0)
    19272004        __(subl lisp_global(ref_base),%imm0)
     
    19332010        __(lock)
    19342011        __(btsl %imm0,(%arg_y))
     2012        __(ref_global(managed_static_refidx,%arg_y))
     2013        __(shrl $8,%imm0)
     2014        __(xorb $31,%imm0_b)
     2015        __(lock)
     2016        __(btsl %imm0,(%arg_y))
     2017        __(ref_global(managed_static_refbits,%arg_y))
    19352018        /* Now memoize the address of the hash vector */
    19362019        __(movl %temp1,%imm0)
     
    19402023        __(lock)
    19412024        __(btsl %imm0,(%arg_y))
     2025        __(ref_global(managed_static_refidx,%arg_y))
     2026        __(shrl $8,%imm0)
     2027        __(xorb $31,%imm0_b)
     2028        __(lock)
     2029        __(btsl %imm0,(%arg_y))
    19422030        .globl C(egc_write_barrier_end)
    19432031C(egc_write_barrier_end):
  • trunk/source/lisp-kernel/x86-spentry64.s

    r15826 r15842  
    17751775        __(jae 2f)
    17761776        __(ref_global(refbits,%temp0))
    1777         __(xorb $63,%imm0_b)
     1777        __(xorq $63,%imm0)
     1778        __(lock)
     1779        __(btsq %imm0,(%temp0))
     1780        __(ref_global(ephemeral_refidx,%temp0))
     1781        __(shrq $8,%imm0)
     1782        __(xorq $63,%imm0)
    17781783        __(lock)
    17791784        __(btsq %imm0,(%temp0))
     
    17811786        __(jae 0b)
    17821787        __(ref_global(managed_static_refbits,%temp0))
    1783         __(xorb $63,%imm1_b)
     1788        __(xor $63,%imm1)
    17841789        __(lock)
     1790        __(btsq %imm1,(%temp0))
     1791        __(shrq $8,%imm1)
     1792        __(ref_global(managed_static_refidx,%temp0))
     1793        __(xor $63,%imm1)
    17851794        __(btsq %imm1,(%temp0))
    17861795        __(ret)
     
    18021811        __(jae 2f)
    18031812        __(ref_global(refbits,%temp0))
    1804         __(xorb $63,%imm0_b)
     1813        __(xorq $63,%imm0)
    18051814        __(lock)
    18061815        __(btsq %imm0,(%temp0))
    1807         __(ret)
     1816        __(ref_global(ephemeral_refidx,%temp0))
     1817        __(shrq $8,%imm0)
     1818        __(xorq $63,%imm0)
     1819        __(lock)
     1820        __(btsq %imm0,(%temp0))
    180818212:      __(cmpq lisp_global(managed_static_dnodes),%imm1)
    18091822        __(jae 0b)
    18101823        __(ref_global(managed_static_refbits,%temp0))
    1811         __(xorb $63,%imm1_b)
     1824        __(xor $63,%imm1)
     1825        __(lock)
     1826        __(btsq %imm1,(%temp0))
     1827        __(shrq $8,%imm1)
     1828        __(ref_global(managed_static_refidx,%temp0))
     1829        __(xorq $63,%imm1)
    18121830        __(lock)
    18131831        __(btsq %imm1,(%temp0))
     
    18331851        __(jae 2f)
    18341852        __(ref_global(refbits,%temp0))
    1835         __(xorb $63,%imm0_b)
     1853        __(xorq $63,%imm0)
     1854        __(lock)
     1855        __(btsq %imm0,(%temp0))
     1856        __(ref_global(ephemeral_refidx,%temp0))
     1857        __(shrq $8,%imm0)
     1858        __(xorq $63,%imm0)
    18361859        __(lock)
    18371860        __(btsq %imm0,(%temp0))
     
    18391862        __(jae 0b)
    18401863        __(ref_global(managed_static_refbits,%temp0))
    1841         __(xorb $63,%imm1_b)
     1864        __(xor $63,%imm1)
    18421865        __(lock)
    18431866        __(btsq %imm1,(%temp0))       
     1867        __(shrq $8,%imm1)
     1868        __(ref_global(managed_static_refidx,%temp0))
     1869        __(xor $63,%imm1)
     1870        __(lock)
     1871        __(btsq %imm1,(%temp0))
    18441872        __(ret)               
    18451873_endsubp(gvset)
     
    18651893        __(jae 2f)
    18661894        __(ref_global(refbits,%temp0))
    1867         __(xorb $63,%imm0_b)
     1895        __(xorq $63,%imm0)
     1896        __(lock)
     1897        __(btsq %imm0,(%temp0))
     1898        __(ref_global(ephemeral_refidx,%temp0))
     1899        __(shrq $8,%imm0)
     1900        __(xorq $63,%imm0)
    18681901        __(lock)
    18691902        __(btsq %imm0,(%temp0))
    18701903        /* Now memoize the address of the hash vector   */
     1904        __(ref_global(refbits,%temp0))
    18711905        __(movq %arg_x,%imm0)
    18721906        __(subq lisp_global(ref_base),%imm0)
    18731907        __(shrq $dnode_shift,%imm0)
    1874         __(xorb $63,%imm0_b)
     1908        __(xorq $63,%imm0)
     1909        __(lock)
     1910        __(btsq %imm0,(%temp0))
     1911        __(ref_global(ephemeral_refidx,%temp0))
     1912        __(shrq $8,%imm0)
     1913        __(xorq $63,%imm0)
    18751914        __(lock)
    18761915        __(btsq %imm0,(%temp0))
     
    18781917        __(jae 0b)
    18791918        __(ref_global(managed_static_refbits,%temp0))
    1880         __(xorb $63,%imm1_b)
     1919        __(xor $63,%imm1)
    18811920        __(lock)
    18821921        __(btsq %imm1,(%temp0))
     1922        __(ref_global(managed_static_refidx,%temp0))
     1923        __(shrq $8,%imm1)
     1924        __(xor $63,%imm1)
     1925        __(lock)
     1926        __(btsq %imm1,(%temp0))       
    18831927        /* Now memoize the address of the hash vector   */
    18841928        __(movq %arg_x,%imm0)
    18851929        __(subq lisp_global(ref_base),%imm0)
    18861930        __(shrq $dnode_shift,%imm0)
    1887         __(xorb $63,%imm0_b)
     1931        __(ref_global(managed_static_refbits,%temp0))
     1932        __(xorq $63,%imm0)
     1933        __(lock)
     1934        __(btsq %imm0,(%temp0))
     1935        __(ref_global(managed_static_refidx,%temp0))
     1936        __(shrq $8,%imm0)
     1937        __(xorq $63,%imm0)
    18881938        __(lock)
    18891939        __(btsq %imm0,(%temp0))
     
    19161966        __(ref_global(refbits,%temp1))
    19171967        __(jae 2f)
    1918         __(xorb $63,%imm0_b)
     1968        __(xorq $63,%imm0)
     1969        __(lock)
     1970        __(btsq %imm0,(%temp1))
     1971        __(shrq $8,%imm0)
     1972        __(ref_global(ephemeral_refidx,%temp1))
     1973        __(xorq $63,%imm0)
    19191974        __(lock)
    19201975        __(btsq %imm0,(%temp1))
     
    19221977        __(jae 8f)
    19231978        __(ref_global(managed_static_refbits,%temp1))
    1924         __(xorb $63,%imm1_b)
     1979        __(xor $63,%imm1)
    19251980        __(lock)
    1926         __(btsq %imm1,(%temp1))       
     1981        __(btsq %imm1,(%temp1))   
     1982        __(ref_global(managed_static_refidx,%temp1))
     1983        __(shrq $8,%imm1)
     1984        __(xor $63,%imm1)
     1985        __(lock)
     1986        __(btsq %imm1,(%temp1))   
    19271987        .globl C(egc_store_node_conditional_success_end)
    19281988C(egc_store_node_conditional_success_end):
     
    19522012        __(ref_global(refbits,%temp1))
    19532013        __(jae 2f)
    1954         __(xorb $63,%imm0_b)
     2014        __(xorq $63,%imm0)
     2015        __(lock)
     2016        __(btsq %imm0,(%temp1))
     2017        __(shrq $8,%imm0)
     2018        __(xorq $63,%imm0)
     2019        __(ref_global(ephemeral_refidx,%temp1))
    19552020        __(lock)
    19562021        __(btsq %imm0,(%temp1))
     
    19582023        __(movq %arg_x,%imm0)
    19592024        __(subq lisp_global(ref_base),%imm0)
     2025        __(ref_global(refbits,%temp1))
    19602026        __(shrq $dnode_shift,%imm0)
    1961         __(xorb $63,%imm0_b)
     2027        __(xorq $63,%imm0)
     2028        __(lock)
     2029        __(btsq %imm0,(%temp1))
     2030        __(shrq $8,%imm0)
     2031        __(xorq $63,%imm0)
     2032        __(ref_global(ephemeral_refidx,%temp1))
    19622033        __(lock)
    19632034        __(btsq %imm0,(%temp1))
     
    19652036        __(jae 8f)
    19662037        __(ref_global(managed_static_refbits,%temp1))
    1967         __(xorb $63,%imm1_b)
     2038        __(xor $63,%imm1)
    19682039        __(lock)
     2040        __(btsq %imm1,(%temp1))
     2041        __(ref_global(managed_static_refidx,%temp1))
     2042        __(shrq $8,%imm1)
     2043        __(xor $63,%imm1)
    19692044        __(btsq %imm1,(%temp1))
    19702045        /* Now memoize the address of the hash vector   */
    19712046        __(movq %arg_x,%imm0)
    19722047        __(subq lisp_global(ref_base),%imm0)
     2048        __(ref_global(managed_static_refbits,%temp1))       
    19732049        __(shrq $dnode_shift,%imm0)
    1974         __(xorb $63,%imm0_b)
     2050        __(xorq $63,%imm0)
     2051        __(lock)
     2052        __(btsq %imm0,(%temp1))
     2053        __(ref_global(managed_static_refidx,%temp1))
     2054        __(shrq $8,%imm0)
     2055        __(xor $63,%imm0)
    19752056        __(lock)
    19762057        __(btsq %imm0,(%temp1))
Note: See TracChangeset for help on using the changeset viewer.