?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "[InstCombine] Support gep nuw in icmp folds" (#118698)
[llvm-project.git] / lldb / unittests / SymbolFile / DWARF / DWARFASTParserClangTests.cpp
blobee90855437a71eafb7ea916cc0ba5f1e32945d27
1 //===-- DWARFASTParserClangTests.cpp --------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
10 #include "Plugins/SymbolFile/DWARF/DWARFCompileUnit.h"
11 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
12 #include "TestingSupport/Symbol/ClangTestUtils.h"
13 #include "TestingSupport/Symbol/YAMLModuleTester.h"
14 #include "lldb/Core/Debugger.h"
15 #include "gmock/gmock.h"
16 #include "gtest/gtest.h"
17
18 using namespace lldb;
19 using namespace lldb_private;
20 using namespace lldb_private::dwarf;
21 using namespace lldb_private::plugin::dwarf;
22
23 namespace {
24 static std::once_flag debugger_initialize_flag;
25
26 class DWARFASTParserClangTests : public testing::Test {
27 void SetUp() override {
28 std::call_once(debugger_initialize_flag,
29 []() { Debugger::Initialize(nullptr); });
30 }
31 };
32
33 class DWARFASTParserClangStub : public DWARFASTParserClang {
34 public:
35 using DWARFASTParserClang::DWARFASTParserClang;
36 using DWARFASTParserClang::LinkDeclContextToDIE;
37
38 std::vector<const clang::DeclContext *> GetDeclContextToDIEMapKeys() {
39 std::vector<const clang::DeclContext *> keys;
40 for (const auto &it : m_decl_ctx_to_die)
41 keys.push_back(it.first);
42 return keys;
43 }
44 };
45 } // namespace
46
47 // If your implementation needs to dereference the dummy pointers we are
48 // defining here, causing this test to fail, feel free to delete it.
49 TEST_F(DWARFASTParserClangTests,
50 EnsureAllDIEsInDeclContextHaveBeenParsedParsesOnlyMatchingEntries) {
51
52 /// Auxiliary debug info.
53 const char *yamldata = R"(
54 --- !ELF
55 FileHeader:
56 Class: ELFCLASS64
57 Data: ELFDATA2LSB
58 Type: ET_EXEC
59 Machine: EM_386
60 DWARF:
61 debug_abbrev:
62 - Table:
63 - Code: 0x00000001
64 Tag: DW_TAG_compile_unit
65 Children: DW_CHILDREN_yes
66 Attributes:
67 - Attribute: DW_AT_language
68 Form: DW_FORM_data2
69 - Code: 0x00000002
70 Tag: DW_TAG_base_type
71 Children: DW_CHILDREN_no
72 Attributes:
73 - Attribute: DW_AT_encoding
74 Form: DW_FORM_data1
75 - Attribute: DW_AT_byte_size
76 Form: DW_FORM_data1
77 debug_info:
78 - Version: 4
79 AddrSize: 8
80 Entries:
81 - AbbrCode: 0x00000001
82 Values:
83 - Value: 0x000000000000000C
84 - AbbrCode: 0x00000002
85 Values:
86 - Value: 0x0000000000000007 # DW_ATE_unsigned
87 - Value: 0x0000000000000004
88 - AbbrCode: 0x00000002
89 Values:
90 - Value: 0x0000000000000007 # DW_ATE_unsigned
91 - Value: 0x0000000000000008
92 - AbbrCode: 0x00000002
93 Values:
94 - Value: 0x0000000000000005 # DW_ATE_signed
95 - Value: 0x0000000000000008
96 - AbbrCode: 0x00000002
97 Values:
98 - Value: 0x0000000000000008 # DW_ATE_unsigned_char
99 - Value: 0x0000000000000001
100 - AbbrCode: 0x00000000
101 )";
102
103 YAMLModuleTester t(yamldata);
104 ASSERT_TRUE((bool)t.GetDwarfUnit());
105
106 auto holder = std::make_unique<clang_utils::TypeSystemClangHolder>("ast");
107 auto &ast_ctx = *holder->GetAST();
108
109 DWARFASTParserClangStub ast_parser(ast_ctx);
110
111 DWARFUnit *unit = t.GetDwarfUnit();
112 const DWARFDebugInfoEntry *die_first = unit->DIE().GetDIE();
113 const DWARFDebugInfoEntry *die_child0 = die_first->GetFirstChild();
114 const DWARFDebugInfoEntry *die_child1 = die_child0->GetSibling();
115 const DWARFDebugInfoEntry *die_child2 = die_child1->GetSibling();
116 const DWARFDebugInfoEntry *die_child3 = die_child2->GetSibling();
117 std::vector<DWARFDIE> dies = {
118 DWARFDIE(unit, die_child0), DWARFDIE(unit, die_child1),
119 DWARFDIE(unit, die_child2), DWARFDIE(unit, die_child3)};
120 std::vector<clang::DeclContext *> decl_ctxs = {
121 (clang::DeclContext *)1LL, (clang::DeclContext *)2LL,
122 (clang::DeclContext *)2LL, (clang::DeclContext *)3LL};
123 for (int i = 0; i < 4; ++i)
124 ast_parser.LinkDeclContextToDIE(decl_ctxs[i], dies[i]);
125 ast_parser.EnsureAllDIEsInDeclContextHaveBeenParsed(
126 CompilerDeclContext(nullptr, decl_ctxs[1]));
127
128 EXPECT_THAT(ast_parser.GetDeclContextToDIEMapKeys(),
129 testing::UnorderedElementsAre(decl_ctxs[0], decl_ctxs[3]));
130 }
131
132 TEST_F(DWARFASTParserClangTests, TestCallingConventionParsing) {
133 // Tests parsing DW_AT_calling_convention values.
134
135 // The DWARF below just declares a list of function types with
136 // DW_AT_calling_convention on them.
137 const char *yamldata = R"(
138 --- !ELF
139 FileHeader:
140 Class: ELFCLASS32
141 Data: ELFDATA2LSB
142 Type: ET_EXEC
143 Machine: EM_386
144 DWARF:
145 debug_str:
146 - func1
147 - func2
148 - func3
149 - func4
150 - func5
151 - func6
152 - func7
153 - func8
154 - func9
155 debug_abbrev:
156 - ID: 0
157 Table:
158 - Code: 0x1
159 Tag: DW_TAG_compile_unit
160 Children: DW_CHILDREN_yes
161 Attributes:
162 - Attribute: DW_AT_language
163 Form: DW_FORM_data2
164 - Code: 0x2
165 Tag: DW_TAG_subprogram
166 Children: DW_CHILDREN_no
167 Attributes:
168 - Attribute: DW_AT_low_pc
169 Form: DW_FORM_addr
170 - Attribute: DW_AT_high_pc
171 Form: DW_FORM_data4
172 - Attribute: DW_AT_name
173 Form: DW_FORM_strp
174 - Attribute: DW_AT_calling_convention
175 Form: DW_FORM_data1
176 - Attribute: DW_AT_external
177 Form: DW_FORM_flag_present
178 debug_info:
179 - Version: 4
180 AddrSize: 4
181 Entries:
182 - AbbrCode: 0x1
183 Values:
184 - Value: 0xC
185 - AbbrCode: 0x2
186 Values:
187 - Value: 0x0
188 - Value: 0x5
189 - Value: 0x00
190 - Value: 0xCB
191 - Value: 0x1
192 - AbbrCode: 0x2
193 Values:
194 - Value: 0x10
195 - Value: 0x5
196 - Value: 0x06
197 - Value: 0xB3
198 - Value: 0x1
199 - AbbrCode: 0x2
200 Values:
201 - Value: 0x20
202 - Value: 0x5
203 - Value: 0x0C
204 - Value: 0xB1
205 - Value: 0x1
206 - AbbrCode: 0x2
207 Values:
208 - Value: 0x30
209 - Value: 0x5
210 - Value: 0x12
211 - Value: 0xC0
212 - Value: 0x1
213 - AbbrCode: 0x2
214 Values:
215 - Value: 0x40
216 - Value: 0x5
217 - Value: 0x18
218 - Value: 0xB2
219 - Value: 0x1
220 - AbbrCode: 0x2
221 Values:
222 - Value: 0x50
223 - Value: 0x5
224 - Value: 0x1E
225 - Value: 0xC1
226 - Value: 0x1
227 - AbbrCode: 0x2
228 Values:
229 - Value: 0x60
230 - Value: 0x5
231 - Value: 0x24
232 - Value: 0xC2
233 - Value: 0x1
234 - AbbrCode: 0x2
235 Values:
236 - Value: 0x70
237 - Value: 0x5
238 - Value: 0x2a
239 - Value: 0xEE
240 - Value: 0x1
241 - AbbrCode: 0x2
242 Values:
243 - Value: 0x80
244 - Value: 0x5
245 - Value: 0x30
246 - Value: 0x01
247 - Value: 0x1
248 - AbbrCode: 0x0
249 ...
250 )";
251 YAMLModuleTester t(yamldata);
252
253 DWARFUnit *unit = t.GetDwarfUnit();
254 ASSERT_NE(unit, nullptr);
255 const DWARFDebugInfoEntry *cu_entry = unit->DIE().GetDIE();
256 ASSERT_EQ(cu_entry->Tag(), DW_TAG_compile_unit);
257 DWARFDIE cu_die(unit, cu_entry);
258
259 auto holder = std::make_unique<clang_utils::TypeSystemClangHolder>("ast");
260 auto &ast_ctx = *holder->GetAST();
261 DWARFASTParserClangStub ast_parser(ast_ctx);
262
263 std::vector<std::string> found_function_types;
264 // The DWARF above is just a list of functions. Parse all of them to
265 // extract the function types and their calling convention values.
266 for (DWARFDIE func : cu_die.children()) {
267 ASSERT_EQ(func.Tag(), DW_TAG_subprogram);
268 SymbolContext sc;
269 bool new_type = false;
270 lldb::TypeSP type = ast_parser.ParseTypeFromDWARF(sc, func, &new_type);
271 found_function_types.push_back(
272 type->GetForwardCompilerType().GetTypeName().AsCString());
273 }
274
275 // Compare the parsed function types against the expected list of types.
276 const std::vector<std::string> expected_function_types = {
277 "void () __attribute__((regcall))",
278 "void () __attribute__((fastcall))",
279 "void () __attribute__((stdcall))",
280 "void () __attribute__((vectorcall))",
281 "void () __attribute__((pascal))",
282 "void () __attribute__((ms_abi))",
283 "void () __attribute__((sysv_abi))",
284 "void ()", // invalid calling convention.
285 "void ()", // DW_CC_normal -> no attribute
286 };
287 ASSERT_EQ(found_function_types, expected_function_types);
288 }
289
290 TEST_F(DWARFASTParserClangTests, TestPtrAuthParsing) {
291 // Tests parsing values with type DW_TAG_LLVM_ptrauth_type corresponding to
292 // explicitly signed raw function pointers
293
294 // This is Dwarf for the following C code:
295 // ```
296 // void (*__ptrauth(0, 0, 42) a)();
297 // ```
298
299 const char *yamldata = R"(
300 --- !ELF
301 FileHeader:
302 Class: ELFCLASS64
303 Data: ELFDATA2LSB
304 Type: ET_EXEC
305 Machine: EM_AARCH64
306 DWARF:
307 debug_str:
308 - a
309 debug_abbrev:
310 - ID: 0
311 Table:
312 - Code: 0x01
313 Tag: DW_TAG_compile_unit
314 Children: DW_CHILDREN_yes
315 Attributes:
316 - Attribute: DW_AT_language
317 Form: DW_FORM_data2
318 - Code: 0x02
319 Tag: DW_TAG_variable
320 Children: DW_CHILDREN_no
321 Attributes:
322 - Attribute: DW_AT_name
323 Form: DW_FORM_strp
324 - Attribute: DW_AT_type
325 Form: DW_FORM_ref4
326 - Attribute: DW_AT_external
327 Form: DW_FORM_flag_present
328 - Code: 0x03
329 Tag: DW_TAG_LLVM_ptrauth_type
330 Children: DW_CHILDREN_no
331 Attributes:
332 - Attribute: DW_AT_type
333 Form: DW_FORM_ref4
334 - Attribute: DW_AT_LLVM_ptrauth_key
335 Form: DW_FORM_data1
336 - Attribute: DW_AT_LLVM_ptrauth_extra_discriminator
337 Form: DW_FORM_data2
338 - Code: 0x04
339 Tag: DW_TAG_pointer_type
340 Children: DW_CHILDREN_no
341 Attributes:
342 - Attribute: DW_AT_type
343 Form: DW_FORM_ref4
344 - Code: 0x05
345 Tag: DW_TAG_subroutine_type
346 Children: DW_CHILDREN_yes
347 - Code: 0x06
348 Tag: DW_TAG_unspecified_parameters
349 Children: DW_CHILDREN_no
350
351 debug_info:
352 - Version: 5
353 UnitType: DW_UT_compile
354 AddrSize: 8
355 Entries:
356 # 0x0c: DW_TAG_compile_unit
357 # DW_AT_language [DW_FORM_data2] (DW_LANG_C99)
358 - AbbrCode: 0x01
359 Values:
360 - Value: 0x0c
361
362 # 0x0f: DW_TAG_variable
363 # DW_AT_name [DW_FORM_strp] (\"a\")
364 # DW_AT_type [DW_FORM_ref4] (0x00000018 \"void (*__ptrauth(0, 0, 0x02a)\")
365 # DW_AT_external [DW_FORM_flag_present] (true)
366 - AbbrCode: 0x02
367 Values:
368 - Value: 0x00
369 - Value: 0x18
370
371 # 0x18: DW_TAG_LLVM_ptrauth_type
372 # DW_AT_type [DW_FORM_ref4] (0x00000020 \"void (*)(...)\")
373 # DW_AT_LLVM_ptrauth_key [DW_FORM_data1] (0x00)
374 # DW_AT_LLVM_ptrauth_extra_discriminator [DW_FORM_data2] (0x002a)
375 - AbbrCode: 0x03
376 Values:
377 - Value: 0x20
378 - Value: 0x00
379 - Value: 0x2a
380
381 # 0x20: DW_TAG_pointer_type
382 # DW_AT_type [DW_AT_type [DW_FORM_ref4] (0x00000025 \"void (...)\")
383 - AbbrCode: 0x04
384 Values:
385 - Value: 0x25
386
387 # 0x25: DW_TAG_subroutine_type
388 - AbbrCode: 0x05
389
390 # 0x26: DW_TAG_unspecified_parameters
391 - AbbrCode: 0x06
392
393 - AbbrCode: 0x00 # end of child tags of 0x25
394 - AbbrCode: 0x00 # end of child tags of 0x0c
395 ...
396 )";
397 YAMLModuleTester t(yamldata);
398
399 DWARFUnit *unit = t.GetDwarfUnit();
400 ASSERT_NE(unit, nullptr);
401 const DWARFDebugInfoEntry *cu_entry = unit->DIE().GetDIE();
402 ASSERT_EQ(cu_entry->Tag(), DW_TAG_compile_unit);
403 DWARFDIE cu_die(unit, cu_entry);
404
405 auto holder = std::make_unique<clang_utils::TypeSystemClangHolder>("ast");
406 auto &ast_ctx = *holder->GetAST();
407 DWARFASTParserClangStub ast_parser(ast_ctx);
408
409 DWARFDIE ptrauth_variable = cu_die.GetFirstChild();
410 ASSERT_EQ(ptrauth_variable.Tag(), DW_TAG_variable);
411 DWARFDIE ptrauth_type =
412 ptrauth_variable.GetAttributeValueAsReferenceDIE(DW_AT_type);
413 ASSERT_EQ(ptrauth_type.Tag(), DW_TAG_LLVM_ptrauth_type);
414
415 SymbolContext sc;
416 bool new_type = false;
417 lldb::TypeSP type_sp =
418 ast_parser.ParseTypeFromDWARF(sc, ptrauth_type, &new_type);
419 CompilerType compiler_type = type_sp->GetForwardCompilerType();
420 ASSERT_EQ(compiler_type.GetPtrAuthKey(), 0U);
421 ASSERT_EQ(compiler_type.GetPtrAuthAddressDiversity(), false);
422 ASSERT_EQ(compiler_type.GetPtrAuthDiscriminator(), 42U);
423 }
424
425 struct ExtractIntFromFormValueTest : public testing::Test {
426 SubsystemRAII<FileSystem, HostInfo> subsystems;
427 clang_utils::TypeSystemClangHolder holder;
428 TypeSystemClang &ts;
429
430 DWARFASTParserClang parser;
431 ExtractIntFromFormValueTest()
432 : holder("dummy ASTContext"), ts(*holder.GetAST()), parser(ts) {}
433
434 /// Takes the given integer value, stores it in a DWARFFormValue and then
435 /// tries to extract the value back via
436 /// DWARFASTParserClang::ExtractIntFromFormValue.
437 /// Returns the string representation of the extracted value or the error
438 /// that was returned from ExtractIntFromFormValue.
439 llvm::Expected<std::string> Extract(clang::QualType qt, uint64_t value) {
440 DWARFFormValue form_value;
441 form_value.SetUnsigned(value);
442 llvm::Expected<llvm::APInt> result =
443 parser.ExtractIntFromFormValue(ts.GetType(qt), form_value);
444 if (!result)
445 return result.takeError();
446 llvm::SmallString<16> result_str;
447 result->toStringUnsigned(result_str);
448 return std::string(result_str.str());
449 }
450
451 /// Same as ExtractIntFromFormValueTest::Extract but takes a signed integer
452 /// and treats the result as a signed integer.
453 llvm::Expected<std::string> ExtractS(clang::QualType qt, int64_t value) {
454 DWARFFormValue form_value;
455 form_value.SetSigned(value);
456 llvm::Expected<llvm::APInt> result =
457 parser.ExtractIntFromFormValue(ts.GetType(qt), form_value);
458 if (!result)
459 return result.takeError();
460 llvm::SmallString<16> result_str;
461 result->toStringSigned(result_str);
462 return std::string(result_str.str());
463 }
464 };
465
466 TEST_F(ExtractIntFromFormValueTest, TestBool) {
467 using namespace llvm;
468 clang::ASTContext &ast = ts.getASTContext();
469
470 EXPECT_THAT_EXPECTED(Extract(ast.BoolTy, 0), HasValue("0"));
471 EXPECT_THAT_EXPECTED(Extract(ast.BoolTy, 1), HasValue("1"));
472 EXPECT_THAT_EXPECTED(Extract(ast.BoolTy, 2), Failed());
473 EXPECT_THAT_EXPECTED(Extract(ast.BoolTy, 3), Failed());
474 }
475
476 TEST_F(ExtractIntFromFormValueTest, TestInt) {
477 using namespace llvm;
478
479 clang::ASTContext &ast = ts.getASTContext();
480
481 // Find the min/max values for 'int' on the current host target.
482 constexpr int64_t int_max = std::numeric_limits<int>::max();
483 constexpr int64_t int_min = std::numeric_limits<int>::min();
484
485 // Check that the bit width of int matches the int width in our type system.
486 ASSERT_EQ(sizeof(int) * 8, ast.getIntWidth(ast.IntTy));
487
488 // Check values around int_min.
489 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_min - 2), llvm::Failed());
490 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_min - 1), llvm::Failed());
491 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_min),
492 HasValue(std::to_string(int_min)));
493 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_min + 1),
494 HasValue(std::to_string(int_min + 1)));
495 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_min + 2),
496 HasValue(std::to_string(int_min + 2)));
497
498 // Check values around 0.
499 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, -128), HasValue("-128"));
500 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, -10), HasValue("-10"));
501 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, -1), HasValue("-1"));
502 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, 0), HasValue("0"));
503 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, 1), HasValue("1"));
504 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, 10), HasValue("10"));
505 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, 128), HasValue("128"));
506
507 // Check values around int_max.
508 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_max - 2),
509 HasValue(std::to_string(int_max - 2)));
510 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_max - 1),
511 HasValue(std::to_string(int_max - 1)));
512 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_max),
513 HasValue(std::to_string(int_max)));
514 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_max + 1), llvm::Failed());
515 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_max + 5), llvm::Failed());
516
517 // Check some values not near an edge case.
518 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_max / 2),
519 HasValue(std::to_string(int_max / 2)));
520 EXPECT_THAT_EXPECTED(ExtractS(ast.IntTy, int_min / 2),
521 HasValue(std::to_string(int_min / 2)));
522 }
523
524 TEST_F(ExtractIntFromFormValueTest, TestUnsignedInt) {
525 using namespace llvm;
526
527 clang::ASTContext &ast = ts.getASTContext();
528 constexpr uint64_t uint_max = std::numeric_limits<uint32_t>::max();
529
530 // Check values around 0.
531 EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, 0), HasValue("0"));
532 EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, 1), HasValue("1"));
533 EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, 1234), HasValue("1234"));
534
535 // Check some values not near an edge case.
536 EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max / 2),
537 HasValue(std::to_string(uint_max / 2)));
538
539 // Check values around uint_max.
540 EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max - 2),
541 HasValue(std::to_string(uint_max - 2)));
542 EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max - 1),
543 HasValue(std::to_string(uint_max - 1)));
544 EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max),
545 HasValue(std::to_string(uint_max)));
546 EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max + 1),
547 llvm::Failed());
548 EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max + 2),
549 llvm::Failed());
550 }
551
552 TEST_F(DWARFASTParserClangTests, TestDefaultTemplateParamParsing) {
553 // Tests parsing DW_AT_default_value for template parameters.
554 auto BufferOrError = llvm::MemoryBuffer::getFile(
555 GetInputFilePath("DW_AT_default_value-test.yaml"), /*IsText=*/true);
556 ASSERT_TRUE(BufferOrError);
557 YAMLModuleTester t(BufferOrError.get()->getBuffer());
558
559 DWARFUnit *unit = t.GetDwarfUnit();
560 ASSERT_NE(unit, nullptr);
561 const DWARFDebugInfoEntry *cu_entry = unit->DIE().GetDIE();
562 ASSERT_EQ(cu_entry->Tag(), DW_TAG_compile_unit);
563 DWARFDIE cu_die(unit, cu_entry);
564
565 auto holder = std::make_unique<clang_utils::TypeSystemClangHolder>("ast");
566 auto &ast_ctx = *holder->GetAST();
567 DWARFASTParserClangStub ast_parser(ast_ctx);
568
569 llvm::SmallVector<lldb::TypeSP, 2> types;
570 for (DWARFDIE die : cu_die.children()) {
571 if (die.Tag() == DW_TAG_class_type) {
572 SymbolContext sc;
573 bool new_type = false;
574 types.push_back(ast_parser.ParseTypeFromDWARF(sc, die, &new_type));
575 }
576 }
577
578 ASSERT_EQ(types.size(), 3U);
579
580 auto check_decl = [](auto const *decl) {
581 clang::ClassTemplateSpecializationDecl const *ctsd =
582 llvm::dyn_cast_or_null<clang::ClassTemplateSpecializationDecl>(decl);
583 ASSERT_NE(ctsd, nullptr);
584
585 auto const &args = ctsd->getTemplateArgs();
586 ASSERT_GT(args.size(), 0U);
587
588 for (auto const &arg : args.asArray()) {
589 EXPECT_TRUE(arg.getIsDefaulted());
590 }
591 };
592
593 for (auto const &type_sp : types) {
594 ASSERT_NE(type_sp, nullptr);
595 auto const *decl = ClangUtil::GetAsTagDecl(type_sp->GetFullCompilerType());
596 if (decl->getName() == "bar" || decl->getName() == "baz") {
597 check_decl(decl);
598 }
599 }
600 }
LLVM monorepo