Generate code for some switch statements.

dart/frog/leg/ssa/builder.dart

Index: dart/frog/leg/ssa/builder.dart
diff --git a/dart/frog/leg/ssa/builder.dart b/dart/frog/leg/ssa/builder.dart
index c75d86b755013ebb3f999eddf7680a956565e96c..ef263dec1cb9d53d47f8d9a61877ef069a9d7457 100644
--- a/dart/frog/leg/ssa/builder.dart
+++ b/dart/frog/leg/ssa/builder.dart
@@ -452,7 +452,7 @@ class LocalsHandler {
    *    goto loop-entry;
    *  loop-exit:
    */
-  void startLoop(Loop node) {
+  void startLoop(Node node) {
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData == null) return;
     if (scopeData.hasBoxedLoopVariables()) {
@@ -1957,7 +1957,11 @@ class SsaBuilder implements Visitor {
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
-      visit(link.head);
+      if (isAborted()) {
+        compiler.reportWarning(link.head, 'dead code');
+      } else {
+        visit(link.head);
+      }
     }
   }
 
@@ -2281,7 +2285,62 @@ class SsaBuilder implements Visitor {
   }
 
   visitSwitchStatement(SwitchStatement node) {
-    generateUnimplemented('switch statement not implemented');
+    work.allowSpeculativeOptimization = false;
+    visit(node.expression);
+    HInstruction expression = pop();
+    Link cases = node.cases.nodes;

[ngeoffray, 2012/03/06 11:49:48]

Link -> Link<Node> ?

[ahe, 2012/03/06 12:24:35]

Done.

+    int count = 0;
+    handleThen() {
+      if (cases.head.statements.nodes.isEmpty()) {
+        compiler.unimplemented('fall-through', node: cases.head);
+      }
+      visit(cases.head.statements);
+      cases = cases.tail;
+    }
+    handleElse() {
+      if (cases.isEmpty()) return;
+      if (cases.head is DefaultCase) {

[ngeoffray, 2012/03/06 11:49:48]

is DefaultCase -> asDefaultCase() != null

[ahe, 2012/03/06 12:24:35]

Done.

+        stack.add(graph.addNewLiteralBool(true));
+        if (!cases.tail.isEmpty()) {
+          compiler.unimplemented('default case not last', node: cases.head);
+        }
+      } else {
+        SwitchCase switchCase = cases.head;
+        visit(switchCase.expression);
+        HInstruction caseExpression = pop();
+        Element equalsHelper = compiler.findHelper(const SourceString('eq'));

[ngeoffray, 2012/03/06 11:49:48]

maybe make that a method in the Interceptors class to make it consistent with
other uses of findHelper?

[ahe, 2012/03/06 12:24:35]

Done.

+        HInstruction target = new HStatic(equalsHelper);
+        add(target);
+        push(new HEquals(target, caseExpression, expression));
+      }
+      handleIf(handleThen, handleElse);
+    }
+
+    localsHandler.startLoop(node);
+    BreakHandler breakHandler = beginLoopHeader(node);
+    HBasicBlock loopEntryBlock = current;
+    localsHandler.enterLoopBody(node);
+
+    handleElse();
+
+    if (isAborted()) {
+      compiler.unimplemented("SsaBuilder for loop with aborting body",

[ngeoffray, 2012/03/06 11:49:48]

Err, not really :)

[ahe, 2012/03/06 12:24:35]

Yes. Really. That is the problem.

[ngeoffray, 2012/03/06 12:32:55]

In 'for loop' I read 'for' as in 'for (;;) {}' :) I think that was the intent of
this message initially but may have been copied without being updated.

[Lasse Reichstein Nielsen, 2012/03/06 12:53:50]

I don't read it as that, but it's still a confusing message for a program with
no loops in it. The loop here is purely synthetic and wasn't in the original
source.
We should probably use a switch statement instead when possible. It also avoids
binding any label-less continues.

[ahe, 2012/03/06 13:10:51]

I understand that the loop is purely synthetic and the error message is
confusing. However, this problem is the same as in all our loops: we cannot deal
with aborting bodies.

I have no clue how to fix that, but I would welcome suggestions. I think this
needs to be implemented ASAP.
Please read my previous comment. I need the loop.

Presumably, the label-less continues will have been bound by the resolver.
Otherwise, it is a bug in the resolver.

[Lasse Reichstein Nielsen, 2012/03/06 13:23:36]

I think that, in the long run, we should have different strategies for different
levels of complexity of switch statements. If there is no continue statements or
only continue as fall-through to the next case, we don't need a loop. If we have
more general continues, we will need a loop (I prefer an implementation with two
switches, the second using only ints as albels being inside a loop).

I would prefer to wait wtih introducing a loop until we're ready to handle the
continues anyway (pure premature-optimization avoidance).


We also definitely need to handle aborting bodies of loops (and try-blocks and
labeled statement blocks and ....). The big question is how much it will
complicate everything else (dominator traversal can get funny when the only exit
from a loop is a break - but switching to subgraph traversal of bodies might
help).

+                             node: node);
+    }
+
+    HBasicBlock bodyExitBlock = close(new HGoto());
+    HBasicBlock conditionBlock = addNewBlock();
+    bodyExitBlock.addSuccessor(conditionBlock);
+    open(conditionBlock);
+    stack.add(graph.addNewLiteralBool(false));
+
+    conditionBlock = close(new HLoopBranch(popBoolified(),
+                                           HLoopBranch.DO_WHILE_LOOP));
+
+    conditionBlock.addSuccessor(loopEntryBlock);  // The back-edge.
+    loopEntryBlock.postProcessLoopHeader();
+
+    endLoop(loopEntryBlock, conditionBlock, breakHandler);
   }
 
   visitTryStatement(TryStatement node) {