Debugger: record reloc info for debug break slot immediate before the slot.

If we do it too early, we might get a constant pool between the reloc info
and the actual slot.

R=ulan@chromium.org

Review URL: https://codereview.chromium.org/1229673005

Cr-Commit-Position: refs/heads/master@{#29568}

src/arm/debug-arm.cc

@@ -121,12 +121,15 @@ void DebugCodegen::GenerateReturnDebugBreak(MacroAssembler* masm) {
 }
 
 
-void DebugCodegen::GenerateSlot(MacroAssembler* masm) {
+void DebugCodegen::GenerateSlot(MacroAssembler* masm,
+                                DebugCodegen::SlotLocation location,
+                                int call_argc) {
   // Generate enough nop's to make space for a call instruction. Avoid emitting
   // the constant pool in the debug break slot code.
   Assembler::BlockConstPoolScope block_const_pool(masm);
   Label check_codesize;
   __ bind(&check_codesize);
+  RecordRelocInfo(masm, location, call_argc);
   for (int i = 0; i < Assembler::kDebugBreakSlotInstructions; i++) {
     __ nop(MacroAssembler::DEBUG_BREAK_NOP);
   }

src/arm64/debug-arm64.cc

@@ -166,11 +166,13 @@ void DebugCodegen::GenerateReturnDebugBreak(MacroAssembler* masm) {
 }
 
 
-void DebugCodegen::GenerateSlot(MacroAssembler* masm) {
+void DebugCodegen::GenerateSlot(MacroAssembler* masm,
+                                DebugCodegen::SlotLocation location,
+                                int call_argc) {
   // Generate enough nop's to make space for a call instruction. Avoid emitting
   // the constant pool in the debug break slot code.
   InstructionAccurateScope scope(masm, Assembler::kDebugBreakSlotInstructions);
-
+  RecordRelocInfo(masm, location, call_argc);
   for (int i = 0; i < Assembler::kDebugBreakSlotInstructions; i++) {
     __ nop(Assembler::DEBUG_BREAK_NOP);
   }

src/debug.cc

@@ -3176,5 +3176,23 @@ void LockingCommandMessageQueue::Clear() {
   queue_.Clear();
 }
 
+
+void DebugCodegen::RecordRelocInfo(MacroAssembler* masm,
+                                   DebugCodegen::SlotLocation location,
+                                   int call_argc) {
+  switch (location) {
+    case PLAIN_DEBUG_BREAK:
+      masm->RecordDebugBreakSlot();
+      return;
+    case DEBUG_BREAK_AT_CALL:
+      DCHECK_LE(0, call_argc);
+      masm->RecordDebugBreakSlotForCall(call_argc);
+      return;
+    case DEBUG_BREAK_AT_CONSTRUCT_CALL:
+      masm->RecordDebugBreakSlotForConstructCall();
+      return;
+  }
+}
+
 }  // namespace internal
 }  // namespace v8

src/debug.h

@@ -791,7 +791,14 @@ class SuppressDebug BASE_EMBEDDED {
 // Code generator routines.
 class DebugCodegen : public AllStatic {
  public:
-  static void GenerateSlot(MacroAssembler* masm);
+  enum SlotLocation {
+    PLAIN_DEBUG_BREAK,
+    DEBUG_BREAK_AT_CALL,
+    DEBUG_BREAK_AT_CONSTRUCT_CALL
+  };
+
+  static void GenerateSlot(MacroAssembler* masm, SlotLocation location,
+                           int call_argc = -1);
   static void GenerateReturnDebugBreak(MacroAssembler* masm);
   static void GenerateSlotDebugBreak(MacroAssembler* masm);
   static void GeneratePlainReturnLiveEdit(MacroAssembler* masm);
@@ -801,6 +808,10 @@ class DebugCodegen : public AllStatic {
   // There is no calling conventions here, because it never actually gets
   // called, it only gets returned to.
   static void GenerateFrameDropperLiveEdit(MacroAssembler* masm);
+
+ private:
+  static void RecordRelocInfo(MacroAssembler* masm, SlotLocation location,
+                              int call_argc);
 };
 
 

src/full-codegen.cc

@@ -433,8 +433,7 @@ void FullCodeGenerator::SetStatementPosition(
   bool recorded = RecordStatementPosition(masm_, stmt->position());
   if (recorded && insert_break == INSERT_BREAK && info_->is_debug() &&
       !stmt->IsDebuggerStatement()) {
-    masm_->RecordDebugBreakSlot();
+    DebugCodegen::GenerateSlot(masm_, DebugCodegen::PLAIN_DEBUG_BREAK);
-    DebugCodegen::GenerateSlot(masm_);
   }
 }
 
@@ -444,8 +443,7 @@ void FullCodeGenerator::SetExpressionPosition(
   if (expr->position() == RelocInfo::kNoPosition) return;
   bool recorded = RecordPosition(masm_, expr->position());
   if (recorded && insert_break == INSERT_BREAK && info_->is_debug()) {
-    masm_->RecordDebugBreakSlot();
+    DebugCodegen::GenerateSlot(masm_, DebugCodegen::PLAIN_DEBUG_BREAK);
-    DebugCodegen::GenerateSlot(masm_);
   }
 }
 
@@ -454,8 +452,7 @@ void FullCodeGenerator::SetExpressionAsStatementPosition(Expression* expr) {
   if (expr->position() == RelocInfo::kNoPosition) return;
   bool recorded = RecordStatementPosition(masm_, expr->position());
   if (recorded && info_->is_debug()) {
-    masm_->RecordDebugBreakSlot();
+    DebugCodegen::GenerateSlot(masm_, DebugCodegen::PLAIN_DEBUG_BREAK);
-    DebugCodegen::GenerateSlot(masm_);
   }
 }
 
@@ -465,8 +462,7 @@ void FullCodeGenerator::SetCallPosition(Expression* expr, int argc) {
   RecordPosition(masm_, expr->position());
   if (info_->is_debug()) {
     // Always emit a debug break slot before a call.
-    masm_->RecordDebugBreakSlotForCall(argc);
+    DebugCodegen::GenerateSlot(masm_, DebugCodegen::DEBUG_BREAK_AT_CALL, argc);
-    DebugCodegen::GenerateSlot(masm_);
   }
 }
 
@@ -476,8 +472,8 @@ void FullCodeGenerator::SetConstructCallPosition(Expression* expr) {
   RecordPosition(masm_, expr->position());
   if (info_->is_debug()) {
     // Always emit a debug break slot before a construct call.
-    masm_->RecordDebugBreakSlotForConstructCall();
+    DebugCodegen::GenerateSlot(masm_,
-    DebugCodegen::GenerateSlot(masm_);
+                               DebugCodegen::DEBUG_BREAK_AT_CONSTRUCT_CALL);
   }
 }
 

src/ia32/debug-ia32.cc

@@ -158,10 +158,13 @@ void DebugCodegen::GenerateReturnDebugBreak(MacroAssembler* masm) {
 }
 
 
-void DebugCodegen::GenerateSlot(MacroAssembler* masm) {
+void DebugCodegen::GenerateSlot(MacroAssembler* masm,
+                                DebugCodegen::SlotLocation location,
+                                int call_argc) {
   // Generate enough nop's to make space for a call instruction.
   Label check_codesize;
   __ bind(&check_codesize);
+  RecordRelocInfo(masm, location, call_argc);
   __ Nop(Assembler::kDebugBreakSlotLength);
   DCHECK_EQ(Assembler::kDebugBreakSlotLength,
             masm->SizeOfCodeGeneratedSince(&check_codesize));

src/mips/debug-mips.cc

@@ -129,12 +129,15 @@ void DebugCodegen::GenerateReturnDebugBreak(MacroAssembler* masm) {
 }
 
 
-void DebugCodegen::GenerateSlot(MacroAssembler* masm) {
+void DebugCodegen::GenerateSlot(MacroAssembler* masm,
+                                DebugCodegen::SlotLocation location,
+                                int call_argc) {
   // Generate enough nop's to make space for a call instruction. Avoid emitting
   // the trampoline pool in the debug break slot code.
   Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm);
   Label check_codesize;
   __ bind(&check_codesize);
+  RecordRelocInfo(masm, location, call_argc);
   for (int i = 0; i < Assembler::kDebugBreakSlotInstructions; i++) {
     __ nop(MacroAssembler::DEBUG_BREAK_NOP);
   }

src/mips64/debug-mips64.cc

@@ -140,12 +140,15 @@ void DebugCodegen::GenerateReturnDebugBreak(MacroAssembler* masm) {
 }
 
 
-void DebugCodegen::GenerateSlot(MacroAssembler* masm) {
+void DebugCodegen::GenerateSlot(MacroAssembler* masm,
+                                DebugCodegen::SlotLocation location,
+                                int call_argc) {
   // Generate enough nop's to make space for a call instruction. Avoid emitting
   // the trampoline pool in the debug break slot code.
   Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm);
   Label check_codesize;
   __ bind(&check_codesize);
+  RecordRelocInfo(masm, location, call_argc);
   for (int i = 0; i < Assembler::kDebugBreakSlotInstructions; i++) {
     __ nop(MacroAssembler::DEBUG_BREAK_NOP);
   }

src/x64/debug-x64.cc

@@ -145,10 +145,13 @@ void DebugCodegen::GenerateReturnDebugBreak(MacroAssembler* masm) {
 }
 
 
-void DebugCodegen::GenerateSlot(MacroAssembler* masm) {
+void DebugCodegen::GenerateSlot(MacroAssembler* masm,
+                                DebugCodegen::SlotLocation location,
+                                int call_argc) {
   // Generate enough nop's to make space for a call instruction.
   Label check_codesize;
   __ bind(&check_codesize);
+  RecordRelocInfo(masm, location, call_argc);
   __ Nop(Assembler::kDebugBreakSlotLength);
   DCHECK_EQ(Assembler::kDebugBreakSlotLength,
             masm->SizeOfCodeGeneratedSince(&check_codesize));