1//===-- SymbolFileDWARF.cpp ------------------------------------*- 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#include "SymbolFileDWARF.h"
11
12// Other libraries and framework includes
13#include "clang/AST/ASTConsumer.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/Decl.h"
16#include "clang/AST/DeclGroup.h"
17#include "clang/AST/DeclObjC.h"
18#include "clang/AST/DeclTemplate.h"
19#include "clang/Basic/Builtins.h"
20#include "clang/Basic/IdentifierTable.h"
21#include "clang/Basic/LangOptions.h"
22#include "clang/Basic/SourceManager.h"
23#include "clang/Basic/TargetInfo.h"
24#include "clang/Basic/Specifiers.h"
25#include "clang/Sema/DeclSpec.h"
26
27#include "llvm/Support/Casting.h"
28
29#include "lldb/Core/Module.h"
30#include "lldb/Core/PluginManager.h"
31#include "lldb/Core/RegularExpression.h"
32#include "lldb/Core/Scalar.h"
33#include "lldb/Core/Section.h"
34#include "lldb/Core/StreamFile.h"
35#include "lldb/Core/StreamString.h"
36#include "lldb/Core/Timer.h"
37#include "lldb/Core/Value.h"
38
39#include "lldb/Host/Host.h"
40
41#include "lldb/Symbol/Block.h"
42#include "lldb/Symbol/ClangExternalASTSourceCallbacks.h"
43#include "lldb/Symbol/CompileUnit.h"
44#include "lldb/Symbol/LineTable.h"
45#include "lldb/Symbol/ObjectFile.h"
46#include "lldb/Symbol/SymbolVendor.h"
47#include "lldb/Symbol/VariableList.h"
48
49#include "lldb/Target/ObjCLanguageRuntime.h"
50#include "lldb/Target/CPPLanguageRuntime.h"
51
52#include "DWARFCompileUnit.h"
53#include "DWARFDebugAbbrev.h"
54#include "DWARFDebugAranges.h"
55#include "DWARFDebugInfo.h"
56#include "DWARFDebugInfoEntry.h"
57#include "DWARFDebugLine.h"
58#include "DWARFDebugPubnames.h"
59#include "DWARFDebugRanges.h"
60#include "DWARFDeclContext.h"
61#include "DWARFDIECollection.h"
62#include "DWARFFormValue.h"
63#include "DWARFLocationList.h"
64#include "LogChannelDWARF.h"
65#include "SymbolFileDWARFDebugMap.h"
66
67#include <map>
68
69//#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
70
71#ifdef ENABLE_DEBUG_PRINTF
72#include <stdio.h>
73#define DEBUG_PRINTF(fmt, ...) printf(fmt, ## __VA_ARGS__)
74#else
75#define DEBUG_PRINTF(fmt, ...)
76#endif
77
78#define DIE_IS_BEING_PARSED ((lldb_private::Type*)1)
79
80using namespace lldb;
81using namespace lldb_private;
82
83//static inline bool
84//child_requires_parent_class_union_or_struct_to_be_completed (dw_tag_t tag)
85//{
86//    switch (tag)
87//    {
88//    default:
89//        break;
90//    case DW_TAG_subprogram:
91//    case DW_TAG_inlined_subroutine:
92//    case DW_TAG_class_type:
93//    case DW_TAG_structure_type:
94//    case DW_TAG_union_type:
95//        return true;
96//    }
97//    return false;
98//}
99//
100static AccessType
101DW_ACCESS_to_AccessType (uint32_t dwarf_accessibility)
102{
103    switch (dwarf_accessibility)
104    {
105        case DW_ACCESS_public:      return eAccessPublic;
106        case DW_ACCESS_private:     return eAccessPrivate;
107        case DW_ACCESS_protected:   return eAccessProtected;
108        default:                    break;
109    }
110    return eAccessNone;
111}
112
113#if defined(LLDB_CONFIGURATION_DEBUG) or defined(LLDB_CONFIGURATION_RELEASE)
114
115class DIEStack
116{
117public:
118
119    void Push (DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die)
120    {
121        m_dies.push_back (DIEInfo(cu, die));
122    }
123
124
125    void LogDIEs (Log *log, SymbolFileDWARF *dwarf)
126    {
127        StreamString log_strm;
128        const size_t n = m_dies.size();
129        log_strm.Printf("DIEStack[%" PRIu64 "]:\n", (uint64_t)n);
130        for (size_t i=0; i<n; i++)
131        {
132            DWARFCompileUnit *cu = m_dies[i].cu;
133            const DWARFDebugInfoEntry *die = m_dies[i].die;
134            std::string qualified_name;
135            die->GetQualifiedName(dwarf, cu, qualified_name);
136            log_strm.Printf ("[%" PRIu64 "] 0x%8.8x: %s name='%s'\n",
137                             (uint64_t)i,
138                             die->GetOffset(),
139                             DW_TAG_value_to_name(die->Tag()),
140                             qualified_name.c_str());
141        }
142        log->PutCString(log_strm.GetData());
143    }
144    void Pop ()
145    {
146        m_dies.pop_back();
147    }
148
149    class ScopedPopper
150    {
151    public:
152        ScopedPopper (DIEStack &die_stack) :
153            m_die_stack (die_stack),
154            m_valid (false)
155        {
156        }
157
158        void
159        Push (DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die)
160        {
161            m_valid = true;
162            m_die_stack.Push (cu, die);
163        }
164
165        ~ScopedPopper ()
166        {
167            if (m_valid)
168                m_die_stack.Pop();
169        }
170
171
172
173    protected:
174        DIEStack &m_die_stack;
175        bool m_valid;
176    };
177
178protected:
179    struct DIEInfo {
180        DIEInfo (DWARFCompileUnit *c, const DWARFDebugInfoEntry *d) :
181            cu(c),
182            die(d)
183        {
184        }
185        DWARFCompileUnit *cu;
186        const DWARFDebugInfoEntry *die;
187    };
188    typedef std::vector<DIEInfo> Stack;
189    Stack m_dies;
190};
191#endif
192
193void
194SymbolFileDWARF::Initialize()
195{
196    LogChannelDWARF::Initialize();
197    PluginManager::RegisterPlugin (GetPluginNameStatic(),
198                                   GetPluginDescriptionStatic(),
199                                   CreateInstance);
200}
201
202void
203SymbolFileDWARF::Terminate()
204{
205    PluginManager::UnregisterPlugin (CreateInstance);
206    LogChannelDWARF::Initialize();
207}
208
209
210lldb_private::ConstString
211SymbolFileDWARF::GetPluginNameStatic()
212{
213    static ConstString g_name("dwarf");
214    return g_name;
215}
216
217const char *
218SymbolFileDWARF::GetPluginDescriptionStatic()
219{
220    return "DWARF and DWARF3 debug symbol file reader.";
221}
222
223
224SymbolFile*
225SymbolFileDWARF::CreateInstance (ObjectFile* obj_file)
226{
227    return new SymbolFileDWARF(obj_file);
228}
229
230TypeList *
231SymbolFileDWARF::GetTypeList ()
232{
233    if (GetDebugMapSymfile ())
234        return m_debug_map_symfile->GetTypeList();
235    return m_obj_file->GetModule()->GetTypeList();
236
237}
238void
239SymbolFileDWARF::GetTypes (DWARFCompileUnit* cu,
240                           const DWARFDebugInfoEntry *die,
241                           dw_offset_t min_die_offset,
242                           dw_offset_t max_die_offset,
243                           uint32_t type_mask,
244                           TypeSet &type_set)
245{
246    if (cu)
247    {
248        if (die)
249        {
250            const dw_offset_t die_offset = die->GetOffset();
251
252            if (die_offset >= max_die_offset)
253                return;
254
255            if (die_offset >= min_die_offset)
256            {
257                const dw_tag_t tag = die->Tag();
258
259                bool add_type = false;
260
261                switch (tag)
262                {
263                    case DW_TAG_array_type:         add_type = (type_mask & eTypeClassArray         ) != 0; break;
264                    case DW_TAG_unspecified_type:
265                    case DW_TAG_base_type:          add_type = (type_mask & eTypeClassBuiltin       ) != 0; break;
266                    case DW_TAG_class_type:         add_type = (type_mask & eTypeClassClass         ) != 0; break;
267                    case DW_TAG_structure_type:     add_type = (type_mask & eTypeClassStruct        ) != 0; break;
268                    case DW_TAG_union_type:         add_type = (type_mask & eTypeClassUnion         ) != 0; break;
269                    case DW_TAG_enumeration_type:   add_type = (type_mask & eTypeClassEnumeration   ) != 0; break;
270                    case DW_TAG_subroutine_type:
271                    case DW_TAG_subprogram:
272                    case DW_TAG_inlined_subroutine: add_type = (type_mask & eTypeClassFunction      ) != 0; break;
273                    case DW_TAG_pointer_type:       add_type = (type_mask & eTypeClassPointer       ) != 0; break;
274                    case DW_TAG_rvalue_reference_type:
275                    case DW_TAG_reference_type:     add_type = (type_mask & eTypeClassReference     ) != 0; break;
276                    case DW_TAG_typedef:            add_type = (type_mask & eTypeClassTypedef       ) != 0; break;
277                    case DW_TAG_ptr_to_member_type: add_type = (type_mask & eTypeClassMemberPointer ) != 0; break;
278                }
279
280                if (add_type)
281                {
282                    const bool assert_not_being_parsed = true;
283                    Type *type = ResolveTypeUID (cu, die, assert_not_being_parsed);
284                    if (type)
285                    {
286                        if (type_set.find(type) == type_set.end())
287                            type_set.insert(type);
288                    }
289                }
290            }
291
292            for (const DWARFDebugInfoEntry *child_die = die->GetFirstChild();
293                 child_die != NULL;
294                 child_die = child_die->GetSibling())
295            {
296                GetTypes (cu, child_die, min_die_offset, max_die_offset, type_mask, type_set);
297            }
298        }
299    }
300}
301
302size_t
303SymbolFileDWARF::GetTypes (SymbolContextScope *sc_scope,
304                           uint32_t type_mask,
305                           TypeList &type_list)
306
307{
308    TypeSet type_set;
309
310    CompileUnit *comp_unit = NULL;
311    DWARFCompileUnit* dwarf_cu = NULL;
312    if (sc_scope)
313        comp_unit = sc_scope->CalculateSymbolContextCompileUnit();
314
315    if (comp_unit)
316    {
317        dwarf_cu = GetDWARFCompileUnit(comp_unit);
318        if (dwarf_cu == 0)
319            return 0;
320        GetTypes (dwarf_cu,
321                  dwarf_cu->DIE(),
322                  dwarf_cu->GetOffset(),
323                  dwarf_cu->GetNextCompileUnitOffset(),
324                  type_mask,
325                  type_set);
326    }
327    else
328    {
329        DWARFDebugInfo* info = DebugInfo();
330        if (info)
331        {
332            const size_t num_cus = info->GetNumCompileUnits();
333            for (size_t cu_idx=0; cu_idx<num_cus; ++cu_idx)
334            {
335                dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
336                if (dwarf_cu)
337                {
338                    GetTypes (dwarf_cu,
339                              dwarf_cu->DIE(),
340                              0,
341                              UINT32_MAX,
342                              type_mask,
343                              type_set);
344                }
345            }
346        }
347    }
348//    if (m_using_apple_tables)
349//    {
350//        DWARFMappedHash::MemoryTable *apple_types = m_apple_types_ap.get();
351//        if (apple_types)
352//        {
353//            apple_types->ForEach([this, &type_set, apple_types, type_mask](const DWARFMappedHash::DIEInfoArray &die_info_array) -> bool {
354//
355//                for (auto die_info: die_info_array)
356//                {
357//                    bool add_type = TagMatchesTypeMask (type_mask, 0);
358//                    if (!add_type)
359//                    {
360//                        dw_tag_t tag = die_info.tag;
361//                        if (tag == 0)
362//                        {
363//                            const DWARFDebugInfoEntry *die = DebugInfo()->GetDIEPtr(die_info.offset, NULL);
364//                            tag = die->Tag();
365//                        }
366//                        add_type = TagMatchesTypeMask (type_mask, tag);
367//                    }
368//                    if (add_type)
369//                    {
370//                        Type *type = ResolveTypeUID(die_info.offset);
371//
372//                        if (type_set.find(type) == type_set.end())
373//                            type_set.insert(type);
374//                    }
375//                }
376//                return true; // Keep iterating
377//            });
378//        }
379//    }
380//    else
381//    {
382//        if (!m_indexed)
383//            Index ();
384//
385//        m_type_index.ForEach([this, &type_set, type_mask](const char *name, uint32_t die_offset) -> bool {
386//
387//            bool add_type = TagMatchesTypeMask (type_mask, 0);
388//
389//            if (!add_type)
390//            {
391//                const DWARFDebugInfoEntry *die = DebugInfo()->GetDIEPtr(die_offset, NULL);
392//                if (die)
393//                {
394//                    const dw_tag_t tag = die->Tag();
395//                    add_type = TagMatchesTypeMask (type_mask, tag);
396//                }
397//            }
398//
399//            if (add_type)
400//            {
401//                Type *type = ResolveTypeUID(die_offset);
402//
403//                if (type_set.find(type) == type_set.end())
404//                    type_set.insert(type);
405//            }
406//            return true; // Keep iterating
407//        });
408//    }
409
410    std::set<ClangASTType> clang_type_set;
411    size_t num_types_added = 0;
412    for (Type *type : type_set)
413    {
414        ClangASTType clang_type = type->GetClangForwardType();
415        if (clang_type_set.find(clang_type) == clang_type_set.end())
416        {
417            clang_type_set.insert(clang_type);
418            type_list.Insert (type->shared_from_this());
419            ++num_types_added;
420        }
421    }
422    return num_types_added;
423}
424
425
426//----------------------------------------------------------------------
427// Gets the first parent that is a lexical block, function or inlined
428// subroutine, or compile unit.
429//----------------------------------------------------------------------
430static const DWARFDebugInfoEntry *
431GetParentSymbolContextDIE(const DWARFDebugInfoEntry *child_die)
432{
433    const DWARFDebugInfoEntry *die;
434    for (die = child_die->GetParent(); die != NULL; die = die->GetParent())
435    {
436        dw_tag_t tag = die->Tag();
437
438        switch (tag)
439        {
440        case DW_TAG_compile_unit:
441        case DW_TAG_subprogram:
442        case DW_TAG_inlined_subroutine:
443        case DW_TAG_lexical_block:
444            return die;
445        }
446    }
447    return NULL;
448}
449
450
451SymbolFileDWARF::SymbolFileDWARF(ObjectFile* objfile) :
452    SymbolFile (objfile),
453    UserID (0),  // Used by SymbolFileDWARFDebugMap to when this class parses .o files to contain the .o file index/ID
454    m_debug_map_module_wp (),
455    m_debug_map_symfile (NULL),
456    m_clang_tu_decl (NULL),
457    m_flags(),
458    m_data_debug_abbrev (),
459    m_data_debug_aranges (),
460    m_data_debug_frame (),
461    m_data_debug_info (),
462    m_data_debug_line (),
463    m_data_debug_loc (),
464    m_data_debug_ranges (),
465    m_data_debug_str (),
466    m_data_apple_names (),
467    m_data_apple_types (),
468    m_data_apple_namespaces (),
469    m_abbr(),
470    m_info(),
471    m_line(),
472    m_apple_names_ap (),
473    m_apple_types_ap (),
474    m_apple_namespaces_ap (),
475    m_apple_objc_ap (),
476    m_function_basename_index(),
477    m_function_fullname_index(),
478    m_function_method_index(),
479    m_function_selector_index(),
480    m_objc_class_selectors_index(),
481    m_global_index(),
482    m_type_index(),
483    m_namespace_index(),
484    m_indexed (false),
485    m_is_external_ast_source (false),
486    m_using_apple_tables (false),
487    m_supports_DW_AT_APPLE_objc_complete_type (eLazyBoolCalculate),
488    m_ranges(),
489    m_unique_ast_type_map ()
490{
491}
492
493SymbolFileDWARF::~SymbolFileDWARF()
494{
495    if (m_is_external_ast_source)
496    {
497        ModuleSP module_sp (m_obj_file->GetModule());
498        if (module_sp)
499            module_sp->GetClangASTContext().RemoveExternalSource ();
500    }
501}
502
503static const ConstString &
504GetDWARFMachOSegmentName ()
505{
506    static ConstString g_dwarf_section_name ("__DWARF");
507    return g_dwarf_section_name;
508}
509
510UniqueDWARFASTTypeMap &
511SymbolFileDWARF::GetUniqueDWARFASTTypeMap ()
512{
513    if (GetDebugMapSymfile ())
514        return m_debug_map_symfile->GetUniqueDWARFASTTypeMap ();
515    return m_unique_ast_type_map;
516}
517
518ClangASTContext &
519SymbolFileDWARF::GetClangASTContext ()
520{
521    if (GetDebugMapSymfile ())
522        return m_debug_map_symfile->GetClangASTContext ();
523
524    ClangASTContext &ast = m_obj_file->GetModule()->GetClangASTContext();
525    if (!m_is_external_ast_source)
526    {
527        m_is_external_ast_source = true;
528        llvm::OwningPtr<clang::ExternalASTSource> ast_source_ap (
529            new ClangExternalASTSourceCallbacks (SymbolFileDWARF::CompleteTagDecl,
530                                                 SymbolFileDWARF::CompleteObjCInterfaceDecl,
531                                                 SymbolFileDWARF::FindExternalVisibleDeclsByName,
532                                                 SymbolFileDWARF::LayoutRecordType,
533                                                 this));
534        ast.SetExternalSource (ast_source_ap);
535    }
536    return ast;
537}
538
539void
540SymbolFileDWARF::InitializeObject()
541{
542    // Install our external AST source callbacks so we can complete Clang types.
543    ModuleSP module_sp (m_obj_file->GetModule());
544    if (module_sp)
545    {
546        const SectionList *section_list = module_sp->GetSectionList();
547
548        const Section* section = section_list->FindSectionByName(GetDWARFMachOSegmentName ()).get();
549
550        // Memory map the DWARF mach-o segment so we have everything mmap'ed
551        // to keep our heap memory usage down.
552        if (section)
553            m_obj_file->MemoryMapSectionData(section, m_dwarf_data);
554    }
555    get_apple_names_data();
556    if (m_data_apple_names.GetByteSize() > 0)
557    {
558        m_apple_names_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_names, get_debug_str_data(), ".apple_names"));
559        if (m_apple_names_ap->IsValid())
560            m_using_apple_tables = true;
561        else
562            m_apple_names_ap.reset();
563    }
564    get_apple_types_data();
565    if (m_data_apple_types.GetByteSize() > 0)
566    {
567        m_apple_types_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_types, get_debug_str_data(), ".apple_types"));
568        if (m_apple_types_ap->IsValid())
569            m_using_apple_tables = true;
570        else
571            m_apple_types_ap.reset();
572    }
573
574    get_apple_namespaces_data();
575    if (m_data_apple_namespaces.GetByteSize() > 0)
576    {
577        m_apple_namespaces_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_namespaces, get_debug_str_data(), ".apple_namespaces"));
578        if (m_apple_namespaces_ap->IsValid())
579            m_using_apple_tables = true;
580        else
581            m_apple_namespaces_ap.reset();
582    }
583
584    get_apple_objc_data();
585    if (m_data_apple_objc.GetByteSize() > 0)
586    {
587        m_apple_objc_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_objc, get_debug_str_data(), ".apple_objc"));
588        if (m_apple_objc_ap->IsValid())
589            m_using_apple_tables = true;
590        else
591            m_apple_objc_ap.reset();
592    }
593}
594
595bool
596SymbolFileDWARF::SupportedVersion(uint16_t version)
597{
598    return version == 2 || version == 3 || version == 4;
599}
600
601uint32_t
602SymbolFileDWARF::CalculateAbilities ()
603{
604    uint32_t abilities = 0;
605    if (m_obj_file != NULL)
606    {
607        const Section* section = NULL;
608        const SectionList *section_list = m_obj_file->GetSectionList();
609        if (section_list == NULL)
610            return 0;
611
612        uint64_t debug_abbrev_file_size = 0;
613        uint64_t debug_info_file_size = 0;
614        uint64_t debug_line_file_size = 0;
615
616        section = section_list->FindSectionByName(GetDWARFMachOSegmentName ()).get();
617
618        if (section)
619            section_list = &section->GetChildren ();
620
621        section = section_list->FindSectionByType (eSectionTypeDWARFDebugInfo, true).get();
622        if (section != NULL)
623        {
624            debug_info_file_size = section->GetFileSize();
625
626            section = section_list->FindSectionByType (eSectionTypeDWARFDebugAbbrev, true).get();
627            if (section)
628                debug_abbrev_file_size = section->GetFileSize();
629            else
630                m_flags.Set (flagsGotDebugAbbrevData);
631
632            section = section_list->FindSectionByType (eSectionTypeDWARFDebugAranges, true).get();
633            if (!section)
634                m_flags.Set (flagsGotDebugArangesData);
635
636            section = section_list->FindSectionByType (eSectionTypeDWARFDebugFrame, true).get();
637            if (!section)
638                m_flags.Set (flagsGotDebugFrameData);
639
640            section = section_list->FindSectionByType (eSectionTypeDWARFDebugLine, true).get();
641            if (section)
642                debug_line_file_size = section->GetFileSize();
643            else
644                m_flags.Set (flagsGotDebugLineData);
645
646            section = section_list->FindSectionByType (eSectionTypeDWARFDebugLoc, true).get();
647            if (!section)
648                m_flags.Set (flagsGotDebugLocData);
649
650            section = section_list->FindSectionByType (eSectionTypeDWARFDebugMacInfo, true).get();
651            if (!section)
652                m_flags.Set (flagsGotDebugMacInfoData);
653
654            section = section_list->FindSectionByType (eSectionTypeDWARFDebugPubNames, true).get();
655            if (!section)
656                m_flags.Set (flagsGotDebugPubNamesData);
657
658            section = section_list->FindSectionByType (eSectionTypeDWARFDebugPubTypes, true).get();
659            if (!section)
660                m_flags.Set (flagsGotDebugPubTypesData);
661
662            section = section_list->FindSectionByType (eSectionTypeDWARFDebugRanges, true).get();
663            if (!section)
664                m_flags.Set (flagsGotDebugRangesData);
665
666            section = section_list->FindSectionByType (eSectionTypeDWARFDebugStr, true).get();
667            if (!section)
668                m_flags.Set (flagsGotDebugStrData);
669        }
670        else
671        {
672            const char *symfile_dir_cstr = m_obj_file->GetFileSpec().GetDirectory().GetCString();
673            if (symfile_dir_cstr)
674            {
675                if (strcasestr(symfile_dir_cstr, ".dsym"))
676                {
677                    if (m_obj_file->GetType() == ObjectFile::eTypeDebugInfo)
678                    {
679                        // We have a dSYM file that didn't have a any debug info.
680                        // If the string table has a size of 1, then it was made from
681                        // an executable with no debug info, or from an executable that
682                        // was stripped.
683                        section = section_list->FindSectionByType (eSectionTypeDWARFDebugStr, true).get();
684                        if (section && section->GetFileSize() == 1)
685                        {
686                            m_obj_file->GetModule()->ReportWarning ("empty dSYM file detected, dSYM was created with an executable with no debug info.");
687                        }
688                    }
689                }
690            }
691        }
692
693        if (debug_abbrev_file_size > 0 && debug_info_file_size > 0)
694            abilities |= CompileUnits | Functions | Blocks | GlobalVariables | LocalVariables | VariableTypes;
695
696        if (debug_line_file_size > 0)
697            abilities |= LineTables;
698    }
699    return abilities;
700}
701
702const DataExtractor&
703SymbolFileDWARF::GetCachedSectionData (uint32_t got_flag, SectionType sect_type, DataExtractor &data)
704{
705    if (m_flags.IsClear (got_flag))
706    {
707        ModuleSP module_sp (m_obj_file->GetModule());
708        m_flags.Set (got_flag);
709        const SectionList *section_list = module_sp->GetSectionList();
710        if (section_list)
711        {
712            SectionSP section_sp (section_list->FindSectionByType(sect_type, true));
713            if (section_sp)
714            {
715                // See if we memory mapped the DWARF segment?
716                if (m_dwarf_data.GetByteSize())
717                {
718                    data.SetData(m_dwarf_data, section_sp->GetOffset (), section_sp->GetFileSize());
719                }
720                else
721                {
722                    if (m_obj_file->ReadSectionData (section_sp.get(), data) == 0)
723                        data.Clear();
724                }
725            }
726        }
727    }
728    return data;
729}
730
731const DataExtractor&
732SymbolFileDWARF::get_debug_abbrev_data()
733{
734    return GetCachedSectionData (flagsGotDebugAbbrevData, eSectionTypeDWARFDebugAbbrev, m_data_debug_abbrev);
735}
736
737const DataExtractor&
738SymbolFileDWARF::get_debug_aranges_data()
739{
740    return GetCachedSectionData (flagsGotDebugArangesData, eSectionTypeDWARFDebugAranges, m_data_debug_aranges);
741}
742
743const DataExtractor&
744SymbolFileDWARF::get_debug_frame_data()
745{
746    return GetCachedSectionData (flagsGotDebugFrameData, eSectionTypeDWARFDebugFrame, m_data_debug_frame);
747}
748
749const DataExtractor&
750SymbolFileDWARF::get_debug_info_data()
751{
752    return GetCachedSectionData (flagsGotDebugInfoData, eSectionTypeDWARFDebugInfo, m_data_debug_info);
753}
754
755const DataExtractor&
756SymbolFileDWARF::get_debug_line_data()
757{
758    return GetCachedSectionData (flagsGotDebugLineData, eSectionTypeDWARFDebugLine, m_data_debug_line);
759}
760
761const DataExtractor&
762SymbolFileDWARF::get_debug_loc_data()
763{
764    return GetCachedSectionData (flagsGotDebugLocData, eSectionTypeDWARFDebugLoc, m_data_debug_loc);
765}
766
767const DataExtractor&
768SymbolFileDWARF::get_debug_ranges_data()
769{
770    return GetCachedSectionData (flagsGotDebugRangesData, eSectionTypeDWARFDebugRanges, m_data_debug_ranges);
771}
772
773const DataExtractor&
774SymbolFileDWARF::get_debug_str_data()
775{
776    return GetCachedSectionData (flagsGotDebugStrData, eSectionTypeDWARFDebugStr, m_data_debug_str);
777}
778
779const DataExtractor&
780SymbolFileDWARF::get_apple_names_data()
781{
782    return GetCachedSectionData (flagsGotAppleNamesData, eSectionTypeDWARFAppleNames, m_data_apple_names);
783}
784
785const DataExtractor&
786SymbolFileDWARF::get_apple_types_data()
787{
788    return GetCachedSectionData (flagsGotAppleTypesData, eSectionTypeDWARFAppleTypes, m_data_apple_types);
789}
790
791const DataExtractor&
792SymbolFileDWARF::get_apple_namespaces_data()
793{
794    return GetCachedSectionData (flagsGotAppleNamespacesData, eSectionTypeDWARFAppleNamespaces, m_data_apple_namespaces);
795}
796
797const DataExtractor&
798SymbolFileDWARF::get_apple_objc_data()
799{
800    return GetCachedSectionData (flagsGotAppleObjCData, eSectionTypeDWARFAppleObjC, m_data_apple_objc);
801}
802
803
804DWARFDebugAbbrev*
805SymbolFileDWARF::DebugAbbrev()
806{
807    if (m_abbr.get() == NULL)
808    {
809        const DataExtractor &debug_abbrev_data = get_debug_abbrev_data();
810        if (debug_abbrev_data.GetByteSize() > 0)
811        {
812            m_abbr.reset(new DWARFDebugAbbrev());
813            if (m_abbr.get())
814                m_abbr->Parse(debug_abbrev_data);
815        }
816    }
817    return m_abbr.get();
818}
819
820const DWARFDebugAbbrev*
821SymbolFileDWARF::DebugAbbrev() const
822{
823    return m_abbr.get();
824}
825
826
827DWARFDebugInfo*
828SymbolFileDWARF::DebugInfo()
829{
830    if (m_info.get() == NULL)
831    {
832        Timer scoped_timer(__PRETTY_FUNCTION__, "%s this = %p", __PRETTY_FUNCTION__, this);
833        if (get_debug_info_data().GetByteSize() > 0)
834        {
835            m_info.reset(new DWARFDebugInfo());
836            if (m_info.get())
837            {
838                m_info->SetDwarfData(this);
839            }
840        }
841    }
842    return m_info.get();
843}
844
845const DWARFDebugInfo*
846SymbolFileDWARF::DebugInfo() const
847{
848    return m_info.get();
849}
850
851DWARFCompileUnit*
852SymbolFileDWARF::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit)
853{
854    DWARFDebugInfo* info = DebugInfo();
855    if (info)
856    {
857        if (GetDebugMapSymfile ())
858        {
859            // The debug map symbol file made the compile units for this DWARF
860            // file which is .o file with DWARF in it, and we should have
861            // only 1 compile unit which is at offset zero in the DWARF.
862            // TODO: modify to support LTO .o files where each .o file might
863            // have multiple DW_TAG_compile_unit tags.
864            return info->GetCompileUnit(0).get();
865        }
866        else
867        {
868            // Just a normal DWARF file whose user ID for the compile unit is
869            // the DWARF offset itself
870            return info->GetCompileUnit((dw_offset_t)comp_unit->GetID()).get();
871        }
872    }
873    return NULL;
874}
875
876
877DWARFDebugRanges*
878SymbolFileDWARF::DebugRanges()
879{
880    if (m_ranges.get() == NULL)
881    {
882        Timer scoped_timer(__PRETTY_FUNCTION__, "%s this = %p", __PRETTY_FUNCTION__, this);
883        if (get_debug_ranges_data().GetByteSize() > 0)
884        {
885            m_ranges.reset(new DWARFDebugRanges());
886            if (m_ranges.get())
887                m_ranges->Extract(this);
888        }
889    }
890    return m_ranges.get();
891}
892
893const DWARFDebugRanges*
894SymbolFileDWARF::DebugRanges() const
895{
896    return m_ranges.get();
897}
898
899lldb::CompUnitSP
900SymbolFileDWARF::ParseCompileUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx)
901{
902    CompUnitSP cu_sp;
903    if (dwarf_cu)
904    {
905        CompileUnit *comp_unit = (CompileUnit*)dwarf_cu->GetUserData();
906        if (comp_unit)
907        {
908            // We already parsed this compile unit, had out a shared pointer to it
909            cu_sp = comp_unit->shared_from_this();
910        }
911        else
912        {
913            if (GetDebugMapSymfile ())
914            {
915                // Let the debug map create the compile unit
916                cu_sp = m_debug_map_symfile->GetCompileUnit(this);
917                dwarf_cu->SetUserData(cu_sp.get());
918            }
919            else
920            {
921                ModuleSP module_sp (m_obj_file->GetModule());
922                if (module_sp)
923                {
924                    const DWARFDebugInfoEntry * cu_die = dwarf_cu->GetCompileUnitDIEOnly ();
925                    if (cu_die)
926                    {
927                        const char * cu_die_name = cu_die->GetName(this, dwarf_cu);
928                        const char * cu_comp_dir = cu_die->GetAttributeValueAsString(this, dwarf_cu, DW_AT_comp_dir, NULL);
929                        LanguageType cu_language = (LanguageType)cu_die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_language, 0);
930                        if (cu_die_name)
931                        {
932                            std::string ramapped_file;
933                            FileSpec cu_file_spec;
934
935                            if (cu_die_name[0] == '/' || cu_comp_dir == NULL || cu_comp_dir[0] == '\0')
936                            {
937                                // If we have a full path to the compile unit, we don't need to resolve
938                                // the file.  This can be expensive e.g. when the source files are NFS mounted.
939                                if (module_sp->RemapSourceFile(cu_die_name, ramapped_file))
940                                    cu_file_spec.SetFile (ramapped_file.c_str(), false);
941                                else
942                                    cu_file_spec.SetFile (cu_die_name, false);
943                            }
944                            else
945                            {
946                                std::string fullpath(cu_comp_dir);
947                                if (*fullpath.rbegin() != '/')
948                                    fullpath += '/';
949                                fullpath += cu_die_name;
950                                if (module_sp->RemapSourceFile (fullpath.c_str(), ramapped_file))
951                                    cu_file_spec.SetFile (ramapped_file.c_str(), false);
952                                else
953                                    cu_file_spec.SetFile (fullpath.c_str(), false);
954                            }
955
956                            cu_sp.reset(new CompileUnit (module_sp,
957                                                         dwarf_cu,
958                                                         cu_file_spec,
959                                                         MakeUserID(dwarf_cu->GetOffset()),
960                                                         cu_language));
961                            if (cu_sp)
962                            {
963                                dwarf_cu->SetUserData(cu_sp.get());
964
965                                // Figure out the compile unit index if we weren't given one
966                                if (cu_idx == UINT32_MAX)
967                                    DebugInfo()->GetCompileUnit(dwarf_cu->GetOffset(), &cu_idx);
968
969                                m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(cu_idx, cu_sp);
970                            }
971                        }
972                    }
973                }
974            }
975        }
976    }
977    return cu_sp;
978}
979
980uint32_t
981SymbolFileDWARF::GetNumCompileUnits()
982{
983    DWARFDebugInfo* info = DebugInfo();
984    if (info)
985        return info->GetNumCompileUnits();
986    return 0;
987}
988
989CompUnitSP
990SymbolFileDWARF::ParseCompileUnitAtIndex(uint32_t cu_idx)
991{
992    CompUnitSP cu_sp;
993    DWARFDebugInfo* info = DebugInfo();
994    if (info)
995    {
996        DWARFCompileUnit* dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
997        if (dwarf_cu)
998            cu_sp = ParseCompileUnit(dwarf_cu, cu_idx);
999    }
1000    return cu_sp;
1001}
1002
1003static void
1004AddRangesToBlock (Block& block,
1005                  DWARFDebugRanges::RangeList& ranges,
1006                  addr_t block_base_addr)
1007{
1008    const size_t num_ranges = ranges.GetSize();
1009    for (size_t i = 0; i<num_ranges; ++i)
1010    {
1011        const DWARFDebugRanges::Range &range = ranges.GetEntryRef (i);
1012        const addr_t range_base = range.GetRangeBase();
1013        assert (range_base >= block_base_addr);
1014        block.AddRange(Block::Range (range_base - block_base_addr, range.GetByteSize()));;
1015    }
1016    block.FinalizeRanges ();
1017}
1018
1019
1020Function *
1021SymbolFileDWARF::ParseCompileUnitFunction (const SymbolContext& sc, DWARFCompileUnit* dwarf_cu, const DWARFDebugInfoEntry *die)
1022{
1023    DWARFDebugRanges::RangeList func_ranges;
1024    const char *name = NULL;
1025    const char *mangled = NULL;
1026    int decl_file = 0;
1027    int decl_line = 0;
1028    int decl_column = 0;
1029    int call_file = 0;
1030    int call_line = 0;
1031    int call_column = 0;
1032    DWARFExpression frame_base;
1033
1034    assert (die->Tag() == DW_TAG_subprogram);
1035
1036    if (die->Tag() != DW_TAG_subprogram)
1037        return NULL;
1038
1039    if (die->GetDIENamesAndRanges (this,
1040                                   dwarf_cu,
1041                                   name,
1042                                   mangled,
1043                                   func_ranges,
1044                                   decl_file,
1045                                   decl_line,
1046                                   decl_column,
1047                                   call_file,
1048                                   call_line,
1049                                   call_column,
1050                                   &frame_base))
1051    {
1052        // Union of all ranges in the function DIE (if the function is discontiguous)
1053        AddressRange func_range;
1054        lldb::addr_t lowest_func_addr = func_ranges.GetMinRangeBase (0);
1055        lldb::addr_t highest_func_addr = func_ranges.GetMaxRangeEnd (0);
1056        if (lowest_func_addr != LLDB_INVALID_ADDRESS && lowest_func_addr <= highest_func_addr)
1057        {
1058            ModuleSP module_sp (m_obj_file->GetModule());
1059            func_range.GetBaseAddress().ResolveAddressUsingFileSections (lowest_func_addr, module_sp->GetSectionList());
1060            if (func_range.GetBaseAddress().IsValid())
1061                func_range.SetByteSize(highest_func_addr - lowest_func_addr);
1062        }
1063
1064        if (func_range.GetBaseAddress().IsValid())
1065        {
1066            Mangled func_name;
1067            if (mangled)
1068                func_name.SetValue(ConstString(mangled), true);
1069            else if (name)
1070                func_name.SetValue(ConstString(name), false);
1071
1072            FunctionSP func_sp;
1073            std::unique_ptr<Declaration> decl_ap;
1074            if (decl_file != 0 || decl_line != 0 || decl_column != 0)
1075                decl_ap.reset(new Declaration (sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
1076                                               decl_line,
1077                                               decl_column));
1078
1079            // Supply the type _only_ if it has already been parsed
1080            Type *func_type = m_die_to_type.lookup (die);
1081
1082            assert(func_type == NULL || func_type != DIE_IS_BEING_PARSED);
1083
1084            if (FixupAddress (func_range.GetBaseAddress()))
1085            {
1086                const user_id_t func_user_id = MakeUserID(die->GetOffset());
1087                func_sp.reset(new Function (sc.comp_unit,
1088                                            MakeUserID(func_user_id),       // UserID is the DIE offset
1089                                            MakeUserID(func_user_id),
1090                                            func_name,
1091                                            func_type,
1092                                            func_range));           // first address range
1093
1094                if (func_sp.get() != NULL)
1095                {
1096                    if (frame_base.IsValid())
1097                        func_sp->GetFrameBaseExpression() = frame_base;
1098                    sc.comp_unit->AddFunction(func_sp);
1099                    return func_sp.get();
1100                }
1101            }
1102        }
1103    }
1104    return NULL;
1105}
1106
1107bool
1108SymbolFileDWARF::FixupAddress (Address &addr)
1109{
1110    SymbolFileDWARFDebugMap * debug_map_symfile = GetDebugMapSymfile ();
1111    if (debug_map_symfile)
1112    {
1113        return debug_map_symfile->LinkOSOAddress(addr);
1114    }
1115    // This is a normal DWARF file, no address fixups need to happen
1116    return true;
1117}
1118lldb::LanguageType
1119SymbolFileDWARF::ParseCompileUnitLanguage (const SymbolContext& sc)
1120{
1121    assert (sc.comp_unit);
1122    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
1123    if (dwarf_cu)
1124    {
1125        const DWARFDebugInfoEntry *die = dwarf_cu->GetCompileUnitDIEOnly();
1126        if (die)
1127        {
1128            const uint32_t language = die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_language, 0);
1129            if (language)
1130                return (lldb::LanguageType)language;
1131        }
1132    }
1133    return eLanguageTypeUnknown;
1134}
1135
1136size_t
1137SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc)
1138{
1139    assert (sc.comp_unit);
1140    size_t functions_added = 0;
1141    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
1142    if (dwarf_cu)
1143    {
1144        DWARFDIECollection function_dies;
1145        const size_t num_functions = dwarf_cu->AppendDIEsWithTag (DW_TAG_subprogram, function_dies);
1146        size_t func_idx;
1147        for (func_idx = 0; func_idx < num_functions; ++func_idx)
1148        {
1149            const DWARFDebugInfoEntry *die = function_dies.GetDIEPtrAtIndex(func_idx);
1150            if (sc.comp_unit->FindFunctionByUID (MakeUserID(die->GetOffset())).get() == NULL)
1151            {
1152                if (ParseCompileUnitFunction(sc, dwarf_cu, die))
1153                    ++functions_added;
1154            }
1155        }
1156        //FixupTypes();
1157    }
1158    return functions_added;
1159}
1160
1161bool
1162SymbolFileDWARF::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files)
1163{
1164    assert (sc.comp_unit);
1165    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
1166    if (dwarf_cu)
1167    {
1168        const DWARFDebugInfoEntry * cu_die = dwarf_cu->GetCompileUnitDIEOnly();
1169
1170        if (cu_die)
1171        {
1172            const char * cu_comp_dir = cu_die->GetAttributeValueAsString(this, dwarf_cu, DW_AT_comp_dir, NULL);
1173            dw_offset_t stmt_list = cu_die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_stmt_list, DW_INVALID_OFFSET);
1174
1175            // All file indexes in DWARF are one based and a file of index zero is
1176            // supposed to be the compile unit itself.
1177            support_files.Append (*sc.comp_unit);
1178
1179            return DWARFDebugLine::ParseSupportFiles(sc.comp_unit->GetModule(), get_debug_line_data(), cu_comp_dir, stmt_list, support_files);
1180        }
1181    }
1182    return false;
1183}
1184
1185struct ParseDWARFLineTableCallbackInfo
1186{
1187    LineTable* line_table;
1188    std::unique_ptr<LineSequence> sequence_ap;
1189};
1190
1191//----------------------------------------------------------------------
1192// ParseStatementTableCallback
1193//----------------------------------------------------------------------
1194static void
1195ParseDWARFLineTableCallback(dw_offset_t offset, const DWARFDebugLine::State& state, void* userData)
1196{
1197    if (state.row == DWARFDebugLine::State::StartParsingLineTable)
1198    {
1199        // Just started parsing the line table
1200    }
1201    else if (state.row == DWARFDebugLine::State::DoneParsingLineTable)
1202    {
1203        // Done parsing line table, nothing to do for the cleanup
1204    }
1205    else
1206    {
1207        ParseDWARFLineTableCallbackInfo* info = (ParseDWARFLineTableCallbackInfo*)userData;
1208        LineTable* line_table = info->line_table;
1209
1210        // If this is our first time here, we need to create a
1211        // sequence container.
1212        if (!info->sequence_ap.get())
1213        {
1214            info->sequence_ap.reset(line_table->CreateLineSequenceContainer());
1215            assert(info->sequence_ap.get());
1216        }
1217        line_table->AppendLineEntryToSequence (info->sequence_ap.get(),
1218                                               state.address,
1219                                               state.line,
1220                                               state.column,
1221                                               state.file,
1222                                               state.is_stmt,
1223                                               state.basic_block,
1224                                               state.prologue_end,
1225                                               state.epilogue_begin,
1226                                               state.end_sequence);
1227        if (state.end_sequence)
1228        {
1229            // First, put the current sequence into the line table.
1230            line_table->InsertSequence(info->sequence_ap.get());
1231            // Then, empty it to prepare for the next sequence.
1232            info->sequence_ap->Clear();
1233        }
1234    }
1235}
1236
1237bool
1238SymbolFileDWARF::ParseCompileUnitLineTable (const SymbolContext &sc)
1239{
1240    assert (sc.comp_unit);
1241    if (sc.comp_unit->GetLineTable() != NULL)
1242        return true;
1243
1244    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
1245    if (dwarf_cu)
1246    {
1247        const DWARFDebugInfoEntry *dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly();
1248        if (dwarf_cu_die)
1249        {
1250            const dw_offset_t cu_line_offset = dwarf_cu_die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_stmt_list, DW_INVALID_OFFSET);
1251            if (cu_line_offset != DW_INVALID_OFFSET)
1252            {
1253                std::unique_ptr<LineTable> line_table_ap(new LineTable(sc.comp_unit));
1254                if (line_table_ap.get())
1255                {
1256                    ParseDWARFLineTableCallbackInfo info;
1257                    info.line_table = line_table_ap.get();
1258                    lldb::offset_t offset = cu_line_offset;
1259                    DWARFDebugLine::ParseStatementTable(get_debug_line_data(), &offset, ParseDWARFLineTableCallback, &info);
1260                    if (m_debug_map_symfile)
1261                    {
1262                        // We have an object file that has a line table with addresses
1263                        // that are not linked. We need to link the line table and convert
1264                        // the addresses that are relative to the .o file into addresses
1265                        // for the main executable.
1266                        sc.comp_unit->SetLineTable (m_debug_map_symfile->LinkOSOLineTable (this, line_table_ap.get()));
1267                    }
1268                    else
1269                    {
1270                        sc.comp_unit->SetLineTable(line_table_ap.release());
1271                        return true;
1272                    }
1273                }
1274            }
1275        }
1276    }
1277    return false;
1278}
1279
1280size_t
1281SymbolFileDWARF::ParseFunctionBlocks
1282(
1283    const SymbolContext& sc,
1284    Block *parent_block,
1285    DWARFCompileUnit* dwarf_cu,
1286    const DWARFDebugInfoEntry *die,
1287    addr_t subprogram_low_pc,
1288    uint32_t depth
1289)
1290{
1291    size_t blocks_added = 0;
1292    while (die != NULL)
1293    {
1294        dw_tag_t tag = die->Tag();
1295
1296        switch (tag)
1297        {
1298        case DW_TAG_inlined_subroutine:
1299        case DW_TAG_subprogram:
1300        case DW_TAG_lexical_block:
1301            {
1302                Block *block = NULL;
1303                if (tag == DW_TAG_subprogram)
1304                {
1305                    // Skip any DW_TAG_subprogram DIEs that are inside
1306                    // of a normal or inlined functions. These will be
1307                    // parsed on their own as separate entities.
1308
1309                    if (depth > 0)
1310                        break;
1311
1312                    block = parent_block;
1313                }
1314                else
1315                {
1316                    BlockSP block_sp(new Block (MakeUserID(die->GetOffset())));
1317                    parent_block->AddChild(block_sp);
1318                    block = block_sp.get();
1319                }
1320                DWARFDebugRanges::RangeList ranges;
1321                const char *name = NULL;
1322                const char *mangled_name = NULL;
1323
1324                int decl_file = 0;
1325                int decl_line = 0;
1326                int decl_column = 0;
1327                int call_file = 0;
1328                int call_line = 0;
1329                int call_column = 0;
1330                if (die->GetDIENamesAndRanges (this,
1331                                               dwarf_cu,
1332                                               name,
1333                                               mangled_name,
1334                                               ranges,
1335                                               decl_file, decl_line, decl_column,
1336                                               call_file, call_line, call_column))
1337                {
1338                    if (tag == DW_TAG_subprogram)
1339                    {
1340                        assert (subprogram_low_pc == LLDB_INVALID_ADDRESS);
1341                        subprogram_low_pc = ranges.GetMinRangeBase(0);
1342                    }
1343                    else if (tag == DW_TAG_inlined_subroutine)
1344                    {
1345                        // We get called here for inlined subroutines in two ways.
1346                        // The first time is when we are making the Function object
1347                        // for this inlined concrete instance.  Since we're creating a top level block at
1348                        // here, the subprogram_low_pc will be LLDB_INVALID_ADDRESS.  So we need to
1349                        // adjust the containing address.
1350                        // The second time is when we are parsing the blocks inside the function that contains
1351                        // the inlined concrete instance.  Since these will be blocks inside the containing "real"
1352                        // function the offset will be for that function.
1353                        if (subprogram_low_pc == LLDB_INVALID_ADDRESS)
1354                        {
1355                            subprogram_low_pc = ranges.GetMinRangeBase(0);
1356                        }
1357                    }
1358
1359                    AddRangesToBlock (*block, ranges, subprogram_low_pc);
1360
1361                    if (tag != DW_TAG_subprogram && (name != NULL || mangled_name != NULL))
1362                    {
1363                        std::unique_ptr<Declaration> decl_ap;
1364                        if (decl_file != 0 || decl_line != 0 || decl_column != 0)
1365                            decl_ap.reset(new Declaration(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
1366                                                          decl_line, decl_column));
1367
1368                        std::unique_ptr<Declaration> call_ap;
1369                        if (call_file != 0 || call_line != 0 || call_column != 0)
1370                            call_ap.reset(new Declaration(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(call_file),
1371                                                          call_line, call_column));
1372
1373                        block->SetInlinedFunctionInfo (name, mangled_name, decl_ap.get(), call_ap.get());
1374                    }
1375
1376                    ++blocks_added;
1377
1378                    if (die->HasChildren())
1379                    {
1380                        blocks_added += ParseFunctionBlocks (sc,
1381                                                             block,
1382                                                             dwarf_cu,
1383                                                             die->GetFirstChild(),
1384                                                             subprogram_low_pc,
1385                                                             depth + 1);
1386                    }
1387                }
1388            }
1389            break;
1390        default:
1391            break;
1392        }
1393
1394        // Only parse siblings of the block if we are not at depth zero. A depth
1395        // of zero indicates we are currently parsing the top level
1396        // DW_TAG_subprogram DIE
1397
1398        if (depth == 0)
1399            die = NULL;
1400        else
1401            die = die->GetSibling();
1402    }
1403    return blocks_added;
1404}
1405
1406bool
1407SymbolFileDWARF::ParseTemplateDIE (DWARFCompileUnit* dwarf_cu,
1408                                   const DWARFDebugInfoEntry *die,
1409                                   ClangASTContext::TemplateParameterInfos &template_param_infos)
1410{
1411    const dw_tag_t tag = die->Tag();
1412
1413    switch (tag)
1414    {
1415    case DW_TAG_template_type_parameter:
1416    case DW_TAG_template_value_parameter:
1417        {
1418            const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize());
1419
1420            DWARFDebugInfoEntry::Attributes attributes;
1421            const size_t num_attributes = die->GetAttributes (this,
1422                                                              dwarf_cu,
1423                                                              fixed_form_sizes,
1424                                                              attributes);
1425            const char *name = NULL;
1426            Type *lldb_type = NULL;
1427            ClangASTType clang_type;
1428            uint64_t uval64 = 0;
1429            bool uval64_valid = false;
1430            if (num_attributes > 0)
1431            {
1432                DWARFFormValue form_value;
1433                for (size_t i=0; i<num_attributes; ++i)
1434                {
1435                    const dw_attr_t attr = attributes.AttributeAtIndex(i);
1436
1437                    switch (attr)
1438                    {
1439                        case DW_AT_name:
1440                            if (attributes.ExtractFormValueAtIndex(this, i, form_value))
1441                                name = form_value.AsCString(&get_debug_str_data());
1442                            break;
1443
1444                        case DW_AT_type:
1445                            if (attributes.ExtractFormValueAtIndex(this, i, form_value))
1446                            {
1447                                const dw_offset_t type_die_offset = form_value.Reference(dwarf_cu);
1448                                lldb_type = ResolveTypeUID(type_die_offset);
1449                                if (lldb_type)
1450                                    clang_type = lldb_type->GetClangForwardType();
1451                            }
1452                            break;
1453
1454                        case DW_AT_const_value:
1455                            if (attributes.ExtractFormValueAtIndex(this, i, form_value))
1456                            {
1457                                uval64_valid = true;
1458                                uval64 = form_value.Unsigned();
1459                            }
1460                            break;
1461                        default:
1462                            break;
1463                    }
1464                }
1465
1466                clang::ASTContext *ast = GetClangASTContext().getASTContext();
1467                if (!clang_type)
1468                    clang_type = GetClangASTContext().GetBasicType(eBasicTypeVoid);
1469
1470                if (clang_type)
1471                {
1472                    bool is_signed = false;
1473                    if (name && name[0])
1474                        template_param_infos.names.push_back(name);
1475                    else
1476                        template_param_infos.names.push_back(NULL);
1477
1478                    if (tag == DW_TAG_template_value_parameter &&
1479                        lldb_type != NULL &&
1480                        clang_type.IsIntegerType (is_signed) &&
1481                        uval64_valid)
1482                    {
1483                        llvm::APInt apint (lldb_type->GetByteSize() * 8, uval64, is_signed);
1484                        template_param_infos.args.push_back (clang::TemplateArgument (*ast,
1485                                                                                      llvm::APSInt(apint),
1486                                                                                      clang_type.GetQualType()));
1487                    }
1488                    else
1489                    {
1490                        template_param_infos.args.push_back (clang::TemplateArgument (clang_type.GetQualType()));
1491                    }
1492                }
1493                else
1494                {
1495                    return false;
1496                }
1497
1498            }
1499        }
1500        return true;
1501
1502    default:
1503        break;
1504    }
1505    return false;
1506}
1507
1508bool
1509SymbolFileDWARF::ParseTemplateParameterInfos (DWARFCompileUnit* dwarf_cu,
1510                                              const DWARFDebugInfoEntry *parent_die,
1511                                              ClangASTContext::TemplateParameterInfos &template_param_infos)
1512{
1513
1514    if (parent_die == NULL)
1515        return false;
1516
1517    Args template_parameter_names;
1518    for (const DWARFDebugInfoEntry *die = parent_die->GetFirstChild();
1519         die != NULL;
1520         die = die->GetSibling())
1521    {
1522        const dw_tag_t tag = die->Tag();
1523
1524        switch (tag)
1525        {
1526            case DW_TAG_template_type_parameter:
1527            case DW_TAG_template_value_parameter:
1528                ParseTemplateDIE (dwarf_cu, die, template_param_infos);
1529            break;
1530
1531        default:
1532            break;
1533        }
1534    }
1535    if (template_param_infos.args.empty())
1536        return false;
1537    return template_param_infos.args.size() == template_param_infos.names.size();
1538}
1539
1540clang::ClassTemplateDecl *
1541SymbolFileDWARF::ParseClassTemplateDecl (clang::DeclContext *decl_ctx,
1542                                         lldb::AccessType access_type,
1543                                         const char *parent_name,
1544                                         int tag_decl_kind,
1545                                         const ClangASTContext::TemplateParameterInfos &template_param_infos)
1546{
1547    if (template_param_infos.IsValid())
1548    {
1549        std::string template_basename(parent_name);
1550        template_basename.erase (template_basename.find('<'));
1551        ClangASTContext &ast = GetClangASTContext();
1552
1553        return ast.CreateClassTemplateDecl (decl_ctx,
1554                                            access_type,
1555                                            template_basename.c_str(),
1556                                            tag_decl_kind,
1557                                            template_param_infos);
1558    }
1559    return NULL;
1560}
1561
1562class SymbolFileDWARF::DelayedAddObjCClassProperty
1563{
1564public:
1565    DelayedAddObjCClassProperty
1566    (
1567        const ClangASTType     &class_opaque_type,
1568        const char             *property_name,
1569        const ClangASTType     &property_opaque_type,  // The property type is only required if you don't have an ivar decl
1570        clang::ObjCIvarDecl    *ivar_decl,
1571        const char             *property_setter_name,
1572        const char             *property_getter_name,
1573        uint32_t                property_attributes,
1574        const ClangASTMetadata *metadata
1575    ) :
1576        m_class_opaque_type     (class_opaque_type),
1577        m_property_name         (property_name),
1578        m_property_opaque_type  (property_opaque_type),
1579        m_ivar_decl             (ivar_decl),
1580        m_property_setter_name  (property_setter_name),
1581        m_property_getter_name  (property_getter_name),
1582        m_property_attributes   (property_attributes)
1583    {
1584        if (metadata != NULL)
1585        {
1586            m_metadata_ap.reset(new ClangASTMetadata());
1587            *m_metadata_ap = *metadata;
1588        }
1589    }
1590
1591    DelayedAddObjCClassProperty (const DelayedAddObjCClassProperty &rhs)
1592    {
1593        *this = rhs;
1594    }
1595
1596    DelayedAddObjCClassProperty& operator= (const DelayedAddObjCClassProperty &rhs)
1597    {
1598        m_class_opaque_type    = rhs.m_class_opaque_type;
1599        m_property_name        = rhs.m_property_name;
1600        m_property_opaque_type = rhs.m_property_opaque_type;
1601        m_ivar_decl            = rhs.m_ivar_decl;
1602        m_property_setter_name = rhs.m_property_setter_name;
1603        m_property_getter_name = rhs.m_property_getter_name;
1604        m_property_attributes  = rhs.m_property_attributes;
1605
1606        if (rhs.m_metadata_ap.get())
1607        {
1608            m_metadata_ap.reset (new ClangASTMetadata());
1609            *m_metadata_ap = *rhs.m_metadata_ap;
1610        }
1611        return *this;
1612    }
1613
1614    bool
1615    Finalize()
1616    {
1617        return m_class_opaque_type.AddObjCClassProperty (m_property_name,
1618                                                         m_property_opaque_type,
1619                                                         m_ivar_decl,
1620                                                         m_property_setter_name,
1621                                                         m_property_getter_name,
1622                                                         m_property_attributes,
1623                                                         m_metadata_ap.get());
1624    }
1625private:
1626    ClangASTType            m_class_opaque_type;
1627    const char             *m_property_name;
1628    ClangASTType            m_property_opaque_type;
1629    clang::ObjCIvarDecl    *m_ivar_decl;
1630    const char             *m_property_setter_name;
1631    const char             *m_property_getter_name;
1632    uint32_t                m_property_attributes;
1633    std::unique_ptr<ClangASTMetadata> m_metadata_ap;
1634};
1635
1636struct BitfieldInfo
1637{
1638    uint64_t bit_size;
1639    uint64_t bit_offset;
1640
1641    BitfieldInfo () :
1642        bit_size (LLDB_INVALID_ADDRESS),
1643        bit_offset (LLDB_INVALID_ADDRESS)
1644    {
1645    }
1646
1647    bool IsValid ()
1648    {
1649        return (bit_size != LLDB_INVALID_ADDRESS) &&
1650               (bit_offset != LLDB_INVALID_ADDRESS);
1651    }
1652};
1653
1654
1655bool
1656SymbolFileDWARF::ClassOrStructIsVirtual (DWARFCompileUnit* dwarf_cu,
1657                                         const DWARFDebugInfoEntry *parent_die)
1658{
1659    if (parent_die)
1660    {
1661        for (const DWARFDebugInfoEntry *die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling())
1662        {
1663            dw_tag_t tag = die->Tag();
1664            bool check_virtuality = false;
1665            switch (tag)
1666            {
1667                case DW_TAG_inheritance:
1668                case DW_TAG_subprogram:
1669                    check_virtuality = true;
1670                    break;
1671                default:
1672                    break;
1673            }
1674            if (check_virtuality)
1675            {
1676                if (die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_virtuality, 0) != 0)
1677                    return true;
1678            }
1679        }
1680    }
1681    return false;
1682}
1683
1684size_t
1685SymbolFileDWARF::ParseChildMembers
1686(
1687    const SymbolContext& sc,
1688    DWARFCompileUnit* dwarf_cu,
1689    const DWARFDebugInfoEntry *parent_die,
1690    ClangASTType &class_clang_type,
1691    const LanguageType class_language,
1692    std::vector<clang::CXXBaseSpecifier *>& base_classes,
1693    std::vector<int>& member_accessibilities,
1694    DWARFDIECollection& member_function_dies,
1695    DelayedPropertyList& delayed_properties,
1696    AccessType& default_accessibility,
1697    bool &is_a_class,
1698    LayoutInfo &layout_info
1699)
1700{
1701    if (parent_die == NULL)
1702        return 0;
1703
1704    size_t count = 0;
1705    const DWARFDebugInfoEntry *die;
1706    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize());
1707    uint32_t member_idx = 0;
1708    BitfieldInfo last_field_info;
1709
1710    for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling())
1711    {
1712        dw_tag_t tag = die->Tag();
1713
1714        switch (tag)
1715        {
1716        case DW_TAG_member:
1717        case DW_TAG_APPLE_property:
1718            {
1719                DWARFDebugInfoEntry::Attributes attributes;
1720                const size_t num_attributes = die->GetAttributes (this,
1721                                                                  dwarf_cu,
1722                                                                  fixed_form_sizes,
1723                                                                  attributes);
1724                if (num_attributes > 0)
1725                {
1726                    Declaration decl;
1727                    //DWARFExpression location;
1728                    const char *name = NULL;
1729                    const char *prop_name = NULL;
1730                    const char *prop_getter_name = NULL;
1731                    const char *prop_setter_name = NULL;
1732                    uint32_t prop_attributes = 0;
1733
1734
1735                    bool is_artificial = false;
1736                    lldb::user_id_t encoding_uid = LLDB_INVALID_UID;
1737                    AccessType accessibility = eAccessNone;
1738                    uint32_t member_byte_offset = UINT32_MAX;
1739                    size_t byte_size = 0;
1740                    size_t bit_offset = 0;
1741                    size_t bit_size = 0;
1742                    bool is_external = false; // On DW_TAG_members, this means the member is static
1743                    uint32_t i;
1744                    for (i=0; i<num_attributes && !is_artificial; ++i)
1745                    {
1746                        const dw_attr_t attr = attributes.AttributeAtIndex(i);
1747                        DWARFFormValue form_value;
1748                        if (attributes.ExtractFormValueAtIndex(this, i, form_value))
1749                        {
1750                            switch (attr)
1751                            {
1752                            case DW_AT_decl_file:   decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
1753                            case DW_AT_decl_line:   decl.SetLine(form_value.Unsigned()); break;
1754                            case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
1755                            case DW_AT_name:        name = form_value.AsCString(&get_debug_str_data()); break;
1756                            case DW_AT_type:        encoding_uid = form_value.Reference(dwarf_cu); break;
1757                            case DW_AT_bit_offset:  bit_offset = form_value.Unsigned(); break;
1758                            case DW_AT_bit_size:    bit_size = form_value.Unsigned(); break;
1759                            case DW_AT_byte_size:   byte_size = form_value.Unsigned(); break;
1760                            case DW_AT_data_member_location:
1761                                if (form_value.BlockData())
1762                                {
1763                                    Value initialValue(0);
1764                                    Value memberOffset(0);
1765                                    const DataExtractor& debug_info_data = get_debug_info_data();
1766                                    uint32_t block_length = form_value.Unsigned();
1767                                    uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();
1768                                    if (DWARFExpression::Evaluate(NULL, // ExecutionContext *
1769                                                                  NULL, // ClangExpressionVariableList *
1770                                                                  NULL, // ClangExpressionDeclMap *
1771                                                                  NULL, // RegisterContext *
1772                                                                  debug_info_data,
1773                                                                  block_offset,
1774                                                                  block_length,
1775                                                                  eRegisterKindDWARF,
1776                                                                  &initialValue,
1777                                                                  memberOffset,
1778                                                                  NULL))
1779                                    {
1780                                        member_byte_offset = memberOffset.ResolveValue(NULL).UInt();
1781                                    }
1782                                }
1783                                else
1784                                {
1785                                    // With DWARF 3 and later, if the value is an integer constant,
1786                                    // this form value is the offset in bytes from the beginning
1787                                    // of the containing entity.
1788                                    member_byte_offset = form_value.Unsigned();
1789                                }
1790                                break;
1791
1792                            case DW_AT_accessibility: accessibility = DW_ACCESS_to_AccessType (form_value.Unsigned()); break;
1793                            case DW_AT_artificial: is_artificial = form_value.Boolean(); break;
1794                            case DW_AT_APPLE_property_name:      prop_name = form_value.AsCString(&get_debug_str_data()); break;
1795                            case DW_AT_APPLE_property_getter:    prop_getter_name = form_value.AsCString(&get_debug_str_data()); break;
1796                            case DW_AT_APPLE_property_setter:    prop_setter_name = form_value.AsCString(&get_debug_str_data()); break;
1797                            case DW_AT_APPLE_property_attribute: prop_attributes = form_value.Unsigned(); break;
1798                            case DW_AT_external:                 is_external = form_value.Boolean(); break;
1799
1800                            default:
1801                            case DW_AT_declaration:
1802                            case DW_AT_description:
1803                            case DW_AT_mutable:
1804                            case DW_AT_visibility:
1805                            case DW_AT_sibling:
1806                                break;
1807                            }
1808                        }
1809                    }
1810
1811                    if (prop_name)
1812                    {
1813                        ConstString fixed_getter;
1814                        ConstString fixed_setter;
1815
1816                        // Check if the property getter/setter were provided as full
1817                        // names.  We want basenames, so we extract them.
1818
1819                        if (prop_getter_name && prop_getter_name[0] == '-')
1820                        {
1821                            ObjCLanguageRuntime::MethodName prop_getter_method(prop_getter_name, true);
1822                            prop_getter_name = prop_getter_method.GetSelector().GetCString();
1823                        }
1824
1825                        if (prop_setter_name && prop_setter_name[0] == '-')
1826                        {
1827                            ObjCLanguageRuntime::MethodName prop_setter_method(prop_setter_name, true);
1828                            prop_setter_name = prop_setter_method.GetSelector().GetCString();
1829                        }
1830
1831                        // If the names haven't been provided, they need to be
1832                        // filled in.
1833
1834                        if (!prop_getter_name)
1835                        {
1836                            prop_getter_name = prop_name;
1837                        }
1838                        if (!prop_setter_name && prop_name[0] && !(prop_attributes & DW_APPLE_PROPERTY_readonly))
1839                        {
1840                            StreamString ss;
1841
1842                            ss.Printf("set%c%s:",
1843                                      toupper(prop_name[0]),
1844                                      &prop_name[1]);
1845
1846                            fixed_setter.SetCString(ss.GetData());
1847                            prop_setter_name = fixed_setter.GetCString();
1848                        }
1849                    }
1850
1851                    // Clang has a DWARF generation bug where sometimes it
1852                    // represents fields that are references with bad byte size
1853                    // and bit size/offset information such as:
1854                    //
1855                    //  DW_AT_byte_size( 0x00 )
1856                    //  DW_AT_bit_size( 0x40 )
1857                    //  DW_AT_bit_offset( 0xffffffffffffffc0 )
1858                    //
1859                    // So check the bit offset to make sure it is sane, and if
1860                    // the values are not sane, remove them. If we don't do this
1861                    // then we will end up with a crash if we try to use this
1862                    // type in an expression when clang becomes unhappy with its
1863                    // recycled debug info.
1864
1865                    if (bit_offset > 128)
1866                    {
1867                        bit_size = 0;
1868                        bit_offset = 0;
1869                    }
1870
1871                    // FIXME: Make Clang ignore Objective-C accessibility for expressions
1872                    if (class_language == eLanguageTypeObjC ||
1873                        class_language == eLanguageTypeObjC_plus_plus)
1874                        accessibility = eAccessNone;
1875
1876                    if (member_idx == 0 && !is_artificial && name && (strstr (name, "_vptr$") == name))
1877                    {
1878                        // Not all compilers will mark the vtable pointer
1879                        // member as artificial (llvm-gcc). We can't have
1880                        // the virtual members in our classes otherwise it
1881                        // throws off all child offsets since we end up
1882                        // having and extra pointer sized member in our
1883                        // class layouts.
1884                        is_artificial = true;
1885                    }
1886
1887                    // Handle static members
1888                    if (is_external && member_byte_offset == UINT32_MAX)
1889                    {
1890                        Type *var_type = ResolveTypeUID(encoding_uid);
1891
1892                        if (var_type)
1893                        {
1894                            if (accessibility == eAccessNone)
1895                                accessibility = eAccessPublic;
1896                            class_clang_type.AddVariableToRecordType (name,
1897                                                                      var_type->GetClangLayoutType(),
1898                                                                      accessibility);
1899                        }
1900                        break;
1901                    }
1902
1903                    if (is_artificial == false)
1904                    {
1905                        Type *member_type = ResolveTypeUID(encoding_uid);
1906
1907                        clang::FieldDecl *field_decl = NULL;
1908                        if (tag == DW_TAG_member)
1909                        {
1910                            if (member_type)
1911                            {
1912                                if (accessibility == eAccessNone)
1913                                    accessibility = default_accessibility;
1914                                member_accessibilities.push_back(accessibility);
1915
1916                                BitfieldInfo this_field_info;
1917
1918                                this_field_info.bit_size = bit_size;
1919
1920                                if (member_byte_offset != UINT32_MAX || bit_size != 0)
1921                                {
1922                                    /////////////////////////////////////////////////////////////
1923                                    // How to locate a field given the DWARF debug information
1924                                    //
1925                                    // AT_byte_size indicates the size of the word in which the
1926                                    // bit offset must be interpreted.
1927                                    //
1928                                    // AT_data_member_location indicates the byte offset of the
1929                                    // word from the base address of the structure.
1930                                    //
1931                                    // AT_bit_offset indicates how many bits into the word
1932                                    // (according to the host endianness) the low-order bit of
1933                                    // the field starts.  AT_bit_offset can be negative.
1934                                    //
1935                                    // AT_bit_size indicates the size of the field in bits.
1936                                    /////////////////////////////////////////////////////////////
1937
1938                                    this_field_info.bit_offset = 0;
1939
1940                                    this_field_info.bit_offset += (member_byte_offset == UINT32_MAX ? 0 : (member_byte_offset * 8));
1941
1942                                    if (GetObjectFile()->GetByteOrder() == eByteOrderLittle)
1943                                    {
1944                                        this_field_info.bit_offset += byte_size * 8;
1945                                        this_field_info.bit_offset -= (bit_offset + bit_size);
1946                                    }
1947                                    else
1948                                    {
1949                                        this_field_info.bit_offset += bit_offset;
1950                                    }
1951                                }
1952
1953                                // If the member to be emitted did not start on a character boundary and there is
1954                                // empty space between the last field and this one, then we need to emit an
1955                                // anonymous member filling up the space up to its start.  There are three cases
1956                                // here:
1957                                //
1958                                // 1 If the previous member ended on a character boundary, then we can emit an
1959                                //   anonymous member starting at the most recent character boundary.
1960                                //
1961                                // 2 If the previous member did not end on a character boundary and the distance
1962                                //   from the end of the previous member to the current member is less than a
1963                                //   word width, then we can emit an anonymous member starting right after the
1964                                //   previous member and right before this member.
1965                                //
1966                                // 3 If the previous member did not end on a character boundary and the distance
1967                                //   from the end of the previous member to the current member is greater than
1968                                //   or equal a word width, then we act as in Case 1.
1969
1970                                const uint64_t character_width = 8;
1971                                const uint64_t word_width = 32;
1972
1973                                if (this_field_info.IsValid())
1974                                {
1975                                    // Objective-C has invalid DW_AT_bit_offset values in older versions
1976                                    // of clang, so we have to be careful and only insert unnammed bitfields
1977                                    // if we have a new enough clang.
1978                                    bool detect_unnamed_bitfields = true;
1979
1980                                    if (class_language == eLanguageTypeObjC || class_language == eLanguageTypeObjC_plus_plus)
1981                                        detect_unnamed_bitfields = dwarf_cu->Supports_unnamed_objc_bitfields ();
1982
1983                                    if (detect_unnamed_bitfields)
1984                                    {
1985                                        BitfieldInfo anon_field_info;
1986
1987                                        if ((this_field_info.bit_offset % character_width) != 0) // not char aligned
1988                                        {
1989                                            uint64_t last_field_end = 0;
1990
1991                                            if (last_field_info.IsValid())
1992                                                last_field_end = last_field_info.bit_offset + last_field_info.bit_size;
1993
1994                                            if (this_field_info.bit_offset != last_field_end)
1995                                            {
1996                                                if (((last_field_end % character_width) == 0) ||                    // case 1
1997                                                    (this_field_info.bit_offset - last_field_end >= word_width))    // case 3
1998                                                {
1999                                                    anon_field_info.bit_size = this_field_info.bit_offset % character_width;
2000                                                    anon_field_info.bit_offset = this_field_info.bit_offset - anon_field_info.bit_size;
2001                                                }
2002                                                else                                                                // case 2
2003                                                {
2004                                                    anon_field_info.bit_size = this_field_info.bit_offset - last_field_end;
2005                                                    anon_field_info.bit_offset = last_field_end;
2006                                                }
2007                                            }
2008                                        }
2009
2010                                        if (anon_field_info.IsValid())
2011                                        {
2012                                            clang::FieldDecl *unnamed_bitfield_decl = class_clang_type.AddFieldToRecordType (NULL,
2013                                                                                                                             GetClangASTContext().GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, word_width),
2014                                                                                                                             accessibility,
2015                                                                                                                             anon_field_info.bit_size);
2016
2017                                            layout_info.field_offsets.insert(std::make_pair(unnamed_bitfield_decl, anon_field_info.bit_offset));
2018                                        }
2019                                    }
2020                                }
2021
2022                                ClangASTType member_clang_type = member_type->GetClangLayoutType();
2023
2024                                {
2025                                    // Older versions of clang emit array[0] and array[1] in the same way (<rdar://problem/12566646>).
2026                                    // If the current field is at the end of the structure, then there is definitely no room for extra
2027                                    // elements and we override the type to array[0].
2028
2029                                    ClangASTType member_array_element_type;
2030                                    uint64_t member_array_size;
2031                                    bool member_array_is_incomplete;
2032
2033                                    if (member_clang_type.IsArrayType(&member_array_element_type,
2034                                                                      &member_array_size,
2035                                                                      &member_array_is_incomplete) &&
2036                                        !member_array_is_incomplete)
2037                                    {
2038                                        uint64_t parent_byte_size = parent_die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_byte_size, UINT64_MAX);
2039
2040                                        if (member_byte_offset >= parent_byte_size)
2041                                        {
2042                                            if (member_array_size != 1)
2043                                            {
2044                                                GetObjectFile()->GetModule()->ReportError ("0x%8.8" PRIx64 ": DW_TAG_member '%s' refers to type 0x%8.8" PRIx64 " which extends beyond the bounds of 0x%8.8" PRIx64,
2045                                                                                           MakeUserID(die->GetOffset()),
2046                                                                                           name,
2047                                                                                           encoding_uid,
2048                                                                                           MakeUserID(parent_die->GetOffset()));
2049                                            }
2050
2051                                            member_clang_type = GetClangASTContext().CreateArrayType(member_array_element_type, 0, false);
2052                                        }
2053                                    }
2054                                }
2055
2056                                field_decl = class_clang_type.AddFieldToRecordType (name,
2057                                                                                    member_clang_type,
2058                                                                                    accessibility,
2059                                                                                    bit_size);
2060
2061                                GetClangASTContext().SetMetadataAsUserID (field_decl, MakeUserID(die->GetOffset()));
2062
2063                                if (this_field_info.IsValid())
2064                                {
2065                                    layout_info.field_offsets.insert(std::make_pair(field_decl, this_field_info.bit_offset));
2066                                    last_field_info = this_field_info;
2067                                }
2068                            }
2069                            else
2070                            {
2071                                if (name)
2072                                    GetObjectFile()->GetModule()->ReportError ("0x%8.8" PRIx64 ": DW_TAG_member '%s' refers to type 0x%8.8" PRIx64 " which was unable to be parsed",
2073                                                                               MakeUserID(die->GetOffset()),
2074                                                                               name,
2075                                                                               encoding_uid);
2076                                else
2077                                    GetObjectFile()->GetModule()->ReportError ("0x%8.8" PRIx64 ": DW_TAG_member refers to type 0x%8.8" PRIx64 " which was unable to be parsed",
2078                                                                               MakeUserID(die->GetOffset()),
2079                                                                               encoding_uid);
2080                            }
2081                        }
2082
2083                        if (prop_name != NULL)
2084                        {
2085                            clang::ObjCIvarDecl *ivar_decl = NULL;
2086
2087                            if (field_decl)
2088                            {
2089                                ivar_decl = clang::dyn_cast<clang::ObjCIvarDecl>(field_decl);
2090                                assert (ivar_decl != NULL);
2091                            }
2092
2093                            ClangASTMetadata metadata;
2094                            metadata.SetUserID (MakeUserID(die->GetOffset()));
2095                            delayed_properties.push_back(DelayedAddObjCClassProperty(class_clang_type,
2096                                                                                     prop_name,
2097                                                                                     member_type->GetClangLayoutType(),
2098                                                                                     ivar_decl,
2099                                                                                     prop_setter_name,
2100                                                                                     prop_getter_name,
2101                                                                                     prop_attributes,
2102                                                                                     &metadata));
2103
2104                            if (ivar_decl)
2105                                GetClangASTContext().SetMetadataAsUserID (ivar_decl, MakeUserID(die->GetOffset()));
2106                        }
2107                    }
2108                }
2109                ++member_idx;
2110            }
2111            break;
2112
2113        case DW_TAG_subprogram:
2114            // Let the type parsing code handle this one for us.
2115            member_function_dies.Append (die);
2116            break;
2117
2118        case DW_TAG_inheritance:
2119            {
2120                is_a_class = true;
2121                if (default_accessibility == eAccessNone)
2122                    default_accessibility = eAccessPrivate;
2123                // TODO: implement DW_TAG_inheritance type parsing
2124                DWARFDebugInfoEntry::Attributes attributes;
2125                const size_t num_attributes = die->GetAttributes (this,
2126                                                                  dwarf_cu,
2127                                                                  fixed_form_sizes,
2128                                                                  attributes);
2129                if (num_attributes > 0)
2130                {
2131                    Declaration decl;
2132                    DWARFExpression location;
2133                    lldb::user_id_t encoding_uid = LLDB_INVALID_UID;
2134                    AccessType accessibility = default_accessibility;
2135                    bool is_virtual = false;
2136                    bool is_base_of_class = true;
2137                    off_t member_byte_offset = 0;
2138                    uint32_t i;
2139                    for (i=0; i<num_attributes; ++i)
2140                    {
2141                        const dw_attr_t attr = attributes.AttributeAtIndex(i);
2142                        DWARFFormValue form_value;
2143                        if (attributes.ExtractFormValueAtIndex(this, i, form_value))
2144                        {
2145                            switch (attr)
2146                            {
2147                            case DW_AT_decl_file:   decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
2148                            case DW_AT_decl_line:   decl.SetLine(form_value.Unsigned()); break;
2149                            case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
2150                            case DW_AT_type:        encoding_uid = form_value.Reference(dwarf_cu); break;
2151                            case DW_AT_data_member_location:
2152                                if (form_value.BlockData())
2153                                {
2154                                    Value initialValue(0);
2155                                    Value memberOffset(0);
2156                                    const DataExtractor& debug_info_data = get_debug_info_data();
2157                                    uint32_t block_length = form_value.Unsigned();
2158                                    uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();
2159                                    if (DWARFExpression::Evaluate (NULL,
2160                                                                   NULL,
2161                                                                   NULL,
2162                                                                   NULL,
2163                                                                   debug_info_data,
2164                                                                   block_offset,
2165                                                                   block_length,
2166                                                                   eRegisterKindDWARF,
2167                                                                   &initialValue,
2168                                                                   memberOffset,
2169                                                                   NULL))
2170                                    {
2171                                        member_byte_offset = memberOffset.ResolveValue(NULL).UInt();
2172                                    }
2173                                }
2174                                else
2175                                {
2176                                    // With DWARF 3 and later, if the value is an integer constant,
2177                                    // this form value is the offset in bytes from the beginning
2178                                    // of the containing entity.
2179                                    member_byte_offset = form_value.Unsigned();
2180                                }
2181                                break;
2182
2183                            case DW_AT_accessibility:
2184                                accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned());
2185                                break;
2186
2187                            case DW_AT_virtuality:
2188                                is_virtual = form_value.Boolean();
2189                                break;
2190
2191                            case DW_AT_sibling:
2192                                break;
2193
2194                            default:
2195                                break;
2196                            }
2197                        }
2198                    }
2199
2200                    Type *base_class_type = ResolveTypeUID(encoding_uid);
2201                    assert(base_class_type);
2202
2203                    ClangASTType base_class_clang_type = base_class_type->GetClangFullType();
2204                    assert (base_class_clang_type);
2205                    if (class_language == eLanguageTypeObjC)
2206                    {
2207                        class_clang_type.SetObjCSuperClass(base_class_clang_type);
2208                    }
2209                    else
2210                    {
2211                        base_classes.push_back (base_class_clang_type.CreateBaseClassSpecifier (accessibility,
2212                                                                                               is_virtual,
2213                                                                                               is_base_of_class));
2214
2215                        if (is_virtual)
2216                        {
2217                            layout_info.vbase_offsets.insert(std::make_pair(class_clang_type.GetAsCXXRecordDecl(),
2218                                                                            clang::CharUnits::fromQuantity(member_byte_offset)));
2219                        }
2220                        else
2221                        {
2222                            layout_info.base_offsets.insert(std::make_pair(class_clang_type.GetAsCXXRecordDecl(),
2223                                                                           clang::CharUnits::fromQuantity(member_byte_offset)));
2224                        }
2225                    }
2226                }
2227            }
2228            break;
2229
2230        default:
2231            break;
2232        }
2233    }
2234
2235    return count;
2236}
2237
2238
2239clang::DeclContext*
2240SymbolFileDWARF::GetClangDeclContextContainingTypeUID (lldb::user_id_t type_uid)
2241{
2242    DWARFDebugInfo* debug_info = DebugInfo();
2243    if (debug_info && UserIDMatches(type_uid))
2244    {
2245        DWARFCompileUnitSP cu_sp;
2246        const DWARFDebugInfoEntry* die = debug_info->GetDIEPtr(type_uid, &cu_sp);
2247        if (die)
2248            return GetClangDeclContextContainingDIE (cu_sp.get(), die, NULL);
2249    }
2250    return NULL;
2251}
2252
2253clang::DeclContext*
2254SymbolFileDWARF::GetClangDeclContextForTypeUID (const lldb_private::SymbolContext &sc, lldb::user_id_t type_uid)
2255{
2256    if (UserIDMatches(type_uid))
2257        return GetClangDeclContextForDIEOffset (sc, type_uid);
2258    return NULL;
2259}
2260
2261Type*
2262SymbolFileDWARF::ResolveTypeUID (lldb::user_id_t type_uid)
2263{
2264    if (UserIDMatches(type_uid))
2265    {
2266        DWARFDebugInfo* debug_info = DebugInfo();
2267        if (debug_info)
2268        {
2269            DWARFCompileUnitSP cu_sp;
2270            const DWARFDebugInfoEntry* type_die = debug_info->GetDIEPtr(type_uid, &cu_sp);
2271            const bool assert_not_being_parsed = true;
2272            return ResolveTypeUID (cu_sp.get(), type_die, assert_not_being_parsed);
2273        }
2274    }
2275    return NULL;
2276}
2277
2278Type*
2279SymbolFileDWARF::ResolveTypeUID (DWARFCompileUnit* cu, const DWARFDebugInfoEntry* die, bool assert_not_being_parsed)
2280{
2281    if (die != NULL)
2282    {
2283        Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
2284        if (log)
2285            GetObjectFile()->GetModule()->LogMessage (log,
2286                                                      "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s'",
2287                                                      die->GetOffset(),
2288                                                      DW_TAG_value_to_name(die->Tag()),
2289                                                      die->GetName(this, cu));
2290
2291        // We might be coming in in the middle of a type tree (a class
2292        // withing a class, an enum within a class), so parse any needed
2293        // parent DIEs before we get to this one...
2294        const DWARFDebugInfoEntry *decl_ctx_die = GetDeclContextDIEContainingDIE (cu, die);
2295        switch (decl_ctx_die->Tag())
2296        {
2297            case DW_TAG_structure_type:
2298            case DW_TAG_union_type:
2299            case DW_TAG_class_type:
2300            {
2301                // Get the type, which could be a forward declaration
2302                if (log)
2303                    GetObjectFile()->GetModule()->LogMessage (log,
2304                                                              "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s' resolve parent forward type for 0x%8.8x",
2305                                                              die->GetOffset(),
2306                                                              DW_TAG_value_to_name(die->Tag()),
2307                                                              die->GetName(this, cu),
2308                                                              decl_ctx_die->GetOffset());
2309//
2310//                Type *parent_type = ResolveTypeUID (cu, decl_ctx_die, assert_not_being_parsed);
2311//                if (child_requires_parent_class_union_or_struct_to_be_completed(die->Tag()))
2312//                {
2313//                    if (log)
2314//                        GetObjectFile()->GetModule()->LogMessage (log,
2315//                                                                  "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s' resolve parent full type for 0x%8.8x since die is a function",
2316//                                                                  die->GetOffset(),
2317//                                                                  DW_TAG_value_to_name(die->Tag()),
2318//                                                                  die->GetName(this, cu),
2319//                                                                  decl_ctx_die->GetOffset());
2320//                    // Ask the type to complete itself if it already hasn't since if we
2321//                    // want a function (method or static) from a class, the class must
2322//                    // create itself and add it's own methods and class functions.
2323//                    if (parent_type)
2324//                        parent_type->GetClangFullType();
2325//                }
2326            }
2327            break;
2328
2329            default:
2330                break;
2331        }
2332        return ResolveType (cu, die);
2333    }
2334    return NULL;
2335}
2336
2337// This function is used when SymbolFileDWARFDebugMap owns a bunch of
2338// SymbolFileDWARF objects to detect if this DWARF file is the one that
2339// can resolve a clang_type.
2340bool
2341SymbolFileDWARF::HasForwardDeclForClangType (const ClangASTType &clang_type)
2342{
2343    ClangASTType clang_type_no_qualifiers = clang_type.RemoveFastQualifiers();
2344    const DWARFDebugInfoEntry* die = m_forward_decl_clang_type_to_die.lookup (clang_type_no_qualifiers.GetOpaqueQualType());
2345    return die != NULL;
2346}
2347
2348
2349bool
2350SymbolFileDWARF::ResolveClangOpaqueTypeDefinition (ClangASTType &clang_type)
2351{
2352    // We have a struct/union/class/enum that needs to be fully resolved.
2353    ClangASTType clang_type_no_qualifiers = clang_type.RemoveFastQualifiers();
2354    const DWARFDebugInfoEntry* die = m_forward_decl_clang_type_to_die.lookup (clang_type_no_qualifiers.GetOpaqueQualType());
2355    if (die == NULL)
2356    {
2357        // We have already resolved this type...
2358        return true;
2359    }
2360    // Once we start resolving this type, remove it from the forward declaration
2361    // map in case anyone child members or other types require this type to get resolved.
2362    // The type will get resolved when all of the calls to SymbolFileDWARF::ResolveClangOpaqueTypeDefinition
2363    // are done.
2364    m_forward_decl_clang_type_to_die.erase (clang_type_no_qualifiers.GetOpaqueQualType());
2365
2366
2367    // Disable external storage for this type so we don't get anymore
2368    // clang::ExternalASTSource queries for this type.
2369    clang_type.SetHasExternalStorage (false);
2370
2371    DWARFDebugInfo* debug_info = DebugInfo();
2372
2373    DWARFCompileUnit *dwarf_cu = debug_info->GetCompileUnitContainingDIE (die->GetOffset()).get();
2374    Type *type = m_die_to_type.lookup (die);
2375
2376    const dw_tag_t tag = die->Tag();
2377
2378    Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION));
2379    if (log)
2380    {
2381        GetObjectFile()->GetModule()->LogMessageVerboseBacktrace (log,
2382                                                                  "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
2383                                                                  MakeUserID(die->GetOffset()),
2384                                                                  DW_TAG_value_to_name(tag),
2385                                                                  type->GetName().AsCString());
2386
2387    }
2388    assert (clang_type);
2389    DWARFDebugInfoEntry::Attributes attributes;
2390
2391    switch (tag)
2392    {
2393    case DW_TAG_structure_type:
2394    case DW_TAG_union_type:
2395    case DW_TAG_class_type:
2396        {
2397            LayoutInfo layout_info;
2398
2399            {
2400                if (die->HasChildren())
2401                {
2402
2403                    LanguageType class_language = eLanguageTypeUnknown;
2404                    if (clang_type.IsObjCObjectOrInterfaceType())
2405                    {
2406                        class_language = eLanguageTypeObjC;
2407                        // For objective C we don't start the definition when
2408                        // the class is created.
2409                        clang_type.StartTagDeclarationDefinition ();
2410                    }
2411
2412                    int tag_decl_kind = -1;
2413                    AccessType default_accessibility = eAccessNone;
2414                    if (tag == DW_TAG_structure_type)
2415                    {
2416                        tag_decl_kind = clang::TTK_Struct;
2417                        default_accessibility = eAccessPublic;
2418                    }
2419                    else if (tag == DW_TAG_union_type)
2420                    {
2421                        tag_decl_kind = clang::TTK_Union;
2422                        default_accessibility = eAccessPublic;
2423                    }
2424                    else if (tag == DW_TAG_class_type)
2425                    {
2426                        tag_decl_kind = clang::TTK_Class;
2427                        default_accessibility = eAccessPrivate;
2428                    }
2429
2430                    SymbolContext sc(GetCompUnitForDWARFCompUnit(dwarf_cu));
2431                    std::vector<clang::CXXBaseSpecifier *> base_classes;
2432                    std::vector<int> member_accessibilities;
2433                    bool is_a_class = false;
2434                    // Parse members and base classes first
2435                    DWARFDIECollection member_function_dies;
2436
2437                    DelayedPropertyList delayed_properties;
2438                    ParseChildMembers (sc,
2439                                       dwarf_cu,
2440                                       die,
2441                                       clang_type,
2442                                       class_language,
2443                                       base_classes,
2444                                       member_accessibilities,
2445                                       member_function_dies,
2446                                       delayed_properties,
2447                                       default_accessibility,
2448                                       is_a_class,
2449                                       layout_info);
2450
2451                    // Now parse any methods if there were any...
2452                    size_t num_functions = member_function_dies.Size();
2453                    if (num_functions > 0)
2454                    {
2455                        for (size_t i=0; i<num_functions; ++i)
2456                        {
2457                            ResolveType(dwarf_cu, member_function_dies.GetDIEPtrAtIndex(i));
2458                        }
2459                    }
2460
2461                    if (class_language == eLanguageTypeObjC)
2462                    {
2463                        std::string class_str (clang_type.GetTypeName());
2464                        if (!class_str.empty())
2465                        {
2466
2467                            DIEArray method_die_offsets;
2468                            if (m_using_apple_tables)
2469                            {
2470                                if (m_apple_objc_ap.get())
2471                                    m_apple_objc_ap->FindByName(class_str.c_str(), method_die_offsets);
2472                            }
2473                            else
2474                            {
2475                                if (!m_indexed)
2476                                    Index ();
2477
2478                                ConstString class_name (class_str.c_str());
2479                                m_objc_class_selectors_index.Find (class_name, method_die_offsets);
2480                            }
2481
2482                            if (!method_die_offsets.empty())
2483                            {
2484                                DWARFDebugInfo* debug_info = DebugInfo();
2485
2486                                DWARFCompileUnit* method_cu = NULL;
2487                                const size_t num_matches = method_die_offsets.size();
2488                                for (size_t i=0; i<num_matches; ++i)
2489                                {
2490                                    const dw_offset_t die_offset = method_die_offsets[i];
2491                                    DWARFDebugInfoEntry *method_die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &method_cu);
2492
2493                                    if (method_die)
2494                                        ResolveType (method_cu, method_die);
2495                                    else
2496                                    {
2497                                        if (m_using_apple_tables)
2498                                        {
2499                                            GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_objc accelerator table had bad die 0x%8.8x for '%s')\n",
2500                                                                                                       die_offset, class_str.c_str());
2501                                        }
2502                                    }
2503                                }
2504                            }
2505
2506                            for (DelayedPropertyList::iterator pi = delayed_properties.begin(), pe = delayed_properties.end();
2507                                 pi != pe;
2508                                 ++pi)
2509                                pi->Finalize();
2510                        }
2511                    }
2512
2513                    // If we have a DW_TAG_structure_type instead of a DW_TAG_class_type we
2514                    // need to tell the clang type it is actually a class.
2515                    if (class_language != eLanguageTypeObjC)
2516                    {
2517                        if (is_a_class && tag_decl_kind != clang::TTK_Class)
2518                            clang_type.SetTagTypeKind (clang::TTK_Class);
2519                    }
2520
2521                    // Since DW_TAG_structure_type gets used for both classes
2522                    // and structures, we may need to set any DW_TAG_member
2523                    // fields to have a "private" access if none was specified.
2524                    // When we parsed the child members we tracked that actual
2525                    // accessibility value for each DW_TAG_member in the
2526                    // "member_accessibilities" array. If the value for the
2527                    // member is zero, then it was set to the "default_accessibility"
2528                    // which for structs was "public". Below we correct this
2529                    // by setting any fields to "private" that weren't correctly
2530                    // set.
2531                    if (is_a_class && !member_accessibilities.empty())
2532                    {
2533                        // This is a class and all members that didn't have
2534                        // their access specified are private.
2535                        clang_type.SetDefaultAccessForRecordFields (eAccessPrivate,
2536                                                                    &member_accessibilities.front(),
2537                                                                    member_accessibilities.size());
2538                    }
2539
2540                    if (!base_classes.empty())
2541                    {
2542                        clang_type.SetBaseClassesForClassType (&base_classes.front(),
2543                                                               base_classes.size());
2544
2545                        // Clang will copy each CXXBaseSpecifier in "base_classes"
2546                        // so we have to free them all.
2547                        ClangASTType::DeleteBaseClassSpecifiers (&base_classes.front(),
2548                                                                 base_classes.size());
2549                    }
2550                }
2551            }
2552
2553            clang_type.BuildIndirectFields ();
2554            clang_type.CompleteTagDeclarationDefinition ();
2555
2556            if (!layout_info.field_offsets.empty() ||
2557                !layout_info.base_offsets.empty()  ||
2558                !layout_info.vbase_offsets.empty() )
2559            {
2560                if (type)
2561                    layout_info.bit_size = type->GetByteSize() * 8;
2562                if (layout_info.bit_size == 0)
2563                    layout_info.bit_size = die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_byte_size, 0) * 8;
2564
2565                clang::CXXRecordDecl *record_decl = clang_type.GetAsCXXRecordDecl();
2566                if (record_decl)
2567                {
2568                    if (log)
2569                    {
2570                        GetObjectFile()->GetModule()->LogMessage (log,
2571                                                                  "SymbolFileDWARF::ResolveClangOpaqueTypeDefinition (clang_type = %p) caching layout info for record_decl = %p, bit_size = %" PRIu64 ", alignment = %" PRIu64 ", field_offsets[%u], base_offsets[%u], vbase_offsets[%u])",
2572                                                                  clang_type.GetOpaqueQualType(),
2573                                                                  record_decl,
2574                                                                  layout_info.bit_size,
2575                                                                  layout_info.alignment,
2576                                                                  (uint32_t)layout_info.field_offsets.size(),
2577                                                                  (uint32_t)layout_info.base_offsets.size(),
2578                                                                  (uint32_t)layout_info.vbase_offsets.size());
2579
2580                        uint32_t idx;
2581                        {
2582                        llvm::DenseMap <const clang::FieldDecl *, uint64_t>::const_iterator pos, end = layout_info.field_offsets.end();
2583                        for (idx = 0, pos = layout_info.field_offsets.begin(); pos != end; ++pos, ++idx)
2584                        {
2585                            GetObjectFile()->GetModule()->LogMessage (log,
2586                                                                      "SymbolFileDWARF::ResolveClangOpaqueTypeDefinition (clang_type = %p) field[%u] = { bit_offset=%u, name='%s' }",
2587                                                                      clang_type.GetOpaqueQualType(),
2588                                                                      idx,
2589                                                                      (uint32_t)pos->second,
2590                                                                      pos->first->getNameAsString().c_str());
2591                        }
2592                        }
2593
2594                        {
2595                        llvm::DenseMap <const clang::CXXRecordDecl *, clang::CharUnits>::const_iterator base_pos, base_end = layout_info.base_offsets.end();
2596                        for (idx = 0, base_pos = layout_info.base_offsets.begin(); base_pos != base_end; ++base_pos, ++idx)
2597                        {
2598                            GetObjectFile()->GetModule()->LogMessage (log,
2599                                                                      "SymbolFileDWARF::ResolveClangOpaqueTypeDefinition (clang_type = %p) base[%u] = { byte_offset=%u, name='%s' }",
2600                                                                      clang_type.GetOpaqueQualType(),
2601                                                                      idx,
2602                                                                      (uint32_t)base_pos->second.getQuantity(),
2603                                                                      base_pos->first->getNameAsString().c_str());
2604                        }
2605                        }
2606                        {
2607                        llvm::DenseMap <const clang::CXXRecordDecl *, clang::CharUnits>::const_iterator vbase_pos, vbase_end = layout_info.vbase_offsets.end();
2608                        for (idx = 0, vbase_pos = layout_info.vbase_offsets.begin(); vbase_pos != vbase_end; ++vbase_pos, ++idx)
2609                        {
2610                            GetObjectFile()->GetModule()->LogMessage (log,
2611                                                                      "SymbolFileDWARF::ResolveClangOpaqueTypeDefinition (clang_type = %p) vbase[%u] = { byte_offset=%u, name='%s' }",
2612                                                                      clang_type.GetOpaqueQualType(),
2613                                                                      idx,
2614                                                                      (uint32_t)vbase_pos->second.getQuantity(),
2615                                                                      vbase_pos->first->getNameAsString().c_str());
2616                        }
2617                        }
2618                    }
2619                    m_record_decl_to_layout_map.insert(std::make_pair(record_decl, layout_info));
2620                }
2621            }
2622        }
2623
2624        return clang_type;
2625
2626    case DW_TAG_enumeration_type:
2627        clang_type.StartTagDeclarationDefinition ();
2628        if (die->HasChildren())
2629        {
2630            SymbolContext sc(GetCompUnitForDWARFCompUnit(dwarf_cu));
2631            bool is_signed = false;
2632            clang_type.IsIntegerType(is_signed);
2633            ParseChildEnumerators(sc, clang_type, is_signed, type->GetByteSize(), dwarf_cu, die);
2634        }
2635        clang_type.CompleteTagDeclarationDefinition ();
2636        return clang_type;
2637
2638    default:
2639        assert(false && "not a forward clang type decl!");
2640        break;
2641    }
2642    return false;
2643}
2644
2645Type*
2646SymbolFileDWARF::ResolveType (DWARFCompileUnit* dwarf_cu, const DWARFDebugInfoEntry* type_die, bool assert_not_being_parsed)
2647{
2648    if (type_die != NULL)
2649    {
2650        Type *type = m_die_to_type.lookup (type_die);
2651
2652        if (type == NULL)
2653            type = GetTypeForDIE (dwarf_cu, type_die).get();
2654
2655        if (assert_not_being_parsed)
2656        {
2657            if (type != DIE_IS_BEING_PARSED)
2658                return type;
2659
2660            GetObjectFile()->GetModule()->ReportError ("Parsing a die that is being parsed die: 0x%8.8x: %s %s",
2661                                                       type_die->GetOffset(),
2662                                                       DW_TAG_value_to_name(type_die->Tag()),
2663                                                       type_die->GetName(this, dwarf_cu));
2664
2665        }
2666        else
2667            return type;
2668    }
2669    return NULL;
2670}
2671
2672CompileUnit*
2673SymbolFileDWARF::GetCompUnitForDWARFCompUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx)
2674{
2675    // Check if the symbol vendor already knows about this compile unit?
2676    if (dwarf_cu->GetUserData() == NULL)
2677    {
2678        // The symbol vendor doesn't know about this compile unit, we
2679        // need to parse and add it to the symbol vendor object.
2680        return ParseCompileUnit(dwarf_cu, cu_idx).get();
2681    }
2682    return (CompileUnit*)dwarf_cu->GetUserData();
2683}
2684
2685bool
2686SymbolFileDWARF::GetFunction (DWARFCompileUnit* dwarf_cu, const DWARFDebugInfoEntry* func_die, SymbolContext& sc)
2687{
2688    sc.Clear(false);
2689    // Check if the symbol vendor already knows about this compile unit?
2690    sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, UINT32_MAX);
2691
2692    sc.function = sc.comp_unit->FindFunctionByUID (MakeUserID(func_die->GetOffset())).get();
2693    if (sc.function == NULL)
2694        sc.function = ParseCompileUnitFunction(sc, dwarf_cu, func_die);
2695
2696    if (sc.function)
2697    {
2698        sc.module_sp = sc.function->CalculateSymbolContextModule();
2699        return true;
2700    }
2701
2702    return false;
2703}
2704
2705uint32_t
2706SymbolFileDWARF::ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc)
2707{
2708    Timer scoped_timer(__PRETTY_FUNCTION__,
2709                       "SymbolFileDWARF::ResolveSymbolContext (so_addr = { section = %p, offset = 0x%" PRIx64 " }, resolve_scope = 0x%8.8x)",
2710                       so_addr.GetSection().get(),
2711                       so_addr.GetOffset(),
2712                       resolve_scope);
2713    uint32_t resolved = 0;
2714    if (resolve_scope & (   eSymbolContextCompUnit |
2715                            eSymbolContextFunction |
2716                            eSymbolContextBlock |
2717                            eSymbolContextLineEntry))
2718    {
2719        lldb::addr_t file_vm_addr = so_addr.GetFileAddress();
2720
2721        DWARFDebugInfo* debug_info = DebugInfo();
2722        if (debug_info)
2723        {
2724            const dw_offset_t cu_offset = debug_info->GetCompileUnitAranges().FindAddress(file_vm_addr);
2725            if (cu_offset != DW_INVALID_OFFSET)
2726            {
2727                uint32_t cu_idx = DW_INVALID_INDEX;
2728                DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnit(cu_offset, &cu_idx).get();
2729                if (dwarf_cu)
2730                {
2731                    sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
2732                    if (sc.comp_unit)
2733                    {
2734                        resolved |= eSymbolContextCompUnit;
2735
2736                        bool force_check_line_table = false;
2737                        if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock))
2738                        {
2739                            DWARFDebugInfoEntry *function_die = NULL;
2740                            DWARFDebugInfoEntry *block_die = NULL;
2741                            if (resolve_scope & eSymbolContextBlock)
2742                            {
2743                                dwarf_cu->LookupAddress(file_vm_addr, &function_die, &block_die);
2744                            }
2745                            else
2746                            {
2747                                dwarf_cu->LookupAddress(file_vm_addr, &function_die, NULL);
2748                            }
2749
2750                            if (function_die != NULL)
2751                            {
2752                                sc.function = sc.comp_unit->FindFunctionByUID (MakeUserID(function_die->GetOffset())).get();
2753                                if (sc.function == NULL)
2754                                    sc.function = ParseCompileUnitFunction(sc, dwarf_cu, function_die);
2755                            }
2756                            else
2757                            {
2758                                // We might have had a compile unit that had discontiguous
2759                                // address ranges where the gaps are symbols that don't have
2760                                // any debug info. Discontiguous compile unit address ranges
2761                                // should only happen when there aren't other functions from
2762                                // other compile units in these gaps. This helps keep the size
2763                                // of the aranges down.
2764                                force_check_line_table = true;
2765                            }
2766
2767                            if (sc.function != NULL)
2768                            {
2769                                resolved |= eSymbolContextFunction;
2770
2771                                if (resolve_scope & eSymbolContextBlock)
2772                                {
2773                                    Block& block = sc.function->GetBlock (true);
2774
2775                                    if (block_die != NULL)
2776                                        sc.block = block.FindBlockByID (MakeUserID(block_die->GetOffset()));
2777                                    else
2778                                        sc.block = block.FindBlockByID (MakeUserID(function_die->GetOffset()));
2779                                    if (sc.block)
2780                                        resolved |= eSymbolContextBlock;
2781                                }
2782                            }
2783                        }
2784
2785                        if ((resolve_scope & eSymbolContextLineEntry) || force_check_line_table)
2786                        {
2787                            LineTable *line_table = sc.comp_unit->GetLineTable();
2788                            if (line_table != NULL)
2789                            {
2790                                // And address that makes it into this function should be in terms
2791                                // of this debug file if there is no debug map, or it will be an
2792                                // address in the .o file which needs to be fixed up to be in terms
2793                                // of the debug map executable. Either way, calling FixupAddress()
2794                                // will work for us.
2795                                Address exe_so_addr (so_addr);
2796                                if (FixupAddress(exe_so_addr))
2797                                {
2798                                    if (line_table->FindLineEntryByAddress (exe_so_addr, sc.line_entry))
2799                                    {
2800                                        resolved |= eSymbolContextLineEntry;
2801                                    }
2802                                }
2803                            }
2804                        }
2805
2806                        if (force_check_line_table && !(resolved & eSymbolContextLineEntry))
2807                        {
2808                            // We might have had a compile unit that had discontiguous
2809                            // address ranges where the gaps are symbols that don't have
2810                            // any debug info. Discontiguous compile unit address ranges
2811                            // should only happen when there aren't other functions from
2812                            // other compile units in these gaps. This helps keep the size
2813                            // of the aranges down.
2814                            sc.comp_unit = NULL;
2815                            resolved &= ~eSymbolContextCompUnit;
2816                        }
2817                    }
2818                    else
2819                    {
2820                        GetObjectFile()->GetModule()->ReportWarning ("0x%8.8x: compile unit %u failed to create a valid lldb_private::CompileUnit class.",
2821                                                                     cu_offset,
2822                                                                     cu_idx);
2823                    }
2824                }
2825            }
2826        }
2827    }
2828    return resolved;
2829}
2830
2831
2832
2833uint32_t
2834SymbolFileDWARF::ResolveSymbolContext(const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list)
2835{
2836    const uint32_t prev_size = sc_list.GetSize();
2837    if (resolve_scope & eSymbolContextCompUnit)
2838    {
2839        DWARFDebugInfo* debug_info = DebugInfo();
2840        if (debug_info)
2841        {
2842            uint32_t cu_idx;
2843            DWARFCompileUnit* dwarf_cu = NULL;
2844
2845            for (cu_idx = 0; (dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx)) != NULL; ++cu_idx)
2846            {
2847                CompileUnit *dc_cu = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
2848                const bool full_match = file_spec.GetDirectory();
2849                bool file_spec_matches_cu_file_spec = dc_cu != NULL && FileSpec::Equal(file_spec, *dc_cu, full_match);
2850                if (check_inlines || file_spec_matches_cu_file_spec)
2851                {
2852                    SymbolContext sc (m_obj_file->GetModule());
2853                    sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
2854                    if (sc.comp_unit)
2855                    {
2856                        uint32_t file_idx = UINT32_MAX;
2857
2858                        // If we are looking for inline functions only and we don't
2859                        // find it in the support files, we are done.
2860                        if (check_inlines)
2861                        {
2862                            file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex (1, file_spec, true);
2863                            if (file_idx == UINT32_MAX)
2864                                continue;
2865                        }
2866
2867                        if (line != 0)
2868                        {
2869                            LineTable *line_table = sc.comp_unit->GetLineTable();
2870
2871                            if (line_table != NULL && line != 0)
2872                            {
2873                                // We will have already looked up the file index if
2874                                // we are searching for inline entries.
2875                                if (!check_inlines)
2876                                    file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex (1, file_spec, true);
2877
2878                                if (file_idx != UINT32_MAX)
2879                                {
2880                                    uint32_t found_line;
2881                                    uint32_t line_idx = line_table->FindLineEntryIndexByFileIndex (0, file_idx, line, false, &sc.line_entry);
2882                                    found_line = sc.line_entry.line;
2883
2884                                    while (line_idx != UINT32_MAX)
2885                                    {
2886                                        sc.function = NULL;
2887                                        sc.block = NULL;
2888                                        if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock))
2889                                        {
2890                                            const lldb::addr_t file_vm_addr = sc.line_entry.range.GetBaseAddress().GetFileAddress();
2891                                            if (file_vm_addr != LLDB_INVALID_ADDRESS)
2892                                            {
2893                                                DWARFDebugInfoEntry *function_die = NULL;
2894                                                DWARFDebugInfoEntry *block_die = NULL;
2895                                                dwarf_cu->LookupAddress(file_vm_addr, &function_die, resolve_scope & eSymbolContextBlock ? &block_die : NULL);
2896
2897                                                if (function_die != NULL)
2898                                                {
2899                                                    sc.function = sc.comp_unit->FindFunctionByUID (MakeUserID(function_die->GetOffset())).get();
2900                                                    if (sc.function == NULL)
2901                                                        sc.function = ParseCompileUnitFunction(sc, dwarf_cu, function_die);
2902                                                }
2903
2904                                                if (sc.function != NULL)
2905                                                {
2906                                                    Block& block = sc.function->GetBlock (true);
2907
2908                                                    if (block_die != NULL)
2909                                                        sc.block = block.FindBlockByID (MakeUserID(block_die->GetOffset()));
2910                                                    else
2911                                                        sc.block = block.FindBlockByID (MakeUserID(function_die->GetOffset()));
2912                                                }
2913                                            }
2914                                        }
2915
2916                                        sc_list.Append(sc);
2917                                        line_idx = line_table->FindLineEntryIndexByFileIndex (line_idx + 1, file_idx, found_line, true, &sc.line_entry);
2918                                    }
2919                                }
2920                            }
2921                            else if (file_spec_matches_cu_file_spec && !check_inlines)
2922                            {
2923                                // only append the context if we aren't looking for inline call sites
2924                                // by file and line and if the file spec matches that of the compile unit
2925                                sc_list.Append(sc);
2926                            }
2927                        }
2928                        else if (file_spec_matches_cu_file_spec && !check_inlines)
2929                        {
2930                            // only append the context if we aren't looking for inline call sites
2931                            // by file and line and if the file spec matches that of the compile unit
2932                            sc_list.Append(sc);
2933                        }
2934
2935                        if (!check_inlines)
2936                            break;
2937                    }
2938                }
2939            }
2940        }
2941    }
2942    return sc_list.GetSize() - prev_size;
2943}
2944
2945void
2946SymbolFileDWARF::Index ()
2947{
2948    if (m_indexed)
2949        return;
2950    m_indexed = true;
2951    Timer scoped_timer (__PRETTY_FUNCTION__,
2952                        "SymbolFileDWARF::Index (%s)",
2953                        GetObjectFile()->GetFileSpec().GetFilename().AsCString());
2954
2955    DWARFDebugInfo* debug_info = DebugInfo();
2956    if (debug_info)
2957    {
2958        uint32_t cu_idx = 0;
2959        const uint32_t num_compile_units = GetNumCompileUnits();
2960        for (cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
2961        {
2962            DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
2963
2964            bool clear_dies = dwarf_cu->ExtractDIEsIfNeeded (false) > 1;
2965
2966            dwarf_cu->Index (cu_idx,
2967                             m_function_basename_index,
2968                             m_function_fullname_index,
2969                             m_function_method_index,
2970                             m_function_selector_index,
2971                             m_objc_class_selectors_index,
2972                             m_global_index,
2973                             m_type_index,
2974                             m_namespace_index);
2975
2976            // Keep memory down by clearing DIEs if this generate function
2977            // caused them to be parsed
2978            if (clear_dies)
2979                dwarf_cu->ClearDIEs (true);
2980        }
2981
2982        m_function_basename_index.Finalize();
2983        m_function_fullname_index.Finalize();
2984        m_function_method_index.Finalize();
2985        m_function_selector_index.Finalize();
2986        m_objc_class_selectors_index.Finalize();
2987        m_global_index.Finalize();
2988        m_type_index.Finalize();
2989        m_namespace_index.Finalize();
2990
2991#if defined (ENABLE_DEBUG_PRINTF)
2992        StreamFile s(stdout, false);
2993        s.Printf ("DWARF index for '%s':",
2994                  GetObjectFile()->GetFileSpec().GetPath().c_str());
2995        s.Printf("\nFunction basenames:\n");    m_function_basename_index.Dump (&s);
2996        s.Printf("\nFunction fullnames:\n");    m_function_fullname_index.Dump (&s);
2997        s.Printf("\nFunction methods:\n");      m_function_method_index.Dump (&s);
2998        s.Printf("\nFunction selectors:\n");    m_function_selector_index.Dump (&s);
2999        s.Printf("\nObjective C class selectors:\n");    m_objc_class_selectors_index.Dump (&s);
3000        s.Printf("\nGlobals and statics:\n");   m_global_index.Dump (&s);
3001        s.Printf("\nTypes:\n");                 m_type_index.Dump (&s);
3002        s.Printf("\nNamepaces:\n");             m_namespace_index.Dump (&s);
3003#endif
3004    }
3005}
3006
3007bool
3008SymbolFileDWARF::NamespaceDeclMatchesThisSymbolFile (const ClangNamespaceDecl *namespace_decl)
3009{
3010    if (namespace_decl == NULL)
3011    {
3012        // Invalid namespace decl which means we aren't matching only things
3013        // in this symbol file, so return true to indicate it matches this
3014        // symbol file.
3015        return true;
3016    }
3017
3018    clang::ASTContext *namespace_ast = namespace_decl->GetASTContext();
3019
3020    if (namespace_ast == NULL)
3021        return true;    // No AST in the "namespace_decl", return true since it
3022                        // could then match any symbol file, including this one
3023
3024    if (namespace_ast == GetClangASTContext().getASTContext())
3025        return true;    // The ASTs match, return true
3026
3027    // The namespace AST was valid, and it does not match...
3028    Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
3029
3030    if (log)
3031        GetObjectFile()->GetModule()->LogMessage(log, "Valid namespace does not match symbol file");
3032
3033    return false;
3034}
3035
3036bool
3037SymbolFileDWARF::DIEIsInNamespace (const ClangNamespaceDecl *namespace_decl,
3038                                   DWARFCompileUnit* cu,
3039                                   const DWARFDebugInfoEntry* die)
3040{
3041    // No namespace specified, so the answesr i
3042    if (namespace_decl == NULL)
3043        return true;
3044
3045    Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
3046
3047    const DWARFDebugInfoEntry *decl_ctx_die = NULL;
3048    clang::DeclContext *die_clang_decl_ctx = GetClangDeclContextContainingDIE (cu, die, &decl_ctx_die);
3049    if (decl_ctx_die)
3050    {
3051        clang::NamespaceDecl *clang_namespace_decl = namespace_decl->GetNamespaceDecl();
3052
3053        if (clang_namespace_decl)
3054        {
3055            if (decl_ctx_die->Tag() != DW_TAG_namespace)
3056            {
3057                if (log)
3058                    GetObjectFile()->GetModule()->LogMessage(log, "Found a match, but its parent is not a namespace");
3059                return false;
3060            }
3061
3062            if (clang_namespace_decl == die_clang_decl_ctx)
3063                return true;
3064            else
3065                return false;
3066        }
3067        else
3068        {
3069            // We have a namespace_decl that was not NULL but it contained
3070            // a NULL "clang::NamespaceDecl", so this means the global namespace
3071            // So as long the the contained decl context DIE isn't a namespace
3072            // we should be ok.
3073            if (decl_ctx_die->Tag() != DW_TAG_namespace)
3074                return true;
3075        }
3076    }
3077
3078    if (log)
3079        GetObjectFile()->GetModule()->LogMessage(log, "Found a match, but its parent doesn't exist");
3080
3081    return false;
3082}
3083uint32_t
3084SymbolFileDWARF::FindGlobalVariables (const ConstString &name, const lldb_private::ClangNamespaceDecl *namespace_decl, bool append, uint32_t max_matches, VariableList& variables)
3085{
3086    Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
3087
3088    if (log)
3089    {
3090        GetObjectFile()->GetModule()->LogMessage (log,
3091                                                  "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", namespace_decl=%p, append=%u, max_matches=%u, variables)",
3092                                                  name.GetCString(),
3093                                                  namespace_decl,
3094                                                  append,
3095                                                  max_matches);
3096    }
3097
3098    if (!NamespaceDeclMatchesThisSymbolFile(namespace_decl))
3099		return 0;
3100
3101    DWARFDebugInfo* info = DebugInfo();
3102    if (info == NULL)
3103        return 0;
3104
3105    // If we aren't appending the results to this list, then clear the list
3106    if (!append)
3107        variables.Clear();
3108
3109    // Remember how many variables are in the list before we search in case
3110    // we are appending the results to a variable list.
3111    const uint32_t original_size = variables.GetSize();
3112
3113    DIEArray die_offsets;
3114
3115    if (m_using_apple_tables)
3116    {
3117        if (m_apple_names_ap.get())
3118        {
3119            const char *name_cstr = name.GetCString();
3120            const char *base_name_start;
3121            const char *base_name_end = NULL;
3122
3123            if (!CPPLanguageRuntime::StripNamespacesFromVariableName(name_cstr, base_name_start, base_name_end))
3124                base_name_start = name_cstr;
3125
3126            m_apple_names_ap->FindByName (base_name_start, die_offsets);
3127        }
3128    }
3129    else
3130    {
3131        // Index the DWARF if we haven't already
3132        if (!m_indexed)
3133            Index ();
3134
3135        m_global_index.Find (name, die_offsets);
3136    }
3137
3138    const size_t num_die_matches = die_offsets.size();
3139    if (num_die_matches)
3140    {
3141        SymbolContext sc;
3142        sc.module_sp = m_obj_file->GetModule();
3143        assert (sc.module_sp);
3144
3145        DWARFDebugInfo* debug_info = DebugInfo();
3146        DWARFCompileUnit* dwarf_cu = NULL;
3147        const DWARFDebugInfoEntry* die = NULL;
3148        bool done = false;
3149        for (size_t i=0; i<num_die_matches && !done; ++i)
3150        {
3151            const dw_offset_t die_offset = die_offsets[i];
3152            die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu);
3153
3154            if (die)
3155            {
3156                switch (die->Tag())
3157                {
3158                    default:
3159                    case DW_TAG_subprogram:
3160                    case DW_TAG_inlined_subroutine:
3161                    case DW_TAG_try_block:
3162                    case DW_TAG_catch_block:
3163                        break;
3164
3165                    case DW_TAG_variable:
3166                        {
3167                            sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, UINT32_MAX);
3168
3169                            if (namespace_decl && !DIEIsInNamespace (namespace_decl, dwarf_cu, die))
3170                                continue;
3171
3172                            ParseVariables(sc, dwarf_cu, LLDB_INVALID_ADDRESS, die, false, false, &variables);
3173
3174                            if (variables.GetSize() - original_size >= max_matches)
3175                                done = true;
3176                        }
3177                        break;
3178                }
3179            }
3180            else
3181            {
3182                if (m_using_apple_tables)
3183                {
3184                    GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')\n",
3185                                                                               die_offset, name.GetCString());
3186                }
3187            }
3188        }
3189    }
3190
3191    // Return the number of variable that were appended to the list
3192    const uint32_t num_matches = variables.GetSize() - original_size;
3193    if (log && num_matches > 0)
3194    {
3195        GetObjectFile()->GetModule()->LogMessage (log,
3196                                                  "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", namespace_decl=%p, append=%u, max_matches=%u, variables) => %u",
3197                                                  name.GetCString(),
3198                                                  namespace_decl,
3199                                                  append,
3200                                                  max_matches,
3201                                                  num_matches);
3202    }
3203    return num_matches;
3204}
3205
3206uint32_t
3207SymbolFileDWARF::FindGlobalVariables(const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables)
3208{
3209    Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
3210
3211    if (log)
3212    {
3213        GetObjectFile()->GetModule()->LogMessage (log,
3214                                                  "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", append=%u, max_matches=%u, variables)",
3215                                                  regex.GetText(),
3216                                                  append,
3217                                                  max_matches);
3218    }
3219
3220    DWARFDebugInfo* info = DebugInfo();
3221    if (info == NULL)
3222        return 0;
3223
3224    // If we aren't appending the results to this list, then clear the list
3225    if (!append)
3226        variables.Clear();
3227
3228    // Remember how many variables are in the list before we search in case
3229    // we are appending the results to a variable list.
3230    const uint32_t original_size = variables.GetSize();
3231
3232    DIEArray die_offsets;
3233
3234    if (m_using_apple_tables)
3235    {
3236        if (m_apple_names_ap.get())
3237        {
3238            DWARFMappedHash::DIEInfoArray hash_data_array;
3239            if (m_apple_names_ap->AppendAllDIEsThatMatchingRegex (regex, hash_data_array))
3240                DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets);
3241        }
3242    }
3243    else
3244    {
3245        // Index the DWARF if we haven't already
3246        if (!m_indexed)
3247            Index ();
3248
3249        m_global_index.Find (regex, die_offsets);
3250    }
3251
3252    SymbolContext sc;
3253    sc.module_sp = m_obj_file->GetModule();
3254    assert (sc.module_sp);
3255
3256    DWARFCompileUnit* dwarf_cu = NULL;
3257    const DWARFDebugInfoEntry* die = NULL;
3258    const size_t num_matches = die_offsets.size();
3259    if (num_matches)
3260    {
3261        DWARFDebugInfo* debug_info = DebugInfo();
3262        for (size_t i=0; i<num_matches; ++i)
3263        {
3264            const dw_offset_t die_offset = die_offsets[i];
3265            die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu);
3266
3267            if (die)
3268            {
3269                sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, UINT32_MAX);
3270
3271                ParseVariables(sc, dwarf_cu, LLDB_INVALID_ADDRESS, die, false, false, &variables);
3272
3273                if (variables.GetSize() - original_size >= max_matches)
3274                    break;
3275            }
3276            else
3277            {
3278                if (m_using_apple_tables)
3279                {
3280                    GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for regex '%s')\n",
3281                                                                               die_offset, regex.GetText());
3282                }
3283            }
3284        }
3285    }
3286
3287    // Return the number of variable that were appended to the list
3288    return variables.GetSize() - original_size;
3289}
3290
3291
3292bool
3293SymbolFileDWARF::ResolveFunction (dw_offset_t die_offset,
3294                                  DWARFCompileUnit *&dwarf_cu,
3295                                  SymbolContextList& sc_list)
3296{
3297    const DWARFDebugInfoEntry *die = DebugInfo()->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu);
3298    return ResolveFunction (dwarf_cu, die, sc_list);
3299}
3300
3301
3302bool
3303SymbolFileDWARF::ResolveFunction (DWARFCompileUnit *cu,
3304                                  const DWARFDebugInfoEntry *die,
3305                                  SymbolContextList& sc_list)
3306{
3307    SymbolContext sc;
3308
3309    if (die == NULL)
3310        return false;
3311
3312    // If we were passed a die that is not a function, just return false...
3313    if (die->Tag() != DW_TAG_subprogram && die->Tag() != DW_TAG_inlined_subroutine)
3314        return false;
3315
3316    const DWARFDebugInfoEntry* inlined_die = NULL;
3317    if (die->Tag() == DW_TAG_inlined_subroutine)
3318    {
3319        inlined_die = die;
3320
3321        while ((die = die->GetParent()) != NULL)
3322        {
3323            if (die->Tag() == DW_TAG_subprogram)
3324                break;
3325        }
3326    }
3327    assert (die->Tag() == DW_TAG_subprogram);
3328    if (GetFunction (cu, die, sc))
3329    {
3330        Address addr;
3331        // Parse all blocks if needed
3332        if (inlined_die)
3333        {
3334            sc.block = sc.function->GetBlock (true).FindBlockByID (MakeUserID(inlined_die->GetOffset()));
3335            assert (sc.block != NULL);
3336            if (sc.block->GetStartAddress (addr) == false)
3337                addr.Clear();
3338        }
3339        else
3340        {
3341            sc.block = NULL;
3342            addr = sc.function->GetAddressRange().GetBaseAddress();
3343        }
3344
3345        if (addr.IsValid())
3346        {
3347            sc_list.Append(sc);
3348            return true;
3349        }
3350    }
3351
3352    return false;
3353}
3354
3355void
3356SymbolFileDWARF::FindFunctions (const ConstString &name,
3357                                const NameToDIE &name_to_die,
3358                                SymbolContextList& sc_list)
3359{
3360    DIEArray die_offsets;
3361    if (name_to_die.Find (name, die_offsets))
3362    {
3363        ParseFunctions (die_offsets, sc_list);
3364    }
3365}
3366
3367
3368void
3369SymbolFileDWARF::FindFunctions (const RegularExpression &regex,
3370                                const NameToDIE &name_to_die,
3371                                SymbolContextList& sc_list)
3372{
3373    DIEArray die_offsets;
3374    if (name_to_die.Find (regex, die_offsets))
3375    {
3376        ParseFunctions (die_offsets, sc_list);
3377    }
3378}
3379
3380
3381void
3382SymbolFileDWARF::FindFunctions (const RegularExpression &regex,
3383                                const DWARFMappedHash::MemoryTable &memory_table,
3384                                SymbolContextList& sc_list)
3385{
3386    DIEArray die_offsets;
3387    DWARFMappedHash::DIEInfoArray hash_data_array;
3388    if (memory_table.AppendAllDIEsThatMatchingRegex (regex, hash_data_array))
3389    {
3390        DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets);
3391        ParseFunctions (die_offsets, sc_list);
3392    }
3393}
3394
3395void
3396SymbolFileDWARF::ParseFunctions (const DIEArray &die_offsets,
3397                                 SymbolContextList& sc_list)
3398{
3399    const size_t num_matches = die_offsets.size();
3400    if (num_matches)
3401    {
3402        SymbolContext sc;
3403
3404        DWARFCompileUnit* dwarf_cu = NULL;
3405        for (size_t i=0; i<num_matches; ++i)
3406        {
3407            const dw_offset_t die_offset = die_offsets[i];
3408            ResolveFunction (die_offset, dwarf_cu, sc_list);
3409        }
3410    }
3411}
3412
3413bool
3414SymbolFileDWARF::FunctionDieMatchesPartialName (const DWARFDebugInfoEntry* die,
3415                                                const DWARFCompileUnit *dwarf_cu,
3416                                                uint32_t name_type_mask,
3417                                                const char *partial_name,
3418                                                const char *base_name_start,
3419                                                const char *base_name_end)
3420{
3421    // If we are looking only for methods, throw away all the ones that are or aren't in C++ classes:
3422    if (name_type_mask == eFunctionNameTypeMethod || name_type_mask == eFunctionNameTypeBase)
3423    {
3424        clang::DeclContext *containing_decl_ctx = GetClangDeclContextContainingDIEOffset(die->GetOffset());
3425        if (!containing_decl_ctx)
3426            return false;
3427
3428        bool is_cxx_method = DeclKindIsCXXClass(containing_decl_ctx->getDeclKind());
3429
3430        if (name_type_mask == eFunctionNameTypeMethod)
3431        {
3432            if (is_cxx_method == false)
3433                return false;
3434        }
3435
3436        if (name_type_mask == eFunctionNameTypeBase)
3437        {
3438            if (is_cxx_method == true)
3439                return false;
3440        }
3441    }
3442
3443    // Now we need to check whether the name we got back for this type matches the extra specifications
3444    // that were in the name we're looking up:
3445    if (base_name_start != partial_name || *base_name_end != '\0')
3446    {
3447        // First see if the stuff to the left matches the full name.  To do that let's see if
3448        // we can pull out the mips linkage name attribute:
3449
3450        Mangled best_name;
3451        DWARFDebugInfoEntry::Attributes attributes;
3452        DWARFFormValue form_value;
3453        die->GetAttributes(this, dwarf_cu, NULL, attributes);
3454        uint32_t idx = attributes.FindAttributeIndex(DW_AT_MIPS_linkage_name);
3455        if (idx == UINT32_MAX)
3456            idx = attributes.FindAttributeIndex(DW_AT_linkage_name);
3457        if (idx != UINT32_MAX)
3458        {
3459            if (attributes.ExtractFormValueAtIndex(this, idx, form_value))
3460            {
3461                const char *mangled_name = form_value.AsCString(&get_debug_str_data());
3462                if (mangled_name)
3463                    best_name.SetValue (ConstString(mangled_name), true);
3464            }
3465        }
3466
3467        if (!best_name)
3468        {
3469            idx = attributes.FindAttributeIndex(DW_AT_name);
3470            if (idx != UINT32_MAX && attributes.ExtractFormValueAtIndex(this, idx, form_value))
3471            {
3472                const char *name = form_value.AsCString(&get_debug_str_data());
3473                best_name.SetValue (ConstString(name), false);
3474            }
3475        }
3476
3477        if (best_name.GetDemangledName())
3478        {
3479            const char *demangled = best_name.GetDemangledName().GetCString();
3480            if (demangled)
3481            {
3482                std::string name_no_parens(partial_name, base_name_end - partial_name);
3483                const char *partial_in_demangled = strstr (demangled, name_no_parens.c_str());
3484                if (partial_in_demangled == NULL)
3485                    return false;
3486                else
3487                {
3488                    // Sort out the case where our name is something like "Process::Destroy" and the match is
3489                    // "SBProcess::Destroy" - that shouldn't be a match.  We should really always match on
3490                    // namespace boundaries...
3491
3492                    if (partial_name[0] == ':'  && partial_name[1] == ':')
3493                    {
3494                        // The partial name was already on a namespace boundary so all matches are good.
3495                        return true;
3496                    }
3497                    else if (partial_in_demangled == demangled)
3498                    {
3499                        // They both start the same, so this is an good match.
3500                        return true;
3501                    }
3502                    else
3503                    {
3504                        if (partial_in_demangled - demangled == 1)
3505                        {
3506                            // Only one character difference, can't be a namespace boundary...
3507                            return false;
3508                        }
3509                        else if (*(partial_in_demangled - 1) == ':' && *(partial_in_demangled - 2) == ':')
3510                        {
3511                            // We are on a namespace boundary, so this is also good.
3512                            return true;
3513                        }
3514                        else
3515                            return false;
3516                    }
3517                }
3518            }
3519        }
3520    }
3521
3522    return true;
3523}
3524
3525uint32_t
3526SymbolFileDWARF::FindFunctions (const ConstString &name,
3527                                const lldb_private::ClangNamespaceDecl *namespace_decl,
3528                                uint32_t name_type_mask,
3529                                bool include_inlines,
3530                                bool append,
3531                                SymbolContextList& sc_list)
3532{
3533    Timer scoped_timer (__PRETTY_FUNCTION__,
3534                        "SymbolFileDWARF::FindFunctions (name = '%s')",
3535                        name.AsCString());
3536
3537    // eFunctionNameTypeAuto should be pre-resolved by a call to Module::PrepareForFunctionNameLookup()
3538    assert ((name_type_mask & eFunctionNameTypeAuto) == 0);
3539
3540    Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
3541
3542    if (log)
3543    {
3544        GetObjectFile()->GetModule()->LogMessage (log,
3545                                                  "SymbolFileDWARF::FindFunctions (name=\"%s\", name_type_mask=0x%x, append=%u, sc_list)",
3546                                                  name.GetCString(),
3547                                                  name_type_mask,
3548                                                  append);
3549    }
3550
3551    // If we aren't appending the results to this list, then clear the list
3552    if (!append)
3553        sc_list.Clear();
3554
3555    if (!NamespaceDeclMatchesThisSymbolFile(namespace_decl))
3556		return 0;
3557
3558    // If name is empty then we won't find anything.
3559    if (name.IsEmpty())
3560        return 0;
3561
3562    // Remember how many sc_list are in the list before we search in case
3563    // we are appending the results to a variable list.
3564
3565    const char *name_cstr = name.GetCString();
3566
3567    const uint32_t original_size = sc_list.GetSize();
3568
3569    DWARFDebugInfo* info = DebugInfo();
3570    if (info == NULL)
3571        return 0;
3572
3573    DWARFCompileUnit *dwarf_cu = NULL;
3574    std::set<const DWARFDebugInfoEntry *> resolved_dies;
3575    if (m_using_apple_tables)
3576    {
3577        if (m_apple_names_ap.get())
3578        {
3579
3580            DIEArray die_offsets;
3581
3582            uint32_t num_matches = 0;
3583
3584            if (name_type_mask & eFunctionNameTypeFull)
3585            {
3586                // If they asked for the full name, match what they typed.  At some point we may
3587                // want to canonicalize this (strip double spaces, etc.  For now, we just add all the
3588                // dies that we find by exact match.
3589                num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets);
3590                for (uint32_t i = 0; i < num_matches; i++)
3591                {
3592                    const dw_offset_t die_offset = die_offsets[i];
3593                    const DWARFDebugInfoEntry *die = info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu);
3594                    if (die)
3595                    {
3596                        if (namespace_decl && !DIEIsInNamespace (namespace_decl, dwarf_cu, die))
3597                            continue;
3598
3599                        if (!include_inlines && die->Tag() == DW_TAG_inlined_subroutine)
3600                            continue;
3601
3602                        if (resolved_dies.find(die) == resolved_dies.end())
3603                        {
3604                            if (ResolveFunction (dwarf_cu, die, sc_list))
3605                                resolved_dies.insert(die);
3606                        }
3607                    }
3608                    else
3609                    {
3610                        GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')",
3611                                                                                   die_offset, name_cstr);
3612                    }
3613                }
3614            }
3615
3616            if (name_type_mask & eFunctionNameTypeSelector)
3617            {
3618                if (namespace_decl && *namespace_decl)
3619                    return 0; // no selectors in namespaces
3620
3621                num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets);
3622                // Now make sure these are actually ObjC methods.  In this case we can simply look up the name,
3623                // and if it is an ObjC method name, we're good.
3624
3625                for (uint32_t i = 0; i < num_matches; i++)
3626                {
3627                    const dw_offset_t die_offset = die_offsets[i];
3628                    const DWARFDebugInfoEntry* die = info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu);
3629                    if (die)
3630                    {
3631                        const char *die_name = die->GetName(this, dwarf_cu);
3632                        if (ObjCLanguageRuntime::IsPossibleObjCMethodName(die_name))
3633                        {
3634                            if (!include_inlines && die->Tag() == DW_TAG_inlined_subroutine)
3635                                continue;
3636
3637                            if (resolved_dies.find(die) == resolved_dies.end())
3638                            {
3639                                if (ResolveFunction (dwarf_cu, die, sc_list))
3640                                    resolved_dies.insert(die);
3641                            }
3642                        }
3643                    }
3644                    else
3645                    {
3646                        GetObjectFile()->GetModule()->ReportError ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')",
3647                                                                   die_offset, name_cstr);
3648                    }
3649                }
3650                die_offsets.clear();
3651            }
3652
3653            if (((name_type_mask & eFunctionNameTypeMethod) && !namespace_decl) || name_type_mask & eFunctionNameTypeBase)
3654            {
3655                // The apple_names table stores just the "base name" of C++ methods in the table.  So we have to
3656                // extract the base name, look that up, and if there is any other information in the name we were
3657                // passed in we have to post-filter based on that.
3658
3659                // FIXME: Arrange the logic above so that we don't calculate the base name twice:
3660                num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets);
3661
3662                for (uint32_t i = 0; i < num_matches; i++)
3663                {
3664                    const dw_offset_t die_offset = die_offsets[i];
3665                    const DWARFDebugInfoEntry* die = info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu);
3666                    if (die)
3667                    {
3668                        if (!include_inlines && die->Tag() == DW_TAG_inlined_subroutine)
3669                            continue;
3670
3671                        if (namespace_decl && !DIEIsInNamespace (namespace_decl, dwarf_cu, die))
3672                            continue;
3673
3674                        // If we get to here, the die is good, and we should add it:
3675                        if (resolved_dies.find(die) == resolved_dies.end())
3676                        if (ResolveFunction (dwarf_cu, die, sc_list))
3677                        {
3678                            bool keep_die = true;
3679                            if ((name_type_mask & (eFunctionNameTypeBase|eFunctionNameTypeMethod)) != (eFunctionNameTypeBase|eFunctionNameTypeMethod))
3680                            {
3681                                // We are looking for either basenames or methods, so we need to
3682                                // trim out the ones we won't want by looking at the type
3683                                SymbolContext sc;
3684                                if (sc_list.GetLastContext(sc))
3685                                {
3686                                    if (sc.block)
3687                                    {
3688                                        // We have an inlined function
3689                                    }
3690                                    else if (sc.function)
3691                                    {
3692                                        Type *type = sc.function->GetType();
3693
3694                                        clang::DeclContext* decl_ctx = GetClangDeclContextContainingTypeUID (type->GetID());
3695                                        if (decl_ctx->isRecord())
3696                                        {
3697                                            if (name_type_mask & eFunctionNameTypeBase)
3698                                            {
3699                                                sc_list.RemoveContextAtIndex(sc_list.GetSize()-1);
3700                                                keep_die = false;
3701                                            }
3702                                        }
3703                                        else
3704                                        {
3705                                            if (name_type_mask & eFunctionNameTypeMethod)
3706                                            {
3707                                                sc_list.RemoveContextAtIndex(sc_list.GetSize()-1);
3708                                                keep_die = false;
3709                                            }
3710                                        }
3711                                    }
3712                                }
3713                            }
3714                            if (keep_die)
3715                                resolved_dies.insert(die);
3716                        }
3717                    }
3718                    else
3719                    {
3720                        GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')",
3721                                                                                   die_offset, name_cstr);
3722                    }
3723                }
3724                die_offsets.clear();
3725            }
3726        }
3727    }
3728    else
3729    {
3730
3731        // Index the DWARF if we haven't already
3732        if (!m_indexed)
3733            Index ();
3734
3735        if (name_type_mask & eFunctionNameTypeFull)
3736        {
3737            FindFunctions (name, m_function_fullname_index, sc_list);
3738
3739            // Temporary workaround for global/anonymous namespace functions on linux
3740#if defined (__linux__)
3741            // If we didn't find any functions in the global namespace try
3742            // looking in the basename index but ignore any returned
3743            // functions that have a namespace (ie. mangled names starting with
3744            // '_ZN') but keep functions which have an anonymous namespace
3745            if (sc_list.GetSize() == 0)
3746            {
3747                SymbolContextList temp_sc_list;
3748                FindFunctions (name, m_function_basename_index, temp_sc_list);
3749                if (!namespace_decl)
3750                {
3751                    SymbolContext sc;
3752                    for (uint32_t i = 0; i < temp_sc_list.GetSize(); i++)
3753                    {
3754                        if (temp_sc_list.GetContextAtIndex(i, sc))
3755                        {
3756                            ConstString mangled_name = sc.GetFunctionName(Mangled::ePreferMangled);
3757                            ConstString demangled_name = sc.GetFunctionName(Mangled::ePreferDemangled);
3758                            if (strncmp(mangled_name.GetCString(), "_ZN", 3) ||
3759                                !strncmp(demangled_name.GetCString(), "(anonymous namespace)", 21))
3760                            {
3761                                sc_list.Append(sc);
3762                            }
3763                        }
3764                    }
3765                }
3766            }
3767#endif
3768        }
3769        DIEArray die_offsets;
3770        DWARFCompileUnit *dwarf_cu = NULL;
3771
3772        if (name_type_mask & eFunctionNameTypeBase)
3773        {
3774            uint32_t num_base = m_function_basename_index.Find(name, die_offsets);
3775            for (uint32_t i = 0; i < num_base; i++)
3776            {
3777                const DWARFDebugInfoEntry* die = info->GetDIEPtrWithCompileUnitHint (die_offsets[i], &dwarf_cu);
3778                if (die)
3779                {
3780                    if (!include_inlines && die->Tag() == DW_TAG_inlined_subroutine)
3781                        continue;
3782
3783                    if (namespace_decl && !DIEIsInNamespace (namespace_decl, dwarf_cu, die))
3784                        continue;
3785
3786                    // If we get to here, the die is good, and we should add it:
3787                    if (resolved_dies.find(die) == resolved_dies.end())
3788                    {
3789                        if (ResolveFunction (dwarf_cu, die, sc_list))
3790                            resolved_dies.insert(die);
3791                    }
3792                }
3793            }
3794            die_offsets.clear();
3795        }
3796
3797        if (name_type_mask & eFunctionNameTypeMethod)
3798        {
3799            if (namespace_decl && *namespace_decl)
3800                return 0; // no methods in namespaces
3801
3802            uint32_t num_base = m_function_method_index.Find(name, die_offsets);
3803            {
3804                for (uint32_t i = 0; i < num_base; i++)
3805                {
3806                    const DWARFDebugInfoEntry* die = info->GetDIEPtrWithCompileUnitHint (die_offsets[i], &dwarf_cu);
3807                    if (die)
3808                    {
3809                        if (!include_inlines && die->Tag() == DW_TAG_inlined_subroutine)
3810                            continue;
3811
3812                        // If we get to here, the die is good, and we should add it:
3813                        if (resolved_dies.find(die) == resolved_dies.end())
3814                        {
3815                            if (ResolveFunction (dwarf_cu, die, sc_list))
3816                                resolved_dies.insert(die);
3817                        }
3818                    }
3819                }
3820            }
3821            die_offsets.clear();
3822        }
3823
3824        if ((name_type_mask & eFunctionNameTypeSelector) && (!namespace_decl || !*namespace_decl))
3825        {
3826            FindFunctions (name, m_function_selector_index, sc_list);
3827        }
3828
3829    }
3830
3831    // Return the number of variable that were appended to the list
3832    const uint32_t num_matches = sc_list.GetSize() - original_size;
3833
3834    if (log && num_matches > 0)
3835    {
3836        GetObjectFile()->GetModule()->LogMessage (log,
3837                                                  "SymbolFileDWARF::FindFunctions (name=\"%s\", name_type_mask=0x%x, append=%u, sc_list) => %u",
3838                                                  name.GetCString(),
3839                                                  name_type_mask,
3840                                                  append,
3841                                                  num_matches);
3842    }
3843    return num_matches;
3844}
3845
3846uint32_t
3847SymbolFileDWARF::FindFunctions(const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list)
3848{
3849    Timer scoped_timer (__PRETTY_FUNCTION__,
3850                        "SymbolFileDWARF::FindFunctions (regex = '%s')",
3851                        regex.GetText());
3852
3853    Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
3854
3855    if (log)
3856    {
3857        GetObjectFile()->GetModule()->LogMessage (log,
3858                                                  "SymbolFileDWARF::FindFunctions (regex=\"%s\", append=%u, sc_list)",
3859                                                  regex.GetText(),
3860                                                  append);
3861    }
3862
3863
3864    // If we aren't appending the results to this list, then clear the list
3865    if (!append)
3866        sc_list.Clear();
3867
3868    // Remember how many sc_list are in the list before we search in case
3869    // we are appending the results to a variable list.
3870    uint32_t original_size = sc_list.GetSize();
3871
3872    if (m_using_apple_tables)
3873    {
3874        if (m_apple_names_ap.get())
3875            FindFunctions (regex, *m_apple_names_ap, sc_list);
3876    }
3877    else
3878    {
3879        // Index the DWARF if we haven't already
3880        if (!m_indexed)
3881            Index ();
3882
3883        FindFunctions (regex, m_function_basename_index, sc_list);
3884
3885        FindFunctions (regex, m_function_fullname_index, sc_list);
3886    }
3887
3888    // Return the number of variable that were appended to the list
3889    return sc_list.GetSize() - original_size;
3890}
3891
3892uint32_t
3893SymbolFileDWARF::FindTypes (const SymbolContext& sc,
3894                            const ConstString &name,
3895                            const lldb_private::ClangNamespaceDecl *namespace_decl,
3896                            bool append,
3897                            uint32_t max_matches,
3898                            TypeList& types)
3899{
3900    DWARFDebugInfo* info = DebugInfo();
3901    if (info == NULL)
3902        return 0;
3903
3904    Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
3905
3906    if (log)
3907    {
3908        if (namespace_decl)
3909        {
3910            GetObjectFile()->GetModule()->LogMessage (log,
3911                                                      "SymbolFileDWARF::FindTypes (sc, name=\"%s\", clang::NamespaceDecl(%p) \"%s\", append=%u, max_matches=%u, type_list)",
3912                                                      name.GetCString(),
3913                                                      namespace_decl->GetNamespaceDecl(),
3914                                                      namespace_decl->GetQualifiedName().c_str(),
3915                                                      append,
3916                                                      max_matches);
3917        }
3918        else
3919        {
3920            GetObjectFile()->GetModule()->LogMessage (log,
3921                                                      "SymbolFileDWARF::FindTypes (sc, name=\"%s\", clang::NamespaceDecl(NULL), append=%u, max_matches=%u, type_list)",
3922                                                      name.GetCString(),
3923                                                      append,
3924                                                      max_matches);
3925        }
3926    }
3927
3928    // If we aren't appending the results to this list, then clear the list
3929    if (!append)
3930        types.Clear();
3931
3932    if (!NamespaceDeclMatchesThisSymbolFile(namespace_decl))
3933		return 0;
3934
3935    DIEArray die_offsets;
3936
3937    if (m_using_apple_tables)
3938    {
3939        if (m_apple_types_ap.get())
3940        {
3941            const char *name_cstr = name.GetCString();
3942            m_apple_types_ap->FindByName (name_cstr, die_offsets);
3943        }
3944    }
3945    else
3946    {
3947        if (!m_indexed)
3948            Index ();
3949
3950        m_type_index.Find (name, die_offsets);
3951    }
3952
3953    const size_t num_die_matches = die_offsets.size();
3954
3955    if (num_die_matches)
3956    {
3957        const uint32_t initial_types_size = types.GetSize();
3958        DWARFCompileUnit* dwarf_cu = NULL;
3959        const DWARFDebugInfoEntry* die = NULL;
3960        DWARFDebugInfo* debug_info = DebugInfo();
3961        for (size_t i=0; i<num_die_matches; ++i)
3962        {
3963            const dw_offset_t die_offset = die_offsets[i];
3964            die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu);
3965
3966            if (die)
3967            {
3968                if (namespace_decl && !DIEIsInNamespace (namespace_decl, dwarf_cu, die))
3969                    continue;
3970
3971                Type *matching_type = ResolveType (dwarf_cu, die);
3972                if (matching_type)
3973                {
3974                    // We found a type pointer, now find the shared pointer form our type list
3975                    types.InsertUnique (matching_type->shared_from_this());
3976                    if (types.GetSize() >= max_matches)
3977                        break;
3978                }
3979            }
3980            else
3981            {
3982                if (m_using_apple_tables)
3983                {
3984                    GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n",
3985                                                                               die_offset, name.GetCString());
3986                }
3987            }
3988
3989        }
3990        const uint32_t num_matches = types.GetSize() - initial_types_size;
3991        if (log && num_matches)
3992        {
3993            if (namespace_decl)
3994            {
3995                GetObjectFile()->GetModule()->LogMessage (log,
3996                                                          "SymbolFileDWARF::FindTypes (sc, name=\"%s\", clang::NamespaceDecl(%p) \"%s\", append=%u, max_matches=%u, type_list) => %u",
3997                                                          name.GetCString(),
3998                                                          namespace_decl->GetNamespaceDecl(),
3999                                                          namespace_decl->GetQualifiedName().c_str(),
4000                                                          append,
4001                                                          max_matches,
4002                                                          num_matches);
4003            }
4004            else
4005            {
4006                GetObjectFile()->GetModule()->LogMessage (log,
4007                                                          "SymbolFileDWARF::FindTypes (sc, name=\"%s\", clang::NamespaceDecl(NULL), append=%u, max_matches=%u, type_list) => %u",
4008                                                          name.GetCString(),
4009                                                          append,
4010                                                          max_matches,
4011                                                          num_matches);
4012            }
4013        }
4014        return num_matches;
4015    }
4016    return 0;
4017}
4018
4019
4020ClangNamespaceDecl
4021SymbolFileDWARF::FindNamespace (const SymbolContext& sc,
4022                                const ConstString &name,
4023                                const lldb_private::ClangNamespaceDecl *parent_namespace_decl)
4024{
4025    Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
4026
4027    if (log)
4028    {
4029        GetObjectFile()->GetModule()->LogMessage (log,
4030                                                  "SymbolFileDWARF::FindNamespace (sc, name=\"%s\")",
4031                                                  name.GetCString());
4032    }
4033
4034    if (!NamespaceDeclMatchesThisSymbolFile(parent_namespace_decl))
4035		return ClangNamespaceDecl();
4036
4037    ClangNamespaceDecl namespace_decl;
4038    DWARFDebugInfo* info = DebugInfo();
4039    if (info)
4040    {
4041        DIEArray die_offsets;
4042
4043        // Index if we already haven't to make sure the compile units
4044        // get indexed and make their global DIE index list
4045        if (m_using_apple_tables)
4046        {
4047            if (m_apple_namespaces_ap.get())
4048            {
4049                const char *name_cstr = name.GetCString();
4050                m_apple_namespaces_ap->FindByName (name_cstr, die_offsets);
4051            }
4052        }
4053        else
4054        {
4055            if (!m_indexed)
4056                Index ();
4057
4058            m_namespace_index.Find (name, die_offsets);
4059        }
4060
4061        DWARFCompileUnit* dwarf_cu = NULL;
4062        const DWARFDebugInfoEntry* die = NULL;
4063        const size_t num_matches = die_offsets.size();
4064        if (num_matches)
4065        {
4066            DWARFDebugInfo* debug_info = DebugInfo();
4067            for (size_t i=0; i<num_matches; ++i)
4068            {
4069                const dw_offset_t die_offset = die_offsets[i];
4070                die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu);
4071
4072                if (die)
4073                {
4074                    if (parent_namespace_decl && !DIEIsInNamespace (parent_namespace_decl, dwarf_cu, die))
4075                        continue;
4076
4077                    clang::NamespaceDecl *clang_namespace_decl = ResolveNamespaceDIE (dwarf_cu, die);
4078                    if (clang_namespace_decl)
4079                    {
4080                        namespace_decl.SetASTContext (GetClangASTContext().getASTContext());
4081                        namespace_decl.SetNamespaceDecl (clang_namespace_decl);
4082                        break;
4083                    }
4084                }
4085                else
4086                {
4087                    if (m_using_apple_tables)
4088                    {
4089                        GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_namespaces accelerator table had bad die 0x%8.8x for '%s')\n",
4090                                                                   die_offset, name.GetCString());
4091                    }
4092                }
4093
4094            }
4095        }
4096    }
4097    if (log && namespace_decl.GetNamespaceDecl())
4098    {
4099        GetObjectFile()->GetModule()->LogMessage (log,
4100                                                  "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => clang::NamespaceDecl(%p) \"%s\"",
4101                                                  name.GetCString(),
4102                                                  namespace_decl.GetNamespaceDecl(),
4103                                                  namespace_decl.GetQualifiedName().c_str());
4104    }
4105
4106    return namespace_decl;
4107}
4108
4109uint32_t
4110SymbolFileDWARF::FindTypes(std::vector<dw_offset_t> die_offsets, uint32_t max_matches, TypeList& types)
4111{
4112    // Remember how many sc_list are in the list before we search in case
4113    // we are appending the results to a variable list.
4114    uint32_t original_size = types.GetSize();
4115
4116    const uint32_t num_die_offsets = die_offsets.size();
4117    // Parse all of the types we found from the pubtypes matches
4118    uint32_t i;
4119    uint32_t num_matches = 0;
4120    for (i = 0; i < num_die_offsets; ++i)
4121    {
4122        Type *matching_type = ResolveTypeUID (die_offsets[i]);
4123        if (matching_type)
4124        {
4125            // We found a type pointer, now find the shared pointer form our type list
4126            types.InsertUnique (matching_type->shared_from_this());
4127            ++num_matches;
4128            if (num_matches >= max_matches)
4129                break;
4130        }
4131    }
4132
4133    // Return the number of variable that were appended to the list
4134    return types.GetSize() - original_size;
4135}
4136
4137
4138size_t
4139SymbolFileDWARF::ParseChildParameters (const SymbolContext& sc,
4140                                       clang::DeclContext *containing_decl_ctx,
4141                                       DWARFCompileUnit* dwarf_cu,
4142                                       const DWARFDebugInfoEntry *parent_die,
4143                                       bool skip_artificial,
4144                                       bool &is_static,
4145                                       TypeList* type_list,
4146                                       std::vector<ClangASTType>& function_param_types,
4147                                       std::vector<clang::ParmVarDecl*>& function_param_decls,
4148                                       unsigned &type_quals,
4149                                       ClangASTContext::TemplateParameterInfos &template_param_infos)
4150{
4151    if (parent_die == NULL)
4152        return 0;
4153
4154    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize());
4155
4156    size_t arg_idx = 0;
4157    const DWARFDebugInfoEntry *die;
4158    for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling())
4159    {
4160        dw_tag_t tag = die->Tag();
4161        switch (tag)
4162        {
4163        case DW_TAG_formal_parameter:
4164            {
4165                DWARFDebugInfoEntry::Attributes attributes;
4166                const size_t num_attributes = die->GetAttributes(this, dwarf_cu, fixed_form_sizes, attributes);
4167                if (num_attributes > 0)
4168                {
4169                    const char *name = NULL;
4170                    Declaration decl;
4171                    dw_offset_t param_type_die_offset = DW_INVALID_OFFSET;
4172                    bool is_artificial = false;
4173                    // one of None, Auto, Register, Extern, Static, PrivateExtern
4174
4175                    clang::StorageClass storage = clang::SC_None;
4176                    uint32_t i;
4177                    for (i=0; i<num_attributes; ++i)
4178                    {
4179                        const dw_attr_t attr = attributes.AttributeAtIndex(i);
4180                        DWARFFormValue form_value;
4181                        if (attributes.ExtractFormValueAtIndex(this, i, form_value))
4182                        {
4183                            switch (attr)
4184                            {
4185                            case DW_AT_decl_file:   decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
4186                            case DW_AT_decl_line:   decl.SetLine(form_value.Unsigned()); break;
4187                            case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
4188                            case DW_AT_name:        name = form_value.AsCString(&get_debug_str_data()); break;
4189                            case DW_AT_type:        param_type_die_offset = form_value.Reference(dwarf_cu); break;
4190                            case DW_AT_artificial:  is_artificial = form_value.Boolean(); break;
4191                            case DW_AT_location:
4192    //                          if (form_value.BlockData())
4193    //                          {
4194    //                              const DataExtractor& debug_info_data = debug_info();
4195    //                              uint32_t block_length = form_value.Unsigned();
4196    //                              DataExtractor location(debug_info_data, form_value.BlockData() - debug_info_data.GetDataStart(), block_length);
4197    //                          }
4198    //                          else
4199    //                          {
4200    //                          }
4201    //                          break;
4202                            case DW_AT_const_value:
4203                            case DW_AT_default_value:
4204                            case DW_AT_description:
4205                            case DW_AT_endianity:
4206                            case DW_AT_is_optional:
4207                            case DW_AT_segment:
4208                            case DW_AT_variable_parameter:
4209                            default:
4210                            case DW_AT_abstract_origin:
4211                            case DW_AT_sibling:
4212                                break;
4213                            }
4214                        }
4215                    }
4216
4217                    bool skip = false;
4218                    if (skip_artificial)
4219                    {
4220                        if (is_artificial)
4221                        {
4222                            // In order to determine if a C++ member function is
4223                            // "const" we have to look at the const-ness of "this"...
4224                            // Ugly, but that
4225                            if (arg_idx == 0)
4226                            {
4227                                if (DeclKindIsCXXClass(containing_decl_ctx->getDeclKind()))
4228                                {
4229                                    // Often times compilers omit the "this" name for the
4230                                    // specification DIEs, so we can't rely upon the name
4231                                    // being in the formal parameter DIE...
4232                                    if (name == NULL || ::strcmp(name, "this")==0)
4233                                    {
4234                                        Type *this_type = ResolveTypeUID (param_type_die_offset);
4235                                        if (this_type)
4236                                        {
4237                                            uint32_t encoding_mask = this_type->GetEncodingMask();
4238                                            if (encoding_mask & Type::eEncodingIsPointerUID)
4239                                            {
4240                                                is_static = false;
4241
4242                                                if (encoding_mask & (1u << Type::eEncodingIsConstUID))
4243                                                    type_quals |= clang::Qualifiers::Const;
4244                                                if (encoding_mask & (1u << Type::eEncodingIsVolatileUID))
4245                                                    type_quals |= clang::Qualifiers::Volatile;
4246                                            }
4247                                        }
4248                                    }
4249                                }
4250                            }
4251                            skip = true;
4252                        }
4253                        else
4254                        {
4255
4256                            // HACK: Objective C formal parameters "self" and "_cmd"
4257                            // are not marked as artificial in the DWARF...
4258                            CompileUnit *comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, UINT32_MAX);
4259                            if (comp_unit)
4260                            {
4261                                switch (comp_unit->GetLanguage())
4262                                {
4263                                    case eLanguageTypeObjC:
4264                                    case eLanguageTypeObjC_plus_plus:
4265                                        if (name && name[0] && (strcmp (name, "self") == 0 || strcmp (name, "_cmd") == 0))
4266                                            skip = true;
4267                                        break;
4268                                    default:
4269                                        break;
4270                                }
4271                            }
4272                        }
4273                    }
4274
4275                    if (!skip)
4276                    {
4277                        Type *type = ResolveTypeUID(param_type_die_offset);
4278                        if (type)
4279                        {
4280                            function_param_types.push_back (type->GetClangForwardType());
4281
4282                            clang::ParmVarDecl *param_var_decl = GetClangASTContext().CreateParameterDeclaration (name,
4283                                                                                                                  type->GetClangForwardType(),
4284                                                                                                                  storage);
4285                            assert(param_var_decl);
4286                            function_param_decls.push_back(param_var_decl);
4287
4288                            GetClangASTContext().SetMetadataAsUserID (param_var_decl, MakeUserID(die->GetOffset()));
4289                        }
4290                    }
4291                }
4292                arg_idx++;
4293            }
4294            break;
4295
4296        case DW_TAG_template_type_parameter:
4297        case DW_TAG_template_value_parameter:
4298            ParseTemplateDIE (dwarf_cu, die,template_param_infos);
4299            break;
4300
4301        default:
4302            break;
4303        }
4304    }
4305    return arg_idx;
4306}
4307
4308size_t
4309SymbolFileDWARF::ParseChildEnumerators
4310(
4311    const SymbolContext& sc,
4312    lldb_private::ClangASTType &clang_type,
4313    bool is_signed,
4314    uint32_t enumerator_byte_size,
4315    DWARFCompileUnit* dwarf_cu,
4316    const DWARFDebugInfoEntry *parent_die
4317)
4318{
4319    if (parent_die == NULL)
4320        return 0;
4321
4322    size_t enumerators_added = 0;
4323    const DWARFDebugInfoEntry *die;
4324    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize());
4325
4326    for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling())
4327    {
4328        const dw_tag_t tag = die->Tag();
4329        if (tag == DW_TAG_enumerator)
4330        {
4331            DWARFDebugInfoEntry::Attributes attributes;
4332            const size_t num_child_attributes = die->GetAttributes(this, dwarf_cu, fixed_form_sizes, attributes);
4333            if (num_child_attributes > 0)
4334            {
4335                const char *name = NULL;
4336                bool got_value = false;
4337                int64_t enum_value = 0;
4338                Declaration decl;
4339
4340                uint32_t i;
4341                for (i=0; i<num_child_attributes; ++i)
4342                {
4343                    const dw_attr_t attr = attributes.AttributeAtIndex(i);
4344                    DWARFFormValue form_value;
4345                    if (attributes.ExtractFormValueAtIndex(this, i, form_value))
4346                    {
4347                        switch (attr)
4348                        {
4349                        case DW_AT_const_value:
4350                            got_value = true;
4351                            if (is_signed)
4352                                enum_value = form_value.Signed();
4353                            else
4354                                enum_value = form_value.Unsigned();
4355                            break;
4356
4357                        case DW_AT_name:
4358                            name = form_value.AsCString(&get_debug_str_data());
4359                            break;
4360
4361                        case DW_AT_description:
4362                        default:
4363                        case DW_AT_decl_file:   decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
4364                        case DW_AT_decl_line:   decl.SetLine(form_value.Unsigned()); break;
4365                        case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
4366                        case DW_AT_sibling:
4367                            break;
4368                        }
4369                    }
4370                }
4371
4372                if (name && name[0] && got_value)
4373                {
4374                    clang_type.AddEnumerationValueToEnumerationType (clang_type.GetEnumerationIntegerType(),
4375                                                                     decl,
4376                                                                     name,
4377                                                                     enum_value,
4378                                                                     enumerator_byte_size * 8);
4379                    ++enumerators_added;
4380                }
4381            }
4382        }
4383    }
4384    return enumerators_added;
4385}
4386
4387void
4388SymbolFileDWARF::ParseChildArrayInfo
4389(
4390    const SymbolContext& sc,
4391    DWARFCompileUnit* dwarf_cu,
4392    const DWARFDebugInfoEntry *parent_die,
4393    int64_t& first_index,
4394    std::vector<uint64_t>& element_orders,
4395    uint32_t& byte_stride,
4396    uint32_t& bit_stride
4397)
4398{
4399    if (parent_die == NULL)
4400        return;
4401
4402    const DWARFDebugInfoEntry *die;
4403    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize());
4404    for (die = parent_die->GetFirstChild(); die != NULL; die = die->GetSibling())
4405    {
4406        const dw_tag_t tag = die->Tag();
4407        switch (tag)
4408        {
4409        case DW_TAG_subrange_type:
4410            {
4411                DWARFDebugInfoEntry::Attributes attributes;
4412                const size_t num_child_attributes = die->GetAttributes(this, dwarf_cu, fixed_form_sizes, attributes);
4413                if (num_child_attributes > 0)
4414                {
4415                    uint64_t num_elements = 0;
4416                    uint64_t lower_bound = 0;
4417                    uint64_t upper_bound = 0;
4418                    bool upper_bound_valid = false;
4419                    uint32_t i;
4420                    for (i=0; i<num_child_attributes; ++i)
4421                    {
4422                        const dw_attr_t attr = attributes.AttributeAtIndex(i);
4423                        DWARFFormValue form_value;
4424                        if (attributes.ExtractFormValueAtIndex(this, i, form_value))
4425                        {
4426                            switch (attr)
4427                            {
4428                            case DW_AT_name:
4429                                break;
4430
4431                            case DW_AT_count:
4432                                num_elements = form_value.Unsigned();
4433                                break;
4434
4435                            case DW_AT_bit_stride:
4436                                bit_stride = form_value.Unsigned();
4437                                break;
4438
4439                            case DW_AT_byte_stride:
4440                                byte_stride = form_value.Unsigned();
4441                                break;
4442
4443                            case DW_AT_lower_bound:
4444                                lower_bound = form_value.Unsigned();
4445                                break;
4446
4447                            case DW_AT_upper_bound:
4448                                upper_bound_valid = true;
4449                                upper_bound = form_value.Unsigned();
4450                                break;
4451
4452                            default:
4453                            case DW_AT_abstract_origin:
4454                            case DW_AT_accessibility:
4455                            case DW_AT_allocated:
4456                            case DW_AT_associated:
4457                            case DW_AT_data_location:
4458                            case DW_AT_declaration:
4459                            case DW_AT_description:
4460                            case DW_AT_sibling:
4461                            case DW_AT_threads_scaled:
4462                            case DW_AT_type:
4463                            case DW_AT_visibility:
4464                                break;
4465                            }
4466                        }
4467                    }
4468
4469                    if (num_elements == 0)
4470                    {
4471                        if (upper_bound_valid && upper_bound >= lower_bound)
4472                            num_elements = upper_bound - lower_bound + 1;
4473                    }
4474
4475                    element_orders.push_back (num_elements);
4476                }
4477            }
4478            break;
4479        }
4480    }
4481}
4482
4483TypeSP
4484SymbolFileDWARF::GetTypeForDIE (DWARFCompileUnit *dwarf_cu, const DWARFDebugInfoEntry* die)
4485{
4486    TypeSP type_sp;
4487    if (die != NULL)
4488    {
4489        assert(dwarf_cu != NULL);
4490        Type *type_ptr = m_die_to_type.lookup (die);
4491        if (type_ptr == NULL)
4492        {
4493            CompileUnit* lldb_cu = GetCompUnitForDWARFCompUnit(dwarf_cu);
4494            assert (lldb_cu);
4495            SymbolContext sc(lldb_cu);
4496            type_sp = ParseType(sc, dwarf_cu, die, NULL);
4497        }
4498        else if (type_ptr != DIE_IS_BEING_PARSED)
4499        {
4500            // Grab the existing type from the master types lists
4501            type_sp = type_ptr->shared_from_this();
4502        }
4503
4504    }
4505    return type_sp;
4506}
4507
4508clang::DeclContext *
4509SymbolFileDWARF::GetClangDeclContextContainingDIEOffset (dw_offset_t die_offset)
4510{
4511    if (die_offset != DW_INVALID_OFFSET)
4512    {
4513        DWARFCompileUnitSP cu_sp;
4514        const DWARFDebugInfoEntry* die = DebugInfo()->GetDIEPtr(die_offset, &cu_sp);
4515        return GetClangDeclContextContainingDIE (cu_sp.get(), die, NULL);
4516    }
4517    return NULL;
4518}
4519
4520clang::DeclContext *
4521SymbolFileDWARF::GetClangDeclContextForDIEOffset (const SymbolContext &sc, dw_offset_t die_offset)
4522{
4523    if (die_offset != DW_INVALID_OFFSET)
4524    {
4525        DWARFDebugInfo* debug_info = DebugInfo();
4526        if (debug_info)
4527        {
4528            DWARFCompileUnitSP cu_sp;
4529            const DWARFDebugInfoEntry* die = debug_info->GetDIEPtr(die_offset, &cu_sp);
4530            if (die)
4531                return GetClangDeclContextForDIE (sc, cu_sp.get(), die);
4532        }
4533    }
4534    return NULL;
4535}
4536
4537clang::NamespaceDecl *
4538SymbolFileDWARF::ResolveNamespaceDIE (DWARFCompileUnit *dwarf_cu, const DWARFDebugInfoEntry *die)
4539{
4540    if (die && die->Tag() == DW_TAG_namespace)
4541    {
4542        // See if we already parsed this namespace DIE and associated it with a
4543        // uniqued namespace declaration
4544        clang::NamespaceDecl *namespace_decl = static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die]);
4545        if (namespace_decl)
4546            return namespace_decl;
4547        else
4548        {
4549            const char *namespace_name = die->GetAttributeValueAsString(this, dwarf_cu, DW_AT_name, NULL);
4550            clang::DeclContext *containing_decl_ctx = GetClangDeclContextContainingDIE (dwarf_cu, die, NULL);
4551            namespace_decl = GetClangASTContext().GetUniqueNamespaceDeclaration (namespace_name, containing_decl_ctx);
4552            Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
4553            if (log)
4554            {
4555                if (namespace_name)
4556                {
4557                    GetObjectFile()->GetModule()->LogMessage (log,
4558                                                              "ASTContext => %p: 0x%8.8" PRIx64 ": DW_TAG_namespace with DW_AT_name(\"%s\") => clang::NamespaceDecl *%p (original = %p)",
4559                                                              GetClangASTContext().getASTContext(),
4560                                                              MakeUserID(die->GetOffset()),
4561                                                              namespace_name,
4562                                                              namespace_decl,
4563                                                              namespace_decl->getOriginalNamespace());
4564                }
4565                else
4566                {
4567                    GetObjectFile()->GetModule()->LogMessage (log,
4568                                                              "ASTContext => %p: 0x%8.8" PRIx64 ": DW_TAG_namespace (anonymous) => clang::NamespaceDecl *%p (original = %p)",
4569                                                              GetClangASTContext().getASTContext(),
4570                                                              MakeUserID(die->GetOffset()),
4571                                                              namespace_decl,
4572                                                              namespace_decl->getOriginalNamespace());
4573                }
4574            }
4575
4576            if (namespace_decl)
4577                LinkDeclContextToDIE((clang::DeclContext*)namespace_decl, die);
4578            return namespace_decl;
4579        }
4580    }
4581    return NULL;
4582}
4583
4584clang::DeclContext *
4585SymbolFileDWARF::GetClangDeclContextForDIE (const SymbolContext &sc, DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die)
4586{
4587    clang::DeclContext *clang_decl_ctx = GetCachedClangDeclContextForDIE (die);
4588    if (clang_decl_ctx)
4589        return clang_decl_ctx;
4590    // If this DIE has a specification, or an abstract origin, then trace to those.
4591
4592    dw_offset_t die_offset = die->GetAttributeValueAsReference(this, cu, DW_AT_specification, DW_INVALID_OFFSET);
4593    if (die_offset != DW_INVALID_OFFSET)
4594        return GetClangDeclContextForDIEOffset (sc, die_offset);
4595
4596    die_offset = die->GetAttributeValueAsReference(this, cu, DW_AT_abstract_origin, DW_INVALID_OFFSET);
4597    if (die_offset != DW_INVALID_OFFSET)
4598        return GetClangDeclContextForDIEOffset (sc, die_offset);
4599
4600    Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
4601    if (log)
4602        GetObjectFile()->GetModule()->LogMessage(log, "SymbolFileDWARF::GetClangDeclContextForDIE (die = 0x%8.8x) %s '%s'", die->GetOffset(), DW_TAG_value_to_name(die->Tag()), die->GetName(this, cu));
4603    // This is the DIE we want.  Parse it, then query our map.
4604    bool assert_not_being_parsed = true;
4605    ResolveTypeUID (cu, die, assert_not_being_parsed);
4606
4607    clang_decl_ctx = GetCachedClangDeclContextForDIE (die);
4608
4609    return clang_decl_ctx;
4610}
4611
4612clang::DeclContext *
4613SymbolFileDWARF::GetClangDeclContextContainingDIE (DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die, const DWARFDebugInfoEntry **decl_ctx_die_copy)
4614{
4615    if (m_clang_tu_decl == NULL)
4616        m_clang_tu_decl = GetClangASTContext().getASTContext()->getTranslationUnitDecl();
4617
4618    const DWARFDebugInfoEntry *decl_ctx_die = GetDeclContextDIEContainingDIE (cu, die);
4619
4620    if (decl_ctx_die_copy)
4621        *decl_ctx_die_copy = decl_ctx_die;
4622
4623    if (decl_ctx_die)
4624    {
4625
4626        DIEToDeclContextMap::iterator pos = m_die_to_decl_ctx.find (decl_ctx_die);
4627        if (pos != m_die_to_decl_ctx.end())
4628            return pos->second;
4629
4630        switch (decl_ctx_die->Tag())
4631        {
4632        case DW_TAG_compile_unit:
4633            return m_clang_tu_decl;
4634
4635        case DW_TAG_namespace:
4636            return ResolveNamespaceDIE (cu, decl_ctx_die);
4637            break;
4638
4639        case DW_TAG_structure_type:
4640        case DW_TAG_union_type:
4641        case DW_TAG_class_type:
4642            {
4643                Type* type = ResolveType (cu, decl_ctx_die);
4644                if (type)
4645                {
4646                    clang::DeclContext *decl_ctx = type->GetClangForwardType().GetDeclContextForType ();
4647                    if (decl_ctx)
4648                    {
4649                        LinkDeclContextToDIE (decl_ctx, decl_ctx_die);
4650                        if (decl_ctx)
4651                            return decl_ctx;
4652                    }
4653                }
4654            }
4655            break;
4656
4657        default:
4658            break;
4659        }
4660    }
4661    return m_clang_tu_decl;
4662}
4663
4664
4665const DWARFDebugInfoEntry *
4666SymbolFileDWARF::GetDeclContextDIEContainingDIE (DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die)
4667{
4668    if (cu && die)
4669    {
4670        const DWARFDebugInfoEntry * const decl_die = die;
4671
4672        while (die != NULL)
4673        {
4674            // If this is the original DIE that we are searching for a declaration
4675            // for, then don't look in the cache as we don't want our own decl
4676            // context to be our decl context...
4677            if (decl_die != die)
4678            {
4679                switch (die->Tag())
4680                {
4681                    case DW_TAG_compile_unit:
4682                    case DW_TAG_namespace:
4683                    case DW_TAG_structure_type:
4684                    case DW_TAG_union_type:
4685                    case DW_TAG_class_type:
4686                        return die;
4687
4688                    default:
4689                        break;
4690                }
4691            }
4692
4693            dw_offset_t die_offset = die->GetAttributeValueAsReference(this, cu, DW_AT_specification, DW_INVALID_OFFSET);
4694            if (die_offset != DW_INVALID_OFFSET)
4695            {
4696                DWARFCompileUnit *spec_cu = cu;
4697                const DWARFDebugInfoEntry *spec_die = DebugInfo()->GetDIEPtrWithCompileUnitHint (die_offset, &spec_cu);
4698                const DWARFDebugInfoEntry *spec_die_decl_ctx_die = GetDeclContextDIEContainingDIE (spec_cu, spec_die);
4699                if (spec_die_decl_ctx_die)
4700                    return spec_die_decl_ctx_die;
4701            }
4702
4703            die_offset = die->GetAttributeValueAsReference(this, cu, DW_AT_abstract_origin, DW_INVALID_OFFSET);
4704            if (die_offset != DW_INVALID_OFFSET)
4705            {
4706                DWARFCompileUnit *abs_cu = cu;
4707                const DWARFDebugInfoEntry *abs_die = DebugInfo()->GetDIEPtrWithCompileUnitHint (die_offset, &abs_cu);
4708                const DWARFDebugInfoEntry *abs_die_decl_ctx_die = GetDeclContextDIEContainingDIE (abs_cu, abs_die);
4709                if (abs_die_decl_ctx_die)
4710                    return abs_die_decl_ctx_die;
4711            }
4712
4713            die = die->GetParent();
4714        }
4715    }
4716    return NULL;
4717}
4718
4719
4720Symbol *
4721SymbolFileDWARF::GetObjCClassSymbol (const ConstString &objc_class_name)
4722{
4723    Symbol *objc_class_symbol = NULL;
4724    if (m_obj_file)
4725    {
4726        Symtab *symtab = m_obj_file->GetSymtab ();
4727        if (symtab)
4728        {
4729            objc_class_symbol = symtab->FindFirstSymbolWithNameAndType (objc_class_name,
4730                                                                        eSymbolTypeObjCClass,
4731                                                                        Symtab::eDebugNo,
4732                                                                        Symtab::eVisibilityAny);
4733        }
4734    }
4735    return objc_class_symbol;
4736}
4737
4738// Some compilers don't emit the DW_AT_APPLE_objc_complete_type attribute. If they don't
4739// then we can end up looking through all class types for a complete type and never find
4740// the full definition. We need to know if this attribute is supported, so we determine
4741// this here and cache th result. We also need to worry about the debug map DWARF file
4742// if we are doing darwin DWARF in .o file debugging.
4743bool
4744SymbolFileDWARF::Supports_DW_AT_APPLE_objc_complete_type (DWARFCompileUnit *cu)
4745{
4746    if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate)
4747    {
4748        m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolNo;
4749        if (cu && cu->Supports_DW_AT_APPLE_objc_complete_type())
4750            m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
4751        else
4752        {
4753            DWARFDebugInfo* debug_info = DebugInfo();
4754            const uint32_t num_compile_units = GetNumCompileUnits();
4755            for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
4756            {
4757                DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
4758                if (dwarf_cu != cu && dwarf_cu->Supports_DW_AT_APPLE_objc_complete_type())
4759                {
4760                    m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
4761                    break;
4762                }
4763            }
4764        }
4765        if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolNo && GetDebugMapSymfile ())
4766            return m_debug_map_symfile->Supports_DW_AT_APPLE_objc_complete_type (this);
4767    }
4768    return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes;
4769}
4770
4771// This function can be used when a DIE is found that is a forward declaration
4772// DIE and we want to try and find a type that has the complete definition.
4773TypeSP
4774SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE (const DWARFDebugInfoEntry *die,
4775                                                       const ConstString &type_name,
4776                                                       bool must_be_implementation)
4777{
4778
4779    TypeSP type_sp;
4780
4781    if (!type_name || (must_be_implementation && !GetObjCClassSymbol (type_name)))
4782        return type_sp;
4783
4784    DIEArray die_offsets;
4785
4786    if (m_using_apple_tables)
4787    {
4788        if (m_apple_types_ap.get())
4789        {
4790            const char *name_cstr = type_name.GetCString();
4791            m_apple_types_ap->FindCompleteObjCClassByName (name_cstr, die_offsets, must_be_implementation);
4792        }
4793    }
4794    else
4795    {
4796        if (!m_indexed)
4797            Index ();
4798
4799        m_type_index.Find (type_name, die_offsets);
4800    }
4801
4802    const size_t num_matches = die_offsets.size();
4803
4804    DWARFCompileUnit* type_cu = NULL;
4805    const DWARFDebugInfoEntry* type_die = NULL;
4806    if (num_matches)
4807    {
4808        DWARFDebugInfo* debug_info = DebugInfo();
4809        for (size_t i=0; i<num_matches; ++i)
4810        {
4811            const dw_offset_t die_offset = die_offsets[i];
4812            type_die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &type_cu);
4813
4814            if (type_die)
4815            {
4816                bool try_resolving_type = false;
4817
4818                // Don't try and resolve the DIE we are looking for with the DIE itself!
4819                if (type_die != die)
4820                {
4821                    switch (type_die->Tag())
4822                    {
4823                        case DW_TAG_class_type:
4824                        case DW_TAG_structure_type:
4825                            try_resolving_type = true;
4826                            break;
4827                        default:
4828                            break;
4829                    }
4830                }
4831
4832                if (try_resolving_type)
4833                {
4834					if (must_be_implementation && type_cu->Supports_DW_AT_APPLE_objc_complete_type())
4835	                    try_resolving_type = type_die->GetAttributeValueAsUnsigned (this, type_cu, DW_AT_APPLE_objc_complete_type, 0);
4836
4837                    if (try_resolving_type)
4838                    {
4839                        Type *resolved_type = ResolveType (type_cu, type_die, false);
4840                        if (resolved_type && resolved_type != DIE_IS_BEING_PARSED)
4841                        {
4842                            DEBUG_PRINTF ("resolved 0x%8.8" PRIx64 " (cu 0x%8.8" PRIx64 ") from %s to 0x%8.8" PRIx64 " (cu 0x%8.8" PRIx64 ")\n",
4843                                          MakeUserID(die->GetOffset()),
4844                                          MakeUserID(dwarf_cu->GetOffset()),
4845                                          m_obj_file->GetFileSpec().GetFilename().AsCString(),
4846                                          MakeUserID(type_die->GetOffset()),
4847                                          MakeUserID(type_cu->GetOffset()));
4848
4849                            if (die)
4850                                m_die_to_type[die] = resolved_type;
4851                            type_sp = resolved_type->shared_from_this();
4852                            break;
4853                        }
4854                    }
4855                }
4856            }
4857            else
4858            {
4859                if (m_using_apple_tables)
4860                {
4861                    GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n",
4862                                                               die_offset, type_name.GetCString());
4863                }
4864            }
4865
4866        }
4867    }
4868    return type_sp;
4869}
4870
4871
4872//----------------------------------------------------------------------
4873// This function helps to ensure that the declaration contexts match for
4874// two different DIEs. Often times debug information will refer to a
4875// forward declaration of a type (the equivalent of "struct my_struct;".
4876// There will often be a declaration of that type elsewhere that has the
4877// full definition. When we go looking for the full type "my_struct", we
4878// will find one or more matches in the accelerator tables and we will
4879// then need to make sure the type was in the same declaration context
4880// as the original DIE. This function can efficiently compare two DIEs
4881// and will return true when the declaration context matches, and false
4882// when they don't.
4883//----------------------------------------------------------------------
4884bool
4885SymbolFileDWARF::DIEDeclContextsMatch (DWARFCompileUnit* cu1, const DWARFDebugInfoEntry *die1,
4886                                       DWARFCompileUnit* cu2, const DWARFDebugInfoEntry *die2)
4887{
4888    if (die1 == die2)
4889        return true;
4890
4891#if defined (LLDB_CONFIGURATION_DEBUG)
4892    // You can't and shouldn't call this function with a compile unit from
4893    // two different SymbolFileDWARF instances.
4894    assert (DebugInfo()->ContainsCompileUnit (cu1));
4895    assert (DebugInfo()->ContainsCompileUnit (cu2));
4896#endif
4897
4898    DWARFDIECollection decl_ctx_1;
4899    DWARFDIECollection decl_ctx_2;
4900    //The declaration DIE stack is a stack of the declaration context
4901    // DIEs all the way back to the compile unit. If a type "T" is
4902    // declared inside a class "B", and class "B" is declared inside
4903    // a class "A" and class "A" is in a namespace "lldb", and the
4904    // namespace is in a compile unit, there will be a stack of DIEs:
4905    //
4906    //   [0] DW_TAG_class_type for "B"
4907    //   [1] DW_TAG_class_type for "A"
4908    //   [2] DW_TAG_namespace  for "lldb"
4909    //   [3] DW_TAG_compile_unit for the source file.
4910    //
4911    // We grab both contexts and make sure that everything matches
4912    // all the way back to the compiler unit.
4913
4914    // First lets grab the decl contexts for both DIEs
4915    die1->GetDeclContextDIEs (this, cu1, decl_ctx_1);
4916    die2->GetDeclContextDIEs (this, cu2, decl_ctx_2);
4917    // Make sure the context arrays have the same size, otherwise
4918    // we are done
4919    const size_t count1 = decl_ctx_1.Size();
4920    const size_t count2 = decl_ctx_2.Size();
4921    if (count1 != count2)
4922        return false;
4923
4924    // Make sure the DW_TAG values match all the way back up the the
4925    // compile unit. If they don't, then we are done.
4926    const DWARFDebugInfoEntry *decl_ctx_die1;
4927    const DWARFDebugInfoEntry *decl_ctx_die2;
4928    size_t i;
4929    for (i=0; i<count1; i++)
4930    {
4931        decl_ctx_die1 = decl_ctx_1.GetDIEPtrAtIndex (i);
4932        decl_ctx_die2 = decl_ctx_2.GetDIEPtrAtIndex (i);
4933        if (decl_ctx_die1->Tag() != decl_ctx_die2->Tag())
4934            return false;
4935    }
4936#if defined LLDB_CONFIGURATION_DEBUG
4937
4938    // Make sure the top item in the decl context die array is always
4939    // DW_TAG_compile_unit. If it isn't then something went wrong in
4940    // the DWARFDebugInfoEntry::GetDeclContextDIEs() function...
4941    assert (decl_ctx_1.GetDIEPtrAtIndex (count1 - 1)->Tag() == DW_TAG_compile_unit);
4942
4943#endif
4944    // Always skip the compile unit when comparing by only iterating up to
4945    // "count - 1". Here we compare the names as we go.
4946    for (i=0; i<count1 - 1; i++)
4947    {
4948        decl_ctx_die1 = decl_ctx_1.GetDIEPtrAtIndex (i);
4949        decl_ctx_die2 = decl_ctx_2.GetDIEPtrAtIndex (i);
4950        const char *name1 = decl_ctx_die1->GetName(this, cu1);
4951        const char *name2 = decl_ctx_die2->GetName(this, cu2);
4952        // If the string was from a DW_FORM_strp, then the pointer will often
4953        // be the same!
4954        if (name1 == name2)
4955            continue;
4956
4957        // Name pointers are not equal, so only compare the strings
4958        // if both are not NULL.
4959        if (name1 && name2)
4960        {
4961            // If the strings don't compare, we are done...
4962            if (strcmp(name1, name2) != 0)
4963                return false;
4964        }
4965        else
4966        {
4967            // One name was NULL while the other wasn't
4968            return false;
4969        }
4970    }
4971    // We made it through all of the checks and the declaration contexts
4972    // are equal.
4973    return true;
4974}
4975
4976// This function can be used when a DIE is found that is a forward declaration
4977// DIE and we want to try and find a type that has the complete definition.
4978// "cu" and "die" must be from this SymbolFileDWARF
4979TypeSP
4980SymbolFileDWARF::FindDefinitionTypeForDIE (DWARFCompileUnit* cu,
4981                                           const DWARFDebugInfoEntry *die,
4982                                           const ConstString &type_name)
4983{
4984    TypeSP type_sp;
4985
4986#if defined (LLDB_CONFIGURATION_DEBUG)
4987    // You can't and shouldn't call this function with a compile unit from
4988    // another SymbolFileDWARF instance.
4989    assert (DebugInfo()->ContainsCompileUnit (cu));
4990#endif
4991
4992    if (cu == NULL || die == NULL || !type_name)
4993        return type_sp;
4994
4995    std::string qualified_name;
4996
4997    Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION|DWARF_LOG_LOOKUPS));
4998    if (log)
4999    {
5000        die->GetQualifiedName(this, cu, qualified_name);
5001        GetObjectFile()->GetModule()->LogMessage (log,
5002                                                  "SymbolFileDWARF::FindDefinitionTypeForDIE(die=0x%8.8x (%s), name='%s')",
5003                                                  die->GetOffset(),
5004                                                  qualified_name.c_str(),
5005                                                  type_name.GetCString());
5006    }
5007
5008    DIEArray die_offsets;
5009
5010    if (m_using_apple_tables)
5011    {
5012        if (m_apple_types_ap.get())
5013        {
5014            const bool has_tag = m_apple_types_ap->GetHeader().header_data.ContainsAtom (DWARFMappedHash::eAtomTypeTag);
5015            const bool has_qualified_name_hash = m_apple_types_ap->GetHeader().header_data.ContainsAtom (DWARFMappedHash::eAtomTypeQualNameHash);
5016            if (has_tag && has_qualified_name_hash)
5017            {
5018                if (qualified_name.empty())
5019                    die->GetQualifiedName(this, cu, qualified_name);
5020
5021                const uint32_t qualified_name_hash = MappedHash::HashStringUsingDJB (qualified_name.c_str());
5022                if (log)
5023                    GetObjectFile()->GetModule()->LogMessage (log,"FindByNameAndTagAndQualifiedNameHash()");
5024                m_apple_types_ap->FindByNameAndTagAndQualifiedNameHash (type_name.GetCString(), die->Tag(), qualified_name_hash, die_offsets);
5025            }
5026            else if (has_tag > 1)
5027            {
5028                if (log)
5029                    GetObjectFile()->GetModule()->LogMessage (log,"FindByNameAndTag()");
5030                m_apple_types_ap->FindByNameAndTag (type_name.GetCString(), die->Tag(), die_offsets);
5031            }
5032            else
5033            {
5034                m_apple_types_ap->FindByName (type_name.GetCString(), die_offsets);
5035            }
5036        }
5037    }
5038    else
5039    {
5040        if (!m_indexed)
5041            Index ();
5042
5043        m_type_index.Find (type_name, die_offsets);
5044    }
5045
5046    const size_t num_matches = die_offsets.size();
5047
5048    const dw_tag_t die_tag = die->Tag();
5049
5050    DWARFCompileUnit* type_cu = NULL;
5051    const DWARFDebugInfoEntry* type_die = NULL;
5052    if (num_matches)
5053    {
5054        DWARFDebugInfo* debug_info = DebugInfo();
5055        for (size_t i=0; i<num_matches; ++i)
5056        {
5057            const dw_offset_t die_offset = die_offsets[i];
5058            type_die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &type_cu);
5059
5060            if (type_die)
5061            {
5062                bool try_resolving_type = false;
5063
5064                // Don't try and resolve the DIE we are looking for with the DIE itself!
5065                if (type_die != die)
5066                {
5067                    const dw_tag_t type_die_tag = type_die->Tag();
5068                    // Make sure the tags match
5069                    if (type_die_tag == die_tag)
5070                    {
5071                        // The tags match, lets try resolving this type
5072                        try_resolving_type = true;
5073                    }
5074                    else
5075                    {
5076                        // The tags don't match, but we need to watch our for a
5077                        // forward declaration for a struct and ("struct foo")
5078                        // ends up being a class ("class foo { ... };") or
5079                        // vice versa.
5080                        switch (type_die_tag)
5081                        {
5082                        case DW_TAG_class_type:
5083                            // We had a "class foo", see if we ended up with a "struct foo { ... };"
5084                            try_resolving_type = (die_tag == DW_TAG_structure_type);
5085                            break;
5086                        case DW_TAG_structure_type:
5087                            // We had a "struct foo", see if we ended up with a "class foo { ... };"
5088                            try_resolving_type = (die_tag == DW_TAG_class_type);
5089                            break;
5090                        default:
5091                            // Tags don't match, don't event try to resolve
5092                            // using this type whose name matches....
5093                            break;
5094                        }
5095                    }
5096                }
5097
5098                if (try_resolving_type)
5099                {
5100                    if (log)
5101                    {
5102                        std::string qualified_name;
5103                        type_die->GetQualifiedName(this, cu, qualified_name);
5104                        GetObjectFile()->GetModule()->LogMessage (log,
5105                                                                  "SymbolFileDWARF::FindDefinitionTypeForDIE(die=0x%8.8x, name='%s') trying die=0x%8.8x (%s)",
5106                                                                  die->GetOffset(),
5107                                                                  type_name.GetCString(),
5108                                                                  type_die->GetOffset(),
5109                                                                  qualified_name.c_str());
5110                    }
5111
5112                    // Make sure the decl contexts match all the way up
5113                    if (DIEDeclContextsMatch(cu, die, type_cu, type_die))
5114                    {
5115                        Type *resolved_type = ResolveType (type_cu, type_die, false);
5116                        if (resolved_type && resolved_type != DIE_IS_BEING_PARSED)
5117                        {
5118                            DEBUG_PRINTF ("resolved 0x%8.8" PRIx64 " (cu 0x%8.8" PRIx64 ") from %s to 0x%8.8" PRIx64 " (cu 0x%8.8" PRIx64 ")\n",
5119                                          MakeUserID(die->GetOffset()),
5120                                          MakeUserID(dwarf_cu->GetOffset()),
5121                                          m_obj_file->GetFileSpec().GetFilename().AsCString(),
5122                                          MakeUserID(type_die->GetOffset()),
5123                                          MakeUserID(type_cu->GetOffset()));
5124
5125                            m_die_to_type[die] = resolved_type;
5126                            type_sp = resolved_type->shared_from_this();
5127                            break;
5128                        }
5129                    }
5130                }
5131                else
5132                {
5133                    if (log)
5134                    {
5135                        std::string qualified_name;
5136                        type_die->GetQualifiedName(this, cu, qualified_name);
5137                        GetObjectFile()->GetModule()->LogMessage (log,
5138                                                                  "SymbolFileDWARF::FindDefinitionTypeForDIE(die=0x%8.8x, name='%s') ignoring die=0x%8.8x (%s)",
5139                                                                  die->GetOffset(),
5140                                                                  type_name.GetCString(),
5141                                                                  type_die->GetOffset(),
5142                                                                  qualified_name.c_str());
5143                    }
5144                }
5145            }
5146            else
5147            {
5148                if (m_using_apple_tables)
5149                {
5150                    GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n",
5151                                                                               die_offset, type_name.GetCString());
5152                }
5153            }
5154
5155        }
5156    }
5157    return type_sp;
5158}
5159
5160TypeSP
5161SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext (const DWARFDeclContext &dwarf_decl_ctx)
5162{
5163    TypeSP type_sp;
5164
5165    const uint32_t dwarf_decl_ctx_count = dwarf_decl_ctx.GetSize();
5166    if (dwarf_decl_ctx_count > 0)
5167    {
5168        const ConstString type_name(dwarf_decl_ctx[0].name);
5169        const dw_tag_t tag = dwarf_decl_ctx[0].tag;
5170
5171        if (type_name)
5172        {
5173            Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION|DWARF_LOG_LOOKUPS));
5174            if (log)
5175            {
5176                GetObjectFile()->GetModule()->LogMessage (log,
5177                                                          "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s')",
5178                                                          DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
5179                                                          dwarf_decl_ctx.GetQualifiedName());
5180            }
5181
5182            DIEArray die_offsets;
5183
5184            if (m_using_apple_tables)
5185            {
5186                if (m_apple_types_ap.get())
5187                {
5188                    const bool has_tag = m_apple_types_ap->GetHeader().header_data.ContainsAtom (DWARFMappedHash::eAtomTypeTag);
5189                    const bool has_qualified_name_hash = m_apple_types_ap->GetHeader().header_data.ContainsAtom (DWARFMappedHash::eAtomTypeQualNameHash);
5190                    if (has_tag && has_qualified_name_hash)
5191                    {
5192                        const char *qualified_name = dwarf_decl_ctx.GetQualifiedName();
5193                        const uint32_t qualified_name_hash = MappedHash::HashStringUsingDJB (qualified_name);
5194                        if (log)
5195                            GetObjectFile()->GetModule()->LogMessage (log,"FindByNameAndTagAndQualifiedNameHash()");
5196                        m_apple_types_ap->FindByNameAndTagAndQualifiedNameHash (type_name.GetCString(), tag, qualified_name_hash, die_offsets);
5197                    }
5198                    else if (has_tag)
5199                    {
5200                        if (log)
5201                            GetObjectFile()->GetModule()->LogMessage (log,"FindByNameAndTag()");
5202                        m_apple_types_ap->FindByNameAndTag (type_name.GetCString(), tag, die_offsets);
5203                    }
5204                    else
5205                    {
5206                        m_apple_types_ap->FindByName (type_name.GetCString(), die_offsets);
5207                    }
5208                }
5209            }
5210            else
5211            {
5212                if (!m_indexed)
5213                    Index ();
5214
5215                m_type_index.Find (type_name, die_offsets);
5216            }
5217
5218            const size_t num_matches = die_offsets.size();
5219
5220
5221            DWARFCompileUnit* type_cu = NULL;
5222            const DWARFDebugInfoEntry* type_die = NULL;
5223            if (num_matches)
5224            {
5225                DWARFDebugInfo* debug_info = DebugInfo();
5226                for (size_t i=0; i<num_matches; ++i)
5227                {
5228                    const dw_offset_t die_offset = die_offsets[i];
5229                    type_die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &type_cu);
5230
5231                    if (type_die)
5232                    {
5233                        bool try_resolving_type = false;
5234
5235                        // Don't try and resolve the DIE we are looking for with the DIE itself!
5236                        const dw_tag_t type_tag = type_die->Tag();
5237                        // Make sure the tags match
5238                        if (type_tag == tag)
5239                        {
5240                            // The tags match, lets try resolving this type
5241                            try_resolving_type = true;
5242                        }
5243                        else
5244                        {
5245                            // The tags don't match, but we need to watch our for a
5246                            // forward declaration for a struct and ("struct foo")
5247                            // ends up being a class ("class foo { ... };") or
5248                            // vice versa.
5249                            switch (type_tag)
5250                            {
5251                                case DW_TAG_class_type:
5252                                    // We had a "class foo", see if we ended up with a "struct foo { ... };"
5253                                    try_resolving_type = (tag == DW_TAG_structure_type);
5254                                    break;
5255                                case DW_TAG_structure_type:
5256                                    // We had a "struct foo", see if we ended up with a "class foo { ... };"
5257                                    try_resolving_type = (tag == DW_TAG_class_type);
5258                                    break;
5259                                default:
5260                                    // Tags don't match, don't event try to resolve
5261                                    // using this type whose name matches....
5262                                    break;
5263                            }
5264                        }
5265
5266                        if (try_resolving_type)
5267                        {
5268                            DWARFDeclContext type_dwarf_decl_ctx;
5269                            type_die->GetDWARFDeclContext (this, type_cu, type_dwarf_decl_ctx);
5270
5271                            if (log)
5272                            {
5273                                GetObjectFile()->GetModule()->LogMessage (log,
5274                                                                          "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s') trying die=0x%8.8x (%s)",
5275                                                                          DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
5276                                                                          dwarf_decl_ctx.GetQualifiedName(),
5277                                                                          type_die->GetOffset(),
5278                                                                          type_dwarf_decl_ctx.GetQualifiedName());
5279                            }
5280
5281                            // Make sure the decl contexts match all the way up
5282                            if (dwarf_decl_ctx == type_dwarf_decl_ctx)
5283                            {
5284                                Type *resolved_type = ResolveType (type_cu, type_die, false);
5285                                if (resolved_type && resolved_type != DIE_IS_BEING_PARSED)
5286                                {
5287                                    type_sp = resolved_type->shared_from_this();
5288                                    break;
5289                                }
5290                            }
5291                        }
5292                        else
5293                        {
5294                            if (log)
5295                            {
5296                                std::string qualified_name;
5297                                type_die->GetQualifiedName(this, type_cu, qualified_name);
5298                                GetObjectFile()->GetModule()->LogMessage (log,
5299                                                                          "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s') ignoring die=0x%8.8x (%s)",
5300                                                                          DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
5301                                                                          dwarf_decl_ctx.GetQualifiedName(),
5302                                                                          type_die->GetOffset(),
5303                                                                          qualified_name.c_str());
5304                            }
5305                        }
5306                    }
5307                    else
5308                    {
5309                        if (m_using_apple_tables)
5310                        {
5311                            GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n",
5312                                                                                       die_offset, type_name.GetCString());
5313                        }
5314                    }
5315
5316                }
5317            }
5318        }
5319    }
5320    return type_sp;
5321}
5322
5323bool
5324SymbolFileDWARF::CopyUniqueClassMethodTypes (SymbolFileDWARF *src_symfile,
5325                                             Type *class_type,
5326                                             DWARFCompileUnit* src_cu,
5327                                             const DWARFDebugInfoEntry *src_class_die,
5328                                             DWARFCompileUnit* dst_cu,
5329                                             const DWARFDebugInfoEntry *dst_class_die,
5330                                             llvm::SmallVectorImpl <const DWARFDebugInfoEntry *> &failures)
5331{
5332    if (!class_type || !src_cu || !src_class_die || !dst_cu || !dst_class_die)
5333        return false;
5334    if (src_class_die->Tag() != dst_class_die->Tag())
5335        return false;
5336
5337    // We need to complete the class type so we can get all of the method types
5338    // parsed so we can then unique those types to their equivalent counterparts
5339    // in "dst_cu" and "dst_class_die"
5340    class_type->GetClangFullType();
5341
5342    const DWARFDebugInfoEntry *src_die;
5343    const DWARFDebugInfoEntry *dst_die;
5344    UniqueCStringMap<const DWARFDebugInfoEntry *> src_name_to_die;
5345    UniqueCStringMap<const DWARFDebugInfoEntry *> dst_name_to_die;
5346    UniqueCStringMap<const DWARFDebugInfoEntry *> src_name_to_die_artificial;
5347    UniqueCStringMap<const DWARFDebugInfoEntry *> dst_name_to_die_artificial;
5348    for (src_die = src_class_die->GetFirstChild(); src_die != NULL; src_die = src_die->GetSibling())
5349    {
5350        if (src_die->Tag() == DW_TAG_subprogram)
5351        {
5352            // Make sure this is a declaration and not a concrete instance by looking
5353            // for DW_AT_declaration set to 1. Sometimes concrete function instances
5354            // are placed inside the class definitions and shouldn't be included in
5355            // the list of things are are tracking here.
5356            if (src_die->GetAttributeValueAsUnsigned(src_symfile, src_cu, DW_AT_declaration, 0) == 1)
5357            {
5358                const char *src_name = src_die->GetMangledName (src_symfile, src_cu);
5359                if (src_name)
5360                {
5361                    ConstString src_const_name(src_name);
5362                    if (src_die->GetAttributeValueAsUnsigned(src_symfile, src_cu, DW_AT_artificial, 0))
5363                        src_name_to_die_artificial.Append(src_const_name.GetCString(), src_die);
5364                    else
5365                        src_name_to_die.Append(src_const_name.GetCString(), src_die);
5366                }
5367            }
5368        }
5369    }
5370    for (dst_die = dst_class_die->GetFirstChild(); dst_die != NULL; dst_die = dst_die->GetSibling())
5371    {
5372        if (dst_die->Tag() == DW_TAG_subprogram)
5373        {
5374            // Make sure this is a declaration and not a concrete instance by looking
5375            // for DW_AT_declaration set to 1. Sometimes concrete function instances
5376            // are placed inside the class definitions and shouldn't be included in
5377            // the list of things are are tracking here.
5378            if (dst_die->GetAttributeValueAsUnsigned(this, dst_cu, DW_AT_declaration, 0) == 1)
5379            {
5380                const char *dst_name = dst_die->GetMangledName (this, dst_cu);
5381                if (dst_name)
5382                {
5383                    ConstString dst_const_name(dst_name);
5384                    if (dst_die->GetAttributeValueAsUnsigned(this, dst_cu, DW_AT_artificial, 0))
5385                        dst_name_to_die_artificial.Append(dst_const_name.GetCString(), dst_die);
5386                    else
5387                        dst_name_to_die.Append(dst_const_name.GetCString(), dst_die);
5388                }
5389            }
5390        }
5391    }
5392    const uint32_t src_size = src_name_to_die.GetSize ();
5393    const uint32_t dst_size = dst_name_to_die.GetSize ();
5394    Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO | DWARF_LOG_TYPE_COMPLETION));
5395
5396    // Is everything kosher so we can go through the members at top speed?
5397    bool fast_path = true;
5398
5399    if (src_size != dst_size)
5400    {
5401        if (src_size != 0 && dst_size != 0)
5402        {
5403            if (log)
5404                log->Printf("warning: trying to unique class DIE 0x%8.8x to 0x%8.8x, but they didn't have the same size (src=%d, dst=%d)",
5405                            src_class_die->GetOffset(),
5406                            dst_class_die->GetOffset(),
5407                            src_size,
5408                            dst_size);
5409        }
5410
5411        fast_path = false;
5412    }
5413
5414    uint32_t idx;
5415
5416    if (fast_path)
5417    {
5418        for (idx = 0; idx < src_size; ++idx)
5419        {
5420            src_die = src_name_to_die.GetValueAtIndexUnchecked (idx);
5421            dst_die = dst_name_to_die.GetValueAtIndexUnchecked (idx);
5422
5423            if (src_die->Tag() != dst_die->Tag())
5424            {
5425                if (log)
5426                    log->Printf("warning: tried to unique class DIE 0x%8.8x to 0x%8.8x, but 0x%8.8x (%s) tags didn't match 0x%8.8x (%s)",
5427                                src_class_die->GetOffset(),
5428                                dst_class_die->GetOffset(),
5429                                src_die->GetOffset(),
5430                                DW_TAG_value_to_name(src_die->Tag()),
5431                                dst_die->GetOffset(),
5432                                DW_TAG_value_to_name(src_die->Tag()));
5433                fast_path = false;
5434            }
5435
5436            const char *src_name = src_die->GetMangledName (src_symfile, src_cu);
5437            const char *dst_name = dst_die->GetMangledName (this, dst_cu);
5438
5439            // Make sure the names match
5440            if (src_name == dst_name || (strcmp (src_name, dst_name) == 0))
5441                continue;
5442
5443            if (log)
5444                log->Printf("warning: tried to unique class DIE 0x%8.8x to 0x%8.8x, but 0x%8.8x (%s) names didn't match 0x%8.8x (%s)",
5445                            src_class_die->GetOffset(),
5446                            dst_class_die->GetOffset(),
5447                            src_die->GetOffset(),
5448                            src_name,
5449                            dst_die->GetOffset(),
5450                            dst_name);
5451
5452            fast_path = false;
5453        }
5454    }
5455
5456    // Now do the work of linking the DeclContexts and Types.
5457    if (fast_path)
5458    {
5459        // We can do this quickly.  Just run across the tables index-for-index since
5460        // we know each node has matching names and tags.
5461        for (idx = 0; idx < src_size; ++idx)
5462        {
5463            src_die = src_name_to_die.GetValueAtIndexUnchecked (idx);
5464            dst_die = dst_name_to_die.GetValueAtIndexUnchecked (idx);
5465
5466            clang::DeclContext *src_decl_ctx = src_symfile->m_die_to_decl_ctx[src_die];
5467            if (src_decl_ctx)
5468            {
5469                if (log)
5470                    log->Printf ("uniquing decl context %p from 0x%8.8x for 0x%8.8x", src_decl_ctx, src_die->GetOffset(), dst_die->GetOffset());
5471                LinkDeclContextToDIE (src_decl_ctx, dst_die);
5472            }
5473            else
5474            {
5475                if (log)
5476                    log->Printf ("warning: tried to unique decl context from 0x%8.8x for 0x%8.8x, but none was found", src_die->GetOffset(), dst_die->GetOffset());
5477            }
5478
5479            Type *src_child_type = m_die_to_type[src_die];
5480            if (src_child_type)
5481            {
5482                if (log)
5483                    log->Printf ("uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x", src_child_type, src_child_type->GetID(), src_die->GetOffset(), dst_die->GetOffset());
5484                m_die_to_type[dst_die] = src_child_type;
5485            }
5486            else
5487            {
5488                if (log)
5489                    log->Printf ("warning: tried to unique lldb_private::Type from 0x%8.8x for 0x%8.8x, but none was found", src_die->GetOffset(), dst_die->GetOffset());
5490            }
5491        }
5492    }
5493    else
5494    {
5495        // We must do this slowly.  For each member of the destination, look
5496        // up a member in the source with the same name, check its tag, and
5497        // unique them if everything matches up.  Report failures.
5498
5499        if (!src_name_to_die.IsEmpty() && !dst_name_to_die.IsEmpty())
5500        {
5501            src_name_to_die.Sort();
5502
5503            for (idx = 0; idx < dst_size; ++idx)
5504            {
5505                const char *dst_name = dst_name_to_die.GetCStringAtIndex(idx);
5506                dst_die = dst_name_to_die.GetValueAtIndexUnchecked(idx);
5507                src_die = src_name_to_die.Find(dst_name, NULL);
5508
5509                if (src_die && (src_die->Tag() == dst_die->Tag()))
5510                {
5511                    clang::DeclContext *src_decl_ctx = src_symfile->m_die_to_decl_ctx[src_die];
5512                    if (src_decl_ctx)
5513                    {
5514                        if (log)
5515                            log->Printf ("uniquing decl context %p from 0x%8.8x for 0x%8.8x", src_decl_ctx, src_die->GetOffset(), dst_die->GetOffset());
5516                        LinkDeclContextToDIE (src_decl_ctx, dst_die);
5517                    }
5518                    else
5519                    {
5520                        if (log)
5521                            log->Printf ("warning: tried to unique decl context from 0x%8.8x for 0x%8.8x, but none was found", src_die->GetOffset(), dst_die->GetOffset());
5522                    }
5523
5524                    Type *src_child_type = m_die_to_type[src_die];
5525                    if (src_child_type)
5526                    {
5527                        if (log)
5528                            log->Printf ("uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x", src_child_type, src_child_type->GetID(), src_die->GetOffset(), dst_die->GetOffset());
5529                        m_die_to_type[dst_die] = src_child_type;
5530                    }
5531                    else
5532                    {
5533                        if (log)
5534                            log->Printf ("warning: tried to unique lldb_private::Type from 0x%8.8x for 0x%8.8x, but none was found", src_die->GetOffset(), dst_die->GetOffset());
5535                    }
5536                }
5537                else
5538                {
5539                    if (log)
5540                        log->Printf ("warning: couldn't find a match for 0x%8.8x", dst_die->GetOffset());
5541
5542                    failures.push_back(dst_die);
5543                }
5544            }
5545        }
5546    }
5547
5548    const uint32_t src_size_artificial = src_name_to_die_artificial.GetSize ();
5549    const uint32_t dst_size_artificial = dst_name_to_die_artificial.GetSize ();
5550
5551    UniqueCStringMap<const DWARFDebugInfoEntry *> name_to_die_artificial_not_in_src;
5552
5553    if (src_size_artificial && dst_size_artificial)
5554    {
5555        dst_name_to_die_artificial.Sort();
5556
5557        for (idx = 0; idx < src_size_artificial; ++idx)
5558        {
5559            const char *src_name_artificial = src_name_to_die_artificial.GetCStringAtIndex(idx);
5560            src_die = src_name_to_die_artificial.GetValueAtIndexUnchecked (idx);
5561            dst_die = dst_name_to_die_artificial.Find(src_name_artificial, NULL);
5562
5563            if (dst_die)
5564            {
5565                // Both classes have the artificial types, link them
5566                clang::DeclContext *src_decl_ctx = m_die_to_decl_ctx[src_die];
5567                if (src_decl_ctx)
5568                {
5569                    if (log)
5570                        log->Printf ("uniquing decl context %p from 0x%8.8x for 0x%8.8x", src_decl_ctx, src_die->GetOffset(), dst_die->GetOffset());
5571                    LinkDeclContextToDIE (src_decl_ctx, dst_die);
5572                }
5573                else
5574                {
5575                    if (log)
5576                        log->Printf ("warning: tried to unique decl context from 0x%8.8x for 0x%8.8x, but none was found", src_die->GetOffset(), dst_die->GetOffset());
5577                }
5578
5579                Type *src_child_type = m_die_to_type[src_die];
5580                if (src_child_type)
5581                {
5582                    if (log)
5583                        log->Printf ("uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x", src_child_type, src_child_type->GetID(), src_die->GetOffset(), dst_die->GetOffset());
5584                    m_die_to_type[dst_die] = src_child_type;
5585                }
5586                else
5587                {
5588                    if (log)
5589                        log->Printf ("warning: tried to unique lldb_private::Type from 0x%8.8x for 0x%8.8x, but none was found", src_die->GetOffset(), dst_die->GetOffset());
5590                }
5591            }
5592        }
5593    }
5594
5595    if (dst_size_artificial)
5596    {
5597        for (idx = 0; idx < dst_size_artificial; ++idx)
5598        {
5599            const char *dst_name_artificial = dst_name_to_die_artificial.GetCStringAtIndex(idx);
5600            dst_die = dst_name_to_die_artificial.GetValueAtIndexUnchecked (idx);
5601            if (log)
5602                log->Printf ("warning: need to create artificial method for 0x%8.8x for method '%s'", dst_die->GetOffset(), dst_name_artificial);
5603
5604            failures.push_back(dst_die);
5605        }
5606    }
5607
5608    return (failures.size() != 0);
5609}
5610
5611TypeSP
5612SymbolFileDWARF::ParseType (const SymbolContext& sc, DWARFCompileUnit* dwarf_cu, const DWARFDebugInfoEntry *die, bool *type_is_new_ptr)
5613{
5614    TypeSP type_sp;
5615
5616    if (type_is_new_ptr)
5617        *type_is_new_ptr = false;
5618
5619#if defined(LLDB_CONFIGURATION_DEBUG) or defined(LLDB_CONFIGURATION_RELEASE)
5620    static DIEStack g_die_stack;
5621    DIEStack::ScopedPopper scoped_die_logger(g_die_stack);
5622#endif
5623
5624    AccessType accessibility = eAccessNone;
5625    if (die != NULL)
5626    {
5627        Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
5628        if (log)
5629        {
5630            const DWARFDebugInfoEntry *context_die;
5631            clang::DeclContext *context = GetClangDeclContextContainingDIE (dwarf_cu, die, &context_die);
5632
5633            GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDWARF::ParseType (die = 0x%8.8x, decl_ctx = %p (die 0x%8.8x)) %s name = '%s')",
5634                        die->GetOffset(),
5635                        context,
5636                        context_die->GetOffset(),
5637                        DW_TAG_value_to_name(die->Tag()),
5638                        die->GetName(this, dwarf_cu));
5639
5640#if defined(LLDB_CONFIGURATION_DEBUG) or defined(LLDB_CONFIGURATION_RELEASE)
5641            scoped_die_logger.Push (dwarf_cu, die);
5642            g_die_stack.LogDIEs(log, this);
5643#endif
5644        }
5645//
5646//        Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
5647//        if (log && dwarf_cu)
5648//        {
5649//            StreamString s;
5650//            die->DumpLocation (this, dwarf_cu, s);
5651//            GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDwarf::%s %s", __FUNCTION__, s.GetData());
5652//
5653//        }
5654
5655        Type *type_ptr = m_die_to_type.lookup (die);
5656        TypeList* type_list = GetTypeList();
5657        if (type_ptr == NULL)
5658        {
5659            ClangASTContext &ast = GetClangASTContext();
5660            if (type_is_new_ptr)
5661                *type_is_new_ptr = true;
5662
5663            const dw_tag_t tag = die->Tag();
5664
5665            bool is_forward_declaration = false;
5666            DWARFDebugInfoEntry::Attributes attributes;
5667            const char *type_name_cstr = NULL;
5668            ConstString type_name_const_str;
5669            Type::ResolveState resolve_state = Type::eResolveStateUnresolved;
5670            uint64_t byte_size = 0;
5671            Declaration decl;
5672
5673            Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID;
5674            ClangASTType clang_type;
5675
5676            dw_attr_t attr;
5677
5678            switch (tag)
5679            {
5680            case DW_TAG_base_type:
5681            case DW_TAG_pointer_type:
5682            case DW_TAG_reference_type:
5683            case DW_TAG_rvalue_reference_type:
5684            case DW_TAG_typedef:
5685            case DW_TAG_const_type:
5686            case DW_TAG_restrict_type:
5687            case DW_TAG_volatile_type:
5688            case DW_TAG_unspecified_type:
5689                {
5690                    // Set a bit that lets us know that we are currently parsing this
5691                    m_die_to_type[die] = DIE_IS_BEING_PARSED;
5692
5693                    const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes);
5694                    uint32_t encoding = 0;
5695                    lldb::user_id_t encoding_uid = LLDB_INVALID_UID;
5696
5697                    if (num_attributes > 0)
5698                    {
5699                        uint32_t i;
5700                        for (i=0; i<num_attributes; ++i)
5701                        {
5702                            attr = attributes.AttributeAtIndex(i);
5703                            DWARFFormValue form_value;
5704                            if (attributes.ExtractFormValueAtIndex(this, i, form_value))
5705                            {
5706                                switch (attr)
5707                                {
5708                                case DW_AT_decl_file:   decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
5709                                case DW_AT_decl_line:   decl.SetLine(form_value.Unsigned()); break;
5710                                case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
5711                                case DW_AT_name:
5712
5713                                    type_name_cstr = form_value.AsCString(&get_debug_str_data());
5714                                    // Work around a bug in llvm-gcc where they give a name to a reference type which doesn't
5715                                    // include the "&"...
5716                                    if (tag == DW_TAG_reference_type)
5717                                    {
5718                                        if (strchr (type_name_cstr, '&') == NULL)
5719                                            type_name_cstr = NULL;
5720                                    }
5721                                    if (type_name_cstr)
5722                                        type_name_const_str.SetCString(type_name_cstr);
5723                                    break;
5724                                case DW_AT_byte_size:   byte_size = form_value.Unsigned(); break;
5725                                case DW_AT_encoding:    encoding = form_value.Unsigned(); break;
5726                                case DW_AT_type:        encoding_uid = form_value.Reference(dwarf_cu); break;
5727                                default:
5728                                case DW_AT_sibling:
5729                                    break;
5730                                }
5731                            }
5732                        }
5733                    }
5734
5735                    DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\") type => 0x%8.8x\n", MakeUserID(die->GetOffset()), DW_TAG_value_to_name(tag), type_name_cstr, encoding_uid);
5736
5737                    switch (tag)
5738                    {
5739                    default:
5740                        break;
5741
5742                    case DW_TAG_unspecified_type:
5743                        if (strcmp(type_name_cstr, "nullptr_t") == 0 ||
5744                            strcmp(type_name_cstr, "decltype(nullptr)") == 0 )
5745                        {
5746                            resolve_state = Type::eResolveStateFull;
5747                            clang_type = ast.GetBasicType(eBasicTypeNullPtr);
5748                            break;
5749                        }
5750                        // Fall through to base type below in case we can handle the type there...
5751
5752                    case DW_TAG_base_type:
5753                        resolve_state = Type::eResolveStateFull;
5754                        clang_type = ast.GetBuiltinTypeForDWARFEncodingAndBitSize (type_name_cstr,
5755                                                                                   encoding,
5756                                                                                   byte_size * 8);
5757                        break;
5758
5759                    case DW_TAG_pointer_type:           encoding_data_type = Type::eEncodingIsPointerUID;           break;
5760                    case DW_TAG_reference_type:         encoding_data_type = Type::eEncodingIsLValueReferenceUID;   break;
5761                    case DW_TAG_rvalue_reference_type:  encoding_data_type = Type::eEncodingIsRValueReferenceUID;   break;
5762                    case DW_TAG_typedef:                encoding_data_type = Type::eEncodingIsTypedefUID;           break;
5763                    case DW_TAG_const_type:             encoding_data_type = Type::eEncodingIsConstUID;             break;
5764                    case DW_TAG_restrict_type:          encoding_data_type = Type::eEncodingIsRestrictUID;          break;
5765                    case DW_TAG_volatile_type:          encoding_data_type = Type::eEncodingIsVolatileUID;          break;
5766                    }
5767
5768                    if (!clang_type && (encoding_data_type == Type::eEncodingIsPointerUID || encoding_data_type == Type::eEncodingIsTypedefUID) && sc.comp_unit != NULL)
5769                    {
5770                        bool translation_unit_is_objc = (sc.comp_unit->GetLanguage() == eLanguageTypeObjC || sc.comp_unit->GetLanguage() == eLanguageTypeObjC_plus_plus);
5771
5772                        if (translation_unit_is_objc)
5773                        {
5774                            if (type_name_cstr != NULL)
5775                            {
5776                                static ConstString g_objc_type_name_id("id");
5777                                static ConstString g_objc_type_name_Class("Class");
5778                                static ConstString g_objc_type_name_selector("SEL");
5779
5780                                if (type_name_const_str == g_objc_type_name_id)
5781                                {
5782                                    if (log)
5783                                        GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' is Objective C 'id' built-in type.",
5784                                                                                  die->GetOffset(),
5785                                                                                  DW_TAG_value_to_name(die->Tag()),
5786                                                                                  die->GetName(this, dwarf_cu));
5787                                    clang_type = ast.GetBasicType(eBasicTypeObjCID);
5788                                    encoding_data_type = Type::eEncodingIsUID;
5789                                    encoding_uid = LLDB_INVALID_UID;
5790                                    resolve_state = Type::eResolveStateFull;
5791
5792                                }
5793                                else if (type_name_const_str == g_objc_type_name_Class)
5794                                {
5795                                    if (log)
5796                                        GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' is Objective C 'Class' built-in type.",
5797                                                                                  die->GetOffset(),
5798                                                                                  DW_TAG_value_to_name(die->Tag()),
5799                                                                                  die->GetName(this, dwarf_cu));
5800                                    clang_type = ast.GetBasicType(eBasicTypeObjCClass);
5801                                    encoding_data_type = Type::eEncodingIsUID;
5802                                    encoding_uid = LLDB_INVALID_UID;
5803                                    resolve_state = Type::eResolveStateFull;
5804                                }
5805                                else if (type_name_const_str == g_objc_type_name_selector)
5806                                {
5807                                    if (log)
5808                                        GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' is Objective C 'selector' built-in type.",
5809                                                                                  die->GetOffset(),
5810                                                                                  DW_TAG_value_to_name(die->Tag()),
5811                                                                                  die->GetName(this, dwarf_cu));
5812                                    clang_type = ast.GetBasicType(eBasicTypeObjCSel);
5813                                    encoding_data_type = Type::eEncodingIsUID;
5814                                    encoding_uid = LLDB_INVALID_UID;
5815                                    resolve_state = Type::eResolveStateFull;
5816                                }
5817                            }
5818                            else if (encoding_data_type == Type::eEncodingIsPointerUID && encoding_uid != LLDB_INVALID_UID)
5819                            {
5820                                // Clang sometimes erroneously emits id as objc_object*.  In that case we fix up the type to "id".
5821
5822                                DWARFDebugInfoEntry* encoding_die = dwarf_cu->GetDIEPtr(encoding_uid);
5823
5824                                if (encoding_die && encoding_die->Tag() == DW_TAG_structure_type)
5825                                {
5826                                    if (const char *struct_name = encoding_die->GetAttributeValueAsString(this, dwarf_cu, DW_AT_name, NULL))
5827                                    {
5828                                        if (!strcmp(struct_name, "objc_object"))
5829                                        {
5830                                            if (log)
5831                                                GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' is 'objc_object*', which we overrode to 'id'.",
5832                                                                                          die->GetOffset(),
5833                                                                                          DW_TAG_value_to_name(die->Tag()),
5834                                                                                          die->GetName(this, dwarf_cu));
5835                                            clang_type = ast.GetBasicType(eBasicTypeObjCID);
5836                                            encoding_data_type = Type::eEncodingIsUID;
5837                                            encoding_uid = LLDB_INVALID_UID;
5838                                            resolve_state = Type::eResolveStateFull;
5839                                        }
5840                                    }
5841                                }
5842                            }
5843                        }
5844                    }
5845
5846                    type_sp.reset( new Type (MakeUserID(die->GetOffset()),
5847                                             this,
5848                                             type_name_const_str,
5849                                             byte_size,
5850                                             NULL,
5851                                             encoding_uid,
5852                                             encoding_data_type,
5853                                             &decl,
5854                                             clang_type,
5855                                             resolve_state));
5856
5857                    m_die_to_type[die] = type_sp.get();
5858
5859//                  Type* encoding_type = GetUniquedTypeForDIEOffset(encoding_uid, type_sp, NULL, 0, 0, false);
5860//                  if (encoding_type != NULL)
5861//                  {
5862//                      if (encoding_type != DIE_IS_BEING_PARSED)
5863//                          type_sp->SetEncodingType(encoding_type);
5864//                      else
5865//                          m_indirect_fixups.push_back(type_sp.get());
5866//                  }
5867                }
5868                break;
5869
5870            case DW_TAG_structure_type:
5871            case DW_TAG_union_type:
5872            case DW_TAG_class_type:
5873                {
5874                    // Set a bit that lets us know that we are currently parsing this
5875                    m_die_to_type[die] = DIE_IS_BEING_PARSED;
5876                    bool byte_size_valid = false;
5877
5878                    LanguageType class_language = eLanguageTypeUnknown;
5879                    bool is_complete_objc_class = false;
5880                    //bool struct_is_class = false;
5881                    const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes);
5882                    if (num_attributes > 0)
5883                    {
5884                        uint32_t i;
5885                        for (i=0; i<num_attributes; ++i)
5886                        {
5887                            attr = attributes.AttributeAtIndex(i);
5888                            DWARFFormValue form_value;
5889                            if (attributes.ExtractFormValueAtIndex(this, i, form_value))
5890                            {
5891                                switch (attr)
5892                                {
5893                                case DW_AT_decl_file:
5894                                    if (dwarf_cu->DW_AT_decl_file_attributes_are_invalid())
5895									{
5896										// llvm-gcc outputs invalid DW_AT_decl_file attributes that always
5897										// point to the compile unit file, so we clear this invalid value
5898										// so that we can still unique types efficiently.
5899                                        decl.SetFile(FileSpec ("<invalid>", false));
5900									}
5901                                    else
5902                                        decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned()));
5903                                    break;
5904
5905                                case DW_AT_decl_line:
5906                                    decl.SetLine(form_value.Unsigned());
5907                                    break;
5908
5909                                case DW_AT_decl_column:
5910                                    decl.SetColumn(form_value.Unsigned());
5911                                    break;
5912
5913                                case DW_AT_name:
5914                                    type_name_cstr = form_value.AsCString(&get_debug_str_data());
5915                                    type_name_const_str.SetCString(type_name_cstr);
5916                                    break;
5917
5918                                case DW_AT_byte_size:
5919                                    byte_size = form_value.Unsigned();
5920                                    byte_size_valid = true;
5921                                    break;
5922
5923                                case DW_AT_accessibility:
5924                                    accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned());
5925                                    break;
5926
5927                                case DW_AT_declaration:
5928                                    is_forward_declaration = form_value.Boolean();
5929                                    break;
5930
5931                                case DW_AT_APPLE_runtime_class:
5932                                    class_language = (LanguageType)form_value.Signed();
5933                                    break;
5934
5935                                case DW_AT_APPLE_objc_complete_type:
5936                                    is_complete_objc_class = form_value.Signed();
5937                                    break;
5938
5939                                case DW_AT_allocated:
5940                                case DW_AT_associated:
5941                                case DW_AT_data_location:
5942                                case DW_AT_description:
5943                                case DW_AT_start_scope:
5944                                case DW_AT_visibility:
5945                                default:
5946                                case DW_AT_sibling:
5947                                    break;
5948                                }
5949                            }
5950                        }
5951                    }
5952
5953                    UniqueDWARFASTType unique_ast_entry;
5954
5955                    // Only try and unique the type if it has a name.
5956                    if (type_name_const_str &&
5957                        GetUniqueDWARFASTTypeMap().Find (type_name_const_str,
5958                                                         this,
5959                                                         dwarf_cu,
5960                                                         die,
5961                                                         decl,
5962                                                         byte_size_valid ? byte_size : -1,
5963                                                         unique_ast_entry))
5964                    {
5965                        // We have already parsed this type or from another
5966                        // compile unit. GCC loves to use the "one definition
5967                        // rule" which can result in multiple definitions
5968                        // of the same class over and over in each compile
5969                        // unit.
5970                        type_sp = unique_ast_entry.m_type_sp;
5971                        if (type_sp)
5972                        {
5973                            m_die_to_type[die] = type_sp.get();
5974                            return type_sp;
5975                        }
5976                    }
5977
5978                    DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", MakeUserID(die->GetOffset()), DW_TAG_value_to_name(tag), type_name_cstr);
5979
5980                    int tag_decl_kind = -1;
5981                    AccessType default_accessibility = eAccessNone;
5982                    if (tag == DW_TAG_structure_type)
5983                    {
5984                        tag_decl_kind = clang::TTK_Struct;
5985                        default_accessibility = eAccessPublic;
5986                    }
5987                    else if (tag == DW_TAG_union_type)
5988                    {
5989                        tag_decl_kind = clang::TTK_Union;
5990                        default_accessibility = eAccessPublic;
5991                    }
5992                    else if (tag == DW_TAG_class_type)
5993                    {
5994                        tag_decl_kind = clang::TTK_Class;
5995                        default_accessibility = eAccessPrivate;
5996                    }
5997
5998                    if (byte_size_valid && byte_size == 0 && type_name_cstr &&
5999                        die->HasChildren() == false &&
6000                        sc.comp_unit->GetLanguage() == eLanguageTypeObjC)
6001                    {
6002                        // Work around an issue with clang at the moment where
6003                        // forward declarations for objective C classes are emitted
6004                        // as:
6005                        //  DW_TAG_structure_type [2]
6006                        //  DW_AT_name( "ForwardObjcClass" )
6007                        //  DW_AT_byte_size( 0x00 )
6008                        //  DW_AT_decl_file( "..." )
6009                        //  DW_AT_decl_line( 1 )
6010                        //
6011                        // Note that there is no DW_AT_declaration and there are
6012                        // no children, and the byte size is zero.
6013                        is_forward_declaration = true;
6014                    }
6015
6016                    if (class_language == eLanguageTypeObjC ||
6017                        class_language == eLanguageTypeObjC_plus_plus)
6018                    {
6019                        if (!is_complete_objc_class && Supports_DW_AT_APPLE_objc_complete_type(dwarf_cu))
6020                        {
6021                            // We have a valid eSymbolTypeObjCClass class symbol whose
6022                            // name matches the current objective C class that we
6023                            // are trying to find and this DIE isn't the complete
6024                            // definition (we checked is_complete_objc_class above and
6025                            // know it is false), so the real definition is in here somewhere
6026                            type_sp = FindCompleteObjCDefinitionTypeForDIE (die, type_name_const_str, true);
6027
6028                            if (!type_sp && GetDebugMapSymfile ())
6029                            {
6030                                // We weren't able to find a full declaration in
6031                                // this DWARF, see if we have a declaration anywhere
6032                                // else...
6033                                type_sp = m_debug_map_symfile->FindCompleteObjCDefinitionTypeForDIE (die, type_name_const_str, true);
6034                            }
6035
6036                            if (type_sp)
6037                            {
6038                                if (log)
6039                                {
6040                                    GetObjectFile()->GetModule()->LogMessage (log,
6041                                                                              "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is an incomplete objc type, complete type is 0x%8.8" PRIx64,
6042                                                                              this,
6043                                                                              die->GetOffset(),
6044                                                                              DW_TAG_value_to_name(tag),
6045                                                                              type_name_cstr,
6046                                                                              type_sp->GetID());
6047                                }
6048
6049                                // We found a real definition for this type elsewhere
6050                                // so lets use it and cache the fact that we found
6051                                // a complete type for this die
6052                                m_die_to_type[die] = type_sp.get();
6053                                return type_sp;
6054                            }
6055                        }
6056                    }
6057
6058
6059                    if (is_forward_declaration)
6060                    {
6061                        // We have a forward declaration to a type and we need
6062                        // to try and find a full declaration. We look in the
6063                        // current type index just in case we have a forward
6064                        // declaration followed by an actual declarations in the
6065                        // DWARF. If this fails, we need to look elsewhere...
6066                        if (log)
6067                        {
6068                            GetObjectFile()->GetModule()->LogMessage (log,
6069                                                                      "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is a forward declaration, trying to find complete type",
6070                                                                      this,
6071                                                                      die->GetOffset(),
6072                                                                      DW_TAG_value_to_name(tag),
6073                                                                      type_name_cstr);
6074                        }
6075
6076                        DWARFDeclContext die_decl_ctx;
6077                        die->GetDWARFDeclContext(this, dwarf_cu, die_decl_ctx);
6078
6079                        //type_sp = FindDefinitionTypeForDIE (dwarf_cu, die, type_name_const_str);
6080                        type_sp = FindDefinitionTypeForDWARFDeclContext (die_decl_ctx);
6081
6082                        if (!type_sp && GetDebugMapSymfile ())
6083                        {
6084                            // We weren't able to find a full declaration in
6085                            // this DWARF, see if we have a declaration anywhere
6086                            // else...
6087                            type_sp = m_debug_map_symfile->FindDefinitionTypeForDWARFDeclContext (die_decl_ctx);
6088                        }
6089
6090                        if (type_sp)
6091                        {
6092                            if (log)
6093                            {
6094                                GetObjectFile()->GetModule()->LogMessage (log,
6095                                                                          "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is a forward declaration, complete type is 0x%8.8" PRIx64,
6096                                                                          this,
6097                                                                          die->GetOffset(),
6098                                                                          DW_TAG_value_to_name(tag),
6099                                                                          type_name_cstr,
6100                                                                          type_sp->GetID());
6101                            }
6102
6103                            // We found a real definition for this type elsewhere
6104                            // so lets use it and cache the fact that we found
6105                            // a complete type for this die
6106                            m_die_to_type[die] = type_sp.get();
6107                            return type_sp;
6108                        }
6109                    }
6110                    assert (tag_decl_kind != -1);
6111                    bool clang_type_was_created = false;
6112                    clang_type.SetClangType(ast.getASTContext(), m_forward_decl_die_to_clang_type.lookup (die));
6113                    if (!clang_type)
6114                    {
6115                        const DWARFDebugInfoEntry *decl_ctx_die;
6116
6117                        clang::DeclContext *decl_ctx = GetClangDeclContextContainingDIE (dwarf_cu, die, &decl_ctx_die);
6118                        if (accessibility == eAccessNone && decl_ctx)
6119                        {
6120                            // Check the decl context that contains this class/struct/union.
6121                            // If it is a class we must give it an accessability.
6122                            const clang::Decl::Kind containing_decl_kind = decl_ctx->getDeclKind();
6123                            if (DeclKindIsCXXClass (containing_decl_kind))
6124                                accessibility = default_accessibility;
6125                        }
6126
6127                        ClangASTMetadata metadata;
6128                        metadata.SetUserID(MakeUserID(die->GetOffset()));
6129                        metadata.SetIsDynamicCXXType(ClassOrStructIsVirtual (dwarf_cu, die));
6130
6131                        if (type_name_cstr && strchr (type_name_cstr, '<'))
6132                        {
6133                            ClangASTContext::TemplateParameterInfos template_param_infos;
6134                            if (ParseTemplateParameterInfos (dwarf_cu, die, template_param_infos))
6135                            {
6136                                clang::ClassTemplateDecl *class_template_decl = ParseClassTemplateDecl (decl_ctx,
6137                                                                                                        accessibility,
6138                                                                                                        type_name_cstr,
6139                                                                                                        tag_decl_kind,
6140                                                                                                        template_param_infos);
6141
6142                                clang::ClassTemplateSpecializationDecl *class_specialization_decl = ast.CreateClassTemplateSpecializationDecl (decl_ctx,
6143                                                                                                                                               class_template_decl,
6144                                                                                                                                               tag_decl_kind,
6145                                                                                                                                               template_param_infos);
6146                                clang_type = ast.CreateClassTemplateSpecializationType (class_specialization_decl);
6147                                clang_type_was_created = true;
6148
6149                                GetClangASTContext().SetMetadata (class_template_decl, metadata);
6150                                GetClangASTContext().SetMetadata (class_specialization_decl, metadata);
6151                            }
6152                        }
6153
6154                        if (!clang_type_was_created)
6155                        {
6156                            clang_type_was_created = true;
6157                            clang_type = ast.CreateRecordType (decl_ctx,
6158                                                               accessibility,
6159                                                               type_name_cstr,
6160                                                               tag_decl_kind,
6161                                                               class_language,
6162                                                               &metadata);
6163                        }
6164                    }
6165
6166                    // Store a forward declaration to this class type in case any
6167                    // parameters in any class methods need it for the clang
6168                    // types for function prototypes.
6169                    LinkDeclContextToDIE(clang_type.GetDeclContextForType(), die);
6170                    type_sp.reset (new Type (MakeUserID(die->GetOffset()),
6171                                             this,
6172                                             type_name_const_str,
6173                                             byte_size,
6174                                             NULL,
6175                                             LLDB_INVALID_UID,
6176                                             Type::eEncodingIsUID,
6177                                             &decl,
6178                                             clang_type,
6179                                             Type::eResolveStateForward));
6180
6181                    type_sp->SetIsCompleteObjCClass(is_complete_objc_class);
6182
6183
6184                    // Add our type to the unique type map so we don't
6185                    // end up creating many copies of the same type over
6186                    // and over in the ASTContext for our module
6187                    unique_ast_entry.m_type_sp = type_sp;
6188                    unique_ast_entry.m_symfile = this;
6189                    unique_ast_entry.m_cu = dwarf_cu;
6190                    unique_ast_entry.m_die = die;
6191                    unique_ast_entry.m_declaration = decl;
6192                    unique_ast_entry.m_byte_size = byte_size;
6193                    GetUniqueDWARFASTTypeMap().Insert (type_name_const_str,
6194                                                       unique_ast_entry);
6195
6196                    if (!is_forward_declaration)
6197                    {
6198                        // Always start the definition for a class type so that
6199                        // if the class has child classes or types that require
6200                        // the class to be created for use as their decl contexts
6201                        // the class will be ready to accept these child definitions.
6202                        if (die->HasChildren() == false)
6203                        {
6204                            // No children for this struct/union/class, lets finish it
6205                            clang_type.StartTagDeclarationDefinition ();
6206                            clang_type.CompleteTagDeclarationDefinition ();
6207
6208                            if (tag == DW_TAG_structure_type) // this only applies in C
6209                            {
6210                                clang::RecordDecl *record_decl = clang_type.GetAsRecordDecl();
6211
6212                                if (record_decl)
6213                                {
6214                                    LayoutInfo layout_info;
6215
6216                                    layout_info.alignment = 0;
6217                                    layout_info.bit_size = 0;
6218
6219                                    m_record_decl_to_layout_map.insert(std::make_pair(record_decl, layout_info));
6220                                }
6221                            }
6222                        }
6223                        else if (clang_type_was_created)
6224                        {
6225                            // Start the definition if the class is not objective C since
6226                            // the underlying decls respond to isCompleteDefinition(). Objective
6227                            // C decls dont' respond to isCompleteDefinition() so we can't
6228                            // start the declaration definition right away. For C++ classs/union/structs
6229                            // we want to start the definition in case the class is needed as the
6230                            // declaration context for a contained class or type without the need
6231                            // to complete that type..
6232
6233                            if (class_language != eLanguageTypeObjC &&
6234                                class_language != eLanguageTypeObjC_plus_plus)
6235                                clang_type.StartTagDeclarationDefinition ();
6236
6237                            // Leave this as a forward declaration until we need
6238                            // to know the details of the type. lldb_private::Type
6239                            // will automatically call the SymbolFile virtual function
6240                            // "SymbolFileDWARF::ResolveClangOpaqueTypeDefinition(Type *)"
6241                            // When the definition needs to be defined.
6242                            m_forward_decl_die_to_clang_type[die] = clang_type.GetOpaqueQualType();
6243                            m_forward_decl_clang_type_to_die[clang_type.RemoveFastQualifiers().GetOpaqueQualType()] = die;
6244                            clang_type.SetHasExternalStorage (true);
6245                        }
6246                    }
6247
6248                }
6249                break;
6250
6251            case DW_TAG_enumeration_type:
6252                {
6253                    // Set a bit that lets us know that we are currently parsing this
6254                    m_die_to_type[die] = DIE_IS_BEING_PARSED;
6255
6256                    lldb::user_id_t encoding_uid = DW_INVALID_OFFSET;
6257
6258                    const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes);
6259                    if (num_attributes > 0)
6260                    {
6261                        uint32_t i;
6262
6263                        for (i=0; i<num_attributes; ++i)
6264                        {
6265                            attr = attributes.AttributeAtIndex(i);
6266                            DWARFFormValue form_value;
6267                            if (attributes.ExtractFormValueAtIndex(this, i, form_value))
6268                            {
6269                                switch (attr)
6270                                {
6271                                case DW_AT_decl_file:       decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
6272                                case DW_AT_decl_line:       decl.SetLine(form_value.Unsigned()); break;
6273                                case DW_AT_decl_column:     decl.SetColumn(form_value.Unsigned()); break;
6274                                case DW_AT_name:
6275                                    type_name_cstr = form_value.AsCString(&get_debug_str_data());
6276                                    type_name_const_str.SetCString(type_name_cstr);
6277                                    break;
6278                                case DW_AT_type:            encoding_uid = form_value.Reference(dwarf_cu); break;
6279                                case DW_AT_byte_size:       byte_size = form_value.Unsigned(); break;
6280                                case DW_AT_accessibility:   break; //accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
6281                                case DW_AT_declaration:     break; //is_forward_declaration = form_value.Boolean(); break;
6282                                case DW_AT_allocated:
6283                                case DW_AT_associated:
6284                                case DW_AT_bit_stride:
6285                                case DW_AT_byte_stride:
6286                                case DW_AT_data_location:
6287                                case DW_AT_description:
6288                                case DW_AT_start_scope:
6289                                case DW_AT_visibility:
6290                                case DW_AT_specification:
6291                                case DW_AT_abstract_origin:
6292                                case DW_AT_sibling:
6293                                    break;
6294                                }
6295                            }
6296                        }
6297
6298                        DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", MakeUserID(die->GetOffset()), DW_TAG_value_to_name(tag), type_name_cstr);
6299
6300                        ClangASTType enumerator_clang_type;
6301                        clang_type.SetClangType (ast.getASTContext(), m_forward_decl_die_to_clang_type.lookup (die));
6302                        if (!clang_type)
6303                        {
6304                            if (encoding_uid != DW_INVALID_OFFSET)
6305                            {
6306                                Type *enumerator_type = ResolveTypeUID(encoding_uid);
6307                                if (enumerator_type)
6308                                    enumerator_clang_type = enumerator_type->GetClangFullType();
6309                            }
6310
6311                            if (!enumerator_clang_type)
6312                                enumerator_clang_type = ast.GetBuiltinTypeForDWARFEncodingAndBitSize (NULL,
6313                                                                                                      DW_ATE_signed,
6314                                                                                                      byte_size * 8);
6315
6316                            clang_type = ast.CreateEnumerationType (type_name_cstr,
6317                                                                    GetClangDeclContextContainingDIE (dwarf_cu, die, NULL),
6318                                                                    decl,
6319                                                                    enumerator_clang_type);
6320                        }
6321                        else
6322                        {
6323                            enumerator_clang_type = clang_type.GetEnumerationIntegerType ();
6324                        }
6325
6326                        LinkDeclContextToDIE(clang_type.GetDeclContextForType(), die);
6327
6328                        type_sp.reset( new Type (MakeUserID(die->GetOffset()),
6329                                                 this,
6330                                                 type_name_const_str,
6331                                                 byte_size,
6332                                                 NULL,
6333                                                 encoding_uid,
6334                                                 Type::eEncodingIsUID,
6335                                                 &decl,
6336                                                 clang_type,
6337                                                 Type::eResolveStateForward));
6338
6339                        clang_type.StartTagDeclarationDefinition ();
6340                        if (die->HasChildren())
6341                        {
6342                            SymbolContext cu_sc(GetCompUnitForDWARFCompUnit(dwarf_cu));
6343                            bool is_signed = false;
6344                            enumerator_clang_type.IsIntegerType(is_signed);
6345                            ParseChildEnumerators(cu_sc, clang_type, is_signed, type_sp->GetByteSize(), dwarf_cu, die);
6346                        }
6347                        clang_type.CompleteTagDeclarationDefinition ();
6348                    }
6349                }
6350                break;
6351
6352            case DW_TAG_inlined_subroutine:
6353            case DW_TAG_subprogram:
6354            case DW_TAG_subroutine_type:
6355                {
6356                    // Set a bit that lets us know that we are currently parsing this
6357                    m_die_to_type[die] = DIE_IS_BEING_PARSED;
6358
6359                    //const char *mangled = NULL;
6360                    dw_offset_t type_die_offset = DW_INVALID_OFFSET;
6361                    bool is_variadic = false;
6362                    bool is_inline = false;
6363                    bool is_static = false;
6364                    bool is_virtual = false;
6365                    bool is_explicit = false;
6366                    bool is_artificial = false;
6367                    dw_offset_t specification_die_offset = DW_INVALID_OFFSET;
6368                    dw_offset_t abstract_origin_die_offset = DW_INVALID_OFFSET;
6369                    dw_offset_t object_pointer_die_offset = DW_INVALID_OFFSET;
6370
6371                    unsigned type_quals = 0;
6372                    clang::StorageClass storage = clang::SC_None;//, Extern, Static, PrivateExtern
6373
6374
6375                    const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes);
6376                    if (num_attributes > 0)
6377                    {
6378                        uint32_t i;
6379                        for (i=0; i<num_attributes; ++i)
6380                        {
6381                            attr = attributes.AttributeAtIndex(i);
6382                            DWARFFormValue form_value;
6383                            if (attributes.ExtractFormValueAtIndex(this, i, form_value))
6384                            {
6385                                switch (attr)
6386                                {
6387                                case DW_AT_decl_file:   decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
6388                                case DW_AT_decl_line:   decl.SetLine(form_value.Unsigned()); break;
6389                                case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
6390                                case DW_AT_name:
6391                                    type_name_cstr = form_value.AsCString(&get_debug_str_data());
6392                                    type_name_const_str.SetCString(type_name_cstr);
6393                                    break;
6394
6395                                case DW_AT_linkage_name:
6396                                case DW_AT_MIPS_linkage_name:   break; // mangled = form_value.AsCString(&get_debug_str_data()); break;
6397                                case DW_AT_type:                type_die_offset = form_value.Reference(dwarf_cu); break;
6398                                case DW_AT_accessibility:       accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
6399                                case DW_AT_declaration:         break; // is_forward_declaration = form_value.Boolean(); break;
6400                                case DW_AT_inline:              is_inline = form_value.Boolean(); break;
6401                                case DW_AT_virtuality:          is_virtual = form_value.Boolean();  break;
6402                                case DW_AT_explicit:            is_explicit = form_value.Boolean();  break;
6403                                case DW_AT_artificial:          is_artificial = form_value.Boolean();  break;
6404
6405
6406                                case DW_AT_external:
6407                                    if (form_value.Unsigned())
6408                                    {
6409                                        if (storage == clang::SC_None)
6410                                            storage = clang::SC_Extern;
6411                                        else
6412                                            storage = clang::SC_PrivateExtern;
6413                                    }
6414                                    break;
6415
6416                                case DW_AT_specification:
6417                                    specification_die_offset = form_value.Reference(dwarf_cu);
6418                                    break;
6419
6420                                case DW_AT_abstract_origin:
6421                                    abstract_origin_die_offset = form_value.Reference(dwarf_cu);
6422                                    break;
6423
6424                                case DW_AT_object_pointer:
6425                                    object_pointer_die_offset = form_value.Reference(dwarf_cu);
6426                                    break;
6427
6428                                case DW_AT_allocated:
6429                                case DW_AT_associated:
6430                                case DW_AT_address_class:
6431                                case DW_AT_calling_convention:
6432                                case DW_AT_data_location:
6433                                case DW_AT_elemental:
6434                                case DW_AT_entry_pc:
6435                                case DW_AT_frame_base:
6436                                case DW_AT_high_pc:
6437                                case DW_AT_low_pc:
6438                                case DW_AT_prototyped:
6439                                case DW_AT_pure:
6440                                case DW_AT_ranges:
6441                                case DW_AT_recursive:
6442                                case DW_AT_return_addr:
6443                                case DW_AT_segment:
6444                                case DW_AT_start_scope:
6445                                case DW_AT_static_link:
6446                                case DW_AT_trampoline:
6447                                case DW_AT_visibility:
6448                                case DW_AT_vtable_elem_location:
6449                                case DW_AT_description:
6450                                case DW_AT_sibling:
6451                                    break;
6452                                }
6453                            }
6454                        }
6455                    }
6456
6457                    std::string object_pointer_name;
6458                    if (object_pointer_die_offset != DW_INVALID_OFFSET)
6459                    {
6460                        // Get the name from the object pointer die
6461                        StreamString s;
6462                        if (DWARFDebugInfoEntry::GetName (this, dwarf_cu, object_pointer_die_offset, s))
6463                        {
6464                            object_pointer_name.assign(s.GetData());
6465                        }
6466                    }
6467
6468                    DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", MakeUserID(die->GetOffset()), DW_TAG_value_to_name(tag), type_name_cstr);
6469
6470                    ClangASTType return_clang_type;
6471                    Type *func_type = NULL;
6472
6473                    if (type_die_offset != DW_INVALID_OFFSET)
6474                        func_type = ResolveTypeUID(type_die_offset);
6475
6476                    if (func_type)
6477                        return_clang_type = func_type->GetClangForwardType();
6478                    else
6479                        return_clang_type = ast.GetBasicType(eBasicTypeVoid);
6480
6481
6482                    std::vector<ClangASTType> function_param_types;
6483                    std::vector<clang::ParmVarDecl*> function_param_decls;
6484
6485                    // Parse the function children for the parameters
6486
6487                    const DWARFDebugInfoEntry *decl_ctx_die = NULL;
6488                    clang::DeclContext *containing_decl_ctx = GetClangDeclContextContainingDIE (dwarf_cu, die, &decl_ctx_die);
6489                    const clang::Decl::Kind containing_decl_kind = containing_decl_ctx->getDeclKind();
6490
6491                    const bool is_cxx_method = DeclKindIsCXXClass (containing_decl_kind);
6492                    // Start off static. This will be set to false in ParseChildParameters(...)
6493                    // if we find a "this" paramters as the first parameter
6494                    if (is_cxx_method)
6495                        is_static = true;
6496                    ClangASTContext::TemplateParameterInfos template_param_infos;
6497
6498                    if (die->HasChildren())
6499                    {
6500                        bool skip_artificial = true;
6501                        ParseChildParameters (sc,
6502                                              containing_decl_ctx,
6503                                              dwarf_cu,
6504                                              die,
6505                                              skip_artificial,
6506                                              is_static,
6507                                              type_list,
6508                                              function_param_types,
6509                                              function_param_decls,
6510                                              type_quals,
6511                                              template_param_infos);
6512                    }
6513
6514                    // clang_type will get the function prototype clang type after this call
6515                    clang_type = ast.CreateFunctionType (return_clang_type,
6516                                                         function_param_types.data(),
6517                                                         function_param_types.size(),
6518                                                         is_variadic,
6519                                                         type_quals);
6520
6521                    bool ignore_containing_context = false;
6522
6523                    if (type_name_cstr)
6524                    {
6525                        bool type_handled = false;
6526                        if (tag == DW_TAG_subprogram)
6527                        {
6528                            ObjCLanguageRuntime::MethodName objc_method (type_name_cstr, true);
6529                            if (objc_method.IsValid(true))
6530                            {
6531                                SymbolContext empty_sc;
6532                                ClangASTType class_opaque_type;
6533                                ConstString class_name(objc_method.GetClassName());
6534                                if (class_name)
6535                                {
6536                                    TypeList types;
6537                                    TypeSP complete_objc_class_type_sp (FindCompleteObjCDefinitionTypeForDIE (NULL, class_name, false));
6538
6539                                    if (complete_objc_class_type_sp)
6540                                    {
6541                                        ClangASTType type_clang_forward_type = complete_objc_class_type_sp->GetClangForwardType();
6542                                        if (type_clang_forward_type.IsObjCObjectOrInterfaceType ())
6543                                            class_opaque_type = type_clang_forward_type;
6544                                    }
6545                                }
6546
6547                                if (class_opaque_type)
6548                                {
6549                                    // If accessibility isn't set to anything valid, assume public for
6550                                    // now...
6551                                    if (accessibility == eAccessNone)
6552                                        accessibility = eAccessPublic;
6553
6554                                    clang::ObjCMethodDecl *objc_method_decl = class_opaque_type.AddMethodToObjCObjectType (type_name_cstr,
6555                                                                                                                           clang_type,
6556                                                                                                                           accessibility,
6557                                                                                                                           is_artificial);
6558                                    type_handled = objc_method_decl != NULL;
6559                                    if (type_handled)
6560                                    {
6561                                        LinkDeclContextToDIE(ClangASTContext::GetAsDeclContext(objc_method_decl), die);
6562                                        GetClangASTContext().SetMetadataAsUserID (objc_method_decl, MakeUserID(die->GetOffset()));
6563                                    }
6564                                    else
6565                                    {
6566                                        GetObjectFile()->GetModule()->ReportError ("{0x%8.8x}: invalid Objective-C method 0x%4.4x (%s), please file a bug and attach the file at the start of this error message",
6567                                                                                   die->GetOffset(),
6568                                                                                   tag,
6569                                                                                   DW_TAG_value_to_name(tag));
6570                                    }
6571                                }
6572                            }
6573                            else if (is_cxx_method)
6574                            {
6575                                // Look at the parent of this DIE and see if is is
6576                                // a class or struct and see if this is actually a
6577                                // C++ method
6578                                Type *class_type = ResolveType (dwarf_cu, decl_ctx_die);
6579                                if (class_type)
6580                                {
6581                                    if (class_type->GetID() != MakeUserID(decl_ctx_die->GetOffset()))
6582                                    {
6583                                        // We uniqued the parent class of this function to another class
6584                                        // so we now need to associate all dies under "decl_ctx_die" to
6585                                        // DIEs in the DIE for "class_type"...
6586                                        SymbolFileDWARF *class_symfile = NULL;
6587                                        DWARFCompileUnitSP class_type_cu_sp;
6588                                        const DWARFDebugInfoEntry *class_type_die = NULL;
6589
6590                                        SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
6591                                        if (debug_map_symfile)
6592                                        {
6593                                            class_symfile = debug_map_symfile->GetSymbolFileByOSOIndex(SymbolFileDWARFDebugMap::GetOSOIndexFromUserID(class_type->GetID()));
6594                                            class_type_die = class_symfile->DebugInfo()->GetDIEPtr(class_type->GetID(), &class_type_cu_sp);
6595                                        }
6596                                        else
6597                                        {
6598                                            class_symfile = this;
6599                                            class_type_die = DebugInfo()->GetDIEPtr(class_type->GetID(), &class_type_cu_sp);
6600                                        }
6601                                        if (class_type_die)
6602                                        {
6603                                            llvm::SmallVector<const DWARFDebugInfoEntry *, 0> failures;
6604
6605                                            CopyUniqueClassMethodTypes (class_symfile,
6606                                                                        class_type,
6607                                                                        class_type_cu_sp.get(),
6608                                                                        class_type_die,
6609                                                                        dwarf_cu,
6610                                                                        decl_ctx_die,
6611                                                                        failures);
6612
6613                                            // FIXME do something with these failures that's smarter than
6614                                            // just dropping them on the ground.  Unfortunately classes don't
6615                                            // like having stuff added to them after their definitions are
6616                                            // complete...
6617
6618                                            type_ptr = m_die_to_type[die];
6619                                            if (type_ptr && type_ptr != DIE_IS_BEING_PARSED)
6620                                            {
6621                                                type_sp = type_ptr->shared_from_this();
6622                                                break;
6623                                            }
6624                                        }
6625                                    }
6626
6627                                    if (specification_die_offset != DW_INVALID_OFFSET)
6628                                    {
6629                                        // We have a specification which we are going to base our function
6630                                        // prototype off of, so we need this type to be completed so that the
6631                                        // m_die_to_decl_ctx for the method in the specification has a valid
6632                                        // clang decl context.
6633                                        class_type->GetClangForwardType();
6634                                        // If we have a specification, then the function type should have been
6635                                        // made with the specification and not with this die.
6636                                        DWARFCompileUnitSP spec_cu_sp;
6637                                        const DWARFDebugInfoEntry* spec_die = DebugInfo()->GetDIEPtr(specification_die_offset, &spec_cu_sp);
6638                                        clang::DeclContext *spec_clang_decl_ctx = GetClangDeclContextForDIE (sc, dwarf_cu, spec_die);
6639                                        if (spec_clang_decl_ctx)
6640                                        {
6641                                            LinkDeclContextToDIE(spec_clang_decl_ctx, die);
6642                                        }
6643                                        else
6644                                        {
6645                                            GetObjectFile()->GetModule()->ReportWarning ("0x%8.8" PRIx64 ": DW_AT_specification(0x%8.8x) has no decl\n",
6646                                                                                         MakeUserID(die->GetOffset()),
6647                                                                                         specification_die_offset);
6648                                        }
6649                                        type_handled = true;
6650                                    }
6651                                    else if (abstract_origin_die_offset != DW_INVALID_OFFSET)
6652                                    {
6653                                        // We have a specification which we are going to base our function
6654                                        // prototype off of, so we need this type to be completed so that the
6655                                        // m_die_to_decl_ctx for the method in the abstract origin has a valid
6656                                        // clang decl context.
6657                                        class_type->GetClangForwardType();
6658
6659                                        DWARFCompileUnitSP abs_cu_sp;
6660                                        const DWARFDebugInfoEntry* abs_die = DebugInfo()->GetDIEPtr(abstract_origin_die_offset, &abs_cu_sp);
6661                                        clang::DeclContext *abs_clang_decl_ctx = GetClangDeclContextForDIE (sc, dwarf_cu, abs_die);
6662                                        if (abs_clang_decl_ctx)
6663                                        {
6664                                            LinkDeclContextToDIE (abs_clang_decl_ctx, die);
6665                                        }
6666                                        else
6667                                        {
6668                                            GetObjectFile()->GetModule()->ReportWarning ("0x%8.8" PRIx64 ": DW_AT_abstract_origin(0x%8.8x) has no decl\n",
6669                                                                                         MakeUserID(die->GetOffset()),
6670                                                                                         abstract_origin_die_offset);
6671                                        }
6672                                        type_handled = true;
6673                                    }
6674                                    else
6675                                    {
6676                                        ClangASTType class_opaque_type = class_type->GetClangForwardType();
6677                                        if (class_opaque_type.IsCXXClassType ())
6678                                        {
6679                                            if (class_opaque_type.IsBeingDefined ())
6680                                            {
6681                                                // Neither GCC 4.2 nor clang++ currently set a valid accessibility
6682                                                // in the DWARF for C++ methods... Default to public for now...
6683                                                if (accessibility == eAccessNone)
6684                                                    accessibility = eAccessPublic;
6685
6686                                                if (!is_static && !die->HasChildren())
6687                                                {
6688                                                    // We have a C++ member function with no children (this pointer!)
6689                                                    // and clang will get mad if we try and make a function that isn't
6690                                                    // well formed in the DWARF, so we will just skip it...
6691                                                    type_handled = true;
6692                                                }
6693                                                else
6694                                                {
6695                                                    clang::CXXMethodDecl *cxx_method_decl;
6696                                                    // REMOVE THE CRASH DESCRIPTION BELOW
6697                                                    Host::SetCrashDescriptionWithFormat ("SymbolFileDWARF::ParseType() is adding a method %s to class %s in DIE 0x%8.8" PRIx64 " from %s",
6698                                                                                         type_name_cstr,
6699                                                                                         class_type->GetName().GetCString(),
6700                                                                                         MakeUserID(die->GetOffset()),
6701                                                                                         m_obj_file->GetFileSpec().GetPath().c_str());
6702
6703                                                    const bool is_attr_used = false;
6704
6705                                                    cxx_method_decl = class_opaque_type.AddMethodToCXXRecordType (type_name_cstr,
6706                                                                                                                  clang_type,
6707                                                                                                                  accessibility,
6708                                                                                                                  is_virtual,
6709                                                                                                                  is_static,
6710                                                                                                                  is_inline,
6711                                                                                                                  is_explicit,
6712                                                                                                                  is_attr_used,
6713                                                                                                                  is_artificial);
6714
6715                                                    type_handled = cxx_method_decl != NULL;
6716
6717                                                    if (type_handled)
6718                                                    {
6719                                                        LinkDeclContextToDIE(ClangASTContext::GetAsDeclContext(cxx_method_decl), die);
6720
6721                                                        Host::SetCrashDescription (NULL);
6722
6723
6724                                                        ClangASTMetadata metadata;
6725                                                        metadata.SetUserID(MakeUserID(die->GetOffset()));
6726
6727                                                        if (!object_pointer_name.empty())
6728                                                        {
6729                                                            metadata.SetObjectPtrName(object_pointer_name.c_str());
6730                                                            if (log)
6731                                                                log->Printf ("Setting object pointer name: %s on method object %p.\n",
6732                                                                             object_pointer_name.c_str(),
6733                                                                             cxx_method_decl);
6734                                                        }
6735                                                        GetClangASTContext().SetMetadata (cxx_method_decl, metadata);
6736                                                    }
6737                                                    else
6738                                                    {
6739                                                        ignore_containing_context = true;
6740                                                    }
6741                                                }
6742                                            }
6743                                            else
6744                                            {
6745                                                // We were asked to parse the type for a method in a class, yet the
6746                                                // class hasn't been asked to complete itself through the
6747                                                // clang::ExternalASTSource protocol, so we need to just have the
6748                                                // class complete itself and do things the right way, then our
6749                                                // DIE should then have an entry in the m_die_to_type map. First
6750                                                // we need to modify the m_die_to_type so it doesn't think we are
6751                                                // trying to parse this DIE anymore...
6752                                                m_die_to_type[die] = NULL;
6753
6754                                                // Now we get the full type to force our class type to complete itself
6755                                                // using the clang::ExternalASTSource protocol which will parse all
6756                                                // base classes and all methods (including the method for this DIE).
6757                                                class_type->GetClangFullType();
6758
6759                                                // The type for this DIE should have been filled in the function call above
6760                                                type_ptr = m_die_to_type[die];
6761                                                if (type_ptr && type_ptr != DIE_IS_BEING_PARSED)
6762                                                {
6763                                                    type_sp = type_ptr->shared_from_this();
6764                                                    break;
6765                                                }
6766
6767                                                // FIXME This is fixing some even uglier behavior but we really need to
6768                                                // uniq the methods of each class as well as the class itself.
6769                                                // <rdar://problem/11240464>
6770                                                type_handled = true;
6771                                            }
6772                                        }
6773                                    }
6774                                }
6775                            }
6776                        }
6777
6778                        if (!type_handled)
6779                        {
6780                            // We just have a function that isn't part of a class
6781                            clang::FunctionDecl *function_decl = ast.CreateFunctionDeclaration (ignore_containing_context ? GetClangASTContext().GetTranslationUnitDecl() : containing_decl_ctx,
6782                                                                                                type_name_cstr,
6783                                                                                                clang_type,
6784                                                                                                storage,
6785                                                                                                is_inline);
6786
6787//                            if (template_param_infos.GetSize() > 0)
6788//                            {
6789//                                clang::FunctionTemplateDecl *func_template_decl = ast.CreateFunctionTemplateDecl (containing_decl_ctx,
6790//                                                                                                                  function_decl,
6791//                                                                                                                  type_name_cstr,
6792//                                                                                                                  template_param_infos);
6793//
6794//                                ast.CreateFunctionTemplateSpecializationInfo (function_decl,
6795//                                                                              func_template_decl,
6796//                                                                              template_param_infos);
6797//                            }
6798                            // Add the decl to our DIE to decl context map
6799                            assert (function_decl);
6800                            LinkDeclContextToDIE(function_decl, die);
6801                            if (!function_param_decls.empty())
6802                                ast.SetFunctionParameters (function_decl,
6803                                                           &function_param_decls.front(),
6804                                                           function_param_decls.size());
6805
6806                            ClangASTMetadata metadata;
6807                            metadata.SetUserID(MakeUserID(die->GetOffset()));
6808
6809                            if (!object_pointer_name.empty())
6810                            {
6811                                metadata.SetObjectPtrName(object_pointer_name.c_str());
6812                                if (log)
6813                                    log->Printf ("Setting object pointer name: %s on function object %p.",
6814                                                 object_pointer_name.c_str(),
6815                                                function_decl);
6816                            }
6817                            GetClangASTContext().SetMetadata (function_decl, metadata);
6818                        }
6819                    }
6820                    type_sp.reset( new Type (MakeUserID(die->GetOffset()),
6821                                             this,
6822                                             type_name_const_str,
6823                                             0,
6824                                             NULL,
6825                                             LLDB_INVALID_UID,
6826                                             Type::eEncodingIsUID,
6827                                             &decl,
6828                                             clang_type,
6829                                             Type::eResolveStateFull));
6830                    assert(type_sp.get());
6831                }
6832                break;
6833
6834            case DW_TAG_array_type:
6835                {
6836                    // Set a bit that lets us know that we are currently parsing this
6837                    m_die_to_type[die] = DIE_IS_BEING_PARSED;
6838
6839                    lldb::user_id_t type_die_offset = DW_INVALID_OFFSET;
6840                    int64_t first_index = 0;
6841                    uint32_t byte_stride = 0;
6842                    uint32_t bit_stride = 0;
6843                    bool is_vector = false;
6844                    const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes);
6845
6846                    if (num_attributes > 0)
6847                    {
6848                        uint32_t i;
6849                        for (i=0; i<num_attributes; ++i)
6850                        {
6851                            attr = attributes.AttributeAtIndex(i);
6852                            DWARFFormValue form_value;
6853                            if (attributes.ExtractFormValueAtIndex(this, i, form_value))
6854                            {
6855                                switch (attr)
6856                                {
6857                                case DW_AT_decl_file:   decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
6858                                case DW_AT_decl_line:   decl.SetLine(form_value.Unsigned()); break;
6859                                case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
6860                                case DW_AT_name:
6861                                    type_name_cstr = form_value.AsCString(&get_debug_str_data());
6862                                    type_name_const_str.SetCString(type_name_cstr);
6863                                    break;
6864
6865                                case DW_AT_type:            type_die_offset = form_value.Reference(dwarf_cu); break;
6866                                case DW_AT_byte_size:       break; // byte_size = form_value.Unsigned(); break;
6867                                case DW_AT_byte_stride:     byte_stride = form_value.Unsigned(); break;
6868                                case DW_AT_bit_stride:      bit_stride = form_value.Unsigned(); break;
6869                                case DW_AT_GNU_vector:      is_vector = form_value.Boolean(); break;
6870                                case DW_AT_accessibility:   break; // accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
6871                                case DW_AT_declaration:     break; // is_forward_declaration = form_value.Boolean(); break;
6872                                case DW_AT_allocated:
6873                                case DW_AT_associated:
6874                                case DW_AT_data_location:
6875                                case DW_AT_description:
6876                                case DW_AT_ordering:
6877                                case DW_AT_start_scope:
6878                                case DW_AT_visibility:
6879                                case DW_AT_specification:
6880                                case DW_AT_abstract_origin:
6881                                case DW_AT_sibling:
6882                                    break;
6883                                }
6884                            }
6885                        }
6886
6887                        DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", MakeUserID(die->GetOffset()), DW_TAG_value_to_name(tag), type_name_cstr);
6888
6889                        Type *element_type = ResolveTypeUID(type_die_offset);
6890
6891                        if (element_type)
6892                        {
6893                            std::vector<uint64_t> element_orders;
6894                            ParseChildArrayInfo(sc, dwarf_cu, die, first_index, element_orders, byte_stride, bit_stride);
6895                            if (byte_stride == 0 && bit_stride == 0)
6896                                byte_stride = element_type->GetByteSize();
6897                            ClangASTType array_element_type = element_type->GetClangForwardType();
6898                            uint64_t array_element_bit_stride = byte_stride * 8 + bit_stride;
6899                            uint64_t num_elements = 0;
6900                            std::vector<uint64_t>::const_reverse_iterator pos;
6901                            std::vector<uint64_t>::const_reverse_iterator end = element_orders.rend();
6902                            for (pos = element_orders.rbegin(); pos != end; ++pos)
6903                            {
6904                                num_elements = *pos;
6905                                clang_type = ast.CreateArrayType (array_element_type,
6906                                                                  num_elements,
6907                                                                  is_vector);
6908                                array_element_type = clang_type;
6909                                array_element_bit_stride = num_elements ? array_element_bit_stride * num_elements : array_element_bit_stride;
6910                            }
6911                            ConstString empty_name;
6912                            type_sp.reset( new Type (MakeUserID(die->GetOffset()),
6913                                                     this,
6914                                                     empty_name,
6915                                                     array_element_bit_stride / 8,
6916                                                     NULL,
6917                                                     type_die_offset,
6918                                                     Type::eEncodingIsUID,
6919                                                     &decl,
6920                                                     clang_type,
6921                                                     Type::eResolveStateFull));
6922                            type_sp->SetEncodingType (element_type);
6923                        }
6924                    }
6925                }
6926                break;
6927
6928            case DW_TAG_ptr_to_member_type:
6929                {
6930                    dw_offset_t type_die_offset = DW_INVALID_OFFSET;
6931                    dw_offset_t containing_type_die_offset = DW_INVALID_OFFSET;
6932
6933                    const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes);
6934
6935                    if (num_attributes > 0) {
6936                        uint32_t i;
6937                        for (i=0; i<num_attributes; ++i)
6938                        {
6939                            attr = attributes.AttributeAtIndex(i);
6940                            DWARFFormValue form_value;
6941                            if (attributes.ExtractFormValueAtIndex(this, i, form_value))
6942                            {
6943                                switch (attr)
6944                                {
6945                                    case DW_AT_type:
6946                                        type_die_offset = form_value.Reference(dwarf_cu); break;
6947                                    case DW_AT_containing_type:
6948                                        containing_type_die_offset = form_value.Reference(dwarf_cu); break;
6949                                }
6950                            }
6951                        }
6952
6953                        Type *pointee_type = ResolveTypeUID(type_die_offset);
6954                        Type *class_type = ResolveTypeUID(containing_type_die_offset);
6955
6956                        ClangASTType pointee_clang_type = pointee_type->GetClangForwardType();
6957                        ClangASTType class_clang_type = class_type->GetClangLayoutType();
6958
6959                        clang_type = pointee_clang_type.CreateMemberPointerType(class_clang_type);
6960
6961                        byte_size = clang_type.GetByteSize();
6962
6963                        type_sp.reset( new Type (MakeUserID(die->GetOffset()),
6964                                                 this,
6965                                                 type_name_const_str,
6966                                                 byte_size,
6967                                                 NULL,
6968                                                 LLDB_INVALID_UID,
6969                                                 Type::eEncodingIsUID,
6970                                                 NULL,
6971                                                 clang_type,
6972                                                 Type::eResolveStateForward));
6973                    }
6974
6975                    break;
6976                }
6977            default:
6978                GetObjectFile()->GetModule()->ReportError ("{0x%8.8x}: unhandled type tag 0x%4.4x (%s), please file a bug and attach the file at the start of this error message",
6979                                                           die->GetOffset(),
6980                                                           tag,
6981                                                           DW_TAG_value_to_name(tag));
6982                break;
6983            }
6984
6985            if (type_sp.get())
6986            {
6987                const DWARFDebugInfoEntry *sc_parent_die = GetParentSymbolContextDIE(die);
6988                dw_tag_t sc_parent_tag = sc_parent_die ? sc_parent_die->Tag() : 0;
6989
6990                SymbolContextScope * symbol_context_scope = NULL;
6991                if (sc_parent_tag == DW_TAG_compile_unit)
6992                {
6993                    symbol_context_scope = sc.comp_unit;
6994                }
6995                else if (sc.function != NULL)
6996                {
6997                    symbol_context_scope = sc.function->GetBlock(true).FindBlockByID(MakeUserID(sc_parent_die->GetOffset()));
6998                    if (symbol_context_scope == NULL)
6999                        symbol_context_scope = sc.function;
7000                }
7001
7002                if (symbol_context_scope != NULL)
7003                {
7004                    type_sp->SetSymbolContextScope(symbol_context_scope);
7005                }
7006
7007                // We are ready to put this type into the uniqued list up at the module level
7008                type_list->Insert (type_sp);
7009
7010                m_die_to_type[die] = type_sp.get();
7011            }
7012        }
7013        else if (type_ptr != DIE_IS_BEING_PARSED)
7014        {
7015            type_sp = type_ptr->shared_from_this();
7016        }
7017    }
7018    return type_sp;
7019}
7020
7021size_t
7022SymbolFileDWARF::ParseTypes
7023(
7024    const SymbolContext& sc,
7025    DWARFCompileUnit* dwarf_cu,
7026    const DWARFDebugInfoEntry *die,
7027    bool parse_siblings,
7028    bool parse_children
7029)
7030{
7031    size_t types_added = 0;
7032    while (die != NULL)
7033    {
7034        bool type_is_new = false;
7035        if (ParseType(sc, dwarf_cu, die, &type_is_new).get())
7036        {
7037            if (type_is_new)
7038                ++types_added;
7039        }
7040
7041        if (parse_children && die->HasChildren())
7042        {
7043            if (die->Tag() == DW_TAG_subprogram)
7044            {
7045                SymbolContext child_sc(sc);
7046                child_sc.function = sc.comp_unit->FindFunctionByUID(MakeUserID(die->GetOffset())).get();
7047                types_added += ParseTypes(child_sc, dwarf_cu, die->GetFirstChild(), true, true);
7048            }
7049            else
7050                types_added += ParseTypes(sc, dwarf_cu, die->GetFirstChild(), true, true);
7051        }
7052
7053        if (parse_siblings)
7054            die = die->GetSibling();
7055        else
7056            die = NULL;
7057    }
7058    return types_added;
7059}
7060
7061
7062size_t
7063SymbolFileDWARF::ParseFunctionBlocks (const SymbolContext &sc)
7064{
7065    assert(sc.comp_unit && sc.function);
7066    size_t functions_added = 0;
7067    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
7068    if (dwarf_cu)
7069    {
7070        dw_offset_t function_die_offset = sc.function->GetID();
7071        const DWARFDebugInfoEntry *function_die = dwarf_cu->GetDIEPtr(function_die_offset);
7072        if (function_die)
7073        {
7074            ParseFunctionBlocks(sc, &sc.function->GetBlock (false), dwarf_cu, function_die, LLDB_INVALID_ADDRESS, 0);
7075        }
7076    }
7077
7078    return functions_added;
7079}
7080
7081
7082size_t
7083SymbolFileDWARF::ParseTypes (const SymbolContext &sc)
7084{
7085    // At least a compile unit must be valid
7086    assert(sc.comp_unit);
7087    size_t types_added = 0;
7088    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
7089    if (dwarf_cu)
7090    {
7091        if (sc.function)
7092        {
7093            dw_offset_t function_die_offset = sc.function->GetID();
7094            const DWARFDebugInfoEntry *func_die = dwarf_cu->GetDIEPtr(function_die_offset);
7095            if (func_die && func_die->HasChildren())
7096            {
7097                types_added = ParseTypes(sc, dwarf_cu, func_die->GetFirstChild(), true, true);
7098            }
7099        }
7100        else
7101        {
7102            const DWARFDebugInfoEntry *dwarf_cu_die = dwarf_cu->DIE();
7103            if (dwarf_cu_die && dwarf_cu_die->HasChildren())
7104            {
7105                types_added = ParseTypes(sc, dwarf_cu, dwarf_cu_die->GetFirstChild(), true, true);
7106            }
7107        }
7108    }
7109
7110    return types_added;
7111}
7112
7113size_t
7114SymbolFileDWARF::ParseVariablesForContext (const SymbolContext& sc)
7115{
7116    if (sc.comp_unit != NULL)
7117    {
7118        DWARFDebugInfo* info = DebugInfo();
7119        if (info == NULL)
7120            return 0;
7121
7122        if (sc.function)
7123        {
7124            DWARFCompileUnit* dwarf_cu = info->GetCompileUnitContainingDIE(sc.function->GetID()).get();
7125
7126            if (dwarf_cu == NULL)
7127                return 0;
7128
7129            const DWARFDebugInfoEntry *function_die = dwarf_cu->GetDIEPtr(sc.function->GetID());
7130
7131            dw_addr_t func_lo_pc = function_die->GetAttributeValueAsUnsigned (this, dwarf_cu, DW_AT_low_pc, LLDB_INVALID_ADDRESS);
7132            if (func_lo_pc != LLDB_INVALID_ADDRESS)
7133            {
7134                const size_t num_variables = ParseVariables(sc, dwarf_cu, func_lo_pc, function_die->GetFirstChild(), true, true);
7135
7136                // Let all blocks know they have parse all their variables
7137                sc.function->GetBlock (false).SetDidParseVariables (true, true);
7138                return num_variables;
7139            }
7140        }
7141        else if (sc.comp_unit)
7142        {
7143            DWARFCompileUnit* dwarf_cu = info->GetCompileUnit(sc.comp_unit->GetID()).get();
7144
7145            if (dwarf_cu == NULL)
7146                return 0;
7147
7148            uint32_t vars_added = 0;
7149            VariableListSP variables (sc.comp_unit->GetVariableList(false));
7150
7151            if (variables.get() == NULL)
7152            {
7153                variables.reset(new VariableList());
7154                sc.comp_unit->SetVariableList(variables);
7155
7156                DWARFCompileUnit* match_dwarf_cu = NULL;
7157                const DWARFDebugInfoEntry* die = NULL;
7158                DIEArray die_offsets;
7159                if (m_using_apple_tables)
7160                {
7161                    if (m_apple_names_ap.get())
7162                    {
7163                        DWARFMappedHash::DIEInfoArray hash_data_array;
7164                        if (m_apple_names_ap->AppendAllDIEsInRange (dwarf_cu->GetOffset(),
7165                                                                    dwarf_cu->GetNextCompileUnitOffset(),
7166                                                                    hash_data_array))
7167                        {
7168                            DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets);
7169                        }
7170                    }
7171                }
7172                else
7173                {
7174                    // Index if we already haven't to make sure the compile units
7175                    // get indexed and make their global DIE index list
7176                    if (!m_indexed)
7177                        Index ();
7178
7179                    m_global_index.FindAllEntriesForCompileUnit (dwarf_cu->GetOffset(),
7180                                                                 dwarf_cu->GetNextCompileUnitOffset(),
7181                                                                 die_offsets);
7182                }
7183
7184                const size_t num_matches = die_offsets.size();
7185                if (num_matches)
7186                {
7187                    DWARFDebugInfo* debug_info = DebugInfo();
7188                    for (size_t i=0; i<num_matches; ++i)
7189                    {
7190                        const dw_offset_t die_offset = die_offsets[i];
7191                        die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &match_dwarf_cu);
7192                        if (die)
7193                        {
7194                            VariableSP var_sp (ParseVariableDIE(sc, dwarf_cu, die, LLDB_INVALID_ADDRESS));
7195                            if (var_sp)
7196                            {
7197                                variables->AddVariableIfUnique (var_sp);
7198                                ++vars_added;
7199                            }
7200                        }
7201                        else
7202                        {
7203                            if (m_using_apple_tables)
7204                            {
7205                                GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x)\n", die_offset);
7206                            }
7207                        }
7208
7209                    }
7210                }
7211            }
7212            return vars_added;
7213        }
7214    }
7215    return 0;
7216}
7217
7218
7219VariableSP
7220SymbolFileDWARF::ParseVariableDIE
7221(
7222    const SymbolContext& sc,
7223    DWARFCompileUnit* dwarf_cu,
7224    const DWARFDebugInfoEntry *die,
7225    const lldb::addr_t func_low_pc
7226)
7227{
7228
7229    VariableSP var_sp (m_die_to_variable_sp[die]);
7230    if (var_sp)
7231        return var_sp;  // Already been parsed!
7232
7233    const dw_tag_t tag = die->Tag();
7234
7235    if ((tag == DW_TAG_variable) ||
7236        (tag == DW_TAG_constant) ||
7237        (tag == DW_TAG_formal_parameter && sc.function))
7238    {
7239        DWARFDebugInfoEntry::Attributes attributes;
7240        const size_t num_attributes = die->GetAttributes(this, dwarf_cu, NULL, attributes);
7241        if (num_attributes > 0)
7242        {
7243            const char *name = NULL;
7244            const char *mangled = NULL;
7245            Declaration decl;
7246            uint32_t i;
7247            lldb::user_id_t type_uid = LLDB_INVALID_UID;
7248            DWARFExpression location;
7249            bool is_external = false;
7250            bool is_artificial = false;
7251            bool location_is_const_value_data = false;
7252            bool has_explicit_location = false;
7253            //AccessType accessibility = eAccessNone;
7254
7255            for (i=0; i<num_attributes; ++i)
7256            {
7257                dw_attr_t attr = attributes.AttributeAtIndex(i);
7258                DWARFFormValue form_value;
7259                if (attributes.ExtractFormValueAtIndex(this, i, form_value))
7260                {
7261                    switch (attr)
7262                    {
7263                    case DW_AT_decl_file:   decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
7264                    case DW_AT_decl_line:   decl.SetLine(form_value.Unsigned()); break;
7265                    case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
7266                    case DW_AT_name:        name = form_value.AsCString(&get_debug_str_data()); break;
7267                    case DW_AT_linkage_name:
7268                    case DW_AT_MIPS_linkage_name: mangled = form_value.AsCString(&get_debug_str_data()); break;
7269                    case DW_AT_type:        type_uid = form_value.Reference(dwarf_cu); break;
7270                    case DW_AT_external:    is_external = form_value.Boolean(); break;
7271                    case DW_AT_const_value:
7272                        // If we have already found a DW_AT_location attribute, ignore this attribute.
7273                        if (!has_explicit_location)
7274                        {
7275                            location_is_const_value_data = true;
7276                            // The constant value will be either a block, a data value or a string.
7277                            const DataExtractor& debug_info_data = get_debug_info_data();
7278                            if (DWARFFormValue::IsBlockForm(form_value.Form()))
7279                            {
7280                                // Retrieve the value as a block expression.
7281                                uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();
7282                                uint32_t block_length = form_value.Unsigned();
7283                                location.CopyOpcodeData(debug_info_data, block_offset, block_length);
7284                            }
7285                            else if (DWARFFormValue::IsDataForm(form_value.Form()))
7286                            {
7287                                // Retrieve the value as a data expression.
7288                                const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize());
7289                                uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
7290                                uint32_t data_length = fixed_form_sizes[form_value.Form()];
7291                                location.CopyOpcodeData(debug_info_data, data_offset, data_length);
7292                            }
7293                            else
7294                            {
7295                                // Retrieve the value as a string expression.
7296                                if (form_value.Form() == DW_FORM_strp)
7297                                {
7298                                    const uint8_t *fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize (dwarf_cu->GetAddressByteSize());
7299                                    uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
7300                                    uint32_t data_length = fixed_form_sizes[form_value.Form()];
7301                                    location.CopyOpcodeData(debug_info_data, data_offset, data_length);
7302                                }
7303                                else
7304                                {
7305                                    const char *str = form_value.AsCString(&debug_info_data);
7306                                    uint32_t string_offset = str - (const char *)debug_info_data.GetDataStart();
7307                                    uint32_t string_length = strlen(str) + 1;
7308                                    location.CopyOpcodeData(debug_info_data, string_offset, string_length);
7309                                }
7310                            }
7311                        }
7312                        break;
7313                    case DW_AT_location:
7314                        {
7315                            location_is_const_value_data = false;
7316                            has_explicit_location = true;
7317                            if (form_value.BlockData())
7318                            {
7319                                const DataExtractor& debug_info_data = get_debug_info_data();
7320
7321                                uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();
7322                                uint32_t block_length = form_value.Unsigned();
7323                                location.CopyOpcodeData(get_debug_info_data(), block_offset, block_length);
7324                            }
7325                            else
7326                            {
7327                                const DataExtractor&    debug_loc_data = get_debug_loc_data();
7328                                const dw_offset_t debug_loc_offset = form_value.Unsigned();
7329
7330                                size_t loc_list_length = DWARFLocationList::Size(debug_loc_data, debug_loc_offset);
7331                                if (loc_list_length > 0)
7332                                {
7333                                    location.CopyOpcodeData(debug_loc_data, debug_loc_offset, loc_list_length);
7334                                    assert (func_low_pc != LLDB_INVALID_ADDRESS);
7335                                    location.SetLocationListSlide (func_low_pc - dwarf_cu->GetBaseAddress());
7336                                }
7337                            }
7338                        }
7339                        break;
7340
7341                    case DW_AT_artificial:      is_artificial = form_value.Boolean(); break;
7342                    case DW_AT_accessibility:   break; //accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
7343                    case DW_AT_declaration:
7344                    case DW_AT_description:
7345                    case DW_AT_endianity:
7346                    case DW_AT_segment:
7347                    case DW_AT_start_scope:
7348                    case DW_AT_visibility:
7349                    default:
7350                    case DW_AT_abstract_origin:
7351                    case DW_AT_sibling:
7352                    case DW_AT_specification:
7353                        break;
7354                    }
7355                }
7356            }
7357
7358            ValueType scope = eValueTypeInvalid;
7359
7360            const DWARFDebugInfoEntry *sc_parent_die = GetParentSymbolContextDIE(die);
7361            dw_tag_t parent_tag = sc_parent_die ? sc_parent_die->Tag() : 0;
7362            SymbolContextScope * symbol_context_scope = NULL;
7363
7364            // DWARF doesn't specify if a DW_TAG_variable is a local, global
7365            // or static variable, so we have to do a little digging by
7366            // looking at the location of a varaible to see if it contains
7367            // a DW_OP_addr opcode _somewhere_ in the definition. I say
7368            // somewhere because clang likes to combine small global variables
7369            // into the same symbol and have locations like:
7370            // DW_OP_addr(0x1000), DW_OP_constu(2), DW_OP_plus
7371            // So if we don't have a DW_TAG_formal_parameter, we can look at
7372            // the location to see if it contains a DW_OP_addr opcode, and
7373            // then we can correctly classify  our variables.
7374            if (tag == DW_TAG_formal_parameter)
7375                scope = eValueTypeVariableArgument;
7376            else
7377            {
7378                bool op_error = false;
7379                // Check if the location has a DW_OP_addr with any address value...
7380                lldb::addr_t location_DW_OP_addr = LLDB_INVALID_ADDRESS;
7381                if (!location_is_const_value_data)
7382                {
7383                    location_DW_OP_addr = location.GetLocation_DW_OP_addr (0, op_error);
7384                    if (op_error)
7385                    {
7386                        StreamString strm;
7387                        location.DumpLocationForAddress (&strm, eDescriptionLevelFull, 0, 0, NULL);
7388                        GetObjectFile()->GetModule()->ReportError ("0x%8.8x: %s has an invalid location: %s", die->GetOffset(), DW_TAG_value_to_name(die->Tag()), strm.GetString().c_str());
7389                    }
7390                }
7391
7392                if (location_DW_OP_addr != LLDB_INVALID_ADDRESS)
7393                {
7394                    if (is_external)
7395                        scope = eValueTypeVariableGlobal;
7396                    else
7397                        scope = eValueTypeVariableStatic;
7398
7399
7400                    SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile ();
7401
7402                    if (debug_map_symfile)
7403                    {
7404                        // When leaving the DWARF in the .o files on darwin,
7405                        // when we have a global variable that wasn't initialized,
7406                        // the .o file might not have allocated a virtual
7407                        // address for the global variable. In this case it will
7408                        // have created a symbol for the global variable
7409                        // that is undefined/data and external and the value will
7410                        // be the byte size of the variable. When we do the
7411                        // address map in SymbolFileDWARFDebugMap we rely on
7412                        // having an address, we need to do some magic here
7413                        // so we can get the correct address for our global
7414                        // variable. The address for all of these entries
7415                        // will be zero, and there will be an undefined symbol
7416                        // in this object file, and the executable will have
7417                        // a matching symbol with a good address. So here we
7418                        // dig up the correct address and replace it in the
7419                        // location for the variable, and set the variable's
7420                        // symbol context scope to be that of the main executable
7421                        // so the file address will resolve correctly.
7422                        bool linked_oso_file_addr = false;
7423                        if (is_external && location_DW_OP_addr == 0)
7424                        {
7425                            // we have a possible uninitialized extern global
7426                            ConstString const_name(mangled ? mangled : name);
7427                            ObjectFile *debug_map_objfile = debug_map_symfile->GetObjectFile();
7428                            if (debug_map_objfile)
7429                            {
7430                                Symtab *debug_map_symtab = debug_map_objfile->GetSymtab();
7431                                if (debug_map_symtab)
7432                                {
7433                                    Symbol *exe_symbol = debug_map_symtab->FindFirstSymbolWithNameAndType (const_name,
7434                                                                                                           eSymbolTypeData,
7435                                                                                                           Symtab::eDebugYes,
7436                                                                                                           Symtab::eVisibilityExtern);
7437                                    if (exe_symbol)
7438                                    {
7439                                        if (exe_symbol->ValueIsAddress())
7440                                        {
7441                                            const addr_t exe_file_addr = exe_symbol->GetAddress().GetFileAddress();
7442                                            if (exe_file_addr != LLDB_INVALID_ADDRESS)
7443                                            {
7444                                                if (location.Update_DW_OP_addr (exe_file_addr))
7445                                                {
7446                                                    linked_oso_file_addr = true;
7447                                                    symbol_context_scope = exe_symbol;
7448                                                }
7449                                            }
7450                                        }
7451                                    }
7452                                }
7453                            }
7454                        }
7455
7456                        if (!linked_oso_file_addr)
7457                        {
7458                            // The DW_OP_addr is not zero, but it contains a .o file address which
7459                            // needs to be linked up correctly.
7460                            const lldb::addr_t exe_file_addr = debug_map_symfile->LinkOSOFileAddress(this, location_DW_OP_addr);
7461                            if (exe_file_addr != LLDB_INVALID_ADDRESS)
7462                            {
7463                                // Update the file address for this variable
7464                                location.Update_DW_OP_addr (exe_file_addr);
7465                            }
7466                            else
7467                            {
7468                                // Variable didn't make it into the final executable
7469                                return var_sp;
7470                            }
7471                        }
7472                    }
7473                }
7474                else
7475                {
7476                    scope = eValueTypeVariableLocal;
7477                }
7478            }
7479
7480            if (symbol_context_scope == NULL)
7481            {
7482                switch (parent_tag)
7483                {
7484                case DW_TAG_subprogram:
7485                case DW_TAG_inlined_subroutine:
7486                case DW_TAG_lexical_block:
7487                    if (sc.function)
7488                    {
7489                        symbol_context_scope = sc.function->GetBlock(true).FindBlockByID(MakeUserID(sc_parent_die->GetOffset()));
7490                        if (symbol_context_scope == NULL)
7491                            symbol_context_scope = sc.function;
7492                    }
7493                    break;
7494
7495                default:
7496                    symbol_context_scope = sc.comp_unit;
7497                    break;
7498                }
7499            }
7500
7501            if (symbol_context_scope)
7502            {
7503                var_sp.reset (new Variable (MakeUserID(die->GetOffset()),
7504                                            name,
7505                                            mangled,
7506                                            SymbolFileTypeSP (new SymbolFileType(*this, type_uid)),
7507                                            scope,
7508                                            symbol_context_scope,
7509                                            &decl,
7510                                            location,
7511                                            is_external,
7512                                            is_artificial));
7513
7514                var_sp->SetLocationIsConstantValueData (location_is_const_value_data);
7515            }
7516            else
7517            {
7518                // Not ready to parse this variable yet. It might be a global
7519                // or static variable that is in a function scope and the function
7520                // in the symbol context wasn't filled in yet
7521                return var_sp;
7522            }
7523        }
7524        // Cache var_sp even if NULL (the variable was just a specification or
7525        // was missing vital information to be able to be displayed in the debugger
7526        // (missing location due to optimization, etc)) so we don't re-parse
7527        // this DIE over and over later...
7528        m_die_to_variable_sp[die] = var_sp;
7529    }
7530    return var_sp;
7531}
7532
7533
7534const DWARFDebugInfoEntry *
7535SymbolFileDWARF::FindBlockContainingSpecification (dw_offset_t func_die_offset,
7536                                                   dw_offset_t spec_block_die_offset,
7537                                                   DWARFCompileUnit **result_die_cu_handle)
7538{
7539    // Give the concrete function die specified by "func_die_offset", find the
7540    // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
7541    // to "spec_block_die_offset"
7542    DWARFDebugInfo* info = DebugInfo();
7543
7544    const DWARFDebugInfoEntry *die = info->GetDIEPtrWithCompileUnitHint(func_die_offset, result_die_cu_handle);
7545    if (die)
7546    {
7547        assert (*result_die_cu_handle);
7548        return FindBlockContainingSpecification (*result_die_cu_handle, die, spec_block_die_offset, result_die_cu_handle);
7549    }
7550    return NULL;
7551}
7552
7553
7554const DWARFDebugInfoEntry *
7555SymbolFileDWARF::FindBlockContainingSpecification(DWARFCompileUnit* dwarf_cu,
7556                                                  const DWARFDebugInfoEntry *die,
7557                                                  dw_offset_t spec_block_die_offset,
7558                                                  DWARFCompileUnit **result_die_cu_handle)
7559{
7560    if (die)
7561    {
7562        switch (die->Tag())
7563        {
7564        case DW_TAG_subprogram:
7565        case DW_TAG_inlined_subroutine:
7566        case DW_TAG_lexical_block:
7567            {
7568                if (die->GetAttributeValueAsReference (this, dwarf_cu, DW_AT_specification, DW_INVALID_OFFSET) == spec_block_die_offset)
7569                {
7570                    *result_die_cu_handle = dwarf_cu;
7571                    return die;
7572                }
7573
7574                if (die->GetAttributeValueAsReference (this, dwarf_cu, DW_AT_abstract_origin, DW_INVALID_OFFSET) == spec_block_die_offset)
7575                {
7576                    *result_die_cu_handle = dwarf_cu;
7577                    return die;
7578                }
7579            }
7580            break;
7581        }
7582
7583        // Give the concrete function die specified by "func_die_offset", find the
7584        // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
7585        // to "spec_block_die_offset"
7586        for (const DWARFDebugInfoEntry *child_die = die->GetFirstChild(); child_die != NULL; child_die = child_die->GetSibling())
7587        {
7588            const DWARFDebugInfoEntry *result_die = FindBlockContainingSpecification (dwarf_cu,
7589                                                                                      child_die,
7590                                                                                      spec_block_die_offset,
7591                                                                                      result_die_cu_handle);
7592            if (result_die)
7593                return result_die;
7594        }
7595    }
7596
7597    *result_die_cu_handle = NULL;
7598    return NULL;
7599}
7600
7601size_t
7602SymbolFileDWARF::ParseVariables
7603(
7604    const SymbolContext& sc,
7605    DWARFCompileUnit* dwarf_cu,
7606    const lldb::addr_t func_low_pc,
7607    const DWARFDebugInfoEntry *orig_die,
7608    bool parse_siblings,
7609    bool parse_children,
7610    VariableList* cc_variable_list
7611)
7612{
7613    if (orig_die == NULL)
7614        return 0;
7615
7616    VariableListSP variable_list_sp;
7617
7618    size_t vars_added = 0;
7619    const DWARFDebugInfoEntry *die = orig_die;
7620    while (die != NULL)
7621    {
7622        dw_tag_t tag = die->Tag();
7623
7624        // Check to see if we have already parsed this variable or constant?
7625        if (m_die_to_variable_sp[die])
7626        {
7627            if (cc_variable_list)
7628                cc_variable_list->AddVariableIfUnique (m_die_to_variable_sp[die]);
7629        }
7630        else
7631        {
7632            // We haven't already parsed it, lets do that now.
7633            if ((tag == DW_TAG_variable) ||
7634                (tag == DW_TAG_constant) ||
7635                (tag == DW_TAG_formal_parameter && sc.function))
7636            {
7637                if (variable_list_sp.get() == NULL)
7638                {
7639                    const DWARFDebugInfoEntry *sc_parent_die = GetParentSymbolContextDIE(orig_die);
7640                    dw_tag_t parent_tag = sc_parent_die ? sc_parent_die->Tag() : 0;
7641                    switch (parent_tag)
7642                    {
7643                        case DW_TAG_compile_unit:
7644                            if (sc.comp_unit != NULL)
7645                            {
7646                                variable_list_sp = sc.comp_unit->GetVariableList(false);
7647                                if (variable_list_sp.get() == NULL)
7648                                {
7649                                    variable_list_sp.reset(new VariableList());
7650                                    sc.comp_unit->SetVariableList(variable_list_sp);
7651                                }
7652                            }
7653                            else
7654                            {
7655                                GetObjectFile()->GetModule()->ReportError ("parent 0x%8.8" PRIx64 " %s with no valid compile unit in symbol context for 0x%8.8" PRIx64 " %s.\n",
7656                                                                           MakeUserID(sc_parent_die->GetOffset()),
7657                                                                           DW_TAG_value_to_name (parent_tag),
7658                                                                           MakeUserID(orig_die->GetOffset()),
7659                                                                           DW_TAG_value_to_name (orig_die->Tag()));
7660                            }
7661                            break;
7662
7663                        case DW_TAG_subprogram:
7664                        case DW_TAG_inlined_subroutine:
7665                        case DW_TAG_lexical_block:
7666                            if (sc.function != NULL)
7667                            {
7668                                // Check to see if we already have parsed the variables for the given scope
7669
7670                                Block *block = sc.function->GetBlock(true).FindBlockByID(MakeUserID(sc_parent_die->GetOffset()));
7671                                if (block == NULL)
7672                                {
7673                                    // This must be a specification or abstract origin with
7674                                    // a concrete block couterpart in the current function. We need
7675                                    // to find the concrete block so we can correctly add the
7676                                    // variable to it
7677                                    DWARFCompileUnit *concrete_block_die_cu = dwarf_cu;
7678                                    const DWARFDebugInfoEntry *concrete_block_die = FindBlockContainingSpecification (sc.function->GetID(),
7679                                                                                                                      sc_parent_die->GetOffset(),
7680                                                                                                                      &concrete_block_die_cu);
7681                                    if (concrete_block_die)
7682                                        block = sc.function->GetBlock(true).FindBlockByID(MakeUserID(concrete_block_die->GetOffset()));
7683                                }
7684
7685                                if (block != NULL)
7686                                {
7687                                    const bool can_create = false;
7688                                    variable_list_sp = block->GetBlockVariableList (can_create);
7689                                    if (variable_list_sp.get() == NULL)
7690                                    {
7691                                        variable_list_sp.reset(new VariableList());
7692                                        block->SetVariableList(variable_list_sp);
7693                                    }
7694                                }
7695                            }
7696                            break;
7697
7698                        default:
7699                             GetObjectFile()->GetModule()->ReportError ("didn't find appropriate parent DIE for variable list for 0x%8.8" PRIx64 " %s.\n",
7700                                                                        MakeUserID(orig_die->GetOffset()),
7701                                                                        DW_TAG_value_to_name (orig_die->Tag()));
7702                            break;
7703                    }
7704                }
7705
7706                if (variable_list_sp)
7707                {
7708                    VariableSP var_sp (ParseVariableDIE(sc, dwarf_cu, die, func_low_pc));
7709                    if (var_sp)
7710                    {
7711                        variable_list_sp->AddVariableIfUnique (var_sp);
7712                        if (cc_variable_list)
7713                            cc_variable_list->AddVariableIfUnique (var_sp);
7714                        ++vars_added;
7715                    }
7716                }
7717            }
7718        }
7719
7720        bool skip_children = (sc.function == NULL && tag == DW_TAG_subprogram);
7721
7722        if (!skip_children && parse_children && die->HasChildren())
7723        {
7724            vars_added += ParseVariables(sc, dwarf_cu, func_low_pc, die->GetFirstChild(), true, true, cc_variable_list);
7725        }
7726
7727        if (parse_siblings)
7728            die = die->GetSibling();
7729        else
7730            die = NULL;
7731    }
7732    return vars_added;
7733}
7734
7735//------------------------------------------------------------------
7736// PluginInterface protocol
7737//------------------------------------------------------------------
7738ConstString
7739SymbolFileDWARF::GetPluginName()
7740{
7741    return GetPluginNameStatic();
7742}
7743
7744uint32_t
7745SymbolFileDWARF::GetPluginVersion()
7746{
7747    return 1;
7748}
7749
7750void
7751SymbolFileDWARF::CompleteTagDecl (void *baton, clang::TagDecl *decl)
7752{
7753    SymbolFileDWARF *symbol_file_dwarf = (SymbolFileDWARF *)baton;
7754    ClangASTType clang_type = symbol_file_dwarf->GetClangASTContext().GetTypeForDecl (decl);
7755    if (clang_type)
7756        symbol_file_dwarf->ResolveClangOpaqueTypeDefinition (clang_type);
7757}
7758
7759void
7760SymbolFileDWARF::CompleteObjCInterfaceDecl (void *baton, clang::ObjCInterfaceDecl *decl)
7761{
7762    SymbolFileDWARF *symbol_file_dwarf = (SymbolFileDWARF *)baton;
7763    ClangASTType clang_type = symbol_file_dwarf->GetClangASTContext().GetTypeForDecl (decl);
7764    if (clang_type)
7765        symbol_file_dwarf->ResolveClangOpaqueTypeDefinition (clang_type);
7766}
7767
7768void
7769SymbolFileDWARF::DumpIndexes ()
7770{
7771    StreamFile s(stdout, false);
7772
7773    s.Printf ("DWARF index for (%s) '%s':",
7774              GetObjectFile()->GetModule()->GetArchitecture().GetArchitectureName(),
7775              GetObjectFile()->GetFileSpec().GetPath().c_str());
7776    s.Printf("\nFunction basenames:\n");    m_function_basename_index.Dump (&s);
7777    s.Printf("\nFunction fullnames:\n");    m_function_fullname_index.Dump (&s);
7778    s.Printf("\nFunction methods:\n");      m_function_method_index.Dump (&s);
7779    s.Printf("\nFunction selectors:\n");    m_function_selector_index.Dump (&s);
7780    s.Printf("\nObjective C class selectors:\n");    m_objc_class_selectors_index.Dump (&s);
7781    s.Printf("\nGlobals and statics:\n");   m_global_index.Dump (&s);
7782    s.Printf("\nTypes:\n");                 m_type_index.Dump (&s);
7783    s.Printf("\nNamepaces:\n");             m_namespace_index.Dump (&s);
7784}
7785
7786void
7787SymbolFileDWARF::SearchDeclContext (const clang::DeclContext *decl_context,
7788                                    const char *name,
7789                                    llvm::SmallVectorImpl <clang::NamedDecl *> *results)
7790{
7791    DeclContextToDIEMap::iterator iter = m_decl_ctx_to_die.find(decl_context);
7792
7793    if (iter == m_decl_ctx_to_die.end())
7794        return;
7795
7796    for (DIEPointerSet::iterator pos = iter->second.begin(), end = iter->second.end(); pos != end; ++pos)
7797    {
7798        const DWARFDebugInfoEntry *context_die = *pos;
7799
7800        if (!results)
7801            return;
7802
7803        DWARFDebugInfo* info = DebugInfo();
7804
7805        DIEArray die_offsets;
7806
7807        DWARFCompileUnit* dwarf_cu = NULL;
7808        const DWARFDebugInfoEntry* die = NULL;
7809
7810        if (m_using_apple_tables)
7811        {
7812            if (m_apple_types_ap.get())
7813                m_apple_types_ap->FindByName (name, die_offsets);
7814        }
7815        else
7816        {
7817            if (!m_indexed)
7818                Index ();
7819
7820            m_type_index.Find (ConstString(name), die_offsets);
7821        }
7822
7823        const size_t num_matches = die_offsets.size();
7824
7825        if (num_matches)
7826        {
7827            for (size_t i = 0; i < num_matches; ++i)
7828            {
7829                const dw_offset_t die_offset = die_offsets[i];
7830                die = info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu);
7831
7832                if (die->GetParent() != context_die)
7833                    continue;
7834
7835                Type *matching_type = ResolveType (dwarf_cu, die);
7836
7837                clang::QualType qual_type = matching_type->GetClangForwardType().GetQualType();
7838
7839                if (const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr()))
7840                {
7841                    clang::TagDecl *tag_decl = tag_type->getDecl();
7842                    results->push_back(tag_decl);
7843                }
7844                else if (const clang::TypedefType *typedef_type = llvm::dyn_cast<clang::TypedefType>(qual_type.getTypePtr()))
7845                {
7846                    clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
7847                    results->push_back(typedef_decl);
7848                }
7849            }
7850        }
7851    }
7852}
7853
7854void
7855SymbolFileDWARF::FindExternalVisibleDeclsByName (void *baton,
7856                                                 const clang::DeclContext *decl_context,
7857                                                 clang::DeclarationName decl_name,
7858                                                 llvm::SmallVectorImpl <clang::NamedDecl *> *results)
7859{
7860
7861    switch (decl_context->getDeclKind())
7862    {
7863    case clang::Decl::Namespace:
7864    case clang::Decl::TranslationUnit:
7865        {
7866            SymbolFileDWARF *symbol_file_dwarf = (SymbolFileDWARF *)baton;
7867            symbol_file_dwarf->SearchDeclContext (decl_context, decl_name.getAsString().c_str(), results);
7868        }
7869        break;
7870    default:
7871        break;
7872    }
7873}
7874
7875bool
7876SymbolFileDWARF::LayoutRecordType (void *baton,
7877                                   const clang::RecordDecl *record_decl,
7878                                   uint64_t &size,
7879                                   uint64_t &alignment,
7880                                   llvm::DenseMap <const clang::FieldDecl *, uint64_t> &field_offsets,
7881                                   llvm::DenseMap <const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets,
7882                                   llvm::DenseMap <const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets)
7883{
7884    SymbolFileDWARF *symbol_file_dwarf = (SymbolFileDWARF *)baton;
7885    return symbol_file_dwarf->LayoutRecordType (record_decl, size, alignment, field_offsets, base_offsets, vbase_offsets);
7886}
7887
7888
7889bool
7890SymbolFileDWARF::LayoutRecordType (const clang::RecordDecl *record_decl,
7891                                   uint64_t &bit_size,
7892                                   uint64_t &alignment,
7893                                   llvm::DenseMap <const clang::FieldDecl *, uint64_t> &field_offsets,
7894                                   llvm::DenseMap <const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets,
7895                                   llvm::DenseMap <const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets)
7896{
7897    Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
7898    RecordDeclToLayoutMap::iterator pos = m_record_decl_to_layout_map.find (record_decl);
7899    bool success = false;
7900    base_offsets.clear();
7901    vbase_offsets.clear();
7902    if (pos != m_record_decl_to_layout_map.end())
7903    {
7904        bit_size = pos->second.bit_size;
7905        alignment = pos->second.alignment;
7906        field_offsets.swap(pos->second.field_offsets);
7907        base_offsets.swap (pos->second.base_offsets);
7908        vbase_offsets.swap (pos->second.vbase_offsets);
7909        m_record_decl_to_layout_map.erase(pos);
7910        success = true;
7911    }
7912    else
7913    {
7914        bit_size = 0;
7915        alignment = 0;
7916        field_offsets.clear();
7917    }
7918
7919    if (log)
7920        GetObjectFile()->GetModule()->LogMessage (log,
7921                                                  "SymbolFileDWARF::LayoutRecordType (record_decl = %p, bit_size = %" PRIu64 ", alignment = %" PRIu64 ", field_offsets[%u],base_offsets[%u], vbase_offsets[%u]) success = %i",
7922                                                  record_decl,
7923                                                  bit_size,
7924                                                  alignment,
7925                                                  (uint32_t)field_offsets.size(),
7926                                                  (uint32_t)base_offsets.size(),
7927                                                  (uint32_t)vbase_offsets.size(),
7928                                                  success);
7929    return success;
7930}
7931
7932
7933SymbolFileDWARFDebugMap *
7934SymbolFileDWARF::GetDebugMapSymfile ()
7935{
7936    if (m_debug_map_symfile == NULL && !m_debug_map_module_wp.expired())
7937    {
7938        lldb::ModuleSP module_sp (m_debug_map_module_wp.lock());
7939        if (module_sp)
7940        {
7941            SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
7942            if (sym_vendor)
7943                m_debug_map_symfile = (SymbolFileDWARFDebugMap *)sym_vendor->GetSymbolFile();
7944        }
7945    }
7946    return m_debug_map_symfile;
7947}
7948
7949
7950