@ExplodeLoop public void profileArguments(Object[] args) { Assumption typesAssumption = profiledArgumentTypesAssumption; if (typesAssumption == null) { CompilerDirectives.transferToInterpreterAndInvalidate(); initializeProfiledArgumentTypes(args); } else { Class<?>[] types = profiledArgumentTypes; if (types != null) { if (types.length != args.length) { CompilerDirectives.transferToInterpreterAndInvalidate(); typesAssumption.invalidate(); profiledArgumentTypes = null; } else if (typesAssumption.isValid()) { for (int i = 0; i < types.length; i++) { Class<?> type = types[i]; Object value = args[i]; if (type != null && (value == null || value.getClass() != type)) { CompilerDirectives.transferToInterpreterAndInvalidate(); updateProfiledArgumentTypes(args, types); break; } } } } } }
@Override public double executeFloat(RubyBasicObject receiver) throws UnexpectedResultException { if (hasFloat && receiver.getRubyClass() == expectedClass && unmodifiedAssumption.isValid()) { return integerFixnumValue; } else { return next.executeFloat(receiver); } }
@Override public boolean executeBoolean(RubyBasicObject receiver) throws UnexpectedResultException { if (hasBoolean && receiver.getRubyClass() == expectedClass && unmodifiedAssumption.isValid()) { return booleanValue; } else { return next.executeBoolean(receiver); } }
private boolean lazyUpdate(VirtualFrame frame) { if (version == null || !version.isValid()) { CompilerDirectives.transferToInterpreterAndInvalidate(); // i am allowed to pass in the virtual frame as its instances are always materialized return lazyUpdatedImpl(frame); } return true; }
@Override public long executeLongFixnum(RubyBasicObject receiver) throws UnexpectedResultException { if (hasLongFixnum && receiver.getRubyClass() == expectedClass && unmodifiedAssumption.isValid()) { return longFixnumValue; } else { return next.executeLongFixnum(receiver); } }
@Override public Object execute(RubyBasicObject receiver) { // TODO(CS): not sure trying next on invalid assumption is right... if (receiver.getRubyClass() == expectedClass && unmodifiedAssumption.isValid()) { return value; } else { return next.execute(receiver); } }
@Override public Object call(Object... args) { compilationProfile.reportIndirectCall(); if (profiledArgumentTypesAssumption != null && profiledArgumentTypesAssumption.isValid()) { // Argument profiling is not possible for targets of indirect calls. CompilerDirectives.transferToInterpreterAndInvalidate(); profiledArgumentTypesAssumption.invalidate(); profiledArgumentTypes = null; } return doInvoke(args); }
public final Object callRoot(Object[] originalArguments) { Object[] args = originalArguments; if (CompilerDirectives.inCompiledCode()) { Assumption argumentTypesAssumption = this.profiledArgumentTypesAssumption; if (argumentTypesAssumption != null && argumentTypesAssumption.isValid()) { args = unsafeCast( castArrayFixedLength(args, profiledArgumentTypes.length), Object[].class, true, true); args = castArguments(args); } } VirtualFrame frame = createFrame(getRootNode().getFrameDescriptor(), args); Object result = callProxy(frame); profileReturnType(result); return result; }
public final Object callDirect(Object... args) { compilationProfile.reportDirectCall(); profileArguments(args); try { Object result = doInvoke(args); Class<?> klass = profiledReturnType; if (klass != null && CompilerDirectives.inCompiledCode() && profiledReturnTypeAssumption.isValid()) { result = unsafeCast(result, klass, true, true); } return result; } catch (Throwable t) { t = exceptionProfile.profile(t); if (t instanceof RuntimeException) { throw (RuntimeException) t; } else if (t instanceof Error) { throw (Error) t; } else { CompilerDirectives.transferToInterpreter(); throw new RuntimeException(t); } } }