Debugger: use debug break slot to break on call.

src/assembler.h

 // 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 488 matching lines @@
 
   // Is the pointer this relocation info refers to coded like a plain pointer
   // or is it strange in some way (e.g. relative or patched into a series of
   // instructions).
   bool IsCodedSpecially();
 
   // If true, the pointer this relocation info refers to is an entry in the
   // constant pool, otherwise the pointer is embedded in the instruction stream.
   bool IsInConstantPool();
 
+  static bool DebugBreakIsConstructCall(intptr_t data);
+  static bool DebugBreakIsCall(intptr_t data);
+  static int DebugBreakCallArgumentsCount(intptr_t data);
+
   // Read/modify the code target in the branch/call instruction
   // this relocation applies to;
   // can only be called if IsCodeTarget(rmode_) || IsRuntimeEntry(rmode_)
   INLINE(Address target_address());
   INLINE(void set_target_address(Address target,
                                  WriteBarrierMode write_barrier_mode =
                                      UPDATE_WRITE_BARRIER,
                                  ICacheFlushMode icache_flush_mode =
                                      FLUSH_ICACHE_IF_NEEDED));
   INLINE(Object* target_object());
@@ skipping 97 matching lines @@
 #endif  // ENABLE_DISASSEMBLER
 #ifdef VERIFY_HEAP
   void Verify(Isolate* isolate);
 #endif
 
   static const int kCodeTargetMask = (1 << (LAST_CODE_ENUM + 1)) - 1;
   static const int kPositionMask = 1 << POSITION | 1 << STATEMENT_POSITION;
   static const int kDataMask =
       (1 << CODE_TARGET_WITH_ID) | kPositionMask | (1 << COMMENT);
   static const int kApplyMask;  // Modes affected by apply. Depends on arch.
+  static const int kDebugBreakNonCallSentinel = -2;
+  static const int kDebugBreakConstructCallSentinel = -1;
 
  private:
   // On ARM, note that pc_ is the address of the constant pool entry
   // to be relocated and not the address of the instruction
   // referencing the constant pool entry (except when rmode_ ==
   // comment).
   byte* pc_;
   Mode rmode_;
   intptr_t data_;
   Code* host_;
@@ skipping 47 matching lines @@
   // ExtraTag, VariableLengthPCJump, ExtraTag, pc_delta, ExtraTag, data_delta.
   // On ia32 and arm this is 1 + 4 + 1 + 1 + 1 + 4 = 12.
   // On x64 this is 1 + 4 + 1 + 1 + 1 + 8 == 16;
   // Here we use the maximum of the two.
   static const int kMaxSize = 16;
 
  private:
   inline uint32_t WriteVariableLengthPCJump(uint32_t pc_delta);
   inline void WriteTaggedPC(uint32_t pc_delta, int tag);
   inline void WriteExtraTaggedPC(uint32_t pc_delta, int extra_tag);
+  inline void WriteInt(int number);
+  inline void WriteDebugBreakSlotData(int data);
   inline void WriteExtraTaggedIntData(int data_delta, int top_tag);
   inline void WriteExtraTaggedPoolData(int data, int pool_type);
   inline void WriteExtraTaggedData(intptr_t data_delta, int top_tag);
   inline void WriteTaggedData(intptr_t data_delta, int tag);
   inline void WriteExtraTag(int extra_tag, int top_tag);
   inline void WritePosition(int pc_delta, int pos_delta, RelocInfo::Mode rmode);
 
   void FlushPosition();
 
   byte* pos_;
@@ skipping 40 matching lines @@
   // Advance* moves the position before/after reading.
   // *Read* reads from current byte(s) into rinfo_.
   // *Get* just reads and returns info on current byte.
   void Advance(int bytes = 1) { pos_ -= bytes; }
   int AdvanceGetTag();
   int GetExtraTag();
   int GetTopTag();
   void ReadTaggedPC();
   void AdvanceReadPC();
   void AdvanceReadId();
+  void AdvanceReadInt();
   void AdvanceReadPoolData();
+  void AdvanceReadDebugBreakSlotData();
   void AdvanceReadPosition();
   void AdvanceReadData();
   void AdvanceReadVariableLengthPCJump();
   int GetLocatableTypeTag();
   void ReadTaggedId();
   void ReadTaggedPosition();
   void ReadTaggedData();
 
   // If the given mode is wanted, set it in rinfo_ and return true.
   // Else return false. Used for efficiently skipping unwanted modes.
@@ skipping 483 matching lines @@
   };
 
   Label emitted_label_;  // Records pc_offset of emitted pool
   PerTypeEntryInfo info_[ConstantPoolEntry::NUMBER_OF_TYPES];
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ASSEMBLER_H_