Refactor constant part.

frog/leg/ssa/nodes.dart

 // Copyright (c) 2011, 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);
   R visitBitXor(HBitXor node);
   R visitBoolify(HBoolify node);
   R visitBoundsCheck(HBoundsCheck node);
   R visitBreak(HBreak node);
+  R visitConstant(HConstant node);
   R visitDivide(HDivide node);
   R visitEquals(HEquals node);
   R visitExit(HExit node);
   R visitFieldGet(HFieldGet node);
   R visitFieldSet(HFieldSet node);
   R visitForeign(HForeign node);
   R visitForeignNew(HForeignNew);
   R visitGoto(HGoto node);
   R visitGreater(HGreater node);
   R visitGreaterEqual(HGreaterEqual node);
   R visitIdentity(HIdentity node);
   R visitIf(HIf node);
   R visitIndex(HIndex node);
   R visitIndexAssign(HIndexAssign node);
   R visitIntegerCheck(HIntegerCheck node);
   R visitInvokeClosure(HInvokeClosure node);
   R visitInvokeDynamicGetter(HInvokeDynamicGetter node);
   R visitInvokeDynamicMethod(HInvokeDynamicMethod node);
   R visitInvokeDynamicSetter(HInvokeDynamicSetter node);
   R visitInvokeInterceptor(HInvokeInterceptor node);
   R visitInvokeStatic(HInvokeStatic node);
   R visitInvokeSuper(HInvokeSuper node);
   R visitIs(HIs node);
   R visitLess(HLess node);
   R visitLessEqual(HLessEqual node);
-  R visitLiteral(HLiteral node);
   R visitLiteralList(HLiteralList node);
   R visitLoad(HLoad node);
   R visitLocal(HLocal node);
   R visitLogicalOperator(HLogicalOperator node);
   R visitLoopBranch(HLoopBranch node);
   R visitModulo(HModulo node);
   R visitMultiply(HMultiply node);
   R visitNegate(HNegate node);
   R visitNot(HNot node);
   R visitParameterValue(HParameterValue node);
@@ skipping 58 matching lines @@
     currentBlock = node;
     visitInstructionList(node);
   }
 }
 
 class HGraph {
   HBasicBlock entry;
   HBasicBlock exit;
   final List<HBasicBlock> blocks;
 
-  // We canonicalize all literals used within a graph so we do not
+  // We canonicalize all constants used within a graph so we do not
   // have to worry about them for global value numbering.
-  HLiteral nullLiteral;
-  HLiteral trueLiteral;
-  HLiteral falseLiteral;
-  HLiteral nanLiteral;
-  HLiteral negativeZeroLiteral;
-  Map<int, HLiteral> intLiterals;
-  Map<double, HLiteral> doubleLiterals;
-  Map<num, HLiteral> numLiterals;
-  Map<String, HLiteral> stringLiterals;
+  Map<Constant, HConstant> constants;
 
-  HGraph() : blocks = new List<HBasicBlock>() {
+  HGraph()
+      : blocks = new List<HBasicBlock>(),
+        constants = new Map<Constant, HConstant>() {
     entry = addNewBlock();
     // The exit block will be added later, so it has an id that is
     // after all others in the system.
     exit = new HBasicBlock();
   }
 
   void addBlock(HBasicBlock block) {
     int id = blocks.length;
     block.id = id;
     blocks.add(block);
     assert(blocks[id] === block);
   }
 
   HBasicBlock addNewBlock() {
     HBasicBlock result = new HBasicBlock();
     addBlock(result);
     return result;
   }
 
   HBasicBlock addNewLoopHeaderBlock(List<SourceString> labels) {
     HBasicBlock result = addNewBlock();
     result.loopInformation = new HLoopInformation(result, labels);
     return result;
   }
 
-  HLiteral addNewLiteralInt(int value) {
-    if (intLiterals === null) intLiterals = new Map<int, HLiteral>();
-    HLiteral result = intLiterals[value];
+  HType mapConstantTypeToSsaType(Constant constant) {

[kasperl, 2012/03/05 13:53:16]

static?

[floitsch, 2012/03/05 15:43:24]

Done.

+    if (constant.isNull()) return HType.UNKNOWN;
+    if (constant.isBool()) return HType.BOOLEAN;
+    if (constant.isInt()) return HType.INTEGER;
+    if (constant.isDouble()) return HType.DOUBLE;
+    if (constant.isString()) return HType.STRING;
+    if (constant.isList()) return HType.ARRAY;
+    return HType.UNKNOWN;
+  }
+
+  HConstant addNewConstant(Constant constant) {
+    HConstant result = constants[constant];
     if (result === null) {
-      result = new HLiteral.internal(value, HType.INTEGER);
+      HType type = mapConstantTypeToSsaType(constant);
+      result = new HConstant.internal(constant, type);
       entry.addAtExit(result);
-      intLiterals[value] = result;
+      constants[constant] = result;
     }
     return result;
   }
 
-  HLiteral addNewLiteralNaN() {
-    if (nanLiteral === null) {
-      nanLiteral = new HLiteral.internal(double.NAN, HType.DOUBLE);
-      entry.addAtExit(nanLiteral);
-    }
-    return nanLiteral;
-  }
-
-  HLiteral addNewNegativeZeroLiteral() {
-    if (negativeZeroLiteral === null) {
-      negativeZeroLiteral = new HLiteral.internal(-0.0, HType.DOUBLE);
-      entry.addAtExit(negativeZeroLiteral);
-    }
-    return negativeZeroLiteral;
-  }
-
-  HLiteral addNewLiteralDouble(double value) {
-    if (value.isNaN()) return addNewLiteralNaN();  // Avoid hashing NaN.
-    if (value == 0 && value.isNegative()) {
-      // Avoid hashing -0.0 as it compares equal to 0.0.
-      return addNewNegativeZeroLiteral();
-    }
-    if (doubleLiterals === null) doubleLiterals = new Map<double, HLiteral>();
-    HLiteral result = doubleLiterals[value];
-    if (result === null) {
-      result = new HLiteral.internal(value, HType.DOUBLE);
-      entry.addAtExit(result);
-      doubleLiterals[value] = result;
-    }
-    return result;
-  }
-
-  HLiteral addNewLiteralNum(num value, HType type) {
-    // If we've propagated type information then the type must be a
-    // number or in conflict, but when we turn off speculative
-    // optimization the type may be unknown. In any case, we make it a
-    // number from this point forward.
-    assert(type.isUnknown() || type.isConflicting() || type.isNumber());
-    if (type.isInteger()) return addNewLiteralInt(value);
-    if (type.isDouble() || value.isNaN()) return addNewLiteralDouble(value);
-    // Probe our literals map and add a new number literal if necessary.
-    if (numLiterals === null) numLiterals = new Map<num, HLiteral>();
-    HLiteral result = numLiterals[value];
-    if (result === null) {
-      result = new HLiteral.internal(value, HType.NUMBER);
-      entry.addAtExit(result);
-      numLiterals[value] = result;
-     }
-    return result;
-  }
-
-  HLiteral addNewLiteralTrue() {
-    if (trueLiteral === null) {
-      trueLiteral = new HLiteral.internal(true, HType.BOOLEAN);
-      entry.addAtExit(trueLiteral);
-    }
-    return trueLiteral;
-  }
-
-  HLiteral addNewLiteralFalse() {
-    if (falseLiteral === null) {
-      falseLiteral = new HLiteral.internal(false, HType.BOOLEAN);
-      entry.addAtExit(falseLiteral);
-    }
-    return falseLiteral;
-  }
-
-  HLiteral addNewLiteralBool(bool value) {
-    return value ? addNewLiteralTrue() : addNewLiteralFalse();
-  }
-
-  HLiteral addNewLiteralString(DartString value) {
-    if (stringLiterals === null) stringLiterals = new Map<String, HLiteral>();
-    String key = value.toString();  // We need something hashable.
-    HLiteral result = stringLiterals[key];
-    if (result === null) {
-      result = new HLiteral.internal(value, HType.STRING);
-      entry.addAtExit(result);
-      stringLiterals[key] = result;
-    }
-    return result;
-  }
-
-  HLiteral addNewLiteralNull() {
-    if (nullLiteral === null) {
-      nullLiteral = new HLiteral.internal(null, HType.UNKNOWN);
-      entry.addAtExit(nullLiteral);
-    }
-    return nullLiteral;
-  }
-
   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 48 matching lines @@
   visitAdd(HAdd node) => visitBinaryArithmetic(node);
   visitBitAnd(HBitAnd node) => visitBinaryBitOp(node);
   visitBitNot(HBitNot node) => visitInvokeUnary(node);
   visitBitOr(HBitOr node) => visitBinaryBitOp(node);
   visitBitXor(HBitXor node) => visitBinaryBitOp(node);
   visitBailoutTarget(HBailoutTarget node) => visitInstruction(node);
   visitBoolify(HBoolify node) => visitInstruction(node);
   visitBoundsCheck(HBoundsCheck node) => visitCheck(node);
   visitBreak(HBreak node) => visitGoto(node);
   visitCheck(HCheck node) => visitInstruction(node);
+  visitConstant(HConstant node) => visitInstruction(node);
   visitDivide(HDivide node) => visitBinaryArithmetic(node);
   visitEquals(HEquals node) => visitRelational(node);
   visitExit(HExit node) => visitControlFlow(node);
   visitFieldGet(HFieldGet node) => visitInstruction(node);
   visitFieldSet(HFieldSet node) => visitInstruction(node);
   visitForeign(HForeign node) => visitInstruction(node);
   visitForeignNew(HForeignNew node) => visitForeign(node);
   visitGoto(HGoto node) => visitControlFlow(node);
   visitGreater(HGreater node) => visitRelational(node);
   visitGreaterEqual(HGreaterEqual node) => visitRelational(node);
@@ skipping 12 matching lines @@
       => visitInvokeDynamicField(node);
   visitInvokeInterceptor(HInvokeInterceptor node)
       => visitInvokeStatic(node);
   visitInvokeStatic(HInvokeStatic node) => visitInvoke(node);
   visitInvokeSuper(HInvokeSuper node) => visitInvoke(node);
   visitLess(HLess node) => visitRelational(node);
   visitLessEqual(HLessEqual node) => visitRelational(node);
   visitLoad(HLoad node) => visitInstruction(node);
   visitLocal(HLocal node) => visitInstruction(node);
   visitLogicalOperator(HLogicalOperator node) => visitInstruction(node);
-  visitLiteral(HLiteral node) => visitInstruction(node);
   visitLiteralList(HLiteralList node) => visitInstruction(node);
   visitLoopBranch(HLoopBranch node) => visitConditionalBranch(node);
   visitModulo(HModulo node) => visitBinaryArithmetic(node);
   visitNegate(HNegate node) => visitInvokeUnary(node);
   visitNot(HNot node) => visitInstruction(node);
   visitPhi(HPhi node) => visitInstruction(node);
   visitMultiply(HMultiply node) => visitBinaryArithmetic(node);
   visitParameterValue(HParameterValue node) => visitInstruction(node);
   visitReturn(HReturn node) => visitControlFlow(node);
   visitShiftRight(HShiftRight node) => visitBinaryBitOp(node);
@@ skipping 628 matching lines @@
           inputUsedBy[j] = inputUsedBy[inputUsedBy.length - 1];
           inputUsedBy.removeLast();
           break;
         }
       }
     }
     this.block = null;
     assert(isValid());
   }
 
-  bool isLiteralNull() => false;
-  bool isLiteralNumber() => false;
-  bool isLiteralString() => false;
+  bool isNullConstant() => false;

[kasperl, 2012/03/05 13:53:16]

I know it doesn't read as well, but I think I'd prefer these to be
isConstantNull, etc. Somehow that just seems more consistent to me.

[floitsch, 2012/03/05 15:43:24]

Done.

+  bool isNumberConstant() => false;
+  bool isStringConstant() => false;
 
   bool isValid() {
     HValidator validator = new HValidator();
     validator.currentBlock = block;
     validator.visitInstruction(this);
     return validator.isValid;
   }
 }
 
 class HBoolify extends HInstruction {
@@ skipping 241 matching lines @@
           || name == const SourceString('removeLast')) {
         return HType.ARRAY;
       }
     }
     return HType.UNKNOWN;
   }
 
   bool hasExpectedType() => builtinJsName != null;
 
   HInstruction fold(HGraph graph) {
-    if (name == const SourceString('length') && inputs[1].isLiteralString()) {
-      HLiteral input = inputs[1];
-      DartString string = input.value;
-      return graph.addNewLiteralInt(string.length);
+    if (name == const SourceString('length') && inputs[1].isStringConstant()) {
+      HConstant input = inputs[1];
+      DartString string = input.constant.value;
+      return graph.addNewConstant(new IntConstant(string.length));

[kasperl, 2012/03/05 13:53:16]

Maybe keeping a few helpers around (graph.addNewConstantInt) for these cases
wouldn't hurt?

[floitsch, 2012/03/05 15:43:24]

Done.

     }
     return this;
   }
 
   void prepareGvn() {
     if (builtinJsName == 'length') {
       assert(!hasSideEffects());
     } else {
       setAllSideEffects();
     }
@@ skipping 74 matching lines @@
 
   HType computeInputsType() {
     HType leftType = left.type;
     HType rightType = right.type;
     if (leftType.isUnknown() || rightType.isUnknown()) {
       return HType.UNKNOWN;
     }
     return leftType.combine(rightType);
   }
 
-  abstract HInstruction fold(HGraph graph);
-  abstract evaluate(num a, num b);
+  HInstruction fold(HGraph graph) {
+    if (left is HConstant && right is HConstant) {
+      HConstant op1 = left;
+      HConstant op2 = right;
+      Constant folded =
+          op1.constant.binaryFold(operationAsString(), op2.constant);
+      if (folded !== null) return graph.addNewConstant(folded);
+    }
+    return this;
+  }
+  abstract String operationAsString();
 }
 
 class HBinaryArithmetic extends HInvokeBinary {
   HBinaryArithmetic(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
   void prepareGvn() {
     // An arithmetic expression can take part in global value
     // numbering and do not have any side-effects if we know that all
     // inputs are numbers.
     if (builtin) {
       assert(!hasSideEffects());
       setUseGvn();
     } else {
       setAllSideEffects();
     }
   }
 
-  HInstruction fold(HGraph graph) {
-    if (left.isLiteralNumber() && right.isLiteralNumber()) {
-      HLiteral op1 = left;
-      HLiteral op2 = right;
-      return graph.addNewLiteralNum(evaluate(op1.value, op2.value), type);
-    }
-    return this;
-  }
-
   HType computeType() {
     HType type = computeInputsType();
     builtin = type.isNumber();
     if (!type.isUnknown()) return type;
     if (left.isNumber()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     if (isNumber() || left.isNumber() || right.isNumber()) return HType.NUMBER;
     if (type.isUnknown()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   bool hasExpectedType() => builtin || type.isUnknown();
-
-  abstract num evaluate(num a, num b);
 }
 
 class HAdd extends HBinaryArithmetic {
   HAdd(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitAdd(this);
-  num evaluate(num a, num b) => a + b;
-  int typeCode() => 5;
-  bool typeEquals(other) => other is HAdd;
-  bool dataEquals(HInstruction other) => true;
 
   HType computeType() {
     HType type = computeInputsType();
     builtin = (type.isNumber() || type.isString());
     if (type.isConflicting() && left.isString()) {
-      builtin = right is HLiteral;
+      builtin = right is HConstant;
       return HType.STRING;
     }
     if (!type.isUnknown()) return type;
     if (left.isNumber()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   bool hasExpectedType() => builtin || type.isUnknown() || left.isString();
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     if (isString() || left.isString()) {
       return (input == left) ? HType.STRING : HType.UNKNOWN;
     }
     if (right.isString()) return HType.STRING;
     if (isNumber() || left.isNumber() || right.isNumber()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   HInstruction fold(HGraph graph) {
-    if (left.isLiteralString() && right is HLiteral) {
-      HLiteral op1 = left;
-      HLiteral op2 = right;
-      DartString leftString = op1.value;
+    // TODO(floitsch): move this code to the compile-time-constant handler.
+    if (left.isStringConstant() && right is HConstant) {
+      HConstant op1 = left;
+      HConstant op2 = right;
+      DartString leftString = op1.constant.value;
       DartString otherString = null;
-      if (right.isLiteralString()) {
-        otherString = op2.value;
+      if (right.isStringConstant()) {
+        otherString = op2.constant.value;
       } else {
-        assert(op2.isLiteralNumber() ||
-               op2.isLiteralBoolean() ||
-               op2.isLiteralNull());
-        otherString = new DartString.literal(op2.value.toString());
+        assert(op2.isNumberConstant() ||
+               op2.isBooleanConstant() ||
+               op2.isNullConstant());
+        otherString = new DartString.literal(op2.constant.value.toString());
       }
       DartString cons = new ConsDartString(leftString, otherString);
-      return graph.addNewLiteralString(cons);
+      return graph.addNewConstant(new StringConstant(cons));
     }
     return super.fold(graph);
   }
+
+  String operationAsString() => "+";

[kasperl, 2012/03/05 13:53:16]

These operationAsString seem a bit broken. I wonder how much work it would be to
introduce const objects for operations?

[floitsch, 2012/03/05 15:43:24]

will think about it in another CL.

+  int typeCode() => 5;
+  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 computeType() {
     HType type = computeInputsType();
     builtin = type.isNumber();
     if (left.isNumber()) return HType.DOUBLE;
     return HType.UNKNOWN;
   }
 
-  num evaluate(num a, num b) => a / b;
+  String operationAsString() => "/";
   int typeCode() => 6;
   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);
-  num evaluate(num a, num b) => a % b;
+
+  String operationAsString() => "%";
   int typeCode() => 7;
   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);
-  num evaluate(num a, num b) => a * b;
+
+  String operationAsString() => "*";
   int typeCode() => 8;
   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);
-  num evaluate(num a, num b) => a - b;
+
+  String operationAsString() => "-";
   int typeCode() => 9;
   bool typeEquals(other) => other is HSubtract;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HTruncatingDivide extends HBinaryArithmetic {
   HTruncatingDivide(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitTruncatingDivide(this);
 
-  HInstruction fold(HGraph graph) {
-    // Avoid a DivisionByZeroException.
-    if (right.isLiteralNumber() && right.dynamic.value == 0) {
-      return this;
-    }
-    return super.fold(graph);
-  }
-
-  num evaluate(num a, num b) => a ~/ b;
+  String operationAsString() => "~/";
   int typeCode() => 10;
   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)
       : super(target, left, right);
 
   HType computeType() {
     HType type = computeInputsType();
     builtin = type.isInteger();
     if (!type.isUnknown()) return type;
     if (left.isInteger()) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     return HType.INTEGER;
   }
 
-  HInstruction fold(HGraph graph) {
-    // Bit-operations are only defined on integers.
-    if (left.isLiteralNumber() && right.isLiteralNumber()) {
-      HLiteral op1 = left;
-      HLiteral op2 = right;
-      // Avoid exceptions.
-      if (op1.isInteger() && op2.isInteger()) {
-        return graph.addNewLiteralInt(evaluate(op1.value, op2.value));
-      }
-    }
-    return this;
-  }
-
   // TODO(floitsch): make class abstract instead of adding an abstract method.
   abstract accept(HVisitor visitor);
 }
 
 class HShiftLeft extends HBinaryBitOp {
   HShiftLeft(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitShiftLeft(this);
 
-  HInstruction fold(HGraph graph) {
-    if (right.isLiteralNumber()) {
-      // TODO(floitsch): find good max left-shift amount.
-      final int MAX_SHIFT_LEFT_AMOUNT = 50;
-      HLiteral op2 = right;
-      // Only positive shifting is allowed. Also guard against out-of-memory
-      // shifts.
-      if (op2.value < 0 || op2.value > MAX_SHIFT_LEFT_AMOUNT) return this;
-    }
-    return super.fold(graph);
-  }
-
-  int evaluate(int a, int b) => a << b;
+  String operationAsString() => "<<";
   int typeCode() => 11;
   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);
 
-  HInstruction fold(HGraph graph) {
-    if (right.isLiteralNumber()) {
-      HLiteral op2 = right;
-      // Only positive shifting is allowed.
-      if (op2.value < 0) return this;
-    }
-    return super.fold(graph);
-  }
-
-  int evaluate(int a, int b) => a >> b;
+  String operationAsString() => ">>";
   int typeCode() => 12;
   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);
 
-  int evaluate(int a, int b) => a | b;
+  String operationAsString() => "|";
   int typeCode() => 13;
   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);
 
-  int evaluate(int a, int b) => a & b;
+  String operationAsString() => "&";
   int typeCode() => 14;
   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);
 
-  int evaluate(int a, int b) => a ^ b;
+  String operationAsString() => "^";
   int typeCode() => 15;
   bool typeEquals(other) => other is HBitXor;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HInvokeUnary extends HInvokeStatic {
   HInvokeUnary(HStatic target, HInstruction input)
       : super(Selector.UNARY_OPERATOR, <HInstruction>[target, input]);
 
   HInstruction get operand() => inputs[1];
@@ skipping 19 matching lines @@
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     if (type.isUnknown() || type.isNumber()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   bool hasExpectedType() => builtin || (type.isUnknown());
 
-  abstract HInstruction fold(HGraph graph);
+  HInstruction fold(HGraph graph) {
+    if (operand is HConstant) {
+      HConstant op = operand;
+      Constant folded = op.constant.unaryFold(operationAsString());
+      if (folded !== null) return graph.addNewConstant(folded);
+    }
+    return this;
+  }
 
-  abstract num evaluate(num a);
+  abstract String operationAsString();
 }
 
 class HNegate extends HInvokeUnary {
   HNegate(HStatic target, HInstruction input) : super(target, input);
   accept(HVisitor visitor) => visitor.visitNegate(this);
 
-  HInstruction fold(HGraph graph) {
-    if (operand.isLiteralNumber()) {
-      HLiteral input = operand;
-      return graph.addNewLiteralNum(evaluate(input.value), type);
-    }
-    return this;
-  }
-
-  num evaluate(num a) => -a;
+  String operationAsString() => "-";
   int typeCode() => 16;
   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 computeType() {
     HType type = operand.type;
     builtin = type.isInteger();
     if (!type.isUnknown()) return type;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     return HType.INTEGER;
   }
 
-  HInstruction fold(HGraph graph) {
-    if (operand.isLiteralNumber()) {
-      HLiteral input = operand;
-      if (input.isInteger()) {
-        return graph.addNewLiteralInt(evaluate(input.value));
-      }
-    }
-    return this;
-  }
-
-  int evaluate(int a) => ~a;
+  String operationAsString() => "~";
   int typeCode() => 17;
   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 59 matching lines @@
   HLoopBranch(HInstruction condition, [this.kind = CONDITION_FIRST_LOOP])
       : super(<HInstruction>[condition]);
   toString() => 'loop-branch';
   accept(HVisitor visitor) => visitor.visitLoopBranch(this);
 
   bool isDoWhile() {
     return kind === DO_WHILE_LOOP;
   }
 }
 
-class HLiteral extends HInstruction {
-  final value;
-  HLiteral.internal(this.value, HType type) : super(<HInstruction>[]) {
+class HConstant extends HInstruction {
+  final Constant constant;
+  HConstant.internal(this.constant, HType type) : super(<HInstruction>[]) {
     this.type = type;
     tryGenerateAtUseSite();  // Maybe avoid this if the literal is big?
   }
 
   void prepareGvn() {
     assert(!hasSideEffects());
   }
 
-  toString() => 'literal: $value';
-  accept(HVisitor visitor) => visitor.visitLiteral(this);
+  toString() => 'literal: $constant';
+  accept(HVisitor visitor) => visitor.visitConstant(this);
   HType computeType() => type;
 
   // Literals have the type they have. It can't be changed.
   bool updateType() => false;
 
   bool hasExpectedType() => true;
 
-  bool isLiteralBoolean() => value is bool;
-  bool isLiteralNull() => value === null;
-  bool isLiteralNumber() => value is num;
-  bool isLiteralString() => value is DartString;
+  bool isBooleanConstant() => constant.isBool();
+  bool isNullConstant() => constant.isNull();
+  bool isNumberConstant() => constant.isNum();
+  bool isStringConstant() => constant.isString();
 }
 
 class HNot extends HInstruction {
   HNot(HInstruction value) : super(<HInstruction>[value]);
   void prepareGvn() {
     assert(!hasSideEffects());
     setUseGvn();
   }
 
   HType computeType() => HType.BOOLEAN;
@@ skipping 118 matching lines @@
     // and do not have any side-effects if we know all the inputs are
     // numbers. This can be improved for at least equality.
     if (builtin) {
       assert(!hasSideEffects());
       setUseGvn();
     } else {
       setAllSideEffects();
     }
   }
 
-   HInstruction fold(HGraph graph) {
-    if (left.isLiteralNumber() && right.isLiteralNumber()) {
-      HLiteral op1 = left;
-      HLiteral op2 = right;
-      return graph.addNewLiteralBool(evaluate(op1.value, op2.value));
-    }
-    return this;
-  }
-
   HType computeType() {
     builtin = computeInputsType().isNumber();
     return HType.BOOLEAN;
   }
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     // For all relational operations exept HEquals, we expect to only
     // get numbers.
     return HType.NUMBER;
   }
 
   // A HRelational goes through the builtin operator or the top level
   // element. Therefore, it always has the expected type.
   bool hasExpectedType() => true;
-
-  abstract bool evaluate(num a, num b);
 }
 
 class HEquals extends HRelational {
   HEquals(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
-  bool evaluate(num a, num b) => a == b;
   accept(HVisitor visitor) => visitor.visitEquals(this);
-  int typeCode() => 19;
-  bool typeEquals(other) => other is HEquals;
-  bool dataEquals(HInstruction other) => true;
 
   HType computeType() {
-    builtin = computeInputsType().isNumber() || (left is HLiteral);
+    builtin = computeInputsType().isNumber() || (left is HConstant);
     return HType.BOOLEAN;
   }
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     if (left.isNumber() || right.isNumber()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
+
+  String operationAsString() => "==";
+  int typeCode() => 19;
+  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);
-  bool evaluate(num a, num b) => a === b;
   accept(HVisitor visitor) => visitor.visitIdentity(this);
-  int typeCode() => 20;
-  bool typeEquals(other) => other is HIdentity;
-  bool dataEquals(HInstruction other) => true;
 
   HType computeType() {
     builtin = true;
     return HType.BOOLEAN;
   }
 
   bool hasExpectedType() => true;
 
   HType computeDesiredInputType(HInstruction input) => HType.UNKNOWN;
+
+  String operationAsString() => "===";
+  int typeCode() => 20;
+  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);
-  bool evaluate(num a, num b) => a > b;
   accept(HVisitor visitor) => visitor.visitGreater(this);
+
+  String operationAsString() => ">";
   int typeCode() => 21;
   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);
-  bool evaluate(num a, num b) => a >= b;
   accept(HVisitor visitor) => visitor.visitGreaterEqual(this);
+
+  String operationAsString() => ">=";
   int typeCode() => 22;
   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);
-  bool evaluate(num a, num b) => a < b;
   accept(HVisitor visitor) => visitor.visitLess(this);
+
+  String operationAsString() => "<";
+  int typeCode() => 23;
   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);
-  bool evaluate(num a, num b) => a <= b;
   accept(HVisitor visitor) => visitor.visitLessEqual(this);
-  int typeCode() => 23;
+
+  String operationAsString() => "<=";
+  int typeCode() => 24;
   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 12 matching lines @@
   void prepareGvn() {
     assert(!hasSideEffects());
     if (!element.isAssignable()) {
       setUseGvn();
     }
   }
   toString() => 'static ${element.name}';
   accept(HVisitor visitor) => visitor.visitStatic(this);
 
   int gvnHashCode() => super.gvnHashCode() ^ element.hashCode();
-  int typeCode() => 24;
+  int typeCode() => 25;
   bool typeEquals(other) => other is HStatic;
   bool dataEquals(HStatic other) => element == other.element;
 }
 
 class HStaticStore extends HInstruction {
   Element element;
   HStaticStore(this.element, HInstruction value) : super(<HInstruction>[value]);
   toString() => 'static store ${element.name}';
   accept(HVisitor visitor) => visitor.visitStaticStore(this);
 
-  int typeCode() => 25;
+  int typeCode() => 26;
   bool typeEquals(other) => other is HStaticStore;
   bool dataEquals(HStaticStore other) => element == other.element;
 }
 
 class HLiteralList extends HInstruction {
   HLiteralList(inputs, this.isConst) : super(inputs);
   toString() => 'literal list';
   accept(HVisitor visitor) => visitor.visitLiteralList(this);
   HType computeType() => HType.ARRAY;
   bool hasExpectedType() => true;
@@ skipping 125 matching lines @@
 
   HInstruction get expression() => inputs[0];
 
   HType computeType() => HType.BOOLEAN;
   bool hasExpectedType() => true;
 
   accept(HVisitor visitor) => visitor.visitIs(this);
 
   toString() => "$expression is $typeExpression";
 }