Bug Summary

File:tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp
Warning:line 464, column 11
Null pointer passed as an argument to a 'nonnull' parameter

Annotated Source Code

1//===-- DWARFASTParserJava.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 "DWARFASTParserJava.h"
11#include "DWARFAttribute.h"
12#include "DWARFCompileUnit.h"
13#include "DWARFDebugInfoEntry.h"
14#include "DWARFDebugInfoEntry.h"
15#include "DWARFDeclContext.h"
16#include "SymbolFileDWARF.h"
17
18#include "lldb/Core/Module.h"
19#include "lldb/Symbol/CompileUnit.h"
20#include "lldb/Symbol/SymbolContextScope.h"
21#include "lldb/Symbol/TypeList.h"
22
23using namespace lldb;
24using namespace lldb_private;
25
26DWARFASTParserJava::DWARFASTParserJava(JavaASTContext &ast) : m_ast(ast) {}
27
28DWARFASTParserJava::~DWARFASTParserJava() {}
29
30TypeSP DWARFASTParserJava::ParseBaseTypeFromDIE(const DWARFDIE &die) {
31 SymbolFileDWARF *dwarf = die.GetDWARF();
32 dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED((lldb_private::Type *)1);
33
34 ConstString type_name;
35 uint64_t byte_size = 0;
36
37 DWARFAttributes attributes;
38 const size_t num_attributes = die.GetAttributes(attributes);
39 for (uint32_t i = 0; i < num_attributes; ++i) {
40 DWARFFormValue form_value;
41 dw_attr_t attr = attributes.AttributeAtIndex(i);
42 if (attributes.ExtractFormValueAtIndex(i, form_value)) {
43 switch (attr) {
44 case DW_AT_name:
45 type_name.SetCString(form_value.AsCString());
46 break;
47 case DW_AT_byte_size:
48 byte_size = form_value.Unsigned();
49 break;
50 case DW_AT_encoding:
51 break;
52 default:
53 assert(false && "Unsupported attribute for DW_TAG_base_type")((false && "Unsupported attribute for DW_TAG_base_type"
) ? static_cast<void> (0) : __assert_fail ("false && \"Unsupported attribute for DW_TAG_base_type\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp"
, 53, __PRETTY_FUNCTION__))
;
54 }
55 }
56 }
57
58 Declaration decl;
59 CompilerType compiler_type = m_ast.CreateBaseType(type_name);
60 return std::make_shared<Type>(die.GetID(), dwarf, type_name, byte_size,
61 nullptr, LLDB_INVALID_UID(18446744073709551615UL), Type::eEncodingIsUID,
62 decl, compiler_type, Type::eResolveStateFull);
63}
64
65TypeSP DWARFASTParserJava::ParseArrayTypeFromDIE(const DWARFDIE &die) {
66 SymbolFileDWARF *dwarf = die.GetDWARF();
67 dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED((lldb_private::Type *)1);
68
69 ConstString linkage_name;
70 DWARFFormValue type_attr_value;
71 lldb::addr_t data_offset = LLDB_INVALID_ADDRESS(18446744073709551615UL);
72 DWARFExpression length_expression(die.GetCU());
73
74 DWARFAttributes attributes;
75 const size_t num_attributes = die.GetAttributes(attributes);
76 for (uint32_t i = 0; i < num_attributes; ++i) {
77 DWARFFormValue form_value;
78 dw_attr_t attr = attributes.AttributeAtIndex(i);
79 if (attributes.ExtractFormValueAtIndex(i, form_value)) {
80 switch (attr) {
81 case DW_AT_linkage_name:
82 linkage_name.SetCString(form_value.AsCString());
83 break;
84 case DW_AT_type:
85 type_attr_value = form_value;
86 break;
87 case DW_AT_data_member_location:
88 data_offset = form_value.Unsigned();
89 break;
90 case DW_AT_declaration:
91 break;
92 default:
93 assert(false && "Unsupported attribute for DW_TAG_array_type")((false && "Unsupported attribute for DW_TAG_array_type"
) ? static_cast<void> (0) : __assert_fail ("false && \"Unsupported attribute for DW_TAG_array_type\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp"
, 93, __PRETTY_FUNCTION__))
;
94 }
95 }
96 }
97
98 for (DWARFDIE child_die = die.GetFirstChild(); child_die.IsValid();
99 child_die = child_die.GetSibling()) {
100 if (child_die.Tag() == DW_TAG_subrange_type) {
101 DWARFAttributes attributes;
102 const size_t num_attributes = child_die.GetAttributes(attributes);
103 for (uint32_t i = 0; i < num_attributes; ++i) {
104 DWARFFormValue form_value;
105 dw_attr_t attr = attributes.AttributeAtIndex(i);
106 if (attributes.ExtractFormValueAtIndex(i, form_value)) {
107 switch (attr) {
108 case DW_AT_count:
109 if (form_value.BlockData())
110 length_expression.CopyOpcodeData(
111 form_value.BlockData(), form_value.Unsigned(),
112 child_die.GetCU()->GetByteOrder(),
113 child_die.GetCU()->GetAddressByteSize());
114 break;
115 default:
116 assert(false && "Unsupported attribute for DW_TAG_subrange_type")((false && "Unsupported attribute for DW_TAG_subrange_type"
) ? static_cast<void> (0) : __assert_fail ("false && \"Unsupported attribute for DW_TAG_subrange_type\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp"
, 116, __PRETTY_FUNCTION__))
;
117 }
118 }
119 }
120 } else {
121 assert(false && "Unsupported child for DW_TAG_array_type")((false && "Unsupported child for DW_TAG_array_type")
? static_cast<void> (0) : __assert_fail ("false && \"Unsupported child for DW_TAG_array_type\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp"
, 121, __PRETTY_FUNCTION__))
;
122 }
123 }
124
125 DIERef type_die_ref(type_attr_value);
126 Type *element_type = dwarf->ResolveTypeUID(type_die_ref);
127 if (!element_type)
128 return nullptr;
129
130 CompilerType element_compiler_type = element_type->GetForwardCompilerType();
131 CompilerType array_compiler_type = m_ast.CreateArrayType(
132 linkage_name, element_compiler_type, length_expression, data_offset);
133
134 Declaration decl;
135 TypeSP type_sp(new Type(die.GetID(), dwarf, array_compiler_type.GetTypeName(),
136 -1, nullptr, type_die_ref.GetUID(dwarf),
137 Type::eEncodingIsUID, &decl, array_compiler_type,
138 Type::eResolveStateFull));
139 type_sp->SetEncodingType(element_type);
140 return type_sp;
141}
142
143TypeSP DWARFASTParserJava::ParseReferenceTypeFromDIE(const DWARFDIE &die) {
144 SymbolFileDWARF *dwarf = die.GetDWARF();
145 dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED((lldb_private::Type *)1);
146
147 Declaration decl;
148 DWARFFormValue type_attr_value;
149
150 DWARFAttributes attributes;
151 const size_t num_attributes = die.GetAttributes(attributes);
152 for (uint32_t i = 0; i < num_attributes; ++i) {
153 DWARFFormValue form_value;
154 dw_attr_t attr = attributes.AttributeAtIndex(i);
155 if (attributes.ExtractFormValueAtIndex(i, form_value)) {
156 switch (attr) {
157 case DW_AT_type:
158 type_attr_value = form_value;
159 break;
160 default:
161 assert(false && "Unsupported attribute for DW_TAG_array_type")((false && "Unsupported attribute for DW_TAG_array_type"
) ? static_cast<void> (0) : __assert_fail ("false && \"Unsupported attribute for DW_TAG_array_type\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp"
, 161, __PRETTY_FUNCTION__))
;
162 }
163 }
164 }
165
166 DIERef type_die_ref(type_attr_value);
167 Type *pointee_type = dwarf->ResolveTypeUID(type_die_ref);
168 if (!pointee_type)
169 return nullptr;
170
171 CompilerType pointee_compiler_type = pointee_type->GetForwardCompilerType();
172 CompilerType reference_compiler_type =
173 m_ast.CreateReferenceType(pointee_compiler_type);
174 TypeSP type_sp(
175 new Type(die.GetID(), dwarf, reference_compiler_type.GetTypeName(), -1,
176 nullptr, type_die_ref.GetUID(dwarf), Type::eEncodingIsUID, &decl,
177 reference_compiler_type, Type::eResolveStateFull));
178 type_sp->SetEncodingType(pointee_type);
179 return type_sp;
180}
181
182lldb::TypeSP DWARFASTParserJava::ParseClassTypeFromDIE(const DWARFDIE &die,
183 bool &is_new_type) {
184 SymbolFileDWARF *dwarf = die.GetDWARF();
185 dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED((lldb_private::Type *)1);
186
187 Declaration decl;
188 ConstString name;
189 ConstString linkage_name;
190 bool is_forward_declaration = false;
191 uint32_t byte_size = 0;
192
193 DWARFAttributes attributes;
194 const size_t num_attributes = die.GetAttributes(attributes);
195 for (uint32_t i = 0; i < num_attributes; ++i) {
196 DWARFFormValue form_value;
197 dw_attr_t attr = attributes.AttributeAtIndex(i);
198 if (attributes.ExtractFormValueAtIndex(i, form_value)) {
199 switch (attr) {
200 case DW_AT_name:
201 name.SetCString(form_value.AsCString());
202 break;
203 case DW_AT_declaration:
204 is_forward_declaration = form_value.Boolean();
205 break;
206 case DW_AT_byte_size:
207 byte_size = form_value.Unsigned();
208 break;
209 case DW_AT_linkage_name:
210 linkage_name.SetCString(form_value.AsCString());
211 break;
212 default:
213 assert(false && "Unsupported attribute for DW_TAG_class_type")((false && "Unsupported attribute for DW_TAG_class_type"
) ? static_cast<void> (0) : __assert_fail ("false && \"Unsupported attribute for DW_TAG_class_type\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp"
, 213, __PRETTY_FUNCTION__))
;
214 }
215 }
216 }
217
218 UniqueDWARFASTType unique_ast_entry;
219 if (name) {
220 std::string qualified_name;
221 if (die.GetQualifiedName(qualified_name)) {
222 name.SetCString(qualified_name.c_str());
223 if (dwarf->GetUniqueDWARFASTTypeMap().Find(name, die, Declaration(), -1,
224 unique_ast_entry)) {
225 if (unique_ast_entry.m_type_sp) {
226 dwarf->GetDIEToType()[die.GetDIE()] =
227 unique_ast_entry.m_type_sp.get();
228 is_new_type = false;
229 return unique_ast_entry.m_type_sp;
230 }
231 }
232 }
233 }
234
235 if (is_forward_declaration) {
236 DWARFDeclContext die_decl_ctx;
237 die.GetDWARFDeclContext(die_decl_ctx);
238
239 TypeSP type_sp = dwarf->FindDefinitionTypeForDWARFDeclContext(die_decl_ctx);
240 if (type_sp) {
241 // We found a real definition for this type elsewhere so lets use it
242 dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
243 is_new_type = false;
244 return type_sp;
245 }
246 }
247
248 CompilerType compiler_type(
249 &m_ast, dwarf->GetForwardDeclDieToClangType().lookup(die.GetDIE()));
250 if (!compiler_type)
251 compiler_type = m_ast.CreateObjectType(name, linkage_name, byte_size);
252
253 is_new_type = true;
254 TypeSP type_sp(new Type(die.GetID(), dwarf, name,
255 -1, // byte size isn't specified
256 nullptr, LLDB_INVALID_UID(18446744073709551615UL), Type::eEncodingIsUID,
257 &decl, compiler_type, Type::eResolveStateForward));
258
259 // Add our type to the unique type map
260 unique_ast_entry.m_type_sp = type_sp;
261 unique_ast_entry.m_die = die;
262 unique_ast_entry.m_declaration = decl;
263 unique_ast_entry.m_byte_size = -1;
264 dwarf->GetUniqueDWARFASTTypeMap().Insert(name, unique_ast_entry);
265
266 if (!is_forward_declaration) {
267 // Leave this as a forward declaration until we need to know the details of
268 // the type
269 dwarf->GetForwardDeclDieToClangType()[die.GetDIE()] =
270 compiler_type.GetOpaqueQualType();
271 dwarf->GetForwardDeclClangTypeToDie()[compiler_type.GetOpaqueQualType()] =
272 die.GetDIERef();
273 }
274 return type_sp;
275}
276
277lldb::TypeSP DWARFASTParserJava::ParseTypeFromDWARF(
278 const lldb_private::SymbolContext &sc, const DWARFDIE &die,
279 lldb_private::Log *log, bool *type_is_new_ptr) {
280 if (type_is_new_ptr)
281 *type_is_new_ptr = false;
282
283 if (!die)
284 return nullptr;
285
286 SymbolFileDWARF *dwarf = die.GetDWARF();
287
288 Type *type_ptr = dwarf->m_die_to_type.lookup(die.GetDIE());
289 if (type_ptr == DIE_IS_BEING_PARSED((lldb_private::Type *)1))
290 return nullptr;
291 if (type_ptr != nullptr)
292 return type_ptr->shared_from_this();
293
294 TypeSP type_sp;
295 if (type_is_new_ptr)
296 *type_is_new_ptr = true;
297
298 switch (die.Tag()) {
299 case DW_TAG_base_type: {
300 type_sp = ParseBaseTypeFromDIE(die);
301 break;
302 }
303 case DW_TAG_array_type: {
304 type_sp = ParseArrayTypeFromDIE(die);
305 break;
306 }
307 case DW_TAG_class_type: {
308 bool is_new_type = false;
309 type_sp = ParseClassTypeFromDIE(die, is_new_type);
310 if (!is_new_type)
311 return type_sp;
312 break;
313 }
314 case DW_TAG_reference_type: {
315 type_sp = ParseReferenceTypeFromDIE(die);
316 break;
317 }
318 }
319
320 if (!type_sp)
321 return nullptr;
322
323 DWARFDIE sc_parent_die = SymbolFileDWARF::GetParentSymbolContextDIE(die);
324 dw_tag_t sc_parent_tag = sc_parent_die.Tag();
325
326 SymbolContextScope *symbol_context_scope = nullptr;
327 if (sc_parent_tag == DW_TAG_compile_unit) {
328 symbol_context_scope = sc.comp_unit;
329 } else if (sc.function != nullptr && sc_parent_die) {
330 symbol_context_scope =
331 sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
332 if (symbol_context_scope == nullptr)
333 symbol_context_scope = sc.function;
334 }
335
336 if (symbol_context_scope != nullptr)
337 type_sp->SetSymbolContextScope(symbol_context_scope);
338
339 dwarf->GetTypeList()->Insert(type_sp);
340 dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
341
342 return type_sp;
343}
344
345lldb_private::Function *DWARFASTParserJava::ParseFunctionFromDWARF(
346 const lldb_private::SymbolContext &sc, const DWARFDIE &die) {
347 assert(die.Tag() == DW_TAG_subprogram)((die.Tag() == DW_TAG_subprogram) ? static_cast<void> (
0) : __assert_fail ("die.Tag() == DW_TAG_subprogram", "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp"
, 347, __PRETTY_FUNCTION__))
;
348
349 const char *name = nullptr;
350 const char *mangled = nullptr;
351 int decl_file = 0;
352 int decl_line = 0;
353 int decl_column = 0;
354 int call_file = 0;
355 int call_line = 0;
356 int call_column = 0;
357 DWARFRangeList func_ranges;
358 DWARFExpression frame_base(die.GetCU());
359
360 if (die.GetDIENamesAndRanges(name, mangled, func_ranges, decl_file, decl_line,
361 decl_column, call_file, call_line, call_column,
362 &frame_base)) {
363 // Union of all ranges in the function DIE (if the function is
364 // discontiguous)
365 AddressRange func_range;
366 lldb::addr_t lowest_func_addr = func_ranges.GetMinRangeBase(0);
367 lldb::addr_t highest_func_addr = func_ranges.GetMaxRangeEnd(0);
368 if (lowest_func_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL) &&
369 lowest_func_addr <= highest_func_addr) {
370 ModuleSP module_sp(die.GetModule());
371 func_range.GetBaseAddress().ResolveAddressUsingFileSections(
372 lowest_func_addr, module_sp->GetSectionList());
373 if (func_range.GetBaseAddress().IsValid())
374 func_range.SetByteSize(highest_func_addr - lowest_func_addr);
375 }
376
377 if (func_range.GetBaseAddress().IsValid()) {
378 std::unique_ptr<Declaration> decl_ap;
379 if (decl_file != 0 || decl_line != 0 || decl_column != 0)
380 decl_ap.reset(new Declaration(
381 sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
382 decl_line, decl_column));
383
384 if (die.GetDWARF()->FixupAddress(func_range.GetBaseAddress())) {
385 FunctionSP func_sp(new Function(sc.comp_unit, die.GetID(), die.GetID(),
386 Mangled(ConstString(name), false),
387 nullptr, // No function types in java
388 func_range));
389 if (frame_base.IsValid())
390 func_sp->GetFrameBaseExpression() = frame_base;
391 sc.comp_unit->AddFunction(func_sp);
392
393 return func_sp.get();
394 }
395 }
396 }
397 return nullptr;
398}
399
400bool DWARFASTParserJava::CompleteTypeFromDWARF(
401 const DWARFDIE &die, lldb_private::Type *type,
402 lldb_private::CompilerType &java_type) {
403 switch (die.Tag()) {
1
Control jumps to 'case DW_TAG_class_type:' at line 404
404 case DW_TAG_class_type: {
405 if (die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0) == 0) {
2
Assuming the condition is true
3
Taking true branch
406 if (die.HasChildren())
4
Assuming the condition is true
5
Taking true branch
407 ParseChildMembers(die, java_type);
6
Calling 'DWARFASTParserJava::ParseChildMembers'
408 m_ast.CompleteObjectType(java_type);
409 return java_type.IsValid();
410 }
411 } break;
412 default:
413 assert(false && "Not a forward java type declaration!")((false && "Not a forward java type declaration!") ? static_cast
<void> (0) : __assert_fail ("false && \"Not a forward java type declaration!\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp"
, 413, __PRETTY_FUNCTION__))
;
414 break;
415 }
416 return false;
417}
418
419void DWARFASTParserJava::ParseChildMembers(const DWARFDIE &parent_die,
420 CompilerType &compiler_type) {
421 DWARFCompileUnit *dwarf_cu = parent_die.GetCU();
422 for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
7
Loop condition is true. Entering loop body
10
Loop condition is true. Entering loop body
13
Loop condition is true. Entering loop body
16
Loop condition is true. Entering loop body
423 die = die.GetSibling()) {
424 switch (die.Tag()) {
8
Control jumps to the 'default' case at line 505
11
Control jumps to the 'default' case at line 505
14
Control jumps to the 'default' case at line 505
17
Control jumps to 'case DW_TAG_member:' at line 425
425 case DW_TAG_member: {
426 const char *name = nullptr;
18
'name' initialized to a null pointer value
427 DWARFFormValue encoding_uid;
428 uint32_t member_byte_offset = UINT32_MAX(4294967295U);
429 DWARFExpression member_location_expression(dwarf_cu);
430
431 DWARFAttributes attributes;
432 size_t num_attributes = die.GetAttributes(attributes);
433 for (size_t i = 0; i < num_attributes; ++i) {
19
Assuming 'i' is >= 'num_attributes'
20
Loop condition is false. Execution continues on line 464
434 DWARFFormValue form_value;
435 if (attributes.ExtractFormValueAtIndex(i, form_value)) {
436 switch (attributes.AttributeAtIndex(i)) {
437 case DW_AT_name:
438 name = form_value.AsCString();
439 break;
440 case DW_AT_type:
441 encoding_uid = form_value;
442 break;
443 case DW_AT_data_member_location:
444 if (form_value.BlockData())
445 member_location_expression.CopyOpcodeData(
446 form_value.BlockData(), form_value.Unsigned(),
447 dwarf_cu->GetByteOrder(), dwarf_cu->GetAddressByteSize());
448 else
449 member_byte_offset = form_value.Unsigned();
450 break;
451 case DW_AT_artificial:
452 static_cast<void>(form_value.Boolean());
453 break;
454 case DW_AT_accessibility:
455 // TODO: Handle when needed
456 break;
457 default:
458 assert(false && "Unhandled attribute for DW_TAG_member")((false && "Unhandled attribute for DW_TAG_member") ?
static_cast<void> (0) : __assert_fail ("false && \"Unhandled attribute for DW_TAG_member\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp"
, 458, __PRETTY_FUNCTION__))
;
459 break;
460 }
461 }
462 }
463
464 if (strcmp(name, ".dynamic_type") == 0)
21
Null pointer passed as an argument to a 'nonnull' parameter
465 m_ast.SetDynamicTypeId(compiler_type, member_location_expression);
466 else {
467 if (Type *member_type = die.ResolveTypeUID(DIERef(encoding_uid)))
468 m_ast.AddMemberToObject(compiler_type, ConstString(name),
469 member_type->GetFullCompilerType(),
470 member_byte_offset);
471 }
472 break;
473 }
474 case DW_TAG_inheritance: {
475 DWARFFormValue encoding_uid;
476 uint32_t member_byte_offset = UINT32_MAX(4294967295U);
477
478 DWARFAttributes attributes;
479 size_t num_attributes = die.GetAttributes(attributes);
480 for (size_t i = 0; i < num_attributes; ++i) {
481 DWARFFormValue form_value;
482 if (attributes.ExtractFormValueAtIndex(i, form_value)) {
483 switch (attributes.AttributeAtIndex(i)) {
484 case DW_AT_type:
485 encoding_uid = form_value;
486 break;
487 case DW_AT_data_member_location:
488 member_byte_offset = form_value.Unsigned();
489 break;
490 case DW_AT_accessibility:
491 // In java all base class is public so we can ignore this attribute
492 break;
493 default:
494 assert(false && "Unhandled attribute for DW_TAG_member")((false && "Unhandled attribute for DW_TAG_member") ?
static_cast<void> (0) : __assert_fail ("false && \"Unhandled attribute for DW_TAG_member\""
, "/tmp/buildd/llvm-toolchain-snapshot-4.0~svn290870/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp"
, 494, __PRETTY_FUNCTION__))
;
495 break;
496 }
497 }
498 }
499 if (Type *base_type = die.ResolveTypeUID(DIERef(encoding_uid)))
500 m_ast.AddBaseClassToObject(compiler_type,
501 base_type->GetFullCompilerType(),
502 member_byte_offset);
503 break;
504 }
505 default:
506 break;
9
Execution continues on line 423
12
Execution continues on line 423
15
Execution continues on line 423
507 }
508 }
509}