Allow MachO JIT debugging

[loladiro]

Summary

This is the LLDB side of http://reviews.llvm.org/D4005

[loladiro]

Slight adjustment to updateSectionLoadAddress to properly adjust the load address range of fake segments.

include/lldb/Core/Section.h

Section (const lldb::ModuleSP &module_sp,
              ObjectFile *obj_file,
              lldb::user_id_t sect_id,
              const ConstString &name,
              lldb::SectionType sect_type,
              lldb::addr_t file_vm_addr,
              lldb::addr_t vm_size,
              lldb::offset_t file_offset,
              lldb::offset_t file_size,
+             uint32_t log2align,
              uint32_t flags);
 
     // Create a section that is a child of parent_section_sp
     Section (const lldb::SectionSP &parent_section_sp,    // NULL for top level sections, non-NULL for child sections
              const lldb::ModuleSP &module_sp,
              ObjectFile *obj_file,
              lldb::user_id_t sect_id,
              const ConstString &name,
              lldb::SectionType sect_type,
              lldb::addr_t file_vm_addr,
              lldb::addr_t vm_size,
              lldb::offset_t file_offset,
              lldb::offset_t file_size,
+             uint32_t log2align,
              uint32_t flags);
 
     ~Section ();
 
     static int
     Compare (const Section& a, const Section& b);
 
     bool
GetObjectFile ()
         return m_obj_file;
     }
     const ObjectFile *
     GetObjectFile () const 
     {
         return m_obj_file;
     }
 
+    uint32_t GetLog2Align()
+    {
+        return m_log2align;
+    }
+
+    void
+    SetLog2Align(uint32_t align)
+    {
+        m_log2align = align;
+    }
+
 
 protected:
 
     ObjectFile      *m_obj_file;        // The object file that data for this section should be read from
     lldb::SectionType m_type;           // The type of this section
     lldb::SectionWP m_parent_wp;        // Weak pointer to parent section
     ConstString     m_name;             // Name of this section
     lldb::addr_t    m_file_addr;        // The absolute file virtual address range of this section if m_parent == NULL,
                                         // offset from parent file virtual address if m_parent != NULL
     lldb::addr_t    m_byte_size;        // Size in bytes that this section will occupy in memory at runtime
     lldb::offset_t  m_file_offset;      // Object file offset (if any)
     lldb::offset_t  m_file_size;        // Object file size (can be smaller than m_byte_size for zero filled sections...)
+    uint32_t        m_log2align;        // log_2(align) of the section (i.e. section has to be aligned to 2^m_log2align)
     SectionList     m_children;         // Child sections
     bool            m_fake:1,           // If true, then this section only can contain the address if one of its
                                         // children contains an address. This allows for gaps between the children
                                         // that are contained in the address range for this section, but do not produce
                                         // hits unless the children contain the address.
                     m_encrypted:1,      // Set to true if the contents are encrypted
                     m_thread_specific:1;// This section is thread specific
 private:
     DISALLOW_COPY_AND_ASSIGN (Section);
 };
 
 
 } // namespace lldb_private
 
 #endif  // liblldb_Section_h_

lib/Makefile

ifeq ($(HOST_OS),Darwin)
   USEDLIBS += lldbHostMacOSX.a \
               lldbPluginDynamicLoaderMacOSX.a \
               lldbPluginDynamicLoaderDarwinKernel.a \
               lldbPluginObjectContainerUniversalMachO.a \
               lldbPluginObjectFileMachO.a \
               lldbPluginSymbolVendorMacOSX.a \
               lldbPluginProcessDarwin.a \
               lldbPluginProcessMachCore.a \
-              lldbPluginSystemRuntimeMacOSX.a
+              lldbPluginSystemRuntimeMacOSX.a \
+              lldbPluginProcessElfCore.a \
+              lldbPluginJITLoaderGDB.a
 endif
 
 ifeq ($(HOST_OS),Linux)
   USEDLIBS += lldbHostLinux.a \
               lldbPluginProcessLinux.a \
               lldbPluginProcessPOSIX.a \
               lldbPluginDynamicLoaderMacOSX.a \
               lldbPluginProcessElfCore.a \

source/Core/Section.cpp

Section::Section (const ModuleSP &module_sp,
                   ObjectFile *obj_file,
                   user_id_t sect_id,
                   const ConstString &name,
                   SectionType sect_type,
                   addr_t file_addr,
                   addr_t byte_size,
                   lldb::offset_t file_offset,
                   lldb::offset_t file_size,
+                  uint32_t log2align,
                   uint32_t flags) :
     ModuleChild     (module_sp),
     UserID          (sect_id),
     Flags           (flags),
     m_obj_file      (obj_file),
     m_type          (sect_type),
     m_parent_wp     (),
     m_name          (name),
     m_file_addr     (file_addr),
     m_byte_size     (byte_size),
     m_file_offset   (file_offset),
     m_file_size     (file_size),
+    m_log2align     (log2align),
     m_children      (),
     m_fake          (false),
     m_encrypted     (false),
     m_thread_specific (false)
 {
 //    printf ("Section::Section(%p): module=%p, sect_id = 0x%16.16" PRIx64 ", addr=[0x%16.16" PRIx64 " - 0x%16.16" PRIx64 "), file [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 "), flags = 0x%8.8x, name = %s\n",
 //            this, module_sp.get(), sect_id, file_addr, file_addr + byte_size, file_offset, file_offset + file_size, flags, name.GetCString());
 }
 
 Section::Section (const lldb::SectionSP &parent_section_sp,
                   const ModuleSP &module_sp,
                   ObjectFile *obj_file,
                   user_id_t sect_id,
                   const ConstString &name,
                   SectionType sect_type,
                   addr_t file_addr,
                   addr_t byte_size,
                   lldb::offset_t file_offset,
                   lldb::offset_t file_size,
+                  uint32_t log2align,
                   uint32_t flags) :
     ModuleChild     (module_sp),
     UserID          (sect_id),
     Flags           (flags),
     m_obj_file      (obj_file),
     m_type          (sect_type),
     m_parent_wp     (),
     m_name          (name),
     m_file_addr     (file_addr),
     m_byte_size     (byte_size),
     m_file_offset   (file_offset),
     m_file_size     (file_size),
+    m_log2align     (log2align),
     m_children      (),
     m_fake          (false),
     m_encrypted     (false),
     m_thread_specific (false)
 {
 //    printf ("Section::Section(%p): module=%p, sect_id = 0x%16.16" PRIx64 ", addr=[0x%16.16" PRIx64 " - 0x%16.16" PRIx64 "), file [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 "), flags = 0x%8.8x, name = %s.%s\n",
 //            this, module_sp.get(), sect_id, file_addr, file_addr + byte_size, file_offset, file_offset + file_size, flags, parent_section_sp->GetName().GetCString(), name.GetCString());
     if (parent_section_sp)
Section::GetLoadBaseAddress (Target *target) const
     addr_t load_base_addr = LLDB_INVALID_ADDRESS;
     SectionSP parent_sp (GetParent ());
     if (parent_sp)
     {
         load_base_addr = parent_sp->GetLoadBaseAddress (target);
         if (load_base_addr != LLDB_INVALID_ADDRESS)
             load_base_addr += GetOffset();
     }
-    else
+    if (load_base_addr == LLDB_INVALID_ADDRESS)
     {
         load_base_addr = target->GetSectionLoadList().GetSectionLoadAddress (const_cast<Section *>(this)->shared_from_this());
     }
     return load_base_addr;
 }
 
 bool
 Section::ResolveContainedAddress (addr_t offset, Address &so_addr) const

source/Expression/IRExecutionUnit.cpp

for (AllocationRecord &record : m_records)
                                                                    obj_file,
                                                                    record.m_section_id,
                                                                    ConstString(record.m_name),
                                                                    record.m_sect_type,
                                                                    record.m_process_address,
                                                                    record.m_size,
                                                                    record.m_host_address,   // file_offset (which is the host address for the data)
                                                                    record.m_size,           // file_size
+                                                                   0,
                                                                    record.m_permissions));  // flags
             section_list.AddSection (section_sp);
         }
     }
 }
 
 bool
 IRExecutionUnit::GetArchitecture (lldb_private::ArchSpec &arch)

source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

JITLoaderGDB::JITDebugBreakpointHit(void *baton,
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER));
     if (log)
         log->Printf("JITLoaderGDB::%s hit JIT breakpoint",
                     __FUNCTION__);
     JITLoaderGDB *instance = static_cast<JITLoaderGDB *>(baton);
     return instance->ReadJITDescriptor(false);
 }
 
+static void updateSectionLoadAddress(const SectionList &section_list, Target &target, uint64_t symbolfile_addr, uint64_t symbolfile_size, 
+        uint64_t &vmaddrheuristic, uint64_t &min_addr, uint64_t &max_addr)
+{
+    const uint32_t num_sections = section_list.GetSize();
+    for (uint32_t i = 0; i<num_sections; ++i)
+    {
+        SectionSP section_sp(section_list.GetSectionAtIndex(i));
+        if (section_sp)
+        {
+            if(section_sp->IsFake()) {
+                uint64_t lower = (uint64_t)-1;
+                uint64_t upper = 0;
+                updateSectionLoadAddress(section_sp->GetChildren(), target, symbolfile_addr, symbolfile_size, vmaddrheuristic,
+                    lower, upper);
+                if (lower < min_addr)
+                    min_addr = lower;
+                if (upper > max_addr)
+                    max_addr = upper;
+                const lldb::addr_t slide_amount = lower - section_sp->GetFileAddress();
+                section_sp->Slide(slide_amount, false);
+                section_sp->GetChildren().Slide(-slide_amount, false);
+                section_sp->SetByteSize (upper - lower);
+            } else {
+                vmaddrheuristic += 2<<section_sp->GetLog2Align();
+                uint64_t lower;
+                if (section_sp->GetFileAddress() > vmaddrheuristic)
+                    lower = section_sp->GetFileAddress();
+                else {
+                    lower = symbolfile_addr+section_sp->GetFileOffset();
+                    section_sp->SetFileAddress(symbolfile_addr+section_sp->GetFileOffset());
+                }
+                target.SetSectionLoadAddress(section_sp, lower, true);
+                uint64_t upper = lower + section_sp->GetByteSize();
+                if (lower < min_addr)
+                    min_addr = lower;
+                if (upper > max_addr)
+                    max_addr = upper;
+                // This is an upper bound, but a good enough heuristic
+                vmaddrheuristic += section_sp->GetByteSize();
+            }
+        }
+    }
+}
+
 bool
 JITLoaderGDB::ReadJITDescriptor(bool all_entries)
 {
     if (m_jit_descriptor_addr == LLDB_INVALID_ADDRESS)
         return false;
 
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER));
     Target &target = m_process->GetTarget();
while (jit_relevant_entry != 0)
                 FileSpec(jit_name, false), symbolfile_addr, symbolfile_size);
 
             if (module_sp && module_sp->GetObjectFile())
             {
                 bool changed;
                 m_jit_objects.insert(
                     std::pair<lldb::addr_t, const lldb::ModuleSP>(
                         symbolfile_addr, module_sp));
+                if (module_sp->GetObjectFile()->GetPluginName() == ConstString("mach-o"))
+                {
+                    ObjectFile *image_object_file = module_sp->GetObjectFile();
+                    if (image_object_file)
+                    {
+                        const SectionList *section_list = image_object_file->GetSectionList ();
+                        if (section_list)
+                        {
+                            uint64_t vmaddrheuristic = 0;
+                            uint64_t lower = (uint64_t)-1;
+                            uint64_t upper = 0;
+                            updateSectionLoadAddress(*section_list, target, symbolfile_addr, symbolfile_size,
+                                vmaddrheuristic, lower, upper);
+                        }
+                    }
+                }
+                else
+                {
                     module_sp->SetLoadAddress(target, 0, true, changed);
+                }
 
                 // load the symbol table right away
                 module_sp->GetObjectFile()->GetSymtab();
 
                 module_list.AppendIfNeeded(module_sp);
 
                 ModuleList module_list;
                 module_list.Append(module_sp);
JITLoaderGDB::GetPluginNameStatic()
     static ConstString g_name("gdb");
     return g_name;
 }
 
 JITLoaderSP
 JITLoaderGDB::CreateInstance(Process *process, bool force)
 {
     JITLoaderSP jit_loader_sp;
-    ArchSpec arch (process->GetTarget().GetArchitecture());
-    if (arch.GetTriple().getVendor() != llvm::Triple::Apple)
-        jit_loader_sp.reset(new JITLoaderGDB(process));
     return jit_loader_sp;
 }
 
 const char *
 JITLoaderGDB::GetPluginDescriptionStatic()
 {
     return "JIT loader plug-in that watches for JIT events using the GDB interface.";
 }

source/Plugins/Makefile

 ifeq ($(HOST_OS),Darwin)
 DIRS += Process/MacOSX-Kernel
 DIRS += DynamicLoader/MacOSX-DYLD DynamicLoader/Darwin-Kernel
 DIRS += ObjectContainer/Universal-Mach-O ObjectFile/Mach-O
 DIRS += SymbolVendor/MacOSX
 #DIRS += Process/MacOSX-User
 DIRS += Process/mach-core
 DIRS += SystemRuntime/MacOSX
+DIRS += Process/elf-core
+DIRS += JITLoader/GDB
 endif
 
 ifeq ($(HOST_OS),Linux)
 DIRS += DynamicLoader/MacOSX-DYLD
 DIRS += Process/Linux Process/POSIX
 DIRS += Process/elf-core
 DIRS += JITLoader/GDB
 endif

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (!m_sections_ap.get() && ParseSectionHeaders())
                                               this,               // ObjectFile to which this section belongs and should read section data from.
                                               SectionIndex(I),    // Section ID.
                                               name,               // Section name.
                                               sect_type,          // Section type.
                                               header.sh_addr,     // VM address.
                                               vm_size,            // VM size in bytes of this section.
                                               header.sh_offset,   // Offset of this section in the file.
                                               file_size,          // Size of the section as found in the file.
+                                              __builtin_ffs(header.sh_addralign), // Alignment of the section
                                               header.sh_flags));  // Flags for this section.
 
             if (is_thread_specific)
                 section_sp->SetIsThreadSpecific (is_thread_specific);
             m_sections_ap->AddSection(section_sp);
         }
     }
 

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

if (!m_sections_ap.get())
                                                           this,                   // Object file to which this sections belongs
                                                           ++segID << 8,           // Section ID is the 1 based segment index shifted right by 8 bits as not to collide with any of the 256 section IDs that are possible
                                                           const_segname,          // Name of this section
                                                           eSectionTypeContainer,  // This section is a container of other sections.
                                                           load_cmd.vmaddr,        // File VM address == addresses as they are found in the object file
                                                           load_cmd.vmsize,        // VM size in bytes of this section
                                                           load_cmd.fileoff,       // Offset to the data for this section in the file
                                                           load_cmd.filesize,      // Size in bytes of this section as found in the the file
+                                                          0,                      // Segments have no alignment information
                                                           load_cmd.flags));       // Flags for this section
 
                             segment_sp->SetIsEncrypted (segment_is_encrypted);
                             m_sections_ap->AddSection(segment_sp);
                             if (add_to_unified)
                                 unified_section_list.AddSection(segment_sp);
                         }
                         else if (unified_section_sp)
if (!m_sections_ap.get())
                                                                       this,                  // Object file to which this section belongs
                                                                       ++segID << 8,          // Section ID is the 1 based segment index shifted right by 8 bits as not to collide with any of the 256 section IDs that are possible
                                                                       const_segname,         // Name of this section
                                                                       eSectionTypeContainer, // This section is a container of other sections.
                                                                       sect64.addr,           // File VM address == addresses as they are found in the object file
                                                                       sect64.size,           // VM size in bytes of this section
                                                                       sect64.offset,         // Offset to the data for this section in the file
                                                                       sect64.offset ? sect64.size : 0,        // Size in bytes of this section as found in the the file
+                                                                      sect64.align,
                                                                       load_cmd.flags));      // Flags for this section
                                         segment_sp->SetIsFake(true);
                                         
                                         m_sections_ap->AddSection(segment_sp);
                                         if (add_to_unified)
                                             unified_section_list.AddSection(segment_sp);
                                         segment_sp->SetIsEncrypted (segment_is_encrypted);
                                     }
if (!m_sections_ap.get())
                                                                   this,
                                                                   ++sectID,
                                                                   section_name,
                                                                   sect_type,
                                                                   sect64.addr - segment_sp->GetFileAddress(),
                                                                   sect64.size,
                                                                   sect64.offset,
                                                                   sect64.offset == 0 ? 0 : sect64.size,
+                                                                  sect64.align,
                                                                   sect64.flags));
                                 // Set the section to be encrypted to match the segment
 
                                 bool section_is_encrypted = false;
                                 if (!segment_is_encrypted && load_cmd.filesize != 0)
                                     section_is_encrypted = encrypted_file_ranges.FindEntryThatContains(sect64.offset) != NULL;
 
                                 section_sp->SetIsEncrypted (segment_is_encrypted || section_is_encrypted);
if (symtab_load_command.cmd)
         const addr_t strtab_data_byte_size = symtab_load_command.strsize;
         addr_t strtab_addr = LLDB_INVALID_ADDRESS;
 
         ProcessSP process_sp (m_process_wp.lock());
         Process *process = process_sp.get();
         
         uint32_t memory_module_load_level = eMemoryModuleLoadLevelComplete;
 
-        if (process)
+        if (process && m_header.filetype != llvm::MachO::MH_OBJECT)
         {
             Target &target = process->GetTarget();
             
             memory_module_load_level = target.GetMemoryModuleLoadLevel();
 
             SectionSP linkedit_section_sp(section_list->FindSectionByName(GetSegmentNameLINKEDIT()));
             // Reading mach file from memory in a process or core file...
 

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

if (!m_sections_ap.get())
                                                    this,                         // Object file to which this section belongs
                                                    idx + 1,                      // Section ID is the 1 based segment index shifted right by 8 bits as not to collide with any of the 256 section IDs that are possible
                                                    const_sect_name,              // Name of this section
                                                    section_type,                 // This section is a container of other sections.
                                                    m_coff_header_opt.image_base + m_sect_headers[idx].vmaddr,   // File VM address == addresses as they are found in the object file
                                                    m_sect_headers[idx].vmsize,   // VM size in bytes of this section
                                                    m_sect_headers[idx].offset,   // Offset to the data for this section in the file
                                                    m_sect_headers[idx].size,     // Size in bytes of this section as found in the the file
+                                                   m_coff_header_opt.sect_alignment, // Section alignment
                                                    m_sect_headers[idx].flags));  // Flags for this section
 
                 //section_sp->SetIsEncrypted (segment_is_encrypted);
 
                 unified_section_list.AddSection(section_sp);
                 m_sections_ap->AddSection (section_sp);
             }
         }