Split TypeGuard and BailoutTarget.

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name() => 'SSA code generator';
@@ skipping 194 matching lines @@
   Compiler get compiler() => backend.compiler;
   NativeEmitter get nativeEmitter() => backend.emitter.nativeEmitter;
   Enqueuer get world() => backend.compiler.enqueuer.codegen;
 
   bool isGenerateAtUseSite(HInstruction instruction) {
     return generateAtUseSite.contains(instruction);
   }
 
   bool isNonNegativeInt32Constant(HInstruction instruction) {
     if (instruction.isConstantInteger()) {
-      int value = instruction.constant.value;
+      int value =
+          ((instruction as HConstant).constant as PrimitiveConstant).value;
       if (value >= 0 && value < (1 << 31)) {
         return true;
       }
     }
     return false;
   }
 
   bool hasNonBitOpUser(HInstruction instruction, Set<HPhi> phiSet) {
     for (HInstruction use in instruction.usedBy) {
       if (use is HPhi) {
         if (!phiSet.contains(use)) {
           phiSet.add(use);
           if (hasNonBitOpUser(use, phiSet)) return true;
         }
       } else if (use is! HBitNot && use is! HBinaryBitOp) {
         return true;
       }
     }
     return false;
   }
 
   // We want the outcome of bit-operations to be positive. However, if
   // the result of a bit-operation is only used by other bit
   // operations we do not have to convert to an unsigned
   // integer. Also, if we are using & with a positive constant we know
   // that the result is positive already and need no conversion.
   bool requiresUintConversion(HInstruction instruction) {
     if (instruction is HBitAnd &&
-        (isNonNegativeInt32Constant(instruction.left) ||
-         isNonNegativeInt32Constant(instruction.right))) {
+        (isNonNegativeInt32Constant((instruction as HBitAnd).left) ||
+         isNonNegativeInt32Constant((instruction as HBitAnd).right))) {
       return false;
     }
     return hasNonBitOpUser(instruction, new Set<HPhi>());
   }
 
   SsaCodeGenerator(this.backend,
                    this.work,
                    this.parameters,
                    this.parameterNames)
     : declaredVariables = new Set<String>(),
       delayedVariableDeclarations = new Set<String>(),
       buffer = new CodeBuffer(),
       generateAtUseSite = new Set<HInstruction>(),
       controlFlowOperators = new Set<HInstruction>(),
       breakAction = new Map<Element, ElementAction>(),
       continueAction = new Map<Element, ElementAction>(),
       unsignedShiftPrecedences = JSPrecedence.binary['>>>'] {
   }
 
   abstract visitTypeGuard(HTypeGuard node);
+  abstract visitBailoutTarget(HBailoutTarget node);
 
   abstract beginGraph(HGraph graph);
   abstract endGraph(HGraph graph);
 
   abstract beginLoop(HBasicBlock block);
   abstract endLoop(HBasicBlock block);
   abstract handleLoopCondition(HLoopBranch node);
 
   abstract preLabeledBlock(HLabeledBlockInformation labeledBlockInfo);
   abstract startLabeledBlock(HLabeledBlockInformation labeledBlockInfo);
@@ skipping 884 matching lines @@
       }
       if (!isGeneratingExpression()) {
         buffer.add(';\n');
       }
     }
   }
 
   void iterateBasicBlock(HBasicBlock node) {
     HInstruction instruction = node.first;
     while (instruction !== node.last) {
-      if (instruction is HTypeGuard) {
+      if (instruction is HTypeGuard || instruction is HBailoutTarget) {
         visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
       } else if (!isGenerateAtUseSite(instruction)) {
         expectedPrecedence = JSPrecedence.STATEMENT_PRECEDENCE;
         define(instruction);
       }
       instruction = instruction.next;
     }
     assignPhisOfSuccessors(node);
     if (instruction is HLoopBranch && isGeneratingExpression()) {
       addExpressionSeparator();
@@ skipping 1523 matching lines @@
 
   int maxBailoutParameters;
 
   HBasicBlock beginGraph(HGraph graph) => graph.entry;
   void endGraph(HGraph graph) {}
 
   void bailout(HTypeGuard guard, String reason) {
     if (maxBailoutParameters === null) {
       maxBailoutParameters = 0;
       work.guards.forEach((HTypeGuard workGuard) {
-        int inputLength = workGuard.inputs.length;
+        HBailoutTarget target = workGuard.bailoutTarget;
+        int inputLength = target.inputs.length;
         if (inputLength > maxBailoutParameters) {
           maxBailoutParameters = inputLength;
         }
       });
     }
     HInstruction input = guard.guarded;
+    HBailoutTarget target = guard.bailoutTarget;
     Namer namer = compiler.namer;
     Element element = work.element;
     buffer.add('return ');
     if (element.isInstanceMember()) {
       // TODO(ngeoffray): This does not work in case we come from a
       // super call. We must make bailout names unique.
       buffer.add('this.${namer.getBailoutName(element)}');
     } else {
       buffer.add(namer.isolateBailoutAccess(element));
     }
     buffer.add('(${guard.state}');
     // TODO(ngeoffray): try to put a variable at a deterministic
     // location, so that multiple bailout calls put the variable at
     // the same parameter index.
     int i = 0;
-    for (; i < guard.inputs.length; i++) {
+    for (; i < target.inputs.length; i++) {
+      assert(guard.inputs.indexOf(target.inputs[i]) >= 0);
       buffer.add(', ');
-      use(guard.inputs[i], JSPrecedence.ASSIGNMENT_PRECEDENCE);
+      use(target.inputs[i], JSPrecedence.ASSIGNMENT_PRECEDENCE);
     }
     // Make sure we call the bailout method with the number of
     // arguments it expects. This avoids having the underlying
     // JS engine fill them in for us.
     for (; i < maxBailoutParameters; i++) {
       buffer.add(', 0');
     }
     buffer.add(')');
   }
 
@@ skipping 73 matching lines @@
       buffer.add(' && ');
       checkType(input, indexingBehavior, negative: true);
       buffer.add('))) ');
       bailout(node, 'Not a string or array');
     } else {
       compiler.internalError('Unexpected type guard', instruction: input);
     }
     buffer.add(';\n');
   }
 
+  void visitBailoutTarget(HBailoutTarget target) {
+    // Do nothing. Bailout targets are only used in the non-optimized version.
+  }
+
   void beginLoop(HBasicBlock block) {
     addIndentation();
     HLoopInformation info = block.loopInformation;
     for (LabelElement label in info.labels) {
       writeLabel(label);
       buffer.add(":");
     }
     buffer.add('while (true) {\n');
     indent++;
   }
@@ skipping 57 matching lines @@
     return labels.last();
   }
 
   HBasicBlock beginGraph(HGraph graph) {
     propagator = new SsaBailoutPropagator(compiler, generateAtUseSite);
     propagator.visitGraph(graph);
     // TODO(ngeoffray): We could avoid generating the state at the
     // call site for non-complex bailout methods.
     newParameters.add('state');
 
-    if (propagator.hasComplexTypeGuards) {
+    if (propagator.hasComplexBailoutTargets) {
       // Use generic parameters that will be assigned to
       // the right variables in the setup phase.
       for (int i = 0; i < propagator.maxBailoutParameters; i++) {
         String name = 'env$i';
         declaredVariables.add(name);
         newParameters.add(', $name');
       }
 
       startBailoutSwitch();
 
       // The setup phase of a bailout function sets up the environment for
       // each bailout target. Each bailout target will populate this
       // setup phase. It is put at the beginning of the function.
       setup.add('  switch (state) {\n');
       return graph.entry;
     } else {
-      // We have a simple type guard, so we can reuse the names that
-      // the type guard expects.
-      for (HInstruction input in propagator.firstTypeGuard.inputs) {
+      // We have a simple bailout target, so we can reuse the names that
+      // the bailout target expects.
+      for (HInstruction input in propagator.firstBailoutTarget.inputs) {
         input = unwrap(input);
         String name = variableNames.getName(input);
         declaredVariables.add(name);
         newParameters.add(', $name');
       }
 
       // We change the first instruction of the first guard to be the
-      // guard. We will change it back in the call to [endGraph].
-      HBasicBlock block = propagator.firstTypeGuard.block;
+      // bailout target. We will change it back in the call to [endGraph].
+      HBasicBlock block = propagator.firstBailoutTarget.block;
       savedFirstInstruction = block.first;
-      block.first = propagator.firstTypeGuard;
+      block.first = propagator.firstBailoutTarget;
       return block;
     }
   }
 
   // If argument is a [HCheck] and it does not have a name, we try to
   // find the name of its checked input. Note that there must be a
   // name, otherwise the instruction would not be in the live
   // environment.
   HInstruction unwrap(HInstruction argument) {
     while (argument is HCheck && !variableNames.hasName(argument)) {
       argument = argument.checkedInput;
     }
     assert(variableNames.hasName(argument));
     return argument;
   }
 
   void endGraph(HGraph graph) {
-    if (propagator.hasComplexTypeGuards) {
+    if (propagator.hasComplexBailoutTargets) {
       indent--; // Close original case.
       indent--;
       addIndented('}\n');  // Close 'switch'.
       setup.add('  }\n');
     } else {
       // Put back the original first instruction of the block.
-      propagator.firstTypeGuard.block.first = savedFirstInstruction;
+      propagator.firstBailoutTarget.block.first = savedFirstInstruction;
     }
   }
 
   bool visitAndOrInfo(HAndOrBlockInformation info) => false;
 
   bool visitIfInfo(HIfBlockInformation info) {
-    if (info.thenGraph.start.hasGuards()) return false;
-    if (info.elseGraph.start.hasGuards()) return false;
+    if (info.thenGraph.start.hasBailoutTargets()) return false;
+    if (info.elseGraph.start.hasBailoutTargets()) return false;
     return super.visitIfInfo(info);
   }
 
   bool visitLoopInfo(HLoopBlockInformation info) {
-    if (info.start.hasGuards()) return false;
-    if (info.loopHeader.hasGuards()) return false;
+    if (info.start.hasBailoutTargets()) return false;
+    if (info.loopHeader.hasBailoutTargets()) return false;
     return super.visitLoopInfo(info);
   }
 
   bool visitTryInfo(HTryBlockInformation info) => false;
   bool visitSequenceInfo(HStatementSequenceInformation info) => false;
 
   void visitTypeGuard(HTypeGuard node) {
-    if (!propagator.hasComplexTypeGuards) return;
+    // Do nothing. Type guards are only used in the optimized version.
+  }
+
+  void visitBailoutTarget(HBailoutTarget node) {
+    if (!propagator.hasComplexBailoutTargets) return;
 
     indent--;
     addIndented('case ${node.state}:\n');
     indent++;
     addIndented('state = 0;\n');
 
     setup.add('    case ${node.state}:\n');
     int i = 0;
     for (HInstruction input in node.inputs) {
       input = unwrap(input);
       String name = variableNames.getName(input);
       setup.add('      ');
       if (!isVariableDeclared(name)) {
         declaredVariables.add(name);
         setup.add('var ');
       }
       setup.add('$name = env$i;\n');
       i++;
     }
     setup.add('      break;\n');
   }
 
-  void startBailoutCase(List<HTypeGuard> bailouts1,
-                        List<HTypeGuard> bailouts2) {
+  void startBailoutCase(List<HBailoutTarget> bailouts1,
+                        List<HBailoutTarget> bailouts2) {
     indent--;
     if (!defaultClauseUsedInBailoutStack.last() &&
         bailouts1.length + bailouts2.length >= 2) {
       addIndented('default:\n');
       int len = defaultClauseUsedInBailoutStack.length;
       defaultClauseUsedInBailoutStack[len - 1] = true;
     } else {
       handleBailoutCase(bailouts1);
       handleBailoutCase(bailouts2);
     }
     indent++;
   }
 
-  void handleBailoutCase(List<HTypeGuard> guards) {
-    if (!defaultClauseUsedInBailoutStack.last() && guards.length >= 2) {
+  void handleBailoutCase(List<HBailoutTarget> targets) {
+    if (!defaultClauseUsedInBailoutStack.last() && targets.length >= 2) {
       addIndented('default:\n');
       int len = defaultClauseUsedInBailoutStack.length;
       defaultClauseUsedInBailoutStack[len - 1] = true;
     } else {
-      for (int i = 0, len = guards.length; i < len; i++) {
-        addIndented('case ${guards[i].state}:\n');
+      for (int i = 0, len = targets.length; i < len; i++) {
+        addIndented('case ${targets[i].state}:\n');
       }
     }
   }
 
   void startBailoutSwitch() {
     defaultClauseUsedInBailoutStack.add(false);
     addIndented('switch (state) {\n');
     indent++;
     addIndented('case 0:\n');
     indent++;
   }
 
   void endBailoutSwitch() {
     indent--; // Close 'case'.
     indent--;
     addIndented('}\n');  // Close 'switch'.
     defaultClauseUsedInBailoutStack.removeLast();
   }
 
   void beginLoop(HBasicBlock block) {
     String newLabel = pushLabel();
-    if (block.hasGuards()) {
-      startBailoutCase(block.guards, const <HTypeGuard>[]);
+    if (block.hasBailoutTargets()) {
+      startBailoutCase(block.bailoutTargets, const <HBailoutTarget>[]);
     }
 
     addIndentation();
     HLoopInformation loopInformation = block.loopInformation;
     for (LabelElement label in loopInformation.labels) {
       writeLabel(label);
       buffer.add(":");
     }
     buffer.add('$newLabel: while (true) {\n');
     indent++;
 
-    if (block.hasGuards()) {
+    if (block.hasBailoutTargets()) {
       startBailoutSwitch();
       if (loopInformation.target !== null) {
         breakAction[loopInformation.target] = (TargetElement target) {
           addIndented("break $newLabel;\n");
         };
       }
     }
   }
 
   void endLoop(HBasicBlock block) {
     popLabel();
     HBasicBlock header = block.isLoopHeader() ? block : block.parentLoopHeader;
-    if (header.hasGuards()) {
+    if (header.hasBailoutTargets()) {
       endBailoutSwitch();
       HLoopInformation info = header.loopInformation;
       if (info.target != null) breakAction.remove(info.target);
     }
     indent--;
     addIndented('}\n');  // Close 'while'.
   }
 
   void handleLoopCondition(HLoopBranch node) {
     buffer.add('if (!');
     use(node.inputs[0], JSPrecedence.PREFIX_PRECEDENCE);
     buffer.add(') break ${currentLabel()};\n');
   }
 
   void generateIf(HIf node, HIfBlockInformation info) {
     HStatementInformation thenGraph = info.thenGraph;
     HStatementInformation elseGraph = info.elseGraph;
-    bool thenHasGuards = thenGraph.start.hasGuards();
-    bool elseHasGuards = elseGraph.start.hasGuards();
+    bool thenHasGuards = thenGraph.start.hasBailoutTargets();
+    bool elseHasGuards = elseGraph.start.hasBailoutTargets();
     bool hasGuards = thenHasGuards || elseHasGuards;
     if (!hasGuards) return super.generateIf(node, info);
 
     int elseKind = analyzeGraphForCodegen(elseGraph);
     bool emptyElse = elseKind == SsaCodeGenerator.EMPTY;
 
-    startBailoutCase(thenGraph.start.guards,
-        emptyElse ? const <HTypeGuard>[] : elseGraph.start.guards);
+    startBailoutCase(thenGraph.start.bailoutTargets,
+        emptyElse ? const <HBailoutTarget>[] : elseGraph.start.bailoutTargets);
 
     addIndented('if (');
     int precedence = JSPrecedence.EXPRESSION_PRECEDENCE;
     // TODO(ngeoffray): Put the condition initialization in the
     // [setup] buffer.
-    List<HTypeGuard> guards = node.thenBlock.guards;
-    for (int i = 0, len = guards.length; i < len; i++) {
-      buffer.add('state == ${guards[i].state} || ');
+    List<HBailoutTarget> targets = node.thenBlock.bailoutTargets;
+    for (int i = 0, len = targets.length; i < len; i++) {
+      buffer.add('state == ${targets[i].state} || ');
     }
     buffer.add('(state == 0 && ');
     precedence = JSPrecedence.BITWISE_OR_PRECEDENCE;
     use(node.inputs[0], precedence);
 
     buffer.add(')) {\n');
 
     indent++;
     if (thenHasGuards) startBailoutSwitch();
     generateStatements(thenGraph);
     if (thenHasGuards) endBailoutSwitch();
     indent--;
 
     if (!emptyElse) {
       addIndented('} else {\n');
       indent++;
       if (elseHasGuards) startBailoutSwitch();
       generateStatements(elseGraph);
       if (elseHasGuards) endBailoutSwitch();
       indent--;
     }
 
     addIndented('}\n');
   }
 
   void preLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
-    if (labeledBlockInfo.body.start.hasGuards()) {
+    if (labeledBlockInfo.body.start.hasBailoutTargets()) {
       indent--;
-      handleBailoutCase(labeledBlockInfo.body.start.guards);
+      handleBailoutCase(labeledBlockInfo.body.start.bailoutTargets);
       indent++;
     }
   }
 
   void startLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
-    if (labeledBlockInfo.body.start.hasGuards()) {
+    if (labeledBlockInfo.body.start.hasBailoutTargets()) {
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
-    if (labeledBlockInfo.body.start.hasGuards()) {
+    if (labeledBlockInfo.body.start.hasBailoutTargets()) {
       endBailoutSwitch();
     }
   }
 }
 
 String singleIdentityComparison(HInstruction left, HInstruction right) {
   // Returns the single identity comparison (== or ===) or null if a more
   // complex expression is required.
   HType leftType = left.propagatedType;
   HType rightType = right.propagatedType;
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }