Use exact instruction names in the SSA tracer.

pkg/compiler/lib/src/ssa/ssa_tracer.dart

 // Copyright (c) 2013, 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.
 
 library ssa.tracer;
 
 import 'dart:async' show EventSink;
 
 import '../compiler.dart' show Compiler;
 import '../diagnostics/invariant.dart' show DEBUG_MODE;
@@ skipping 142 matching lines @@
     } else {
       prefix = 'U';
     }
     return "$prefix${instruction.id}";
   }
 
   String visitBoolify(HBoolify node) {
     return "Boolify: ${temporaryId(node.inputs[0])}";
   }
 
-  String handleInvokeBinary(HInvokeBinary node, String op) {
+  String handleInvokeBinary(HInvokeBinary node, String opcode) {
     String left = temporaryId(node.left);
     String right= temporaryId(node.right);
-    return '$left $op $right';
+    return '$opcode: $left $right';
   }
 
-  String visitAdd(HAdd node) => handleInvokeBinary(node, '+');
+  String visitAdd(HAdd node) => handleInvokeBinary(node, 'Add');
 
-  String visitBitAnd(HBitAnd node) => handleInvokeBinary(node, '&');
+  String visitBitAnd(HBitAnd node) => handleInvokeBinary(node, 'BitAnd');
 
   String visitBitNot(HBitNot node) {
     String operand = temporaryId(node.operand);
-    return "~$operand";
+    return "BitNot: $operand";
   }
 
-  String visitBitOr(HBitOr node) => handleInvokeBinary(node, '|');
+  String visitBitOr(HBitOr node) => handleInvokeBinary(node, 'BitOr');
 
-  String visitBitXor(HBitXor node) => handleInvokeBinary(node, '^');
+  String visitBitXor(HBitXor node) => handleInvokeBinary(node, 'BitXor');
 
   String visitBoundsCheck(HBoundsCheck node) {
     String lengthId = temporaryId(node.length);
     String indexId = temporaryId(node.index);
-    return "Bounds check: length = $lengthId, index = $indexId";
+    return "BoundsCheck: length = $lengthId, index = $indexId";
   }
 
   String visitBreak(HBreak node) {
     HBasicBlock target = currentBlock.successors[0];
     if (node.label != null) {
       return "Break ${node.label.labelName}: (B${target.id})";
     }
     return "Break: (B${target.id})";
   }
 
-  String visitConstant(HConstant constant) => "Constant ${constant.constant}";
+  String visitConstant(HConstant constant) => "Constant: ${constant.constant}";
 
   String visitContinue(HContinue node) {
     HBasicBlock target = currentBlock.successors[0];
     if (node.label != null) {
       return "Continue ${node.label.labelName}: (B${target.id})";
     }
     return "Continue: (B${target.id})";
   }
 
-  String visitDivide(HDivide node) => handleInvokeBinary(node, '/');
+  String visitDivide(HDivide node) => handleInvokeBinary(node, 'Divide');
 
-  String visitExit(HExit node) => "exit";
+  String visitExit(HExit node) => "Exit";
 
   String visitFieldGet(HFieldGet node) {
     if (node.isNullCheck) {
-      return 'null check on ${temporaryId(node.receiver)}';
+      return 'FieldGet: NullCheck ${temporaryId(node.receiver)}';
     }
     String fieldName = node.element.name;
-    return 'field get ${temporaryId(node.receiver)}.$fieldName';
+    return 'FieldGet: ${temporaryId(node.receiver)}.$fieldName';
   }
 
   String visitFieldSet(HFieldSet node) {
     String valueId = temporaryId(node.value);
     String fieldName = node.element.name;
-    return 'field set ${temporaryId(node.receiver)}.$fieldName to $valueId';
+    return 'FieldSet: ${temporaryId(node.receiver)}.$fieldName to $valueId';
   }
 
   String visitReadModifyWrite(HReadModifyWrite node) {
     String fieldName = node.element.name;
     String receiverId = temporaryId(node.receiver);
     String op = node.jsOp;
     if (node.isAssignOp) {
       String valueId = temporaryId(node.value);
-      return 'field-update $receiverId.$fieldName $op= $valueId';
+      return 'ReadModifyWrite: $receiverId.$fieldName $op= $valueId';
     } else if (node.isPreOp) {
-      return 'field-update $op$receiverId.$fieldName';
+      return 'ReadModifyWrite: $op$receiverId.$fieldName';
     } else {
-      return 'field-update $receiverId.$fieldName$op';
+      return 'ReadModifyWrite: $receiverId.$fieldName$op';
     }
   }
 
   String visitLocalGet(HLocalGet node) {
     String localName = node.variable.name;
-    return 'local get ${temporaryId(node.local)}.$localName';
+    return 'LocalGet: ${temporaryId(node.local)}.$localName';
   }
 
   String visitLocalSet(HLocalSet node) {
     String valueId = temporaryId(node.value);
     String localName = node.variable.name;
-    return 'local set ${temporaryId(node.local)}.$localName to $valueId';
+    return 'LocalSet: ${temporaryId(node.local)}.$localName to $valueId';
   }
 
   String visitGoto(HGoto node) {
     HBasicBlock target = currentBlock.successors[0];
     return "Goto: (B${target.id})";
   }
 
-  String visitGreater(HGreater node) => handleInvokeBinary(node, '>');
+  String visitGreater(HGreater node) => handleInvokeBinary(node, 'Greater');
   String visitGreaterEqual(HGreaterEqual node) {
-    return handleInvokeBinary(node, '>=');
+    return handleInvokeBinary(node, 'GreaterEqual');
   }
-  String visitIdentity(HIdentity node) => handleInvokeBinary(node, '===');
+  String visitIdentity(HIdentity node) => handleInvokeBinary(node, 'Identity');
 
   String visitIf(HIf node) {
     HBasicBlock thenBlock = currentBlock.successors[0];
     HBasicBlock elseBlock = currentBlock.successors[1];
     String conditionId = temporaryId(node.inputs[0]);
     return "If ($conditionId): (B${thenBlock.id}) else (B${elseBlock.id})";
   }
 
-  String visitGenericInvoke(String invokeType, String functionName,
-                            List<HInstruction> arguments) {
+  String handleGenericInvoke(String invokeType, String functionName,
+                             List<HInstruction> arguments) {
     StringBuffer argumentsString = new StringBuffer();
     for (int i = 0; i < arguments.length; i++) {
       if (i != 0) argumentsString.write(", ");
       argumentsString.write(temporaryId(arguments[i]));
     }
     return "$invokeType: $functionName($argumentsString)";
   }
 
   String visitIndex(HIndex node) {
     String receiver = temporaryId(node.receiver);
     String index = temporaryId(node.index);
     return "Index: $receiver[$index]";
   }
 
   String visitIndexAssign(HIndexAssign node) {
     String receiver = temporaryId(node.receiver);
     String index = temporaryId(node.index);
     String value = temporaryId(node.value);
     return "IndexAssign: $receiver[$index] = $value";
   }
 
   String visitInterceptor(HInterceptor node) {
     String value = temporaryId(node.inputs[0]);
     if (node.interceptedClasses != null) {
       JavaScriptBackend backend = compiler.backend;
       String cls =
           backend.namer.suffixForGetInterceptor(node.interceptedClasses);
-      return "Intercept ($cls): $value";
+      return "Interceptor ($cls): $value";
     }
-    return "Intercept: $value";
+    return "Interceptor: $value";
   }
 
   String visitInvokeClosure(HInvokeClosure node)
-      => visitInvokeDynamic(node, "closure");
+      => handleInvokeDynamic(node, "InvokeClosure");
 
-  String visitInvokeDynamic(HInvokeDynamic invoke, String kind) {
+  String handleInvokeDynamic(HInvokeDynamic invoke, String kind) {
     String receiver = temporaryId(invoke.receiver);
     String name = invoke.selector.name;
-    String target = "($kind) $receiver.$name";
+    String target = "$receiver.$name";
     int offset = HInvoke.ARGUMENTS_OFFSET;
     List arguments = invoke.inputs.sublist(offset);
-    return visitGenericInvoke("Invoke", target, arguments) +
+    return handleGenericInvoke(kind, target, arguments) +
         "(${invoke.mask})";
   }
 
   String visitInvokeDynamicMethod(HInvokeDynamicMethod node)
-      => visitInvokeDynamic(node, "method");
+      => handleInvokeDynamic(node, "InvokeDynamicMethod");
   String visitInvokeDynamicGetter(HInvokeDynamicGetter node)
-      => visitInvokeDynamic(node, "get");
+      => handleInvokeDynamic(node, "InvokeDynamicGetter");
   String visitInvokeDynamicSetter(HInvokeDynamicSetter node)
-      => visitInvokeDynamic(node, "set");
+      => handleInvokeDynamic(node, "InvokeDynamicSetter");
 
   String visitInvokeStatic(HInvokeStatic invoke) {
     String target = invoke.element.name;
-    return visitGenericInvoke("Invoke", target, invoke.inputs);
+    return handleGenericInvoke("InvokeStatic", target, invoke.inputs);
   }
 
   String visitInvokeSuper(HInvokeSuper invoke) {
     String target = invoke.element.name;
-    return visitGenericInvoke("Invoke super", target, invoke.inputs);
+    return handleGenericInvoke("InvokeSuper", target, invoke.inputs);
   }
 
   String visitInvokeConstructorBody(HInvokeConstructorBody invoke) {
     String target = invoke.element.name;
-    return visitGenericInvoke("Invoke constructor body", target, invoke.inputs);
+    return handleGenericInvoke("InvokeConstructorBody", target, invoke.inputs);
   }
 
   String visitForeignCode(HForeignCode foreign) {
-    return visitGenericInvoke("Foreign", "${foreign.codeTemplate.ast}",
+    return handleGenericInvoke("ForeignCode", "${foreign.codeTemplate.ast}",
                               foreign.inputs);
   }
 
   String visitForeignNew(HForeignNew node) {
-    return visitGenericInvoke("New",
+    return handleGenericInvoke("ForeignNew",
                               "${node.element.name}",
                               node.inputs);
   }
 
-  String visitLess(HLess node) => handleInvokeBinary(node, '<');
-  String visitLessEqual(HLessEqual node) => handleInvokeBinary(node, '<=');
+  String visitLess(HLess node) => handleInvokeBinary(node, 'Less');
+  String visitLessEqual(HLessEqual node) =>
+      handleInvokeBinary(node, 'LessEqual');
 
   String visitLiteralList(HLiteralList node) {
     StringBuffer elementsString = new StringBuffer();
     for (int i = 0; i < node.inputs.length; i++) {
       if (i != 0) elementsString.write(", ");
       elementsString.write(temporaryId(node.inputs[i]));
     }
-    return "Literal list: [$elementsString]";
+    return "LiteralList: [$elementsString]";
   }
 
   String visitLoopBranch(HLoopBranch branch) {
     HBasicBlock bodyBlock = currentBlock.successors[0];
     HBasicBlock exitBlock = currentBlock.successors[1];
     String conditionId = temporaryId(branch.inputs[0]);
-    return "While ($conditionId): (B${bodyBlock.id}) then (B${exitBlock.id})";
+    return
+      "LoopBranch ($conditionId): (B${bodyBlock.id}) then (B${exitBlock.id})";
   }
 
-  String visitMultiply(HMultiply node) => handleInvokeBinary(node, '*');
+  String visitMultiply(HMultiply node) => handleInvokeBinary(node, 'Multiply');
 
   String visitNegate(HNegate node) {
     String operand = temporaryId(node.operand);
-    return "-$operand";
+    return "Negate: $operand";
   }
 
   String visitNot(HNot node) => "Not: ${temporaryId(node.inputs[0])}";
 
   String visitParameterValue(HParameterValue node) {
-    return "p${node.sourceElement.name}";
+    return "ParameterValue: ${node.sourceElement.name}";
   }
 
   String visitLocalValue(HLocalValue node) {
-    return "l${node.sourceElement.name}";
+    return "LocalValue: ${node.sourceElement.name}";
   }
 
   String visitPhi(HPhi phi) {
     StringBuffer buffer = new StringBuffer();
-    buffer.write("Phi(");
+    buffer.write("Phi: ");
     for (int i = 0; i < phi.inputs.length; i++) {
       if (i > 0) buffer.write(", ");
       buffer.write(temporaryId(phi.inputs[i]));
     }
-    buffer.write(")");
     return buffer.toString();
   }
 
   String visitRef(HRef node) {
-    return 'Ref ${temporaryId(node.value)}';
+    return 'Ref: ${temporaryId(node.value)}';
   }
 
-  String visitReturn(HReturn node) => "Return ${temporaryId(node.inputs[0])}";
+  String visitReturn(HReturn node) => "Return: ${temporaryId(node.inputs[0])}";
 
-  String visitShiftLeft(HShiftLeft node) => handleInvokeBinary(node, '<<');
-  String visitShiftRight(HShiftRight node) => handleInvokeBinary(node, '>>');
+  String visitShiftLeft(HShiftLeft node) =>
+      handleInvokeBinary(node, 'ShiftLeft');
+  String visitShiftRight(HShiftRight node) =>
+      handleInvokeBinary(node, 'ShiftRight');
 
   String visitStatic(HStatic node)
-      => "Static ${node.element.name}";
+      => "Static: ${node.element.name}";
 
   String visitLazyStatic(HLazyStatic node)
-      => "LazyStatic ${node.element.name}";
+      => "LazyStatic: ${node.element.name}";
 
   String visitOneShotInterceptor(HOneShotInterceptor node)
-      => visitInvokeDynamic(node, "one shot interceptor");
+      => handleInvokeDynamic(node, "OneShotInterceptor");
 
   String visitStaticStore(HStaticStore node) {
     String lhs = node.element.name;
-    return "Static $lhs = ${temporaryId(node.inputs[0])}";
+    return "StaticStore: $lhs = ${temporaryId(node.inputs[0])}";
   }
 
   String visitStringConcat(HStringConcat node) {
     var leftId = temporaryId(node.left);
     var rightId = temporaryId(node.right);
     return "StringConcat: $leftId + $rightId";
   }
 
   String visitStringify(HStringify node) {
-    return "Stringify ${temporaryId(node.inputs[0])}";
+    return "Stringify: ${temporaryId(node.inputs[0])}";
   }
 
-  String visitSubtract(HSubtract node) => handleInvokeBinary(node, '-');
+  String visitSubtract(HSubtract node) => handleInvokeBinary(node, 'Subtract');
 
   String visitSwitch(HSwitch node) {
     StringBuffer buf = new StringBuffer();
     buf.write("Switch: (");
     buf.write(temporaryId(node.inputs[0]));
     buf.write(") ");
     for (int i = 1; i < node.inputs.length; i++) {
       buf.write(temporaryId(node.inputs[i]));
       buf.write(": B");
       buf.write(node.block.successors[i - 1].id);
       buf.write(", ");
     }
     buf.write("default: B");
     buf.write(node.defaultTarget.id);
     return buf.toString();
   }
 
-  String visitThis(HThis node) => "this";
+  String visitThis(HThis node) => "This";
 
-  String visitThrow(HThrow node) => "Throw ${temporaryId(node.inputs[0])}";
+  String visitThrow(HThrow node) => "Throw: ${temporaryId(node.inputs[0])}";
 
   String visitThrowExpression(HThrowExpression node) {
-    return "ThrowExpression ${temporaryId(node.inputs[0])}";
+    return "ThrowExpression: ${temporaryId(node.inputs[0])}";
   }
 
   String visitTruncatingDivide(HTruncatingDivide node) {
-    return handleInvokeBinary(node, '~/');
+    return handleInvokeBinary(node, 'TruncatingDivide');
   }
 
   String visitExitTry(HExitTry node) {
-    return "Exit try";
+    return "ExitTry";
   }
 
   String visitTry(HTry node) {
     List<HBasicBlock> successors = currentBlock.successors;
     String tryBlock = 'B${successors[0].id}';
     String catchBlock = 'none';
     if (node.catchBlock != null) {
       catchBlock = 'B${successors[1].id}';
     }
 
     String finallyBlock = 'none';
     if (node.finallyBlock != null) {
       finallyBlock = 'B${node.finallyBlock.id}';
     }
 
     return "Try: $tryBlock, Catch: $catchBlock, Finally: $finallyBlock, "
         "Join: B${successors.last.id}";
   }
 
   String visitIs(HIs node) {
     String type = node.typeExpression.toString();
-    return "TypeTest: ${temporaryId(node.expression)} is $type";
+    return "Is: ${temporaryId(node.expression)} is $type";
   }
 
   String visitIsViaInterceptor(HIsViaInterceptor node) {
     String type = node.typeExpression.toString();
-    return "TypeTest: ${temporaryId(node.inputs[0])} is $type";
+    return "IsViaInterceptor: ${temporaryId(node.inputs[0])} is $type";
   }
 
   String visitTypeConversion(HTypeConversion node) {
     assert(node.inputs.length <= 2);
     String otherInput = (node.inputs.length == 2)
         ? temporaryId(node.inputs[1])
         : '';
     return "TypeConversion: ${temporaryId(node.checkedInput)} to "
       "${node.instructionType} $otherInput";
   }
@@ skipping 26 matching lines @@
 
   String visitInterfaceType(HInterfaceType node) {
     return "InterfaceType: ${node.dartType}";
   }
 
   String visitDynamicType(HDynamicType node) {
     return "DynamicType";
   }
 
   String visitAwait(HAwait node) {
-    return "await ${temporaryId(node.inputs[0])}";
+    return "Await: ${temporaryId(node.inputs[0])}";
   }
 
   String visitYield(HYield node) {
-    return "yield${node.hasStar ? "*" : ""} ${temporaryId(node.inputs[0])}";
+    return "Yield${node.hasStar ? "*" : ""}: ${temporaryId(node.inputs[0])}";
   }
 }