Esempio n. 1
0
public class Bootstrap {
  private static final Logger LOG = LoggerFactory.getLogger("Bootstrap");
  static final Lookup LOOKUP = MethodHandles.lookup();

  public static CallSite string(
      Lookup lookup, String name, MethodType type, String value, String encodingName) {
    Encoding encoding;
    EncodingDB.Entry entry = EncodingDB.getEncodings().get(encodingName.getBytes());
    if (entry == null) entry = EncodingDB.getAliases().get(encodingName.getBytes());
    if (entry == null) throw new RuntimeException("could not find encoding: " + encodingName);
    encoding = entry.getEncoding();
    ByteList byteList = new ByteList(value.getBytes(RubyEncoding.ISO), encoding);
    MutableCallSite site = new MutableCallSite(type);
    Binder binder =
        Binder.from(RubyString.class, ThreadContext.class)
            .insert(0, arrayOf(MutableCallSite.class, ByteList.class), site, byteList);
    if (name.equals("frozen")) {
      site.setTarget(binder.invokeStaticQuiet(lookup, Bootstrap.class, "frozenString"));
    } else {
      site.setTarget(binder.invokeStaticQuiet(lookup, Bootstrap.class, "string"));
    }

    return site;
  }

  public static CallSite bytelist(
      Lookup lookup, String name, MethodType type, String value, String encodingName) {
    Encoding encoding;
    EncodingDB.Entry entry = EncodingDB.getEncodings().get(encodingName.getBytes());
    if (entry == null) entry = EncodingDB.getAliases().get(encodingName.getBytes());
    if (entry == null) throw new RuntimeException("could not find encoding: " + encodingName);
    encoding = entry.getEncoding();
    ByteList byteList = new ByteList(value.getBytes(RubyEncoding.ISO), encoding);
    return new ConstantCallSite(constant(ByteList.class, byteList));
  }

  public static CallSite array(Lookup lookup, String name, MethodType type) {
    MethodHandle handle =
        Binder.from(type)
            .collect(1, IRubyObject[].class)
            .invokeStaticQuiet(LOOKUP, Bootstrap.class, "array");
    CallSite site = new ConstantCallSite(handle);
    return site;
  }

  public static CallSite hash(Lookup lookup, String name, MethodType type) {
    MethodHandle handle =
        Binder.from(lookup, type)
            .collect(1, IRubyObject[].class)
            .invokeStaticQuiet(LOOKUP, Bootstrap.class, "hash");
    CallSite site = new ConstantCallSite(handle);
    return site;
  }

  public static CallSite kwargsHash(Lookup lookup, String name, MethodType type) {
    MethodHandle handle =
        Binder.from(lookup, type)
            .collect(2, IRubyObject[].class)
            .invokeStaticQuiet(LOOKUP, Bootstrap.class, "kwargsHash");
    CallSite site = new ConstantCallSite(handle);
    return site;
  }

  public static CallSite ivar(Lookup lookup, String name, MethodType type) throws Throwable {
    String[] names = name.split(":");
    String operation = names[0];
    String varName = names[1];
    VariableSite site = new VariableSite(type, varName, "noname", 0);
    MethodHandle handle;

    handle =
        lookup.findStatic(
            Bootstrap.class, operation, type.insertParameterTypes(0, VariableSite.class));

    handle = handle.bindTo(site);
    site.setTarget(handle.asType(site.type()));

    return site;
  }

  public static CallSite searchConst(
      Lookup lookup, String name, MethodType type, int noPrivateConsts) {
    MutableCallSite site = new MutableCallSite(type);
    String[] bits = name.split(":");
    String constName = bits[1];

    MethodHandle handle =
        Binder.from(lookup, type)
            .append(site, constName.intern())
            .append(noPrivateConsts == 0 ? false : true)
            .invokeStaticQuiet(LOOKUP, Bootstrap.class, bits[0]);

    site.setTarget(handle);

    return site;
  }

  public static Handle string() {
    return new Handle(
        Opcodes.H_INVOKESTATIC,
        p(Bootstrap.class),
        "string",
        sig(
            CallSite.class,
            Lookup.class,
            String.class,
            MethodType.class,
            String.class,
            String.class));
  }

  public static Handle bytelist() {
    return new Handle(
        Opcodes.H_INVOKESTATIC,
        p(Bootstrap.class),
        "bytelist",
        sig(
            CallSite.class,
            Lookup.class,
            String.class,
            MethodType.class,
            String.class,
            String.class));
  }

  public static Handle array() {
    return new Handle(
        Opcodes.H_INVOKESTATIC,
        p(Bootstrap.class),
        "array",
        sig(CallSite.class, Lookup.class, String.class, MethodType.class));
  }

  public static Handle hash() {
    return new Handle(
        Opcodes.H_INVOKESTATIC,
        p(Bootstrap.class),
        "hash",
        sig(CallSite.class, Lookup.class, String.class, MethodType.class));
  }

  public static Handle kwargsHash() {
    return new Handle(
        Opcodes.H_INVOKESTATIC,
        p(Bootstrap.class),
        "kwargsHash",
        sig(CallSite.class, Lookup.class, String.class, MethodType.class));
  }

  public static Handle invokeSuper() {
    return SuperInvokeSite.BOOTSTRAP;
  }

  public static Handle ivar() {
    return new Handle(
        Opcodes.H_INVOKESTATIC,
        p(Bootstrap.class),
        "ivar",
        sig(CallSite.class, Lookup.class, String.class, MethodType.class));
  }

  public static Handle searchConst() {
    return new Handle(
        Opcodes.H_INVOKESTATIC,
        p(Bootstrap.class),
        "searchConst",
        sig(CallSite.class, Lookup.class, String.class, MethodType.class, int.class));
  }

  public static RubyString string(MutableCallSite site, ByteList value, ThreadContext context)
      throws Throwable {
    MethodHandle handle =
        SmartBinder.from(STRING_SIGNATURE)
            .invoke(NEW_STRING_SHARED_HANDLE.apply("byteList", value))
            .handle();

    site.setTarget(handle);

    return RubyString.newStringShared(context.runtime, value);
  }

  public static RubyString frozenString(MutableCallSite site, ByteList value, ThreadContext context)
      throws Throwable {
    RubyString frozen =
        context.runtime.freezeAndDedupString(RubyString.newStringShared(context.runtime, value));
    MethodHandle handle =
        Binder.from(RubyString.class, ThreadContext.class).dropAll().constant(frozen);

    site.setTarget(handle);

    return frozen;
  }

  private static final Signature STRING_SIGNATURE =
      Signature.from(RubyString.class, arrayOf(ThreadContext.class), "context");
  private static final Signature NEW_STRING_SHARED_SIGNATURE =
      Signature.from(
          RubyString.class, arrayOf(ThreadContext.class, ByteList.class), "context", "byteList");

  private static final SmartHandle NEW_STRING_SHARED_HANDLE =
      SmartBinder.from(NEW_STRING_SHARED_SIGNATURE)
          .invokeStaticQuiet(MethodHandles.lookup(), Bootstrap.class, "newStringShared");

  @JIT
  private static RubyString newStringShared(ThreadContext context, ByteList byteList) {
    return RubyString.newStringShared(context.runtime, byteList);
  }

  public static IRubyObject array(ThreadContext context, IRubyObject[] elts) {
    return RubyArray.newArrayNoCopy(context.runtime, elts);
  }

  public static Handle contextValue() {
    return new Handle(
        Opcodes.H_INVOKESTATIC,
        p(Bootstrap.class),
        "contextValue",
        sig(CallSite.class, Lookup.class, String.class, MethodType.class));
  }

  public static Handle contextValueString() {
    return new Handle(
        Opcodes.H_INVOKESTATIC,
        p(Bootstrap.class),
        "contextValueString",
        sig(CallSite.class, Lookup.class, String.class, MethodType.class, String.class));
  }

  public static CallSite contextValue(Lookup lookup, String name, MethodType type) {
    MutableCallSite site = new MutableCallSite(type);
    site.setTarget(Binder.from(type).append(site).invokeStaticQuiet(lookup, Bootstrap.class, name));
    return site;
  }

  public static CallSite contextValueString(
      Lookup lookup, String name, MethodType type, String str) {
    MutableCallSite site = new MutableCallSite(type);
    site.setTarget(
        Binder.from(type).append(site, str).invokeStaticQuiet(lookup, Bootstrap.class, name));
    return site;
  }

  public static IRubyObject nil(ThreadContext context, MutableCallSite site) {
    MethodHandle constant = (MethodHandle) ((RubyNil) context.nil).constant();
    if (constant == null)
      constant = (MethodHandle) OptoFactory.newConstantWrapper(IRubyObject.class, context.nil);

    site.setTarget(constant);

    return context.nil;
  }

  public static IRubyObject True(ThreadContext context, MutableCallSite site) {
    MethodHandle constant = (MethodHandle) context.runtime.getTrue().constant();
    if (constant == null)
      constant =
          (MethodHandle)
              OptoFactory.newConstantWrapper(IRubyObject.class, context.runtime.getTrue());

    site.setTarget(constant);

    return context.runtime.getTrue();
  }

  public static IRubyObject False(ThreadContext context, MutableCallSite site) {
    MethodHandle constant = (MethodHandle) context.runtime.getFalse().constant();
    if (constant == null)
      constant =
          (MethodHandle)
              OptoFactory.newConstantWrapper(IRubyObject.class, context.runtime.getFalse());

    site.setTarget(constant);

    return context.runtime.getFalse();
  }

  public static Ruby runtime(ThreadContext context, MutableCallSite site) {
    MethodHandle constant = (MethodHandle) context.runtime.constant();
    if (constant == null)
      constant = (MethodHandle) OptoFactory.newConstantWrapper(Ruby.class, context.runtime);

    site.setTarget(constant);

    return context.runtime;
  }

  public static RubyEncoding encoding(ThreadContext context, MutableCallSite site, String name) {
    RubyEncoding rubyEncoding = IRRuntimeHelpers.retrieveEncoding(context, name);

    MethodHandle constant = (MethodHandle) rubyEncoding.constant();
    if (constant == null)
      constant = (MethodHandle) OptoFactory.newConstantWrapper(RubyEncoding.class, rubyEncoding);

    site.setTarget(constant);

    return rubyEncoding;
  }

  public static IRubyObject hash(ThreadContext context, IRubyObject[] pairs) {
    Ruby runtime = context.runtime;
    RubyHash hash = RubyHash.newHash(runtime);
    for (int i = 0; i < pairs.length; ) {
      hash.fastASetCheckString(runtime, pairs[i++], pairs[i++]);
    }
    return hash;
  }

  public static IRubyObject kwargsHash(ThreadContext context, RubyHash hash, IRubyObject[] pairs) {
    return IRRuntimeHelpers.dupKwargsHashAndPopulateFromArray(context, hash, pairs);
  }

  static MethodHandle buildGenericHandle(
      InvokeSite site, DynamicMethod method, RubyClass dispatchClass) {
    SmartBinder binder;

    binder =
        SmartBinder.from(site.signature)
            .permute("context", "self", "arg.*", "block")
            .insert(
                2,
                new String[] {"rubyClass", "name"},
                new Class[] {RubyModule.class, String.class},
                dispatchClass,
                site.name())
            .insert(0, "method", DynamicMethod.class, method);

    if (site.arity > 3) {
      binder = binder.collect("args", "arg.*");
    }

    return binder.invokeVirtualQuiet(LOOKUP, "call").handle();
  }

  static MethodHandle buildJittedHandle(InvokeSite site, DynamicMethod method, boolean blockGiven) {
    MethodHandle mh = null;
    SmartBinder binder;
    CompiledIRMethod compiledIRMethod = null;

    if (method instanceof CompiledIRMethod) {
      compiledIRMethod = (CompiledIRMethod) method;
    } else if (method instanceof InterpretedIRMethod) {
      DynamicMethod actualMethod = ((InterpretedIRMethod) method).getActualMethod();
      if (actualMethod instanceof CompiledIRMethod) {
        compiledIRMethod = (CompiledIRMethod) actualMethod;
      }
    }

    if (compiledIRMethod != null) {
      // attempt IR direct binding
      // TODO: this will have to expand when we start specializing arities

      binder = SmartBinder.from(site.signature).permute("context", "self", "arg.*", "block");

      if (site.arity == -1) {
        // already [], nothing to do
        mh = (MethodHandle) compiledIRMethod.getHandle();
      } else if (site.arity == 0) {
        MethodHandle specific;
        if ((specific = compiledIRMethod.getHandleFor(site.arity)) != null) {
          mh = specific;
        } else {
          mh = (MethodHandle) compiledIRMethod.getHandle();
          binder = binder.insert(2, "args", IRubyObject.NULL_ARRAY);
        }
      } else {
        MethodHandle specific;
        if ((specific = compiledIRMethod.getHandleFor(site.arity)) != null) {
          mh = specific;
        } else {
          mh = (MethodHandle) compiledIRMethod.getHandle();
          binder = binder.collect("args", "arg.*");
        }
      }

      if (!blockGiven) {
        binder = binder.append("block", Block.class, Block.NULL_BLOCK);
      }

      binder =
          binder
              .insert(1, "scope", StaticScope.class, compiledIRMethod.getStaticScope())
              .append("class", RubyModule.class, compiledIRMethod.getImplementationClass());

      mh = binder.invoke(mh).handle();
    }

    return mh;
  }

  static MethodHandle buildNativeHandle(InvokeSite site, DynamicMethod method, boolean blockGiven) {
    MethodHandle mh = null;
    SmartBinder binder = null;

    if (method.getNativeCall() != null) {

      int nativeArgCount = getNativeArgCount(method, method.getNativeCall());

      DynamicMethod.NativeCall nc = method.getNativeCall();

      if (nc.isJava()) {
        // not supported yet, use DynamicMethod.call
      } else {
        if (nativeArgCount >= 0) { // native methods only support arity 3
          if (nativeArgCount == site.arity) {
            // nothing to do
            binder = SmartBinder.from(lookup(), site.signature);
          } else {
            // arity mismatch...leave null and use DynamicMethod.call below
          }
        } else {
          // varargs
          if (site.arity == -1) {
            // ok, already passing []
            binder = SmartBinder.from(lookup(), site.signature);
          } else if (site.arity == 0) {
            // no args, insert dummy
            binder =
                SmartBinder.from(lookup(), site.signature)
                    .insert(2, "args", IRubyObject.NULL_ARRAY);
          } else {
            // 1 or more args, collect into []
            binder = SmartBinder.from(lookup(), site.signature).collect("args", "arg.*");
          }
        }

        if (binder != null) {

          // clean up non-arguments, ordering, types
          if (!nc.hasContext()) {
            binder = binder.drop("context");
          }

          if (nc.hasBlock() && !blockGiven) {
            binder = binder.append("block", Block.NULL_BLOCK);
          } else if (!nc.hasBlock() && blockGiven) {
            binder = binder.drop("block");
          }

          if (nc.isStatic()) {
            mh =
                binder
                    .permute("context", "self", "arg.*", "block") // filter caller
                    .cast(nc.getNativeReturn(), nc.getNativeSignature())
                    .invokeStaticQuiet(LOOKUP, nc.getNativeTarget(), nc.getNativeName())
                    .handle();
          } else {
            mh =
                binder
                    .permute("self", "context", "arg.*", "block") // filter caller, move self
                    .castArg("self", nc.getNativeTarget())
                    .castVirtual(
                        nc.getNativeReturn(), nc.getNativeTarget(), nc.getNativeSignature())
                    .invokeVirtualQuiet(LOOKUP, nc.getNativeName())
                    .handle();
          }
        }
      }
    }

    return mh;
  }

  public static int getNativeArgCount(DynamicMethod method, DynamicMethod.NativeCall nativeCall) {
    // if non-Java, must:
    // * exactly match arities or both are [] boxed
    // * 3 or fewer arguments
    return getArgCount(nativeCall.getNativeSignature(), nativeCall.isStatic());
  }

  private static int getArgCount(Class[] args, boolean isStatic) {
    int length = args.length;
    boolean hasContext = false;
    if (isStatic) {
      if (args.length > 1 && args[0] == ThreadContext.class) {
        length--;
        hasContext = true;
      }

      // remove self object
      assert args.length >= 1;
      length--;

      if (args.length > 1 && args[args.length - 1] == Block.class) {
        length--;
      }

      if (length == 1) {
        if (hasContext && args[2] == IRubyObject[].class) {
          length = -1;
        } else if (args[1] == IRubyObject[].class) {
          length = -1;
        }
      }
    } else {
      if (args.length > 0 && args[0] == ThreadContext.class) {
        length--;
        hasContext = true;
      }

      if (args.length > 0 && args[args.length - 1] == Block.class) {
        length--;
      }

      if (length == 1) {
        if (hasContext && args[1] == IRubyObject[].class) {
          length = -1;
        } else if (args[0] == IRubyObject[].class) {
          length = -1;
        }
      }
    }
    return length;
  }

  public static IRubyObject ivarGet(VariableSite site, IRubyObject self) throws Throwable {
    RubyClass realClass = self.getMetaClass().getRealClass();
    VariableAccessor accessor = realClass.getVariableAccessorForRead(site.name());

    // produce nil if the variable has not been initialize
    MethodHandle nullToNil =
        findStatic(
            Helpers.class,
            "nullToNil",
            methodType(IRubyObject.class, IRubyObject.class, IRubyObject.class));
    nullToNil = insertArguments(nullToNil, 1, self.getRuntime().getNil());
    nullToNil = explicitCastArguments(nullToNil, methodType(IRubyObject.class, Object.class));

    // get variable value and filter with nullToNil
    MethodHandle getValue;
    boolean direct = false;

    if (accessor instanceof FieldVariableAccessor) {
      direct = true;
      int offset = ((FieldVariableAccessor) accessor).getOffset();
      Class cls = REIFIED_OBJECT_CLASSES[offset];
      getValue = lookup().findGetter(cls, "var" + offset, Object.class);
      getValue = explicitCastArguments(getValue, methodType(Object.class, IRubyObject.class));
    } else {
      getValue =
          findStatic(
              VariableAccessor.class,
              "getVariable",
              methodType(Object.class, RubyBasicObject.class, int.class));
      getValue =
          explicitCastArguments(getValue, methodType(Object.class, IRubyObject.class, int.class));
      getValue = insertArguments(getValue, 1, accessor.getIndex());
    }

    getValue = filterReturnValue(getValue, nullToNil);

    // prepare fallback
    MethodHandle fallback = null;
    if (site.chainCount() + 1 > Options.INVOKEDYNAMIC_MAXPOLY.load()) {
      if (Options.INVOKEDYNAMIC_LOG_BINDING.load())
        LOG.info(
            site.name()
                + "\tqet on type "
                + self.getMetaClass().id
                + " failed (polymorphic)"
                + extractSourceInfo(site));
      fallback =
          findStatic(
              Bootstrap.class,
              "ivarGetFail",
              methodType(IRubyObject.class, VariableSite.class, IRubyObject.class));
      fallback = fallback.bindTo(site);
      site.setTarget(fallback);
      return (IRubyObject) fallback.invokeWithArguments(self);
    } else {
      if (Options.INVOKEDYNAMIC_LOG_BINDING.load()) {
        if (direct) {
          LOG.info(
              site.name()
                  + "\tget field on type "
                  + self.getMetaClass().id
                  + " added to PIC"
                  + extractSourceInfo(site));
        } else {
          LOG.info(
              site.name()
                  + "\tget on type "
                  + self.getMetaClass().id
                  + " added to PIC"
                  + extractSourceInfo(site));
        }
      }
      fallback = site.getTarget();
      site.incrementChainCount();
    }

    // prepare test
    MethodHandle test =
        findStatic(
            InvocationLinker.class,
            "testRealClass",
            methodType(boolean.class, int.class, IRubyObject.class));
    test = insertArguments(test, 0, accessor.getClassId());

    getValue = guardWithTest(test, getValue, fallback);

    if (Options.INVOKEDYNAMIC_LOG_BINDING.load())
      LOG.info(
          site.name()
              + "\tget on class "
              + self.getMetaClass().id
              + " bound directly"
              + extractSourceInfo(site));
    site.setTarget(getValue);

    return (IRubyObject) getValue.invokeExact(self);
  }

  public static IRubyObject ivarGetFail(VariableSite site, IRubyObject self) throws Throwable {
    return site.getVariable(self);
  }

  public static void ivarSet(VariableSite site, IRubyObject self, IRubyObject value)
      throws Throwable {
    RubyClass realClass = self.getMetaClass().getRealClass();
    VariableAccessor accessor = realClass.getVariableAccessorForWrite(site.name());

    // set variable value and fold by returning value
    MethodHandle setValue;
    boolean direct = false;

    if (accessor instanceof FieldVariableAccessor) {
      direct = true;
      int offset = ((FieldVariableAccessor) accessor).getOffset();
      Class cls = REIFIED_OBJECT_CLASSES[offset];
      setValue = findStatic(cls, "setVariableChecked", methodType(void.class, cls, Object.class));
      setValue =
          explicitCastArguments(
              setValue, methodType(void.class, IRubyObject.class, IRubyObject.class));
    } else {
      setValue =
          findStatic(
              accessor.getClass(),
              "setVariableChecked",
              methodType(
                  void.class, RubyBasicObject.class, RubyClass.class, int.class, Object.class));
      setValue =
          explicitCastArguments(
              setValue,
              methodType(
                  void.class, IRubyObject.class, RubyClass.class, int.class, IRubyObject.class));
      setValue = insertArguments(setValue, 1, realClass, accessor.getIndex());
    }

    // prepare fallback
    MethodHandle fallback = null;
    if (site.chainCount() + 1 > Options.INVOKEDYNAMIC_MAXPOLY.load()) {
      if (Options.INVOKEDYNAMIC_LOG_BINDING.load())
        LOG.info(
            site.name()
                + "\tset on type "
                + self.getMetaClass().id
                + " failed (polymorphic)"
                + extractSourceInfo(site));
      fallback =
          findStatic(
              Bootstrap.class,
              "ivarSetFail",
              methodType(void.class, VariableSite.class, IRubyObject.class, IRubyObject.class));
      fallback = fallback.bindTo(site);
      site.setTarget(fallback);
      fallback.invokeExact(self, value);
    } else {
      if (Options.INVOKEDYNAMIC_LOG_BINDING.load()) {
        if (direct) {
          LOG.info(
              site.name()
                  + "\tset field on type "
                  + self.getMetaClass().id
                  + " added to PIC"
                  + extractSourceInfo(site));
        } else {
          LOG.info(
              site.name()
                  + "\tset on type "
                  + self.getMetaClass().id
                  + " added to PIC"
                  + extractSourceInfo(site));
        }
      }
      fallback = site.getTarget();
      site.incrementChainCount();
    }

    // prepare test
    MethodHandle test =
        findStatic(
            InvocationLinker.class,
            "testRealClass",
            methodType(boolean.class, int.class, IRubyObject.class));
    test = insertArguments(test, 0, accessor.getClassId());
    test = dropArguments(test, 1, IRubyObject.class);

    setValue = guardWithTest(test, setValue, fallback);

    if (Options.INVOKEDYNAMIC_LOG_BINDING.load())
      LOG.info(
          site.name()
              + "\tset on class "
              + self.getMetaClass().id
              + " bound directly"
              + extractSourceInfo(site));
    site.setTarget(setValue);

    setValue.invokeExact(self, value);
  }

  public static void ivarSetFail(VariableSite site, IRubyObject self, IRubyObject value)
      throws Throwable {
    site.setVariable(self, value);
  }

  private static MethodHandle findStatic(Class target, String name, MethodType type) {
    return findStatic(lookup(), target, name, type);
  }

  private static MethodHandle findStatic(
      Lookup lookup, Class target, String name, MethodType type) {
    try {
      return lookup.findStatic(target, name, type);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  public static boolean testType(RubyClass original, IRubyObject self) {
    // naive test
    return ((RubyBasicObject) self).getMetaClass() == original;
  }

  ///////////////////////////////////////////////////////////////////////////
  // constant lookup

  public static IRubyObject searchConst(
      ThreadContext context,
      StaticScope staticScope,
      MutableCallSite site,
      String constName,
      boolean noPrivateConsts)
      throws Throwable {

    // Lexical lookup
    Ruby runtime = context.getRuntime();
    RubyModule object = runtime.getObject();
    IRubyObject constant =
        (staticScope == null)
            ? object.getConstant(constName)
            : staticScope.getConstantInner(constName);

    // Inheritance lookup
    RubyModule module = null;
    if (constant == null) {
      // SSS FIXME: Is this null check case correct?
      module = staticScope == null ? object : staticScope.getModule();
      constant =
          noPrivateConsts
              ? module.getConstantFromNoConstMissing(constName, false)
              : module.getConstantNoConstMissing(constName);
    }

    // Call const_missing or cache
    if (constant == null) {
      return module.callMethod(context, "const_missing", context.runtime.fastNewSymbol(constName));
    }

    SwitchPoint switchPoint = (SwitchPoint) runtime.getConstantInvalidator(constName).getData();

    // bind constant until invalidated
    MethodHandle target = Binder.from(site.type()).drop(0, 2).constant(constant);
    MethodHandle fallback =
        Binder.from(site.type())
            .append(site, constName)
            .append(noPrivateConsts)
            .invokeStatic(LOOKUP, Bootstrap.class, "searchConst");

    site.setTarget(switchPoint.guardWithTest(target, fallback));

    return constant;
  }

  public static IRubyObject inheritanceSearchConst(
      ThreadContext context,
      IRubyObject cmVal,
      MutableCallSite site,
      String constName,
      boolean noPrivateConsts)
      throws Throwable {
    Ruby runtime = context.runtime;
    RubyModule module;

    if (cmVal instanceof RubyModule) {
      module = (RubyModule) cmVal;
    } else {
      throw runtime.newTypeError(cmVal + " is not a type/class");
    }

    IRubyObject constant =
        noPrivateConsts
            ? module.getConstantFromNoConstMissing(constName, false)
            : module.getConstantNoConstMissing(constName);

    if (constant == null) {
      constant = UndefinedValue.UNDEFINED;
    }

    SwitchPoint switchPoint = (SwitchPoint) runtime.getConstantInvalidator(constName).getData();

    // bind constant until invalidated
    MethodHandle target = Binder.from(site.type()).drop(0, 2).constant(constant);
    MethodHandle fallback =
        Binder.from(site.type())
            .append(site, constName)
            .append(noPrivateConsts)
            .invokeStatic(LOOKUP, Bootstrap.class, "inheritanceSearchConst");

    // test that module is same as before
    MethodHandle test =
        Binder.from(site.type().changeReturnType(boolean.class))
            .drop(0, 1)
            .insert(1, module.id)
            .invokeStaticQuiet(LOOKUP, Bootstrap.class, "testArg0ModuleMatch");
    target = guardWithTest(test, target, fallback);
    site.setTarget(switchPoint.guardWithTest(target, fallback));

    return constant;
  }

  public static IRubyObject lexicalSearchConst(
      ThreadContext context,
      StaticScope scope,
      MutableCallSite site,
      String constName,
      boolean noPrivateConsts)
      throws Throwable {
    Ruby runtime = context.runtime;

    IRubyObject constant = scope.getConstantInner(constName);

    if (constant == null) {
      constant = UndefinedValue.UNDEFINED;
    }

    SwitchPoint switchPoint = (SwitchPoint) runtime.getConstantInvalidator(constName).getData();

    // bind constant until invalidated
    MethodHandle target = Binder.from(site.type()).drop(0, 2).constant(constant);
    MethodHandle fallback =
        Binder.from(site.type())
            .append(site, constName)
            .append(noPrivateConsts)
            .invokeStatic(LOOKUP, Bootstrap.class, "lexicalSearchConst");

    site.setTarget(switchPoint.guardWithTest(target, fallback));

    return constant;
  }

  ///////////////////////////////////////////////////////////////////////////
  // Fixnum binding

  public static IRubyObject instVarNullToNil(IRubyObject value, IRubyObject nil, String name) {
    if (value == null) {
      Ruby runtime = nil.getRuntime();
      if (runtime.isVerbose()) {
        nil.getRuntime()
            .getWarnings()
            .warning(
                IRubyWarnings.ID.IVAR_NOT_INITIALIZED,
                "instance variable " + name + " not initialized");
      }
      return nil;
    }
    return value;
  }

  public static boolean testArg0ModuleMatch(IRubyObject arg0, int id) {
    return arg0 instanceof RubyModule && ((RubyModule) arg0).id == id;
  }

  private static String extractSourceInfo(VariableSite site) {
    return " (" + site.file() + ":" + site.line() + ")";
  }
}
Esempio n. 2
0
/** This file implements a seekable IO file. */
public class ChannelStream implements Stream, Finalizable {

  private static final Logger LOG = LoggerFactory.getLogger("ChannelStream");

  private static final boolean DEBUG = false;

  /**
   * The size of the read/write buffer allocated for this stream.
   *
   * <p>This size has been scaled back from its original 16k because although the larger buffer size
   * results in raw File.open times being rather slow (due to the cost of instantiating a relatively
   * large buffer). We should try to find a happy medium, or potentially pool buffers, or perhaps
   * even choose a value based on platform(??), but for now I am reducing it along with changes for
   * the "large read" patch from JRUBY-2657.
   */
  public static final int BUFSIZE = 4 * 1024;

  /**
   * The size at which a single read should turn into a chunkier bulk read. Currently, this size is
   * about 4x a normal buffer size.
   *
   * <p>This size was not really arrived at experimentally, and could potentially be increased.
   * However, it seems like a "good size" and we should probably only adjust it if it turns out we
   * would perform better with a larger buffer for large bulk reads.
   */
  private static final int BULK_READ_SIZE = 16 * 1024;

  private static final ByteBuffer EMPTY_BUFFER = ByteBuffer.allocate(0);

  /**
   * A cached EOFException. Since EOFException is only used by us internally, we create a single
   * instance to avoid stack trace generation. Comment out the initialization of this field to cause
   * a new one each time.
   */
  private static EOFException eofException = new EOFException();

  private volatile Ruby runtime;
  protected ModeFlags modes;
  protected boolean sync = false;

  protected volatile ByteBuffer buffer; // r/w buffer
  protected boolean reading; // are we reading or writing?
  private ChannelDescriptor descriptor;
  private boolean blocking = true;
  protected int ungotc = -1;
  private volatile boolean closedExplicitly = false;

  private volatile boolean eof = false;
  private volatile boolean autoclose = true;

  private ChannelStream(Ruby runtime, ChannelDescriptor descriptor, boolean autoclose) {
    this.runtime = runtime;
    this.descriptor = descriptor;
    this.modes = descriptor.getOriginalModes();
    buffer = ByteBuffer.allocate(BUFSIZE);
    buffer.flip();
    this.reading = true;
    this.autoclose = autoclose;
    runtime.addInternalFinalizer(this);
  }

  private ChannelStream(
      Ruby runtime, ChannelDescriptor descriptor, ModeFlags modes, boolean autoclose) {
    this(runtime, descriptor, autoclose);
    this.modes = modes;
  }

  public Ruby getRuntime() {
    return runtime;
  }

  public void checkReadable() throws IOException {
    if (!modes.isReadable()) throw new IOException("not opened for reading");
  }

  public void checkWritable() throws IOException {
    if (!modes.isWritable()) throw new IOException("not opened for writing");
  }

  public void checkPermissionsSubsetOf(ModeFlags subsetModes) {
    subsetModes.isSubsetOf(modes);
  }

  public ModeFlags getModes() {
    return modes;
  }

  public boolean isSync() {
    return sync;
  }

  public void setSync(boolean sync) {
    this.sync = sync;
  }

  public void setBinmode() {
    // No-op here, no binmode handling needed.
  }

  public boolean isBinmode() {
    return false;
  }

  public boolean isAutoclose() {
    return autoclose;
  }

  public void setAutoclose(boolean autoclose) {
    this.autoclose = autoclose;
  }

  /**
   * Implement IO#wait as per io/wait in MRI. waits until input available or timed out and returns
   * self, or nil when EOF reached.
   *
   * <p>The default implementation loops while ready returns 0.
   */
  public void waitUntilReady() throws IOException, InterruptedException {
    while (ready() == 0) {
      Thread.sleep(10);
    }
  }

  public boolean readDataBuffered() {
    return reading && (ungotc != -1 || buffer.hasRemaining());
  }

  public boolean writeDataBuffered() {
    return !reading && buffer.position() > 0;
  }

  private final int refillBuffer() throws IOException {
    buffer.clear();
    int n = ((ReadableByteChannel) descriptor.getChannel()).read(buffer);
    buffer.flip();
    return n;
  }

  public synchronized ByteList fgets(ByteList separatorString)
      throws IOException, BadDescriptorException {
    checkReadable();
    ensureRead();

    if (separatorString == null) {
      return readall();
    }

    final ByteList separator =
        (separatorString == PARAGRAPH_DELIMETER) ? PARAGRAPH_SEPARATOR : separatorString;

    descriptor.checkOpen();

    if (feof()) {
      return null;
    }

    int c = read();

    if (c == -1) {
      return null;
    }

    // unread back
    buffer.position(buffer.position() - 1);

    ByteList buf = new ByteList(40);

    byte first = separator.getUnsafeBytes()[separator.getBegin()];

    LineLoop:
    while (true) {
      ReadLoop:
      while (true) {
        byte[] bytes = buffer.array();
        int offset = buffer.position();
        int max = buffer.limit();

        // iterate over remainder of buffer until we find a match
        for (int i = offset; i < max; i++) {
          c = bytes[i];
          if (c == first) {
            // terminate and advance buffer when we find our char
            buf.append(bytes, offset, i - offset);
            if (i >= max) {
              buffer.clear();
            } else {
              buffer.position(i + 1);
            }
            break ReadLoop;
          }
        }

        // no match, append remainder of buffer and continue with next block
        buf.append(bytes, offset, buffer.remaining());
        int read = refillBuffer();
        if (read == -1) break LineLoop;
      }

      // found a match above, check if remaining separator characters match, appending as we go
      for (int i = 0; i < separator.getRealSize(); i++) {
        if (c == -1) {
          break LineLoop;
        } else if (c != separator.getUnsafeBytes()[separator.getBegin() + i]) {
          buf.append(c);
          continue LineLoop;
        }
        buf.append(c);
        if (i < separator.getRealSize() - 1) {
          c = read();
        }
      }
      break;
    }

    if (separatorString == PARAGRAPH_DELIMETER) {
      while (c == separator.getUnsafeBytes()[separator.getBegin()]) {
        c = read();
      }
      ungetc(c);
    }

    return buf;
  }

  public synchronized int getline(ByteList dst, byte terminator)
      throws IOException, BadDescriptorException {
    checkReadable();
    ensureRead();
    descriptor.checkOpen();

    int totalRead = 0;
    boolean found = false;
    if (ungotc != -1) {
      dst.append((byte) ungotc);
      found = ungotc == terminator;
      ungotc = -1;
      ++totalRead;
    }
    while (!found) {
      final byte[] bytes = buffer.array();
      final int begin = buffer.arrayOffset() + buffer.position();
      final int end = begin + buffer.remaining();
      int len = 0;
      for (int i = begin; i < end && !found; ++i) {
        found = bytes[i] == terminator;
        ++len;
      }
      if (len > 0) {
        dst.append(buffer, len);
        totalRead += len;
      }
      if (!found) {
        int n = refillBuffer();
        if (n <= 0) {
          if (n < 0 && totalRead < 1) {
            return -1;
          }
          break;
        }
      }
    }
    return totalRead;
  }

  public synchronized int getline(ByteList dst, byte terminator, long limit)
      throws IOException, BadDescriptorException {
    checkReadable();
    ensureRead();
    descriptor.checkOpen();

    int totalRead = 0;
    boolean found = false;
    if (ungotc != -1) {
      dst.append((byte) ungotc);
      found = ungotc == terminator;
      ungotc = -1;
      limit--;
      ++totalRead;
    }
    while (!found) {
      final byte[] bytes = buffer.array();
      final int begin = buffer.arrayOffset() + buffer.position();
      final int end = begin + buffer.remaining();
      int len = 0;
      for (int i = begin; i < end && limit-- > 0 && !found; ++i) {
        found = bytes[i] == terminator;
        ++len;
      }
      if (limit < 1) found = true;

      if (len > 0) {
        dst.append(buffer, len);
        totalRead += len;
      }
      if (!found) {
        int n = refillBuffer();
        if (n <= 0) {
          if (n < 0 && totalRead < 1) {
            return -1;
          }
          break;
        }
      }
    }
    return totalRead;
  }

  /**
   * @deprecated readall do busy loop for the IO which has NONBLOCK bit. You should implement the
   *     logic by yourself with fread().
   */
  @Deprecated
  public synchronized ByteList readall() throws IOException, BadDescriptorException {
    final long fileSize =
        descriptor.isSeekable() && descriptor.getChannel() instanceof FileChannel
            ? ((FileChannel) descriptor.getChannel()).size()
            : 0;
    //
    // Check file size - special files in /proc have zero size and need to be
    // handled by the generic read path.
    //
    if (fileSize > 0) {
      ensureRead();

      FileChannel channel = (FileChannel) descriptor.getChannel();
      final long left = fileSize - channel.position() + bufferedInputBytesRemaining();
      if (left <= 0) {
        eof = true;
        return null;
      }

      if (left > Integer.MAX_VALUE) {
        if (getRuntime() != null) {
          throw getRuntime().newIOError("File too large");
        } else {
          throw new IOException("File too large");
        }
      }

      ByteList result = new ByteList((int) left);
      ByteBuffer buf = ByteBuffer.wrap(result.getUnsafeBytes(), result.begin(), (int) left);

      //
      // Copy any buffered data (including ungetc byte)
      //
      copyBufferedBytes(buf);

      //
      // Now read unbuffered directly from the file
      //
      while (buf.hasRemaining()) {
        final int MAX_READ_CHUNK = 1 * 1024 * 1024;
        //
        // When reading into a heap buffer, the jvm allocates a temporary
        // direct ByteBuffer of the requested size.  To avoid allocating
        // a huge direct buffer when doing ludicrous reads (e.g. 1G or more)
        // we split the read up into chunks of no more than 1M
        //
        ByteBuffer tmp = buf.duplicate();
        if (tmp.remaining() > MAX_READ_CHUNK) {
          tmp.limit(tmp.position() + MAX_READ_CHUNK);
        }
        int n = channel.read(tmp);
        if (n <= 0) {
          break;
        }
        buf.position(tmp.position());
      }
      eof = true;
      result.length(buf.position());
      return result;
    } else if (descriptor.isNull()) {
      return new ByteList(0);
    } else {
      checkReadable();

      ByteList byteList = new ByteList();
      ByteList read = fread(BUFSIZE);

      if (read == null) {
        eof = true;
        return byteList;
      }

      while (read != null) {
        byteList.append(read);
        read = fread(BUFSIZE);
      }

      return byteList;
    }
  }

  /**
   * Copies bytes from the channel buffer into a destination <tt>ByteBuffer</tt>
   *
   * @param dst A <tt>ByteBuffer</tt> to place the data in.
   * @return The number of bytes copied.
   */
  private final int copyBufferedBytes(ByteBuffer dst) {
    final int bytesToCopy = dst.remaining();

    if (ungotc != -1 && dst.hasRemaining()) {
      dst.put((byte) ungotc);
      ungotc = -1;
    }

    if (buffer.hasRemaining() && dst.hasRemaining()) {

      if (dst.remaining() >= buffer.remaining()) {
        //
        // Copy out any buffered bytes
        //
        dst.put(buffer);

      } else {
        //
        // Need to clamp source (buffer) size to avoid overrun
        //
        ByteBuffer tmp = buffer.duplicate();
        tmp.limit(tmp.position() + dst.remaining());
        dst.put(tmp);
        buffer.position(tmp.position());
      }
    }

    return bytesToCopy - dst.remaining();
  }

  /**
   * Copies bytes from the channel buffer into a destination <tt>ByteBuffer</tt>
   *
   * @param dst A <tt>ByteBuffer</tt> to place the data in.
   * @return The number of bytes copied.
   */
  private final int copyBufferedBytes(byte[] dst, int off, int len) {
    int bytesCopied = 0;

    if (ungotc != -1 && len > 0) {
      dst[off++] = (byte) ungotc;
      ungotc = -1;
      ++bytesCopied;
    }

    final int n = Math.min(len - bytesCopied, buffer.remaining());
    buffer.get(dst, off, n);
    bytesCopied += n;

    return bytesCopied;
  }

  /**
   * Copies bytes from the channel buffer into a destination <tt>ByteBuffer</tt>
   *
   * @param dst A <tt>ByteList</tt> to place the data in.
   * @param len The maximum number of bytes to copy.
   * @return The number of bytes copied.
   */
  private final int copyBufferedBytes(ByteList dst, int len) {
    int bytesCopied = 0;

    dst.ensure(Math.min(len, bufferedInputBytesRemaining()));

    if (bytesCopied < len && ungotc != -1) {
      ++bytesCopied;
      dst.append((byte) ungotc);
      ungotc = -1;
    }

    //
    // Copy out any buffered bytes
    //
    if (bytesCopied < len && buffer.hasRemaining()) {
      int n = Math.min(buffer.remaining(), len - bytesCopied);
      dst.append(buffer, n);
      bytesCopied += n;
    }

    return bytesCopied;
  }

  /**
   * Returns a count of how many bytes are available in the read buffer
   *
   * @return The number of bytes that can be read without reading the underlying stream.
   */
  private final int bufferedInputBytesRemaining() {
    return reading ? (buffer.remaining() + (ungotc != -1 ? 1 : 0)) : 0;
  }

  /**
   * Tests if there are bytes remaining in the read buffer.
   *
   * @return <tt>true</tt> if there are bytes available in the read buffer.
   */
  private final boolean hasBufferedInputBytes() {
    return reading && (buffer.hasRemaining() || ungotc != -1);
  }

  /**
   * Returns a count of how many bytes of space is available in the write buffer.
   *
   * @return The number of bytes that can be written to the buffer without flushing to the
   *     underlying stream.
   */
  private final int bufferedOutputSpaceRemaining() {
    return !reading ? buffer.remaining() : 0;
  }

  /**
   * Tests if there is space available in the write buffer.
   *
   * @return <tt>true</tt> if there are bytes available in the write buffer.
   */
  private final boolean hasBufferedOutputSpace() {
    return !reading && buffer.hasRemaining();
  }

  /**
   * Closes IO handler resources.
   *
   * @throws IOException
   * @throws BadDescriptorException
   */
  public void fclose() throws IOException, BadDescriptorException {
    try {
      synchronized (this) {
        closedExplicitly = true;
        close(); // not closing from finalize
      }
    } finally {
      Ruby localRuntime = getRuntime();

      // Make sure we remove finalizers while not holding self lock,
      // otherwise there is a possibility for a deadlock!
      if (localRuntime != null) localRuntime.removeInternalFinalizer(this);

      // clear runtime so it doesn't get stuck in memory (JRUBY-2933)
      runtime = null;
    }
  }

  /**
   * Internal close.
   *
   * @throws IOException
   * @throws BadDescriptorException
   */
  private void close() throws IOException, BadDescriptorException {
    // finish and close ourselves
    finish(true);
  }

  private void finish(boolean close) throws BadDescriptorException, IOException {
    try {
      flushWrite();

      if (DEBUG) LOG.info("Descriptor for fileno {} closed by stream", descriptor.getFileno());
    } finally {
      buffer = EMPTY_BUFFER;

      // clear runtime so it doesn't get stuck in memory (JRUBY-2933)
      runtime = null;

      // finish descriptor
      descriptor.finish(close);
    }
  }

  /**
   * @throws IOException
   * @throws BadDescriptorException
   */
  public synchronized int fflush() throws IOException, BadDescriptorException {
    checkWritable();
    try {
      flushWrite();
    } catch (EOFException eofe) {
      return -1;
    }
    return 0;
  }

  /**
   * Flush the write buffer to the channel (if needed)
   *
   * @throws IOException
   */
  private void flushWrite() throws IOException, BadDescriptorException {
    if (reading || !modes.isWritable() || buffer.position() == 0) return; // Don't bother

    int len = buffer.position();
    buffer.flip();
    int n = descriptor.write(buffer);

    if (n != len) {
      // TODO: check the return value here
    }
    buffer.clear();
  }

  /**
   * Flush the write buffer to the channel (if needed)
   *
   * @throws IOException
   */
  private boolean flushWrite(final boolean block) throws IOException, BadDescriptorException {
    if (reading || !modes.isWritable() || buffer.position() == 0) return false; // Don't bother
    int len = buffer.position();
    int nWritten = 0;
    buffer.flip();

    // For Sockets, only write as much as will fit.
    if (descriptor.getChannel() instanceof SelectableChannel) {
      SelectableChannel selectableChannel = (SelectableChannel) descriptor.getChannel();
      synchronized (selectableChannel.blockingLock()) {
        boolean oldBlocking = selectableChannel.isBlocking();
        try {
          if (oldBlocking != block) {
            selectableChannel.configureBlocking(block);
          }
          nWritten = descriptor.write(buffer);
        } finally {
          if (oldBlocking != block) {
            selectableChannel.configureBlocking(oldBlocking);
          }
        }
      }
    } else {
      nWritten = descriptor.write(buffer);
    }
    if (nWritten != len) {
      buffer.compact();
      return false;
    }
    buffer.clear();
    return true;
  }

  public InputStream newInputStream() {
    InputStream in = descriptor.getBaseInputStream();
    return in == null ? new InputStreamAdapter(this) : in;
  }

  public OutputStream newOutputStream() {
    return new OutputStreamAdapter(this);
  }

  public void clearerr() {
    eof = false;
  }

  /**
   * @throws IOException
   * @throws BadDescriptorException
   */
  public boolean feof() throws IOException, BadDescriptorException {
    checkReadable();

    if (eof) {
      return true;
    } else {
      return false;
    }
  }

  /** @throws IOException */
  public synchronized long fgetpos()
      throws IOException, PipeException, InvalidValueException, BadDescriptorException {
    // Correct position for read / write buffering (we could invalidate, but expensive)
    if (descriptor.isSeekable()) {
      FileChannel fileChannel = (FileChannel) descriptor.getChannel();
      long pos = fileChannel.position();
      // Adjust for buffered data
      if (reading) {
        pos -= buffer.remaining();
        return pos - (pos > 0 && ungotc != -1 ? 1 : 0);
      } else {
        return pos + buffer.position();
      }
    } else if (descriptor.isNull()) {
      return 0;
    } else {
      throw new PipeException();
    }
  }

  /**
   * Implementation of libc "lseek", which seeks on seekable streams, raises EPIPE if the fd is
   * assocated with a pipe, socket, or FIFO, and doesn't do anything for other cases (like stdio).
   *
   * @throws IOException
   * @throws InvalidValueException
   */
  public synchronized void lseek(long offset, int type)
      throws IOException, InvalidValueException, PipeException, BadDescriptorException {
    if (descriptor.isSeekable()) {
      FileChannel fileChannel = (FileChannel) descriptor.getChannel();
      ungotc = -1;
      int adj = 0;
      if (reading) {
        // for SEEK_CUR, need to adjust for buffered data
        adj = buffer.remaining();
        buffer.clear();
        buffer.flip();
      } else {
        flushWrite();
      }
      try {
        switch (type) {
          case SEEK_SET:
            fileChannel.position(offset);
            break;
          case SEEK_CUR:
            fileChannel.position(fileChannel.position() - adj + offset);
            break;
          case SEEK_END:
            fileChannel.position(fileChannel.size() + offset);
            break;
        }
      } catch (IllegalArgumentException e) {
        throw new InvalidValueException();
      } catch (IOException ioe) {
        throw ioe;
      }
    } else if (descriptor.getChannel() instanceof SelectableChannel) {
      // TODO: It's perhaps just a coincidence that all the channels for
      // which we should raise are instanceof SelectableChannel, since
      // stdio is not...so this bothers me slightly. -CON
      throw new PipeException();
    } else {
    }
  }

  public synchronized void sync() throws IOException, BadDescriptorException {
    flushWrite();
  }

  /**
   * Ensure buffer is ready for reading, flushing remaining writes if required
   *
   * @throws IOException
   */
  private void ensureRead() throws IOException, BadDescriptorException {
    if (reading) return;
    flushWrite();
    buffer.clear();
    buffer.flip();
    reading = true;
  }

  /**
   * Ensure buffer is ready for reading, flushing remaining writes if required
   *
   * @throws IOException
   */
  private void ensureReadNonBuffered() throws IOException, BadDescriptorException {
    if (reading) {
      if (buffer.hasRemaining()) {
        Ruby localRuntime = getRuntime();
        if (localRuntime != null) {
          throw localRuntime.newIOError("sysread for buffered IO");
        } else {
          throw new IOException("sysread for buffered IO");
        }
      }
    } else {
      // libc flushes writes on any read from the actual file, so we flush here
      flushWrite();
      buffer.clear();
      buffer.flip();
      reading = true;
    }
  }

  private void resetForWrite() throws IOException {
    if (descriptor.isSeekable()) {
      FileChannel fileChannel = (FileChannel) descriptor.getChannel();
      if (buffer.hasRemaining()) { // we have read ahead, and need to back up
        fileChannel.position(fileChannel.position() - buffer.remaining());
      }
    }
    // FIXME: Clearing read buffer here...is this appropriate?
    buffer.clear();
    reading = false;
  }

  /**
   * Ensure buffer is ready for writing.
   *
   * @throws IOException
   */
  private void ensureWrite() throws IOException {
    if (!reading) return;
    resetForWrite();
  }

  public synchronized ByteList read(int number) throws IOException, BadDescriptorException {
    checkReadable();
    ensureReadNonBuffered();

    ByteList byteList = new ByteList(number);

    // TODO this should entry into error handling somewhere
    int bytesRead = descriptor.read(number, byteList);

    if (bytesRead == -1) {
      eof = true;
    }

    return byteList;
  }

  private ByteList bufferedRead(int number) throws IOException, BadDescriptorException {
    checkReadable();
    ensureRead();

    int resultSize = 0;

    // 128K seems to be the minimum at which the stat+seek is faster than reallocation
    final int BULK_THRESHOLD = 128 * 1024;
    if (number >= BULK_THRESHOLD
        && descriptor.isSeekable()
        && descriptor.getChannel() instanceof FileChannel) {
      //
      // If it is a file channel, then we can pre-allocate the output buffer
      // to the total size of buffered + remaining bytes in file
      //
      FileChannel fileChannel = (FileChannel) descriptor.getChannel();
      resultSize =
          (int)
              Math.min(
                  fileChannel.size() - fileChannel.position() + bufferedInputBytesRemaining(),
                  number);
    } else {
      //
      // Cannot discern the total read length - allocate at least enough for the buffered data
      //
      resultSize = Math.min(bufferedInputBytesRemaining(), number);
    }

    ByteList result = new ByteList(resultSize);
    bufferedRead(result, number);
    return result;
  }

  private int bufferedRead(ByteList dst, int number) throws IOException, BadDescriptorException {

    int bytesRead = 0;

    //
    // Copy what is in the buffer, if there is some buffered data
    //
    bytesRead += copyBufferedBytes(dst, number);

    boolean done = false;
    //
    // Avoid double-copying for reads that are larger than the buffer size
    //
    while ((number - bytesRead) >= BUFSIZE) {
      //
      // limit each iteration to a max of BULK_READ_SIZE to avoid over-size allocations
      //
      final int bytesToRead = Math.min(BULK_READ_SIZE, number - bytesRead);
      final int n = descriptor.read(bytesToRead, dst);
      if (n == -1) {
        eof = true;
        done = true;
        break;
      } else if (n == 0) {
        done = true;
        break;
      }
      bytesRead += n;
    }

    //
    // Complete the request by filling the read buffer first
    //
    while (!done && bytesRead < number) {
      int read = refillBuffer();

      if (read == -1) {
        eof = true;
        break;
      } else if (read == 0) {
        break;
      }

      // append what we read into our buffer and allow the loop to continue
      final int len = Math.min(buffer.remaining(), number - bytesRead);
      dst.append(buffer, len);
      bytesRead += len;
    }

    if (bytesRead == 0 && number != 0) {
      if (eof) {
        throw newEOFException();
      }
    }

    return bytesRead;
  }

  private EOFException newEOFException() {
    if (eofException != null) {
      return eofException;
    } else {
      return new EOFException();
    }
  }

  private int bufferedRead(ByteBuffer dst, boolean partial)
      throws IOException, BadDescriptorException {
    checkReadable();
    ensureRead();

    boolean done = false;
    int bytesRead = 0;

    //
    // Copy what is in the buffer, if there is some buffered data
    //
    bytesRead += copyBufferedBytes(dst);

    //
    // Avoid double-copying for reads that are larger than the buffer size, or
    // the destination is a direct buffer.
    //
    while ((bytesRead < 1 || !partial) && (dst.remaining() >= BUFSIZE || dst.isDirect())) {
      ByteBuffer tmpDst = dst;
      if (!dst.isDirect()) {
        //
        // We limit reads to BULK_READ_SIZED chunks to avoid NIO allocating
        // a huge temporary native buffer, when doing reads into a heap buffer
        // If the dst buffer is direct, then no need to limit.
        //
        int bytesToRead = Math.min(BULK_READ_SIZE, dst.remaining());
        if (bytesToRead < dst.remaining()) {
          tmpDst = dst.duplicate();
          tmpDst.limit(tmpDst.position() + bytesToRead);
        }
      }
      int n = descriptor.read(tmpDst);
      if (n == -1) {
        eof = true;
        done = true;
        break;
      } else if (n == 0) {
        done = true;
        break;
      } else {
        bytesRead += n;
      }
    }

    //
    // Complete the request by filling the read buffer first
    //
    while (!done && dst.hasRemaining() && (bytesRead < 1 || !partial)) {
      int read = refillBuffer();

      if (read == -1) {
        eof = true;
        done = true;
        break;
      } else if (read == 0) {
        done = true;
        break;
      } else {
        // append what we read into our buffer and allow the loop to continue
        bytesRead += copyBufferedBytes(dst);
      }
    }

    if (eof && bytesRead == 0 && dst.remaining() != 0) {
      throw newEOFException();
    }

    return bytesRead;
  }

  private int bufferedRead() throws IOException, BadDescriptorException {
    ensureRead();

    if (!buffer.hasRemaining()) {
      int len = refillBuffer();
      if (len == -1) {
        eof = true;
        return -1;
      } else if (len == 0) {
        return -1;
      }
    }
    return buffer.get() & 0xFF;
  }

  /**
   * @throws IOException
   * @throws BadDescriptorException
   */
  private int bufferedWrite(ByteList buf) throws IOException, BadDescriptorException {
    checkWritable();
    ensureWrite();

    // Ruby ignores empty syswrites
    if (buf == null || buf.length() == 0) return 0;

    if (buf.length() > buffer.capacity()) { // Doesn't fit in buffer. Write immediately.
      flushWrite(); // ensure nothing left to write

      int n = descriptor.write(ByteBuffer.wrap(buf.getUnsafeBytes(), buf.begin(), buf.length()));
      if (n != buf.length()) {
        // TODO: check the return value here
      }
    } else {
      if (buf.length() > buffer.remaining()) flushWrite();

      buffer.put(buf.getUnsafeBytes(), buf.begin(), buf.length());
    }

    if (isSync()) flushWrite();

    return buf.getRealSize();
  }

  /**
   * @throws IOException
   * @throws BadDescriptorException
   */
  private int bufferedWrite(ByteBuffer buf) throws IOException, BadDescriptorException {
    checkWritable();
    ensureWrite();

    // Ruby ignores empty syswrites
    if (buf == null || !buf.hasRemaining()) return 0;

    final int nbytes = buf.remaining();
    if (nbytes >= buffer.capacity()) { // Doesn't fit in buffer. Write immediately.
      flushWrite(); // ensure nothing left to write

      descriptor.write(buf);
      // TODO: check the return value here
    } else {
      if (nbytes > buffer.remaining()) flushWrite();

      buffer.put(buf);
    }

    if (isSync()) flushWrite();

    return nbytes - buf.remaining();
  }

  /**
   * @throws IOException
   * @throws BadDescriptorException
   */
  private int bufferedWrite(int c) throws IOException, BadDescriptorException {
    checkWritable();
    ensureWrite();

    if (!buffer.hasRemaining()) flushWrite();

    buffer.put((byte) c);

    if (isSync()) flushWrite();

    return 1;
  }

  public synchronized void ftruncate(long newLength)
      throws IOException, BadDescriptorException, InvalidValueException {
    Channel ch = descriptor.getChannel();
    if (!(ch instanceof FileChannel)) {
      throw new InvalidValueException();
    }
    invalidateBuffer();
    FileChannel fileChannel = (FileChannel) ch;
    long position = fileChannel.position();
    if (newLength > fileChannel.size()) {
      // truncate can't lengthen files, so we save position, seek/write, and go back
      int difference = (int) (newLength - fileChannel.size());

      fileChannel.position(fileChannel.size());
      // FIXME: This worries me a bit, since it could allocate a lot with a large newLength
      fileChannel.write(ByteBuffer.allocate(difference));
    } else {
      fileChannel.truncate(newLength);
    }
    fileChannel.position(position);
  }

  /**
   * Invalidate buffer before a position change has occurred (e.g. seek), flushing writes if
   * required, and correcting file position if reading
   *
   * @throws IOException
   */
  private void invalidateBuffer() throws IOException, BadDescriptorException {
    if (!reading) flushWrite();
    int posOverrun = buffer.remaining(); // how far ahead we are when reading
    buffer.clear();
    if (reading) {
      buffer.flip();
      // if the read buffer is ahead, back up
      FileChannel fileChannel = (FileChannel) descriptor.getChannel();
      if (posOverrun != 0) fileChannel.position(fileChannel.position() - posOverrun);
    }
  }

  /** Ensure close (especially flush) when we're finished with. */
  @Override
  public void finalize() throws Throwable {
    super.finalize();

    if (closedExplicitly) return;

    if (DEBUG) {
      LOG.info("finalize() for not explicitly closed stream");
    }

    // FIXME: I got a bunch of NPEs when I didn't check for nulls here...HOW?!
    if (descriptor != null && descriptor.isOpen()) {
      // tidy up
      finish(autoclose);
    }
  }

  public int ready() throws IOException {
    if (descriptor.getChannel() instanceof SelectableChannel) {
      int ready_stat = 0;
      java.nio.channels.Selector sel =
          SelectorFactory.openWithRetryFrom(
              null, ((SelectableChannel) descriptor.getChannel()).provider());
      SelectableChannel selchan = (SelectableChannel) descriptor.getChannel();
      synchronized (selchan.blockingLock()) {
        boolean is_block = selchan.isBlocking();
        try {
          selchan.configureBlocking(false);
          selchan.register(sel, java.nio.channels.SelectionKey.OP_READ);
          ready_stat = sel.selectNow();
          sel.close();
        } catch (Throwable ex) {
        } finally {
          if (sel != null) {
            try {
              sel.close();
            } catch (Exception e) {
            }
          }
          selchan.configureBlocking(is_block);
        }
      }
      return ready_stat;
    } else {
      return newInputStream().available();
    }
  }

  public synchronized void fputc(int c) throws IOException, BadDescriptorException {
    bufferedWrite(c);
  }

  public int ungetc(int c) {
    if (c == -1) {
      return -1;
    }

    // putting a bit back, so we're not at EOF anymore
    eof = false;

    // save the ungot
    ungotc = c;

    return c;
  }

  public synchronized int fgetc() throws IOException, BadDescriptorException {
    if (eof) {
      return -1;
    }

    checkReadable();

    int c = read();

    if (c == -1) {
      eof = true;
      return c;
    }

    return c & 0xff;
  }

  public synchronized int fwrite(ByteList string) throws IOException, BadDescriptorException {
    return bufferedWrite(string);
  }

  public synchronized int write(ByteBuffer buf) throws IOException, BadDescriptorException {
    return bufferedWrite(buf);
  }

  public synchronized int writenonblock(ByteList buf) throws IOException, BadDescriptorException {
    checkWritable();
    ensureWrite();

    // Ruby ignores empty syswrites
    if (buf == null || buf.length() == 0) return 0;

    if (buffer.position() != 0 && !flushWrite(false)) return 0;

    if (descriptor.getChannel() instanceof SelectableChannel) {
      SelectableChannel selectableChannel = (SelectableChannel) descriptor.getChannel();
      synchronized (selectableChannel.blockingLock()) {
        boolean oldBlocking = selectableChannel.isBlocking();
        try {
          if (oldBlocking) {
            selectableChannel.configureBlocking(false);
          }
          return descriptor.write(ByteBuffer.wrap(buf.getUnsafeBytes(), buf.begin(), buf.length()));
        } finally {
          if (oldBlocking) {
            selectableChannel.configureBlocking(oldBlocking);
          }
        }
      }
    } else {
      // can't set nonblocking, so go ahead with it...not much else we can do
      return descriptor.write(ByteBuffer.wrap(buf.getUnsafeBytes(), buf.begin(), buf.length()));
    }
  }

  public synchronized ByteList fread(int number) throws IOException, BadDescriptorException {
    try {
      if (number == 0) {
        if (eof) {
          return null;
        } else {
          return new ByteList(0);
        }
      }

      return bufferedRead(number);
    } catch (EOFException e) {
      eof = true;
      return null;
    }
  }

  public synchronized ByteList readnonblock(int number)
      throws IOException, BadDescriptorException, EOFException {
    assert number >= 0;

    if (number == 0) {
      return null;
    }

    if (descriptor.getChannel() instanceof SelectableChannel) {
      SelectableChannel selectableChannel = (SelectableChannel) descriptor.getChannel();
      synchronized (selectableChannel.blockingLock()) {
        boolean oldBlocking = selectableChannel.isBlocking();
        try {
          selectableChannel.configureBlocking(false);
          return readpartial(number);
        } finally {
          selectableChannel.configureBlocking(oldBlocking);
        }
      }
    } else if (descriptor.getChannel() instanceof FileChannel) {
      return fread(number);
    } else {
      return null;
    }
  }

  public synchronized ByteList readpartial(int number)
      throws IOException, BadDescriptorException, EOFException {
    assert number >= 0;

    if (number == 0) {
      return null;
    }
    if (descriptor.getChannel() instanceof FileChannel) {
      return fread(number);
    }

    if (hasBufferedInputBytes()) {
      // already have some bytes buffered, just return those
      return bufferedRead(Math.min(bufferedInputBytesRemaining(), number));
    } else {
      // otherwise, we try an unbuffered read to get whatever's available
      return read(number);
    }
  }

  public synchronized int read(ByteBuffer dst)
      throws IOException, BadDescriptorException, EOFException {
    return read(dst, !(descriptor.getChannel() instanceof FileChannel));
  }

  public synchronized int read(ByteBuffer dst, boolean partial)
      throws IOException, BadDescriptorException, EOFException {
    assert dst.hasRemaining();

    return bufferedRead(dst, partial);
  }

  public synchronized int read() throws IOException, BadDescriptorException {
    try {
      descriptor.checkOpen();

      if (ungotc >= 0) {
        int c = ungotc;
        ungotc = -1;
        return c;
      }

      return bufferedRead();
    } catch (EOFException e) {
      eof = true;
      return -1;
    }
  }

  public ChannelDescriptor getDescriptor() {
    return descriptor;
  }

  public void setBlocking(boolean block) throws IOException {
    if (!(descriptor.getChannel() instanceof SelectableChannel)) {
      return;
    }
    synchronized (((SelectableChannel) descriptor.getChannel()).blockingLock()) {
      blocking = block;
      try {
        ((SelectableChannel) descriptor.getChannel()).configureBlocking(block);
      } catch (IllegalBlockingModeException e) {
        // ignore this; select() will set the correct mode when it is finished
      }
    }
  }

  public boolean isBlocking() {
    return blocking;
  }

  public synchronized void freopen(Ruby runtime, String path, ModeFlags modes)
      throws DirectoryAsFileException, IOException, InvalidValueException, PipeException,
          BadDescriptorException {
    // flush first
    flushWrite();

    // reset buffer
    buffer.clear();
    if (reading) {
      buffer.flip();
    }

    this.modes = modes;

    if (descriptor.isOpen()) {
      descriptor.close();
    }

    if (path.equals("/dev/null") || path.equalsIgnoreCase("nul:") || path.equalsIgnoreCase("nul")) {
      descriptor = descriptor.reopen(new NullChannel(), modes);
    } else {
      String cwd = runtime.getCurrentDirectory();
      JRubyFile theFile = JRubyFile.create(cwd, path);

      if (theFile.isDirectory() && modes.isWritable()) throw new DirectoryAsFileException();

      if (modes.isCreate()) {
        if (theFile.exists() && modes.isExclusive()) {
          throw runtime.newErrnoEEXISTError("File exists - " + path);
        }
        theFile.createNewFile();
      } else {
        if (!theFile.exists()) {
          throw runtime.newErrnoENOENTError("file not found - " + path);
        }
      }

      // We always open this rw since we can only open it r or rw.
      RandomAccessFile file = new RandomAccessFile(theFile, modes.toJavaModeString());

      if (modes.isTruncate()) file.setLength(0L);

      descriptor = descriptor.reopen(file, modes);

      try {
        if (modes.isAppendable()) lseek(0, SEEK_END);
      } catch (PipeException pe) {
        // ignore, it's a pipe or fifo
      }
    }
  }

  public static Stream open(Ruby runtime, ChannelDescriptor descriptor) {
    return maybeWrapWithLineEndingWrapper(
        new ChannelStream(runtime, descriptor, true), descriptor.getOriginalModes());
  }

  public static Stream fdopen(Ruby runtime, ChannelDescriptor descriptor, ModeFlags modes)
      throws InvalidValueException {
    // check these modes before constructing, so we don't finalize the partially-initialized stream
    descriptor.checkNewModes(modes);
    return maybeWrapWithLineEndingWrapper(
        new ChannelStream(runtime, descriptor, modes, true), modes);
  }

  public static Stream open(Ruby runtime, ChannelDescriptor descriptor, boolean autoclose) {
    return maybeWrapWithLineEndingWrapper(
        new ChannelStream(runtime, descriptor, autoclose), descriptor.getOriginalModes());
  }

  public static Stream fdopen(
      Ruby runtime, ChannelDescriptor descriptor, ModeFlags modes, boolean autoclose)
      throws InvalidValueException {
    // check these modes before constructing, so we don't finalize the partially-initialized stream
    descriptor.checkNewModes(modes);
    return maybeWrapWithLineEndingWrapper(
        new ChannelStream(runtime, descriptor, modes, autoclose), modes);
  }

  private static Stream maybeWrapWithLineEndingWrapper(Stream stream, ModeFlags modes) {
    if (Platform.IS_WINDOWS
        && stream.getDescriptor().getChannel() instanceof FileChannel
        && !modes.isBinary()) {
      return new CRLFStreamWrapper(stream);
    }
    return stream;
  }

  public static Stream fopen(Ruby runtime, String path, ModeFlags modes)
      throws FileNotFoundException, DirectoryAsFileException, FileExistsException, IOException,
          InvalidValueException, PipeException, BadDescriptorException {
    ChannelDescriptor descriptor =
        ChannelDescriptor.open(
            runtime.getCurrentDirectory(), path, modes, runtime.getClassLoader());
    Stream stream = fdopen(runtime, descriptor, modes);

    return stream;
  }

  public Channel getChannel() {
    return getDescriptor().getChannel();
  }

  private static final class InputStreamAdapter extends java.io.InputStream {
    private final ChannelStream stream;

    public InputStreamAdapter(ChannelStream stream) {
      this.stream = stream;
    }

    @Override
    public int read() throws IOException {
      synchronized (stream) {
        // If it can be pulled direct from the buffer, don't go via the slow path
        if (stream.hasBufferedInputBytes()) {
          try {
            return stream.read();
          } catch (BadDescriptorException ex) {
            throw new IOException(ex.getMessage());
          }
        }
      }

      byte[] b = new byte[1];
      // java.io.InputStream#read must return an unsigned value;
      return read(b, 0, 1) == 1 ? b[0] & 0xff : -1;
    }

    @Override
    public int read(byte[] bytes, int off, int len) throws IOException {
      if (bytes == null) {
        throw new NullPointerException("null destination buffer");
      }
      if ((len | off | (off + len) | (bytes.length - (off + len))) < 0) {
        throw new IndexOutOfBoundsException();
      }
      if (len == 0) {
        return 0;
      }

      try {
        synchronized (stream) {
          final int available = stream.bufferedInputBytesRemaining();
          if (available >= len) {
            return stream.copyBufferedBytes(bytes, off, len);
          } else if (stream.getDescriptor().getChannel() instanceof SelectableChannel) {
            SelectableChannel ch = (SelectableChannel) stream.getDescriptor().getChannel();
            synchronized (ch.blockingLock()) {
              boolean oldBlocking = ch.isBlocking();
              try {
                if (!oldBlocking) {
                  ch.configureBlocking(true);
                }
                return stream.bufferedRead(ByteBuffer.wrap(bytes, off, len), true);
              } finally {
                if (!oldBlocking) {
                  ch.configureBlocking(oldBlocking);
                }
              }
            }
          } else {
            return stream.bufferedRead(ByteBuffer.wrap(bytes, off, len), true);
          }
        }
      } catch (BadDescriptorException ex) {
        throw new IOException(ex.getMessage());
      } catch (EOFException ex) {
        return -1;
      }
    }

    @Override
    public int available() throws IOException {
      synchronized (stream) {
        return !stream.eof ? stream.bufferedInputBytesRemaining() : 0;
      }
    }

    @Override
    public void close() throws IOException {
      try {
        synchronized (stream) {
          stream.fclose();
        }
      } catch (BadDescriptorException ex) {
        throw new IOException(ex.getMessage());
      }
    }
  }

  private static final class OutputStreamAdapter extends java.io.OutputStream {
    private final ChannelStream stream;

    public OutputStreamAdapter(ChannelStream stream) {
      this.stream = stream;
    }

    @Override
    public void write(int i) throws IOException {
      synchronized (stream) {
        if (!stream.isSync() && stream.hasBufferedOutputSpace()) {
          stream.buffer.put((byte) i);
          return;
        }
      }
      byte[] b = {(byte) i};
      write(b, 0, 1);
    }

    @Override
    public void write(byte[] bytes, int off, int len) throws IOException {
      if (bytes == null) {
        throw new NullPointerException("null source buffer");
      }
      if ((len | off | (off + len) | (bytes.length - (off + len))) < 0) {
        throw new IndexOutOfBoundsException();
      }

      try {
        synchronized (stream) {
          if (!stream.isSync() && stream.bufferedOutputSpaceRemaining() >= len) {
            stream.buffer.put(bytes, off, len);

          } else if (stream.getDescriptor().getChannel() instanceof SelectableChannel) {
            SelectableChannel ch = (SelectableChannel) stream.getDescriptor().getChannel();
            synchronized (ch.blockingLock()) {
              boolean oldBlocking = ch.isBlocking();
              try {
                if (!oldBlocking) {
                  ch.configureBlocking(true);
                }
                stream.bufferedWrite(ByteBuffer.wrap(bytes, off, len));
              } finally {
                if (!oldBlocking) {
                  ch.configureBlocking(oldBlocking);
                }
              }
            }
          } else {
            stream.bufferedWrite(ByteBuffer.wrap(bytes, off, len));
          }
        }
      } catch (BadDescriptorException ex) {
        throw new IOException(ex.getMessage());
      }
    }

    @Override
    public void close() throws IOException {
      try {
        synchronized (stream) {
          stream.fclose();
        }
      } catch (BadDescriptorException ex) {
        throw new IOException(ex.getMessage());
      }
    }

    @Override
    public void flush() throws IOException {
      try {
        synchronized (stream) {
          stream.flushWrite(true);
        }
      } catch (BadDescriptorException ex) {
        throw new IOException(ex.getMessage());
      }
    }
  }
}
Esempio n. 3
0
public class MixedModeIRMethod extends DynamicMethod
    implements IRMethodArgs, PositionAware, Compilable<DynamicMethod> {
  private static final Logger LOG = LoggerFactory.getLogger("InterpretedIRMethod");

  private Signature signature;
  private boolean displayedCFG = false; // FIXME: Remove when we find nicer way of logging CFG

  protected final IRScope method;

  protected static class DynamicMethodBox {
    public DynamicMethod actualMethod;
    public int callCount = 0;
  }

  protected DynamicMethodBox box = new DynamicMethodBox();

  public MixedModeIRMethod(IRScope method, Visibility visibility, RubyModule implementationClass) {
    super(implementationClass, visibility, CallConfiguration.FrameNoneScopeNone, method.getName());
    this.method = method;
    getStaticScope().determineModule();
    this.signature = getStaticScope().getSignature();

    // disable JIT if JIT is disabled
    if (!implementationClass.getRuntime().getInstanceConfig().getCompileMode().shouldJIT()) {
      this.box.callCount = -1;
    }
  }

  public IRScope getIRScope() {
    return method;
  }

  public DynamicMethod getActualMethod() {
    return box.actualMethod;
  }

  public StaticScope getStaticScope() {
    return method.getStaticScope();
  }

  public ArgumentDescriptor[] getArgumentDescriptors() {
    ensureInstrsReady(); // Make sure method is minimally built before returning this info
    return ((IRMethod) method).getArgumentDescriptors();
  }

  public Signature getSignature() {
    return signature;
  }

  @Override
  public Arity getArity() {
    return signature.arity();
  }

  protected void post(InterpreterContext ic, ThreadContext context) {
    // update call stacks (pop: ..)
    context.popFrame();
    if (ic.popDynScope()) {
      context.popScope();
    }
  }

  protected void pre(
      InterpreterContext ic,
      ThreadContext context,
      IRubyObject self,
      String name,
      Block block,
      RubyModule implClass) {
    // update call stacks (push: frame, class, scope, etc.)
    context.preMethodFrameOnly(implClass, name, self, block);
    if (ic.pushNewDynScope()) {
      context.pushScope(DynamicScope.newDynamicScope(ic.getStaticScope()));
    }
  }

  // FIXME: for subclasses we should override this method since it can be simple get
  // FIXME: to avoid cost of synch call in lazilyacquire we can save the ic here
  public InterpreterContext ensureInstrsReady() {
    if (method instanceof IRMethod) {
      return ((IRMethod) method).lazilyAcquireInterpreterContext();
    }
    return method.getInterpreterContext();
  }

  @Override
  public IRubyObject call(
      ThreadContext context,
      IRubyObject self,
      RubyModule clazz,
      String name,
      IRubyObject[] args,
      Block block) {
    if (IRRuntimeHelpers.isDebug()) doDebug();

    DynamicMethodBox box = this.box;
    if (box.callCount >= 0) tryJit(context, box);
    DynamicMethod jittedMethod = box.actualMethod;

    if (jittedMethod != null) {
      return jittedMethod.call(context, self, clazz, name, args, block);
    } else {
      return INTERPRET_METHOD(
          context,
          ensureInstrsReady(),
          getImplementationClass().getMethodLocation(),
          self,
          name,
          args,
          block);
    }
  }

  private IRubyObject INTERPRET_METHOD(
      ThreadContext context,
      InterpreterContext ic,
      RubyModule implClass,
      IRubyObject self,
      String name,
      IRubyObject[] args,
      Block block) {
    try {
      ThreadContext.pushBacktrace(context, name, ic.getFileName(), context.getLine());

      if (ic.hasExplicitCallProtocol()) {
        return ic.engine.interpret(context, self, ic, implClass, name, args, block, null);
      } else {
        try {
          this.pre(ic, context, self, name, block, implClass);
          return ic.engine.interpret(context, self, ic, implClass, name, args, block, null);
        } finally {
          this.post(ic, context);
        }
      }
    } finally {
      ThreadContext.popBacktrace(context);
    }
  }

  @Override
  public IRubyObject call(
      ThreadContext context, IRubyObject self, RubyModule clazz, String name, Block block) {
    if (IRRuntimeHelpers.isDebug()) doDebug();

    DynamicMethodBox box = this.box;
    if (box.callCount >= 0) tryJit(context, box);
    DynamicMethod jittedMethod = box.actualMethod;

    if (jittedMethod != null) {
      return jittedMethod.call(context, self, clazz, name, block);
    } else {
      return INTERPRET_METHOD(
          context,
          ensureInstrsReady(),
          getImplementationClass().getMethodLocation(),
          self,
          name,
          block);
    }
  }

  private IRubyObject INTERPRET_METHOD(
      ThreadContext context,
      InterpreterContext ic,
      RubyModule implClass,
      IRubyObject self,
      String name,
      Block block) {
    try {
      ThreadContext.pushBacktrace(context, name, ic.getFileName(), context.getLine());

      if (ic.hasExplicitCallProtocol()) {
        return ic.engine.interpret(context, self, ic, implClass, name, block, null);
      } else {
        try {
          this.pre(ic, context, self, name, block, implClass);
          return ic.engine.interpret(context, self, ic, implClass, name, block, null);
        } finally {
          this.post(ic, context);
        }
      }
    } finally {
      ThreadContext.popBacktrace(context);
    }
  }

  @Override
  public IRubyObject call(
      ThreadContext context,
      IRubyObject self,
      RubyModule clazz,
      String name,
      IRubyObject arg0,
      Block block) {
    if (IRRuntimeHelpers.isDebug()) doDebug();

    DynamicMethodBox box = this.box;
    if (box.callCount >= 0) tryJit(context, box);
    DynamicMethod jittedMethod = box.actualMethod;

    if (jittedMethod != null) {
      return jittedMethod.call(context, self, clazz, name, arg0, block);
    } else {
      return INTERPRET_METHOD(
          context,
          ensureInstrsReady(),
          getImplementationClass().getMethodLocation(),
          self,
          name,
          arg0,
          block);
    }
  }

  private IRubyObject INTERPRET_METHOD(
      ThreadContext context,
      InterpreterContext ic,
      RubyModule implClass,
      IRubyObject self,
      String name,
      IRubyObject arg1,
      Block block) {
    try {
      ThreadContext.pushBacktrace(context, name, ic.getFileName(), context.getLine());

      if (ic.hasExplicitCallProtocol()) {
        return ic.engine.interpret(context, self, ic, implClass, name, arg1, block, null);
      } else {
        try {
          this.pre(ic, context, self, name, block, implClass);
          return ic.engine.interpret(context, self, ic, implClass, name, arg1, block, null);
        } finally {
          this.post(ic, context);
        }
      }
    } finally {
      ThreadContext.popBacktrace(context);
    }
  }

  @Override
  public IRubyObject call(
      ThreadContext context,
      IRubyObject self,
      RubyModule clazz,
      String name,
      IRubyObject arg0,
      IRubyObject arg1,
      Block block) {
    if (IRRuntimeHelpers.isDebug()) doDebug();

    DynamicMethodBox box = this.box;
    if (box.callCount >= 0) tryJit(context, box);
    DynamicMethod jittedMethod = box.actualMethod;

    if (jittedMethod != null) {
      return jittedMethod.call(context, self, clazz, name, arg0, arg1, block);
    } else {
      return INTERPRET_METHOD(
          context,
          ensureInstrsReady(),
          getImplementationClass().getMethodLocation(),
          self,
          name,
          arg0,
          arg1,
          block);
    }
  }

  private IRubyObject INTERPRET_METHOD(
      ThreadContext context,
      InterpreterContext ic,
      RubyModule implClass,
      IRubyObject self,
      String name,
      IRubyObject arg1,
      IRubyObject arg2,
      Block block) {
    try {
      ThreadContext.pushBacktrace(context, name, ic.getFileName(), context.getLine());

      if (ic.hasExplicitCallProtocol()) {
        return ic.engine.interpret(context, self, ic, implClass, name, arg1, arg2, block, null);
      } else {
        try {
          this.pre(ic, context, self, name, block, implClass);
          return ic.engine.interpret(context, self, ic, implClass, name, arg1, arg2, block, null);
        } finally {
          this.post(ic, context);
        }
      }
    } finally {
      ThreadContext.popBacktrace(context);
    }
  }

  @Override
  public IRubyObject call(
      ThreadContext context,
      IRubyObject self,
      RubyModule clazz,
      String name,
      IRubyObject arg0,
      IRubyObject arg1,
      IRubyObject arg2,
      Block block) {
    if (IRRuntimeHelpers.isDebug()) doDebug();

    DynamicMethodBox box = this.box;
    if (box.callCount >= 0) tryJit(context, box);
    DynamicMethod jittedMethod = box.actualMethod;

    if (jittedMethod != null) {
      return jittedMethod.call(context, self, clazz, name, arg0, arg1, arg2, block);
    } else {
      return INTERPRET_METHOD(
          context,
          ensureInstrsReady(),
          getImplementationClass().getMethodLocation(),
          self,
          name,
          arg0,
          arg1,
          arg2,
          block);
    }
  }

  private IRubyObject INTERPRET_METHOD(
      ThreadContext context,
      InterpreterContext ic,
      RubyModule implClass,
      IRubyObject self,
      String name,
      IRubyObject arg1,
      IRubyObject arg2,
      IRubyObject arg3,
      Block block) {
    try {
      ThreadContext.pushBacktrace(context, name, ic.getFileName(), context.getLine());

      if (ic.hasExplicitCallProtocol()) {
        return ic.engine.interpret(
            context, self, ic, implClass, name, arg1, arg2, arg3, block, null);
      } else {
        try {
          this.pre(ic, context, self, name, block, implClass);
          return ic.engine.interpret(
              context, self, ic, implClass, name, arg1, arg2, arg3, block, null);
        } finally {
          this.post(ic, context);
        }
      }
    } finally {
      ThreadContext.popBacktrace(context);
    }
  }

  protected void doDebug() {
    // FIXME: This is printing out IRScope CFG but JIT may be active and it might not reflect
    // currently executing.  Move into JIT and into interp since they will be getting CFG from
    // different sources
    // FIXME: This is only printing out CFG once.  If we keep applying more passes then we
    // will want to print out after those new passes.
    ensureInstrsReady();
    LOG.info("Executing '" + method.getName() + "'");
    if (!displayedCFG) {
      LOG.info(method.debugOutput());
      displayedCFG = true;
    }
  }

  public DynamicMethod getMethodForCaching() {
    DynamicMethod method = box.actualMethod;
    if (method instanceof CompiledIRMethod) {
      return method;
    }
    return this;
  }

  @Override
  public void completeBuild(DynamicMethod newMethod) {
    this.box.actualMethod = newMethod;
    this.box.actualMethod.serialNumber = this.serialNumber;
    this.box.callCount = -1;
    getImplementationClass().invalidateCacheDescendants();
  }

  protected void tryJit(ThreadContext context, DynamicMethodBox box) {
    if (context.runtime.isBooting()) return; // don't JIT during runtime boot

    if (box.callCount++ >= Options.JIT_THRESHOLD.load())
      context.runtime.getJITCompiler().buildThresholdReached(context, this);
  }

  public String getClassName(ThreadContext context) {
    String className;
    if (implementationClass.isSingleton()) {
      MetaClass metaClass = (MetaClass) implementationClass;
      RubyClass realClass = metaClass.getRealClass();
      // if real class is Class
      if (realClass == context.runtime.getClassClass()) {
        // use the attached class's name
        className = ((RubyClass) metaClass.getAttached()).getName();
      } else {
        // use the real class name
        className = realClass.getName();
      }
    } else {
      // use the class name
      className = implementationClass.getName();
    }
    return className;
  }

  public void setActualMethod(CompiledIRMethod method) {
    this.box.actualMethod = method;
  }

  protected void dupBox(MixedModeIRMethod orig) {
    this.box = orig.box;
  }

  @Override
  public DynamicMethod dup() {
    MixedModeIRMethod x = new MixedModeIRMethod(method, visibility, implementationClass);
    x.box = box;

    return x;
  }

  public String getFile() {
    return method.getFileName();
  }

  public int getLine() {
    return method.getLineNumber();
  }

  public void setCallCount(int callCount) {
    box.callCount = callCount;
  }
}
Esempio n. 4
0
public class Interpreter {

  private static final Logger LOG = LoggerFactory.getLogger("Interpreter");

  public static IRubyObject interpret(Ruby runtime, Node rootNode, IRubyObject self) {
    IRScope scope = new IRBuilder().buildRoot((RootNode) rootNode);
    scope.prepareForInterpretation();
    //        scope.runCompilerPass(new CallSplitter());

    return interpretTop(runtime, scope, self);
  }

  private static int interpInstrsCount = 0;

  public static boolean isDebug() {
    return RubyInstanceConfig.IR_DEBUG;
  }

  public static IRubyObject interpretTop(Ruby runtime, IRScope scope, IRubyObject self) {
    assert scope instanceof IRScript : "Must be an IRScript scope at Top!!!";

    IRScript root = (IRScript) scope;

    // We get the live object ball rolling here.  This give a valid value for the top
    // of this lexical tree.  All new scope can then retrieve and set based on lexical parent.
    if (root.getStaticScope().getModule() == null) { // If an eval this may already be setup.
      root.getStaticScope().setModule(runtime.getObject());
    }

    RubyModule currModule = root.getStaticScope().getModule();
    IRMethod rootMethod = root.getRootClass().getRootMethod();
    InterpretedIRMethod method = new InterpretedIRMethod(rootMethod, currModule);
    ThreadContext context = runtime.getCurrentContext();

    IRubyObject rv = method.call(context, self, currModule, "", IRubyObject.NULL_ARRAY);
    if (isDebug()) LOG.debug("-- Interpreted instructions: {}", interpInstrsCount);

    return rv;
  }

  public static IRubyObject interpret(ThreadContext context, CFG cfg, InterpreterContext interp) {
    Ruby runtime = context.getRuntime();
    boolean inClosure = (cfg.getScope() instanceof IRClosure);
    boolean passThroughBreak = false;

    try {
      interp.setMethodExitLabel(
          cfg.getExitBB().getLabel()); // used by return and break instructions!

      Instr[] instrs = cfg.prepareForInterpretation();
      int n = instrs.length;
      int ipc = 0;
      Instr lastInstr = null;
      while (ipc < n) {
        interpInstrsCount++;
        lastInstr = instrs[ipc];

        if (isDebug()) LOG.debug("I: {}", lastInstr);

        try {
          Label jumpTarget = lastInstr.interpret(interp);
          ipc = (jumpTarget == null) ? ipc + 1 : jumpTarget.getTargetPC();
        }
        // SSS FIXME: This only catches Ruby exceptions
        // What about Java exceptions?
        catch (org.jruby.exceptions.RaiseException re) {
          ipc = cfg.getRescuerPC(lastInstr);

          if (ipc == -1) throw re; // No one rescued exception, pass it on!

          interp.setException(re.getException());
        }
      }

      // If a closure, and lastInstr was a return, have to return from the nearest method!
      IRubyObject rv = (IRubyObject) interp.getReturnValue();

      if (lastInstr instanceof ReturnInstr && inClosure && !interp.inLambda()) {
        throw new IRReturnJump(((ReturnInstr) lastInstr).methodToReturnFrom, rv);
      }
      // If a closure, and lastInstr was a break, have to return from the nearest closure!
      else if (lastInstr instanceof BREAK_Instr) {
        if (!inClosure) throw runtime.newLocalJumpError(Reason.BREAK, rv, "unexpected break");

        passThroughBreak = true;
        RuntimeHelpers.breakJump(context, rv);
      }

      return rv;
    } catch (JumpException.BreakJump bj) {
      if (passThroughBreak) throw bj;
      return (IRubyObject) bj.getValue();
    } catch (IRReturnJump rj) {
      // - If we are in a lambda, stop propagating
      // - If not in a lambda
      //   - if in a closure, pass it along
      //   - if not in a closure, we got this return jump from a closure further up the call stack.
      //     So, continue popping the call stack till we get to the right method
      if (!interp.inLambda() && (inClosure || (rj.methodToReturnFrom != cfg.getScope())))
        throw rj; // pass it along

      return (IRubyObject) rj.returnValue;
    } finally {
      if (interp.getFrame() != null) {
        context.popFrame();
        interp.setFrame(null);
      }

      if (interp.hasAllocatedDynamicScope()) context.postMethodScopeOnly();
    }
  }

  public static IRubyObject INTERPRET_METHOD(
      ThreadContext context,
      CFG cfg,
      InterpreterContext interp,
      String name,
      RubyModule implClass,
      boolean isTraceable) {
    Ruby runtime = interp.getRuntime();
    boolean syntheticMethod = name == null || name.equals("");

    try {
      String className = implClass.getName();
      if (!syntheticMethod)
        ThreadContext.pushBacktrace(context, className, name, context.getFile(), context.getLine());
      if (isTraceable) methodPreTrace(runtime, context, name, implClass);
      return interpret(context, cfg, interp);
    } finally {
      if (isTraceable) {
        try {
          methodPostTrace(runtime, context, name, implClass);
        } finally {
          if (!syntheticMethod) ThreadContext.popBacktrace(context);
        }
      } else {
        if (!syntheticMethod) ThreadContext.popBacktrace(context);
      }
    }
  }

  private static void methodPreTrace(
      Ruby runtime, ThreadContext context, String name, RubyModule implClass) {
    if (runtime.hasEventHooks()) context.trace(RubyEvent.CALL, name, implClass);
  }

  private static void methodPostTrace(
      Ruby runtime, ThreadContext context, String name, RubyModule implClass) {
    if (runtime.hasEventHooks()) context.trace(RubyEvent.RETURN, name, implClass);
  }
}
Esempio n. 5
0
File: CFG.java Progetto: cwgem/jruby
/**
 * Represents the base build of a CFG. All information here is accessed via delegation from the CFG
 * itself so this is meant as an internal organizational structure for a build.
 */
public class CFG {
  public enum EdgeType {
    REGULAR, // Any non-special edge.  Not really used.
    EXCEPTION, // Edge to exception handling basic blocks
    FALL_THROUGH, // Edge which is the natural fall through choice on a branch
    EXIT // Edge to dummy exit BB
  }

  private static final Logger LOG = LoggerFactory.getLogger("CFG");

  private IRExecutionScope scope;
  private Map<Label, BasicBlock> bbMap = new HashMap<Label, BasicBlock>();

  // Map of bb -> first bb of the rescue block that initiates exception handling for all exceptions
  // thrown within this bb
  private Map<BasicBlock, BasicBlock> rescuerMap = new HashMap<BasicBlock, BasicBlock>();

  // Map of bb -> first bb of the ensure block that protects this bb
  private Map<BasicBlock, BasicBlock> ensurerMap = new HashMap<BasicBlock, BasicBlock>();

  private List<ExceptionRegion> outermostERs = new ArrayList<ExceptionRegion>();

  private BasicBlock entryBB = null;
  private BasicBlock exitBB = null;
  private DirectedGraph<BasicBlock> graph = new DirectedGraph<BasicBlock>();

  private int nextBBId = 0; // Next available basic block id

  LinkedList<BasicBlock> postOrderList = null; // Post order traversal list of the cfg

  public CFG(IRExecutionScope scope) {
    this.scope = scope;
  }

  public int getNextBBID() {
    nextBBId++;
    return nextBBId;
  }

  public int getMaxNodeID() {
    return nextBBId;
  }

  public boolean bbIsProtected(BasicBlock b) {
    // No need to look in ensurerMap because (_bbEnsurerMap(b) != null) => (_bbResucerMap(b) !=
    // null)
    return getRescuerBBFor(b) != null;
  }

  public BasicBlock getBBForLabel(Label label) {
    return bbMap.get(label);
  }

  public BasicBlock getEnsurerBBFor(BasicBlock block) {
    return ensurerMap.get(block);
  }

  public BasicBlock getEntryBB() {
    return entryBB;
  }

  public BasicBlock getExitBB() {
    return exitBB;
  }

  public List<ExceptionRegion> getOutermostExceptionRegions() {
    return outermostERs;
  }

  public LinkedList<BasicBlock> postOrderList() {
    if (postOrderList == null) postOrderList = buildPostOrderList();
    return postOrderList;
  }

  public ListIterator<BasicBlock> getPostOrderTraverser() {
    return postOrderList().listIterator();
  }

  public ListIterator<BasicBlock> getReversePostOrderTraverser() {
    return postOrderList().listIterator(size());
  }

  public IRExecutionScope getScope() {
    return scope;
  }

  public int size() {
    return graph.size();
  }

  public Collection<BasicBlock> getBasicBlocks() {
    return graph.allData();
  }

  public Collection<BasicBlock> getSortedBasicBlocks() {
    return graph.getSortedData();
  }

  public Iterable<BasicBlock> getIncomingSources(BasicBlock block) {
    return graph.vertexFor(block).getIncomingSourcesData();
  }

  public Iterable<Edge<BasicBlock>> getIncomingEdges(BasicBlock block) {
    return graph.vertexFor(block).getIncomingEdges();
  }

  public BasicBlock getIncomingSource(BasicBlock block) {
    return graph.vertexFor(block).getIncomingSourceData();
  }

  public BasicBlock getIncomingSourceOfType(BasicBlock block, Object type) {
    return graph.vertexFor(block).getIncomingSourceDataOfType(type);
  }

  public Edge<BasicBlock> getIncomingEdgeOfType(BasicBlock block, Object type) {
    return graph.vertexFor(block).getIncomingEdgeOfType(type);
  }

  public Edge<BasicBlock> getOutgoingEdgeOfType(BasicBlock block, Object type) {
    return graph.vertexFor(block).getOutgoingEdgeOfType(type);
  }

  public BasicBlock getOutgoingDestination(BasicBlock block) {
    return graph.vertexFor(block).getOutgoingDestinationData();
  }

  public BasicBlock getOutgoingDestinationOfType(BasicBlock block, Object type) {
    return graph.vertexFor(block).getOutgoingDestinationDataOfType(type);
  }

  public Iterable<BasicBlock> getOutgoingDestinations(BasicBlock block) {
    return graph.vertexFor(block).getOutgoingDestinationsData();
  }

  public Iterable<BasicBlock> getOutgoingDestinationsOfType(BasicBlock block, Object type) {
    return graph.vertexFor(block).getOutgoingDestinationsDataOfType(type);
  }

  public Iterable<BasicBlock> getOutgoingDestinationsNotOfType(BasicBlock block, Object type) {
    return graph.vertexFor(block).getOutgoingDestinationsDataNotOfType(type);
  }

  public Set<Edge<BasicBlock>> getOutgoingEdges(BasicBlock block) {
    return graph.vertexFor(block).getOutgoingEdges();
  }

  public Iterable<Edge<BasicBlock>> getOutgoingEdgesNotOfType(BasicBlock block, Object type) {
    return graph.vertexFor(block).getOutgoingEdgesNotOfType(type);
  }

  public BasicBlock getRescuerBBFor(BasicBlock block) {
    return rescuerMap.get(block);
  }

  public void addEdge(BasicBlock source, BasicBlock destination, Object type) {
    graph.vertexFor(source).addEdgeTo(destination, type);
  }

  /* Add 'b' as a global ensure block that protects all unprotected blocks in this scope */
  public void addGlobalEnsureBlock(BasicBlock geb) {
    addEdge(geb, getExitBB(), EdgeType.EXIT);

    for (BasicBlock basicBlock : getBasicBlocks()) {
      if (basicBlock != geb && !bbIsProtected(basicBlock)) {
        addEdge(basicBlock, geb, EdgeType.EXCEPTION);
        setRescuerBB(basicBlock, geb);
        setEnsurerBB(basicBlock, geb);
      }
    }
  }

  public void putBBForLabel(Label label, BasicBlock block) {
    bbMap.put(label, block);
  }

  public void setEnsurerBB(BasicBlock block, BasicBlock ensureBlock) {
    ensurerMap.put(block, ensureBlock);
  }

  public void setRescuerBB(BasicBlock block, BasicBlock exceptionBlock) {
    rescuerMap.put(block, exceptionBlock);
  }

  /** Build the Control Flow Graph */
  public DirectedGraph<BasicBlock> build(List<Instr> instrs) {
    // Map of label & basic blocks which are waiting for a bb with that label
    Map<Label, List<BasicBlock>> forwardRefs = new HashMap<Label, List<BasicBlock>>();

    // Map of return address variable and all possible targets (required to connect up ensure blocks
    // with their targets)
    Map<Variable, Set<Label>> retAddrMap = new HashMap<Variable, Set<Label>>();
    Map<Variable, BasicBlock> retAddrTargetMap = new HashMap<Variable, BasicBlock>();

    // List of bbs that have a 'return' instruction
    List<BasicBlock> returnBBs = new ArrayList<BasicBlock>();

    // List of bbs that have a 'throw' instruction
    List<BasicBlock> exceptionBBs = new ArrayList<BasicBlock>();

    // Stack of nested rescue regions
    Stack<ExceptionRegion> nestedExceptionRegions = new Stack<ExceptionRegion>();

    // List of all rescued regions
    List<ExceptionRegion> allExceptionRegions = new ArrayList<ExceptionRegion>();

    // Dummy entry basic block (see note at end to see why)
    entryBB = createBB(nestedExceptionRegions);

    // First real bb
    BasicBlock firstBB = createBB(nestedExceptionRegions);

    // Build the rest!
    BasicBlock currBB = firstBB;
    BasicBlock newBB = null;
    boolean bbEnded = false;
    boolean nextBBIsFallThrough = true;
    for (Instr i : instrs) {
      Operation iop = i.getOperation();
      if (iop == Operation.LABEL) {
        Label l = ((LabelInstr) i).label;
        newBB = createBB(l, nestedExceptionRegions);
        // Jump instruction bbs dont add an edge to the succeeding bb by default
        if (nextBBIsFallThrough) graph.addEdge(currBB, newBB, EdgeType.FALL_THROUGH);
        currBB = newBB;
        bbEnded = false;
        nextBBIsFallThrough = true;

        // Add forward reference edges
        List<BasicBlock> frefs = forwardRefs.get(l);
        if (frefs != null) {
          for (BasicBlock b : frefs) {
            graph.addEdge(b, newBB, EdgeType.REGULAR);
          }
        }
      } else if (bbEnded && (iop != Operation.EXC_REGION_END)) {
        newBB = createBB(nestedExceptionRegions);
        // Jump instruction bbs dont add an edge to the succeeding bb by default
        if (nextBBIsFallThrough)
          graph.addEdge(currBB, newBB, EdgeType.FALL_THROUGH); // currBB cannot be null!
        currBB = newBB;
        bbEnded = false;
        nextBBIsFallThrough = true;
      }

      if (i instanceof ExceptionRegionStartMarkerInstr) {
        // SSS: Do we need this anymore?
        //                currBB.addInstr(i);
        ExceptionRegionStartMarkerInstr ersmi = (ExceptionRegionStartMarkerInstr) i;
        ExceptionRegion rr =
            new ExceptionRegion(ersmi.firstRescueBlockLabel, ersmi.ensureBlockLabel);
        rr.addBB(currBB);
        allExceptionRegions.add(rr);

        if (nestedExceptionRegions.empty()) {
          outermostERs.add(rr);
        } else {
          nestedExceptionRegions.peek().addNestedRegion(rr);
        }

        nestedExceptionRegions.push(rr);
      } else if (i instanceof ExceptionRegionEndMarkerInstr) {
        // SSS: Do we need this anymore?
        //                currBB.addInstr(i);
        nestedExceptionRegions.pop().setEndBB(currBB);
      } else if (iop.endsBasicBlock()) {
        bbEnded = true;
        currBB.addInstr(i);
        Label tgt;
        nextBBIsFallThrough = false;
        if (i instanceof BranchInstr) {
          tgt = ((BranchInstr) i).getJumpTarget();
          nextBBIsFallThrough = true;
        } else if (i instanceof JumpInstr) {
          tgt = ((JumpInstr) i).getJumpTarget();
        } else if (iop.isReturn()) { // BREAK, RETURN, CLOSURE_RETURN
          tgt = null;
          returnBBs.add(currBB);
        } else if (i instanceof ThrowExceptionInstr) {
          tgt = null;
          exceptionBBs.add(currBB);
        } else if (i instanceof JumpIndirectInstr) {
          tgt = null;
          Set<Label> retAddrs = retAddrMap.get(((JumpIndirectInstr) i).getJumpTarget());
          for (Label l : retAddrs) {
            addEdge(currBB, l, forwardRefs);
          }
          // Record the target bb for the retaddr var for any set_addr instrs that appear later and
          // use the same retaddr var
          retAddrTargetMap.put(((JumpIndirectInstr) i).getJumpTarget(), currBB);
        } else {
          throw new RuntimeException(
              "Unhandled case in CFG builder for basic block ending instr: " + i);
        }

        if (tgt != null) addEdge(currBB, tgt, forwardRefs);
      } else if (iop != Operation.LABEL) {
        currBB.addInstr(i);
      }

      if (i instanceof SetReturnAddressInstr) {
        Variable v = i.getResult();
        Label tgtLbl = ((SetReturnAddressInstr) i).getReturnAddr();
        BasicBlock tgtBB = retAddrTargetMap.get(v);
        // If we have the target bb, add the edge
        // If not, record it for fixup later
        if (tgtBB != null) {
          addEdge(tgtBB, tgtLbl, forwardRefs);
        } else {
          Set<Label> addrs = retAddrMap.get(v);
          if (addrs == null) {
            addrs = new HashSet<Label>();
            retAddrMap.put(v, addrs);
          }
          addrs.add(tgtLbl);
        }
      } else if (i instanceof CallInstr) { // Build CFG for the closure if there exists one
        Operand closureArg = ((CallInstr) i).getClosureArg();
        if (closureArg instanceof MetaObject) {
          ((IRClosure) ((MetaObject) closureArg).scope).buildCFG();
        }
      }
    }

    // Process all rescued regions
    for (ExceptionRegion rr : allExceptionRegions) {
      BasicBlock firstRescueBB = bbMap.get(rr.getFirstRescueBlockLabel());

      // 1. Tell the region that firstRescueBB is its protector!
      rr.setFirstRescueBB(firstRescueBB);

      // 2. Record a mapping from the region's exclusive basic blocks to the first bb that will
      // start exception handling for all their exceptions.
      // 3. Add an exception edge from every exclusive bb of the region to firstRescueBB
      BasicBlock ensureBlockBB =
          rr.getEnsureBlockLabel() == null ? null : bbMap.get(rr.getEnsureBlockLabel());
      for (BasicBlock b : rr.getExclusiveBBs()) {
        rescuerMap.put(b, firstRescueBB);
        graph.addEdge(b, firstRescueBB, EdgeType.EXCEPTION);
        if (ensureBlockBB != null) {
          ensurerMap.put(b, ensureBlockBB);
          // SSS FIXME: This is a conservative edge because when a rescue block is present
          // that catches an exception, control never reaches the ensure block directly.
          // Only when we get an error or threadkill even, or when breaks propagate upward
          // do we need to hit an ensure directly.  This edge is present to account for that
          // control-flow scneario.
          graph.addEdge(b, ensureBlockBB, EdgeType.EXCEPTION);
        }
      }
    }

    buildExitBasicBlock(
        nestedExceptionRegions,
        firstBB,
        returnBBs,
        exceptionBBs,
        nextBBIsFallThrough,
        currBB,
        entryBB);

    optimize(); // remove useless cfg edges & orphaned bbs

    return graph;
  }

  private void addEdge(
      BasicBlock src, Label targetLabel, Map<Label, List<BasicBlock>> forwardRefs) {
    BasicBlock target = bbMap.get(targetLabel);

    if (target != null) {
      graph.addEdge(src, target, EdgeType.REGULAR);
      return;
    }

    // Add a forward reference from target -> source
    List<BasicBlock> forwardReferences = forwardRefs.get(targetLabel);

    if (forwardReferences == null) {
      forwardReferences = new ArrayList<BasicBlock>();
      forwardRefs.put(targetLabel, forwardReferences);
    }

    forwardReferences.add(src);
  }

  /**
   * Create special empty exit BasicBlock that all BasicBlocks will eventually flow into. All Edges
   * to this 'dummy' BasicBlock will get marked with an edge type of EXIT.
   *
   * <p>Special BasicBlocks worth noting: 1. Exceptions, Returns, Entry(why?) -> ExitBB 2. Returns
   * -> ExitBB
   */
  private BasicBlock buildExitBasicBlock(
      Stack<ExceptionRegion> nestedExceptionRegions,
      BasicBlock firstBB,
      List<BasicBlock> returnBBs,
      List<BasicBlock> exceptionBBs,
      boolean nextIsFallThrough,
      BasicBlock currBB,
      BasicBlock entryBB) {
    exitBB = createBB(nestedExceptionRegions);

    graph.addEdge(entryBB, exitBB, EdgeType.EXIT);
    graph.addEdge(entryBB, firstBB, EdgeType.FALL_THROUGH);

    for (BasicBlock rb : returnBBs) {
      graph.addEdge(rb, exitBB, EdgeType.EXIT);
    }

    for (BasicBlock rb : exceptionBBs) {
      graph.addEdge(rb, exitBB, EdgeType.EXIT);
    }

    if (nextIsFallThrough) graph.addEdge(currBB, exitBB, EdgeType.EXIT);

    return exitBB;
  }

  private BasicBlock createBB(Label label, Stack<ExceptionRegion> nestedExceptionRegions) {
    BasicBlock basicBlock = new BasicBlock(this, label);
    bbMap.put(label, basicBlock);
    graph.vertexFor(basicBlock);

    if (!nestedExceptionRegions.empty()) nestedExceptionRegions.peek().addBB(basicBlock);

    return basicBlock;
  }

  private BasicBlock createBB(Stack<ExceptionRegion> nestedExceptionRegions) {
    return createBB(scope.getNewLabel(), nestedExceptionRegions);
  }

  public void removeEdge(Edge edge) {
    graph.removeEdge(edge);
  }

  private void deleteOrphanedBlocks(DirectedGraph<BasicBlock> graph) {
    // System.out.println("\nGraph:\n" + getGraph().toString());
    // System.out.println("\nInstructions:\n" + toStringInstrs());

    // FIXME: Quick and dirty implementation
    while (true) {
      BasicBlock bbToRemove = null;
      for (BasicBlock b : graph.allData()) {
        if (b == entryBB) continue; // Skip entry bb!

        // Every other bb should have at least one incoming edge
        if (graph.vertexFor(b).getIncomingEdges().isEmpty()) {
          bbToRemove = b;
          break;
        }
      }
      if (bbToRemove == null) break;

      removeBB(bbToRemove);
    }
  }

  void removeBB(BasicBlock b) {
    graph.removeVertexFor(b);
    bbMap.remove(b.getLabel());
    rescuerMap.remove(b);
    ensurerMap.remove(b);
    // SSS FIXME: Patch up rescued regions as well??
  }

  private void optimize() {
    // SSS FIXME: Can't we not add some of these exception edges in the first place??
    // Remove exception edges from blocks that couldn't possibly thrown an exception!
    List<Edge> toRemove = new ArrayList<Edge>();
    for (BasicBlock b : graph.allData()) {
      boolean noExceptions = true;
      for (Instr i : b.getInstrs()) {
        if (i.canRaiseException()) {
          noExceptions = false;
          break;
        }
      }

      if (noExceptions) {
        for (Edge<BasicBlock> e : graph.vertexFor(b).getOutgoingEdgesOfType(EdgeType.EXCEPTION)) {
          BasicBlock source = e.getSource().getData();
          BasicBlock destination = e.getDestination().getData();
          toRemove.add(e);

          if (rescuerMap.get(source) == destination) rescuerMap.remove(source);
          if (ensurerMap.get(source) == destination) ensurerMap.remove(source);
        }
      }
    }

    if (!toRemove.isEmpty()) {
      for (Edge edge : toRemove) {
        graph.removeEdge(edge);
      }
    }

    deleteOrphanedBlocks(graph);
  }

  public String toStringGraph() {
    return graph.toString();
  }

  public String toStringInstrs() {
    StringBuilder buf = new StringBuilder();

    for (BasicBlock b : getSortedBasicBlocks()) {
      buf.append(b.toStringInstrs());
    }
    buf.append("\n\n------ Rescue block map ------\n");
    for (BasicBlock bb : rescuerMap.keySet()) {
      buf.append("BB ")
          .append(bb.getID())
          .append(" --> BB ")
          .append(rescuerMap.get(bb).getID())
          .append("\n");
    }
    buf.append("\n\n------ Ensure block map ------\n");
    for (BasicBlock bb : ensurerMap.keySet()) {
      buf.append("BB ")
          .append(bb.getID())
          .append(" --> BB ")
          .append(ensurerMap.get(bb).getID())
          .append("\n");
    }

    List<IRClosure> closures = scope.getClosures();
    if (!closures.isEmpty()) {
      buf.append("\n\n------ Closures encountered in this scope ------\n");
      for (IRClosure c : closures) {
        buf.append(c.toStringBody());
      }
      buf.append("------------------------------------------------\n");
    }

    return buf.toString();
  }

  void removeEdge(BasicBlock a, BasicBlock b) {
    throw new UnsupportedOperationException("Not yet implemented");
  }

  private LinkedList<BasicBlock> buildPostOrderList() {
    LinkedList<BasicBlock> list = new LinkedList<BasicBlock>();
    BasicBlock root = getEntryBB();
    Stack<BasicBlock> stack = new Stack<BasicBlock>();
    stack.push(root);
    BitSet bbSet = new BitSet(1 + getMaxNodeID());
    bbSet.set(root.getID());

    // Non-recursive post-order traversal (the added flag is required to handle cycles and common
    // ancestors)
    while (!stack.empty()) {
      // Check if all children of the top of the stack have been added
      BasicBlock b = stack.peek();
      boolean allChildrenDone = true;
      for (BasicBlock dst : getOutgoingDestinations(b)) {
        int dstID = dst.getID();
        if (!bbSet.get(dstID)) {
          allChildrenDone = false;
          stack.push(dst);
          bbSet.set(dstID);
        }
      }

      // If all children have been added previously, we are ready with 'b' in this round!
      if (allChildrenDone) {
        stack.pop();
        list.add(b);
      }
    }

    // Sanity check!
    for (BasicBlock b : getBasicBlocks()) {
      if (!bbSet.get(b.getID())) {
        printError("BB " + b.getID() + " missing from po list!");
        break;
      }
    }

    return list;
  }

  private void printError(String message) {
    LOG.error(message + "\nGraph:\n" + this + "\nInstructions:\n" + toStringInstrs());
  }
}
Esempio n. 6
0
/**
 * Implementation of Ruby's <code>Thread</code> class. Each Ruby thread is mapped to an underlying
 * Java Virtual Machine thread.
 *
 * <p>Thread encapsulates the behavior of a thread of execution, including the main thread of the
 * Ruby script. In the descriptions that follow, the parameter <code>aSymbol</code> refers to a
 * symbol, which is either a quoted string or a <code>Symbol</code> (such as <code>:name</code>).
 *
 * <p>Note: For CVS history, see ThreadClass.java.
 */
@JRubyClass(name = "Thread")
public class RubyThread extends RubyObject implements ExecutionContext {

  private static final Logger LOG = LoggerFactory.getLogger("RubyThread");

  /** The thread-like think that is actually executing */
  private ThreadLike threadImpl;

  /** Normal thread-local variables */
  private transient Map<IRubyObject, IRubyObject> threadLocalVariables;

  /** Context-local variables, internal-ish thread locals */
  private final Map<Object, IRubyObject> contextVariables = new WeakHashMap<Object, IRubyObject>();

  /** Whether this thread should try to abort the program on exception */
  private boolean abortOnException;

  /** The final value resulting from the thread's execution */
  private IRubyObject finalResult;

  /**
   * The exception currently being raised out of the thread. We reference it here to continue
   * propagating it while handling thread shutdown logic and abort_on_exception.
   */
  private RaiseException exitingException;

  /** The ThreadGroup to which this thread belongs */
  private RubyThreadGroup threadGroup;

  /** Per-thread "current exception" */
  private IRubyObject errorInfo;

  /** Weak reference to the ThreadContext for this thread. */
  private volatile WeakReference<ThreadContext> contextRef;

  private static final boolean DEBUG = false;

  /** Thread statuses */
  public static enum Status {
    RUN,
    SLEEP,
    ABORTING,
    DEAD
  }

  /** Current status in an atomic reference */
  private final AtomicReference<Status> status = new AtomicReference<Status>(Status.RUN);

  /** Mail slot for cross-thread events */
  private volatile ThreadService.Event mail;

  /** The current task blocking a thread, to allow interrupting it in an appropriate way */
  private volatile BlockingTask currentBlockingTask;

  /** The list of locks this thread currently holds, so they can be released on exit */
  private final List<Lock> heldLocks = new ArrayList<Lock>();

  /** Whether or not this thread has been disposed of */
  private volatile boolean disposed = false;

  /** The thread's initial priority, for use in thread pooled mode */
  private int initialPriority;

  protected RubyThread(Ruby runtime, RubyClass type) {
    super(runtime, type);

    finalResult = runtime.getNil();
    errorInfo = runtime.getNil();
  }

  public void receiveMail(ThreadService.Event event) {
    synchronized (this) {
      // if we're already aborting, we can receive no further mail
      if (status.get() == Status.ABORTING) return;

      mail = event;
      switch (event.type) {
        case KILL:
          status.set(Status.ABORTING);
      }

      // If this thread is sleeping or stopped, wake it
      notify();
    }

    // interrupt the target thread in case it's blocking or waiting
    // WARNING: We no longer interrupt the target thread, since this usually means
    // interrupting IO and with NIO that means the channel is no longer usable.
    // We either need a new way to handle waking a target thread that's waiting
    // on IO, or we need to accept that we can't wake such threads and must wait
    // for them to complete their operation.
    // threadImpl.interrupt();

    // new interrupt, to hopefully wake it out of any blocking IO
    this.interrupt();
  }

  public synchronized void checkMail(ThreadContext context) {
    ThreadService.Event myEvent = mail;
    mail = null;
    if (myEvent != null) {
      switch (myEvent.type) {
        case RAISE:
          receivedAnException(context, myEvent.exception);
        case KILL:
          throwThreadKill();
      }
    }
  }

  public IRubyObject getErrorInfo() {
    return errorInfo;
  }

  public IRubyObject setErrorInfo(IRubyObject errorInfo) {
    this.errorInfo = errorInfo;
    return errorInfo;
  }

  public void setContext(ThreadContext context) {
    this.contextRef = new WeakReference<ThreadContext>(context);
  }

  public ThreadContext getContext() {
    return contextRef.get();
  }

  public Thread getNativeThread() {
    return threadImpl.nativeThread();
  }

  /**
   * Perform pre-execution tasks once the native thread is running, but we have not yet called the
   * Ruby code for the thread.
   */
  public void beforeStart() {
    // store initial priority, for restoring pooled threads to normal
    initialPriority = threadImpl.getPriority();

    // set to "normal" priority
    threadImpl.setPriority(Thread.NORM_PRIORITY);
  }

  /** Dispose of the current thread by tidying up connections to other stuff */
  public synchronized void dispose() {
    if (!disposed) {
      disposed = true;

      // remove from parent thread group
      threadGroup.remove(this);

      // unlock all locked locks
      unlockAll();

      // reset thread priority to initial if pooling
      if (Options.THREADPOOL_ENABLED.load()) {
        threadImpl.setPriority(initialPriority);
      }

      // mark thread as DEAD
      beDead();

      // unregister from runtime's ThreadService
      getRuntime().getThreadService().unregisterThread(this);
    }
  }

  public static RubyClass createThreadClass(Ruby runtime) {
    // FIXME: In order for Thread to play well with the standard 'new' behavior,
    // it must provide an allocator that can create empty object instances which
    // initialize then fills with appropriate data.
    RubyClass threadClass =
        runtime.defineClass(
            "Thread", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
    runtime.setThread(threadClass);

    threadClass.index = ClassIndex.THREAD;
    threadClass.setReifiedClass(RubyThread.class);

    threadClass.defineAnnotatedMethods(RubyThread.class);

    RubyThread rubyThread = new RubyThread(runtime, threadClass);
    // TODO: need to isolate the "current" thread from class creation
    rubyThread.threadImpl = new NativeThread(rubyThread, Thread.currentThread());
    runtime.getThreadService().setMainThread(Thread.currentThread(), rubyThread);

    // set to default thread group
    runtime.getDefaultThreadGroup().addDirectly(rubyThread);

    threadClass.setMarshal(ObjectMarshal.NOT_MARSHALABLE_MARSHAL);

    return threadClass;
  }

  /**
   * <code>Thread.new</code>
   *
   * <p>Thread.new( <i>[ arg ]*</i> ) {| args | block } -> aThread
   *
   * <p>Creates a new thread to execute the instructions given in block, and begins running it. Any
   * arguments passed to Thread.new are passed into the block.
   *
   * <pre>
   * x = Thread.new { sleep .1; print "x"; print "y"; print "z" }
   * a = Thread.new { print "a"; print "b"; sleep .2; print "c" }
   * x.join # Let the threads finish before
   * a.join # main thread exits...
   * </pre>
   *
   * <i>produces:</i> abxyzc
   */
  @JRubyMethod(
      name = {"new", "fork"},
      rest = true,
      meta = true)
  public static IRubyObject newInstance(IRubyObject recv, IRubyObject[] args, Block block) {
    return startThread(recv, args, true, block);
  }

  /**
   * Basically the same as Thread.new . However, if class Thread is subclassed, then calling start
   * in that subclass will not invoke the subclass's initialize method.
   */
  @JRubyMethod(rest = true, meta = true, compat = RUBY1_8)
  public static RubyThread start(IRubyObject recv, IRubyObject[] args, Block block) {
    return startThread(recv, args, false, block);
  }

  @JRubyMethod(rest = true, name = "start", meta = true, compat = RUBY1_9)
  public static RubyThread start19(IRubyObject recv, IRubyObject[] args, Block block) {
    Ruby runtime = recv.getRuntime();
    // The error message may appear incongruous here, due to the difference
    // between JRuby's Thread model and MRI's.
    // We mimic MRI's message in the name of compatibility.
    if (!block.isGiven())
      throw runtime.newArgumentError("tried to create Proc object without a block");
    return startThread(recv, args, false, block);
  }

  public static RubyThread adopt(IRubyObject recv, Thread t) {
    return adoptThread(recv, t, Block.NULL_BLOCK);
  }

  private static RubyThread adoptThread(final IRubyObject recv, Thread t, Block block) {
    final Ruby runtime = recv.getRuntime();
    final RubyThread rubyThread = new RubyThread(runtime, (RubyClass) recv);

    rubyThread.threadImpl = new NativeThread(rubyThread, t);
    ThreadContext context = runtime.getThreadService().registerNewThread(rubyThread);
    runtime.getThreadService().associateThread(t, rubyThread);

    context.preAdoptThread();

    // set to default thread group
    runtime.getDefaultThreadGroup().addDirectly(rubyThread);

    return rubyThread;
  }

  @JRubyMethod(rest = true, visibility = PRIVATE)
  public IRubyObject initialize(ThreadContext context, IRubyObject[] args, Block block) {
    Ruby runtime = getRuntime();
    if (!block.isGiven()) throw runtime.newThreadError("must be called with a block");

    try {
      RubyRunnable runnable = new RubyRunnable(this, args, context.getFrames(0), block);
      if (RubyInstanceConfig.POOLING_ENABLED) {
        FutureThread futureThread = new FutureThread(this, runnable);
        threadImpl = futureThread;

        addToCorrectThreadGroup(context);

        threadImpl.start();

        // JRUBY-2380, associate future early so it shows up in Thread.list right away, in case it
        // doesn't run immediately
        runtime.getThreadService().associateThread(futureThread.getFuture(), this);
      } else {
        Thread thread = new Thread(runnable);
        thread.setDaemon(true);
        thread.setName(
            "Ruby" + thread.getName() + ": " + context.getFile() + ":" + (context.getLine() + 1));
        threadImpl = new NativeThread(this, thread);

        addToCorrectThreadGroup(context);

        // JRUBY-2380, associate thread early so it shows up in Thread.list right away, in case it
        // doesn't run immediately
        runtime.getThreadService().associateThread(thread, this);

        threadImpl.start();
      }

      // We yield here to hopefully permit the target thread to schedule
      // MRI immediately schedules it, so this is close but not exact
      Thread.yield();

      return this;
    } catch (OutOfMemoryError oome) {
      if (oome.getMessage().equals("unable to create new native thread")) {
        throw runtime.newThreadError(oome.getMessage());
      }
      throw oome;
    } catch (SecurityException ex) {
      throw runtime.newThreadError(ex.getMessage());
    }
  }

  private static RubyThread startThread(
      final IRubyObject recv, final IRubyObject[] args, boolean callInit, Block block) {
    RubyThread rubyThread = new RubyThread(recv.getRuntime(), (RubyClass) recv);

    if (callInit) {
      rubyThread.callInit(args, block);
    } else {
      // for Thread::start, which does not call the subclass's initialize
      rubyThread.initialize(recv.getRuntime().getCurrentContext(), args, block);
    }

    return rubyThread;
  }

  public synchronized void cleanTerminate(IRubyObject result) {
    finalResult = result;
  }

  public synchronized void beDead() {
    status.set(Status.DEAD);
  }

  public void pollThreadEvents() {
    pollThreadEvents(getRuntime().getCurrentContext());
  }

  public void pollThreadEvents(ThreadContext context) {
    if (mail != null) checkMail(context);
  }

  private static void throwThreadKill() {
    throw new ThreadKill();
  }

  /**
   * Returns the status of the global ``abort on exception'' condition. The default is false. When
   * set to true, will cause all threads to abort (the process will exit(0)) if an exception is
   * raised in any thread. See also Thread.abort_on_exception= .
   */
  @JRubyMethod(name = "abort_on_exception", meta = true)
  public static RubyBoolean abort_on_exception_x(IRubyObject recv) {
    Ruby runtime = recv.getRuntime();
    return runtime.isGlobalAbortOnExceptionEnabled() ? runtime.getTrue() : runtime.getFalse();
  }

  @JRubyMethod(name = "abort_on_exception=", required = 1, meta = true)
  public static IRubyObject abort_on_exception_set_x(IRubyObject recv, IRubyObject value) {
    recv.getRuntime().setGlobalAbortOnExceptionEnabled(value.isTrue());
    return value;
  }

  @JRubyMethod(name = "current", meta = true)
  public static RubyThread current(IRubyObject recv) {
    return recv.getRuntime().getCurrentContext().getThread();
  }

  @JRubyMethod(name = "main", meta = true)
  public static RubyThread main(IRubyObject recv) {
    return recv.getRuntime().getThreadService().getMainThread();
  }

  @JRubyMethod(name = "pass", meta = true)
  public static IRubyObject pass(IRubyObject recv) {
    Ruby runtime = recv.getRuntime();
    ThreadService ts = runtime.getThreadService();
    boolean critical = ts.getCritical();

    ts.setCritical(false);

    Thread.yield();

    ts.setCritical(critical);

    return recv.getRuntime().getNil();
  }

  @JRubyMethod(name = "list", meta = true)
  public static RubyArray list(IRubyObject recv) {
    RubyThread[] activeThreads = recv.getRuntime().getThreadService().getActiveRubyThreads();

    return recv.getRuntime().newArrayNoCopy(activeThreads);
  }

  private void addToCorrectThreadGroup(ThreadContext context) {
    // JRUBY-3568, inherit threadgroup or use default
    IRubyObject group = context.getThread().group();
    if (!group.isNil()) {
      ((RubyThreadGroup) group).addDirectly(this);
    } else {
      context.runtime.getDefaultThreadGroup().addDirectly(this);
    }
  }

  private IRubyObject getSymbolKey(IRubyObject originalKey) {
    if (originalKey instanceof RubySymbol) {
      return originalKey;
    } else if (originalKey instanceof RubyString) {
      return getRuntime().newSymbol(originalKey.asJavaString());
    } else if (originalKey instanceof RubyFixnum) {
      getRuntime().getWarnings().warn(ID.FIXNUMS_NOT_SYMBOLS, "Do not use Fixnums as Symbols");
      throw getRuntime().newArgumentError(originalKey + " is not a symbol");
    } else {
      throw getRuntime().newTypeError(originalKey + " is not a symbol");
    }
  }

  private synchronized Map<IRubyObject, IRubyObject> getThreadLocals() {
    if (threadLocalVariables == null) {
      threadLocalVariables = new HashMap<IRubyObject, IRubyObject>();
    }
    return threadLocalVariables;
  }

  private void clearThreadLocals() {
    threadLocalVariables = null;
  }

  public final Map<Object, IRubyObject> getContextVariables() {
    return contextVariables;
  }

  public boolean isAlive() {
    return threadImpl.isAlive() && status.get() != Status.ABORTING;
  }

  @JRubyMethod(name = "[]", required = 1)
  public IRubyObject op_aref(IRubyObject key) {
    IRubyObject value;
    if ((value = getThreadLocals().get(getSymbolKey(key))) != null) {
      return value;
    }
    return getRuntime().getNil();
  }

  @JRubyMethod(name = "[]=", required = 2)
  public IRubyObject op_aset(IRubyObject key, IRubyObject value) {
    key = getSymbolKey(key);

    getThreadLocals().put(key, value);
    return value;
  }

  @JRubyMethod(name = "abort_on_exception")
  public RubyBoolean abort_on_exception() {
    return abortOnException ? getRuntime().getTrue() : getRuntime().getFalse();
  }

  @JRubyMethod(name = "abort_on_exception=", required = 1)
  public IRubyObject abort_on_exception_set(IRubyObject val) {
    abortOnException = val.isTrue();
    return val;
  }

  @JRubyMethod(name = "alive?")
  public RubyBoolean alive_p() {
    return isAlive() ? getRuntime().getTrue() : getRuntime().getFalse();
  }

  @JRubyMethod(name = "join", optional = 1)
  public IRubyObject join(IRubyObject[] args) {
    Ruby runtime = getRuntime();
    long timeoutMillis = Long.MAX_VALUE;

    if (args.length > 0 && !args[0].isNil()) {
      if (args.length > 1) {
        throw getRuntime().newArgumentError(args.length, 1);
      }
      // MRI behavior: value given in seconds; converted to Float; less
      // than or equal to zero returns immediately; returns nil
      timeoutMillis = (long) (1000.0D * args[0].convertToFloat().getValue());
      if (timeoutMillis <= 0) {
        // TODO: not sure that we should skip calling join() altogether.
        // Thread.join() has some implications for Java Memory Model, etc.
        if (threadImpl.isAlive()) {
          return getRuntime().getNil();
        } else {
          return this;
        }
      }
    }

    if (isCurrent()) {
      throw getRuntime().newThreadError("thread " + identityString() + " tried to join itself");
    }

    try {
      if (runtime.getThreadService().getCritical()) {
        // If the target thread is sleeping or stopped, wake it
        synchronized (this) {
          notify();
        }

        // interrupt the target thread in case it's blocking or waiting
        // WARNING: We no longer interrupt the target thread, since this usually means
        // interrupting IO and with NIO that means the channel is no longer usable.
        // We either need a new way to handle waking a target thread that's waiting
        // on IO, or we need to accept that we can't wake such threads and must wait
        // for them to complete their operation.
        // threadImpl.interrupt();
      }

      RubyThread currentThread = getRuntime().getCurrentContext().getThread();
      final long timeToWait = Math.min(timeoutMillis, 200);

      // We need this loop in order to be able to "unblock" the
      // join call without actually calling interrupt.
      long start = System.currentTimeMillis();
      while (true) {
        currentThread.pollThreadEvents();
        threadImpl.join(timeToWait);
        if (!threadImpl.isAlive()) {
          break;
        }
        if (System.currentTimeMillis() - start > timeoutMillis) {
          break;
        }
      }
    } catch (InterruptedException ie) {
      ie.printStackTrace();
      assert false : ie;
    } catch (ExecutionException ie) {
      ie.printStackTrace();
      assert false : ie;
    }

    if (exitingException != null) {
      // Set $! in the current thread before exiting
      getRuntime().getGlobalVariables().set("$!", (IRubyObject) exitingException.getException());
      throw exitingException;
    }

    if (threadImpl.isAlive()) {
      return getRuntime().getNil();
    } else {
      return this;
    }
  }

  @JRubyMethod
  public IRubyObject value() {
    join(new IRubyObject[0]);
    synchronized (this) {
      return finalResult;
    }
  }

  @JRubyMethod
  public IRubyObject group() {
    if (threadGroup == null) {
      return getRuntime().getNil();
    }

    return threadGroup;
  }

  void setThreadGroup(RubyThreadGroup rubyThreadGroup) {
    threadGroup = rubyThreadGroup;
  }

  @JRubyMethod(name = "inspect")
  @Override
  public synchronized IRubyObject inspect() {
    // FIXME: There's some code duplication here with RubyObject#inspect
    StringBuilder part = new StringBuilder();
    String cname = getMetaClass().getRealClass().getName();
    part.append("#<").append(cname).append(":");
    part.append(identityString());
    part.append(' ');
    part.append(status.toString().toLowerCase());
    part.append('>');
    return getRuntime().newString(part.toString());
  }

  @JRubyMethod(name = "key?", required = 1)
  public RubyBoolean key_p(IRubyObject key) {
    key = getSymbolKey(key);

    return getRuntime().newBoolean(getThreadLocals().containsKey(key));
  }

  @JRubyMethod(name = "keys")
  public RubyArray keys() {
    IRubyObject[] keys = new IRubyObject[getThreadLocals().size()];

    return RubyArray.newArrayNoCopy(getRuntime(), getThreadLocals().keySet().toArray(keys));
  }

  @JRubyMethod(name = "critical=", required = 1, meta = true, compat = CompatVersion.RUBY1_8)
  public static IRubyObject critical_set(IRubyObject receiver, IRubyObject value) {
    receiver.getRuntime().getThreadService().setCritical(value.isTrue());

    return value;
  }

  @JRubyMethod(name = "critical", meta = true, compat = CompatVersion.RUBY1_8)
  public static IRubyObject critical(IRubyObject receiver) {
    return receiver.getRuntime().newBoolean(receiver.getRuntime().getThreadService().getCritical());
  }

  @JRubyMethod(name = "stop", meta = true)
  public static IRubyObject stop(ThreadContext context, IRubyObject receiver) {
    RubyThread rubyThread = context.getThread();

    synchronized (rubyThread) {
      rubyThread.checkMail(context);
      try {
        // attempt to decriticalize all if we're the critical thread
        receiver.getRuntime().getThreadService().setCritical(false);

        rubyThread.status.set(Status.SLEEP);
        rubyThread.wait();
      } catch (InterruptedException ie) {
        rubyThread.checkMail(context);
        rubyThread.status.set(Status.RUN);
      }
    }

    return receiver.getRuntime().getNil();
  }

  @JRubyMethod(required = 1, meta = true)
  public static IRubyObject kill(IRubyObject receiver, IRubyObject rubyThread, Block block) {
    if (!(rubyThread instanceof RubyThread))
      throw receiver.getRuntime().newTypeError(rubyThread, receiver.getRuntime().getThread());
    return ((RubyThread) rubyThread).kill();
  }

  @JRubyMethod(meta = true)
  public static IRubyObject exit(IRubyObject receiver, Block block) {
    RubyThread rubyThread =
        receiver.getRuntime().getThreadService().getCurrentContext().getThread();

    synchronized (rubyThread) {
      rubyThread.status.set(Status.ABORTING);
      rubyThread.mail = null;
      receiver.getRuntime().getThreadService().setCritical(false);
      throw new ThreadKill();
    }
  }

  @JRubyMethod(name = "stop?")
  public RubyBoolean stop_p() {
    // not valid for "dead" state
    return getRuntime().newBoolean(status.get() == Status.SLEEP || status.get() == Status.DEAD);
  }

  @JRubyMethod(name = "wakeup")
  public synchronized RubyThread wakeup() {
    if (!threadImpl.isAlive() && status.get() == Status.DEAD) {
      throw getRuntime().newThreadError("killed thread");
    }

    status.set(Status.RUN);
    notifyAll();

    return this;
  }

  @JRubyMethod(name = "priority")
  public RubyFixnum priority() {
    return RubyFixnum.newFixnum(getRuntime(), threadImpl.getPriority());
  }

  @JRubyMethod(name = "priority=", required = 1)
  public IRubyObject priority_set(IRubyObject priority) {
    // FIXME: This should probably do some translation from Ruby priority levels to Java priority
    // levels (until we have green threads)
    int iPriority = RubyNumeric.fix2int(priority);

    if (iPriority < Thread.MIN_PRIORITY) {
      iPriority = Thread.MIN_PRIORITY;
    } else if (iPriority > Thread.MAX_PRIORITY) {
      iPriority = Thread.MAX_PRIORITY;
    }

    if (threadImpl.isAlive()) {
      threadImpl.setPriority(iPriority);
    }

    return RubyFixnum.newFixnum(getRuntime(), iPriority);
  }

  @JRubyMethod(optional = 3)
  public IRubyObject raise(IRubyObject[] args, Block block) {
    Ruby runtime = getRuntime();
    ThreadContext context = runtime.getCurrentContext();
    if (this == context.getThread()) {
      return RubyKernel.raise(context, runtime.getKernel(), args, block);
    }

    debug(this, "before raising");
    RubyThread currentThread = getRuntime().getCurrentContext().getThread();

    debug(this, "raising");
    IRubyObject exception = prepareRaiseException(runtime, args, block);

    runtime
        .getThreadService()
        .deliverEvent(
            new ThreadService.Event(
                currentThread, this, ThreadService.Event.Type.RAISE, exception));

    return this;
  }

  /**
   * This is intended to be used to raise exceptions in Ruby threads from non- Ruby threads like
   * Timeout's thread.
   *
   * @param args Same args as for Thread#raise
   * @param block Same as for Thread#raise
   */
  public void internalRaise(IRubyObject[] args) {
    Ruby runtime = getRuntime();

    IRubyObject exception = prepareRaiseException(runtime, args, Block.NULL_BLOCK);

    receiveMail(new ThreadService.Event(this, this, ThreadService.Event.Type.RAISE, exception));
  }

  private IRubyObject prepareRaiseException(Ruby runtime, IRubyObject[] args, Block block) {
    if (args.length == 0) {
      IRubyObject lastException = errorInfo;
      if (lastException.isNil()) {
        return new RaiseException(runtime, runtime.getRuntimeError(), "", false).getException();
      }
      return lastException;
    }

    IRubyObject exception;
    ThreadContext context = getRuntime().getCurrentContext();

    if (args.length == 1) {
      if (args[0] instanceof RubyString) {
        return runtime.getRuntimeError().newInstance(context, args, block);
      }

      if (!args[0].respondsTo("exception")) {
        return runtime.newTypeError("exception class/object expected").getException();
      }
      exception = args[0].callMethod(context, "exception");
    } else {
      if (!args[0].respondsTo("exception")) {
        return runtime.newTypeError("exception class/object expected").getException();
      }

      exception = args[0].callMethod(context, "exception", args[1]);
    }

    if (!runtime.getException().isInstance(exception)) {
      return runtime.newTypeError("exception object expected").getException();
    }

    if (args.length == 3) {
      ((RubyException) exception).set_backtrace(args[2]);
    }

    return exception;
  }

  @JRubyMethod(name = "run")
  public synchronized IRubyObject run() {
    return wakeup();
  }

  /**
   * We can never be sure if a wait will finish because of a Java "spurious wakeup". So if we
   * explicitly wakeup and we wait less than requested amount we will return false. We will return
   * true if we sleep right amount or less than right amount via spurious wakeup.
   */
  public synchronized boolean sleep(long millis) throws InterruptedException {
    assert this == getRuntime().getCurrentContext().getThread();
    boolean result = true;

    synchronized (this) {
      pollThreadEvents();
      try {
        status.set(Status.SLEEP);
        if (millis == -1) {
          wait();
        } else {
          wait(millis);
        }
      } finally {
        result = (status.get() != Status.RUN);
        pollThreadEvents();
        status.set(Status.RUN);
      }
    }

    return result;
  }

  @JRubyMethod(name = "status")
  public synchronized IRubyObject status() {
    if (threadImpl.isAlive()) {
      // TODO: no java stringity
      return getRuntime().newString(status.toString().toLowerCase());
    } else if (exitingException != null) {
      return getRuntime().getNil();
    } else {
      return getRuntime().getFalse();
    }
  }

  public static interface BlockingTask {
    public void run() throws InterruptedException;

    public void wakeup();
  }

  public static final class SleepTask implements BlockingTask {
    private final Object object;
    private final long millis;
    private final int nanos;

    public SleepTask(Object object, long millis, int nanos) {
      this.object = object;
      this.millis = millis;
      this.nanos = nanos;
    }

    public void run() throws InterruptedException {
      synchronized (object) {
        object.wait(millis, nanos);
      }
    }

    public void wakeup() {
      synchronized (object) {
        object.notify();
      }
    }
  }

  public void executeBlockingTask(BlockingTask task) throws InterruptedException {
    enterSleep();
    try {
      currentBlockingTask = task;
      pollThreadEvents();
      task.run();
    } finally {
      exitSleep();
      currentBlockingTask = null;
      pollThreadEvents();
    }
  }

  public void enterSleep() {
    status.set(Status.SLEEP);
  }

  public void exitSleep() {
    status.set(Status.RUN);
  }

  @JRubyMethod(name = {"kill", "exit", "terminate"})
  public IRubyObject kill() {
    // need to reexamine this
    RubyThread currentThread = getRuntime().getCurrentContext().getThread();

    // If the killee thread is the same as the killer thread, just die
    if (currentThread == this) throwThreadKill();

    debug(this, "trying to kill");

    currentThread.pollThreadEvents();

    getRuntime()
        .getThreadService()
        .deliverEvent(new ThreadService.Event(currentThread, this, ThreadService.Event.Type.KILL));

    debug(this, "succeeded with kill");

    return this;
  }

  private static void debug(RubyThread thread, String message) {
    if (DEBUG) LOG.debug(Thread.currentThread() + "(" + thread.status + "): " + message);
  }

  @JRubyMethod(
      name = {"kill!", "exit!", "terminate!"},
      compat = RUBY1_8)
  public IRubyObject kill_bang() {
    throw getRuntime()
        .newNotImplementedError(
            "Thread#kill!, exit!, and terminate! are not safe and not supported");
  }

  @JRubyMethod(name = "safe_level")
  public IRubyObject safe_level() {
    throw getRuntime().newNotImplementedError("Thread-specific SAFE levels are not supported");
  }

  @JRubyMethod(compat = CompatVersion.RUBY1_9)
  public IRubyObject backtrace(ThreadContext context) {
    return getContext().createCallerBacktrace(context.runtime, 0);
  }

  public StackTraceElement[] javaBacktrace() {
    if (threadImpl instanceof NativeThread) {
      return ((NativeThread) threadImpl).getThread().getStackTrace();
    }

    // Future-based threads can't get a Java trace
    return new StackTraceElement[0];
  }

  private boolean isCurrent() {
    return threadImpl.isCurrent();
  }

  public void exceptionRaised(RaiseException exception) {
    assert isCurrent();

    RubyException rubyException = exception.getException();
    Ruby runtime = rubyException.getRuntime();
    if (runtime.getSystemExit().isInstance(rubyException)) {
      runtime
          .getThreadService()
          .getMainThread()
          .raise(new IRubyObject[] {rubyException}, Block.NULL_BLOCK);
    } else if (abortOnException(runtime)) {
      RubyException systemExit;

      if (!runtime.is1_9()) {
        runtime.printError(rubyException);

        systemExit = RubySystemExit.newInstance(runtime, 1);
        systemExit.message = rubyException.message;
        systemExit.set_backtrace(rubyException.backtrace());
      } else {
        systemExit = rubyException;
      }

      runtime
          .getThreadService()
          .getMainThread()
          .raise(new IRubyObject[] {systemExit}, Block.NULL_BLOCK);
      return;
    } else if (runtime.getDebug().isTrue()) {
      runtime.printError(exception.getException());
    }
    exitingException = exception;
  }

  /**
   * For handling all non-Ruby exceptions bubbling out of threads
   *
   * @param exception
   */
  @SuppressWarnings("deprecation")
  public void exceptionRaised(Throwable exception) {
    if (exception instanceof RaiseException) {
      exceptionRaised((RaiseException) exception);
      return;
    }

    assert isCurrent();

    Ruby runtime = getRuntime();
    if (abortOnException(runtime) && exception instanceof Error) {
      // re-propagate on main thread
      runtime.getThreadService().getMainThread().getNativeThread().stop(exception);
    } else {
      // just rethrow on this thread, let system handlers report it
      UnsafeFactory.getUnsafe().throwException(exception);
    }
  }

  private boolean abortOnException(Ruby runtime) {
    return (runtime.isGlobalAbortOnExceptionEnabled() || abortOnException);
  }

  public static RubyThread mainThread(IRubyObject receiver) {
    return receiver.getRuntime().getThreadService().getMainThread();
  }

  private volatile Selector currentSelector;

  @Deprecated
  public boolean selectForAccept(RubyIO io) {
    return select(io, SelectionKey.OP_ACCEPT);
  }

  private synchronized Selector getSelector(SelectableChannel channel) throws IOException {
    return SelectorFactory.openWithRetryFrom(getRuntime(), channel.provider());
  }

  public boolean select(RubyIO io, int ops) {
    return select(io.getChannel(), io, ops);
  }

  public boolean select(RubyIO io, int ops, long timeout) {
    return select(io.getChannel(), io, ops, timeout);
  }

  public boolean select(Channel channel, RubyIO io, int ops) {
    return select(channel, io, ops, -1);
  }

  public boolean select(Channel channel, RubyIO io, int ops, long timeout) {
    if (channel instanceof SelectableChannel) {
      SelectableChannel selectable = (SelectableChannel) channel;

      synchronized (selectable.blockingLock()) {
        boolean oldBlocking = selectable.isBlocking();

        SelectionKey key = null;
        try {
          selectable.configureBlocking(false);

          if (io != null) io.addBlockingThread(this);
          currentSelector = getRuntime().getSelectorPool().get(selectable.provider());

          key = selectable.register(currentSelector, ops);

          beforeBlockingCall();
          int result;
          if (timeout < 0) {
            result = currentSelector.select();
          } else if (timeout == 0) {
            result = currentSelector.selectNow();
          } else {
            result = currentSelector.select(timeout);
          }

          // check for thread events, in case we've been woken up to die
          pollThreadEvents();

          if (result == 1) {
            Set<SelectionKey> keySet = currentSelector.selectedKeys();

            if (keySet.iterator().next() == key) {
              return true;
            }
          }

          return false;
        } catch (IOException ioe) {
          throw getRuntime().newIOErrorFromException(ioe);
        } finally {
          // Note: I don't like ignoring these exceptions, but it's
          // unclear how likely they are to happen or what damage we
          // might do by ignoring them. Note that the pieces are separate
          // so that we can ensure one failing does not affect the others
          // running.

          // clean up the key in the selector
          try {
            if (key != null) key.cancel();
            if (currentSelector != null) currentSelector.selectNow();
          } catch (Exception e) {
            // ignore
          }

          // shut down and null out the selector
          try {
            if (currentSelector != null) {
              getRuntime().getSelectorPool().put(currentSelector);
            }
          } catch (Exception e) {
            // ignore
          } finally {
            currentSelector = null;
          }

          // remove this thread as a blocker against the given IO
          if (io != null) io.removeBlockingThread(this);

          // go back to previous blocking state on the selectable
          try {
            selectable.configureBlocking(oldBlocking);
          } catch (Exception e) {
            // ignore
          }

          // clear thread state from blocking call
          afterBlockingCall();
        }
      }
    } else {
      // can't select, just have to do a blocking call
      return true;
    }
  }

  public void interrupt() {
    Selector activeSelector = currentSelector;
    if (activeSelector != null) {
      activeSelector.wakeup();
    }
    BlockingIO.Condition iowait = blockingIO;
    if (iowait != null) {
      iowait.cancel();
    }

    BlockingTask task = currentBlockingTask;
    if (task != null) {
      task.wakeup();
    }
  }

  private volatile BlockingIO.Condition blockingIO = null;

  public boolean waitForIO(ThreadContext context, RubyIO io, int ops) {
    Channel channel = io.getChannel();

    if (!(channel instanceof SelectableChannel)) {
      return true;
    }
    try {
      io.addBlockingThread(this);
      blockingIO = BlockingIO.newCondition(channel, ops);
      boolean ready = blockingIO.await();

      // check for thread events, in case we've been woken up to die
      pollThreadEvents();
      return ready;
    } catch (IOException ioe) {
      throw context.runtime.newRuntimeError("Error with selector: " + ioe);
    } catch (InterruptedException ex) {
      // FIXME: not correct exception
      throw context.runtime.newRuntimeError("Interrupted");
    } finally {
      blockingIO = null;
      io.removeBlockingThread(this);
    }
  }

  public void beforeBlockingCall() {
    pollThreadEvents();
    enterSleep();
  }

  public void afterBlockingCall() {
    exitSleep();
    pollThreadEvents();
  }

  private void receivedAnException(ThreadContext context, IRubyObject exception) {
    RubyModule kernelModule = getRuntime().getKernel();
    debug(this, "before propagating exception");
    kernelModule.callMethod(context, "raise", exception);
  }

  public boolean wait_timeout(IRubyObject o, Double timeout) throws InterruptedException {
    if (timeout != null) {
      long delay_ns = (long) (timeout.doubleValue() * 1000000000.0);
      long start_ns = System.nanoTime();
      if (delay_ns > 0) {
        long delay_ms = delay_ns / 1000000;
        int delay_ns_remainder = (int) (delay_ns % 1000000);
        executeBlockingTask(new SleepTask(o, delay_ms, delay_ns_remainder));
      }
      long end_ns = System.nanoTime();
      return (end_ns - start_ns) <= delay_ns;
    } else {
      executeBlockingTask(new SleepTask(o, 0, 0));
      return true;
    }
  }

  @Override
  public boolean equals(Object obj) {
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    final RubyThread other = (RubyThread) obj;
    if (this.threadImpl != other.threadImpl
        && (this.threadImpl == null || !this.threadImpl.equals(other.threadImpl))) {
      return false;
    }
    return true;
  }

  @Override
  public int hashCode() {
    int hash = 3;
    hash = 97 * hash + (this.threadImpl != null ? this.threadImpl.hashCode() : 0);
    return hash;
  }

  public String toString() {
    return threadImpl.toString();
  }

  /**
   * Acquire the given lock, holding a reference to it for cleanup on thread termination.
   *
   * @param lock the lock to acquire, released on thread termination
   */
  public void lock(Lock lock) {
    assert Thread.currentThread() == getNativeThread();
    lock.lock();
    heldLocks.add(lock);
  }

  /**
   * Acquire the given lock interruptibly, holding a reference to it for cleanup on thread
   * termination.
   *
   * @param lock the lock to acquire, released on thread termination
   * @throws InterruptedException if the lock acquisition is interrupted
   */
  public void lockInterruptibly(Lock lock) throws InterruptedException {
    assert Thread.currentThread() == getNativeThread();
    lock.lockInterruptibly();
    heldLocks.add(lock);
  }

  /**
   * Try to acquire the given lock, adding it to a list of held locks for cleanup on thread
   * termination if it is acquired. Return immediately if the lock cannot be acquired.
   *
   * @param lock the lock to acquire, released on thread termination
   */
  public boolean tryLock(Lock lock) {
    assert Thread.currentThread() == getNativeThread();
    boolean locked = lock.tryLock();
    if (locked) {
      heldLocks.add(lock);
    }
    return locked;
  }

  /**
   * Release the given lock and remove it from the list of locks to be released on thread
   * termination.
   *
   * @param lock the lock to release and dereferences
   */
  public void unlock(Lock lock) {
    assert Thread.currentThread() == getNativeThread();
    lock.unlock();
    heldLocks.remove(lock);
  }

  /** Release all locks held. */
  public void unlockAll() {
    assert Thread.currentThread() == getNativeThread();
    for (Lock lock : heldLocks) {
      lock.unlock();
    }
  }

  private String identityString() {
    return "0x" + Integer.toHexString(System.identityHashCode(this));
  }
}
Esempio n. 7
0
public class InterpretedIRBlockBody extends IRBlockBody implements Compilable<InterpreterContext> {
  private static final Logger LOG = LoggerFactory.getLogger("InterpretedIRBlockBody");
  protected boolean pushScope;
  protected boolean reuseParentScope;
  private boolean displayedCFG = false; // FIXME: Remove when we find nicer way of logging CFG
  private int callCount = 0;
  private InterpreterContext interpreterContext;
  private InterpreterContext fullInterpreterContext;

  public InterpretedIRBlockBody(IRClosure closure, Signature signature) {
    super(closure, signature);
    this.pushScope = true;
    this.reuseParentScope = false;

    // JIT currently JITs blocks along with their method and no on-demand by themselves.  We only
    // promote to full build here if we are -X-C.
    if (closure.getManager().getInstanceConfig().getCompileMode().shouldJIT()
        || Options.JIT_THRESHOLD.load() == -1) {
      callCount = -1;
    }
  }

  @Override
  public void setCallCount(int callCount) {
    this.callCount = callCount;
  }

  @Override
  public void completeBuild(InterpreterContext interpreterContext) {
    this.fullInterpreterContext = interpreterContext;
    // This enables IR & CFG to be dumped in debug mode
    // when this updated code starts executing.
    this.displayedCFG = false;
  }

  @Override
  public IRScope getIRScope() {
    return closure;
  }

  @Override
  public ArgumentDescriptor[] getArgumentDescriptors() {
    return closure.getArgumentDescriptors();
  }

  public InterpreterContext ensureInstrsReady() {
    if (IRRuntimeHelpers.isDebug() && !displayedCFG) {
      LOG.info(
          "Executing '"
              + closure
              + "' (pushScope="
              + pushScope
              + ", reuseParentScope="
              + reuseParentScope);
      LOG.info(closure.debugOutput());
      displayedCFG = true;
    }

    if (interpreterContext == null) {
      if (Options.IR_PRINT.load()) {
        ByteArrayOutputStream baos = IRDumper.printIR(closure, false);

        LOG.info(
            "Printing simple IR for " + closure.getName(), "\n" + new String(baos.toByteArray()));
      }

      interpreterContext = closure.getInterpreterContext();
      fullInterpreterContext = interpreterContext;
    }
    return interpreterContext;
  }

  @Override
  public String getClassName(ThreadContext context) {
    return null;
  }

  @Override
  public String getName() {
    return null;
  }

  @Override
  public boolean canCallDirect() {
    return interpreterContext != null && interpreterContext.hasExplicitCallProtocol();
  }

  @Override
  protected IRubyObject callDirect(
      ThreadContext context, Block block, IRubyObject[] args, Block blockArg) {
    context.setCurrentBlockType(Block.Type.PROC);
    InterpreterContext ic = ensureInstrsReady(); // so we get debugging output
    return Interpreter.INTERPRET_BLOCK(
        context, block, null, ic, args, block.getBinding().getMethod(), blockArg);
  }

  @Override
  protected IRubyObject yieldDirect(
      ThreadContext context, Block block, IRubyObject[] args, IRubyObject self) {
    context.setCurrentBlockType(Block.Type.NORMAL);
    InterpreterContext ic = ensureInstrsReady(); // so we get debugging output
    return Interpreter.INTERPRET_BLOCK(
        context, block, self, ic, args, block.getBinding().getMethod(), Block.NULL_BLOCK);
  }

  @Override
  protected IRubyObject commonYieldPath(
      ThreadContext context,
      Block block,
      Block.Type type,
      IRubyObject[] args,
      IRubyObject self,
      Block blockArg) {
    if (callCount >= 0) promoteToFullBuild(context);

    InterpreterContext ic = ensureInstrsReady();

    // Update interpreter context for next time this block is executed
    // This ensures that if we had determined canCallDirect() is false
    // based on the old IC, we continue to execute with it.
    interpreterContext = fullInterpreterContext;

    Binding binding = block.getBinding();
    Visibility oldVis = binding.getFrame().getVisibility();
    Frame prevFrame = context.preYieldNoScope(binding);

    // SSS FIXME: Maybe, we should allocate a NoVarsScope/DummyScope for for-loop bodies because the
    // static-scope here
    // probably points to the parent scope? To be verified and fixed if necessary. There is no harm
    // as it is now. It
    // is just wasteful allocation since the scope is not used at all.
    DynamicScope actualScope = binding.getDynamicScope();
    if (ic.pushNewDynScope()) {
      context.pushScope(block.allocScope(actualScope));
    } else if (ic.reuseParentDynScope()) {
      // Reuse! We can avoid the push only if surrounding vars aren't referenced!
      context.pushScope(actualScope);
    }

    self = IRRuntimeHelpers.updateBlockState(block, self);

    try {
      return Interpreter.INTERPRET_BLOCK(
          context, block, self, ic, args, binding.getMethod(), blockArg);
    } finally {
      // IMPORTANT: Do not clear eval-type in case this is reused in bindings!
      // Ex: eval("...", foo.instance_eval { binding })
      // The dyn-scope used for binding needs to have its eval-type set to INSTANCE_EVAL
      binding.getFrame().setVisibility(oldVis);
      if (ic.popDynScope()) {
        context.postYield(binding, prevFrame);
      } else {
        context.postYieldNoScope(prevFrame);
      }
    }
  }

  // Unlike JIT in MixedMode this will always successfully build but if using executor pool it may
  // take a while
  // and replace interpreterContext asynchronously.
  protected void promoteToFullBuild(ThreadContext context) {
    if (context.runtime.isBooting()) return; // don't Promote to full build during runtime boot

    if (callCount++ >= Options.JIT_THRESHOLD.load())
      context.runtime.getJITCompiler().buildThresholdReached(context, this);
  }

  public RubyModule getImplementationClass() {
    return null;
  }
}
Esempio n. 8
0
public class Interpreter {
  private static class IRCallSite {
    IRScope s;
    int v; // scope version
    CallBase call;
    long count;
    InterpretedIRMethod tgtM;

    public IRCallSite() {}

    public IRCallSite(IRCallSite cs) {
      this.s = cs.s;
      this.v = cs.v;
      this.call = cs.call;
      this.count = 0;
    }

    public int hashCode() {
      return (int) this.call.callSiteId;
    }
  }

  private static class CallSiteProfile {
    IRCallSite cs;
    HashMap<IRScope, Counter> counters;

    public CallSiteProfile(IRCallSite cs) {
      this.cs = new IRCallSite(cs);
      this.counters = new HashMap<IRScope, Counter>();
    }
  }

  private static IRCallSite callerSite = new IRCallSite();

  private static final Logger LOG = LoggerFactory.getLogger("Interpreter");

  private static int versionCount = 1;
  private static HashMap<IRScope, Integer> scopeVersionMap = new HashMap<IRScope, Integer>();

  private static int inlineCount = 0;
  private static int interpInstrsCount = 0;
  private static int codeModificationsCount = 0;
  private static int numCyclesWithNoModifications = 0;
  private static int globalThreadPollCount = 0;
  private static HashMap<IRScope, Counter> scopeThreadPollCounts = new HashMap<IRScope, Counter>();
  private static HashMap<Long, CallSiteProfile> callProfile = new HashMap<Long, CallSiteProfile>();
  private static HashMap<Operation, Counter> opStats = new HashMap<Operation, Counter>();

  private static IRScope getEvalContainerScope(Ruby runtime, StaticScope evalScope) {
    // SSS FIXME: Weirdness here.  We cannot get the containing IR scope from evalScope because of
    // static-scope wrapping
    // that is going on
    // 1. In all cases, DynamicScope.getEvalScope wraps the executing static scope in a new local
    // scope.
    // 2. For instance-eval (module-eval, class-eval) scenarios, there is an extra scope that is
    // added to
    //    the stack in ThreadContext.java:preExecuteUnder
    // I dont know what rule to apply when.  However, in both these cases, since there is no
    // IR-scope associated,
    // I have used the hack below where I first unwrap once and see if I get a non-null IR scope.
    // If that doesn't
    // work, I unwarp once more and I am guaranteed to get the IR scope I want.
    IRScope containingIRScope = ((IRStaticScope) evalScope.getEnclosingScope()).getIRScope();
    if (containingIRScope == null)
      containingIRScope =
          ((IRStaticScope) evalScope.getEnclosingScope().getEnclosingScope()).getIRScope();
    return containingIRScope;
  }

  public static IRubyObject interpretCommonEval(
      Ruby runtime,
      String file,
      int lineNumber,
      String backtraceName,
      RootNode rootNode,
      IRubyObject self,
      Block block) {
    // SSS FIXME: Is this required here since the IR version cannot change from eval-to-eval? This
    // is much more of a global setting.
    boolean is_1_9 = runtime.is1_9();
    if (is_1_9) IRBuilder.setRubyVersion("1.9");

    StaticScope ss = rootNode.getStaticScope();
    IRScope containingIRScope = getEvalContainerScope(runtime, ss);
    IREvalScript evalScript =
        IRBuilder.createIRBuilder(runtime, runtime.getIRManager())
            .buildEvalRoot(ss, containingIRScope, file, lineNumber, rootNode);
    evalScript.prepareForInterpretation(false);
    //        evalScript.runCompilerPass(new CallSplitter());
    ThreadContext context = runtime.getCurrentContext();
    runBeginEndBlocks(
        evalScript.getBeginBlocks(), context, self, null); // FIXME: No temp vars yet right?
    IRubyObject rv =
        evalScript.call(
            context,
            self,
            evalScript.getStaticScope().getModule(),
            rootNode.getScope(),
            block,
            backtraceName);
    runBeginEndBlocks(evalScript.getEndBlocks(), context, self, null); // FIXME: No temp vars right?
    return rv;
  }

  public static IRubyObject interpretSimpleEval(
      Ruby runtime,
      String file,
      int lineNumber,
      String backtraceName,
      Node node,
      IRubyObject self) {
    return interpretCommonEval(
        runtime, file, lineNumber, backtraceName, (RootNode) node, self, Block.NULL_BLOCK);
  }

  public static IRubyObject interpretBindingEval(
      Ruby runtime,
      String file,
      int lineNumber,
      String backtraceName,
      Node node,
      IRubyObject self,
      Block block) {
    return interpretCommonEval(
        runtime, file, lineNumber, backtraceName, (RootNode) node, self, block);
  }

  public static void runBeginEndBlocks(
      List<IRClosure> beBlocks, ThreadContext context, IRubyObject self, Object[] temp) {
    if (beBlocks == null) return;

    for (IRClosure b : beBlocks) {
      // SSS FIXME: Should I piggyback on WrappedIRClosure.retrieve or just copy that code here?
      b.prepareForInterpretation(false);
      Block blk =
          (Block)
              (new WrappedIRClosure(b)).retrieve(context, self, context.getCurrentScope(), temp);
      blk.yield(context, null);
    }
  }

  public static IRubyObject interpret(Ruby runtime, Node rootNode, IRubyObject self) {
    if (runtime.is1_9()) IRBuilder.setRubyVersion("1.9");

    IRScriptBody root =
        (IRScriptBody)
            IRBuilder.createIRBuilder(runtime, runtime.getIRManager())
                .buildRoot((RootNode) rootNode);

    // We get the live object ball rolling here.  This give a valid value for the top
    // of this lexical tree.  All new scope can then retrieve and set based on lexical parent.
    if (root.getStaticScope().getModule() == null) { // If an eval this may already be setup.
      root.getStaticScope().setModule(runtime.getObject());
    }

    RubyModule currModule = root.getStaticScope().getModule();

    // Scope state for root?
    IRStaticScopeFactory.newIRLocalScope(null).setModule(currModule);
    ThreadContext context = runtime.getCurrentContext();

    try {
      runBeginEndBlocks(
          root.getBeginBlocks(), context, self, null); // FIXME: No temp vars yet...not needed?
      InterpretedIRMethod method = new InterpretedIRMethod(root, currModule);
      IRubyObject rv = method.call(context, self, currModule, "(root)", IRubyObject.NULL_ARRAY);
      runBeginEndBlocks(
          root.getEndBlocks(), context, self, null); // FIXME: No temp vars yet...not needed?
      if ((IRRuntimeHelpers.isDebug() || IRRuntimeHelpers.inProfileMode())
          && interpInstrsCount > 10000) {
        LOG.info("-- Interpreted instructions: {}", interpInstrsCount);
        /*
        for (Operation o: opStats.keySet()) {
            System.out.println(o + " = " + opStats.get(o).count);
        }
        */
      }
      return rv;
    } catch (IRBreakJump bj) {
      throw IRException.BREAK_LocalJumpError.getException(context.runtime);
    }
  }

  private static void analyzeProfile() {
    versionCount++;

    // if (inlineCount == 2) return;

    if (codeModificationsCount == 0) numCyclesWithNoModifications++;
    else numCyclesWithNoModifications = 0;

    codeModificationsCount = 0;

    if (numCyclesWithNoModifications < 3) return;

    // We are now good to go -- start analyzing the profile

    // System.out.println("-------------------start analysis-----------------------");

    final HashMap<IRScope, Long> scopeCounts = new HashMap<IRScope, Long>();
    final ArrayList<IRCallSite> callSites = new ArrayList<IRCallSite>();
    HashMap<IRCallSite, Long> callSiteCounts = new HashMap<IRCallSite, Long>();
    // System.out.println("# call sites: " + callProfile.keySet().size());
    long total = 0;
    for (Long id : callProfile.keySet()) {
      Long c;

      CallSiteProfile csp = callProfile.get(id);
      IRCallSite cs = csp.cs;

      if (cs.v != scopeVersionMap.get(cs.s).intValue()) {
        // System.out.println("Skipping callsite: <" + cs.s + "," + cs.v + "> with compiled version:
        // " + scopeVersionMap.get(cs.s));
        continue;
      }

      Set<IRScope> calledScopes = csp.counters.keySet();
      cs.count = 0;
      for (IRScope s : calledScopes) {
        c = scopeCounts.get(s);
        if (c == null) {
          c = new Long(0);
          scopeCounts.put(s, c);
        }

        long x = csp.counters.get(s).count;
        c += x;
        cs.count += x;
      }

      CallBase call = cs.call;
      if (calledScopes.size() == 1 && !call.inliningBlocked()) {
        CallSite runtimeCS = call.getCallSite();
        if (runtimeCS != null && (runtimeCS instanceof CachingCallSite)) {
          CachingCallSite ccs = (CachingCallSite) runtimeCS;
          CacheEntry ce = ccs.getCache();

          if (!(ce.method instanceof InterpretedIRMethod)) {
            // System.out.println("NOT IR-M!");
            continue;
          } else {
            callSites.add(cs);
            cs.tgtM = (InterpretedIRMethod) ce.method;
          }
        }
      }

      total += cs.count;
    }

    Collections.sort(
        callSites,
        new java.util.Comparator<IRCallSite>() {
          @Override
          public int compare(IRCallSite a, IRCallSite b) {
            if (a.count == b.count) return 0;
            return (a.count < b.count) ? 1 : -1;
          }
        });

    // Find top N call sites
    double freq = 0.0;
    int i = 0;
    boolean noInlining = true;
    Set<IRScope> inlinedScopes = new HashSet<IRScope>();
    for (IRCallSite ircs : callSites) {
      double contrib = (ircs.count * 100.0) / total;

      // 1% is arbitrary
      if (contrib < 1.0) break;

      i++;
      freq += contrib;

      // This check is arbitrary
      if (i == 100 || freq > 99.0) break;

      // System.out.println("Considering: " + ircs.call + " with id: " + ircs.call.callSiteId +
      // " in scope " + ircs.s + " with count " + ircs.count + "; contrib " + contrib + "; freq: " +
      // freq);

      // Now inline here!
      CallBase call = ircs.call;

      IRScope hs = ircs.s;
      boolean isHotClosure = hs instanceof IRClosure;
      IRScope hc = isHotClosure ? hs : null;
      hs = isHotClosure ? hs.getLexicalParent() : hs;

      IRScope tgtMethod = ircs.tgtM.getIRMethod();

      Instr[] instrs = tgtMethod.getInstrsForInterpretation();
      // Dont inline large methods -- 500 is arbitrary
      // Can be null if a previously inlined method hasn't been rebuilt
      if ((instrs == null) || instrs.length > 500) {
        // if (instrs == null) System.out.println("no instrs!");
        // else System.out.println("large method with " + instrs.length + " instrs. skipping!");
        continue;
      }

      RubyModule implClass = ircs.tgtM.getImplementationClass();
      int classToken = implClass.getGeneration();
      String n = tgtMethod.getName();
      boolean inlineCall = true;
      if (isHotClosure) {
        Operand clArg = call.getClosureArg(null);
        inlineCall =
            (clArg instanceof WrappedIRClosure) && (((WrappedIRClosure) clArg).getClosure() == hc);
      }

      if (inlineCall) {
        noInlining = false;
        long start = new java.util.Date().getTime();
        hs.inlineMethod(tgtMethod, implClass, classToken, null, call);
        inlinedScopes.add(hs);
        long end = new java.util.Date().getTime();
        // System.out.println("Inlined " + tgtMethod + " in " + hs +
        //     " @ instr " + call + " in time (ms): "
        //     + (end-start) + " # instrs: " + instrs.length);

        inlineCount++;
      } else {
        // System.out.println("--no inlining--");
      }
    }

    for (IRScope x : inlinedScopes) {
      // update version count for 'hs'
      scopeVersionMap.put(x, versionCount);
      // System.out.println("Updating version of " + x + " to " + versionCount);
      // System.out.println("--- pre-inline-instrs ---");
      // System.out.println(x.getCFG().toStringInstrs());
      // System.out.println("--- post-inline-instrs ---");
      // System.out.println(x.getCFG().toStringInstrs());
    }

    // reset
    codeModificationsCount = 0;
    callProfile = new HashMap<Long, CallSiteProfile>();

    // Every 1M thread polls, discard stats by reallocating the thread-poll count map
    if (globalThreadPollCount % 1000000 == 0) {
      globalThreadPollCount = 0;
    }
  }

  private static void outputProfileStats() {
    ArrayList<IRScope> scopes = new ArrayList<IRScope>(scopeThreadPollCounts.keySet());
    Collections.sort(
        scopes,
        new java.util.Comparator<IRScope>() {
          @Override
          public int compare(IRScope a, IRScope b) {
            // In non-methods and non-closures, we may not have any thread poll instrs.
            int aden = a.getThreadPollInstrsCount();
            if (aden == 0) aden = 1;
            int bden = b.getThreadPollInstrsCount();
            if (bden == 0) bden = 1;

            // Use estimated instr count to order scopes -- rather than raw thread-poll count
            float aCount =
                scopeThreadPollCounts.get(a).count
                    * (1.0f * a.getInstrsForInterpretation().length / aden);
            float bCount =
                scopeThreadPollCounts.get(b).count
                    * (1.0f * b.getInstrsForInterpretation().length / bden);
            if (aCount == bCount) return 0;
            return (aCount < bCount) ? 1 : -1;
          }
        });

    /*
    LOG.info("------------------------");
    LOG.info("Stats after " + globalThreadPollCount + " thread polls:");
    LOG.info("------------------------");
    LOG.info("# instructions: " + interpInstrsCount);
    LOG.info("# code modifications in this period : " + codeModificationsCount);
    LOG.info("------------------------");
    */
    int i = 0;
    float f1 = 0.0f;
    for (IRScope s : scopes) {
      long n = scopeThreadPollCounts.get(s).count;
      float p1 = ((n * 1000) / globalThreadPollCount) / 10.0f;
      String msg =
          i
              + ". "
              + s
              + " [file:"
              + s.getFileName()
              + ":"
              + s.getLineNumber()
              + "] = "
              + n
              + "; ("
              + p1
              + "%)";
      if (s instanceof IRClosure) {
        IRMethod m = s.getNearestMethod();
        // if (m != null) LOG.info(msg + " -- nearest enclosing method: " + m);
        // else LOG.info(msg + " -- no enclosing method --");
      } else {
        // LOG.info(msg);
      }

      i++;
      f1 += p1;

      // Top 20 or those that account for 95% of thread poll events.
      if (i == 20 || f1 >= 95.0) break;
    }

    // reset code modification counter
    codeModificationsCount = 0;

    // Every 1M thread polls, discard stats by reallocating the thread-poll count map
    if (globalThreadPollCount % 1000000 == 0) {
      // System.out.println("---- resetting thread-poll counters ----");
      scopeThreadPollCounts = new HashMap<IRScope, Counter>();
      globalThreadPollCount = 0;
    }
  }

  private static Integer initProfiling(IRScope scope) {
    /* SSS: Not being used currently
    tpCount = scopeThreadPollCounts.get(scope);
    if (tpCount == null) {
        tpCount = new Counter();
        scopeThreadPollCounts.put(scope, tpCount);
    }
    */

    Integer scopeVersion = scopeVersionMap.get(scope);
    if (scopeVersion == null) {
      scopeVersionMap.put(scope, versionCount);
      scopeVersion = new Integer(versionCount);
    }

    if (callerSite.call != null) {
      Long id = callerSite.call.callSiteId;
      CallSiteProfile csp = callProfile.get(id);
      if (csp == null) {
        csp = new CallSiteProfile(callerSite);
        callProfile.put(id, csp);
      }

      Counter csCount = csp.counters.get(scope);
      if (csCount == null) {
        csCount = new Counter();
        csp.counters.put(scope, csCount);
      }
      csCount.count++;
    }

    return scopeVersion;
  }

  private static void setResult(
      Object[] temp, DynamicScope currDynScope, Variable resultVar, Object result) {
    if (resultVar instanceof TemporaryVariable) {
      temp[((TemporaryVariable) resultVar).offset] = result;
    } else {
      LocalVariable lv = (LocalVariable) resultVar;
      currDynScope.setValue((IRubyObject) result, lv.getLocation(), lv.getScopeDepth());
    }
  }

  private static void setResult(
      Object[] temp, DynamicScope currDynScope, Instr instr, Object result) {
    if (instr instanceof ResultInstr) {
      setResult(temp, currDynScope, ((ResultInstr) instr).getResult(), result);
    }
  }

  private static Object retrieveOp(
      Operand r,
      ThreadContext context,
      IRubyObject self,
      DynamicScope currDynScope,
      Object[] temp) {
    Object res;
    if (r instanceof Self) {
      return self;
    } else if (r instanceof TemporaryVariable) {
      res = temp[((TemporaryVariable) r).offset];
      return res == null ? context.nil : res;
    } else if (r instanceof LocalVariable) {
      LocalVariable lv = (LocalVariable) r;
      res = currDynScope.getValue(lv.getLocation(), lv.getScopeDepth());
      return res == null ? context.nil : res;
    } else {
      return r.retrieve(context, self, currDynScope, temp);
    }
  }

  private static void updateCallSite(Instr instr, IRScope scope, Integer scopeVersion) {
    if (instr instanceof CallBase) {
      callerSite.s = scope;
      callerSite.v = scopeVersion;
      callerSite.call = (CallBase) instr;
    }
  }

  private static void receiveArg(
      ThreadContext context,
      Instr i,
      Operation operation,
      IRubyObject[] args,
      int kwArgHashCount,
      DynamicScope currDynScope,
      Object[] temp,
      Object exception,
      Block block) {
    Object result = null;
    ResultInstr instr = (ResultInstr) i;
    switch (operation) {
      case RECV_PRE_REQD_ARG:
        int argIndex = ((ReceivePreReqdArgInstr) instr).getArgIndex();
        result =
            ((argIndex + kwArgHashCount) < args.length)
                ? args[argIndex]
                : context.nil; // SSS FIXME: This check is only required for closures, not methods
        break;
      case RECV_CLOSURE:
        result =
            (block == Block.NULL_BLOCK)
                ? context.nil
                : context.runtime.newProc(Block.Type.PROC, block);
        break;
      case RECV_OPT_ARG:
        result = ((ReceiveOptArgInstr) instr).receiveOptArg(args, kwArgHashCount);
        break;
      case RECV_POST_REQD_ARG:
        result = ((ReceivePostReqdArgInstr) instr).receivePostReqdArg(args, kwArgHashCount);
        // For blocks, missing arg translates to nil
        result = result == null ? context.nil : result;
        break;
      case RECV_REST_ARG:
        result =
            ((ReceiveRestArgInstr) instr).receiveRestArg(context.runtime, args, kwArgHashCount);
        break;
      case RECV_KW_ARG:
        result = ((ReceiveKeywordArgInstr) instr).receiveKWArg(context, kwArgHashCount, args);
        break;
      case RECV_KW_REST_ARG:
        result = ((ReceiveKeywordRestArgInstr) instr).receiveKWArg(context, kwArgHashCount, args);
        break;
      case RECV_EXCEPTION:
        {
          ReceiveExceptionInstr rei = (ReceiveExceptionInstr) instr;
          result =
              (exception instanceof RaiseException && rei.checkType)
                  ? ((RaiseException) exception).getException()
                  : exception;
          break;
        }
    }

    setResult(temp, currDynScope, instr.getResult(), result);
  }

  private static void processCall(
      ThreadContext context,
      Instr instr,
      Operation operation,
      IRScope scope,
      DynamicScope currDynScope,
      Object[] temp,
      IRubyObject self,
      Block block,
      Block.Type blockType) {
    Object result = null;
    switch (operation) {
      case RUNTIME_HELPER:
        {
          RuntimeHelperCall rhc = (RuntimeHelperCall) instr;
          result = rhc.callHelper(context, currDynScope, self, temp, scope, blockType);
          setResult(temp, currDynScope, rhc.getResult(), result);
          break;
        }
      case CALL_1F:
        {
          OneFixnumArgNoBlockCallInstr call = (OneFixnumArgNoBlockCallInstr) instr;
          IRubyObject r =
              (IRubyObject) retrieveOp(call.getReceiver(), context, self, currDynScope, temp);
          result = call.getCallSite().call(context, self, r, call.getFixnumArg());
          setResult(temp, currDynScope, call.getResult(), result);
          break;
        }
      case CALL_1O:
        {
          OneOperandArgNoBlockCallInstr call = (OneOperandArgNoBlockCallInstr) instr;
          IRubyObject r =
              (IRubyObject) retrieveOp(call.getReceiver(), context, self, currDynScope, temp);
          IRubyObject o = (IRubyObject) call.getArg1().retrieve(context, self, currDynScope, temp);
          result = call.getCallSite().call(context, self, r, o);
          setResult(temp, currDynScope, call.getResult(), result);
          break;
        }
      case CALL_0O:
        {
          ZeroOperandArgNoBlockCallInstr call = (ZeroOperandArgNoBlockCallInstr) instr;
          IRubyObject r =
              (IRubyObject) retrieveOp(call.getReceiver(), context, self, currDynScope, temp);
          result = call.getCallSite().call(context, self, r);
          setResult(temp, currDynScope, call.getResult(), result);
          break;
        }
      case NORESULT_CALL_1O:
        {
          OneOperandArgNoBlockNoResultCallInstr call =
              (OneOperandArgNoBlockNoResultCallInstr) instr;
          IRubyObject r =
              (IRubyObject) retrieveOp(call.getReceiver(), context, self, currDynScope, temp);
          IRubyObject o = (IRubyObject) call.getArg1().retrieve(context, self, currDynScope, temp);
          call.getCallSite().call(context, self, r, o);
          break;
        }
      case NORESULT_CALL:
        instr.interpret(context, currDynScope, self, temp, block);
        break;
      case CALL:
      default:
        result = instr.interpret(context, currDynScope, self, temp, block);
        setResult(temp, currDynScope, instr, result);
        break;
    }
  }

  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 static IRubyObject INTERPRET_EVAL(
      ThreadContext context,
      IRubyObject self,
      IRScope scope,
      RubyModule clazz,
      IRubyObject[] args,
      String name,
      Block block,
      Block.Type blockType) {
    try {
      ThreadContext.pushBacktrace(context, name, scope.getFileName(), context.getLine());
      return interpret(context, self, scope, null, clazz, args, block, blockType);
    } finally {
      ThreadContext.popBacktrace(context);
    }
  }

  public static IRubyObject INTERPRET_BLOCK(
      ThreadContext context,
      IRubyObject self,
      IRScope scope,
      IRubyObject[] args,
      String name,
      Block block,
      Block.Type blockType) {
    try {
      ThreadContext.pushBacktrace(context, name, scope.getFileName(), context.getLine());
      return interpret(context, self, scope, null, null, args, block, blockType);
    } finally {
      ThreadContext.popBacktrace(context);
    }
  }

  public static IRubyObject INTERPRET_METHOD(
      ThreadContext context,
      InterpretedIRMethod irMethod,
      IRubyObject self,
      String name,
      IRubyObject[] args,
      Block block,
      Block.Type blockType,
      boolean isTraceable) {
    Ruby runtime = context.runtime;
    IRScope scope = irMethod.getIRMethod();
    RubyModule implClass = irMethod.getImplementationClass();
    Visibility viz = irMethod.getVisibility();
    boolean syntheticMethod = name == null || name.equals("");

    try {
      if (!syntheticMethod)
        ThreadContext.pushBacktrace(context, name, scope.getFileName(), context.getLine());
      if (isTraceable) methodPreTrace(runtime, context, name, implClass);
      return interpret(context, self, scope, viz, implClass, args, block, blockType);
    } finally {
      if (isTraceable) {
        try {
          methodPostTrace(runtime, context, name, implClass);
        } finally {
          if (!syntheticMethod) ThreadContext.popBacktrace(context);
        }
      } else {
        if (!syntheticMethod) ThreadContext.popBacktrace(context);
      }
    }
  }

  private static void methodPreTrace(
      Ruby runtime, ThreadContext context, String name, RubyModule implClass) {
    if (runtime.hasEventHooks()) context.trace(RubyEvent.CALL, name, implClass);
  }

  private static void methodPostTrace(
      Ruby runtime, ThreadContext context, String name, RubyModule implClass) {
    if (runtime.hasEventHooks()) context.trace(RubyEvent.RETURN, name, implClass);
  }
}
Esempio n. 9
0
// This class represents JVM as the target of compilation
// and outputs bytecode
public class JVM {
  private static final Logger LOG = LoggerFactory.getLogger("IRBuilder");

  Stack<ClassData> clsStack = new Stack();
  ClassWriter writer;

  public JVM() {}

  public static final int CMP_EQ = 0;

  public byte[] code() {
    return writer.toByteArray();
  }

  public ClassVisitor cls() {
    return clsData().cls;
  }

  public ClassData clsData() {
    return clsStack.peek();
  }

  public MethodData methodData() {
    return clsData().methodData();
  }

  public void pushclass(String clsName) {
    PrintWriter pw = new PrintWriter(System.out);
    clsStack.push(
        new ClassData(
            clsName, new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS)));
    pw.flush();
  }

  public void pushscript(String clsName, String filename) {
    PrintWriter pw = new PrintWriter(System.out);
    writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
    clsStack.push(new ClassData(clsName, writer));

    cls()
        .visit(
            RubyInstanceConfig.JAVA_VERSION,
            ACC_PUBLIC + ACC_SUPER,
            clsName,
            null,
            p(Object.class),
            null);
    cls().visitSource(filename, null);
    pw.flush();
  }

  public void popclass() {
    clsStack.pop();
  }

  public IRBytecodeAdapter method() {
    return clsData().method();
  }

  public void pushmethod(String name, int arity) {
    clsData().pushmethod(name, arity);
    method().startMethod();

    // locals for ThreadContext and self
    methodData().local("$context", JVM.THREADCONTEXT_TYPE);
    methodData().local("$scope", JVM.STATICSCOPE_TYPE);
    methodData().local("$self"); // , JVM.OBJECT_TYPE);
    for (int i = 0; i < arity; i++) {
      // incoming arguments
      methodData().local("$argument" + i);
    }
    methodData().local("$block", Type.getType(Block.class));

    // TODO: this should go into the PushBinding instruction
    methodData().local("$dynamicScope");
  }

  public void popmethod() {
    clsData().popmethod();
  }

  public static String scriptToClass(String name) {
    if (name.equals("-e")) {
      return "DashE";
    } else {
      return JavaNameMangler.mangledFilenameForStartupClasspath(name);
    }
  }

  public void declareField(String field) {
    if (!clsData().fieldSet.contains(field)) {
      cls().visitField(ACC_PROTECTED, field, ci(Object.class), null, null);
      clsData().fieldSet.add(field);
    }
  }

  public static final Class OBJECT = IRubyObject.class;
  public static final Class BLOCK = Block.class;
  public static final Class THREADCONTEXT = ThreadContext.class;
  public static final Class STATICSCOPE = StaticScope.class;
  public static final Type OBJECT_TYPE = Type.getType(OBJECT);
  public static final Type BLOCK_TYPE = Type.getType(BLOCK);
  public static final Type THREADCONTEXT_TYPE = Type.getType(THREADCONTEXT);
  public static final Type STATICSCOPE_TYPE = Type.getType(STATICSCOPE);
}
Esempio n. 10
0
public class IREvalScript extends IRClosure {
  private static final Logger LOG = LoggerFactory.getLogger("IREvalScript");

  private IRScope nearestNonEvalScope;
  private int nearestNonEvalScopeDepth;
  private List<IRClosure> beginBlocks;
  private List<IRClosure> endBlocks;

  public IREvalScript(
      IRManager manager,
      IRScope lexicalParent,
      String fileName,
      int lineNumber,
      StaticScope staticScope) {
    super(manager, lexicalParent, fileName, lineNumber, staticScope, "EVAL_");

    int n = 0;
    IRScope s = lexicalParent;
    while (s instanceof IREvalScript) {
      n++;
      s = s.getLexicalParent();
    }

    this.nearestNonEvalScope = s;
    this.nearestNonEvalScopeDepth = n;
    this.nearestNonEvalScope.initEvalScopeVariableAllocator(false);
  }

  @Override
  public Label getNewLabel() {
    return getNewLabel("EV" + closureId + "_LBL");
  }

  @Override
  public IRScopeType getScopeType() {
    return IRScopeType.EVAL_SCRIPT;
  }

  @Override
  public Operand[] getBlockArgs() {
    return new Operand[0];
  }

  /* Record a begin block -- not all scope implementations can handle them */
  @Override
  public void recordBeginBlock(IRClosure beginBlockClosure) {
    if (beginBlocks == null) beginBlocks = new ArrayList<IRClosure>();
    beginBlockClosure.setBeginEndBlock();
    beginBlocks.add(beginBlockClosure);
  }

  /* Record an end block -- not all scope implementations can handle them */
  @Override
  public void recordEndBlock(IRClosure endBlockClosure) {
    if (endBlocks == null) endBlocks = new ArrayList<IRClosure>();
    endBlockClosure.setBeginEndBlock();
    endBlocks.add(endBlockClosure);
  }

  public List<IRClosure> getBeginBlocks() {
    return beginBlocks;
  }

  public List<IRClosure> getEndBlocks() {
    return endBlocks;
  }

  public IRubyObject call(
      ThreadContext context,
      IRubyObject self,
      RubyModule clazz,
      DynamicScope evalScope,
      Block block,
      String backtraceName) {
    if (IRRuntimeHelpers.isDebug()) {
      LOG.info("Graph:\n" + cfg().toStringGraph());
      LOG.info("CFG:\n" + cfg().toStringInstrs());
    }

    // FIXME: Do not push new empty arg array in every time
    return Interpreter.INTERPRET_EVAL(
        context, self, this, clazz, new IRubyObject[] {}, backtraceName, block, null);
  }

  @Override
  public LocalVariable lookupExistingLVar(String name) {
    return nearestNonEvalScope.evalScopeVars.get(name);
  }

  @Override
  public LocalVariable findExistingLocalVariable(String name, int scopeDepth) {
    // Look in the nearest non-eval scope's shared eval scope vars first.
    // If you dont find anything there, look in the nearest non-eval scope's regular vars.
    LocalVariable lvar = lookupExistingLVar(name);
    if (lvar != null || scopeDepth == 0) return lvar;
    else
      return nearestNonEvalScope.findExistingLocalVariable(
          name, scopeDepth - nearestNonEvalScopeDepth - 1);
  }

  @Override
  public LocalVariable getLocalVariable(String name, int scopeDepth) {
    LocalVariable lvar = findExistingLocalVariable(name, scopeDepth);
    if (lvar == null) lvar = getNewLocalVariable(name, scopeDepth);
    // Create a copy of the variable usable at the right depth
    if (lvar.getScopeDepth() != scopeDepth) lvar = lvar.cloneForDepth(scopeDepth);

    return lvar;
  }

  @Override
  public LocalVariable getImplicitBlockArg() {
    return getLocalVariable(Variable.BLOCK, nearestNonEvalScopeDepth);
  }

  @Override
  public LocalVariable getNewLocalVariable(String name, int depth) {
    assert depth == nearestNonEvalScopeDepth
        : "Local variable depth in IREvalScript:getNewLocalVariable must be "
            + nearestNonEvalScopeDepth
            + ".  Got "
            + depth;
    LocalVariable lvar =
        new ClosureLocalVariable(this, name, 0, nearestNonEvalScope.evalScopeVars.size());
    nearestNonEvalScope.evalScopeVars.put(name, lvar);
    // CON: unsure how to get static scope to reflect this name as in IRClosure and IRMethod
    return lvar;
  }

  @Override
  public LocalVariable getNewFlipStateVariable() {
    return getLocalVariable("%flip_" + allocateNextPrefixedName("%flip"), 0);
  }

  @Override
  public int getUsedVariablesCount() {
    return 1 + nearestNonEvalScope.evalScopeVars.size() + getPrefixCountSize("%flip");
  }

  @Override
  public boolean isScriptScope() {
    return true;
  }

  @Override
  public boolean isTopLocalVariableScope() {
    return false;
  }

  @Override
  public boolean isFlipScope() {
    return true;
  }
}
Esempio n. 11
0
/** Created by headius on 10/23/14. */
public abstract class InvokeSite extends MutableCallSite {
  final Signature signature;
  final Signature fullSignature;
  final int arity;
  protected final String methodName;
  final MethodHandle fallback;
  private final Set<Integer> seenTypes = new HashSet<Integer>();
  private int clearCount;
  private static final AtomicLong SITE_ID = new AtomicLong(1);
  private final long siteID = SITE_ID.getAndIncrement();
  private final int argOffset;
  private boolean boundOnce;
  CacheEntry cache = CacheEntry.NULL_CACHE;

  private static final Logger LOG = LoggerFactory.getLogger("InvokeSite");

  public String name() {
    return methodName;
  }

  public final CallType callType;

  public InvokeSite(MethodType type, String name, CallType callType) {
    super(type);
    this.methodName = name;
    this.callType = callType;

    Signature startSig;

    if (callType == CallType.SUPER) {
      // super calls receive current class argument, so offsets and signature are different
      startSig = JRubyCallSite.STANDARD_SUPER_SIG;
      argOffset = 4;
    } else {
      startSig = JRubyCallSite.STANDARD_SITE_SIG;
      argOffset = 3;
    }

    int arity;
    if (type.parameterType(type.parameterCount() - 1) == Block.class) {
      arity = type.parameterCount() - (argOffset + 1);

      if (arity == 1 && type.parameterType(argOffset) == IRubyObject[].class) {
        arity = -1;
        startSig = startSig.appendArg("args", IRubyObject[].class);
      } else {
        for (int i = 0; i < arity; i++) {
          startSig = startSig.appendArg("arg" + i, IRubyObject.class);
        }
      }
      startSig = startSig.appendArg("block", Block.class);
      fullSignature = signature = startSig;
    } else {
      arity = type.parameterCount() - argOffset;

      if (arity == 1 && type.parameterType(argOffset) == IRubyObject[].class) {
        arity = -1;
        startSig = startSig.appendArg("args", IRubyObject[].class);
      } else {
        for (int i = 0; i < arity; i++) {
          startSig = startSig.appendArg("arg" + i, IRubyObject.class);
        }
      }
      signature = startSig;
      fullSignature = startSig.appendArg("block", Block.class);
    }

    this.arity = arity;

    this.fallback = prepareBinder().invokeVirtualQuiet(Bootstrap.LOOKUP, "invoke");
  }

  public static CallSite bootstrap(InvokeSite site, MethodHandles.Lookup lookup) {
    site.setInitialTarget(site.fallback);

    return site;
  }

  public IRubyObject invoke(
      ThreadContext context, IRubyObject caller, IRubyObject self, IRubyObject[] args, Block block)
      throws Throwable {
    RubyClass selfClass = pollAndGetClass(context, self);
    SwitchPoint switchPoint = (SwitchPoint) selfClass.getInvalidator().getData();
    CacheEntry entry = selfClass.searchWithCache(methodName);
    DynamicMethod method = entry.method;

    if (methodMissing(entry, caller)) {
      return callMethodMissing(entry, callType, context, self, methodName, args, block);
    }

    MethodHandle mh = getHandle(selfClass, this, method);

    updateInvocationTarget(mh, self, selfClass, entry, switchPoint);

    return method.call(context, self, selfClass, methodName, args, block);
  }

  /** Failover version uses a monomorphic cache and DynamicMethod.call, as in non-indy. */
  public IRubyObject fail(
      ThreadContext context, IRubyObject caller, IRubyObject self, IRubyObject[] args, Block block)
      throws Throwable {
    RubyClass selfClass = pollAndGetClass(context, self);
    String name = methodName;
    CacheEntry entry = cache;

    if (entry.typeOk(selfClass)) {
      return entry.method.call(context, self, selfClass, name, args, block);
    }

    entry = selfClass.searchWithCache(name);

    if (methodMissing(entry, caller)) {
      return callMethodMissing(entry, callType, context, self, name, args, block);
    }

    cache = entry;

    return entry.method.call(context, self, selfClass, name, args, block);
  }

  public Binder prepareBinder() {
    SmartBinder binder = SmartBinder.from(signature);

    // prepare arg[]
    if (arity == -1) {
      // do nothing, already have IRubyObject[] in args
    } else if (arity == 0) {
      binder = binder.insert(argOffset, "args", IRubyObject.NULL_ARRAY);
    } else {
      binder = binder.collect("args", "arg[0-9]+");
    }

    // add block if needed
    if (signature.lastArgType() != Block.class) {
      binder = binder.append("block", Block.NULL_BLOCK);
    }

    // bind to site
    binder = binder.insert(0, "site", this);

    return binder.binder();
  }

  MethodHandle getHandle(RubyClass dispatchClass, InvokeSite site, DynamicMethod method)
      throws Throwable {
    boolean blockGiven = signature.lastArgType() == Block.class;

    MethodHandle mh = Bootstrap.buildNativeHandle(site, method, blockGiven);
    if (mh == null) mh = Bootstrap.buildIndyHandle(site, method, method.getImplementationClass());
    if (mh == null) mh = Bootstrap.buildJittedHandle(site, method, blockGiven);
    if (mh == null) mh = Bootstrap.buildGenericHandle(site, method, dispatchClass);

    assert mh != null : "we should have a method handle of some sort by now";

    return mh;
  }

  /**
   * Update the given call site using the new target, wrapping with appropriate guard and
   * argument-juggling logic. Return a handle suitable for invoking with the site's original method
   * type.
   */
  MethodHandle updateInvocationTarget(
      MethodHandle target,
      IRubyObject self,
      RubyModule testClass,
      CacheEntry entry,
      SwitchPoint switchPoint) {
    if (target == null
        || clearCount > Options.INVOKEDYNAMIC_MAXFAIL.load()
        || (!hasSeenType(testClass.id)
            && seenTypesCount() + 1 > Options.INVOKEDYNAMIC_MAXPOLY.load())) {
      setTarget(target = prepareBinder().invokeVirtualQuiet(lookup(), "fail"));
    } else {
      MethodHandle fallback;
      MethodHandle gwt;

      // if we've cached no types, and the site is bound and we haven't seen this new type...
      if (seenTypesCount() > 0 && getTarget() != null && !hasSeenType(testClass.id)) {
        // stack it up into a PIC
        if (Options.INVOKEDYNAMIC_LOG_BINDING.load())
          LOG.info(methodName + "\tadded to PIC " + logMethod(entry.method));
        fallback = getTarget();
      } else {
        // wipe out site with this new type and method
        String bind = boundOnce ? "rebind" : "bind";
        if (Options.INVOKEDYNAMIC_LOG_BINDING.load())
          LOG.info(
              methodName
                  + "\ttriggered site #"
                  + siteID
                  + " "
                  + bind); // + " (" + file() + ":" + line() + ")");
        fallback = this.fallback;
        clearTypes();
      }

      addType(testClass.id);

      SmartHandle test;
      SmartBinder selfTest = SmartBinder.from(signature.asFold(boolean.class)).permute("self");

      if (self instanceof RubySymbol
          || self instanceof RubyFixnum
          || self instanceof RubyFloat
          || self instanceof RubyNil
          || self instanceof RubyBoolean.True
          || self instanceof RubyBoolean.False) {

        test =
            selfTest
                .insert(1, "selfJavaType", self.getClass())
                .cast(boolean.class, Object.class, Class.class)
                .invoke(TEST_CLASS);

      } else {

        test =
            SmartBinder.from(signature.changeReturn(boolean.class))
                .permute("self")
                .insert(0, "selfClass", RubyClass.class, testClass)
                .invokeStaticQuiet(Bootstrap.LOOKUP, Bootstrap.class, "testType");
      }

      gwt = MethodHandles.guardWithTest(test.handle(), target, fallback);

      // wrap in switchpoint for mutation invalidation
      gwt = switchPoint.guardWithTest(gwt, fallback);

      setTarget(gwt);
    }

    return target;
  }

  public RubyClass pollAndGetClass(ThreadContext context, IRubyObject self) {
    context.callThreadPoll();
    RubyClass selfType = ((RubyBasicObject) self).getMetaClass();
    return selfType;
  }

  @Override
  public void setTarget(MethodHandle target) {
    super.setTarget(target);
    boundOnce = true;
  }

  public void setInitialTarget(MethodHandle target) {
    super.setTarget(target);
  }

  public synchronized boolean hasSeenType(int typeCode) {
    return seenTypes.contains(typeCode);
  }

  public synchronized void addType(int typeCode) {
    seenTypes.add(typeCode);
  }

  public synchronized int seenTypesCount() {
    return seenTypes.size();
  }

  public synchronized void clearTypes() {
    seenTypes.clear();
    clearCount++;
  }

  public abstract boolean methodMissing(CacheEntry entry, IRubyObject caller);

  public IRubyObject callMethodMissing(
      CacheEntry entry,
      CallType callType,
      ThreadContext context,
      IRubyObject self,
      String name,
      IRubyObject[] args,
      Block block) {
    return Helpers.selectMethodMissing(context, self, entry.method.getVisibility(), name, callType)
        .call(context, self, self.getMetaClass(), name, args, block);
  }

  private static String logMethod(DynamicMethod method) {
    return "[#" + method.getSerialNumber() + " " + method.getImplementationClass() + "]";
  }

  @JIT
  public static boolean testMetaclass(RubyClass metaclass, IRubyObject self) {
    return metaclass == ((RubyBasicObject) self).getMetaClass();
  }

  @JIT
  public static boolean testClass(Object object, Class clazz) {
    return object.getClass() == clazz;
  }

  private static final MethodHandle TEST_CLASS =
      Binder.from(boolean.class, Object.class, Class.class)
          .invokeStaticQuiet(lookup(), InvokeSite.class, "testClass");
}
Esempio n. 12
0
/** @author headius */
public class ASTInspector {

  private static final Logger LOG = LoggerFactory.getLogger("ASTInspector");

  private final boolean dump;
  private final String name;

  public ASTInspector() {
    dump = false;
    name = null;
  }

  public ASTInspector(String name, boolean dump) {
    this.name = name;
    this.dump = dump;
  }

  private static final boolean DEBUG = false;

  enum Flag {
    BLOCK_ARG(0x1), // block argument to the method
    CLOSURE(0x2), // closure present
    CLASS(0x4), // class present
    METHOD(0x8), // method table mutations, def, defs, undef, alias
    EVAL(0x10), // likely call to eval
    FRAME_AWARE(0x20), // makes calls that are aware of the frame
    FRAME_SELF(0x40), // makes calls that are aware of the frame's self
    FRAME_VISIBILITY(0x80), // makes calls that are aware of the frame's visibility
    FRAME_BLOCK(0x100), // makes calls that are aware of the frame's block
    FRAME_NAME(0x200), // makes calls that are aware of the frame's name
    BACKREF(0x400), // makes calls that set or get backref
    LASTLINE(0x800), // makes calls that set or get lastline
    FRAME_CLASS(0x1000), // makes calls that are aware of the frame's class
    OPT_ARGS(0x2000), // optional arguments to the method
    REST_ARG(0x4000), // rest arg to the method
    SCOPE_AWARE(0x8000), // makes calls that are aware of the scope
    ZSUPER(0x10000), // makes a zero-argument super call
    CONSTANT(0x20000), // accesses or sets constants
    CLASS_VAR(0x40000), // accesses or sets class variables
    SUPER(0x80000), // makes normal super call
    RETRY(0x100000); // contains a retry

    private Flag(int value) {
      flag = value;
    }

    public final int flag;
  }

  public static final Flag BLOCK_ARG = Flag.BLOCK_ARG;
  public static final Flag CLOSURE = Flag.CLOSURE;
  public static final Flag CLASS = Flag.CLASS;
  public static final Flag METHOD = Flag.METHOD;
  public static final Flag EVAL = Flag.EVAL;
  public static final Flag FRAME_AWARE = Flag.FRAME_AWARE;
  public static final Flag FRAME_SELF = Flag.FRAME_SELF;
  public static final Flag FRAME_VISIBILITY = Flag.FRAME_VISIBILITY;
  public static final Flag FRAME_BLOCK = Flag.FRAME_BLOCK;
  public static final Flag FRAME_NAME = Flag.FRAME_NAME;
  public static final Flag BACKREF = Flag.BACKREF;
  public static final Flag LASTLINE = Flag.LASTLINE;
  public static final Flag FRAME_CLASS = Flag.FRAME_CLASS;
  public static final Flag OPT_ARGS = Flag.OPT_ARGS;
  public static final Flag REST_ARG = Flag.REST_ARG;
  public static final Flag SCOPE_AWARE = Flag.SCOPE_AWARE;
  public static final Flag ZSUPER = Flag.ZSUPER;
  public static final Flag CONSTANT = Flag.CONSTANT;
  public static final Flag CLASS_VAR = Flag.CLASS_VAR;
  public static final Flag SUPER = Flag.SUPER;
  public static final Flag RETRY = Flag.RETRY;

  private static final String[] MODIFIER_NAMES = {
    "BLOCK",
    "CLOSURE",
    "CLASS",
    "METHOD",
    "EVAL",
    "FRAME_AWARE",
    "FRAME_SELF",
    "FRAME_VISIBILITY",
    "FRAME_BLOCK",
    "FRAME_NAME",
    "BACKREF",
    "LASTLINE",
    "FRAME_CLASS",
    "OPT_ARGS",
    "REST_ARG",
    "SCOPE_AWARE",
    "ZSUPER",
    "CONSTANT",
    "CLASS_VAR",
    "SUPER",
    "RETRY"
  };

  private int flags;

  // pragmas
  private boolean noFrame;

  public static final Set<String> FRAME_AWARE_METHODS =
      Collections.synchronizedSet(new HashSet<String>());
  public static final Set<String> SCOPE_AWARE_METHODS =
      Collections.synchronizedSet(new HashSet<String>());

  public static void addFrameAwareMethods(String... methods) {
    if (DEBUG) LOG.debug("Adding frame-aware method names: {}", Arrays.toString(methods));
    FRAME_AWARE_METHODS.addAll(Arrays.asList(methods));
  }

  public static void addScopeAwareMethods(String... methods) {
    if (DEBUG) LOG.debug("Adding scope-aware method names: {}", Arrays.toString(methods));
    SCOPE_AWARE_METHODS.addAll(Arrays.asList(methods));
  }

  public static final Set<String> PRAGMAS = Collections.synchronizedSet(new HashSet<String>());

  static {
    FRAME_AWARE_METHODS.add("eval");
    FRAME_AWARE_METHODS.add("module_eval");
    FRAME_AWARE_METHODS.add("class_eval");
    FRAME_AWARE_METHODS.add("instance_eval");
    FRAME_AWARE_METHODS.add("binding");
    FRAME_AWARE_METHODS.add("public");
    FRAME_AWARE_METHODS.add("private");
    FRAME_AWARE_METHODS.add("protected");
    FRAME_AWARE_METHODS.add("module_function");
    FRAME_AWARE_METHODS.add("block_given?");
    FRAME_AWARE_METHODS.add("iterator?");

    SCOPE_AWARE_METHODS.addAll(RubyModule.SCOPE_CAPTURING_METHODS);

    PRAGMAS.add("__NOFRAME__");
  }

  public void disable() {
    if (dump) LOG.debug("[ASTInspector] {} DISABLED", name);
    flags = 0xFFFFFFFF;
  }

  public CallConfiguration getCallConfig() {
    if (!noFrame()
        && (hasFrameAwareMethods() || hasClosure() || RubyInstanceConfig.FULL_TRACE_ENABLED)) {
      // We're doing normal framed compilation or the method needs a frame
      if (hasClosure() || hasScopeAwareMethods()) {
        // The method also needs a scope, do both
        return CallConfiguration.FrameFullScopeFull;
      } else {
        // The method doesn't need a scope or static scope; frame only
        return CallConfiguration.FrameFullScopeNone;
      }
    } else {
      if (hasClosure() || hasScopeAwareMethods()) {
        return CallConfiguration.FrameNoneScopeFull;
      } else {
        return CallConfiguration.FrameNoneScopeNone;
      }
    }
  }

  /**
   * Perform an inspection of a subtree or set of subtrees separate from the parent inspection, to
   * make independent decisions based on that subtree(s).
   *
   * @param nodes The child nodes to walk with a new inspector
   * @return The new inspector resulting from the walk
   */
  public ASTInspector subInspect(Node... nodes) {
    ASTInspector newInspector = new ASTInspector(name, dump);

    for (Node node : nodes) {
      newInspector.inspect(node);
    }

    return newInspector;
  }

  public boolean getFlag(Flag modifier) {
    return (flags & modifier.flag) != 0;
  }

  public boolean getFlag(Flag... modifiers) {
    int mask = 0;
    for (Flag flag : modifiers) {
      mask |= flag.flag;
    }
    return (flags & mask) != 0;
  }

  public void setFlag(Flag modifier) {
    if (dump) {
      LOG.info("[ASTInspector] " + name + "\n\tset flag " + modifier);
    }
    flags |= modifier.flag;
  }

  public void setFlag(Node node, Flag modifier) {
    if (dump) {
      LOG.info(
          "[ASTInspector] "
              + name
              + "\n\tset flag "
              + modifier
              + " because of "
              + node.getNodeType()
              + " at "
              + node.getPosition());
    }
    flags |= modifier.flag;
  }

  /**
   * Integrate the results of a separate inspection into the state of this inspector.
   *
   * @param other The other inspector whose state to integrate.
   */
  public void integrate(ASTInspector other) {
    flags |= other.flags;
  }

  public void inspect(Node node) {
    if (RubyInstanceConfig.FULL_TRACE_ENABLED) {
      disable();
      // we still inspect since some nodes change state as a result (JRUBY-6836)
    }

    if (node == null) return;

    switch (node.getNodeType()) {
      case ALIASNODE:
        setFlag(node, METHOD);
        break;
      case ANDNODE:
        AndNode andNode = (AndNode) node;
        inspect(andNode.getFirstNode());
        inspect(andNode.getSecondNode());
        break;
      case ARGSCATNODE:
        ArgsCatNode argsCatNode = (ArgsCatNode) node;
        inspect(argsCatNode.getFirstNode());
        inspect(argsCatNode.getSecondNode());
        break;
      case ARGSPUSHNODE:
        ArgsPushNode argsPushNode = (ArgsPushNode) node;
        inspect(argsPushNode.getFirstNode());
        inspect(argsPushNode.getSecondNode());
        break;
      case ARGUMENTNODE:
        break;
      case ARRAYNODE:
      case BLOCKNODE:
      case DREGEXPNODE:
      case DSTRNODE:
      case DSYMBOLNODE:
      case DXSTRNODE:
      case LISTNODE:
        ListNode listNode = (ListNode) node;
        for (int i = 0; i < listNode.size(); i++) {
          inspect(listNode.get(i));
        }
        break;
      case ARGSNODE:
        ArgsNode argsNode = (ArgsNode) node;
        if (argsNode.getBlock() != null) setFlag(node, BLOCK_ARG);
        if (argsNode.getOptArgs() != null) {
          setFlag(node, OPT_ARGS);
          inspect(argsNode.getOptArgs());
        }
        if (argsNode.getRestArg() == -2 || argsNode.getRestArg() >= 0) setFlag(node, REST_ARG);
        break;
      case ATTRASSIGNNODE:
        AttrAssignNode attrAssignNode = (AttrAssignNode) node;
        inspect(attrAssignNode.getArgsNode());
        inspect(attrAssignNode.getReceiverNode());
        break;
      case BACKREFNODE:
        setFlag(node, BACKREF);
        break;
      case BEGINNODE:
        inspect(((BeginNode) node).getBodyNode());
        break;
      case BIGNUMNODE:
        break;
      case BINARYOPERATORNODE:
        BinaryOperatorNode binaryOperatorNode = (BinaryOperatorNode) node;
        inspect(binaryOperatorNode.getFirstNode());
        inspect(binaryOperatorNode.getSecondNode());
        break;
      case BLOCKARGNODE:
        break;
      case BLOCKPASSNODE:
        BlockPassNode blockPassNode = (BlockPassNode) node;
        inspect(blockPassNode.getArgsNode());
        inspect(blockPassNode.getBodyNode());
        break;
      case BREAKNODE:
        inspect(((BreakNode) node).getValueNode());
        break;
      case CALLNODE:
        CallNode callNode = (CallNode) node;
        inspect(callNode.getReceiverNode());
        // check for Proc.new, an especially magic method
        if (callNode.getName() == "new"
            && callNode.getReceiverNode() instanceof ConstNode
            && ((ConstNode) callNode.getReceiverNode()).getName() == "Proc") {
          // Proc.new needs the caller's block to instantiate a proc
          setFlag(node, FRAME_BLOCK);
        }
        if (callNode.getArgsNode() == null && callNode.getIterNode() == null) {
          switch (callNode.getReceiverNode().getNodeType()) {
              // no unary methods on literal numbers, symbols, or strings have frame/scope effects
            case FIXNUMNODE:
            case FLOATNODE:
            case BIGNUMNODE:
            case STRNODE:
            case SYMBOLNODE:
              return;
          }
        }
      case FCALLNODE:
        inspect(((IArgumentNode) node).getArgsNode());
        inspect(((BlockAcceptingNode) node).getIterNode());
      case VCALLNODE:
        INameNode nameNode = (INameNode) node;
        if (FRAME_AWARE_METHODS.contains(nameNode.getName())) {
          setFlag(node, FRAME_AWARE);
          if (nameNode.getName().indexOf("eval") != -1) {
            setFlag(node, EVAL);
          }
        }
        if (SCOPE_AWARE_METHODS.contains(nameNode.getName())) {
          setFlag(node, SCOPE_AWARE);
        }
        break;
      case CASENODE:
        CaseNode caseNode = (CaseNode) node;
        inspect(caseNode.getCaseNode());
        if (caseNode.getCases().size() > Options.COMPILE_OUTLINE_CASECOUNT.load()) {
          // if more than N cases, disable; we'll compile them as separate bodies
          // see BaseBodyCompiler#compiledSequencedConditional and ASTCompiler#compileCase
          disable();
          return;
        } else {
          for (Node when : caseNode.getCases().childNodes()) {
            inspect(when);
          }
          inspect(caseNode.getElseNode());
        }
        break;
      case CLASSNODE:
        setFlag(node, CLASS);
        ClassNode classNode = (ClassNode) node;
        inspect(classNode.getCPath());
        inspect(classNode.getSuperNode());
        break;
      case CLASSVARNODE:
        setFlag(node, CLASS_VAR);
        break;
      case CONSTDECLNODE:
        inspect(((AssignableNode) node).getValueNode());
        setFlag(node, CONSTANT);
        break;
      case CLASSVARASGNNODE:
        inspect(((AssignableNode) node).getValueNode());
        setFlag(node, CLASS_VAR);
        break;
      case CLASSVARDECLNODE:
        inspect(((AssignableNode) node).getValueNode());
        setFlag(node, CLASS_VAR);
        break;
      case COLON2NODE:
        inspect(((Colon2Node) node).getLeftNode());
        break;
      case COLON3NODE:
        break;
      case CONSTNODE:
        setFlag(node, CONSTANT);
        break;
      case DEFNNODE:
      case DEFSNODE:
        setFlag(node, METHOD);
        setFlag(node, FRAME_VISIBILITY);
        setFlag(node, SCOPE_AWARE);
        break;
      case DEFINEDNODE:
        switch (((DefinedNode) node).getExpressionNode().getNodeType()) {
          case CLASSVARASGNNODE:
          case CLASSVARDECLNODE:
          case CONSTDECLNODE:
          case DASGNNODE:
          case GLOBALASGNNODE:
          case LOCALASGNNODE:
          case MULTIPLEASGNNODE:
          case OPASGNNODE:
          case OPELEMENTASGNNODE:
          case DVARNODE:
          case FALSENODE:
          case TRUENODE:
          case LOCALVARNODE:
          case INSTVARNODE:
          case BACKREFNODE:
          case SELFNODE:
          case VCALLNODE:
          case YIELDNODE:
          case GLOBALVARNODE:
          case CONSTNODE:
          case FCALLNODE:
          case CLASSVARNODE:
            // ok, we have fast paths
            inspect(((DefinedNode) node).getExpressionNode());
            break;
          default:
            // long, slow way causes disabling
            // we still inspect because some nodes may change state (JRUBY-6836)
            inspect(((DefinedNode) node).getExpressionNode());
            disable();
        }
        break;
      case DOTNODE:
        DotNode dotNode = (DotNode) node;
        inspect(dotNode.getBeginNode());
        inspect(dotNode.getEndNode());
        break;
      case DASGNNODE:
        inspect(((AssignableNode) node).getValueNode());
        break;
      case DVARNODE:
        break;
      case ENSURENODE:
        inspect(((EnsureNode) node).getBodyNode());
        inspect(((EnsureNode) node).getEnsureNode());
        disable();
        break;
      case ENCODINGNODE:
        break;
      case EVSTRNODE:
        inspect(((EvStrNode) node).getBody());
        break;
      case FALSENODE:
        break;
      case FIXNUMNODE:
        break;
      case FLIPNODE:
        inspect(((FlipNode) node).getBeginNode());
        inspect(((FlipNode) node).getEndNode());
        break;
      case FLOATNODE:
        break;
      case FORNODE:
        setFlag(node, CLOSURE);
        setFlag(node, SCOPE_AWARE);
        inspect(((ForNode) node).getIterNode());
        inspect(((ForNode) node).getBodyNode());
        inspect(((ForNode) node).getVarNode());
        break;
      case GLOBALASGNNODE:
        GlobalAsgnNode globalAsgnNode = (GlobalAsgnNode) node;
        if (globalAsgnNode.getName().equals("$_")) {
          setFlag(node, LASTLINE);
        } else if (globalAsgnNode.getName().equals("$~")) {
          setFlag(node, BACKREF);
        }
        inspect(globalAsgnNode.getValueNode());
        break;
      case GLOBALVARNODE:
        {
          String name = ((GlobalVarNode) node).getName();
          if (name.equals("$_") || name.equals("$LAST_READ_LINE")) {
            setFlag(node, LASTLINE);
          } else if (name.equals("$~")
              || name.equals("$`")
              || name.equals("$'")
              || name.equals("$+")
              || name.equals("$LAST_MATCH_INFO")
              || name.equals("$PREMATCH")
              || name.equals("$POSTMATCH")
              || name.equals("$LAST_PAREN_MATCH")) {
            setFlag(node, BACKREF);
          }
          break;
        }
      case HASHNODE:
        HashNode hashNode = (HashNode) node;
        inspect(hashNode.getListNode());
        break;
      case IFNODE:
        IfNode ifNode = (IfNode) node;
        inspect(ifNode.getCondition());
        inspect(ifNode.getThenBody());
        inspect(ifNode.getElseBody());
        break;
      case INSTASGNNODE:
        inspect(((AssignableNode) node).getValueNode());
        break;
      case INSTVARNODE:
        break;
      case ISCOPINGNODE:
        IScopingNode iscopingNode = (IScopingNode) node;
        inspect(iscopingNode.getCPath());
        break;
      case ITERNODE:
        setFlag(node, CLOSURE);
        break;
      case LAMBDANODE:
        setFlag(node, CLOSURE);
        break;
      case LOCALASGNNODE:
        LocalAsgnNode localAsgnNode = (LocalAsgnNode) node;
        if (PRAGMAS.contains(localAsgnNode.getName())) {
          if (localAsgnNode.getName().equals("__NOFRAME__")) {
            noFrame = localAsgnNode.getValueNode() instanceof TrueNode;
          }
          break;
        }
        inspect(localAsgnNode.getValueNode());
        break;
      case LOCALVARNODE:
        break;
      case MATCHNODE:
        inspect(((MatchNode) node).getRegexpNode());
        setFlag(node, BACKREF);
        break;
      case MATCH2NODE:
        Match2Node match2Node = (Match2Node) node;
        inspect(match2Node.getReceiverNode());
        inspect(match2Node.getValueNode());
        setFlag(node, BACKREF);
        if (match2Node instanceof Match2CaptureNode) {
          // additionally need scope, to set local vars
          // FIXME: this can be done without heap scope
          setFlag(node, SCOPE_AWARE);
        }
        break;
      case MATCH3NODE:
        Match3Node match3Node = (Match3Node) node;
        inspect(match3Node.getReceiverNode());
        inspect(match3Node.getValueNode());
        setFlag(node, BACKREF);
        break;
      case MODULENODE:
        setFlag(node, CLASS);
        inspect(((ModuleNode) node).getCPath());
        break;
      case MULTIPLEASGN19NODE:
        MultipleAsgn19Node multipleAsgn19Node = (MultipleAsgn19Node) node;
        inspect(multipleAsgn19Node.getPre());
        inspect(multipleAsgn19Node.getPost());
        inspect(multipleAsgn19Node.getRest());
        inspect(multipleAsgn19Node.getValueNode());
        break;
      case MULTIPLEASGNNODE:
        MultipleAsgnNode multipleAsgnNode = (MultipleAsgnNode) node;
        inspect(multipleAsgnNode.getArgsNode());
        inspect(multipleAsgnNode.getHeadNode());
        inspect(multipleAsgnNode.getValueNode());
        break;
      case NEWLINENODE:
        inspect(((NewlineNode) node).getNextNode());
        break;
      case NEXTNODE:
        inspect(((NextNode) node).getValueNode());
        break;
      case NILNODE:
        break;
      case NOTNODE:
        inspect(((NotNode) node).getConditionNode());
        break;
      case NTHREFNODE:
        break;
      case OPASGNANDNODE:
        OpAsgnAndNode opAsgnAndNode = (OpAsgnAndNode) node;
        inspect(opAsgnAndNode.getFirstNode());
        inspect(opAsgnAndNode.getSecondNode());
        break;
      case OPASGNNODE:
        OpAsgnNode opAsgnNode = (OpAsgnNode) node;
        inspect(opAsgnNode.getReceiverNode());
        inspect(opAsgnNode.getValueNode());
        break;
      case OPASGNORNODE:
        switch (((OpAsgnOrNode) node).getFirstNode().getNodeType()) {
          case CLASSVARASGNNODE:
          case CLASSVARDECLNODE:
          case CONSTDECLNODE:
          case DASGNNODE:
          case GLOBALASGNNODE:
          case LOCALASGNNODE:
          case MULTIPLEASGNNODE:
          case OPASGNNODE:
          case OPELEMENTASGNNODE:
          case DVARNODE:
          case FALSENODE:
          case TRUENODE:
          case LOCALVARNODE:
          case INSTVARNODE:
          case BACKREFNODE:
          case SELFNODE:
          case VCALLNODE:
          case YIELDNODE:
          case GLOBALVARNODE:
          case CONSTNODE:
          case FCALLNODE:
          case CLASSVARNODE:
            // ok, we have fast paths
            inspect(((OpAsgnOrNode) node).getSecondNode());
            break;
          default:
            // long, slow way causes disabling for defined
            inspect(((OpAsgnOrNode) node).getFirstNode());
            inspect(((OpAsgnOrNode) node).getSecondNode());
            disable();
        }
        break;
      case OPELEMENTASGNNODE:
        OpElementAsgnNode opElementAsgnNode = (OpElementAsgnNode) node;
        inspect(opElementAsgnNode.getArgsNode());
        inspect(opElementAsgnNode.getReceiverNode());
        inspect(opElementAsgnNode.getValueNode());
        break;
      case OPTARGNODE:
        inspect(((OptArgNode) node).getValue());
        break;
      case ORNODE:
        OrNode orNode = (OrNode) node;
        inspect(orNode.getFirstNode());
        inspect(orNode.getSecondNode());
        break;
      case POSTEXENODE:
        PostExeNode postExeNode = (PostExeNode) node;
        setFlag(node, CLOSURE);
        setFlag(node, SCOPE_AWARE);
        inspect(postExeNode.getBodyNode());
        inspect(postExeNode.getVarNode());
        break;
      case PREEXENODE:
        PreExeNode preExeNode = (PreExeNode) node;
        setFlag(node, CLOSURE);
        setFlag(node, SCOPE_AWARE);
        inspect(preExeNode.getBodyNode());
        inspect(preExeNode.getVarNode());
        break;
      case REDONODE:
        break;
      case REGEXPNODE:
        break;
      case ROOTNODE:
        inspect(((RootNode) node).getBodyNode());
        if (((RootNode) node).getBodyNode() instanceof BlockNode) {
          BlockNode blockNode = (BlockNode) ((RootNode) node).getBodyNode();
          if (blockNode.size() > 500) {
            // method has more than 500 lines; we'll need to split it
            // and therefore need to use a heap-based scope
            setFlag(node, SCOPE_AWARE);
          }
        }
        break;
      case RESCUEBODYNODE:
        RescueBodyNode rescueBody = (RescueBodyNode) node;
        inspect(rescueBody.getExceptionNodes());
        inspect(rescueBody.getBodyNode());
        inspect(rescueBody.getOptRescueNode());
        break;
      case RESCUENODE:
        RescueNode rescueNode = (RescueNode) node;
        inspect(rescueNode.getBodyNode());
        inspect(rescueNode.getElseNode());
        inspect(rescueNode.getRescueNode());
        disable();
        break;
      case RETRYNODE:
        setFlag(node, RETRY);
        break;
      case RETURNNODE:
        inspect(((ReturnNode) node).getValueNode());
        break;
      case SCLASSNODE:
        setFlag(node, CLASS);
        setFlag(node, FRAME_AWARE);
        SClassNode sclassNode = (SClassNode) node;
        inspect(sclassNode.getReceiverNode());
        break;
      case SCOPENODE:
        break;
      case SELFNODE:
        break;
      case SPLATNODE:
        inspect(((SplatNode) node).getValue());
        break;
      case STARNODE:
        break;
      case STRNODE:
        break;
      case SUPERNODE:
        SuperNode superNode = (SuperNode) node;
        inspect(superNode.getArgsNode());
        inspect(superNode.getIterNode());
        setFlag(node, SUPER);
        break;
      case SVALUENODE:
        inspect(((SValueNode) node).getValue());
        break;
      case SYMBOLNODE:
        break;
      case TOARYNODE:
        inspect(((ToAryNode) node).getValue());
        break;
      case TRUENODE:
        break;
      case UNDEFNODE:
        setFlag(node, METHOD);
        break;
      case UNTILNODE:
        UntilNode untilNode = (UntilNode) node;
        ASTInspector untilInspector =
            subInspect(untilNode.getConditionNode(), untilNode.getBodyNode());
        // a while node could receive non-local flow control from any of these:
        // * a closure within the loop
        // * an eval within the loop
        // * a block-arg-based proc called within the loop
        if (untilInspector.getFlag(CLOSURE) || untilInspector.getFlag(EVAL)) {
          untilNode.containsNonlocalFlow = true;

          // we set scope-aware to true to force heap-based locals
          setFlag(node, SCOPE_AWARE);
        }
        integrate(untilInspector);
        break;
      case VALIASNODE:
        break;
      case WHENNODE:
        {
          inspect(((WhenNode) node).getBodyNode());
          inspect(((WhenNode) node).getExpressionNodes());
          inspect(((WhenNode) node).getNextCase());
          // if any elements are not literals or are regexp, set backref
          Node expr = ((WhenNode) node).getExpressionNodes();
          if (!(expr instanceof ILiteralNode) || expr.getNodeType() == NodeType.REGEXPNODE) {
            setFlag(node, BACKREF);
          }
          break;
        }
      case WHILENODE:
        WhileNode whileNode = (WhileNode) node;
        ASTInspector whileInspector =
            subInspect(whileNode.getConditionNode(), whileNode.getBodyNode());
        // a while node could receive non-local flow control from any of these:
        // * a closure within the loop
        // * an eval within the loop
        // * a block-arg-based proc called within the loop
        // * any case that disables optimization, like rescues and ensures
        if (whileInspector.getFlag(CLOSURE) || whileInspector.getFlag(EVAL) || getFlag(BLOCK_ARG)) {
          whileNode.containsNonlocalFlow = true;

          // we set scope-aware to true to force heap-based locals
          setFlag(node, SCOPE_AWARE);
        }
        integrate(whileInspector);
        break;
      case XSTRNODE:
        break;
      case YIELDNODE:
        inspect(((YieldNode) node).getArgsNode());
        break;
      case ZARRAYNODE:
        break;
      case ZEROARGNODE:
        break;
      case ZSUPERNODE:
        setFlag(node, SCOPE_AWARE);
        setFlag(node, ZSUPER);
        inspect(((ZSuperNode) node).getIterNode());
        break;
      default:
        // encountered a node we don't recognize, set everything to true to disable optz
        assert false : "All nodes should be accounted for in AST inspector: " + node;
        disable();
    }
  }

  public boolean hasClass() {
    return getFlag(CLASS);
  }

  public boolean hasClosure() {
    return getFlag(CLOSURE);
  }

  /**
   * Whether the tree under inspection contains any method-table mutations, including def, defs,
   * undef, and alias.
   *
   * @return True if there are mutations, false otherwise
   */
  public boolean hasMethod() {
    return getFlag(METHOD);
  }

  public boolean hasFrameAwareMethods() {
    return getFlag(
        FRAME_AWARE,
        FRAME_BLOCK,
        FRAME_CLASS,
        FRAME_NAME,
        FRAME_SELF,
        FRAME_VISIBILITY,
        CLOSURE,
        EVAL,
        ZSUPER,
        SUPER,
        BACKREF,
        LASTLINE);
  }

  public boolean hasScopeAwareMethods() {
    return getFlag(SCOPE_AWARE);
  }

  public boolean hasBlockArg() {
    return getFlag(BLOCK_ARG);
  }

  public boolean hasOptArgs() {
    return getFlag(OPT_ARGS);
  }

  public boolean hasRestArg() {
    return getFlag(REST_ARG);
  }

  public boolean hasConstant() {
    return getFlag(CONSTANT);
  }

  public boolean hasClassVar() {
    return getFlag(CLASS_VAR);
  }

  public boolean noFrame() {
    return noFrame;
  }
}
Esempio n. 13
0
public class JITCompiler implements JITCompilerMBean {
  private static final Logger LOG = LoggerFactory.getLogger("JITCompiler");

  public static final boolean USE_CACHE = true;
  public static final String RUBY_JIT_PREFIX = "rubyjit";

  public static final String CLASS_METHOD_DELIMITER = "$$";

  public static class JITCounts {
    private final AtomicLong compiledCount = new AtomicLong(0);
    private final AtomicLong successCount = new AtomicLong(0);
    private final AtomicLong failCount = new AtomicLong(0);
    private final AtomicLong abandonCount = new AtomicLong(0);
    private final AtomicLong compileTime = new AtomicLong(0);
    private final AtomicLong averageCompileTime = new AtomicLong(0);
    private final AtomicLong codeSize = new AtomicLong(0);
    private final AtomicLong averageCodeSize = new AtomicLong(0);
    private final AtomicLong largestCodeSize = new AtomicLong(0);
  }

  private final JITCounts counts = new JITCounts();
  private final ExecutorService executor =
      new ThreadPoolExecutor(
          2, // always two threads
          2,
          0, // never stop
          TimeUnit.SECONDS,
          new LinkedBlockingQueue<Runnable>(),
          new DaemonThreadFactory("JRubyJIT", Thread.MIN_PRIORITY));

  private final Ruby runtime;
  private final RubyInstanceConfig config;

  public JITCompiler(Ruby runtime) {
    this.runtime = runtime;
    this.config = runtime.getInstanceConfig();

    runtime.getBeanManager().register(this);
  }

  public long getSuccessCount() {
    return counts.successCount.get();
  }

  public long getCompileCount() {
    return counts.compiledCount.get();
  }

  public long getFailCount() {
    return counts.failCount.get();
  }

  public long getCompileTime() {
    return counts.compileTime.get() / 1000;
  }

  public long getAbandonCount() {
    return counts.abandonCount.get();
  }

  public long getCodeSize() {
    return counts.codeSize.get();
  }

  public long getAverageCodeSize() {
    return counts.averageCodeSize.get();
  }

  public long getAverageCompileTime() {
    return counts.averageCompileTime.get() / 1000;
  }

  public long getLargestCodeSize() {
    return counts.largestCodeSize.get();
  }

  public void tryJIT(
      DefaultMethod method, ThreadContext context, String className, String methodName) {
    if (!config.getCompileMode().shouldJIT()) return;

    if (method.incrementCallCount() < config.getJitThreshold()) return;

    jitThresholdReached(method, config, context, className, methodName);
  }

  public void tearDown() {
    if (executor != null) {
      try {
        executor.shutdown();
      } catch (SecurityException se) {
        // ignore, can't shut down executor
      }
    }
  }

  private void jitThresholdReached(
      final DefaultMethod method,
      final RubyInstanceConfig config,
      ThreadContext context,
      final String className,
      final String methodName) {
    // Disable any other jit tasks from entering queue
    method.setCallCount(-1);

    final Ruby runtime = context.runtime;

    Runnable jitTask = new JITTask(className, method, methodName);

    // if background JIT is enabled and threshold is > 0 and we have an executor...
    if (config.getJitBackground() && config.getJitThreshold() > 0 && executor != null) {
      // JIT in background
      try {
        executor.submit(jitTask);
      } catch (RejectedExecutionException ree) {
        // failed to submit, just run it directly
        jitTask.run();
      }
    } else {
      // just run directly
      jitTask.run();
    }
  }

  private class JITTask implements Runnable {
    private final String className;
    private final DefaultMethod method;
    private final String methodName;

    public JITTask(String className, DefaultMethod method, String methodName) {
      this.className = className;
      this.method = method;
      this.methodName = methodName;
    }

    public void run() {
      try {
        // The cache is full. Abandon JIT for this method and bail out.
        ClassCache classCache = config.getClassCache();
        if (classCache.isFull()) {
          counts.abandonCount.incrementAndGet();
          return;
        }

        // Check if the method has been explicitly excluded
        if (config.getExcludedMethods().size() > 0) {
          String excludeModuleName = className;
          if (method.getImplementationClass().isSingleton()) {
            IRubyObject possibleRealClass =
                ((MetaClass) method.getImplementationClass()).getAttached();
            if (possibleRealClass instanceof RubyModule) {
              excludeModuleName = "Meta:" + ((RubyModule) possibleRealClass).getName();
            }
          }

          if ((config.getExcludedMethods().contains(excludeModuleName)
              || config.getExcludedMethods().contains(excludeModuleName + "#" + methodName)
              || config.getExcludedMethods().contains(methodName))) {
            method.setCallCount(-1);
            log(method, methodName, "skipping method: " + excludeModuleName + "#" + methodName);
            return;
          }
        }

        String key = SexpMaker.create(methodName, method.getArgsNode(), method.getBodyNode());
        JITClassGenerator generator =
            new JITClassGenerator(className, methodName, key, runtime, method, counts);

        Class<Script> sourceClass =
            (Class<Script>)
                config.getClassCache().cacheClassByKey(generator.digestString, generator);

        if (sourceClass == null) {
          // class could not be found nor generated; give up on JIT and bail out
          counts.failCount.incrementAndGet();
          return;
        }

        // successfully got back a jitted method
        counts.successCount.incrementAndGet();

        // finally, grab the script
        Script jitCompiledScript = sourceClass.newInstance();

        // set root scope
        jitCompiledScript.setRootScope(method.getStaticScope());

        // add to the jitted methods set
        Set<Script> jittedMethods = runtime.getJittedMethods();
        jittedMethods.add(jitCompiledScript);

        // logEvery n methods based on configuration
        if (config.getJitLogEvery() > 0) {
          int methodCount = jittedMethods.size();
          if (methodCount % config.getJitLogEvery() == 0) {
            log(method, methodName, "live compiled methods: " + methodCount);
          }
        }

        if (config.isJitLogging()) {
          log(method, className + "." + methodName, "done jitting");
        }

        method.switchToJitted(jitCompiledScript, generator.callConfig());
        return;
      } catch (Throwable t) {
        if (runtime.getDebug().isTrue()) {
          t.printStackTrace();
        }
        if (config.isJitLoggingVerbose()) {
          log(method, className + "." + methodName, "could not compile", t.getMessage());
        }

        counts.failCount.incrementAndGet();
        return;
      }
    }
  }

  public static String getHashForString(String str) {
    return getHashForBytes(RubyEncoding.encodeUTF8(str));
  }

  public static String getHashForBytes(byte[] bytes) {
    try {
      MessageDigest sha1 = MessageDigest.getInstance("SHA1");
      sha1.update(bytes);
      byte[] digest = sha1.digest();
      StringBuilder builder = new StringBuilder();
      for (int i = 0; i < digest.length; i++) {
        builder.append(Integer.toString((digest[i] & 0xff) + 0x100, 16).substring(1));
      }
      return builder.toString().toUpperCase(Locale.ENGLISH);
    } catch (NoSuchAlgorithmException nsae) {
      throw new RuntimeException(nsae);
    }
  }

  public static void saveToCodeCache(
      Ruby ruby, byte[] bytecode, String packageName, File cachedClassFile) {
    String codeCache = RubyInstanceConfig.JIT_CODE_CACHE;
    File codeCacheDir = new File(codeCache);
    if (!codeCacheDir.exists()) {
      ruby.getWarnings().warn("jruby.jit.codeCache directory " + codeCacheDir + " does not exist");
    } else if (!codeCacheDir.isDirectory()) {
      ruby.getWarnings()
          .warn("jruby.jit.codeCache directory " + codeCacheDir + " is not a directory");
    } else if (!codeCacheDir.canWrite()) {
      ruby.getWarnings().warn("jruby.jit.codeCache directory " + codeCacheDir + " is not writable");
    } else {
      if (!new File(codeCache, packageName).isDirectory()) {
        boolean createdDirs = new File(codeCache, packageName).mkdirs();
        if (!createdDirs) {
          ruby.getWarnings()
              .warn("could not create JIT cache dir: " + new File(codeCache, packageName));
        }
      }
      // write to code cache
      FileOutputStream fos = null;
      try {
        if (RubyInstanceConfig.JIT_LOADING_DEBUG)
          LOG.info("writing jitted code to to " + cachedClassFile);
        fos = new FileOutputStream(cachedClassFile);
        fos.write(bytecode);
      } catch (Exception e) {
        e.printStackTrace();
        // ignore
      } finally {
        try {
          fos.close();
        } catch (Exception e) {
        }
      }
    }
  }

  public static class JITClassGenerator implements ClassCache.ClassGenerator {
    public JITClassGenerator(
        String className,
        String methodName,
        String key,
        Ruby ruby,
        DefaultMethod method,
        JITCounts counts) {
      this.packageName = JITCompiler.RUBY_JIT_PREFIX;
      if (RubyInstanceConfig.JAVA_VERSION == Opcodes.V1_7) {
        // recent Java 7 seems to have a bug that leaks definitions across cousin classloaders
        // so we force the class name to be unique to this runtime
        digestString = getHashForString(key) + Math.abs(ruby.hashCode());
      } else {
        digestString = getHashForString(key);
      }
      this.className =
          packageName
              + "/"
              + className.replace('.', '/')
              + CLASS_METHOD_DELIMITER
              + JavaNameMangler.mangleMethodName(methodName)
              + "_"
              + digestString;
      this.name = this.className.replaceAll("/", ".");
      this.bodyNode = method.getBodyNode();
      this.argsNode = method.getArgsNode();
      this.methodName = methodName;
      filename = calculateFilename(argsNode, bodyNode);
      staticScope = method.getStaticScope();
      asmCompiler = new StandardASMCompiler(this.className, filename);
      this.ruby = ruby;
      this.counts = counts;
    }

    @SuppressWarnings("unchecked")
    protected void compile() {
      if (bytecode != null) return;

      // check if we have a cached compiled version on disk
      String codeCache = RubyInstanceConfig.JIT_CODE_CACHE;
      File cachedClassFile = new File(codeCache + "/" + className + ".class");

      if (codeCache != null && cachedClassFile.exists()) {
        FileInputStream fis = null;
        try {
          if (RubyInstanceConfig.JIT_LOADING_DEBUG)
            LOG.info("loading cached code from: " + cachedClassFile);
          fis = new FileInputStream(cachedClassFile);
          bytecode = new byte[(int) fis.getChannel().size()];
          fis.read(bytecode);
          name = new ClassReader(bytecode).getClassName();
          return;
        } catch (Exception e) {
          // ignore and proceed to compile
        } finally {
          try {
            fis.close();
          } catch (Exception e) {
          }
        }
      }

      // Time the compilation
      long start = System.nanoTime();

      asmCompiler.startScript(staticScope);
      final ASTCompiler compiler = ruby.getInstanceConfig().newCompiler();

      CompilerCallback args =
          new CompilerCallback() {
            public void call(BodyCompiler context) {
              compiler.compileArgs(argsNode, context, true);
            }
          };

      ASTInspector inspector = new ASTInspector();
      if (ruby.getInstanceConfig().isJitDumping()) {
        inspector = new ASTInspector(className, true);
      }
      // check args first, since body inspection can depend on args
      inspector.inspect(argsNode);
      inspector.inspect(bodyNode);

      BodyCompiler methodCompiler;
      if (bodyNode != null) {
        // we have a body, do a full-on method
        methodCompiler = asmCompiler.startFileMethod(args, staticScope, inspector);
        compiler.compileBody(bodyNode, methodCompiler, true);
      } else {
        // If we don't have a body, check for required or opt args
        // if opt args, they could have side effects
        // if required args, need to raise errors if too few args passed
        // otherwise, method does nothing, make it a nop
        if (argsNode != null
            && (argsNode.getRequiredArgsCount() > 0 || argsNode.getOptionalArgsCount() > 0)) {
          methodCompiler = asmCompiler.startFileMethod(args, staticScope, inspector);
          methodCompiler.loadNil();
        } else {
          methodCompiler = asmCompiler.startFileMethod(null, staticScope, inspector);
          methodCompiler.loadNil();
          jitCallConfig = CallConfiguration.FrameNoneScopeNone;
        }
      }
      methodCompiler.endBody();
      asmCompiler.endScript(false, false);

      // if we haven't already decided on a do-nothing call
      if (jitCallConfig == null) {
        jitCallConfig = inspector.getCallConfig();
      }

      bytecode = asmCompiler.getClassByteArray();
      if (ruby.getInstanceConfig().isJitDumping()) {
        TraceClassVisitor tcv = new TraceClassVisitor(new PrintWriter(System.out));
        new ClassReader(bytecode).accept(tcv, 0);
      }

      if (bytecode.length > ruby.getInstanceConfig().getJitMaxSize()) {
        bytecode = null;
        throw new NotCompilableException(
            "JITed method size exceeds configured max of "
                + ruby.getInstanceConfig().getJitMaxSize());
      }

      if (codeCache != null) {
        JITCompiler.saveToCodeCache(ruby, bytecode, packageName, cachedClassFile);
      }

      counts.compiledCount.incrementAndGet();
      counts.compileTime.addAndGet(System.nanoTime() - start);
      counts.codeSize.addAndGet(bytecode.length);
      counts.averageCompileTime.set(counts.compileTime.get() / counts.compiledCount.get());
      counts.averageCodeSize.set(counts.codeSize.get() / counts.compiledCount.get());
      synchronized (counts) {
        if (counts.largestCodeSize.get() < bytecode.length) {
          counts.largestCodeSize.set(bytecode.length);
        }
      }
    }

    public void generate() {
      compile();
    }

    public byte[] bytecode() {
      return bytecode;
    }

    public String name() {
      return name;
    }

    public CallConfiguration callConfig() {
      compile();
      return jitCallConfig;
    }

    @Override
    public String toString() {
      return methodName
          + "() at "
          + bodyNode.getPosition().getFile()
          + ":"
          + bodyNode.getPosition().getLine();
    }

    private final StandardASMCompiler asmCompiler;
    private final StaticScope staticScope;
    private final Node bodyNode;
    private final ArgsNode argsNode;
    private final Ruby ruby;
    private final String packageName;
    private final String className;
    private final String filename;
    private final String methodName;
    private final JITCounts counts;
    private final String digestString;

    private CallConfiguration jitCallConfig;
    private byte[] bytecode;
    private String name;
  }

  public Block newCompiledClosure(ThreadContext context, IterNode iterNode, IRubyObject self) {
    Binding binding = context.currentBinding(self);
    NodeType argsNodeId = getArgumentTypeWackyHack(iterNode);

    boolean hasMultipleArgsHead = false;
    if (iterNode.getVarNode() instanceof MultipleAsgnNode) {
      hasMultipleArgsHead = ((MultipleAsgnNode) iterNode.getVarNode()).getHeadNode() != null;
    }

    BlockBody body =
        new CompiledBlock(
            Arity.procArityOf(iterNode.getVarNode()),
            iterNode.getScope(),
            compileBlock(
                context,
                new StandardASMCompiler("blahfooblah" + System.currentTimeMillis(), "blahfooblah"),
                iterNode),
            hasMultipleArgsHead,
            BlockBody.asArgumentType(argsNodeId));
    return new Block(body, binding);
  }

  public BlockBody newCompiledBlockBody(
      ThreadContext context, IterNode iterNode, Arity arity, int argumentType) {
    NodeType argsNodeId = getArgumentTypeWackyHack(iterNode);

    boolean hasMultipleArgsHead = false;
    if (iterNode.getVarNode() instanceof MultipleAsgnNode) {
      hasMultipleArgsHead = ((MultipleAsgnNode) iterNode.getVarNode()).getHeadNode() != null;
    }
    return new CompiledBlock(
        Arity.procArityOf(iterNode.getVarNode()),
        iterNode.getScope(),
        compileBlock(
            context,
            new StandardASMCompiler("blahfooblah" + System.currentTimeMillis(), "blahfooblah"),
            iterNode),
        hasMultipleArgsHead,
        BlockBody.asArgumentType(argsNodeId));
  }

  // ENEBO: Some of this logic should be put back into the Nodes themselves, but the more
  // esoteric features of 1.9 make this difficult to know how to do this yet.
  public BlockBody newCompiledBlockBody19(ThreadContext context, IterNode iterNode) {
    final ArgsNode argsNode = (ArgsNode) iterNode.getVarNode();

    boolean hasMultipleArgsHead = false;
    if (iterNode.getVarNode() instanceof MultipleAsgnNode) {
      hasMultipleArgsHead = ((MultipleAsgnNode) iterNode.getVarNode()).getHeadNode() != null;
    }

    NodeType argsNodeId = BlockBody.getArgumentTypeWackyHack(iterNode);

    return new CompiledBlock19(
        ((ArgsNode) iterNode.getVarNode()).getArity(),
        iterNode.getScope(),
        compileBlock19(
            context,
            new StandardASMCompiler("blahfooblah" + System.currentTimeMillis(), "blahfooblah"),
            iterNode),
        hasMultipleArgsHead,
        BlockBody.asArgumentType(argsNodeId),
        Helpers.encodeParameterList(argsNode).split(";"));
  }

  public CompiledBlockCallback compileBlock(
      ThreadContext context, StandardASMCompiler asmCompiler, final IterNode iterNode) {
    final ASTCompiler astCompiler = new ASTCompiler();
    final StaticScope scope = iterNode.getScope();

    asmCompiler.startScript(scope);

    // create the closure class and instantiate it
    final CompilerCallback closureBody =
        new CompilerCallback() {

          public void call(BodyCompiler context) {
            if (iterNode.getBodyNode() != null) {
              astCompiler.compile(iterNode.getBodyNode(), context, true);
            } else {
              context.loadNil();
            }
          }
        };

    // create the closure class and instantiate it
    final CompilerCallback closureArgs =
        new CompilerCallback() {
          public void call(BodyCompiler context) {
            if (iterNode.getVarNode() != null) {
              astCompiler.compileAssignment(iterNode.getVarNode(), context);
            } else {
              context.consumeCurrentValue();
            }

            if (iterNode.getBlockVarNode() != null) {
              astCompiler.compileAssignment(iterNode.getBlockVarNode(), context);
            } else {
              context.consumeCurrentValue();
            }
          }
        };

    ASTInspector inspector = new ASTInspector();
    inspector.inspect(iterNode.getBodyNode());
    inspector.inspect(iterNode.getVarNode());

    int scopeIndex = asmCompiler.getCacheCompiler().reserveStaticScope();
    ChildScopedBodyCompiler closureCompiler =
        new ChildScopedBodyCompiler(
            asmCompiler, "__file__", asmCompiler.getClassname(), inspector, scope, scopeIndex);

    closureCompiler.beginMethod(closureArgs, scope);

    closureBody.call(closureCompiler);

    closureCompiler.endBody();

    // __file__ method with [] args; no-op
    SkinnyMethodAdapter method =
        new SkinnyMethodAdapter(
            asmCompiler.getClassVisitor(),
            ACC_PUBLIC,
            "__file__",
            getMethodSignature(4),
            null,
            null);
    method.start();

    method.aload(SELF_INDEX);
    method.areturn();
    method.end();

    // __file__ method to call static version
    method =
        new SkinnyMethodAdapter(
            asmCompiler.getClassVisitor(),
            ACC_PUBLIC,
            "__file__",
            getMethodSignature(1),
            null,
            null);
    method.start();

    // invoke static __file__
    method.aload(THIS);
    method.aload(THREADCONTEXT_INDEX);
    method.aload(SELF_INDEX);
    method.aload(ARGS_INDEX);
    method.aload(ARGS_INDEX + 1); // block
    method.invokestatic(
        asmCompiler.getClassname(),
        "__file__",
        getStaticMethodSignature(asmCompiler.getClassname(), 1));

    method.areturn();
    method.end();

    asmCompiler.endScript(false, false);

    byte[] bytes = asmCompiler.getClassByteArray();
    Class blockClass =
        new JRubyClassLoader(context.runtime.getJRubyClassLoader())
            .defineClass(asmCompiler.getClassname(), bytes);
    try {
      final AbstractScript script = (AbstractScript) blockClass.newInstance();
      script.setRootScope(scope);

      return new CompiledBlockCallback() {

        @Override
        public IRubyObject call(
            ThreadContext context, IRubyObject self, IRubyObject args, Block block) {
          return script.__file__(context, self, args, block);
        }

        @Override
        public String getFile() {
          return "blah";
        }

        @Override
        public int getLine() {
          return -1;
        }
      };
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  public CompiledBlockCallback19 compileBlock19(
      ThreadContext context, StandardASMCompiler asmCompiler, final IterNode iterNode) {
    final ASTCompiler19 astCompiler = new ASTCompiler19();
    final StaticScope scope = iterNode.getScope();

    asmCompiler.startScript(scope);

    final ArgsNode argsNode = (ArgsNode) iterNode.getVarNode();

    // create the closure class and instantiate it
    final CompilerCallback closureBody =
        new CompilerCallback() {
          public void call(BodyCompiler context) {
            if (iterNode.getBodyNode() != null) {
              astCompiler.compile(iterNode.getBodyNode(), context, true);
            } else {
              context.loadNil();
            }
          }
        };

    // create the closure class and instantiate it
    final CompilerCallback closureArgs =
        new CompilerCallback() {
          public void call(BodyCompiler context) {
            // FIXME: This is temporary since the variable compilers assume we want
            // args already on stack for assignment. We just pop and continue with
            // 1.9 args logic.
            context.consumeCurrentValue(); // args value
            context.consumeCurrentValue(); // passed block
            if (iterNode.getVarNode() != null) {
              if (iterNode instanceof LambdaNode) {
                final int required = argsNode.getRequiredArgsCount();
                final int opt = argsNode.getOptionalArgsCount();
                final int rest = argsNode.getRestArg();
                context.getVariableCompiler().checkMethodArity(required, opt, rest);
                astCompiler.compileMethodArgs(argsNode, context, true);
              } else {
                astCompiler.compileMethodArgs(argsNode, context, true);
              }
            }
          }
        };

    ASTInspector inspector = new ASTInspector();
    inspector.inspect(iterNode.getBodyNode());
    inspector.inspect(iterNode.getVarNode());

    NodeType argsNodeId = BlockBody.getArgumentTypeWackyHack(iterNode);

    int scopeIndex = asmCompiler.getCacheCompiler().reserveStaticScope();
    ChildScopedBodyCompiler closureCompiler =
        new ChildScopedBodyCompiler19(
            asmCompiler, "__file__", asmCompiler.getClassname(), inspector, scope, scopeIndex);

    closureCompiler.beginMethod(argsNodeId == null ? null : closureArgs, scope);

    closureBody.call(closureCompiler);

    closureCompiler.endBody();

    // __file__ method to call static version
    SkinnyMethodAdapter method =
        new SkinnyMethodAdapter(
            asmCompiler.getClassVisitor(),
            ACC_PUBLIC,
            "__file__",
            getMethodSignature(4),
            null,
            null);
    method.start();

    // invoke static __file__
    method.aload(THIS);
    method.aload(THREADCONTEXT_INDEX);
    method.aload(SELF_INDEX);
    method.aload(ARGS_INDEX);
    method.aload(ARGS_INDEX + 1); // block
    method.invokestatic(
        asmCompiler.getClassname(),
        "__file__",
        asmCompiler.getStaticMethodSignature(asmCompiler.getClassname(), 4));

    method.areturn();
    method.end();

    asmCompiler.endScript(false, false);

    byte[] bytes = asmCompiler.getClassByteArray();
    Class blockClass =
        new JRubyClassLoader(context.runtime.getJRubyClassLoader())
            .defineClass(asmCompiler.getClassname(), bytes);
    try {
      final AbstractScript script = (AbstractScript) blockClass.newInstance();
      script.setRootScope(scope);

      return new CompiledBlockCallback19() {

        @Override
        public IRubyObject call(
            ThreadContext context, IRubyObject self, IRubyObject[] args, Block block) {
          return script.__file__(context, self, args, block);
        }

        @Override
        public String getFile() {
          return iterNode.getPosition().getFile();
        }

        @Override
        public int getLine() {
          return iterNode.getPosition().getLine();
        }
      };
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  static void log(DefaultMethod method, String name, String message, String... reason) {
    String className = method.getImplementationClass().getBaseName();

    if (className == null) className = "<anon class>";

    StringBuilder builder =
        new StringBuilder(message + ":" + className + "." + name + " at " + method.getPosition());

    if (reason.length > 0) {
      builder.append(" because of: \"");
      for (int i = 0; i < reason.length; i++) {
        builder.append(reason[i]);
      }
      builder.append('"');
    }

    LOG.info(builder.toString());
  }

  private static String calculateFilename(ArgsNode argsNode, Node bodyNode) {
    if (bodyNode != null) return bodyNode.getPosition().getFile();
    if (argsNode != null) return argsNode.getPosition().getFile();

    return "__eval__";
  }
}
Esempio n. 14
0
/**
 * ChannelDescriptor provides an abstraction similar to the concept of a "file descriptor" on any
 * POSIX system. In our case, it's a numbered object (fileno) enclosing a Channel (@see
 * java.nio.channels.Channel), FileDescriptor (@see java.io.FileDescriptor), and flags under which
 * the original open occured (@see org.jruby.util.io.ModeFlags). Several operations you would
 * normally expect to use with a POSIX file descriptor are implemented here and used by higher-level
 * classes to implement higher-level IO behavior.
 *
 * <p>Note that the channel specified when constructing a ChannelDescriptor will be
 * reference-counted; that is, until all known references to it through this class have gone away,
 * it will be left open. This is to support operations like "dup" which must produce two independent
 * ChannelDescriptor instances that can be closed separately without affecting the other.
 *
 * <p>At present there's no way to simulate the behavior on some platforms where POSIX dup also
 * allows independent positioning information.
 */
public class ChannelDescriptor {
  private static final Logger LOG = LoggerFactory.getLogger("ChannelDescriptor");

  /** Whether to log debugging information */
  private static final boolean DEBUG = false;

  /** The java.nio.channels.Channel this descriptor wraps. */
  private Channel channel;
  /**
   * The file number (equivalent to the int file descriptor value in POSIX) for this descriptor.
   * This is generated new for most ChannelDescriptor instances, except when they need to masquerade
   * as another fileno.
   */
  private int internalFileno;
  /** The java.io.FileDescriptor object for this descriptor. */
  private FileDescriptor fileDescriptor;
  /** The original org.jruby.util.io.ModeFlags with which the specified channel was opened. */
  private ModeFlags originalModes;
  /**
   * The reference count for the provided channel. Only counts references through ChannelDescriptor
   * instances.
   */
  private AtomicInteger refCounter;

  /**
   * Used to work-around blocking problems with STDIN. In most cases <code>null</code>. See {@link
   * ChannelDescriptor#ChannelDescriptor(java.io.InputStream, ModeFlags, java.io.FileDescriptor)}
   * for more details. You probably should not use it.
   */
  private InputStream baseInputStream;

  /**
   * Process streams get Channel.newChannel()ed into FileChannel but are not actually seekable. So
   * instead of just the isSeekable check doing instanceof FileChannel, we must also add this
   * boolean to check, which we set to false when it's known that the incoming channel is from a
   * process.
   *
   * <p>FIXME: This is gross, and it's NIO's fault for not providing a nice way to tell if a channel
   * is "really" seekable.
   */
  private boolean canBeSeekable = true;

  /**
   * If the incoming channel is already in append mode (i.e. it will do the requisite seeking), we
   * don't want to do our own additional seeks.
   */
  private boolean isInAppendMode = false;

  /** Whether the current channe is writable or not. */
  private boolean readableChannel;

  /** Whether the current channel is readable or not. */
  private boolean writableChannel;

  /** Whether the current channel is seekable or not. */
  private boolean seekableChannel;

  /**
   * Construct a new ChannelDescriptor with the specified channel, file number, mode flags, file
   * descriptor object and reference counter. This constructor is only used when constructing a new
   * copy of an existing ChannelDescriptor with an existing reference count, to allow the two
   * instances to safely share and appropriately close a given channel.
   *
   * @param channel The channel for the new descriptor, which will be shared with another
   * @param fileno The new file number for the new descriptor
   * @param originalModes The mode flags to use as the "origina" set for this descriptor
   * @param fileDescriptor The java.io.FileDescriptor object to associate with this
   *     ChannelDescriptor
   * @param refCounter The reference counter from another ChannelDescriptor being duped.
   * @param canBeSeekable If the underlying channel can be considered seekable.
   * @param isInAppendMode If the underlying channel is already in append mode.
   */
  private ChannelDescriptor(
      Channel channel,
      int fileno,
      ModeFlags originalModes,
      FileDescriptor fileDescriptor,
      AtomicInteger refCounter,
      boolean canBeSeekable,
      boolean isInAppendMode) {
    this.refCounter = refCounter;
    this.channel = channel;
    this.internalFileno = fileno;
    this.originalModes = originalModes;
    this.fileDescriptor = fileDescriptor;
    this.canBeSeekable = canBeSeekable;
    this.isInAppendMode = isInAppendMode;

    this.readableChannel = channel instanceof ReadableByteChannel;
    this.writableChannel = channel instanceof WritableByteChannel;
    this.seekableChannel = channel instanceof FileChannel;

    registerDescriptor(this);
  }

  private ChannelDescriptor(
      Channel channel, int fileno, ModeFlags originalModes, FileDescriptor fileDescriptor) {
    this(channel, fileno, originalModes, fileDescriptor, new AtomicInteger(1), true, false);
  }

  /**
   * Construct a new ChannelDescriptor with the given channel, file number, mode flags, and file
   * descriptor object. The channel will be kept open until all ChannelDescriptor references to it
   * have been closed.
   *
   * @param channel The channel for the new descriptor
   * @param originalModes The mode flags for the new descriptor
   * @param fileDescriptor The java.io.FileDescriptor object for the new descriptor
   */
  public ChannelDescriptor(
      Channel channel, ModeFlags originalModes, FileDescriptor fileDescriptor) {
    this(channel, getNewFileno(), originalModes, fileDescriptor, new AtomicInteger(1), true, false);
  }

  /**
   * Construct a new ChannelDescriptor with the given channel, file number, mode flags, and file
   * descriptor object. The channel will be kept open until all ChannelDescriptor references to it
   * have been closed.
   *
   * @param channel The channel for the new descriptor
   * @param originalModes The mode flags for the new descriptor
   * @param fileDescriptor The java.io.FileDescriptor object for the new descriptor
   */
  public ChannelDescriptor(
      Channel channel,
      ModeFlags originalModes,
      FileDescriptor fileDescriptor,
      boolean isInAppendMode) {
    this(
        channel,
        getNewFileno(),
        originalModes,
        fileDescriptor,
        new AtomicInteger(1),
        true,
        isInAppendMode);
  }

  /**
   * Construct a new ChannelDescriptor with the given channel, file number, mode flags, and file
   * descriptor object. The channel will be kept open until all ChannelDescriptor references to it
   * have been closed.
   *
   * @param channel The channel for the new descriptor
   * @param originalModes The mode flags for the new descriptor
   */
  public ChannelDescriptor(Channel channel, ModeFlags originalModes) {
    this(
        channel,
        getNewFileno(),
        originalModes,
        getDescriptorFromChannel(channel),
        new AtomicInteger(1),
        true,
        false);
  }

  /**
   * Special constructor to create the ChannelDescriptor out of the stream, file number, mode flags,
   * and file descriptor object. The channel will be created from the provided stream. The channel
   * will be kept open until all ChannelDescriptor references to it have been closed. <b>Note:</b>
   * in most cases, you should not use this constructor, it's reserved mostly for STDIN.
   *
   * @param baseInputStream The stream to create the channel for the new descriptor
   * @param originalModes The mode flags for the new descriptor
   * @param fileDescriptor The java.io.FileDescriptor object for the new descriptor
   */
  public ChannelDescriptor(
      InputStream baseInputStream, ModeFlags originalModes, FileDescriptor fileDescriptor) {
    // The reason why we need the stream is to be able to invoke available() on it.
    // STDIN in Java is non-interruptible, non-selectable, and attempt to read
    // on such stream might lead to thread being blocked without *any* way to unblock it.
    // That's where available() comes it, so at least we could check whether
    // anything is available to be read without blocking.
    this(
        Channels.newChannel(baseInputStream),
        getNewFileno(),
        originalModes,
        fileDescriptor,
        new AtomicInteger(1),
        true,
        false);
    this.baseInputStream = baseInputStream;
  }

  /**
   * Special constructor to create the ChannelDescriptor out of the stream, file number, mode flags,
   * and file descriptor object. The channel will be created from the provided stream. The channel
   * will be kept open until all ChannelDescriptor references to it have been closed. <b>Note:</b>
   * in most cases, you should not use this constructor, it's reserved mostly for STDIN.
   *
   * @param baseInputStream The stream to create the channel for the new descriptor
   * @param originalModes The mode flags for the new descriptor
   */
  public ChannelDescriptor(InputStream baseInputStream, ModeFlags originalModes) {
    // The reason why we need the stream is to be able to invoke available() on it.
    // STDIN in Java is non-interruptible, non-selectable, and attempt to read
    // on such stream might lead to thread being blocked without *any* way to unblock it.
    // That's where available() comes it, so at least we could check whether
    // anything is available to be read without blocking.
    this(
        Channels.newChannel(baseInputStream),
        getNewFileno(),
        originalModes,
        new FileDescriptor(),
        new AtomicInteger(1),
        true,
        false);
    this.baseInputStream = baseInputStream;
  }

  /**
   * Construct a new ChannelDescriptor with the given channel, file number, and file descriptor
   * object. The channel will be kept open until all ChannelDescriptor references to it have been
   * closed. The channel's capabilities will be used to determine the "original" set of mode flags.
   *
   * @param channel The channel for the new descriptor
   * @param fileDescriptor The java.io.FileDescriptor object for the new descriptor
   */
  public ChannelDescriptor(Channel channel, FileDescriptor fileDescriptor)
      throws InvalidValueException {
    this(channel, getModesFromChannel(channel), fileDescriptor);
  }

  @Deprecated
  public ChannelDescriptor(Channel channel, int fileno, FileDescriptor fileDescriptor)
      throws InvalidValueException {
    this(channel, getModesFromChannel(channel), fileDescriptor);
  }

  /**
   * Construct a new ChannelDescriptor with the given channel, file number, and file descriptor
   * object. The channel will be kept open until all ChannelDescriptor references to it have been
   * closed. The channel's capabilities will be used to determine the "original" set of mode flags.
   * This version generates a new fileno.
   *
   * @param channel The channel for the new descriptor
   */
  public ChannelDescriptor(Channel channel) throws InvalidValueException {
    this(channel, getModesFromChannel(channel), getDescriptorFromChannel(channel));
  }

  /**
   * Get this descriptor's file number.
   *
   * @return the fileno for this descriptor
   */
  public int getFileno() {
    return internalFileno;
  }

  /**
   * Get the FileDescriptor object associated with this descriptor. This is not guaranteed to be a
   * "valid" descriptor in the terms of the Java implementation, but is provided for completeness
   * and for cases where it is possible to get a valid FileDescriptor for a given channel.
   *
   * @return the java.io.FileDescriptor object associated with this descriptor
   */
  public FileDescriptor getFileDescriptor() {
    return fileDescriptor;
  }

  /**
   * The channel associated with this descriptor. The channel will be reference counted through
   * ChannelDescriptor and kept open until all ChannelDescriptor objects have been closed.
   * References that leave ChannelDescriptor through this method will not be counted.
   *
   * @return the java.nio.channels.Channel associated with this descriptor
   */
  public Channel getChannel() {
    return channel;
  }

  /**
   * This is intentionally non-public, since it should not be really used outside of very limited
   * use case (handling of STDIN). See {@link
   * ChannelDescriptor#ChannelDescriptor(java.io.InputStream, ModeFlags, java.io.FileDescriptor)}
   * for more info.
   */
  /*package-protected*/ InputStream getBaseInputStream() {
    return baseInputStream;
  }

  /**
   * Whether the channel associated with this descriptor is seekable (i.e. whether it is instanceof
   * FileChannel).
   *
   * @return true if the associated channel is seekable, false otherwise
   */
  public boolean isSeekable() {
    return canBeSeekable && seekableChannel;
  }

  /**
   * Set the channel to be explicitly seekable or not, for streams that appear to be seekable with
   * the instanceof FileChannel check.
   *
   * @param canBeSeekable Whether the channel is seekable or not.
   */
  public void setCanBeSeekable(boolean canBeSeekable) {
    this.canBeSeekable = canBeSeekable;
  }

  /**
   * Whether the channel associated with this descriptor is a NullChannel, for which many operations
   * are simply noops.
   */
  public boolean isNull() {
    return channel instanceof NullChannel;
  }

  /**
   * Whether the channel associated with this descriptor is writable (i.e. whether it is instanceof
   * WritableByteChannel).
   *
   * @return true if the associated channel is writable, false otherwise
   */
  public boolean isWritable() {
    return writableChannel;
  }

  /**
   * Whether the channel associated with this descriptor is readable (i.e. whether it is instanceof
   * ReadableByteChannel).
   *
   * @return true if the associated channel is readable, false otherwise
   */
  public boolean isReadable() {
    return readableChannel;
  }

  /**
   * Whether the channel associated with this descriptor is open.
   *
   * @return true if the associated channel is open, false otherwise
   */
  public boolean isOpen() {
    return channel.isOpen();
  }

  /**
   * Check whether the isOpen returns true, raising a BadDescriptorException if it returns false.
   *
   * @throws org.jruby.util.io.BadDescriptorException if isOpen returns false
   */
  public void checkOpen() throws BadDescriptorException {
    if (!isOpen()) {
      throw new BadDescriptorException();
    }
  }

  /**
   * Get the original mode flags for the descriptor.
   *
   * @return the original mode flags for the descriptor
   */
  public ModeFlags getOriginalModes() {
    return originalModes;
  }

  /**
   * Check whether a specified set of mode flags is a superset of this descriptor's original set of
   * mode flags.
   *
   * @param newModes The modes to confirm as superset
   * @throws org.jruby.util.io.InvalidValueException if the modes are not a superset
   */
  public void checkNewModes(ModeFlags newModes) throws InvalidValueException {
    if (!newModes.isSubsetOf(originalModes)) {
      throw new InvalidValueException();
    }
  }

  /**
   * Mimics the POSIX dup(2) function, returning a new descriptor that references the same open
   * channel.
   *
   * @return A duplicate ChannelDescriptor based on this one
   */
  public ChannelDescriptor dup() {
    synchronized (refCounter) {
      refCounter.incrementAndGet();

      int newFileno = getNewFileno();

      if (DEBUG) LOG.info("Reopen fileno {}, refs now: {}", newFileno, refCounter.get());

      return new ChannelDescriptor(
          channel,
          newFileno,
          originalModes,
          fileDescriptor,
          refCounter,
          canBeSeekable,
          isInAppendMode);
    }
  }

  /**
   * Mimics the POSIX dup2(2) function, returning a new descriptor that references the same open
   * channel but with a specified fileno.
   *
   * @param fileno The fileno to use for the new descriptor
   * @return A duplicate ChannelDescriptor based on this one
   */
  public ChannelDescriptor dup2(int fileno) {
    synchronized (refCounter) {
      refCounter.incrementAndGet();

      if (DEBUG) LOG.info("Reopen fileno {}, refs now: {}", fileno, refCounter.get());

      return new ChannelDescriptor(
          channel,
          fileno,
          originalModes,
          fileDescriptor,
          refCounter,
          canBeSeekable,
          isInAppendMode);
    }
  }

  /**
   * Mimics the POSIX dup2(2) function, returning a new descriptor that references the same open
   * channel but with a specified fileno. This differs from the fileno version by making the target
   * descriptor into a new reference to the current descriptor's channel, closing what it originally
   * pointed to and preserving its original fileno.
   *
   * @param other the descriptor to dup this one into
   */
  public void dup2Into(ChannelDescriptor other) throws BadDescriptorException, IOException {
    synchronized (refCounter) {
      refCounter.incrementAndGet();

      if (DEBUG) LOG.info("Reopen fileno {}, refs now: {}", internalFileno, refCounter.get());

      other.close();

      other.channel = channel;
      other.originalModes = originalModes;
      other.fileDescriptor = fileDescriptor;
      other.refCounter = refCounter;
      other.canBeSeekable = canBeSeekable;
      other.readableChannel = readableChannel;
      other.writableChannel = writableChannel;
      other.seekableChannel = seekableChannel;
    }
  }

  public ChannelDescriptor reopen(Channel channel, ModeFlags modes) {
    return new ChannelDescriptor(channel, internalFileno, modes, fileDescriptor);
  }

  public ChannelDescriptor reopen(RandomAccessFile file, ModeFlags modes) throws IOException {
    return new ChannelDescriptor(file.getChannel(), internalFileno, modes, file.getFD());
  }

  /**
   * Perform a low-level seek operation on the associated channel if it is instanceof FileChannel,
   * or raise PipeException if it is not a FileChannel. Calls checkOpen to confirm the target
   * channel is open. This is equivalent to the lseek(2) POSIX function, and like that function it
   * bypasses any buffer flushing or invalidation as in ChannelStream.fseek.
   *
   * @param offset the offset value to use
   * @param whence whence to seek
   * @throws java.io.IOException If there is an exception while seeking
   * @throws org.jruby.util.io.InvalidValueException If the value specified for offset or whence is
   *     invalid
   * @throws org.jruby.util.io.PipeException If the target channel is not seekable
   * @throws org.jruby.util.io.BadDescriptorException If the target channel is already closed.
   * @return the new offset into the FileChannel.
   */
  public long lseek(long offset, int whence)
      throws IOException, InvalidValueException, PipeException, BadDescriptorException {
    if (seekableChannel) {
      checkOpen();

      FileChannel fileChannel = (FileChannel) channel;
      try {
        long pos;
        switch (whence) {
          case Stream.SEEK_SET:
            pos = offset;
            fileChannel.position(pos);
            break;
          case Stream.SEEK_CUR:
            pos = fileChannel.position() + offset;
            fileChannel.position(pos);
            break;
          case Stream.SEEK_END:
            pos = fileChannel.size() + offset;
            fileChannel.position(pos);
            break;
          default:
            throw new InvalidValueException();
        }
        return pos;
      } catch (IllegalArgumentException e) {
        throw new InvalidValueException();
      } catch (IOException ioe) {
        // "invalid seek" means it's an ESPIPE, so we rethrow as a PipeException()
        if (ioe.getMessage().equals("Illegal seek")) {
          throw new PipeException();
        }
        throw ioe;
      }
    } else {
      throw new PipeException();
    }
  }

  /**
   * Perform a low-level read of the specified number of bytes into the specified byte list. The
   * incoming bytes will be appended to the byte list. This is equivalent to the read(2) POSIX
   * function, and like that function it ignores read and write buffers defined elsewhere.
   *
   * @param number the number of bytes to read
   * @param byteList the byte list on which to append the incoming bytes
   * @return the number of bytes actually read
   * @throws java.io.IOException if there is an exception during IO
   * @throws org.jruby.util.io.BadDescriptorException if the associated channel is already closed.
   * @see org.jruby.util.ByteList
   */
  public int read(int number, ByteList byteList) throws IOException, BadDescriptorException {
    checkOpen();

    byteList.ensure(byteList.length() + number);
    int bytesRead =
        read(
            ByteBuffer.wrap(
                byteList.getUnsafeBytes(), byteList.begin() + byteList.length(), number));
    if (bytesRead > 0) {
      byteList.length(byteList.length() + bytesRead);
    }
    return bytesRead;
  }

  /**
   * Perform a low-level read of the remaining number of bytes into the specified byte buffer. The
   * incoming bytes will be used to fill the remaining space in the target byte buffer. This is
   * equivalent to the read(2) POSIX function, and like that function it ignores read and write
   * buffers defined elsewhere.
   *
   * @param buffer the java.nio.ByteBuffer in which to put the incoming bytes
   * @return the number of bytes actually read
   * @throws java.io.IOException if there is an exception during IO
   * @throws org.jruby.util.io.BadDescriptorException if the associated channel is already closed
   * @see java.nio.ByteBuffer
   */
  public int read(ByteBuffer buffer) throws IOException, BadDescriptorException {
    checkOpen();

    // TODO: It would be nice to throw a better error for this
    if (!isReadable()) {
      throw new BadDescriptorException();
    }
    ReadableByteChannel readChannel = (ReadableByteChannel) channel;
    int bytesRead = 0;
    bytesRead = readChannel.read(buffer);

    return bytesRead;
  }

  /**
   * Write the bytes in the specified byte list to the associated channel.
   *
   * @param buffer the byte list containing the bytes to be written
   * @return the number of bytes actually written
   * @throws java.io.IOException if there is an exception during IO
   * @throws org.jruby.util.io.BadDescriptorException if the associated channel is already closed
   */
  public int internalWrite(ByteBuffer buffer) throws IOException, BadDescriptorException {
    checkOpen();

    // TODO: It would be nice to throw a better error for this
    if (!isWritable()) {
      throw new BadDescriptorException();
    }

    WritableByteChannel writeChannel = (WritableByteChannel) channel;

    // if appendable, we always seek to the end before writing
    if (isSeekable() && originalModes.isAppendable()) {
      // if already in append mode, we don't do our own seeking
      if (!isInAppendMode) {
        FileChannel fileChannel = (FileChannel) channel;
        fileChannel.position(fileChannel.size());
      }
    }

    return writeChannel.write(buffer);
  }

  /**
   * Write the bytes in the specified byte list to the associated channel.
   *
   * @param buffer the byte list containing the bytes to be written
   * @return the number of bytes actually written
   * @throws java.io.IOException if there is an exception during IO
   * @throws org.jruby.util.io.BadDescriptorException if the associated channel is already closed
   */
  public int write(ByteBuffer buffer) throws IOException, BadDescriptorException {
    checkOpen();

    return internalWrite(buffer);
  }

  /**
   * Write the bytes in the specified byte list to the associated channel.
   *
   * @param buf the byte list containing the bytes to be written
   * @return the number of bytes actually written
   * @throws java.io.IOException if there is an exception during IO
   * @throws org.jruby.util.io.BadDescriptorException if the associated channel is already closed
   */
  public int write(ByteList buf) throws IOException, BadDescriptorException {
    checkOpen();

    return internalWrite(ByteBuffer.wrap(buf.getUnsafeBytes(), buf.begin(), buf.length()));
  }

  /**
   * Write the bytes in the specified byte list to the associated channel.
   *
   * @param buf the byte list containing the bytes to be written
   * @param offset the offset to start at. this is relative to the begin variable in the but
   * @param len the amount of bytes to write. this should not be longer than the buffer
   * @return the number of bytes actually written
   * @throws java.io.IOException if there is an exception during IO
   * @throws org.jruby.util.io.BadDescriptorException if the associated channel is already closed
   */
  public int write(ByteList buf, int offset, int len) throws IOException, BadDescriptorException {
    checkOpen();

    return internalWrite(ByteBuffer.wrap(buf.getUnsafeBytes(), buf.begin() + offset, len));
  }

  /**
   * Write the byte represented by the specified int to the associated channel.
   *
   * @param c The byte to write
   * @return 1 if the byte was written, 0 if not and -1 if there was an error (@see
   *     java.nio.channels.WritableByteChannel.write(java.nio.ByteBuffer))
   * @throws java.io.IOException If there was an exception during IO
   * @throws org.jruby.util.io.BadDescriptorException if the associated channel is already closed
   */
  public int write(int c) throws IOException, BadDescriptorException {
    checkOpen();

    ByteBuffer buf = ByteBuffer.allocate(1);
    buf.put((byte) c);
    buf.flip();

    return internalWrite(buf);
  }

  /**
   * Open a new descriptor using the given working directory, file path, mode flags, and file
   * permission. This is equivalent to the open(2) POSIX function. See
   * org.jruby.util.io.ChannelDescriptor.open(String, String, ModeFlags, int, POSIX) for the version
   * that also sets file permissions.
   *
   * @param cwd the "current working directory" to use when opening the file
   * @param path the file path to open
   * @param flags the mode flags to use for opening the file
   * @return a new ChannelDescriptor based on the specified parameters
   */
  public static ChannelDescriptor open(String cwd, String path, ModeFlags flags)
      throws FileNotFoundException, DirectoryAsFileException, FileExistsException, IOException {
    return open(cwd, path, flags, 0, null, null);
  }

  /**
   * Open a new descriptor using the given working directory, file path, mode flags, and file
   * permission. This is equivalent to the open(2) POSIX function. See
   * org.jruby.util.io.ChannelDescriptor.open(String, String, ModeFlags, int, POSIX) for the version
   * that also sets file permissions.
   *
   * @param cwd the "current working directory" to use when opening the file
   * @param path the file path to open
   * @param flags the mode flags to use for opening the file
   * @param classLoader a ClassLoader to use for classpath: resources
   * @return a new ChannelDescriptor based on the specified parameters
   */
  public static ChannelDescriptor open(
      String cwd, String path, ModeFlags flags, ClassLoader classLoader)
      throws FileNotFoundException, DirectoryAsFileException, FileExistsException, IOException {
    return open(cwd, path, flags, 0, null, classLoader);
  }

  /**
   * Open a new descriptor using the given working directory, file path, mode flags, and file
   * permission. This is equivalent to the open(2) POSIX function.
   *
   * @param cwd the "current working directory" to use when opening the file
   * @param path the file path to open
   * @param flags the mode flags to use for opening the file
   * @param perm the file permissions to use when creating a new file (currently unobserved)
   * @param posix a POSIX api implementation, used for setting permissions; if null, permissions are
   *     ignored
   * @return a new ChannelDescriptor based on the specified parameters
   */
  public static ChannelDescriptor open(
      String cwd, String path, ModeFlags flags, int perm, POSIX posix)
      throws FileNotFoundException, DirectoryAsFileException, FileExistsException, IOException {
    return open(cwd, path, flags, perm, posix, null);
  }

  /**
   * Open a new descriptor using the given working directory, file path, mode flags, and file
   * permission. This is equivalent to the open(2) POSIX function.
   *
   * @param cwd the "current working directory" to use when opening the file
   * @param path the file path to open
   * @param flags the mode flags to use for opening the file
   * @param perm the file permissions to use when creating a new file (currently unobserved)
   * @param posix a POSIX api implementation, used for setting permissions; if null, permissions are
   *     ignored
   * @param classLoader a ClassLoader to use for classpath: resources
   * @return a new ChannelDescriptor based on the specified parameters
   */
  public static ChannelDescriptor open(
      String cwd, String path, ModeFlags flags, int perm, POSIX posix, ClassLoader classLoader)
      throws FileNotFoundException, DirectoryAsFileException, FileExistsException, IOException {
    if (path.equals("/dev/null") || path.equalsIgnoreCase("nul:") || path.equalsIgnoreCase("nul")) {
      Channel nullChannel = new NullChannel();
      // FIXME: don't use RubyIO for this
      return new ChannelDescriptor(nullChannel, flags);
    }

    if (path.startsWith("classpath:/") && classLoader != null) {
      path = path.substring("classpath:/".length());
      InputStream is = classLoader.getResourceAsStream(path);
      // FIXME: don't use RubyIO for this
      return new ChannelDescriptor(Channels.newChannel(is), flags);
    }

    return JRubyFile.createResource(posix, cwd, path).openDescriptor(flags, perm);
  }

  /**
   * Close this descriptor. If in closing the last ChannelDescriptor reference to the associate
   * channel is closed, the channel itself will be closed.
   *
   * @throws org.jruby.util.io.BadDescriptorException if the associated channel is already closed
   * @throws java.io.IOException if there is an exception during IO
   */
  public void close() throws BadDescriptorException, IOException {
    // tidy up
    finish(true);
  }

  void finish(boolean close) throws BadDescriptorException, IOException {
    synchronized (refCounter) {
      // if refcount is at or below zero, we're no longer valid
      if (refCounter.get() <= 0) {
        throw new BadDescriptorException();
      }

      // if channel is already closed, we're no longer valid
      if (!channel.isOpen()) {
        throw new BadDescriptorException();
      }

      // otherwise decrement and possibly close as normal
      if (close) {
        int count = refCounter.decrementAndGet();

        if (DEBUG) LOG.info("Descriptor for fileno {} refs: {}", internalFileno, count);

        if (count <= 0) {
          // if we're the last referrer, close the channel
          try {
            channel.close();
          } finally {
            unregisterDescriptor(internalFileno);
          }
        }
      }
    }
  }

  /**
   * Build a set of mode flags using the specified channel's actual capabilities.
   *
   * @param channel the channel to examine for capabilities
   * @return the mode flags
   * @throws org.jruby.util.io.InvalidValueException
   */
  private static ModeFlags getModesFromChannel(Channel channel) throws InvalidValueException {
    ModeFlags modes;
    if (channel instanceof ReadableByteChannel) {
      if (channel instanceof WritableByteChannel) {
        modes = new ModeFlags(RDWR);
      } else {
        modes = new ModeFlags(RDONLY);
      }
    } else if (channel instanceof WritableByteChannel) {
      modes = new ModeFlags(WRONLY);
    } else {
      // FIXME: I don't like this
      modes = new ModeFlags(RDWR);
    }

    return modes;
  }

  // FIXME shouldn't use static; would interfere with other runtimes in the same JVM
  protected static final AtomicInteger internalFilenoIndex = new AtomicInteger(2);

  public static int getNewFileno() {
    return internalFilenoIndex.incrementAndGet();
  }

  private static void registerDescriptor(ChannelDescriptor descriptor) {
    filenoDescriptorMap.put(descriptor.getFileno(), descriptor);
  }

  public static void unregisterDescriptor(int aFileno) {
    filenoDescriptorMap.remove(aFileno);
  }

  public static ChannelDescriptor getDescriptorByFileno(int aFileno) {
    return filenoDescriptorMap.get(aFileno);
  }

  public static Map<Integer, ChannelDescriptor> getFilenoDescriptorMapReadOnly() {
    return Collections.unmodifiableMap(filenoDescriptorMap);
  }

  private static final Map<Integer, ChannelDescriptor> filenoDescriptorMap =
      new ConcurrentHashMap<Integer, ChannelDescriptor>();

  private static final Class SEL_CH_IMPL;
  private static final Method SEL_CH_IMPL_GET_FD;
  private static final Class FILE_CHANNEL_IMPL;
  private static final Field FILE_CHANNEL_IMPL_FD;
  private static final Field FILE_DESCRIPTOR_FD;

  static {
    Method getFD;
    Class selChImpl;
    try {
      selChImpl = Class.forName("sun.nio.ch.SelChImpl");
      try {
        getFD = selChImpl.getMethod("getFD");
        getFD.setAccessible(true);
      } catch (Exception e) {
        getFD = null;
      }
    } catch (Exception e) {
      selChImpl = null;
      getFD = null;
    }
    SEL_CH_IMPL = selChImpl;
    SEL_CH_IMPL_GET_FD = getFD;

    Field fd;
    Class fileChannelImpl;
    try {
      fileChannelImpl = Class.forName("sun.nio.ch.FileChannelImpl");
      try {
        fd = fileChannelImpl.getDeclaredField("fd");
        fd.setAccessible(true);
      } catch (Exception e) {
        fd = null;
      }
    } catch (Exception e) {
      fileChannelImpl = null;
      fd = null;
    }
    FILE_CHANNEL_IMPL = fileChannelImpl;
    FILE_CHANNEL_IMPL_FD = fd;

    Field ffd;
    try {
      ffd = FileDescriptor.class.getDeclaredField("fd");
      ffd.setAccessible(true);
    } catch (Exception e) {
      ffd = null;
    }
    FILE_DESCRIPTOR_FD = ffd;
  }

  public static FileDescriptor getDescriptorFromChannel(Channel channel) {
    if (SEL_CH_IMPL_GET_FD != null && SEL_CH_IMPL.isInstance(channel)) {
      // Pipe Source and Sink, Sockets, and other several other selectable channels
      try {
        return (FileDescriptor) SEL_CH_IMPL_GET_FD.invoke(channel);
      } catch (Exception e) {
        // return bogus below
      }
    } else if (FILE_CHANNEL_IMPL_FD != null && FILE_CHANNEL_IMPL.isInstance(channel)) {
      // FileChannels
      try {
        return (FileDescriptor) FILE_CHANNEL_IMPL_FD.get(channel);
      } catch (Exception e) {
        // return bogus below
      }
    } else if (FILE_DESCRIPTOR_FD != null) {
      FileDescriptor unixFD = new FileDescriptor();

      // UNIX sockets, from jnr-unixsocket
      try {
        if (channel instanceof UnixSocketChannel) {
          FILE_DESCRIPTOR_FD.set(unixFD, ((UnixSocketChannel) channel).getFD());
          return unixFD;
        } else if (channel instanceof UnixServerSocketChannel) {
          FILE_DESCRIPTOR_FD.set(unixFD, ((UnixServerSocketChannel) channel).getFD());
          return unixFD;
        }
      } catch (Exception e) {
        // return bogus below
      }
    }
    return new FileDescriptor();
  }
}
Esempio n. 15
0
/**
 * Right now, this class abstracts the following execution scopes: Method, Closure, Module, Class,
 * MetaClass Top-level Script, and Eval Script
 *
 * <p>In the compiler-land, IR versions of these scopes encapsulate only as much information as is
 * required to convert Ruby code into equivalent Java code.
 *
 * <p>But, in the non-compiler land, there will be a corresponding java object for some of these
 * scopes which encapsulates the runtime semantics and data needed for implementing them. In the
 * case of Module, Class, MetaClass, and Method, they also happen to be instances of the
 * corresponding Ruby classes -- so, in addition to providing code that help with this specific ruby
 * implementation, they also have code that let them behave as ruby instances of their corresponding
 * classes.
 *
 * <p>Examples: - the runtime class object might have refs. to the runtime method objects. - the
 * runtime method object might have a slot for a heap frame (for when it has closures that need
 * access to the method's local variables), it might have version information, it might have
 * references to other methods that were optimized with the current version number, etc. - the
 * runtime closure object will have a slot for a heap frame (for when it has closures within) and
 * might get reified as a method in the java land (but inaccessible in ruby land). So, passing
 * closures in Java land might be equivalent to passing around the method handles.
 *
 * <p>and so on ...
 */
public abstract class IRScope {
  private static final Logger LOG = LoggerFactory.getLogger("IRScope");

  private static Integer globalScopeCount = 0;

  /** Unique global scope id */
  private int scopeId;

  /** Name */
  private String name;

  /** File within which this scope has been defined */
  private final String fileName;

  /** Starting line for this scope's definition */
  private final int lineNumber;

  /** Lexical parent scope */
  private IRScope lexicalParent;

  /** Parser static-scope that this IR scope corresponds to */
  private StaticScope staticScope;

  /** Live version of module within whose context this method executes */
  private RubyModule containerModule;

  /** List of IR instructions for this method */
  private List<Instr> instrList;

  /** Control flow graph representation of this method's instructions */
  private CFG cfg;

  /** List of (nested) closures in this scope */
  private List<IRClosure> nestedClosures;

  /** Local variables defined in this scope */
  private Set<Variable> definedLocalVars;

  /** Local variables used in this scope */
  private Set<Variable> usedLocalVars;

  /** Is %block implicit block arg unused? */
  private boolean hasUnusedImplicitBlockArg;

  /** %current_module and %current_scope variables */
  private TemporaryVariable currentModuleVar;

  private TemporaryVariable currentScopeVar;

  /** Map of name -> dataflow problem */
  private Map<String, DataFlowProblem> dfProbs;

  private Instr[] linearizedInstrArray;
  private List<BasicBlock> linearizedBBList;
  protected int temporaryVariableIndex;

  /** Keeps track of types of prefix indexes for variables and labels */
  private Map<String, Integer> nextVarIndex;

  // Index values to guarantee we don't assign same internal index twice
  private int nextClosureIndex;

  // List of all scopes this scope contains lexically.  This is not used
  // for execution, but is used during dry-runs for debugging.
  List<IRScope> lexicalChildren;

  protected static class LocalVariableAllocator {
    public int nextSlot;
    public Map<String, LocalVariable> varMap;

    public LocalVariableAllocator() {
      varMap = new HashMap<String, LocalVariable>();
      nextSlot = 0;
    }

    public final LocalVariable getVariable(String name) {
      return varMap.get(name);
    }

    public final void putVariable(String name, LocalVariable var) {
      varMap.put(name, var);
      nextSlot++;
    }
  }

  LocalVariableAllocator localVars;
  LocalVariableAllocator evalScopeVars;

  /** Have scope flags been computed? */
  private boolean flagsComputed;

  /* *****************************************************************************************************
   * Does this execution scope (applicable only to methods) receive a block and use it in such a way that
   * all of the caller's local variables need to be materialized into a heap binding?
   * Ex:
   *    def foo(&b)
   *      eval 'puts a', b
   *    end
   *
   *    def bar
   *      a = 1
   *      foo {} # prints out '1'
   *    end
   *
   * Here, 'foo' can access all of bar's variables because it captures the caller's closure.
   *
   * There are 2 scenarios when this can happen (even this is conservative -- but, good enough for now)
   * 1. This method receives an explicit block argument (in this case, the block can be stored, passed around,
   *    eval'ed against, called, etc.).
   *    CAVEAT: This is conservative ... it may not actually be stored & passed around, evaled, called, ...
   * 2. This method has a 'super' call (ZSuper AST node -- ZSuperInstr IR instruction)
   *    In this case, the parent (in the inheritance hierarchy) can access the block and store it, etc.  So, in reality,
   *    rather than assume that the parent will always do this, we can query the parent, if we can precisely identify
   *    the parent method (which in the face of Ruby's dynamic hierarchy, we cannot).  So, be pessimistic.
   *
   * This logic was extracted from an email thread on the JRuby mailing list -- Yehuda Katz & Charles Nutter
   * contributed this analysis above.
   * ********************************************************************************************************/
  private boolean canCaptureCallersBinding;

  /* ****************************************************************************
   * Does this scope define code, i.e. does it (or anybody in the downward call chain)
   * do class_eval, module_eval? In the absence of any other information, we default
   * to yes -- which basically leads to pessimistic but safe optimizations.  But, for
   * library and internal methods, this might be false.
   * **************************************************************************** */
  private boolean canModifyCode;

  /* ****************************************************************************
   * Does this scope require a binding to be materialized?
   * Yes if any of the following holds true:
   * - calls 'Proc.new'
   * - calls 'eval'
   * - calls 'call' (could be a call on a stored block which could be local!)
   * - calls 'send' and we cannot resolve the message (method name) that is being sent!
   * - calls methods that can access the caller's binding
   * - calls a method which we cannot resolve now!
   * - has a call whose closure requires a binding
   * **************************************************************************** */
  private boolean bindingHasEscaped;

  /** Does this scope call any eval */
  private boolean usesEval;

  /** Does this scope receive keyword args? */
  private boolean receivesKeywordArgs;

  /** Does this scope have a break instr? */
  protected boolean hasBreakInstrs;

  /** Can this scope receive breaks */
  protected boolean canReceiveBreaks;

  /** Does this scope have a non-local return instr? */
  protected boolean hasNonlocalReturns;

  /** Can this scope receive a non-local return? */
  public boolean canReceiveNonlocalReturns;

  /**
   * Since backref ($~) and lastline ($_) vars are allocated space on the dynamic scope, this is an
   * useful flag to compute.
   */
  private boolean usesBackrefOrLastline;

  /** Does this scope call any zsuper */
  private boolean usesZSuper;

  /** Does this scope have loops? */
  private boolean hasLoops;

  /** # of thread poll instrs added to this scope */
  private int threadPollInstrsCount;

  /**
   * Does this scope have explicit call protocol instructions? If yes, there are IR instructions for
   * managing bindings/frames, etc. If not, this has to be managed implicitly as in the current
   * runtime For now, only dyn-scopes are managed explicitly. Others will come in time
   */
  private boolean hasExplicitCallProtocol;

  /** Should we re-run compiler passes -- yes after we've inlined, for example */
  private boolean relinearizeCFG;

  private IRManager manager;

  // Used by cloning code
  protected IRScope(IRScope s, IRScope lexicalParent) {
    this.lexicalParent = lexicalParent;
    this.manager = s.manager;
    this.fileName = s.fileName;
    this.lineNumber = s.lineNumber;
    this.staticScope = s.staticScope;
    this.threadPollInstrsCount = s.threadPollInstrsCount;
    this.nextClosureIndex = s.nextClosureIndex;
    this.temporaryVariableIndex = s.temporaryVariableIndex;
    this.hasLoops = s.hasLoops;
    this.hasUnusedImplicitBlockArg = s.hasUnusedImplicitBlockArg;
    this.instrList = null;
    this.nestedClosures = new ArrayList<IRClosure>();
    this.dfProbs = new HashMap<String, DataFlowProblem>();
    this.nextVarIndex = new HashMap<String, Integer>(); // SSS FIXME: clone!
    this.cfg = null;
    this.linearizedInstrArray = null;
    this.linearizedBBList = null;

    this.flagsComputed = s.flagsComputed;
    this.canModifyCode = s.canModifyCode;
    this.canCaptureCallersBinding = s.canCaptureCallersBinding;
    this.receivesKeywordArgs = s.receivesKeywordArgs;
    this.hasBreakInstrs = s.hasBreakInstrs;
    this.hasNonlocalReturns = s.hasNonlocalReturns;
    this.canReceiveBreaks = s.canReceiveBreaks;
    this.canReceiveNonlocalReturns = s.canReceiveNonlocalReturns;
    this.bindingHasEscaped = s.bindingHasEscaped;
    this.usesEval = s.usesEval;
    this.usesBackrefOrLastline = s.usesBackrefOrLastline;
    this.usesZSuper = s.usesZSuper;
    this.hasExplicitCallProtocol = s.hasExplicitCallProtocol;

    this.localVars = new LocalVariableAllocator(); // SSS FIXME: clone!
    this.localVars.nextSlot = s.localVars.nextSlot;
    this.relinearizeCFG = false;

    setupLexicalContainment();
  }

  public IRScope(
      IRManager manager,
      IRScope lexicalParent,
      String name,
      String fileName,
      int lineNumber,
      StaticScope staticScope) {
    this.manager = manager;
    this.lexicalParent = lexicalParent;
    this.name = name;
    this.fileName = fileName;
    this.lineNumber = lineNumber;
    this.staticScope = staticScope;
    this.threadPollInstrsCount = 0;
    this.nextClosureIndex = 0;
    this.temporaryVariableIndex = -1;
    this.instrList = new ArrayList<Instr>();
    this.nestedClosures = new ArrayList<IRClosure>();
    this.dfProbs = new HashMap<String, DataFlowProblem>();
    this.nextVarIndex = new HashMap<String, Integer>();
    this.cfg = null;
    this.linearizedInstrArray = null;
    this.linearizedBBList = null;
    this.hasLoops = false;
    this.hasUnusedImplicitBlockArg = false;

    this.flagsComputed = false;
    this.receivesKeywordArgs = false;
    this.hasBreakInstrs = false;
    this.hasNonlocalReturns = false;
    this.canReceiveBreaks = false;
    this.canReceiveNonlocalReturns = false;

    // These flags are true by default!
    this.canModifyCode = true;
    this.canCaptureCallersBinding = true;
    this.bindingHasEscaped = true;
    this.usesEval = true;
    this.usesBackrefOrLastline = true;
    this.usesZSuper = true;

    this.hasExplicitCallProtocol = false;

    this.localVars = new LocalVariableAllocator();
    synchronized (globalScopeCount) {
      this.scopeId = globalScopeCount++;
    }
    this.relinearizeCFG = false;

    setupLexicalContainment();
  }

  private final void setupLexicalContainment() {
    if (manager.isDryRun()) {
      lexicalChildren = new ArrayList<IRScope>();
      if (lexicalParent != null) lexicalParent.addChildScope(this);
    }
  }

  @Override
  public int hashCode() {
    return scopeId;
  }

  protected void addChildScope(IRScope scope) {
    lexicalChildren.add(scope);
  }

  public List<IRScope> getLexicalScopes() {
    return lexicalChildren;
  }

  public void addClosure(IRClosure c) {
    nestedClosures.add(c);
  }

  public Instr getLastInstr() {
    return instrList.get(instrList.size() - 1);
  }

  public void addInstrAtBeginning(Instr i) {
    instrList.add(0, i);
  }

  public void addInstr(Instr i) {
    // SSS FIXME: If more instructions set these flags, there may be
    // a better way to do this by encoding flags in its own object
    // and letting every instruction update it.
    if (i instanceof ThreadPollInstr) threadPollInstrsCount++;
    else if (i instanceof BreakInstr) this.hasBreakInstrs = true;
    else if (i instanceof NonlocalReturnInstr) this.hasNonlocalReturns = true;
    else if (i instanceof DefineMetaClassInstr) this.canReceiveNonlocalReturns = true;
    else if (i instanceof ReceiveKeywordArgInstr || i instanceof ReceiveKeywordRestArgInstr)
      this.receivesKeywordArgs = true;
    instrList.add(i);
  }

  public LocalVariable getNewFlipStateVariable() {
    return getLocalVariable("%flip_" + allocateNextPrefixedName("%flip"), 0);
  }

  public void initFlipStateVariable(Variable v, Operand initState) {
    // Add it to the beginning
    instrList.add(0, new CopyInstr(v, initState));
  }

  public boolean isForLoopBody() {
    return false;
  }

  public Label getNewLabel(String prefix) {
    return new Label(prefix + "_" + allocateNextPrefixedName(prefix));
  }

  public Label getNewLabel() {
    return getNewLabel("LBL");
  }

  public List<IRClosure> getClosures() {
    return nestedClosures;
  }

  public IRManager getManager() {
    return manager;
  }

  /** Returns the lexical scope that contains this scope definition */
  public IRScope getLexicalParent() {
    return lexicalParent;
  }

  public StaticScope getStaticScope() {
    return staticScope;
  }

  public IRMethod getNearestMethod() {
    IRScope current = this;

    while (current != null && !(current instanceof IRMethod)) {
      current = current.getLexicalParent();
    }

    return (IRMethod) current;
  }

  public IRScope getNearestFlipVariableScope() {
    IRScope current = this;

    while (current != null && !current.isFlipScope()) {
      current = current.getLexicalParent();
    }

    return current;
  }

  public IRScope getNearestTopLocalVariableScope() {
    IRScope current = this;

    while (current != null && !current.isTopLocalVariableScope()) {
      current = current.getLexicalParent();
    }

    return current;
  }

  /**
   * Returns the nearest scope which we can extract a live module from. If this returns null (like
   * for evals), then it means it cannot be statically determined.
   */
  public IRScope getNearestModuleReferencingScope() {
    IRScope current = this;

    while (!(current instanceof IRModuleBody)) {
      // When eval'ing, we dont have a lexical view of what module we are nested in
      // because binding_eval, class_eval, module_eval, instance_eval can switch
      // around the lexical scope for evaluation to be something else.
      if (current == null || current instanceof IREvalScript) return null;

      current = current.getLexicalParent();
    }

    return current;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) { // This is for IRClosure ;(
    this.name = name;
  }

  public String getFileName() {
    return fileName;
  }

  public int getLineNumber() {
    return lineNumber;
  }

  /** Returns the top level scope */
  public IRScope getTopLevelScope() {
    IRScope current = this;

    for (; current != null && !current.isScriptScope(); current = current.getLexicalParent()) {}

    return current;
  }

  public boolean isNestedInClosure(IRClosure closure) {
    for (IRScope s = this; s != null && !s.isTopLocalVariableScope(); s = s.getLexicalParent()) {
      if (s == closure) return true;
    }

    return false;
  }

  public void setHasLoopsFlag(boolean f) {
    hasLoops = true;
  }

  public boolean hasLoops() {
    return hasLoops;
  }

  public boolean hasExplicitCallProtocol() {
    return hasExplicitCallProtocol;
  }

  public void setExplicitCallProtocolFlag(boolean flag) {
    this.hasExplicitCallProtocol = flag;
  }

  public void setCodeModificationFlag(boolean f) {
    canModifyCode = f;
  }

  public boolean receivesKeywordArgs() {
    return this.receivesKeywordArgs;
  }

  public boolean modifiesCode() {
    return canModifyCode;
  }

  public boolean bindingHasEscaped() {
    return bindingHasEscaped;
  }

  public boolean usesBackrefOrLastline() {
    return usesBackrefOrLastline;
  }

  public boolean usesEval() {
    return usesEval;
  }

  public boolean usesZSuper() {
    return usesZSuper;
  }

  public boolean canCaptureCallersBinding() {
    return canCaptureCallersBinding;
  }

  public boolean canReceiveNonlocalReturns() {
    if (this.canReceiveNonlocalReturns) {
      return true;
    }

    boolean canReceiveNonlocalReturns = false;
    for (IRClosure cl : getClosures()) {
      if (cl.hasNonlocalReturns || cl.canReceiveNonlocalReturns()) {
        canReceiveNonlocalReturns = true;
      }
    }
    return canReceiveNonlocalReturns;
  }

  public CFG buildCFG() {
    cfg = new CFG(this);
    cfg.build(instrList);
    // Clear out instruction list after CFG has been built.
    this.instrList = null;
    return cfg;
  }

  protected void setCFG(CFG cfg) {
    this.cfg = cfg;
  }

  public CFG getCFG() {
    return cfg;
  }

  private void setupLabelPCs(HashMap<Label, Integer> labelIPCMap) {
    for (BasicBlock b : linearizedBBList) {
      Label l = b.getLabel();
      l.setTargetPC(labelIPCMap.get(l));
    }
  }

  private Instr[] prepareInstructionsForInterpretation() {
    checkRelinearization();

    if (linearizedInstrArray != null) return linearizedInstrArray; // Already prepared

    try {
      buildLinearization(); // FIXME: compiler passes should have done this
      depends(linearization());
    } catch (RuntimeException e) {
      LOG.error("Error linearizing cfg: ", e);
      CFG c = cfg();
      LOG.error("\nGraph:\n" + c.toStringGraph());
      LOG.error("\nInstructions:\n" + c.toStringInstrs());
      throw e;
    }

    // Set up IPCs
    HashMap<Label, Integer> labelIPCMap = new HashMap<Label, Integer>();
    List<Instr> newInstrs = new ArrayList<Instr>();
    int ipc = 0;
    for (BasicBlock b : linearizedBBList) {
      labelIPCMap.put(b.getLabel(), ipc);
      List<Instr> bbInstrs = b.getInstrs();
      int bbInstrsLength = bbInstrs.size();
      for (int i = 0; i < bbInstrsLength; i++) {
        Instr instr = bbInstrs.get(i);

        if (instr instanceof Specializeable) {
          instr = ((Specializeable) instr).specializeForInterpretation();
          bbInstrs.set(i, instr);
        }

        if (!(instr instanceof ReceiveSelfInstr)) {
          newInstrs.add(instr);
          ipc++;
        }
      }
    }

    // Set up label PCs
    setupLabelPCs(labelIPCMap);

    // Exit BB ipc
    cfg().getExitBB().getLabel().setTargetPC(ipc + 1);

    linearizedInstrArray = newInstrs.toArray(new Instr[newInstrs.size()]);
    return linearizedInstrArray;
  }

  private void runCompilerPasses() {
    // SSS FIXME: Why is this again?  Document this weirdness!
    // Forcibly clear out the shared eval-scope variable allocator each time this method executes
    initEvalScopeVariableAllocator(true);

    // SSS FIXME: We should configure different optimization levels
    // and run different kinds of analysis depending on time budget.  Accordingly, we need to set
    // IR levels/states (basic, optimized, etc.) and the
    // ENEBO: If we use a MT optimization mechanism we cannot mutate CFG
    // while another thread is using it.  This may need to happen on a clone()
    // and we may need to update the method to return the new method.  Also,
    // if this scope is held in multiple locations how do we update all references?
    for (CompilerPass pass : getManager().getCompilerPasses(this)) {
      pass.run(this);
    }
  }

  /** Run any necessary passes to get the IR ready for interpretation */
  public synchronized Instr[] prepareForInterpretation(boolean isLambda) {
    if (isLambda) {
      // Add a global ensure block to catch uncaught breaks
      // and throw a LocalJumpError.
      if (((IRClosure) this).addGEBForUncaughtBreaks()) {
        this.relinearizeCFG = true;
      }
    }

    checkRelinearization();

    if (linearizedInstrArray != null) return linearizedInstrArray;

    // Build CFG and run compiler passes, if necessary
    if (getCFG() == null) runCompilerPasses();

    // Linearize CFG, etc.
    return prepareInstructionsForInterpretation();
  }

  /* SSS FIXME: Do we need to synchronize on this?  Cache this info in a scope field? */
  /** Run any necessary passes to get the IR ready for compilation */
  public Tuple<Instr[], Map<Integer, Label[]>> prepareForCompilation() {
    // Build CFG and run compiler passes, if necessary
    if (getCFG() == null) runCompilerPasses();

    // Add this always since we dont re-JIT a previously
    // JIT-ted closure.  But, check if there are other
    // smarts available to us and eliminate adding this
    // code to every closure there is.
    //
    // Add a global ensure block to catch uncaught breaks
    // and throw a LocalJumpError.
    if (this instanceof IRClosure && ((IRClosure) this).addGEBForUncaughtBreaks()) {
      this.relinearizeCFG = true;
    }

    try {
      buildLinearization(); // FIXME: compiler passes should have done this
      depends(linearization());
    } catch (RuntimeException e) {
      LOG.error("Error linearizing cfg: ", e);
      CFG c = cfg();
      LOG.error("\nGraph:\n" + c.toStringGraph());
      LOG.error("\nInstructions:\n" + c.toStringInstrs());
      throw e;
    }

    // Set up IPCs
    // FIXME: Would be nice to collapse duplicate labels; for now, using Label[]
    HashMap<Integer, Label[]> ipcLabelMap = new HashMap<Integer, Label[]>();
    List<Instr> newInstrs = new ArrayList<Instr>();
    int ipc = 0;
    for (BasicBlock b : linearizedBBList) {
      Label l = b.getLabel();
      ipcLabelMap.put(ipc, catLabels(ipcLabelMap.get(ipc), l));
      for (Instr i : b.getInstrs()) {
        if (!(i instanceof ReceiveSelfInstr)) {
          newInstrs.add(i);
          ipc++;
        }
      }
    }

    return new Tuple<Instr[], Map<Integer, Label[]>>(
        newInstrs.toArray(new Instr[newInstrs.size()]), ipcLabelMap);
  }

  private List<Object[]> buildJVMExceptionTable() {
    List<Object[]> etEntries = new ArrayList<Object[]>();
    for (BasicBlock b : linearizedBBList) {
      // We need handlers for:
      // - Unrescuable    (handled by ensures),
      // - Throwable      (handled by rescues)
      // in that order since Throwable < Unrescuable
      BasicBlock rBB = cfg().getRescuerBBFor(b);
      BasicBlock eBB = cfg().getEnsurerBBFor(b);
      if ((eBB != null) && (rBB == eBB || rBB == null)) {
        // 1. same rescue and ensure handler ==> just spit out one entry with a Throwable class
        // 2. only ensure handler            ==> just spit out one entry with a Throwable class

        etEntries.add(new Object[] {b.getLabel(), eBB.getLabel(), Throwable.class});
      } else if (rBB != null) {
        // Unrescuable comes before Throwable
        if (eBB != null)
          etEntries.add(new Object[] {b.getLabel(), eBB.getLabel(), Unrescuable.class});
        etEntries.add(new Object[] {b.getLabel(), rBB.getLabel(), Throwable.class});
      }
    }

    // SSS FIXME: This could be optimized by compressing entries for adjacent BBs that have
    // identical handlers
    // This could be optimized either during generation or as another pass over the table.  But, if
    // the JVM
    // does that already, do we need to bother with it?
    return etEntries;
  }

  private static Label[] catLabels(Label[] labels, Label cat) {
    if (labels == null) return new Label[] {cat};
    Label[] newLabels = new Label[labels.length + 1];
    System.arraycopy(labels, 0, newLabels, 0, labels.length);
    newLabels[labels.length] = cat;
    return newLabels;
  }

  private boolean computeScopeFlags(boolean receivesClosureArg, List<Instr> instrs) {
    for (Instr i : instrs) {
      Operation op = i.getOperation();
      if (op == Operation.RECV_CLOSURE) {
        receivesClosureArg = true;
      } else if (op == Operation.ZSUPER) {
        this.canCaptureCallersBinding = true;
        this.usesZSuper = true;
      } else if (i instanceof CallBase) {
        CallBase call = (CallBase) i;

        if (call.targetRequiresCallersBinding()) this.bindingHasEscaped = true;

        if (call.canBeEval()) {
          this.usesEval = true;

          // If this method receives a closure arg, and this call is an eval that has more than 1
          // argument,
          // it could be using the closure as a binding -- which means it could be using pretty much
          // any
          // variable from the caller's binding!
          if (receivesClosureArg && (call.getCallArgs().length > 1)) {
            this.canCaptureCallersBinding = true;
          }
        }
      } else if (op == Operation.GET_GLOBAL_VAR) {
        GlobalVariable gv = (GlobalVariable) ((GetGlobalVariableInstr) i).getSource();
        String gvName = gv.getName();
        if (gvName.equals("$_")
            || gvName.equals("$~")
            || gvName.equals("$`")
            || gvName.equals("$'")
            || gvName.equals("$+")
            || gvName.equals("$LAST_READ_LINE")
            || gvName.equals("$LAST_MATCH_INFO")
            || gvName.equals("$PREMATCH")
            || gvName.equals("$POSTMATCH")
            || gvName.equals("$LAST_PAREN_MATCH")) {
          this.usesBackrefOrLastline = true;
        }
      } else if (op == Operation.PUT_GLOBAL_VAR) {
        GlobalVariable gv = (GlobalVariable) ((PutGlobalVarInstr) i).getTarget();
        String gvName = gv.getName();
        if (gvName.equals("$_") || gvName.equals("$~")) usesBackrefOrLastline = true;
      } else if (op == Operation.MATCH || op == Operation.MATCH2 || op == Operation.MATCH3) {
        this.usesBackrefOrLastline = true;
      } else if (op == Operation.BREAK) {
        this.hasBreakInstrs = true;
      } else if (i instanceof NonlocalReturnInstr) {
        this.hasNonlocalReturns = true;
      } else if (i instanceof DefineMetaClassInstr) {
        // SSS: Inner-classes are defined with closures and
        // a return in the closure can force a return from this method
        // For now conservatively assume that a scope with inner-classes
        // can receive non-local returns. (Alternatively, have to inspect
        // all lexically nested scopes, not just closures in computeScopeFlags())
        this.canReceiveNonlocalReturns = true;
      }
    }

    return receivesClosureArg;
  }

  //
  // This can help use eliminate writes to %block that are not used since this is
  // a special local-variable, not programmer-defined local-variable
  public void computeScopeFlags() {
    if (flagsComputed) {
      return;
    }

    // init
    canModifyCode = true;
    canCaptureCallersBinding = false;
    usesZSuper = false;
    usesEval = false;
    usesBackrefOrLastline = false;
    // NOTE: bindingHasEscaped is the crucial flag and it effectively is
    // unconditionally true whenever it has a call that receives a closure.
    // See CallInstr.computeRequiresCallersBindingFlag
    bindingHasEscaped =
        (this instanceof IREvalScript); // for eval scopes, bindings are considered escaped ...
    hasBreakInstrs = false;
    hasNonlocalReturns = false;
    canReceiveBreaks = false;
    canReceiveNonlocalReturns = false;

    // recompute flags -- we could be calling this method different times
    // definitely once after ir generation and local optimizations propagates constants locally
    // but potentially at a later time after doing ssa generation and constant propagation
    if (cfg == null) {
      computeScopeFlags(false, getInstrs());
    } else {
      boolean receivesClosureArg = false;
      for (BasicBlock b : cfg.getBasicBlocks()) {
        receivesClosureArg = computeScopeFlags(receivesClosureArg, b.getInstrs());
      }
    }

    // Compute flags for nested closures (recursively) and set derived flags.
    for (IRClosure cl : getClosures()) {
      cl.computeScopeFlags();
      if (cl.hasBreakInstrs || cl.canReceiveBreaks) {
        canReceiveBreaks = true;
      }
      if (cl.hasNonlocalReturns || cl.canReceiveNonlocalReturns) {
        canReceiveNonlocalReturns = true;
      }
      if (cl.usesZSuper()) {
        usesZSuper = true;
      }
    }

    flagsComputed = true;
  }

  public abstract String getScopeName();

  @Override
  public String toString() {
    return getScopeName() + " " + getName() + "[" + getFileName() + ":" + getLineNumber() + "]";
  }

  public String toStringInstrs() {
    StringBuilder b = new StringBuilder();

    int i = 0;
    for (Instr instr : instrList) {
      if (i > 0) b.append("\n");

      b.append("  ").append(i).append('\t').append(instr);

      i++;
    }

    if (!nestedClosures.isEmpty()) {
      b.append("\n\n------ Closures encountered in this scope ------\n");
      for (IRClosure c : nestedClosures) b.append(c.toStringBody());
      b.append("------------------------------------------------\n");
    }

    return b.toString();
  }

  public String toPersistableString() {
    StringBuilder b = new StringBuilder();

    b.append("Scope:<");
    b.append(name);
    b.append(">");
    for (Instr instr : instrList) {
      b.append("\n");
      b.append(instr);
    }

    return b.toString();
  }

  public String toStringVariables() {
    Map<Variable, Integer> ends = new HashMap<Variable, Integer>();
    Map<Variable, Integer> starts = new HashMap<Variable, Integer>();
    SortedSet<Variable> variables = new TreeSet<Variable>();

    for (int i = instrList.size() - 1; i >= 0; i--) {
      Instr instr = instrList.get(i);

      if (instr instanceof ResultInstr) {
        Variable var = ((ResultInstr) instr).getResult();
        variables.add(var);
        starts.put(var, i);
      }

      for (Operand operand : instr.getOperands()) {
        if (operand != null
            && operand instanceof Variable
            && ends.get((Variable) operand) == null) {
          ends.put((Variable) operand, i);
          variables.add((Variable) operand);
        }
      }
    }

    StringBuilder sb = new StringBuilder();
    int i = 0;
    for (Variable var : variables) {
      Integer end = ends.get(var);
      if (end != null) { // Variable is actually used somewhere and not dead
        if (i > 0) sb.append("\n");
        i++;
        sb.append("    ").append(var).append(": ").append(starts.get(var)).append("-").append(end);
      }
    }

    return sb.toString();
  }

  /**
   * --------------------------------------- SSS FIXME: What is this method for? @Interp public void
   * calculateParameterCounts() { for (int i = instrList.size() - 1; i >= 0; i--) { Instr instr =
   * instrList.get(i); } } ------------------------------------------ *
   */
  public LocalVariable getSelf() {
    return Self.SELF;
  }

  public Variable getCurrentModuleVariable() {
    // SSS: Used in only 3 cases in generated IR:
    // -> searching a constant in the inheritance hierarchy
    // -> searching a super-method in the inheritance hierarchy
    // -> looking up 'StandardError' (which can be eliminated by creating a special operand type for
    // this)
    if (currentModuleVar == null)
      currentModuleVar = getNewTemporaryVariable(Variable.CURRENT_MODULE);
    return currentModuleVar;
  }

  public Variable getCurrentScopeVariable() {
    // SSS: Used in only 1 case in generated IR:
    // -> searching a constant in the lexical scope hierarchy
    if (currentScopeVar == null) currentScopeVar = getNewTemporaryVariable(Variable.CURRENT_SCOPE);
    return currentScopeVar;
  }

  public abstract LocalVariable getImplicitBlockArg();

  public void markUnusedImplicitBlockArg() {
    hasUnusedImplicitBlockArg = true;
  }

  public LocalVariable findExistingLocalVariable(String name, int depth) {
    return localVars.getVariable(name);
  }

  /**
   * Find or create a local variable. By default, scopes are assumed to only check current depth.
   * Blocks/Closures override this because they have special nesting rules.
   */
  public LocalVariable getLocalVariable(String name, int scopeDepth) {
    LocalVariable lvar = findExistingLocalVariable(name, scopeDepth);
    if (lvar == null) {
      lvar = new LocalVariable(name, scopeDepth, localVars.nextSlot);
      localVars.putVariable(name, lvar);
    }

    return lvar;
  }

  public LocalVariable getNewLocalVariable(String name, int depth) {
    throw new RuntimeException(
        "getNewLocalVariable should be called for: " + this.getClass().getName());
  }

  protected void initEvalScopeVariableAllocator(boolean reset) {
    if (reset || evalScopeVars == null) evalScopeVars = new LocalVariableAllocator();
  }

  public TemporaryVariable getNewTemporaryVariable() {
    temporaryVariableIndex++;
    return new TemporaryVariable(temporaryVariableIndex);
  }

  public TemporaryVariable getNewTemporaryVariable(String name) {
    temporaryVariableIndex++;
    return new TemporaryVariable(name, temporaryVariableIndex);
  }

  public void resetTemporaryVariables() {
    temporaryVariableIndex = -1;
  }

  public int getTemporaryVariableSize() {
    return temporaryVariableIndex + 1;
  }

  // Generate a new variable for inlined code
  public Variable getNewInlineVariable(String inlinePrefix, Variable v) {
    if (v instanceof LocalVariable) {
      LocalVariable lv = (LocalVariable) v;
      return getLocalVariable(inlinePrefix + lv.getName(), lv.getScopeDepth());
    } else {
      return getNewTemporaryVariable();
    }
  }

  public int getThreadPollInstrsCount() {
    return threadPollInstrsCount;
  }

  public int getLocalVariablesCount() {
    return localVars.nextSlot;
  }

  public int getUsedVariablesCount() {
    // System.out.println("For " + this + ", # lvs: " + nextLocalVariableSlot);
    // # local vars, # flip vars
    //
    // SSS FIXME: When we are opting local var access,
    // no need to allocate local var space except when we have been asked to!
    return getLocalVariablesCount() + getPrefixCountSize("%flip");
  }

  public void setUpUseDefLocalVarMaps() {
    definedLocalVars = new java.util.HashSet<Variable>();
    usedLocalVars = new java.util.HashSet<Variable>();
    for (BasicBlock bb : cfg().getBasicBlocks()) {
      for (Instr i : bb.getInstrs()) {
        for (Variable v : i.getUsedVariables()) {
          if (v instanceof LocalVariable) usedLocalVars.add(v);
        }

        if (i instanceof ResultInstr) {
          Variable v = ((ResultInstr) i).getResult();

          if (v instanceof LocalVariable) definedLocalVars.add(v);
        }
      }
    }

    for (IRClosure cl : getClosures()) {
      cl.setUpUseDefLocalVarMaps();
    }
  }

  public boolean usesLocalVariable(Variable v) {
    if (usedLocalVars == null) setUpUseDefLocalVarMaps();
    if (usedLocalVars.contains(v)) return true;

    for (IRClosure cl : getClosures()) {
      if (cl.usesLocalVariable(v)) return true;
    }

    return false;
  }

  public boolean definesLocalVariable(Variable v) {
    if (definedLocalVars == null) setUpUseDefLocalVarMaps();
    if (definedLocalVars.contains(v)) return true;

    for (IRClosure cl : getClosures()) {
      if (cl.definesLocalVariable(v)) return true;
    }

    return false;
  }

  public void setDataFlowSolution(String name, DataFlowProblem p) {
    dfProbs.put(name, p);
  }

  public DataFlowProblem getDataFlowSolution(String name) {
    return dfProbs.get(name);
  }

  // This should only be used to do pre-cfg opts and to build the CFG.
  // Everyone else should use the CFG.
  public List<Instr> getInstrs() {
    if (cfg != null)
      throw new RuntimeException("Please use the CFG to access this scope's instructions.");
    return instrList;
  }

  public Instr[] getInstrsForInterpretation() {
    return linearizedInstrArray;
  }

  public void resetLinearizationData() {
    linearizedBBList = null;
    relinearizeCFG = false;
  }

  public void checkRelinearization() {
    if (relinearizeCFG) resetLinearizationData();
  }

  public List<BasicBlock> buildLinearization() {
    checkRelinearization();

    if (linearizedBBList != null) return linearizedBBList; // Already linearized

    linearizedBBList = CFGLinearizer.linearize(cfg);

    return linearizedBBList;
  }

  // SSS FIXME: Extremely inefficient
  public int getRescuerPC(Instr excInstr) {
    depends(cfg());

    for (BasicBlock b : linearizedBBList) {
      for (Instr i : b.getInstrs()) {
        if (i == excInstr) {
          BasicBlock rescuerBB = cfg().getRescuerBBFor(b);
          return (rescuerBB == null) ? -1 : rescuerBB.getLabel().getTargetPC();
        }
      }
    }

    // SSS FIXME: Cannot happen! Throw runtime exception
    LOG.error("Fell through looking for rescuer ipc for " + excInstr);
    return -1;
  }

  // SSS FIXME: Extremely inefficient
  public int getEnsurerPC(Instr excInstr) {
    depends(cfg());

    for (BasicBlock b : linearizedBBList) {
      for (Instr i : b.getInstrs()) {
        if (i == excInstr) {
          BasicBlock ensurerBB = cfg.getEnsurerBBFor(b);
          return (ensurerBB == null) ? -1 : ensurerBB.getLabel().getTargetPC();
        }
      }
    }

    // SSS FIXME: Cannot happen! Throw runtime exception
    LOG.error("Fell through looking for ensurer ipc for " + excInstr);
    return -1;
  }

  public List<BasicBlock> linearization() {
    depends(cfg());

    assert linearizedBBList != null : "You have not run linearization";

    return linearizedBBList;
  }

  protected void depends(Object obj) {
    assert obj != null
        : "Unsatisfied dependency and this depends() was set "
            + "up wrong.  Use depends(build()) not depends(build).";
  }

  public CFG cfg() {
    assert cfg != null : "Trying to access build before build started";
    return cfg;
  }

  public void splitCalls() {
    // FIXME: (Enebo) We are going to make a SplitCallInstr so this logic can be separate
    // from unsplit calls.  Comment out until new SplitCall is created.
    //        for (BasicBlock b: getNodes()) {
    //            List<Instr> bInstrs = b.getInstrs();
    //            for (ListIterator<Instr> it = ((ArrayList<Instr>)b.getInstrs()).listIterator();
    // it.hasNext(); ) {
    //                Instr i = it.next();
    //                // Only user calls, not Ruby & JRuby internal calls
    //                if (i.operation == Operation.CALL) {
    //                    CallInstr call = (CallInstr)i;
    //                    Operand   r    = call.getReceiver();
    //                    Operand   m    = call.getMethodAddr();
    //                    Variable  mh   = _scope.getNewTemporaryVariable();
    //                    MethodLookupInstr mli = new MethodLookupInstr(mh, m, r);
    //                    // insert method lookup at the right place
    //                    it.previous();
    //                    it.add(mli);
    //                    it.next();
    //                    // update call address
    //                    call.setMethodAddr(mh);
    //                }
    //            }
    //        }
    //
    //        List<IRClosure> nestedClosures = _scope.getClosures();
    //        if (!nestedClosures.isEmpty()) {
    //            for (IRClosure c : nestedClosures) {
    //                c.getCFG().splitCalls();
    //            }
    //        }
  }

  public void resetDFProblemsState() {
    dfProbs = new HashMap<String, DataFlowProblem>();
    for (IRClosure c : nestedClosures) c.resetDFProblemsState();
  }

  public void resetState() {
    relinearizeCFG = true;
    linearizedInstrArray = null;
    cfg.resetState();

    // reset flags
    flagsComputed = false;
    canModifyCode = true;
    canCaptureCallersBinding = true;
    bindingHasEscaped = true;
    usesEval = true;
    usesZSuper = true;
    hasBreakInstrs = false;
    hasNonlocalReturns = false;
    canReceiveBreaks = false;
    canReceiveNonlocalReturns = false;

    // Reset dataflow problems state
    resetDFProblemsState();
  }

  public void inlineMethod(
      IRScope method, RubyModule implClass, int classToken, BasicBlock basicBlock, CallBase call) {
    // Inline
    depends(cfg());
    new CFGInliner(cfg).inlineMethod(method, implClass, classToken, basicBlock, call);

    // Reset state
    resetState();

    // Re-run opts
    for (CompilerPass pass : getManager().getInliningCompilerPasses(this)) {
      pass.run(this);
    }
  }

  public void buildCFG(List<Instr> instrList) {
    CFG newBuild = new CFG(this);
    newBuild.build(instrList);
    cfg = newBuild;
  }

  public void resetCFG() {
    cfg = null;
  }

  /* Record a begin block -- not all scope implementations can handle them */
  public void recordBeginBlock(IRClosure beginBlockClosure) {
    throw new RuntimeException("BEGIN blocks cannot be added to: " + this.getClass().getName());
  }

  /* Record an end block -- not all scope implementations can handle them */
  public void recordEndBlock(IRClosure endBlockClosure) {
    throw new RuntimeException("END blocks cannot be added to: " + this.getClass().getName());
  }

  // Enebo: We should just make n primitive int and not take the hash hit
  protected int allocateNextPrefixedName(String prefix) {
    int index = getPrefixCountSize(prefix);

    nextVarIndex.put(prefix, index + 1);

    return index;
  }

  protected void resetVariableCounter(String prefix) {
    nextVarIndex.remove(prefix);
  }

  protected int getPrefixCountSize(String prefix) {
    Integer index = nextVarIndex.get(prefix);

    if (index == null) return 0;

    return index.intValue();
  }

  public RubyModule getContainerModule() {
    //        System.out.println("GET: container module of " + getName() + " with hc " + hashCode()
    // + " to " + containerModule.getName());
    return containerModule;
  }

  public int getNextClosureId() {
    nextClosureIndex++;

    return nextClosureIndex;
  }

  /**
   * Does this scope represent a module body? (SSS FIXME: what about script or eval script bodies?)
   */
  public boolean isModuleBody() {
    return false;
  }

  /** Is this IRClassBody but not IRMetaClassBody? */
  public boolean isNonSingletonClassBody() {
    return false;
  }

  public boolean isFlipScope() {
    return true;
  }

  public boolean isTopLocalVariableScope() {
    return true;
  }

  /** Is this an eval script or a regular file script? */
  public boolean isScriptScope() {
    return false;
  }
}
Esempio n. 16
0
/**
 * Class used to launch the interpreter. This is the main class as defined in the jruby.mf manifest.
 * It is very basic and does not support yet the same array of switches as the C interpreter. Usage:
 * java -jar jruby.jar [switches] [rubyfile.rb] [arguments] -e 'command' one line of script. Several
 * -e's allowed. Omit [programfile]
 *
 * @author jpetersen
 */
public class Main {
  private static final Logger LOG = LoggerFactory.getLogger("Main");

  public Main(RubyInstanceConfig config) {
    this(config, false);
  }

  public Main(final InputStream in, final PrintStream out, final PrintStream err) {
    this(new RubyInstanceConfig(in, out, err));
  }

  public Main() {
    this(new RubyInstanceConfig());
  }

  private Main(RubyInstanceConfig config, boolean hardExit) {
    this.config = config;
    config.setHardExit(hardExit);
  }

  private Main(boolean hardExit) {
    // used only from main(String[]), so we process dotfile here
    processDotfile();
    this.config = new RubyInstanceConfig();
    config.setHardExit(hardExit);
  }

  private static List<String> getDotfileDirectories() {
    ArrayList<String> searchList = new ArrayList<String>();
    for (String homeProp : new String[] {"user.dir", "user.home"}) {
      String home = SafePropertyAccessor.getProperty(homeProp);
      if (home != null) searchList.add(home);
    }

    // JVM sometimes picks odd location for user.home based on a registry entry
    // (see http://bugs.sun.com/view_bug.do?bug_id=4787931).  Add extra check in
    // case that entry is wrong. Add before user.home in search list.
    if (Platform.IS_WINDOWS) {
      String homeDrive = System.getenv("HOMEDRIVE");
      String homePath = System.getenv("HOMEPATH");
      if (homeDrive != null && homePath != null) {
        searchList.add(1, (homeDrive + homePath).replace('\\', '/'));
      }
    }

    return searchList;
  }

  public static void processDotfile() {
    for (String home : getDotfileDirectories()) {
      File dotfile = new File(home + "/.jrubyrc");
      if (dotfile.exists()) loadJRubyProperties(dotfile);
    }
  }

  private static void loadJRubyProperties(File dotfile) {
    FileInputStream fis = null;

    try {
      // update system properties with long form jruby properties from .jrubyrc
      Properties sysProps = System.getProperties();
      Properties newProps = new Properties();
      // load properties and re-set as jruby.*
      fis = new FileInputStream(dotfile);
      newProps.load(fis);
      for (Map.Entry entry : newProps.entrySet()) {
        sysProps.put("jruby." + entry.getKey(), entry.getValue());
      }
    } catch (IOException ioe) {
      LOG.debug("exception loading " + dotfile, ioe);
    } catch (SecurityException se) {
      LOG.debug("exception loading " + dotfile, se);
    } finally {
      if (fis != null)
        try {
          fis.close();
        } catch (Exception e) {
        }
    }
  }

  public static class Status {
    private boolean isExit = false;
    private int status = 0;

    /**
     * Creates a status object with the specified value and with explicit exit flag. An exit flag
     * means that Kernel.exit() has been explicitly invoked during the run.
     *
     * @param status The status value.
     */
    Status(int status) {
      this.isExit = true;
      this.status = status;
    }

    /** Creates a status object with 0 value and no explicit exit flag. */
    Status() {}

    public boolean isExit() {
      return isExit;
    }

    public int getStatus() {
      return status;
    }
  }

  /**
   * This is the command-line entry point for JRuby, and should ONLY be used by Java when starting
   * up JRuby from a command-line. Use other mechanisms when embedding JRuby into another
   * application.
   *
   * @param args command-line args, provided by the JVM.
   */
  public static void main(String[] args) {
    doGCJCheck();

    Main main;

    if (DripMain.DRIP_RUNTIME != null) {
      main = new Main(DripMain.DRIP_CONFIG, true);
    } else {
      main = new Main(true);
    }

    try {
      Status status = main.run(args);
      if (status.isExit()) {
        System.exit(status.getStatus());
      }
    } catch (RaiseException rj) {
      System.exit(handleRaiseException(rj));
    } catch (Throwable t) {
      // print out as a nice Ruby backtrace
      System.err.println(ThreadContext.createRawBacktraceStringFromThrowable(t));
      while ((t = t.getCause()) != null) {
        System.err.println("Caused by:");
        System.err.println(ThreadContext.createRawBacktraceStringFromThrowable(t));
      }
      System.exit(1);
    }
  }

  public Status run(String[] args) {
    try {
      if (Options.TRUFFLE_PRINT_RUNTIME.load()) {
        config.getError().println("jruby: using " + Truffle.getRuntime().getName());
      }

      config.processArguments(args);
      return internalRun();
    } catch (MainExitException mee) {
      return handleMainExit(mee);
    } catch (OutOfMemoryError oome) {
      return handleOutOfMemory(oome);
    } catch (StackOverflowError soe) {
      return handleStackOverflow(soe);
    } catch (UnsupportedClassVersionError ucve) {
      return handleUnsupportedClassVersion(ucve);
    } catch (ThreadKill kill) {
      return new Status();
    }
  }

  @Deprecated
  public Status run() {
    return internalRun();
  }

  private Status internalRun() {
    doShowVersion();
    doShowCopyright();

    if (!config.getShouldRunInterpreter()) {
      doPrintUsage(false);
      doPrintProperties();
      return new Status();
    }

    InputStream in = config.getScriptSource();
    String filename = config.displayedFileName();

    doProcessArguments(in);

    Ruby _runtime;

    if (DripMain.DRIP_RUNTIME != null) {
      // use drip's runtime, reinitializing config
      _runtime = DripMain.DRIP_RUNTIME;
      _runtime.reinitialize(true);
    } else {
      _runtime = Ruby.newInstance(config);
    }

    final Ruby runtime = _runtime;
    final AtomicBoolean didTeardown = new AtomicBoolean();

    if (config.isHardExit()) {
      // we're the command-line JRuby, and should set a shutdown hook for
      // teardown.
      Runtime.getRuntime()
          .addShutdownHook(
              new Thread() {
                public void run() {
                  if (didTeardown.compareAndSet(false, true)) {
                    runtime.tearDown();
                  }
                }
              });
    }

    try {
      doSetContextClassLoader(runtime);

      if (in == null) {
        // no script to run, return success
        return new Status();
      } else if (config.isXFlag() && !config.hasShebangLine()) {
        // no shebang was found and x option is set
        throw new MainExitException(1, "jruby: no Ruby script found in input (LoadError)");
      } else if (config.getShouldCheckSyntax()) {
        // check syntax only and exit
        return doCheckSyntax(runtime, in, filename);
      } else {
        // proceed to run the script
        return doRunFromMain(runtime, in, filename);
      }
    } finally {
      if (didTeardown.compareAndSet(false, true)) {
        runtime.tearDown();
      }
    }
  }

  private Status handleUnsupportedClassVersion(UnsupportedClassVersionError ucve) {
    config
        .getError()
        .println("Error: Some library (perhaps JRuby) was built with a later JVM version.");
    config
        .getError()
        .println(
            "Please use libraries built with the version you intend to use or an earlier one.");
    if (config.isVerbose()) {
      config.getError().println("Exception trace follows:");
      ucve.printStackTrace();
    } else {
      config.getError().println("Specify -w for full UnsupportedClassVersionError stack trace");
    }
    return new Status(1);
  }

  /** Print a nicer stack size error since Rubyists aren't used to seeing this. */
  private Status handleStackOverflow(StackOverflowError soe) {
    String memoryMax = getRuntimeFlagValue("-Xss");

    if (memoryMax != null) {
      config
          .getError()
          .println(
              "Error: Your application used more stack memory than the safety cap of "
                  + memoryMax
                  + ".");
    } else {
      config
          .getError()
          .println("Error: Your application used more stack memory than the default safety cap.");
    }
    config.getError().println("Specify -J-Xss####k to increase it (#### = cap size in KB).");

    if (config.isVerbose()) {
      config.getError().println("Exception trace follows:");
      soe.printStackTrace(config.getError());
    } else {
      config.getError().println("Specify -w for full StackOverflowError stack trace");
    }

    return new Status(1);
  }

  /** Print a nicer memory error since Rubyists aren't used to seeing this. */
  private Status handleOutOfMemory(OutOfMemoryError oome) {
    System.gc(); // try to clean up a bit of space, hopefully, so we can report this error

    String oomeMessage = oome.getMessage();

    if (oomeMessage.contains("PermGen")) { // report permgen memory error
      config.getError().println("Error: Your application exhausted PermGen area of the heap.");
      config
          .getError()
          .println("Specify -J-XX:MaxPermSize=###M to increase it (### = PermGen size in MB).");

    } else { // report heap memory error

      String memoryMax = getRuntimeFlagValue("-Xmx");

      if (memoryMax != null) {
        config
            .getError()
            .println(
                "Error: Your application used more memory than the safety cap of "
                    + memoryMax
                    + ".");
      } else {
        config
            .getError()
            .println("Error: Your application used more memory than the default safety cap.");
      }
      config.getError().println("Specify -J-Xmx####m to increase it (#### = cap size in MB).");
    }

    if (config.isVerbose()) {
      config.getError().println("Exception trace follows:");
      oome.printStackTrace(config.getError());
    } else {
      config.getError().println("Specify -w for full OutOfMemoryError stack trace");
    }

    return new Status(1);
  }

  private String getRuntimeFlagValue(String prefix) {
    RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();

    for (String param : runtime.getInputArguments()) {
      if (param.startsWith(prefix)) {
        return param.substring(prefix.length()).toUpperCase();
      }
    }

    return null;
  }

  private Status handleMainExit(MainExitException mee) {
    if (!mee.isAborted()) {
      config.getOutput().println(mee.getMessage());
      if (mee.isUsageError()) {
        doPrintUsage(true);
      }
    }
    return new Status(mee.getStatus());
  }

  private Status doRunFromMain(Ruby runtime, InputStream in, String filename) {
    long now = -1;
    try {
      doCheckSecurityManager();

      runtime.runFromMain(in, filename);

      runtime.getTruffleBridge().shutdown();

    } catch (RaiseException rj) {
      return new Status(handleRaiseException(rj));
    }
    return new Status();
  }

  private Status doCheckSyntax(Ruby runtime, InputStream in, String filename)
      throws RaiseException {
    // check primary script
    boolean status = checkStreamSyntax(runtime, in, filename);

    // check other scripts specified on argv
    for (String arg : config.getArgv()) {
      status = status && checkFileSyntax(runtime, arg);
    }

    return new Status(status ? 0 : -1);
  }

  private boolean checkFileSyntax(Ruby runtime, String filename) {
    File file = new File(filename);
    if (file.exists()) {
      try {
        return checkStreamSyntax(runtime, new FileInputStream(file), filename);
      } catch (FileNotFoundException fnfe) {
        config.getError().println("File not found: " + filename);
        return false;
      }
    } else {
      return false;
    }
  }

  private boolean checkStreamSyntax(Ruby runtime, InputStream in, String filename) {
    try {
      runtime.parseFromMain(in, filename);
      config.getOutput().println("Syntax OK");
      return true;
    } catch (RaiseException re) {
      if (re.getException().getMetaClass().getBaseName().equals("SyntaxError")) {
        config
            .getError()
            .println("SyntaxError in " + re.getException().message(runtime.getCurrentContext()));
      } else {
        throw re;
      }
      return false;
    }
  }

  private void doSetContextClassLoader(Ruby runtime) {
    // set thread context JRuby classloader here, for the main thread
    try {
      Thread.currentThread().setContextClassLoader(runtime.getJRubyClassLoader());
    } catch (SecurityException se) {
      // can't set TC classloader
      if (runtime.getInstanceConfig().isVerbose()) {
        config
            .getError()
            .println(
                "WARNING: Security restrictions disallowed setting context classloader for main thread.");
      }
    }
  }

  private void doProcessArguments(InputStream in) {
    config.processArguments(config.parseShebangOptions(in));
  }

  private void doPrintProperties() {
    if (config.getShouldPrintProperties()) {
      config.getOutput().print(OutputStrings.getPropertyHelp());
    }
  }

  private void doPrintUsage(boolean force) {
    if (config.getShouldPrintUsage() || force) {
      config.getOutput().print(OutputStrings.getBasicUsageHelp());
    }
  }

  private void doShowCopyright() {
    if (config.isShowCopyright()) {
      config.getOutput().println(OutputStrings.getCopyrightString());
    }
  }

  private void doShowVersion() {
    if (config.isShowVersion()) {
      config.getOutput().println(OutputStrings.getVersionString());
    }
  }

  private static void doGCJCheck() {
    // Ensure we're not running on GCJ, since it's not supported and leads to weird errors
    if (Platform.IS_GCJ) {
      System.err.println("Fatal: GCJ (GNU Compiler for Java) is not supported by JRuby.");
      System.exit(1);
    }
  }

  private void doCheckSecurityManager() {
    if (Main.class.getClassLoader() == null && System.getSecurityManager() != null) {
      System.err.println(
          "Warning: security manager and JRuby running from boot classpath.\n"
              + "Run from jruby.jar or set env VERIFY_JRUBY=true to enable security.");
    }
  }

  private static int handleRaiseException(RaiseException rj) {
    RubyException raisedException = rj.getException();
    Ruby runtime = raisedException.getRuntime();
    if (runtime.getSystemExit().isInstance(raisedException)) {
      IRubyObject status = raisedException.callMethod(runtime.getCurrentContext(), "status");
      if (status != null && !status.isNil()) {
        return RubyNumeric.fix2int(status);
      } else {
        return 0;
      }
    } else {
      runtime
          .getErrorStream()
          .print(
              runtime
                  .getInstanceConfig()
                  .getTraceType()
                  .printBacktrace(raisedException, runtime.getPosix().isatty(FileDescriptor.err)));
      return 1;
    }
  }

  private final RubyInstanceConfig config;
}