Fix in loading mach files from memory when using DynamicLoaderMacOSXDYLD.
Removed the uuid mismatch warning that could be spit out and any time during debugging and removed the test case that was looking for that. Currently the "add-dsym" or "target symbols add" command will report an error when the UUID's don't match.
Be more careful when checking and resolving section + offset addresses to make sure none of the base addresses are invalid.
llvm-svn: 174222
lldb::ModuleSP
ReadModuleFromMemory (const FileSpec& file_spec,
- lldb::addr_t header_addr,
- bool add_image_to_target,
- bool load_sections_in_target);
+ lldb::addr_t header_addr);
//------------------------------------------------------------------
/// Attempt to get the attributes for a region of memory in the process.
ProcessSP process_sp (process.GetSP());
if (process_sp)
{
- const bool add_image_to_target = true;
- const bool load_image_sections_in_target = true;
- m_opaque_sp = process_sp->ReadModuleFromMemory (FileSpec(),
- header_addr,
- add_image_to_target,
- load_image_sections_in_target);
+ m_opaque_sp = process_sp->ReadModuleFromMemory (FileSpec(), header_addr);
+ if (m_opaque_sp)
+ {
+ Target &target = process_sp->GetTarget();
+ bool changed = false;
+ m_opaque_sp->SetLoadAddress(target, 0, changed);
+ target.GetImages().Append(m_opaque_sp);
+ }
}
}
lldb_private::UUID file_uuid (data.GetData(&data_offset, 16), 16);
if (file_uuid == *uuid)
return true;
-
- // Emit some warning messages since the UUIDs do not match!
- char path_buf[PATH_MAX];
- path_buf[0] = '\0';
- const char *path = file_spec.GetPath(path_buf, PATH_MAX) ? path_buf
- : file_spec.GetFilename().AsCString();
- StreamString ss_m_uuid, ss_o_uuid;
- uuid->Dump(&ss_m_uuid);
- file_uuid.Dump(&ss_o_uuid);
- Host::SystemLog (Host::eSystemLogWarning,
- "warning: UUID mismatch detected between binary (%s) and:\n\t'%s' (%s)\n",
- ss_m_uuid.GetData(), path, ss_o_uuid.GetData());
return false;
}
data_offset = cmd_offset + cmd_size;
&& (header.flags & llvm::MachO::HeaderFlagBitIsDynamicLinkObject) == 0)
{
// Create a full module to get the UUID
- ModuleSP memory_module_sp = process->ReadModuleFromMemory (FileSpec ("temp_mach_kernel", false), addr, false, false);
+ ModuleSP memory_module_sp = process->ReadModuleFromMemory (FileSpec ("temp_mach_kernel", false), addr);
if (!memory_module_sp.get())
return UUID();
else
file_spec.SetFile (name, false);
- memory_module_sp = process->ReadModuleFromMemory (file_spec, address, false, false);
+ memory_module_sp = process->ReadModuleFromMemory (file_spec, address);
if (memory_module_sp && !uuid_is_valid)
{
uuid = memory_module_sp->GetUUID();
// mach header for dyld, or it might point to the
// dyld_all_image_infos struct
const addr_t shlib_addr = m_process->GetImageInfoAddress ();
- ByteOrder byte_order = m_process->GetTarget().GetArchitecture().GetByteOrder();
- uint8_t buf[4];
- DataExtractor data (buf, sizeof(buf), byte_order, 4);
- Error error;
- if (m_process->ReadMemory (shlib_addr, buf, 4, error) == 4)
+ if (shlib_addr != LLDB_INVALID_ADDRESS)
{
- lldb::offset_t offset = 0;
- uint32_t magic = data.GetU32 (&offset);
- switch (magic)
+ ByteOrder byte_order = m_process->GetTarget().GetArchitecture().GetByteOrder();
+ uint8_t buf[4];
+ DataExtractor data (buf, sizeof(buf), byte_order, 4);
+ Error error;
+ if (m_process->ReadMemory (shlib_addr, buf, 4, error) == 4)
{
- case llvm::MachO::HeaderMagic32:
- case llvm::MachO::HeaderMagic64:
- case llvm::MachO::HeaderMagic32Swapped:
- case llvm::MachO::HeaderMagic64Swapped:
- m_process_image_addr_is_all_images_infos = false;
- return ReadDYLDInfoFromMemoryAndSetNotificationCallback(shlib_addr);
-
- default:
- break;
+ lldb::offset_t offset = 0;
+ uint32_t magic = data.GetU32 (&offset);
+ switch (magic)
+ {
+ case llvm::MachO::HeaderMagic32:
+ case llvm::MachO::HeaderMagic64:
+ case llvm::MachO::HeaderMagic32Swapped:
+ case llvm::MachO::HeaderMagic64Swapped:
+ m_process_image_addr_is_all_images_infos = false;
+ return ReadDYLDInfoFromMemoryAndSetNotificationCallback(shlib_addr);
+
+ default:
+ break;
+ }
}
+ // Maybe it points to the all image infos?
+ m_dyld_all_image_infos_addr = shlib_addr;
+ m_process_image_addr_is_all_images_infos = true;
}
- // Maybe it points to the all image infos?
- m_dyld_all_image_infos_addr = shlib_addr;
- m_process_image_addr_is_all_images_infos = true;
}
if (m_dyld_all_image_infos_addr != LLDB_INVALID_ADDRESS)
}
ModuleSP
-DynamicLoaderMacOSXDYLD::FindTargetModuleForDYLDImageInfo (const DYLDImageInfo &image_info, bool can_create, bool *did_create_ptr)
+DynamicLoaderMacOSXDYLD::FindTargetModuleForDYLDImageInfo (DYLDImageInfo &image_info, bool can_create, bool *did_create_ptr)
{
if (did_create_ptr)
*did_create_ptr = false;
-
- const ModuleList &target_images = m_process->GetTarget().GetImages();
+ Target &target = m_process->GetTarget();
+ const ModuleList &target_images = target.GetImages();
ModuleSpec module_spec (image_info.file_spec, image_info.GetArchitecture ());
module_spec.GetUUID() = image_info.uuid;
ModuleSP module_sp (target_images.FindFirstModule (module_spec));
{
if (can_create)
{
- module_sp = m_process->GetTarget().GetSharedModule (module_spec);
+ module_sp = target.GetSharedModule (module_spec);
if (!module_sp || module_sp->GetObjectFile() == NULL)
- {
- const bool add_image_to_target = true;
- const bool load_image_sections_in_target = false;
- module_sp = m_process->ReadModuleFromMemory (image_info.file_spec,
- image_info.address,
- add_image_to_target,
- load_image_sections_in_target);
- }
+ module_sp = m_process->ReadModuleFromMemory (image_info.file_spec, image_info.address);
if (did_create_ptr)
*did_create_ptr = (bool) module_sp;
}
}
+ Target &target = m_process->GetTarget();
+
if (m_dyld_all_image_infos_addr == LLDB_INVALID_ADDRESS && dyld_module_sp.get())
{
static ConstString g_dyld_all_image_infos ("dyld_all_image_infos");
const Symbol *symbol = dyld_module_sp->FindFirstSymbolWithNameAndType (g_dyld_all_image_infos, eSymbolTypeData);
if (symbol)
- m_dyld_all_image_infos_addr = symbol->GetAddress().GetLoadAddress(&m_process->GetTarget());
+ m_dyld_all_image_infos_addr = symbol->GetAddress().GetLoadAddress(&target);
}
// Update all image infos
/// unique!
if (dyld_module_sp)
{
- if (m_process->GetTarget().GetImages().AppendIfNeeded (dyld_module_sp))
- UpdateImageLoadAddress(dyld_module_sp.get(), m_dyld);
+ target.GetImages().AppendIfNeeded (dyld_module_sp);
// At this point we should have read in dyld's module, and so we should set breakpoints in it:
ModuleList modules;
modules.Append(dyld_module_sp);
- m_process->GetTarget().ModulesDidLoad(modules);
+ target.ModulesDidLoad(modules);
}
return true;
}
return m_dyld_all_image_infos_addr == LLDB_INVALID_ADDRESS;
}
-bool
-DynamicLoaderMacOSXDYLD::UpdateCommPageLoadAddress(Module *module)
-{
- bool changed = false;
- if (module)
- {
- ObjectFile *image_object_file = module->GetObjectFile();
- if (image_object_file)
- {
- SectionList *section_list = image_object_file->GetSectionList ();
- if (section_list)
- {
- const size_t num_sections = section_list->GetSize();
- for (size_t i=0; i<num_sections; ++i)
- {
- SectionSP section_sp (section_list->GetSectionAtIndex (i));
- if (section_sp)
- {
- const addr_t new_section_load_addr = section_sp->GetFileAddress ();
- const addr_t old_section_load_addr = m_process->GetTarget().GetSectionLoadList().GetSectionLoadAddress (section_sp);
- if (old_section_load_addr == LLDB_INVALID_ADDRESS ||
- old_section_load_addr != new_section_load_addr)
- {
- if (m_process->GetTarget().GetSectionLoadList().SetSectionLoadAddress (section_sp, section_sp->GetFileAddress ()))
- changed = true;
- }
- }
- }
- }
- }
- }
- return changed;
-}
-
//----------------------------------------------------------------------
// Update the load addresses for all segments in MODULE using the
// updated INFO that is passed in.
}
}
}
+ // We might have an in memory image that was loaded as soon as it was created
+ if (info.load_stop_id == m_process->GetStopID())
+ changed = true;
+ else if (changed)
+ {
+ // Update the stop ID when this library was updated
+ info.load_stop_id = m_process->GetStopID();
+ }
return changed;
}
// Now add these images to the main list.
ModuleList loaded_module_list;
LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER));
+ Target &target = m_process->GetTarget();
+ ModuleList& target_images = target.GetImages();
for (uint32_t idx = 0; idx < image_infos.size(); ++idx)
{
Section *commpage_section = sections->FindSectionByName(commpage_dbstr).get();
if (commpage_section)
{
- const ModuleList& target_images = m_process->GetTarget().GetImages();
ModuleSpec module_spec (objfile->GetFileSpec(), image_infos[idx].GetArchitecture ());
module_spec.GetObjectName() = commpage_dbstr;
ModuleSP commpage_image_module_sp(target_images.FindFirstModule (module_spec));
if (!commpage_image_module_sp)
{
module_spec.SetObjectOffset (objfile->GetOffset() + commpage_section->GetFileOffset());
- commpage_image_module_sp = m_process->GetTarget().GetSharedModule (module_spec);
+ commpage_image_module_sp = target.GetSharedModule (module_spec);
if (!commpage_image_module_sp || commpage_image_module_sp->GetObjectFile() == NULL)
{
- const bool add_image_to_target = true;
- const bool load_image_sections_in_target = false;
commpage_image_module_sp = m_process->ReadModuleFromMemory (image_infos[idx].file_spec,
- image_infos[idx].address,
- add_image_to_target,
- load_image_sections_in_target);
+ image_infos[idx].address);
+ // Always load a memory image right away in the target in case
+ // we end up trying to read the symbol table from memory... The
+ // __LINKEDIT will need to be mapped so we can figure out where
+ // the symbol table bits are...
+ bool changed = false;
+ UpdateImageLoadAddress (commpage_image_module_sp.get(), image_infos[idx]);
+ target.GetImages().Append(commpage_image_module_sp);
+ if (changed)
+ {
+ image_infos[idx].load_stop_id = m_process->GetStopID();
+ loaded_module_list.AppendIfNeeded (commpage_image_module_sp);
+ }
}
}
- if (commpage_image_module_sp)
- UpdateCommPageLoadAddress (commpage_image_module_sp.get());
}
}
}
// shared libraries each time.
if (UpdateImageLoadAddress (image_module_sp.get(), image_infos[idx]))
{
+ target_images.AppendIfNeeded(image_module_sp);
loaded_module_list.AppendIfNeeded (image_module_sp);
}
}
}
}
+ Target &target = m_process->GetTarget();
+
if (exe_idx < image_infos.size())
{
const bool can_create = true;
ModuleSP exe_module_sp (FindTargetModuleForDYLDImageInfo (image_infos[exe_idx], can_create, NULL));
- if (!exe_module_sp)
- {
- ArchSpec exe_arch_spec (image_infos[exe_idx].GetArchitecture ());
- ModuleSpec module_spec (image_infos[exe_idx].file_spec,
- image_infos[exe_idx].GetArchitecture ());
- module_spec.GetUUID() = image_infos[exe_idx].uuid;
- exe_module_sp = m_process->GetTarget().GetSharedModule (module_spec);
- if (!exe_module_sp || exe_module_sp->GetObjectFile() == NULL)
- {
- const bool add_image_to_target = true;
- const bool load_image_sections_in_target = false;
- exe_module_sp = m_process->ReadModuleFromMemory (image_infos[exe_idx].file_spec,
- image_infos[exe_idx].address,
- add_image_to_target,
- load_image_sections_in_target);
- }
- }
-
if (exe_module_sp)
{
- if (exe_module_sp.get() != m_process->GetTarget().GetExecutableModulePointer())
+ UpdateImageLoadAddress (exe_module_sp.get(), image_infos[exe_idx]);
+
+ if (exe_module_sp.get() != target.GetExecutableModulePointer())
{
// Don't load dependent images since we are in dyld where we will know
// and find out about all images that are loaded
lldb_private::UUID uuid; // UUID for this dylib if it has one, else all zeros
llvm::MachO::mach_header header; // The mach header for this image
std::vector<Segment> segments; // All segment vmaddr and vmsize pairs for this executable (from memory of inferior)
+ uint32_t load_stop_id; // The process stop ID that the sections for this image were loadeded
DYLDImageInfo() :
address(LLDB_INVALID_ADDRESS),
file_spec(),
uuid(),
header(),
- segments()
+ segments(),
+ load_stop_id(0)
{
}
}
uuid.Clear();
segments.clear();
+ load_stop_id = 0;
}
bool
DYLDImageInfo& info);
lldb::ModuleSP
- FindTargetModuleForDYLDImageInfo (const DYLDImageInfo &image_info,
+ FindTargetModuleForDYLDImageInfo (DYLDImageInfo &image_info,
bool can_create,
bool *did_create_ptr);
bool update_executable);
bool
- UpdateCommPageLoadAddress (lldb_private::Module *module);
-
- bool
ReadImageInfos (lldb::addr_t image_infos_addr,
uint32_t image_infos_count,
DYLDImageInfo::collection &image_infos);
if (process_sp)
{
Error error;
- return process_sp->ReadMemory (section->GetLoadBaseAddress (&process_sp->GetTarget()) + section_offset, dst, dst_len, error);
+ const addr_t base_load_addr = section->GetLoadBaseAddress (&process_sp->GetTarget());
+ if (base_load_addr != LLDB_INVALID_ADDRESS)
+ return process_sp->ReadMemory (base_load_addr + section_offset, dst, dst_len, error);
}
}
else
ProcessSP process_sp (m_process_wp.lock());
if (process_sp)
{
- DataBufferSP data_sp (ReadMemory (process_sp, section->GetLoadBaseAddress (&process_sp->GetTarget()), section->GetByteSize()));
- if (data_sp)
+ const addr_t base_load_addr = section->GetLoadBaseAddress (&process_sp->GetTarget());
+ if (base_load_addr != LLDB_INVALID_ADDRESS)
{
- section_data.SetData (data_sp, 0, data_sp->GetByteSize());
- section_data.SetByteOrder (process_sp->GetByteOrder());
- section_data.SetAddressByteSize (process_sp->GetAddressByteSize());
- return section_data.GetByteSize();
+ DataBufferSP data_sp (ReadMemory (process_sp, base_load_addr, section->GetByteSize()));
+ if (data_sp)
+ {
+ section_data.SetData (data_sp, 0, data_sp->GetByteSize());
+ section_data.SetByteOrder (process_sp->GetByteOrder());
+ section_data.SetAddressByteSize (process_sp->GetAddressByteSize());
+ return section_data.GetByteSize();
+ }
}
}
}
ModuleSP
Process::ReadModuleFromMemory (const FileSpec& file_spec,
- lldb::addr_t header_addr,
- bool add_image_to_target,
- bool load_sections_in_target)
+ lldb::addr_t header_addr)
{
ModuleSP module_sp (new Module (file_spec, ArchSpec()));
if (module_sp)
Error error;
ObjectFile *objfile = module_sp->GetMemoryObjectFile (shared_from_this(), header_addr, error);
if (objfile)
- {
- if (add_image_to_target)
- {
- m_target.GetImages().Append(module_sp);
- if (load_sections_in_target)
- {
- bool changed = false;
- module_sp->SetLoadAddress (m_target, 0, changed);
- }
- }
return module_sp;
- }
}
return ModuleSP();
}
{
if (load_addr != pos->first && pos != m_addr_to_sect.begin())
--pos;
- if (load_addr >= pos->first)
+ const addr_t pos_load_addr = pos->first;
+ if (load_addr >= pos_load_addr)
{
- addr_t offset = load_addr - pos->first;
+ addr_t offset = load_addr - pos_load_addr;
if (offset < pos->second->GetByteSize())
{
// We have found the top level section, now we need to find the
+++ /dev/null
-"""Test that the 'warning: UUID mismatch detected ...' message is emitted if a
-dsym in vicinity of the executable does not match its UUID."""
-
-import os, time
-import unittest2
-import lldb
-import pexpect
-from lldbtest import *
-
-@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
-class UUIDMismatchWarningCase(TestBase):
-
- mydir = os.path.join("warnings", "uuid")
-
- @classmethod
- def classCleanup(cls):
- """Cleanup the test byproducts."""
- cls.RemoveTempFile("child_send.txt")
- cls.RemoveTempFile("child_read.txt")
-
- def setUp(self):
- TestBase.setUp(self)
- self.template = 'main.cpp.template'
- self.source = 'main.cpp'
- self.teardown_hook_added = False
-
- def test_uuid_mismatch_warning(self):
- """Test that the 'warning: UUID mismatch detected ...' message is emitted."""
-
- # Call the program generator to produce main.cpp, version 1.
- self.generate_main_cpp(version=1)
- self.line_to_break = line_number(self.source, '// Set breakpoint here.')
- self.buildDsym(clean=True)
-
- # Insert some delay and then call the program generator to produce main.cpp, version 2.
- time.sleep(5)
- self.generate_main_cpp(version=101)
- # Now call make again, but this time don't generate the dSYM.
- self.buildDwarf(clean=False)
-
- self.exe_name = 'a.out'
- self.check_executable_and_dsym(self.exe_name)
-
- def generate_main_cpp(self, version=0):
- """Generate main.cpp from main.cpp.template."""
- temp = os.path.join(os.getcwd(), self.template)
- with open(temp, 'r') as f:
- content = f.read()
-
- new_content = content.replace('%ADD_EXTRA_CODE%',
- 'printf("This is version %d\\n");' % version)
- src = os.path.join(os.getcwd(), self.source)
- with open(src, 'w') as f:
- f.write(new_content)
-
- # The main.cpp has been generated, add a teardown hook to remove it.
- if not self.teardown_hook_added:
- self.addTearDownHook(lambda: os.remove(src))
- self.teardown_hook_added = True
-
- def check_executable_and_dsym(self, exe_name):
- """Sanity check executable compiled from the auto-generated program."""
-
- # The default lldb prompt.
- prompt = "(lldb) "
-
- # So that the child gets torn down after the test.
- self.child = pexpect.spawn('%s %s' % (self.lldbHere, self.lldbOption))
- child = self.child
- # Turn on logging for input/output to/from the child.
- with open('child_send.txt', 'w') as f_send:
- with open('child_read.txt', 'w') as f_read:
- child.logfile_send = f_send
- child.logfile_read = f_read
-
- child.expect_exact(prompt)
- child.setecho(True)
-
- # Execute the file command, followed by a breakpoint set, the
- # UUID mismatch warning should be generated by then.
-
- child.sendline("file %s" % exe_name)
- child.expect_exact(prompt)
- child.sendline("breakpoint set -f %s -l %d" % (self.source, self.line_to_break))
- child.expect_exact(prompt)
- child.sendline("run")
- child.expect_exact(prompt)
-
- # Now that the necessary logging is done, restore logfile to None to
- # stop further logging.
- child.logfile_send = None
- child.logfile_read = None
-
- with open('child_send.txt', 'r') as fs:
- if self.TraceOn():
- print "\n\nContents of child_send.txt:"
- print fs.read()
- with open('child_read.txt', 'r') as fr:
- from_child = fr.read()
- if self.TraceOn():
- print "\n\nContents of child_read.txt:"
- print from_child
-
- # Test that lldb emits the "UUID mismatch detected" message.
- self.expect(from_child, msg="UUID mismatch expected!", exe=False,
- substrs = ['warning: UUID mismatch detected'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
projects / platform / upstream / llvm.git / commitdiff