/**
* Gets the previous frame (if any)
*
* @param sf The stackframe to get the previous frame from.
* @return The previous frame or null.
*/
@KernelSpace
@Internal
public final Address getPrevious(Address sf) {
if (isValid(sf)) {
return sf.loadAddress(getPreviousOffset(sf));
} else {
return null;
}
}
/**
* Trace a reference during GC. This involves determining which collection policy applies and
* calling the appropriate <code>trace</code> method.
*
* @param target The object the interior edge points within.
* @param slot The location of the interior edge.
* @param root True if this is a root edge.
*/
public final void processInteriorEdge(ObjectReference target, Address slot, boolean root) {
Address interiorRef = slot.loadAddress();
Offset offset = interiorRef.diff(target.toAddress());
ObjectReference newTarget = traceObject(target, root);
if (VM.VERIFY_ASSERTIONS) {
if (offset.sLT(Offset.zero()) || offset.sGT(Offset.fromIntSignExtend(1 << 24))) {
// There is probably no object this large
Log.writeln("ERROR: Suspiciously large delta to interior pointer");
Log.write(" object base = ");
Log.writeln(target);
Log.write(" interior reference = ");
Log.writeln(interiorRef);
Log.write(" delta = ");
Log.writeln(offset);
VM.assertions._assert(false);
}
}
slot.store(newTarget.toAddress().plus(offset));
}
/**
* Gets the return address of a given stackframe.
*
* @param sf Stackframe pointer
* @return The address
*/
@Internal
public final Address getReturnAddress(Address sf) {
return sf.loadAddress(getReturnAddressOffset(sf));
}
/**
* This method is called when a call stack edge needs to be sampled. Expect the sfp argument to
* point to the stack frame that contains the target of the edge to be sampled.
*
* <p>NOTE: This method is uninterruptible, therefore we don't need to disable thread switching
* during stackframe inspection.
*
* @param sfp a pointer to the stack frame that corresponds to the callee of the call graph edge
* that is to be sampled.
* @param whereFrom Was this a yieldpoint in a PROLOGUE, BACKEDGE, or EPILOGUE?
*/
@Override
public final void update(Address sfp, int whereFrom) {
if (DEBUG) {
VM.sysWrite("EdgeListener.update(", sfp, ",", whereFrom);
VM.sysWriteln("): enter ", samplesTaken);
}
Synchronization.fetchAndAdd(this, AosEntrypoints.edgeListenerUpdateCalledField.getOffset(), 1);
// don't take a sample for back edge yield points
if (whereFrom == RVMThread.BACKEDGE) return;
int calleeCMID = 0;
int callerCMID = 0;
Address returnAddress = Address.zero();
if (sfp.loadAddress().EQ(STACKFRAME_SENTINEL_FP)) {
if (DEBUG) VM.sysWrite(" Walking off end of stack!\n");
return;
}
calleeCMID = Magic.getCompiledMethodID(sfp);
if (calleeCMID == INVISIBLE_METHOD_ID) {
if (DEBUG) {
VM.sysWrite(" INVISIBLE_METHOD_ID (assembler code) ");
VM.sysWrite(calleeCMID);
VM.sysWrite("\n");
}
return;
}
returnAddress = Magic.getReturnAddress(sfp); // return address in caller
sfp = Magic.getCallerFramePointer(sfp); // caller's frame pointer
if (sfp.loadAddress().EQ(STACKFRAME_SENTINEL_FP)) {
if (DEBUG) VM.sysWrite(" Walking off end of stack\n");
return;
}
callerCMID = Magic.getCompiledMethodID(sfp);
if (callerCMID == INVISIBLE_METHOD_ID) {
if (DEBUG) {
VM.sysWrite(" INVISIBLE_METHOD_ID (assembler code) ");
VM.sysWrite(callerCMID);
VM.sysWrite("\n");
}
return;
}
// store the offset of the return address from the beginning of the
// instruction
CompiledMethod callerCM = CompiledMethods.getCompiledMethod(callerCMID);
if (callerCM.getCompilerType() == CompiledMethod.TRAP) {
if (DEBUG) {
VM.sysWriteln(" HARDWARE TRAP FRAME ");
}
return;
}
Offset callSite = callerCM.getInstructionOffset(returnAddress);
if (DEBUG) {
VM.sysWrite(" <");
VM.sysWrite(calleeCMID);
VM.sysWrite(",");
VM.sysWrite(callerCMID);
VM.sysWrite(",");
VM.sysWrite(returnAddress);
VM.sysWrite(">\n");
}
// Find out what sample we are.
int sampleNumber =
Synchronization.fetchAndAdd(
this, AosEntrypoints.edgeListenerSamplesTakenField.getOffset(), 1);
int idx = 3 * sampleNumber;
// If we got buffer slots that are beyond the end of the buffer, that means
// that we're actually not supposed to take the sample at all (the system
// is in the process of activating our organizer and processing the buffer).
if (idx < buffer.length) {
buffer[idx + 1] = callerCMID;
buffer[idx + 2] = callSite.toInt();
Magic.sync();
buffer[idx + 0] = calleeCMID;
// If we are the last sample, we need to activate the organizer.
if (sampleNumber + 1 == desiredSamples) {
activateOrganizer();
}
}
}
