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