Add X32 port into V8

src/deoptimizer.cc

 // Copyright 2013 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 879 matching lines @@
   // There are no translation commands for the caller's pc and fp, the
   // context, and the function.  Synthesize their values and set them up
   // explicitly.
   //
   // The caller's pc for the bottommost output frame is the same as in the
   // input frame.  For all subsequent output frames, it can be read from the
   // previous one.  This frame's pc can be computed from the non-optimized
   // function code and AST id of the bailout.
   output_offset -= kPointerSize;
   input_offset -= kPointerSize;
+#if V8_TARGET_ARCH_X32

[danno, 2013/07/17 13:33:21]

No platform-specific code should be here. Please factor this out here and below
into:

output_frame->SetReturnAddress(output_offset, 0);
output_offset -= kReturnAddressOnStackSize;
input_offset -= kPCOnStackSize;

SetReturnAddress will of course have to be platform-specific, zeroing out the
right bits on x32 as part of setting the link.

+  // Set high 32-bit of PC 0.
+  output_frame->SetFrameSlot(output_offset, 0);
+  output_offset -= kPointerSize;
+  input_offset -= kPointerSize;
+#endif
   intptr_t value;
   if (is_bottommost) {
     value = input_->GetFrameSlot(input_offset);
   } else {
     value = output_[frame_index - 1]->GetPc();
   }
   output_frame->SetFrameSlot(output_offset, value);
   if (trace_) {
     PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR  " ; caller's pc\n",
            top_address + output_offset, output_offset, value);
   }
 
   // The caller's frame pointer for the bottommost output frame is the same
   // as in the input frame.  For all subsequent output frames, it can be
   // read from the previous one.  Also compute and set this frame's frame
   // pointer.
   output_offset -= kPointerSize;
   input_offset -= kPointerSize;
+#if V8_TARGET_ARCH_X32
+  // Set high 32-bit of FP 0.
+  output_frame->SetFrameSlot(output_offset, 0);
+  output_offset -= kPointerSize;
+  input_offset -= kPointerSize;
+#endif
   if (is_bottommost) {
     value = input_->GetFrameSlot(input_offset);
   } else {
     value = output_[frame_index - 1]->GetFp();
   }
   output_frame->SetFrameSlot(output_offset, value);
   intptr_t fp_value = top_address + output_offset;
   ASSERT(!is_bottommost || (input_->GetRegister(fp_reg.code()) +
       has_alignment_padding_ * kPointerSize) == fp_value);
   output_frame->SetFp(fp_value);
@@ skipping 109 matching lines @@
   // Compute the incoming parameter translation.
   int parameter_count = height;
   unsigned output_offset = output_frame_size;
   for (int i = 0; i < parameter_count; ++i) {
     output_offset -= kPointerSize;
     DoTranslateCommand(iterator, frame_index, output_offset);
   }
 
   // Read caller's PC from the previous frame.
   output_offset -= kPointerSize;
+#if V8_TARGET_ARCH_X32
+  // Set high 32-bit of PC 0.
+  output_frame->SetFrameSlot(output_offset, 0);
+  output_offset -= kPointerSize;
+#endif
   intptr_t callers_pc = output_[frame_index - 1]->GetPc();
   output_frame->SetFrameSlot(output_offset, callers_pc);
   if (trace_) {
     PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; caller's pc\n",
            top_address + output_offset, output_offset, callers_pc);
   }
 
   // Read caller's FP from the previous frame, and set this frame's FP.
   output_offset -= kPointerSize;
+#if V8_TARGET_ARCH_X32
+  // Set high 32-bit of FP 0.
+  output_frame->SetFrameSlot(output_offset, 0);
+  output_offset -= kPointerSize;
+#endif
   intptr_t value = output_[frame_index - 1]->GetFp();
   output_frame->SetFrameSlot(output_offset, value);
   intptr_t fp_value = top_address + output_offset;
   output_frame->SetFp(fp_value);
   if (trace_) {
     PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; caller's fp\n",
            fp_value, output_offset, value);
   }
 
@@ skipping 73 matching lines @@
   // Compute the incoming parameter translation.
   int parameter_count = height;
   unsigned output_offset = output_frame_size;
   for (int i = 0; i < parameter_count; ++i) {
     output_offset -= kPointerSize;
     DoTranslateCommand(iterator, frame_index, output_offset);
   }
 
   // Read caller's PC from the previous frame.
   output_offset -= kPointerSize;
+#if V8_TARGET_ARCH_X32
+  // Set high 32-bit of PC 0.
+  output_frame->SetFrameSlot(output_offset, 0);
+  output_offset -= kPointerSize;
+#endif
   intptr_t callers_pc = output_[frame_index - 1]->GetPc();
   output_frame->SetFrameSlot(output_offset, callers_pc);
   if (trace_) {
     PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; caller's pc\n",
            top_address + output_offset, output_offset, callers_pc);
   }
 
   // Read caller's FP from the previous frame, and set this frame's FP.
   output_offset -= kPointerSize;
+#if V8_TARGET_ARCH_X32
+  // Set high 32-bit of FP 0.
+  output_frame->SetFrameSlot(output_offset, 0);
+  output_offset -= kPointerSize;
+#endif
   intptr_t value = output_[frame_index - 1]->GetFp();
   output_frame->SetFrameSlot(output_offset, value);
   intptr_t fp_value = top_address + output_offset;
   output_frame->SetFp(fp_value);
   if (trace_) {
     PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; caller's fp\n",
            fp_value, output_offset, value);
   }
 
@@ skipping 82 matching lines @@
   const char* kind = is_setter_stub_frame ? "setter" : "getter";
   if (trace_) {
     PrintF("  translating %s stub => height=%u\n", kind, height_in_bytes);
   }
 
   // We need 1 stack entry for the return address + 4 stack entries from
   // StackFrame::INTERNAL (FP, context, frame type, code object, see
   // MacroAssembler::EnterFrame). For a setter stub frame we need one additional
   // entry for the implicit return value, see
   // StoreStubCompiler::CompileStoreViaSetter.
+#ifndef V8_TARGET_ARCH_X32
   unsigned fixed_frame_entries = 1 + 4 + (is_setter_stub_frame ? 1 : 0);
+#else
+  unsigned fixed_frame_entries = 2 * (kHWRegSize/kPointerSize) + 3 +

[danno, 2013/07/17 13:33:21]

I think you can remove the special case here if you define both kRegisterSize
and kkReturnAddressOnStackSize (isn't this why there is a difference here?). In
this case, you would have:

(kReturnAddressOnStackSize/kPointerSize) +  (kHWRegSize/kPointerSize) + 3 ...

+                                 (is_setter_stub_frame ? 1 : 0);
+#endif
   unsigned fixed_frame_size = fixed_frame_entries * kPointerSize;
   unsigned output_frame_size = height_in_bytes + fixed_frame_size;
 
   // Allocate and store the output frame description.
   FrameDescription* output_frame =
       new(output_frame_size) FrameDescription(output_frame_size, accessor);
   output_frame->SetFrameType(StackFrame::INTERNAL);
 
   // A frame for an accessor stub can not be the topmost or bottommost one.
   ASSERT(frame_index > 0 && frame_index < output_count_ - 1);
   ASSERT(output_[frame_index] == NULL);
   output_[frame_index] = output_frame;
 
   // The top address of the frame is computed from the previous frame's top and
   // this frame's size.
   intptr_t top_address = output_[frame_index - 1]->GetTop() - output_frame_size;
   output_frame->SetTop(top_address);
 
   unsigned output_offset = output_frame_size;
 
   // Read caller's PC from the previous frame.
   output_offset -= kPointerSize;
+#if V8_TARGET_ARCH_X32
+  // Set high 32-bit of PC 0.
+  output_frame->SetFrameSlot(output_offset, 0);
+  output_offset -= kPointerSize;
+#endif
   intptr_t callers_pc = output_[frame_index - 1]->GetPc();
   output_frame->SetFrameSlot(output_offset, callers_pc);
   if (trace_) {
     PrintF("    0x%08" V8PRIxPTR ": [top + %u] <- 0x%08" V8PRIxPTR
            " ; caller's pc\n",
            top_address + output_offset, output_offset, callers_pc);
   }
 
   // Read caller's FP from the previous frame, and set this frame's FP.
   output_offset -= kPointerSize;
+#if V8_TARGET_ARCH_X32
+  // Set high 32-bit of FP 0.
+  output_frame->SetFrameSlot(output_offset, 0);

[danno, 2013/07/17 13:33:21]

Similar to return address handling, you need something like:

output_frame->SetNextFrameFP(output_offset, 0);
output_offset -= kFPOnStackSize;
input_offset -= kFPOnStackSize;

here

+  output_offset -= kPointerSize;
+#endif
   intptr_t value = output_[frame_index - 1]->GetFp();
   output_frame->SetFrameSlot(output_offset, value);
   intptr_t fp_value = top_address + output_offset;
   output_frame->SetFp(fp_value);
   if (trace_) {
     PrintF("    0x%08" V8PRIxPTR ": [top + %u] <- 0x%08" V8PRIxPTR
            " ; caller's fp\n",
            fp_value, output_offset, value);
   }
 
@@ skipping 119 matching lines @@
   // frame pointer and the output frame's height. Subtract space for the
   // context and function slots.
   Register fp_reg = StubFailureTrampolineFrame::fp_register();
   intptr_t top_address = input_->GetRegister(fp_reg.code()) -
       (2 * kPointerSize) - height_in_bytes;
   output_frame->SetTop(top_address);
 
   // Read caller's PC (JSFunction continuation) from the input frame.
   unsigned input_frame_offset = input_frame_size - kPointerSize;
   unsigned output_frame_offset = output_frame_size - kPointerSize;
+#if V8_TARGET_ARCH_X32
+  // Set high 32-bit of PC 0.
+  output_frame->SetFrameSlot(output_frame_offset, 0);
+  output_frame_offset -= kPointerSize;
+  input_frame_offset -= kPointerSize;
+#endif
   intptr_t value = input_->GetFrameSlot(input_frame_offset);
   output_frame->SetFrameSlot(output_frame_offset, value);
   if (trace_) {
     PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; caller's pc\n",
            top_address + output_frame_offset, output_frame_offset, value);
   }
 
   // Read caller's FP from the input frame, and set this frame's FP.
   input_frame_offset -= kPointerSize;
+#if V8_TARGET_ARCH_X32
+  input_frame_offset -= kPointerSize;
+#endif
   value = input_->GetFrameSlot(input_frame_offset);
   output_frame_offset -= kPointerSize;
+#if V8_TARGET_ARCH_X32
+  output_frame->SetFrameSlot(output_frame_offset, 0);
+  output_frame_offset -= kPointerSize;
+#endif
   output_frame->SetFrameSlot(output_frame_offset, value);
   intptr_t frame_ptr = input_->GetRegister(fp_reg.code());
   output_frame->SetRegister(fp_reg.code(), frame_ptr);
   output_frame->SetFp(frame_ptr);
   if (trace_) {
     PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; caller's fp\n",
            top_address + output_frame_offset, output_frame_offset, value);
   }
 
@@ skipping 1636 matching lines @@
 
 void DeoptimizedFrameInfo::Iterate(ObjectVisitor* v) {
   v->VisitPointer(BitCast<Object**>(&function_));
   v->VisitPointers(parameters_, parameters_ + parameters_count_);
   v->VisitPointers(expression_stack_, expression_stack_ + expression_count_);
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal