Home | History | Annotate | Download | only in DWARF 
      1 //===-- UniqueDWARFASTType.h ------------------------------------*- C++ -*-===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 #ifndef lldb_UniqueDWARFASTType_h_
     11 #define lldb_UniqueDWARFASTType_h_
     12 
     13 // C Includes
     14 // C++ Includes
     15 #include <vector>
     16 
     17 // Other libraries and framework includes
     18 #include "llvm/ADT/DenseMap.h"
     19 
     20 // Project includes
     21 #include "lldb/Symbol/Declaration.h"
     22 
     23 class DWARFCompileUnit;
     24 class DWARFDebugInfoEntry;
     25 class SymbolFileDWARF;
     26 
     27 class UniqueDWARFASTType
     28 {
     29 public:
     30 	//------------------------------------------------------------------
     31 	// Constructors and Destructors
     32 	//------------------------------------------------------------------
     33 	UniqueDWARFASTType () :
     34         m_type_sp (),
     35         m_symfile (NULL),
     36         m_cu (NULL),
     37         m_die (NULL),
     38         m_declaration (),
     39         m_byte_size (-1) // Set to negative value to make sure we have a valid value
     40     {
     41     }
     42 
     43 	UniqueDWARFASTType (lldb::TypeSP &type_sp,
     44                         SymbolFileDWARF *symfile,
     45                         DWARFCompileUnit *cu,
     46                         DWARFDebugInfoEntry *die,
     47                         const lldb_private::Declaration &decl,
     48                         int32_t byte_size) :
     49         m_type_sp (type_sp),
     50         m_symfile (symfile),
     51         m_cu (cu),
     52         m_die (die),
     53         m_declaration (decl),
     54         m_byte_size (byte_size)
     55     {
     56     }
     57 
     58     UniqueDWARFASTType (const UniqueDWARFASTType &rhs) :
     59         m_type_sp (rhs.m_type_sp),
     60         m_symfile (rhs.m_symfile),
     61         m_cu (rhs.m_cu),
     62         m_die (rhs.m_die),
     63         m_declaration (rhs.m_declaration),
     64         m_byte_size (rhs.m_byte_size)
     65     {
     66     }
     67 
     68 	~UniqueDWARFASTType()
     69     {
     70     }
     71 
     72     UniqueDWARFASTType &
     73     operator= (const UniqueDWARFASTType &rhs)
     74     {
     75         if (this != &rhs)
     76         {
     77             m_type_sp = rhs.m_type_sp;
     78             m_symfile = rhs.m_symfile;
     79             m_cu = rhs.m_cu;
     80             m_die = rhs.m_die;
     81             m_declaration = rhs.m_declaration;
     82             m_byte_size = rhs.m_byte_size;
     83         }
     84         return *this;
     85     }
     86 
     87     lldb::TypeSP m_type_sp;
     88     SymbolFileDWARF *m_symfile;
     89     const DWARFCompileUnit *m_cu;
     90     const DWARFDebugInfoEntry *m_die;
     91     lldb_private::Declaration m_declaration;
     92     int32_t m_byte_size;
     93 };
     94 
     95 class UniqueDWARFASTTypeList
     96 {
     97 public:
     98     UniqueDWARFASTTypeList () :
     99         m_collection()
    100     {
    101     }
    102 
    103     ~UniqueDWARFASTTypeList ()
    104     {
    105     }
    106 
    107     uint32_t
    108     GetSize()
    109     {
    110         return (uint32_t)m_collection.size();
    111     }
    112 
    113     void
    114     Append (const UniqueDWARFASTType &entry)
    115     {
    116         m_collection.push_back (entry);
    117     }
    118 
    119     bool
    120     Find (SymbolFileDWARF *symfile,
    121           const DWARFCompileUnit *cu,
    122           const DWARFDebugInfoEntry *die,
    123           const lldb_private::Declaration &decl,
    124           const int32_t byte_size,
    125           UniqueDWARFASTType &entry) const;
    126 
    127 protected:
    128     typedef std::vector<UniqueDWARFASTType> collection;
    129     collection m_collection;
    130 };
    131 
    132 class UniqueDWARFASTTypeMap
    133 {
    134 public:
    135     UniqueDWARFASTTypeMap () :
    136         m_collection ()
    137     {
    138     }
    139 
    140     ~UniqueDWARFASTTypeMap ()
    141     {
    142     }
    143 
    144     void
    145     Insert (const lldb_private::ConstString &name,
    146             const UniqueDWARFASTType &entry)
    147     {
    148         m_collection[name.GetCString()].Append (entry);
    149     }
    150 
    151     bool
    152     Find (const lldb_private::ConstString &name,
    153           SymbolFileDWARF *symfile,
    154           const DWARFCompileUnit *cu,
    155           const DWARFDebugInfoEntry *die,
    156           const lldb_private::Declaration &decl,
    157           const int32_t byte_size,
    158           UniqueDWARFASTType &entry) const
    159     {
    160         const char *unique_name_cstr = name.GetCString();
    161         collection::const_iterator pos = m_collection.find (unique_name_cstr);
    162         if (pos != m_collection.end())
    163         {
    164             return pos->second.Find (symfile, cu, die, decl, byte_size, entry);
    165         }
    166         return false;
    167     }
    168 
    169 protected:
    170     // A unique name string should be used
    171     typedef llvm::DenseMap<const char *, UniqueDWARFASTTypeList> collection;
    172     collection m_collection;
    173 };
    174 
    175 #endif	// lldb_UniqueDWARFASTType_h_
    176