Merge libv1.

sdk/lib/_internal/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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 36 matching lines @@
     if (work.element.isField()) {
       return generateLazyInitializer(work, graph);
     } else {
       return generateMethod(work, graph);
     }
   }
 
   CodeBuffer generateLazyInitializer(work, graph) {
     return measure(() {
       compiler.tracer.traceGraph("codegen", graph);
-      List<js.Parameter> parameters = <js.Parameter>[];
-      SsaOptimizedCodeGenerator codegen = new SsaOptimizedCodeGenerator(
-          backend, work, parameters, new Map<Element, String>());
+      SsaOptimizedCodeGenerator codegen =
+          new SsaOptimizedCodeGenerator(backend, work);
       codegen.visitGraph(graph);
       js.Block body = codegen.body;
-      js.Fun fun = new js.Fun(parameters, body);
+      js.Fun fun = new js.Fun(codegen.parameters, body);
       return prettyPrint(fun);
     });
   }
 
   CodeBuffer generateMethod(WorkItem work, HGraph graph) {
     return measure(() {
       JavaScriptItemCompilationContext context = work.compilationContext;
       HTypeMap types = context.types;
       graph.exit.predecessors.forEach((block) {
         assert(block.last is HGoto || block.last is HReturn);
         if (block.last is HReturn) {
           backend.registerReturnType(work.element, types[block.last.inputs[0]]);
         } else {
           backend.registerReturnType(work.element, HType.NULL);
         }
       });
       compiler.tracer.traceGraph("codegen", graph);
-      Map<Element, String> parameterNames = getParameterNames(work);
-      // Use [work.element] to ensure that the parameter element come from
-      // the declaration.
-      FunctionElement function = work.element;
-      function.computeSignature(compiler).forEachParameter((element) {
-        compiler.enqueuer.codegen.addToWorkList(element, work.resolutionTree);
-      });
-      List<js.Parameter> parameters = <js.Parameter>[];
-      parameterNames.forEach((element, name) {
-        parameters.add(new js.Parameter(name));
-      });
-      addBackendParameters(work.element, parameters, parameterNames);
-      String parametersString = Strings.join(parameterNames.values, ", ");
-      SsaOptimizedCodeGenerator codegen = new SsaOptimizedCodeGenerator(
-          backend, work, parameters, parameterNames);
+      SsaOptimizedCodeGenerator codegen =
+          new SsaOptimizedCodeGenerator(backend, work);
       codegen.visitGraph(graph);
 
       FunctionElement element = work.element;
       js.Block body;
       ClassElement enclosingClass = element.getEnclosingClass();
       bool allowVariableMinification;
       if (element.isInstanceMember()
           && enclosingClass.isNative()
           && native.isOverriddenMethod(
               element, enclosingClass, nativeEmitter)) {
         // Record that this method is overridden. In case of optional
         // arguments, the emitter will generate stubs to handle them,
         // and needs to know if the method is overridden.
         nativeEmitter.overriddenMethods.add(element);
         StringBuffer buffer = new StringBuffer();
         String codeString = prettyPrint(codegen.body).toString();
+        String parametersString =
+            Strings.join(codegen.parameterNames.values, ", ");
         native.generateMethodWithPrototypeCheckForElement(
             compiler, buffer, element, codeString, parametersString);
         js.Node nativeCode = new js.LiteralStatement(buffer.toString());
         body = new js.Block(<js.Statement>[nativeCode]);
         allowVariableMinification = false;
       } else {
         body = codegen.body;
         allowVariableMinification = !codegen.visitedForeignCode;
       }
-      js.Fun fun = buildJavaScriptFunction(element, parameters, body);
+      js.Fun fun = buildJavaScriptFunction(element, codegen.parameters, body);
       return prettyPrint(fun,
                          allowVariableMinification: allowVariableMinification);
     });
   }
 
-  void addBackendParameter(Element element,
-                           List<js.Parameter> parameters,
-                           Map<Element, String> parameterNames) {
-    String name = element.name.slowToString();
-    String prefix = '';
-    // Avoid collisions with real parameters of the method.
-    do {
-      name = JsNames.getValid('$prefix$name');
-      prefix = '\$$prefix';
-    } while (parameterNames.containsValue(name));
-    parameterNames[element] = name;
-    parameters.add(new js.Parameter(name));
-  }
-
-  void addBackendParameters(Element element,
-                            List<js.Parameter> parameters,
-                            Map<Element, String> parameterNames) {
-    // TODO(ngeoffray): We should infer this information from the
-    // graph, instead of recomputing what the builder did.
-    if (element.isConstructor()) {
-      // Put the type parameters.
-      ClassElement cls = element.enclosingElement;
-      if (!compiler.world.needsRti(cls)) return;
-      cls.typeVariables.forEach((TypeVariableType typeVariable) {
-        addBackendParameter(typeVariable.element, parameters, parameterNames);
-      });
-    } else if (element.isGenerativeConstructorBody()) {
-      // Put the parameter checks parameters.
-      Node node = element.implementation.parseNode(compiler);
-      ClosureClassMap closureData =
-          compiler.closureToClassMapper.getMappingForNestedFunction(node);
-      FunctionElement functionElement = element;
-      FunctionSignature params = functionElement.computeSignature(compiler);
-      TreeElements elements =
-          compiler.enqueuer.resolution.getCachedElements(element);
-      params.orderedForEachParameter((Element element) {
-        if (elements.isParameterChecked(element)) {
-          Element checkResultElement =
-              closureData.parametersWithSentinel[element];
-          addBackendParameter(checkResultElement, parameters, parameterNames);
-        }
-      });
-      // Put the box parameter.
-      ClosureScope scopeData = closureData.capturingScopes[node];
-      if (scopeData != null) {
-        addBackendParameter(scopeData.boxElement, parameters, parameterNames);
-      }
-    }
-  }
-
   CodeBuffer generateBailoutMethod(WorkItem work, HGraph graph) {
     return measure(() {
       compiler.tracer.traceGraph("codegen-bailout", graph);
 
-      Map<Element, String> parameterNames = getParameterNames(work);
-      List<js.Parameter> parameters = <js.Parameter>[];
-      parameterNames.forEach((element, name) {
-        parameters.add(new js.Parameter(name));
-      });
-      addBackendParameters(work.element, parameters, parameterNames);
-
-      SsaUnoptimizedCodeGenerator codegen = new SsaUnoptimizedCodeGenerator(
-          backend, work, parameters, parameterNames);
+      SsaUnoptimizedCodeGenerator codegen =
+          new SsaUnoptimizedCodeGenerator(backend, work);
       codegen.visitGraph(graph);
 
       js.Block body = new js.Block(<js.Statement>[]);
       if (codegen.setup != null) body.statements.add(codegen.setup);
       body.statements.add(codegen.body);
       js.Fun fun =
           buildJavaScriptFunction(work.element, codegen.newParameters, body);
       return prettyPrint(fun);
     });
   }
-
-  Map<Element, String> getParameterNames(WorkItem work) {
-    // Make sure the map preserves insertion order, so that fetching
-    // the values will keep the order of parameters.
-    Map<Element, String> parameterNames = new LinkedHashMap<Element, String>();
-    FunctionElement function = work.element.implementation;
-
-    // The dom/html libraries have inline JS code that reference
-    // parameter names directly. Long-term such code will be rejected.
-    // Now, just don't mangle the parameter name.
-    FunctionSignature signature = function.computeSignature(compiler);
-    signature.orderedForEachParameter((Element element) {
-      parameterNames[element] = function.isNative()
-          ? element.name.slowToString()
-          : JsNames.getValid('${element.name.slowToString()}');
-    });
-    return parameterNames;
-  }
 }
 
 // Stop-gap until the core classes have such a class.
 class OrderedSet<T> {
   final LinkedHashMap<T, bool> map = new LinkedHashMap<T, bool>();
 
   void add(T x) {
     if (!map.containsKey(x)) {
       map[x] = true;
     }
@@ skipping 41 matching lines @@
 
   final JavaScriptBackend backend;
   final WorkItem work;
   final HTypeMap types;
 
   final Set<HInstruction> generateAtUseSite;
   final Set<HInstruction> controlFlowOperators;
   final Map<Element, ElementAction> breakAction;
   final Map<Element, ElementAction> continueAction;
   final Map<Element, String> parameterNames;
+  final List<js.Parameter> parameters;
 
   js.Block currentContainer;
   js.Block get body => currentContainer;
   List<js.Expression> expressionStack;
   List<js.Block> oldContainerStack;
 
   /**
    * Contains the names of the instructions, as well as the parallel
    * copies to perform on block transitioning.
    */
@@ skipping 19 matching lines @@
   HGraph currentGraph;
   HBasicBlock currentBlock;
 
   // Records a block-information that is being handled specially.
   // Used to break bad recursion.
   HBlockInformation currentBlockInformation;
   // The subgraph is used to delimit traversal for some constructions, e.g.,
   // if branches.
   SubGraph subGraph;
 
-  SsaCodeGenerator(this.backend,
-                   WorkItem work,
-                   this.parameterNames)
+  SsaCodeGenerator(this.backend, WorkItem work)
     : this.work = work,
       this.types =
           (work.compilationContext as JavaScriptItemCompilationContext).types,
+      parameterNames = new LinkedHashMap<Element, String>(),
       declaredLocals = new Set<String>(),
       collectedVariableDeclarations = new OrderedSet<String>(),
       currentContainer = new js.Block.empty(),
+      parameters = <js.Parameter>[],
       expressionStack = <js.Expression>[],
       oldContainerStack = <js.Block>[],
       generateAtUseSite = new Set<HInstruction>(),
       controlFlowOperators = new Set<HInstruction>(),
       breakAction = new Map<Element, ElementAction>(),
       continueAction = new Map<Element, ElementAction>();
 
   LibraryElement get currentLibrary => work.element.getLibrary();
   Compiler get compiler => backend.compiler;
   NativeEmitter get nativeEmitter => backend.emitter.nativeEmitter;
@@ skipping 574 matching lines @@
       currentBlockInformation = info.body.start.blockFlow.body;
       generateStatements(info.body);
       currentBlockInformation = oldInfo;
     } else {
       generateStatements(info.body);
     }
   }
 
   bool visitLoopInfo(HLoopBlockInformation info) {
     HExpressionInformation condition = info.condition;
-    bool isConditionExpression = isJSCondition(condition);
+    bool isConditionExpression = condition == null || isJSCondition(condition);
 
     js.Loop loop;
 
     switch (info.kind) {
       // Treate all three "test-first" loops the same way.
       case HLoopBlockInformation.FOR_LOOP:
       case HLoopBlockInformation.WHILE_LOOP:
       case HLoopBlockInformation.FOR_IN_LOOP:
         HBlockInformation initialization = info.initializer;
         int initializationType = TYPE_STATEMENT;
@@ skipping 91 matching lines @@
             generateStatements(info.updates);
           } else {
             visitBodyIgnoreLabels(info);
           }
           currentContainer = oldContainer;
           body = unwrapStatement(body);
           loop = new js.While(jsCondition, body);
         }
         break;
       case HLoopBlockInformation.DO_WHILE_LOOP:
-        // Generate do-while loop in all cases.
+        // If there are phi copies after the condition, we cannot emit
+        // a pretty do/while loop, se we fallback to the generic
+        // emission of a loop.
+        CopyHandler handler = variableNames.getCopyHandler(info.end);
+        if (handler != null && !handler.isEmpty) return false;
         if (info.initializer != null) {
           generateStatements(info.initializer);
         }
         js.Block oldContainer = currentContainer;
         js.Statement body = new js.Block.empty();
         currentContainer = body;
         if (!isConditionExpression || info.updates != null) {
           wrapLoopBodyForContinue(info);
         } else {
           visitBodyIgnoreLabels(info);
         }
         if (info.updates != null) {
           generateStatements(info.updates);
         }
-        if (isConditionExpression) {
+        if (condition == null) {
+          push(newLiteralBool(false));
+        } else if (isConditionExpression) {
           push(generateExpression(condition));
         } else {
           generateStatements(condition);
           use(condition.conditionExpression);
         }
         js.Expression jsCondition = pop();
         currentContainer = oldContainer;
         body = unwrapStatement(body);
         loop = new js.Do(body, jsCondition);
         break;
@@ skipping 259 matching lines @@
   void iterateBasicBlock(HBasicBlock node) {
     HInstruction instruction = node.first;
     while (!identical(instruction, node.last)) {
       if (instruction is HTypeGuard || instruction is HBailoutTarget) {
         visit(instruction);
       } else if (!isGenerateAtUseSite(instruction)) {
         define(instruction);
       }
       instruction = instruction.next;
     }
-    assignPhisOfSuccessors(node);
+    if (instruction is HLoopBranch) {
+      HLoopBranch branch = instruction;
+      // If the loop is a do/while loop, the phi updates must happen
+      // after the evaluation of the condition.
+      if (!branch.isDoWhile()) {
+        assignPhisOfSuccessors(node);
+      }
+    } else {
+      assignPhisOfSuccessors(node);
+    }
     visit(instruction);
   }
 
   visitInvokeBinary(HInvokeBinary node, String op) {
     if (node.isBuiltin(types)) {
       use(node.left);
       js.Expression jsLeft = pop();
       use(node.right);
       push(new js.Binary(op, jsLeft, pop()), node);
     } else {
@@ skipping 155 matching lines @@
                       node);
       }
     } else {
       TargetElement target = node.target;
       if (!tryCallAction(continueAction, target)) {
         pushStatement(new js.Continue(null), node);
       }
     }
   }
 
+  visitExitTry(HExitTry node) {
+    // An [HExitTry] is used to represent the control flow graph of a
+    // try/catch block, ie the try body is always a predecessor
+    // of the catch and finally. Here, we continue visiting the try
+    // body by visiting the block that contains the user-level control
+    // flow instruction.
+    visitBasicBlock(node.bodyTrySuccessor);
+  }
+
   visitTry(HTry node) {
     // We should never get here. Try/catch/finally is always handled using block
     // information in [visitTryInfo], or not at all, in the case of the bailout
     // generator.
     compiler.internalError('visitTry should not be called', instruction: node);
   }
 
   bool tryControlFlowOperation(HIf node) {
     if (!controlFlowOperators.contains(node)) return false;
     HPhi phi = node.joinBlock.phis.first;
@@ skipping 387 matching lines @@
       // Otherwise, we don't generate the expression, and leave that
       // to the code that called [visitSubGraph].
       if (isGeneratingExpression) {
         use(node.inputs[0]);
       }
       return;
     }
     HBasicBlock branchBlock = currentBlock;
     handleLoopCondition(node);
     List<HBasicBlock> dominated = currentBlock.dominatedBlocks;
-    // For a do while loop, the body has already been visited.
-    if (!node.isDoWhile()) {
+    if (node.isDoWhile()) {
+      // Now that the condition has been evaluated, we can update the
+      // phis of a do/while loop.
+      assignPhisOfSuccessors(node.block);
+    } else {
+      // For a do while loop, the body has already been visited.
       visitBasicBlock(dominated[0]);
     }
     endLoop(node.block);
 
     // If the branch does not dominate the code after the loop, the
     // dominator will visit it.
     if (!identical(branchBlock.successors[1].dominator, branchBlock)) return;
 
     visitBasicBlock(branchBlock.successors[1]);
     // With labeled breaks we can have more dominated blocks.
@@ skipping 685 matching lines @@
       }
       String helperName = backend.namer.isolateAccess(helperElement);
       push(new js.Call(new js.VariableUse(helperName), arguments));
     } else {
       use(node.checkedInput);
     }
   }
 }
 
 class SsaOptimizedCodeGenerator extends SsaCodeGenerator {
-  SsaOptimizedCodeGenerator(backend, work, parameters, parameterNames)
-    : super(backend, work, parameterNames) {
+  SsaOptimizedCodeGenerator(backend, work) : super(backend, work);
+
+  int maxBailoutParameters;
+
+  HBasicBlock beginGraph(HGraph graph) {
     // Declare the parameter names only for the optimized version. The
     // unoptimized version has different parameters.
     parameterNames.forEach((Element element, String name) {
+      parameters.add(new js.Parameter(name));
       declaredLocals.add(name);
     });
+    return graph.entry;
   }
 
-  int maxBailoutParameters;
-
-  HBasicBlock beginGraph(HGraph graph) => graph.entry;
   void endGraph(HGraph graph) {}
 
   js.Statement bailout(HTypeGuard guard, String reason) {
     if (maxBailoutParameters == null) {
       maxBailoutParameters = 0;
       work.guards.forEach((HTypeGuard workGuard) {
         HBailoutTarget target = workGuard.bailoutTarget;
         int inputLength = target.inputs.length;
         if (inputLength > maxBailoutParameters) {
           maxBailoutParameters = inputLength;
@@ skipping 124 matching lines @@
     oldContainerStack.add(currentContainer);
     currentContainer = new js.Block.empty();
   }
 
   void endLoop(HBasicBlock block) {
     js.Statement body = currentContainer;
     currentContainer = oldContainerStack.removeLast();
     body = unwrapStatement(body);
     js.While loop = new js.While(newLiteralBool(true), body);
 
-    HLoopInformation info = block.loopInformation;
+    HBasicBlock header = block.isLoopHeader() ? block : block.parentLoopHeader;
+    HLoopInformation info = header.loopInformation;
     attachLocationRange(loop,
                         info.loopBlockInformation.sourcePosition,
                         info.loopBlockInformation.endSourcePosition);
     pushStatement(wrapIntoLabels(loop, info.labels));
   }
 
   void handleLoopCondition(HLoopBranch node) {
     use(node.inputs[0]);
-    pushStatement(new js.If.noElse(pop(), new js.Break(null)), node);
+    js.Expression test = new js.Prefix('!', pop());
+    js.Statement then = new js.Break(null);
+    pushStatement(new js.If.noElse(test, then), node);
   }
 
 
   void preLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
   }
 
   void startLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
@@ skipping 11 matching lines @@
   /**
    * Keeps track if a bailout switch already used its [:default::] clause. New
    * bailout-switches just push [:false:] on the stack and replace it when
    * they used the [:default::] clause.
    */
   final List<bool> defaultClauseUsedInBailoutStack;
 
   SsaBailoutPropagator propagator;
   HInstruction savedFirstInstruction;
 
-  SsaUnoptimizedCodeGenerator(backend, work, parameters, parameterNames)
-    : super(backend, work, parameterNames),
+  SsaUnoptimizedCodeGenerator(backend, work)
+    : super(backend, work),
       oldBailoutSwitches = <js.Switch>[],
       newParameters = <js.Parameter>[],
       labels = <String>[],
       defaultClauseUsedInBailoutStack = <bool>[];
 
   String pushLabel() {
     String label = 'L${labelId++}';
     labels.addLast(label);
     return label;
   }
@@ skipping 307 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }