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

-:ec3094d9d5d5
+:03a68e7ca1d5
 import static jdk.nashorn.internal.codegen.CompilerConstants.VARARGS;
 import static jdk.nashorn.internal.codegen.CompilerConstants.constructorNoLookup;
 import static jdk.nashorn.internal.codegen.CompilerConstants.interfaceCallNoLookup;
 import static jdk.nashorn.internal.codegen.CompilerConstants.methodDescriptor;
 import static jdk.nashorn.internal.codegen.CompilerConstants.staticCallNoLookup;
-import static jdk.nashorn.internal.codegen.CompilerConstants.staticField;
 import static jdk.nashorn.internal.codegen.CompilerConstants.typeDescriptor;
 import static jdk.nashorn.internal.codegen.CompilerConstants.virtualCallNoLookup;
 import static jdk.nashorn.internal.ir.Symbol.IS_INTERNAL;
 import static jdk.nashorn.internal.ir.Symbol.IS_TEMP;
 import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_FAST_SCOPE;
 import java.util.EnumSet;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Locale;
 import java.util.Set;
 import java.util.TreeMap;
 import jdk.nashorn.internal.codegen.ClassEmitter.Flag;
 import jdk.nashorn.internal.codegen.CompilerConstants.Call;
 import jdk.nashorn.internal.codegen.RuntimeCallSite.SpecializedRuntimeNode;
 import jdk.nashorn.internal.ir.TryNode;
 import jdk.nashorn.internal.ir.UnaryNode;
 import jdk.nashorn.internal.ir.VarNode;
 import jdk.nashorn.internal.ir.WhileNode;
 import jdk.nashorn.internal.ir.WithNode;
-import jdk.nashorn.internal.ir.debug.ASTWriter;
 import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor;
 import jdk.nashorn.internal.ir.visitor.NodeVisitor;
 import jdk.nashorn.internal.objects.Global;
 import jdk.nashorn.internal.objects.ScriptFunctionImpl;
 import jdk.nashorn.internal.parser.Lexer.RegexToken;
 * Load an identity node
 *
 * @param identNode an identity node to load
 * @return the method generator used
 */
-private MethodEmitter loadIdent(final IdentNode identNode) {
+private MethodEmitter loadIdent(final IdentNode identNode, final Type type) {
 final Symbol symbol = identNode.getSymbol();
 if (!symbol.isScope()) {
 assert symbol.hasSlot() || symbol.isParam();
-return method.load(symbol);
+return method.load(symbol).convert(type);
 }
 final String name   = symbol.getName();
 final Source source = lc.getCurrentFunction().getSource();
 method.loadCompilerConstant(SCOPE);
 if (isFastScope(symbol)) {
 // Only generate shared scope getter for fast-scope symbols so we know we can dial in correct scope.
 if (symbol.getUseCount() > SharedScopeCall.FAST_SCOPE_GET_THRESHOLD) {
-return loadSharedScopeVar(identNode.getType(), symbol, flags);
+return loadSharedScopeVar(type, symbol, flags);
 }
-return loadFastScopeVar(identNode.getType(), symbol, flags, identNode.isFunction());
+return loadFastScopeVar(type, symbol, flags, identNode.isFunction());
 }
-return method.dynamicGet(identNode.getType(), identNode.getName(), flags, identNode.isFunction());
+return method.dynamicGet(type, identNode.getName(), flags, identNode.isFunction());
 }
 }
 /**
 * Check if this symbol can be accessed directly with a putfield or getfield or dynamic load
 private MethodEmitter loadFastScopeVar(final Type valueType, final Symbol symbol, final int flags, final boolean isMethod) {
 loadFastScopeProto(symbol, false);
 return method.dynamicGet(valueType, symbol.getName(), flags | CALLSITE_FAST_SCOPE, isMethod);
 }
-private MethodEmitter storeFastScopeVar(final Type valueType, final Symbol symbol, final int flags) {
+private MethodEmitter storeFastScopeVar(final Symbol symbol, final int flags) {
 loadFastScopeProto(symbol, true);
-method.dynamicSet(valueType, symbol.getName(), flags | CALLSITE_FAST_SCOPE);
+method.dynamicSet(symbol.getName(), flags | CALLSITE_FAST_SCOPE);
 return method;
 }
 private int getScopeProtoDepth(final Block startingBlock, final Symbol symbol) {
 int depth = 0;
 * @param node node to load
 *
 * @return the method emitter used
 */
 MethodEmitter load(final Expression node) {
-return load(node, false);
+return load(node, node.hasType() ? node.getType() : null, false);
 }
-private MethodEmitter load(final Expression node, final boolean baseAlreadyOnStack) {
+private static boolean safeLiteral(final Expression rhs) {
+return rhs instanceof LiteralNode && !(rhs instanceof ArrayLiteralNode);
+}
+MethodEmitter loadBinaryOperands(final Expression lhs, final Expression rhs, final Type type) {
+return loadBinaryOperands(lhs, rhs, type, false);
+}
+private MethodEmitter loadBinaryOperands(final Expression lhs, final Expression rhs, final Type type, final boolean baseAlreadyOnStack) {
+// ECMAScript 5.1 specification (sections 11.5-11.11 and 11.13) prescribes that when evaluating a binary
+// expression "LEFT op RIGHT", the order of operations must be: LOAD LEFT, LOAD RIGHT, CONVERT LEFT, CONVERT
+// RIGHT, EXECUTE OP. Unfortunately, doing it in this order defeats potential optimizations that arise when we
+// can combine a LOAD with a CONVERT operation (e.g. use a dynamic getter with the conversion target type as its
+// return value). What we do here is reorder LOAD RIGHT and CONVERT LEFT when possible; it is possible only when
+// we can prove that executing CONVERT LEFT can't have a side effect that changes the value of LOAD RIGHT.
+// Basically, if we know that either LEFT is not an object, or RIGHT is a constant literal, then we can do the
+// reordering and collapse LOAD/CONVERT into a single operation; otherwise we need to do the more costly
+// separate operations to preserve specification semantics.
+final Type lhsType = lhs.getType();
+if (lhsType.isObject() && !safeLiteral(rhs)) {
+// Can't reorder. Load and convert separately.
+load(lhs, lhsType, baseAlreadyOnStack);
+load(rhs, rhs.getType(), false);
+// Avoid empty SWAP, SWAP bytecode sequence if CONVERT LEFT is a no-op
+if (!lhsType.isEquivalentTo(type)) {
+method.swap();
+method.convert(type);
+method.swap();
+}
+method.convert(type);
+} else {
+// Can reorder. Combine load and convert into single operations.
+load(lhs, type, baseAlreadyOnStack);
+load(rhs, type, false);
+}
+return method;
+}
+MethodEmitter loadBinaryOperands(final BinaryNode node) {
+return loadBinaryOperands(node.lhs(), node.rhs(), node.getType(), false);
+}
+private MethodEmitter load(final Expression node, final Type type) {
+return load(node, type, false);
+}
+private MethodEmitter load(final Expression node, final Type type, final boolean baseAlreadyOnStack) {
 final Symbol symbol = node.getSymbol();
 // If we lack symbols, we just generate what we see.
-if (symbol == null) {
+if (symbol == null || type == null) {
 node.accept(this);
 return method;
 }
 /*
 * or IndexNode e.g. "x[y]". Both AccessNodes and IndexNodes are
 * BaseNodes and the logic for loading the base object is reused
 */
 final CodeGenerator codegen = this;
-node.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
+node.accept(new NodeVisitor<LexicalContext>(lc) {
 @Override
 public boolean enterIdentNode(final IdentNode identNode) {
-loadIdent(identNode);
+loadIdent(identNode, type);
 return false;
 }
 @Override
 public boolean enterAccessNode(final AccessNode accessNode) {
 if (!baseAlreadyOnStack) {
 load(accessNode.getBase()).convert(Type.OBJECT);
 }
 assert method.peekType().isObject();
-method.dynamicGet(node.getType(), accessNode.getProperty().getName(), getCallSiteFlags(), accessNode.isFunction());
+method.dynamicGet(type, accessNode.getProperty().getName(), getCallSiteFlags(), accessNode.isFunction());
 return false;
 }
 @Override
 public boolean enterIndexNode(final IndexNode indexNode) {
 if (!baseAlreadyOnStack) {
 load(indexNode.getBase()).convert(Type.OBJECT);
 load(indexNode.getIndex());
 }
-method.dynamicGetIndex(node.getType(), getCallSiteFlags(), indexNode.isFunction());
+method.dynamicGetIndex(type, getCallSiteFlags(), indexNode.isFunction());
 return false;
 }
 @Override
 public boolean enterFunctionNode(FunctionNode functionNode) {
 // function nodes will always leave a constructed function object on stack, no need to load the symbol
 // separately as in enterDefault()
 functionNode.accept(codegen);
+method.convert(type);
 return false;
 }
 @Override
+public boolean enterCallNode(CallNode callNode) {
+return codegen.enterCallNode(callNode, type);
+}
+@Override
+public boolean enterLiteralNode(LiteralNode<?> literalNode) {
+return codegen.enterLiteralNode(literalNode, type);
+}
+@Override
 public boolean enterDefault(final Node otherNode) {
+final Node currentDiscard = codegen.lc.getCurrentDiscard();
 otherNode.accept(codegen); // generate code for whatever we are looking at.
-method.load(symbol); // load the final symbol to the stack (or nop if no slot, then result is already there)
+if(currentDiscard != otherNode) {
+method.load(symbol); // load the final symbol to the stack (or nop if no slot, then result is already there)
+assert method.peekType() != null;
+method.convert(type);
+}
 return false;
 }
 });
 return method;
 }
 return argCount;
 }
 @Override
 public boolean enterCallNode(final CallNode callNode) {
+return enterCallNode(callNode, callNode.getType());
+}
+private boolean enterCallNode(final CallNode callNode, final Type callNodeType) {
 lineNumber(callNode.getLineNumber());
 final List<Expression> args = callNode.getArgs();
 final Expression function = callNode.getFunction();
 final Block currentBlock = lc.getCurrentBlock();
 final CodeGeneratorLexicalContext codegenLexicalContext = lc;
-final Type callNodeType = callNode.getType();
 function.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
 private MethodEmitter sharedScopeCall(final IdentNode identNode, final int flags) {
 final Symbol symbol = identNode.getSymbol();
 final SharedScopeCall scopeCall = codegenLexicalContext.getScopeCall(unit, symbol, identNode.getType(), callNodeType, paramTypes, scopeCallFlags);
 return scopeCall.generateInvoke(method);
 }
 private void scopeCall(final IdentNode node, final int flags) {
-load(node);
+load(node, Type.OBJECT); // Type.OBJECT as foo() makes no sense if foo == 3
-method.convert(Type.OBJECT); // foo() makes no sense if foo == 3
 // ScriptFunction will see CALLSITE_SCOPE and will bind scope accordingly.
 method.loadNull(); //the 'this'
 method.dynamicCall(callNodeType, 2 + loadArgs(args), flags);
 }
 private void evalCall(final IdentNode node, final int flags) {
-load(node);
+load(node, Type.OBJECT); // Type.OBJECT as foo() makes no sense if foo == 3
-method.convert(Type.OBJECT); // foo() makes no sense if foo == 3
 final Label not_eval  = new Label("not_eval");
 final Label eval_done = new Label("eval_done");
 // check if this is the real built-in eval
 method.loadCompilerConstant(SCOPE); // Load up self (scope).
 final CallNode.EvalArgs evalArgs = callNode.getEvalArgs();
 // load evaluated code
-load(evalArgs.getCode());
+load(evalArgs.getCode(), Type.OBJECT);
-method.convert(Type.OBJECT);
 // special/extra 'eval' arguments
 load(evalArgs.getThis());
 method.load(evalArgs.getLocation());
 method.load(evalArgs.getStrictMode());
 method.convert(Type.OBJECT);
 return false;
 }
 @Override
 public boolean enterAccessNode(final AccessNode node) {
-load(node.getBase());
+load(node.getBase(), Type.OBJECT);
-method.convert(Type.OBJECT);
 method.dup();
 method.dynamicGet(node.getType(), node.getProperty().getName(), getCallSiteFlags(), true);
 method.swap();
 method.dynamicCall(callNodeType, 2 + loadArgs(args), getCallSiteFlags());
-assert method.peekType().equals(callNodeType);
 return false;
 }
 @Override
 return false;
 }
 @Override
 public boolean enterIndexNode(final IndexNode node) {
-load(node.getBase());
+load(node.getBase(), Type.OBJECT);
-method.convert(Type.OBJECT);
 method.dup();
-load(node.getIndex());
 final Type indexType = node.getIndex().getType();
 if (indexType.isObject() || indexType.isBoolean()) {
-method.convert(Type.OBJECT); //TODO
+load(node.getIndex(), Type.OBJECT); //TODO
+} else {
+load(node.getIndex());
 }
 method.dynamicGetIndex(node.getType(), getCallSiteFlags(), true);
 method.swap();
 method.dynamicCall(callNodeType, 2 + loadArgs(args), getCallSiteFlags());
-assert method.peekType().equals(callNode.getType());
 return false;
 }
 @Override
 protected boolean enterDefault(final Node node) {
 // Load up function.
-load(function);
+load(function, Type.OBJECT); //TODO, e.g. booleans can be used as functions
-method.convert(Type.OBJECT); //TODO, e.g. booleans can be used as functions
 method.loadNull(); // ScriptFunction will figure out the correct this when it sees CALLSITE_SCOPE
 method.dynamicCall(callNodeType, 2 + loadArgs(args), getCallSiteFlags() | CALLSITE_SCOPE);
-assert method.peekType().equals(callNode.getType());
 return false;
 }
 });
 final Symbol iter      = forNode.getIterator();
 final Label  loopLabel = new Label("loop");
 final Expression init = forNode.getInit();
-load(modify);
+load(modify, Type.OBJECT);
-assert modify.getType().isObject();
 method.invoke(forNode.isForEach() ? ScriptRuntime.TO_VALUE_ITERATOR : ScriptRuntime.TO_PROPERTY_ITERATOR);
 method.store(iter);
 method._goto(forNode.getContinueLabel());
 method.label(loopLabel);
 final Expression element = nodes[index];
 if (element == null) {
 method.loadEmpty(elementType);
 } else {
-assert elementType.isEquivalentTo(element.getType()) : "array element type doesn't match array type";
+load(element, elementType);
-load(element);
 }
 method.arraystore();
 }
 }
 }
 }
 // literal values
-private MethodEmitter load(final LiteralNode<?> node) {
+private MethodEmitter loadLiteral(final LiteralNode<?> node, final Type type) {
 final Object value = node.getValue();
 if (value == null) {
 method.loadNull();
 } else if (value instanceof Undefined) {
 } else if (value instanceof RegexToken) {
 loadRegex((RegexToken)value);
 } else if (value instanceof Boolean) {
 method.load((Boolean)value);
 } else if (value instanceof Integer) {
-method.load((Integer)value);
+if(type.isEquivalentTo(Type.NUMBER)) {
+method.load(((Integer)value).doubleValue());
+} else if(type.isEquivalentTo(Type.LONG)) {
+method.load(((Integer)value).longValue());
+} else {
+method.load((Integer)value);
+}
 } else if (value instanceof Long) {
-method.load((Long)value);
+if(type.isEquivalentTo(Type.NUMBER)) {
+method.load(((Long)value).doubleValue());
+} else {
+method.load((Long)value);
+}
 } else if (value instanceof Double) {
 method.load((Double)value);
 } else if (node instanceof ArrayLiteralNode) {
-final ArrayType type = (ArrayType)node.getType();
+final ArrayLiteralNode arrayLiteral = (ArrayLiteralNode)node;
-loadArray((ArrayLiteralNode)node, type);
+final ArrayType atype = arrayLiteral.getArrayType();
-globalAllocateArray(type);
+loadArray(arrayLiteral, atype);
+globalAllocateArray(atype);
 } else {
 assert false : "Unknown literal for " + node.getClass() + " " + value.getClass() + " " + value;
 }
 return method;
 return method;
 }
 @Override
 public boolean enterLiteralNode(final LiteralNode<?> literalNode) {
+return enterLiteralNode(literalNode, literalNode.getType());
+}
+private boolean enterLiteralNode(final LiteralNode<?> literalNode, final Type type) {
 assert literalNode.getSymbol() != null : literalNode + " has no symbol";
-load(literalNode).store(literalNode.getSymbol());
+loadLiteral(literalNode, type).convert(type).store(literalNode.getSymbol());
 return false;
 }
 @Override
 public boolean enterObjectNode(final ObjectNode objectNode) {
 return enterCmp(lhs, rhs, Condition.GE, type, symbol);
 case GT:
 return enterCmp(lhs, rhs, Condition.GT, type, symbol);
 case ADD:
 Type widest = Type.widest(lhs.getType(), rhs.getType());
-load(lhs);
+load(lhs, widest);
-method.convert(widest);
+load(rhs, widest);
-load(rhs);
-method.convert(widest);
 method.add();
 method.convert(type);
 method.store(symbol);
 return false;
 default:
 break;
 }
 }
 if (nullCheck(runtimeNode, args, new FunctionSignature(false, false, runtimeNode.getType(), args).toString())) {
 return false;
 }
 if (!runtimeNode.isFinal() && specializationCheck(runtimeNode.getRequest(), runtimeNode, args)) {
 return false;
 }
 for (final Expression arg : args) {
-load(arg).convert(Type.OBJECT); //TODO this should not be necessary below Lower
+load(arg).convert(Type.OBJECT);
 }
 method.invokestatic(
 CompilerConstants.className(ScriptRuntime.class),
 runtimeNode.getRequest().toString(),
 }
 method.lookupswitch(defaultLabel, ints, labels);
 }
 } else {
-load(expression);
+load(expression, Type.OBJECT);
+method.store(tag);
-if (expression.getType().isInteger()) {
-method.convert(Type.NUMBER).dup();
-method.store(tag);
-method.conditionalJump(Condition.NE, true, defaultLabel);
-} else {
-assert tag.getSymbolType().isObject();
-method.convert(Type.OBJECT); //e.g. 1 literal pushed and tag is object
-method.store(tag);
-}
 for (final CaseNode caseNode : cases) {
 final Expression test = caseNode.getTest();
 if (test != null) {
 method.load(tag);
-load(test);
+load(test, Type.OBJECT);
 method.invoke(ScriptRuntime.EQ_STRICT);
 method.ifne(caseNode.getEntry());
 }
 }
 final Expression expression = throwNode.getExpression();
 final int        position   = throwNode.position();
 final int        line       = throwNode.getLineNumber();
 final int        column     = source.getColumn(position);
-load(expression);
+load(expression, Type.OBJECT);
-assert expression.getType().isObject();
 method.load(source.getName());
 method.load(line);
 method.load(column);
 method.invoke(ECMAException.THROW_INIT);
 return false;
 }
 lineNumber(varNode);
-final Symbol varSymbol = varNode.getName().getSymbol();
+final IdentNode identNode = varNode.getName();
-assert varSymbol != null : "variable node " + varNode + " requires a name with a symbol";
+final Symbol identSymbol = identNode.getSymbol();
+assert identSymbol != null : "variable node " + varNode + " requires a name with a symbol";
 assert method != null;
-final boolean needsScope = varSymbol.isScope();
+final boolean needsScope = identSymbol.isScope();
 if (needsScope) {
 method.loadCompilerConstant(SCOPE);
 }
-load(init);
 if (needsScope) {
+load(init);
 int flags = CALLSITE_SCOPE | getCallSiteFlags();
-final IdentNode identNode = varNode.getName();
+if (isFastScope(identSymbol)) {
-final Type type = identNode.getType();
+storeFastScopeVar(identSymbol, flags);
-if (isFastScope(varSymbol)) {
-storeFastScopeVar(type, varSymbol, flags);
 } else {
-method.dynamicSet(type, identNode.getName(), flags);
+method.dynamicSet(identNode.getName(), flags);
 }
 } else {
-method.convert(varNode.getName().getType()); // aw: convert moved here
+load(init, identNode.getType());
-method.store(varSymbol);
+method.store(identSymbol);
 }
 return false;
 }
 method.loadCompilerConstant(SCOPE);
 } else {
 tryLabel = null;
 }
-load(expression);
+load(expression, Type.OBJECT);
-assert expression.getType().isObject() : "with expression needs to be object: " + expression;
 if (hasScope) {
 // Construct a WithObject if we have a scope
 method.invoke(ScriptRuntime.OPEN_WITH);
 method.storeCompilerConstant(SCOPE);
 return false;
 }
 @Override
 public boolean enterADD(final UnaryNode unaryNode) {
-load(unaryNode.rhs());
+load(unaryNode.rhs(), unaryNode.getType());
-assert unaryNode.rhs().getType().isNumber() : unaryNode.rhs().getType() + " "+ unaryNode.getSymbol();
+assert unaryNode.getType().isNumeric();
 method.store(unaryNode.getSymbol());
 return false;
 }
 @Override
 public boolean enterBIT_NOT(final UnaryNode unaryNode) {
-load(unaryNode.rhs()).convert(Type.INT).load(-1).xor().store(unaryNode.getSymbol());
+load(unaryNode.rhs(), Type.INT).load(-1).xor().store(unaryNode.getSymbol());
-return false;
-}
-// do this better with convert calls to method. TODO
-@Override
-public boolean enterCONVERT(final UnaryNode unaryNode) {
-final Expression rhs = unaryNode.rhs();
-final Type to  = unaryNode.getType();
-if (to.isObject() && rhs instanceof LiteralNode) {
-final LiteralNode<?> literalNode = (LiteralNode<?>)rhs;
-final Object value = literalNode.getValue();
-if (value instanceof Number) {
-assert !to.isArray() : "type hygiene - cannot convert number to array: (" + to.getTypeClass().getSimpleName() + ')' + value;
-if (value instanceof Integer) {
-method.load((Integer)value);
-} else if (value instanceof Long) {
-method.load((Long)value);
-} else if (value instanceof Double) {
-method.load((Double)value);
-} else {
-assert false;
-}
-method.convert(Type.OBJECT);
-} else if (value instanceof Boolean) {
-method.getField(staticField(Boolean.class, value.toString().toUpperCase(Locale.ENGLISH), Boolean.class));
-} else {
-load(rhs);
-method.convert(unaryNode.getType());
-}
-} else {
-load(rhs);
-method.convert(unaryNode.getType());
-}
-method.store(unaryNode.getSymbol());
 return false;
 }
 @Override
 public boolean enterDECINC(final UnaryNode unaryNode) {
 new SelfModifyingStore<UnaryNode>(unaryNode, rhs) {
 @Override
 protected void evaluate() {
-load(rhs, true);
+load(rhs, type, true);
-method.convert(type);
 if (!isPostfix) {
 if (type.isInteger()) {
 method.load(isIncrement ? 1 : -1);
 } else if (type.isLong()) {
 method.load(isIncrement ? 1L : -1L);
 @Override
 public boolean enterNOT(final UnaryNode unaryNode) {
 final Expression rhs = unaryNode.rhs();
-load(rhs);
+load(rhs, Type.BOOLEAN);
 final Label trueLabel  = new Label("true");
 final Label afterLabel = new Label("after");
-method.convert(Type.BOOLEAN);
 method.ifne(trueLabel);
 method.load(true);
 method._goto(afterLabel);
 method.label(trueLabel);
 method.load(false);
 return false;
 }
 @Override
 public boolean enterSUB(final UnaryNode unaryNode) {
-load(unaryNode.rhs()).neg().store(unaryNode.getSymbol());
+assert unaryNode.getType().isNumeric();
+load(unaryNode.rhs()).convert(unaryNode.getType()).neg().store(unaryNode.getSymbol());
 return false;
 }
 @Override
 public boolean enterVOID(final UnaryNode unaryNode) {
 return false;
 }
 private void enterNumericAdd(final Expression lhs, final Expression rhs, final Type type, final Symbol symbol) {
-assert lhs.getType().equals(rhs.getType()) && lhs.getType().equals(type) : lhs.getType() + " != " + rhs.getType() + " != " + type + " " + new ASTWriter(lhs) + " " + new ASTWriter(rhs);
+loadBinaryOperands(lhs, rhs, type);
-load(lhs);
-load(rhs);
 method.add(); //if the symbol is optimistic, it always needs to be written, not on the stack?
 method.store(symbol);
 }
 @Override
 final Type type = binaryNode.getType();
 if (type.isNumeric()) {
 enterNumericAdd(lhs, rhs, type, binaryNode.getSymbol());
 } else {
-load(lhs).convert(Type.OBJECT);
+loadBinaryOperands(binaryNode);
-load(rhs).convert(Type.OBJECT);
 method.add();
 method.store(binaryNode.getSymbol());
 }
 return false;
 final Type lhsType = lhs.getType();
 final Type rhsType = rhs.getType();
 if (!lhsType.isEquivalentTo(rhsType)) {
 //this is OK if scoped, only locals are wrong
-assert !(lhs instanceof IdentNode) || lhs.getSymbol().isScope() : new ASTWriter(binaryNode);
 }
 new Store<BinaryNode>(binaryNode, lhs) {
 @Override
 protected void evaluate() {
-load(rhs);
+if ((lhs instanceof IdentNode) && !lhs.getSymbol().isScope()) {
+load(rhs, lhsType);
+} else {
+load(rhs);
+}
 }
 }.store();
 return false;
 }
 protected abstract void op();
 @Override
 protected void evaluate() {
-load(assignNode.lhs(), true).convert(opType);
+loadBinaryOperands(assignNode.lhs(), assignNode.rhs(), opType, true);
-load(assignNode.rhs()).convert(opType);
 op();
 method.convert(assignNode.getType());
 }
 }
 private abstract class BinaryArith {
 protected abstract void op();
 protected void evaluate(final BinaryNode node) {
-load(node.lhs());
+loadBinaryOperands(node);
-load(node.rhs());
 op();
 method.store(node.getSymbol());
 }
 }
 final Type rhsType = rhs.getType();
 final Type widest = Type.widest(lhsType, rhsType);
 assert widest.isNumeric() || widest.isBoolean() : widest;
-load(lhs);
+loadBinaryOperands(lhs, rhs, widest);
-method.convert(widest);
-load(rhs);
-method.convert(widest);
 final Label trueLabel  = new Label("trueLabel");
 final Label afterLabel = new Label("skip");
 method.conditionalJump(cond, trueLabel);
 @Override
 public boolean enterSHR(final BinaryNode binaryNode) {
 new BinaryArith() {
 @Override
+protected void evaluate(final BinaryNode node) {
+loadBinaryOperands(node.lhs(), node.rhs(), Type.INT);
+op();
+method.store(node.getSymbol());
+}
+@Override
 protected void op() {
 method.shr();
 method.convert(Type.LONG).load(JSType.MAX_UINT).and();
 }
 }.evaluate(binaryNode);
 Type widest = Type.widest(ternaryNode.getType(), Type.widest(trueExpr.getType(), falseExpr.getType()));
 if (trueExpr.getType().isArray() || falseExpr.getType().isArray()) { //loadArray creates a Java array type on the stack, calls global allocate, which creates a native array type
 widest = Type.OBJECT;
 }
-load(test);
+load(test, Type.BOOLEAN);
-assert test.getType().isBoolean() : "lhs in ternary must be boolean";
 // we still keep the conversion here as the AccessSpecializer can have separated the types, e.g. var y = x ? x=55 : 17
 // will left as (Object)x=55 : (Object)17 by Lower. Then the first term can be {I}x=55 of type int, which breaks the
 // symmetry for the temporary slot for this TernaryNode. This is evidence that we assign types and explicit conversions
 // too early, or Apply the AccessSpecializer too late. We are mostly probably looking for a separate type pass to
 // do this property. Then we never need any conversions in CodeGenerator
 method.ifeq(falseLabel);
-load(trueExpr);
+load(trueExpr, widest);
-method.convert(widest);
 method._goto(exitLabel);
 method.label(falseLabel);
-load(falseExpr);
+load(falseExpr, widest);
-method.convert(widest);
 method.label(exitLabel);
 method.store(symbol);
 return false;
 }
 private void enterBaseNode() {
 assert target instanceof BaseNode : "error - base node " + target + " must be instanceof BaseNode";
 final BaseNode   baseNode = (BaseNode)target;
 final Expression base     = baseNode.getBase();
-load(base);
+load(base, Type.OBJECT);
-method.convert(Type.OBJECT);
 depth += Type.OBJECT.getSlots();
 if (isSelfModifying()) {
 method.dup();
 }
 @Override
 public boolean enterIndexNode(final IndexNode node) {
 enterBaseNode();
 final Expression index = node.getIndex();
-// could be boolean here as well
-load(index);
 if (!index.getType().isNumeric()) {
-method.convert(Type.OBJECT);
+// could be boolean here as well
+load(index, Type.OBJECT);
+} else {
+load(index);
 }
 depth += index.getType().getSlots();
 if (isSelfModifying()) {
 //convert "base base index" to "base index base index"
 *
 * The case that targetSymbol is in scope (!hasSlot) and we actually
 * need to do a conversion on non-equivalent types exists, but is
 * very rare. See for example test/script/basic/access-specializer.js
 */
-method.convert(target.getType());
 target.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
 @Override
 protected boolean enterDefault(Node node) {
 throw new AssertionError("Unexpected node " + node + " in store epilogue");
-}
-@Override
-public boolean enterUnaryNode(final UnaryNode node) {
-if (node.tokenType() == TokenType.CONVERT && node.getSymbol() != null) {
-method.convert(node.rhs().getType());
-}
-return true;
 }
 @Override
 public boolean enterIdentNode(final IdentNode node) {
 final Symbol symbol = node.getSymbol();
 assert symbol != null;
 if (symbol.isScope()) {
 if (isFastScope(symbol)) {
-storeFastScopeVar(node.getType(), symbol, CALLSITE_SCOPE | getCallSiteFlags());
+storeFastScopeVar(symbol, CALLSITE_SCOPE | getCallSiteFlags());
 } else {
-method.dynamicSet(node.getType(), node.getName(), CALLSITE_SCOPE | getCallSiteFlags());
+method.dynamicSet(node.getName(), CALLSITE_SCOPE | getCallSiteFlags());
 }
 } else {
+method.convert(node.getType());
 method.store(symbol);
 }
 return false;
 }
 @Override
 public boolean enterAccessNode(final AccessNode node) {
-method.dynamicSet(node.getProperty().getType(), node.getProperty().getName(), getCallSiteFlags());
+method.dynamicSet(node.getProperty().getName(), getCallSiteFlags());
 return false;
 }
 @Override
 public boolean enterIndexNode(final IndexNode node) {

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

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

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