Add X32 port into V8

src/x64/deoptimizer-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 66 matching lines @@
 #endif
   DeoptimizationInputData* deopt_data =
       DeoptimizationInputData::cast(code->deoptimization_data());
   for (int i = 0; i < deopt_data->DeoptCount(); i++) {
     if (deopt_data->Pc(i)->value() == -1) continue;
     // Position where Call will be patched in.
     Address call_address = instruction_start + deopt_data->Pc(i)->value();
     // There is room enough to write a long call instruction because we pad
     // LLazyBailout instructions with nops if necessary.
     CodePatcher patcher(call_address, Assembler::kCallInstructionLength);
+#ifndef V8_TARGET_ARCH_X32
     patcher.masm()->Call(GetDeoptimizationEntry(isolate, i, LAZY),
                          RelocInfo::NONE64);
+#else
+    patcher.masm()->Call(GetDeoptimizationEntry(isolate, i, LAZY),
+                         RelocInfo::NONE32);
+#endif
     ASSERT(prev_call_address == NULL ||
            call_address >= prev_call_address + patch_size());
     ASSERT(call_address + patch_size() <= code->instruction_end());
 #ifdef DEBUG
     prev_call_address = call_address;
 #endif
   }
 
   // Add the deoptimizing code to the list.
   DeoptimizingCodeListNode* node = new DeoptimizingCodeListNode(code);
@@ skipping 10 matching lines @@
 
   if (FLAG_trace_deopt) {
     PrintF("[forced deoptimization: ");
     function->PrintName();
     PrintF(" / %" V8PRIxPTR "]\n", reinterpret_cast<intptr_t>(function));
   }
 }
 
 
 static const byte kJnsInstruction = 0x79;
+#ifndef V8_TARGET_ARCH_X32
 static const byte kJnsOffset = 0x1d;
+#else
+static const byte kJnsOffset = 0x14;
+#endif
 static const byte kCallInstruction = 0xe8;
 static const byte kNopByteOne = 0x66;
 static const byte kNopByteTwo = 0x90;
 
 // The back edge bookkeeping code matches the pattern:
 //
 //     add <profiling_counter>, <-delta>
 //     jns ok
 //     call <stack guard>
 //   ok:
@@ skipping 167 matching lines @@
   int limit = input_offset - (parameter_count * kPointerSize);
   while (ok && input_offset > limit) {
     ok = DoOsrTranslateCommand(&iterator, &input_offset);
   }
 
   // There are no translation commands for the caller's pc and fp, the
   // context, and the function.  Set them up explicitly.
   for (int i = StandardFrameConstants::kCallerPCOffset;
        ok && i >=  StandardFrameConstants::kMarkerOffset;
        i -= kPointerSize) {
+#ifdef V8_TARGET_ARCH_X32
+    if (i == StandardFrameConstants::kCallerPCOffset ||
+        i == StandardFrameConstants::kCallerFPOffset) {
+      // Set the high-32 bit of PC and FP to 0.
+      output_[0]->SetFrameSlot(output_offset, 0);
+      input_offset -= kPointerSize;
+      output_offset -= kPointerSize;
+    }
+#endif
     intptr_t input_value = input_->GetFrameSlot(input_offset);
     if (FLAG_trace_osr) {
       const char* name = "UNKNOWN";
       switch (i) {
         case StandardFrameConstants::kCallerPCOffset:
           name = "caller's pc";
           break;
         case StandardFrameConstants::kCallerFPOffset:
           name = "fp";
           break;
         case StandardFrameConstants::kContextOffset:
           name = "context";
           break;
         case StandardFrameConstants::kMarkerOffset:
           name = "function";
           break;
       }
       PrintF("    [rsp + %d] <- 0x%08" V8PRIxPTR " ; [rsp + %d] "
              "(fixed part - %s)\n",
              output_offset,
              input_value,
              input_offset,
              name);
     }
     output_[0]->SetFrameSlot(output_offset, input_->GetFrameSlot(input_offset));
     input_offset -= kPointerSize;
     output_offset -= kPointerSize;
+#ifdef V8_TARGET_ARCH_X32
+    if (i == StandardFrameConstants::kCallerPCOffset) {
+      i -= kHWRegSize - kPointerSize;
+    }
+#endif
   }
 
   // Translate the rest of the frame.
   while (ok && input_offset >= 0) {
     ok = DoOsrTranslateCommand(&iterator, &input_offset);
   }
 
   // If translation of any command failed, continue using the input frame.
   if (!ok) {
     delete output_[0];
@@ skipping 32 matching lines @@
     input_->SetRegister(i, i * 4);
   }
   input_->SetRegister(rsp.code(), reinterpret_cast<intptr_t>(frame->sp()));
   input_->SetRegister(rbp.code(), reinterpret_cast<intptr_t>(frame->fp()));
   for (int i = 0; i < DoubleRegister::NumAllocatableRegisters(); i++) {
     input_->SetDoubleRegister(i, 0.0);
   }
 
   // Fill the frame content from the actual data on the frame.
   for (unsigned i = 0; i < input_->GetFrameSize(); i += kPointerSize) {
+#ifndef V8_TARGET_ARCH_X32
     input_->SetFrameSlot(i, Memory::uint64_at(tos + i));
+#else
+    input_->SetFrameSlot(i, Memory::uint32_at(tos + i));
+#endif
   }
 }
 
 
 void Deoptimizer::SetPlatformCompiledStubRegisters(
     FrameDescription* output_frame, CodeStubInterfaceDescriptor* descriptor) {
   intptr_t handler =
       reinterpret_cast<intptr_t>(descriptor->deoptimization_handler_);
   int params = descriptor->register_param_count_;
   if (descriptor->stack_parameter_count_ != NULL) {
@@ skipping 12 matching lines @@
 }
 
 
 bool Deoptimizer::HasAlignmentPadding(JSFunction* function) {
   // There is no dynamic alignment padding on x64 in the input frame.
   return false;
 }
 
 
 #define __ masm()->
+#define __k __
+#define __q __
 
 void Deoptimizer::EntryGenerator::Generate() {
   GeneratePrologue();
 
   // Save all general purpose registers before messing with them.
   const int kNumberOfRegisters = Register::kNumRegisters;
 
   const int kDoubleRegsSize = kDoubleSize *
       XMMRegister::NumAllocatableRegisters();
   __ subq(rsp, Immediate(kDoubleRegsSize));
 
   for (int i = 0; i < XMMRegister::NumAllocatableRegisters(); ++i) {
     XMMRegister xmm_reg = XMMRegister::FromAllocationIndex(i);
     int offset = i * kDoubleSize;
     __ movsd(Operand(rsp, offset), xmm_reg);
   }
 
   // We push all registers onto the stack, even though we do not need
   // to restore all later.
   for (int i = 0; i < kNumberOfRegisters; i++) {
     Register r = Register::from_code(i);
-    __ push(r);
+    __k push(r);
   }
 
+#ifndef V8_TARGET_ARCH_X32
   const int kSavedRegistersAreaSize = kNumberOfRegisters * kPointerSize +
                                       kDoubleRegsSize;
+#else
+  const int kSavedRegistersAreaSize = kNumberOfRegisters * kHWRegSize +
+                                      kDoubleRegsSize;
+#endif
 
   // We use this to keep the value of the fifth argument temporarily.
   // Unfortunately we can't store it directly in r8 (used for passing
   // this on linux), since it is another parameter passing register on windows.
   Register arg5 = r11;
 
   // Get the bailout id from the stack.
   __ movq(arg_reg_3, Operand(rsp, kSavedRegistersAreaSize));
 
   // Get the address of the location in the code object if possible
   // and compute the fp-to-sp delta in register arg5.
   if (type() == EAGER || type() == SOFT) {
     __ Set(arg_reg_4, 0);
-    __ lea(arg5, Operand(rsp, kSavedRegistersAreaSize + 1 * kPointerSize));
+    __q lea(arg5, Operand(rsp, kSavedRegistersAreaSize + 1 * kPointerSize));
   } else {
+#ifndef V8_TARGET_ARCH_X32
     __ movq(arg_reg_4,
             Operand(rsp, kSavedRegistersAreaSize + 1 * kPointerSize));
-    __ lea(arg5, Operand(rsp, kSavedRegistersAreaSize + 2 * kPointerSize));
+#else
+    __ movl(arg_reg_4, Operand(rsp, kSavedRegistersAreaSize + 1 * kHWRegSize));
+#endif
+    __q lea(arg5, Operand(rsp, kSavedRegistersAreaSize + 2 * kPointerSize));
   }
 
   __ subq(arg5, rbp);
   __ neg(arg5);
 
   // Allocate a new deoptimizer object.
   __ PrepareCallCFunction(6);
   __ movq(rax, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
   __ movq(arg_reg_1, rax);
   __ Set(arg_reg_2, type());
@@ skipping 13 matching lines @@
   { AllowExternalCallThatCantCauseGC scope(masm());
     __ CallCFunction(ExternalReference::new_deoptimizer_function(isolate()), 6);
   }
   // Preserve deoptimizer object in register rax and get the input
   // frame descriptor pointer.
   __ movq(rbx, Operand(rax, Deoptimizer::input_offset()));
 
   // Fill in the input registers.
   for (int i = kNumberOfRegisters -1; i >= 0; i--) {
     int offset = (i * kPointerSize) + FrameDescription::registers_offset();
+#ifndef V8_TARGET_ARCH_X32
     __ pop(Operand(rbx, offset));
+#else
+    __ pop(kScratchRegister);
+    __ movl(Operand(rbx, offset), kScratchRegister);
+#endif
   }
 
   // Fill in the double input registers.
   int double_regs_offset = FrameDescription::double_registers_offset();
   for (int i = 0; i < XMMRegister::NumAllocatableRegisters(); i++) {
     int dst_offset = i * kDoubleSize + double_regs_offset;
-    __ pop(Operand(rbx, dst_offset));
+    __k pop(Operand(rbx, dst_offset));
   }
 
   // Remove the bailout id from the stack.
   if (type() == EAGER || type() == SOFT) {
-    __ addq(rsp, Immediate(kPointerSize));
+    __q addq(rsp, Immediate(kPointerSize));
   } else {
-    __ addq(rsp, Immediate(2 * kPointerSize));
+    __q addq(rsp, Immediate(2 * kPointerSize));
   }
 
   // Compute a pointer to the unwinding limit in register rcx; that is
   // the first stack slot not part of the input frame.
   __ movq(rcx, Operand(rbx, FrameDescription::frame_size_offset()));
   __ addq(rcx, rsp);
 
   // Unwind the stack down to - but not including - the unwinding
   // limit and copy the contents of the activation frame to the input
   // frame description.
   __ lea(rdx, Operand(rbx, FrameDescription::frame_content_offset()));
   Label pop_loop_header;
   __ jmp(&pop_loop_header);
   Label pop_loop;
   __ bind(&pop_loop);
   __ pop(Operand(rdx, 0));
   __ addq(rdx, Immediate(sizeof(intptr_t)));
   __ bind(&pop_loop_header);
   __ cmpq(rcx, rsp);
   __ j(not_equal, &pop_loop);
 
   // Compute the output frame in the deoptimizer.
-  __ push(rax);
+  __k push(rax);
   __ PrepareCallCFunction(2);
   __ movq(arg_reg_1, rax);
   __ LoadAddress(arg_reg_2, ExternalReference::isolate_address(isolate()));
   {
     AllowExternalCallThatCantCauseGC scope(masm());
     __ CallCFunction(
         ExternalReference::compute_output_frames_function(isolate()), 2);
   }
-  __ pop(rax);
+  __k pop(rax);
 
   // Replace the current frame with the output frames.
   Label outer_push_loop, inner_push_loop,
       outer_loop_header, inner_loop_header;
   // Outer loop state: rax = current FrameDescription**, rdx = one past the
   // last FrameDescription**.
   __ movl(rdx, Operand(rax, Deoptimizer::output_count_offset()));
   __ movq(rax, Operand(rax, Deoptimizer::output_offset()));
   __ lea(rdx, Operand(rax, rdx, times_pointer_size, 0));
   __ jmp(&outer_loop_header);
@@ skipping 14 matching lines @@
   __ j(below, &outer_push_loop);
 
   for (int i = 0; i < XMMRegister::NumAllocatableRegisters(); ++i) {
     XMMRegister xmm_reg = XMMRegister::FromAllocationIndex(i);
     int src_offset = i * kDoubleSize + double_regs_offset;
     __ movsd(xmm_reg, Operand(rbx, src_offset));
   }
 
   // Push state, pc, and continuation from the last output frame.
   if (type() != OSR) {
+#ifdef V8_TARGET_ARCH_X32
+    __ Push(Immediate(0));
+#endif
     __ push(Operand(rbx, FrameDescription::state_offset()));
   }
+#ifdef V8_TARGET_ARCH_X32
+  __ Push(Immediate(0));
+#endif
   __ push(Operand(rbx, FrameDescription::pc_offset()));
+#ifdef V8_TARGET_ARCH_X32
+  __ Push(Immediate(0));
+#endif
   __ push(Operand(rbx, FrameDescription::continuation_offset()));
 
   // Push the registers from the last output frame.
   for (int i = 0; i < kNumberOfRegisters; i++) {
     int offset = (i * kPointerSize) + FrameDescription::registers_offset();
+#ifndef V8_TARGET_ARCH_X32
     __ push(Operand(rbx, offset));
+#else
+    __ movl(kScratchRegister, Operand(rbx, offset));
+    __ push(kScratchRegister);
+#endif
   }
 
   // Restore the registers from the stack.
   for (int i = kNumberOfRegisters - 1; i >= 0 ; i--) {
     Register r = Register::from_code(i);
     // Do not restore rsp, simply pop the value into the next register
     // and overwrite this afterwards.
     if (r.is(rsp)) {
       ASSERT(i > 0);
       r = Register::from_code(i - 1);
     }
-    __ pop(r);
+    __k pop(r);
   }
 
   // Set up the roots register.
   __ InitializeRootRegister();
   __ InitializeSmiConstantRegister();
 
   // Return to the continuation point.
   __ ret(0);
 }
 
 
 void Deoptimizer::TableEntryGenerator::GeneratePrologue() {
   // Create a sequence of deoptimization entries.
   Label done;
   for (int i = 0; i < count(); i++) {
     int start = masm()->pc_offset();
     USE(start);
-    __ push_imm32(i);
+    __k push_imm32(i);
     __ jmp(&done);
     ASSERT(masm()->pc_offset() - start == table_entry_size_);
   }
   __ bind(&done);
 }
 
+#undef __k
+#undef __k
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64