API tools faq
paste
Guest User

Untitled

a guest
Jul 19th, 2016
169
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 14.21 KB | None | 0 0
raw download clone embed print report
  1. /*  As the final phase of global garbage collect, sweep the heap to follow
  2.     forwarders, then free forwarders, coalescing with free space as we go. */
  3.  
  4.     /* SpurMemoryManager>>#eliminateAndFreeForwardersForPigCompact */
  5. static void
  6. eliminateAndFreeForwardersForPigCompact(void)
  7. {   DECL_MAYBE_SQ_GLOBAL_STRUCT
  8.     sqInt address;
  9.     sqInt address1;
  10.     sqInt bytes;
  11.     sqInt endOfFreeRun;
  12.     sqInt f;
  13.     sqInt firstOfFreeRun;
  14.     sqInt followingWord;
  15.     sqInt followingWord1;
  16.     sqInt followingWord11;
  17.     sqInt followingWord2;
  18.     sqInt followingWordAddress;
  19.     sqInt followingWordAddress1;
  20.     sqInt followingWordAddress11;
  21.     sqInt followingWordAddress2;
  22.     sqInt i;
  23.     sqInt iLimiT;
  24.     sqInt index;
  25.     sqInt lowest;
  26.     usqInt lowestForwarder;
  27.     usqInt lowestForwarder1;
  28.     usqInt numSlots;
  29.     usqInt numSlots1;
  30.     usqInt numSlots11;
  31.     usqInt numSlots111;
  32.     usqInt numSlots12;
  33.     usqInt numSlots2;
  34.     usqInt numSlots21;
  35.     usqInt numSlots3;
  36.     usqInt numSlots31;
  37.     usqInt numSlots4;
  38.     sqInt o;
  39.     sqInt o1;
  40.     sqInt obj;
  41.     sqInt objOop;
  42.     sqInt objOop1;
  43.     sqInt objOop11;
  44.     sqInt objOop12;
  45.     sqInt objOop2;
  46.     sqInt objOop21;
  47.     sqInt objOop3;
  48.     sqInt objOop4;
  49.     sqInt prevFree;
  50.     sqInt prevObj;
  51.     sqInt prevObj1;
  52.     sqInt prevObj11;
  53.     sqInt prevObj2;
  54.     sqInt prevPrevFree;
  55.     sqInt prevPrevObj;
  56.     sqInt prevPrevObj1;
  57.     sqInt prevPrevObj11;
  58.     sqInt prevPrevObj2;
  59.     sqInt referent;
  60.     sqInt referent1;
  61.     sqInt referent11;
  62.     sqInt referent2;
  63.     sqInt slotBytes;
  64.     sqInt slotBytes1;
  65.     sqInt slotBytes11;
  66.     sqInt slotBytes2;
  67.     sqInt startOfFreeRun;
  68.  
  69.     endOfFreeRun = 0;
  70.     startOfFreeRun = 0;
  71.     assert(!(isForwarded(GIV(nilObj))));
  72.     assert(!(isForwarded(GIV(falseObj))));
  73.     assert(!(isForwarded(GIV(trueObj))));
  74.     assert(!(isForwarded(freeListsObj())));
  75.     assert(!(isForwarded(GIV(hiddenRootsObj))));
  76.     assert(!(isForwarded(GIV(classTableFirstPage))));
  77.     /* begin followSpecialObjectsOop */
  78.     if (((longAt(GIV(specialObjectsOop))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
  79.         /* begin followForwarded: */
  80.         assert(isUnambiguouslyForwarder(GIV(specialObjectsOop)));
  81.         referent = longAt((GIV(specialObjectsOop) + BaseHeaderSize) + (0L << (shiftForWord())));
  82.         while (((referent & (tagMask())) == 0)
  83.          && (((longAt(referent)) & (classIndexMask())) == (isForwardedObjectClassIndexPun()))) {
  84.             referent = longAt((referent + BaseHeaderSize) + (0L << (shiftForWord())));
  85.         }
  86.         GIV(specialObjectsOop) = referent;
  87.     }
  88.     followForwardedObjectFieldstoDepth(GIV(specialObjectsOop), 0);
  89.     /* begin followForwardedObjStacks */
  90.     followForwardedInObjStackatIndex(GIV(markStack), MarkStackRootIndex);
  91.     followForwardedInObjStackatIndex(GIV(weaklingStack), WeaklingStackRootIndex);
  92.     followForwardedInObjStackatIndex(GIV(mournQueue), MournQueueRootIndex);
  93.     mapInterpreterOops();
  94.     /* begin followRememberedForwardersAndForgetFreeObjectsForPigCompact */
  95.     index = 0;
  96.     while (index < GIV(rememberedSetSize)) {
  97. obj = GIV(rememberedSet)[index];
  98.         if (((longAt(obj)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
  99.  
  100.             /* free; remove by overwriting with last element */
  101.  
  102.             /* free; remove by overwriting with last element */
  103. GIV(rememberedSetSize) -= 1;
  104.             GIV(rememberedSet)[index] = (GIV(rememberedSet)[GIV(rememberedSetSize)]);
  105.         }
  106.         else {
  107. if (((longAt(obj)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
  108.                 /* begin setIsRememberedOf:to: */
  109.                 flag("endianness");
  110.                 longAtput(obj, (longAt(obj)) & ((unsigned int)~(1L << (rememberedBitShift()))));
  111.                 /* begin followForwarded: */
  112.                 assert(isUnambiguouslyForwarder(obj));
  113.                 referent1 = longAt((obj + BaseHeaderSize) + (0L << (shiftForWord())));
  114.                 while (((referent1 & (tagMask())) == 0)
  115.                  && (((longAt(referent1)) & (classIndexMask())) == (isForwardedObjectClassIndexPun()))) {
  116.                     referent1 = longAt((referent1 + BaseHeaderSize) + (0L << (shiftForWord())));
  117.                 }
  118.                 obj = referent1;
  119.                 assert(isRemembered(obj));
  120.                 GIV(rememberedSet)[index] = obj;
  121.             }
  122.             index += 1;
  123.         }
  124.     }
  125.     /* begin unmarkSurvivingObjectsForPigCompact */
  126.     prevPrevObj = (prevObj = null);
  127.     /* begin objectStartingAt: */
  128.     address = ((pastSpace()).start);
  129.     numSlots = byteAt(address + 7);
  130.     objOop1 = (numSlots == (numSlotsMask())
  131.         ? address + BaseHeaderSize
  132.         : address);
  133.     while (oopisLessThan(objOop1, GIV(pastSpaceStart))) {
  134.         assert(isEnumerableObjectNoAssert(objOop1));
  135.         if (((((usqInt) (longAt(objOop1 + 4))) >> 23) & 1) != 0) {
  136.             setIsMarkedOfto(objOop1, 0);
  137.         }
  138.  
  139.  
  140.         prevPrevObj = prevObj;
  141.         prevObj = objOop1;
  142.         /* begin objectAfter:limit: */
  143.         numSlots1 = byteAt(objOop1 + 7);
  144.         numSlots2 = (numSlots1 == (numSlotsMask())
  145.             ? longAt(objOop1 - BaseHeaderSize)
  146.             : numSlots1);
  147.         if (numSlots2 == 0) {
  148. slotBytes = 8;
  149.         }
  150.         else {
  151. slotBytes = (numSlots2 + (numSlots2 & 1)) << (shiftForWord());
  152.         }
  153.         followingWordAddress = (objOop1 + BaseHeaderSize) + slotBytes;
  154.         if (oopisGreaterThanOrEqualTo(followingWordAddress, GIV(pastSpaceStart))) {
  155.             objOop1 = GIV(pastSpaceStart);
  156.             goto l6;
  157.         }
  158.         flag("endianness");
  159.         followingWord = longAt(followingWordAddress + 4);
  160.         objOop1 = ((((usqInt) followingWord) >> (numSlotsHalfShift())) == (numSlotsMask())
  161.             ? followingWordAddress + BaseHeaderSize
  162.             : followingWordAddress);
  163.     l6: /* end objectAfter:limit: */;
  164.     }
  165.     /* begin sweepToFollowForwardersForPigCompact */
  166.     assert((GIV(freeStart) == (((eden()).start)))
  167.      && ((futureSurvivorStart()) == (((futureSpace()).start))));
  168.     /* begin allPastSpaceObjectsDo: */
  169.     prevPrevObj2 = (prevObj2 = null);
  170.     /* begin objectStartingAt: */
  171.     address1 = ((pastSpace()).start);
  172.     numSlots4 = byteAt(address1 + 7);
  173.     objOop12 = (numSlots4 == (numSlotsMask())
  174.         ? address1 + BaseHeaderSize
  175.         : address1);
  176.     while (oopisLessThan(objOop12, GIV(pastSpaceStart))) {
  177.         assert(isEnumerableObjectNoAssert(objOop12));
  178.         if (!(((longAt(objOop12)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
  179.             for (i = 0, iLimiT = ((numPointerSlotsOf(objOop12)) - 1); i <= iLimiT; i += 1) {
  180.                 f = longAt((objOop12 + BaseHeaderSize) + (i << (shiftForWord())));
  181.                 if (((f & (tagMask())) == 0)
  182.                  && (((longAt(f)) & (classIndexMask())) == (isForwardedObjectClassIndexPun()))) {
  183.                     /* begin followForwarded: */
  184.                     assert(isUnambiguouslyForwarder(f));
  185.                     referent2 = longAt((f + BaseHeaderSize) + (0L << (shiftForWord())));
  186.                     while (((referent2 & (tagMask())) == 0)
  187.                      && (((longAt(referent2)) & (classIndexMask())) == (isForwardedObjectClassIndexPun()))) {
  188.                         referent2 = longAt((referent2 + BaseHeaderSize) + (0L << (shiftForWord())));
  189.                     }
  190.                     f = referent2;
  191.                     /* begin storePointerUnchecked:ofObject:withValue: */
  192.                     assert(!(isForwarded(objOop12)));
  193.                     longAtput((objOop12 + BaseHeaderSize) + (i << (shiftForWord())), f);
  194.                 }
  195.             }
  196.         }
  197.  
  198.  
  199.         prevPrevObj2 = prevObj2;
  200.         prevObj2 = objOop12;
  201.         /* begin objectAfter:limit: */
  202.         numSlots12 = byteAt(objOop12 + 7);
  203.         numSlots21 = (numSlots12 == (numSlotsMask())
  204.             ? longAt(objOop12 - BaseHeaderSize)
  205.             : numSlots12);
  206.         if (numSlots21 == 0) {
  207. slotBytes2 = 8;
  208.         }
  209.         else {
  210. slotBytes2 = (numSlots21 + (numSlots21 & 1)) << (shiftForWord());
  211.         }
  212.         followingWordAddress2 = (objOop12 + BaseHeaderSize) + slotBytes2;
  213.         if (oopisGreaterThanOrEqualTo(followingWordAddress2, GIV(pastSpaceStart))) {
  214.             objOop12 = GIV(pastSpaceStart);
  215.             goto l19;
  216.         }
  217.         flag("endianness");
  218.         followingWord2 = longAt(followingWordAddress2 + 4);
  219.         objOop12 = ((((usqInt) followingWord2) >> (numSlotsHalfShift())) == (numSlotsMask())
  220.             ? followingWordAddress2 + BaseHeaderSize
  221.             : followingWordAddress2);
  222.     l19:    /* end objectAfter:limit: */;
  223.     }
  224.     lowestForwarder1 = 0;
  225.     /* begin allOldSpaceObjectsDo: */
  226.     assert(isOldObject(GIV(nilObj)));
  227.     prevPrevObj11 = (prevObj11 = null);
  228.     objOop11 = GIV(nilObj);
  229.     while (1) {
  230. assert((objOop11 % (allocationUnit())) == 0);
  231.         if (!(oopisLessThan(objOop11, GIV(endOfMemory)))) break;
  232.         assert((long64At(objOop11)) != 0);
  233.         if (isEnumerableObject(objOop11)) {
  234.             if (((longAt(objOop11)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
  235.                 if (lowestForwarder1 == 0) {
  236. lowestForwarder1 = objOop11;
  237.                 }
  238.             }
  239.             else {
  240. for (i = 0, iLimiT = ((numPointerSlotsOf(objOop11)) - 1); i <= iLimiT; i += 1) {
  241.                     f = longAt((objOop11 + BaseHeaderSize) + (i << (shiftForWord())));
  242.                     if (((f & (tagMask())) == 0)
  243.                      && (((longAt(f)) & (classIndexMask())) == (isForwardedObjectClassIndexPun()))) {
  244.                         /* begin followForwarded: */
  245.                         assert(isUnambiguouslyForwarder(f));
  246.                         referent11 = longAt((f + BaseHeaderSize) + (0L << (shiftForWord())));
  247.                         while (((referent11 & (tagMask())) == 0)
  248.                          && (((longAt(referent11)) & (classIndexMask())) == (isForwardedObjectClassIndexPun()))) {
  249.                             referent11 = longAt((referent11 + BaseHeaderSize) + (0L << (shiftForWord())));
  250.                         }
  251.                         f = referent11;
  252.                         /* begin storePointer:ofObject:withValue: */
  253.                         assert(!(isForwarded(objOop11)));
  254.                         if (isOldObject(objOop11)) {
  255.  
  256.                             /* most stores into young objects */
  257. if (((f & (tagMask())) == 0)
  258.                              && (oopisLessThan(f, GIV(newSpaceLimit)))) {
  259.  
  260.                                 /* most stores into young objects */
  261. /* begin possibleRootStoreInto: */
  262.                                 if (!(((((usqInt) (longAt(objOop11))) >> (rememberedBitShift())) & 1) != 0)) {
  263.                                     remember(objOop11);
  264.                                 }
  265.                             }
  266.                         }
  267.                         longAtput((objOop11 + BaseHeaderSize) + (i << (shiftForWord())), f);
  268.                     }
  269.                 }
  270.             }
  271.  
  272.         }
  273.  
  274.         prevPrevObj11 = prevObj11;
  275.         prevObj11 = objOop11;
  276.         /* begin objectAfter:limit: */
  277.         numSlots111 = byteAt(objOop11 + 7);
  278.         numSlots31 = (numSlots111 == (numSlotsMask())
  279.             ? longAt(objOop11 - BaseHeaderSize)
  280.             : numSlots111);
  281.         if (numSlots31 == 0) {
  282. slotBytes11 = 8;
  283.         }
  284.         else {
  285. slotBytes11 = (numSlots31 + (numSlots31 & 1)) << (shiftForWord());
  286.         }
  287.         followingWordAddress11 = (objOop11 + BaseHeaderSize) + slotBytes11;
  288.         if (oopisGreaterThanOrEqualTo(followingWordAddress11, GIV(endOfMemory))) {
  289.             objOop11 = GIV(endOfMemory);
  290.             goto l23;
  291.         }
  292.         flag("endianness");
  293.         followingWord11 = longAt(followingWordAddress11 + 4);
  294.         objOop11 = ((((usqInt) followingWord11) >> (numSlotsHalfShift())) == (numSlotsMask())
  295.             ? followingWordAddress11 + BaseHeaderSize
  296.             : followingWordAddress11);
  297.     l23:    /* end objectAfter:limit: */;
  298.     }
  299.     lowestForwarder = lowestForwarder1;
  300.     /* begin sweepToCoallesceFreeSpaceForPigCompactFrom: */
  301.     lowest = ((((lowestForwarder == 0
  302.     ? GIV(endOfMemory)
  303.     : lowestForwarder)) < ((GIV(firstFreeChunk) == 0
  304.     ? GIV(endOfMemory)
  305.     : GIV(firstFreeChunk)))) ? ((lowestForwarder == 0
  306.     ? GIV(endOfMemory)
  307.     : lowestForwarder)) : ((GIV(firstFreeChunk) == 0
  308.     ? GIV(endOfMemory)
  309.     : GIV(firstFreeChunk))));
  310.     firstOfFreeRun = (prevPrevFree = (prevFree = 0));
  311.     /* begin allOldSpaceEntitiesFrom:do: */
  312.     assert(isOldObject(lowest));
  313.     prevPrevObj1 = (prevObj1 = null);
  314.     objOop3 = lowest;
  315.     while (1) {
  316. assert((objOop3 % (allocationUnit())) == 0);
  317.         if (!(oopisLessThan(objOop3, GIV(endOfMemory)))) break;
  318.         assert((long64At(objOop3)) != 0);
  319.         if ((((longAt(objOop3)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))
  320.          || (((longAt(objOop3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
  321.             if (firstOfFreeRun == 0) {
  322. /* begin setObjectFree: */
  323.                 if ((byteAt(objOop3 + 7)) == 0) {
  324.                     byteAtput(objOop3 + 7, 1);
  325.                 }
  326.                 /* begin setFree: */
  327.                 long32Atput(objOop3, 0);
  328.                 firstOfFreeRun = objOop3;
  329.                 startOfFreeRun = ((byteAt(objOop3 + 7)) == (numSlotsMask())
  330.                     ? objOop3 - BaseHeaderSize
  331.                     : objOop3);
  332.             }
  333.             endOfFreeRun = objOop3;
  334.         }
  335.         else {
  336. if (firstOfFreeRun != 0) {
  337. bytes = (addressAfter(endOfFreeRun)) - startOfFreeRun;
  338.                 firstOfFreeRun = initFreeChunkWithBytesat(bytes, startOfFreeRun);
  339.                 /* begin inSortedFreeListLink:to:given: */
  340.                 if (prevFree == 0) {
  341. GIV(firstFreeChunk) = firstOfFreeRun;
  342.                 }
  343.                 else {
  344. /* begin storePointer:ofFreeChunk:withUncheckedValue: */
  345.                     assert(isFreeObject(prevFree));
  346.                     longAtput((prevFree + BaseHeaderSize) + (0L << (shiftForWord())), prevPrevFree ^ firstOfFreeRun);
  347.                 }
  348.                 prevPrevFree = prevFree;
  349.                 prevFree = firstOfFreeRun;
  350.                 firstOfFreeRun = 0;
  351.             }
  352.         }
  353.  
  354.         prevPrevObj1 = prevObj1;
  355.         prevObj1 = objOop3;
  356.         /* begin objectAfter:limit: */
  357.         numSlots11 = byteAt(objOop3 + 7);
  358.         numSlots3 = (numSlots11 == (numSlotsMask())
  359.             ? longAt(objOop3 - BaseHeaderSize)
  360.             : numSlots11);
  361.         if (numSlots3 == 0) {
  362. slotBytes1 = 8;
  363.         }
  364.         else {
  365. slotBytes1 = (numSlots3 + (numSlots3 & 1)) << (shiftForWord());
  366.         }
  367.         followingWordAddress1 = (objOop3 + BaseHeaderSize) + slotBytes1;
  368.         if (oopisGreaterThanOrEqualTo(followingWordAddress1, GIV(endOfMemory))) {
  369.             objOop3 = GIV(endOfMemory);
  370.             goto l9;
  371.         }
  372.         flag("endianness");
  373.         followingWord1 = longAt(followingWordAddress1 + 4);
  374.         objOop3 = ((((usqInt) followingWord1) >> (numSlotsHalfShift())) == (numSlotsMask())
  375.             ? followingWordAddress1 + BaseHeaderSize
  376.             : followingWordAddress1);
  377.     l9: /* end objectAfter:limit: */;
  378.     }
  379.     if (firstOfFreeRun != 0) {
  380. bytes = (addressAfter(endOfFreeRun)) - startOfFreeRun;
  381.         firstOfFreeRun = initFreeChunkWithBytesat(bytes, startOfFreeRun);
  382.         /* begin inSortedFreeListLink:to:given: */
  383.         if (prevFree == 0) {
  384. GIV(firstFreeChunk) = firstOfFreeRun;
  385.         }
  386.         else {
  387. /* begin storePointer:ofFreeChunk:withUncheckedValue: */
  388.             assert(isFreeObject(prevFree));
  389.             longAtput((prevFree + BaseHeaderSize) + (0L << (shiftForWord())), prevPrevFree ^ firstOfFreeRun);
  390.         }
  391.         prevPrevFree = prevFree;
  392.         prevFree = firstOfFreeRun;
  393.         firstOfFreeRun = 0;
  394.     }
  395.     if (prevFree != GIV(firstFreeChunk)) {
  396. /* begin storePointer:ofFreeChunk:withValue: */
  397.         assert(isFreeObject(prevFree));
  398.         assert((prevPrevFree == 0)
  399.          || (isFreeObject(prevPrevFree)));
  400.         longAtput((prevFree + BaseHeaderSize) + (0L << (shiftForWord())), prevPrevFree);
  401.     }
  402.     GIV(lastFreeChunk) = prevFree;
  403.     /* begin inSortedFreeListLink:to:given: */
  404.     if (GIV(lastFreeChunk) == 0) {
  405. GIV(firstFreeChunk) = 0;
  406.     }
  407.     else {
  408. /* begin storePointer:ofFreeChunk:withUncheckedValue: */
  409.         assert(isFreeObject(GIV(lastFreeChunk)));
  410.         longAtput((GIV(lastFreeChunk) + BaseHeaderSize) + (0L << (shiftForWord())), prevPrevFree ^ 0);
  411.     }
  412.     assert(checkTraversableSortedFreeList());
  413.     assert((numberOfForwarders()) == 0);
  414. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!