1 //===-- TypeList.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/TypeList.h" 18 19 using namespace lldb; 20 using namespace lldb_private; 21 22 TypeList::TypeList() : m_types() {} 23 24 // Destructor 25 TypeList::~TypeList() {} 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(const char *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(const std::string &type_scope, 115 const std::string &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