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.



git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@134990 91177308-0d34-0410-b5e6-96231b3b80d8

7 files changed, 217 insertions, 59 deletions

diff --git a/source/Breakpoint/BreakpointResolverName.cpp b/source/Breakpoint/BreakpointResolverName.cpp
index 87acb521b..37054d4af 100644
--- a/source/Breakpoint/BreakpointResolverName.cpp
+++ b/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/source/Plugins/DynamicLoader/MacOSX-Kernel/DynamicLoaderMacOSXKernel.cpp b/source/Plugins/DynamicLoader/MacOSX-Kernel/DynamicLoaderMacOSXKernel.cpp
index 50004ce27..609e6fc2c 100644
--- a/source/Plugins/DynamicLoader/MacOSX-Kernel/DynamicLoaderMacOSXKernel.cpp
+++ b/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/source/Plugins/DynamicLoader/MacOSX-Kernel/DynamicLoaderMacOSXKernel.h b/source/Plugins/DynamicLoader/MacOSX-Kernel/DynamicLoaderMacOSXKernel.h
index 53d3c6003..c2066f562 100644
--- a/source/Plugins/DynamicLoader/MacOSX-Kernel/DynamicLoaderMacOSXKernel.h
+++ b/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/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
index 75977a309..be9a12b62 100644
--- a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
+++ b/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);
-
-                        GetClangASTContext().AddFieldToRecordType (class_clang_type, 
-                                                                   name, 
-                                                                   member_type->GetClangLayoutType(), 
-                                                                   accessibility, 
-                                                                   bit_size);
+                        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);
+                        }
+                        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/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
index d3b309cfc..3ed1d9493 100644
--- a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
+++ b/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/source/Symbol/SymbolContext.cpp b/source/Symbol/SymbolContext.cpp
index 0898b8125..6d570d79e 100644
--- a/source/Symbol/SymbolContext.cpp
+++ b/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/source/Target/Target.cpp b/source/Target/Target.cpp
index 136269bd9..8ef6b92f3 100644
--- a/source/Target/Target.cpp
+++ b/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