1//===-- TypeMap.cpp --------------------------------------------*- C++ -*-===//
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
19using namespace lldb;
20using namespace lldb_private;
21
22TypeMap::TypeMap() : m_types() {}
23
24// Destructor
25TypeMap::~TypeMap() {}
26
27void 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
34bool 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
73void TypeMap::Clear() { m_types.clear(); }
74
75uint32_t TypeMap::GetSize() const { return m_types.size(); }
76
77bool 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
83TypeSP 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
94void 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
102void 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
110bool 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
124void TypeMap::Dump(Stream *s, bool show_context) {
125  for (iterator pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) {
126    pos->second->Dump(s, show_context);
127  }
128}
129
130void 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(type_scope, type_basename, type_class,
141                               exact_match);
142}
143
144void TypeMap::RemoveMismatchedTypes(const std::string &type_scope,
145                                    const std::string &type_basename,
146                                    TypeClass type_class, bool exact_match) {
147  // Our "collection" type currently is a std::map which doesn't have any good
148  // way to iterate and remove items from the map so we currently just make a
149  // new list and add all of the matching types to it, and then swap it into
150  // m_types at the end
151  collection matching_types;
152
153  iterator pos, end = m_types.end();
154
155  for (pos = m_types.begin(); pos != end; ++pos) {
156    Type *the_type = pos->second.get();
157    bool keep_match = false;
158    TypeClass match_type_class = eTypeClassAny;
159
160    if (type_class != eTypeClassAny) {
161      match_type_class = the_type->GetForwardCompilerType().GetTypeClass();
162      if ((match_type_class & type_class) == 0)
163        continue;
164    }
165
166    ConstString match_type_name_const_str(the_type->GetQualifiedName());
167    if (match_type_name_const_str) {
168      const char *match_type_name = match_type_name_const_str.GetCString();
169      llvm::StringRef match_type_scope;
170      llvm::StringRef match_type_basename;
171      if (Type::GetTypeScopeAndBasename(match_type_name, match_type_scope,
172                                        match_type_basename,
173                                        match_type_class)) {
174        if (match_type_basename == type_basename) {
175          const size_t type_scope_size = type_scope.size();
176          const size_t match_type_scope_size = match_type_scope.size();
177          if (exact_match || (type_scope_size == match_type_scope_size)) {
178            keep_match = match_type_scope == type_scope;
179          } else {
180            if (match_type_scope_size > type_scope_size) {
181              const size_t type_scope_pos = match_type_scope.rfind(type_scope);
182              if (type_scope_pos == match_type_scope_size - type_scope_size) {
183                if (type_scope_pos >= 2) {
184                  // Our match scope ends with the type scope we were looking
185                  // for, but we need to make sure what comes before the
186                  // matching type scope is a namespace boundary in case we are
187                  // trying to match: type_basename = "d" type_scope = "b::c::"
188                  // We want to match:
189                  //  match_type_scope "a::b::c::"
190                  // But not:
191                  //  match_type_scope "a::bb::c::"
192                  // So below we make sure what comes before "b::c::" in
193                  // match_type_scope is "::", or the namespace boundary
194                  if (match_type_scope[type_scope_pos - 1] == ':' &&
195                      match_type_scope[type_scope_pos - 2] == ':') {
196                    keep_match = true;
197                  }
198                }
199              }
200            }
201          }
202        }
203      } else {
204        // The type we are currently looking at doesn't exists in a namespace
205        // or class, so it only matches if there is no type scope...
206        keep_match = type_scope.empty() && type_basename == match_type_name;
207      }
208    }
209
210    if (keep_match) {
211      matching_types.insert(*pos);
212    }
213  }
214  m_types.swap(matching_types);
215}
216
217void TypeMap::RemoveMismatchedTypes(TypeClass type_class) {
218  if (type_class == eTypeClassAny)
219    return;
220
221  // Our "collection" type currently is a std::map which doesn't have any good
222  // way to iterate and remove items from the map so we currently just make a
223  // new list and add all of the matching types to it, and then swap it into
224  // m_types at the end
225  collection matching_types;
226
227  iterator pos, end = m_types.end();
228
229  for (pos = m_types.begin(); pos != end; ++pos) {
230    Type *the_type = pos->second.get();
231    TypeClass match_type_class =
232        the_type->GetForwardCompilerType().GetTypeClass();
233    if (match_type_class & type_class)
234      matching_types.insert(*pos);
235  }
236  m_types.swap(matching_types);
237}
238