Exemplo n.º 1
0
  Type getOptimisticType(final Optimistic node) {
    assert compiler.useOptimisticTypes();

    final int programPoint = node.getProgramPoint();
    final Type validType = compiler.getInvalidatedProgramPointType(programPoint);

    if (validType != null) {
      return validType;
    }

    final Type mostOptimisticType = node.getMostOptimisticType();
    final Type evaluatedType = getEvaluatedType(node);

    if (evaluatedType != null) {
      if (evaluatedType.widerThan(mostOptimisticType)) {
        final Type newValidType =
            evaluatedType.isObject() || evaluatedType.isBoolean() ? Type.OBJECT : evaluatedType;
        // Update invalidatedProgramPoints so we don't re-evaluate the expression next time. This is
        // a heuristic
        // as we're doing a tradeoff. Re-evaluating expressions on each recompile takes time, but it
        // might
        // notice a widening in the type of the expression and thus prevent an unnecessary
        // deoptimization later.
        // We'll presume though that the types of expressions are mostly stable, so if we evaluated
        // it in one
        // compilation, we'll keep to that and risk a low-probability deoptimization if its type
        // gets widened
        // in the future.
        compiler.addInvalidatedProgramPoint(node.getProgramPoint(), newValidType);
      }
      return evaluatedType;
    }
    return mostOptimisticType;
  }
 private static ArrayType getArrayType(final Type elementType) {
   if (elementType.isInteger()) {
     return Type.INT_ARRAY;
   } else if (elementType.isLong()) {
     return Type.LONG_ARRAY;
   } else if (elementType.isNumeric()) {
     return Type.NUMBER_ARRAY;
   } else {
     return Type.OBJECT_ARRAY;
   }
 }
 static Object computePresets(
     final Expression[] value, final Type elementType, final int[] postsets) {
   assert !elementType.isUnknown();
   if (elementType.isInteger()) {
     return presetIntArray(value, postsets);
   } else if (elementType.isLong()) {
     return presetLongArray(value, postsets);
   } else if (elementType.isNumeric()) {
     return presetDoubleArray(value, postsets);
   } else {
     return presetObjectArray(value, postsets);
   }
 }
Exemplo n.º 4
0
  private static Type getPropertyType(final ScriptObject sobj, final String name) {
    final FindProperty find = sobj.findProperty(name, true);
    if (find == null) {
      return null;
    }

    final Property property = find.getProperty();
    final Class<?> propertyClass = property.getType();
    if (propertyClass == null) {
      // propertyClass == null means its value is Undefined. It is probably not initialized yet, so
      // we won't make
      // a type assumption yet.
      return null;
    } else if (propertyClass.isPrimitive()) {
      return Type.typeFor(propertyClass);
    }

    final ScriptObject owner = find.getOwner();
    if (property.hasGetterFunction(owner)) {
      // Can have side effects, so we can't safely evaluate it; since !propertyClass.isPrimitive(),
      // it's Object.
      return Type.OBJECT;
    }

    // Safely evaluate the property, and return the narrowest type for the actual value (e.g.
    // Type.INT for a boxed
    // integer).
    final Object value =
        property.needsDeclaration()
            ? ScriptRuntime.UNDEFINED
            : property.getObjectValue(owner, owner);
    if (value == ScriptRuntime.UNDEFINED) {
      return null;
    }
    return Type.typeFor(JSType.unboxedFieldType(value));
  }
      private static Type computeElementType(final Expression[] value) {
        Type widestElementType = Type.INT;

        for (final Expression elem : value) {
          if (elem == null) {
            widestElementType =
                widestElementType.widest(Type.OBJECT); // no way to represent undefined as number
            break;
          }

          final Type type = elem.getType().isUnknown() ? Type.OBJECT : elem.getType();
          if (type.isBoolean()) {
            // TODO fix this with explicit boolean types
            widestElementType = widestElementType.widest(Type.OBJECT);
            break;
          }

          widestElementType = widestElementType.widest(type);
          if (widestElementType.isObject()) {
            break;
          }
        }
        return widestElementType;
      }
 /**
  * Get the element type of this array literal
  *
  * @return element type
  */
 public Type getElementType() {
   assert !elementType.isUnknown() : this + " has elementType=unknown";
   return elementType;
 }
 @Override
 public Type getType() {
   return Type.typeFor(NativeArray.class);
 }
 @Override
 public Type getType() {
   return Type.typeFor(value.getClass());
 }
Exemplo n.º 9
0
  private Type getEvaluatedType(final Optimistic expr) {
    if (expr instanceof IdentNode) {
      if (runtimeScope == null) {
        return null;
      }
      return getPropertyType(runtimeScope, ((IdentNode) expr).getName());
    } else if (expr instanceof AccessNode) {
      final AccessNode accessNode = (AccessNode) expr;
      final Object base = evaluateSafely(accessNode.getBase());
      if (!(base instanceof ScriptObject)) {
        return null;
      }
      return getPropertyType((ScriptObject) base, accessNode.getProperty());
    } else if (expr instanceof IndexNode) {
      final IndexNode indexNode = (IndexNode) expr;
      final Object base = evaluateSafely(indexNode.getBase());
      if (base instanceof NativeArray || base instanceof ArrayBufferView) {
        // NOTE: optimistic array getters throw UnwarrantedOptimismException based on the type of
        // their
        // underlying array storage, not based on values of individual elements. Thus, a
        // LongArrayData will
        // throw UOE for every optimistic int linkage attempt, even if the long value being returned
        // in the
        // first invocation would be representable as int. That way, we can presume that the array's
        // optimistic
        // type is the most optimistic type for which an element getter has a chance of executing
        // successfully.
        return ((ScriptObject) base).getArray().getOptimisticType();
      }
    } else if (expr instanceof CallNode) {
      // Currently, we'll only try to guess the return type of immediately invoked function
      // expressions with no
      // parameters, that is (function() { ... })(). We could do better, but these are all
      // heuristics and we can
      // gradually introduce them as needed. An easy one would be to do the same for .call(this)
      // idiom.
      final CallNode callExpr = (CallNode) expr;
      final Expression fnExpr = callExpr.getFunction();
      if (fnExpr instanceof FunctionNode) {
        final FunctionNode fn = (FunctionNode) fnExpr;
        if (callExpr.getArgs().isEmpty()) {
          final RecompilableScriptFunctionData data = compiler.getScriptFunctionData(fn.getId());
          if (data != null) {
            final Type returnType =
                Type.typeFor(data.getReturnType(EMPTY_INVOCATION_TYPE, runtimeScope));
            if (returnType == Type.BOOLEAN) {
              // We don't have optimistic booleans. In fact, optimistic call sites getting back
              // boolean
              // currently deoptimize all the way to Object.
              return Type.OBJECT;
            }
            assert returnType == Type.INT
                || returnType == Type.LONG
                || returnType == Type.NUMBER
                || returnType == Type.OBJECT;
            return returnType;
          }
        }
      }
    }

    return null;
  }