Add X32 port into V8

src/x64/full-codegen-x64.cc

 // Copyright 2012 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 25 matching lines @@
 #include "full-codegen.h"
 #include "isolate-inl.h"
 #include "parser.h"
 #include "scopes.h"
 #include "stub-cache.h"
 
 namespace v8 {
 namespace internal {
 
 #define __ ACCESS_MASM(masm_)
+#define __k __
+#define __n __
 
 
 class JumpPatchSite BASE_EMBEDDED {
  public:
   explicit JumpPatchSite(MacroAssembler* masm) : masm_(masm) {
 #ifdef DEBUG
     info_emitted_ = false;
 #endif
   }
 
@@ skipping 77 matching lines @@
 #endif
 
   // Strict mode functions and builtins need to replace the receiver
   // with undefined when called as functions (without an explicit
   // receiver object). rcx is zero for method calls and non-zero for
   // function calls.
   if (!info->is_classic_mode() || info->is_native()) {
     Label ok;
     __ testq(rcx, rcx);
     __ j(zero, &ok, Label::kNear);
+#ifndef V8_TARGET_ARCH_X32
     // +1 for return address.
     int receiver_offset = (info->scope()->num_parameters() + 1) * kPointerSize;
+#else
+    int receiver_offset = 1 * kHWRegSize +
+                          info->scope()->num_parameters() * kPointerSize;
+#endif
     __ LoadRoot(kScratchRegister, Heap::kUndefinedValueRootIndex);
     __ movq(Operand(rsp, receiver_offset), kScratchRegister);
     __ bind(&ok);
   }
 
   // Open a frame scope to indicate that there is a frame on the stack.  The
   // MANUAL indicates that the scope shouldn't actually generate code to set up
   // the frame (that is done below).
   FrameScope frame_scope(masm_, StackFrame::MANUAL);
 
@@ skipping 158 matching lines @@
 }
 
 
 void FullCodeGenerator::EmitProfilingCounterReset() {
   int reset_value = FLAG_interrupt_budget;
   if (info_->ShouldSelfOptimize() && !FLAG_retry_self_opt) {
     // Self-optimization is a one-off thing; if it fails, don't try again.
     reset_value = Smi::kMaxValue;
   }
   __ movq(rbx, profiling_counter_, RelocInfo::EMBEDDED_OBJECT);
+#ifndef V8_TARGET_ARCH_X32
   __ movq(kScratchRegister,
           reinterpret_cast<uint64_t>(Smi::FromInt(reset_value)),
           RelocInfo::NONE64);
+#else
+  __ movl(kScratchRegister,
+          reinterpret_cast<uint32_t>(Smi::FromInt(reset_value)),
+          RelocInfo::NONE32);
+#endif
   __ movq(FieldOperand(rbx, Cell::kValueOffset), kScratchRegister);
 }
 
 
 void FullCodeGenerator::EmitBackEdgeBookkeeping(IterationStatement* stmt,
                                                 Label* back_edge_target) {
   Comment cmnt(masm_, "[ Back edge bookkeeping");
   Label ok;
 
   int weight = 1;
@@ skipping 72 matching lines @@
     __ pop(rbp);
     int no_frame_start = masm_->pc_offset();
 
     int arguments_bytes = (info_->scope()->num_parameters() + 1) * kPointerSize;
     __ Ret(arguments_bytes, rcx);
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
     // Add padding that will be overwritten by a debugger breakpoint.  We
     // have just generated at least 7 bytes: "movq rsp, rbp; pop rbp; ret k"
     // (3 + 1 + 3).
+#ifndef V8_TARGET_ARCH_X32
     const int kPadding = Assembler::kJSReturnSequenceLength - 7;
+#else
+    const int kPadding = Assembler::kJSReturnSequenceLength - 6;
+#endif
     for (int i = 0; i < kPadding; ++i) {
       masm_->int3();
     }
     // Check that the size of the code used for returning is large enough
     // for the debugger's requirements.
     ASSERT(Assembler::kJSReturnSequenceLength <=
            masm_->SizeOfCodeGeneratedSince(&check_exit_codesize));
 #endif
     info_->AddNoFrameRange(no_frame_start, masm_->pc_offset());
   }
@@ skipping 244 matching lines @@
   }
 }
 
 
 MemOperand FullCodeGenerator::StackOperand(Variable* var) {
   ASSERT(var->IsStackAllocated());
   // Offset is negative because higher indexes are at lower addresses.
   int offset = -var->index() * kPointerSize;
   // Adjust by a (parameter or local) base offset.
   if (var->IsParameter()) {
+#ifndef V8_TARGET_ARCH_X32
     offset += (info_->scope()->num_parameters() + 1) * kPointerSize;
+#else
+    offset += 2 * kHWRegSize +
+              (info_->scope()->num_parameters() - 1) * kPointerSize;
+#endif
   } else {
     offset += JavaScriptFrameConstants::kLocal0Offset;
   }
   return Operand(rbp, offset);
 }
 
 
 MemOperand FullCodeGenerator::VarOperand(Variable* var, Register scratch) {
   ASSERT(var->IsContextSlot() || var->IsStackAllocated());
   if (var->IsContextSlot()) {
@@ skipping 1433 matching lines @@
 
   // Load suspended function and context.
   __ movq(rsi, FieldOperand(rbx, JSGeneratorObject::kContextOffset));
   __ movq(rdi, FieldOperand(rbx, JSGeneratorObject::kFunctionOffset));
 
   // Push receiver.
   __ push(FieldOperand(rbx, JSGeneratorObject::kReceiverOffset));
 
   // Push holes for arguments to generator function.
   __ movq(rdx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
+#ifndef V8_TARGET_ARCH_X32
   __ movsxlq(rdx,
              FieldOperand(rdx,
                           SharedFunctionInfo::kFormalParameterCountOffset));
+#else
+  __ movl(rdx,
+          FieldOperand(rdx,
+                       SharedFunctionInfo::kFormalParameterCountOffset));
+  __ SmiToInteger32(rdx, rdx);
+#endif
   __ LoadRoot(rcx, Heap::kTheHoleValueRootIndex);
   Label push_argument_holes, push_frame;
   __ bind(&push_argument_holes);
   __ subq(rdx, Immediate(1));
   __ j(carry, &push_frame);
   __ push(rcx);
   __ jmp(&push_argument_holes);
 
   // Enter a new JavaScript frame, and initialize its slots as they were when
   // the generator was suspended.
@@ skipping 129 matching lines @@
          expr->BinaryOperationFeedbackId());
   patch_site.EmitPatchInfo();
   __ jmp(&done, Label::kNear);
 
   __ bind(&smi_case);
   switch (op) {
     case Token::SAR:
       __ SmiShiftArithmeticRight(rax, rdx, rcx);
       break;
     case Token::SHL:
+#ifndef V8_TARGET_ARCH_X32
       __ SmiShiftLeft(rax, rdx, rcx);
+#else
+      __ SmiShiftLeft(rax, rdx, rcx, &stub_call);
+#endif
       break;
     case Token::SHR:
       __ SmiShiftLogicalRight(rax, rdx, rcx, &stub_call);
       break;
     case Token::ADD:
       __ SmiAdd(rax, rdx, rcx, &stub_call);
       break;
     case Token::SUB:
       __ SmiSub(rax, rdx, rcx, &stub_call);
       break;
@@ skipping 333 matching lines @@
 
 void FullCodeGenerator::EmitResolvePossiblyDirectEval(int arg_count) {
   // Push copy of the first argument or undefined if it doesn't exist.
   if (arg_count > 0) {
     __ push(Operand(rsp, arg_count * kPointerSize));
   } else {
     __ PushRoot(Heap::kUndefinedValueRootIndex);
   }
 
   // Push the receiver of the enclosing function and do runtime call.
+#ifndef V8_TARGET_ARCH_X32
   __ push(Operand(rbp, (2 + info_->scope()->num_parameters()) * kPointerSize));
+#else
+  __ Push(Operand(rbp, 2 * kHWRegSize +
+                       info_->scope()->num_parameters() * kPointerSize));
+#endif
 
   // Push the language mode.
   __ Push(Smi::FromInt(language_mode()));
 
   // Push the start position of the scope the calls resides in.
   __ Push(Smi::FromInt(scope()->start_position()));
 
   // Do the runtime call.
   __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 5);
 }
@@ skipping 719 matching lines @@
       Operand stamp_operand = __ ExternalOperand(stamp);
       __ movq(scratch, stamp_operand);
       __ cmpq(scratch, FieldOperand(object, JSDate::kCacheStampOffset));
       __ j(not_equal, &runtime, Label::kNear);
       __ movq(result, FieldOperand(object, JSDate::kValueOffset +
                                            kPointerSize * index->value()));
       __ jmp(&done);
     }
     __ bind(&runtime);
     __ PrepareCallCFunction(2);
-  __ movq(arg_reg_1, object);
-  __ movq(arg_reg_2, index, RelocInfo::NONE64);
+    __ movq(arg_reg_1, object);
+    __n movq(arg_reg_2, index, RelocInfo::NONE64);
     __ CallCFunction(ExternalReference::get_date_field_function(isolate()), 2);
     __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
     __ jmp(&done);
   }
 
   __ bind(&not_date_object);
   __ CallRuntime(Runtime::kThrowNotDateError, 0);
   __ bind(&done);
   context()->Plug(rax);
 }
@@ skipping 734 matching lines @@
 
   // Long separator case (separator is more than one character).
   __ bind(&long_separator);
 
   // Make elements point to end of elements array, and index
   // count from -array_length to zero, so we don't need to maintain
   // a loop limit.
   __ movl(index, array_length_operand);
   __ lea(elements, FieldOperand(elements, index, times_pointer_size,
                                 FixedArray::kHeaderSize));
-  __ neg(index);
+  __k neg(index);
 
   // Replace separator string with pointer to its first character, and
   // make scratch be its length.
   __ movq(string, separator_operand);
   __ SmiToInteger32(scratch,
                     FieldOperand(string, String::kLengthOffset));
   __ lea(string,
          FieldOperand(string, SeqOneByteString::kHeaderSize));
   __ movq(separator_operand, string);
 
@@ skipping 15 matching lines @@
   __ CopyBytes(result_pos, string, string_length, 2);
 
   __ bind(&loop_3_entry);
   // Get string = array[index].
   __ movq(string, Operand(elements, index, times_pointer_size, 0));
   __ SmiToInteger32(string_length,
                     FieldOperand(string, String::kLengthOffset));
   __ lea(string,
          FieldOperand(string, SeqOneByteString::kHeaderSize));
   __ CopyBytes(result_pos, string, string_length);
-  __ incq(index);
+  __k incq(index);
   __ j(not_equal, &loop_3);  // Loop while (index < 0).
 
   __ bind(&done);
   __ movq(rax, result_operand);
 
   __ bind(&return_result);
   // Drop temp values from the stack, and restore context register.
   __ addq(rsp, Immediate(3 * kPointerSize));
   __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
   context()->Plug(rax);
@@ skipping 627 matching lines @@
 
 
 // ----------------------------------------------------------------------------
 // Non-local control flow support.
 
 
 void FullCodeGenerator::EnterFinallyBlock() {
   ASSERT(!result_register().is(rdx));
   ASSERT(!result_register().is(rcx));
   // Cook return address on top of stack (smi encoded Code* delta)
-  __ pop(rdx);
+  __k pop(rdx);
   __ Move(rcx, masm_->CodeObject());
   __ subq(rdx, rcx);
   __ Integer32ToSmi(rdx, rdx);
   __ push(rdx);
 
   // Store result register while executing finally block.
   __ push(result_register());
 
   // Store pending message while executing finally block.
   ExternalReference pending_message_obj =
@@ skipping 67 matching lines @@
   }
   __ PopTryHandler();
   __ call(finally_entry_);
 
   *stack_depth = 0;
   *context_length = 0;
   return previous_;
 }
 
 
+#undef __n
+#undef __k
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64