x64 code generation for construct calls, declaring global variables...

src/x64/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 105 matching lines @@
       scope_(NULL),
       frame_(NULL),
       allocator_(NULL),
       state_(NULL),
       loop_nesting_(0),
       function_return_is_shadowed_(false),
       in_spilled_code_(false) {
 }
 
 
-void CodeGenerator::DeclareGlobals(Handle<FixedArray> a) {
-  UNIMPLEMENTED();
+void CodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
+  // Call the runtime to declare the globals.  The inevitable call
+  // will sync frame elements to memory anyway, so we do it eagerly to
+  // allow us to push the arguments directly into place.
+  frame_->SyncRange(0, frame_->element_count() - 1);
+
+  __ movq(kScratchRegister, pairs, RelocInfo::EMBEDDED_OBJECT);
+  frame_->EmitPush(kScratchRegister);
+  frame_->EmitPush(rsi);  // The context is the second argument.
+  frame_->EmitPush(Immediate(Smi::FromInt(is_eval() ? 1 : 0)));
+  Result ignored = frame_->CallRuntime(Runtime::kDeclareGlobals, 3);
+  // Return value is ignored.
 }
 
+
 void CodeGenerator::TestCodeGenerator() {
   // Compile a function from a string, and run it.
 
   // Set flags appropriately for this stage of implementation.
   // TODO(X64): Make ic work, and stop disabling them.
   // These settings stick - remove them when we don't want them anymore.
 #ifdef DEBUG
   FLAG_print_builtin_source = true;
   FLAG_print_builtin_ast = true;
 #endif
@@ skipping 139 matching lines @@
       Comment cmnt(masm_, "[ function body");
 #ifdef DEBUG
       bool is_builtin = Bootstrapper::IsActive();
       bool should_trace =
           is_builtin ? FLAG_trace_builtin_calls : FLAG_trace_calls;
       if (should_trace) {
         frame_->CallRuntime(Runtime::kDebugTrace, 0);
         // Ignore the return value.
       }
 #endif
+      VisitStatements(body);
+
+      // Handle the return from the function.
+      if (has_valid_frame()) {
+        // If there is a valid frame, control flow can fall off the end of
+        // the body.  In that case there is an implicit return statement.
+        ASSERT(!function_return_is_shadowed_);
+        CodeForReturnPosition(function);
+        frame_->PrepareForReturn();
+        Result undefined(Factory::undefined_value());
+        if (function_return_.is_bound()) {
+          function_return_.Jump(&undefined);
+        } else {
+          function_return_.Bind(&undefined);
+          GenerateReturnSequence(&undefined);
+        }
+      } else if (function_return_.is_linked()) {
+        // If the return target has dangling jumps to it, then we have not
+        // yet generated the return sequence.  This can happen when (a)
+        // control does not flow off the end of the body so we did not
+        // compile an artificial return statement just above, and (b) there
+        // are return statements in the body but (c) they are all shadowed.
+        Result return_value;
+        function_return_.Bind(&return_value);
+        GenerateReturnSequence(&return_value);
+      }
     }
+  }
 
-    VisitStatements(body);
-  }
   // Adjust for function-level loop nesting.
   loop_nesting_ -= function->loop_nesting();
 
   // Code generation state must be reset.
   ASSERT(state_ == NULL);
   ASSERT(loop_nesting() == 0);
   ASSERT(!function_return_is_shadowed_);
   function_return_.Unuse();
   DeleteFrame();
 
@@ skipping 1009 matching lines @@
     CallWithArguments(args, node->position());
   }
 }
 
 
 void CodeGenerator::VisitCallEval(CallEval* a) {
   UNIMPLEMENTED();
 }
 
 
-void CodeGenerator::VisitCallNew(CallNew* a) {
-  UNIMPLEMENTED();
+void CodeGenerator::VisitCallNew(CallNew* node) {
+  Comment cmnt(masm_, "[ CallNew");
+  CodeForStatementPosition(node);
+
+  // According to ECMA-262, section 11.2.2, page 44, the function
+  // expression in new calls must be evaluated before the
+  // arguments. This is different from ordinary calls, where the
+  // actual function to call is resolved after the arguments have been
+  // evaluated.
+
+  // Compute function to call and use the global object as the
+  // receiver. There is no need to use the global proxy here because
+  // it will always be replaced with a newly allocated object.
+  Load(node->expression());
+  LoadGlobal();
+
+  // 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++) {
+    Load(args->at(i));
+  }
+
+  // Call the construct call builtin that handles allocation and
+  // constructor invocation.
+  CodeForSourcePosition(node->position());
+  Result result = frame_->CallConstructor(arg_count);
+  // Replace the function on the stack with the result.
+  frame_->SetElementAt(0, &result);
 }
 
 
-void CodeGenerator::VisitCallRuntime(CallRuntime* a) {
-  UNIMPLEMENTED();
+void CodeGenerator::VisitCallRuntime(CallRuntime* node) {
+  if (CheckForInlineRuntimeCall(node)) {
+    return;
+  }
+
+  ZoneList<Expression*>* args = node->arguments();
+  Comment cmnt(masm_, "[ CallRuntime");
+  Runtime::Function* function = node->function();
+
+  if (function == NULL) {
+    // Prepare stack for calling JS runtime function.
+    frame_->Push(node->name());
+    // Push the builtins object found in the current global object.
+    Result temp = allocator()->Allocate();

[William Hesse, 2009/06/24 07:55:57]

Use kScratchRegister here.

[Mads Ager (chromium), 2009/06/24 08:18:50]

Done.

+    ASSERT(temp.is_valid());
+    __ movq(temp.reg(), GlobalObject());
+    __ movq(temp.reg(),
+            FieldOperand(temp.reg(), GlobalObject::kBuiltinsOffset));
+    frame_->Push(&temp);
+  }
+
+  // Push the arguments ("left-to-right").
+  int arg_count = args->length();
+  for (int i = 0; i < arg_count; i++) {
+    Load(args->at(i));
+  }
+
+  if (function == NULL) {
+    // Call the JS runtime function.
+    Result answer = frame_->CallCallIC(RelocInfo::CODE_TARGET,
+                                       arg_count,
+                                       loop_nesting_);
+    frame_->RestoreContextRegister();
+    frame_->SetElementAt(0, &answer);
+  } else {
+    // Call the C runtime function.
+    Result answer = frame_->CallRuntime(function, arg_count);
+    frame_->Push(&answer);
+  }
 }
 
 
 void CodeGenerator::VisitUnaryOperation(UnaryOperation* a) {
   UNIMPLEMENTED();
 }
 
 void CodeGenerator::VisitCountOperation(CountOperation* a) {
   UNIMPLEMENTED();
 }
 
 void CodeGenerator::VisitBinaryOperation(BinaryOperation* a) {
   UNIMPLEMENTED();
 }
 
 void CodeGenerator::VisitCompareOperation(CompareOperation* a) {
   UNIMPLEMENTED();
 }
 
-void CodeGenerator::VisitThisFunction(ThisFunction* a) {
-  UNIMPLEMENTED();
+
+void CodeGenerator::VisitThisFunction(ThisFunction* node) {
+  frame_->PushFunction();
 }
 
+
 void CodeGenerator::GenerateArgumentsAccess(ZoneList<Expression*>* args) {
   UNIMPLEMENTED();
 }
 
 void CodeGenerator::GenerateArgumentsLength(ZoneList<Expression*>* args) {
   UNIMPLEMENTED();}
 
 void CodeGenerator::GenerateFastCharCodeAt(ZoneList<Expression*>* a) {
   UNIMPLEMENTED();
 }
@@ skipping 173 matching lines @@
   dest->true_target()->Branch(equal);
 
   // 'undefined' => false.
   __ Cmp(value.reg(), Factory::undefined_value());
   dest->false_target()->Branch(equal);
 
   // Smi => false iff zero.
   ASSERT(kSmiTag == 0);
   __ testq(value.reg(), value.reg());
   dest->false_target()->Branch(zero);
-  __ testq(value.reg(), Immediate(kSmiTagMask));
+  __ testl(value.reg(), Immediate(kSmiTagMask));

[William Hesse, 2009/06/24 07:55:57]

We have many of these throughout the code, and have been using testq for them. 
Since the high bits of the mask are zero, it doesn't matter which we use, but
testl can lead to a shorter encoding, I suppose.  We should be consistent, for
now.  If you plan to replacing these throughout all the code, that is OK with
me.

[Mads Ager (chromium), 2009/06/24 08:18:50]

We were using it inconsistently before.  There was a mix of the two.  I have
changed it to consistently use testl in all the x64 files.

   dest->true_target()->Branch(zero);
 
   // Call the stub for all other cases.
   frame_->Push(&value);  // Undo the Pop() from above.
   ToBooleanStub stub;
   Result temp = frame_->CallStub(&stub, 1);
   // Convert the result to a condition code.
   __ testq(temp.reg(), temp.reg());
   temp.Unuse();
   dest->Split(not_equal);
@@ skipping 493 matching lines @@
         receiver.ToRegister();
 
         Result value = cgen_->allocator()->Allocate();
         ASSERT(value.is_valid());
         DeferredReferenceGetNamedValue* deferred =
             new DeferredReferenceGetNamedValue(value.reg(),
                                                receiver.reg(),
                                                GetName());
 
         // Check that the receiver is a heap object.
-        __ testq(receiver.reg(), Immediate(kSmiTagMask));
+        __ testl(receiver.reg(), Immediate(kSmiTagMask));
         deferred->Branch(zero);
 
         __ bind(deferred->patch_site());
         // This is the map check instruction that will be patched (so we can't
         // use the double underscore macro that may insert instructions).
         // Initially use an invalid map to force a failure.
         masm->Move(kScratchRegister, Factory::null_value());
         masm->cmpq(FieldOperand(receiver.reg(), HeapObject::kMapOffset),
                    kScratchRegister);
         // This branch is always a forwards branch so it's always a fixed
@@ skipping 293 matching lines @@
       // by -1. We cannot use the overflow flag, since it is not set
       // by idiv instruction.
       ASSERT(kSmiTag == 0 && kSmiTagSize == 1);
       // TODO(X64): TODO(Smi): Smi implementation dependent constant.
       // Value is Smi::fromInt(-(1<<31)) / Smi::fromInt(-1)
       __ cmpq(rax, Immediate(0x40000000));
       __ j(equal, slow);
       // Check for negative zero result.
       __ NegativeZeroTest(rax, rcx, slow);  // use ecx = x | y
       // Tag the result and store it in register rax.
-      ASSERT(kSmiTagSize == kTimes2);  // adjust code if not the case
-      __ lea(rax, Operand(rax, rax, kTimes1, kSmiTag));
+      ASSERT(kSmiTagSize == times_2);  // adjust code if not the case
+      __ lea(rax, Operand(rax, rax, times_1, kSmiTag));
       break;
 
     case Token::MOD:
       // Divide rdx:rax by rbx.
       __ idiv(rbx);
       // Check for negative zero result.
       __ NegativeZeroTest(rdx, rcx, slow);  // use ecx = x | y
       // Move remainder to register rax.
       __ movq(rax, rdx);
       break;
@@ skipping 43 matching lines @@
           // shifting the SmiTag in at the bottom doesn't change the sign.
           ASSERT(kSmiTagSize == 1);
           __ cmpl(rax, Immediate(0xc0000000));
           __ j(sign, slow);
           __ movsxlq(rax, rax);  // Extend new sign of eax into rax.
           break;
         default:
           UNREACHABLE();
       }
       // Tag the result and store it in register eax.
-      ASSERT(kSmiTagSize == kTimes2);  // adjust code if not the case
-      __ lea(rax, Operand(rax, rax, kTimes1, kSmiTag));
+      ASSERT(kSmiTagSize == times_2);  // adjust code if not the case
+      __ lea(rax, Operand(rax, rax, times_1, kSmiTag));
       break;
 
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 void GenericBinaryOpStub::Generate(MacroAssembler* masm) {
@@ skipping 61 matching lines @@
 
 
 void CallFunctionStub::Generate(MacroAssembler* masm) {
   Label slow;
 
   // Get the function to call from the stack.
   // +2 ~ receiver, return address
   __ movq(rdi, Operand(rsp, (argc_ + 2) * kPointerSize));
 
   // Check that the function really is a JavaScript function.
-  __ testq(rdi, Immediate(kSmiTagMask));
+  __ testl(rdi, Immediate(kSmiTagMask));
   __ j(zero, &slow);
   // Goto slow case if we do not have a function.
   __ CmpObjectType(rdi, JS_FUNCTION_TYPE, rcx);
   __ j(not_equal, &slow);
 
   // Fast-case: Just invoke the function.
   ParameterCount actual(argc_);
   __ InvokeFunction(rdi, actual, JUMP_FUNCTION);
 
   // Slow-case: Non-function called.
@@ skipping 44 matching lines @@
   Label runtime;
   __ movq(rdx, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
   __ movq(rcx, Operand(rdx, StandardFrameConstants::kContextOffset));
   __ cmpq(rcx, Immediate(ArgumentsAdaptorFrame::SENTINEL));
   __ j(not_equal, &runtime);
   // Value in rcx is Smi encoded.
 
   // Patch the arguments.length and the parameters pointer.
   __ movq(rcx, Operand(rdx, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ movq(Operand(rsp, 1 * kPointerSize), rcx);
-  __ lea(rdx, Operand(rdx, rcx, kTimes4, kDisplacement));
+  __ lea(rdx, Operand(rdx, rcx, times_4, kDisplacement));
   __ movq(Operand(rsp, 2 * kPointerSize), rdx);
 
   // Do the runtime call to allocate the arguments object.
   __ bind(&runtime);
   __ TailCallRuntime(ExternalReference(Runtime::kNewArgumentsFast), 3);
 }
 
 void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) {
   // The key is in rdx and the parameter count is in rax.
 
@@ skipping 17 matching lines @@
   // Check index against formal parameters count limit passed in
   // through register rax. Use unsigned comparison to get negative
   // check for free.
   __ cmpq(rdx, rax);
   __ j(above_equal, &slow);
 
   // Read the argument from the stack and return it.
   // Shifting code depends on SmiEncoding being equivalent to left shift:
   // we multiply by four to get pointer alignment.
   ASSERT(kSmiTagSize == 1 && kSmiTag == 0);
-  __ lea(rbx, Operand(rbp, rax, kTimes4, 0));
+  __ lea(rbx, Operand(rbp, rax, times_4, 0));
   __ neg(rdx);
-  __ movq(rax, Operand(rbx, rdx, kTimes4, kDisplacement));
+  __ movq(rax, Operand(rbx, rdx, times_4, kDisplacement));
   __ Ret();
 
   // Arguments adaptor case: Check index against actual arguments
   // limit found in the arguments adaptor frame. Use unsigned
   // comparison to get negative check for free.
   __ bind(&adaptor);
   __ movq(rcx, Operand(rbx, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ cmpq(rdx, rcx);
   __ j(above_equal, &slow);
 
   // Read the argument from the stack and return it.
   // Shifting code depends on SmiEncoding being equivalent to left shift:
   // we multiply by four to get pointer alignment.
   ASSERT(kSmiTagSize == 1 && kSmiTag == 0);
-  __ lea(rbx, Operand(rbx, rcx, kTimes4, 0));
+  __ lea(rbx, Operand(rbx, rcx, times_4, 0));
   __ neg(rdx);
-  __ movq(rax, Operand(rbx, rdx, kTimes4, kDisplacement));
+  __ movq(rax, Operand(rbx, rdx, times_4, kDisplacement));
   __ Ret();
 
   // Slow-case: Handle non-smi or out-of-bounds access to arguments
   // by calling the runtime system.
   __ bind(&slow);
   __ pop(rbx);  // Return address.
   __ push(rdx);
   __ push(rbx);
   __ TailCallRuntime(ExternalReference(Runtime::kGetArgumentsProperty), 1);
 }
@@ skipping 360 matching lines @@
   __ addq(rsp, Immediate(2 * kPointerSize));  // remove markers
 
   // Restore frame pointer and return.
   __ pop(rbp);
   __ ret(0);
 }
 
 #undef __
 
 } }  // namespace v8::internal