1 //===-- TypeList.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/TypeList.h"
18 
19 using namespace lldb;
20 using namespace lldb_private;
21 
22 TypeList::TypeList() : m_types() {}
23 
24 // Destructor
25 TypeList::~TypeList() = default;
26 
27 void TypeList::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.push_back(type_sp);
32 }
33 
34 // Find a base type by its unique ID.
35 // TypeSP
36 // TypeList::FindType(lldb::user_id_t uid)
37 //{
38 //    iterator pos = m_types.find(uid);
39 //    if (pos != m_types.end())
40 //        return pos->second;
41 //    return TypeSP();
42 //}
43 
44 // Find a type by name.
45 // TypeList
46 // TypeList::FindTypes (ConstString name)
47 //{
48 //    // Do we ever need to make a lookup by name map? Here we are doing
49 //    // a linear search which isn't going to be fast.
50 //    TypeList types(m_ast.getTargetInfo()->getTriple().getTriple().c_str());
51 //    iterator pos, end;
52 //    for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
53 //        if (pos->second->GetName() == name)
54 //            types.Insert (pos->second);
55 //    return types;
56 //}
57 
58 void TypeList::Clear() { m_types.clear(); }
59 
60 uint32_t TypeList::GetSize() const { return m_types.size(); }
61 
62 // GetTypeAtIndex isn't used a lot for large type lists, currently only for
63 // type lists that are returned for "image dump -t TYPENAME" commands and other
64 // simple symbol queries that grab the first result...
65 
66 TypeSP TypeList::GetTypeAtIndex(uint32_t idx) {
67   iterator pos, end;
68   uint32_t i = idx;
69   assert(i < GetSize() && "Accessing past the end of a TypeList");
70   for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) {
71     if (i == 0)
72       return *pos;
73     --i;
74   }
75   return TypeSP();
76 }
77 
78 void TypeList::ForEach(
79     std::function<bool(const lldb::TypeSP &type_sp)> const &callback) const {
80   for (auto pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) {
81     if (!callback(*pos))
82       break;
83   }
84 }
85 
86 void TypeList::ForEach(
87     std::function<bool(lldb::TypeSP &type_sp)> const &callback) {
88   for (auto pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) {
89     if (!callback(*pos))
90       break;
91   }
92 }
93 
94 void TypeList::Dump(Stream *s, bool show_context) {
95   for (iterator pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) {
96     pos->get()->Dump(s, show_context);
97   }
98 }
99 
100 void TypeList::RemoveMismatchedTypes(llvm::StringRef qualified_typename,
101                                      bool exact_match) {
102   llvm::StringRef type_scope;
103   llvm::StringRef type_basename;
104   TypeClass type_class = eTypeClassAny;
105   if (!Type::GetTypeScopeAndBasename(qualified_typename, type_scope,
106                                      type_basename, type_class)) {
107     type_basename = qualified_typename;
108     type_scope = "";
109   }
110   return RemoveMismatchedTypes(type_scope, type_basename, type_class,
111                                exact_match);
112 }
113 
114 void TypeList::RemoveMismatchedTypes(llvm::StringRef type_scope,
115                                      llvm::StringRef type_basename,
116                                      TypeClass type_class, bool exact_match) {
117   // Our "collection" type currently is a std::map which doesn't have any good
118   // way to iterate and remove items from the map so we currently just make a
119   // new list and add all of the matching types to it, and then swap it into
120   // m_types at the end
121   collection matching_types;
122 
123   iterator pos, end = m_types.end();
124 
125   for (pos = m_types.begin(); pos != end; ++pos) {
126     Type *the_type = pos->get();
127     bool keep_match = false;
128     TypeClass match_type_class = eTypeClassAny;
129 
130     if (type_class != eTypeClassAny) {
131       match_type_class = the_type->GetForwardCompilerType().GetTypeClass();
132       if ((match_type_class & type_class) == 0)
133         continue;
134     }
135 
136     ConstString match_type_name_const_str(the_type->GetQualifiedName());
137     if (match_type_name_const_str) {
138       const char *match_type_name = match_type_name_const_str.GetCString();
139       llvm::StringRef match_type_scope;
140       llvm::StringRef match_type_basename;
141       if (Type::GetTypeScopeAndBasename(match_type_name, match_type_scope,
142                                         match_type_basename,
143                                         match_type_class)) {
144         if (match_type_basename == type_basename) {
145           const size_t type_scope_size = type_scope.size();
146           const size_t match_type_scope_size = match_type_scope.size();
147           if (exact_match || (type_scope_size == match_type_scope_size)) {
148             keep_match = match_type_scope == type_scope;
149           } else {
150             if (match_type_scope_size > type_scope_size) {
151               const size_t type_scope_pos = match_type_scope.rfind(type_scope);
152               if (type_scope_pos == match_type_scope_size - type_scope_size) {
153                 if (type_scope_pos >= 2) {
154                   // Our match scope ends with the type scope we were looking
155                   // for, but we need to make sure what comes before the
156                   // matching type scope is a namespace boundary in case we are
157                   // trying to match: type_basename = "d" type_scope = "b::c::"
158                   // We want to match:
159                   //  match_type_scope "a::b::c::"
160                   // But not:
161                   //  match_type_scope "a::bb::c::"
162                   // So below we make sure what comes before "b::c::" in
163                   // match_type_scope is "::", or the namespace boundary
164                   if (match_type_scope[type_scope_pos - 1] == ':' &&
165                       match_type_scope[type_scope_pos - 2] == ':') {
166                     keep_match = true;
167                   }
168                 }
169               }
170             }
171           }
172         }
173       } else {
174         // The type we are currently looking at doesn't exists in a namespace
175         // or class, so it only matches if there is no type scope...
176         keep_match = type_scope.empty() && type_basename == match_type_name;
177       }
178     }
179 
180     if (keep_match) {
181       matching_types.push_back(*pos);
182     }
183   }
184   m_types.swap(matching_types);
185 }
186 
187 void TypeList::RemoveMismatchedTypes(TypeClass type_class) {
188   if (type_class == eTypeClassAny)
189     return;
190 
191   // Our "collection" type currently is a std::map which doesn't have any good
192   // way to iterate and remove items from the map so we currently just make a
193   // new list and add all of the matching types to it, and then swap it into
194   // m_types at the end
195   collection matching_types;
196 
197   iterator pos, end = m_types.end();
198 
199   for (pos = m_types.begin(); pos != end; ++pos) {
200     Type *the_type = pos->get();
201     TypeClass match_type_class =
202         the_type->GetForwardCompilerType().GetTypeClass();
203     if (match_type_class & type_class)
204       matching_types.push_back(*pos);
205   }
206   m_types.swap(matching_types);
207 }
208