lldb/source/Symbol/TypeMap.cpp

   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(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 }