Use uniqueness of C++ fully-qualified names to resolve conflicts

[artagnon]

Summary

A very expected layout: source tree is in ~/src/llvm, the build directory is in
~/src/llvm-build, and the install location is in /usr/local/{lib,include}.

The DWARF information in /usr/local/lib/libLLVM.a for ilist.h points to
~/src/llvm-build/include/llvm/ADT/ilist.h. Now, when someone includes
"llvm/ADT/ilist.h" and links against /usr/local/lib/libLLVM.a. Disaster.

The DWARF information in libUser.so for ilist.h points to two locations: the one
in /usr/include, and the one in ~/src/llvm-build/include. LLDB gets confused.

Let's uniquify fully-qualified names and never trip on such a thing.

Patch-by: Greg Clayton

[clayborg]

Looks good!

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

if (die)
                         }
                     }
 
                     // UniqueDWARFASTType is large, so don't create a local variables on the
                     // stack, put it on the heap. This function is often called recursively
                     // and clang isn't good and sharing the stack space for variables in different blocks.
                     std::unique_ptr<UniqueDWARFASTType> unique_ast_entry_ap(new UniqueDWARFASTType());
 
-                    // Only try and unique the type if it has a name.
-                    if (type_name_const_str &&
-                        dwarf->GetUniqueDWARFASTTypeMap().Find (type_name_const_str,
-                                                                die,
-                                                                decl,
+                    if (type_name_const_str)
+                    {
+                        LanguageType die_language = die.GetLanguage();
+                        bool handled = false;
+                        if (Language::LanguageIsCPlusPlus(die_language))
+                        {
+                            std::string qualified_name;
+                            if (die.GetQualifiedName(qualified_name))
+                            {
+                                handled = true;
+                                ConstString const_qualified_name(qualified_name);
+                                if (dwarf->GetUniqueDWARFASTTypeMap().Find(const_qualified_name, die, Declaration(),
+                                                                           byte_size_valid ? byte_size : -1,
+                                                                           *unique_ast_entry_ap))
+                                {
+                                    type_sp = unique_ast_entry_ap->m_type_sp;
+                                    if (type_sp)
+                                    {
+                                        dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+                                        return type_sp;
+                                    }
+                                }
+                            }
+                        }
+
+                        if (!handled)
+                        {
+                            if (dwarf->GetUniqueDWARFASTTypeMap().Find(type_name_const_str, die, decl,
                                                                        byte_size_valid ? byte_size : -1,
                                                                        *unique_ast_entry_ap))
                         {
-                        // We have already parsed this type or from another
-                        // compile unit. GCC loves to use the "one definition
-                        // rule" which can result in multiple definitions
-                        // of the same class over and over in each compile
-                        // unit.
                             type_sp = unique_ast_entry_ap->m_type_sp;
                             if (type_sp)
                             {
                             dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
                             return type_sp;
                             }
                         }
+                        }
+                    }
 
                     DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(), DW_TAG_value_to_name(tag), type_name_cstr);
 
                     int tag_decl_kind = -1;
                     AccessType default_accessibility = eAccessNone;
                     if (tag == DW_TAG_structure_type)
                     {
                         tag_decl_kind = clang::TTK_Struct;

                                                     if (add_method)
                                                     {
                                                         // REMOVE THE CRASH DESCRIPTION BELOW
                                                         Host::SetCrashDescriptionWithFormat ("SymbolFileDWARF::ParseType() is adding a method %s to class %s in DIE 0x%8.8" PRIx64 " from %s",
                                                                                              type_name_cstr,
                                                                                              class_type->GetName().GetCString(),
                                                                                              die.GetID(),
                                                                                              dwarf->GetObjectFile()->GetFileSpec().GetPath().c_str());
-    
                                                         const bool is_attr_used = false;
                                                         // Neither GCC 4.2 nor clang++ currently set a valid accessibility
                                                         // in the DWARF for C++ methods... Default to public for now...
                                                         if (accessibility == eAccessNone)
                                                             accessibility = eAccessPublic;
-    
                                                         clang::CXXMethodDecl *cxx_method_decl;
                                                         cxx_method_decl = m_ast.AddMethodToCXXRecordType (class_opaque_type.GetOpaqueQualType(),
                                                                                                           type_name_cstr,
                                                                                                           clang_type,
                                                                                                           accessibility,
                                                                                                           is_virtual,
                                                                                                           is_static,
                                                                                                           is_inline,
                                                                                                           is_explicit,
                                                                                                           is_attr_used,
                                                                                                           is_artificial);
-    
                                                         type_handled = cxx_method_decl != NULL;
-    
                                                         if (type_handled)
                                                         {
                                                             LinkDeclContextToDIE(ClangASTContext::GetAsDeclContext(cxx_method_decl), die);
-    
                                                             Host::SetCrashDescription (NULL);
-    
-    
                                                             ClangASTMetadata metadata;
                                                             metadata.SetUserID(die.GetID());
-    
                                                             if (!object_pointer_name.empty())
                                                             {
                                                                 metadata.SetObjectPtrName(object_pointer_name.c_str());
                                                                 if (log)
                                                                     log->Printf ("Setting object pointer name: %s on method object %p.\n",
                                                                                  object_pointer_name.c_str(),
                                                                                  static_cast<void*>(cxx_method_decl));
                                                             }

                                 {
                                     case DW_AT_type:
                                         type_die_form = form_value; break;
                                     case DW_AT_containing_type:
                                         containing_type_die_form = form_value; break;
                                 }
                             }
                         }
-                        
                         Type *pointee_type = dwarf->ResolveTypeUID(DIERef(type_die_form).GetUID());
                         Type *class_type = dwarf->ResolveTypeUID(DIERef(containing_type_die_form).GetUID());
-                        
                         CompilerType pointee_clang_type = pointee_type->GetForwardCompilerType ();
                         CompilerType class_clang_type = class_type->GetLayoutCompilerType ();
                         
                         clang_type = ClangASTContext::CreateMemberPointerType(class_clang_type, pointee_clang_type);
-                        
                         byte_size = clang_type.GetByteSize(nullptr);
-                        
-                        type_sp.reset( new Type (die.GetID(),
-                                                 dwarf,
-                                                 type_name_const_str, 
-                                                 byte_size, 
-                                                 NULL, 
-                                                 LLDB_INVALID_UID, 
-                                                 Type::eEncodingIsUID, 
-                                                 NULL, 
-                                                 clang_type, 
-                                                 Type::eResolveStateForward));
+                        type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str, byte_size, NULL,
+                                               LLDB_INVALID_UID, Type::eEncodingIsUID, NULL, clang_type,
                     }
-                    
                     break;
                 }
                 default:
                     dwarf->GetObjectFile()->GetModule()->ReportError ("{0x%8.8x}: unhandled type tag 0x%4.4x (%s), please file a bug and attach the file at the start of this error message",
                                                                       die.GetOffset(),
                                                                       tag,
                                                                       DW_TAG_value_to_name(tag));
                     break;
             }
-            
             if (type_sp.get())
             {
                 DWARFDIE sc_parent_die = SymbolFileDWARF::GetParentSymbolContextDIE(die);
                 dw_tag_t sc_parent_tag = sc_parent_die.Tag();
-                
                 SymbolContextScope * symbol_context_scope = NULL;
                 if (sc_parent_tag == DW_TAG_compile_unit)
                 {
                     symbol_context_scope = sc.comp_unit;
                 }
                 else if (sc.function != NULL && sc_parent_die)
                 {
                     symbol_context_scope = sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
                     if (symbol_context_scope == NULL)
                         symbol_context_scope = sc.function;
                 }
-                
                 if (symbol_context_scope != NULL)
                 {
                     type_sp->SetSymbolContextScope(symbol_context_scope);
                 }
-                
                 // We are ready to put this type into the uniqued list up at the module level
                 type_list->Insert (type_sp);
-                
                 dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
             }
         }
         else if (type_ptr != DIE_IS_BEING_PARSED)
         {
             type_sp = type_ptr->shared_from_this();
         }
     }
switch (tag)
             assert(false && "not a forward clang type decl!");
             break;
     }
 
     return false;
 }
 
 std::vector<DWARFDIE>
-DWARFASTParserClang::GetDIEForDeclContext (lldb_private::CompilerDeclContext decl_context) 
+DWARFASTParserClang::GetDIEForDeclContext(lldb_private::CompilerDeclContext decl_context)
 {
     std::vector<DWARFDIE> result;
     for (auto it = m_decl_ctx_to_die.find((clang::DeclContext *)decl_context.GetOpaqueDeclContext()); it != m_decl_ctx_to_die.end(); it++)
         result.push_back(it->second);
     return result;
 }
 
 CompilerDecl
if (die)
         const size_t num_attributes = die.GetAttributes(attributes);
         if (num_attributes > 0)
         {
             DWARFFormValue type_die_form;
             for (size_t i = 0; i < num_attributes; ++i)
             {
                 dw_attr_t attr = attributes.AttributeAtIndex(i);
                 DWARFFormValue form_value;
-                
                 if (attr == DW_AT_type && attributes.ExtractFormValueAtIndex(i, form_value))
                     return dwarf->ResolveTypeUID(DIERef(form_value).GetUID());
             }
         }
     }
 
     return nullptr;
 }
switch (die.Tag())
 
             if (dwarf->UserIDMatches(imported_uid))
             {
                 CompilerDecl imported_decl = dwarf->GetDeclForUID(imported_uid);
                 if (imported_decl)
                 {
                     clang::DeclContext *decl_context = ClangASTContext::DeclContextGetAsDeclContext(dwarf->GetDeclContextContainingUID(die.GetID()));
                     if (clang::NamedDecl *clang_imported_decl = llvm::dyn_cast<clang::NamedDecl>((clang::Decl *)imported_decl.GetOpaqueDecl()))
-                        decl = m_ast.CreateUsingDeclaration(decl_context, clang_imported_decl); 
+                        decl = m_ast.CreateUsingDeclaration(decl_context, clang_imported_decl);
                 }
             }
             break;
         }
         case DW_TAG_imported_module:
         {
             SymbolFileDWARF *dwarf = die.GetDWARF();
             lldb::user_id_t imported_uid = die.GetAttributeValueAsReference(DW_AT_import, DW_INVALID_OFFSET);

 }
 
 clang::BlockDecl *
 DWARFASTParserClang::ResolveBlockDIE (const DWARFDIE &die)
 {
     if (die && die.Tag() == DW_TAG_lexical_block)
     {
         clang::BlockDecl *decl = llvm::cast_or_null<clang::BlockDecl>(m_die_to_decl_ctx[die.GetDIE()]);
-        
         if (!decl)
         {
             DWARFDIE decl_context_die;
             clang::DeclContext *decl_context = GetClangDeclContextContainingDIE(die, &decl_context_die);
             decl = m_ast.CreateBlockDeclaration(decl_context);
 
             if (decl)
                 LinkDeclContextToDIE((clang::DeclContext *)decl, die);
else
                         if (log)
                             log->Printf ("warning: tried to unique lldb_private::Type from 0x%8.8x for 0x%8.8x, but none was found", src_die.GetOffset(), dst_die.GetOffset());
                     }
                 }
                 else
                 {
                     if (log)
                         log->Printf ("warning: couldn't find a match for 0x%8.8x", dst_die.GetOffset());
-                    
                     failures.Append(dst_die);
                 }
             }
         }
     }
-    
     const uint32_t src_size_artificial = src_name_to_die_artificial.GetSize ();
     const uint32_t dst_size_artificial = dst_name_to_die_artificial.GetSize ();
-    
     if (src_size_artificial && dst_size_artificial)
     {
         dst_name_to_die_artificial.Sort();
-        
         for (idx = 0; idx < src_size_artificial; ++idx)
         {
             const char *src_name_artificial = src_name_to_die_artificial.GetCStringAtIndex(idx);
             src_die = src_name_to_die_artificial.GetValueAtIndexUnchecked (idx);
             dst_die = dst_name_to_die_artificial.Find(src_name_artificial, DWARFDIE());
-            
             if (dst_die)
             {
                 // Both classes have the artificial types, link them
                 clang::DeclContext *src_decl_ctx = src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
                 if (src_decl_ctx)
                 {
                     if (log)
                         log->Printf ("uniquing decl context %p from 0x%8.8x for 0x%8.8x",
                                      static_cast<void*>(src_decl_ctx),
                                      src_die.GetOffset(), dst_die.GetOffset());
                     dst_dwarf_ast_parser->LinkDeclContextToDIE (src_decl_ctx, dst_die);
                 }
                 else
                 {
                     if (log)
                         log->Printf ("warning: tried to unique decl context from 0x%8.8x for 0x%8.8x, but none was found", src_die.GetOffset(), dst_die.GetOffset());
                 }
-                
                 Type *src_child_type = dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
                 if (src_child_type)
                 {
                     if (log)
                         log->Printf ("uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x",
                                      static_cast<void*>(src_child_type),
                                      src_child_type->GetID(),
                                      src_die.GetOffset(), dst_die.GetOffset());
                     dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;
                 }
                 else
                 {
                     if (log)
                         log->Printf ("warning: tried to unique lldb_private::Type from 0x%8.8x for 0x%8.8x, but none was found", src_die.GetOffset(), dst_die.GetOffset());
                 }
             }
         }
     }
-    
     if (dst_size_artificial)
     {
         for (idx = 0; idx < dst_size_artificial; ++idx)
         {
             const char *dst_name_artificial = dst_name_to_die_artificial.GetCStringAtIndex(idx);
             dst_die = dst_name_to_die_artificial.GetValueAtIndexUnchecked (idx);
             if (log)
                 log->Printf ("warning: need to create artificial method for 0x%8.8x for method '%s'", dst_die.GetOffset(), dst_name_artificial);
-            
             failures.Append(dst_die);
         }
     }
-    
     return (failures.Size() != 0);
 }
 
 
 bool
 DWARFASTParserClang::LayoutRecordType(const clang::RecordDecl *record_decl,
                                       uint64_t &bit_size,
                                       uint64_t &alignment,