Emit unwinding information for TurboFan code.

src/compiler/x64/code-generator-x64.cc

 // Copyright 2013 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/compiler/code-generator.h"
 
 #include "src/ast/scopes.h"
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/gap-resolver.h"
 #include "src/compiler/node-matchers.h"
@@ skipping 162 matching lines @@
   void Generate() final { __ Pcmpeqd(result_, result_); }
 
  private:
   XMMRegister const result_;
 };
 
 
 class OutOfLineTruncateDoubleToI final : public OutOfLineCode {
  public:
   OutOfLineTruncateDoubleToI(CodeGenerator* gen, Register result,
-                             XMMRegister input)
-      : OutOfLineCode(gen), result_(result), input_(input) {}
+                             XMMRegister input,
+                             UnwindingInfoWriter* unwinding_info_writer)
+      : OutOfLineCode(gen),
+        result_(result),
+        input_(input),
+        unwinding_info_writer_(unwinding_info_writer) {}
 
   void Generate() final {
     __ subp(rsp, Immediate(kDoubleSize));
+    if (unwinding_info_writer_) {
+      unwinding_info_writer_->MaybeIncreaseFrameBaseOffsetAt(__ pc_offset(),
+                                                             kDoubleSize);
+    }
     __ Movsd(MemOperand(rsp, 0), input_);
     __ SlowTruncateToI(result_, rsp, 0);
     __ addp(rsp, Immediate(kDoubleSize));
+    if (unwinding_info_writer_) {
+      unwinding_info_writer_->MaybeIncreaseFrameBaseOffsetAt(__ pc_offset(),
+                                                             -kDoubleSize);
+    }
   }
 
  private:
   Register const result_;
   XMMRegister const input_;
+  UnwindingInfoWriter* const unwinding_info_writer_;
 };
 
 
 class OutOfLineRecordWrite final : public OutOfLineCode {
  public:
   OutOfLineRecordWrite(CodeGenerator* gen, Register object, Operand operand,
                        Register value, Register scratch0, Register scratch1,
                        RecordWriteMode mode)
       : OutOfLineCode(gen),
         object_(object),
@@ skipping 409 matching lines @@
   } while (false)
 
 #define ASSEMBLE_IEEE754_UNOP(name)                                           \
   do {                                                                        \
     __ PrepareCallCFunction(1);                                               \
     __ CallCFunction(ExternalReference::ieee754_##name##_function(isolate()), \
                      1);                                                      \
   } while (false)
 
 void CodeGenerator::AssembleDeconstructFrame() {
+  if (!unwinding_info_writer_.is_empty()) {
+    unwinding_info_writer_->MarkFrameDeconstructed(__ pc_offset());
+  }
   __ movq(rsp, rbp);
   __ popq(rbp);
 }
 
 void CodeGenerator::AssemblePrepareTailCall() {
   if (frame_access_state()->has_frame()) {
     __ movq(rbp, MemOperand(rbp, 0));
   }
   frame_access_state()->SetFrameAccessToSP();
 }
@@ skipping 114 matching lines @@
                                          i.TempRegister(2));
       }
       if (HasImmediateInput(instr, 0)) {
         Handle<Code> code = Handle<Code>::cast(i.InputHeapObject(0));
         __ jmp(code, RelocInfo::CODE_TARGET);
       } else {
         Register reg = i.InputRegister(0);
         __ addp(reg, Immediate(Code::kHeaderSize - kHeapObjectTag));
         __ jmp(reg);
       }
+      if (!unwinding_info_writer_.is_empty()) {
+        unwinding_info_writer_->MarkBlockWillExit();
+      }
       frame_access_state()->ClearSPDelta();
       frame_access_state()->SetFrameAccessToDefault();
       break;
     }
     case kArchTailCallAddress: {
       CHECK(!HasImmediateInput(instr, 0));
       Register reg = i.InputRegister(0);
       __ jmp(reg);
+      if (!unwinding_info_writer_.is_empty()) {
+        unwinding_info_writer_->MarkBlockWillExit();
+      }
       frame_access_state()->ClearSPDelta();
       frame_access_state()->SetFrameAccessToDefault();
       break;
     }
     case kArchCallJSFunction: {
       EnsureSpaceForLazyDeopt();
       Register func = i.InputRegister(0);
       if (FLAG_debug_code) {
         // Check the function's context matches the context argument.
         __ cmpp(rsi, FieldOperand(func, JSFunction::kContextOffset));
@@ skipping 88 matching lines @@
     case kArchParentFramePointer:
       if (frame_access_state()->has_frame()) {
         __ movq(i.OutputRegister(), Operand(rbp, 0));
       } else {
         __ movq(i.OutputRegister(), rbp);
       }
       break;
     case kArchTruncateDoubleToI: {
       auto result = i.OutputRegister();
       auto input = i.InputDoubleRegister(0);
-      auto ool = new (zone()) OutOfLineTruncateDoubleToI(this, result, input);
+      auto ool = new (zone()) OutOfLineTruncateDoubleToI(
+          this, result, input, unwinding_info_writer_.get());
       // We use Cvttsd2siq instead of Cvttsd2si due to performance reasons. The
       // use of Cvttsd2siq requires the movl below to avoid sign extension.
       __ Cvttsd2siq(result, input);
       __ cmpq(result, Immediate(1));
       __ j(overflow, ool->entry());
       __ bind(ool->exit());
       __ movl(result, result);
       break;
     }
     case kArchStoreWithWriteBarrier: {
@@ skipping 341 matching lines @@
       ASSEMBLE_SSE_BINOP(mulsd);
       break;
     case kSSEFloat64Div:
       ASSEMBLE_SSE_BINOP(divsd);
       // Don't delete this mov. It may improve performance on some CPUs,
       // when there is a (v)mulsd depending on the result.
       __ Movapd(i.OutputDoubleRegister(), i.OutputDoubleRegister());
       break;
     case kSSEFloat64Mod: {
       __ subq(rsp, Immediate(kDoubleSize));
+      if (!unwinding_info_writer_.is_empty()) {
+        unwinding_info_writer_->MaybeIncreaseFrameBaseOffsetAt(__ pc_offset(),
+                                                               kDoubleSize);
+      }
       // Move values to st(0) and st(1).
       __ Movsd(Operand(rsp, 0), i.InputDoubleRegister(1));
       __ fld_d(Operand(rsp, 0));
       __ Movsd(Operand(rsp, 0), i.InputDoubleRegister(0));
       __ fld_d(Operand(rsp, 0));
       // Loop while fprem isn't done.
       Label mod_loop;
       __ bind(&mod_loop);
       // This instructions traps on all kinds inputs, but we are assuming the
       // floating point control word is set to ignore them all.
       __ fprem();
       // The following 2 instruction implicitly use rax.
       __ fnstsw_ax();
       if (CpuFeatures::IsSupported(SAHF)) {
         CpuFeatureScope sahf_scope(masm(), SAHF);
         __ sahf();
       } else {
         __ shrl(rax, Immediate(8));
         __ andl(rax, Immediate(0xFF));
         __ pushq(rax);
+        if (!unwinding_info_writer_.is_empty()) {
+          unwinding_info_writer_->MaybeIncreaseFrameBaseOffsetAt(__ pc_offset(),
+                                                                 kInt64Size);
+        }
         __ popfq();
+        if (!unwinding_info_writer_.is_empty()) {
+          unwinding_info_writer_->MaybeIncreaseFrameBaseOffsetAt(__ pc_offset(),
+                                                                 -kInt64Size);
+        }
       }
       __ j(parity_even, &mod_loop);
       // Move output to stack and clean up.
       __ fstp(1);
       __ fstp_d(Operand(rsp, 0));
       __ Movsd(i.OutputDoubleRegister(), Operand(rsp, 0));
       __ addq(rsp, Immediate(kDoubleSize));
+      if (!unwinding_info_writer_.is_empty()) {
+        unwinding_info_writer_->MaybeIncreaseFrameBaseOffsetAt(__ pc_offset(),
+                                                               -kDoubleSize);
+      }
       break;
     }
     case kSSEFloat64Max:
       ASSEMBLE_SSE_BINOP(maxsd);
       break;
     case kSSEFloat64Min:
       ASSEMBLE_SSE_BINOP(minsd);
       break;
     case kSSEFloat64Abs: {
       // TODO(bmeurer): Use RIP relative 128-bit constants.
@@ skipping 561 matching lines @@
     case kX64Dec32:
       __ decl(i.OutputRegister());
       break;
     case kX64Inc32:
       __ incl(i.OutputRegister());
       break;
     case kX64Push:
       if (HasImmediateInput(instr, 0)) {
         __ pushq(i.InputImmediate(0));
         frame_access_state()->IncreaseSPDelta(1);
+        if (!unwinding_info_writer_.is_empty()) {
+          unwinding_info_writer_->MaybeIncreaseFrameBaseOffsetAt(__ pc_offset(),
+                                                                 kInt64Size);

[Jarin, 2016/07/06 07:09:42]

kInt64Size ==> kPointerSize (here and below)

[Stefano Sanfilippo, 2016/07/06 13:25:10]

Done.

+        }
       } else {
         if (instr->InputAt(0)->IsRegister()) {
           __ pushq(i.InputRegister(0));
           frame_access_state()->IncreaseSPDelta(1);
+          if (!unwinding_info_writer_.is_empty()) {
+            unwinding_info_writer_->MaybeIncreaseFrameBaseOffsetAt(
+                __ pc_offset(), kInt64Size);
+          }
         } else if (instr->InputAt(0)->IsFPRegister()) {
           // TODO(titzer): use another machine instruction?
           __ subq(rsp, Immediate(kDoubleSize));
           frame_access_state()->IncreaseSPDelta(kDoubleSize / kPointerSize);
+          if (!unwinding_info_writer_.is_empty()) {
+            unwinding_info_writer_->MaybeIncreaseFrameBaseOffsetAt(
+                __ pc_offset(), kDoubleSize);
+          }
           __ Movsd(Operand(rsp, 0), i.InputDoubleRegister(0));
         } else {
           __ pushq(i.InputOperand(0));
           frame_access_state()->IncreaseSPDelta(1);
+          if (!unwinding_info_writer_.is_empty()) {
+            unwinding_info_writer_->MaybeIncreaseFrameBaseOffsetAt(
+                __ pc_offset(), kInt64Size);
+          }
         }
       }
       break;
     case kX64Poke: {
       int const slot = MiscField::decode(instr->opcode());
       if (HasImmediateInput(instr, 0)) {
         __ movq(Operand(rsp, slot * kPointerSize), i.InputImmediate(0));
       } else {
         __ movq(Operand(rsp, slot * kPointerSize), i.InputRegister(0));
       }
@@ skipping 272 matching lines @@
         ++count;
       }
     }
     frame->AllocateSavedCalleeRegisterSlots(count);
   }
 }
 
 void CodeGenerator::AssembleConstructFrame() {
   CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
   if (frame_access_state()->has_frame()) {
+    int pc_base = __ pc_offset();
+
     if (descriptor->IsCFunctionCall()) {
       __ pushq(rbp);
       __ movq(rbp, rsp);
     } else if (descriptor->IsJSFunctionCall()) {
       __ Prologue(this->info()->GeneratePreagedPrologue());
     } else {
       __ StubPrologue(info()->GetOutputStackFrameType());
     }
+
+    if (!unwinding_info_writer_.is_empty() &&
+        (!descriptor->IsJSFunctionCall() ||
+         !info()->GeneratePreagedPrologue())) {
+      unwinding_info_writer_->MarkFrameConstructed(pc_base);
+    }
   }
   int shrink_slots = frame()->GetSpillSlotCount();
 
   if (info()->is_osr()) {
     // TurboFan OSR-compiled functions cannot be entered directly.
     __ Abort(kShouldNotDirectlyEnterOsrFunction);
 
     // Unoptimized code jumps directly to this entrypoint while the unoptimized
     // frame is still on the stack. Optimized code uses OSR values directly from
     // the unoptimized frame. Thus, all that needs to be done is to allocate the
@@ skipping 53 matching lines @@
     for (int i = 0; i < XMMRegister::kMaxNumRegisters; i++) {
       if (!((1 << i) & saves_fp)) continue;
       __ movdqu(XMMRegister::from_code(i),
                 Operand(rsp, kQuadWordSize * slot_idx));
       slot_idx++;
     }
     // Adjust the stack pointer.
     __ addp(rsp, Immediate(stack_size));
   }
 
+  if (!unwinding_info_writer_.is_empty()) {
+    unwinding_info_writer_->MarkBlockWillExit();
+  }
+
   if (descriptor->IsCFunctionCall()) {
     AssembleDeconstructFrame();
   } else if (frame_access_state()->has_frame()) {
     // Canonicalize JSFunction return sites for now.
     if (return_label_.is_bound()) {
       __ jmp(&return_label_);
       return;
     } else {
       __ bind(&return_label_);
       AssembleDeconstructFrame();
@@ skipping 152 matching lines @@
     // Register-register.
     Register src = g.ToRegister(source);
     Register dst = g.ToRegister(destination);
     __ movq(kScratchRegister, src);
     __ movq(src, dst);
     __ movq(dst, kScratchRegister);
   } else if (source->IsRegister() && destination->IsStackSlot()) {
     Register src = g.ToRegister(source);
     __ pushq(src);
     frame_access_state()->IncreaseSPDelta(1);
+    if (!unwinding_info_writer_.is_empty()) {
+      unwinding_info_writer_->MaybeIncreaseFrameBaseOffsetAt(__ pc_offset(),
+                                                             kInt64Size);
+    }
     Operand dst = g.ToOperand(destination);
     __ movq(src, dst);
     frame_access_state()->IncreaseSPDelta(-1);
     dst = g.ToOperand(destination);
     __ popq(dst);
+    if (!unwinding_info_writer_.is_empty()) {
+      unwinding_info_writer_->MaybeIncreaseFrameBaseOffsetAt(__ pc_offset(),
+                                                             -kInt64Size);
+    }
   } else if ((source->IsStackSlot() && destination->IsStackSlot()) ||
              (source->IsFPStackSlot() && destination->IsFPStackSlot())) {
     // Memory-memory.
     Register tmp = kScratchRegister;
     Operand src = g.ToOperand(source);
     Operand dst = g.ToOperand(destination);
     __ movq(tmp, dst);
     __ pushq(src);
+    if (!unwinding_info_writer_.is_empty()) {
+      unwinding_info_writer_->MaybeIncreaseFrameBaseOffsetAt(__ pc_offset(),
+                                                             kInt64Size);
+    }
     frame_access_state()->IncreaseSPDelta(1);
     src = g.ToOperand(source);
     __ movq(src, tmp);
     frame_access_state()->IncreaseSPDelta(-1);
     dst = g.ToOperand(destination);
     __ popq(dst);
+    if (!unwinding_info_writer_.is_empty()) {
+      unwinding_info_writer_->MaybeIncreaseFrameBaseOffsetAt(__ pc_offset(),
+                                                             -kInt64Size);
+    }
   } else if (source->IsFPRegister() && destination->IsFPRegister()) {
     // XMM register-register swap.
     XMMRegister src = g.ToDoubleRegister(source);
     XMMRegister dst = g.ToDoubleRegister(destination);
     __ Movapd(kScratchDoubleReg, src);
     __ Movapd(src, dst);
     __ Movapd(dst, kScratchDoubleReg);
   } else if (source->IsFPRegister() && destination->IsFPStackSlot()) {
     // XMM register-memory swap.
     XMMRegister src = g.ToDoubleRegister(source);
@@ skipping 16 matching lines @@
 
 
 void CodeGenerator::EnsureSpaceForLazyDeopt() {
   if (!info()->ShouldEnsureSpaceForLazyDeopt()) {
     return;
   }
 
   int space_needed = Deoptimizer::patch_size();
   // Ensure that we have enough space after the previous lazy-bailout
   // instruction for patching the code here.
-  int current_pc = masm()->pc_offset();
+  int current_pc = __ pc_offset();
   if (current_pc < last_lazy_deopt_pc_ + space_needed) {
     int padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;
     __ Nop(padding_size);
   }
 }
 
 #undef __
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8