Implement ProcessInfo::Dump(), log gdb-remote stub launch

[tfiala]

Summary

This change implements dumping the executable, triple,
args and environment when using ProcessInfo::Dump().

It also tweaks the way Args::Dump() works so that it prints
a configurable label rather than argv[{index}]={value}. By
default it behaves the same, but if the Dump() method with
the additional arg is provided, it can be overridden. The
environment variables dumped as part of ProcessInfo::Dump()
make use of that.

lldb-server has been modified to dump the gdb-remote stub's
ProcessInfo before launching if the "gdb-remote process" channel
is logged.

[tfiala]

Hang on, this diff is busted. It seems to have a few more changes in it than came from me. (I suspect it is something slightly out of sync between my change branch and trunk... I'll re-upload as soon as I straighten that out).

[tfiala]

Fixed up whatever my arcanist-foo did wrong on the initial 'arc diff' creation of the patch. (The diff I'm putting up is exactly what comes out of 'git diff origin/master', so not sure how this got mutated into the original diff).

[tfiala]

This was the logging I used to discover the breakage in launching debugserver from 'lldb-server platform' on Apple platforms.

[clayborg]

See inlined comments.

include/lldb/Interpreter/Args.h

120 ↗

(On Diff #58751)

I would make just one Dump function and default the label_name to "argv". No need for two functions.

[tfiala]

include/lldb/Interpreter/Args.h

120 ↗

(On Diff #58751)

Okay - I wasn't sure if we preferred to avoid default args - they used to sometimes cause problems with stale compilations in some build systems, but we're probably way past that point nowadays.

I'll fix that up. Also, I'll run it through the clang formatter. I kept the formatting of the (unimplemented) header in ProcessInfo, but that was using the non-official space-before-the-paren style.

[tfiala]

Updates per Greg.

• Args::Dump(stream, label) now takes a default label.
• Dropped the Args::Dump(stream) call.
• Converted the Args stream parameter to a ref. It is not valid to call this without a stream.
• Updated in-source docs to reflect changes.

[tfiala]

Marked comments as done.

[tfiala]

Closed by commit r271312.

include/lldb/Breakpoint/BreakpointLocationCollection.h

 //===-- BreakpointLocationCollection.h --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_BreakpointLocationCollection_h_
 #define liblldb_BreakpointLocationCollection_h_
 
 // C Includes
 // C++ Includes
 #include <vector>
+#include <mutex>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Utility/Iterable.h"
 
 namespace lldb_private {
 
 class BreakpointLocationCollection
private:
     typedef std::vector<lldb::BreakpointLocationSP> collection;
 
     collection::iterator
     GetIDPairIterator(lldb::break_id_t break_id, lldb::break_id_t break_loc_id);
 
     collection::const_iterator
     GetIDPairConstIterator(lldb::break_id_t break_id, lldb::break_id_t break_loc_id) const;
 
-    collection m_break_loc_collection;
+    collection     m_break_loc_collection;
+    mutable std::mutex  m_collection_mutex;
 
 public:
     typedef AdaptedIterable<collection, lldb::BreakpointLocationSP, vector_adapter> BreakpointLocationCollectionIterable;
     BreakpointLocationCollectionIterable
     BreakpointLocations()
     {
         return BreakpointLocationCollectionIterable(m_break_loc_collection);
     }
 
 };
 
 } // namespace lldb_private
 
 #endif  // liblldb_BreakpointLocationCollection_h_

include/lldb/Core/Logging.h

 #define LIBLLDB_LOG_TARGET              (1u << 22)
 #define LIBLLDB_LOG_MMAP                (1u << 23)
 #define LIBLLDB_LOG_OS                  (1u << 24)
 #define LIBLLDB_LOG_PLATFORM            (1u << 25)
 #define LIBLLDB_LOG_SYSTEM_RUNTIME      (1u << 26)
 #define LIBLLDB_LOG_JIT_LOADER          (1u << 27)
 #define LIBLLDB_LOG_LANGUAGE            (1u << 28)
 #define LIBLLDB_LOG_DATAFORMATTERS      (1u << 29)
+#define LIBLLDB_LOG_DEMANGLE            (1u << 30)
 #define LIBLLDB_LOG_ALL                 (UINT32_MAX)
 #define LIBLLDB_LOG_DEFAULT             (LIBLLDB_LOG_PROCESS              |\
                                          LIBLLDB_LOG_THREAD               |\
                                          LIBLLDB_LOG_DYNAMIC_LOADER       |\
                                          LIBLLDB_LOG_BREAKPOINTS          |\
                                          LIBLLDB_LOG_WATCHPOINTS          |\
                                          LIBLLDB_LOG_STEP                 |\
                                          LIBLLDB_LOG_STATE                |\

source/Breakpoint/BreakpointLocationCollection.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // BreakpointLocationCollection constructor
 //----------------------------------------------------------------------
 BreakpointLocationCollection::BreakpointLocationCollection() :
-    m_break_loc_collection()
+    m_break_loc_collection(),
+    m_collection_mutex()
 {
 }
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 BreakpointLocationCollection::~BreakpointLocationCollection()
 {
 }
 
 void
 BreakpointLocationCollection::Add(const BreakpointLocationSP &bp_loc)
 {
+    std::lock_guard<std::mutex> guard(m_collection_mutex);
     BreakpointLocationSP old_bp_loc = FindByIDPair (bp_loc->GetBreakpoint().GetID(), bp_loc->GetID());
     if (!old_bp_loc.get())
         m_break_loc_collection.push_back(bp_loc);
 }
 
 bool
 BreakpointLocationCollection::Remove (lldb::break_id_t bp_id, lldb::break_id_t bp_loc_id)
 {
+    std::lock_guard<std::mutex> guard(m_collection_mutex);
     collection::iterator pos = GetIDPairIterator(bp_id, bp_loc_id);    // Predicate
     if (pos != m_break_loc_collection.end())
     {
         m_break_loc_collection.erase(pos);
         return true;
     }
     return false;
 
if (pos != m_break_loc_collection.end())
         stop_sp = *pos;
 
     return stop_sp;
 }
 
 BreakpointLocationSP
 BreakpointLocationCollection::GetByIndex (size_t i)
 {
+    std::lock_guard<std::mutex> guard(m_collection_mutex);
     BreakpointLocationSP stop_sp;
     if (i < m_break_loc_collection.size())
         stop_sp = m_break_loc_collection[i];
 
     return stop_sp;
 }
 
 const BreakpointLocationSP
 BreakpointLocationCollection::GetByIndex (size_t i) const
 {
+    std::lock_guard<std::mutex> guard(m_collection_mutex);
     BreakpointLocationSP stop_sp;
     if (i < m_break_loc_collection.size())
         stop_sp = m_break_loc_collection[i];
 
     return stop_sp;
 }
 
 bool
while (i < prev_size)
         prev_size = GetSize();
     }
     return shouldStop;
 }
 
 bool 
 BreakpointLocationCollection::ValidForThisThread (Thread *thread)
 {
+    std::lock_guard<std::mutex> guard(m_collection_mutex);
     collection::iterator pos,
         begin = m_break_loc_collection.begin(),
         end = m_break_loc_collection.end();
 
     for (pos = begin; pos != end; ++pos)
     {
         if ((*pos)->ValidForThisThread (thread))
             return true;
     }
     return false;
 }
 
 bool 
 BreakpointLocationCollection::IsInternal () const
 {
+    std::lock_guard<std::mutex> guard(m_collection_mutex);
     collection::const_iterator pos,
         begin = m_break_loc_collection.begin(),
         end = m_break_loc_collection.end();
 
     bool is_internal = true;
     
     for (pos = begin; pos != end; ++pos)
     {
         if (!(*pos)->GetBreakpoint().IsInternal ())
         {
             is_internal = false;
             break;
         }
     }
     return is_internal;
 }
 
 void
 BreakpointLocationCollection::GetDescription (Stream *s, lldb::DescriptionLevel level)
 {
+    std::lock_guard<std::mutex> guard(m_collection_mutex);
     collection::iterator pos,
         begin = m_break_loc_collection.begin(),
         end = m_break_loc_collection.end();
 
     for (pos = begin; pos != end; ++pos)
     {
         if (pos != begin)
             s->PutChar(' ');
         (*pos)->GetDescription(s, level);
     }
 }
 

source/Core/Logging.cpp

if (log != nullptr)
                 else if (0 == ::strncasecmp(arg, "symbol", 6))  flag_bits &= ~LIBLLDB_LOG_SYMBOLS;
                 else if (0 == ::strcasecmp(arg, "system-runtime"))  flag_bits &= ~LIBLLDB_LOG_SYSTEM_RUNTIME;
                 else if (0 == ::strncasecmp(arg, "module", 6))  flag_bits &= ~LIBLLDB_LOG_MODULES;
                 else if (0 == ::strncasecmp(arg, "mmap", 4))    flag_bits &= ~LIBLLDB_LOG_MMAP;
                 else if (0 == ::strcasecmp(arg, "os"))          flag_bits &= ~LIBLLDB_LOG_OS;
                 else if (0 == ::strcasecmp(arg, "jit"))         flag_bits &= ~LIBLLDB_LOG_JIT_LOADER;
                 else if (0 == ::strcasecmp(arg, "language"))    flag_bits &= ~LIBLLDB_LOG_LANGUAGE;
                 else if (0 == ::strncasecmp(arg, "formatters", 10))   flag_bits &= ~LIBLLDB_LOG_DATAFORMATTERS;
+                else if (0 == ::strncasecmp(arg, "demangle", 8))      flag_bits &= ~LIBLLDB_LOG_DEMANGLE;
                 else
                 {
                     feedback_strm->Printf ("error:  unrecognized log category '%s'\n", arg);
                     ListLogCategories (feedback_strm);
                     return;
                 }
             }
         }
if (g_log != nullptr)
             else if (0 == ::strcasecmp(arg, "thread"))      flag_bits |= LIBLLDB_LOG_THREAD;
             else if (0 == ::strncasecmp(arg, "types", 5))   flag_bits |= LIBLLDB_LOG_TYPES;
             else if (0 == ::strncasecmp(arg, "unwind", 6))  flag_bits |= LIBLLDB_LOG_UNWIND;
             else if (0 == ::strcasecmp(arg, "verbose"))     flag_bits |= LIBLLDB_LOG_VERBOSE;
             else if (0 == ::strncasecmp(arg, "watch", 5))   flag_bits |= LIBLLDB_LOG_WATCHPOINTS;
             else if (0 == ::strcasecmp(arg, "jit"))         flag_bits |= LIBLLDB_LOG_JIT_LOADER;
             else if (0 == ::strcasecmp(arg, "language"))    flag_bits |= LIBLLDB_LOG_LANGUAGE;
             else if (0 == ::strncasecmp(arg, "formatters", 10))   flag_bits |= LIBLLDB_LOG_DATAFORMATTERS;
+            else if (0 == ::strncasecmp(arg, "demangle", 8))      flag_bits |= LIBLLDB_LOG_DEMANGLE;
             else
             {
                 feedback_strm->Printf("error: unrecognized log category '%s'\n", arg);
                 ListLogCategories (feedback_strm);
                 return g_log;
             }
         }
 
lldb_private::ListLogCategories (Stream *strm)
     strm->Printf("Logging categories for 'lldb':\n"
                  "  all - turn on all available logging categories\n"
                  "  api - enable logging of API calls and return values\n"
                  "  break - log breakpoints\n"
                  "  commands - log command argument parsing\n"
                  "  communication - log communication activities\n"
                  "  connection - log connection details\n"
                  "  default - enable the default set of logging categories for liblldb\n"
+                 "  demangle - log mangled names to catch demangler crashes\n"
                  "  dyld - log shared library related activities\n"
                  "  events - log broadcaster, listener and event queue activities\n"
                  "  expr - log expressions\n"
                  "  formatters - log data formatters related activities\n"
                  "  host - log host activities\n"
                  "  jit - log JIT events in the target\n"
                  "  language - log language runtime events\n"
                  "  mmap - log mmap related activities\n"

source/Core/Mangled.cpp

 #include "lldb/Core/CxaDemangle.h"
 
 #endif
 
 
 #include "llvm/ADT/DenseMap.h"
 
 #include "lldb/Core/ConstString.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Core/Logging.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/Timer.h"
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include <ctype.h>
 #include <string.h>
Mangled::GetDemangledName (lldb::LanguageType language) const
     // haven't already decoded our mangled name.
     if (m_mangled && !m_demangled)
     {
         // We need to generate and cache the demangled name.
         Timer scoped_timer (__PRETTY_FUNCTION__,
                             "Mangled::GetDemangledName (m_mangled = %s)",
                             m_mangled.GetCString());
 
+        Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_DEMANGLE);
+
         // Don't bother running anything that isn't mangled
         const char *mangled_name = m_mangled.GetCString();
         ManglingScheme mangling_scheme{cstring_mangling_scheme(mangled_name)};
         if (mangling_scheme != eManglingSchemeNone &&
             !m_mangled.GetMangledCounterpart(m_demangled))
         {
             // We didn't already mangle this name, demangle it and if all goes well
             // add it to our map.
             char *demangled_name = nullptr;
             switch (mangling_scheme)
             {
                 case eManglingSchemeMSVC:
                 {
 #if defined(_MSC_VER)
+                    if (log)
+                        log->Printf("demangle msvc: %s", mangled_name);
                     const size_t demangled_length = 2048;
                     demangled_name = static_cast<char *>(::malloc(demangled_length));
                     ::ZeroMemory(demangled_name, demangled_length);
                     DWORD result = ::UnDecorateSymbolName(mangled_name, demangled_name, demangled_length,
                             UNDNAME_NO_ACCESS_SPECIFIERS   | // Strip public, private, protected keywords
                             UNDNAME_NO_ALLOCATION_LANGUAGE | // Strip __thiscall, __stdcall, etc keywords
                             UNDNAME_NO_THROW_SIGNATURES    | // Strip throw() specifications
                             UNDNAME_NO_MEMBER_TYPE         | // Strip virtual, static, etc specifiers
                             UNDNAME_NO_MS_KEYWORDS           // Strip all MS extension keywords
                         );
+                    if (log)
+                    {
+                        if (demangled_name && demangled_name[0])
+                            log->Printf("demangled msvc: %s -> \"%s\"", mangled_name, demangled_name);
+                        else
+                            log->Printf("demangled msvc: %s -> error: 0x%" PRIx64, mangled_name, result);
+                    }
+
                     if (result == 0)
                     {
                         free(demangled_name);
                         demangled_name = nullptr;
                     }
 #endif
                     break;
                 }
                 case eManglingSchemeItanium:
                 {
 #ifdef LLDB_USE_BUILTIN_DEMANGLER
+                    if (log)
+                        log->Printf("demangle itanium: %s", mangled_name);
                     // Try to use the fast-path demangler first for the
                     // performance win, falling back to the full demangler only
                     // when necessary
                     demangled_name = FastDemangle(mangled_name, m_mangled.GetLength());
                     if (!demangled_name)
                         demangled_name = __cxa_demangle(mangled_name, NULL, NULL, NULL);
 #else
                     demangled_name = abi::__cxa_demangle(mangled_name, NULL, NULL, NULL);
 #endif
+                    if (log)
+                    {
+                        if (demangled_name)
+                            log->Printf("demangled itanium: %s -> \"%s\"", mangled_name, demangled_name);
+                        else
+                            log->Printf("demangled itanium: %s -> error: failed to demangle", mangled_name);
+                    }
                     break;
                 }
                 case eManglingSchemeNone:
                     break;
             }
             if (demangled_name)
             {
                 m_demangled.SetCStringWithMangledCounterpart(demangled_name, m_mangled);

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h

public:
         FixUpState fixedup;
     };
 
     lldb::addr_t
     SetupDispatchFunction (Thread &thread, ValueList &dispatch_values);
 
 private:
     static const char *g_lookup_implementation_function_name;
-    static const char *g_lookup_implementation_function_code;
     static const char *g_lookup_implementation_with_stret_function_code;
     static const char *g_lookup_implementation_no_stret_function_code;
 
     class AppleObjCVTables
     {
     public:
         // These come from objc-gdb.h.
         enum VTableFlags
private:
     };
     
     static const DispatchFunction g_dispatch_functions[];
     
     typedef std::map<lldb::addr_t, int> MsgsendMap; // This table maps an dispatch fn address to the index in g_dispatch_functions
     MsgsendMap m_msgSend_map;
     lldb::ProcessWP m_process_wp;
     lldb::ModuleSP m_objc_module_sp;
+    const char *m_lookup_implementation_function_code;
     std::unique_ptr<UtilityFunction> m_impl_code;
     std::mutex m_impl_function_mutex;
     lldb::addr_t m_impl_fn_addr;
     lldb::addr_t m_impl_stret_fn_addr;
     lldb::addr_t m_msg_forward_addr;
     lldb::addr_t m_msg_forward_stret_addr;
     std::unique_ptr<AppleObjCVTables> m_vtables_ap;
 };
 
 } // namespace lldb_private
 
 #endif // lldb_AppleObjCTrampolineHandler_h_

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

 #include "lldb/Target/ThreadPlanRunToAddress.h"
 
 #include "llvm/ADT/STLExtras.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 const char *AppleObjCTrampolineHandler::g_lookup_implementation_function_name = "__lldb_objc_find_implementation_for_selector";
-const char *AppleObjCTrampolineHandler::g_lookup_implementation_function_code = NULL;
 const char *AppleObjCTrampolineHandler::g_lookup_implementation_with_stret_function_code = "                               \n\
 extern \"C\"                                                                                                    \n\
 {                                                                                                               \n\
     extern void *class_getMethodImplementation(void *objc_class, void *sel);                                    \n\
     extern void *class_getMethodImplementation_stret(void *objc_class, void *sel);                              \n\
     extern void * object_getClass (id object);                                                                  \n\
     extern void * sel_getUid(char *name);                                                                       \n\
     extern int printf(const char *format, ...);                                                                 \n\
AppleObjCTrampolineHandler::g_dispatch_functions[] =
     {"objc_msgSendSuper2_stret_fixup",   true,  true,   true, DispatchFunction::eFixUpToFix   },
     {"objc_msgSendSuper2_stret_fixedup", true,  true,   true, DispatchFunction::eFixUpFixed   },
 };
 
 AppleObjCTrampolineHandler::AppleObjCTrampolineHandler (const ProcessSP &process_sp, 
                                                         const ModuleSP &objc_module_sp) :
     m_process_wp (),
     m_objc_module_sp (objc_module_sp),
+    m_lookup_implementation_function_code(nullptr),
     m_impl_fn_addr (LLDB_INVALID_ADDRESS),
     m_impl_stret_fn_addr (LLDB_INVALID_ADDRESS),
     m_msg_forward_addr (LLDB_INVALID_ADDRESS)
 {
     if (process_sp)
         m_process_wp = process_sp;
     // Look up the known resolution functions:
     
if (m_impl_fn_addr == LLDB_INVALID_ADDRESS)
         }
         return;
     }
     else if (m_impl_stret_fn_addr == LLDB_INVALID_ADDRESS)
     {
         // It there is no stret return lookup function, assume that it is the same as the straight lookup:
         m_impl_stret_fn_addr = m_impl_fn_addr;
         // Also we will use the version of the lookup code that doesn't rely on the stret version of the function.
-        g_lookup_implementation_function_code = g_lookup_implementation_no_stret_function_code;
+        m_lookup_implementation_function_code = g_lookup_implementation_no_stret_function_code;
     }
     else
     {
-        g_lookup_implementation_function_code = g_lookup_implementation_with_stret_function_code;
+        m_lookup_implementation_function_code = g_lookup_implementation_with_stret_function_code;
     }
         
     // Look up the addresses for the objc dispatch functions and cache them.  For now I'm inspecting the symbol
     // names dynamically to figure out how to dispatch to them.  If it becomes more complicated than this we can 
     // turn the g_dispatch_functions char * array into a template table, and populate the DispatchFunction map
     // from there.
 
     for (size_t i = 0; i != llvm::array_lengthof(g_dispatch_functions); i++)
AppleObjCTrampolineHandler::SetupDispatchFunction(Thread &thread, ValueList &dispatch_values)
     // Scope for mutex locker:
     {
         std::lock_guard<std::mutex> guard(m_impl_function_mutex);
 
         // First stage is to make the ClangUtility to hold our injected function:
 
         if (!m_impl_code.get())
         {
-            if (g_lookup_implementation_function_code != NULL)
+            if (m_lookup_implementation_function_code != NULL)
             {
                 Error error;
-                m_impl_code.reset (exe_ctx.GetTargetRef().GetUtilityFunctionForLanguage (g_lookup_implementation_function_code,
+                m_impl_code.reset (exe_ctx.GetTargetRef().GetUtilityFunctionForLanguage (m_lookup_implementation_function_code,
                                                                                          eLanguageTypeObjC,
                                                                                          g_lookup_implementation_function_name,
                                                                                          error));
                 if (error.Fail())
                 {
                     if (log)
                         log->Printf ("Failed to get Utility Function for implementation lookup: %s.", error.AsCString());
                     m_impl_code.reset();

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

GDBRemoteCommunicationServerPlatform::LaunchGDBServer(const lldb_private::Args& args,
     std::string platform_ip;
     int platform_port;
     std::string platform_path;
     bool ok = UriParser::Parse(GetConnection()->GetURI().c_str(), platform_scheme, platform_ip, platform_port, platform_path);
     UNUSED_IF_ASSERT_DISABLED(ok);
     assert(ok);
 
     std::ostringstream url;
+    // debugserver does not accept the URL scheme prefix.
+#if !defined(__APPLE__)
     url << m_socket_scheme << "://";
+#endif
     uint16_t* port_ptr = &port;
     if (m_socket_protocol == Socket::ProtocolTcp)
         url << platform_ip << ":" << port;
     else
     {
         socket_name = GetDomainSocketPath("gdbserver").GetPath();
         url << socket_name;
         port_ptr = nullptr;

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

if (die)
                     {
                         // Always start the definition for a class type so that
                         // if the class has child classes or types that require
                         // the class to be created for use as their decl contexts
                         // the class will be ready to accept these child definitions.
                         if (die.HasChildren() == false)
                         {
                             // No children for this struct/union/class, lets finish it
-                            ClangASTContext::StartTagDeclarationDefinition (clang_type);
+                            if (ClangASTContext::StartTagDeclarationDefinition (clang_type))
+                            {
                                 ClangASTContext::CompleteTagDeclarationDefinition (clang_type);
+                            }
+                            else
+                            {
+                                dwarf->GetObjectFile()->GetModule()->ReportError("DWARF DIE at 0x%8.8x named \"%s\" was not able to start its definition.\nPlease file a bug and attach the file at the start of this error message",
+                                                                                 die.GetOffset(),
+                                                                                 type_name_cstr);
+                            }
 
                             if (tag == DW_TAG_structure_type) // this only applies in C
                             {
                                 clang::RecordDecl *record_decl = ClangASTContext::GetAsRecordDecl(clang_type);
 
                                 if (record_decl)
                                 {
                                     GetClangASTImporter().InsertRecordDecl(record_decl, ClangASTImporter::LayoutInfo());
if (die)
                                                  byte_size,
                                                  NULL,
                                                  DIERef(encoding_form).GetUID(dwarf),
                                                  Type::eEncodingIsUID,
                                                  &decl,
                                                  clang_type,
                                                  Type::eResolveStateForward));
 
-                        ClangASTContext::StartTagDeclarationDefinition (clang_type);
+                        if (ClangASTContext::StartTagDeclarationDefinition (clang_type))
+                        {
                             if (die.HasChildren())
                             {
                                 SymbolContext cu_sc(die.GetLLDBCompileUnit());
                                 bool is_signed = false;
                                 enumerator_clang_type.IsIntegerType(is_signed);
                                 ParseChildEnumerators(cu_sc, clang_type, is_signed, type_sp->GetByteSize(), die);
                             }
                             ClangASTContext::CompleteTagDeclarationDefinition (clang_type);
                         }
+                        else
+                        {
+                            dwarf->GetObjectFile()->GetModule()->ReportError("DWARF DIE at 0x%8.8x named \"%s\" was not able to start its definition.\nPlease file a bug and attach the file at the start of this error message",
+                                                                             die.GetOffset(),
+                                                                             type_name_cstr);
+                        }
+                    }
                 }
                     break;
 
                 case DW_TAG_inlined_subroutine:
                 case DW_TAG_subprogram:
                 case DW_TAG_subroutine_type:
                 {
                     // Set a bit that lets us know that we are currently parsing this

                                                                 die.GetLLDBCompileUnit() ? die.GetLLDBCompileUnit()->GetPath().c_str() : "the source file");
                                 }
 
                                 // We have no choice other than to pretend that the element class type
                                 // is complete. If we don't do this, clang will crash when trying
                                 // to layout the class. Since we provide layout assistance, all
                                 // ivars in this class and other classes will be fine, this is
                                 // the best we can do short of crashing.
-                                ClangASTContext::StartTagDeclarationDefinition(array_element_type);
+                                if (ClangASTContext::StartTagDeclarationDefinition(array_element_type))
+                                {
                                     ClangASTContext::CompleteTagDeclarationDefinition(array_element_type);
                                 }
+                                else
+                                {
+                                    module_sp->ReportError ("DWARF DIE at 0x%8.8x was not able to start its definition.\nPlease file a bug and attach the file at the start of this error message",
+                                                            type_die_ref.die_offset,
+                                                            type_name_cstr);
+                                }
+                            }
 
                             uint64_t array_element_bit_stride = byte_stride * 8 + bit_stride;
                             if (element_orders.size() > 0)
                             {
                                 uint64_t num_elements = 0;
                                 std::vector<uint64_t>::const_reverse_iterator pos;
                                 std::vector<uint64_t>::const_reverse_iterator end = element_orders.rend();
                                 for (pos = element_orders.rbegin(); pos != end; ++pos)
switch (tag)
                                          module->ReportError (":: Try compiling the source file with -fno-limit-debug-info.");
 
                                     // We have no choice other than to pretend that the base class
                                     // is complete. If we don't do this, clang will crash when we
                                     // call setBases() inside of "clang_type.SetBaseClassesForClassType()"
                                     // below. Since we provide layout assistance, all ivars in this
                                     // class and other classes will be fine, this is the best we can do
                                     // short of crashing.
-                                    ClangASTContext::StartTagDeclarationDefinition (base_class_type);
+                                    if (ClangASTContext::StartTagDeclarationDefinition (base_class_type))
+                                    {
                                         ClangASTContext::CompleteTagDeclarationDefinition (base_class_type);
                                     }
                                 }
                             }
+                        }
                         m_ast.SetBaseClassesForClassType (clang_type.GetOpaqueQualType(),
                                                           &base_classes.front(),
                                                           base_classes.size());
 
                         // Clang will copy each CXXBaseSpecifier in "base_classes"
                         // so we have to free them all.
                         ClangASTContext::DeleteBaseClassSpecifiers (&base_classes.front(),
                                                                     base_classes.size());
switch (tag)
                     GetClangASTImporter().InsertRecordDecl(record_decl, layout_info);
                 }
             }
         }
 
             return (bool)clang_type;
 
         case DW_TAG_enumeration_type:
-            ClangASTContext::StartTagDeclarationDefinition (clang_type);
+            if (ClangASTContext::StartTagDeclarationDefinition (clang_type))
+            {
                 if (die.HasChildren())
                 {
                     SymbolContext sc(die.GetLLDBCompileUnit());
                     bool is_signed = false;
                     clang_type.IsIntegerType(is_signed);
                     ParseChildEnumerators(sc, clang_type, is_signed, type->GetByteSize(), die);
                 }
                 ClangASTContext::CompleteTagDeclarationDefinition (clang_type);
+            }
             return (bool)clang_type;
 
         default:
             assert(false && "not a forward clang type decl!");
             break;
     }
 
     return false;
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
                                                                 die.GetOffset(),
                                                                 name,
                                                                 sc.comp_unit ? sc.comp_unit->GetPath().c_str() : "the source file");
                                     // We have no choice other than to pretend that the member class
                                     // is complete. If we don't do this, clang will crash when trying
                                     // to layout the class. Since we provide layout assistance, all
                                     // ivars in this class and other classes will be fine, this is
                                     // the best we can do short of crashing.
-                                    ClangASTContext::StartTagDeclarationDefinition(member_clang_type);
+                                    if (ClangASTContext::StartTagDeclarationDefinition(member_clang_type))
+                                    {
                                         ClangASTContext::CompleteTagDeclarationDefinition(member_clang_type);
                                     }
+                                    else
+                                    {
+                                        module_sp->ReportError ("DWARF DIE at 0x%8.8x (class %s) has a member variable 0x%8.8x (%s) whose type claims to be a C++ class but we were not able to start its definition.\nPlease file a bug and attach the file at the start of this error message",
+                                                                parent_die.GetOffset(),
+                                                                parent_die.GetName(),
+                                                                die.GetOffset(),
+                                                                name);
+                                    }
+                                }
 
                                 field_decl = ClangASTContext::AddFieldToRecordType (class_clang_type,
                                                                                     name,
                                                                                     member_clang_type,
                                                                                     accessibility,
                                                                                     bit_size);
 
                                 m_ast.SetMetadataAsUserID (field_decl, die.GetID());

source/Symbol/ClangASTContext.cpp

 CompilerType
 ClangASTContext::CreateFunctionType (ASTContext *ast,
                                      const CompilerType& result_type,
                                      const CompilerType *args,
                                      unsigned num_args, 
                                      bool is_variadic, 
                                      unsigned type_quals)
 {
-    assert (ast != nullptr);
+    if (ast == nullptr)
+        return CompilerType(); // invalid AST
+
+    if (!result_type || !ClangUtil::IsClangType(result_type))
+        return CompilerType(); // invalid return type
+
     std::vector<QualType> qual_type_args;
+    if (num_args > 0 && args == nullptr)
+        return CompilerType(); // invalid argument array passed in
+
+    // Verify that all arguments are valid and the right type
     for (unsigned i=0; i<num_args; ++i)
+    {
+        if (args[i])
+        {
+            // Make sure we have a clang type in args[i] and not a type from another
+            // language whose name might match
+            const bool is_clang_type = ClangUtil::IsClangType(args[i]);
+            lldbassert(is_clang_type);
+            if (is_clang_type)
                 qual_type_args.push_back(ClangUtil::GetQualType(args[i]));
+            else
+                return CompilerType(); //  invalid argument type (must be a clang type)
+        }
+        else
+            return CompilerType(); // invalid argument type (empty)
+    }
 
     // TODO: Detect calling convention in DWARF?
     FunctionProtoType::ExtProtoInfo proto_info;
     proto_info.Variadic = is_variadic;
     proto_info.ExceptionSpec = EST_None;
     proto_info.TypeQuals = type_quals;
     proto_info.RefQualifier = RQ_None;
 

 }
 
 bool
 ClangASTContext::CompleteTagDeclarationDefinition (const CompilerType& type)
 {
     clang::QualType qual_type(ClangUtil::GetQualType(type));
     if (!qual_type.isNull())
     {
-        clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
+        // Make sure we use the same methodology as ClangASTContext::StartTagDeclarationDefinition()
+        // as to how we start/end the definition. Previously we were calling 
+        const clang::TagType *tag_type = qual_type->getAs<clang::TagType>();
+        if (tag_type)
+        {
+            clang::TagDecl *tag_decl = tag_type->getDecl();
+            if (tag_decl)
+            {
+                clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast_or_null<clang::CXXRecordDecl>(tag_decl);
                 
                 if (cxx_record_decl)
                 {
                     if (!cxx_record_decl->isCompleteDefinition())
                         cxx_record_decl->completeDefinition();
                     cxx_record_decl->setHasLoadedFieldsFromExternalStorage(true);
                     cxx_record_decl->setHasExternalLexicalStorage (false);
                     cxx_record_decl->setHasExternalVisibleStorage (false);
                     return true;
                 }
-        
+            }
+        }
         const clang::EnumType *enutype = qual_type->getAs<clang::EnumType>();
         
         if (enutype)
         {
             clang::EnumDecl *enum_decl = enutype->getDecl();
             
             if (enum_decl)
             {

source/Target/ProcessInfo.cpp

 ProcessInfo::GetNameLength() const
 {
     return m_executable.GetFilename().GetLength();
 }
 
 void
 ProcessInfo::Dump (Stream &s, Platform *platform) const
 {
-    // Print executable name.
-    s << "ProcessInfo\nExecutable:\n\t" << GetName() << "\n\n";
-
-    // Triple.
+    s << "Executable: " << GetName() << "\n";
     s << "Triple: ";
     m_arch.DumpTriple(s);
+    s << "\n";
 
-    // Print arguments
-    s << "\nArguments:\n";
+    s << "Arguments:\n";
     m_arguments.Dump(&s);
 
-    // Print environment.
-    s << "\nEnvironment:\n";
+    s << "Environment:\n";
     m_environment.Dump(&s, "env");
 }
 
 void
 ProcessInfo::SetExecutableFile (const FileSpec &exe_file, bool add_exe_file_as_first_arg)
 {
     if (exe_file)
     {