6e3b0cc2fb
Summary: This commit renames ClangASTContext to TypeSystemClang to better reflect what this class is actually supposed to do (implement the TypeSystem interface for Clang). It also gets rid of the very confusing situation that we have both a `clang::ASTContext` and a `ClangASTContext` in clang (which sometimes causes Clang people to think I'm fiddling with Clang's ASTContext when I'm actually just doing LLDB work). I also have plans to potentially have multiple clang::ASTContext instances associated with one ClangASTContext so the ASTContext naming will then become even more confusing to people. Reviewers: #lldb, aprantl, shafik, clayborg, labath, JDevlieghere, davide, espindola, jdoerfert, xiaobai Reviewed By: clayborg, labath, xiaobai Subscribers: wuzish, emaste, nemanjai, mgorny, kbarton, MaskRay, arphaman, jfb, usaxena95, jingham, xiaobai, abidh, JDevlieghere, lldb-commits Tags: #lldb Differential Revision: https://reviews.llvm.org/D72684
268 lines
10 KiB
C++
268 lines
10 KiB
C++
//===-- DWARFASTParserClang.h -----------------------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SymbolFileDWARF_DWARFASTParserClang_h_
|
|
#define SymbolFileDWARF_DWARFASTParserClang_h_
|
|
|
|
#include "clang/AST/CharUnits.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
|
|
#include "DWARFASTParser.h"
|
|
#include "DWARFDIE.h"
|
|
#include "DWARFDefines.h"
|
|
#include "DWARFFormValue.h"
|
|
#include "LogChannelDWARF.h"
|
|
#include "lldb/Core/ClangForward.h"
|
|
#include "lldb/Core/PluginInterface.h"
|
|
#include "lldb/Symbol/TypeSystemClang.h"
|
|
#include "lldb/Symbol/ClangASTImporter.h"
|
|
|
|
#include <vector>
|
|
|
|
namespace lldb_private {
|
|
class CompileUnit;
|
|
}
|
|
class DWARFDebugInfoEntry;
|
|
class SymbolFileDWARF;
|
|
|
|
struct ParsedDWARFTypeAttributes;
|
|
|
|
class DWARFASTParserClang : public DWARFASTParser {
|
|
public:
|
|
DWARFASTParserClang(lldb_private::TypeSystemClang &ast);
|
|
|
|
~DWARFASTParserClang() override;
|
|
|
|
// DWARFASTParser interface.
|
|
lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
|
|
const DWARFDIE &die,
|
|
bool *type_is_new_ptr) override;
|
|
|
|
lldb_private::Function *
|
|
ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit,
|
|
const DWARFDIE &die) override;
|
|
|
|
bool
|
|
CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
|
|
lldb_private::CompilerType &compiler_type) override;
|
|
|
|
lldb_private::CompilerDecl
|
|
GetDeclForUIDFromDWARF(const DWARFDIE &die) override;
|
|
|
|
void EnsureAllDIEsInDeclContextHaveBeenParsed(
|
|
lldb_private::CompilerDeclContext decl_context) override;
|
|
|
|
lldb_private::CompilerDeclContext
|
|
GetDeclContextForUIDFromDWARF(const DWARFDIE &die) override;
|
|
|
|
lldb_private::CompilerDeclContext
|
|
GetDeclContextContainingUIDFromDWARF(const DWARFDIE &die) override;
|
|
|
|
lldb_private::ClangASTImporter &GetClangASTImporter();
|
|
|
|
protected:
|
|
/// Protected typedefs and members.
|
|
/// @{
|
|
class DelayedAddObjCClassProperty;
|
|
typedef std::vector<DelayedAddObjCClassProperty> DelayedPropertyList;
|
|
|
|
typedef llvm::SmallPtrSet<const DWARFDebugInfoEntry *, 4> DIEPointerSet;
|
|
typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *>
|
|
DIEToDeclContextMap;
|
|
typedef std::multimap<const clang::DeclContext *, const DWARFDIE>
|
|
DeclContextToDIEMap;
|
|
typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *>
|
|
DIEToDeclMap;
|
|
typedef llvm::DenseMap<const clang::Decl *, DIEPointerSet> DeclToDIEMap;
|
|
|
|
lldb_private::TypeSystemClang &m_ast;
|
|
DIEToDeclMap m_die_to_decl;
|
|
DeclToDIEMap m_decl_to_die;
|
|
DIEToDeclContextMap m_die_to_decl_ctx;
|
|
DeclContextToDIEMap m_decl_ctx_to_die;
|
|
std::unique_ptr<lldb_private::ClangASTImporter> m_clang_ast_importer_up;
|
|
/// @}
|
|
|
|
clang::DeclContext *GetDeclContextForBlock(const DWARFDIE &die);
|
|
|
|
clang::BlockDecl *ResolveBlockDIE(const DWARFDIE &die);
|
|
|
|
clang::NamespaceDecl *ResolveNamespaceDIE(const DWARFDIE &die);
|
|
|
|
bool ParseTemplateDIE(const DWARFDIE &die,
|
|
lldb_private::TypeSystemClang::TemplateParameterInfos
|
|
&template_param_infos);
|
|
bool ParseTemplateParameterInfos(
|
|
const DWARFDIE &parent_die,
|
|
lldb_private::TypeSystemClang::TemplateParameterInfos
|
|
&template_param_infos);
|
|
|
|
bool ParseChildMembers(
|
|
const DWARFDIE &die, lldb_private::CompilerType &class_compiler_type,
|
|
const lldb::LanguageType class_language,
|
|
std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
|
|
std::vector<int> &member_accessibilities,
|
|
std::vector<DWARFDIE> &member_function_dies,
|
|
DelayedPropertyList &delayed_properties,
|
|
lldb::AccessType &default_accessibility, bool &is_a_class,
|
|
lldb_private::ClangASTImporter::LayoutInfo &layout_info);
|
|
|
|
size_t
|
|
ParseChildParameters(clang::DeclContext *containing_decl_ctx,
|
|
const DWARFDIE &parent_die, bool skip_artificial,
|
|
bool &is_static, bool &is_variadic,
|
|
bool &has_template_params,
|
|
std::vector<lldb_private::CompilerType> &function_args,
|
|
std::vector<clang::ParmVarDecl *> &function_param_decls,
|
|
unsigned &type_quals);
|
|
|
|
size_t ParseChildEnumerators(lldb_private::CompilerType &compiler_type,
|
|
bool is_signed, uint32_t enumerator_byte_size,
|
|
const DWARFDIE &parent_die);
|
|
|
|
/// Parse a structure, class, or union type DIE.
|
|
lldb::TypeSP ParseStructureLikeDIE(const lldb_private::SymbolContext &sc,
|
|
const DWARFDIE &die,
|
|
ParsedDWARFTypeAttributes &attrs);
|
|
|
|
lldb_private::Type *GetTypeForDIE(const DWARFDIE &die);
|
|
|
|
clang::Decl *GetClangDeclForDIE(const DWARFDIE &die);
|
|
|
|
clang::DeclContext *GetClangDeclContextForDIE(const DWARFDIE &die);
|
|
|
|
clang::DeclContext *GetClangDeclContextContainingDIE(const DWARFDIE &die,
|
|
DWARFDIE *decl_ctx_die);
|
|
|
|
bool CopyUniqueClassMethodTypes(const DWARFDIE &src_class_die,
|
|
const DWARFDIE &dst_class_die,
|
|
lldb_private::Type *class_type,
|
|
std::vector<DWARFDIE> &failures);
|
|
|
|
clang::DeclContext *GetCachedClangDeclContextForDIE(const DWARFDIE &die);
|
|
|
|
void LinkDeclContextToDIE(clang::DeclContext *decl_ctx, const DWARFDIE &die);
|
|
|
|
void LinkDeclToDIE(clang::Decl *decl, const DWARFDIE &die);
|
|
|
|
/// If \p type_sp is valid, calculate and set its symbol context scope, and
|
|
/// update the type list for its backing symbol file.
|
|
///
|
|
/// Returns \p type_sp.
|
|
lldb::TypeSP
|
|
UpdateSymbolContextScopeForType(const lldb_private::SymbolContext &sc,
|
|
const DWARFDIE &die, lldb::TypeSP type_sp);
|
|
|
|
/// Follow Clang Module Skeleton CU references to find a type definition.
|
|
lldb::TypeSP ParseTypeFromClangModule(const lldb_private::SymbolContext &sc,
|
|
const DWARFDIE &die,
|
|
lldb_private::Log *log);
|
|
|
|
// Return true if this type is a declaration to a type in an external
|
|
// module.
|
|
lldb::ModuleSP GetModuleForType(const DWARFDIE &die);
|
|
|
|
private:
|
|
struct BitfieldInfo {
|
|
uint64_t bit_size;
|
|
uint64_t bit_offset;
|
|
|
|
BitfieldInfo()
|
|
: bit_size(LLDB_INVALID_ADDRESS), bit_offset(LLDB_INVALID_ADDRESS) {}
|
|
|
|
void Clear() {
|
|
bit_size = LLDB_INVALID_ADDRESS;
|
|
bit_offset = LLDB_INVALID_ADDRESS;
|
|
}
|
|
|
|
bool IsValid() const {
|
|
return (bit_size != LLDB_INVALID_ADDRESS) &&
|
|
(bit_offset != LLDB_INVALID_ADDRESS);
|
|
}
|
|
|
|
bool NextBitfieldOffsetIsValid(const uint64_t next_bit_offset) const {
|
|
if (IsValid()) {
|
|
// This bitfield info is valid, so any subsequent bitfields must not
|
|
// overlap and must be at a higher bit offset than any previous bitfield
|
|
// + size.
|
|
return (bit_size + bit_offset) <= next_bit_offset;
|
|
} else {
|
|
// If the this BitfieldInfo is not valid, then any offset isOK
|
|
return true;
|
|
}
|
|
}
|
|
};
|
|
|
|
void
|
|
ParseSingleMember(const DWARFDIE &die, const DWARFDIE &parent_die,
|
|
lldb_private::CompilerType &class_clang_type,
|
|
const lldb::LanguageType class_language,
|
|
std::vector<int> &member_accessibilities,
|
|
lldb::AccessType &default_accessibility,
|
|
DelayedPropertyList &delayed_properties,
|
|
lldb_private::ClangASTImporter::LayoutInfo &layout_info,
|
|
BitfieldInfo &last_field_info);
|
|
|
|
bool CompleteRecordType(const DWARFDIE &die, lldb_private::Type *type,
|
|
lldb_private::CompilerType &clang_type);
|
|
bool CompleteEnumType(const DWARFDIE &die, lldb_private::Type *type,
|
|
lldb_private::CompilerType &clang_type);
|
|
|
|
lldb::TypeSP ParseTypeModifier(const lldb_private::SymbolContext &sc,
|
|
const DWARFDIE &die,
|
|
ParsedDWARFTypeAttributes &attrs);
|
|
lldb::TypeSP ParseEnum(const lldb_private::SymbolContext &sc,
|
|
const DWARFDIE &die, ParsedDWARFTypeAttributes &attrs);
|
|
lldb::TypeSP ParseSubroutine(const DWARFDIE &die,
|
|
ParsedDWARFTypeAttributes &attrs);
|
|
// FIXME: attrs should be passed as a const reference.
|
|
lldb::TypeSP ParseArrayType(const DWARFDIE &die,
|
|
ParsedDWARFTypeAttributes &attrs);
|
|
lldb::TypeSP ParsePointerToMemberType(const DWARFDIE &die,
|
|
const ParsedDWARFTypeAttributes &attrs);
|
|
};
|
|
|
|
/// Parsed form of all attributes that are relevant for type reconstruction.
|
|
/// Some attributes are relevant for all kinds of types (declaration), while
|
|
/// others are only meaningful to a specific type (is_virtual)
|
|
struct ParsedDWARFTypeAttributes {
|
|
explicit ParsedDWARFTypeAttributes(const DWARFDIE &die);
|
|
|
|
lldb::AccessType accessibility = lldb::eAccessNone;
|
|
bool is_artificial = false;
|
|
bool is_complete_objc_class = false;
|
|
bool is_explicit = false;
|
|
bool is_forward_declaration = false;
|
|
bool is_inline = false;
|
|
bool is_scoped_enum = false;
|
|
bool is_vector = false;
|
|
bool is_virtual = false;
|
|
bool is_objc_direct_call = false;
|
|
bool exports_symbols = false;
|
|
clang::StorageClass storage = clang::SC_None;
|
|
const char *mangled_name = nullptr;
|
|
lldb_private::ConstString name;
|
|
lldb_private::Declaration decl;
|
|
DWARFDIE object_pointer;
|
|
DWARFFormValue abstract_origin;
|
|
DWARFFormValue containing_type;
|
|
DWARFFormValue signature;
|
|
DWARFFormValue specification;
|
|
DWARFFormValue type;
|
|
lldb::LanguageType class_language = lldb::eLanguageTypeUnknown;
|
|
llvm::Optional<uint64_t> byte_size;
|
|
size_t calling_convention = llvm::dwarf::DW_CC_normal;
|
|
uint32_t bit_stride = 0;
|
|
uint32_t byte_stride = 0;
|
|
uint32_t encoding = 0;
|
|
};
|
|
|
|
#endif // SymbolFileDWARF_DWARFASTParserClang_h_
|