Use JavaScript runtime semantics when constant folding.

lib/compiler/implementation/ssa/nodes.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 HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
@@ skipping 160 matching lines @@
     HConstant result = constants[constant];
     if (result === null) {
       HType type = mapConstantTypeToSsaType(constant);
       result = new HConstant.internal(constant, type);
       entry.addAtExit(result);
       constants[constant] = result;
     }
     return result;
   }
 
-  HConstant addConstantInt(int i) {

[ngeoffray, 2012/09/05 11:20:36]

I would keep these helpers, and pass the backend or the compiler as a second
argument.

[floitsch, 2012/09/05 16:12:01]

Kept them, but they want the constantSystem.

-    return addConstant(new IntConstant(i));
-  }
-
-  HConstant addConstantDouble(double d) {
-    return addConstant(new DoubleConstant(d));
-  }
-
-  HConstant addConstantString(DartString str, Node node) {
-    return addConstant(new StringConstant(str, node));
-  }
-
-  HConstant addConstantBool(bool value) {
-    return addConstant(new BoolConstant(value));
-  }
-
-  HConstant addConstantNull() {
-    return addConstant(new NullConstant());
-  }
-
   void finalize() {
     addBlock(exit);
     exit.open();
     exit.close(new HExit());
     assignDominators();
   }
 
   void assignDominators() {
     // Run through the blocks in order of increasing ids so we are
     // guaranteed that we have computed dominators for all blocks
@@ skipping 1297 matching lines @@
   accept(HVisitor visitor) => visitor.visitForeignNew(this);
 }
 
 class HInvokeBinary extends HInvokeStatic {
   HInvokeBinary(HStatic target, HInstruction left, HInstruction right)
       : super(<HInstruction>[target, left, right]);
 
   HInstruction get left => inputs[1];
   HInstruction get right => inputs[2];
 
-  abstract BinaryOperation get operation;
+  abstract BinaryOperation operation(ConstantSystem constantSystem);
   abstract isBuiltin(HTypeMap types);
 }
 
 class HBinaryArithmetic extends HInvokeBinary {
   HBinaryArithmetic(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
   void prepareGvn(HTypeMap types) {
     // An arithmetic expression can take part in global value
     // numbering and do not have any side-effects if we know that all
@@ skipping 40 matching lines @@
     if (input == right && left.isNumber(types)) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   HType computeLikelyType(HTypeMap types) {
     if (left.isTypeUnknown(types)) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   // TODO(1603): The class should be marked as abstract.
-  abstract BinaryOperation get operation;
+  abstract BinaryOperation operation(ConstantSystem constantSystem);
 }
 
 class HAdd extends HBinaryArithmetic {
   HAdd(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitAdd(this);
 
-  AddOperation get operation => const AddOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.add;
   int typeCode() => HInstruction.ADD_TYPECODE;
   bool typeEquals(other) => other is HAdd;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HDivide extends HBinaryArithmetic {
   HDivide(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitDivide(this);
 
   HType computeTypeFromInputTypes(HTypeMap types) {
     if (left.isNumber(types)) return HType.DOUBLE;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
                                             HTypeMap types) {
     // A division can never return an integer. So don't ask for integer inputs.
     if (isInteger(types)) return HType.UNKNOWN;
     return super.computeDesiredTypeForNonTargetInput(input, types);
   }
 
-  DivideOperation get operation => const DivideOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.divide;
   int typeCode() => HInstruction.DIVIDE_TYPECODE;
   bool typeEquals(other) => other is HDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HModulo extends HBinaryArithmetic {
   HModulo(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitModulo(this);
 
-  ModuloOperation get operation => const ModuloOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.modulo;
   int typeCode() => HInstruction.MODULO_TYPECODE;
   bool typeEquals(other) => other is HModulo;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HMultiply extends HBinaryArithmetic {
   HMultiply(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitMultiply(this);
 
-  MultiplyOperation get operation => const MultiplyOperation();
+  BinaryOperation operation(ConstantSystem operations)
+      => operations.multiply;
   int typeCode() => HInstruction.MULTIPLY_TYPECODE;
   bool typeEquals(other) => other is HMultiply;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HSubtract extends HBinaryArithmetic {
   HSubtract(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitSubtract(this);
 
-  SubtractOperation get operation => const SubtractOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.subtract;
   int typeCode() => HInstruction.SUBTRACT_TYPECODE;
   bool typeEquals(other) => other is HSubtract;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
  * An [HSwitch] instruction has one input for the incoming
  * value, and one input per constant that it can switch on.
  * Its block has one successor per constant, and one for the default.
  */
@@ skipping 13 matching lines @@
   accept(HVisitor visitor) => visitor.visitSwitch(this);
 
   String toString() => "HSwitch cases = $inputs";
 }
 
 class HTruncatingDivide extends HBinaryArithmetic {
   HTruncatingDivide(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitTruncatingDivide(this);
 
-  TruncatingDivideOperation get operation
-      => const TruncatingDivideOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.truncatingDivide;
   int typeCode() => HInstruction.TRUNCATING_DIVIDE_TYPECODE;
   bool typeEquals(other) => other is HTruncatingDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
 
 // TODO(floitsch): Should HBinaryArithmetic really be the super class of
 // HBinaryBitOp?
 class HBinaryBitOp extends HBinaryArithmetic {
   HBinaryBitOp(HStatic target, HInstruction left, HInstruction right)
@@ skipping 35 matching lines @@
   // Shift left cannot be mapped to the native operator unless the
   // shift count is guaranteed to be an integer in the [0,31] range.
   bool isBuiltin(HTypeMap types) {
     if (!left.isNumber(types) || !right.isConstantInteger()) return false;
     HConstant rightConstant = right;
     IntConstant intConstant = rightConstant.constant;
     int count = intConstant.value;
     return count >= 0 && count <= 31;
   }
 
-  ShiftLeftOperation get operation => const ShiftLeftOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.shiftLeft;
   int typeCode() => HInstruction.SHIFT_LEFT_TYPECODE;
   bool typeEquals(other) => other is HShiftLeft;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HShiftRight extends HBinaryBitOp {
   HShiftRight(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitShiftRight(this);
 
   // Shift right cannot be mapped to the native operator easily.
   bool isBuiltin(HTypeMap types) => false;
 
-  ShiftRightOperation get operation => const ShiftRightOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.shiftRight;
   int typeCode() => HInstruction.SHIFT_RIGHT_TYPECODE;
   bool typeEquals(other) => other is HShiftRight;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitOr extends HBinaryBitOp {
   HBitOr(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitBitOr(this);
 
-  BitOrOperation get operation => const BitOrOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.bitOr;
   int typeCode() => HInstruction.BIT_OR_TYPECODE;
   bool typeEquals(other) => other is HBitOr;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitAnd extends HBinaryBitOp {
   HBitAnd(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitBitAnd(this);
 
-  BitAndOperation get operation => const BitAndOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.bitAnd;
   int typeCode() => HInstruction.BIT_AND_TYPECODE;
   bool typeEquals(other) => other is HBitAnd;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitXor extends HBinaryBitOp {
   HBitXor(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitBitXor(this);
 
-  BitXorOperation get operation => const BitXorOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.bitXor;
   int typeCode() => HInstruction.BIT_XOR_TYPECODE;
   bool typeEquals(other) => other is HBitXor;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HInvokeUnary extends HInvokeStatic {
   HInvokeUnary(HStatic target, HInstruction input)
       : super(<HInstruction>[target, input]);
 
   HInstruction get operand => inputs[1];
@@ skipping 24 matching lines @@
     // If the outgoing type should be a number (integer, double or both) we
     // want the outgoing type to be the input too.
     // If we don't know the outgoing type we try to make it a number.
     if (propagatedType.isNumber()) return propagatedType;
     if (propagatedType.isUnknown()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   HType computeLikelyType(HTypeMap types) => HType.NUMBER;
 
-  abstract UnaryOperation get operation;
+  abstract UnaryOperation operation(ConstantSystem constantSystem);
 }
 
 class HNegate extends HInvokeUnary {
   HNegate(HStatic target, HInstruction input) : super(target, input);
   accept(HVisitor visitor) => visitor.visitNegate(this);
 
-  NegateOperation get operation => const NegateOperation();
+  UnaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.negate;
   int typeCode() => HInstruction.NEGATE_TYPECODE;
   bool typeEquals(other) => other is HNegate;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitNot extends HInvokeUnary {
   HBitNot(HStatic target, HInstruction input) : super(target, input);
   accept(HVisitor visitor) => visitor.visitBitNot(this);
 
   HType computeTypeFromInputTypes(HTypeMap types) {
     // All bitwise operations on primitive types either produce an
     // integer or throw an error.
     if (operand.isPrimitive(types)) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
                                             HTypeMap types) {
     HType propagatedType = types[this];
     // Bit operations only work on integers. If there is no desired output
     // type or if it as a number we want to get an integer as input.
     if (propagatedType.isUnknown() || propagatedType.isNumber()) {
       return HType.INTEGER;
     }
     return HType.UNKNOWN;
   }
 
-  BitNotOperation get operation => const BitNotOperation();
+  UnaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.bitNot;
   int typeCode() => HInstruction.BIT_NOT_TYPECODE;
   bool typeEquals(other) => other is HBitNot;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HExit extends HControlFlow {
   HExit() : super(const <HInstruction>[]);
   toString() => 'exit';
   accept(HVisitor visitor) => visitor.visitExit(this);
 }
@@ skipping 278 matching lines @@
       }
     }
     return HType.UNKNOWN;
   }
 
   HType computeLikelyType(HTypeMap types) => HType.BOOLEAN;
 
   bool isBuiltin(HTypeMap types)
       => left.isNumber(types) && right.isNumber(types);
   // TODO(1603): the class should be marked as abstract.
-  abstract BinaryOperation get operation;
+  abstract BinaryOperation operation(ConstantSystem constantSystem);
 }
 
 class HEquals extends HRelational {
   HEquals(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitEquals(this);
 
   bool isBuiltin(HTypeMap types) {
     // All primitive types have === semantics.
     // Note that this includes all constants except the user-constructed
@@ skipping 28 matching lines @@
     if (input == left && left.isIndexablePrimitive(types)) {
       return HType.READABLE_ARRAY;
     }
     // String equality testing is much more common than array equality testing.
     if (input == right && right.isIndexablePrimitive(types)) {
       return HType.STRING;
     }
     return HType.UNKNOWN;
   }
 
-  EqualsOperation get operation => const EqualsOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.equal;
   int typeCode() => HInstruction.EQUALS_TYPECODE;
   bool typeEquals(other) => other is HEquals;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HIdentity extends HRelational {
   HIdentity(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitIdentity(this);
 
   bool isBuiltin(HTypeMap types) => true;
 
   HType get guaranteedType => HType.BOOLEAN;
   HType computeTypeFromInputTypes(HTypeMap types)
       => HType.BOOLEAN;
   // Note that the identity operator really does not care for its input types.
   HType computeDesiredTypeForInput(HInstruction input, HTypeMap types)
       => HType.UNKNOWN;
 
-  IdentityOperation get operation => const IdentityOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.identity;
   int typeCode() => HInstruction.IDENTITY_TYPECODE;
   bool typeEquals(other) => other is HIdentity;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HGreater extends HRelational {
   HGreater(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitGreater(this);
 
-  GreaterOperation get operation => const GreaterOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.greater;
   int typeCode() => HInstruction.GREATER_TYPECODE;
   bool typeEquals(other) => other is HGreater;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HGreaterEqual extends HRelational {
   HGreaterEqual(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitGreaterEqual(this);
 
-  GreaterEqualOperation get operation => const GreaterEqualOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.greaterEqual;
   int typeCode() => HInstruction.GREATER_EQUAL_TYPECODE;
   bool typeEquals(other) => other is HGreaterEqual;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HLess extends HRelational {
   HLess(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitLess(this);
 
-  LessOperation get operation => const LessOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.less;
   int typeCode() => HInstruction.LESS_TYPECODE;
   bool typeEquals(other) => other is HLess;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HLessEqual extends HRelational {
   HLessEqual(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitLessEqual(this);
 
-  LessEqualOperation get operation => const LessEqualOperation();
+  BinaryOperation operation(ConstantSystem constantSystem)
+      => constantSystem.lessEqual;
   int typeCode() => HInstruction.LESS_EQUAL_TYPECODE;
   bool typeEquals(other) => other is HLessEqual;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HReturn extends HControlFlow {
   HReturn(value) : super(<HInstruction>[value]);
   toString() => 'return';
   accept(HVisitor visitor) => visitor.visitReturn(this);
 }
@@ skipping 517 matching lines @@
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty());
     return statements.last().end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }