Experimental: a grab bag of support for register allocation. Push the...

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 485 matching lines @@
 }
 
 
 void CodeGenerator::LoadReference(Reference* ref) {
   Comment cmnt(masm_, "[ LoadReference");
   Expression* e = ref->expression();
   Property* property = e->AsProperty();
   Variable* var = e->AsVariableProxy()->AsVariable();
 
   if (property != NULL) {
-    VirtualFrame::SpilledScope spilled_scope(this);
     // The expression is either a property or a variable proxy that rewrites
     // to a property.
-    LoadAndSpill(property->obj());
+    Load(property->obj());
     // We use a named reference if the key is a literal symbol, unless it is
     // a string that can be legally parsed as an integer.  This is because
     // otherwise we will not get into the slow case code that handles [] on
     // String objects.
     Literal* literal = property->key()->AsLiteral();
     uint32_t dummy;
     if (literal != NULL &&
         literal->handle()->IsSymbol() &&
         !String::cast(*(literal->handle()))->AsArrayIndex(&dummy)) {
       ref->set_type(Reference::NAMED);
     } else {
-      LoadAndSpill(property->key());
+      Load(property->key());
       ref->set_type(Reference::KEYED);
     }
   } else if (var != NULL) {
     // The expression is a variable proxy that does not rewrite to a
     // property.  Global variables are treated as named property references.
     if (var->is_global()) {
       VirtualFrame::SpilledScope spilled_scope(this);
       LoadGlobal();
       ref->set_type(Reference::NAMED);
     } else {
       ASSERT(var->slot() != NULL);
       ref->set_type(Reference::SLOT);
     }
   } else {
-    VirtualFrame::SpilledScope spilled_scope(this);
     // Anything else is a runtime error.
-    LoadAndSpill(e);
+    Load(e);
     frame_->CallRuntime(Runtime::kThrowReferenceError, 1);
   }
 }
 
 
 void CodeGenerator::UnloadReference(Reference* ref) {
   // Pop a reference from the stack while preserving TOS.
   Comment cmnt(masm_, "[ UnloadReference");
   int size = ref->size();
   if (size == 1) {
+    VirtualFrame::SpilledScope spilled_scope(this);
     frame_->EmitPop(eax);
     __ mov(frame_->Top(), eax);
   } else if (size > 1) {
+    VirtualFrame::SpilledScope spilled_scope(this);
     frame_->EmitPop(eax);
     frame_->Drop(size);
     frame_->EmitPush(eax);
   }
 }
 
 
 class ToBooleanStub: public CodeStub {
  public:
   ToBooleanStub() { }
@@ skipping 1637 matching lines @@
 
   // If the property has been removed while iterating, we just skip it.
   __ cmp(ebx, Factory::null_value());
   node->continue_target()->Branch(equal);
 
   end_del_check.Bind();
   // Store the entry in the 'each' expression and take another spin in the
   // loop.  edx: i'th entry of the enum cache (or string there of)
   frame_->EmitPush(ebx);
   { Reference each(this, node->each());
+    // Loading a reference may leave the frame in an unspilled state.
+    frame_->SpillAll();
     if (!each.is_illegal()) {
       if (each.size() > 0) {
         frame_->EmitPush(frame_->ElementAt(each.size()));
       }
       // If the reference was to a slot we rely on the convenient property
       // that it doesn't matter whether a value (eg, ebx pushed above) is
       // right on top of or right underneath a zero-sized reference.
       each.SetValue(NOT_CONST_INIT);
       if (each.size() > 0) {
         // It's safe to pop the value lying on top of the reference before
         // unloading the reference itself (which preserves the top of stack,
         // ie, now the topmost value of the non-zero sized reference), since
         // we will discard the top of stack after unloading the reference
         // anyway.
         frame_->Drop();
       }
     }
   }
+  // Unloading a reference may leave the frame in an unspilled state.
+  frame_->SpillAll();
+
   // Discard the i'th entry pushed above or else the remainder of the
   // reference, whichever is currently on top of the stack.
   frame_->Drop();
 
   // Body.
   CheckStack();  // TODO(1222600): ignore if body contains calls.
   VisitAndSpill(node->body());
 
   // Next.
   node->continue_target()->Bind();
@@ skipping 285 matching lines @@
     frame_->CallRuntime(Runtime::kReThrow, 1);
 
     // Done.
     exit.Bind();
   }
 }
 
 
 void CodeGenerator::VisitDebuggerStatement(DebuggerStatement* node) {
   ASSERT(!in_spilled_code());
-  VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ DebuggerStatement");
   CodeForStatement(node);
+  // Spill everything, even constants, to the frame.
+  frame_->SpillAll();
   frame_->CallRuntime(Runtime::kDebugBreak, 0);
   // Ignore the return value.
 }
 
 
 void CodeGenerator::InstantiateBoilerplate(Handle<JSFunction> boilerplate) {
   ASSERT(boilerplate->IsBoilerplate());
 
   // Push the boilerplate on the stack.
-  frame_->EmitPush(Immediate(boilerplate));
+  frame_->Push(boilerplate);
 
   // Create a new closure.
-  frame_->EmitPush(esi);
-  frame_->CallRuntime(Runtime::kNewClosure, 2);
-  frame_->EmitPush(eax);
+  frame_->Push(esi);
+  Result result = frame_->CallRuntime(Runtime::kNewClosure, 2);
+  frame_->Push(&result);
 }
 
 
 void CodeGenerator::VisitFunctionLiteral(FunctionLiteral* node) {
-  VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ FunctionLiteral");
 
   // Build the function boilerplate and instantiate it.
   Handle<JSFunction> boilerplate = BuildBoilerplate(node);
   // Check for stack-overflow exception.
   if (HasStackOverflow()) return;
   InstantiateBoilerplate(boilerplate);
 }
 
 
 void CodeGenerator::VisitFunctionBoilerplateLiteral(
     FunctionBoilerplateLiteral* node) {
-  VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ FunctionBoilerplateLiteral");
   InstantiateBoilerplate(node->boilerplate());
 }
 
 
 void CodeGenerator::VisitConditional(Conditional* node) {
-  VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ Conditional");
   JumpTarget then(this);
   JumpTarget else_(this);
   JumpTarget exit(this);
-  LoadConditionAndSpill(node->condition(), NOT_INSIDE_TYPEOF,
-                        &then, &else_, true);
+  LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &then, &else_, true);
   if (has_valid_frame()) {
     Branch(false, &else_);
   }
-  if (has_valid_frame() || then.is_linked()) {
+  if (then.is_linked()) {
     then.Bind();
-    LoadAndSpill(node->then_expression(), typeof_state());
+  }
+  if (has_valid_frame()) {
+    Load(node->then_expression(), typeof_state());
     exit.Jump();
   }
   if (else_.is_linked()) {
     else_.Bind();
-    LoadAndSpill(node->else_expression(), typeof_state());
+    Load(node->else_expression(), typeof_state());
   }
   exit.Bind();
 }
 
 
 void CodeGenerator::LoadFromSlot(Slot* slot, TypeofState typeof_state) {
   if (slot->type() == Slot::LOOKUP) {
     ASSERT(slot->var()->mode() == Variable::DYNAMIC);
 
     // For now, just do a runtime call.
-    VirtualFrame::SpilledScope spilled_scope(this);
-    frame_->EmitPush(esi);
-    frame_->EmitPush(Immediate(slot->var()->name()));
+    frame_->Push(esi);
+    frame_->Push(slot->var()->name());
 
+    Result value(this);
     if (typeof_state == INSIDE_TYPEOF) {
-      frame_->CallRuntime(Runtime::kLoadContextSlotNoReferenceError, 2);
+      value =
+          frame_->CallRuntime(Runtime::kLoadContextSlotNoReferenceError, 2);
     } else {
-      frame_->CallRuntime(Runtime::kLoadContextSlot, 2);
+      value = frame_->CallRuntime(Runtime::kLoadContextSlot, 2);
     }
-    frame_->EmitPush(eax);
+    frame_->Push(&value);
+
+  } else if (slot->var()->mode() == Variable::CONST) {
+    // Const slots may contain 'the hole' value (the constant hasn't been
+    // initialized yet) which needs to be converted into the 'undefined'
+    // value.
+    Comment cmnt(masm_, "[ Load const");
+    JumpTarget exit(this);
+    Result temp = allocator_->Allocate();
+    ASSERT(temp.is_valid());
+    __ mov(temp.reg(), SlotOperand(slot, temp.reg()));

[William Hesse, 2009/01/06 14:40:27]

This was __mov(eax, SlotOperand(slot, ecx)).
What is ecx, and why has it been replaced by temp.reg()?
Isn't it something different than eax?

+    __ cmp(temp.reg(), Factory::the_hole_value());
+    exit.Branch(not_equal, &temp);
+    __ mov(temp.reg(), Factory::undefined_value());
+    exit.Bind(&temp);
+    frame_->Push(&temp);
+
+  } else if (slot->type() == Slot::PARAMETER) {
+    frame_->LoadParameterAt(slot->index());
+
+  } else if (slot->type() == Slot::LOCAL) {
+    frame_->LoadLocalAt(slot->index());
 
   } else {
-    // Note: We would like to keep the assert below, but it fires because of
-    // some nasty code in LoadTypeofExpression() which should be removed...
-    // ASSERT(slot->var()->mode() != Variable::DYNAMIC);
-    if (slot->var()->mode() == Variable::CONST) {
-      // Const slots may contain 'the hole' value (the constant hasn't been
-      // initialized yet) which needs to be converted into the 'undefined'
-      // value.
-      VirtualFrame::SpilledScope spilled_scope(this);
-      Comment cmnt(masm_, "[ Load const");
-      JumpTarget exit(this);
-      __ mov(eax, SlotOperand(slot, ecx));
-      __ cmp(eax, Factory::the_hole_value());
-      exit.Branch(not_equal);
-      __ mov(eax, Factory::undefined_value());
-      exit.Bind();
-      frame_->EmitPush(eax);
-    } else {
-      if (slot->type() == Slot::PARAMETER) {
-        frame_->LoadParameterAt(slot->index());
-      } else if (slot->type() == Slot::LOCAL) {
-        frame_->LoadLocalAt(slot->index());
-      } else {
-        // The other remaining slot types (LOOKUP and GLOBAL) cannot reach
-        // here.
-        ASSERT(slot->type() == Slot::CONTEXT);
-        VirtualFrame::SpilledScope spilled_scope(this);
-        frame_->EmitPush(SlotOperand(slot, ecx));
-      }
-    }
+    // The other remaining slot types (LOOKUP and GLOBAL) cannot reach
+    // here.
+    ASSERT(slot->type() == Slot::CONTEXT);
+    Result temp = allocator_->Allocate();
+    ASSERT(temp.is_valid());
+    __ mov(temp.reg(), SlotOperand(slot, temp.reg()));

[William Hesse, 2009/01/06 14:40:27]

Same here, second arg of SlotOperand() was ecx.

+    frame_->Push(&temp);
   }
 }
 
 
 void CodeGenerator::StoreToSlot(Slot* slot, InitState init_state) {
   if (slot->type() == Slot::LOOKUP) {
     ASSERT(slot->var()->mode() == Variable::DYNAMIC);
 
     // For now, just do a runtime call.
-    VirtualFrame::SpilledScope spilled_scope(this);
-    frame_->EmitPush(esi);
-    frame_->EmitPush(Immediate(slot->var()->name()));
+    frame_->Push(esi);
+    frame_->Push(slot->var()->name());
 
+    Result value(this);
     if (init_state == CONST_INIT) {
       // Same as the case for a normal store, but ignores attribute
       // (e.g. READ_ONLY) of context slot so that we can initialize const
       // properties (introduced via eval("const foo = (some expr);")). Also,
       // uses the current function context instead of the top context.
       //
       // Note that we must declare the foo upon entry of eval(), via a
       // context slot declaration, but we cannot initialize it at the same
       // time, because the const declaration may be at the end of the eval
       // code (sigh...) and the const variable may have been used before
       // (where its value is 'undefined'). Thus, we can only do the
       // initialization when we actually encounter the expression and when
       // the expression operands are defined and valid, and thus we need the
       // split into 2 operations: declaration of the context slot followed
       // by initialization.
-      frame_->CallRuntime(Runtime::kInitializeConstContextSlot, 3);
+      value = frame_->CallRuntime(Runtime::kInitializeConstContextSlot, 3);
     } else {
-      frame_->CallRuntime(Runtime::kStoreContextSlot, 3);
+      value = frame_->CallRuntime(Runtime::kStoreContextSlot, 3);
     }
     // Storing a variable must keep the (new) value on the expression
     // stack. This is necessary for compiling chained assignment
     // expressions.
-    frame_->EmitPush(eax);
+    frame_->Push(&value);
 
   } else {
     ASSERT(slot->var()->mode() != Variable::DYNAMIC);
 
     JumpTarget exit(this);
     if (init_state == CONST_INIT) {
       ASSERT(slot->var()->mode() == Variable::CONST);
       // Only the first const initialization must be executed (the slot
       // still contains 'the hole' value). When the assignment is executed,
       // the code is identical to a normal store (see below).
       Comment cmnt(masm_, "[ Init const");
-      VirtualFrame::SpilledScope spilled_scope(this);
-      __ mov(eax, SlotOperand(slot, ecx));
-      __ cmp(eax, Factory::the_hole_value());
+      Result temp = allocator_->Allocate();
+      ASSERT(temp.is_valid());
+      __ mov(temp.reg(), SlotOperand(slot, temp.reg()));

[William Hesse, 2009/01/06 14:40:27]

Same, ecx versus eax.

+      __ cmp(temp.reg(), Factory::the_hole_value());
+      temp.Unuse();
       exit.Branch(not_equal);
     }
 
     // We must execute the store.  Storing a variable must keep the (new)
     // value on the stack. This is necessary for compiling assignment
     // expressions.
     //
     // Note: We will reach here even with slot->var()->mode() ==
     // Variable::CONST because of const declarations which will initialize
     // consts to 'the hole' value and by doing so, end up calling this code.
     if (slot->type() == Slot::PARAMETER) {
       frame_->StoreToParameterAt(slot->index());
     } else if (slot->type() == Slot::LOCAL) {
       frame_->StoreToLocalAt(slot->index());
     } else {
       // The other slot types (LOOKUP and GLOBAL) cannot reach here.
       ASSERT(slot->type() == Slot::CONTEXT);
-      VirtualFrame::SpilledScope spilled_scope(this);
-      frame_->EmitPop(eax);
-      __ mov(SlotOperand(slot, ecx), eax);
-      frame_->EmitPush(eax);  // RecordWrite may destroy the value in eax.
+      frame_->Dup();
+      Result value = frame_->Pop();
+      value.ToRegister();
+      Result start = allocator_->Allocate();
+      ASSERT(start.is_valid());
+      __ mov(SlotOperand(slot, start.reg()), value.reg());
+      // RecordWrite may destroy the value registers.
+      //
+      // TODO(): Avoid actually spilling when the value is not needed
+      // (probably the common case).
+      frame_->Spill(value.reg());
       int offset = FixedArray::kHeaderSize + slot->index() * kPointerSize;
-      __ RecordWrite(ecx, offset, eax, ebx);
+      Result temp = allocator_->Allocate();
+      ASSERT(temp.is_valid());
+      __ RecordWrite(start.reg(), offset, value.reg(), temp.reg());
+      // The results start, value, and temp are unused by going out of
+      // scope.
     }
 
     // If we definitely did not jump over the assignment, we do not need
     // to bind the exit label.  Doing so can defeat peephole
     // optimization.
-    if (init_state == CONST_INIT) {
+    if (exit.is_linked()) {
       exit.Bind();
     }
   }
 }
 
 
 void CodeGenerator::VisitSlot(Slot* node) {
   Comment cmnt(masm_, "[ Slot");
   LoadFromSlot(node, typeof_state());
 }
@@ skipping 285 matching lines @@
 
 
 void CodeGenerator::VisitAssignment(Assignment* node) {
   Comment cmnt(masm_, "[ Assignment");
   CodeForStatement(node);
 
   { Reference target(this, node->target());
     if (target.is_illegal()) {
       // Fool the virtual frame into thinking that we left the assignment's
       // value on the frame.
-      frame_->EmitPush(Immediate(Smi::FromInt(0)));
+      frame_->Push(Handle<Object>(Smi::FromInt(0)));
       return;
     }
 
     if (node->op() == Token::ASSIGN ||
         node->op() == Token::INIT_VAR ||
         node->op() == Token::INIT_CONST) {
       Load(node->value());
 
     } else {
       VirtualFrame::SpilledScope spilled_scope(this);
@@ skipping 33 matching lines @@
   Comment cmnt(masm_, "[ Throw");
   CodeForStatement(node);
 
   LoadAndSpill(node->exception());
   frame_->CallRuntime(Runtime::kThrow, 1);
   frame_->EmitPush(eax);
 }
 
 
 void CodeGenerator::VisitProperty(Property* node) {
-  VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ Property");
   Reference property(this, node);
-  property.GetValueAndSpill(typeof_state());
+  property.GetValue(typeof_state());
 }
 
 
 void CodeGenerator::VisitCall(Call* node) {
   VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ Call");
 
   ZoneList<Expression*>* args = node->arguments();
 
   CodeForStatement(node);
@@ skipping 91 matching lines @@
       // Overwrite the function on the stack with the result.
       __ mov(frame_->Top(), eax);
 
     } else {
       // -------------------------------------------
       // JavaScript example: 'array[index](1, 2, 3)'
       // -------------------------------------------
 
       // Load the function to call from the property through a reference.
       Reference ref(this, property);
+      frame_->SpillAll();
       ref.GetValueAndSpill(NOT_INSIDE_TYPEOF);
 
       // Pass receiver to called function.
       // The reference's size is non-negative.
       frame_->EmitPush(frame_->ElementAt(ref.size()));
 
       // Call the function.
       CallWithArguments(args, node->position());
     }
 
@@ skipping 2601 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal