jdk8-mips64-public/nashorn: comparison src/jdk/nashorn/internal/codegen/CodeGenerator.java

-:95b8a01d3b52
+:c09b105e7be5
 private static final Call CREATE_REWRITE_EXCEPTION_REST_OF = CompilerConstants.staticCallNoLookup(RewriteException.class,
 "create", RewriteException.class, UnwarrantedOptimismException.class, Object[].class, String[].class, int[].class);
 private static final Call ENSURE_INT = CompilerConstants.staticCallNoLookup(OptimisticReturnFilters.class,
 "ensureInt", int.class, Object.class, int.class);
-private static final Call ENSURE_LONG = CompilerConstants.staticCallNoLookup(OptimisticReturnFilters.class,
-"ensureLong", long.class, Object.class, int.class);
 private static final Call ENSURE_NUMBER = CompilerConstants.staticCallNoLookup(OptimisticReturnFilters.class,
 "ensureNumber", double.class, Object.class, int.class);
 private static final Call CREATE_FUNCTION_OBJECT = CompilerConstants.staticCallNoLookup(ScriptFunction.class,
 "create", ScriptFunction.class, Object[].class, int.class, ScriptObject.class);
 return false;
 }
 enterStatement(expressionStatement);
 loadAndDiscard(expressionStatement.getExpression());
-assert method.getStackSize() == 0;
+assert method.getStackSize() == 0 : "stack not empty in " + expressionStatement;
 return false;
 }
 @Override
 *
 * @param arrayLiteralNode the array of contents
 * @param arrayType        the type of the array, e.g. ARRAY_NUMBER or ARRAY_OBJECT
 */
 private void loadArray(final ArrayLiteralNode arrayLiteralNode, final ArrayType arrayType) {
-assert arrayType == Type.INT_ARRAY || arrayType == Type.LONG_ARRAY || arrayType == Type.NUMBER_ARRAY || arrayType == Type.OBJECT_ARRAY;
+assert arrayType == Type.INT_ARRAY || arrayType == Type.NUMBER_ARRAY || arrayType == Type.OBJECT_ARRAY;
 final Expression[]     nodes    = arrayLiteralNode.getValue();
 final Object           presets  = arrayLiteralNode.getPresets();
 final int[]            postsets = arrayLiteralNode.getPostsets();
 final List<Splittable.SplitRange> ranges   = arrayLiteralNode.getSplitRanges();
 if(!resultBounds.canBeNarrowerThan(Type.OBJECT)) {
 method.load((Integer)value);
 method.convert(Type.OBJECT);
 } else if(!resultBounds.canBeNarrowerThan(Type.NUMBER)) {
 method.load(((Integer)value).doubleValue());
-} else if(!resultBounds.canBeNarrowerThan(Type.LONG)) {
-method.load(((Integer)value).longValue());
 } else {
 method.load((Integer)value);
-}
-} else if (value instanceof Long) {
-if(!resultBounds.canBeNarrowerThan(Type.OBJECT)) {
-method.load((Long)value);
-method.convert(Type.OBJECT);
-} else if(!resultBounds.canBeNarrowerThan(Type.NUMBER)) {
-method.load(((Long)value).doubleValue());
-} else {
-method.load((Long)value);
 }
 } else if (value instanceof Double) {
 if(!resultBounds.canBeNarrowerThan(Type.OBJECT)) {
 method.load((Double)value);
 method.convert(Type.OBJECT);
 }
 private void loadMinusOne() {
 if (type.isInteger()) {
 method.load(isIncrement ? 1 : -1);
-} else if (type.isLong()) {
-method.load(isIncrement ? 1L : -1L);
 } else {
 method.load(isIncrement ? 1.0 : -1.0);
 }
 }
 }
 }.store();
 }
 private void loadASSIGN_SHR(final BinaryNode binaryNode) {
-new BinarySelfAssignment(binaryNode) {
+new SelfModifyingStore<BinaryNode>(binaryNode, binaryNode.lhs()) {
 @Override
-protected void op() {
+protected void evaluate() {
-doSHR();
+new OptimisticOperation(assignNode, new TypeBounds(Type.INT, Type.NUMBER)) {
-}
+@Override
+void loadStack() {
+assert assignNode.getWidestOperandType() == Type.INT;
+if (isRhsZero(binaryNode)) {
+loadExpressionAsType(binaryNode.lhs(), Type.INT);
+} else {
+loadBinaryOperands(binaryNode.lhs(), binaryNode.rhs(), TypeBounds.INT, true, false);
+method.shr();
+}
+}
+@Override
+void consumeStack() {
+if (isOptimistic(binaryNode)) {
+toUint32Optimistic(binaryNode.getProgramPoint());
+} else {
+toUint32Double();
+}
+}
+}.emit(getOptimisticIgnoreCountForSelfModifyingExpression(binaryNode.lhs()));
+method.convert(assignNode.getType());
+}
 }.store();
 }
-private void doSHR() {
+private void doSHR(final BinaryNode binaryNode) {
-// TODO: make SHR optimistic
+new OptimisticOperation(binaryNode, new TypeBounds(Type.INT, Type.NUMBER)) {
-method.shr();
+@Override
-toUint();
+void loadStack() {
-}
+if (isRhsZero(binaryNode)) {
+loadExpressionAsType(binaryNode.lhs(), Type.INT);
-private void toUint() {
+} else {
-JSType.TO_UINT32_I.invoke(method);
+loadBinaryOperands(binaryNode);
+method.shr();
+}
+}
+@Override
+void consumeStack() {
+if (isOptimistic(binaryNode)) {
+toUint32Optimistic(binaryNode.getProgramPoint());
+} else {
+toUint32Double();
+}
+}
+}.emit();
+}
+private void toUint32Optimistic(final int programPoint) {
+method.load(programPoint);
+JSType.TO_UINT32_OPTIMISTIC.invoke(method);
+}
+private void toUint32Double() {
+JSType.TO_UINT32_DOUBLE.invoke(method);
 }
 private void loadASSIGN_SUB(final BinaryNode binaryNode) {
 new BinaryOptimisticSelfAssignment(binaryNode) {
 @Override
 operandBounds = new TypeBounds(node.getType(), Type.NUMBER);
 } else {
 // Non-optimistic, non-FP subtraction or multiplication. Allow them to overflow.
 operandBounds = new TypeBounds(Type.narrowest(node.getWidestOperandType(),
 numericBounds.widest), Type.NUMBER);
-forceConversionSeparation = node.getWidestOperationType().narrowerThan(numericBounds.widest);
+forceConversionSeparation = true;
 }
 }
 loadBinaryOperands(node.lhs(), node.rhs(), operandBounds, false, forceConversionSeparation);
 }
 loadBinaryOperands(binaryNode);
 method.shl();
 }
 private void loadSHR(final BinaryNode binaryNode) {
-// Optimize x >>> 0 to (uint)x
+doSHR(binaryNode);
-if (isRhsZero(binaryNode)) {
-loadExpressionAsType(binaryNode.lhs(), Type.INT);
-toUint();
-} else {
-loadBinaryOperands(binaryNode);
-doSHR();
-}
 }
 private void loadSUB(final BinaryNode binaryNode, final TypeBounds resultBounds) {
 new BinaryArith() {
 @Override
 } else {
 method.dynamicSet(node.getName(), flags, false);
 }
 } else {
 final Type storeType = assignNode.getType();
+assert storeType != Type.LONG;
 if (symbol.hasSlotFor(storeType)) {
 // Only emit a convert for a store known to be live; converts for dead stores can
 // give us an unnecessary ClassCastException.
 method.convert(storeType);
 }
 final Type optimisticType = getOptimisticCoercedType();
 if(!optimisticType.isObject()) {
 method.load(optimistic.getProgramPoint());
 if(optimisticType.isInteger()) {
 method.invoke(ENSURE_INT);
-} else if(optimisticType.isLong()) {
-method.invoke(ENSURE_LONG);
 } else if(optimisticType.isNumber()) {
 method.invoke(ENSURE_NUMBER);
 } else {
 throw new AssertionError(optimisticType);
 }

Mercurial > jdk8-mips64-public > nashorn / file comparison

comparison: src/jdk/nashorn/internal/codegen/CodeGenerator.java

src/jdk/nashorn/internal/codegen/CodeGenerator.java