WIP: new.target

src/x64/full-codegen-x64.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #if V8_TARGET_ARCH_X64
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
@@ skipping 214 matching lines @@
         } else if (FLAG_debug_code) {
           Label done;
           __ JumpIfInNewSpace(rsi, rax, &done, Label::kNear);
           __ Abort(kExpectedNewSpaceObject);
           __ bind(&done);
         }
       }
     }
   }
 
+  Variable* new_target_var = scope()->new_target_var();
+  if (new_target_var != nullptr) {
+    EmitAssignNewTarget(new_target_var);
+    new_target_var->set_initializer_position(scope()->start_position());
+  }
+
+  // TODO(arv): Remove ArgumentsAccessStub::HasNewTarget
   ArgumentsAccessStub::HasNewTarget has_new_target =
-      IsSubclassConstructor(info->function()->kind())
-          ? ArgumentsAccessStub::HAS_NEW_TARGET
-          : ArgumentsAccessStub::NO_NEW_TARGET;
+      ArgumentsAccessStub::NO_NEW_TARGET;
 
   // Possibly allocate RestParameters
   int rest_index;
   Variable* rest_param = scope()->rest_parameter(&rest_index);
   if (rest_param) {
     Comment cmnt(masm_, "[ Allocate rest parameter array");
 
     int num_parameters = info->scope()->num_parameters();
     int offset = num_parameters * kPointerSize;
     if (has_new_target == ArgumentsAccessStub::HAS_NEW_TARGET) {
@@ skipping 191 matching lines @@
     masm_->bind(&check_exit_codesize);
 #endif
     CodeGenerator::RecordPositions(masm_, function()->end_position() - 1);
     __ RecordJSReturn();
     // Do not use the leave instruction here because it is too short to
     // patch with the code required by the debugger.
     __ movp(rsp, rbp);
     __ popq(rbp);
     int no_frame_start = masm_->pc_offset();
 
-    int arg_count = info_->scope()->num_parameters() + 1;
-    if (IsSubclassConstructor(info_->function()->kind())) {
-      arg_count++;
+    int offset = info_->scope()->num_parameters() + 1;
+    if (scope()->uses_new_target()) {
+      offset++;
     }
-    int arguments_bytes = arg_count * kPointerSize;
-    __ Ret(arguments_bytes, rcx);
+    __ Ret(offset * kPointerSize, rcx);
 
     // Add padding that will be overwritten by a debugger breakpoint.  We
     // have just generated at least 7 bytes: "movp rsp, rbp; pop rbp; ret k"
     // (3 + 1 + 3) for x64 and at least 6 (2 + 1 + 3) bytes for x32.
     const int kPadding = Assembler::kJSReturnSequenceLength -
                          kPointerSize == kInt64Size ? 7 : 6;
     for (int i = 0; i < kPadding; ++i) {
       masm_->int3();
     }
     // Check that the size of the code used for returning is large enough
@@ skipping 2550 matching lines @@
   Label uninitialized_this;
   __ j(equal, &uninitialized_this);
   __ Push(this_var->name());
   __ CallRuntime(Runtime::kThrowReferenceError, 1);
   __ bind(&uninitialized_this);
 
   EmitVariableAssignment(this_var, Token::INIT_CONST);
 }
 
 
+void FullCodeGenerator::EmitAssignNewTarget(Variable* new_target_var) {
+  __ CallRuntime(Runtime::kGetNewTarget, 0);
+
+  // Register fp = rax;
+  // // Register count = rbx;
+  // // Register scratch = rcx;
+
+  // // Get the frame pointer for the calling frame.
+  // __ movp(fp, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
+
+  // // Skip the arguments adaptor frame if it exists.
+  // Label check_frame_marker, construct_frame, assign;
+
+  // __ Cmp(Operand(fp, StandardFrameConstants::kContextOffset),
+  //        Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
+  // __ j(not_equal, &check_frame_marker, Label::kNear);
+  // __ movp(fp, Operand(fp, StandardFrameConstants::kCallerFPOffset));
+
+  // // Check the marker in the calling frame.
+  // __ bind(&check_frame_marker);
+  // __ Cmp(Operand(fp, StandardFrameConstants::kMarkerOffset),
+  //        Smi::FromInt(StackFrame::CONSTRUCT));
+  // __ j(equal, &construct_frame, Label::kNear);
+
+  // // [[Call]] always return undefined
+  // __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
+  // __ jmp(&assign, Label::kNear);
+
+  // // [[Construct]] get new.target from stack.
+  // __ bind(&construct_frame);
+
+  // // Get the number of formal parameters.
+  // // __ Move(count, Smi::FromInt(info_->scope()->num_parameters()));
+
+  // // Label length_done;
+  // // // TODO(arv): Don't check this again...
+  // // // Check if the calling frame is an arguments adaptor frame.
+  // // __ movp(scratch, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
+  // // __ Cmp(Operand(scratch, StandardFrameConstants::kContextOffset),
+  // //        Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
+  // // __ j(not_equal, &length_done, Label::kNear);
+
+  // // // Arguments adaptor case: Read the arguments length from the
+  // // // adaptor frame.
+  // // __ movp(count, Operand(rbx,
+  // ArgumentsAdaptorFrameConstants::kLengthOffset));
+
+  // // __ bind(&length_done);
+
+  // // // static const int kNewTargetOffset = kFPOnStackSize + kPCOnStackSize;
+  // // static const int kNewTargetOffset = 3 * kPointerSize;
+
+  // // __ leap(rax, Operand(fp, count, times_pointer_size, kNewTargetOffset));
+
+  // __ movp(rax, Operand(fp, (3 + info_->scope()->num_parameters()) *
+  // kPointerSize));
+
+  // __ bind(&assign);
+  EmitVariableAssignment(new_target_var, Token::INIT_CONST);
+}
+
+
 void FullCodeGenerator::VisitCall(Call* expr) {
 #ifdef DEBUG
   // We want to verify that RecordJSReturnSite gets called on all paths
   // through this function.  Avoid early returns.
   expr->return_is_recorded_ = false;
 #endif
 
   Comment cmnt(masm_, "[ Call");
   Expression* callee = expr->expression();
   Call::CallType call_type = expr->GetCallType(isolate());
@@ skipping 1085 matching lines @@
   __ movp(rax, Immediate(0));
   __ jmp(&args_set_up);
 
   // Copy arguments from adaptor frame.
   {
     __ bind(&adaptor_frame);
     __ movp(rcx, Operand(rdx, ArgumentsAdaptorFrameConstants::kLengthOffset));
     __ SmiToInteger64(rcx, rcx);
 
     // Subtract 1 from arguments count, for new.target.
-    __ subp(rcx, Immediate(1));
+    // TODO(arv): FIXME!
+    // __ subp(rcx, Immediate(1));
     __ movp(rax, rcx);
     __ leap(rdx, Operand(rdx, rcx, times_pointer_size,
                          StandardFrameConstants::kCallerSPOffset));
     Label loop;
     __ bind(&loop);
     __ Push(Operand(rdx, -1 * kPointerSize));
     __ subp(rdx, Immediate(kPointerSize));
     __ decp(rcx);
     __ j(not_zero, &loop);
   }
@@ skipping 1275 matching lines @@
   DCHECK_EQ(isolate->builtins()->OsrAfterStackCheck()->entry(),
             Assembler::target_address_at(call_target_address,
                                          unoptimized_code));
   return OSR_AFTER_STACK_CHECK;
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64