X64: Addition binary operation.

src/x64/macro-assembler-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 526 matching lines @@
       movq(kScratchRegister, reg_addr);
       movq(Operand(kScratchRegister, 0), scratch);
       lea(base, Operand(base, kPointerSize));
     }
   }
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 
+void MacroAssembler::InvokeBuiltin(Builtins::JavaScript id, InvokeFlag flag) {
+  bool resolved;
+  Handle<Code> code = ResolveBuiltin(id, &resolved);
+
+  // Calls are not allowed in some stubs.
+  ASSERT(flag == JUMP_FUNCTION || allow_stub_calls());
+
+  // Rely on the assertion to check that the number of provided
+  // arguments match the expected number of arguments. Fake a
+  // parameter count to avoid emitting code to do the check.
+  ParameterCount expected(0);
+  InvokeCode(Handle<Code>(code), expected, expected,
+             RelocInfo::CODE_TARGET, flag);
+
+  const char* name = Builtins::GetName(id);
+  int argc = Builtins::GetArgumentsCount(id);
+  // The target address for the jump is stored as an immediate at offset
+  // kInvokeCodeAddressOffset.
+  if (!resolved) {
+    uint32_t flags =
+        Bootstrapper::FixupFlagsArgumentsCount::encode(argc) |
+        Bootstrapper::FixupFlagsIsPCRelative::encode(true) |
+        Bootstrapper::FixupFlagsUseCodeObject::encode(false);
+    Unresolved entry = { pc_offset() - kInvokeCodeAddressOffset, flags, name };
+    unresolved_.Add(entry);
+  }
+}
+
+
+
+
 void MacroAssembler::InvokePrologue(const ParameterCount& expected,
                                     const ParameterCount& actual,
                                     Handle<Code> code_constant,
                                     Register code_register,
                                     Label* done,
                                     InvokeFlag flag) {
   bool definitely_matches = false;
   Label invoke;
   if (expected.is_immediate()) {
     ASSERT(actual.is_immediate());
@@ skipping 73 matching lines @@
 
 void MacroAssembler::InvokeCode(Handle<Code> code,
                                 const ParameterCount& expected,
                                 const ParameterCount& actual,
                                 RelocInfo::Mode rmode,
                                 InvokeFlag flag) {
   Label done;
   Register dummy = rax;
   InvokePrologue(expected, actual, code, dummy, &done, flag);
   movq(kScratchRegister, code, rmode);
+#ifdef DEBUG
+  // Address of the immediate code pointer.
+  int immediate_address = pc_offset() - kPointerSize;
+#endif
+  // The kInvokeCodeAddressOffset computations assumes the REX.B prefix
+  // on the jmp and call opcodes.
+  ASSERT_EQ(1, kScratchRegister.high_bit());
   if (flag == CALL_FUNCTION) {
     call(kScratchRegister);
   } else {
     ASSERT(flag == JUMP_FUNCTION);
     jmp(kScratchRegister);
   }
+  ASSERT_EQ(kInvokeCodeAddressOffset, immediate_address - pc_offset());
   bind(&done);
 }
 
 
 void MacroAssembler::InvokeFunction(Register function,
                                     const ParameterCount& actual,
                                     InvokeFlag flag) {
   ASSERT(function.is(rdi));
   movq(rdx, FieldOperand(function, JSFunction::kSharedFunctionInfoOffset));
   movq(rsi, FieldOperand(function, JSFunction::kContextOffset));
@@ skipping 132 matching lines @@
   push(rcx);
 
   // Clear the top frame.
   ExternalReference c_entry_fp_address(Top::k_c_entry_fp_address);
   movq(kScratchRegister, c_entry_fp_address);
   movq(Operand(kScratchRegister, 0), Immediate(0));
 }
 
 
 } }  // namespace v8::internal