Move the Location class into the AST Expression class as a member....

src/x64/fast-codegen-x64.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 98 matching lines @@
     // (3 + 1 + 3).
     const int kPadding = Debug::kX64JSReturnSequenceLength - 7;
     for (int i = 0; i < kPadding; ++i) {
       masm_->int3();
     }
 #endif
   }
 }
 
 
-void FastCodeGenerator::Move(Location destination, Slot* source) {
-  switch (destination.type()) {
-    case Location::kUninitialized:
+void FastCodeGenerator::Move(Expression::Context context, Slot* source) {
+  switch (context) {
+    case Expression::kUninitialized:
       UNREACHABLE();
-    case Location::kEffect:
+    case Expression::kEffect:
       break;
-    case Location::kValue:
+    case Expression::kValue:
       __ push(Operand(rbp, SlotOffset(source)));
       break;
   }
 }
 
 
-void FastCodeGenerator::Move(Location destination, Literal* expr) {
-  switch (destination.type()) {
-    case Location::kUninitialized:
+void FastCodeGenerator::Move(Expression::Context context, Literal* expr) {
+  switch (context) {
+    case Expression::kUninitialized:
       UNREACHABLE();
-    case Location::kEffect:
+    case Expression::kEffect:
       break;
-    case Location::kValue:
+    case Expression::kValue:
       __ Push(expr->handle());
       break;
   }
 }
 
 
-void FastCodeGenerator::Move(Slot* destination, Location source) {
-  switch (source.type()) {
-    case Location::kUninitialized:  // Fall through.
-    case Location::kEffect:
+void FastCodeGenerator::DropAndMove(Expression::Context context,
+                                    Register source) {
+  switch (context) {
+    case Expression::kUninitialized:
       UNREACHABLE();
-    case Location::kValue:
-      __ pop(Operand(rbp, SlotOffset(destination)));
-      break;
-  }
-}
-
-
-void FastCodeGenerator::DropAndMove(Location destination, Register source) {
-  switch (destination.type()) {
-    case Location::kUninitialized:
-      UNREACHABLE();
-    case Location::kEffect:
+    case Expression::kEffect:
       __ addq(rsp, Immediate(kPointerSize));
       break;
-    case Location::kValue:
+    case Expression::kValue:
       __ movq(Operand(rsp, 0), source);
       break;
   }
 }
 
 
 void FastCodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
   // Call the runtime to declare the globals.
   __ push(rsi);  // The context is the first argument.
   __ Push(pairs);
   __ Push(Smi::FromInt(is_eval_ ? 1 : 0));
   __ CallRuntime(Runtime::kDeclareGlobals, 3);
   // Return value is ignored.
 }
 
 
 void FastCodeGenerator::VisitReturnStatement(ReturnStatement* stmt) {
   Comment cmnt(masm_, "[ ReturnStatement");
   SetStatementPosition(stmt);
   Expression* expr = stmt->expression();
   // Complete the statement based on the type of the subexpression.
-  if (expr->AsLiteral() != NULL) {
-    __ Move(rax, expr->AsLiteral()->handle());
-  } else {
-    Visit(expr);
-    Move(rax, expr->location());
-  }
+  Visit(expr);
+  ASSERT_EQ(Expression::kValue, expr->context());
+  __ pop(rax);
 
   if (FLAG_trace) {
     __ push(rax);
     __ CallRuntime(Runtime::kTraceExit, 1);
   }
 
   __ RecordJSReturn();
   // Do not use the leave instruction here because it is too short to
   // patch with the code required by the debugger.
   __ movq(rsp, rbp);
@@ skipping 17 matching lines @@
   // Build the function boilerplate and instantiate it.
   Handle<JSFunction> boilerplate = BuildBoilerplate(expr);
   if (HasStackOverflow()) return;
 
   ASSERT(boilerplate->IsBoilerplate());
 
   // Create a new closure.
   __ push(rsi);
   __ Push(boilerplate);
   __ CallRuntime(Runtime::kNewClosure, 2);
-  Move(expr->location(), rax);
+  Move(expr->context(), rax);
 }
 
 
 void FastCodeGenerator::VisitVariableProxy(VariableProxy* expr) {
   Comment cmnt(masm_, "[ VariableProxy");
   Expression* rewrite = expr->var()->rewrite();
   if (rewrite == NULL) {
     Comment cmnt(masm_, "Global variable");
     // Use inline caching. Variable name is passed in rcx and the global
     // object on the stack.
     __ push(CodeGenerator::GlobalObject());
     __ Move(rcx, expr->name());
     Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
     __ Call(ic, RelocInfo::CODE_TARGET_CONTEXT);
 
     // A test rax instruction following the call is used by the IC to
     // indicate that the inobject property case was inlined.  Ensure there
     // is no test rax instruction here.
-    DropAndMove(expr->location(), rax);
+    DropAndMove(expr->context(), rax);
   } else {
     Comment cmnt(masm_, "Stack slot");
-    Move(expr->location(), rewrite->AsSlot());
+    Move(expr->context(), rewrite->AsSlot());
   }
 }
 
 
 void FastCodeGenerator::VisitRegExpLiteral(RegExpLiteral* expr) {
   Comment cmnt(masm_, "[ RegExp Literal");
   Label done;
   // Registers will be used as follows:
   // rdi = JS function.
   // rbx = literals array.
   // rax = regexp literal.
   __ movq(rdi, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
   __ movq(rbx, FieldOperand(rdi, JSFunction::kLiteralsOffset));
   int literal_offset =
     FixedArray::kHeaderSize + expr->literal_index() * kPointerSize;
   __ movq(rax, FieldOperand(rbx, literal_offset));
   __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
   __ j(not_equal, &done);
   // Create regexp literal using runtime function
   // Result will be in rax.
   __ push(rbx);
   __ Push(Smi::FromInt(expr->literal_index()));
   __ Push(expr->pattern());
   __ Push(expr->flags());
   __ CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
   // Label done:
   __ bind(&done);
-  Move(expr->location(), rax);
+  Move(expr->context(), rax);
 }
 
 
 void FastCodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
   Comment cmnt(masm_, "[ ObjectLiteral");
   Label boilerplate_exists;
 
   __ movq(rdi, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
   __ movq(rbx, FieldOperand(rdi, JSFunction::kLiteralsOffset));
   int literal_offset =
@@ skipping 32 matching lines @@
     if (!result_saved) {
       __ push(rax);  // Save result on the stack
       result_saved = true;
     }
     switch (property->kind()) {
       case ObjectLiteral::Property::MATERIALIZED_LITERAL:  // fall through
         ASSERT(!CompileTimeValue::IsCompileTimeValue(value));
       case ObjectLiteral::Property::COMPUTED:
         if (key->handle()->IsSymbol()) {
           Visit(value);
-          ASSERT(value->location().is_value());
+          ASSERT_EQ(Expression::kValue, value->context());
           __ pop(rax);
           __ Move(rcx, 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(rax);
         Visit(key);
-        ASSERT(key->location().is_value());
+        ASSERT_EQ(Expression::kValue, key->context());
         Visit(value);
-        ASSERT(value->location().is_value());
+        ASSERT_EQ(Expression::kValue, value->context());
         __ CallRuntime(Runtime::kSetProperty, 3);
         __ movq(rax, Operand(rsp, 0));  // Restore result into rax.
         break;
       case ObjectLiteral::Property::SETTER:  // fall through
       case ObjectLiteral::Property::GETTER:
         __ push(rax);
         Visit(key);
-        ASSERT(key->location().is_value());
+        ASSERT_EQ(Expression::kValue, key->context());
         __ Push(property->kind() == ObjectLiteral::Property::SETTER ?
                 Smi::FromInt(1) :
                 Smi::FromInt(0));
         Visit(value);
-        ASSERT(value->location().is_value());
+        ASSERT_EQ(Expression::kValue, value->context());
         __ CallRuntime(Runtime::kDefineAccessor, 4);
         __ movq(rax, Operand(rsp, 0));  // Restore result into rax.
         break;
       default: UNREACHABLE();
     }
   }
-  switch (expr->location().type()) {
-    case Location::kUninitialized:
+  switch (expr->context()) {
+    case Expression::kUninitialized:
       UNREACHABLE();
-    case Location::kEffect:
+    case Expression::kEffect:
       if (result_saved) __ addq(rsp, Immediate(kPointerSize));
       break;
-    case Location::kValue:
+    case Expression::kValue:
       if (!result_saved) __ push(rax);
       break;
   }
 }
 
 
 void FastCodeGenerator::VisitArrayLiteral(ArrayLiteral* expr) {
   Comment cmnt(masm_, "[ ArrayLiteral");
   Label make_clone;
 
@@ skipping 34 matching lines @@
     if (subexpr->AsLiteral() != NULL ||
         CompileTimeValue::IsCompileTimeValue(subexpr)) {
       continue;
     }
 
     if (!result_saved) {
       __ push(rax);
       result_saved = true;
     }
     Visit(subexpr);
-    ASSERT(subexpr->location().is_value());
+    ASSERT_EQ(Expression::kValue, subexpr->context());
 
     // Store the subexpression value in the array's elements.
     __ pop(rax);  // Subexpression value.
     __ movq(rbx, Operand(rsp, 0));  // Copy of array literal.
     __ movq(rbx, FieldOperand(rbx, JSObject::kElementsOffset));
     int offset = FixedArray::kHeaderSize + (i * kPointerSize);
     __ movq(FieldOperand(rbx, offset), rax);
 
     // Update the write barrier for the array store.
     __ RecordWrite(rbx, offset, rax, rcx);
   }
 
-  switch (expr->location().type()) {
-    case Location::kUninitialized:
+  switch (expr->context()) {
+    case Expression::kUninitialized:
       UNREACHABLE();
-    case Location::kEffect:
+    case Expression::kEffect:
       if (result_saved) __ addq(rsp, Immediate(kPointerSize));
       break;
-    case Location::kValue:
+    case Expression::kValue:
       if (!result_saved) __ push(rax);
       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();

[William Hesse, 2009/10/29 15:15:25]

Why wasn't this giving an "unused" warning before?

[Kevin Millikin (Chromium), 2009/10/29 16:36:10]

Dunno.

   if (var->is_global()) {
     // Assignment to a global variable, use inline caching.  Right-hand-side
     // value is passed in rax, variable name in rcx, and the global object
     // on the stack.
 
     // Code for the right-hand-side expression depends on its type.
     if (rhs->AsLiteral() != NULL) {
       __ Move(rax, rhs->AsLiteral()->handle());
     } else {
-      ASSERT(rhs->location().is_value());
+      ASSERT_EQ(Expression::kValue, rhs->context());
       Visit(rhs);
       __ pop(rax);
     }
     __ Move(rcx, var->name());
     __ push(CodeGenerator::GlobalObject());
     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(), rax);
+    DropAndMove(expr->context(), rax);
   } 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.
       __ Move(kScratchRegister, rhs->AsLiteral()->handle());
       __ movq(Operand(rbp, SlotOffset(var->slot())), kScratchRegister);
-      Move(expr->location(), kScratchRegister);
+      Move(expr->context(), kScratchRegister);
     } else {
-      ASSERT(rhs->location().is_value());
+      ASSERT_EQ(Expression::kValue, rhs->context());
       Visit(rhs);
-      switch (expr->location().type()) {
-        case Location::kUninitialized:
+      switch (expr->context()) {
+        case Expression::kUninitialized:
           UNREACHABLE();
-        case Location::kEffect:
+        case Expression::kEffect:
           // Case 'var = temp'.  Discard right-hand-side temporary.
-          Move(var->slot(), rhs->location());
+          __ pop(Operand(rbp, SlotOffset(var->slot())));
           break;
-        case Location::kValue:
+        case Expression::kValue:
           // Case 'temp1 <- (var = temp0)'.  Preserve right-hand-side
           // temporary on the stack.
           __ movq(kScratchRegister, Operand(rsp, 0));
           __ movq(Operand(rbp, SlotOffset(var->slot())), kScratchRegister);
           break;
       }
     }
   }
 }
 
@@ skipping 23 matching lines @@
     // Do a KEYED property load.
     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 ..."
     // instruction after the call it is treated specially by the LoadIC code.
     __ nop();
     // Drop key left on the stack by IC.
     __ addq(rsp, Immediate(kPointerSize));
   }
-  switch (expr->location().type()) {
-    case Location::kUninitialized:
-      UNREACHABLE();
-    case Location::kValue:
-      __ movq(Operand(rsp, 0), rax);
-      break;
-    case Location::kEffect:
-      __ addq(rsp, Immediate(kPointerSize));
-      break;
-  }
+  DropAndMove(expr->context(), rax);
 }
 
 
 void FastCodeGenerator::VisitCall(Call* expr) {
   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());
 
   __ Push(var->name());
   // Push global object (receiver).
   __ push(CodeGenerator::GlobalObject());
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Visit(args->at(i));
-    ASSERT(args->at(i)->location().is_value());
+    ASSERT_EQ(Expression::kValue, args->at(i)->context());
   }
   // 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.
   __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
   // Discard the function left on TOS.
-  DropAndMove(expr->location(), rax);
+  DropAndMove(expr->context(), rax);
 }
 
 
-void FastCodeGenerator::VisitCallNew(CallNew* node) {
+void FastCodeGenerator::VisitCallNew(CallNew* expr) {
   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_value());
+  Visit(expr->expression());
+  ASSERT_EQ(Expression::kValue, expr->expression()->context());
   // If location is value, already on the stack,
 
   // Push global object (receiver).
   __ push(CodeGenerator::GlobalObject());
 
   // Push the arguments ("left-to-right") on the stack.
-  ZoneList<Expression*>* args = node->arguments();
+  ZoneList<Expression*>* args = expr->arguments();
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Visit(args->at(i));
-    ASSERT(args->at(i)->location().is_value());
+    ASSERT_EQ(Expression::kValue, args->at(i)->context());
     // If location is value, 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());
+  SetSourcePosition(expr->position());
 
   // Load function, arg_count into rdi and rax.
   __ Set(rax, arg_count);
   // Function is in rsp[arg_count + 1].
   __ movq(rdi, Operand(rsp, rax, times_pointer_size, kPointerSize));
 
   Handle<Code> construct_builtin(Builtins::builtin(Builtins::JSConstructCall));
   __ Call(construct_builtin, RelocInfo::CONSTRUCT_CALL);
 
   // Replace function on TOS with result in rax, or pop it.
-  DropAndMove(node->location(), rax);
+  DropAndMove(expr->context(), rax);
 }
 
 
 void FastCodeGenerator::VisitCallRuntime(CallRuntime* expr) {
   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_value());
+    ASSERT_EQ(Expression::kValue, args->at(i)->context());
   }
 
   __ CallRuntime(function, arg_count);
-  Move(expr->location(), rax);
+  Move(expr->context(), rax);
 }
 
 
 void FastCodeGenerator::VisitBinaryOperation(BinaryOperation* expr) {
   switch (expr->op()) {
     case Token::COMMA:
-      ASSERT(expr->left()->location().is_effect());
-      ASSERT_EQ(expr->right()->location().type(), expr->location().type());
+      ASSERT_EQ(Expression::kEffect, expr->left()->context());
+      ASSERT_EQ(expr->context(), expr->right()->context());
       Visit(expr->left());
       Visit(expr->right());
       break;
 
     case Token::OR:
     case Token::AND:
       EmitLogicalOperation(expr);
       break;
 
     case Token::ADD:
     case Token::SUB:
     case Token::DIV:
     case Token::MOD:
     case Token::MUL:
     case Token::BIT_OR:
     case Token::BIT_AND:
     case Token::BIT_XOR:
     case Token::SHL:
     case Token::SHR:
     case Token::SAR: {
-      ASSERT(expr->left()->location().is_value());
-      ASSERT(expr->right()->location().is_value());
+      ASSERT_EQ(Expression::kValue, expr->left()->context());
+      ASSERT_EQ(Expression::kValue, expr->right()->context());
 
       Visit(expr->left());
       Visit(expr->right());
       GenericBinaryOpStub stub(expr->op(),
                                NO_OVERWRITE,
                                NO_GENERIC_BINARY_FLAGS);
       __ CallStub(&stub);
-      Move(expr->location(), rax);
+      Move(expr->context(), rax);
 
       break;
     }
     default:
       UNREACHABLE();
   }
 }
 
 
 void FastCodeGenerator::EmitLogicalOperation(BinaryOperation* expr) {
   // Compile a short-circuited boolean operation in a non-test context.
 
   // Compile (e0 || e1) as if it were
   // (let (temp = e0) temp ? temp : e1).
   // Compile (e0 && e1) as if it were
   // (let (temp = e0) !temp ? temp : e1).
 
   Label eval_right, done;
   Label *left_true, *left_false;  // Where to branch to if lhs has that value.
   if (expr->op() == Token::OR) {
     left_true = &done;
     left_false = &eval_right;
   } else {
     left_true = &eval_right;
     left_false = &done;
   }
-  Location destination = expr->location();
+  Expression::Context context = expr->context();
   Expression* left = expr->left();
   Expression* right = expr->right();
 
   // Use the shared ToBoolean stub to find the boolean value of the
   // left-hand subexpression.  Load the value into rax to perform some
   // inlined checks assumed by the stub.
 
   // Compile the left-hand value into rax.  Put it on the stack if we may
   // need it as the value of the whole expression.
   if (left->AsLiteral() != NULL) {
     __ Move(rax, left->AsLiteral()->handle());
-    if (destination.is_value()) __ push(rax);
+    if (context == Expression::kValue) __ push(rax);
   } else {
     Visit(left);
-    ASSERT(left->location().is_value());
-    switch (destination.type()) {
-      case Location::kUninitialized:
+    ASSERT_EQ(Expression::kValue, left->context());
+    switch (context) {
+      case Expression::kUninitialized:
         UNREACHABLE();
-      case Location::kEffect:
+      case Expression::kEffect:
         // Pop the left-hand value into rax because we will not need it as the
         // final result.
         __ pop(rax);
         break;
-      case Location::kValue:
+      case Expression::kValue:
         // Copy the left-hand value into rax because we may need it as the
         // final result.
         __ movq(rax, Operand(rsp, 0));
         break;
     }
   }
   // The left-hand value is in rax.  It is also on the stack iff the
   // destination location is value.
 
   // Perform fast checks assumed by the stub.
@@ skipping 16 matching lines @@
   __ CallStub(&stub);
   __ testq(rax, rax);  // The stub returns nonzero for true.
   if (expr->op() == Token::OR) {
     __ j(not_zero, &done);
   } else {
     __ j(zero, &done);
   }
 
   __ bind(&eval_right);
   // Discard the left-hand value if present on the stack.
-  if (destination.is_value()) {
+  if (context == Expression::kValue) {
     __ addq(rsp, Immediate(kPointerSize));
   }
   // Save or discard the right-hand value as needed.
   Visit(right);
-  ASSERT_EQ(destination.type(), right->location().type());
+  ASSERT_EQ(context, right->context());
 
   __ bind(&done);
 }
 
 
 } }  // namespace v8::internal