Use JavaScript runtime semantics when constant folding.

lib/compiler/implementation/ssa/optimize.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 interface OptimizationPhase {
   String get name();
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaOptimizerTask(JavaScriptBackend backend)
     : this.backend = backend,
       super(backend.compiler);
   String get name => 'SSA optimizer';
   Compiler get compiler => backend.compiler;
 
   void runPhases(HGraph graph, List<OptimizationPhase> phases) {
     for (OptimizationPhase phase in phases) {
       runPhase(graph, phase);
     }
   }
 
   void runPhase(HGraph graph, OptimizationPhase phase) {
     phase.visitGraph(graph);
     compiler.tracer.traceGraph(phase.name, graph);
   }
 
   void optimize(WorkItem work, HGraph graph) {
+    ConstantSystem constantSystem = compiler.backend.constantSystem;
     JavaScriptItemCompilationContext context = work.compilationContext;
     HTypeMap types = context.types;
     measure(() {
       List<OptimizationPhase> phases = <OptimizationPhase>[
           // Run trivial constant folding first to optimize
           // some patterns useful for type conversion.
-          new SsaConstantFolder(backend, work, types),
+          new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaTypeConversionInserter(compiler),
           new SsaTypePropagator(compiler, types),
           new SsaCheckInserter(backend, types),
-          new SsaConstantFolder(backend, work, types),
+          new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
           new SsaGlobalValueNumberer(compiler, types),
           new SsaCodeMotion(),
           // Previous optimizations may have generated new
           // opportunities for constant folding.
-          new SsaConstantFolder(backend, work, types),
+          new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaDeadCodeEliminator(types),
           new SsaRegisterRecompilationCandidates(backend, work, types)];
       runPhases(graph, phases);
     });
   }
 
   bool trySpeculativeOptimizations(WorkItem work, HGraph graph) {
     if (work.element.isField()) {
       // Lazy initializers may not have bailout methods.
       return false;
@@ skipping 45 matching lines @@
 }
 
 /**
  * If both inputs to known operations are available execute the operation at
  * compile-time.
  */
 class SsaConstantFolder extends HBaseVisitor implements OptimizationPhase {
   final String name = "SsaConstantFolder";
   final JavaScriptBackend backend;
   final WorkItem work;
+  final ConstantSystem constantSystem;
   final HTypeMap types;
   HGraph graph;
   Compiler get compiler => backend.compiler;
 
-  SsaConstantFolder(this.backend, this.work, this.types);
+  SsaConstantFolder(this.constantSystem, this.backend, this.work, this.types);
 
   void visitGraph(HGraph visitee) {
     graph = visitee;
     visitDominatorTree(visitee);
   }
 
   visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction !== null) {
       HInstruction next = instruction.next;
@@ skipping 26 matching lines @@
   }
 
   HInstruction visitBoolify(HBoolify node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     if (input.isBoolean(types)) return input;
     // All values !== true are boolified to false.
     DartType type = types[input].computeType(compiler);
     if (type !== null && type.element !== compiler.boolClass) {
-      return graph.addConstantBool(false);
+      return graph.addConstantBool(false, constantSystem);
     }
     return node;
   }
 
   HInstruction visitNot(HNot node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     if (input is HConstant) {
       HConstant constant = input;
       bool isTrue = constant.constant.isTrue();
-      return graph.addConstantBool(!isTrue);
+      return graph.addConstantBool(!isTrue, constantSystem);
     } else if (input is HNot) {
       return input.inputs[0];
     }
     return node;
   }
 
   HInstruction visitInvokeUnary(HInvokeUnary node) {
     HInstruction operand = node.operand;
     if (operand is HConstant) {
-      UnaryOperation operation = node.operation;
+      UnaryOperation operation = node.operation(constantSystem);
       HConstant receiver = operand;
       Constant folded = operation.fold(receiver.constant);
       if (folded !== null) return graph.addConstant(folded);
     }
     return node;
   }
 
   HInstruction visitInvokeInterceptor(HInvokeInterceptor node) {
     HInstruction input = node.inputs[1];
     if (node.isLengthGetter()) {
       if (input.isConstantString()) {
         HConstant constantInput = input;
         StringConstant constant = constantInput.constant;
-        return graph.addConstantInt(constant.length);
+        return graph.addConstantInt(constant.length, constantSystem);
       } else if (input.isConstantList()) {
         HConstant constantInput = input;
         ListConstant constant = constantInput.constant;
-        return graph.addConstantInt(constant.length);
+        return graph.addConstantInt(constant.length, constantSystem);
       } else if (input.isConstantMap()) {
         HConstant constantInput = input;
         MapConstant constant = constantInput.constant;
-        return graph.addConstantInt(constant.length);
+        return graph.addConstantInt(constant.length, constantSystem);
       }
     }
 
     if (input.isString(types)
         && node.selector.name == const SourceString('toString')) {
       return node.inputs[1];
     }
 
     if (!input.canBePrimitive(types) && node.selector.isCall()) {
       bool transformToDynamicInvocation = true;
@@ skipping 81 matching lines @@
       }
       node.staticChecks = HBoundsCheck.ALWAYS_ABOVE_ZERO;
     }
     return node;
   }
 
   HInstruction visitIntegerCheck(HIntegerCheck node) {
     HInstruction value = node.value;
     if (value.isInteger(types)) return value;
     if (value.isConstant()) {
-      assert((){
-        HConstant constantInstruction = value;
-        return !constantInstruction.constant.isInt();
-      });
-      node.alwaysFalse = true;
+      HConstant constantInstruction = value;
+      assert(!constantInstruction.constant.isInt());
+      if (!constantSystem.isInt(constantInstruction.constant)) {
+        // -0.0 is a double but will pass the runtime integer check.
+        node.alwaysFalse = true;
+      }
     }
     return node;
   }
 
 
   HInstruction visitIndex(HIndex node) {
     if (!node.receiver.canBePrimitive(types)) {
       Selector selector = new Selector.index();
       return fromInterceptorToDynamicInvocation(node, selector);
     }
     return node;
   }
 
   HInstruction visitIndexAssign(HIndexAssign node) {
     if (!node.receiver.canBePrimitive(types)) {
       Selector selector = new Selector.indexSet();
       return fromInterceptorToDynamicInvocation(node, selector);
     }
     return node;
   }
 
   HInstruction visitInvokeBinary(HInvokeBinary node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
+    BinaryOperation operation = node.operation(constantSystem);
     if (left is HConstant && right is HConstant) {
-      BinaryOperation operation = node.operation;
       HConstant op1 = left;
       HConstant op2 = right;
       Constant folded = operation.fold(op1.constant, op2.constant);
       if (folded !== null) return graph.addConstant(folded);
     }
 
     if (!left.canBePrimitive(types)
-        && node.operation.isUserDefinable()
+        && operation.isUserDefinable()
         // The equals operation is being optimized in visitEquals.
-        && node.operation !== const EqualsOperation()) {
-      Selector selector = new Selector.binaryOperator(node.operation.name);
+        && node is! HEquals) {
+      Selector selector = new Selector.binaryOperator(operation.name);
       return fromInterceptorToDynamicInvocation(node, selector);
     }
     return node;
   }
 
   bool allUsersAreBoolifies(HInstruction instruction) {
     List<HInstruction> users = instruction.usedBy;
     int length = users.length;
     for (int i = 0; i < length; i++) {
       if (users[i] is! HBoolify) return false;
@@ skipping 32 matching lines @@
   HInstruction handleIdentityCheck(HInvokeBinary node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
     HType leftType = types[left];
     HType rightType = types[right];
     assert(!leftType.isConflicting() && !rightType.isConflicting());
 
     // We don't optimize on numbers to preserve the runtime semantics.
     if (!(left.isNumber(types) && right.isNumber(types)) &&
         leftType.intersection(rightType).isConflicting()) {
-      return graph.addConstantBool(false);
+      return graph.addConstantBool(false, constantSystem);
     }
 
     if (left.isConstantBoolean() && right.isBoolean(types)) {
       HConstant constant = left;
       if (constant.constant.isTrue()) {
         return right;
       } else {
         return new HNot(right);
       }
     }
@@ skipping 43 matching lines @@
     HType leftType = types[left];
     if (leftType.isExact()) {
       HBoundedType type = leftType;
       Element element = type.lookupMember(Elements.OPERATOR_EQUALS);
       if (element !== null) {
         // If the left-hand side is guaranteed to be a non-primitive
         // type and and it defines operator==, we emit a call to that
         // operator.
         return super.visitEquals(node);
       } else if (right.isConstantNull()) {
-        return graph.addConstantBool(false);
+        return graph.addConstantBool(false, constantSystem);
       } else {
         // We can just emit an identity check because the type does
         // not implement operator=.
         return foldBuiltinEqualsCheck(node);
       }
     }
 
     if (right.isConstantNull()) {
       if (leftType.isPrimitive()) {
-        return graph.addConstantBool(false);
+        return graph.addConstantBool(false, constantSystem);
       }
     }
 
     // All other cases are dealt with by the [visitRelational] and
     // [visitInvokeBinary], which are visited by invoking the [super]'s
     // visit method.
     return super.visitEquals(node);
   }
 
   HInstruction visitTypeGuard(HTypeGuard node) {
     HInstruction value = node.guarded;
     // If the intersection of the types is still the incoming type then
     // the incoming type was a subtype of the guarded type, and no check
     // is required.
     HType combinedType = types[value].intersection(node.guardedType);
     return (combinedType == types[value]) ? value : node;
   }
 
   HInstruction visitIs(HIs node) {
     DartType type = node.typeExpression;
     Element element = type.element;
     if (element.kind === ElementKind.TYPE_VARIABLE) {
       compiler.unimplemented("visitIs for type variables");
     }
 
     HType expressionType = types[node.expression];
     if (element === compiler.objectClass
         || element === compiler.dynamicClass) {
-      return graph.addConstantBool(true);
+      return graph.addConstantBool(true, constantSystem);
     } else if (expressionType.isInteger()) {
       if (element === compiler.intClass || element === compiler.numClass) {
-        return graph.addConstantBool(true);
+        return graph.addConstantBool(true, constantSystem);
       } else if (element === compiler.doubleClass) {
         // We let the JS semantics decide for that check. Currently
         // the code we emit will always return true.
         return node;
       } else {
-        return graph.addConstantBool(false);
+        return graph.addConstantBool(false, constantSystem);
       }
     } else if (expressionType.isDouble()) {
       if (element === compiler.doubleClass || element === compiler.numClass) {
-        return graph.addConstantBool(true);
+        return graph.addConstantBool(true, constantSystem);
       } else if (element === compiler.intClass) {
         // We let the JS semantics decide for that check. Currently
         // the code we emit will return true for a double that can be
-        // represented as a 31-bit integer.
+        // represented as a 31-bit integer and for -0.0.
         return node;
       } else {
-        return graph.addConstantBool(false);
+        return graph.addConstantBool(false, constantSystem);
       }
     } else if (expressionType.isNumber()) {
       if (element === compiler.numClass) {
-        return graph.addConstantBool(true);
+        return graph.addConstantBool(true, constantSystem);
       }
       // We cannot just return false, because the expression may be of
       // type int or double.
     } else if (expressionType.isString()) {
       if (element === compiler.stringClass
                || Elements.isStringSupertype(element, compiler)) {
-        return graph.addConstantBool(true);
+        return graph.addConstantBool(true, constantSystem);
       } else {
-        return graph.addConstantBool(false);
+        return graph.addConstantBool(false, constantSystem);
       }
     } else if (expressionType.isArray()) {
       if (element === compiler.listClass
           || Elements.isListSupertype(element, compiler)) {
-        return graph.addConstantBool(true);
+        return graph.addConstantBool(true, constantSystem);
       } else {
-        return graph.addConstantBool(false);
+        return graph.addConstantBool(false, constantSystem);
       }
     // TODO(karlklose): remove the hasTypeArguments check.
     } else if (expressionType.isUseful()
                && !expressionType.canBeNull()
                && !compiler.codegenWorld.rti.hasTypeArguments(type)) {
       DartType receiverType = expressionType.computeType(compiler);
       if (receiverType !== null) {
         if (compiler.types.isSubtype(receiverType, type)) {
-          return graph.addConstantBool(true);
+          return graph.addConstantBool(true, constantSystem);
         } else if (expressionType.isExact()) {
-          return graph.addConstantBool(false);
+          return graph.addConstantBool(false, constantSystem);
         }
       }
     }
     return node;
   }
 
   HInstruction visitTypeConversion(HTypeConversion node) {
     HInstruction value = node.inputs[0];
     DartType type = types[node].computeType(compiler);
     if (type.element === compiler.dynamicClass
@@ skipping 58 matching lines @@
   HInstruction visitStringConcat(HStringConcat node) {
     DartString folded = const LiteralDartString("");
     for (int i = 0; i < node.inputs.length; i++) {
       HInstruction part = node.inputs[i];
       if (!part.isConstant()) return node;
       HConstant constant = part;
       if (!constant.constant.isPrimitive()) return node;
       PrimitiveConstant primitive = constant.constant;
       folded = new DartString.concat(folded, primitive.toDartString());
     }
-    return graph.addConstantString(folded, node.node);
+    return graph.addConstant(constantSystem.createString(folded, node.node));
   }
 }
 
 class SsaCheckInserter extends HBaseVisitor implements OptimizationPhase {
   final HTypeMap types;
   final String name = "SsaCheckInserter";
   Element lengthInterceptor;
 
   SsaCheckInserter(JavaScriptBackend backend, this.types) {
     SourceString lengthString = const SourceString('length');
@@ skipping 682 matching lines @@
       // this type for the field is still a strong signal
       // indicating the expected type of the field.
       types[field] = type;
     } else {
       // If there are no invoked setters we know the type of
       // this field for sure.
       field.guaranteedType = type;
     }
   }
 }