Experimental: begin using the register allocator for switch statements...

src/codegen-ia32.cc

 // Copyright 2006-2008 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 1706 matching lines @@
     Vector<JumpTarget*> case_targets,
     Vector<JumpTarget> case_labels) {
   // Notice: Internal references, used by both the jmp instruction and
   // the table entries, need to be relocated if the buffer grows. This
   // prevents the forward use of Labels, since a displacement cannot
   // survive relocation, and it also cannot safely be distinguished
   // from a real address.  Instead we put in zero-values as
   // placeholders, and fill in the addresses after the labels have been
   // bound.
 
+  VirtualFrame::SpilledScope spilled_scope(this);
   frame_->EmitPop(eax);  // supposed Smi
   // check range of value, if outside [0..length-1] jump to default/end label.
   ASSERT(kSmiTagSize == 1 && kSmiTag == 0);
 
   // Test whether input is a HeapNumber that is really a Smi
   JumpTarget is_smi(this);
   __ test(eax, Immediate(kSmiTagMask));
   is_smi.Branch(equal);
   // It's a heap object, not a Smi or a Failure
   __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
   __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
   __ cmp(ebx, HEAP_NUMBER_TYPE);
   fail_label->Branch(not_equal);
   // eax points to a heap number.
-  __ push(eax);
-  __ CallRuntime(Runtime::kNumberToSmi, 1);
+  frame_->EmitPush(eax);
+  frame_->CallRuntime(Runtime::kNumberToSmi, 1);
   is_smi.Bind();
 
   if (min_index != 0) {
     __ sub(Operand(eax), Immediate(min_index << kSmiTagSize));
   }
   __ test(eax, Immediate(0x80000000 | kSmiTagMask));  // negative or not Smi
   fail_label->Branch(not_equal, not_taken);
   __ cmp(eax, range << kSmiTagSize);
   fail_label->Branch(greater_equal, not_taken);
 
@@ skipping 17 matching lines @@
   for (int i = 0, entry_pos = table_start.label()->pos();
        i < range;
        i++, entry_pos += sizeof(uint32_t)) {
     __ WriteInternalReference(entry_pos, *case_targets[i]->label());
   }
 }
 
 
 void CodeGenerator::VisitSwitchStatement(SwitchStatement* node) {
   ASSERT(!in_spilled_code());
-  VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ SwitchStatement");
   CodeForStatement(node);
   node->set_break_stack_height(break_stack_height_);
   node->break_target()->set_code_generator(this);
 
-  LoadAndSpill(node->tag());
+  Load(node->tag());
 
   if (TryGenerateFastCaseSwitchStatement(node)) {
     return;
   }
 
   JumpTarget next_test(this);
   JumpTarget fall_through(this);
   JumpTarget default_entry(this);
   JumpTarget default_exit(this);
   ZoneList<CaseClause*>* cases = node->cases();
   int length = cases->length();
   CaseClause* default_clause = NULL;
 
   for (int i = 0; i < length; i++) {
     CaseClause* clause = cases->at(i);
     if (clause->is_default()) {
       // Remember the default clause and compile it at the end.
       default_clause = clause;
       continue;
     }
 
+    // Compile each non-default clause.
     Comment cmnt(masm_, "[ Case clause");
-    // Compile the test.
-    next_test.Bind();
-    next_test.Unuse();
-    // Duplicate TOS.
-    __ mov(eax, frame_->Top());
-    frame_->EmitPush(eax);
-    LoadAndSpill(clause->label());
+    // Label and compile the test.
+    if (next_test.is_linked()) {
+      // Recycle the same label for each test.
+      next_test.Bind();
+      next_test.Unuse();
+    }
+    // Duplicate the switch value.
+    frame_->Dup();
+    Load(clause->label());
     Comparison(equal, true);
     Branch(false, &next_test);
 
-    // Before entering the body from the test, remove the switch value from
-    // the stack.
+    // Before entering the body from the test remove the switch value from
+    // the frame.

[William Hesse, 2009/01/06 13:37:02]

How about 
// Drop the switch value from the frame before entering the case body.

[Kevin Millikin (Chromium), 2009/01/06 14:18:47]

I want the comment to indicate that it only happens when entering from the test.
 I'll leave it for now, because it seems concise and accurate.

     frame_->Drop();
 
     // Label the body so that fall through is enabled.
     if (i > 0 && cases->at(i - 1)->is_default()) {
+      // The previous case was the default.  This will be the target of a
+      // possible backward edge.
       default_exit.Bind();
-    } else {
+    } else if (fall_through.is_linked()) {
+      // Recycle the same label for each fall through except for the default
+      // case.
       fall_through.Bind();
       fall_through.Unuse();
     }
-    VisitStatementsAndSpill(clause->statements());
+    VisitStatements(clause->statements());
 
-    // If control flow can fall through from the body, jump to the next body
+    // If control flow can fall through from the body jump to the next body
     // or the end of the statement.
     if (has_valid_frame()) {
       if (i < length - 1 && cases->at(i + 1)->is_default()) {
+        // The next case is the default.
         default_entry.Jump();
       } else {
         fall_through.Jump();
       }
     }
   }
 
-  // The final "test" removes the switch value.
+  // The block at the final "test" label removes the switch value.
   next_test.Bind();
   frame_->Drop();
 
-  // If there is a default clause, compile it.
+  // If there is a default clause, compile it now.
   if (default_clause != NULL) {
     Comment cmnt(masm_, "[ Default clause");
     default_entry.Bind();
-    VisitStatementsAndSpill(default_clause->statements());
+    VisitStatements(default_clause->statements());
     // If control flow can fall out of the default and there is a case after
     // it, jump to that case's body.
     if (has_valid_frame() && default_exit.is_bound()) {
       default_exit.Jump();
     }
   }
 
   if (fall_through.is_linked()) {
     fall_through.Bind();
   }
@@ skipping 3937 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal