//===-- TypeList.cpp --------------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // C Includes // C++ Includes #include <vector> // Other libraries and framework includes #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclGroup.h" #include "clang/Basic/Builtins.h" #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/TargetInfo.h" #include "llvm/Support/FormattedStream.h" #include "llvm/Support/raw_ostream.h" // Project includes #include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/Type.h" #include "lldb/Symbol/TypeList.h" using namespace lldb; using namespace lldb_private; using namespace clang; TypeList::TypeList() : m_types () { } //---------------------------------------------------------------------- // Destructor //---------------------------------------------------------------------- TypeList::~TypeList() { } void TypeList::Insert (TypeSP& type_sp) { // Just push each type on the back for now. We will worry about uniquing later if (type_sp) m_types.insert(std::make_pair(type_sp->GetID(), type_sp)); } bool TypeList::InsertUnique (TypeSP& type_sp) { if (type_sp) { user_id_t type_uid = type_sp->GetID(); iterator pos, end = m_types.end(); for (pos = m_types.find(type_uid); pos != end && pos->second->GetID() == type_uid; ++pos) { if (pos->second.get() == type_sp.get()) return false; } } Insert (type_sp); return true; } //---------------------------------------------------------------------- // Find a base type by its unique ID. //---------------------------------------------------------------------- TypeSP TypeList::FindType(lldb::user_id_t uid) { iterator pos = m_types.find(uid); if (pos != m_types.end()) return pos->second; return TypeSP(); } //---------------------------------------------------------------------- // Find a type by name. //---------------------------------------------------------------------- //TypeList //TypeList::FindTypes (const ConstString &name) //{ // // Do we ever need to make a lookup by name map? Here we are doing // // a linear search which isn't going to be fast. // TypeList types(m_ast.getTargetInfo()->getTriple().getTriple().c_str()); // iterator pos, end; // for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) // if (pos->second->GetName() == name) // types.Insert (pos->second); // return types; //} void TypeList::Clear() { m_types.clear(); } uint32_t TypeList::GetSize() const { return m_types.size(); } // GetTypeAtIndex isn't used a lot for large type lists, currently only for // type lists that are returned for "image dump -t TYPENAME" commands and other // simple symbol queries that grab the first result... TypeSP TypeList::GetTypeAtIndex(uint32_t idx) { iterator pos, end; uint32_t i = idx; for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) { if (i == 0) return pos->second; --i; } return TypeSP(); } void TypeList::Dump(Stream *s, bool show_context) { for (iterator pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) { pos->second->Dump(s, show_context); } } //void * //TypeList::CreateClangPointerType (Type *type) //{ // assert(type); // return m_ast.CreatePointerType(type->GetClangForwardType()); //} // //void * //TypeList::CreateClangTypedefType (Type *typedef_type, Type *base_type) //{ // assert(typedef_type && base_type); // return m_ast.CreateTypedefType (typedef_type->GetName().AsCString(), // base_type->GetClangForwardType(), // typedef_type->GetSymbolFile()->GetClangDeclContextForTypeUID(typedef_type->GetID())); //} // //void * //TypeList::CreateClangLValueReferenceType (Type *type) //{ // assert(type); // return m_ast.CreateLValueReferenceType(type->GetClangForwardType()); //} // //void * //TypeList::CreateClangRValueReferenceType (Type *type) //{ // assert(type); // return m_ast.CreateRValueReferenceType (type->GetClangForwardType()); //} //