[hydrogen] optimize switch with string clauses

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 2672 matching lines @@
   int clause_count = clauses->length();
   if (clause_count > kCaseClauseLimit) {
     return Bailout("SwitchStatement: too many clauses");
   }
 
   CHECK_ALIVE(VisitForValue(stmt->tag()));
   AddSimulate(stmt->EntryId());
   HValue* tag_value = Pop();
   HBasicBlock* first_test_block = current_block();
 
+  enum {

[Vyacheslav Egorov (Chromium), 2011/10/24 10:56:26]

We don't use anonymous enums

+    none, smi, string

[Vyacheslav Egorov (Chromium), 2011/10/24 10:56:26]

use either 

kSmiSwitch

or 

SMI_SWITCH

naming for enum-members.

+  } clause_type = none;
+
   // 1. Build all the tests, with dangling true branches.  Unconditionally
   // deoptimize if we encounter a non-smi comparison.
   for (int i = 0; i < clause_count; ++i) {
     CaseClause* clause = clauses->at(i);
     if (clause->is_default()) continue;
-    if (!clause->label()->IsSmiLiteral()) {
-      return Bailout("SwitchStatement: non-literal switch label");
+
+    if (clause_type == none) {

[Vyacheslav Egorov (Chromium), 2011/10/24 10:56:26]

I would suggest extracting loop part that computes switch type into a separate
method just to make it cleaner.

+      if (clause->label()->IsSmiLiteral()) {
+        clause_type = smi;
+      } else if (clause->label()->IsStringLiteral()) {
+        clause_type = string;
+      } else {
+        return Bailout("SwitchStatement: non-literal switch label");
+      }
+    } else if (clause->label()->IsSmiLiteral() && clause_type == string ||

[Vyacheslav Egorov (Chromium), 2011/10/24 10:56:26]

clause can be neither smi nor string literal.

I think what you want here is 

(clause_type == kSmiSwitch && !clause->label()->IsSmiLiteral()) || ...

+               clause->label()->IsStringLiteral() && clause_type == smi) {
+      return Bailout("SwitchStatemnt: mixed label types are not supported");
     }
 
-    // Unconditionally deoptimize on the first non-smi compare.
     clause->RecordTypeFeedback(oracle());
-    if (!clause->IsSmiCompare()) {
-      // Finish with deoptimize and add uses of enviroment values to
-      // account for invisible uses.
-      current_block()->FinishExitWithDeoptimization(HDeoptimize::kUseAll);
-      set_current_block(NULL);
-      break;
+
+    // Generate a compare and branch.
+    CHECK_ALIVE(VisitForValue(clause->label()));
+    HValue* label_value = Pop();
+
+    HBasicBlock* next_test_block = graph()->CreateBasicBlock();
+    HBasicBlock* body_block = graph()->CreateBasicBlock();
+
+    HControlInstruction* compare;
+
+    if (clause_type == smi) {
+      if (!clause->IsSmiCompare()) {
+        // Finish with deoptimize and add uses of enviroment values to
+        // account for invisible uses.
+        current_block()->FinishExitWithDeoptimization(HDeoptimize::kUseAll);
+        set_current_block(NULL);
+        break;
+      }
+
+      HCompareIDAndBranch* compare_ =
+          new(zone()) HCompareIDAndBranch(tag_value,
+                                          label_value,
+                                          Token::EQ_STRICT);
+      compare_->SetInputRepresentation(Representation::Integer32());
+      compare = reinterpret_cast<HControlInstruction*>(compare_);

[Vyacheslav Egorov (Chromium), 2011/10/24 10:56:26]

I don't think you need reinterpret_cast here.

HCompareObjectEqAndBranch* should be assignable to HControlInstruction.

+    } else {
+      HCompareObjectEqAndBranch* compare_ =

[Vyacheslav Egorov (Chromium), 2011/10/24 10:56:26]

I think you don't need this temp variable

+          new(zone()) HCompareObjectEqAndBranch(tag_value, label_value);

[Vyacheslav Egorov (Chromium), 2011/10/24 10:56:26]

Why not CompareIDAndBranch? Once loop that computes type is extracted you can
use computed type to emit is-symbol test before the switch.

+      compare = reinterpret_cast<HControlInstruction*>(compare_);

[Vyacheslav Egorov (Chromium), 2011/10/24 10:56:26]

I don't think you need reinterpret_cast here.

HCompareObjectEqAndBranch* should be assignable to HControlInstruction.

     }
 
-    // Otherwise generate a compare and branch.
-    CHECK_ALIVE(VisitForValue(clause->label()));
-    HValue* label_value = Pop();
-    HCompareIDAndBranch* compare =
-        new(zone()) HCompareIDAndBranch(tag_value,
-                                        label_value,
-                                        Token::EQ_STRICT);
-    compare->SetInputRepresentation(Representation::Integer32());
-    HBasicBlock* body_block = graph()->CreateBasicBlock();
-    HBasicBlock* next_test_block = graph()->CreateBasicBlock();
     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();
 
   // 2. Loop over the clauses and the linked list of tests in lockstep,
   // translating the clause bodies.
   HBasicBlock* curr_test_block = first_test_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