Make GDBJIT interface compile again.

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 169 matching lines @@
     ASSERT(offset < capacity_ && offset + sizeof(T) <= capacity_);
     return reinterpret_cast<T*>(&buffer_[offset]);
   }
 
   DebugObject* debug_object_;
   uintptr_t position_;
   uintptr_t capacity_;
   byte* buffer_;
 };
 
-class StringTable;
+class ELFStringTable;
 
 template<typename THeader>
 class DebugSectionBase : public ZoneObject {
  public:
   virtual ~DebugSectionBase() { }
 
   virtual void WriteBody(Writer::Slot<THeader> header, Writer* writer) {
     uintptr_t start = writer->position();
     if (WriteBodyInternal(writer)) {
       uintptr_t end = writer->position();
@@ skipping 130 matching lines @@
 
   enum SpecialIndexes {
     INDEX_ABSOLUTE = 0xfff1
   };
 
   ELFSection(const char* name, Type type, uintptr_t align)
       : name_(name), type_(type), align_(align) { }
 
   virtual ~ELFSection() { }
 
-  void PopulateHeader(Writer::Slot<Header> header, StringTable* strtab);
+  void PopulateHeader(Writer::Slot<Header> header, ELFStringTable* strtab);
 
   virtual void WriteBody(Writer::Slot<Header> header, Writer* w) {
     uintptr_t start = w->position();
     if (WriteBodyInternal(w)) {
       uintptr_t end = w->position();
       header->offset = start;
       header->size = end - start;
     }
   }
 
@@ skipping 79 matching lines @@
   }
 
  private:
   uintptr_t addr_;
   uintptr_t offset_;
   uintptr_t size_;
   uintptr_t flags_;
 };
 
 
-class StringTable : public ELFSection {
+class ELFStringTable : public ELFSection {
  public:
-  explicit StringTable(const char* name)
+  explicit ELFStringTable(const char* name)
       : ELFSection(name, TYPE_STRTAB, 1), writer_(NULL), offset_(0), size_(0) {
   }
 
   uintptr_t Add(const char* str) {
     if (*str == '\0') return 0;
 
     uintptr_t offset = size_;
     WriteString(str);
     return offset;
   }
@@ skipping 27 matching lines @@
   }
 
   Writer* writer_;
 
   uintptr_t offset_;
   uintptr_t size_;
 };
 
 
 void ELFSection::PopulateHeader(Writer::Slot<ELFSection::Header> header,
-                                StringTable* strtab) {
+                                ELFStringTable* strtab) {
   header->name = strtab->Add(name_);
   header->type = type_;
   header->alignment = align_;
   PopulateHeader(header);
 }
 #endif  // defined(__ELF)
 
 
 #if defined(__MACH_O)
 class MachO BASE_EMBEDDED {
@@ skipping 122 matching lines @@
   ZoneList<MachOSection*> sections_;
 };
 #endif  // defined(__MACH_O)
 
 
 #if defined(__ELF)
 class ELF BASE_EMBEDDED {
  public:
   ELF(Zone* zone) : sections_(6, zone) {
     sections_.Add(new(zone) ELFSection("", ELFSection::TYPE_NULL, 0), zone);
-    sections_.Add(new(zone) StringTable(".shstrtab"), zone);
+    sections_.Add(new(zone) ELFStringTable(".shstrtab"), zone);
   }
 
   void Write(Writer* w) {
     WriteHeader(w);
     WriteSectionTable(w);
     WriteSections(w);
   }
 
   ELFSection* SectionAt(uint32_t index) {
     return sections_[index];
@@ skipping 66 matching lines @@
   }
 
   void WriteSectionTable(Writer* w) {
     // Section headers table immediately follows file header.
     ASSERT(w->position() == sizeof(ELFHeader));
 
     Writer::Slot<ELFSection::Header> headers =
         w->CreateSlotsHere<ELFSection::Header>(sections_.length());
 
     // String table for section table is the first section.
-    StringTable* strtab = static_cast<StringTable*>(SectionAt(1));
+    ELFStringTable* strtab = static_cast<ELFStringTable*>(SectionAt(1));
     strtab->AttachWriter(w);
     for (int i = 0, length = sections_.length();
          i < length;
          i++) {
       sections_[i]->PopulateHeader(headers.at(i), strtab);
     }
     strtab->DetachWriter();
   }
 
   int SectionHeaderPosition(uint32_t section_index) {
@@ skipping 93 matching lines @@
 
     uint32_t name;
     uint8_t info;
     uint8_t other;
     uint16_t section;
     uintptr_t value;
     uintptr_t size;
   };
 #endif
 
-  void Write(Writer::Slot<SerializedLayout> s, StringTable* t) {
+  void Write(Writer::Slot<SerializedLayout> s, ELFStringTable* t) {
     // Convert symbol names from strings to indexes in the string table.
     s->name = t->Add(name);
     s->value = value;
     s->size = size;
     s->info = info;
     s->other = other;
     s->section = section;
   }
 
  private:
@@ skipping 18 matching lines @@
     w->Align(header->alignment);
     int total_symbols = locals_.length() + globals_.length() + 1;
     header->offset = w->position();
 
     Writer::Slot<ELFSymbol::SerializedLayout> symbols =
         w->CreateSlotsHere<ELFSymbol::SerializedLayout>(total_symbols);
 
     header->size = w->position() - header->offset;
 
     // String table for this symbol table should follow it in the section table.
-    StringTable* strtab =
-        static_cast<StringTable*>(w->debug_object()->SectionAt(index() + 1));
+    ELFStringTable* strtab =
+        static_cast<ELFStringTable*>(w->debug_object()->SectionAt(index() + 1));
     strtab->AttachWriter(w);
     symbols.at(0).set(ELFSymbol::SerializedLayout(0,
                                                   0,
                                                   0,
                                                   ELFSymbol::BIND_LOCAL,
                                                   ELFSymbol::TYPE_NOTYPE,
                                                   0));
     WriteSymbolsList(&locals_, symbols.at(1), strtab);
     WriteSymbolsList(&globals_, symbols.at(locals_.length() + 1), strtab);
     strtab->DetachWriter();
@@ skipping 12 matching lines @@
     ELFSection::PopulateHeader(header);
     // We are assuming that string table will follow symbol table.
     header->link = index() + 1;
     header->info = locals_.length() + 1;
     header->entry_size = sizeof(ELFSymbol::SerializedLayout);
   }
 
  private:
   void WriteSymbolsList(const ZoneList<ELFSymbol>* src,
                         Writer::Slot<ELFSymbol::SerializedLayout> dst,
-                        StringTable* strtab) {
+                        ELFStringTable* strtab) {
     for (int i = 0, len = src->length();
          i < len;
          i++) {
       src->at(i).Write(dst.at(i), strtab);
     }
   }
 
   ZoneList<ELFSymbol> locals_;
   ZoneList<ELFSymbol> globals_;
 };
@@ skipping 97 matching lines @@
   uintptr_t stack_state_start_addresses_[STACK_STATE_MAX];
 #endif
 };
 
 #if defined(__ELF)
 static void CreateSymbolsTable(CodeDescription* desc,
                                ELF* elf,
                                int text_section_index) {
   Zone* zone = desc->info()->zone();
   ELFSymbolTable* symtab = new(zone) ELFSymbolTable(".symtab", zone);
-  StringTable* strtab = new(zone) StringTable(".strtab");
+  ELFStringTable* strtab = new(zone) ELFStringTable(".strtab");
 
   // Symbol table should be followed by the linked string table.
   elf->AddSection(symtab, zone);
   elf->AddSection(strtab, zone);
 
   symtab->Add(ELFSymbol("V8 Code",
                         0,
                         0,
                         ELFSymbol::BIND_LOCAL,
                         ELFSymbol::TYPE_FILE,
@@ skipping 952 matching lines @@
       reinterpret_cast<intptr_t>(ptr) | kLineInfoTag);
 }
 
 
 static GDBJITLineInfo* UntagLineInfo(void* ptr) {
   return reinterpret_cast<GDBJITLineInfo*>(
       reinterpret_cast<intptr_t>(ptr) & ~kLineInfoTag);
 }
 
 
-void GDBJITInterface::AddCode(Handle<String> name,
+void GDBJITInterface::AddCode(Handle<Name> name,
                               Handle<Script> script,
                               Handle<Code> code,
                               CompilationInfo* info) {
   if (!FLAG_gdbjit) return;
 
   // Force initialization of line_ends array.
   GetScriptLineNumber(script, 0);
 
-  if (!name.is_null()) {
-    SmartArrayPointer<char> name_cstring = name->ToCString(DISALLOW_NULLS);
+  if (!name.is_null() && name->IsString()) {
+    SmartArrayPointer<char> name_cstring =
+        Handle<String>::cast(name)->ToCString(DISALLOW_NULLS);
     AddCode(*name_cstring, *code, GDBJITInterface::FUNCTION, *script, info);
   } else {
     AddCode("", *code, GDBJITInterface::FUNCTION, *script, info);
   }
 }
 
 static void AddUnwindInfo(CodeDescription* desc) {
 #ifdef V8_TARGET_ARCH_X64
   if (desc->tag() == GDBJITInterface::FUNCTION) {
     // To avoid propagating unwinding information through
@@ skipping 97 matching lines @@
     builder.AddString(name);
   } else {
     builder.AddFormatted(": code object %p", static_cast<void*>(code));
   }
 
   AddCode(builder.Finalize(), code, tag, NULL, NULL);
 }
 
 
 void GDBJITInterface::AddCode(GDBJITInterface::CodeTag tag,
-                              String* name,
+                              Name* name,
                               Code* code) {
   if (!FLAG_gdbjit) return;
-  AddCode(tag, name != NULL ? *name->ToCString(DISALLOW_NULLS) : NULL, code);
+  if (name != NULL && name->IsString()) {
+    AddCode(tag, *String::cast(name)->ToCString(DISALLOW_NULLS), code);
+  } else {
+    AddCode(tag, "", code);
+  }
 }
 
 
 void GDBJITInterface::AddCode(GDBJITInterface::CodeTag tag, Code* code) {
   if (!FLAG_gdbjit) return;
 
   AddCode(tag, "", code);
 }
 
 
@@ skipping 23 matching lines @@
   ScopedLock lock(mutex.Pointer());
   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