A64: Synchronize with r15545.

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 199 matching lines @@
     return false;
   }
 
   typedef THeader Header;
 };
 
 
 struct MachOSectionHeader {
   char sectname[16];
   char segname[16];
-#if defined(V8_TARGET_ARCH_IA32)
+#if V8_TARGET_ARCH_IA32
   uint32_t addr;
   uint32_t size;
 #else
   uint64_t addr;
   uint64_t size;
 #endif
   uint32_t offset;
   uint32_t align;
   uint32_t reloff;
   uint32_t nreloc;
@@ skipping 262 matching lines @@
   header->type = type_;
   header->alignment = align_;
   PopulateHeader(header);
 }
 #endif  // defined(__ELF)
 
 
 #if defined(__MACH_O)
 class MachO BASE_EMBEDDED {
  public:
-  MachO() : sections_(6) { }
+  explicit MachO(Zone* zone) : zone_(zone), sections_(6, zone) { }
 
   uint32_t AddSection(MachOSection* section) {
-    sections_.Add(section);
+    sections_.Add(section, zone_);
     return sections_.length() - 1;
   }
 
   void Write(Writer* w, uintptr_t code_start, uintptr_t code_size) {
     Writer::Slot<MachOHeader> header = WriteHeader(w);
     uintptr_t load_command_start = w->position();
     Writer::Slot<MachOSegmentCommand> cmd = WriteSegmentCommand(w,
                                                                 code_start,
                                                                 code_size);
     WriteSections(w, cmd, header, load_command_start);
   }
 
  private:
   struct MachOHeader {
     uint32_t magic;
     uint32_t cputype;
     uint32_t cpusubtype;
     uint32_t filetype;
     uint32_t ncmds;
     uint32_t sizeofcmds;
     uint32_t flags;
-#if defined(V8_TARGET_ARCH_X64)
+#if V8_TARGET_ARCH_X64
     uint32_t reserved;
 #endif
   };
 
   struct MachOSegmentCommand {
     uint32_t cmd;
     uint32_t cmdsize;
     char segname[16];
-#if defined(V8_TARGET_ARCH_IA32)
+#if V8_TARGET_ARCH_IA32
     uint32_t vmaddr;
     uint32_t vmsize;
     uint32_t fileoff;
     uint32_t filesize;
 #else
     uint64_t vmaddr;
     uint64_t vmsize;
     uint64_t fileoff;
     uint64_t filesize;
 #endif
     uint32_t maxprot;
     uint32_t initprot;
     uint32_t nsects;
     uint32_t flags;
   };
 
   enum MachOLoadCommandCmd {
     LC_SEGMENT_32 = 0x00000001u,
     LC_SEGMENT_64 = 0x00000019u
   };
 
 
   Writer::Slot<MachOHeader> WriteHeader(Writer* w) {
     ASSERT(w->position() == 0);
     Writer::Slot<MachOHeader> header = w->CreateSlotHere<MachOHeader>();
-#if defined(V8_TARGET_ARCH_IA32)
+#if V8_TARGET_ARCH_IA32
     header->magic = 0xFEEDFACEu;
     header->cputype = 7;  // i386
     header->cpusubtype = 3;  // CPU_SUBTYPE_I386_ALL
-#elif defined(V8_TARGET_ARCH_X64)
+#elif V8_TARGET_ARCH_X64
     header->magic = 0xFEEDFACFu;
     header->cputype = 7 | 0x01000000;  // i386 | 64-bit ABI
     header->cpusubtype = 3;  // CPU_SUBTYPE_I386_ALL
     header->reserved = 0;
 #else
 #error Unsupported target architecture.
 #endif
     header->filetype = 0x1;  // MH_OBJECT
     header->ncmds = 1;
     header->sizeofcmds = 0;
     header->flags = 0;
     return header;
   }
 
 
   Writer::Slot<MachOSegmentCommand> WriteSegmentCommand(Writer* w,
                                                         uintptr_t code_start,
                                                         uintptr_t code_size) {
     Writer::Slot<MachOSegmentCommand> cmd =
         w->CreateSlotHere<MachOSegmentCommand>();
-#if defined(V8_TARGET_ARCH_IA32)
+#if V8_TARGET_ARCH_IA32
     cmd->cmd = LC_SEGMENT_32;
 #else
     cmd->cmd = LC_SEGMENT_64;
 #endif
     cmd->vmaddr = code_start;
     cmd->vmsize = code_size;
     cmd->fileoff = 0;
     cmd->filesize = 0;
     cmd->maxprot = 7;
     cmd->initprot = 7;
@@ skipping 14 matching lines @@
         w->CreateSlotsHere<MachOSection::Header>(sections_.length());
     cmd->fileoff = w->position();
     header->sizeofcmds = w->position() - load_command_start;
     for (int section = 0; section < sections_.length(); ++section) {
       sections_[section]->PopulateHeader(headers.at(section));
       sections_[section]->WriteBody(headers.at(section), w);
     }
     cmd->filesize = w->position() - (uintptr_t)cmd->fileoff;
   }
 
-
+  Zone* zone_;
   ZoneList<MachOSection*> sections_;
 };
 #endif  // defined(__MACH_O)
 
 
 #if defined(__ELF)
 class ELF BASE_EMBEDDED {
  public:
-  explicit ELF(Zone* zone) : sections_(6, zone) {
+  explicit ELF(Zone* zone) : zone_(zone), sections_(6, zone) {
     sections_.Add(new(zone) ELFSection("", ELFSection::TYPE_NULL, 0), 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];
   }
 
-  uint32_t AddSection(ELFSection* section, Zone* zone) {
-    sections_.Add(section, zone);
+  uint32_t AddSection(ELFSection* section) {
+    sections_.Add(section, zone_);
     section->set_index(sections_.length() - 1);
     return sections_.length() - 1;
   }
 
  private:
   struct ELFHeader {
     uint8_t ident[16];
     uint16_t type;
     uint16_t machine;
     uint32_t version;
     uintptr_t entry;
     uintptr_t pht_offset;
     uintptr_t sht_offset;
     uint32_t flags;
     uint16_t header_size;
     uint16_t pht_entry_size;
     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) || defined(V8_TARGET_ARCH_ARM)
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM
     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)
+#elif 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
     OS::MemCopy(header->ident, ident, 16);
     header->type = 1;
-#if defined(V8_TARGET_ARCH_IA32)
+#if V8_TARGET_ARCH_IA32
     header->machine = 3;
-#elif defined(V8_TARGET_ARCH_X64)
+#elif 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)
+#elif 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.
@@ skipping 32 matching lines @@
     Writer::Slot<ELFSection::Header> headers =
         w->SlotAt<ELFSection::Header>(sizeof(ELFHeader));
 
     for (int i = 0, length = sections_.length();
          i < length;
          i++) {
       sections_[i]->WriteBody(headers.at(i), w);
     }
   }
 
+  Zone* zone_;
   ZoneList<ELFSection*> sections_;
 };
 
 
 class ELFSymbol BASE_EMBEDDED {
  public:
   enum Type {
     TYPE_NOTYPE = 0,
     TYPE_OBJECT = 1,
     TYPE_FUNC = 2,
@@ skipping 21 matching lines @@
         value(value),
         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) || defined(V8_TARGET_ARCH_ARM)
+#if V8_TARGET_ARCH_IA32 || 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),
           info((binding << 4) | type),
           other(0),
           section(section) {
     }
 
     uint32_t name;
     uintptr_t value;
     uintptr_t size;
     uint8_t info;
     uint8_t other;
     uint16_t section;
   };
-#elif defined(V8_TARGET_ARCH_X64)
+#elif V8_TARGET_ARCH_X64
   struct SerializedLayout {
     SerializedLayout(uint32_t name,
                      uintptr_t value,
                      uintptr_t size,
                      Binding binding,
                      Type type,
                      uint16_t section)
         : name(name),
           info((binding << 4) | type),
           other(0),
@@ skipping 93 matching lines @@
   }
 
   ZoneList<ELFSymbol> locals_;
   ZoneList<ELFSymbol> globals_;
 };
 #endif  // defined(__ELF)
 
 
 class CodeDescription BASE_EMBEDDED {
  public:
-#ifdef V8_TARGET_ARCH_X64
+#if V8_TARGET_ARCH_X64
   enum StackState {
     POST_RBP_PUSH,
     POST_RBP_SET,
     POST_RBP_POP,
     STACK_STATE_MAX
   };
 #endif
 
   CodeDescription(const char* name,
                   Code* code,
@@ skipping 42 matching lines @@
   }
 
   bool IsLineInfoAvailable() {
     return !script_.is_null() &&
         script_->source()->IsString() &&
         script_->HasValidSource() &&
         script_->name()->IsString() &&
         lineinfo_ != NULL;
   }
 
-#ifdef V8_TARGET_ARCH_X64
+#if V8_TARGET_ARCH_X64
   uintptr_t GetStackStateStartAddress(StackState state) const {
     ASSERT(state < STACK_STATE_MAX);
     return stack_state_start_addresses_[state];
   }
 
   void SetStackStateStartAddress(StackState state, uintptr_t addr) {
     ASSERT(state < STACK_STATE_MAX);
     stack_state_start_addresses_[state] = addr;
   }
 #endif
 
   SmartArrayPointer<char> GetFilename() {
     return String::cast(script_->name())->ToCString();
   }
 
   int GetScriptLineNumber(int pos) {
     return GetScriptLineNumberSafe(script_, pos) + 1;
   }
 
 
  private:
   const char* name_;
   Code* code_;
   Handle<Script> script_;
   GDBJITLineInfo* lineinfo_;
   GDBJITInterface::CodeTag tag_;
   CompilationInfo* info_;
-#ifdef V8_TARGET_ARCH_X64
+#if V8_TARGET_ARCH_X64
   uintptr_t stack_state_start_addresses_[STACK_STATE_MAX];
 #endif
 };
 
 #if defined(__ELF)
 static void CreateSymbolsTable(CodeDescription* desc,
                                Zone* zone,
                                ELF* elf,
                                int text_section_index) {
   ELFSymbolTable* symtab = new(zone) ELFSymbolTable(".symtab", zone);
   ELFStringTable* strtab = new(zone) ELFStringTable(".strtab");
 
   // Symbol table should be followed by the linked string table.
-  elf->AddSection(symtab, zone);
-  elf->AddSection(strtab, zone);
+  elf->AddSection(symtab);
+  elf->AddSection(strtab);
 
   symtab->Add(ELFSymbol("V8 Code",
                         0,
                         0,
                         ELFSymbol::BIND_LOCAL,
                         ELFSymbol::TYPE_FILE,
                         ELFSection::INDEX_ABSOLUTE),
               zone);
 
   symtab->Add(ELFSymbol(desc->name(),
@@ skipping 58 matching lines @@
     w->WriteString("v8value");
 
     if (desc_->IsInfoAvailable()) {
       Scope* scope = desc_->info()->scope();
       w->WriteULEB128(2);
       w->WriteString(desc_->name());
       w->Write<intptr_t>(desc_->CodeStart());
       w->Write<intptr_t>(desc_->CodeStart() + desc_->CodeSize());
       Writer::Slot<uint32_t> fb_block_size = w->CreateSlotHere<uint32_t>();
       uintptr_t fb_block_start = w->position();
-#if defined(V8_TARGET_ARCH_IA32)
+#if V8_TARGET_ARCH_IA32
       w->Write<uint8_t>(DW_OP_reg5);  // The frame pointer's here on ia32
-#elif defined(V8_TARGET_ARCH_X64)
+#elif V8_TARGET_ARCH_X64
       w->Write<uint8_t>(DW_OP_reg6);  // and here on x64.
-#elif defined(V8_TARGET_ARCH_ARM)
+#elif V8_TARGET_ARCH_ARM
       UNIMPLEMENTED();
-#elif defined(V8_TARGET_ARCH_MIPS)
+#elif V8_TARGET_ARCH_MIPS
       UNIMPLEMENTED();
 #else
 #error Unsupported target architecture.
 #endif
       fb_block_size.set(static_cast<uint32_t>(w->position() - fb_block_start));
 
       int params = scope->num_parameters();
       int slots = scope->num_stack_slots();
       int context_slots = scope->ContextLocalCount();
       // The real slot ID is internal_slots + context_slot_id.
@@ skipping 430 matching lines @@
       return +1;
     } else {
       return -1;
     }
   }
 
   CodeDescription* desc_;
 };
 
 
-#ifdef V8_TARGET_ARCH_X64
+#if V8_TARGET_ARCH_X64
 
 class UnwindInfoSection : public DebugSection {
  public:
   explicit UnwindInfoSection(CodeDescription* desc);
   virtual bool WriteBodyInternal(Writer* w);
 
   int WriteCIE(Writer* w);
   void WriteFDE(Writer* w, int);
 
   void WriteFDEStateOnEntry(Writer* w);
@@ skipping 209 matching lines @@
   return true;
 }
 
 
 #endif  // V8_TARGET_ARCH_X64
 
 static void CreateDWARFSections(CodeDescription* desc,
                                 Zone* zone,
                                 DebugObject* obj) {
   if (desc->IsLineInfoAvailable()) {
-    obj->AddSection(new(zone) DebugInfoSection(desc), zone);
-    obj->AddSection(new(zone) DebugAbbrevSection(desc), zone);
-    obj->AddSection(new(zone) DebugLineSection(desc), zone);
+    obj->AddSection(new(zone) DebugInfoSection(desc));
+    obj->AddSection(new(zone) DebugAbbrevSection(desc));
+    obj->AddSection(new(zone) DebugLineSection(desc));
   }
-#ifdef V8_TARGET_ARCH_X64
-  obj->AddSection(new(zone) UnwindInfoSection(desc), zone);
+#if V8_TARGET_ARCH_X64
+  obj->AddSection(new(zone) UnwindInfoSection(desc));
 #endif
 }
 
 
 // -------------------------------------------------------------------
 // Binary GDB JIT Interface as described in
 //   http://sourceware.org/gdb/onlinedocs/gdb/Declarations.html
 extern "C" {
   typedef enum {
     JIT_NOACTION = 0,
@@ skipping 99 matching lines @@
   }
 
   __jit_debug_descriptor.relevant_entry_ = entry;
   __jit_debug_descriptor.action_flag_ = JIT_UNREGISTER_FN;
   __jit_debug_register_code();
 }
 
 
 static JITCodeEntry* CreateELFObject(CodeDescription* desc, Isolate* isolate) {
 #ifdef __MACH_O
-  MachO mach_o;
+  Zone zone(isolate);
+  MachO mach_o(&zone);
   Writer w(&mach_o);
 
-  mach_o.AddSection(new MachOTextSection(kCodeAlignment,
-                                         desc->CodeStart(),
-                                         desc->CodeSize()));
+  mach_o.AddSection(new(&zone) MachOTextSection(kCodeAlignment,
+                                                desc->CodeStart(),
+                                                desc->CodeSize()));
 
-  CreateDWARFSections(desc, &mach_o);
+  CreateDWARFSections(desc, &zone, &mach_o);
 
   mach_o.Write(&w, desc->CodeStart(), desc->CodeSize());
 #else
   Zone zone(isolate);
   ELF elf(&zone);
   Writer w(&elf);
 
   int text_section_index = elf.AddSection(
       new(&zone) FullHeaderELFSection(
           ".text",
           ELFSection::TYPE_NOBITS,
           kCodeAlignment,
           desc->CodeStart(),
           0,
           desc->CodeSize(),
-          ELFSection::FLAG_ALLOC | ELFSection::FLAG_EXEC),
-      &zone);
+          ELFSection::FLAG_ALLOC | ELFSection::FLAG_EXEC));
 
   CreateSymbolsTable(desc, &zone, &elf, text_section_index);
 
   CreateDWARFSections(desc, &zone, &elf);
 
   elf.Write(&w);
 #endif
 
   return CreateCodeEntry(w.buffer(), w.position());
 }
@@ skipping 51 matching lines @@
 
   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 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 =
         desc->CodeStart() + kFramePointerPushOffset;
@@ skipping 129 matching lines @@
   } else {
     JITCodeEntry* entry = static_cast<JITCodeEntry*>(e->value);
     UnregisterCodeEntry(entry);
     DestroyCodeEntry(entry);
   }
   e->value = NULL;
   GetEntries()->Remove(code, HashForCodeObject(code));
 }
 
 
+void GDBJITInterface::RemoveCodeRange(Address start, Address end) {
+  HashMap* entries = GetEntries();
+  Zone zone(Isolate::Current());
+  ZoneList<Code*> dead_codes(1, &zone);
+
+  for (HashMap::Entry* e = entries->Start(); e != NULL; e = entries->Next(e)) {
+    Code* code = reinterpret_cast<Code*>(e->key);
+    if (code->address() >= start && code->address() < end) {
+      dead_codes.Add(code, &zone);
+    }
+  }
+
+  for (int i = 0; i < dead_codes.length(); i++) {
+    RemoveCode(dead_codes.at(i));
+  }
+}
+
+
 void GDBJITInterface::RegisterDetailedLineInfo(Code* code,
                                                GDBJITLineInfo* line_info) {
   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