Version 3.8.6

src/gdb-jit.cc

 // Copyright 2010 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 1538 matching lines @@
   }
 
   CodeDescription* desc_;
 };
 
 
 #ifdef V8_TARGET_ARCH_X64
 
 class UnwindInfoSection : public DebugSection {
  public:
-  explicit UnwindInfoSection(CodeDescription *desc);
-  virtual bool WriteBody(Writer *w);
+  explicit UnwindInfoSection(CodeDescription* desc);
+  virtual bool WriteBody(Writer* w);
 
-  int WriteCIE(Writer *w);
-  void WriteFDE(Writer *w, int);
+  int WriteCIE(Writer* w);
+  void WriteFDE(Writer* w, int);
 
-  void WriteFDEStateOnEntry(Writer *w);
-  void WriteFDEStateAfterRBPPush(Writer *w);
-  void WriteFDEStateAfterRBPSet(Writer *w);
-  void WriteFDEStateAfterRBPPop(Writer *w);
+  void WriteFDEStateOnEntry(Writer* w);
+  void WriteFDEStateAfterRBPPush(Writer* w);
+  void WriteFDEStateAfterRBPSet(Writer* w);
+  void WriteFDEStateAfterRBPPop(Writer* w);
 
-  void WriteLength(Writer *w,
+  void WriteLength(Writer* w,
                    Writer::Slot<uint32_t>* length_slot,
                    int initial_position);
 
  private:
-  CodeDescription *desc_;
+  CodeDescription* desc_;
 
   // DWARF3 Specification, Table 7.23
   enum CFIInstructions {
     DW_CFA_ADVANCE_LOC = 0x40,
     DW_CFA_OFFSET = 0x80,
     DW_CFA_RESTORE = 0xC0,
     DW_CFA_NOP = 0x00,
     DW_CFA_SET_LOC = 0x01,
     DW_CFA_ADVANCE_LOC1 = 0x02,
     DW_CFA_ADVANCE_LOC2 = 0x03,
@@ skipping 30 matching lines @@
   enum CFIConstants {
     CIE_ID = 0,
     CIE_VERSION = 1,
     CODE_ALIGN_FACTOR = 1,
     DATA_ALIGN_FACTOR = 1,
     RETURN_ADDRESS_REGISTER = AMD64_RA
   };
 };
 
 
-void UnwindInfoSection::WriteLength(Writer *w,
+void UnwindInfoSection::WriteLength(Writer* w,
                                     Writer::Slot<uint32_t>* length_slot,
                                     int initial_position) {
   uint32_t align = (w->position() - initial_position) % kPointerSize;
 
   if (align != 0) {
     for (uint32_t i = 0; i < (kPointerSize - align); i++) {
       w->Write<uint8_t>(DW_CFA_NOP);
     }
   }
 
   ASSERT((w->position() - initial_position) % kPointerSize == 0);
   length_slot->set(w->position() - initial_position);
 }
 
 
-UnwindInfoSection::UnwindInfoSection(CodeDescription *desc)
+UnwindInfoSection::UnwindInfoSection(CodeDescription* desc)
 #ifdef __ELF
     : ELFSection(".eh_frame", TYPE_X86_64_UNWIND, 1),
 #else
     : MachOSection("__eh_frame", "__TEXT", sizeof(uintptr_t),
                    MachOSection::S_REGULAR),
 #endif
       desc_(desc) { }
 
-int UnwindInfoSection::WriteCIE(Writer *w) {
+int UnwindInfoSection::WriteCIE(Writer* w) {
   Writer::Slot<uint32_t> cie_length_slot = w->CreateSlotHere<uint32_t>();
   uint32_t cie_position = w->position();
 
   // Write out the CIE header. Currently no 'common instructions' are
   // emitted onto the CIE; every FDE has its own set of instructions.
 
   w->Write<uint32_t>(CIE_ID);
   w->Write<uint8_t>(CIE_VERSION);
   w->Write<uint8_t>(0);  // Null augmentation string.
   w->WriteSLEB128(CODE_ALIGN_FACTOR);
   w->WriteSLEB128(DATA_ALIGN_FACTOR);
   w->Write<uint8_t>(RETURN_ADDRESS_REGISTER);
 
   WriteLength(w, &cie_length_slot, cie_position);
 
   return cie_position;
 }
 
 
-void UnwindInfoSection::WriteFDE(Writer *w, int cie_position) {
+void UnwindInfoSection::WriteFDE(Writer* w, int cie_position) {
   // The only FDE for this function. The CFA is the current RBP.
   Writer::Slot<uint32_t> fde_length_slot = w->CreateSlotHere<uint32_t>();
   int fde_position = w->position();
   w->Write<int32_t>(fde_position - cie_position + 4);
 
   w->Write<uintptr_t>(desc_->CodeStart());
   w->Write<uintptr_t>(desc_->CodeSize());
 
   WriteFDEStateOnEntry(w);
   WriteFDEStateAfterRBPPush(w);
   WriteFDEStateAfterRBPSet(w);
   WriteFDEStateAfterRBPPop(w);
 
   WriteLength(w, &fde_length_slot, fde_position);
 }
 
 
-void UnwindInfoSection::WriteFDEStateOnEntry(Writer *w) {
+void UnwindInfoSection::WriteFDEStateOnEntry(Writer* w) {
   // The first state, just after the control has been transferred to the the
   // function.
 
   // RBP for this function will be the value of RSP after pushing the RBP
   // for the previous function. The previous RBP has not been pushed yet.
   w->Write<uint8_t>(DW_CFA_DEF_CFA_SF);
   w->WriteULEB128(AMD64_RSP);
   w->WriteSLEB128(-kPointerSize);
 
   // The RA is stored at location CFA + kCallerPCOffset. This is an invariant,
   // and hence omitted from the next states.
   w->Write<uint8_t>(DW_CFA_OFFSET_EXTENDED);
   w->WriteULEB128(AMD64_RA);
   w->WriteSLEB128(StandardFrameConstants::kCallerPCOffset);
 
   // The RBP of the previous function is still in RBP.
   w->Write<uint8_t>(DW_CFA_SAME_VALUE);
   w->WriteULEB128(AMD64_RBP);
 
   // Last location described by this entry.
   w->Write<uint8_t>(DW_CFA_SET_LOC);
   w->Write<uint64_t>(
       desc_->GetStackStateStartAddress(CodeDescription::POST_RBP_PUSH));
 }
 
 
-void UnwindInfoSection::WriteFDEStateAfterRBPPush(Writer *w) {
+void UnwindInfoSection::WriteFDEStateAfterRBPPush(Writer* w) {
   // The second state, just after RBP has been pushed.
 
   // RBP / CFA for this function is now the current RSP, so just set the
   // offset from the previous rule (from -8) to 0.
   w->Write<uint8_t>(DW_CFA_DEF_CFA_OFFSET);
   w->WriteULEB128(0);
 
   // The previous RBP is stored at CFA + kCallerFPOffset. This is an invariant
   // in this and the next state, and hence omitted in the next state.
   w->Write<uint8_t>(DW_CFA_OFFSET_EXTENDED);
   w->WriteULEB128(AMD64_RBP);
   w->WriteSLEB128(StandardFrameConstants::kCallerFPOffset);
 
   // Last location described by this entry.
   w->Write<uint8_t>(DW_CFA_SET_LOC);
   w->Write<uint64_t>(
       desc_->GetStackStateStartAddress(CodeDescription::POST_RBP_SET));
 }
 
 
-void UnwindInfoSection::WriteFDEStateAfterRBPSet(Writer *w) {
+void UnwindInfoSection::WriteFDEStateAfterRBPSet(Writer* w) {
   // The third state, after the RBP has been set.
 
   // The CFA can now directly be set to RBP.
   w->Write<uint8_t>(DW_CFA_DEF_CFA);
   w->WriteULEB128(AMD64_RBP);
   w->WriteULEB128(0);
 
   // Last location described by this entry.
   w->Write<uint8_t>(DW_CFA_SET_LOC);
   w->Write<uint64_t>(
       desc_->GetStackStateStartAddress(CodeDescription::POST_RBP_POP));
 }
 
 
-void UnwindInfoSection::WriteFDEStateAfterRBPPop(Writer *w) {
+void UnwindInfoSection::WriteFDEStateAfterRBPPop(Writer* w) {
   // The fourth (final) state. The RBP has been popped (just before issuing a
   // return).
 
   // The CFA can is now calculated in the same way as in the first state.
   w->Write<uint8_t>(DW_CFA_DEF_CFA_SF);
   w->WriteULEB128(AMD64_RSP);
   w->WriteSLEB128(-kPointerSize);
 
   // The RBP
   w->Write<uint8_t>(DW_CFA_OFFSET_EXTENDED);
   w->WriteULEB128(AMD64_RBP);
   w->WriteSLEB128(StandardFrameConstants::kCallerFPOffset);
 
   // Last location described by this entry.
   w->Write<uint8_t>(DW_CFA_SET_LOC);
   w->Write<uint64_t>(desc_->CodeEnd());
 }
 
 
-bool UnwindInfoSection::WriteBody(Writer *w) {
+bool UnwindInfoSection::WriteBody(Writer* w) {
   uint32_t cie_position = WriteCIE(w);
   WriteFDE(w, cie_position);
   return true;
 }
 
 
 #endif  // V8_TARGET_ARCH_X64
 
 static void CreateDWARFSections(CodeDescription* desc, DebugObject* obj) {
   if (desc->IsLineInfoAvailable()) {
@@ skipping 20 matching lines @@
   struct JITCodeEntry {
     JITCodeEntry* next_;
     JITCodeEntry* prev_;
     Address symfile_addr_;
     uint64_t symfile_size_;
   };
 
   struct JITDescriptor {
     uint32_t version_;
     uint32_t action_flag_;
-    JITCodeEntry *relevant_entry_;
-    JITCodeEntry *first_entry_;
+    JITCodeEntry* relevant_entry_;
+    JITCodeEntry* first_entry_;
   };
 
   // GDB will place breakpoint into this function.
   // To prevent GCC from inlining or removing it we place noinline attribute
   // and inline assembler statement inside.
   void __attribute__((noinline)) __jit_debug_register_code() {
     __asm__("");
   }
 
   // GDB will inspect contents of this descriptor.
@@ skipping 166 matching lines @@
   GetScriptLineNumber(script, 0);
 
   if (!name.is_null()) {
     SmartArrayPointer<char> name_cstring = name->ToCString(DISALLOW_NULLS);
     AddCode(*name_cstring, *code, GDBJITInterface::FUNCTION, *script, info);
   } else {
     AddCode("", *code, GDBJITInterface::FUNCTION, *script, info);
   }
 }
 
-static void AddUnwindInfo(CodeDescription *desc) {
+static void AddUnwindInfo(CodeDescription* desc) {
 #ifdef V8_TARGET_ARCH_X64
   if (desc->tag() == GDBJITInterface::FUNCTION) {
     // To avoid propagating unwinding information through
     // compilation pipeline we use an approximation.
     // For most use cases this should not affect usability.
     static const int kFramePointerPushOffset = 1;
     static const int kFramePointerSetOffset = 4;
     static const int kFramePointerPopOffset = -3;
 
     uintptr_t frame_pointer_push_address =
@@ skipping 137 matching lines @@
   ScopedLock lock(mutex_);
   ASSERT(!IsLineInfoTagged(line_info));
   HashMap::Entry* e = GetEntries()->Lookup(code, HashForCodeObject(code), true);
   ASSERT(e->value == NULL);
   e->value = TagLineInfo(line_info);
 }
 
 
 } }  // namespace v8::internal
 #endif