Validate that all instructions dominate their inputs. And fix a bug where that did not happen.

lib/compiler/implementation/ssa/builder.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 Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 394 matching lines @@
       // accessed through a closure-field.
       // Calling [readLocal] makes sure we generate the correct code to get
       // the box.
       assert(redirect.enclosingElement.kind == ElementKind.VARIABLE);
       HInstruction box = readLocal(redirect.enclosingElement);
       HInstruction lookup = new HFieldGet(redirect.name, box);
       builder.add(lookup);
       return lookup;
     } else {
       assert(isUsedInTry(element));
-      HParameterValue parameter = getActivationParameter(element);
-      HInstruction variable = new HFieldGet.fromActivation(parameter);
+      HInstruction instruction = getActivationValue(element);
+      HInstruction variable = new HFieldGet.fromActivation(instruction);
       builder.add(variable);
       return variable;
     }
   }
 
   HType cachedTypeOfThis;
 
   HInstruction readThis() {
     HInstruction res = readLocal(closureData.thisElement);
     if (res.guaranteedType === null) {
       if (cachedTypeOfThis === null) {
         assert(closureData.isClosure());
         Element element = closureData.thisElement;
         ClassElement cls = element.enclosingElement.enclosingElement;
         Type type = cls.computeType(builder.compiler);
         cachedTypeOfThis = new HBoundedType(type);
       }
       res.guaranteedType = cachedTypeOfThis;
     }
     return res;
   }
 
-  HParameterValue getActivationParameter(Element element) {
-    if (element.isParameter()) {
-      HInstruction instruction = directLocals[element];
-      if (instruction is HParameterValue) return instruction;
-    }
+  HInstruction getActivationValue(Element element) {
+    if (element.isParameter()) return directLocals[element];

[floitsch, 2012/05/29 18:31:38]

Please add comment what is happening here.

[ngeoffray, 2012/05/30 08:31:45]

Done.

 
     return builder.activationVariables.putIfAbsent(element, () {
       HParameterValue parameter = new HParameterValue(element);
       builder.graph.entry.addAtExit(parameter);
       return parameter;
     });
   }
 
   /**
    * Sets the [element] to [value]. If the element is boxed or stored in a
@@ skipping 14 matching lines @@
       Element redirect = redirectionMapping[element];
       // The box itself could be captured, or be local. A local variable that
       // is captured will be boxed, but the box itself will be a local.
       // Inside the closure the box is stored in a closure-field and cannot
       // be accessed directly.
       assert(redirect.enclosingElement.kind == ElementKind.VARIABLE);
       HInstruction box = readLocal(redirect.enclosingElement);
       builder.add(new HFieldSet(redirect.name, box, value));
     } else {
       assert(isUsedInTry(element));
-      HParameterValue parameter = getActivationParameter(element);
-      builder.add(new HFieldSet.fromActivation(parameter, value));
+      HInstruction instruction = getActivationValue(element);
+      builder.add(new HFieldSet.fromActivation(instruction, value));
     }
   }
 
   /**
    * This function must be called before visiting any children of the loop. In
    * particular it needs to be called before executing the initializers.
    *
    * The [LocalsHandler] will make the boxes and updates at the right moment.
    * The builder just needs to call [enterLoopBody] and [enterLoopUpdates] (for
    * [For] loops) at the correct places. For phi-handling [beginLoopHeader] and
@@ skipping 2621 matching lines @@
   visitSwitchCase(SwitchCase node) {
     compiler.internalError('SsaBuilder.visitSwitchCase');
   }
 
   visitCaseMatch(CaseMatch node) {
     compiler.internalError('SsaBuilder.visitCaseMatch');
   }
 
   visitTryStatement(TryStatement node) {
     work.allowSpeculativeOptimization = false;
+    // Save the current locals. The catch block, the finally block, and
+    // the merge block need to use this state of the locals.
+    LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
+
     HBasicBlock enterBlock = openNewBlock();
     HTry tryInstruction = new HTry();
     List<HBasicBlock> blocks = <HBasicBlock>[];
     blocks.add(close(tryInstruction));
 
     HBasicBlock tryBody = graph.addNewBlock();
     enterBlock.addSuccessor(tryBody);
     open(tryBody);
     visit(node.tryBlock);
     if (!isAborted()) blocks.add(close(new HGoto()));
     SubGraph bodyGraph = new SubGraph(tryBody, lastOpenedBlock);
     SubGraph catchGraph = null;
     HParameterValue exception = null;
     if (!node.catchBlocks.isEmpty()) {
+      localsHandler = new LocalsHandler.from(savedLocals);

[floitsch, 2012/05/29 18:31:38]

Add comment:
The catch block must not reuse the existing LocalsHandler. None of the variables
that have been defined in the body-block will be used, but for loops we will add
(unnecessary) phis that will reference the body variables. This will make it
look as if the variables were used in a non-dominated block.

[ngeoffray, 2012/05/30 08:31:45]

Done.

       HBasicBlock block = graph.addNewBlock();
       enterBlock.addSuccessor(block);
       open(block);
       // Note that the name of this element is irrelevant.
       Element element = new Element(
           const SourceString('exception'), ElementKind.PARAMETER, work.element);
       exception = new HParameterValue(element);
       add(exception);
       HInstruction oldRethrowableException = rethrowableException;
       rethrowableException = exception;
@@ skipping 47 matching lines @@
                    visitThen, visitElse);
         }
       }
 
       CatchBlock firstBlock = link.head;
       handleIf(() { pushCondition(firstBlock); }, visitThen, visitElse);
       if (!isAborted()) blocks.add(close(new HGoto()));
 
       rethrowableException = oldRethrowableException;
       catchGraph = new SubGraph(block, lastOpenedBlock);
+      tryInstruction.catchBlock = block;
     }
 
     SubGraph finallyGraph = null;
     if (node.finallyBlock != null) {
+      localsHandler = new LocalsHandler.from(savedLocals);
       HBasicBlock finallyBlock = graph.addNewBlock();
       enterBlock.addSuccessor(finallyBlock);
       open(finallyBlock);
       visit(node.finallyBlock);
       if (!isAborted()) blocks.add(close(new HGoto()));
       tryInstruction.finallyBlock = finallyBlock;
       finallyGraph = new SubGraph(finallyBlock, lastOpenedBlock);
     }
 
     HBasicBlock exitBlock = graph.addNewBlock();
 
     for (HBasicBlock block in blocks) {
       block.addSuccessor(exitBlock);
     }
 
     open(exitBlock);
+    localsHandler = savedLocals;
+
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
           wrapStatementGraph(bodyGraph),
           exception,
           wrapStatementGraph(catchGraph),
           wrapStatementGraph(finallyGraph)),
         exitBlock);
   }
 
   visitScriptTag(ScriptTag node) {
@@ skipping 157 matching lines @@
                                    <HInstruction>[target, input],
                                    HType.STRING));
     return builder.pop();
   }
 
   HInstruction result(Node node) {
     flushLiterals(node);
     return prefix;
   }
 }