You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
202 lines
6.8 KiB
202 lines
6.8 KiB
//===-- HashedNameToDIE.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 LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_HASHEDNAMETODIE_H
|
|
#define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_HASHEDNAMETODIE_H
|
|
|
|
#include <vector>
|
|
|
|
#include "lldb/Core/MappedHash.h"
|
|
#include "lldb/Core/dwarf.h"
|
|
#include "lldb/Utility/RegularExpression.h"
|
|
#include "lldb/lldb-defines.h"
|
|
|
|
#include "DWARFDefines.h"
|
|
#include "DWARFFormValue.h"
|
|
#include "NameToDIE.h"
|
|
|
|
class DWARFMappedHash {
|
|
public:
|
|
enum AtomType : uint16_t {
|
|
eAtomTypeNULL = 0u,
|
|
/// DIE offset, check form for encoding.
|
|
eAtomTypeDIEOffset = 1u,
|
|
/// DIE offset of the compiler unit header that contains the item in
|
|
/// question.
|
|
eAtomTypeCUOffset = 2u,
|
|
/// DW_TAG_xxx value, should be encoded as DW_FORM_data1 (if no tags exceed
|
|
/// 255) or DW_FORM_data2.
|
|
eAtomTypeTag = 3u,
|
|
// Flags from enum NameFlags.
|
|
eAtomTypeNameFlags = 4u,
|
|
// Flags from enum TypeFlags.
|
|
eAtomTypeTypeFlags = 5u,
|
|
/// A 32 bit hash of the full qualified name (since all hash entries are
|
|
/// basename only) For example a type like "std::vector<int>::iterator"
|
|
/// would have a name of "iterator" and a 32 bit hash for
|
|
/// "std::vector<int>::iterator" to allow us to not have to pull in debug
|
|
/// info for a type when we know the fully qualified name.
|
|
eAtomTypeQualNameHash = 6u
|
|
};
|
|
|
|
/// Bit definitions for the eAtomTypeTypeFlags flags.
|
|
enum TypeFlags {
|
|
/// Always set for C++, only set for ObjC if this is the
|
|
/// @implementation for class.
|
|
eTypeFlagClassIsImplementation = (1u << 1)
|
|
};
|
|
|
|
struct DIEInfo {
|
|
dw_offset_t die_offset = DW_INVALID_OFFSET;
|
|
dw_tag_t tag = llvm::dwarf::DW_TAG_null;
|
|
|
|
/// Any flags for this DIEInfo.
|
|
uint32_t type_flags = 0;
|
|
|
|
/// A 32 bit hash of the fully qualified name.
|
|
uint32_t qualified_name_hash = 0;
|
|
|
|
DIEInfo() = default;
|
|
DIEInfo(dw_offset_t o, dw_tag_t t, uint32_t f, uint32_t h);
|
|
|
|
explicit operator DIERef() const {
|
|
return DIERef(llvm::None, DIERef::Section::DebugInfo, die_offset);
|
|
}
|
|
};
|
|
|
|
struct Atom {
|
|
AtomType type;
|
|
dw_form_t form;
|
|
};
|
|
|
|
typedef std::vector<DIEInfo> DIEInfoArray;
|
|
typedef std::vector<Atom> AtomArray;
|
|
|
|
class Prologue {
|
|
public:
|
|
Prologue(dw_offset_t _die_base_offset = 0);
|
|
|
|
void ClearAtoms();
|
|
|
|
bool ContainsAtom(AtomType atom_type) const;
|
|
|
|
void Clear();
|
|
|
|
void AppendAtom(AtomType type, dw_form_t form);
|
|
|
|
lldb::offset_t Read(const lldb_private::DataExtractor &data,
|
|
lldb::offset_t offset);
|
|
|
|
size_t GetByteSize() const;
|
|
|
|
size_t GetMinimumHashDataByteSize() const;
|
|
|
|
bool HashDataHasFixedByteSize() const;
|
|
|
|
/// DIE offset base so die offsets in hash_data can be CU relative.
|
|
dw_offset_t die_base_offset;
|
|
AtomArray atoms;
|
|
uint32_t atom_mask;
|
|
size_t min_hash_data_byte_size;
|
|
bool hash_data_has_fixed_byte_size;
|
|
};
|
|
|
|
class Header : public MappedHash::Header<Prologue> {
|
|
public:
|
|
size_t GetByteSize(const HeaderData &header_data) override;
|
|
|
|
lldb::offset_t Read(lldb_private::DataExtractor &data,
|
|
lldb::offset_t offset) override;
|
|
|
|
bool Read(const lldb_private::DWARFDataExtractor &data,
|
|
lldb::offset_t *offset_ptr, DIEInfo &hash_data) const;
|
|
};
|
|
|
|
/// A class for reading and using a saved hash table from a block of data in
|
|
/// memory.
|
|
class MemoryTable
|
|
: public MappedHash::MemoryTable<uint32_t, DWARFMappedHash::Header,
|
|
DIEInfoArray> {
|
|
public:
|
|
MemoryTable(lldb_private::DWARFDataExtractor &table_data,
|
|
const lldb_private::DWARFDataExtractor &string_table,
|
|
const char *name);
|
|
|
|
const char *GetStringForKeyType(KeyType key) const override;
|
|
|
|
bool ReadHashData(uint32_t hash_data_offset,
|
|
HashData &hash_data) const override;
|
|
|
|
void
|
|
AppendAllDIEsThatMatchingRegex(const lldb_private::RegularExpression ®ex,
|
|
DIEInfoArray &die_info_array) const;
|
|
|
|
void AppendAllDIEsInRange(const uint32_t die_offset_start,
|
|
const uint32_t die_offset_end,
|
|
DIEInfoArray &die_info_array) const;
|
|
|
|
bool FindByName(llvm::StringRef name,
|
|
llvm::function_ref<bool(DIERef ref)> callback);
|
|
|
|
void FindByNameAndTag(llvm::StringRef name, const dw_tag_t tag,
|
|
llvm::function_ref<bool(DIERef ref)> callback);
|
|
|
|
void FindByNameAndTagAndQualifiedNameHash(
|
|
llvm::StringRef name, const dw_tag_t tag,
|
|
const uint32_t qualified_name_hash,
|
|
llvm::function_ref<bool(DIERef ref)> callback);
|
|
|
|
void
|
|
FindCompleteObjCClassByName(llvm::StringRef name,
|
|
llvm::function_ref<bool(DIERef ref)> callback,
|
|
bool must_be_implementation);
|
|
|
|
protected:
|
|
Result AppendHashDataForRegularExpression(
|
|
const lldb_private::RegularExpression ®ex,
|
|
lldb::offset_t *hash_data_offset_ptr, Pair &pair) const;
|
|
|
|
void FindByName(llvm::StringRef name, DIEInfoArray &die_info_array);
|
|
|
|
Result GetHashDataForName(llvm::StringRef name,
|
|
lldb::offset_t *hash_data_offset_ptr,
|
|
Pair &pair) const override;
|
|
|
|
lldb_private::DWARFDataExtractor m_data;
|
|
lldb_private::DWARFDataExtractor m_string_table;
|
|
std::string m_name;
|
|
};
|
|
|
|
static bool ExtractDIEArray(const DIEInfoArray &die_info_array,
|
|
llvm::function_ref<bool(DIERef ref)> callback);
|
|
|
|
protected:
|
|
static void ExtractDIEArray(const DIEInfoArray &die_info_array,
|
|
const dw_tag_t tag,
|
|
llvm::function_ref<bool(DIERef ref)> callback);
|
|
|
|
static void ExtractDIEArray(const DIEInfoArray &die_info_array,
|
|
const dw_tag_t tag,
|
|
const uint32_t qualified_name_hash,
|
|
llvm::function_ref<bool(DIERef ref)> callback);
|
|
|
|
static void
|
|
ExtractClassOrStructDIEArray(const DIEInfoArray &die_info_array,
|
|
bool return_implementation_only_if_available,
|
|
llvm::function_ref<bool(DIERef ref)> callback);
|
|
|
|
static void
|
|
ExtractTypesFromDIEArray(const DIEInfoArray &die_info_array,
|
|
uint32_t type_flag_mask, uint32_t type_flag_value,
|
|
llvm::function_ref<bool(DIERef ref)> callback);
|
|
|
|
static const char *GetAtomTypeName(uint16_t atom);
|
|
};
|
|
|
|
#endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_HASHEDNAMETODIE_H
|