private static IRubyObject interpret(
ThreadContext context,
IRubyObject self,
IRScope scope,
Visibility visibility,
RubyModule implClass,
IRubyObject[] args,
Block block,
Block.Type blockType) {
Instr[] instrs = scope.getInstrsForInterpretation();
// The base IR may not have been processed yet
if (instrs == null) instrs = scope.prepareForInterpretation(blockType == Block.Type.LAMBDA);
int numTempVars = scope.getTemporaryVariableSize();
Object[] temp = numTempVars > 0 ? new Object[numTempVars] : null;
int n = instrs.length;
int ipc = 0;
Instr instr = null;
Object exception = null;
int kwArgHashCount =
(scope.receivesKeywordArgs() && args[args.length - 1] instanceof RubyHash) ? 1 : 0;
DynamicScope currDynScope = context.getCurrentScope();
// Counter tpCount = null;
// Init profiling this scope
boolean debug = IRRuntimeHelpers.isDebug();
boolean profile = IRRuntimeHelpers.inProfileMode();
Integer scopeVersion = profile ? initProfiling(scope) : 0;
// Enter the looooop!
while (ipc < n) {
instr = instrs[ipc];
ipc++;
Operation operation = instr.getOperation();
if (debug) {
LOG.info("I: {}", instr);
interpInstrsCount++;
} else if (profile) {
if (operation.modifiesCode()) codeModificationsCount++;
interpInstrsCount++;
/*
Counter cnt = opStats.get(operation);
if (cnt == null) {
cnt = new Counter();
opStats.put(operation, cnt);
}
cnt.count++;
*/
}
try {
switch (operation.opClass) {
case ARG_OP:
{
receiveArg(
context,
instr,
operation,
args,
kwArgHashCount,
currDynScope,
temp,
exception,
block);
break;
}
case BRANCH_OP:
{
if (operation == Operation.JUMP) {
ipc = ((JumpInstr) instr).getJumpTarget().getTargetPC();
} else {
ipc = instr.interpretAndGetNewIPC(context, currDynScope, self, temp, ipc);
}
break;
}
case CALL_OP:
{
if (profile) updateCallSite(instr, scope, scopeVersion);
processCall(
context, instr, operation, scope, currDynScope, temp, self, block, blockType);
break;
}
case BOOK_KEEPING_OP:
{
switch (operation) {
case PUSH_FRAME:
{
context.preMethodFrameAndClass(
implClass, scope.getName(), self, block, scope.getStaticScope());
context.setCurrentVisibility(visibility);
break;
}
case PUSH_BINDING:
{
// SSS NOTE: Method scopes only!
//
// Blocks are a headache -- so, these instrs. are only added to IRMethods.
// Blocks have more complicated logic for pushing a dynamic scope (see
// InterpretedIRBlockBody)
// Changed by DPR
currDynScope =
DynamicScope.newDynamicScope(
scope.getStaticScope(), context.getCurrentScope().getDepth());
context.pushScope(currDynScope);
break;
}
case CHECK_ARITY:
((CheckArityInstr) instr).checkArity(context.runtime, args.length);
break;
case POP_FRAME:
context.popFrame();
context.popRubyClass();
break;
case POP_BINDING:
context.popScope();
break;
case THREAD_POLL:
if (profile) {
// SSS: Not being used currently
// tpCount.count++;
globalThreadPollCount++;
// 20K is arbitrary
// Every 20K profile counts, spit out profile stats
if (globalThreadPollCount % 20000 == 0) {
analyzeProfile();
// outputProfileStats();
}
}
context.callThreadPoll();
break;
case LINE_NUM:
context.setLine(((LineNumberInstr) instr).lineNumber);
break;
case RECORD_END_BLOCK:
((RecordEndBlockInstr) instr).interpret();
break;
}
break;
}
case OTHER_OP:
{
Object result = null;
switch (operation) {
// --------- Return flavored instructions --------
case BREAK:
{
BreakInstr bi = (BreakInstr) instr;
IRubyObject rv =
(IRubyObject)
bi.getReturnValue().retrieve(context, self, currDynScope, temp);
// This also handles breaks in lambdas -- by converting them to a return
return IRRuntimeHelpers.initiateBreak(
context, scope, bi.getScopeToReturnTo().getScopeId(), rv, blockType);
}
case RETURN:
{
return (IRubyObject)
retrieveOp(
((ReturnBase) instr).getReturnValue(),
context,
self,
currDynScope,
temp);
}
case NONLOCAL_RETURN:
{
NonlocalReturnInstr ri = (NonlocalReturnInstr) instr;
IRubyObject rv =
(IRubyObject)
retrieveOp(ri.getReturnValue(), context, self, currDynScope, temp);
ipc = n;
// If not in a lambda, check if this was a non-local return
if (!IRRuntimeHelpers.inLambda(blockType)) {
IRRuntimeHelpers.initiateNonLocalReturn(
context, scope, ri.methodToReturnFrom, rv);
}
return rv;
}
// ---------- Common instruction ---------
case COPY:
{
CopyInstr c = (CopyInstr) instr;
result = retrieveOp(c.getSource(), context, self, currDynScope, temp);
setResult(temp, currDynScope, c.getResult(), result);
break;
}
case GET_FIELD:
{
GetFieldInstr gfi = (GetFieldInstr) instr;
IRubyObject object =
(IRubyObject) gfi.getSource().retrieve(context, self, currDynScope, temp);
VariableAccessor a = gfi.getAccessor(object);
result = a == null ? null : (IRubyObject) a.get(object);
if (result == null) {
result = context.nil;
}
setResult(temp, currDynScope, gfi.getResult(), result);
break;
}
case SEARCH_CONST:
{
SearchConstInstr sci = (SearchConstInstr) instr;
result = sci.getCachedConst();
if (!sci.isCached(context, result))
result = sci.cache(context, currDynScope, self, temp);
setResult(temp, currDynScope, sci.getResult(), result);
break;
}
// ---------- All the rest ---------
default:
result = instr.interpret(context, currDynScope, self, temp, block);
setResult(temp, currDynScope, instr, result);
break;
}
break;
}
}
} catch (Throwable t) {
// Unrescuable:
// IRReturnJump, ThreadKill, RubyContinuation, MainExitException, etc.
// These cannot be rescued -- only run ensure blocks
//
// Others:
// IRBreakJump, Ruby exceptions, errors, and other java exceptions.
// These can be rescued -- run rescue blocks
if (debug)
LOG.info(
"in scope: "
+ scope
+ ", caught Java throwable: "
+ t
+ "; excepting instr: "
+ instr);
ipc = (t instanceof Unrescuable) ? scope.getEnsurerPC(instr) : scope.getRescuerPC(instr);
if (debug) LOG.info("ipc for rescuer/ensurer: " + ipc);
if (ipc == -1) {
Helpers.throwException((Throwable) t);
} else {
exception = t;
}
}
}
// Control should never get here!
// SSS FIXME: But looks like BEGIN/END blocks get here -- needs fixing
return null;
}
public IRubyObject interpret(
ThreadContext context,
IRubyObject self,
InterpreterContext interpreterContext,
RubyModule implClass,
String name,
IRubyObject[] args,
Block block,
Block.Type blockType) {
Instr[] instrs = interpreterContext.getInstructions();
Object[] temp = interpreterContext.allocateTemporaryVariables();
int n = instrs.length;
int ipc = 0;
Object exception = null;
if (interpreterContext.receivesKeywordArguments())
IRRuntimeHelpers.frobnicateKwargsArgument(
context, interpreterContext.getRequiredArgsCount(), args);
StaticScope currScope = interpreterContext.getStaticScope();
DynamicScope currDynScope = context.getCurrentScope();
boolean acceptsKeywordArgument = interpreterContext.receivesKeywordArguments();
Stack<Integer> rescuePCs = null;
// Init profiling this scope
boolean debug = IRRuntimeHelpers.isDebug();
boolean profile = IRRuntimeHelpers.inProfileMode();
Integer scopeVersion = profile ? Profiler.initProfiling(interpreterContext.getScope()) : 0;
// Enter the looooop!
while (ipc < n) {
Instr instr = instrs[ipc];
Operation operation = instr.getOperation();
if (debug) {
Interpreter.LOG.info("I: {" + ipc + "} ", instr + "; <#RPCs=" + rescuePCs.size() + ">");
Interpreter.interpInstrsCount++;
} else if (profile) {
Profiler.instrTick(operation);
Interpreter.interpInstrsCount++;
}
ipc++;
try {
switch (operation.opClass) {
case ARG_OP:
receiveArg(
context,
instr,
operation,
args,
acceptsKeywordArgument,
currDynScope,
temp,
exception,
block);
break;
case CALL_OP:
if (profile)
Profiler.updateCallSite(instr, interpreterContext.getScope(), scopeVersion);
processCall(context, instr, operation, currDynScope, currScope, temp, self);
break;
case RET_OP:
return processReturnOp(
context, instr, operation, currDynScope, temp, self, blockType, currScope);
case BRANCH_OP:
switch (operation) {
case JUMP:
JumpInstr jump = ((JumpInstr) instr);
if (jump.exitsExcRegion()) {
rescuePCs.pop();
}
ipc = jump.getJumpTarget().getTargetPC();
break;
default:
ipc =
instr.interpretAndGetNewIPC(context, currDynScope, currScope, self, temp, ipc);
break;
}
break;
case BOOK_KEEPING_OP:
switch (operation) {
case PUSH_BINDING:
// IMPORTANT: Preserve this update of currDynScope.
// This affects execution of all instructions in this scope
// which will now use the updated value of currDynScope.
currDynScope = interpreterContext.newDynamicScope(context);
context.pushScope(currDynScope);
case EXC_REGION_START:
if (rescuePCs == null) rescuePCs = new Stack<>();
rescuePCs.push(
((ExceptionRegionStartMarkerInstr) instr)
.getFirstRescueBlockLabel()
.getTargetPC());
break;
case EXC_REGION_END:
rescuePCs.pop();
break;
default:
processBookKeepingOp(
context, instr, operation, name, args, self, block, blockType, implClass);
}
break;
case OTHER_OP:
processOtherOp(
context, instr, operation, currDynScope, currScope, temp, self, blockType);
break;
}
} catch (Throwable t) {
if (debug) extractToMethodToAvoidC2Crash(instr, t);
if (rescuePCs == null
|| rescuePCs.empty()
|| (t instanceof IRBreakJump && instr instanceof BreakInstr)
|| (t instanceof IRReturnJump && instr instanceof NonlocalReturnInstr)) {
ipc = -1;
} else {
ipc = rescuePCs.pop();
}
if (debug) {
Interpreter.LOG.info(
"in : "
+ interpreterContext.getScope()
+ ", caught Java throwable: "
+ t
+ "; excepting instr: "
+ instr);
Interpreter.LOG.info("ipc for rescuer: " + ipc);
}
if (ipc == -1) {
Helpers.throwException(t);
} else {
exception = t;
}
}
}
// Control should never get here!
throw context.runtime.newRuntimeError("BUG: interpreter fell through to end unexpectedly");
}