LLDB  mainline
TypeMap.cpp
Go to the documentation of this file.
1 //===-- TypeMap.cpp -------------------------------------------------------===//
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 #include <vector>
10 
11 #include "llvm/Support/FormattedStream.h"
12 #include "llvm/Support/raw_ostream.h"
13 
14 #include "lldb/Symbol/SymbolFile.h"
16 #include "lldb/Symbol/Type.h"
17 #include "lldb/Symbol/TypeMap.h"
18 
19 using namespace lldb;
20 using namespace lldb_private;
21 
22 TypeMap::TypeMap() : m_types() {}
23 
24 // Destructor
26 
27 void TypeMap::Insert(const TypeSP &type_sp) {
28  // Just push each type on the back for now. We will worry about uniquing
29  // later
30  if (type_sp)
31  m_types.insert(std::make_pair(type_sp->GetID(), type_sp));
32 }
33 
34 bool TypeMap::InsertUnique(const TypeSP &type_sp) {
35  if (type_sp) {
36  user_id_t type_uid = type_sp->GetID();
37  iterator pos, end = m_types.end();
38 
39  for (pos = m_types.find(type_uid);
40  pos != end && pos->second->GetID() == type_uid; ++pos) {
41  if (pos->second.get() == type_sp.get())
42  return false;
43  }
44  Insert(type_sp);
45  }
46  return true;
47 }
48 
49 // Find a base type by its unique ID.
50 // TypeSP
51 // TypeMap::FindType(lldb::user_id_t uid)
52 //{
53 // iterator pos = m_types.find(uid);
54 // if (pos != m_types.end())
55 // return pos->second;
56 // return TypeSP();
57 //}
58 
59 // Find a type by name.
60 // TypeMap
61 // TypeMap::FindTypes (ConstString name)
62 //{
63 // // Do we ever need to make a lookup by name map? Here we are doing
64 // // a linear search which isn't going to be fast.
65 // TypeMap types(m_ast.getTargetInfo()->getTriple().getTriple().c_str());
66 // iterator pos, end;
67 // for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
68 // if (pos->second->GetName() == name)
69 // types.Insert (pos->second);
70 // return types;
71 //}
72 
73 void TypeMap::Clear() { m_types.clear(); }
74 
75 uint32_t TypeMap::GetSize() const { return m_types.size(); }
76 
77 bool TypeMap::Empty() const { return m_types.empty(); }
78 
79 // GetTypeAtIndex isn't used a lot for large type lists, currently only for
80 // type lists that are returned for "image dump -t TYPENAME" commands and other
81 // simple symbol queries that grab the first result...
82 
84  iterator pos, end;
85  uint32_t i = idx;
86  for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) {
87  if (i == 0)
88  return pos->second;
89  --i;
90  }
91  return TypeSP();
92 }
93 
95  std::function<bool(const lldb::TypeSP &type_sp)> const &callback) const {
96  for (auto pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) {
97  if (!callback(pos->second))
98  break;
99  }
100 }
101 
103  std::function<bool(lldb::TypeSP &type_sp)> const &callback) {
104  for (auto pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) {
105  if (!callback(pos->second))
106  break;
107  }
108 }
109 
110 bool TypeMap::Remove(const lldb::TypeSP &type_sp) {
111  if (type_sp) {
112  lldb::user_id_t uid = type_sp->GetID();
113  for (iterator pos = m_types.find(uid), end = m_types.end();
114  pos != end && pos->first == uid; ++pos) {
115  if (pos->second == type_sp) {
116  m_types.erase(pos);
117  return true;
118  }
119  }
120  }
121  return false;
122 }
123 
124 void TypeMap::Dump(Stream *s, bool show_context, lldb::DescriptionLevel level) {
125  for (iterator pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) {
126  pos->second->Dump(s, show_context, level);
127  }
128 }
129 
130 void TypeMap::RemoveMismatchedTypes(const char *qualified_typename,
131  bool exact_match) {
132  llvm::StringRef type_scope;
133  llvm::StringRef type_basename;
134  TypeClass type_class = eTypeClassAny;
135  if (!Type::GetTypeScopeAndBasename(qualified_typename, type_scope,
136  type_basename, type_class)) {
137  type_basename = qualified_typename;
138  type_scope = "";
139  }
140  return RemoveMismatchedTypes(std::string(type_scope),
141  std::string(type_basename), type_class,
142  exact_match);
143 }
144 
145 void TypeMap::RemoveMismatchedTypes(const std::string &type_scope,
146  const std::string &type_basename,
147  TypeClass type_class, bool exact_match) {
148  // Our "collection" type currently is a std::map which doesn't have any good
149  // way to iterate and remove items from the map so we currently just make a
150  // new list and add all of the matching types to it, and then swap it into
151  // m_types at the end
152  collection matching_types;
153 
154  iterator pos, end = m_types.end();
155 
156  for (pos = m_types.begin(); pos != end; ++pos) {
157  Type *the_type = pos->second.get();
158  bool keep_match = false;
159  TypeClass match_type_class = eTypeClassAny;
160 
161  if (type_class != eTypeClassAny) {
162  match_type_class = the_type->GetForwardCompilerType().GetTypeClass();
163  if ((match_type_class & type_class) == 0)
164  continue;
165  }
166 
167  ConstString match_type_name_const_str(the_type->GetQualifiedName());
168  if (match_type_name_const_str) {
169  const char *match_type_name = match_type_name_const_str.GetCString();
170  llvm::StringRef match_type_scope;
171  llvm::StringRef match_type_basename;
172  if (Type::GetTypeScopeAndBasename(match_type_name, match_type_scope,
173  match_type_basename,
174  match_type_class)) {
175  if (match_type_basename == type_basename) {
176  const size_t type_scope_size = type_scope.size();
177  const size_t match_type_scope_size = match_type_scope.size();
178  if (exact_match || (type_scope_size == match_type_scope_size)) {
179  keep_match = match_type_scope == type_scope;
180  } else {
181  if (match_type_scope_size > type_scope_size) {
182  const size_t type_scope_pos = match_type_scope.rfind(type_scope);
183  if (type_scope_pos == match_type_scope_size - type_scope_size) {
184  if (type_scope_pos >= 2) {
185  // Our match scope ends with the type scope we were looking
186  // for, but we need to make sure what comes before the
187  // matching type scope is a namespace boundary in case we are
188  // trying to match: type_basename = "d" type_scope = "b::c::"
189  // We want to match:
190  // match_type_scope "a::b::c::"
191  // But not:
192  // match_type_scope "a::bb::c::"
193  // So below we make sure what comes before "b::c::" in
194  // match_type_scope is "::", or the namespace boundary
195  if (match_type_scope[type_scope_pos - 1] == ':' &&
196  match_type_scope[type_scope_pos - 2] == ':') {
197  keep_match = true;
198  }
199  }
200  }
201  }
202  }
203  }
204  } else {
205  // The type we are currently looking at doesn't exists in a namespace
206  // or class, so it only matches if there is no type scope...
207  keep_match = type_scope.empty() && type_basename == match_type_name;
208  }
209  }
210 
211  if (keep_match) {
212  matching_types.insert(*pos);
213  }
214  }
215  m_types.swap(matching_types);
216 }
217 
218 void TypeMap::RemoveMismatchedTypes(TypeClass type_class) {
219  if (type_class == eTypeClassAny)
220  return;
221 
222  // Our "collection" type currently is a std::map which doesn't have any good
223  // way to iterate and remove items from the map so we currently just make a
224  // new list and add all of the matching types to it, and then swap it into
225  // m_types at the end
226  collection matching_types;
227 
228  iterator pos, end = m_types.end();
229 
230  for (pos = m_types.begin(); pos != end; ++pos) {
231  Type *the_type = pos->second.get();
232  TypeClass match_type_class =
233  the_type->GetForwardCompilerType().GetTypeClass();
234  if (match_type_class & type_class)
235  matching_types.insert(*pos);
236  }
237  m_types.swap(matching_types);
238 }
void RemoveMismatchedTypes(const char *qualified_typename, bool exact_match)
Definition: TypeMap.cpp:130
A class that represents a running process on the host machine.
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
bool Remove(const lldb::TypeSP &type_sp)
Definition: TypeMap.cpp:110
static bool GetTypeScopeAndBasename(const llvm::StringRef &name, llvm::StringRef &scope, llvm::StringRef &basename, lldb::TypeClass &type_class)
Definition: Type.cpp:662
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
void Insert(const lldb::TypeSP &type)
Definition: TypeMap.cpp:27
virtual ~TypeMap()
Definition: TypeMap.cpp:25
uint64_t user_id_t
Definition: lldb-types.h:84
lldb::TypeSP GetTypeAtIndex(uint32_t idx)
Definition: TypeMap.cpp:83
lldb::TypeClass GetTypeClass() const
ConstString GetQualifiedName()
Definition: Type.cpp:658
bool Empty() const
Definition: TypeMap.cpp:77
CompilerType GetForwardCompilerType()
Definition: Type.cpp:653
collection m_types
Definition: TypeMap.h:68
collection::iterator iterator
Definition: TypeMap.h:65
std::multimap< lldb::user_id_t, lldb::TypeSP > collection
Definition: TypeMap.h:44
void ForEach(std::function< bool(const lldb::TypeSP &type_sp)> const &callback) const
Definition: TypeMap.cpp:94
bool InsertUnique(const lldb::TypeSP &type)
Definition: TypeMap.cpp:34
A uniqued constant string class.
Definition: ConstString.h:40
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:246
void Dump(Stream *s, bool show_context, lldb::DescriptionLevel level=lldb::eDescriptionLevelFull)
Definition: TypeMap.cpp:124
Definition: SBAddress.h:15
uint32_t GetSize() const
Definition: TypeMap.cpp:75