1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
//===-- HashedNameToDIE.h ---------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef SymbolFileDWARF_HashedNameToDIE_h_
#define SymbolFileDWARF_HashedNameToDIE_h_
#include <vector>
#include "lldb/lldb-defines.h"
#include "lldb/Core/dwarf.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/MappedHash.h"
#include "DWARFDefines.h"
#include "DWARFFormValue.h"
#include "NameToDIE.h"
class SymbolFileDWARF;
class DWARFCompileUnit;
class DWARFDebugInfoEntry;
class DWARFMappedHash
{
public:
enum AtomType : uint16_t
{
eAtomTypeNULL = 0u,
eAtomTypeDIEOffset = 1u, // DIE offset, check form for encoding
eAtomTypeCUOffset = 2u, // DIE offset of the compiler unit header that contains the item in question
eAtomTypeTag = 3u, // DW_TAG_xxx value, should be encoded as DW_FORM_data1 (if no tags exceed 255) or DW_FORM_data2
eAtomTypeNameFlags = 4u, // Flags from enum NameFlags
eAtomTypeTypeFlags = 5u, // Flags from enum TypeFlags,
eAtomTypeQualNameHash = 6u // 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.
};
// 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 cu_offset;
dw_offset_t offset; // The DIE offset
dw_tag_t tag;
uint32_t type_flags; // Any flags for this DIEInfo
uint32_t qualified_name_hash; // A 32 bit hash of the fully qualified name
DIEInfo ();
DIEInfo (dw_offset_t c, dw_offset_t o, dw_tag_t t, uint32_t f, uint32_t h);
};
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;
void
Dump (lldb_private::Stream& strm, const 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;
size_t
AppendAllDIEsThatMatchingRegex (const lldb_private::RegularExpression& regex,
DIEInfoArray &die_info_array) const;
size_t
AppendAllDIEsInRange (const uint32_t die_offset_start,
const uint32_t die_offset_end,
DIEInfoArray &die_info_array) const;
size_t
FindByName (const char *name, DIEArray &die_offsets);
size_t
FindByNameAndTag (const char *name, const dw_tag_t tag, DIEArray &die_offsets);
size_t
FindByNameAndTagAndQualifiedNameHash (const char *name,
const dw_tag_t tag,
const uint32_t qualified_name_hash,
DIEArray &die_offsets);
size_t
FindCompleteObjCClassByName (const char *name,
DIEArray &die_offsets,
bool must_be_implementation);
protected:
Result
AppendHashDataForRegularExpression (const lldb_private::RegularExpression& regex,
lldb::offset_t* hash_data_offset_ptr,
Pair &pair) const;
size_t
FindByName (const char *name, DIEInfoArray &die_info_array);
Result
GetHashDataForName (const char *name,
lldb::offset_t* hash_data_offset_ptr,
Pair &pair) const override;
const lldb_private::DWARFDataExtractor &m_data;
const lldb_private::DWARFDataExtractor &m_string_table;
std::string m_name;
};
static void
ExtractDIEArray (const DIEInfoArray &die_info_array, DIEArray &die_offsets);
protected:
static void
ExtractDIEArray (const DIEInfoArray &die_info_array,
const dw_tag_t tag,
DIEArray &die_offsets);
static void
ExtractDIEArray (const DIEInfoArray &die_info_array,
const dw_tag_t tag,
const uint32_t qualified_name_hash,
DIEArray &die_offsets);
static void
ExtractClassOrStructDIEArray (const DIEInfoArray &die_info_array,
bool return_implementation_only_if_available,
DIEArray &die_offsets);
static void
ExtractTypesFromDIEArray (const DIEInfoArray &die_info_array,
uint32_t type_flag_mask,
uint32_t type_flag_value,
DIEArray &die_offsets);
static const char *
GetAtomTypeName (uint16_t atom);
};
#endif // SymbolFileDWARF_HashedNameToDIE_h_
|
