/*  scavengeReferentsOf: referrer inspects all the pointers in referrer. If
    any are new objects, it has them moved to FutureSurvivorSpace, and
    answers truth. If there are no new referents, it answers falsity. To
    handle weak arrays, if the referrer is weak only scavenge strong slots and
    answer true so that it won't be removed from the remembered set until
    later.  */
/*  forwarding objects should be followed by callers,
    unless the forwarder is a root in the remembered table. */

    /* SpurGenerationScavenger>>#scavengeReferentsOf: */
static sqInt NoDbgRegParms
scavengeReferentsOf(sqInt referrer)
{   DECL_MAYBE_SQ_GLOBAL_STRUCT
    sqInt contextSize;
    sqInt fmt;
    sqInt foundNewReferentOrIsWeakling;
    sqInt header;
    sqInt header1;
    sqInt i;
    sqInt newLocation;
    sqInt numLiterals;
    sqInt numSlots;
    usqInt numSlots1;
    usqInt numSlots2;
    sqInt objOop1;
    sqInt referent;
    sqInt referent1;
    sqInt sp;

    assert((!(isForwarded(referrer)))
     || (isRemembered(referrer)));
    assert((!(isEphemeron(referrer)))
     || ((isScavengeSurvivor(keyOfEphemeron(referrer)))
     || (isonWeaklingList(referrer, GIV(ephemeronList)))));
    fmt = (((usqInt) (longAt(referrer))) >> (formatShift())) & (formatMask());
    foundNewReferentOrIsWeakling = fmt == (weakArrayFormat());
    /* begin numStrongSlotsOf:format:ephemeronInactiveIf: */
    if (fmt <= 5) {
/* begin numSlotsOf: */
        flag("endianness");
        assert((classIndexOf(referrer)) > (isForwardedObjectClassIndexPun()));
        numSlots1 = byteAt(referrer + 7);
        numSlots2 = (numSlots1 == (numSlotsMask())
            ? longAt(referrer - BaseHeaderSize)
            : numSlots1);
        if (fmt <= 2) {
numSlots = numSlots2;
            goto l6;
        }
        if (fmt == (indexablePointersFormat())) {
            if (((longAt(referrer)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
                setTraceFlagOnContextsFramesPageIfNeeded(referrer);
                /* begin fetchStackPointerOf: */
                sp = longAt((referrer + BaseHeaderSize) + (StackPointerIndex << (shiftForWord())));
                if (!((sp & 1))) {
                    contextSize = 0;
                    goto l4;
                }
                assert((ReceiverIndex + ((sp >> 1))) < (lengthOf(referrer)));
                contextSize = (sp >> 1);
            l4: /* end fetchStackPointerOf: */;
                numSlots = CtxtTempFrameStart + contextSize;
                goto l6;
            }
            numSlots = numSlots2;
            goto l6;
        }
        if (fmt == (weakArrayFormat())) {
            /* begin fixedFieldsOfClass: */
            objOop1 = fetchClassOfNonImm(referrer);
            /* begin fixedFieldsOfClassFormat: */
            numSlots = (((longAt((objOop1 + BaseHeaderSize) + (InstanceSpecificationIndex << (shiftForWord())))) >> 1)) & ((1L << (fixedFieldsFieldWidth())) - 1);
            goto l6;
        }
        assert(fmt == (ephemeronFormat()));
        numSlots = (isScavengeSurvivor((keyOfEphemeron(referrer)))
            ? numSlots2
            : 0);
        goto l6;
    }
    if (fmt == 7) {
numSlots = 1;
        goto l6;
    }
    if (fmt < (firstCompiledMethodFormat())) {
        numSlots = 0;
        goto l6;
    }
    /* begin methodHeaderOf: */
    assert(isCompiledMethod(referrer));
    header1 = longAt((referrer + BaseHeaderSize) + (HeaderIndex << (shiftForWord())));
    if ((header1 & 1)) {
header = header1;
    }
    else {
assert((((usqInt)header1)) < GIV(newSpaceStart));
        assert((((((CogMethod *) header1))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
        header = ((((CogMethod *) header1))->methodHeader);
    }
    /* begin literalCountOfMethodHeader: */
    assert((header & 1));
    numLiterals = ((header >> 1)) & AlternateHeaderNumLiteralsMask;
    numSlots = numLiterals + LiteralStart;
l6: /* end numStrongSlotsOf:format:ephemeronInactiveIf: */;
    for (i = 0; i < numSlots; i += 1) {
referent = longAt((referrer + BaseHeaderSize) + (i << (shiftForWord())));
        if ((referent & (tagMask())) == 0) {

            /* a forwarding pointer could be because of become: or scavenging. */
if (((longAt(referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {

                /* a forwarding pointer could be because of become: or scavenging. */
/* begin followForwarded: */
                assert(isUnambiguouslyForwarder(referent));
                referent1 = longAt((referent + BaseHeaderSize) + (0L << (shiftForWord())));
                while (((referent1 & (tagMask())) == 0)
                 && (((longAt(referent1)) & (classIndexMask())) == (isForwardedObjectClassIndexPun()))) {
                    referent1 = longAt((referent1 + BaseHeaderSize) + (0L << (shiftForWord())));
                }
                referent = referent1;
            }
            if (isReallyYoungObject(referent)) {

                /* if target is already in future space forwarding pointer was due to a become:. */
if (oopisGreaterThanOrEqualToandLessThan(referent, ((futureSpace()).start), futureSurvivorStart())) {

                    /* if target is already in future space forwarding pointer was due to a become:. */

                    /* if target is already in future space forwarding pointer was due to a become:. */
newLocation = referent;
                    foundNewReferentOrIsWeakling = 1;
                }
                else {
newLocation = copyAndForward(referent);
                    if (((newLocation & (tagMask())) == 0)
                     && (oopisLessThan(newLocation, GIV(newSpaceLimit)))) {
                        foundNewReferentOrIsWeakling = 1;
                    }
                }
                longAtput((referrer + BaseHeaderSize) + (i << (shiftForWord())), newLocation);
            }
            else {
longAtput((referrer + BaseHeaderSize) + (i << (shiftForWord())), referent);
            }
        }
    }
    return foundNewReferentOrIsWeakling;
}