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