void ScanAddress::ScanAddressesInRegion(PolyWord *region, PolyWord *end) { PolyWord *pt = region; while (pt < end) { pt++; // Skip length word. // pt actually points AT the object here. PolyObject *obj = (PolyObject*)pt; if (obj->ContainsForwardingPtr()) /* skip over moved object */ { // We can now get multiple forwarding pointers as a result // of applying ShareData repeatedly. Perhaps we should // turn the forwarding pointers back into normal words in // an extra pass. while (obj->ContainsForwardingPtr()) obj = obj->GetForwardingPtr(); ASSERT(obj->ContainsNormalLengthWord()); CheckObject(obj); pt += obj->Length(); } else { ASSERT(obj->ContainsNormalLengthWord()); POLYUNSIGNED length = obj->Length(); if (pt+length > end) Crash("Malformed object at %p - length %lu\n", pt, length); if (length != 0) ScanAddressesInObject(obj); pt += length; } } }
// Returns the new address if the argument is the address of an object that // has moved, otherwise returns the original. PolyWord SaveFixupAddress::GetNewAddress(PolyWord old) { if (old.IsTagged() || old == PolyWord::FromUnsigned(0) || gMem.IsIOPointer(old.AsAddress())) return old; // Nothing to do. // When we are updating addresses in the stack or in code segments we may have // code pointers. if (old.IsCodePtr()) { // Find the start of the code segment PolyObject *oldObject = ObjCodePtrToPtr(old.AsCodePtr()); // Calculate the byte offset of this value within the code object. POLYUNSIGNED offset = old.AsCodePtr() - (byte*)oldObject; PolyWord newObject = GetNewAddress(oldObject); return PolyWord::FromCodePtr(newObject.AsCodePtr() + offset); } ASSERT(old.IsDataPtr()); PolyObject *obj = old.AsObjPtr(); if (obj->ContainsForwardingPtr()) // tombstone is a pointer to a moved object { PolyObject *newp = obj->GetForwardingPtr(); ASSERT (newp->ContainsNormalLengthWord()); return newp; } ASSERT (obj->ContainsNormalLengthWord()); // object is not moved return old; }
bool GetSharing::TestForScan(PolyWord *pt) { PolyObject *obj; // This may be a forwarding pointer left over from a minor GC that did // not complete or it may be a sharing chain pointer that we've set up. while (1) { PolyWord p = *pt; ASSERT(p.IsDataPtr()); obj = p.AsObjPtr(); PolyWord *lengthWord = ((PolyWord*)obj) - 1; LocalMemSpace *space = gMem.LocalSpaceForAddress(lengthWord); if (space == 0) return false; // Ignore it if it points to a permanent area if (space->bitmap.TestBit(space->wordNo(lengthWord))) return false; // Wasn't marked - must be a forwarding pointer. if (obj->ContainsForwardingPtr()) { obj = obj->GetForwardingPtr(); *pt = obj; } else break; } ASSERT(obj->ContainsNormalLengthWord()); totalVisited += 1; totalSize += obj->Length() + 1; return true; }
static void CheckAddress(PolyWord *pt) { MemSpace *space = gMem.SpaceForAddress(pt-1); if (space == 0) { Log("Check: Bad pointer %p (no space found)\n", pt); ASSERT(space != 0); } if (space->spaceType == ST_STACK) // This may not have valid length words. return; PolyObject *obj = (PolyObject*)pt; ASSERT(obj->ContainsNormalLengthWord()); POLYUNSIGNED length = obj->Length(); if (pt+length > space->top) { Log("Check: Bad pointer %p (space %p) length %" POLYUFMT "\n", pt, space, length); ASSERT(pt+length <= space->top); } if (space->spaceType == ST_LOCAL) { LocalMemSpace *lSpace = (LocalMemSpace*)space; if (!((pt > lSpace->bottom && pt+length <= lSpace->lowerAllocPtr) || (pt > lSpace->upperAllocPtr && pt+length <= space->top))) { Log("Check: Bad pointer %p (space %p) length %" POLYUFMT " outside allocated area\n", pt, space, length); ASSERT((pt > lSpace->bottom && pt+length <= lSpace->lowerAllocPtr) || (pt > lSpace->upperAllocPtr && pt+length <= space->top)); } } }
static void SetBitmaps(LocalMemSpace *space, PolyWord *pt, PolyWord *top) { while (pt < top) { PolyObject *obj = (PolyObject*)++pt; // If it has been copied by a minor collection skip it if (obj->ContainsForwardingPtr()) { obj = FollowForwarding(obj); ASSERT(obj->ContainsNormalLengthWord()); pt += obj->Length(); } else { POLYUNSIGNED L = obj->LengthWord(); POLYUNSIGNED n = OBJ_OBJECT_LENGTH(L); if (L & _OBJ_GC_MARK) { obj->SetLengthWord(L & ~(_OBJ_GC_MARK)); POLYUNSIGNED bitno = space->wordNo(pt); space->bitmap.SetBits(bitno - 1, n + 1); if (OBJ_IS_MUTABLE_OBJECT(L)) space->m_marked += n + 1; else space->i_marked += n + 1; if ((PolyWord*)obj <= space->fullGCLowerLimit) space->fullGCLowerLimit = (PolyWord*)obj-1; if (OBJ_IS_WEAKREF_OBJECT(L)) { // Add this to the limits for the containing area. PolyWord *baseAddr = (PolyWord*)obj; PolyWord *startAddr = baseAddr-1; // Must point AT length word. PolyWord *endObject = baseAddr + n; if (startAddr < space->lowestWeak) space->lowestWeak = startAddr; if (endObject > space->highestWeak) space->highestWeak = endObject; } } pt += n; } } }
// Returns the new address if the argument is the address of an object that // has moved, otherwise returns the original. PolyWord ProcessFixupAddress::GetNewAddress(PolyWord old) { if (old.IsTagged() || old == PolyWord::FromUnsigned(0) || gMem.IsIOPointer(old.AsAddress())) return old; // Nothing to do. // When we are updating addresses in the stack or in code segments we may have // code pointers. if (old.IsCodePtr()) { // Find the start of the code segment PolyObject *oldObject = ObjCodePtrToPtr(old.AsCodePtr()); // Calculate the byte offset of this value within the code object. POLYUNSIGNED offset = old.AsCodePtr() - (byte*)oldObject; PolyWord newObject = GetNewAddress(oldObject); return PolyWord::FromCodePtr(newObject.AsCodePtr() + offset); } ASSERT(old.IsDataPtr()); PolyObject *obj = old.AsObjPtr(); POLYUNSIGNED L = obj->LengthWord(); // Generally each address will point to an object processed at a lower depth. // The exception is if we have a cycle and have assigned the rest of the // structure to a higher depth. // N.B. We return the original address here but this could actually share // with something else and not be retained. if (OBJ_IS_DEPTH(L)) return old; if (obj->ContainsForwardingPtr()) // tombstone is a pointer to a shared object { PolyObject *newp = obj->GetForwardingPtr(); // ASSERT (newp->ContainsNormalLengthWord()); return newp; } ASSERT (obj->ContainsNormalLengthWord()); // object is not shared return old; }