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"
15 #include "lldb/Symbol/SymbolVendor.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
25 TypeMap::~TypeMap() = default;
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 
83 TypeSP TypeMap::GetTypeAtIndex(uint32_t idx) {
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 
94 void TypeMap::ForEach(
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 
102 void TypeMap::ForEach(
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(llvm::StringRef type_scope,
131                                     llvm::StringRef type_basename,
132                                     TypeClass type_class, bool exact_match) {
133   // Our "collection" type currently is a std::map which doesn't have any good
134   // way to iterate and remove items from the map so we currently just make a
135   // new list and add all of the matching types to it, and then swap it into
136   // m_types at the end
137   collection matching_types;
138 
139   iterator pos, end = m_types.end();
140 
141   for (pos = m_types.begin(); pos != end; ++pos) {
142     Type *the_type = pos->second.get();
143     bool keep_match = false;
144     TypeClass match_type_class = eTypeClassAny;
145 
146     if (type_class != eTypeClassAny) {
147       match_type_class = the_type->GetForwardCompilerType().GetTypeClass();
148       if ((match_type_class & type_class) == 0)
149         continue;
150     }
151 
152     ConstString match_type_name_const_str(the_type->GetQualifiedName());
153     if (match_type_name_const_str) {
154       const char *match_type_name = match_type_name_const_str.GetCString();
155       llvm::StringRef match_type_scope;
156       llvm::StringRef match_type_basename;
157       if (Type::GetTypeScopeAndBasename(match_type_name, match_type_scope,
158                                         match_type_basename,
159                                         match_type_class)) {
160         if (match_type_basename == type_basename) {
161           const size_t type_scope_size = type_scope.size();
162           const size_t match_type_scope_size = match_type_scope.size();
163           if (exact_match || (type_scope_size == match_type_scope_size)) {
164             keep_match = match_type_scope == type_scope;
165           } else {
166             if (match_type_scope_size > type_scope_size) {
167               const size_t type_scope_pos = match_type_scope.rfind(type_scope);
168               if (type_scope_pos == match_type_scope_size - type_scope_size) {
169                 if (type_scope_pos >= 2) {
170                   // Our match scope ends with the type scope we were looking
171                   // for, but we need to make sure what comes before the
172                   // matching type scope is a namespace boundary in case we are
173                   // trying to match: type_basename = "d" type_scope = "b::c::"
174                   // We want to match:
175                   //  match_type_scope "a::b::c::"
176                   // But not:
177                   //  match_type_scope "a::bb::c::"
178                   // So below we make sure what comes before "b::c::" in
179                   // match_type_scope is "::", or the namespace boundary
180                   if (match_type_scope[type_scope_pos - 1] == ':' &&
181                       match_type_scope[type_scope_pos - 2] == ':') {
182                     keep_match = true;
183                   }
184                 }
185               }
186             }
187           }
188         }
189       } else {
190         // The type we are currently looking at doesn't exists in a namespace
191         // or class, so it only matches if there is no type scope...
192         keep_match = type_scope.empty() && type_basename == match_type_name;
193       }
194     }
195 
196     if (keep_match) {
197       matching_types.insert(*pos);
198     }
199   }
200   m_types.swap(matching_types);
201 }
202