Simplify the way the code generator handles calls to IC stubs. Before...

src/codegen-ia32.cc

 // Copyright 2006-2009 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 3217 matching lines @@
     __ mov(tmp.reg(), ContextOperand(tmp.reg(), Context::CLOSURE_INDEX));
     __ mov(tmp.reg(), FieldOperand(tmp.reg(), JSFunction::kContextOffset));
     __ jmp(&next);
     __ bind(&fast);
   }
   context.Unuse();
   tmp.Unuse();
 
   // All extension objects were empty and it is safe to use a global
   // load IC call.
-  Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
-  // Load the global object.
   LoadGlobal();
-  // Setup the name register.  All non-reserved registers are available.
-  Result name = allocator_->Allocate(ecx);
-  ASSERT(name.is_valid());
-  __ mov(name.reg(), slot->var()->name());
-  RelocInfo::Mode rmode = (typeof_state == INSIDE_TYPEOF)
-                        ? RelocInfo::CODE_TARGET
-                        : RelocInfo::CODE_TARGET_CONTEXT;
-  Result answer = frame_->CallCodeObject(ic, rmode, &name, 0);
+  frame_->Push(slot->var()->name());
+  RelocInfo::Mode mode = (typeof_state == INSIDE_TYPEOF)
+                         ? RelocInfo::CODE_TARGET
+                         : RelocInfo::CODE_TARGET_CONTEXT;
+  Result answer = frame_->CallLoadIC(mode);
 
   // Discard the global object. The result is in answer.
   frame_->Drop();
   return answer;
 }
 
 
 void CodeGenerator::StoreToSlot(Slot* slot, InitState init_state) {
   if (slot->type() == Slot::LOOKUP) {
     ASSERT(slot->var()->is_dynamic());
@@ skipping 286 matching lines @@
   for (int i = 0; i < node->properties()->length(); i++) {
     ObjectLiteral::Property* property = node->properties()->at(i);
     switch (property->kind()) {
       case ObjectLiteral::Property::CONSTANT:
         break;
       case ObjectLiteral::Property::MATERIALIZED_LITERAL:
         if (CompileTimeValue::IsCompileTimeValue(property->value())) break;
         // else fall through.
       case ObjectLiteral::Property::COMPUTED: {
         Handle<Object> key(property->key()->handle());
-        Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
         if (key->IsSymbol()) {
           // Duplicate the object as the IC receiver.
           frame_->Dup();
           Load(property->value());
-          Result value = frame_->Pop();
-          value.ToRegister(eax);
-
-          Result name = allocator_->Allocate(ecx);
-          ASSERT(name.is_valid());
-          __ Set(name.reg(), Immediate(key));
-          Result ignored =
-              frame_->CallCodeObject(ic, RelocInfo::CODE_TARGET,
-                                     &value, &name, 0);
+          frame_->Push(key);
+          Result ignored = frame_->CallStoreIC();
           // Drop the duplicated receiver and ignore the result.
           frame_->Drop();
           break;
         }
         // Fall through
       }
       case ObjectLiteral::Property::PROTOTYPE: {
         // Duplicate the object as an argument to the runtime call.
         frame_->Dup();
         Load(property->key());
@@ skipping 1601 matching lines @@
   Label* patch_site() { return &patch_site_; }
 
  private:
   Label patch_site_;
   bool is_global_;
 };
 
 
 void DeferredReferenceGetKeyedValue::Generate() {
   CodeGenerator* cgen = generator();
-  Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
   Result receiver(cgen);
   Result key(cgen);
   enter()->Bind(&receiver, &key);
   cgen->frame()->Push(&receiver);  // First IC argument.
   cgen->frame()->Push(&key);       // Second IC argument.
 
   // Calculate the delta from the IC call instruction to the map check
   // cmp instruction in the inlined version.  This delta is stored in
   // a test(eax, delta) instruction after the call so that we can find
   // it in the IC initialization code and patch the cmp instruction.
   // This means that we cannot allow test instructions after calls to
   // KeyedLoadIC stubs in other places.
-  Result value(cgen);
-  if (is_global_) {
-    value = cgen->frame()->CallCodeObject(ic,
-                                          RelocInfo::CODE_TARGET_CONTEXT,
-                                          0);
-  } else {
-    value = cgen->frame()->CallCodeObject(ic, RelocInfo::CODE_TARGET, 0);
-  }
+  RelocInfo::Mode mode = is_global_
+                         ? RelocInfo::CODE_TARGET_CONTEXT

[Kasper Lund, 2009/03/25 13:25:34]

4 space indent here?

+                         : RelocInfo::CODE_TARGET;
+  Result value = cgen->frame()->CallKeyedLoadIC(mode);
   // The result needs to be specifically the eax register because the
   // offset to the patch site will be expected in a test eax
   // instruction.
   ASSERT(value.is_register() && value.reg().is(eax));
   // The delta from the start of the map-compare instruction to the
   // test eax instruction.
   int delta_to_patch_site = __ SizeOfCodeGeneratedSince(patch_site());
   __ test(value.reg(), Immediate(-delta_to_patch_site));
   __ IncrementCounter(&Counters::keyed_load_inline_miss, 1);
 
@@ skipping 41 matching lines @@
       break;
     }
 
     case NAMED: {
       // TODO(1241834): Make sure that it is safe to ignore the
       // distinction between expressions in a typeof and not in a
       // typeof. If there is a chance that reference errors can be
       // thrown below, we must distinguish between the two kinds of
       // loads (typeof expression loads must not throw a reference
       // error).
-      VirtualFrame* frame = cgen_->frame();
       Comment cmnt(masm, "[ Load from named Property");
-      Handle<String> name(GetName());
+      cgen_->frame()->Push(GetName());
+
       Variable* var = expression_->AsVariableProxy()->AsVariable();
-      Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
-      // Setup the name register.
-      Result name_reg = cgen_->allocator()->Allocate(ecx);
-      ASSERT(name_reg.is_valid());
-      __ mov(name_reg.reg(), name);
       ASSERT(var == NULL || var->is_global());
-      RelocInfo::Mode rmode = (var == NULL)
-                            ? RelocInfo::CODE_TARGET
-                            : RelocInfo::CODE_TARGET_CONTEXT;
-      Result answer = frame->CallCodeObject(ic, rmode, &name_reg, 0);
-      frame->Push(&answer);
+      RelocInfo::Mode mode = (var == NULL)
+                             ? RelocInfo::CODE_TARGET
+                             : RelocInfo::CODE_TARGET_CONTEXT;
+      Result answer = cgen_->frame()->CallLoadIC(mode);
+      cgen_->frame()->Push(&answer);
       break;
     }
 
     case KEYED: {
       // TODO(1241834): Make sure that this it is safe to ignore the
       // distinction between expressions in a typeof and not in a typeof.
       Comment cmnt(masm, "[ Load from keyed Property");
       Variable* var = expression_->AsVariableProxy()->AsVariable();
       bool is_global = var != NULL;
       ASSERT(!is_global || var->is_global());
@@ skipping 69 matching lines @@
         __ IncrementCounter(&Counters::keyed_load_inline, 1);
 
         // Restore the receiver and key to the frame and push the
         // result on top of it.
         deferred->BindExit(&receiver, &key, &value);
         cgen_->frame()->Push(&receiver);
         cgen_->frame()->Push(&key);
         cgen_->frame()->Push(&value);
 
       } else {
-        VirtualFrame* frame = cgen_->frame();
         Comment cmnt(masm, "[ Load from keyed Property");
-        Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
-        RelocInfo::Mode rmode = is_global
-                              ? RelocInfo::CODE_TARGET_CONTEXT
-                              : RelocInfo::CODE_TARGET;
-        Result answer = frame->CallCodeObject(ic, rmode, 0);
+        RelocInfo::Mode mode = is_global
+                               ? RelocInfo::CODE_TARGET_CONTEXT
+                               : RelocInfo::CODE_TARGET;
+        Result answer = cgen_->frame()->CallKeyedLoadIC(mode);
         // Make sure that we do not have a test instruction after the
         // call.  A test instruction after the call is used to
         // indicate that we have generated an inline version of the
         // keyed load.  The explicit nop instruction is here because
         // the push that follows might be peep-hole optimized away.
         __ nop();
-        frame->Push(&answer);
+        cgen_->frame()->Push(&answer);
       }
       break;
     }
 
     default:
       UNREACHABLE();
   }
 }
 
 
@@ skipping 23 matching lines @@
   } else {
     ASSERT(slot->type() == Slot::LOCAL);
     cgen_->frame()->TakeLocalAt(slot->index());
   }
 }
 
 
 void Reference::SetValue(InitState init_state) {
   ASSERT(cgen_->HasValidEntryRegisters());
   ASSERT(!is_illegal());
-  MacroAssembler* masm = cgen_->masm();
-  VirtualFrame* frame = cgen_->frame();
   switch (type_) {
     case SLOT: {
-      Comment cmnt(masm, "[ Store to Slot");
+      Comment cmnt(cgen_->masm(), "[ Store to Slot");
       Slot* slot = expression_->AsVariableProxy()->AsVariable()->slot();
       ASSERT(slot != NULL);
       cgen_->StoreToSlot(slot, init_state);
       break;
     }
 
     case NAMED: {
-      Comment cmnt(masm, "[ Store to named Property");
-      // Call the appropriate IC code.
-      Handle<String> name(GetName());
-      Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
-      // TODO(1222589): Make the IC grab the values from the stack.
-      Result argument = frame->Pop();
-      argument.ToRegister(eax);
-      ASSERT(argument.is_valid());
-      Result property_name = cgen_->allocator()->Allocate(ecx);
-      ASSERT(property_name.is_valid());
-      // Setup the name register.
-      __ mov(property_name.reg(), name);
-      Result answer = frame->CallCodeObject(ic, RelocInfo::CODE_TARGET,
-                                            &argument, &property_name, 0);
-      frame->Push(&answer);
+      Comment cmnt(cgen_->masm(), "[ Store to named Property");
+      cgen_->frame()->Push(GetName());
+      Result answer = cgen_->frame()->CallStoreIC();
+      cgen_->frame()->Push(&answer);
       break;
     }
 
     case KEYED: {
-      Comment cmnt(masm, "[ Store to keyed Property");
-      // Call IC code.
-      Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
-      // TODO(1222589): Make the IC grab the values from the stack.
-      Result arg = frame->Pop();
-      arg.ToRegister(eax);
-      ASSERT(arg.is_valid());
-      Result answer = frame->CallCodeObject(ic, RelocInfo::CODE_TARGET,
-                                            &arg, 0);
-      frame->Push(&answer);
+      Comment cmnt(cgen_->masm(), "[ Store to keyed Property");
+      Result answer = cgen_->frame()->CallKeyedStoreIC();
+      cgen_->frame()->Push(&answer);
       break;
     }
 
     default:
       UNREACHABLE();
   }
 }
 
 
 // NOTE: The stub does not handle the inlined cases (Smis, Booleans, undefined).
@@ skipping 1504 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal