Rename the kinds of locations to be consistent with the (codegen)...

src/arm/fast-codegen-arm.cc

 // Copyright 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 101 matching lines @@
     __ ldm(ia_w, sp, fp.bit() | lr.bit());
     int num_parameters = function_->scope()->num_parameters();
     __ add(sp, sp, Operand((num_parameters + 1) * kPointerSize));
     __ Jump(lr);
   }
 }
 
 
 void FastCodeGenerator::Move(Location destination, Slot* source) {
   switch (destination.type()) {
-    case Location::NOWHERE:
+    case Location::UNINITIALIZED:
+      UNREACHABLE();
+    case Location::EFFECT:
       break;
-    case Location::TEMP:
+    case Location::VALUE:
       __ ldr(ip, MemOperand(fp, SlotOffset(source)));
       __ push(ip);
       break;
   }
 }
 
 
 void FastCodeGenerator::Move(Location destination, Literal* expr) {
   switch (destination.type()) {
-    case Location::NOWHERE:
+    case Location::UNINITIALIZED:
+      UNREACHABLE();
+    case Location::EFFECT:
       break;
-    case Location::TEMP:
+    case Location::VALUE:
       __ mov(ip, Operand(expr->handle()));
       __ push(ip);
       break;
   }
 }
 
 
 void FastCodeGenerator::Move(Slot* destination, Location source) {
   switch (source.type()) {
-    case Location::NOWHERE:
+    case Location::UNINITIALIZED:  // Fall through.
+    case Location::EFFECT:
       UNREACHABLE();
-    case Location::TEMP:
+    case Location::VALUE:
       __ pop(ip);
       __ str(ip, MemOperand(fp, SlotOffset(destination)));
       break;
   }
 }
 
 
 void FastCodeGenerator::DropAndMove(Location destination, Register source) {
   switch (destination.type()) {
-    case Location::NOWHERE:
+    case Location::UNINITIALIZED:
+      UNREACHABLE();
+    case Location::EFFECT:
       __ pop();
       break;
-    case Location::TEMP:
+    case Location::VALUE:
       __ str(source, MemOperand(sp));
       break;
   }
 }
 
 
 void FastCodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
   // Call the runtime to declare the globals.
   // The context is the first argument.
   __ mov(r1, Operand(pairs));
@@ skipping 60 matching lines @@
     Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
     __ Call(ic, RelocInfo::CODE_TARGET_CONTEXT);
     DropAndMove(expr->location(), r0);
   } else {
     Comment cmnt(masm_, "Stack slot");
     Move(expr->location(), rewrite->AsSlot());
   }
 }
 
 
+void FastCodeGenerator::VisitRegExpLiteral(RegExpLiteral* expr) {
+  Comment cmnt(masm_, "[ RegExp Literal");
+  Label done;
+  // Registers will be used as follows:
+  // r4 = JS function, literals array
+  // r3 = literal index
+  // r2 = RegExp pattern
+  // r1 = RegExp flags
+  // r0 = temp + return value (RegExp literal)
+  __ ldr(r0, MemOperand(fp,  JavaScriptFrameConstants::kFunctionOffset));
+  __ ldr(r4,  FieldMemOperand(r0, JSFunction::kLiteralsOffset));
+  int literal_offset =
+    FixedArray::kHeaderSize + expr->literal_index() * kPointerSize;
+  __ ldr(r0, FieldMemOperand(r4, literal_offset));
+  __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
+  __ cmp(r0, ip);
+  __ b(ne, &done);
+  __ mov(r3, Operand(Smi::FromInt(expr->literal_index())));
+  __ mov(r2, Operand(expr->pattern()));
+  __ mov(r1, Operand(expr->flags()));
+  __ stm(db_w, sp, r4.bit() | r3.bit() | r2.bit() | r1.bit());
+  __ CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
+  __ bind(&done);
+  Move(expr->location(), r0);
+}
+
+
 void FastCodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
   Comment cmnt(masm_, "[ ObjectLiteral");
   Label boilerplate_exists;
   __ ldr(r2, MemOperand(fp,  JavaScriptFrameConstants::kFunctionOffset));
   // r2 = literal array (0).
   __ ldr(r2, FieldMemOperand(r2, JSFunction::kLiteralsOffset));
   int literal_offset =
       FixedArray::kHeaderSize + expr->literal_index() * kPointerSize;
   __ ldr(r0, FieldMemOperand(r2, literal_offset));
   // Check whether we need to materialize the object literal boilerplate.
@@ skipping 25 matching lines @@
     ObjectLiteral::Property* property = expr->properties()->at(i);
     if (property->IsCompileTimeValue()) continue;
 
     Literal* key = property->key();
     Expression* value = property->value();
     if (!result_saved) {
       __ push(r0);  // Save result on stack
       result_saved = true;
     }
     switch (property->kind()) {
-      case ObjectLiteral::Property::MATERIALIZED_LITERAL:   // fall through
+      case ObjectLiteral::Property::CONSTANT:
+        UNREACHABLE();
+
+      case ObjectLiteral::Property::MATERIALIZED_LITERAL:   // Fall through.
         ASSERT(!CompileTimeValue::IsCompileTimeValue(property->value()));
-      case ObjectLiteral::Property::COMPUTED:  // fall through
+      case ObjectLiteral::Property::COMPUTED:
+        if (key->handle()->IsSymbol()) {
+          Visit(value);
+          Move(r0, value->location());
+          __ mov(r2, Operand(key->handle()));
+          Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
+          __ Call(ic, RelocInfo::CODE_TARGET);
+          // StoreIC leaves the receiver on the stack.
+          break;
+        }
+        // Fall through.
+
       case ObjectLiteral::Property::PROTOTYPE:
         __ push(r0);
         Visit(key);
-        ASSERT(key->location().is_temporary());
+        ASSERT(key->location().is_value());
         Visit(value);
-        ASSERT(value->location().is_temporary());
+        ASSERT(value->location().is_value());
         __ CallRuntime(Runtime::kSetProperty, 3);
         __ ldr(r0, MemOperand(sp));  // Restore result into r0
         break;
-      case ObjectLiteral::Property::SETTER:  // fall through
-      case ObjectLiteral::Property::GETTER:
+
+      case ObjectLiteral::Property::GETTER:  // Fall through.
+      case ObjectLiteral::Property::SETTER:
         __ push(r0);
         Visit(key);
-        ASSERT(key->location().is_temporary());
+        ASSERT(key->location().is_value());
         __ mov(r1, Operand(property->kind() == ObjectLiteral::Property::SETTER ?
                            Smi::FromInt(1) :
                            Smi::FromInt(0)));
         __ push(r1);
         Visit(value);
-        ASSERT(value->location().is_temporary());
+        ASSERT(value->location().is_value());
         __ CallRuntime(Runtime::kDefineAccessor, 4);
         __ ldr(r0, MemOperand(sp));  // Restore result into r0
         break;
-      default: UNREACHABLE();
     }
   }
   switch (expr->location().type()) {
-    case Location::NOWHERE:
+    case Location::UNINITIALIZED:
+      UNREACHABLE();
+    case Location::EFFECT:
       if (result_saved) __ pop();
       break;
-    case Location::TEMP:
+    case Location::VALUE:
       if (!result_saved) __ push(r0);
       break;
   }
 }
 
 
-void FastCodeGenerator::VisitRegExpLiteral(RegExpLiteral* expr) {
-  Comment cmnt(masm_, "[ RegExp Literal");
-  Label done;
-  // Registers will be used as follows:
-  // r4 = JS function, literals array
-  // r3 = literal index
-  // r2 = RegExp pattern
-  // r1 = RegExp flags
-  // r0 = temp + return value (RegExp literal)
-  __ ldr(r0, MemOperand(fp,  JavaScriptFrameConstants::kFunctionOffset));
-  __ ldr(r4,  FieldMemOperand(r0, JSFunction::kLiteralsOffset));
-  int literal_offset =
-    FixedArray::kHeaderSize + expr->literal_index() * kPointerSize;
-  __ ldr(r0, FieldMemOperand(r4, literal_offset));
-  __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
-  __ cmp(r0, ip);
-  __ b(ne, &done);
-  __ mov(r3, Operand(Smi::FromInt(expr->literal_index())));
-  __ mov(r2, Operand(expr->pattern()));
-  __ mov(r1, Operand(expr->flags()));
-  __ stm(db_w, sp, r4.bit() | r3.bit() | r2.bit() | r1.bit());
-  __ CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
-  __ bind(&done);
-  Move(expr->location(), r0);
-}
-
-
 void FastCodeGenerator::VisitArrayLiteral(ArrayLiteral* expr) {
   Comment cmnt(masm_, "[ ArrayLiteral");
   Label make_clone;
 
   // Fetch the function's literals array.
   __ ldr(r3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
   __ ldr(r3, FieldMemOperand(r3, JSFunction::kLiteralsOffset));
   // Check if the literal's boilerplate has been instantiated.
   int offset =
       FixedArray::kHeaderSize + (expr->literal_index() * kPointerSize);
@@ skipping 29 matching lines @@
     if (subexpr->AsLiteral() != NULL ||
         CompileTimeValue::IsCompileTimeValue(subexpr)) {
       continue;
     }
 
     if (!result_saved) {
       __ push(r0);
       result_saved = true;
     }
     Visit(subexpr);
-    ASSERT(subexpr->location().is_temporary());
+    ASSERT(subexpr->location().is_value());
 
     // Store the subexpression value in the array's elements.
     __ pop(r0);  // Subexpression value.
     __ ldr(r1, MemOperand(sp));  // Copy of array literal.
     __ ldr(r1, FieldMemOperand(r1, JSObject::kElementsOffset));
     int offset = FixedArray::kHeaderSize + (i * kPointerSize);
     __ str(r0, FieldMemOperand(r1, offset));
 
     // Update the write barrier for the array store with r0 as the scratch
     // register.
     __ mov(r2, Operand(offset));
     __ RecordWrite(r1, r2, r0);
   }
 
   switch (expr->location().type()) {
-    case Location::NOWHERE:
+    case Location::UNINITIALIZED:
+      UNREACHABLE();
+    case Location::EFFECT:
       if (result_saved) __ pop();
       break;
-    case Location::TEMP:
+    case Location::VALUE:
       if (!result_saved) __ push(r0);
       break;
   }
 }
 
 
 void FastCodeGenerator::VisitAssignment(Assignment* expr) {
   Comment cmnt(masm_, "[ Assignment");
   ASSERT(expr->op() == Token::ASSIGN || expr->op() == Token::INIT_VAR);
 
   // Left-hand side can only be a global or a (parameter or local) slot.
   Variable* var = expr->target()->AsVariableProxy()->AsVariable();
   ASSERT(var != NULL);
   ASSERT(var->is_global() || var->slot() != NULL);
 
   Expression* rhs = expr->value();
   Location destination = expr->location();
   if (var->is_global()) {
     // Assignment to a global variable, use inline caching.  Right-hand-side
     // value is passed in r0, variable name in r2, and the global object on
     // the stack.
 
     // Code for the right-hand-side expression depends on its type.
     if (rhs->AsLiteral() != NULL) {
       __ mov(r0, Operand(rhs->AsLiteral()->handle()));
     } else {
-      ASSERT(rhs->location().is_temporary());
+      ASSERT(rhs->location().is_value());
       Visit(rhs);
       __ pop(r0);
     }
     __ mov(r2, Operand(var->name()));
     __ ldr(ip, CodeGenerator::GlobalObject());
     __ push(ip);
     Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
     __ Call(ic, RelocInfo::CODE_TARGET);
     // Overwrite the global object on the stack with the result if needed.
     DropAndMove(expr->location(), r0);
   } else {
     // Local or parameter assignment.
 
     // Code for the right-hand side expression depends on its type.
     if (rhs->AsLiteral() != NULL) {
       // Two cases: 'temp <- (var = constant)', or 'var = constant' with a
       // discarded result.  Always perform the assignment.
       __ mov(ip, Operand(rhs->AsLiteral()->handle()));
       __ str(ip, MemOperand(fp, SlotOffset(var->slot())));
       Move(expr->location(), ip);
     } else {
-      ASSERT(rhs->location().is_temporary());
+      ASSERT(rhs->location().is_value());
       Visit(rhs);
       // Load right-hand side into ip.
       switch (expr->location().type()) {
-        case Location::NOWHERE:
+        case Location::UNINITIALIZED:
+          UNREACHABLE();
+        case Location::EFFECT:
           // Case 'var = temp'.  Discard right-hand-side temporary.
           __ pop(ip);
           break;
-        case Location::TEMP:
+        case Location::VALUE:
           // Case 'temp1 <- (var = temp0)'.  Preserve right-hand-side
           // temporary on the stack.
           __ ldr(ip, MemOperand(sp));
           break;
       }
       // Do the slot assignment.
       __ str(ip, MemOperand(fp, SlotOffset(var->slot())));
     }
   }
 }
@@ skipping 25 matching lines @@
     Visit(expr->key());
     Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
     __ Call(ic, RelocInfo::CODE_TARGET);
     // By emitting a nop we make sure that we do not have a "test eax,..."
     // instruction after the call it is treated specially by the LoadIC code.
     __ nop();
     // Drop key and receiver left on the stack by IC.
     __ pop();
   }
   switch (expr->location().type()) {
-    case Location::TEMP:
+    case Location::UNINITIALIZED:
+      UNREACHABLE();
+    case Location::VALUE:
       __ str(r0, MemOperand(sp));
       break;
-    case Location::NOWHERE:
+    case Location::EFFECT:
       __ pop();
   }
 }
 
 
 void FastCodeGenerator::VisitCall(Call* expr) {
   Comment cmnt(masm_, "[ Call");
   Expression* fun = expr->expression();
   ZoneList<Expression*>* args = expr->arguments();
   Variable* var = fun->AsVariableProxy()->AsVariable();
   ASSERT(var != NULL && !var->is_this() && var->is_global());
   ASSERT(!var->is_possibly_eval());
 
   __ mov(r1, Operand(var->name()));
   // Push global object as receiver.
   __ ldr(r0, CodeGenerator::GlobalObject());
   __ stm(db_w, sp, r1.bit() | r0.bit());
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Visit(args->at(i));
-    ASSERT(args->at(i)->location().is_temporary());
+    ASSERT(args->at(i)->location().is_value());
   }
   // Record source position for debugger
   SetSourcePosition(expr->position());
   // Call the IC initialization code.
   Handle<Code> ic = CodeGenerator::ComputeCallInitialize(arg_count,
                                                          NOT_IN_LOOP);
   __ Call(ic, RelocInfo::CODE_TARGET_CONTEXT);
   // Restore context register.
   __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
   DropAndMove(expr->location(), r0);
 }
 
 
 void FastCodeGenerator::VisitCallNew(CallNew* node) {
   Comment cmnt(masm_, "[ CallNew");
   // According to ECMA-262, section 11.2.2, page 44, the function
   // expression in new calls must be evaluated before the
   // arguments.
   // Push function on the stack.
   Visit(node->expression());
-  ASSERT(node->expression()->location().is_temporary());
+  ASSERT(node->expression()->location().is_value());
 
   // Push global object (receiver).
   __ ldr(r0, CodeGenerator::GlobalObject());
   __ push(r0);
   // Push the arguments ("left-to-right") on the stack.
   ZoneList<Expression*>* args = node->arguments();
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Visit(args->at(i));
-    ASSERT(args->at(i)->location().is_temporary());
+    ASSERT(args->at(i)->location().is_value());
     // If location is temporary, it is already on the stack,
     // so nothing to do here.
   }
 
   // Call the construct call builtin that handles allocation and
   // constructor invocation.
   SetSourcePosition(node->position());
 
   // Load function, arg_count into r1 and r0.
   __ mov(r0, Operand(arg_count));
@@ skipping 12 matching lines @@
   Comment cmnt(masm_, "[ CallRuntime");
   ZoneList<Expression*>* args = expr->arguments();
   Runtime::Function* function = expr->function();
 
   ASSERT(function != NULL);
 
   // Push the arguments ("left-to-right").
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Visit(args->at(i));
-    ASSERT(args->at(i)->location().is_temporary());
+    ASSERT(args->at(i)->location().is_value());
   }
 
   __ CallRuntime(function, arg_count);
   Move(expr->location(), r0);
 }
 
 
 void FastCodeGenerator::VisitBinaryOperation(BinaryOperation* expr) {
   // Compile a short-circuited boolean or operation in a non-test
   // context.
   ASSERT(expr->op() == Token::OR);
   // Compile (e0 || e1) as if it were
   // (let (temp = e0) temp ? temp : e1).
 
   Label done;
   Location destination = expr->location();
   Expression* left = expr->left();
   Expression* right = expr->right();
 
   // Call the runtime to find the boolean value of the left-hand
   // subexpression.  Duplicate the value if it may be needed as the final
   // result.
   if (left->AsLiteral() != NULL) {
     __ mov(r0, Operand(left->AsLiteral()->handle()));
     __ push(r0);
-    if (destination.is_temporary()) __ push(r0);
+    if (destination.is_value()) __ push(r0);
   } else {
     Visit(left);
-    ASSERT(left->location().is_temporary());
-    if (destination.is_temporary()) {
+    ASSERT(left->location().is_value());
+    if (destination.is_value()) {
       __ ldr(r0, MemOperand(sp));
       __ push(r0);
     }
   }
   // The left-hand value is in on top of the stack.  It is duplicated on the
   // stack iff the destination location is temporary.
   __ CallRuntime(Runtime::kToBool, 1);
   __ LoadRoot(ip, Heap::kTrueValueRootIndex);
   __ cmp(r0, ip);
   __ b(eq, &done);
 
   // Discard the left-hand value if present on the stack.
-  if (destination.is_temporary()) __ pop();
+  if (destination.is_value()) __ pop();
   // Save or discard the right-hand value as needed.
   if (right->AsLiteral() != NULL) {
     Move(destination, right->AsLiteral());
   } else {
     Visit(right);
     Move(destination, right->location());
   }
 
   __ bind(&done);
 }
 
 } }  // namespace v8::internal