1 //===-- DWARFASTParserClang.h -----------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef SymbolFileDWARF_DWARFASTParserClang_h_ 10 #define SymbolFileDWARF_DWARFASTParserClang_h_ 11 12 #include "clang/AST/CharUnits.h" 13 #include "llvm/ADT/DenseMap.h" 14 #include "llvm/ADT/SmallPtrSet.h" 15 #include "llvm/ADT/SmallVector.h" 16 17 #include "DWARFASTParser.h" 18 #include "DWARFDIE.h" 19 #include "DWARFDefines.h" 20 #include "DWARFFormValue.h" 21 #include "LogChannelDWARF.h" 22 #include "lldb/Core/ClangForward.h" 23 #include "lldb/Core/PluginInterface.h" 24 #include "lldb/Symbol/ClangASTContext.h" 25 #include "lldb/Symbol/ClangASTImporter.h" 26 27 #include <vector> 28 29 namespace lldb_private { 30 class CompileUnit; 31 } 32 class DWARFDebugInfoEntry; 33 class SymbolFileDWARF; 34 35 struct ParsedDWARFTypeAttributes; 36 37 class DWARFASTParserClang : public DWARFASTParser { 38 public: 39 DWARFASTParserClang(lldb_private::ClangASTContext &ast); 40 41 ~DWARFASTParserClang() override; 42 43 // DWARFASTParser interface. 44 lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc, 45 const DWARFDIE &die, 46 bool *type_is_new_ptr) override; 47 48 lldb_private::Function * 49 ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit, 50 const DWARFDIE &die) override; 51 52 bool 53 CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type, 54 lldb_private::CompilerType &compiler_type) override; 55 56 lldb_private::CompilerDecl 57 GetDeclForUIDFromDWARF(const DWARFDIE &die) override; 58 59 void EnsureAllDIEsInDeclContextHaveBeenParsed( 60 lldb_private::CompilerDeclContext decl_context) override; 61 62 lldb_private::CompilerDeclContext 63 GetDeclContextForUIDFromDWARF(const DWARFDIE &die) override; 64 65 lldb_private::CompilerDeclContext 66 GetDeclContextContainingUIDFromDWARF(const DWARFDIE &die) override; 67 68 lldb_private::ClangASTImporter &GetClangASTImporter(); 69 70 protected: 71 /// Protected typedefs and members. 72 /// @{ 73 class DelayedAddObjCClassProperty; 74 typedef std::vector<DelayedAddObjCClassProperty> DelayedPropertyList; 75 76 typedef llvm::SmallPtrSet<const DWARFDebugInfoEntry *, 4> DIEPointerSet; 77 typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *> 78 DIEToDeclContextMap; 79 typedef std::multimap<const clang::DeclContext *, const DWARFDIE> 80 DeclContextToDIEMap; 81 typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *> 82 DIEToDeclMap; 83 typedef llvm::DenseMap<const clang::Decl *, DIEPointerSet> DeclToDIEMap; 84 85 lldb_private::ClangASTContext &m_ast; 86 DIEToDeclMap m_die_to_decl; 87 DeclToDIEMap m_decl_to_die; 88 DIEToDeclContextMap m_die_to_decl_ctx; 89 DeclContextToDIEMap m_decl_ctx_to_die; 90 std::unique_ptr<lldb_private::ClangASTImporter> m_clang_ast_importer_up; 91 /// @} 92 93 clang::DeclContext *GetDeclContextForBlock(const DWARFDIE &die); 94 95 clang::BlockDecl *ResolveBlockDIE(const DWARFDIE &die); 96 97 clang::NamespaceDecl *ResolveNamespaceDIE(const DWARFDIE &die); 98 99 bool ParseTemplateDIE(const DWARFDIE &die, 100 lldb_private::ClangASTContext::TemplateParameterInfos 101 &template_param_infos); 102 bool ParseTemplateParameterInfos( 103 const DWARFDIE &parent_die, 104 lldb_private::ClangASTContext::TemplateParameterInfos 105 &template_param_infos); 106 107 bool ParseChildMembers( 108 const DWARFDIE &die, lldb_private::CompilerType &class_compiler_type, 109 const lldb::LanguageType class_language, 110 std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes, 111 std::vector<int> &member_accessibilities, 112 std::vector<DWARFDIE> &member_function_dies, 113 DelayedPropertyList &delayed_properties, 114 lldb::AccessType &default_accessibility, bool &is_a_class, 115 lldb_private::ClangASTImporter::LayoutInfo &layout_info); 116 117 size_t 118 ParseChildParameters(clang::DeclContext *containing_decl_ctx, 119 const DWARFDIE &parent_die, bool skip_artificial, 120 bool &is_static, bool &is_variadic, 121 bool &has_template_params, 122 std::vector<lldb_private::CompilerType> &function_args, 123 std::vector<clang::ParmVarDecl *> &function_param_decls, 124 unsigned &type_quals); 125 126 size_t ParseChildEnumerators(lldb_private::CompilerType &compiler_type, 127 bool is_signed, uint32_t enumerator_byte_size, 128 const DWARFDIE &parent_die); 129 130 /// Parse a structure, class, or union type DIE. 131 lldb::TypeSP ParseStructureLikeDIE(const lldb_private::SymbolContext &sc, 132 const DWARFDIE &die, 133 ParsedDWARFTypeAttributes &attrs); 134 135 lldb_private::Type *GetTypeForDIE(const DWARFDIE &die); 136 137 clang::Decl *GetClangDeclForDIE(const DWARFDIE &die); 138 139 clang::DeclContext *GetClangDeclContextForDIE(const DWARFDIE &die); 140 141 clang::DeclContext *GetClangDeclContextContainingDIE(const DWARFDIE &die, 142 DWARFDIE *decl_ctx_die); 143 144 bool CopyUniqueClassMethodTypes(const DWARFDIE &src_class_die, 145 const DWARFDIE &dst_class_die, 146 lldb_private::Type *class_type, 147 std::vector<DWARFDIE> &failures); 148 149 clang::DeclContext *GetCachedClangDeclContextForDIE(const DWARFDIE &die); 150 151 void LinkDeclContextToDIE(clang::DeclContext *decl_ctx, const DWARFDIE &die); 152 153 void LinkDeclToDIE(clang::Decl *decl, const DWARFDIE &die); 154 155 /// If \p type_sp is valid, calculate and set its symbol context scope, and 156 /// update the type list for its backing symbol file. 157 /// 158 /// Returns \p type_sp. 159 lldb::TypeSP 160 UpdateSymbolContextScopeForType(const lldb_private::SymbolContext &sc, 161 const DWARFDIE &die, lldb::TypeSP type_sp); 162 163 /// Follow Clang Module Skeleton CU references to find a type definition. 164 lldb::TypeSP ParseTypeFromClangModule(const lldb_private::SymbolContext &sc, 165 const DWARFDIE &die, 166 lldb_private::Log *log); 167 168 // Return true if this type is a declaration to a type in an external 169 // module. 170 lldb::ModuleSP GetModuleForType(const DWARFDIE &die); 171 172 private: 173 struct FieldInfo { 174 uint64_t bit_size = 0; 175 uint64_t bit_offset = 0; 176 bool is_bitfield = false; 177 178 FieldInfo() = default; 179 180 void SetIsBitfield(bool flag) { is_bitfield = flag; } 181 bool IsBitfield() { return is_bitfield; } 182 183 bool NextBitfieldOffsetIsValid(const uint64_t next_bit_offset) const { 184 // Any subsequent bitfields must not overlap and must be at a higher 185 // bit offset than any previous bitfield + size. 186 return (bit_size + bit_offset) <= next_bit_offset; 187 } 188 }; 189 190 void 191 ParseSingleMember(const DWARFDIE &die, const DWARFDIE &parent_die, 192 lldb_private::CompilerType &class_clang_type, 193 const lldb::LanguageType class_language, 194 std::vector<int> &member_accessibilities, 195 lldb::AccessType &default_accessibility, 196 DelayedPropertyList &delayed_properties, 197 lldb_private::ClangASTImporter::LayoutInfo &layout_info, 198 FieldInfo &last_field_info); 199 200 bool CompleteRecordType(const DWARFDIE &die, lldb_private::Type *type, 201 lldb_private::CompilerType &clang_type); 202 bool CompleteEnumType(const DWARFDIE &die, lldb_private::Type *type, 203 lldb_private::CompilerType &clang_type); 204 205 lldb::TypeSP ParseTypeModifier(const lldb_private::SymbolContext &sc, 206 const DWARFDIE &die, 207 ParsedDWARFTypeAttributes &attrs); 208 lldb::TypeSP ParseEnum(const lldb_private::SymbolContext &sc, 209 const DWARFDIE &die, ParsedDWARFTypeAttributes &attrs); 210 lldb::TypeSP ParseSubroutine(const DWARFDIE &die, 211 ParsedDWARFTypeAttributes &attrs); 212 // FIXME: attrs should be passed as a const reference. 213 lldb::TypeSP ParseArrayType(const DWARFDIE &die, 214 ParsedDWARFTypeAttributes &attrs); 215 lldb::TypeSP ParsePointerToMemberType(const DWARFDIE &die, 216 const ParsedDWARFTypeAttributes &attrs); 217 }; 218 219 /// Parsed form of all attributes that are relevant for type reconstruction. 220 /// Some attributes are relevant for all kinds of types (declaration), while 221 /// others are only meaningful to a specific type (is_virtual) 222 struct ParsedDWARFTypeAttributes { 223 explicit ParsedDWARFTypeAttributes(const DWARFDIE &die); 224 225 lldb::AccessType accessibility = lldb::eAccessNone; 226 bool is_artificial = false; 227 bool is_complete_objc_class = false; 228 bool is_explicit = false; 229 bool is_forward_declaration = false; 230 bool is_inline = false; 231 bool is_scoped_enum = false; 232 bool is_vector = false; 233 bool is_virtual = false; 234 bool is_objc_direct_call = false; 235 bool exports_symbols = false; 236 clang::StorageClass storage = clang::SC_None; 237 const char *mangled_name = nullptr; 238 lldb_private::ConstString name; 239 lldb_private::Declaration decl; 240 DWARFDIE object_pointer; 241 DWARFFormValue abstract_origin; 242 DWARFFormValue containing_type; 243 DWARFFormValue signature; 244 DWARFFormValue specification; 245 DWARFFormValue type; 246 lldb::LanguageType class_language = lldb::eLanguageTypeUnknown; 247 llvm::Optional<uint64_t> byte_size; 248 size_t calling_convention = llvm::dwarf::DW_CC_normal; 249 uint32_t bit_stride = 0; 250 uint32_t byte_stride = 0; 251 uint32_t encoding = 0; 252 }; 253 254 #endif // SymbolFileDWARF_DWARFASTParserClang_h_ 255