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
|
//===-- UniqueDWARFASTType.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_UniqueDWARFASTType_h_
#define lldb_UniqueDWARFASTType_h_
#include <vector>
#include "llvm/ADT/DenseMap.h"
#include "DWARFDIE.h"
#include "lldb/Symbol/Declaration.h"
class UniqueDWARFASTType {
public:
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
UniqueDWARFASTType()
: m_type_sp(), m_die(), m_declaration(),
m_byte_size(
-1) // Set to negative value to make sure we have a valid value
{}
UniqueDWARFASTType(lldb::TypeSP &type_sp, const DWARFDIE &die,
const lldb_private::Declaration &decl, int32_t byte_size)
: m_type_sp(type_sp), m_die(die), m_declaration(decl),
m_byte_size(byte_size) {}
UniqueDWARFASTType(const UniqueDWARFASTType &rhs)
: m_type_sp(rhs.m_type_sp), m_die(rhs.m_die),
m_declaration(rhs.m_declaration), m_byte_size(rhs.m_byte_size) {}
~UniqueDWARFASTType() {}
UniqueDWARFASTType &operator=(const UniqueDWARFASTType &rhs) {
if (this != &rhs) {
m_type_sp = rhs.m_type_sp;
m_die = rhs.m_die;
m_declaration = rhs.m_declaration;
m_byte_size = rhs.m_byte_size;
}
return *this;
}
lldb::TypeSP m_type_sp;
DWARFDIE m_die;
lldb_private::Declaration m_declaration;
int32_t m_byte_size;
};
class UniqueDWARFASTTypeList {
public:
UniqueDWARFASTTypeList() : m_collection() {}
~UniqueDWARFASTTypeList() {}
uint32_t GetSize() { return (uint32_t)m_collection.size(); }
void Append(const UniqueDWARFASTType &entry) {
m_collection.push_back(entry);
}
bool Find(const DWARFDIE &die, const lldb_private::Declaration &decl,
const int32_t byte_size, UniqueDWARFASTType &entry) const;
protected:
typedef std::vector<UniqueDWARFASTType> collection;
collection m_collection;
};
class UniqueDWARFASTTypeMap {
public:
UniqueDWARFASTTypeMap() : m_collection() {}
~UniqueDWARFASTTypeMap() {}
void Insert(const lldb_private::ConstString &name,
const UniqueDWARFASTType &entry) {
m_collection[name.GetCString()].Append(entry);
}
bool Find(const lldb_private::ConstString &name, const DWARFDIE &die,
const lldb_private::Declaration &decl, const int32_t byte_size,
UniqueDWARFASTType &entry) const {
const char *unique_name_cstr = name.GetCString();
collection::const_iterator pos = m_collection.find(unique_name_cstr);
if (pos != m_collection.end()) {
return pos->second.Find(die, decl, byte_size, entry);
}
return false;
}
protected:
// A unique name string should be used
typedef llvm::DenseMap<const char *, UniqueDWARFASTTypeList> collection;
collection m_collection;
};
#endif // lldb_UniqueDWARFASTType_h_
|
