/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

Bug Summary

File:	tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp
Location:	line 1279, column 45
Description:	Value stored to 'class_symfile' is never read

Annotated Source Code

1	//===-- DWARFASTParserClang.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 "DWARFASTParserClang.h"
11	#include "DWARFCompileUnit.h"
12	#include "DWARFDebugInfo.h"
13	#include "DWARFDeclContext.h"
14	#include "DWARFDefines.h"
15	#include "DWARFDIE.h"
16	#include "DWARFDIECollection.h"
17	#include "SymbolFileDWARF.h"
18	#include "SymbolFileDWARFDebugMap.h"
19	#include "UniqueDWARFASTType.h"
20
21	#include "lldb/Interpreter/Args.h"
22	#include "lldb/Core/Log.h"
23	#include "lldb/Core/Module.h"
24	#include "lldb/Core/StreamString.h"
25	#include "lldb/Core/Value.h"
26	#include "lldb/Host/Host.h"
27	#include "lldb/Symbol/ClangASTImporter.h"
28	#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
29	#include "lldb/Symbol/CompileUnit.h"
30	#include "lldb/Symbol/Function.h"
31	#include "lldb/Symbol/ObjectFile.h"
32	#include "lldb/Symbol/SymbolVendor.h"
33	#include "lldb/Symbol/TypeList.h"
34	#include "lldb/Symbol/TypeMap.h"
35	#include "lldb/Target/Language.h"
36	#include "Plugins/Language/ObjC/ObjCLanguage.h"
37
38	#include "clang/AST/DeclCXX.h"
39	#include "clang/AST/DeclObjC.h"
40
41	#include <map>
42	#include <vector>
43
44	//#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
45
46	#ifdef ENABLE_DEBUG_PRINTF
47	#include <stdio.h>
48	#define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
49	#else
50	#define DEBUG_PRINTF(fmt, ...)
51	#endif
52
53
54	using namespace lldb;
55	using namespace lldb_private;
56	DWARFASTParserClang::DWARFASTParserClang (ClangASTContext &ast) :
57	m_ast (ast),
58	m_die_to_decl_ctx (),
59	m_decl_ctx_to_die ()
60	{
61	}
62
63	DWARFASTParserClang::~DWARFASTParserClang ()
64	{
65	}
66
67
68	static AccessType
69	DW_ACCESS_to_AccessType (uint32_t dwarf_accessibility)
70	{
71	switch (dwarf_accessibility)
72	{
73	case DW_ACCESS_public: return eAccessPublic;
74	case DW_ACCESS_private: return eAccessPrivate;
75	case DW_ACCESS_protected: return eAccessProtected;
76	default: break;
77	}
78	return eAccessNone;
79	}
80
81	static bool
82	DeclKindIsCXXClass (clang::Decl::Kind decl_kind)
83	{
84	switch (decl_kind)
85	{
86	case clang::Decl::CXXRecord:
87	case clang::Decl::ClassTemplateSpecialization:
88	return true;
89	default:
90	break;
91	}
92	return false;
93	}
94
95	struct BitfieldInfo
96	{
97	uint64_t bit_size;
98	uint64_t bit_offset;
99
100	BitfieldInfo () :
101	bit_size (LLDB_INVALID_ADDRESS(18446744073709551615UL)),
102	bit_offset (LLDB_INVALID_ADDRESS(18446744073709551615UL))
103	{
104	}
105
106	void
107	Clear()
108	{
109	bit_size = LLDB_INVALID_ADDRESS(18446744073709551615UL);
110	bit_offset = LLDB_INVALID_ADDRESS(18446744073709551615UL);
111	}
112
113	bool IsValid ()
114	{
115	return (bit_size != LLDB_INVALID_ADDRESS(18446744073709551615UL)) &&
116	(bit_offset != LLDB_INVALID_ADDRESS(18446744073709551615UL));
117	}
118	};
119
120
121	ClangASTImporter &
122	DWARFASTParserClang::GetClangASTImporter()
123	{
124	if (!m_clang_ast_importer_ap)
125	{
126	m_clang_ast_importer_ap.reset (new ClangASTImporter);
127	}
128	return *m_clang_ast_importer_ap;
129	}
130
131
132	TypeSP
133	DWARFASTParserClang::ParseTypeFromDWO (const DWARFDIE &die, Log *log)
134	{
135	ModuleSP dwo_module_sp = die.GetContainingDWOModule();
136	if (dwo_module_sp)
137	{
138	// This type comes from an external DWO module
139	std::vector<CompilerContext> dwo_context;
140	die.GetDWOContext(dwo_context);
141	TypeMap dwo_types;
142	if (dwo_module_sp->GetSymbolVendor()->FindTypes(dwo_context, true, dwo_types))
143	{
144	const size_t num_dwo_types = dwo_types.GetSize();
145	if (num_dwo_types == 1)
146	{
147	// We found a real definition for this type elsewhere
148	// so lets use it and cache the fact that we found
149	// a complete type for this die
150	TypeSP dwo_type_sp = dwo_types.GetTypeAtIndex(0);
151	if (dwo_type_sp)
152	{
153	lldb_private::CompilerType dwo_type = dwo_type_sp->GetForwardCompilerType();
154
155	lldb_private::CompilerType type = GetClangASTImporter().CopyType (m_ast, dwo_type);
156
157	//printf ("copied_qual_type: ast = %p, clang_type = %p, name = '%s'\n", m_ast, copied_qual_type.getAsOpaquePtr(), external_type->GetName().GetCString());
158	if (type)
159	{
160	SymbolFileDWARF *dwarf = die.GetDWARF();
161	TypeSP type_sp (new Type (die.GetID(),
162	dwarf,
163	dwo_type_sp->GetName(),
164	dwo_type_sp->GetByteSize(),
165	NULL__null,
166	LLDB_INVALID_UID(18446744073709551615UL),
167	Type::eEncodingInvalid,
168	&dwo_type_sp->GetDeclaration(),
169	type,
170	Type::eResolveStateForward));
171
172	dwarf->GetTypeList()->Insert(type_sp);
173	dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
174	clang::TagDecl *tag_decl = ClangASTContext::GetAsTagDecl(type);
175	if (tag_decl)
176	LinkDeclContextToDIE(tag_decl, die);
177	else
178	{
179	clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(die);
180	if (defn_decl_ctx)
181	LinkDeclContextToDIE(defn_decl_ctx, die);
182	}
183	return type_sp;
184	}
185	}
186	}
187	}
188	}
189	return TypeSP();
190	}
191
192	TypeSP
193	DWARFASTParserClang::ParseTypeFromDWARF (const SymbolContext& sc,
194	const DWARFDIE &die,
195	Log *log,
196	bool *type_is_new_ptr)
197	{
198	TypeSP type_sp;
199
200	if (type_is_new_ptr)
201	*type_is_new_ptr = false;
202
203	AccessType accessibility = eAccessNone;
204	if (die)
205	{
206	SymbolFileDWARF *dwarf = die.GetDWARF();
207	if (log)
208	{
209	DWARFDIE context_die;
210	clang::DeclContext *context = GetClangDeclContextContainingDIE (die, &context_die);
211
212	dwarf->GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDWARF::ParseType (die = 0x%8.8x, decl_ctx = %p (die 0x%8.8x)) %s name = '%s')",
213	die.GetOffset(),
214	static_cast<void*>(context),
215	context_die.GetOffset(),
216	die.GetTagAsCString(),
217	die.GetName());
218
219	}
220	//
221	// Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
222	// if (log && dwarf_cu)
223	// {
224	// StreamString s;
225	// die->DumpLocation (this, dwarf_cu, s);
226	// dwarf->GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDwarf::%s %s", __FUNCTION__, s.GetData());
227	//
228	// }
229
230	Type *type_ptr = dwarf->GetDIEToType().lookup (die.GetDIE());
231	TypeList* type_list = dwarf->GetTypeList();
232	if (type_ptr == NULL__null)
233	{
234	if (type_is_new_ptr)
235	*type_is_new_ptr = true;
236
237	const dw_tag_t tag = die.Tag();
238
239	bool is_forward_declaration = false;
240	DWARFAttributes attributes;
241	const char *type_name_cstr = NULL__null;
242	ConstString type_name_const_str;
243	Type::ResolveState resolve_state = Type::eResolveStateUnresolved;
244	uint64_t byte_size = 0;
245	Declaration decl;
246
247	Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID;
248	CompilerType clang_type;
249	DWARFFormValue form_value;
250
251	dw_attr_t attr;
252
253	switch (tag)
254	{
255	case DW_TAG_base_type:
256	case DW_TAG_pointer_type:
257	case DW_TAG_reference_type:
258	case DW_TAG_rvalue_reference_type:
259	case DW_TAG_typedef:
260	case DW_TAG_const_type:
261	case DW_TAG_restrict_type:
262	case DW_TAG_volatile_type:
263	case DW_TAG_unspecified_type:
264	{
265	// Set a bit that lets us know that we are currently parsing this
266	dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED((lldb_private::Type*)1);
267
268	const size_t num_attributes = die.GetAttributes (attributes);
269	uint32_t encoding = 0;
270	lldb::user_id_t encoding_uid = LLDB_INVALID_UID(18446744073709551615UL);
271
272	if (num_attributes > 0)
273	{
274	uint32_t i;
275	for (i=0; i<num_attributes; ++i)
276	{
277	attr = attributes.AttributeAtIndex(i);
278	if (attributes.ExtractFormValueAtIndex(i, form_value))
279	{
280	switch (attr)
281	{
282	case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
283	case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break;
284	case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
285	case DW_AT_name:
286
287	type_name_cstr = form_value.AsCString();
288	// Work around a bug in llvm-gcc where they give a name to a reference type which doesn't
289	// include the "&"...
290	if (tag == DW_TAG_reference_type)
291	{
292	if (strchr (type_name_cstr, '&') == NULL__null)
293	type_name_cstr = NULL__null;
294	}
295	if (type_name_cstr)
296	type_name_const_str.SetCString(type_name_cstr);
297	break;
298	case DW_AT_byte_size: byte_size = form_value.Unsigned(); break;
299	case DW_AT_encoding: encoding = form_value.Unsigned(); break;
300	case DW_AT_type: encoding_uid = DIERef(form_value).GetUID(); break;
301	default:
302	case DW_AT_sibling:
303	break;
304	}
305	}
306	}
307	}
308
309	DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\") type => 0x%8.8lx\n", die.GetID(), DW_TAG_value_to_name(tag), type_name_cstr, encoding_uid);
310
311	switch (tag)
312	{
313	default:
314	break;
315
316	case DW_TAG_unspecified_type:
317	if (strcmp(type_name_cstr, "nullptr_t") == 0 \|\|
318	strcmp(type_name_cstr, "decltype(nullptr)") == 0 )
319	{
320	resolve_state = Type::eResolveStateFull;
321	clang_type = m_ast.GetBasicType(eBasicTypeNullPtr);
322	break;
323	}
324	// Fall through to base type below in case we can handle the type there...
325
326	case DW_TAG_base_type:
327	resolve_state = Type::eResolveStateFull;
328	clang_type = m_ast.GetBuiltinTypeForDWARFEncodingAndBitSize (type_name_cstr,
329	encoding,
330	byte_size * 8);
331	break;
332
333	case DW_TAG_pointer_type: encoding_data_type = Type::eEncodingIsPointerUID; break;
334	case DW_TAG_reference_type: encoding_data_type = Type::eEncodingIsLValueReferenceUID; break;
335	case DW_TAG_rvalue_reference_type: encoding_data_type = Type::eEncodingIsRValueReferenceUID; break;
336	case DW_TAG_typedef: encoding_data_type = Type::eEncodingIsTypedefUID; break;
337	case DW_TAG_const_type: encoding_data_type = Type::eEncodingIsConstUID; break;
338	case DW_TAG_restrict_type: encoding_data_type = Type::eEncodingIsRestrictUID; break;
339	case DW_TAG_volatile_type: encoding_data_type = Type::eEncodingIsVolatileUID; break;
340	}
341
342	if (!clang_type && (encoding_data_type == Type::eEncodingIsPointerUID \|\| encoding_data_type == Type::eEncodingIsTypedefUID) && sc.comp_unit != NULL__null)
343	{
344	bool translation_unit_is_objc = (sc.comp_unit->GetLanguage() == eLanguageTypeObjC \|\| sc.comp_unit->GetLanguage() == eLanguageTypeObjC_plus_plus);
345
346	if (translation_unit_is_objc)
347	{
348	if (type_name_cstr != NULL__null)
349	{
350	static ConstString g_objc_type_name_id("id");
351	static ConstString g_objc_type_name_Class("Class");
352	static ConstString g_objc_type_name_selector("SEL");
353
354	if (type_name_const_str == g_objc_type_name_id)
355	{
356	if (log)
357	dwarf->GetObjectFile()->GetModule()->LogMessage (log,
358	"SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' is Objective C 'id' built-in type.",
359	die.GetOffset(),
360	die.GetTagAsCString(),
361	die.GetName());
362	clang_type = m_ast.GetBasicType(eBasicTypeObjCID);
363	encoding_data_type = Type::eEncodingIsUID;
364	encoding_uid = LLDB_INVALID_UID(18446744073709551615UL);
365	resolve_state = Type::eResolveStateFull;
366
367	}
368	else if (type_name_const_str == g_objc_type_name_Class)
369	{
370	if (log)
371	dwarf->GetObjectFile()->GetModule()->LogMessage (log,
372	"SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' is Objective C 'Class' built-in type.",
373	die.GetOffset(),
374	die.GetTagAsCString(),
375	die.GetName());
376	clang_type = m_ast.GetBasicType(eBasicTypeObjCClass);
377	encoding_data_type = Type::eEncodingIsUID;
378	encoding_uid = LLDB_INVALID_UID(18446744073709551615UL);
379	resolve_state = Type::eResolveStateFull;
380	}
381	else if (type_name_const_str == g_objc_type_name_selector)
382	{
383	if (log)
384	dwarf->GetObjectFile()->GetModule()->LogMessage (log,
385	"SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' is Objective C 'selector' built-in type.",
386	die.GetOffset(),
387	die.GetTagAsCString(),
388	die.GetName());
389	clang_type = m_ast.GetBasicType(eBasicTypeObjCSel);
390	encoding_data_type = Type::eEncodingIsUID;
391	encoding_uid = LLDB_INVALID_UID(18446744073709551615UL);
392	resolve_state = Type::eResolveStateFull;
393	}
394	}
395	else if (encoding_data_type == Type::eEncodingIsPointerUID && encoding_uid != LLDB_INVALID_UID(18446744073709551615UL))
396	{
397	// Clang sometimes erroneously emits id as objc_object*. In that case we fix up the type to "id".
398
399	const DWARFDIE encoding_die = die.GetDIE(encoding_uid);
400
401	if (encoding_die && encoding_die.Tag() == DW_TAG_structure_type)
402	{
403	if (const char *struct_name = encoding_die.GetName())
404	{
405	if (!strcmp(struct_name, "objc_object"))
406	{
407	if (log)
408	dwarf->GetObjectFile()->GetModule()->LogMessage (log,
409	"SymbolFileDWARF::ParseType (die = 0x%8.8x) %s '%s' is 'objc_object*', which we overrode to 'id'.",
410	die.GetOffset(),
411	die.GetTagAsCString(),
412	die.GetName());
413	clang_type = m_ast.GetBasicType(eBasicTypeObjCID);
414	encoding_data_type = Type::eEncodingIsUID;
415	encoding_uid = LLDB_INVALID_UID(18446744073709551615UL);
416	resolve_state = Type::eResolveStateFull;
417	}
418	}
419	}
420	}
421	}
422	}
423
424	type_sp.reset( new Type (die.GetID(),
425	dwarf,
426	type_name_const_str,
427	byte_size,
428	NULL__null,
429	encoding_uid,
430	encoding_data_type,
431	&decl,
432	clang_type,
433	resolve_state));
434
435	dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
436
437	// Type* encoding_type = GetUniquedTypeForDIEOffset(encoding_uid, type_sp, NULL, 0, 0, false);
438	// if (encoding_type != NULL)
439	// {
440	// if (encoding_type != DIE_IS_BEING_PARSED)
441	// type_sp->SetEncodingType(encoding_type);
442	// else
443	// m_indirect_fixups.push_back(type_sp.get());
444	// }
445	}
446	break;
447
448	case DW_TAG_structure_type:
449	case DW_TAG_union_type:
450	case DW_TAG_class_type:
451	{
452	// Set a bit that lets us know that we are currently parsing this
453	dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED((lldb_private::Type*)1);
454	bool byte_size_valid = false;
455
456	LanguageType class_language = eLanguageTypeUnknown;
457	bool is_complete_objc_class = false;
458	//bool struct_is_class = false;
459	const size_t num_attributes = die.GetAttributes (attributes);
460	if (num_attributes > 0)
461	{
462	uint32_t i;
463	for (i=0; i<num_attributes; ++i)
464	{
465	attr = attributes.AttributeAtIndex(i);
466	if (attributes.ExtractFormValueAtIndex(i, form_value))
467	{
468	switch (attr)
469	{
470	case DW_AT_decl_file:
471	if (die.GetCU()->DW_AT_decl_file_attributes_are_invalid())
472	{
473	// llvm-gcc outputs invalid DW_AT_decl_file attributes that always
474	// point to the compile unit file, so we clear this invalid value
475	// so that we can still unique types efficiently.
476	decl.SetFile(FileSpec ("<invalid>", false));
477	}
478	else
479	decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned()));
480	break;
481
482	case DW_AT_decl_line:
483	decl.SetLine(form_value.Unsigned());
484	break;
485
486	case DW_AT_decl_column:
487	decl.SetColumn(form_value.Unsigned());
488	break;
489
490	case DW_AT_name:
491	type_name_cstr = form_value.AsCString();
492	type_name_const_str.SetCString(type_name_cstr);
493	break;
494
495	case DW_AT_byte_size:
496	byte_size = form_value.Unsigned();
497	byte_size_valid = true;
498	break;
499
500	case DW_AT_accessibility:
501	accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned());
502	break;
503
504	case DW_AT_declaration:
505	is_forward_declaration = form_value.Boolean();
506	break;
507
508	case DW_AT_APPLE_runtime_class:
509	class_language = (LanguageType)form_value.Signed();
510	break;
511
512	case DW_AT_APPLE_objc_complete_type:
513	is_complete_objc_class = form_value.Signed();
514	break;
515
516	case DW_AT_allocated:
517	case DW_AT_associated:
518	case DW_AT_data_location:
519	case DW_AT_description:
520	case DW_AT_start_scope:
521	case DW_AT_visibility:
522	default:
523	case DW_AT_sibling:
524	break;
525	}
526	}
527	}
528	}
529
530	// UniqueDWARFASTType is large, so don't create a local variables on the
531	// stack, put it on the heap. This function is often called recursively
532	// and clang isn't good and sharing the stack space for variables in different blocks.
533	std::unique_ptr<UniqueDWARFASTType> unique_ast_entry_ap(new UniqueDWARFASTType());
534
535	if (type_name_const_str)
536	{
537	LanguageType die_language = die.GetLanguage();
538	bool handled = false;
539	if (Language::LanguageIsCPlusPlus(die_language))
540	{
541	std::string qualified_name;
542	if (die.GetQualifiedName(qualified_name))
543	{
544	handled = true;
545	ConstString const_qualified_name(qualified_name);
546	if (dwarf->GetUniqueDWARFASTTypeMap().Find(const_qualified_name, die, Declaration(),
547	byte_size_valid ? byte_size : -1,
548	*unique_ast_entry_ap))
549	{
550	type_sp = unique_ast_entry_ap->m_type_sp;
551	if (type_sp)
552	{
553	dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
554	return type_sp;
555	}
556	}
557	}
558	}
559
560	if (!handled)
561	{
562	if (dwarf->GetUniqueDWARFASTTypeMap().Find(type_name_const_str, die, decl,
563	byte_size_valid ? byte_size : -1,
564	*unique_ast_entry_ap))
565	{
566	type_sp = unique_ast_entry_ap->m_type_sp;
567	if (type_sp)
568	{
569	dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
570	return type_sp;
571	}
572	}
573	}
574	}
575
576	DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(), DW_TAG_value_to_name(tag), type_name_cstr);
577
578	int tag_decl_kind = -1;
579	AccessType default_accessibility = eAccessNone;
580	if (tag == DW_TAG_structure_type)
581	{
582	tag_decl_kind = clang::TTK_Struct;
583	default_accessibility = eAccessPublic;
584	}
585	else if (tag == DW_TAG_union_type)
586	{
587	tag_decl_kind = clang::TTK_Union;
588	default_accessibility = eAccessPublic;
589	}
590	else if (tag == DW_TAG_class_type)
591	{
592	tag_decl_kind = clang::TTK_Class;
593	default_accessibility = eAccessPrivate;
594	}
595
596	if (byte_size_valid && byte_size == 0 && type_name_cstr &&
597	die.HasChildren() == false &&
598	sc.comp_unit->GetLanguage() == eLanguageTypeObjC)
599	{
600	// Work around an issue with clang at the moment where
601	// forward declarations for objective C classes are emitted
602	// as:
603	// DW_TAG_structure_type [2]
604	// DW_AT_name( "ForwardObjcClass" )
605	// DW_AT_byte_size( 0x00 )
606	// DW_AT_decl_file( "..." )
607	// DW_AT_decl_line( 1 )
608	//
609	// Note that there is no DW_AT_declaration and there are
610	// no children, and the byte size is zero.
611	is_forward_declaration = true;
612	}
613
614	if (class_language == eLanguageTypeObjC \|\|
615	class_language == eLanguageTypeObjC_plus_plus)
616	{
617	if (!is_complete_objc_class && die.Supports_DW_AT_APPLE_objc_complete_type())
618	{
619	// We have a valid eSymbolTypeObjCClass class symbol whose
620	// name matches the current objective C class that we
621	// are trying to find and this DIE isn't the complete
622	// definition (we checked is_complete_objc_class above and
623	// know it is false), so the real definition is in here somewhere
624	type_sp = dwarf->FindCompleteObjCDefinitionTypeForDIE (die, type_name_const_str, true);
625
626	if (!type_sp)
627	{
628	SymbolFileDWARFDebugMap *debug_map_symfile = dwarf->GetDebugMapSymfile();
629	if (debug_map_symfile)
630	{
631	// We weren't able to find a full declaration in
632	// this DWARF, see if we have a declaration anywhere
633	// else...
634	type_sp = debug_map_symfile->FindCompleteObjCDefinitionTypeForDIE (die, type_name_const_str, true);
635	}
636	}
637
638	if (type_sp)
639	{
640	if (log)
641	{
642	dwarf->GetObjectFile()->GetModule()->LogMessage (log,
643	"SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is an incomplete objc type, complete type is 0x%8.8" PRIx64"l" "x",
644	static_cast<void*>(this),
645	die.GetOffset(),
646	DW_TAG_value_to_name(tag),
647	type_name_cstr,
648	type_sp->GetID());
649	}
650
651	// We found a real definition for this type elsewhere
652	// so lets use it and cache the fact that we found
653	// a complete type for this die
654	dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
655	return type_sp;
656	}
657	}
658	}
659
660
661	if (is_forward_declaration)
662	{
663	// We have a forward declaration to a type and we need
664	// to try and find a full declaration. We look in the
665	// current type index just in case we have a forward
666	// declaration followed by an actual declarations in the
667	// DWARF. If this fails, we need to look elsewhere...
668	if (log)
669	{
670	dwarf->GetObjectFile()->GetModule()->LogMessage (log,
671	"SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is a forward declaration, trying to find complete type",
672	static_cast<void*>(this),
673	die.GetOffset(),
674	DW_TAG_value_to_name(tag),
675	type_name_cstr);
676	}
677
678	// See if the type comes from a DWO module and if so, track down that type.
679	type_sp = ParseTypeFromDWO(die, log);
680	if (type_sp)
681	return type_sp;
682
683	DWARFDeclContext die_decl_ctx;
684	die.GetDWARFDeclContext(die_decl_ctx);
685
686	//type_sp = FindDefinitionTypeForDIE (dwarf_cu, die, type_name_const_str);
687	type_sp = dwarf->FindDefinitionTypeForDWARFDeclContext (die_decl_ctx);
688
689	if (!type_sp)
690	{
691	SymbolFileDWARFDebugMap *debug_map_symfile = dwarf->GetDebugMapSymfile();
692	if (debug_map_symfile)
693	{
694	// We weren't able to find a full declaration in
695	// this DWARF, see if we have a declaration anywhere
696	// else...
697	type_sp = debug_map_symfile->FindDefinitionTypeForDWARFDeclContext (die_decl_ctx);
698	}
699	}
700
701	if (type_sp)
702	{
703	if (log)
704	{
705	dwarf->GetObjectFile()->GetModule()->LogMessage (log,
706	"SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is a forward declaration, complete type is 0x%8.8" PRIx64"l" "x",
707	static_cast<void*>(this),
708	die.GetOffset(),
709	DW_TAG_value_to_name(tag),
710	type_name_cstr,
711	type_sp->GetID());
712	}
713
714	// We found a real definition for this type elsewhere
715	// so lets use it and cache the fact that we found
716	// a complete type for this die
717	dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
718	clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(
719	dwarf->DebugInfo()->GetDIE(DIERef(type_sp->GetID())));
720	if (defn_decl_ctx)
721	LinkDeclContextToDIE(defn_decl_ctx, die);
722	return type_sp;
723	}
724	}
725	assert (tag_decl_kind != -1)((tag_decl_kind != -1) ? static_cast<void> (0) : __assert_fail ("tag_decl_kind != -1", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp" , 725, __PRETTY_FUNCTION__));
726	bool clang_type_was_created = false;
727	clang_type.SetCompilerType(&m_ast, dwarf->GetForwardDeclDieToClangType().lookup (die.GetDIE()));
728	if (!clang_type)
729	{
730	clang::DeclContext *decl_ctx = GetClangDeclContextContainingDIE (die, nullptr);
731	if (accessibility == eAccessNone && decl_ctx)
732	{
733	// Check the decl context that contains this class/struct/union.
734	// If it is a class we must give it an accessibility.
735	const clang::Decl::Kind containing_decl_kind = decl_ctx->getDeclKind();
736	if (DeclKindIsCXXClass (containing_decl_kind))
737	accessibility = default_accessibility;
738	}
739
740	ClangASTMetadata metadata;
741	metadata.SetUserID(die.GetID());
742	metadata.SetIsDynamicCXXType(dwarf->ClassOrStructIsVirtual (die));
743
744	if (type_name_cstr && strchr (type_name_cstr, '<'))
745	{
746	ClangASTContext::TemplateParameterInfos template_param_infos;
747	if (ParseTemplateParameterInfos (die, template_param_infos))
748	{
749	clang::ClassTemplateDecl *class_template_decl = m_ast.ParseClassTemplateDecl (decl_ctx,
750	accessibility,
751	type_name_cstr,
752	tag_decl_kind,
753	template_param_infos);
754
755	clang::ClassTemplateSpecializationDecl *class_specialization_decl = m_ast.CreateClassTemplateSpecializationDecl (decl_ctx,
756	class_template_decl,
757	tag_decl_kind,
758	template_param_infos);
759	clang_type = m_ast.CreateClassTemplateSpecializationType (class_specialization_decl);
760	clang_type_was_created = true;
761
762	m_ast.SetMetadata (class_template_decl, metadata);
763	m_ast.SetMetadata (class_specialization_decl, metadata);
764	}
765	}
766
767	if (!clang_type_was_created)
768	{
769	clang_type_was_created = true;
770	clang_type = m_ast.CreateRecordType (decl_ctx,
771	accessibility,
772	type_name_cstr,
773	tag_decl_kind,
774	class_language,
775	&metadata);
776	}
777	}
778
779	// Store a forward declaration to this class type in case any
780	// parameters in any class methods need it for the clang
781	// types for function prototypes.
782	LinkDeclContextToDIE(m_ast.GetDeclContextForType(clang_type), die);
783	type_sp.reset (new Type (die.GetID(),
784	dwarf,
785	type_name_const_str,
786	byte_size,
787	NULL__null,
788	LLDB_INVALID_UID(18446744073709551615UL),
789	Type::eEncodingIsUID,
790	&decl,
791	clang_type,
792	Type::eResolveStateForward));
793
794	type_sp->SetIsCompleteObjCClass(is_complete_objc_class);
795
796
797	// Add our type to the unique type map so we don't
798	// end up creating many copies of the same type over
799	// and over in the ASTContext for our module
800	unique_ast_entry_ap->m_type_sp = type_sp;
801	unique_ast_entry_ap->m_die = die;
802	unique_ast_entry_ap->m_declaration = decl;
803	unique_ast_entry_ap->m_byte_size = byte_size;
804	dwarf->GetUniqueDWARFASTTypeMap().Insert (type_name_const_str,
805	*unique_ast_entry_ap);
806
807	if (is_forward_declaration && die.HasChildren())
808	{
809	// Check to see if the DIE actually has a definition, some version of GCC will
810	// emit DIEs with DW_AT_declaration set to true, but yet still have subprogram,
811	// members, or inheritance, so we can't trust it
812	DWARFDIE child_die = die.GetFirstChild();
813	while (child_die)
814	{
815	switch (child_die.Tag())
816	{
817	case DW_TAG_inheritance:
818	case DW_TAG_subprogram:
819	case DW_TAG_member:
820	case DW_TAG_APPLE_property:
821	case DW_TAG_class_type:
822	case DW_TAG_structure_type:
823	case DW_TAG_enumeration_type:
824	case DW_TAG_typedef:
825	case DW_TAG_union_type:
826	child_die.Clear();
827	is_forward_declaration = false;
828	break;
829	default:
830	child_die = child_die.GetSibling();
831	break;
832	}
833	}
834	}
835
836	if (!is_forward_declaration)
837	{
838	// Always start the definition for a class type so that
839	// if the class has child classes or types that require
840	// the class to be created for use as their decl contexts
841	// the class will be ready to accept these child definitions.
842	if (die.HasChildren() == false)
843	{
844	// No children for this struct/union/class, lets finish it
845	ClangASTContext::StartTagDeclarationDefinition (clang_type);
846	ClangASTContext::CompleteTagDeclarationDefinition (clang_type);
847
848	if (tag == DW_TAG_structure_type) // this only applies in C
849	{
850	clang::RecordDecl *record_decl = ClangASTContext::GetAsRecordDecl(clang_type);
851
852	if (record_decl)
853	m_record_decl_to_layout_map.insert(std::make_pair(record_decl, LayoutInfo()));
854	}
855	}
856	else if (clang_type_was_created)
857	{
858	// Start the definition if the class is not objective C since
859	// the underlying decls respond to isCompleteDefinition(). Objective
860	// C decls don't respond to isCompleteDefinition() so we can't
861	// start the declaration definition right away. For C++ class/union/structs
862	// we want to start the definition in case the class is needed as the
863	// declaration context for a contained class or type without the need
864	// to complete that type..
865
866	if (class_language != eLanguageTypeObjC &&
867	class_language != eLanguageTypeObjC_plus_plus)
868	ClangASTContext::StartTagDeclarationDefinition (clang_type);
869
870	// Leave this as a forward declaration until we need
871	// to know the details of the type. lldb_private::Type
872	// will automatically call the SymbolFile virtual function
873	// "SymbolFileDWARF::CompleteType(Type *)"
874	// When the definition needs to be defined.
875	assert(!dwarf->GetForwardDeclClangTypeToDie().count(ClangASTContext::RemoveFastQualifiers(clang_type).GetOpaqueQualType()) &&((!dwarf->GetForwardDeclClangTypeToDie().count(ClangASTContext ::RemoveFastQualifiers(clang_type).GetOpaqueQualType()) && "Type already in the forward declaration map!") ? static_cast <void> (0) : __assert_fail ("!dwarf->GetForwardDeclClangTypeToDie().count(ClangASTContext::RemoveFastQualifiers(clang_type).GetOpaqueQualType()) && \"Type already in the forward declaration map!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp" , 876, __PRETTY_FUNCTION__))
876	"Type already in the forward declaration map!")((!dwarf->GetForwardDeclClangTypeToDie().count(ClangASTContext ::RemoveFastQualifiers(clang_type).GetOpaqueQualType()) && "Type already in the forward declaration map!") ? static_cast <void> (0) : __assert_fail ("!dwarf->GetForwardDeclClangTypeToDie().count(ClangASTContext::RemoveFastQualifiers(clang_type).GetOpaqueQualType()) && \"Type already in the forward declaration map!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp" , 876, __PRETTY_FUNCTION__));
877	assert(((SymbolFileDWARF)m_ast.GetSymbolFile())->UserIDMatches(die.GetDIERef().GetUID()) &&((((SymbolFileDWARF)m_ast.GetSymbolFile())->UserIDMatches (die.GetDIERef().GetUID()) && "Adding incorrect type to forward declaration map" ) ? static_cast<void> (0) : __assert_fail ("((SymbolFileDWARF*)m_ast.GetSymbolFile())->UserIDMatches(die.GetDIERef().GetUID()) && \"Adding incorrect type to forward declaration map\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp" , 878, __PRETTY_FUNCTION__))
878	"Adding incorrect type to forward declaration map")((((SymbolFileDWARF)m_ast.GetSymbolFile())->UserIDMatches (die.GetDIERef().GetUID()) && "Adding incorrect type to forward declaration map" ) ? static_cast<void> (0) : __assert_fail ("((SymbolFileDWARF)m_ast.GetSymbolFile())->UserIDMatches(die.GetDIERef().GetUID()) && \"Adding incorrect type to forward declaration map\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp" , 878, __PRETTY_FUNCTION__));
879	dwarf->GetForwardDeclDieToClangType()[die.GetDIE()] = clang_type.GetOpaqueQualType();
880	dwarf->GetForwardDeclClangTypeToDie()[ClangASTContext::RemoveFastQualifiers(clang_type).GetOpaqueQualType()] = die.GetDIERef();
881	m_ast.SetHasExternalStorage (clang_type.GetOpaqueQualType(), true);
882	}
883	}
884	}
885	break;
886
887	case DW_TAG_enumeration_type:
888	{
889	// Set a bit that lets us know that we are currently parsing this
890	dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED((lldb_private::Type*)1);
891
892	DWARFFormValue encoding_form;
893
894	const size_t num_attributes = die.GetAttributes (attributes);
895	if (num_attributes > 0)
896	{
897	uint32_t i;
898
899	for (i=0; i<num_attributes; ++i)
900	{
901	attr = attributes.AttributeAtIndex(i);
902	if (attributes.ExtractFormValueAtIndex(i, form_value))
903	{
904	switch (attr)
905	{
906	case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
907	case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break;
908	case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
909	case DW_AT_name:
910	type_name_cstr = form_value.AsCString();
911	type_name_const_str.SetCString(type_name_cstr);
912	break;
913	case DW_AT_type: encoding_form = form_value; break;
914	case DW_AT_byte_size: byte_size = form_value.Unsigned(); break;
915	case DW_AT_accessibility: break; //accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
916	case DW_AT_declaration: is_forward_declaration = form_value.Boolean(); break;
917	case DW_AT_allocated:
918	case DW_AT_associated:
919	case DW_AT_bit_stride:
920	case DW_AT_byte_stride:
921	case DW_AT_data_location:
922	case DW_AT_description:
923	case DW_AT_start_scope:
924	case DW_AT_visibility:
925	case DW_AT_specification:
926	case DW_AT_abstract_origin:
927	case DW_AT_sibling:
928	break;
929	}
930	}
931	}
932
933	if (is_forward_declaration)
934	{
935	type_sp = ParseTypeFromDWO(die, log);
936	if (type_sp)
937	return type_sp;
938
939	DWARFDeclContext die_decl_ctx;
940	die.GetDWARFDeclContext(die_decl_ctx);
941
942	type_sp = dwarf->FindDefinitionTypeForDWARFDeclContext (die_decl_ctx);
943
944	if (!type_sp)
945	{
946	SymbolFileDWARFDebugMap *debug_map_symfile = dwarf->GetDebugMapSymfile();
947	if (debug_map_symfile)
948	{
949	// We weren't able to find a full declaration in
950	// this DWARF, see if we have a declaration anywhere
951	// else...
952	type_sp = debug_map_symfile->FindDefinitionTypeForDWARFDeclContext (die_decl_ctx);
953	}
954	}
955
956	if (type_sp)
957	{
958	if (log)
959	{
960	dwarf->GetObjectFile()->GetModule()->LogMessage (log,
961	"SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is a forward declaration, complete type is 0x%8.8" PRIx64"l" "x",
962	static_cast<void*>(this),
963	die.GetOffset(),
964	DW_TAG_value_to_name(tag),
965	type_name_cstr,
966	type_sp->GetID());
967	}
968
969	// We found a real definition for this type elsewhere
970	// so lets use it and cache the fact that we found
971	// a complete type for this die
972	dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
973	clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(
974	dwarf->DebugInfo()->GetDIE(DIERef(type_sp->GetID())));
975	if (defn_decl_ctx)
976	LinkDeclContextToDIE(defn_decl_ctx, die);
977	return type_sp;
978	}
979
980	}
981	DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(), DW_TAG_value_to_name(tag), type_name_cstr);
982
983	CompilerType enumerator_clang_type;
984	clang_type.SetCompilerType (&m_ast, dwarf->GetForwardDeclDieToClangType().lookup (die.GetDIE()));
985	if (!clang_type)
986	{
987	if (encoding_form.IsValid())
988	{
989	Type *enumerator_type = dwarf->ResolveTypeUID(DIERef(encoding_form).GetUID());
990	if (enumerator_type)
991	enumerator_clang_type = enumerator_type->GetFullCompilerType ();
992	}
993
994	if (!enumerator_clang_type)
995	enumerator_clang_type = m_ast.GetBuiltinTypeForDWARFEncodingAndBitSize (NULL__null,
996	DW_ATE_signed,
997	byte_size * 8);
998
999	clang_type = m_ast.CreateEnumerationType (type_name_cstr,
1000	GetClangDeclContextContainingDIE (die, nullptr),
1001	decl,
1002	enumerator_clang_type);
1003	}
1004	else
1005	{
1006	enumerator_clang_type = m_ast.GetEnumerationIntegerType (clang_type.GetOpaqueQualType());
1007	}
1008
1009	LinkDeclContextToDIE(ClangASTContext::GetDeclContextForType(clang_type), die);
1010
1011	type_sp.reset( new Type (die.GetID(),
1012	dwarf,
1013	type_name_const_str,
1014	byte_size,
1015	NULL__null,
1016	DIERef(encoding_form).GetUID(),
1017	Type::eEncodingIsUID,
1018	&decl,
1019	clang_type,
1020	Type::eResolveStateForward));
1021
1022	ClangASTContext::StartTagDeclarationDefinition (clang_type);
1023	if (die.HasChildren())
1024	{
1025	SymbolContext cu_sc(die.GetLLDBCompileUnit());
1026	bool is_signed = false;
1027	enumerator_clang_type.IsIntegerType(is_signed);
1028	ParseChildEnumerators(cu_sc, clang_type, is_signed, type_sp->GetByteSize(), die);
1029	}
1030	ClangASTContext::CompleteTagDeclarationDefinition (clang_type);
1031	}
1032	}
1033	break;
1034
1035	case DW_TAG_inlined_subroutine:
1036	case DW_TAG_subprogram:
1037	case DW_TAG_subroutine_type:
1038	{
1039	// Set a bit that lets us know that we are currently parsing this
1040	dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED((lldb_private::Type*)1);
1041
1042	DWARFFormValue type_die_form;
1043	bool is_variadic = false;
1044	bool is_inline = false;
1045	bool is_static = false;
1046	bool is_virtual = false;
1047	bool is_explicit = false;
1048	bool is_artificial = false;
1049	DWARFFormValue specification_die_form;
1050	DWARFFormValue abstract_origin_die_form;
1051	dw_offset_t object_pointer_die_offset = DW_INVALID_OFFSET(~(dw_offset_t)0);
1052
1053	unsigned type_quals = 0;
1054	clang::StorageClass storage = clang::SC_None;//, Extern, Static, PrivateExtern
1055
1056
1057	const size_t num_attributes = die.GetAttributes (attributes);
1058	if (num_attributes > 0)
1059	{
1060	uint32_t i;
1061	for (i=0; i<num_attributes; ++i)
1062	{
1063	attr = attributes.AttributeAtIndex(i);
1064	if (attributes.ExtractFormValueAtIndex(i, form_value))
1065	{
1066	switch (attr)
1067	{
1068	case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
1069	case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break;
1070	case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
1071	case DW_AT_name:
1072	type_name_cstr = form_value.AsCString();
1073	type_name_const_str.SetCString(type_name_cstr);
1074	break;
1075
1076	case DW_AT_linkage_name:
1077	case DW_AT_MIPS_linkage_name: break; // mangled = form_value.AsCString(&dwarf->get_debug_str_data()); break;
1078	case DW_AT_type: type_die_form = form_value; break;
1079	case DW_AT_accessibility: accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
1080	case DW_AT_declaration: break; // is_forward_declaration = form_value.Boolean(); break;
1081	case DW_AT_inline: is_inline = form_value.Boolean(); break;
1082	case DW_AT_virtuality: is_virtual = form_value.Boolean(); break;
1083	case DW_AT_explicit: is_explicit = form_value.Boolean(); break;
1084	case DW_AT_artificial: is_artificial = form_value.Boolean(); break;
1085
1086
1087	case DW_AT_external:
1088	if (form_value.Unsigned())
1089	{
1090	if (storage == clang::SC_None)
1091	storage = clang::SC_Extern;
1092	else
1093	storage = clang::SC_PrivateExtern;
1094	}
1095	break;
1096
1097	case DW_AT_specification:
1098	specification_die_form = form_value;
1099	break;
1100
1101	case DW_AT_abstract_origin:
1102	abstract_origin_die_form = form_value;
1103	break;
1104
1105	case DW_AT_object_pointer:
1106	object_pointer_die_offset = form_value.Reference();
1107	break;
1108
1109	case DW_AT_allocated:
1110	case DW_AT_associated:
1111	case DW_AT_address_class:
1112	case DW_AT_calling_convention:
1113	case DW_AT_data_location:
1114	case DW_AT_elemental:
1115	case DW_AT_entry_pc:
1116	case DW_AT_frame_base:
1117	case DW_AT_high_pc:
1118	case DW_AT_low_pc:
1119	case DW_AT_prototyped:
1120	case DW_AT_pure:
1121	case DW_AT_ranges:
1122	case DW_AT_recursive:
1123	case DW_AT_return_addr:
1124	case DW_AT_segment:
1125	case DW_AT_start_scope:
1126	case DW_AT_static_link:
1127	case DW_AT_trampoline:
1128	case DW_AT_visibility:
1129	case DW_AT_vtable_elem_location:
1130	case DW_AT_description:
1131	case DW_AT_sibling:
1132	break;
1133	}
1134	}
1135	}
1136	}
1137
1138	std::string object_pointer_name;
1139	if (object_pointer_die_offset != DW_INVALID_OFFSET(~(dw_offset_t)0))
1140	{
1141	DWARFDIE object_pointer_die = die.GetDIE (object_pointer_die_offset);
1142	if (object_pointer_die)
1143	{
1144	const char *object_pointer_name_cstr = object_pointer_die.GetName();
1145	if (object_pointer_name_cstr)
1146	object_pointer_name = object_pointer_name_cstr;
1147	}
1148	}
1149
1150	DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(), DW_TAG_value_to_name(tag), type_name_cstr);
1151
1152	CompilerType return_clang_type;
1153	Type *func_type = NULL__null;
1154
1155	if (type_die_form.IsValid())
1156	func_type = dwarf->ResolveTypeUID(DIERef(type_die_form).GetUID());
1157
1158	if (func_type)
1159	return_clang_type = func_type->GetForwardCompilerType ();
1160	else
1161	return_clang_type = m_ast.GetBasicType(eBasicTypeVoid);
1162
1163
1164	std::vector<CompilerType> function_param_types;
1165	std::vector<clang::ParmVarDecl*> function_param_decls;
1166
1167	// Parse the function children for the parameters
1168
1169	DWARFDIE decl_ctx_die;
1170	clang::DeclContext *containing_decl_ctx = GetClangDeclContextContainingDIE (die, &decl_ctx_die);
1171	const clang::Decl::Kind containing_decl_kind = containing_decl_ctx->getDeclKind();
1172
1173	const bool is_cxx_method = DeclKindIsCXXClass (containing_decl_kind);
1174	// Start off static. This will be set to false in ParseChildParameters(...)
1175	// if we find a "this" parameters as the first parameter
1176	if (is_cxx_method)
1177	is_static = true;
1178
1179	if (die.HasChildren())
1180	{
1181	bool skip_artificial = true;
1182	ParseChildParameters (sc,
1183	containing_decl_ctx,
1184	die,
1185	skip_artificial,
1186	is_static,
1187	is_variadic,
1188	function_param_types,
1189	function_param_decls,
1190	type_quals);
1191	}
1192
1193	// clang_type will get the function prototype clang type after this call
1194	clang_type = m_ast.CreateFunctionType (return_clang_type,
1195	function_param_types.data(),
1196	function_param_types.size(),
1197	is_variadic,
1198	type_quals);
1199
1200	bool ignore_containing_context = false;
1201
1202	if (type_name_cstr)
1203	{
1204	bool type_handled = false;
1205	if (tag == DW_TAG_subprogram \|\|
1206	tag == DW_TAG_inlined_subroutine)
1207	{
1208	ObjCLanguage::MethodName objc_method (type_name_cstr, true);
1209	if (objc_method.IsValid(true))
1210	{
1211	CompilerType class_opaque_type;
1212	ConstString class_name(objc_method.GetClassName());
1213	if (class_name)
1214	{
1215	TypeSP complete_objc_class_type_sp (dwarf->FindCompleteObjCDefinitionTypeForDIE (DWARFDIE(), class_name, false));
1216
1217	if (complete_objc_class_type_sp)
1218	{
1219	CompilerType type_clang_forward_type = complete_objc_class_type_sp->GetForwardCompilerType ();
1220	if (ClangASTContext::IsObjCObjectOrInterfaceType(type_clang_forward_type))
1221	class_opaque_type = type_clang_forward_type;
1222	}
1223	}
1224
1225	if (class_opaque_type)
1226	{
1227	// If accessibility isn't set to anything valid, assume public for
1228	// now...
1229	if (accessibility == eAccessNone)
1230	accessibility = eAccessPublic;
1231
1232	clang::ObjCMethodDecl *objc_method_decl = m_ast.AddMethodToObjCObjectType (class_opaque_type,
1233	type_name_cstr,
1234	clang_type,
1235	accessibility,
1236	is_artificial);
1237	type_handled = objc_method_decl != NULL__null;
1238	if (type_handled)
1239	{
1240	LinkDeclContextToDIE(ClangASTContext::GetAsDeclContext(objc_method_decl), die);
1241	m_ast.SetMetadataAsUserID (objc_method_decl, die.GetID());
1242	}
1243	else
1244	{
1245	dwarf->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",
1246	die.GetOffset(),
1247	tag,
1248	DW_TAG_value_to_name(tag));
1249	}
1250	}
1251	}
1252	else if (is_cxx_method)
1253	{
1254	// Look at the parent of this DIE and see if is is
1255	// a class or struct and see if this is actually a
1256	// C++ method
1257	Type *class_type = dwarf->ResolveType (decl_ctx_die);
1258	if (class_type)
1259	{
1260	bool alternate_defn = false;
1261	if (class_type->GetID() != decl_ctx_die.GetID() \|\| decl_ctx_die.GetContainingDWOModuleDIE())
1262	{
1263	alternate_defn = true;
1264
1265	// We uniqued the parent class of this function to another class
1266	// so we now need to associate all dies under "decl_ctx_die" to
1267	// DIEs in the DIE for "class_type"...
1268	SymbolFileDWARF *class_symfile = NULL__null;
1269	DWARFDIE class_type_die;
1270
1271	SymbolFileDWARFDebugMap *debug_map_symfile = dwarf->GetDebugMapSymfile();
1272	if (debug_map_symfile)
1273	{
1274	class_symfile = debug_map_symfile->GetSymbolFileByOSOIndex(SymbolFileDWARFDebugMap::GetOSOIndexFromUserID(class_type->GetID()));
1275	class_type_die = class_symfile->DebugInfo()->GetDIE (DIERef(class_type->GetID()));
1276	}
1277	else
1278	{
1279	class_symfile = dwarf;
	Value stored to 'class_symfile' is never read
1280	class_type_die = dwarf->DebugInfo()->GetDIE (DIERef(class_type->GetID()));
1281	}
1282	if (class_type_die)
1283	{
1284	DWARFDIECollection failures;
1285
1286	CopyUniqueClassMethodTypes (decl_ctx_die,
1287	class_type_die,
1288	class_type,
1289	failures);
1290
1291	// FIXME do something with these failures that's smarter than
1292	// just dropping them on the ground. Unfortunately classes don't
1293	// like having stuff added to them after their definitions are
1294	// complete...
1295
1296	type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
1297	if (type_ptr && type_ptr != DIE_IS_BEING_PARSED((lldb_private::Type*)1))
1298	{
1299	type_sp = type_ptr->shared_from_this();
1300	break;
1301	}
1302	}
1303	}
1304
1305	if (specification_die_form.IsValid())
1306	{
1307	// We have a specification which we are going to base our function
1308	// prototype off of, so we need this type to be completed so that the
1309	// m_die_to_decl_ctx for the method in the specification has a valid
1310	// clang decl context.
1311	class_type->GetForwardCompilerType ();
1312	// If we have a specification, then the function type should have been
1313	// made with the specification and not with this die.
1314	DWARFDIE spec_die = dwarf->DebugInfo()->GetDIE(DIERef(specification_die_form));
1315	clang::DeclContext *spec_clang_decl_ctx = GetClangDeclContextForDIE (spec_die);
1316	if (spec_clang_decl_ctx)
1317	{
1318	LinkDeclContextToDIE(spec_clang_decl_ctx, die);
1319	}
1320	else
1321	{
1322	dwarf->GetObjectFile()->GetModule()->ReportWarning ("0x%8.8" PRIx64"l" "x" ": DW_AT_specification(0x%8.8" PRIx64"l" "x" ") has no decl\n",
1323	die.GetID(),
1324	specification_die_form.Reference());
1325	}
1326	type_handled = true;
1327	}
1328	else if (abstract_origin_die_form.IsValid())
1329	{
1330	// We have a specification which we are going to base our function
1331	// prototype off of, so we need this type to be completed so that the
1332	// m_die_to_decl_ctx for the method in the abstract origin has a valid
1333	// clang decl context.
1334	class_type->GetForwardCompilerType ();
1335
1336	DWARFDIE abs_die = dwarf->DebugInfo()->GetDIE (DIERef(abstract_origin_die_form));
1337	clang::DeclContext *abs_clang_decl_ctx = GetClangDeclContextForDIE (abs_die);
1338	if (abs_clang_decl_ctx)
1339	{
1340	LinkDeclContextToDIE (abs_clang_decl_ctx, die);
1341	}
1342	else
1343	{
1344	dwarf->GetObjectFile()->GetModule()->ReportWarning ("0x%8.8" PRIx64"l" "x" ": DW_AT_abstract_origin(0x%8.8" PRIx64"l" "x" ") has no decl\n",
1345	die.GetID(),
1346	abstract_origin_die_form.Reference());
1347	}
1348	type_handled = true;
1349	}
1350	else
1351	{
1352	CompilerType class_opaque_type = class_type->GetForwardCompilerType ();
1353	if (ClangASTContext::IsCXXClassType(class_opaque_type))
1354	{
1355	if (class_opaque_type.IsBeingDefined () \|\| alternate_defn)
1356	{
1357	if (!is_static && !die.HasChildren())
1358	{
1359	// We have a C++ member function with no children (this pointer!)
1360	// and clang will get mad if we try and make a function that isn't
1361	// well formed in the DWARF, so we will just skip it...
1362	type_handled = true;
1363	}
1364	else
1365	{
1366	bool add_method = true;
1367	if (alternate_defn)
1368	{
1369	// If an alternate definition for the class exists, then add the method only if an
1370	// equivalent is not already present.
1371	clang::CXXRecordDecl *record_decl = m_ast.GetAsCXXRecordDecl(class_opaque_type.GetOpaqueQualType());
1372	if (record_decl)
1373	{
1374	for (auto method_iter = record_decl->method_begin();
1375	method_iter != record_decl->method_end();
1376	method_iter++)
1377	{
1378	clang::CXXMethodDecl method_decl = method_iter;
1379	if (method_decl->getNameInfo().getAsString() == std::string(type_name_cstr))
1380	{
1381	if (method_decl->getType() == ClangASTContext::GetQualType(clang_type))
1382	{
1383	add_method = false;
1384	LinkDeclContextToDIE(ClangASTContext::GetAsDeclContext(method_decl), die);
1385	type_handled = true;
1386
1387	break;
1388	}
1389	}
1390	}
1391	}
1392	}
1393
1394	if (add_method)
1395	{
1396	// REMOVE THE CRASH DESCRIPTION BELOW
1397	Host::SetCrashDescriptionWithFormat ("SymbolFileDWARF::ParseType() is adding a method %s to class %s in DIE 0x%8.8" PRIx64"l" "x" " from %s",
1398	type_name_cstr,
1399	class_type->GetName().GetCString(),
1400	die.GetID(),
1401	dwarf->GetObjectFile()->GetFileSpec().GetPath().c_str());
1402
1403	const bool is_attr_used = false;
1404	// Neither GCC 4.2 nor clang++ currently set a valid accessibility
1405	// in the DWARF for C++ methods... Default to public for now...
1406	if (accessibility == eAccessNone)
1407	accessibility = eAccessPublic;
1408
1409	clang::CXXMethodDecl *cxx_method_decl;
1410	cxx_method_decl = m_ast.AddMethodToCXXRecordType (class_opaque_type.GetOpaqueQualType(),
1411	type_name_cstr,
1412	clang_type,
1413	accessibility,
1414	is_virtual,
1415	is_static,
1416	is_inline,
1417	is_explicit,
1418	is_attr_used,
1419	is_artificial);
1420
1421	type_handled = cxx_method_decl != NULL__null;
1422
1423	if (type_handled)
1424	{
1425	LinkDeclContextToDIE(ClangASTContext::GetAsDeclContext(cxx_method_decl), die);
1426
1427	Host::SetCrashDescription (NULL__null);
1428
1429	ClangASTMetadata metadata;
1430	metadata.SetUserID(die.GetID());
1431
1432	if (!object_pointer_name.empty())
1433	{
1434	metadata.SetObjectPtrName(object_pointer_name.c_str());
1435	if (log)
1436	log->Printf ("Setting object pointer name: %s on method object %p.\n",
1437	object_pointer_name.c_str(),
1438	static_cast<void*>(cxx_method_decl));
1439	}
1440	m_ast.SetMetadata (cxx_method_decl, metadata);
1441	}
1442	else
1443	{
1444	ignore_containing_context = true;
1445	}
1446	}
1447	}
1448	}
1449	else
1450	{
1451	// We were asked to parse the type for a method in a class, yet the
1452	// class hasn't been asked to complete itself through the
1453	// clang::ExternalASTSource protocol, so we need to just have the
1454	// class complete itself and do things the right way, then our
1455	// DIE should then have an entry in the dwarf->GetDIEToType() map. First
1456	// we need to modify the dwarf->GetDIEToType() so it doesn't think we are
1457	// trying to parse this DIE anymore...
1458	dwarf->GetDIEToType()[die.GetDIE()] = NULL__null;
1459
1460	// Now we get the full type to force our class type to complete itself
1461	// using the clang::ExternalASTSource protocol which will parse all
1462	// base classes and all methods (including the method for this DIE).
1463	class_type->GetFullCompilerType ();
1464
1465	// The type for this DIE should have been filled in the function call above
1466	type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
1467	if (type_ptr && type_ptr != DIE_IS_BEING_PARSED((lldb_private::Type*)1))
1468	{
1469	type_sp = type_ptr->shared_from_this();
1470	break;
1471	}
1472
1473	// FIXME This is fixing some even uglier behavior but we really need to
1474	// uniq the methods of each class as well as the class itself.
1475	// <rdar://problem/11240464>
1476	type_handled = true;
1477	}
1478	}
1479	}
1480	}
1481	}
1482	}
1483
1484	if (!type_handled)
1485	{
1486	// We just have a function that isn't part of a class
1487	clang::FunctionDecl *function_decl = m_ast.CreateFunctionDeclaration (ignore_containing_context ? m_ast.GetTranslationUnitDecl() : containing_decl_ctx,
1488	type_name_cstr,
1489	clang_type,
1490	storage,
1491	is_inline);
1492
1493	// if (template_param_infos.GetSize() > 0)
1494	// {
1495	// clang::FunctionTemplateDecl *func_template_decl = CreateFunctionTemplateDecl (containing_decl_ctx,
1496	// function_decl,
1497	// type_name_cstr,
1498	// template_param_infos);
1499	//
1500	// CreateFunctionTemplateSpecializationInfo (function_decl,
1501	// func_template_decl,
1502	// template_param_infos);
1503	// }
1504	// Add the decl to our DIE to decl context map
1505	assert (function_decl)((function_decl) ? static_cast<void> (0) : __assert_fail ("function_decl", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp" , 1505, __PRETTY_FUNCTION__));
1506	LinkDeclContextToDIE(function_decl, die);
1507	if (!function_param_decls.empty())
1508	m_ast.SetFunctionParameters (function_decl,
1509	&function_param_decls.front(),
1510	function_param_decls.size());
1511
1512	ClangASTMetadata metadata;
1513	metadata.SetUserID(die.GetID());
1514
1515	if (!object_pointer_name.empty())
1516	{
1517	metadata.SetObjectPtrName(object_pointer_name.c_str());
1518	if (log)
1519	log->Printf ("Setting object pointer name: %s on function object %p.",
1520	object_pointer_name.c_str(),
1521	static_cast<void*>(function_decl));
1522	}
1523	m_ast.SetMetadata (function_decl, metadata);
1524	}
1525	}
1526	type_sp.reset( new Type (die.GetID(),
1527	dwarf,
1528	type_name_const_str,
1529	0,
1530	NULL__null,
1531	LLDB_INVALID_UID(18446744073709551615UL),
1532	Type::eEncodingIsUID,
1533	&decl,
1534	clang_type,
1535	Type::eResolveStateFull));
1536	assert(type_sp.get())((type_sp.get()) ? static_cast<void> (0) : __assert_fail ("type_sp.get()", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp" , 1536, __PRETTY_FUNCTION__));
1537	}
1538	break;
1539
1540	case DW_TAG_array_type:
1541	{
1542	// Set a bit that lets us know that we are currently parsing this
1543	dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED((lldb_private::Type*)1);
1544
1545	DWARFFormValue type_die_form;
1546	int64_t first_index = 0;
1547	uint32_t byte_stride = 0;
1548	uint32_t bit_stride = 0;
1549	bool is_vector = false;
1550	const size_t num_attributes = die.GetAttributes (attributes);
1551
1552	if (num_attributes > 0)
1553	{
1554	uint32_t i;
1555	for (i=0; i<num_attributes; ++i)
1556	{
1557	attr = attributes.AttributeAtIndex(i);
1558	if (attributes.ExtractFormValueAtIndex(i, form_value))
1559	{
1560	switch (attr)
1561	{
1562	case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
1563	case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break;
1564	case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
1565	case DW_AT_name:
1566	type_name_cstr = form_value.AsCString();
1567	type_name_const_str.SetCString(type_name_cstr);
1568	break;
1569
1570	case DW_AT_type: type_die_form = form_value; break;
1571	case DW_AT_byte_size: break; // byte_size = form_value.Unsigned(); break;
1572	case DW_AT_byte_stride: byte_stride = form_value.Unsigned(); break;
1573	case DW_AT_bit_stride: bit_stride = form_value.Unsigned(); break;
1574	case DW_AT_GNU_vector: is_vector = form_value.Boolean(); break;
1575	case DW_AT_accessibility: break; // accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
1576	case DW_AT_declaration: break; // is_forward_declaration = form_value.Boolean(); break;
1577	case DW_AT_allocated:
1578	case DW_AT_associated:
1579	case DW_AT_data_location:
1580	case DW_AT_description:
1581	case DW_AT_ordering:
1582	case DW_AT_start_scope:
1583	case DW_AT_visibility:
1584	case DW_AT_specification:
1585	case DW_AT_abstract_origin:
1586	case DW_AT_sibling:
1587	break;
1588	}
1589	}
1590	}
1591
1592	DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(), DW_TAG_value_to_name(tag), type_name_cstr);
1593
1594	Type *element_type = dwarf->ResolveTypeUID(DIERef(type_die_form).GetUID());
1595
1596	if (element_type)
1597	{
1598	std::vector<uint64_t> element_orders;
1599	ParseChildArrayInfo(sc, die, first_index, element_orders, byte_stride, bit_stride);
1600	if (byte_stride == 0 && bit_stride == 0)
1601	byte_stride = element_type->GetByteSize();
1602	CompilerType array_element_type = element_type->GetForwardCompilerType ();
1603	uint64_t array_element_bit_stride = byte_stride * 8 + bit_stride;
1604	if (element_orders.size() > 0)
1605	{
1606	uint64_t num_elements = 0;
1607	std::vector<uint64_t>::const_reverse_iterator pos;
1608	std::vector<uint64_t>::const_reverse_iterator end = element_orders.rend();
1609	for (pos = element_orders.rbegin(); pos != end; ++pos)
1610	{
1611	num_elements = *pos;
1612	clang_type = m_ast.CreateArrayType (array_element_type,
1613	num_elements,
1614	is_vector);
1615	array_element_type = clang_type;
1616	array_element_bit_stride = num_elements ?
1617	array_element_bit_stride * num_elements :
1618	array_element_bit_stride;
1619	}
1620	}
1621	else
1622	{
1623	clang_type = m_ast.CreateArrayType (array_element_type, 0, is_vector);
1624	}
1625	ConstString empty_name;
1626	type_sp.reset( new Type (die.GetID(),
1627	dwarf,
1628	empty_name,
1629	array_element_bit_stride / 8,
1630	NULL__null,
1631	DIERef(type_die_form).GetUID(),
1632	Type::eEncodingIsUID,
1633	&decl,
1634	clang_type,
1635	Type::eResolveStateFull));
1636	type_sp->SetEncodingType (element_type);
1637	}
1638	}
1639	}
1640	break;
1641
1642	case DW_TAG_ptr_to_member_type:
1643	{
1644	DWARFFormValue type_die_form;
1645	DWARFFormValue containing_type_die_form;
1646
1647	const size_t num_attributes = die.GetAttributes (attributes);
1648
1649	if (num_attributes > 0) {
1650	uint32_t i;
1651	for (i=0; i<num_attributes; ++i)
1652	{
1653	attr = attributes.AttributeAtIndex(i);
1654	if (attributes.ExtractFormValueAtIndex(i, form_value))
1655	{
1656	switch (attr)
1657	{
1658	case DW_AT_type:
1659	type_die_form = form_value; break;
1660	case DW_AT_containing_type:
1661	containing_type_die_form = form_value; break;
1662	}
1663	}
1664	}
1665
1666	Type *pointee_type = dwarf->ResolveTypeUID(DIERef(type_die_form).GetUID());
1667	Type *class_type = dwarf->ResolveTypeUID(DIERef(containing_type_die_form).GetUID());
1668
1669	CompilerType pointee_clang_type = pointee_type->GetForwardCompilerType ();
1670	CompilerType class_clang_type = class_type->GetLayoutCompilerType ();
1671
1672	clang_type = ClangASTContext::CreateMemberPointerType(class_clang_type, pointee_clang_type);
1673
1674	byte_size = clang_type.GetByteSize(nullptr);
1675
1676	type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str, byte_size, NULL__null,
1677	LLDB_INVALID_UID(18446744073709551615UL), Type::eEncodingIsUID, NULL__null, clang_type,
1678	Type::eResolveStateForward));
1679	}
1680
1681	break;
1682	}
1683	default:
1684	dwarf->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",
1685	die.GetOffset(),
1686	tag,
1687	DW_TAG_value_to_name(tag));
1688	break;
1689	}
1690
1691	if (type_sp.get())
1692	{
1693	DWARFDIE sc_parent_die = SymbolFileDWARF::GetParentSymbolContextDIE(die);
1694	dw_tag_t sc_parent_tag = sc_parent_die.Tag();
1695
1696	SymbolContextScope * symbol_context_scope = NULL__null;
1697	if (sc_parent_tag == DW_TAG_compile_unit)
1698	{
1699	symbol_context_scope = sc.comp_unit;
1700	}
1701	else if (sc.function != NULL__null && sc_parent_die)
1702	{
1703	symbol_context_scope = sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
1704	if (symbol_context_scope == NULL__null)
1705	symbol_context_scope = sc.function;
1706	}
1707
1708	if (symbol_context_scope != NULL__null)
1709	{
1710	type_sp->SetSymbolContextScope(symbol_context_scope);
1711	}
1712
1713	// We are ready to put this type into the uniqued list up at the module level
1714	type_list->Insert (type_sp);
1715
1716	dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
1717	}
1718	}
1719	else if (type_ptr != DIE_IS_BEING_PARSED((lldb_private::Type*)1))
1720	{
1721	type_sp = type_ptr->shared_from_this();
1722	}
1723	}
1724	return type_sp;
1725	}
1726
1727	// DWARF parsing functions
1728
1729	class DWARFASTParserClang::DelayedAddObjCClassProperty
1730	{
1731	public:
1732	DelayedAddObjCClassProperty(const CompilerType &class_opaque_type,
1733	const char *property_name,
1734	const CompilerType &property_opaque_type, // The property type is only required if you don't have an ivar decl
1735	clang::ObjCIvarDecl *ivar_decl,
1736	const char *property_setter_name,
1737	const char *property_getter_name,
1738	uint32_t property_attributes,
1739	const ClangASTMetadata *metadata) :
1740	m_class_opaque_type (class_opaque_type),
1741	m_property_name (property_name),
1742	m_property_opaque_type (property_opaque_type),
1743	m_ivar_decl (ivar_decl),
1744	m_property_setter_name (property_setter_name),
1745	m_property_getter_name (property_getter_name),
1746	m_property_attributes (property_attributes)
1747	{
1748	if (metadata != NULL__null)
1749	{
1750	m_metadata_ap.reset(new ClangASTMetadata());
1751	m_metadata_ap = metadata;
1752	}
1753	}
1754
1755	DelayedAddObjCClassProperty (const DelayedAddObjCClassProperty &rhs)
1756	{
1757	*this = rhs;
1758	}
1759
1760	DelayedAddObjCClassProperty& operator= (const DelayedAddObjCClassProperty &rhs)
1761	{
1762	m_class_opaque_type = rhs.m_class_opaque_type;
1763	m_property_name = rhs.m_property_name;
1764	m_property_opaque_type = rhs.m_property_opaque_type;
1765	m_ivar_decl = rhs.m_ivar_decl;
1766	m_property_setter_name = rhs.m_property_setter_name;
1767	m_property_getter_name = rhs.m_property_getter_name;
1768	m_property_attributes = rhs.m_property_attributes;
1769
1770	if (rhs.m_metadata_ap.get())
1771	{
1772	m_metadata_ap.reset (new ClangASTMetadata());
1773	m_metadata_ap = rhs.m_metadata_ap;
1774	}
1775	return *this;
1776	}
1777
1778	bool
1779	Finalize()
1780	{
1781	return ClangASTContext::AddObjCClassProperty (m_class_opaque_type,
1782	m_property_name,
1783	m_property_opaque_type,
1784	m_ivar_decl,
1785	m_property_setter_name,
1786	m_property_getter_name,
1787	m_property_attributes,
1788	m_metadata_ap.get());
1789	}
1790
1791	private:
1792	CompilerType m_class_opaque_type;
1793	const char *m_property_name;
1794	CompilerType m_property_opaque_type;
1795	clang::ObjCIvarDecl *m_ivar_decl;
1796	const char *m_property_setter_name;
1797	const char *m_property_getter_name;
1798	uint32_t m_property_attributes;
1799	std::unique_ptr<ClangASTMetadata> m_metadata_ap;
1800	};
1801
1802	bool
1803	DWARFASTParserClang::ParseTemplateDIE (const DWARFDIE &die,
1804	ClangASTContext::TemplateParameterInfos &template_param_infos)
1805	{
1806	const dw_tag_t tag = die.Tag();
1807
1808	switch (tag)
1809	{
1810	case DW_TAG_template_type_parameter:
1811	case DW_TAG_template_value_parameter:
1812	{
1813	DWARFAttributes attributes;
1814	const size_t num_attributes = die.GetAttributes (attributes);
1815	const char *name = NULL__null;
1816	Type *lldb_type = NULL__null;
1817	CompilerType clang_type;
1818	uint64_t uval64 = 0;
1819	bool uval64_valid = false;
1820	if (num_attributes > 0)
1821	{
1822	DWARFFormValue form_value;
1823	for (size_t i=0; i<num_attributes; ++i)
1824	{
1825	const dw_attr_t attr = attributes.AttributeAtIndex(i);
1826
1827	switch (attr)
1828	{
1829	case DW_AT_name:
1830	if (attributes.ExtractFormValueAtIndex(i, form_value))
1831	name = form_value.AsCString();
1832	break;
1833
1834	case DW_AT_type:
1835	if (attributes.ExtractFormValueAtIndex(i, form_value))
1836	{
1837	lldb_type = die.ResolveTypeUID(DIERef(form_value).GetUID());
1838	if (lldb_type)
1839	clang_type = lldb_type->GetForwardCompilerType ();
1840	}
1841	break;
1842
1843	case DW_AT_const_value:
1844	if (attributes.ExtractFormValueAtIndex(i, form_value))
1845	{
1846	uval64_valid = true;
1847	uval64 = form_value.Unsigned();
1848	}
1849	break;
1850	default:
1851	break;
1852	}
1853	}
1854
1855	clang::ASTContext *ast = m_ast.getASTContext();
1856	if (!clang_type)
1857	clang_type = m_ast.GetBasicType(eBasicTypeVoid);
1858
1859	if (clang_type)
1860	{
1861	bool is_signed = false;
1862	if (name && name[0])
1863	template_param_infos.names.push_back(name);
1864	else
1865	template_param_infos.names.push_back(NULL__null);
1866
1867	if (tag == DW_TAG_template_value_parameter &&
1868	lldb_type != NULL__null &&
1869	clang_type.IsIntegerType (is_signed) &&
1870	uval64_valid)
1871	{
1872	llvm::APInt apint (lldb_type->GetByteSize() * 8, uval64, is_signed);
1873	template_param_infos.args.push_back (clang::TemplateArgument (*ast,
1874	llvm::APSInt(apint),
1875	ClangASTContext::GetQualType(clang_type)));
1876	}
1877	else
1878	{
1879	template_param_infos.args.push_back (clang::TemplateArgument (ClangASTContext::GetQualType(clang_type)));
1880	}
1881	}
1882	else
1883	{
1884	return false;
1885	}
1886
1887	}
1888	}
1889	return true;
1890
1891	default:
1892	break;
1893	}
1894	return false;
1895	}
1896
1897	bool
1898	DWARFASTParserClang::ParseTemplateParameterInfos (const DWARFDIE &parent_die,
1899	ClangASTContext::TemplateParameterInfos &template_param_infos)
1900	{
1901
1902	if (!parent_die)
1903	return false;
1904
1905	Args template_parameter_names;
1906	for (DWARFDIE die = parent_die.GetFirstChild();
1907	die.IsValid();
1908	die = die.GetSibling())
1909	{
1910	const dw_tag_t tag = die.Tag();
1911
1912	switch (tag)
1913	{
1914	case DW_TAG_template_type_parameter:
1915	case DW_TAG_template_value_parameter:
1916	ParseTemplateDIE (die, template_param_infos);
1917	break;
1918
1919	default:
1920	break;
1921	}
1922	}
1923	if (template_param_infos.args.empty())
1924	return false;
1925	return template_param_infos.args.size() == template_param_infos.names.size();
1926	}
1927
1928	bool
1929	DWARFASTParserClang::CanCompleteType (const lldb_private::CompilerType &compiler_type)
1930	{
1931	if (m_clang_ast_importer_ap)
1932	return ClangASTContext::CanImport(compiler_type, GetClangASTImporter());
1933	else
1934	return false;
1935	}
1936
1937	bool
1938	DWARFASTParserClang::CompleteType (const lldb_private::CompilerType &compiler_type)
1939	{
1940	if (CanCompleteType(compiler_type))
1941	{
1942	if (ClangASTContext::Import(compiler_type, GetClangASTImporter()))
1943	{
1944	ClangASTContext::CompleteTagDeclarationDefinition(compiler_type);
1945	return true;
1946	}
1947	else
1948	{
1949	ClangASTContext::SetHasExternalStorage (compiler_type.GetOpaqueQualType(), false);
1950	}
1951	}
1952	return false;
1953	}
1954
1955	bool
1956	DWARFASTParserClang::CompleteTypeFromDWARF (const DWARFDIE &die,
1957	lldb_private::Type *type,
1958	CompilerType &clang_type)
1959	{
1960	// Disable external storage for this type so we don't get anymore
1961	// clang::ExternalASTSource queries for this type.
1962	m_ast.SetHasExternalStorage (clang_type.GetOpaqueQualType(), false);
1963
1964	if (!die)
1965	return false;
1966
1967	const dw_tag_t tag = die.Tag();
1968
1969	SymbolFileDWARF *dwarf = die.GetDWARF();
1970
1971	Log *log = nullptr; // (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO\|DWARF_LOG_TYPE_COMPLETION));
1972	if (log)
1973	dwarf->GetObjectFile()->GetModule()->LogMessageVerboseBacktrace (log,
1974	"0x%8.8" PRIx64"l" "x" ": %s '%s' resolving forward declaration...",
1975	die.GetID(),
1976	die.GetTagAsCString(),
1977	type->GetName().AsCString());
1978	assert (clang_type)((clang_type) ? static_cast<void> (0) : __assert_fail ( "clang_type", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp" , 1978, __PRETTY_FUNCTION__));
1979	DWARFAttributes attributes;
1980	switch (tag)
1981	{
1982	case DW_TAG_structure_type:
1983	case DW_TAG_union_type:
1984	case DW_TAG_class_type:
1985	{
1986	LayoutInfo layout_info;
1987
1988	{
1989	if (die.HasChildren())
1990	{
1991	LanguageType class_language = eLanguageTypeUnknown;
1992	if (ClangASTContext::IsObjCObjectOrInterfaceType(clang_type))
1993	{
1994	class_language = eLanguageTypeObjC;
1995	// For objective C we don't start the definition when
1996	// the class is created.
1997	ClangASTContext::StartTagDeclarationDefinition (clang_type);
1998	}
1999
2000	int tag_decl_kind = -1;
2001	AccessType default_accessibility = eAccessNone;
2002	if (tag == DW_TAG_structure_type)
2003	{
2004	tag_decl_kind = clang::TTK_Struct;
2005	default_accessibility = eAccessPublic;
2006	}
2007	else if (tag == DW_TAG_union_type)
2008	{
2009	tag_decl_kind = clang::TTK_Union;
2010	default_accessibility = eAccessPublic;
2011	}
2012	else if (tag == DW_TAG_class_type)
2013	{
2014	tag_decl_kind = clang::TTK_Class;
2015	default_accessibility = eAccessPrivate;
2016	}
2017
2018	SymbolContext sc(die.GetLLDBCompileUnit());
2019	std::vector<clang::CXXBaseSpecifier *> base_classes;
2020	std::vector<int> member_accessibilities;
2021	bool is_a_class = false;
2022	// Parse members and base classes first
2023	DWARFDIECollection member_function_dies;
2024
2025	DelayedPropertyList delayed_properties;
2026	ParseChildMembers (sc,
2027	die,
2028	clang_type,
2029	class_language,
2030	base_classes,
2031	member_accessibilities,
2032	member_function_dies,
2033	delayed_properties,
2034	default_accessibility,
2035	is_a_class,
2036	layout_info);
2037
2038	// Now parse any methods if there were any...
2039	size_t num_functions = member_function_dies.Size();
2040	if (num_functions > 0)
2041	{
2042	for (size_t i=0; i<num_functions; ++i)
2043	{
2044	dwarf->ResolveType(member_function_dies.GetDIEAtIndex(i));
2045	}
2046	}
2047
2048	if (class_language == eLanguageTypeObjC)
2049	{
2050	ConstString class_name (clang_type.GetTypeName());
2051	if (class_name)
2052	{
2053	DIEArray method_die_offsets;
2054	dwarf->GetObjCMethodDIEOffsets(class_name, method_die_offsets);
2055
2056	if (!method_die_offsets.empty())
2057	{
2058	DWARFDebugInfo* debug_info = dwarf->DebugInfo();
2059
2060	const size_t num_matches = method_die_offsets.size();
2061	for (size_t i=0; i<num_matches; ++i)
2062	{
2063	const DIERef& die_ref = method_die_offsets[i];
2064	DWARFDIE method_die = debug_info->GetDIE (die_ref);
2065
2066	if (method_die)
2067	method_die.ResolveType ();
2068	}
2069	}
2070
2071	for (DelayedPropertyList::iterator pi = delayed_properties.begin(), pe = delayed_properties.end();
2072	pi != pe;
2073	++pi)
2074	pi->Finalize();
2075	}
2076	}
2077
2078	// If we have a DW_TAG_structure_type instead of a DW_TAG_class_type we
2079	// need to tell the clang type it is actually a class.
2080	if (class_language != eLanguageTypeObjC)
2081	{
2082	if (is_a_class && tag_decl_kind != clang::TTK_Class)
2083	m_ast.SetTagTypeKind (ClangASTContext::GetQualType(clang_type), clang::TTK_Class);
2084	}
2085
2086	// Since DW_TAG_structure_type gets used for both classes
2087	// and structures, we may need to set any DW_TAG_member
2088	// fields to have a "private" access if none was specified.
2089	// When we parsed the child members we tracked that actual
2090	// accessibility value for each DW_TAG_member in the
2091	// "member_accessibilities" array. If the value for the
2092	// member is zero, then it was set to the "default_accessibility"
2093	// which for structs was "public". Below we correct this
2094	// by setting any fields to "private" that weren't correctly
2095	// set.
2096	if (is_a_class && !member_accessibilities.empty())
2097	{
2098	// This is a class and all members that didn't have
2099	// their access specified are private.
2100	m_ast.SetDefaultAccessForRecordFields (m_ast.GetAsRecordDecl(clang_type),
2101	eAccessPrivate,
2102	&member_accessibilities.front(),
2103	member_accessibilities.size());
2104	}
2105
2106	if (!base_classes.empty())
2107	{
2108	// Make sure all base classes refer to complete types and not
2109	// forward declarations. If we don't do this, clang will crash
2110	// with an assertion in the call to clang_type.SetBaseClassesForClassType()
2111	for (auto &base_class : base_classes)
2112	{
2113	clang::TypeSourceInfo *type_source_info = base_class->getTypeSourceInfo();
2114	if (type_source_info)
2115	{
2116	CompilerType base_class_type (&m_ast, type_source_info->getType().getAsOpaquePtr());
2117	if (base_class_type.GetCompleteType() == false)
2118	{
2119	auto module = dwarf->GetObjectFile()->GetModule();
2120	module->ReportError (
2121	":: Class '%s' has a base class '%s' which does not have a complete definition.",
2122	die.GetName(),
2123	base_class_type.GetTypeName().GetCString());
2124	if (die.GetCU()->GetProducer() == DWARFCompileUnit::eProducerClang)
2125	module->ReportError (":: Try compiling the source file with -fno-limit-debug-info.");
2126
2127	// We have no choice other than to pretend that the base class
2128	// is complete. If we don't do this, clang will crash when we
2129	// call setBases() inside of "clang_type.SetBaseClassesForClassType()"
2130	// below. Since we provide layout assistance, all ivars in this
2131	// class and other classes will be fine, this is the best we can do
2132	// short of crashing.
2133	ClangASTContext::StartTagDeclarationDefinition (base_class_type);
2134	ClangASTContext::CompleteTagDeclarationDefinition (base_class_type);
2135	}
2136	}
2137	}
2138	m_ast.SetBaseClassesForClassType (clang_type.GetOpaqueQualType(),
2139	&base_classes.front(),
2140	base_classes.size());
2141
2142	// Clang will copy each CXXBaseSpecifier in "base_classes"
2143	// so we have to free them all.
2144	ClangASTContext::DeleteBaseClassSpecifiers (&base_classes.front(),
2145	base_classes.size());
2146	}
2147	}
2148	}
2149
2150	ClangASTContext::BuildIndirectFields (clang_type);
2151	ClangASTContext::CompleteTagDeclarationDefinition (clang_type);
2152
2153	if (!layout_info.field_offsets.empty() \|\|
2154	!layout_info.base_offsets.empty() \|\|
2155	!layout_info.vbase_offsets.empty() )
2156	{
2157	if (type)
2158	layout_info.bit_size = type->GetByteSize() * 8;
2159	if (layout_info.bit_size == 0)
2160	layout_info.bit_size = die.GetAttributeValueAsUnsigned(DW_AT_byte_size, 0) * 8;
2161
2162	clang::CXXRecordDecl *record_decl = m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
2163	if (record_decl)
2164	{
2165	if (log)
2166	{
2167	ModuleSP module_sp = dwarf->GetObjectFile()->GetModule();
2168
2169	if (module_sp)
2170	{
2171	module_sp->LogMessage (log,
2172	"ClangASTContext::CompleteTypeFromDWARF (clang_type = %p) caching layout info for record_decl = %p, bit_size = %" PRIu64"l" "u" ", alignment = %" PRIu64"l" "u" ", field_offsets[%u], base_offsets[%u], vbase_offsets[%u])",
2173	static_cast<void*>(clang_type.GetOpaqueQualType()),
2174	static_cast<void*>(record_decl),
2175	layout_info.bit_size,
2176	layout_info.alignment,
2177	static_cast<uint32_t>(layout_info.field_offsets.size()),
2178	static_cast<uint32_t>(layout_info.base_offsets.size()),
2179	static_cast<uint32_t>(layout_info.vbase_offsets.size()));
2180
2181	uint32_t idx;
2182	{
2183	llvm::DenseMap<const clang::FieldDecl *, uint64_t>::const_iterator pos,
2184	end = layout_info.field_offsets.end();
2185	for (idx = 0, pos = layout_info.field_offsets.begin(); pos != end; ++pos, ++idx)
2186	{
2187	module_sp->LogMessage(log,
2188	"ClangASTContext::CompleteTypeFromDWARF (clang_type = %p) field[%u] = { bit_offset=%u, name='%s' }",
2189	static_cast<void *>(clang_type.GetOpaqueQualType()),
2190	idx,
2191	static_cast<uint32_t>(pos->second),
2192	pos->first->getNameAsString().c_str());
2193	}
2194	}
2195
2196	{
2197	llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>::const_iterator base_pos,
2198	base_end = layout_info.base_offsets.end();
2199	for (idx = 0, base_pos = layout_info.base_offsets.begin(); base_pos != base_end; ++base_pos, ++idx)
2200	{
2201	module_sp->LogMessage(log,
2202	"ClangASTContext::CompleteTypeFromDWARF (clang_type = %p) base[%u] = { byte_offset=%u, name='%s' }",
2203	clang_type.GetOpaqueQualType(), idx, (uint32_t)base_pos->second.getQuantity(),
2204	base_pos->first->getNameAsString().c_str());
2205	}
2206	}
2207	{
2208	llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>::const_iterator vbase_pos,
2209	vbase_end = layout_info.vbase_offsets.end();
2210	for (idx = 0, vbase_pos = layout_info.vbase_offsets.begin(); vbase_pos != vbase_end; ++vbase_pos, ++idx)
2211	{
2212	module_sp->LogMessage(log,
2213	"ClangASTContext::CompleteTypeFromDWARF (clang_type = %p) vbase[%u] = { byte_offset=%u, name='%s' }",
2214	static_cast<void *>(clang_type.GetOpaqueQualType()), idx,
2215	static_cast<uint32_t>(vbase_pos->second.getQuantity()),
2216	vbase_pos->first->getNameAsString().c_str());
2217	}
2218	}
2219
2220	}
2221	}
2222	m_record_decl_to_layout_map.insert(std::make_pair(record_decl, layout_info));
2223	}
2224	}
2225	}
2226
2227	return (bool)clang_type;
2228
2229	case DW_TAG_enumeration_type:
2230	ClangASTContext::StartTagDeclarationDefinition (clang_type);
2231	if (die.HasChildren())
2232	{
2233	SymbolContext sc(die.GetLLDBCompileUnit());
2234	bool is_signed = false;
2235	clang_type.IsIntegerType(is_signed);
2236	ParseChildEnumerators(sc, clang_type, is_signed, type->GetByteSize(), die);
2237	}
2238	ClangASTContext::CompleteTagDeclarationDefinition (clang_type);
2239	return (bool)clang_type;
2240
2241	default:
2242	assert(false && "not a forward clang type decl!")((false && "not a forward clang type decl!") ? static_cast <void> (0) : __assert_fail ("false && \"not a forward clang type decl!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp" , 2242, __PRETTY_FUNCTION__));
2243	break;
2244	}
2245
2246	return false;
2247	}
2248
2249	std::vector<DWARFDIE>
2250	DWARFASTParserClang::GetDIEForDeclContext(lldb_private::CompilerDeclContext decl_context)
2251	{
2252	std::vector<DWARFDIE> result;
2253	for (auto it = m_decl_ctx_to_die.find((clang::DeclContext *)decl_context.GetOpaqueDeclContext()); it != m_decl_ctx_to_die.end(); it++)
2254	result.push_back(it->second);
2255	return result;
2256	}
2257
2258	CompilerDecl
2259	DWARFASTParserClang::GetDeclForUIDFromDWARF (const DWARFDIE &die)
2260	{
2261	clang::Decl *clang_decl = GetClangDeclForDIE(die);
2262	if (clang_decl != nullptr)
2263	return CompilerDecl(&m_ast, clang_decl);
2264	return CompilerDecl();
2265	}
2266
2267	CompilerDeclContext
2268	DWARFASTParserClang::GetDeclContextForUIDFromDWARF (const DWARFDIE &die)
2269	{
2270	clang::DeclContext *clang_decl_ctx = GetClangDeclContextForDIE (die);
2271	if (clang_decl_ctx)
2272	return CompilerDeclContext(&m_ast, clang_decl_ctx);
2273	return CompilerDeclContext();
2274	}
2275
2276	CompilerDeclContext
2277	DWARFASTParserClang::GetDeclContextContainingUIDFromDWARF (const DWARFDIE &die)
2278	{
2279	clang::DeclContext *clang_decl_ctx = GetClangDeclContextContainingDIE (die, nullptr);
2280	if (clang_decl_ctx)
2281	return CompilerDeclContext(&m_ast, clang_decl_ctx);
2282	return CompilerDeclContext();
2283	}
2284
2285	size_t
2286	DWARFASTParserClang::ParseChildEnumerators (const SymbolContext& sc,
2287	lldb_private::CompilerType &clang_type,
2288	bool is_signed,
2289	uint32_t enumerator_byte_size,
2290	const DWARFDIE &parent_die)
2291	{
2292	if (!parent_die)
2293	return 0;
2294
2295	size_t enumerators_added = 0;
2296
2297	for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
2298	{
2299	const dw_tag_t tag = die.Tag();
2300	if (tag == DW_TAG_enumerator)
2301	{
2302	DWARFAttributes attributes;
2303	const size_t num_child_attributes = die.GetAttributes(attributes);
2304	if (num_child_attributes > 0)
2305	{
2306	const char *name = NULL__null;
2307	bool got_value = false;
2308	int64_t enum_value = 0;
2309	Declaration decl;
2310
2311	uint32_t i;
2312	for (i=0; i<num_child_attributes; ++i)
2313	{
2314	const dw_attr_t attr = attributes.AttributeAtIndex(i);
2315	DWARFFormValue form_value;
2316	if (attributes.ExtractFormValueAtIndex(i, form_value))
2317	{
2318	switch (attr)
2319	{
2320	case DW_AT_const_value:
2321	got_value = true;
2322	if (is_signed)
2323	enum_value = form_value.Signed();
2324	else
2325	enum_value = form_value.Unsigned();
2326	break;
2327
2328	case DW_AT_name:
2329	name = form_value.AsCString();
2330	break;
2331
2332	case DW_AT_description:
2333	default:
2334	case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
2335	case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break;
2336	case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
2337	case DW_AT_sibling:
2338	break;
2339	}
2340	}
2341	}
2342
2343	if (name && name[0] && got_value)
2344	{
2345	m_ast.AddEnumerationValueToEnumerationType (clang_type.GetOpaqueQualType(),
2346	m_ast.GetEnumerationIntegerType(clang_type.GetOpaqueQualType()),
2347	decl,
2348	name,
2349	enum_value,
2350	enumerator_byte_size * 8);
2351	++enumerators_added;
2352	}
2353	}
2354	}
2355	}
2356	return enumerators_added;
2357	}
2358
2359	#if defined(LLDB_CONFIGURATION_DEBUG) \|\| defined(LLDB_CONFIGURATION_RELEASE)
2360
2361	class DIEStack
2362	{
2363	public:
2364
2365	void Push (const DWARFDIE &die)
2366	{
2367	m_dies.push_back (die);
2368	}
2369
2370
2371	void LogDIEs (Log *log)
2372	{
2373	StreamString log_strm;
2374	const size_t n = m_dies.size();
2375	log_strm.Printf("DIEStack[%" PRIu64"l" "u" "]:\n", (uint64_t)n);
2376	for (size_t i=0; i<n; i++)
2377	{
2378	std::string qualified_name;
2379	const DWARFDIE &die = m_dies[i];
2380	die.GetQualifiedName(qualified_name);
2381	log_strm.Printf ("[%" PRIu64"l" "u" "] 0x%8.8x: %s name='%s'\n",
2382	(uint64_t)i,
2383	die.GetOffset(),
2384	die.GetTagAsCString(),
2385	qualified_name.c_str());
2386	}
2387	log->PutCString(log_strm.GetData());
2388	}
2389	void Pop ()
2390	{
2391	m_dies.pop_back();
2392	}
2393
2394	class ScopedPopper
2395	{
2396	public:
2397	ScopedPopper (DIEStack &die_stack) :
2398	m_die_stack (die_stack),
2399	m_valid (false)
2400	{
2401	}
2402
2403	void
2404	Push (const DWARFDIE &die)
2405	{
2406	m_valid = true;
2407	m_die_stack.Push (die);
2408	}
2409
2410	~ScopedPopper ()
2411	{
2412	if (m_valid)
2413	m_die_stack.Pop();
2414	}
2415
2416
2417
2418	protected:
2419	DIEStack &m_die_stack;
2420	bool m_valid;
2421	};
2422
2423	protected:
2424	typedef std::vector<DWARFDIE> Stack;
2425	Stack m_dies;
2426	};
2427	#endif
2428
2429	Function *
2430	DWARFASTParserClang::ParseFunctionFromDWARF (const SymbolContext& sc,
2431	const DWARFDIE &die)
2432	{
2433	DWARFRangeList func_ranges;
2434	const char *name = NULL__null;
2435	const char *mangled = NULL__null;
2436	int decl_file = 0;
2437	int decl_line = 0;
2438	int decl_column = 0;
2439	int call_file = 0;
2440	int call_line = 0;
2441	int call_column = 0;
2442	DWARFExpression frame_base(die.GetCU());
2443
2444	const dw_tag_t tag = die.Tag();
2445
2446	if (tag != DW_TAG_subprogram)
2447	return NULL__null;
2448
2449	if (die.GetDIENamesAndRanges (name,
2450	mangled,
2451	func_ranges,
2452	decl_file,
2453	decl_line,
2454	decl_column,
2455	call_file,
2456	call_line,
2457	call_column,
2458	&frame_base))
2459	{
2460
2461	// Union of all ranges in the function DIE (if the function is discontiguous)
2462	AddressRange func_range;
2463	lldb::addr_t lowest_func_addr = func_ranges.GetMinRangeBase (0);
2464	lldb::addr_t highest_func_addr = func_ranges.GetMaxRangeEnd (0);
2465	if (lowest_func_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL) && lowest_func_addr <= highest_func_addr)
2466	{
2467	ModuleSP module_sp (die.GetModule());
2468	func_range.GetBaseAddress().ResolveAddressUsingFileSections (lowest_func_addr, module_sp->GetSectionList());
2469	if (func_range.GetBaseAddress().IsValid())
2470	func_range.SetByteSize(highest_func_addr - lowest_func_addr);
2471	}
2472
2473	if (func_range.GetBaseAddress().IsValid())
2474	{
2475	Mangled func_name;
2476	if (mangled)
2477	func_name.SetValue(ConstString(mangled), true);
2478	else if (die.GetParent().Tag() == DW_TAG_compile_unit &&
2479	Language::LanguageIsCPlusPlus(die.GetLanguage()) &&
2480	name && strcmp(name, "main") != 0)
2481	{
2482	// If the mangled name is not present in the DWARF, generate the demangled name
2483	// using the decl context. We skip if the function is "main" as its name is
2484	// never mangled.
2485	bool is_static = false;
2486	bool is_variadic = false;
2487	unsigned type_quals = 0;
2488	std::vector<CompilerType> param_types;
2489	std::vector<clang::ParmVarDecl*> param_decls;
2490	DWARFDeclContext decl_ctx;
2491	StreamString sstr;
2492
2493	die.GetDWARFDeclContext(decl_ctx);
2494	sstr << decl_ctx.GetQualifiedName();
2495
2496	clang::DeclContext *containing_decl_ctx = GetClangDeclContextContainingDIE(die, nullptr);
2497	ParseChildParameters(sc,
2498	containing_decl_ctx,
2499	die,
2500	true,
2501	is_static,
2502	is_variadic,
2503	param_types,
2504	param_decls,
2505	type_quals);
2506	sstr << "(";
2507	for (size_t i = 0; i < param_types.size(); i++)
2508	{
2509	if (i > 0)
2510	sstr << ", ";
2511	sstr << param_types[i].GetTypeName();
2512	}
2513	if (is_variadic)
2514	sstr << ", ...";
2515	sstr << ")";
2516	if (type_quals & clang::Qualifiers::Const)
2517	sstr << " const";
2518
2519	func_name.SetValue(ConstString(sstr.GetData()), false);
2520	}
2521	else
2522	func_name.SetValue(ConstString(name), false);
2523
2524	FunctionSP func_sp;
2525	std::unique_ptr<Declaration> decl_ap;
2526	if (decl_file != 0 \|\| decl_line != 0 \|\| decl_column != 0)
2527	decl_ap.reset(new Declaration (sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
2528	decl_line,
2529	decl_column));
2530
2531	SymbolFileDWARF *dwarf = die.GetDWARF();
2532	// Supply the type _only_ if it has already been parsed
2533	Type *func_type = dwarf->GetDIEToType().lookup (die.GetDIE());
2534
2535	assert(func_type == NULL \|\| func_type != DIE_IS_BEING_PARSED)((func_type == __null \|\| func_type != ((lldb_private::Type)1 )) ? static_cast<void> (0) : __assert_fail ("func_type == __null \|\| func_type != ((lldb_private::Type)1)" , "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp" , 2535, __PRETTY_FUNCTION__));
2536
2537	if (dwarf->FixupAddress (func_range.GetBaseAddress()))
2538	{
2539	const user_id_t func_user_id = die.GetID();
2540	func_sp.reset(new Function (sc.comp_unit,
2541	func_user_id, // UserID is the DIE offset
2542	func_user_id,
2543	func_name,
2544	func_type,
2545	func_range)); // first address range
2546
2547	if (func_sp.get() != NULL__null)
2548	{
2549	if (frame_base.IsValid())
2550	func_sp->GetFrameBaseExpression() = frame_base;
2551	sc.comp_unit->AddFunction(func_sp);
2552	return func_sp.get();
2553	}
2554	}
2555	}
2556	}
2557	return NULL__null;
2558	}
2559
2560
2561	bool
2562	DWARFASTParserClang::ParseChildMembers (const SymbolContext& sc,
2563	const DWARFDIE &parent_die,
2564	CompilerType &class_clang_type,
2565	const LanguageType class_language,
2566	std::vector<clang::CXXBaseSpecifier *>& base_classes,
2567	std::vector<int>& member_accessibilities,
2568	DWARFDIECollection& member_function_dies,
2569	DelayedPropertyList& delayed_properties,
2570	AccessType& default_accessibility,
2571	bool &is_a_class,
2572	LayoutInfo &layout_info)
2573	{
2574	if (!parent_die)
2575	return 0;
2576
2577	uint32_t member_idx = 0;
2578	BitfieldInfo last_field_info;
2579
2580	ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule();
2581	ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(class_clang_type.GetTypeSystem());
2582	if (ast == nullptr)
2583	return 0;
2584
2585	for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
2586	{
2587	dw_tag_t tag = die.Tag();
2588
2589	switch (tag)
2590	{
2591	case DW_TAG_member:
2592	case DW_TAG_APPLE_property:
2593	{
2594	DWARFAttributes attributes;
2595	const size_t num_attributes = die.GetAttributes (attributes);
2596	if (num_attributes > 0)
2597	{
2598	Declaration decl;
2599	//DWARFExpression location;
2600	const char *name = NULL__null;
2601	const char *prop_name = NULL__null;
2602	const char *prop_getter_name = NULL__null;
2603	const char *prop_setter_name = NULL__null;
2604	uint32_t prop_attributes = 0;
2605
2606
2607	bool is_artificial = false;
2608	DWARFFormValue encoding_form;
2609	AccessType accessibility = eAccessNone;
2610	uint32_t member_byte_offset = UINT32_MAX(4294967295U);
2611	size_t byte_size = 0;
2612	size_t bit_offset = 0;
2613	size_t bit_size = 0;
2614	bool is_external = false; // On DW_TAG_members, this means the member is static
2615	uint32_t i;
2616	for (i=0; i<num_attributes && !is_artificial; ++i)
2617	{
2618	const dw_attr_t attr = attributes.AttributeAtIndex(i);
2619	DWARFFormValue form_value;
2620	if (attributes.ExtractFormValueAtIndex(i, form_value))
2621	{
2622	switch (attr)
2623	{
2624	case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
2625	case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break;
2626	case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
2627	case DW_AT_name: name = form_value.AsCString(); break;
2628	case DW_AT_type: encoding_form = form_value; break;
2629	case DW_AT_bit_offset: bit_offset = form_value.Unsigned(); break;
2630	case DW_AT_bit_size: bit_size = form_value.Unsigned(); break;
2631	case DW_AT_byte_size: byte_size = form_value.Unsigned(); break;
2632	case DW_AT_data_member_location:
2633	if (form_value.BlockData())
2634	{
2635	Value initialValue(0);
2636	Value memberOffset(0);
2637	const DWARFDataExtractor& debug_info_data = die.GetDWARF()->get_debug_info_data();
2638	uint32_t block_length = form_value.Unsigned();
2639	uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();
2640	if (DWARFExpression::Evaluate(NULL__null, // ExecutionContext *
2641	NULL__null, // ClangExpressionVariableList *
2642	NULL__null, // ClangExpressionDeclMap *
2643	NULL__null, // RegisterContext *
2644	module_sp,
2645	debug_info_data,
2646	die.GetCU(),
2647	block_offset,
2648	block_length,
2649	eRegisterKindDWARF,
2650	&initialValue,
2651	memberOffset,
2652	NULL__null))
2653	{
2654	member_byte_offset = memberOffset.ResolveValue(NULL__null).UInt();
2655	}
2656	}
2657	else
2658	{
2659	// With DWARF 3 and later, if the value is an integer constant,
2660	// this form value is the offset in bytes from the beginning
2661	// of the containing entity.
2662	member_byte_offset = form_value.Unsigned();
2663	}
2664	break;
2665
2666	case DW_AT_accessibility: accessibility = DW_ACCESS_to_AccessType (form_value.Unsigned()); break;
2667	case DW_AT_artificial: is_artificial = form_value.Boolean(); break;
2668	case DW_AT_APPLE_property_name: prop_name = form_value.AsCString();
2669	break;
2670	case DW_AT_APPLE_property_getter: prop_getter_name = form_value.AsCString();
2671	break;
2672	case DW_AT_APPLE_property_setter: prop_setter_name = form_value.AsCString();
2673	break;
2674	case DW_AT_APPLE_property_attribute: prop_attributes = form_value.Unsigned(); break;
2675	case DW_AT_external: is_external = form_value.Boolean(); break;
2676
2677	default:
2678	case DW_AT_declaration:
2679	case DW_AT_description:
2680	case DW_AT_mutable:
2681	case DW_AT_visibility:
2682	case DW_AT_sibling:
2683	break;
2684	}
2685	}
2686	}
2687
2688	if (prop_name)
2689	{
2690	ConstString fixed_getter;
2691	ConstString fixed_setter;
2692
2693	// Check if the property getter/setter were provided as full
2694	// names. We want basenames, so we extract them.
2695
2696	if (prop_getter_name && prop_getter_name[0] == '-')
2697	{
2698	ObjCLanguage::MethodName prop_getter_method(prop_getter_name, true);
2699	prop_getter_name = prop_getter_method.GetSelector().GetCString();
2700	}
2701
2702	if (prop_setter_name && prop_setter_name[0] == '-')
2703	{
2704	ObjCLanguage::MethodName prop_setter_method(prop_setter_name, true);
2705	prop_setter_name = prop_setter_method.GetSelector().GetCString();
2706	}
2707
2708	// If the names haven't been provided, they need to be
2709	// filled in.
2710
2711	if (!prop_getter_name)
2712	{
2713	prop_getter_name = prop_name;
2714	}
2715	if (!prop_setter_name && prop_name[0] && !(prop_attributes & DW_APPLE_PROPERTY_readonly))
2716	{
2717	StreamString ss;
2718
2719	ss.Printf("set%c%s:",
2720	toupper(prop_name[0]),
2721	&prop_name[1]);
2722
2723	fixed_setter.SetCString(ss.GetData());
2724	prop_setter_name = fixed_setter.GetCString();
2725	}
2726	}
2727
2728	// Clang has a DWARF generation bug where sometimes it
2729	// represents fields that are references with bad byte size
2730	// and bit size/offset information such as:
2731	//
2732	// DW_AT_byte_size( 0x00 )
2733	// DW_AT_bit_size( 0x40 )
2734	// DW_AT_bit_offset( 0xffffffffffffffc0 )
2735	//
2736	// So check the bit offset to make sure it is sane, and if
2737	// the values are not sane, remove them. If we don't do this
2738	// then we will end up with a crash if we try to use this
2739	// type in an expression when clang becomes unhappy with its
2740	// recycled debug info.
2741
2742	if (bit_offset > 128)
2743	{
2744	bit_size = 0;
2745	bit_offset = 0;
2746	}
2747
2748	// FIXME: Make Clang ignore Objective-C accessibility for expressions
2749	if (class_language == eLanguageTypeObjC \|\|
2750	class_language == eLanguageTypeObjC_plus_plus)
2751	accessibility = eAccessNone;
2752
2753	if (member_idx == 0 && !is_artificial && name && (strstr (name, "_vptr$") == name))
2754	{
2755	// Not all compilers will mark the vtable pointer
2756	// member as artificial (llvm-gcc). We can't have
2757	// the virtual members in our classes otherwise it
2758	// throws off all child offsets since we end up
2759	// having and extra pointer sized member in our
2760	// class layouts.
2761	is_artificial = true;
2762	}
2763
2764	// Handle static members
2765	if (is_external && member_byte_offset == UINT32_MAX(4294967295U))
2766	{
2767	Type *var_type = die.ResolveTypeUID(DIERef(encoding_form).GetUID());
2768
2769	if (var_type)
2770	{
2771	if (accessibility == eAccessNone)
2772	accessibility = eAccessPublic;
2773	ClangASTContext::AddVariableToRecordType (class_clang_type,
2774	name,
2775	var_type->GetLayoutCompilerType (),
2776	accessibility);
2777	}
2778	break;
2779	}
2780
2781	if (is_artificial == false)
2782	{
2783	Type *member_type = die.ResolveTypeUID(DIERef(encoding_form).GetUID());
2784
2785	clang::FieldDecl *field_decl = NULL__null;
2786	if (tag == DW_TAG_member)
2787	{
2788	if (member_type)
2789	{
2790	if (accessibility == eAccessNone)
2791	accessibility = default_accessibility;
2792	member_accessibilities.push_back(accessibility);
2793
2794	uint64_t field_bit_offset = (member_byte_offset == UINT32_MAX(4294967295U) ? 0 : (member_byte_offset * 8));
2795	if (bit_size > 0)
2796	{
2797
2798	BitfieldInfo this_field_info;
2799	this_field_info.bit_offset = field_bit_offset;
2800	this_field_info.bit_size = bit_size;
2801
2802	/////////////////////////////////////////////////////////////
2803	// How to locate a field given the DWARF debug information
2804	//
2805	// AT_byte_size indicates the size of the word in which the
2806	// bit offset must be interpreted.
2807	//
2808	// AT_data_member_location indicates the byte offset of the
2809	// word from the base address of the structure.
2810	//
2811	// AT_bit_offset indicates how many bits into the word
2812	// (according to the host endianness) the low-order bit of
2813	// the field starts. AT_bit_offset can be negative.
2814	//
2815	// AT_bit_size indicates the size of the field in bits.
2816	/////////////////////////////////////////////////////////////
2817
2818	if (byte_size == 0)
2819	byte_size = member_type->GetByteSize();
2820
2821	if (die.GetDWARF()->GetObjectFile()->GetByteOrder() == eByteOrderLittle)
2822	{
2823	this_field_info.bit_offset += byte_size * 8;
2824	this_field_info.bit_offset -= (bit_offset + bit_size);
2825	}
2826	else
2827	{
2828	this_field_info.bit_offset += bit_offset;
2829	}
2830
2831	// Update the field bit offset we will report for layout
2832	field_bit_offset = this_field_info.bit_offset;
2833
2834	// If the member to be emitted did not start on a character boundary and there is
2835	// empty space between the last field and this one, then we need to emit an
2836	// anonymous member filling up the space up to its start. There are three cases
2837	// here:
2838	//
2839	// 1 If the previous member ended on a character boundary, then we can emit an
2840	// anonymous member starting at the most recent character boundary.
2841	//
2842	// 2 If the previous member did not end on a character boundary and the distance
2843	// from the end of the previous member to the current member is less than a
2844	// word width, then we can emit an anonymous member starting right after the
2845	// previous member and right before this member.
2846	//
2847	// 3 If the previous member did not end on a character boundary and the distance
2848	// from the end of the previous member to the current member is greater than
2849	// or equal a word width, then we act as in Case 1.
2850
2851	const uint64_t character_width = 8;
2852	const uint64_t word_width = 32;
2853
2854	// Objective-C has invalid DW_AT_bit_offset values in older versions
2855	// of clang, so we have to be careful and only insert unnamed bitfields
2856	// if we have a new enough clang.
2857	bool detect_unnamed_bitfields = true;
2858
2859	if (class_language == eLanguageTypeObjC \|\| class_language == eLanguageTypeObjC_plus_plus)
2860	detect_unnamed_bitfields = die.GetCU()->Supports_unnamed_objc_bitfields ();
2861
2862	if (detect_unnamed_bitfields)
2863	{
2864	BitfieldInfo anon_field_info;
2865
2866	if ((this_field_info.bit_offset % character_width) != 0) // not char aligned
2867	{
2868	uint64_t last_field_end = 0;
2869
2870	if (last_field_info.IsValid())
2871	last_field_end = last_field_info.bit_offset + last_field_info.bit_size;
2872
2873	if (this_field_info.bit_offset != last_field_end)
2874	{
2875	if (((last_field_end % character_width) == 0) \|\| // case 1
2876	(this_field_info.bit_offset - last_field_end >= word_width)) // case 3
2877	{
2878	anon_field_info.bit_size = this_field_info.bit_offset % character_width;
2879	anon_field_info.bit_offset = this_field_info.bit_offset - anon_field_info.bit_size;
2880	}
2881	else // case 2
2882	{
2883	anon_field_info.bit_size = this_field_info.bit_offset - last_field_end;
2884	anon_field_info.bit_offset = last_field_end;
2885	}
2886	}
2887	}
2888
2889	if (anon_field_info.IsValid())
2890	{
2891	clang::FieldDecl *unnamed_bitfield_decl =
2892	ClangASTContext::AddFieldToRecordType (class_clang_type,
2893	NULL__null,
2894	m_ast.GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, word_width),
2895	accessibility,
2896	anon_field_info.bit_size);
2897
2898	layout_info.field_offsets.insert(
2899	std::make_pair(unnamed_bitfield_decl, anon_field_info.bit_offset));
2900	}
2901	}
2902	last_field_info = this_field_info;
2903	}
2904	else
2905	{
2906	last_field_info.Clear();
2907	}
2908
2909	CompilerType member_clang_type = member_type->GetLayoutCompilerType ();
2910	if (!member_clang_type.IsCompleteType())
2911	member_clang_type.GetCompleteType();
2912
2913	{
2914	// Older versions of clang emit array[0] and array[1] in the same way (<rdar://problem/12566646>).
2915	// If the current field is at the end of the structure, then there is definitely no room for extra
2916	// elements and we override the type to array[0].
2917
2918	CompilerType member_array_element_type;
2919	uint64_t member_array_size;
2920	bool member_array_is_incomplete;
2921
2922	if (member_clang_type.IsArrayType(&member_array_element_type,
2923	&member_array_size,
2924	&member_array_is_incomplete) &&
2925	!member_array_is_incomplete)
2926	{
2927	uint64_t parent_byte_size = parent_die.GetAttributeValueAsUnsigned(DW_AT_byte_size, UINT64_MAX(18446744073709551615UL));
2928
2929	if (member_byte_offset >= parent_byte_size)
2930	{
2931	if (member_array_size != 1)
2932	{
2933	module_sp->ReportError ("0x%8.8" PRIx64"l" "x" ": DW_TAG_member '%s' refers to type 0x%8.8" PRIx64"l" "x" " which extends beyond the bounds of 0x%8.8" PRIx64"l" "x",
2934	die.GetID(),
2935	name,
2936	encoding_form.Reference(),
2937	parent_die.GetID());
2938	}
2939
2940	member_clang_type = m_ast.CreateArrayType(member_array_element_type, 0, false);
2941	}
2942	}
2943	}
2944
2945	if (ClangASTContext::IsCXXClassType(member_clang_type) && member_clang_type.GetCompleteType() == false)
2946	{
2947	if (die.GetCU()->GetProducer() == DWARFCompileUnit::eProducerClang)
2948	module_sp->ReportError ("DWARF DIE at 0x%8.8x (class %s) has a member variable 0x%8.8x (%s) whose type is a forward declaration, not a complete definition.\nTry compiling the source file with -fno-limit-debug-info",
2949	parent_die.GetOffset(),
2950	parent_die.GetName(),
2951	die.GetOffset(),
2952	name);
2953	else
2954	module_sp->ReportError ("DWARF DIE at 0x%8.8x (class %s) has a member variable 0x%8.8x (%s) whose type is a forward declaration, not a complete definition.\nPlease file a bug against the compiler and include the preprocessed output for %s",
2955	parent_die.GetOffset(),
2956	parent_die.GetName(),
2957	die.GetOffset(),
2958	name,
2959	sc.comp_unit ? sc.comp_unit->GetPath().c_str() : "the source file");
2960	// We have no choice other than to pretend that the member class
2961	// is complete. If we don't do this, clang will crash when trying
2962	// to layout the class. Since we provide layout assistance, all
2963	// ivars in this class and other classes will be fine, this is
2964	// the best we can do short of crashing.
2965	ClangASTContext::StartTagDeclarationDefinition(member_clang_type);
2966	ClangASTContext::CompleteTagDeclarationDefinition(member_clang_type);
2967	}
2968
2969	field_decl = ClangASTContext::AddFieldToRecordType (class_clang_type,
2970	name,
2971	member_clang_type,
2972	accessibility,
2973	bit_size);
2974
2975	m_ast.SetMetadataAsUserID (field_decl, die.GetID());
2976
2977	layout_info.field_offsets.insert(std::make_pair(field_decl, field_bit_offset));
2978	}
2979	else
2980	{
2981	if (name)
2982	module_sp->ReportError ("0x%8.8" PRIx64"l" "x" ": DW_TAG_member '%s' refers to type 0x%8.8" PRIx64"l" "x" " which was unable to be parsed",
2983	die.GetID(),
2984	name,
2985	encoding_form.Reference());
2986	else
2987	module_sp->ReportError ("0x%8.8" PRIx64"l" "x" ": DW_TAG_member refers to type 0x%8.8" PRIx64"l" "x" " which was unable to be parsed",
2988	die.GetID(),
2989	encoding_form.Reference());
2990	}
2991	}
2992
2993	if (prop_name != NULL__null && member_type)
2994	{
2995	clang::ObjCIvarDecl *ivar_decl = NULL__null;
2996
2997	if (field_decl)
2998	{
2999	ivar_decl = clang::dyn_cast<clang::ObjCIvarDecl>(field_decl);
3000	assert (ivar_decl != NULL)((ivar_decl != __null) ? static_cast<void> (0) : __assert_fail ("ivar_decl != __null", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp" , 3000, __PRETTY_FUNCTION__));
3001	}
3002
3003	ClangASTMetadata metadata;
3004	metadata.SetUserID (die.GetID());
3005	delayed_properties.push_back(DelayedAddObjCClassProperty(class_clang_type,
3006	prop_name,
3007	member_type->GetLayoutCompilerType (),
3008	ivar_decl,
3009	prop_setter_name,
3010	prop_getter_name,
3011	prop_attributes,
3012	&metadata));
3013
3014	if (ivar_decl)
3015	m_ast.SetMetadataAsUserID (ivar_decl, die.GetID());
3016	}
3017	}
3018	}
3019	++member_idx;
3020	}
3021	break;
3022
3023	case DW_TAG_subprogram:
3024	// Let the type parsing code handle this one for us.
3025	member_function_dies.Append (die);
3026	break;
3027
3028	case DW_TAG_inheritance:
3029	{
3030	is_a_class = true;
3031	if (default_accessibility == eAccessNone)
3032	default_accessibility = eAccessPrivate;
3033	// TODO: implement DW_TAG_inheritance type parsing
3034	DWARFAttributes attributes;
3035	const size_t num_attributes = die.GetAttributes (attributes);
3036	if (num_attributes > 0)
3037	{
3038	Declaration decl;
3039	DWARFExpression location(die.GetCU());
3040	DWARFFormValue encoding_form;
3041	AccessType accessibility = default_accessibility;
3042	bool is_virtual = false;
3043	bool is_base_of_class = true;
3044	off_t member_byte_offset = 0;
3045	uint32_t i;
3046	for (i=0; i<num_attributes; ++i)
3047	{
3048	const dw_attr_t attr = attributes.AttributeAtIndex(i);
3049	DWARFFormValue form_value;
3050	if (attributes.ExtractFormValueAtIndex(i, form_value))
3051	{
3052	switch (attr)
3053	{
3054	case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
3055	case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break;
3056	case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
3057	case DW_AT_type: encoding_form = form_value; break;
3058	case DW_AT_data_member_location:
3059	if (form_value.BlockData())
3060	{
3061	Value initialValue(0);
3062	Value memberOffset(0);
3063	const DWARFDataExtractor& debug_info_data = die.GetDWARF()->get_debug_info_data();
3064	uint32_t block_length = form_value.Unsigned();
3065	uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();
3066	if (DWARFExpression::Evaluate (NULL__null,
3067	NULL__null,
3068	NULL__null,
3069	NULL__null,
3070	module_sp,
3071	debug_info_data,
3072	die.GetCU(),
3073	block_offset,
3074	block_length,
3075	eRegisterKindDWARF,
3076	&initialValue,
3077	memberOffset,
3078	NULL__null))
3079	{
3080	member_byte_offset = memberOffset.ResolveValue(NULL__null).UInt();
3081	}
3082	}
3083	else
3084	{
3085	// With DWARF 3 and later, if the value is an integer constant,
3086	// this form value is the offset in bytes from the beginning
3087	// of the containing entity.
3088	member_byte_offset = form_value.Unsigned();
3089	}
3090	break;
3091
3092	case DW_AT_accessibility:
3093	accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned());
3094	break;
3095
3096	case DW_AT_virtuality:
3097	is_virtual = form_value.Boolean();
3098	break;
3099
3100	case DW_AT_sibling:
3101	break;
3102
3103	default:
3104	break;
3105	}
3106	}
3107	}
3108
3109	Type *base_class_type = die.ResolveTypeUID(DIERef(encoding_form).GetUID());
3110	if (base_class_type == NULL__null)
3111	{
3112	module_sp->ReportError("0x%8.8x: DW_TAG_inheritance failed to resolve the base class at 0x%8.8" PRIx64"l" "x" " from enclosing type 0x%8.8x. \nPlease file a bug and attach the file at the start of this error message",
3113	die.GetOffset(),
3114	encoding_form.Reference(),
3115	parent_die.GetOffset());
3116	break;
3117	}
3118
3119	CompilerType base_class_clang_type = base_class_type->GetFullCompilerType ();
3120	assert (base_class_clang_type)((base_class_clang_type) ? static_cast<void> (0) : __assert_fail ("base_class_clang_type", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp" , 3120, __PRETTY_FUNCTION__));
3121	if (class_language == eLanguageTypeObjC)
3122	{
3123	ast->SetObjCSuperClass(class_clang_type, base_class_clang_type);
3124	}
3125	else
3126	{
3127	base_classes.push_back (ast->CreateBaseClassSpecifier (base_class_clang_type.GetOpaqueQualType(),
3128	accessibility,
3129	is_virtual,
3130	is_base_of_class));
3131
3132	if (is_virtual)
3133	{
3134	// Do not specify any offset for virtual inheritance. The DWARF produced by clang doesn't
3135	// give us a constant offset, but gives us a DWARF expressions that requires an actual object
3136	// in memory. the DW_AT_data_member_location for a virtual base class looks like:
3137	// DW_AT_data_member_location( DW_OP_dup, DW_OP_deref, DW_OP_constu(0x00000018), DW_OP_minus, DW_OP_deref, DW_OP_plus )
3138	// Given this, there is really no valid response we can give to clang for virtual base
3139	// class offsets, and this should eventually be removed from LayoutRecordType() in the external
3140	// AST source in clang.
3141	}
3142	else
3143	{
3144	layout_info.base_offsets.insert(
3145	std::make_pair(ast->GetAsCXXRecordDecl(base_class_clang_type.GetOpaqueQualType()),
3146	clang::CharUnits::fromQuantity(member_byte_offset)));
3147	}
3148	}
3149	}
3150	}
3151	break;
3152
3153	default:
3154	break;
3155	}
3156	}
3157
3158	return true;
3159	}
3160
3161
3162	size_t
3163	DWARFASTParserClang::ParseChildParameters (const SymbolContext& sc,
3164	clang::DeclContext *containing_decl_ctx,
3165	const DWARFDIE &parent_die,
3166	bool skip_artificial,
3167	bool &is_static,
3168	bool &is_variadic,
3169	std::vector<CompilerType>& function_param_types,
3170	std::vector<clang::ParmVarDecl*>& function_param_decls,
3171	unsigned &type_quals)
3172	{
3173	if (!parent_die)
3174	return 0;
3175
3176	size_t arg_idx = 0;
3177	for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
3178	{
3179	const dw_tag_t tag = die.Tag();
3180	switch (tag)
3181	{
3182	case DW_TAG_formal_parameter:
3183	{
3184	DWARFAttributes attributes;
3185	const size_t num_attributes = die.GetAttributes(attributes);
3186	if (num_attributes > 0)
3187	{
3188	const char *name = NULL__null;
3189	Declaration decl;
3190	DWARFFormValue param_type_die_form;
3191	bool is_artificial = false;
3192	// one of None, Auto, Register, Extern, Static, PrivateExtern
3193
3194	clang::StorageClass storage = clang::SC_None;
3195	uint32_t i;
3196	for (i=0; i<num_attributes; ++i)
3197	{
3198	const dw_attr_t attr = attributes.AttributeAtIndex(i);
3199	DWARFFormValue form_value;
3200	if (attributes.ExtractFormValueAtIndex(i, form_value))
3201	{
3202	switch (attr)
3203	{
3204	case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
3205	case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break;
3206	case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
3207	case DW_AT_name: name = form_value.AsCString();
3208	break;
3209	case DW_AT_type: param_type_die_form = form_value; break;
3210	case DW_AT_artificial: is_artificial = form_value.Boolean(); break;
3211	case DW_AT_location:
3212	// if (form_value.BlockData())
3213	// {
3214	// const DWARFDataExtractor& debug_info_data = debug_info();
3215	// uint32_t block_length = form_value.Unsigned();
3216	// DWARFDataExtractor location(debug_info_data, form_value.BlockData() - debug_info_data.GetDataStart(), block_length);
3217	// }
3218	// else
3219	// {
3220	// }
3221	// break;
3222	case DW_AT_const_value:
3223	case DW_AT_default_value:
3224	case DW_AT_description:
3225	case DW_AT_endianity:
3226	case DW_AT_is_optional:
3227	case DW_AT_segment:
3228	case DW_AT_variable_parameter:
3229	default:
3230	case DW_AT_abstract_origin:
3231	case DW_AT_sibling:
3232	break;
3233	}
3234	}
3235	}
3236
3237	bool skip = false;
3238	if (skip_artificial)
3239	{
3240	if (is_artificial)
3241	{
3242	// In order to determine if a C++ member function is
3243	// "const" we have to look at the const-ness of "this"...
3244	// Ugly, but that
3245	if (arg_idx == 0)
3246	{
3247	if (DeclKindIsCXXClass(containing_decl_ctx->getDeclKind()))
3248	{
3249	// Often times compilers omit the "this" name for the
3250	// specification DIEs, so we can't rely upon the name
3251	// being in the formal parameter DIE...
3252	if (name == NULL__null \|\| ::strcmp(name, "this")==0)
3253	{
3254	Type *this_type = die.ResolveTypeUID (DIERef(param_type_die_form).GetUID());
3255	if (this_type)
3256	{
3257	uint32_t encoding_mask = this_type->GetEncodingMask();
3258	if (encoding_mask & Type::eEncodingIsPointerUID)
3259	{
3260	is_static = false;
3261
3262	if (encoding_mask & (1u << Type::eEncodingIsConstUID))
3263	type_quals \|= clang::Qualifiers::Const;
3264	if (encoding_mask & (1u << Type::eEncodingIsVolatileUID))
3265	type_quals \|= clang::Qualifiers::Volatile;
3266	}
3267	}
3268	}
3269	}
3270	}
3271	skip = true;
3272	}
3273	else
3274	{
3275
3276	// HACK: Objective C formal parameters "self" and "_cmd"
3277	// are not marked as artificial in the DWARF...
3278	CompileUnit *comp_unit = die.GetLLDBCompileUnit();
3279	if (comp_unit)
3280	{
3281	switch (comp_unit->GetLanguage())
3282	{
3283	case eLanguageTypeObjC:
3284	case eLanguageTypeObjC_plus_plus:
3285	if (name && name[0] && (strcmp (name, "self") == 0 \|\| strcmp (name, "_cmd") == 0))
3286	skip = true;
3287	break;
3288	default:
3289	break;
3290	}
3291	}
3292	}
3293	}
3294
3295	if (!skip)
3296	{
3297	Type *type = die.ResolveTypeUID(DIERef(param_type_die_form).GetUID());
3298	if (type)
3299	{
3300	function_param_types.push_back (type->GetForwardCompilerType ());
3301
3302	clang::ParmVarDecl *param_var_decl = m_ast.CreateParameterDeclaration (name,
3303	type->GetForwardCompilerType (),
3304	storage);
3305	assert(param_var_decl)((param_var_decl) ? static_cast<void> (0) : __assert_fail ("param_var_decl", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp" , 3305, __PRETTY_FUNCTION__));
3306	function_param_decls.push_back(param_var_decl);
3307
3308	m_ast.SetMetadataAsUserID (param_var_decl, die.GetID());
3309	}
3310	}
3311	}
3312	arg_idx++;
3313	}
3314	break;
3315
3316	case DW_TAG_unspecified_parameters:
3317	is_variadic = true;
3318	break;
3319
3320	case DW_TAG_template_type_parameter:
3321	case DW_TAG_template_value_parameter:
3322	// The one caller of this was never using the template_param_infos,
3323	// and the local variable was taking up a large amount of stack space
3324	// in SymbolFileDWARF::ParseType() so this was removed. If we ever need
3325	// the template params back, we can add them back.
3326	// ParseTemplateDIE (dwarf_cu, die, template_param_infos);
3327	break;
3328
3329	default:
3330	break;
3331	}
3332	}
3333	return arg_idx;
3334	}
3335
3336	void
3337	DWARFASTParserClang::ParseChildArrayInfo (const SymbolContext& sc,
3338	const DWARFDIE &parent_die,
3339	int64_t& first_index,
3340	std::vector<uint64_t>& element_orders,
3341	uint32_t& byte_stride,
3342	uint32_t& bit_stride)
3343	{
3344	if (!parent_die)
3345	return;
3346
3347	for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
3348	{
3349	const dw_tag_t tag = die.Tag();
3350	switch (tag)
3351	{
3352	case DW_TAG_subrange_type:
3353	{
3354	DWARFAttributes attributes;
3355	const size_t num_child_attributes = die.GetAttributes(attributes);
3356	if (num_child_attributes > 0)
3357	{
3358	uint64_t num_elements = 0;
3359	uint64_t lower_bound = 0;
3360	uint64_t upper_bound = 0;
3361	bool upper_bound_valid = false;
3362	uint32_t i;
3363	for (i=0; i<num_child_attributes; ++i)
3364	{
3365	const dw_attr_t attr = attributes.AttributeAtIndex(i);
3366	DWARFFormValue form_value;
3367	if (attributes.ExtractFormValueAtIndex(i, form_value))
3368	{
3369	switch (attr)
3370	{
3371	case DW_AT_name:
3372	break;
3373
3374	case DW_AT_count:
3375	num_elements = form_value.Unsigned();
3376	break;
3377
3378	case DW_AT_bit_stride:
3379	bit_stride = form_value.Unsigned();
3380	break;
3381
3382	case DW_AT_byte_stride:
3383	byte_stride = form_value.Unsigned();
3384	break;
3385
3386	case DW_AT_lower_bound:
3387	lower_bound = form_value.Unsigned();
3388	break;
3389
3390	case DW_AT_upper_bound:
3391	upper_bound_valid = true;
3392	upper_bound = form_value.Unsigned();
3393	break;
3394
3395	default:
3396	case DW_AT_abstract_origin:
3397	case DW_AT_accessibility:
3398	case DW_AT_allocated:
3399	case DW_AT_associated:
3400	case DW_AT_data_location:
3401	case DW_AT_declaration:
3402	case DW_AT_description:
3403	case DW_AT_sibling:
3404	case DW_AT_threads_scaled:
3405	case DW_AT_type:
3406	case DW_AT_visibility:
3407	break;
3408	}
3409	}
3410	}
3411
3412	if (num_elements == 0)
3413	{
3414	if (upper_bound_valid && upper_bound >= lower_bound)
3415	num_elements = upper_bound - lower_bound + 1;
3416	}
3417
3418	element_orders.push_back (num_elements);
3419	}
3420	}
3421	break;
3422	}
3423	}
3424	}
3425
3426	Type *
3427	DWARFASTParserClang::GetTypeForDIE (const DWARFDIE &die)
3428	{
3429	if (die)
3430	{
3431	SymbolFileDWARF *dwarf = die.GetDWARF();
3432	DWARFAttributes attributes;
3433	const size_t num_attributes = die.GetAttributes(attributes);
3434	if (num_attributes > 0)
3435	{
3436	DWARFFormValue type_die_form;
3437	for (size_t i = 0; i < num_attributes; ++i)
3438	{
3439	dw_attr_t attr = attributes.AttributeAtIndex(i);
3440	DWARFFormValue form_value;
3441
3442	if (attr == DW_AT_type && attributes.ExtractFormValueAtIndex(i, form_value))
3443	return dwarf->ResolveTypeUID(DIERef(form_value).GetUID());
3444	}
3445	}
3446	}
3447
3448	return nullptr;
3449	}
3450
3451	clang::Decl *
3452	DWARFASTParserClang::GetClangDeclForDIE (const DWARFDIE &die)
3453	{
3454	if (!die)
3455	return nullptr;
3456
3457	switch (die.Tag())
3458	{
3459	case DW_TAG_variable:
3460	case DW_TAG_constant:
3461	case DW_TAG_formal_parameter:
3462	case DW_TAG_imported_declaration:
3463	case DW_TAG_imported_module:
3464	break;
3465	default:
3466	return nullptr;
3467	}
3468
3469	DIEToDeclMap::iterator cache_pos = m_die_to_decl.find(die.GetDIE());
3470	if (cache_pos != m_die_to_decl.end())
3471	return cache_pos->second;
3472
3473	if (DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification))
3474	{
3475	clang::Decl *decl = GetClangDeclForDIE(spec_die);
3476	m_die_to_decl[die.GetDIE()] = decl;
3477	m_decl_to_die[decl].insert(die.GetDIE());
3478	return decl;
3479	}
3480
3481	clang::Decl *decl = nullptr;
3482	switch (die.Tag())
3483	{
3484	case DW_TAG_variable:
3485	case DW_TAG_constant:
3486	case DW_TAG_formal_parameter:
3487	{
3488	SymbolFileDWARF *dwarf = die.GetDWARF();
3489	Type *type = GetTypeForDIE(die);
3490	const char *name = die.GetName();
3491	clang::DeclContext *decl_context = ClangASTContext::DeclContextGetAsDeclContext(dwarf->GetDeclContextContainingUID(die.GetID()));
3492	decl = m_ast.CreateVariableDeclaration(
3493	decl_context,
3494	name,
3495	ClangASTContext::GetQualType(type->GetForwardCompilerType()));
3496	break;
3497	}
3498	case DW_TAG_imported_declaration:
3499	{
3500	SymbolFileDWARF *dwarf = die.GetDWARF();
3501	lldb::user_id_t imported_uid = die.GetAttributeValueAsReference(DW_AT_import, DW_INVALID_OFFSET(~(dw_offset_t)0));
3502
3503	if (dwarf->UserIDMatches(imported_uid))
3504	{
3505	CompilerDecl imported_decl = dwarf->GetDeclForUID(imported_uid);
3506	if (imported_decl)
3507	{
3508	clang::DeclContext *decl_context = ClangASTContext::DeclContextGetAsDeclContext(dwarf->GetDeclContextContainingUID(die.GetID()));
3509	if (clang::NamedDecl clang_imported_decl = llvm::dyn_cast<clang::NamedDecl>((clang::Decl )imported_decl.GetOpaqueDecl()))
3510	decl = m_ast.CreateUsingDeclaration(decl_context, clang_imported_decl);
3511	}
3512	}
3513	break;
3514	}
3515	case DW_TAG_imported_module:
3516	{
3517	SymbolFileDWARF *dwarf = die.GetDWARF();
3518	lldb::user_id_t imported_uid = die.GetAttributeValueAsReference(DW_AT_import, DW_INVALID_OFFSET(~(dw_offset_t)0));
3519
3520	if (dwarf->UserIDMatches(imported_uid))
3521	{
3522	CompilerDeclContext imported_decl = dwarf->GetDeclContextForUID(imported_uid);
3523	if (imported_decl)
3524	{
3525	clang::DeclContext *decl_context = ClangASTContext::DeclContextGetAsDeclContext(dwarf->GetDeclContextContainingUID(die.GetID()));
3526	if (clang::NamespaceDecl *ns_decl = ClangASTContext::DeclContextGetAsNamespaceDecl(imported_decl))
3527	decl = m_ast.CreateUsingDirectiveDeclaration(decl_context, ns_decl);
3528	}
3529	}
3530	break;
3531	}
3532	default:
3533	break;
3534	}
3535
3536	m_die_to_decl[die.GetDIE()] = decl;
3537	m_decl_to_die[decl].insert(die.GetDIE());
3538
3539	return decl;
3540	}
3541
3542	clang::DeclContext *
3543	DWARFASTParserClang::GetClangDeclContextForDIE (const DWARFDIE &die)
3544	{
3545	if (die)
3546	{
3547	clang::DeclContext *decl_ctx = GetCachedClangDeclContextForDIE (die);
3548	if (decl_ctx)
3549	return decl_ctx;
3550
3551	bool try_parsing_type = true;
3552	switch (die.Tag())
3553	{
3554	case DW_TAG_compile_unit:
3555	decl_ctx = m_ast.GetTranslationUnitDecl();
3556	try_parsing_type = false;
3557	break;
3558
3559	case DW_TAG_namespace:
3560	decl_ctx = ResolveNamespaceDIE (die);
3561	try_parsing_type = false;
3562	break;
3563
3564	case DW_TAG_lexical_block:
3565	decl_ctx = (clang::DeclContext *)ResolveBlockDIE(die);
3566	try_parsing_type = false;
3567	break;
3568
3569	default:
3570	break;
3571	}
3572
3573	if (decl_ctx == nullptr && try_parsing_type)
3574	{
3575	Type* type = die.GetDWARF()->ResolveType (die);
3576	if (type)
3577	decl_ctx = GetCachedClangDeclContextForDIE (die);
3578	}
3579
3580	if (decl_ctx)
3581	{
3582	LinkDeclContextToDIE (decl_ctx, die);
3583	return decl_ctx;
3584	}
3585	}
3586	return nullptr;
3587	}
3588
3589	clang::BlockDecl *
3590	DWARFASTParserClang::ResolveBlockDIE (const DWARFDIE &die)
3591	{
3592	if (die && die.Tag() == DW_TAG_lexical_block)
3593	{
3594	clang::BlockDecl *decl = llvm::cast_or_null<clang::BlockDecl>(m_die_to_decl_ctx[die.GetDIE()]);
3595
3596	if (!decl)
3597	{
3598	DWARFDIE decl_context_die;
3599	clang::DeclContext *decl_context = GetClangDeclContextContainingDIE(die, &decl_context_die);
3600	decl = m_ast.CreateBlockDeclaration(decl_context);
3601
3602	if (decl)
3603	LinkDeclContextToDIE((clang::DeclContext *)decl, die);
3604	}
3605
3606	return decl;
3607	}
3608	return nullptr;
3609	}
3610
3611	clang::NamespaceDecl *
3612	DWARFASTParserClang::ResolveNamespaceDIE (const DWARFDIE &die)
3613	{
3614	if (die && die.Tag() == DW_TAG_namespace)
3615	{
3616	// See if we already parsed this namespace DIE and associated it with a
3617	// uniqued namespace declaration
3618	clang::NamespaceDecl namespace_decl = static_cast<clang::NamespaceDecl >(m_die_to_decl_ctx[die.GetDIE()]);
3619	if (namespace_decl)
3620	return namespace_decl;
3621	else
3622	{
3623	const char *namespace_name = die.GetName();
3624	clang::DeclContext *containing_decl_ctx = GetClangDeclContextContainingDIE (die, nullptr);
3625	namespace_decl = m_ast.GetUniqueNamespaceDeclaration (namespace_name, containing_decl_ctx);
3626	Log *log = nullptr;// (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
3627	if (log)
3628	{
3629	SymbolFileDWARF *dwarf = die.GetDWARF();
3630	if (namespace_name)
3631	{
3632	dwarf->GetObjectFile()->GetModule()->LogMessage (log,
3633	"ASTContext => %p: 0x%8.8" PRIx64"l" "x" ": DW_TAG_namespace with DW_AT_name(\"%s\") => clang::NamespaceDecl *%p (original = %p)",
3634	static_cast<void*>(m_ast.getASTContext()),
3635	die.GetID(),
3636	namespace_name,
3637	static_cast<void*>(namespace_decl),
3638	static_cast<void*>(namespace_decl->getOriginalNamespace()));
3639	}
3640	else
3641	{
3642	dwarf->GetObjectFile()->GetModule()->LogMessage (log,
3643	"ASTContext => %p: 0x%8.8" PRIx64"l" "x" ": DW_TAG_namespace (anonymous) => clang::NamespaceDecl *%p (original = %p)",
3644	static_cast<void*>(m_ast.getASTContext()),
3645	die.GetID(),
3646	static_cast<void*>(namespace_decl),
3647	static_cast<void*>(namespace_decl->getOriginalNamespace()));
3648	}
3649	}
3650
3651	if (namespace_decl)
3652	LinkDeclContextToDIE((clang::DeclContext*)namespace_decl, die);
3653	return namespace_decl;
3654	}
3655	}
3656	return nullptr;
3657	}
3658
3659	clang::DeclContext *
3660	DWARFASTParserClang::GetClangDeclContextContainingDIE (const DWARFDIE &die,
3661	DWARFDIE *decl_ctx_die_copy)
3662	{
3663	SymbolFileDWARF *dwarf = die.GetDWARF();
3664
3665	DWARFDIE decl_ctx_die = dwarf->GetDeclContextDIEContainingDIE (die);
3666
3667	if (decl_ctx_die_copy)
3668	*decl_ctx_die_copy = decl_ctx_die;
3669
3670	if (decl_ctx_die)
3671	{
3672	clang::DeclContext *clang_decl_ctx = GetClangDeclContextForDIE (decl_ctx_die);
3673	if (clang_decl_ctx)
3674	return clang_decl_ctx;
3675	}
3676	return m_ast.GetTranslationUnitDecl();
3677	}
3678
3679	clang::DeclContext *
3680	DWARFASTParserClang::GetCachedClangDeclContextForDIE (const DWARFDIE &die)
3681	{
3682	if (die)
3683	{
3684	DIEToDeclContextMap::iterator pos = m_die_to_decl_ctx.find(die.GetDIE());
3685	if (pos != m_die_to_decl_ctx.end())
3686	return pos->second;
3687	}
3688	return nullptr;
3689	}
3690
3691	void
3692	DWARFASTParserClang::LinkDeclContextToDIE (clang::DeclContext *decl_ctx, const DWARFDIE &die)
3693	{
3694	m_die_to_decl_ctx[die.GetDIE()] = decl_ctx;
3695	// There can be many DIEs for a single decl context
3696	//m_decl_ctx_to_die[decl_ctx].insert(die.GetDIE());
3697	m_decl_ctx_to_die.insert(std::make_pair(decl_ctx, die));
3698	}
3699
3700	bool
3701	DWARFASTParserClang::CopyUniqueClassMethodTypes (const DWARFDIE &src_class_die,
3702	const DWARFDIE &dst_class_die,
3703	lldb_private::Type *class_type,
3704	DWARFDIECollection &failures)
3705	{
3706	if (!class_type \|\| !src_class_die \|\| !dst_class_die)
3707	return false;
3708	if (src_class_die.Tag() != dst_class_die.Tag())
3709	return false;
3710
3711	// We need to complete the class type so we can get all of the method types
3712	// parsed so we can then unique those types to their equivalent counterparts
3713	// in "dst_cu" and "dst_class_die"
3714	class_type->GetFullCompilerType ();
3715
3716	DWARFDIE src_die;
3717	DWARFDIE dst_die;
3718	UniqueCStringMap<DWARFDIE> src_name_to_die;
3719	UniqueCStringMap<DWARFDIE> dst_name_to_die;
3720	UniqueCStringMap<DWARFDIE> src_name_to_die_artificial;
3721	UniqueCStringMap<DWARFDIE> dst_name_to_die_artificial;
3722	for (src_die = src_class_die.GetFirstChild(); src_die.IsValid(); src_die = src_die.GetSibling())
3723	{
3724	if (src_die.Tag() == DW_TAG_subprogram)
3725	{
3726	// Make sure this is a declaration and not a concrete instance by looking
3727	// for DW_AT_declaration set to 1. Sometimes concrete function instances
3728	// are placed inside the class definitions and shouldn't be included in
3729	// the list of things are are tracking here.
3730	if (src_die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0) == 1)
3731	{
3732	const char *src_name = src_die.GetMangledName ();
3733	if (src_name)
3734	{
3735	ConstString src_const_name(src_name);
3736	if (src_die.GetAttributeValueAsUnsigned(DW_AT_artificial, 0))
3737	src_name_to_die_artificial.Append(src_const_name.GetCString(), src_die);
3738	else
3739	src_name_to_die.Append(src_const_name.GetCString(), src_die);
3740	}
3741	}
3742	}
3743	}
3744	for (dst_die = dst_class_die.GetFirstChild(); dst_die.IsValid(); dst_die = dst_die.GetSibling())
3745	{
3746	if (dst_die.Tag() == DW_TAG_subprogram)
3747	{
3748	// Make sure this is a declaration and not a concrete instance by looking
3749	// for DW_AT_declaration set to 1. Sometimes concrete function instances
3750	// are placed inside the class definitions and shouldn't be included in
3751	// the list of things are are tracking here.
3752	if (dst_die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0) == 1)
3753	{
3754	const char *dst_name = dst_die.GetMangledName ();
3755	if (dst_name)
3756	{
3757	ConstString dst_const_name(dst_name);
3758	if ( dst_die.GetAttributeValueAsUnsigned(DW_AT_artificial, 0))
3759	dst_name_to_die_artificial.Append(dst_const_name.GetCString(), dst_die);
3760	else
3761	dst_name_to_die.Append(dst_const_name.GetCString(), dst_die);
3762	}
3763	}
3764	}
3765	}
3766	const uint32_t src_size = src_name_to_die.GetSize ();
3767	const uint32_t dst_size = dst_name_to_die.GetSize ();
3768	Log *log = nullptr; // (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO \| DWARF_LOG_TYPE_COMPLETION));
3769
3770	// Is everything kosher so we can go through the members at top speed?
3771	bool fast_path = true;
3772
3773	if (src_size != dst_size)
3774	{
3775	if (src_size != 0 && dst_size != 0)
3776	{
3777	if (log)
3778	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)",
3779	src_class_die.GetOffset(),
3780	dst_class_die.GetOffset(),
3781	src_size,
3782	dst_size);
3783	}
3784
3785	fast_path = false;
3786	}
3787
3788	uint32_t idx;
3789
3790	if (fast_path)
3791	{
3792	for (idx = 0; idx < src_size; ++idx)
3793	{
3794	src_die = src_name_to_die.GetValueAtIndexUnchecked (idx);
3795	dst_die = dst_name_to_die.GetValueAtIndexUnchecked (idx);
3796
3797	if (src_die.Tag() != dst_die.Tag())
3798	{
3799	if (log)
3800	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)",
3801	src_class_die.GetOffset(),
3802	dst_class_die.GetOffset(),
3803	src_die.GetOffset(),
3804	src_die.GetTagAsCString(),
3805	dst_die.GetOffset(),
3806	dst_die.GetTagAsCString());
3807	fast_path = false;
3808	}
3809
3810	const char *src_name = src_die.GetMangledName ();
3811	const char *dst_name = dst_die.GetMangledName ();
3812
3813	// Make sure the names match
3814	if (src_name == dst_name \|\| (strcmp (src_name, dst_name) == 0))
3815	continue;
3816
3817	if (log)
3818	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)",
3819	src_class_die.GetOffset(),
3820	dst_class_die.GetOffset(),
3821	src_die.GetOffset(),
3822	src_name,
3823	dst_die.GetOffset(),
3824	dst_name);
3825
3826	fast_path = false;
3827	}
3828	}
3829
3830	DWARFASTParserClang src_dwarf_ast_parser = (DWARFASTParserClang )src_die.GetDWARFParser();
3831	DWARFASTParserClang dst_dwarf_ast_parser = (DWARFASTParserClang )dst_die.GetDWARFParser();
3832
3833	// Now do the work of linking the DeclContexts and Types.
3834	if (fast_path)
3835	{
3836	// We can do this quickly. Just run across the tables index-for-index since
3837	// we know each node has matching names and tags.
3838	for (idx = 0; idx < src_size; ++idx)
3839	{
3840	src_die = src_name_to_die.GetValueAtIndexUnchecked (idx);
3841	dst_die = dst_name_to_die.GetValueAtIndexUnchecked (idx);
3842
3843	clang::DeclContext *src_decl_ctx = src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
3844	if (src_decl_ctx)
3845	{
3846	if (log)
3847	log->Printf ("uniquing decl context %p from 0x%8.8x for 0x%8.8x",
3848	static_cast<void*>(src_decl_ctx),
3849	src_die.GetOffset(), dst_die.GetOffset());
3850	dst_dwarf_ast_parser->LinkDeclContextToDIE (src_decl_ctx, dst_die);
3851	}
3852	else
3853	{
3854	if (log)
3855	log->Printf ("warning: tried to unique decl context from 0x%8.8x for 0x%8.8x, but none was found",
3856	src_die.GetOffset(), dst_die.GetOffset());
3857	}
3858
3859	Type *src_child_type = dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
3860	if (src_child_type)
3861	{
3862	if (log)
3863	log->Printf ("uniquing type %p (uid=0x%" PRIx64"l" "x" ") from 0x%8.8x for 0x%8.8x",
3864	static_cast<void*>(src_child_type),
3865	src_child_type->GetID(),
3866	src_die.GetOffset(), dst_die.GetOffset());
3867	dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;
3868	}
3869	else
3870	{
3871	if (log)
3872	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());
3873	}
3874	}
3875	}
3876	else
3877	{
3878	// We must do this slowly. For each member of the destination, look
3879	// up a member in the source with the same name, check its tag, and
3880	// unique them if everything matches up. Report failures.
3881
3882	if (!src_name_to_die.IsEmpty() && !dst_name_to_die.IsEmpty())
3883	{
3884	src_name_to_die.Sort();
3885
3886	for (idx = 0; idx < dst_size; ++idx)
3887	{
3888	const char *dst_name = dst_name_to_die.GetCStringAtIndex(idx);
3889	dst_die = dst_name_to_die.GetValueAtIndexUnchecked(idx);
3890	src_die = src_name_to_die.Find(dst_name, DWARFDIE());
3891
3892	if (src_die && (src_die.Tag() == dst_die.Tag()))
3893	{
3894	clang::DeclContext *src_decl_ctx = src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
3895	if (src_decl_ctx)
3896	{
3897	if (log)
3898	log->Printf ("uniquing decl context %p from 0x%8.8x for 0x%8.8x",
3899	static_cast<void*>(src_decl_ctx),
3900	src_die.GetOffset(),
3901	dst_die.GetOffset());
3902	dst_dwarf_ast_parser->LinkDeclContextToDIE (src_decl_ctx, dst_die);
3903	}
3904	else
3905	{
3906	if (log)
3907	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());
3908	}
3909
3910	Type *src_child_type = dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
3911	if (src_child_type)
3912	{
3913	if (log)
3914	log->Printf ("uniquing type %p (uid=0x%" PRIx64"l" "x" ") from 0x%8.8x for 0x%8.8x",
3915	static_cast<void*>(src_child_type),
3916	src_child_type->GetID(),
3917	src_die.GetOffset(),
3918	dst_die.GetOffset());
3919	dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;
3920	}
3921	else
3922	{
3923	if (log)
3924	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());
3925	}
3926	}
3927	else
3928	{
3929	if (log)
3930	log->Printf ("warning: couldn't find a match for 0x%8.8x", dst_die.GetOffset());
3931
3932	failures.Append(dst_die);
3933	}
3934	}
3935	}
3936	}
3937
3938	const uint32_t src_size_artificial = src_name_to_die_artificial.GetSize ();
3939	const uint32_t dst_size_artificial = dst_name_to_die_artificial.GetSize ();
3940
3941	if (src_size_artificial && dst_size_artificial)
3942	{
3943	dst_name_to_die_artificial.Sort();
3944
3945	for (idx = 0; idx < src_size_artificial; ++idx)
3946	{
3947	const char *src_name_artificial = src_name_to_die_artificial.GetCStringAtIndex(idx);
3948	src_die = src_name_to_die_artificial.GetValueAtIndexUnchecked (idx);
3949	dst_die = dst_name_to_die_artificial.Find(src_name_artificial, DWARFDIE());
3950
3951	if (dst_die)
3952	{
3953	// Both classes have the artificial types, link them
3954	clang::DeclContext *src_decl_ctx = src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
3955	if (src_decl_ctx)
3956	{
3957	if (log)
3958	log->Printf ("uniquing decl context %p from 0x%8.8x for 0x%8.8x",
3959	static_cast<void*>(src_decl_ctx),
3960	src_die.GetOffset(), dst_die.GetOffset());
3961	dst_dwarf_ast_parser->LinkDeclContextToDIE (src_decl_ctx, dst_die);
3962	}
3963	else
3964	{
3965	if (log)
3966	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());
3967	}
3968
3969	Type *src_child_type = dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
3970	if (src_child_type)
3971	{
3972	if (log)
3973	log->Printf ("uniquing type %p (uid=0x%" PRIx64"l" "x" ") from 0x%8.8x for 0x%8.8x",
3974	static_cast<void*>(src_child_type),
3975	src_child_type->GetID(),
3976	src_die.GetOffset(), dst_die.GetOffset());
3977	dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;
3978	}
3979	else
3980	{
3981	if (log)
3982	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());
3983	}
3984	}
3985	}
3986	}
3987
3988	if (dst_size_artificial)
3989	{
3990	for (idx = 0; idx < dst_size_artificial; ++idx)
3991	{
3992	const char *dst_name_artificial = dst_name_to_die_artificial.GetCStringAtIndex(idx);
3993	dst_die = dst_name_to_die_artificial.GetValueAtIndexUnchecked (idx);
3994	if (log)
3995	log->Printf ("warning: need to create artificial method for 0x%8.8x for method '%s'", dst_die.GetOffset(), dst_name_artificial);
3996
3997	failures.Append(dst_die);
3998	}
3999	}
4000
4001	return (failures.Size() != 0);
4002	}
4003
4004
4005	bool
4006	DWARFASTParserClang::LayoutRecordType(const clang::RecordDecl *record_decl,
4007	uint64_t &bit_size,
4008	uint64_t &alignment,
4009	llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
4010	llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets,
4011	llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets)
4012	{
4013	RecordDeclToLayoutMap::iterator pos = m_record_decl_to_layout_map.find (record_decl);
4014	bool success = false;
4015	base_offsets.clear();
4016	vbase_offsets.clear();
4017	if (pos != m_record_decl_to_layout_map.end())
4018	{
4019	bit_size = pos->second.bit_size;
4020	alignment = pos->second.alignment;
4021	field_offsets.swap(pos->second.field_offsets);
4022	base_offsets.swap (pos->second.base_offsets);
4023	vbase_offsets.swap (pos->second.vbase_offsets);
4024	m_record_decl_to_layout_map.erase(pos);
4025	success = true;
4026	}
4027	else
4028	{
4029	bit_size = 0;
4030	alignment = 0;
4031	field_offsets.clear();
4032	}
4033	return success;
4034	}