Remove variable rewrites and the unneccesary Slot class.

src/mips/full-codegen-mips.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 182 matching lines @@
     } else {
       __ CallRuntime(Runtime::kNewFunctionContext, 1);
     }
     function_in_register = false;
     // Context is returned in both v0 and cp.  It replaces the context
     // passed to us.  It's saved in the stack and kept live in cp.
     __ sw(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
     // Copy any necessary parameters into the context.
     int num_parameters = info->scope()->num_parameters();
     for (int i = 0; i < num_parameters; i++) {
-      Slot* slot = scope()->parameter(i)->AsSlot();
+      Slot* slot = scope()->parameter(i)->rewrite();
       if (slot != NULL && slot->type() == Slot::CONTEXT) {
         int parameter_offset = StandardFrameConstants::kCallerSPOffset +
                                  (num_parameters - 1 - i) * kPointerSize;
         // Load parameter from stack.
         __ lw(a0, MemOperand(fp, parameter_offset));
         // Store it in the context.
         __ li(a1, Operand(Context::SlotOffset(slot->index())));
         __ addu(a2, cp, a1);
         __ sw(a0, MemOperand(a2, 0));
         // Update the write barrier. This clobbers all involved
@@ skipping 31 matching lines @@
     if (is_strict_mode()) {
       type = ArgumentsAccessStub::NEW_STRICT;
     } else if (function()->has_duplicate_parameters()) {
       type = ArgumentsAccessStub::NEW_NON_STRICT_SLOW;
     } else {
       type = ArgumentsAccessStub::NEW_NON_STRICT_FAST;
     }
     ArgumentsAccessStub stub(type);
     __ CallStub(&stub);
 
-    Move(arguments->AsSlot(), v0, a1, a2);
+    Move(arguments->rewrite(), v0, a1, a2);
   }
 
   if (FLAG_trace) {
     __ CallRuntime(Runtime::kTraceEnter, 0);
   }
 
   // Visit the declarations and body unless there is an illegal
   // redeclaration.
   if (scope()->HasIllegalRedeclaration()) {
     Comment cmnt(masm_, "[ Declarations");
@@ skipping 360 matching lines @@
     case Slot::PARAMETER:
     case Slot::LOCAL:
       return MemOperand(fp, SlotOffset(slot));
     case Slot::CONTEXT: {
       int context_chain_length =
           scope()->ContextChainLength(slot->var()->scope());
       __ LoadContext(scratch, context_chain_length);
       return ContextOperand(scratch, slot->index());
     }
     case Slot::LOOKUP:
+    case Slot::GLOBAL:
       UNREACHABLE();
   }
   UNREACHABLE();
   return MemOperand(v0, 0);
 }
 
 
 void FullCodeGenerator::Move(Register destination, Slot* source) {
   // Use destination as scratch.
   MemOperand slot_operand = EmitSlotSearch(source, destination);
@@ skipping 43 matching lines @@
                    src);
   }
 }
 
 
 void FullCodeGenerator::EmitDeclaration(Variable* variable,
                                         Variable::Mode mode,
                                         FunctionLiteral* function) {
   Comment cmnt(masm_, "[ Declaration");
   ASSERT(variable != NULL);  // Must have been resolved.
-  Slot* slot = variable->AsSlot();
+  Slot* slot = variable->rewrite();
   ASSERT(slot != NULL);
   switch (slot->type()) {
     case Slot::PARAMETER:
     case Slot::LOCAL:
       if (function != NULL) {
         VisitForAccumulatorValue(function);
         __ sw(result_register(), MemOperand(fp, SlotOffset(slot)));
       } else if (mode == Variable::CONST || mode == Variable::LET) {
           __ LoadRoot(t0, Heap::kTheHoleValueRootIndex);
           __ sw(t0, MemOperand(fp, SlotOffset(slot)));
@@ skipping 52 matching lines @@
           __ Push(cp, a2, a1, a0);
       } else {
         ASSERT(Smi::FromInt(0) == 0);
         // No initial value!
         __ mov(a0, zero_reg);  // Operand(Smi::FromInt(0)));
         __ Push(cp, a2, a1, a0);
       }
       __ CallRuntime(Runtime::kDeclareContextSlot, 4);
       break;
     }
+
+    case Slot::GLOBAL:
+      UNREACHABLE();
   }
 }
 
 
 void FullCodeGenerator::VisitDeclaration(Declaration* decl) {
   EmitDeclaration(decl->proxy()->var(), decl->mode(), decl->fun());
 }
 
 
 void FullCodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
@@ skipping 400 matching lines @@
     Label* done) {
   // Generate fast-case code for variables that might be shadowed by
   // eval-introduced variables.  Eval is used a lot without
   // introducing variables.  In those cases, we do not want to
   // perform a runtime call for all variables in the scope
   // containing the eval.
   if (slot->var()->mode() == Variable::DYNAMIC_GLOBAL) {
     EmitLoadGlobalSlotCheckExtensions(slot, typeof_state, slow);
     __ Branch(done);
   } else if (slot->var()->mode() == Variable::DYNAMIC_LOCAL) {
-    Slot* potential_slot = slot->var()->local_if_not_shadowed()->AsSlot();
+    Slot* potential_slot = slot->var()->local_if_not_shadowed()->rewrite();
     Expression* rewrite = slot->var()->local_if_not_shadowed()->rewrite();
     if (potential_slot != NULL) {
       // Generate fast case for locals that rewrite to slots.
       __ lw(v0, ContextSlotOperandCheckExtensions(potential_slot, slow));
       if (potential_slot->var()->mode() == Variable::CONST) {
         __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
         __ subu(at, v0, at);  // Sub as compare: at == 0 on eq.
         __ LoadRoot(a0, Heap::kUndefinedValueRootIndex);
         __ movz(v0, a0, at);  // Conditional move.
       }
       __ Branch(done);
     } else if (rewrite != NULL) {
       // Generate fast case for calls of an argument function.
       Property* property = rewrite->AsProperty();
       if (property != NULL) {
         VariableProxy* obj_proxy = property->obj()->AsVariableProxy();
         Literal* key_literal = property->key()->AsLiteral();
         if (obj_proxy != NULL &&
             key_literal != NULL &&
             obj_proxy->IsArguments() &&
             key_literal->handle()->IsSmi()) {
           // Load arguments object if there are no eval-introduced
           // variables. Then load the argument from the arguments
           // object using keyed load.
           __ lw(a1,
-                 ContextSlotOperandCheckExtensions(obj_proxy->var()->AsSlot(),
+                 ContextSlotOperandCheckExtensions(obj_proxy->var()->rewrite(),
                                                    slow));
           __ li(a0, Operand(key_literal->handle()));
           Handle<Code> ic =
               isolate()->builtins()->KeyedLoadIC_Initialize();
           __ Call(ic, RelocInfo::CODE_TARGET, GetPropertyId(property));
           __ Branch(done);
         }
       }
     }
   }
 }
 
 
 void FullCodeGenerator::EmitVariableLoad(VariableProxy* proxy) {
   // Record position before possible IC call.
   SetSourcePosition(proxy->position());
   Variable* var = proxy->var();
 
   // Three cases: non-this global variables, lookup slots, and all other
   // types of slots.
-  Slot* slot = var->AsSlot();
+  Slot* slot = var->rewrite();
   ASSERT((var->is_global() && !var->is_this()) == (slot == NULL));
 
   if (slot == NULL) {
     Comment cmnt(masm_, "Global variable");
     // Use inline caching. Variable name is passed in a2 and the global
     // object (receiver) in a0.
     __ lw(a0, GlobalObjectOperand());
     __ li(a2, Operand(var->name()));
     Handle<Code> ic = isolate()->builtins()->LoadIC_Initialize();
     __ Call(ic, RelocInfo::CODE_TARGET_CONTEXT);
@@ skipping 576 matching lines @@
     }
   }
   PrepareForBailoutForId(bailout_ast_id, TOS_REG);
   context()->Plug(v0);
 }
 
 
 void FullCodeGenerator::EmitVariableAssignment(Variable* var,
                                                Token::Value op) {
   ASSERT(var != NULL);
-  ASSERT(var->is_global() || var->AsSlot() != NULL);
+  ASSERT(var->is_global() || var->rewrite() != NULL);
 
   if (var->is_global()) {
     ASSERT(!var->is_this());
     // Assignment to a global variable.  Use inline caching for the
     // assignment.  Right-hand-side value is passed in a0, variable name in
     // a2, and the global object in a1.
     __ mov(a0, result_register());
     __ li(a2, Operand(var->name()));
     __ lw(a1, GlobalObjectOperand());
     Handle<Code> ic = is_strict_mode()
         ? isolate()->builtins()->StoreIC_Initialize_Strict()
         : isolate()->builtins()->StoreIC_Initialize();
     __ Call(ic, RelocInfo::CODE_TARGET_CONTEXT);
 
   } else if (op == Token::INIT_CONST) {
     // Like var declarations, const declarations are hoisted to function
     // scope.  However, unlike var initializers, const initializers are able
     // to drill a hole to that function context, even from inside a 'with'
     // context.  We thus bypass the normal static scope lookup.
-    Slot* slot = var->AsSlot();
+    Slot* slot = var->rewrite();
     Label skip;
     switch (slot->type()) {
       case Slot::PARAMETER:
         // No const parameters.
         UNREACHABLE();
         break;
       case Slot::LOCAL:
         // Detect const reinitialization by checking for the hole value.
         __ lw(a1, MemOperand(fp, SlotOffset(slot)));
         __ LoadRoot(t0, Heap::kTheHoleValueRootIndex);
         __ Branch(&skip, ne, a1, Operand(t0));
         __ sw(result_register(), MemOperand(fp, SlotOffset(slot)));
         break;
       case Slot::CONTEXT:
       case Slot::LOOKUP:
         __ push(result_register());
         __ li(a0, Operand(slot->var()->name()));
         __ Push(cp, a0);  // Context and name.
         __ CallRuntime(Runtime::kInitializeConstContextSlot, 3);
         break;
+      case Slot::GLOBAL:
+        UNREACHABLE();
     }
     __ bind(&skip);
   } else if (var->mode() == Variable::LET && op != Token::INIT_LET) {
     // Perform the assignment for non-const variables.  Const assignments
     // are simply skipped.
     Slot* slot = var->AsSlot();
     switch (slot->type()) {
       case Slot::PARAMETER:
       case Slot::LOCAL: {
         Label assign;
@@ skipping 36 matching lines @@
         __ li(a1, Operand(slot->var()->name()));
         __ li(a0, Operand(Smi::FromInt(strict_mode_flag())));
         __ Push(cp, a1, a0);  // Context, name, strict mode.
         __ CallRuntime(Runtime::kStoreContextSlot, 4);
         break;
     }
 
   } else if (var->mode() != Variable::CONST) {
     // Perform the assignment for non-const variables.  Const assignments
     // are simply skipped.
-    Slot* slot = var->AsSlot();
+    Slot* slot = var->rewrite();
     switch (slot->type()) {
       case Slot::PARAMETER:
       case Slot::LOCAL:
         // Perform the assignment.
         __ sw(result_register(), MemOperand(fp, SlotOffset(slot)));
         break;
 
       case Slot::CONTEXT: {
         MemOperand target = EmitSlotSearch(slot, a1);
         // Perform the assignment and issue the write barrier.
         __ sw(result_register(), target);
         // RecordWrite may destroy all its register arguments.
         __ mov(a3, result_register());
          int offset = FixedArray::kHeaderSize + slot->index() * kPointerSize;
         __ RecordWrite(a1, Operand(offset), a2, a3);
         break;
       }
 
       case Slot::LOOKUP:
         // Call the runtime for the assignment.
         __ push(v0);  // Value.
         __ li(a1, Operand(slot->var()->name()));
         __ li(a0, Operand(Smi::FromInt(strict_mode_flag())));
         __ Push(cp, a1, a0);  // Context, name, strict mode.
         __ CallRuntime(Runtime::kStoreContextSlot, 4);
         break;
+
+      case Slot::GLOBAL:
+        UNREACHABLE();
     }
   }
 }
 
 
 void FullCodeGenerator::EmitNamedPropertyAssignment(Assignment* expr) {
   // Assignment to a property, using a named store IC.
   Property* prop = expr->target()->AsProperty();
   ASSERT(prop != NULL);
   ASSERT(prop->key()->AsLiteral() != NULL);
@@ skipping 247 matching lines @@
 
       // Push the arguments.
       for (int i = 0; i < arg_count; i++) {
         VisitForStackValue(args->at(i));
       }
       // If we know that eval can only be shadowed by eval-introduced
       // variables we attempt to load the global eval function directly
       // in generated code. If we succeed, there is no need to perform a
       // context lookup in the runtime system.
       Label done;
-      if (var->AsSlot() != NULL && var->mode() == Variable::DYNAMIC_GLOBAL) {
+      if (var->rewrite() != NULL && var->mode() == Variable::DYNAMIC_GLOBAL) {
         Label slow;
-        EmitLoadGlobalSlotCheckExtensions(var->AsSlot(),
+        EmitLoadGlobalSlotCheckExtensions(var->rewrite(),
                                           NOT_INSIDE_TYPEOF,
                                           &slow);
         // Push the function and resolve eval.
         __ push(v0);
         EmitResolvePossiblyDirectEval(SKIP_CONTEXT_LOOKUP, arg_count);
         __ jmp(&done);
         __ bind(&slow);
       }
 
       // Push copy of the function (found below the arguments) and
@@ skipping 17 matching lines @@
     __ CallStub(&stub);
     RecordJSReturnSite(expr);
     // Restore context register.
     __ lw(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
     context()->DropAndPlug(1, v0);
   } else if (var != NULL && !var->is_this() && var->is_global()) {
     // Push global object as receiver for the call IC.
     __ lw(a0, GlobalObjectOperand());
     __ push(a0);
     EmitCallWithIC(expr, var->name(), RelocInfo::CODE_TARGET_CONTEXT);
-  } else if (var != NULL && var->AsSlot() != NULL &&
-             var->AsSlot()->type() == Slot::LOOKUP) {
+  } else if (var != NULL && var->rewrite() != NULL &&
+             var->rewrite()->type() == Slot::LOOKUP) {
     // Call to a lookup slot (dynamically introduced variable).
     Label slow, done;
 
     { PreservePositionScope scope(masm()->positions_recorder());
       // Generate code for loading from variables potentially shadowed
       // by eval-introduced variables.
-      EmitDynamicLoadFromSlotFastCase(var->AsSlot(),
+      EmitDynamicLoadFromSlotFastCase(var->rewrite(),
                                       NOT_INSIDE_TYPEOF,
                                       &slow,
                                       &done);
     }
 
     __ bind(&slow);
     // Call the runtime to find the function to call (returned in v0)
     // and the object holding it (returned in v1).
     __ push(context_register());
     __ li(a2, Operand(var->name()));
@@ skipping 1384 matching lines @@
         // Delete of an unqualified identifier is disallowed in strict mode
         // but "delete this" is.
         ASSERT(strict_mode_flag() == kNonStrictMode || var->is_this());
         if (var->is_global()) {
           __ lw(a2, GlobalObjectOperand());
           __ li(a1, Operand(var->name()));
           __ li(a0, Operand(Smi::FromInt(kNonStrictMode)));
           __ Push(a2, a1, a0);
           __ InvokeBuiltin(Builtins::DELETE, CALL_FUNCTION);
           context()->Plug(v0);
-        } else if (var->AsSlot() != NULL &&
-                   var->AsSlot()->type() != Slot::LOOKUP) {
+        } else if (var->rewrite() != NULL &&
+                   var->rewrite()->type() != Slot::LOOKUP) {
           // Result of deleting non-global, non-dynamic variables is false.
           // The subexpression does not have side effects.
           context()->Plug(false);
         } else {
           // Non-global variable.  Call the runtime to try to delete from the
           // context where the variable was introduced.
           __ push(context_register());
           __ li(a2, Operand(var->name()));
           __ push(a2);
           __ CallRuntime(Runtime::kDeleteContextSlot, 2);
@@ skipping 269 matching lines @@
     Comment cmnt(masm_, "Global variable");
     __ lw(a0, GlobalObjectOperand());
     __ li(a2, Operand(proxy->name()));
     Handle<Code> ic = isolate()->builtins()->LoadIC_Initialize();
     // Use a regular load, not a contextual load, to avoid a reference
     // error.
     __ Call(ic);
     PrepareForBailout(expr, TOS_REG);
     context()->Plug(v0);
   } else if (proxy != NULL &&
-             proxy->var()->AsSlot() != NULL &&
-             proxy->var()->AsSlot()->type() == Slot::LOOKUP) {
+             proxy->var()->rewrite() != NULL &&
+             proxy->var()->rewrite()->type() == Slot::LOOKUP) {
     Label done, slow;
 
     // Generate code for loading from variables potentially shadowed
     // by eval-introduced variables.
-    Slot* slot = proxy->var()->AsSlot();
+    Slot* slot = proxy->var()->rewrite();
     EmitDynamicLoadFromSlotFastCase(slot, INSIDE_TYPEOF, &slow, &done);
 
     __ bind(&slow);
     __ li(a0, Operand(proxy->name()));
     __ Push(cp, a0);
     __ CallRuntime(Runtime::kLoadContextSlotNoReferenceError, 2);
     PrepareForBailout(expr, TOS_REG);
     __ bind(&done);
 
     context()->Plug(v0);
@@ skipping 298 matching lines @@
   __ Addu(at, a1, Operand(masm_->CodeObject()));
   __ Jump(at);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_MIPS