Optimize switch statements (second pass)

src/hydrogen.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2724 matching lines @@
                 !clause->label()->IsStringLiteral()) ||
                (switch_type == SMI_SWITCH &&
                 !clause->label()->IsSmiLiteral())) {
       return Bailout("SwitchStatemnt: mixed label types are not supported");
     }
   }
 
   HUnaryControlInstruction* string_check = NULL;
   HBasicBlock* not_string_block = NULL;
 
+  int iterations = clause_count;
+
   // Test switch's tag value if all clauses are string literals
   if (switch_type == STRING_SWITCH) {
+    // Bailout if we seen string(non-symbol) comparisons here
+    for (int i = 0; i < clause_count; ++i) {
+      CaseClause* clause = clauses->at(i);
+      if (clause->is_default()) continue;
+
+      clause->RecordTypeFeedback(oracle());
+
+      if (clause->IsStringCompare()) {
+        return Bailout("SwitchStatement: no symbol comparisons expected");
+      }
+    }
+
+    // We'll generate two passes of checks
+    iterations = iterations * 2;
+
     string_check = new(zone()) HIsStringAndBranch(tag_value);
     first_test_block = graph()->CreateBasicBlock();
     not_string_block = graph()->CreateBasicBlock();
 
     string_check->SetSuccessorAt(0, first_test_block);
     string_check->SetSuccessorAt(1, not_string_block);
     current_block()->Finish(string_check);
 
     set_current_block(first_test_block);
   }
 
   // 2. Build all the tests, with dangling true branches
-  for (int i = 0; i < clause_count; ++i) {
-    CaseClause* clause = clauses->at(i);
+  for (int i = 0; i < iterations; ++i) {
+    CaseClause* clause = clauses->at(i % clause_count);
     if (clause->is_default()) continue;
 
     if (switch_type == SMI_SWITCH) {
       clause->RecordTypeFeedback(oracle());
     }
 
     // Generate a compare and branch.
     CHECK_ALIVE(VisitForValue(clause->label()));
     HValue* label_value = Pop();
 
@@ skipping 11 matching lines @@
         break;
       }
 
       HCompareIDAndBranch* compare_ =
           new(zone()) HCompareIDAndBranch(tag_value,
                                           label_value,
                                           Token::EQ_STRICT);
       compare_->SetInputRepresentation(Representation::Integer32());
       compare = compare_;
     } else {
-      compare = new(zone()) HStringCompareAndBranch(context, tag_value,
-                                                     label_value,
-                                                     Token::EQ_STRICT);
+      if (i < clause_count) {
+        compare = new(zone()) HCompareObjectEqAndBranch(tag_value, label_value);
+      } else {
+        compare = new(zone()) HStringCompareAndBranch(context, tag_value,
+                                                       label_value,
+                                                       Token::EQ_STRICT);
+      }
     }
 
     compare->SetSuccessorAt(0, body_block);
     compare->SetSuccessorAt(1, next_test_block);
     current_block()->Finish(compare);
 
     set_current_block(next_test_block);
   }
 
   // Save the current block to use for the default or to join with the
   // exit.  This block is NULL if we deoptimized.
   HBasicBlock* last_block = current_block();
 
   if (not_string_block != NULL) {
     last_block = CreateJoin(last_block, not_string_block, stmt->ExitId());
   }
 
   // 3. Loop over the clauses and the linked list of tests in lockstep,
   // translating the clause bodies.
   HBasicBlock* curr_test_block = first_test_block;
   HBasicBlock* fall_through_block = NULL;
+  HBasicBlock* fall_through_block_left = NULL;
 
   BreakAndContinueInfo break_info(stmt);
   { BreakAndContinueScope push(&break_info, this);
-    for (int i = 0; i < clause_count; ++i) {
-      CaseClause* clause = clauses->at(i);
+    for (int i = 0; i < iterations; ++i) {
+      // Create shadow last block for second pass
+      if (i == clause_count) {
+        fall_through_block_left = fall_through_block;
+        fall_through_block = NULL;
+      }
+
+      CaseClause* clause = clauses->at(i % clause_count);
 
       // Identify the block where normal (non-fall-through) control flow
       // goes to.
       HBasicBlock* normal_block = NULL;
       if (clause->is_default()) {
         if (last_block != NULL) {
           normal_block = last_block;
           last_block = NULL;  // Cleared to indicate we've handled it.
         }
       } else if (!curr_test_block->end()->IsDeoptimize()) {
@@ skipping 18 matching lines @@
         // (c) Reachable only normally.
         set_current_block(normal_block);
       } else {
         // (d) Reachable both ways.
         HBasicBlock* join = CreateJoin(fall_through_block,
                                        normal_block,
                                        clause->EntryId());
         set_current_block(join);
       }
 
       CHECK_BAILOUT(VisitStatements(clause->statements()));

[fschneider, 2011/11/23 15:12:47]

I think duplicating all clause bodies increases code size too much. There should
be only one body per clause.

       fall_through_block = current_block();
     }
   }
 
+  // Join tails of parallel branches
+  fall_through_block = CreateJoin(fall_through_block, fall_through_block_left,
+                                  stmt->ExitId());
+
   // Create an up-to-3-way join.  Use the break block if it exists since
   // it's already a join block.
   HBasicBlock* break_block = break_info.break_block();
   if (break_block == NULL) {
     set_current_block(CreateJoin(fall_through_block,
                                  last_block,
                                  stmt->ExitId()));
   } else {
     if (fall_through_block != NULL) fall_through_block->Goto(break_block);
     if (last_block != NULL) last_block->Goto(break_block);
@@ skipping 4278 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal