Added gdb-jit interface support for ARM. Compressed .debug_line table by 1)...

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 376 matching lines @@
     uint16_t pht_entry_num;
     uint16_t sht_entry_size;
     uint16_t sht_entry_num;
     uint16_t sht_strtab_index;
   };
 
 
   void WriteHeader(Writer* w) {
     ASSERT(w->position() == 0);
     Writer::Slot<ELFHeader> header = w->CreateSlotHere<ELFHeader>();
-#if defined(V8_TARGET_ARCH_IA32)
+#if defined(V8_TARGET_ARCH_IA32) || defined(V8_TARGET_ARCH_ARM)

[Vyacheslav Egorov (Chromium), 2011/02/01 12:49:51]

I think that you need to change SConstruct to enable building with gdbjit=on on
arm but I do not see it in this changelist. 

Did you accidentally omit it?

     const uint8_t ident[16] =
         { 0x7f, 'E', 'L', 'F', 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 #elif defined(V8_TARGET_ARCH_X64)
     const uint8_t ident[16] =
         { 0x7f, 'E', 'L', 'F', 2, 1, 1, 0, 0, 0 , 0, 0, 0, 0, 0, 0};
 #else
 #error Unsupported target architecture.
 #endif
     memcpy(header->ident, ident, 16);
     header->type = 1;
 #if defined(V8_TARGET_ARCH_IA32)
     header->machine = 3;
 #elif defined(V8_TARGET_ARCH_X64)
     // Processor identification value for x64 is 62 as defined in
     //    System V ABI, AMD64 Supplement
     //    http://www.x86-64.org/documentation/abi.pdf
     header->machine = 62;
+#elif defined(V8_TARGET_ARCH_ARM)
+    // Set to EM_ARM, defined as 40, in "ARM ELF File Format" at
+    // infocenter.arm.com/help/topic/com.arm.doc.dui0101a/DUI0101A_Elf.pdf
+    header->machine = 40;
 #else
 #error Unsupported target architecture.
 #endif
     header->version = 1;
     header->entry = 0;
     header->pht_offset = 0;
     header->sht_offset = sizeof(ELFHeader);  // Section table follows header.
     header->flags = 0;
     header->header_size = sizeof(ELFHeader);
     header->pht_entry_size = 0;
@@ skipping 71 matching lines @@
         size(size),
         info((binding << 4) | type),
         other(0),
         section(section) {
   }
 
   Binding binding() const {
     return static_cast<Binding>(info >> 4);
   }
 
-#if defined(V8_TARGET_ARCH_IA32)
+#if defined(V8_TARGET_ARCH_IA32) || defined(V8_TARGET_ARCH_ARM)
   struct SerializedLayout {
     SerializedLayout(uint32_t name,
                      uintptr_t value,
                      uintptr_t size,
                      Binding binding,
                      Type type,
                      uint16_t section)
         : name(name),
           value(value),
           size(size),
@@ skipping 290 matching lines @@
     DW_LNE_END_SEQUENCE = 1,
     DW_LNE_SET_ADDRESS = 2,
     DW_LNE_DEFINE_FILE = 3
   };
 
   bool WriteBody(Writer* w) {
     // Write prologue.
     Writer::Slot<uint32_t> total_length = w->CreateSlotHere<uint32_t>();
     uintptr_t start = w->position();
 
+    // Used for special opcodes
+    const int8_t line_base = 1;
+    const uint8_t line_range = 7;
+    const int8_t max_line_incr = (line_base + line_range - 1);
+    const uint8_t opcode_base = DW_LNS_NEGATE_STMT + 1;
+
     w->Write<uint16_t>(2);  // Field version.
     Writer::Slot<uint32_t> prologue_length = w->CreateSlotHere<uint32_t>();
     uintptr_t prologue_start = w->position();
     w->Write<uint8_t>(1);  // Field minimum_instruction_length.
     w->Write<uint8_t>(1);  // Field default_is_stmt.
-    w->Write<int8_t>(0);  // Field line_base.
-    w->Write<uint8_t>(2);  // Field line_range.
-    w->Write<uint8_t>(DW_LNS_NEGATE_STMT + 1);  // Field opcode_base.
+    w->Write<int8_t>(line_base);  // Field line_base.
+    w->Write<uint8_t>(line_range);  // Field line_range.
+    w->Write<uint8_t>(opcode_base);  // Field opcode_base.
     w->Write<uint8_t>(0);  // DW_LNS_COPY operands count.
     w->Write<uint8_t>(1);  // DW_LNS_ADVANCE_PC operands count.
     w->Write<uint8_t>(1);  // DW_LNS_ADVANCE_LINE operands count.
     w->Write<uint8_t>(1);  // DW_LNS_SET_FILE operands count.
     w->Write<uint8_t>(1);  // DW_LNS_SET_COLUMN operands count.
     w->Write<uint8_t>(0);  // DW_LNS_NEGATE_STMT operands count.
     w->Write<uint8_t>(0);  // Empty include_directories sequence.
     w->WriteString(*desc_->filename());  // File name.
     w->WriteULEB128(0);  // Current directory.
     w->WriteULEB128(0);  // Unknown modification time.
     w->WriteULEB128(0);  // Unknown file size.
     w->Write<uint8_t>(0);
     prologue_length.set(static_cast<uint32_t>(w->position() - prologue_start));
 
     WriteExtendedOpcode(w, DW_LNE_SET_ADDRESS, sizeof(intptr_t));
     w->Write<intptr_t>(desc_->code_start());
+    w->Write<uint8_t>(DW_LNS_COPY);
 
     intptr_t pc = 0;
     intptr_t line = 1;
     bool is_statement = true;
 
     List<GDBJITLineInfo::PCInfo>* pc_info = desc_->lineinfo()->pc_info();
     pc_info->Sort(&ComparePCInfo);
-    for (int i = 0; i < pc_info->length(); i++) {
+
+    int pc_info_length = pc_info->length();
+    for (int i = 0; i < pc_info_length; i++) {
       GDBJITLineInfo::PCInfo* info = &pc_info->at(i);
-      uintptr_t pc_diff = info->pc_ - pc;
       ASSERT(info->pc_ >= pc);
-      if (pc_diff != 0) {
-        w->Write<uint8_t>(DW_LNS_ADVANCE_PC);
-        w->WriteSLEB128(pc_diff);
-        pc += pc_diff;
+
+      // Reduce bloating in the debug line table by removing duplicate
+      // <file, line, column> entries (per dwarf 2.0 standard).

[Vyacheslav Egorov (Chromium), 2011/02/01 12:49:51]

Comment is slightly confusing as we do not track column information.

+      intptr_t  new_line = desc_->GetScriptLineNumber(info->pos_);
+      if (new_line == line) {
+        continue;
       }
-      intptr_t line_diff = desc_->GetScriptLineNumber(info->pos_) - line;
-      if (line_diff != 0) {
-        w->Write<uint8_t>(DW_LNS_ADVANCE_LINE);
-        w->WriteSLEB128(line_diff);
-        line += line_diff;
-      }
-      if (is_statement != info->is_statement_) {
+
+      // Mark statement boundaries.  For a better debugging experience, mark
+      // the last pc address in the function as a statement (e.g. "}"), so that
+      // a user can see the result of the last line executed in the function,
+      // should control reach the end.
+      if ((i+1) == pc_info_length) {
+        if (!is_statement) {
+          w->Write<uint8_t>(DW_LNS_NEGATE_STMT);
+        }
+      } else if (is_statement != info->is_statement_) {
         w->Write<uint8_t>(DW_LNS_NEGATE_STMT);
         is_statement = !is_statement;
       }
-      if (pc_diff != 0 || i == 0) {
+
+      // Generate special opcodes, if possible.  This results in more compact
+      // debug line tables.  See the DWARF 2.0 standard to learn more about
+      // special opcodes.
+      bool special_opcode_used = false;
+      uintptr_t pc_diff = info->pc_ - pc;
+      intptr_t line_diff = desc_->GetScriptLineNumber(info->pos_) - line;

[Vyacheslav Egorov (Chromium), 2011/02/01 12:49:51]

I think desc_->GetScriptLineNumber(info->pos_) is already in new_line variable.
You can use it here to avoid recalculation (it has linear complexity, not O(1)
one AFAIK).

+
+      // Compute special opcode (see DWARF 2.0 standard)
+      intptr_t special_opcode = (line_diff - line_base) +
+                                (line_range * pc_diff) + opcode_base;
+
+      // If the special opcode is < 255, it can be used as a special opcode.

[Vyacheslav Egorov (Chromium), 2011/02/01 12:49:51]

I prefer to write "less than" instead of "<". 

BTW you probably meant less than or equal.

This sentence is also slightly confusing: can you please change first "special
opcode" to special_opcode.

+      // If line_diff is larger than the max line increment allowed for a
+      // special opcode, or if line_diff is less than the minimum line that can
+      // be added to the line register (i.e. line_base), then special opcode
+      // can't be used.
+      if ((special_opcode >= opcode_base) && (special_opcode <= 255) &&
+          (line_diff <= max_line_incr) && (line_diff >= line_base)) {
+        w->Write<uint8_t>(special_opcode);
+        special_opcode_used = true;
+      } else {
+        if (pc_diff != 0) {
+          w->Write<uint8_t>(DW_LNS_ADVANCE_PC);
+          w->WriteSLEB128(pc_diff);
+        }
+        if (line_diff != 0) {

[Vyacheslav Egorov (Chromium), 2011/02/01 12:49:51]

line_diff is guaranteed to be non-zero now.

+          w->Write<uint8_t>(DW_LNS_ADVANCE_LINE);
+          w->WriteSLEB128(line_diff);
+        }
+      }
+
+      // Increment the pc and line operands.
+      pc += pc_diff;
+      line += line_diff;
+
+      // Copy state machine registers if there is a line number difference.
+      // A copy operation is not needed if a special opcode was emitted.
+      if (!special_opcode_used && (line_diff != 0)) {

[Vyacheslav Egorov (Chromium), 2011/02/01 12:49:51]

line_diff is guaranteed to be non-zero now. 

So you can move DW_LNS_COPY emittance to the end of the else branch and remove
special_opcode_used variable.

 

         w->Write<uint8_t>(DW_LNS_COPY);
       }
     }
+    // Need to advance the pc to the end of the routine before an end sequence

[Vyacheslav Egorov (Chromium), 2011/02/01 12:49:51]

Empty line before comment.

+    // can be generated (otherwise the wrong pc address gets associated with
+    // the last line).
+
+    // Advance the pc to the end of the routine, since the end sequence opcode
+    // requires this.
+    w->Write<uint8_t>(DW_LNS_ADVANCE_PC);
+    w->WriteSLEB128(desc_->code_size() - pc);
     WriteExtendedOpcode(w, DW_LNE_END_SEQUENCE, 0);
     total_length.set(static_cast<uint32_t>(w->position() - start));
     return true;
   }
 
  private:
   void WriteExtendedOpcode(Writer* w,
                            DWARF2ExtendedOpcode op,
                            size_t operands_size) {
     w->Write<uint8_t>(0);
@@ skipping 80 matching lines @@
   return entry;
 }
 
 
 static void DestroyCodeEntry(JITCodeEntry* entry) {
   free(entry);
 }
 
 
 static void RegisterCodeEntry(JITCodeEntry* entry) {
+#if defined(DEBUG) && !defined(WIN32)
+  static int fileNum = 0;
+  FILE* file;
+  if (FLAG_gdbjit_dump) {
+    static const int kBufferSize = 64;
+    static const char* kElfFilePre = "/tmp/elfdump";
+    static const char* kObjFileExt = ".o";
+    char buffer[64];
+
+    OS::SNPrintF(Vector<char>(buffer, kBufferSize), "%s%d%s",
+                 kElfFilePre, fileNum, kObjFileExt);
+    file = OS::FOpen(buffer, "w");
+    fwrite(entry->symfile_addr_, entry->symfile_size_, 1, file);

[Vyacheslav Egorov (Chromium), 2011/02/01 12:49:51]

I think you can use WriteBytes() utility function (see v8utils.h).

+  }
+#endif
+
   entry->next_ = __jit_debug_descriptor.first_entry_;
   if (entry->next_ != NULL) entry->next_->prev_ = entry;
   __jit_debug_descriptor.first_entry_ =
       __jit_debug_descriptor.relevant_entry_ = entry;
 
   __jit_debug_descriptor.action_flag_ = JIT_REGISTER_FN;
   __jit_debug_register_code();
+
+#if defined(DEBUG) && !defined(WIN32)
+  if (FLAG_gdbjit_dump) {
+    fileNum++;

[Vyacheslav Egorov (Chromium), 2011/02/01 12:49:51]

it's not clear why you close the file after calling __jit_debug_register_code().

I think code will be much more compact and readable if you close the file
immediately after fwrite.

+    fclose(file);
+  }
+#endif
 }
 
 
 static void UnregisterCodeEntry(JITCodeEntry* entry) {
   if (entry->prev_ != NULL) {
     entry->prev_->next_ = entry->next_;
   } else {
     __jit_debug_descriptor.first_entry_ = entry->next_;
   }
 
@@ skipping 30 matching lines @@
 
   return CreateCodeEntry(w.buffer(), w.position());
 }
 
 
 static bool SameCodeObjects(void* key1, void* key2) {
   return key1 == key2;
 }
 
 
-static HashMap entries(&SameCodeObjects);
+static HashMap* GetEntries() {
+  static HashMap entries(&SameCodeObjects);

[Vyacheslav Egorov (Chromium), 2011/02/01 12:49:51]

Google C++ Style Guide explicitly forbid non POD static variable
(http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Static...)
and recommends to use pointers. We somehow managed to overlook this point.

Can you change GetEntries so it will use pointer?

Something like:

static HashMap* GetEntries() {
  if (entries == NULL) {
    entries = new HashMap(&SameCodeObjects); 
  }
  return entries;
}

should be fine.

+  return &entries;
+}
 
 
 static uint32_t HashForCodeObject(Code* code) {
   static const uintptr_t kGoldenRatio = 2654435761u;
   uintptr_t hash = reinterpret_cast<uintptr_t>(code->address());
   return static_cast<uint32_t>((hash >> kCodeAlignmentBits) * kGoldenRatio);
 }
 
 
 static const intptr_t kLineInfoTag = 0x1;
@@ skipping 32 matching lines @@
   }
 }
 
 
 void GDBJITInterface::AddCode(const char* name,
                               Code* code,
                               Script* script) {
   if (!FLAG_gdbjit) return;
   AssertNoAllocation no_gc;
 
-  HashMap::Entry* e = entries.Lookup(code, HashForCodeObject(code), true);
+  HashMap::Entry* e = GetEntries()->Lookup(code, HashForCodeObject(code), true);
   if (e->value != NULL && !IsLineInfoTagged(e->value)) return;
 
   GDBJITLineInfo* lineinfo = UntagLineInfo(e->value);
   CodeDescription code_desc(name,
                             code,
                             script != NULL ? Handle<Script>(script)
                                            : Handle<Script>(),
                             lineinfo);
 
   if (!FLAG_gdbjit_full && !code_desc.is_line_info_available()) {
     delete lineinfo;
-    entries.Remove(code, HashForCodeObject(code));
+    GetEntries()->Remove(code, HashForCodeObject(code));
     return;
   }
 
   JITCodeEntry* entry = CreateELFObject(&code_desc);
   ASSERT(!IsLineInfoTagged(entry));
 
   delete lineinfo;
   e->value = entry;
 
   RegisterCodeEntry(entry);
@@ skipping 31 matching lines @@
 void GDBJITInterface::AddCode(GDBJITInterface::CodeTag tag, Code* code) {
   if (!FLAG_gdbjit) return;
 
   AddCode(tag, "", code);
 }
 
 
 void GDBJITInterface::RemoveCode(Code* code) {
   if (!FLAG_gdbjit) return;
 
-  HashMap::Entry* e = entries.Lookup(code, HashForCodeObject(code), false);
+  HashMap::Entry* e =GetEntries()->Lookup(code, HashForCodeObject(code), false);

[Vyacheslav Egorov (Chromium), 2011/02/01 12:49:51]

after = add space

   if (e == NULL) return;
 
   if (IsLineInfoTagged(e->value)) {
     delete UntagLineInfo(e->value);
   } else {
     JITCodeEntry* entry = static_cast<JITCodeEntry*>(e->value);
     UnregisterCodeEntry(entry);
     DestroyCodeEntry(entry);
   }
   e->value = NULL;
-  entries.Remove(code, HashForCodeObject(code));
+  GetEntries()->Remove(code, HashForCodeObject(code));
 }
 
 
 void GDBJITInterface::RegisterDetailedLineInfo(Code* code,
                                                GDBJITLineInfo* line_info) {
   ASSERT(!IsLineInfoTagged(line_info));
-  HashMap::Entry* e = entries.Lookup(code, HashForCodeObject(code), true);
+  HashMap::Entry* e = GetEntries()->Lookup(code, HashForCodeObject(code), true);
   ASSERT(e->value == NULL);
   e->value = TagLineInfo(line_info);
 }
 
 
 } }  // namespace v8::internal
 #endif