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 lldb::TypeSP TypeMap::FirstType() const {
  95   if (m_types.empty())
  96     return TypeSP();
  97   return m_types.begin()->second;
  98 }
  99
 100 void TypeMap::ForEach(
 101     std::function<bool(const lldb::TypeSP &type_sp)> const &callback) const {
 102   for (auto pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) {
 103     if (!callback(pos->second))
 104       break;
 105   }
 106 }
 107
 108 void TypeMap::ForEach(
 109     std::function<bool(lldb::TypeSP &type_sp)> const &callback) {
 110   for (auto pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) {
 111     if (!callback(pos->second))
 112       break;
 113   }
 114 }
 115
 116 bool TypeMap::Remove(const lldb::TypeSP &type_sp) {
 117   if (type_sp) {
 118     lldb::user_id_t uid = type_sp->GetID();
 119     for (iterator pos = m_types.find(uid), end = m_types.end();
 120          pos != end && pos->first == uid; ++pos) {
 121       if (pos->second == type_sp) {
 122         m_types.erase(pos);
 123         return true;
 124       }
 125     }
 126   }
 127   return false;
 128 }
 129
 130 void TypeMap::Dump(Stream *s, bool show_context,
 131                    lldb::DescriptionLevel level) const {
 132   for (const auto &pair : m_types)
 133     pair.second->Dump(s, show_context, level);
 134 }