[LLDB][NativePDB] Check for missing type info to avoid crash.

[zequanwu]

Summary

NativePDB often assumes that all debug info are available.
This is one step to make it more pervasive.

[rnk]

lgtm

lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

if (parent_iter == m_parent_types.end()) {
     return {context, uname};
   }
 
   // Otherwise, all we need to do is get the parent type of this type and
   // recurse into our lazy type creation / AST reconstruction logic to get an
   // LLDB TypeSP for the parent.  This will cause the AST to automatically get
   // the right DeclContext created for any parent.
   clang::QualType parent_qt = GetOrCreateType(parent_iter->second);
+  if (parent_qt.isNull())
+    return {nullptr, ""};
 
   context = clang::TagDecl::castToDeclContext(parent_qt->getAsTagDecl());
   return {context, uname};
 }
 
 void PdbAstBuilder::BuildParentMap() {
   LazyRandomTypeCollection &types = m_index.tpi().typeCollection();
 
llvm::Optional<CompilerDecl> PdbAstBuilder::GetOrCreateDeclForUid(PdbSymUid uid) {
 
   clang::Decl *result = nullptr;
   switch (uid.kind()) {
   case PdbSymUidKind::CompilandSym:
     result = GetOrCreateSymbolForId(uid.asCompilandSym());
     break;
   case PdbSymUidKind::Type: {
     clang::QualType qt = GetOrCreateType(uid.asTypeSym());
+    if (qt.isNull())
+      return llvm::None;
     if (auto *tag = qt->getAsTagDecl()) {
       result = tag;
       break;
     }
     return llvm::None;
   }
   default:
     return llvm::None;
if (specs.empty())
     return {context, std::string(name)};
 
   llvm::StringRef scope_name = specs.back().GetFullName();
 
   // It might be a class name, try that first.
   std::vector<TypeIndex> types = m_index.tpi().findRecordsByName(scope_name);
   while (!types.empty()) {
     clang::QualType qt = GetOrCreateType(types.back());
+    if (qt.isNull())
+      continue;
     clang::TagDecl *tag = qt->getAsTagDecl();
     if (tag)
       return {clang::TagDecl::castToDeclContext(tag), std::string(uname)};
     types.pop_back();
   }
 
   // If that fails, treat it as a series of namespaces.
   for (const MSVCUndecoratedNameSpecifier &spec : specs) {
if (!name_components.empty()) {
     // Render the current list of scope nodes as a fully qualified name, and
     // look it up in the debug info as a type name.  If we find something,
     // this is a type (which may itself be prefixed by a namespace).  If we
     // don't, this is a list of namespaces.
     std::string qname = RenderScopeList(name_components);
     std::vector<TypeIndex> matches = m_index.tpi().findRecordsByName(qname);
     while (!matches.empty()) {
       clang::QualType qt = GetOrCreateType(matches.back());
+      if (qt.isNull())
+        continue;
       clang::TagDecl *tag = qt->getAsTagDecl();
       if (tag)
         return clang::TagDecl::castToDeclContext(tag);
       matches.pop_back();
     }
   }
 
   // It's not a type.  It must be a series of namespaces.
clang::DeclContext *PdbAstBuilder::GetParentDeclContext(PdbSymUid uid) {
   }
   default:
     break;
   }
   return FromCompilerDeclContext(GetTranslationUnitDecl());
 }
 
 bool PdbAstBuilder::CompleteType(clang::QualType qt) {
+  if (qt.isNull())
+    return false;
   clang::TagDecl *tag = qt->getAsTagDecl();
   if (!tag)
     return false;
 
   return CompleteTagDecl(*tag);
 }
 
 bool PdbAstBuilder::CompleteTagDecl(clang::TagDecl &tag) {

 }
 
 clang::QualType PdbAstBuilder::CreateSimpleType(TypeIndex ti) {
   if (ti == TypeIndex::NullptrT())
     return GetBasicType(lldb::eBasicTypeNullPtr);
 
   if (ti.getSimpleMode() != SimpleTypeMode::Direct) {
     clang::QualType direct_type = GetOrCreateType(ti.makeDirect());
+    if (direct_type.isNull())
+      return {};
     return m_clang.getASTContext().getPointerType(direct_type);
   }
 
   if (ti.getSimpleKind() == SimpleTypeKind::NotTranslated)
     return {};
 
   lldb::BasicType bt = GetCompilerTypeForSimpleKind(ti.getSimpleKind());
   if (bt == lldb::eBasicTypeInvalid)
     return {};
 
   return GetBasicType(bt);
 }
 
 clang::QualType PdbAstBuilder::CreatePointerType(const PointerRecord &pointer) {
   clang::QualType pointee_type = GetOrCreateType(pointer.ReferentType);
 
   // This can happen for pointers to LF_VTSHAPE records, which we shouldn't
   // create in the AST.
   if (pointee_type.isNull())
     return {};
 
   if (pointer.isPointerToMember()) {
     MemberPointerInfo mpi = pointer.getMemberInfo();
     clang::QualType class_type = GetOrCreateType(mpi.ContainingType);
-
+    if (class_type.isNull())
+      return {};
     return m_clang.getASTContext().getMemberPointerType(
         pointee_type, class_type.getTypePtr());
   }
 
   clang::QualType pointer_type;
   if (pointer.getMode() == PointerMode::LValueReference)
     pointer_type = m_clang.getASTContext().getLValueReferenceType(pointee_type);
   else if (pointer.getMode() == PointerMode::RValueReference)
PdbAstBuilder::CreateModifierType(const ModifierRecord &modifier) {
   return unmodified_type;
 }
 
 clang::QualType PdbAstBuilder::CreateRecordType(PdbTypeSymId id,
                                                 const TagRecord &record) {
   clang::DeclContext *context = nullptr;
   std::string uname;
   std::tie(context, uname) = CreateDeclInfoForType(record, id.index);
+  if (!context)
+    return {};
+
   clang::TagTypeKind ttk = TranslateUdtKind(record);
   lldb::AccessType access =
       (ttk == clang::TTK_Class) ? lldb::eAccessPrivate : lldb::eAccessPublic;
 
   ClangASTMetadata metadata;
   metadata.SetUserID(toOpaqueUid(id));
   metadata.SetIsDynamicCXXType(false);
 
PdbAstBuilder::GetOrCreateBlockDecl(PdbCompilandSymId block_id) {
 
   return block_decl;
 }
 
 clang::VarDecl *PdbAstBuilder::CreateVariableDecl(PdbSymUid uid, CVSymbol sym,
                                                   clang::DeclContext &scope) {
   VariableInfo var_info = GetVariableNameInfo(sym);
   clang::QualType qt = GetOrCreateType(var_info.type);
+  if (qt.isNull())
+    return nullptr;
 
   clang::VarDecl *var_decl = m_clang.CreateVariableDeclaration(
       &scope, OptionalClangModuleID(), var_info.name.str().c_str(), qt);
 
   m_uid_to_decl[toOpaqueUid(uid)] = var_decl;
   DeclStatus status;
   status.resolved = true;
   status.uid = toOpaqueUid(uid);
PdbAstBuilder::GetOrCreateTypedefDecl(PdbGlobalSymId id) {
   CVSymbol sym = m_index.ReadSymbolRecord(id);
   lldbassert(sym.kind() == S_UDT);
   UDTSym udt = llvm::cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));
 
   clang::DeclContext *scope = GetParentDeclContext(id);
 
   PdbTypeSymId real_type_id{udt.Type, false};
   clang::QualType qt = GetOrCreateType(real_type_id);
+  if (qt.isNull())
+    return nullptr;
 
   std::string uname = std::string(DropNameScope(udt.Name));
 
   CompilerType ct = ToCompilerType(qt).CreateTypedef(
       uname.c_str(), ToCompilerDeclContext(*scope), 0);
   clang::TypedefNameDecl *tnd = m_clang.GetAsTypedefDecl(ct);
   DeclStatus status;
   status.resolved = true;
llvm::cantFail(
         TypeDeserializer::deserializeAs<MemberFunctionRecord>(cvt, mfr));
     return CreateFunctionType(mfr.ArgumentList, mfr.ReturnType, mfr.CallConv);
   }
 
   return {};
 }
 
 clang::QualType PdbAstBuilder::GetOrCreateType(PdbTypeSymId type) {
+  if (type.index.isNoneType())
+    return {};
+
   lldb::user_id_t uid = toOpaqueUid(type);
   auto iter = m_uid_to_type.find(uid);
   if (iter != m_uid_to_type.end())
     return iter->second;
 
   PdbTypeSymId best_type = GetBestPossibleDecl(type, m_index.tpi());
 
   clang::QualType qt;
   if (best_type.index != type.index) {
     // This is a forward decl.  Call GetOrCreate on the full decl, then map the
     // forward decl id to the full decl QualType.
     clang::QualType qt = GetOrCreateType(best_type);
+    if (qt.isNull())
+      return {};
     m_uid_to_type[toOpaqueUid(type)] = qt;
     return qt;
   }
 
   // This is either a full decl, or a forward decl with no matching full decl
   // in the debug info.
   qt = CreateType(type);
+  if (qt.isNull())
+    return {};
+
   m_uid_to_type[toOpaqueUid(type)] = qt;
   if (IsTagRecord(type, m_index.tpi())) {
     clang::TagDecl *tag = qt->getAsTagDecl();
     lldbassert(m_decl_to_status.count(tag) == 0);
 
     DeclStatus &status = m_decl_to_status[tag];
     status.uid = uid;
     status.resolved = false;
case S_INLINESITE2:
       // contain information about all parameters.
       return;
     default:
       continue;
     }
 
     PdbCompilandSymId param_uid(func_id.modi, record_offset);
     clang::QualType qt = GetOrCreateType(param_type);
+    if (qt.isNull())
+      return;
 
     CompilerType param_type_ct = m_clang.GetType(qt);
     clang::ParmVarDecl *param = m_clang.CreateParameterDeclaration(
         &function_decl, OptionalClangModuleID(), param_name.str().c_str(),
         param_type_ct, clang::SC_None, true);
     lldbassert(m_uid_to_decl.count(toOpaqueUid(param_uid)) == 0);
 
     m_uid_to_decl[toOpaqueUid(param_uid)] = param;
     params.push_back(param);
     ++i;
   }
 
   if (!params.empty() && params.size() == param_count)
     m_clang.SetFunctionParameters(&function_decl, params);
 }
 
 clang::QualType PdbAstBuilder::CreateEnumType(PdbTypeSymId id,
                                               const EnumRecord &er) {
   clang::DeclContext *decl_context = nullptr;
   std::string uname;
   std::tie(decl_context, uname) = CreateDeclInfoForType(er, id.index);
+  if (!decl_context)
+    return {};
+
   clang::QualType underlying_type = GetOrCreateType(er.UnderlyingType);
+  if (underlying_type.isNull())
+    return {};
 
   Declaration declaration;
   CompilerType enum_ct = m_clang.CreateEnumerationType(
       uname, decl_context, OptionalClangModuleID(), declaration,
       ToCompilerType(underlying_type), er.isScoped());
 
   TypeSystemClang::StartTagDeclarationDefinition(enum_ct);
   TypeSystemClang::SetHasExternalStorage(enum_ct.GetOpaqueQualType(), true);
 
   return clang::QualType::getFromOpaquePtr(enum_ct.GetOpaqueQualType());
 }
 
 clang::QualType PdbAstBuilder::CreateArrayType(const ArrayRecord &ar) {
   clang::QualType element_type = GetOrCreateType(ar.ElementType);
 
   uint64_t element_size = GetSizeOfType({ar.ElementType}, m_index.tpi());
-  if (element_size == 0)
+  if (element_type.isNull() || element_size == 0)
     return {};
   uint64_t element_count = ar.Size / element_size;
 
   CompilerType array_ct = m_clang.CreateArrayType(ToCompilerType(element_type),
                                                   element_count, false);
   return clang::QualType::getFromOpaquePtr(array_ct.GetOpaqueQualType());
 }
 
clang::QualType PdbAstBuilder::CreateFunctionType(
   if (is_variadic)
     arg_indices = arg_indices.drop_back();
 
   std::vector<CompilerType> arg_types;
   arg_types.reserve(arg_indices.size());
 
   for (TypeIndex arg_index : arg_indices) {
     clang::QualType arg_type = GetOrCreateType(arg_index);
+    if (arg_type.isNull())
+      continue;
     arg_types.push_back(ToCompilerType(arg_type));
   }
 
   clang::QualType return_type = GetOrCreateType(return_type_idx);
+  if (return_type.isNull())
+    return {};
 
   llvm::Optional<clang::CallingConv> cc =
       TranslateCallingConvention(calling_convention);
   if (!cc)
     return {};
 
   CompilerType return_ct = ToCompilerType(return_type);
   CompilerType func_sig_ast_type = m_clang.CreateFunctionType(
for (const CVType &cvt : m_index.tpi().typeArray()) {
     }
 
     // Call CreateDeclInfoForType unconditionally so that the namespace info
     // gets created.  But only call CreateRecordType if the namespace name
     // matches.
     clang::DeclContext *context = nullptr;
     std::string uname;
     std::tie(context, uname) = CreateDeclInfoForType(tag.asTag(), tid.index);
-    if (!context->isNamespace())
+    if (!context || !context->isNamespace())
       continue;
 
     clang::NamespaceDecl *ns = llvm::cast<clang::NamespaceDecl>(context);
     std::string actual_ns = ns->getQualifiedNameAsString();
     if (llvm::StringRef(actual_ns).startswith(*parent)) {
       clang::QualType qt = GetOrCreateType(tid);
       CompleteType(qt);
       continue;

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

else if (*expected_full_ti != type_id.index) {
         return result;
       }
     }
   }
 
   PdbTypeSymId best_decl_id = full_decl_uid ? *full_decl_uid : type_id;
 
   clang::QualType qt = m_ast->GetOrCreateType(best_decl_id);
+  if (qt.isNull())
+    return nullptr;
 
   TypeSP result = CreateType(best_decl_id, m_ast->ToCompilerType(qt));
   if (!result)
     return nullptr;
 
   uint64_t best_uid = toOpaqueUid(best_decl_id);
   m_types[best_uid] = result;
   // If we had both a forward decl and a full decl, make both point to the new

lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.cpp

clang::QualType UdtRecordCompleter::AddBaseClassForTypeIndex(
   clang::QualType qt = m_ast_builder.GetOrCreateType(type_id);
 
   CVType udt_cvt = m_index.tpi().getType(ti);
 
   std::unique_ptr<clang::CXXBaseSpecifier> base_spec =
       m_ast_builder.clang().CreateBaseClassSpecifier(
           qt.getAsOpaquePtr(), TranslateMemberAccess(access),
           vtable_idx.hasValue(), udt_cvt.kind() == LF_CLASS);
-  lldbassert(base_spec);
+  if (!base_spec)
+    return {};
 
   m_bases.push_back(
       std::make_pair(vtable_idx.getValueOr(0), std::move(base_spec)));
 
   return qt;
 }
 
 void UdtRecordCompleter::AddMethod(llvm::StringRef name, TypeIndex type_idx,
                                    MemberAccess access, MethodOptions options,
                                    MemberAttributes attrs) {
   clang::QualType method_qt =
       m_ast_builder.GetOrCreateType(PdbTypeSymId(type_idx));
+  if (method_qt.isNull())
+    return;
   m_ast_builder.CompleteType(method_qt);
   CompilerType method_ct = m_ast_builder.ToCompilerType(method_qt);
   lldb::opaque_compiler_type_t derived_opaque_ty = m_derived_ct.GetOpaqueQualType();
   auto iter = m_cxx_record_map.find(derived_opaque_ty);
   if (iter != m_cxx_record_map.end()) {
     if (iter->getSecond().contains({name, method_ct})) {
       return;
     }
void UdtRecordCompleter::AddMethod(llvm::StringRef name, TypeIndex type_idx,
   m_cxx_record_map[derived_opaque_ty].insert({name, method_ct});
 }
 
 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
                                            BaseClassRecord &base) {
   clang::QualType base_qt =
       AddBaseClassForTypeIndex(base.Type, base.getAccess());
 
+  if (base_qt.isNull())
+    return llvm::Error::success();
   auto decl =
       m_ast_builder.clang().GetAsCXXRecordDecl(base_qt.getAsOpaquePtr());
   lldbassert(decl);
 
   auto offset = clang::CharUnits::fromQuantity(base.getBaseOffset());
   m_layout.base_offsets.insert(std::make_pair(decl, offset));
 
   return llvm::Error::success();
Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
                                            VFPtrRecord &vfptr) {
   return Error::success();
 }
 
 Error UdtRecordCompleter::visitKnownMember(
     CVMemberRecord &cvr, StaticDataMemberRecord &static_data_member) {
   clang::QualType member_type =
       m_ast_builder.GetOrCreateType(PdbTypeSymId(static_data_member.Type));
+  if (member_type.isNull())
+    return llvm::Error::success();
 
   CompilerType member_ct = m_ast_builder.ToCompilerType(member_type);
 
   lldb::AccessType access =
       TranslateMemberAccess(static_data_member.getAccess());
   auto decl = TypeSystemClang::AddVariableToRecordType(
       m_derived_ct, static_data_member.Name, member_ct, access);
 
if (cvt.kind() == LF_BITFIELD) {
       llvm::cantFail(TypeDeserializer::deserializeAs<BitFieldRecord>(cvt, bfr));
       offset += bfr.BitOffset;
       bitfield_width = bfr.BitSize;
       ti = bfr.Type;
     }
   }
 
   clang::QualType member_qt = m_ast_builder.GetOrCreateType(PdbTypeSymId(ti));
+  if (member_qt.isNull())
+    return Error::success();
   m_ast_builder.CompleteType(member_qt);
 
   lldb::AccessType access = TranslateMemberAccess(data_member.getAccess());
 
   clang::FieldDecl *decl = TypeSystemClang::AddFieldToRecordType(
       m_derived_ct, data_member.Name, m_ast_builder.ToCompilerType(member_qt),
       access, bitfield_width);
   // FIXME: Add a PdbSymUid namespace for field list members and update

lldb/test/Shell/SymbolFile/NativePDB/missing-type.s

+# clang-format off
+# REQUIRES: lld, x86
+
+# Test when type index is missing in FieldList.
+# RUN: llvm-mc -triple=x86_64-windows-msvc --filetype=obj %s > %t.obj
+# RUN: lld-link /debug:full /nodefaultlib /entry:main %t.obj /out:%t.exe /base:0x140000000
+# RUN: lldb-test symbols --find=type --name=S %t.exe | FileCheck %s
+
+# CHECK:      name = "S", size = 4, compiler_type = {{.*}} struct S {
+# CHECK-NEXT: }
+
+
+
+  .text
+  .def  @feat.00;
+  .scl  3;
+  .type 0;
+  .endef
+  .globl  @feat.00
+.set @feat.00, 0
+  .intel_syntax noprefix
+  .file "a.cpp"
+  .def  main;
+  .scl  2;
+  .type 32;
+  .endef
+  .globl  main                            # -- Begin function main
+  .p2align  4, 0x90
+main:                                   # @main
+.seh_proc main
+# %bb.0:                                # %entry
+  sub rsp, 24
+  .seh_stackalloc 24
+  .seh_endprologue
+  mov dword ptr [rsp + 20], 0
+  mov qword ptr [rsp + 8], rdx
+  mov dword ptr [rsp + 4], ecx
+.Ltmp0:
+  mov eax, dword ptr [rsp]
+  add rsp, 24
+  ret
+.Ltmp1:
+.Lfunc_end0:
+  .seh_endproc
+                                        # -- End function
+  .section  .drectve,"yn"
+.Ltmp25:
+  .section  .debug$T,"dr"
+  .p2align  2
+  .long 4                               # Debug section magic
+  # Pointer (0x1000)
+  .short  0xa                             # Record length
+  .short  0x1002                          # Record kind: LF_POINTER
+  .long 0x670                           # PointeeType: char*
+  .long 0x1000c                         # Attrs: [ Type: Near64, Mode: Pointer, SizeOf: 8 ]
+  # ArgList (0x1001)
+  .short  0xe                             # Record length
+  .short  0x1201                          # Record kind: LF_ARGLIST
+  .long 0x2                             # NumArgs
+  .long 0x74                            # Argument: int
+  .long 0x1000                          # Argument: char**
+  # Procedure (0x1002)
+  .short  0xe                             # Record length
+  .short  0x1008                          # Record kind: LF_PROCEDURE
+  .long 0x74                            # ReturnType: int
+  .byte 0x0                             # CallingConvention: NearC
+  .byte 0x0                             # FunctionOptions
+  .short  0x2                             # NumParameters
+  .long 0x1001                          # ArgListType: (int, char**)
+  # FuncId (0x1003)
+  .short  0x12                            # Record length
+  .short  0x1601                          # Record kind: LF_FUNC_ID
+  .long 0x0                             # ParentScope
+  .long 0x1002                          # FunctionType: int (int, char**)
+  .asciz  "main"                          # Name
+  .byte 243
+  .byte 242
+  .byte 241
+  # Struct (0x1004)
+  .short  0x1e                            # Record length
+  .short  0x1505                          # Record kind: LF_STRUCTURE
+  .short  0x0                             # MemberCount
+  .short  0x280                           # Properties ( ForwardReference (0x80) | HasUniqueName (0x200) )
+  .long 0x0                             # FieldList
+  .long 0x0                             # DerivedFrom
+  .long 0x0                             # VShape
+  .short  0x0                             # SizeOf
+  .asciz  "S"                             # Name
+  .asciz  ".?AUS@@"                       # LinkageName
+  # FieldList (0x1005)
+  .short  0xe                             # Record length
+  .short  0x1203                          # Record kind: LF_FIELDLIST
+  .short  0x150d                          # Member kind: DataMember ( LF_MEMBER )
+  .short  0x3                             # Attrs: Public
+  .long 0                               # Type. It's intentionally written as 0 for testing.
+  .short  0x0                             # FieldOffset
+  .asciz  "x"                             # Name
+  # Struct (0x1006)
+  .short  0x1e                            # Record length
+  .short  0x1505                          # Record kind: LF_STRUCTURE
+  .short  0x1                             # MemberCount
+  .short  0x200                           # Properties ( HasUniqueName (0x200) )
+  .long 0x1005                          # FieldList: <field list>
+  .long 0x0                             # DerivedFrom
+  .long 0x0                             # VShape
+  .short  0x4                             # SizeOf
+  .asciz  "S"                             # Name
+  .asciz  ".?AUS@@"                       # LinkageName