Debugger: use debug break slot to break on call.

src/assembler.cc

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // 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.
 //
@@ skipping 362 matching lines @@
 
 
 void RelocInfoWriter::WriteExtraTaggedPC(uint32_t pc_delta, int extra_tag) {
   // Write two-byte tagged pc-delta, possibly preceded by var. length pc-jump.
   pc_delta = WriteVariableLengthPCJump(pc_delta);
   WriteExtraTag(extra_tag, 0);
   *--pos_ = pc_delta;
 }
 
 
+void RelocInfoWriter::WriteInt(int number) {
+  for (int i = 0; i < kIntSize; i++) {
+    *--pos_ = static_cast<byte>(number);
+    // Signed right shift is arithmetic shift.  Tested in test-utils.cc.
+    number = number >> kBitsPerByte;
+  }
+}
+
+
+void RelocInfoWriter::WriteDebugBreakSlotData(int data) { WriteInt(data); }
+
+
 void RelocInfoWriter::WriteExtraTaggedIntData(int data_delta, int top_tag) {
   WriteExtraTag(kDataJumpExtraTag, top_tag);
-  for (int i = 0; i < kIntSize; i++) {
-    *--pos_ = static_cast<byte>(data_delta);
-    // Signed right shift is arithmetic shift.  Tested in test-utils.cc.
-    data_delta = data_delta >> kBitsPerByte;
-  }
+  WriteInt(data_delta);
 }
 
 
 void RelocInfoWriter::WriteExtraTaggedPoolData(int data, int pool_type) {
   WriteExtraTag(kPoolExtraTag, pool_type);
-  for (int i = 0; i < kIntSize; i++) {
-    *--pos_ = static_cast<byte>(data);
-    // Signed right shift is arithmetic shift.  Tested in test-utils.cc.
-    data = data >> kBitsPerByte;
-  }
+  WriteInt(data);
 }
 
 
 void RelocInfoWriter::WriteExtraTaggedData(intptr_t data_delta, int top_tag) {
   WriteExtraTag(kDataJumpExtraTag, top_tag);
   for (int i = 0; i < kIntptrSize; i++) {
     *--pos_ = static_cast<byte>(data_delta);
     // Signed right shift is arithmetic shift.  Tested in test-utils.cc.
     data_delta = data_delta >> kBitsPerByte;
   }
@@ skipping 81 matching lines @@
       }
       next_position_candidate_flushed_ = false;
     }
     last_position_ = static_cast<int>(rinfo->data());
   } else if (RelocInfo::IsComment(rmode)) {
     // Comments are normally not generated, so we use the costly encoding.
     WriteExtraTaggedPC(pc_delta, kPCJumpExtraTag);
     WriteExtraTaggedData(rinfo->data(), kCommentTag);
     DCHECK(begin_pos - pos_ >= RelocInfo::kMinRelocCommentSize);
   } else if (RelocInfo::IsConstPool(rmode) || RelocInfo::IsVeneerPool(rmode)) {
-      WriteExtraTaggedPC(pc_delta, kPCJumpExtraTag);
-      WriteExtraTaggedPoolData(static_cast<int>(rinfo->data()),
-                               RelocInfo::IsConstPool(rmode) ? kConstPoolTag
-                                                             : kVeneerPoolTag);
+    WriteExtraTaggedPC(pc_delta, kPCJumpExtraTag);
+    WriteExtraTaggedPoolData(
+        static_cast<int>(rinfo->data()),
+        RelocInfo::IsConstPool(rmode) ? kConstPoolTag : kVeneerPoolTag);
   } else {
     DCHECK(rmode > RelocInfo::LAST_COMPACT_ENUM);
     DCHECK(rmode <= RelocInfo::LAST_STANDARD_NONCOMPACT_ENUM);
     STATIC_ASSERT(RelocInfo::LAST_STANDARD_NONCOMPACT_ENUM -
                       RelocInfo::LAST_COMPACT_ENUM <=
                   kPoolExtraTag);
     int saved_mode = rmode - RelocInfo::LAST_COMPACT_ENUM - 1;
     // For all other modes we simply use the mode as the extra tag.
     // None of these modes need a data component.
     DCHECK(0 <= saved_mode && saved_mode < kPoolExtraTag);
     WriteExtraTaggedPC(pc_delta, saved_mode);
+    if (RelocInfo::IsDebugBreakSlot(rmode)) {
+      WriteDebugBreakSlotData(static_cast<int>(rinfo->data()));
+    }
   }
   last_pc_ = rinfo->pc();
   last_mode_ = rmode;
 #ifdef DEBUG
   DCHECK(begin_pos - pos_ <= kMaxSize);
 #endif
 }
 
 
 inline int RelocIterator::AdvanceGetTag() {
@@ skipping 24 matching lines @@
 void RelocIterator::AdvanceReadId() {
   int x = 0;
   for (int i = 0; i < kIntSize; i++) {
     x |= static_cast<int>(*--pos_) << i * kBitsPerByte;
   }
   last_id_ += x;
   rinfo_.data_ = last_id_;
 }
 
 
-void RelocIterator::AdvanceReadPoolData() {
+void RelocIterator::AdvanceReadInt() {
   int x = 0;
   for (int i = 0; i < kIntSize; i++) {
     x |= static_cast<int>(*--pos_) << i * kBitsPerByte;
   }
   rinfo_.data_ = x;
 }
 
 
+void RelocIterator::AdvanceReadPoolData() { AdvanceReadInt(); }
+
+
+void RelocIterator::AdvanceReadDebugBreakSlotData() { AdvanceReadInt(); }
+
+
 void RelocIterator::AdvanceReadPosition() {
   int x = 0;
   for (int i = 0; i < kIntSize; i++) {
     x |= static_cast<int>(*--pos_) << i * kBitsPerByte;
   }
   last_position_ += x;
   rinfo_.data_ = last_position_;
 }
 
 
@@ skipping 132 matching lines @@
         DCHECK(pool_type == kConstPoolTag || pool_type == kVeneerPoolTag);
         RelocInfo::Mode rmode = (pool_type == kConstPoolTag) ?
           RelocInfo::CONST_POOL : RelocInfo::VENEER_POOL;
         if (SetMode(rmode)) {
           AdvanceReadPoolData();
           return;
         }
         Advance(kIntSize);
       } else {
         AdvanceReadPC();
-        int rmode = extra_tag + RelocInfo::LAST_COMPACT_ENUM + 1;
-        if (SetMode(static_cast<RelocInfo::Mode>(rmode))) return;
+        RelocInfo::Mode rmode = static_cast<RelocInfo::Mode>(
+            extra_tag + RelocInfo::LAST_COMPACT_ENUM + 1);
+        if (RelocInfo::IsDebugBreakSlot(rmode)) {
+          if (SetMode(rmode)) {
+            AdvanceReadDebugBreakSlotData();
+            return;
+          }
+          Advance(kIntSize);
+        } else if (SetMode(rmode)) {
+          return;
+        }
       }
     }
   }
   if (code_age_sequence_ != NULL) {
     byte* old_code_age_sequence = code_age_sequence_;
     code_age_sequence_ = NULL;
     if (SetMode(RelocInfo::CODE_AGE_SEQUENCE)) {
       rinfo_.data_ = 0;
       rinfo_.pc_ = old_code_age_sequence;
       return;
@@ skipping 143 matching lines @@
   } else if (IsRuntimeEntry(rmode_) &&
              isolate->deoptimizer_data() != NULL) {
     // Depotimization bailouts are stored as runtime entries.
     int id = Deoptimizer::GetDeoptimizationId(
         isolate, target_address(), Deoptimizer::EAGER);
     if (id != Deoptimizer::kNotDeoptimizationEntry) {
       os << "  (deoptimization bailout " << id << ")";
     }
   } else if (IsConstPool(rmode_)) {
     os << " (size " << static_cast<int>(data_) << ")";
+  } else if (IsDebugBreakSlot(rmode_)) {
+    if (DebugBreakIsCall(data_)) {
+      os << " (call with " << DebugBreakCallArgumentsCount(data_) << " args)";
+    } else if (DebugBreakIsConstructCall(data_)) {
+      os << " (construct call)";
+    } else {
+      os << " (slot)";
+    }
   }
 
   os << "\n";
 }
 #endif  // ENABLE_DISASSEMBLER
 
 
 #ifdef VERIFY_HEAP
 void RelocInfo::Verify(Isolate* isolate) {
   switch (rmode_) {
@@ skipping 43 matching lines @@
       UNREACHABLE();
       break;
     case CODE_AGE_SEQUENCE:
       DCHECK(Code::IsYoungSequence(isolate, pc_) || code_age_stub()->IsCode());
       break;
   }
 }
 #endif  // VERIFY_HEAP
 
 
+bool RelocInfo::DebugBreakIsConstructCall(intptr_t data) {
+  return data == static_cast<intptr_t>(kDebugBreakConstructCallSentinel);
+}
+
+
+bool RelocInfo::DebugBreakIsCall(intptr_t data) { return data >= 0; }
+
+
+int RelocInfo::DebugBreakCallArgumentsCount(intptr_t data) {
+  DCHECK(DebugBreakIsCall(data));
+  return static_cast<int>(data);
+}
+
+
 // -----------------------------------------------------------------------------
 // Implementation of ExternalReference
 
 void ExternalReference::SetUp() {
   double_constants.min_int = kMinInt;
   double_constants.one_half = 0.5;
   double_constants.minus_one_half = -0.5;
   double_constants.the_hole_nan = bit_cast<double>(kHoleNanInt64);
   double_constants.negative_infinity = -V8_INFINITY;
   double_constants.uint32_bias =
@@ skipping 903 matching lines @@
 
 void Assembler::RecordJSReturn() {
   positions_recorder()->WriteRecordedPositions();
   EnsureSpace ensure_space(this);
   RecordRelocInfo(RelocInfo::JS_RETURN);
 }
 
 
 void Assembler::RecordDebugBreakSlot() {
   EnsureSpace ensure_space(this);
-  RecordRelocInfo(RelocInfo::DEBUG_BREAK_SLOT);
+  intptr_t data = static_cast<intptr_t>(RelocInfo::kDebugBreakNonCallSentinel);
+  RecordRelocInfo(RelocInfo::DEBUG_BREAK_SLOT, data);
 }
 
 
+void Assembler::RecordDebugBreakSlotForCall(int argc) {
+  EnsureSpace ensure_space(this);
+  intptr_t data = static_cast<intptr_t>(argc);
+  RecordRelocInfo(RelocInfo::DEBUG_BREAK_SLOT, data);
+}
+
+
+void Assembler::RecordDebugBreakSlotForConstructCall() {
+  EnsureSpace ensure_space(this);
+  intptr_t data =
+      static_cast<intptr_t>(RelocInfo::kDebugBreakConstructCallSentinel);
+  RecordRelocInfo(RelocInfo::DEBUG_BREAK_SLOT, data);
+}
+
+
 void Assembler::DataAlign(int m) {
   DCHECK(m >= 2 && base::bits::IsPowerOfTwo32(m));
   while ((pc_offset() & (m - 1)) != 0) {
     db(0);
   }
 }
 }  // namespace internal
 }  // namespace v8