From d16e1e596a8db9ff6200bf2f58cc6cd0b78d0d0d Mon Sep 17 00:00:00 2001 From: Greg Clayton Date: Tue, 12 Jul 2011 17:06:17 +0000 Subject: [PATCH] Added the ability to _not_ skip the prologue when settings breakpoints by name by adding an extra parameter to the lldb_private::Target breakpoint setting functions. Added a function in the DWARF symbol file plug-in that can dump errors and prints out which DWARF file the error is happening in so we can track down what used to be assertions easily. Fixed the MacOSX kernel plug-in to properly read the kext images and set the kext breakpoint to watch for kexts as they are loaded. llvm-svn: 134990 --- .../lldb/Breakpoint/BreakpointResolverName.h | 10 +- lldb/include/lldb/Target/Target.h | 31 +++- .../Breakpoint/BreakpointResolverName.cpp | 28 ++-- .../DynamicLoaderMacOSXKernel.cpp | 60 +++++--- .../MacOSX-Kernel/DynamicLoaderMacOSXKernel.h | 1 + .../SymbolFile/DWARF/SymbolFileDWARF.cpp | 45 ++++-- .../SymbolFile/DWARF/SymbolFileDWARF.h | 3 + lldb/source/Symbol/SymbolContext.cpp | 2 +- lldb/source/Target/Target.cpp | 135 ++++++++++++++++-- 9 files changed, 252 insertions(+), 63 deletions(-) diff --git a/lldb/include/lldb/Breakpoint/BreakpointResolverName.h b/lldb/include/lldb/Breakpoint/BreakpointResolverName.h index 3593efead77d..cf69231824ac 100644 --- a/lldb/include/lldb/Breakpoint/BreakpointResolverName.h +++ b/lldb/include/lldb/Breakpoint/BreakpointResolverName.h @@ -32,16 +32,19 @@ public: BreakpointResolverName (Breakpoint *bkpt, const char *name, uint32_t name_type_mask, - Breakpoint::MatchType type); + Breakpoint::MatchType type, + bool skip_prologue); // Creates a function breakpoint by regular expression. Takes over control of the lifespan of func_regex. BreakpointResolverName (Breakpoint *bkpt, - RegularExpression &func_regex); + RegularExpression &func_regex, + bool skip_prologue); BreakpointResolverName (Breakpoint *bkpt, const char *class_name, const char *method, - Breakpoint::MatchType type); + Breakpoint::MatchType type, + bool skip_prologue); virtual ~BreakpointResolverName (); @@ -81,6 +84,7 @@ protected: ConstString m_class_name; // FIXME: Not used yet. The idea would be to stop on methods of this class. RegularExpression m_regex; Breakpoint::MatchType m_match_type; + bool m_skip_prologue; private: DISALLOW_COPY_AND_ASSIGN(BreakpointResolverName); diff --git a/lldb/include/lldb/Target/Target.h b/lldb/include/lldb/Target/Target.h index effb68a3ef84..51b27f643d2a 100644 --- a/lldb/include/lldb/Target/Target.h +++ b/lldb/include/lldb/Target/Target.h @@ -238,17 +238,23 @@ public: bool internal = false); // Use this to create a function breakpoint by regexp in containingModule, or all modules if it is NULL + // When "skip_prologue is set to eLazyBoolCalculate, we use the current target + // setting, else we use the values passed in lldb::BreakpointSP CreateBreakpoint (const FileSpec *containingModule, RegularExpression &func_regexp, - bool internal = false); + bool internal = false, + LazyBool skip_prologue = eLazyBoolCalculate); // Use this to create a function breakpoint by name in containingModule, or all modules if it is NULL + // When "skip_prologue is set to eLazyBoolCalculate, we use the current target + // setting, else we use the values passed in lldb::BreakpointSP CreateBreakpoint (const FileSpec *containingModule, const char *func_name, uint32_t func_name_type_mask, - bool internal = false); + bool internal = false, + LazyBool skip_prologue = eLazyBoolCalculate); // Use this to create a general breakpoint: lldb::BreakpointSP @@ -461,6 +467,27 @@ public: size_t dst_len, Error &error); + size_t + ReadScalarIntegerFromMemory (const Address& addr, + bool prefer_file_cache, + uint32_t byte_size, + bool is_signed, + Scalar &scalar, + Error &error); + + uint64_t + ReadUnsignedIntegerFromMemory (const Address& addr, + bool prefer_file_cache, + size_t integer_byte_size, + uint64_t fail_value, + Error &error); + + bool + ReadPointerFromMemory (const Address& addr, + bool prefer_file_cache, + Error &error, + Address &pointer_addr); + SectionLoadList& GetSectionLoadList() { diff --git a/lldb/source/Breakpoint/BreakpointResolverName.cpp b/lldb/source/Breakpoint/BreakpointResolverName.cpp index 87acb521bd08..37054d4afa7f 100644 --- a/lldb/source/Breakpoint/BreakpointResolverName.cpp +++ b/lldb/source/Breakpoint/BreakpointResolverName.cpp @@ -26,7 +26,8 @@ BreakpointResolverName::BreakpointResolverName Breakpoint *bkpt, const char *func_name, uint32_t func_name_type_mask, - Breakpoint::MatchType type + Breakpoint::MatchType type, + bool skip_prologue ) : BreakpointResolver (bkpt, BreakpointResolver::NameResolver), m_func_name (), @@ -34,7 +35,8 @@ BreakpointResolverName::BreakpointResolverName m_func_name_type_mask (func_name_type_mask), m_class_name (), m_regex (), - m_match_type (type) + m_match_type (type), + m_skip_prologue (skip_prologue) { if (func_name_type_mask == eFunctionNameTypeAuto) { @@ -92,13 +94,15 @@ BreakpointResolverName::BreakpointResolverName BreakpointResolverName::BreakpointResolverName ( Breakpoint *bkpt, - RegularExpression &func_regex + RegularExpression &func_regex, + bool skip_prologue ) : BreakpointResolver (bkpt, BreakpointResolver::NameResolver), m_func_name (NULL), m_class_name (NULL), m_regex (func_regex), - m_match_type (Breakpoint::Regexp) + m_match_type (Breakpoint::Regexp), + m_skip_prologue (skip_prologue) { } @@ -108,13 +112,15 @@ BreakpointResolverName::BreakpointResolverName Breakpoint *bkpt, const char *class_name, const char *method, - Breakpoint::MatchType type + Breakpoint::MatchType type, + bool skip_prologue ) : BreakpointResolver (bkpt, BreakpointResolver::NameResolver), m_func_name (method), m_class_name (class_name), m_regex (), - m_match_type (type) + m_match_type (type), + m_skip_prologue (skip_prologue) { } @@ -139,18 +145,12 @@ BreakpointResolverName::SearchCallback SymbolContextList func_list; SymbolContextList sym_list; - bool skip_prologue = true; uint32_t i; bool new_location; SymbolContext sc; Address break_addr; assert (m_breakpoint != NULL); - if (context.target_sp) - { - skip_prologue = context.target_sp->GetSkipPrologue(); - } - LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); if (m_class_name) @@ -294,7 +294,7 @@ BreakpointResolverName::SearchCallback else if (sc.function) { break_addr = sc.function->GetAddressRange().GetBaseAddress(); - if (skip_prologue) + if (m_skip_prologue) { if (break_addr.IsValid()) { @@ -333,7 +333,7 @@ BreakpointResolverName::SearchCallback { break_addr = sc.symbol->GetAddressRangePtr()->GetBaseAddress(); - if (skip_prologue) + if (m_skip_prologue) { const uint32_t prologue_byte_size = sc.symbol->GetPrologueByteSize(); if (prologue_byte_size) diff --git a/lldb/source/Plugins/DynamicLoader/MacOSX-Kernel/DynamicLoaderMacOSXKernel.cpp b/lldb/source/Plugins/DynamicLoader/MacOSX-Kernel/DynamicLoaderMacOSXKernel.cpp index 50004ce27157..609e6fc2c3a9 100644 --- a/lldb/source/Plugins/DynamicLoader/MacOSX-Kernel/DynamicLoaderMacOSXKernel.cpp +++ b/lldb/source/Plugins/DynamicLoader/MacOSX-Kernel/DynamicLoaderMacOSXKernel.cpp @@ -87,6 +87,7 @@ DynamicLoaderMacOSXKernel::CreateInstance (Process* process, bool force) DynamicLoaderMacOSXKernel::DynamicLoaderMacOSXKernel (Process* process) : DynamicLoader(process), m_kernel(), + m_kext_summary_header_ptr_addr (), m_kext_summary_header_addr (), m_kext_summary_header (), m_break_id (LLDB_INVALID_BREAK_ID), @@ -150,6 +151,7 @@ DynamicLoaderMacOSXKernel::Clear (bool clear_process) if (clear_process) m_process = NULL; m_kernel.Clear(false); + m_kext_summary_header_ptr_addr.Clear(); m_kext_summary_header_addr.Clear(); m_kext_summaries.clear(); m_break_id = LLDB_INVALID_BREAK_ID; @@ -165,7 +167,7 @@ DynamicLoaderMacOSXKernel::Clear (bool clear_process) void DynamicLoaderMacOSXKernel::LoadKernelModuleIfNeeded() { - if (!m_kext_summary_header_addr.IsValid()) + if (!m_kext_summary_header_ptr_addr.IsValid()) { m_kernel.Clear(false); m_kernel.module_sp = m_process->GetTarget().GetExecutableModule(); @@ -176,7 +178,7 @@ DynamicLoaderMacOSXKernel::LoadKernelModuleIfNeeded() const Symbol *symbol = NULL; symbol = m_kernel.module_sp->FindFirstSymbolWithNameAndType (kext_summary_symbol, eSymbolTypeData); if (symbol) - m_kext_summary_header_addr = symbol->GetValue(); + m_kext_summary_header_ptr_addr = symbol->GetValue(); symbol = m_kernel.module_sp->FindFirstSymbolWithNameAndType (mach_header_name, eSymbolTypeAbsolute); if (symbol) @@ -395,7 +397,15 @@ DynamicLoaderMacOSXKernel::BreakpointHit (StoppointCallbackContext *context, user_id_t break_id, user_id_t break_loc_id) { + LogSP log(GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER)); + if (log) + log->Printf ("DynamicLoaderMacOSXKernel::BreakpointHit (...)\n"); + ReadAllKextSummaries (); + + if (log) + PutToLog(log.get()); + return GetStopWhenImagesChange(); } @@ -408,7 +418,7 @@ DynamicLoaderMacOSXKernel::ReadKextSummaryHeader () // the all image infos is already valid for this process stop ID m_kext_summaries.clear(); - if (m_kext_summary_header_addr.IsValid()) + if (m_kext_summary_header_ptr_addr.IsValid()) { const uint32_t addr_size = m_kernel.GetAddressByteSize (); const ByteOrder byte_order = m_kernel.GetByteOrder(); @@ -419,17 +429,29 @@ DynamicLoaderMacOSXKernel::ReadKextSummaryHeader () DataExtractor data (buf, sizeof(buf), byte_order, addr_size); const size_t count = 4 * sizeof(uint32_t) + addr_size; const bool prefer_file_cache = false; - const size_t bytes_read = m_process->GetTarget().ReadMemory (m_kext_summary_header_addr, prefer_file_cache, buf, count, error); - if (bytes_read == count) + if (m_process->GetTarget().ReadPointerFromMemory (m_kext_summary_header_ptr_addr, + prefer_file_cache, + error, + m_kext_summary_header_addr)) { - uint32_t offset = 0; - m_kext_summary_header.version = data.GetU32(&offset); - m_kext_summary_header.entry_size = data.GetU32(&offset); - m_kext_summary_header.entry_count = data.GetU32(&offset); - m_kext_summary_header.reserved = data.GetU32(&offset); - return true; + // We got a valid address for our kext summary header and make sure it isn't NULL + if (m_kext_summary_header_addr.IsValid() && + m_kext_summary_header_addr.GetFileAddress() != 0) + { + const size_t bytes_read = m_process->GetTarget().ReadMemory (m_kext_summary_header_addr, prefer_file_cache, buf, count, error); + if (bytes_read == count) + { + uint32_t offset = 0; + m_kext_summary_header.version = data.GetU32(&offset); + m_kext_summary_header.entry_size = data.GetU32(&offset); + m_kext_summary_header.entry_count = data.GetU32(&offset); + m_kext_summary_header.reserved = data.GetU32(&offset); + return true; + } + } } } + m_kext_summary_header_addr.Clear(); return false; } @@ -471,16 +493,9 @@ DynamicLoaderMacOSXKernel::AddModulesUsingImageInfos (OSKextLoadedKextSummary::c { // Now add these images to the main list. ModuleList loaded_module_list; - LogSP log(GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER)); for (uint32_t idx = 0; idx < image_infos.size(); ++idx) { - if (log) - { - log->Printf ("Adding new image at address=0x%16.16llx.", image_infos[idx].address); - image_infos[idx].PutToLog (log.get()); - } - m_kext_summaries.push_back(image_infos[idx]); if (FindTargetModule (image_infos[idx], true, NULL)) @@ -517,8 +532,8 @@ DynamicLoaderMacOSXKernel::AddModulesUsingImageInfos (OSKextLoadedKextSummary::c } } } - if (log) - loaded_module_list.LogUUIDAndPaths (log, "DynamicLoaderMacOSXKernel::ModulesDidLoad"); +// if (log) +// loaded_module_list.LogUUIDAndPaths (log, "DynamicLoaderMacOSXKernel::ModulesDidLoad"); m_process->GetTarget().ModulesDidLoad (loaded_module_list); } return true; @@ -895,11 +910,14 @@ DynamicLoaderMacOSXKernel::SetNotificationBreakpointIfNeeded () { DEBUG_PRINTF("DynamicLoaderMacOSXKernel::%s() process state = %s\n", __FUNCTION__, StateAsCString(m_process->GetState())); + const bool internal_bp = false; + const LazyBool skip_prologue = eLazyBoolNo; Breakpoint *bp = m_process->GetTarget().CreateBreakpoint (&m_kernel.module_sp->GetFileSpec(), "OSKextLoadedKextSummariesUpdated", eFunctionNameTypeFull, - internal_bp).get(); + internal_bp, + skip_prologue).get(); bp->SetCallback (DynamicLoaderMacOSXKernel::BreakpointHitCallback, this, true); m_break_id = bp->GetID(); diff --git a/lldb/source/Plugins/DynamicLoader/MacOSX-Kernel/DynamicLoaderMacOSXKernel.h b/lldb/source/Plugins/DynamicLoader/MacOSX-Kernel/DynamicLoaderMacOSXKernel.h index 53d3c60037cd..c2066f56269d 100644 --- a/lldb/source/Plugins/DynamicLoader/MacOSX-Kernel/DynamicLoaderMacOSXKernel.h +++ b/lldb/source/Plugins/DynamicLoader/MacOSX-Kernel/DynamicLoaderMacOSXKernel.h @@ -411,6 +411,7 @@ protected: UnloadImageLoadAddress (OSKextLoadedKextSummary& info); OSKextLoadedKextSummary m_kernel; // Info about the current kernel image being used + lldb_private::Address m_kext_summary_header_ptr_addr; lldb_private::Address m_kext_summary_header_addr; OSKextLoadedKextSummaryHeader m_kext_summary_header; OSKextLoadedKextSummary::collection m_kext_summaries; diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp index 75977a309c04..be9a12b6234f 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp +++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp @@ -1218,16 +1218,30 @@ SymbolFileDWARF::ParseChildMembers if (is_artificial == false) { Type *member_type = ResolveTypeUID(encoding_uid); - assert(member_type); - if (accessibility == eAccessNone) - accessibility = default_accessibility; - member_accessibilities.push_back(accessibility); + if (member_type) + { + if (accessibility == eAccessNone) + accessibility = default_accessibility; + member_accessibilities.push_back(accessibility); - GetClangASTContext().AddFieldToRecordType (class_clang_type, - name, - member_type->GetClangLayoutType(), - accessibility, - bit_size); + GetClangASTContext().AddFieldToRecordType (class_clang_type, + name, + member_type->GetClangLayoutType(), + accessibility, + bit_size); + } + else + { + if (name) + ReportError ("0x%8.8x: DW_TAG_member '%s' refers to type 0x%8.8x which was unable to be parsed", + die->GetOffset(), + name, + encoding_uid); + else + ReportError ("0x%8.8x: DW_TAG_member refers to type 0x%8.8x which was unable to be parsed", + die->GetOffset(), + encoding_uid); + } } } ++member_idx; @@ -2237,6 +2251,19 @@ SymbolFileDWARF::FindFunctions(const RegularExpression& regex, bool append, Symb // Return the number of variable that were appended to the list return sc_list.GetSize() - original_size; } +void +SymbolFileDWARF::ReportError (const char *format, ...) +{ + ::fprintf (stderr, + "error: %s/%s ", + m_obj_file->GetFileSpec().GetDirectory().GetCString(), + m_obj_file->GetFileSpec().GetFilename().GetCString()); + + va_list args; + va_start (args, format); + vfprintf (stderr, format, args); + va_end (args); +} uint32_t SymbolFileDWARF::FindTypes(const SymbolContext& sc, const ConstString &name, bool append, uint32_t max_matches, TypeList& types) diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h index d3b309cfc9eb..3ed1d949303b 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h @@ -347,6 +347,9 @@ protected: m_decl_ctx_to_die[decl_ctx] = die; } + void + ReportError (const char *format, ...); + SymbolFileDWARFDebugMap * m_debug_map_symfile; clang::TranslationUnitDecl * m_clang_tu_decl; lldb_private::Flags m_flags; diff --git a/lldb/source/Symbol/SymbolContext.cpp b/lldb/source/Symbol/SymbolContext.cpp index 0898b812552d..6d570d79ea72 100644 --- a/lldb/source/Symbol/SymbolContext.cpp +++ b/lldb/source/Symbol/SymbolContext.cpp @@ -164,7 +164,7 @@ SymbolContext::DumpStopContext dumped_something = true; s->PutCString(" at "); if (line_entry.DumpStopContext(s, show_fullpaths)) - return dumped_something; + dumped_something = true; } } } diff --git a/lldb/source/Target/Target.cpp b/lldb/source/Target/Target.cpp index 136269bd9da9..8ef6b92f3764 100644 --- a/lldb/source/Target/Target.cpp +++ b/lldb/source/Target/Target.cpp @@ -213,13 +213,22 @@ Target::CreateBreakpoint (Address &addr, bool internal) } BreakpointSP -Target::CreateBreakpoint (const FileSpec *containingModule, const char *func_name, uint32_t func_name_type_mask, bool internal) +Target::CreateBreakpoint (const FileSpec *containingModule, + const char *func_name, + uint32_t func_name_type_mask, + bool internal, + LazyBool skip_prologue) { BreakpointSP bp_sp; if (func_name) { SearchFilterSP filter_sp(GetSearchFilterForModule (containingModule)); - BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL, func_name, func_name_type_mask, Breakpoint::Exact)); + + BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL, + func_name, + func_name_type_mask, + Breakpoint::Exact, + skip_prologue == eLazyBoolCalculate ? GetSkipPrologue() : skip_prologue)); bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal); } return bp_sp; @@ -247,10 +256,15 @@ Target::GetSearchFilterForModule (const FileSpec *containingModule) } BreakpointSP -Target::CreateBreakpoint (const FileSpec *containingModule, RegularExpression &func_regex, bool internal) +Target::CreateBreakpoint (const FileSpec *containingModule, + RegularExpression &func_regex, + bool internal, + LazyBool skip_prologue) { SearchFilterSP filter_sp(GetSearchFilterForModule (containingModule)); - BreakpointResolverSP resolver_sp(new BreakpointResolverName (NULL, func_regex)); + BreakpointResolverSP resolver_sp(new BreakpointResolverName (NULL, + func_regex, + skip_prologue == eLazyBoolCalculate ? GetSkipPrologue() : skip_prologue)); return CreateBreakpoint (filter_sp, resolver_sp, internal); } @@ -600,19 +614,21 @@ Target::ReadMemory (const Address& addr, bool prefer_file_cache, void *dst, size Address resolved_addr; if (!addr.IsSectionOffset()) { - if (process_is_valid) + if (m_section_load_list.IsEmpty()) { - // Process is valid and we were given an address that - // isn't section offset, so assume this is a load address - load_addr = addr.GetOffset(); - m_section_load_list.ResolveLoadAddress (addr.GetOffset(), resolved_addr); + // No sections are loaded, so we must assume we are not running + // yet and anything we are given is a file address. + file_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the file address + m_images.ResolveFileAddress (file_addr, resolved_addr); } else { - // Process is NOT valid and we were given an address that - // isn't section offset, so assume this is a file address - file_addr = addr.GetOffset(); - m_images.ResolveFileAddress(addr.GetOffset(), resolved_addr); + // We have at least one section loaded. This can be becuase + // we have manually loaded some sections with "target modules load ..." + // or because we have have a live process that has sections loaded + // through the dynamic loader + load_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the load address + m_section_load_list.ResolveLoadAddress (load_addr, resolved_addr); } } if (!resolved_addr.IsValid()) @@ -674,6 +690,99 @@ Target::ReadMemory (const Address& addr, bool prefer_file_cache, void *dst, size return 0; } +size_t +Target::ReadScalarIntegerFromMemory (const Address& addr, + bool prefer_file_cache, + uint32_t byte_size, + bool is_signed, + Scalar &scalar, + Error &error) +{ + uint64_t uval; + + if (byte_size <= sizeof(uval)) + { + size_t bytes_read = ReadMemory (addr, prefer_file_cache, &uval, byte_size, error); + if (bytes_read == byte_size) + { + DataExtractor data (&uval, sizeof(uval), m_arch.GetByteOrder(), m_arch.GetAddressByteSize()); + uint32_t offset = 0; + if (byte_size <= 4) + scalar = data.GetMaxU32 (&offset, byte_size); + else + scalar = data.GetMaxU64 (&offset, byte_size); + + if (is_signed) + scalar.SignExtend(byte_size * 8); + return bytes_read; + } + } + else + { + error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size); + } + return 0; +} + +uint64_t +Target::ReadUnsignedIntegerFromMemory (const Address& addr, + bool prefer_file_cache, + size_t integer_byte_size, + uint64_t fail_value, + Error &error) +{ + Scalar scalar; + if (ReadScalarIntegerFromMemory (addr, + prefer_file_cache, + integer_byte_size, + false, + scalar, + error)) + return scalar.ULongLong(fail_value); + return fail_value; +} + +bool +Target::ReadPointerFromMemory (const Address& addr, + bool prefer_file_cache, + Error &error, + Address &pointer_addr) +{ + Scalar scalar; + if (ReadScalarIntegerFromMemory (addr, + prefer_file_cache, + m_arch.GetAddressByteSize(), + false, + scalar, + error)) + { + addr_t pointer_vm_addr = scalar.ULongLong(LLDB_INVALID_ADDRESS); + if (pointer_vm_addr != LLDB_INVALID_ADDRESS) + { + if (m_section_load_list.IsEmpty()) + { + // No sections are loaded, so we must assume we are not running + // yet and anything we are given is a file address. + m_images.ResolveFileAddress (pointer_vm_addr, pointer_addr); + } + else + { + // We have at least one section loaded. This can be becuase + // we have manually loaded some sections with "target modules load ..." + // or because we have have a live process that has sections loaded + // through the dynamic loader + m_section_load_list.ResolveLoadAddress (pointer_vm_addr, pointer_addr); + } + // We weren't able to resolve the pointer value, so just return + // an address with no section + if (!pointer_addr.IsValid()) + pointer_addr.SetOffset (pointer_vm_addr); + return true; + + } + } + return false; +} ModuleSP Target::GetSharedModule