maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/CodeGenCXX/debug-info-template.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

273 lines
13 KiB
C++
Raw Normal View History

PR48169: Fix crash generating debug info for class non-type template parameters. It appears that LLVM isn't able to generate a DW_AT_const_value for a constant of class type, but if it could, we'd match GCC's debug info in this case, and in the interim we no longer crash.
2020-11-16 09:40:57 +08:00
// RUN: %clang -S -emit-llvm -target x86_64-unknown_unknown -g %s -o - -std=c++20 | FileCheck %s
Emit debug info for template type parameters. llvm-svn: 124753
2011-02-03 05:38:49 +08:00
Recommit r324107 again. The difference from the previous try is that we no longer directly access function declarations from position independent executables. It should work, but currently doesn't with some linkers. It now includes a fix to not mark available_externally definitions as dso_local. Original message: Start setting dso_local in clang. This starts adding dso_local to clang. The hope is to eventually have TargetMachine::shouldAssumeDsoLocal go away. My objective for now is to move enough of it to clang to remove the need for the TargetMachine one to handle PIE copy relocations and -fno-plt. With that it should then be easy to implement a -fno-copy-reloc in clang. This patch just adds the cases where we assume a symbol to be local based on the file being compiled for an executable or a shared library. llvm-svn: 324535
2018-02-08 06:15:33 +08:00
// CHECK: @tci = dso_local global %"struct.TC<unsigned int, 2, &glb, &foo::e, &foo::f, &foo::g, 1, 2, 3>::nested" zeroinitializer, align 1, !dbg [[TCI:![0-9]+]]
// CHECK: @tcn = dso_local global %struct.TC zeroinitializer, align 1, !dbg [[TCN:![0-9]+]]
// CHECK: @nn = dso_local global %struct.NN zeroinitializer, align 1, !dbg [[NN:![0-9]+]]
Update Clang for D20147 ("DebugInfo: New metadata representation for global variables.") Differential Revision: http://reviews.llvm.org/D20415 llvm-svn: 281285
2016-09-13 09:13:19 +08:00
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: !DICompileUnit(
Debug Info: Silently accept template argument packs We could support the GCC extension DW_TAG_GNU_template_parameter_pack if we're feeling adventurous, at some point - but I don't think GDB's doing anything useful with it yet anyway. llvm-svn: 181644
2013-05-11 06:53:25 +08:00
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
struct foo {
char pad[8]; // make the member pointer to 'e' a bit more interesting (nonzero)
int e;
void f();
static void g();
};
Debug Info: Silently accept template argument packs We could support the GCC extension DW_TAG_GNU_template_parameter_pack if we're feeling adventurous, at some point - but I don't think GDB's doing anything useful with it yet anyway. llvm-svn: 181644
2013-05-11 06:53:25 +08:00
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
typedef int foo::*foo_mem;
template<typename T, T, const int *x, foo_mem a, void (foo::*b)(), void (*f)(), int ...Is>
struct TC {
struct nested {
};
};
int glb;
void func();
Adapt testcases to LLVM change r312144 in DIGlobalVariableExpression llvm-svn: 312148
2017-08-31 02:22:23 +08:00
// CHECK: [[TCI]] = !DIGlobalVariableExpression(var: [[TCIV:.*]], expr: !DIExpression())
Update for LLVM global variable debug info API change. This reapplies r289921. llvm-svn: 290155
2016-12-20 10:10:02 +08:00
// CHECK: [[TCIV]] = distinct !DIGlobalVariable(name: "tci",
// CHECK-SAME: type: ![[TCNESTED:[0-9]+]]
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
// CHECK: ![[TCNESTED]] ={{.*}}!DICompositeType(tag: DW_TAG_structure_type, name: "nested",
// CHECK-SAME: scope: ![[TC:[0-9]+]],
// CHECK: ![[TC]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "TC<unsigned int, 2, &glb, &foo::e, &foo::f, &foo::g, 1, 2, 3>"
DebugInfo: Move new hierarchy into place (clang) Update testcases for LLVM change in r231082 to use the new debug info hierarchy. llvm-svn: 231083
2015-03-04 01:25:55 +08:00
// CHECK-SAME: templateParams: [[TCARGS:![0-9]*]]
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
TC
[DIBuilder] Do not replace empty enum types It looks like this array was missed in 4276d4a8d08b7640eb57cabf6988a5cf65b228b6 Fixed tests that expected `elements` to be empty or depeneded on the order of the empty DINode. Reviewed By: aprantl Differential Revision: https://reviews.llvm.org/D107024
2021-08-31 03:32:57 +08:00
// CHECK: [[EMPTY:![0-9]*]] = !{}
IR: Make metadata typeless in assembly, clang side Match LLVM changes from r224257. llvm-svn: 224259
2014-12-16 03:10:08 +08:00
// CHECK: [[TCARGS]] = !{[[TCARG1:![0-9]*]], [[TCARG2:![0-9]*]], [[TCARG3:![0-9]*]], [[TCARG4:![0-9]*]], [[TCARG5:![0-9]*]], [[TCARG6:![0-9]*]], [[TCARG7:![0-9]*]]}
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCARG1]] = !DITemplateTypeParameter(name: "T", type: [[UINT:![0-9]*]])
// CHECK: [[UINT:![0-9]*]] = !DIBasicType(name: "unsigned int"
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
< unsigned,
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCARG2]] = !DITemplateValueParameter(type: [[UINT]], value: i32 2)
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
2,
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCARG3]] = !DITemplateValueParameter(name: "x", type: [[CINTPTR:![0-9]*]], value: i32* @glb)
// CHECK: [[CINTPTR]] = !DIDerivedType(tag: DW_TAG_pointer_type, {{.*}}baseType: [[CINT:![0-9]+]]
Update Clang for D20147 ("DebugInfo: New metadata representation for global variables.") Differential Revision: http://reviews.llvm.org/D20415 llvm-svn: 281285
2016-09-13 09:13:19 +08:00
// CHECK: [[CINT]] = !DIDerivedType(tag: DW_TAG_const_type, {{.*}}baseType: [[INT:![0-9]+]]
// CHECK: [[INT]] = !DIBasicType(name: "int"
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
&glb,
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCARG4]] = !DITemplateValueParameter(name: "a", type: [[MEMINTPTR:![0-9]*]], value: i64 8)
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
// CHECK: [[MEMINTPTR]] = !DIDerivedType(tag: DW_TAG_ptr_to_member_type, {{.*}}baseType: [[INT]], {{.*}}extraData: ![[FOO:[0-9]+]])
//
// We could just emit a declaration of 'foo' here, rather than the entire
// definition (same goes for any time we emit a member (function or data)
// pointer type)
// CHECK: [[FOO]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "foo", {{.*}}identifier: "_ZTS3foo")
// CHECK: !DISubprogram(name: "f", linkageName: "_ZN3foo1fEv", {{.*}}type: [[FTYPE:![0-9]*]]
PR14992: Debug Info: Support more non-type template parameters * Provide DW_TAG_template_value_parameter for pointers, function pointers, member pointers, and member function pointers (still missing support for template template parameters which GCC encodes as a DW_TAG_GNU_template_template_param) * Provide values for all but the (member & non-member) function pointer case. Simple constant integer values for member pointers (offset within the object) and address for the value pointer case. GCC doesn't provide a value for the member function pointer case so I'm not sure how, if at all, GDB supports encoding that. & non-member function pointers should follow shortly in a subsequent patch. * Null pointer value encodings of all of these types, including correctly encoding null data member pointers as -1. llvm-svn: 181634
2013-05-11 05:53:14 +08:00
//
// Currently Clang emits the pointer-to-member-function value, but LLVM doesn't
// use it (GCC doesn't emit a value for pointers to member functions either - so
// it's not clear what, if any, format would be acceptable to GDB)
//
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
// CHECK: [[FTYPE:![0-9]*]] = !DISubroutineType(types: [[FARGS:![0-9]*]])
IR: Make metadata typeless in assembly, clang side Match LLVM changes from r224257. llvm-svn: 224259
2014-12-16 03:10:08 +08:00
// CHECK: [[FARGS]] = !{null, [[FARG1:![0-9]*]]}
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[FARG1]] = !DIDerivedType(tag: DW_TAG_pointer_type,
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
// CHECK-SAME: baseType: ![[FOO]]
DebugInfo: Move new hierarchy into place (clang) Update testcases for LLVM change in r231082 to use the new debug info hierarchy. llvm-svn: 231083
2015-03-04 01:25:55 +08:00
// CHECK-NOT: line:
DebugInfo: pass alignment value only if it was forced Preparation to implement DW_AT_alignment support: - We pass non-zero align value to DIBuilder only when alignment was forced - Modify tests to match this change Differential Revision: https://reviews.llvm.org/D24426 llvm-svn: 284679
2016-10-20 08:13:19 +08:00
// CHECK-SAME: size: 64
DebugInfo: Move new hierarchy into place (clang) Update testcases for LLVM change in r231082 to use the new debug info hierarchy. llvm-svn: 231083
2015-03-04 01:25:55 +08:00
// CHECK-NOT: offset: 0
// CHECK-SAME: DIFlagArtificial
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
// CHECK: [[FUNTYPE:![0-9]*]] = !DISubroutineType(types: [[FUNARGS:![0-9]*]])
IR: Make metadata typeless in assembly, clang side Match LLVM changes from r224257. llvm-svn: 224259
2014-12-16 03:10:08 +08:00
// CHECK: [[FUNARGS]] = !{null}
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
&foo::e,
// CHECK: [[TCARG5]] = !DITemplateValueParameter(name: "b", type: [[MEMFUNPTR:![0-9]*]], value: { i64, i64 } { i64 ptrtoint (void (%struct.foo*)* @_ZN3foo1fEv to i64), i64 0 })
// CHECK: [[MEMFUNPTR]] = !DIDerivedType(tag: DW_TAG_ptr_to_member_type, {{.*}}baseType: [[FTYPE]], {{.*}}extraData: ![[FOO]])
&foo::f,
// CHECK: [[TCARG6]] = !DITemplateValueParameter(name: "f", type: [[FUNPTR:![0-9]*]], value: void ()* @_ZN3foo1gEv)
// CHECK: [[FUNPTR]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: [[FUNTYPE]]
&foo::g,
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCARG7]] = !DITemplateValueParameter(tag: DW_TAG_GNU_template_parameter_pack, name: "Is", value: [[TCARG7_VALS:![0-9]*]])
IR: Make metadata typeless in assembly, clang side Match LLVM changes from r224257. llvm-svn: 224259
2014-12-16 03:10:08 +08:00
// CHECK: [[TCARG7_VALS]] = !{[[TCARG7_1:![0-9]*]], [[TCARG7_2:![0-9]*]], [[TCARG7_3:![0-9]*]]}
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCARG7_1]] = !DITemplateValueParameter(type: [[INT]], value: i32 1)
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
1,
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCARG7_2]] = !DITemplateValueParameter(type: [[INT]], value: i32 2)
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
2,
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCARG7_3]] = !DITemplateValueParameter(type: [[INT]], value: i32 3)
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
3>::nested tci;
PR14992: Debug Info: Support more non-type template parameters * Provide DW_TAG_template_value_parameter for pointers, function pointers, member pointers, and member function pointers (still missing support for template template parameters which GCC encodes as a DW_TAG_GNU_template_template_param) * Provide values for all but the (member & non-member) function pointer case. Simple constant integer values for member pointers (offset within the object) and address for the value pointer case. GCC doesn't provide a value for the member function pointer case so I'm not sure how, if at all, GDB supports encoding that. & non-member function pointers should follow shortly in a subsequent patch. * Null pointer value encodings of all of these types, including correctly encoding null data member pointers as -1. llvm-svn: 181634
2013-05-11 05:53:14 +08:00
Adapt testcases to LLVM change r312144 in DIGlobalVariableExpression llvm-svn: 312148
2017-08-31 02:22:23 +08:00
// CHECK: [[TCN]] = !DIGlobalVariableExpression(var: [[TCNV:.*]], expr: !DIExpression())
Update for LLVM global variable debug info API change. This reapplies r289921. llvm-svn: 290155
2016-12-20 10:10:02 +08:00
// CHECK: [[TCNV]] = distinct !DIGlobalVariable(name: "tcn"
// CHECK-SAME: type: ![[TCNT:[0-9]+]]
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
TC
// CHECK: ![[TCNT]] ={{.*}}!DICompositeType(tag: DW_TAG_structure_type, name: "TC<int, -3, nullptr, nullptr, nullptr, nullptr>"
DebugInfo: Move new hierarchy into place (clang) Update testcases for LLVM change in r231082 to use the new debug info hierarchy. llvm-svn: 231083
2015-03-04 01:25:55 +08:00
// CHECK-SAME: templateParams: [[TCNARGS:![0-9]*]]
IR: Make metadata typeless in assembly, clang side Match LLVM changes from r224257. llvm-svn: 224259
2014-12-16 03:10:08 +08:00
// CHECK: [[TCNARGS]] = !{[[TCNARG1:![0-9]*]], [[TCNARG2:![0-9]*]], [[TCNARG3:![0-9]*]], [[TCNARG4:![0-9]*]], [[TCNARG5:![0-9]*]], [[TCNARG6:![0-9]*]], [[TCNARG7:![0-9]*]]}
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCNARG1]] = !DITemplateTypeParameter(name: "T", type: [[INT]])
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
<int,
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCNARG2]] = !DITemplateValueParameter(type: [[INT]], value: i32 -3)
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
-3,
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCNARG3]] = !DITemplateValueParameter(name: "x", type: [[CINTPTR]], value: i8 0)
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
nullptr,
PR14992: Debug Info: Support more non-type template parameters * Provide DW_TAG_template_value_parameter for pointers, function pointers, member pointers, and member function pointers (still missing support for template template parameters which GCC encodes as a DW_TAG_GNU_template_template_param) * Provide values for all but the (member & non-member) function pointer case. Simple constant integer values for member pointers (offset within the object) and address for the value pointer case. GCC doesn't provide a value for the member function pointer case so I'm not sure how, if at all, GDB supports encoding that. & non-member function pointers should follow shortly in a subsequent patch. * Null pointer value encodings of all of these types, including correctly encoding null data member pointers as -1. llvm-svn: 181634
2013-05-11 05:53:14 +08:00
// The interesting null pointer: -1 for member data pointers (since they are
// just an offset in an object, they can be zero and non-null for the first
// member)
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCNARG4]] = !DITemplateValueParameter(name: "a", type: [[MEMINTPTR]], value: i64 -1)
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
nullptr,
PR14992: Debug Info: Support more non-type template parameters * Provide DW_TAG_template_value_parameter for pointers, function pointers, member pointers, and member function pointers (still missing support for template template parameters which GCC encodes as a DW_TAG_GNU_template_template_param) * Provide values for all but the (member & non-member) function pointer case. Simple constant integer values for member pointers (offset within the object) and address for the value pointer case. GCC doesn't provide a value for the member function pointer case so I'm not sure how, if at all, GDB supports encoding that. & non-member function pointers should follow shortly in a subsequent patch. * Null pointer value encodings of all of these types, including correctly encoding null data member pointers as -1. llvm-svn: 181634
2013-05-11 05:53:14 +08:00
//
// In some future iteration we could possibly emit the value of a null member
// function pointer as '{ i64, i64 } zeroinitializer' as it may be handled
// naturally from the LLVM CodeGen side once we decide how to handle non-null
// member function pointers. For now, it's simpler just to emit the 'i8 0'.
//
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCNARG5]] = !DITemplateValueParameter(name: "b", type: [[MEMFUNPTR]], value: i8 0)
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
nullptr,
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCNARG6]] = !DITemplateValueParameter(name: "f", type: [[FUNPTR]], value: i8 0)
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
nullptr
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[TCNARG7]] = !DITemplateValueParameter(tag: DW_TAG_GNU_template_parameter_pack, name: "Is", value: [[EMPTY]])
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
> tcn;
template<typename>
struct tmpl_impl {
};
[c++20] For P1907R1: Add checking for structural types for non-type template parameters. No support for the new kinds of non-type template argument yet. This is not entirely NFC for prior language modes: we have historically incorrectly accepted rvalue references as the types of non-type template parameters. Such invalid code is now rejected.
2020-09-21 11:10:02 +08:00
template <template <typename> class tmpl, int &lvr>
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
struct NN {
};
Adapt testcases to LLVM change r312144 in DIGlobalVariableExpression llvm-svn: 312148
2017-08-31 02:22:23 +08:00
// CHECK: [[NN]] = !DIGlobalVariableExpression(var: [[NNV:.*]], expr: !DIExpression())
Update for LLVM global variable debug info API change. This reapplies r289921. llvm-svn: 290155
2016-12-20 10:10:02 +08:00
// CHECK: [[NNV]] = distinct !DIGlobalVariable(name: "nn"
// CHECK-SAME: type: ![[NNT:[0-9]+]]
DebugInfo: Cleanup testing of non-type template parameters. Separate out the non-nullable parameters from the nullable ones (currently only the template template parameter) and demonstrate that cv-qualifiers aren't preserved for non-null parameters (but are preserved for null parameters) by adding 'const' to an int* non-type template parameter. llvm-svn: 219883
2014-10-16 08:41:40 +08:00
[c++20] For P1907R1: Add checking for structural types for non-type template parameters. No support for the new kinds of non-type template argument yet. This is not entirely NFC for prior language modes: we have historically incorrectly accepted rvalue references as the types of non-type template parameters. Such invalid code is now rejected.
2020-09-21 11:10:02 +08:00
// CHECK: ![[NNT]] ={{.*}}!DICompositeType(tag: DW_TAG_structure_type, name: "NN<tmpl_impl, glb>",
DebugInfo: Move new hierarchy into place (clang) Update testcases for LLVM change in r231082 to use the new debug info hierarchy. llvm-svn: 231083
2015-03-04 01:25:55 +08:00
// CHECK-SAME: templateParams: [[NNARGS:![0-9]*]]
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
// CHECK-SAME: identifier:
[c++20] For P1907R1: Add checking for structural types for non-type template parameters. No support for the new kinds of non-type template argument yet. This is not entirely NFC for prior language modes: we have historically incorrectly accepted rvalue references as the types of non-type template parameters. Such invalid code is now rejected.
2020-09-21 11:10:02 +08:00
// CHECK: [[NNARGS]] = !{[[NNARG1:![0-9]*]], [[NNARG2:![0-9]*]]}
DebugInfo: Metadata constructs now start with DI* LLVM r236120 renamed debug info IR constructs to use a `DI` prefix, now that the `DIDescriptor` hierarchy has been gone for about a week. This commit was generated using the rename-md-di-nodes.sh upgrade script attached to PR23080, followed by running clang-format-diff.py on the `lib/` portion of the patch. llvm-svn: 236121
2015-04-30 00:40:08 +08:00
// CHECK: [[NNARG1]] = !DITemplateValueParameter(tag: DW_TAG_GNU_template_template_param, name: "tmpl", value: !"tmpl_impl")
// CHECK: [[NNARG2]] = !DITemplateValueParameter(name: "lvr", type: [[INTLVR:![0-9]*]], value: i32* @glb)
// CHECK: [[INTLVR]] = !DIDerivedType(tag: DW_TAG_reference_type, baseType: [[INT]]
[c++20] For P1907R1: Add checking for structural types for non-type template parameters. No support for the new kinds of non-type template argument yet. This is not entirely NFC for prior language modes: we have historically incorrectly accepted rvalue references as the types of non-type template parameters. Such invalid code is now rejected.
2020-09-21 11:10:02 +08:00
NN<tmpl_impl, glb> nn;
DebugInfo: Emit info for constant expressions in template arguments Summary: This allows us to handle the general case where a non-type template argument evaluates to a constant expression which isn't integral or a declaration. This fixes PR16939. Reviewers: dblaikie, rsmith Reviewed By: dblaikie CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1453 llvm-svn: 189165
2013-08-24 16:21:10 +08:00
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
// CHECK: ![[PADDINGATEND:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "PaddingAtEnd",
DebugInfo: Emit info for casted decls in template args Summary: Previously the backend wouldn't get to see the underlying GlobalValue that corresponds to the template argument because it would be hidden by a cast at the IR level. Instead strip the pointer casts off of the value until we see the underlying GlobalValue. Reviewers: dblaikie, echristo, majnemer Reviewed By: majnemer CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1508 llvm-svn: 189200
2013-08-26 06:13:27 +08:00
struct PaddingAtEnd {
int i;
char c;
};
PaddingAtEnd PaddedObj = {};
DebugInfo: Adapt to loss of DITypeRef in LLVM r267296 LLVM stopped using MDString-based type references, and DIBuilder no longer fills 'retainedTypes:' with every DICompositeType that has an 'identifier:' field. There are just minor changes to keep the same behaviour in CFE. Leaving 'retainedTypes:' unfilled has a dramatic impact on the output order of the IR though. There are a huge number of testcase changes, which were unfortunately not really scriptable. llvm-svn: 267297
2016-04-24 05:08:27 +08:00
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "PaddingAtEndTemplate<&PaddedObj>"
// CHECK-SAME: templateParams: [[PTOARGS:![0-9]*]]
// CHECK: [[PTOARGS]] = !{[[PTOARG1:![0-9]*]]}
// CHECK: [[PTOARG1]] = !DITemplateValueParameter(type: [[CONST_PADDINGATEND_PTR:![0-9]*]], value: %struct.PaddingAtEnd* @PaddedObj)
DebugInfo: pass alignment value only if it was forced Preparation to implement DW_AT_alignment support: - We pass non-zero align value to DIBuilder only when alignment was forced - Modify tests to match this change Differential Revision: https://reviews.llvm.org/D24426 llvm-svn: 284679
2016-10-20 08:13:19 +08:00
// CHECK: [[CONST_PADDINGATEND_PTR]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: ![[PADDINGATEND]], size: 64)
DebugInfo: Cleanup testing of non-type template parameters. Separate out the non-nullable parameters from the nullable ones (currently only the template template parameter) and demonstrate that cv-qualifiers aren't preserved for non-null parameters (but are preserved for null parameters) by adding 'const' to an int* non-type template parameter. llvm-svn: 219883
2014-10-16 08:41:40 +08:00
template <PaddingAtEnd *>
DebugInfo: Emit info for casted decls in template args Summary: Previously the backend wouldn't get to see the underlying GlobalValue that corresponds to the template argument because it would be hidden by a cast at the IR level. Instead strip the pointer casts off of the value until we see the underlying GlobalValue. Reviewers: dblaikie, echristo, majnemer Reviewed By: majnemer CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D1508 llvm-svn: 189200
2013-08-26 06:13:27 +08:00
struct PaddingAtEndTemplate {
};
PaddingAtEndTemplate<&PaddedObj> PaddedTemplateObj;
PR48169: Fix crash generating debug info for class non-type template parameters. It appears that LLVM isn't able to generate a DW_AT_const_value for a constant of class type, but if it could, we'd match GCC's debug info in this case, and in the interim we no longer crash.
2020-11-16 09:40:57 +08:00
struct ClassTemplateArg {
int a;
float f;
};
template<ClassTemplateArg A> struct ClassTemplateArgTemplate {
static constexpr const ClassTemplateArg &Arg = A;
};
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "ClassTemplateArgTemplate<{1, 2.000000e+00}>", {{.*}}, templateParams: ![[CLASS_TEMP_ARGS:[0-9]*]],
// CHECK: ![[CLASS_TEMP_ARG_CONST_REF_TYPE:[0-9]*]] = !DIDerivedType(tag: DW_TAG_reference_type, baseType: ![[CLASS_TEMP_ARG_CONST_TYPE:[0-9]*]],
// CHECK: ![[CLASS_TEMP_ARG_CONST_TYPE]] = !DIDerivedType(tag: DW_TAG_const_type, baseType: ![[CLASS_TEMP_ARG_TYPE:[0-9]*]])
// CHECK: ![[CLASS_TEMP_ARG_TYPE]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "ClassTemplateArg",
// CHECK: ![[CLASS_TEMP_ARGS]] = !{![[CLASS_TEMP_ARG:[0-9]*]]}
// CHECK: ![[CLASS_TEMP_ARG]] = !DITemplateValueParameter(name: "A", type: ![[CLASS_TEMP_ARG_TYPE]], value: %{{[^ *]+}} { i32 1, float 2.000000e+00 })
ClassTemplateArgTemplate<ClassTemplateArg{1, 2.0f}> ClassTemplateArgObj;
template<const ClassTemplateArg&> struct ClassTemplateArgRefTemplate {};
ClassTemplateArgRefTemplate<ClassTemplateArgObj.Arg> ClassTemplateArgRefObj;
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "ClassTemplateArgRefTemplate<<template param ClassTemplateArg{1, 2.000000e+00}> >", {{.*}}, templateParams: ![[CLASS_TEMP_REF_ARGS:[0-9]*]],
// CHECK: ![[CLASS_TEMP_REF_ARGS]] = !{![[CLASS_TEMP_REF_ARG:[0-9]*]]}
// CHECK: ![[CLASS_TEMP_REF_ARG]] = !DITemplateValueParameter(type: ![[CLASS_TEMP_ARG_CONST_REF_TYPE]], value: %{{.*}}* @_ZTAXtl16ClassTemplateArgLi1ELf40000000EEE)
DebugInfo: Include inline namespaces in template specialization parameter names This ensures these types have distinct names if they are distinct types (eg: if one is an instantiation with a type in one inline namespace, and another from a type with the same simple name, but in a different inline namespace).
2021-04-09 08:36:41 +08:00
inline namespace inl {
struct t1 { };
}
template<typename T> struct ClassTemplateInlineNamespaceArg {
};
ClassTemplateInlineNamespaceArg<inl::t1> ClassTemplateInlineNamespaceArgObj;
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "ClassTemplateInlineNamespaceArg<inl::t1>",
DebugInfo: Name class templates with default arguments consistently (both direct naming, and as a template argument for a function template) It's noteworthy that GCC has the same bug here, which is a bit surprising. Both Clang and GCC's bug is only for function template arguments that are themselves templates with default template arguments (f1<t1<int[, missing_default_here]>>). Probably because function name matching isn't generally necessary - whereas type matching is necessary for DWARF consumers to associate declarations and definitions across translation units, so the bug's been addressed there already - but continued to exist for function templates since it's fairly benign there. I came across this while working on a change that could reconstitute these pretty printed names based on the rest of the DWARF, reducing the size of the DWARF by not having to encode all the template parameters in the name string. That reconstitution code can't tell the difference between a defaulted argument or not, so couldn't create the current buggy-ish output. Making the names more consistent between direct and indirect references, and between function and class templates seems all to the good. (I fixed the function template version of this a few years back in 9fdd09a4ccd01feb8e00be22b17e944e46807746 - clearly I should've looked more closely and generalized the code better so it only had to be fixed once - well, doing that here now)
2021-07-18 14:38:33 +08:00
namespace IndirectDefaultArgument {
template<typename T1, typename T2 = int>
struct t1 { };
template<typename T>
void f1() {
}
template void f1<t1<int>>();
// CHECK: !DISubprogram(name: "f1<IndirectDefaultArgument::t1<int, int> >",
DebugInfo: Correct printing empty template parameter packs Empty packs in the non-final position would result in an extra ", ". Empty packs in the final position would result in missing the space between trailing >>.
2021-08-31 01:06:00 +08:00
} // namespace IndirectDefaultArgument
namespace EmptyTrailingPack {
template<typename T>
struct t1 { };
template<typename T, typename ...Ts>
void f1() {
}
template void f1<t1<int>>();
// CHECK: !DISubprogram(name: "f1<EmptyTrailingPack::t1<int> >",
} // namespace EmptyTrailingPack
namespace EmptyInnerPack {
template<typename ...Ts, typename T = int>
void f1() {
DebugInfo: Name class templates with default arguments consistently (both direct naming, and as a template argument for a function template) It's noteworthy that GCC has the same bug here, which is a bit surprising. Both Clang and GCC's bug is only for function template arguments that are themselves templates with default template arguments (f1<t1<int[, missing_default_here]>>). Probably because function name matching isn't generally necessary - whereas type matching is necessary for DWARF consumers to associate declarations and definitions across translation units, so the bug's been addressed there already - but continued to exist for function templates since it's fairly benign there. I came across this while working on a change that could reconstitute these pretty printed names based on the rest of the DWARF, reducing the size of the DWARF by not having to encode all the template parameters in the name string. That reconstitution code can't tell the difference between a defaulted argument or not, so couldn't create the current buggy-ish output. Making the names more consistent between direct and indirect references, and between function and class templates seems all to the good. (I fixed the function template version of this a few years back in 9fdd09a4ccd01feb8e00be22b17e944e46807746 - clearly I should've looked more closely and generalized the code better so it only had to be fixed once - well, doing that here now)
2021-07-18 14:38:33 +08:00
}
DebugInfo: Correct printing empty template parameter packs Empty packs in the non-final position would result in an extra ", ". Empty packs in the final position would result in missing the space between trailing >>.
2021-08-31 01:06:00 +08:00
template void f1<>();
// CHECK: !DISubprogram(name: "f1<int>",
} // namespace EmptyInnerPack
DebugInfo: Add support for template parameters with qualifiers eg: t1<void () const> - DWARF doesn't have a particularly nice way to encode this, for real member function types (like `void (t1::*)() const`) the const-ness is encoded in the type of the artificial first parameter. But `void () const` has no parameters, so encode it like a normal const-qualified type, using DW_TAG_const_type. (similarly for restrict and volatile) Reference qualifiers (& and &&) coming in a separate commit shortly.
2021-09-14 15:02:36 +08:00
namespace RawFuncQual {
struct t1; // use this to ensure the type parameter doesn't shift due to other test cases in this file
DebugInfo: Add support for template parameters with reference qualifiers Followon from the previous commit supporting cvr qualifiers.
2021-09-14 15:32:06 +08:00
template<typename T1, typename T2, typename T3, typename T4>
DebugInfo: Add support for template parameters with qualifiers eg: t1<void () const> - DWARF doesn't have a particularly nice way to encode this, for real member function types (like `void (t1::*)() const`) the const-ness is encoded in the type of the artificial first parameter. But `void () const` has no parameters, so encode it like a normal const-qualified type, using DW_TAG_const_type. (similarly for restrict and volatile) Reference qualifiers (& and &&) coming in a separate commit shortly.
2021-09-14 15:02:36 +08:00
void f1() { }
DebugInfo: Add support for template parameters with reference qualifiers Followon from the previous commit supporting cvr qualifiers.
2021-09-14 15:32:06 +08:00
template void f1<t1 () volatile, t1 () const volatile, t1 () &, t1 () &&>();
// CHECK: !DISubprogram(name: "f1<RawFuncQual::t1 () volatile, RawFuncQual::t1 () const volatile, RawFuncQual::t1 () &, RawFuncQual::t1 () &&>",
DebugInfo: Add support for template parameters with qualifiers eg: t1<void () const> - DWARF doesn't have a particularly nice way to encode this, for real member function types (like `void (t1::*)() const`) the const-ness is encoded in the type of the artificial first parameter. But `void () const` has no parameters, so encode it like a normal const-qualified type, using DW_TAG_const_type. (similarly for restrict and volatile) Reference qualifiers (& and &&) coming in a separate commit shortly.
2021-09-14 15:02:36 +08:00
// CHECK-SAME: templateParams: ![[RAW_FUNC_QUAL_ARGS:[0-9]*]],
DebugInfo: Add support for template parameters with reference qualifiers Followon from the previous commit supporting cvr qualifiers.
2021-09-14 15:32:06 +08:00
// CHECK: ![[RAW_FUNC_QUAL_ARGS]] = !{![[RAW_FUNC_QUAL_T1:[0-9]*]], ![[RAW_FUNC_QUAL_T2:[0-9]*]], ![[RAW_FUNC_QUAL_T3:[0-9]*]], ![[RAW_FUNC_QUAL_T4:[0-9]*]]}
DebugInfo: Add support for template parameters with qualifiers eg: t1<void () const> - DWARF doesn't have a particularly nice way to encode this, for real member function types (like `void (t1::*)() const`) the const-ness is encoded in the type of the artificial first parameter. But `void () const` has no parameters, so encode it like a normal const-qualified type, using DW_TAG_const_type. (similarly for restrict and volatile) Reference qualifiers (& and &&) coming in a separate commit shortly.
2021-09-14 15:02:36 +08:00
// CHECK: ![[RAW_FUNC_QUAL_T1]] = !DITemplateTypeParameter(name: "T1", type: ![[RAW_FUNC_QUAL_VOL:[0-9]*]])
// CHECK: ![[RAW_FUNC_QUAL_VOL]] = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: ![[RAW_FUNC_QUAL_TYPE:[0-9]*]])
// CHECK: ![[RAW_FUNC_QUAL_TYPE]] = !DISubroutineType(types: ![[RAW_FUNC_QUAL_LIST:[0-9]*]]
// CHECK: ![[RAW_FUNC_QUAL_LIST]] = !{![[RAW_FUNC_QUAL_STRUCT:[0-9]*]]}
// CHECK: ![[RAW_FUNC_QUAL_STRUCT]] = !DICompositeType(tag: DW_TAG_structure_type, name: "t1"
// CHECK: ![[RAW_FUNC_QUAL_T2]] = !DITemplateTypeParameter(name: "T2", type: ![[RAW_FUNC_QUAL_CNST:[0-9]*]])
// CHECK: ![[RAW_FUNC_QUAL_CNST]] = !DIDerivedType(tag: DW_TAG_const_type, baseType: ![[RAW_FUNC_QUAL_TYPE:[0-9]*]])
DebugInfo: Add support for template parameters with reference qualifiers Followon from the previous commit supporting cvr qualifiers.
2021-09-14 15:32:06 +08:00
// CHECK: ![[RAW_FUNC_QUAL_T3]] = !DITemplateTypeParameter(name: "T3", type: ![[RAW_FUNC_QUAL_REF:[0-9]*]])
// CHECK: ![[RAW_FUNC_QUAL_REF]] = !DISubroutineType(flags: DIFlagLValueReference, types: ![[RAW_FUNC_QUAL_LIST]])
// CHECK: ![[RAW_FUNC_QUAL_T4]] = !DITemplateTypeParameter(name: "T4", type: ![[RAW_FUNC_QUAL_REF_REF:[0-9]*]])
// CHECK: ![[RAW_FUNC_QUAL_REF_REF]] = !DISubroutineType(flags: DIFlagRValueReference, types: ![[RAW_FUNC_QUAL_LIST]])
DebugInfo: Add support for template parameters with qualifiers eg: t1<void () const> - DWARF doesn't have a particularly nice way to encode this, for real member function types (like `void (t1::*)() const`) the const-ness is encoded in the type of the artificial first parameter. But `void () const` has no parameters, so encode it like a normal const-qualified type, using DW_TAG_const_type. (similarly for restrict and volatile) Reference qualifiers (& and &&) coming in a separate commit shortly.
2021-09-14 15:02:36 +08:00
} // namespace RawFuncQual
Print nullptr_t namespace qualified within std:: This improves diagnostic (& important to me, DWARF) accuracy - otherwise there could be ambiguities between "std::nullptr_t" and some user-defined type that's /actually/ "nullptr_t" defined in the global namespace. Differential Revision: https://reviews.llvm.org/D110044
2021-09-20 05:32:45 +08:00
namespace Nullptr_t {
template <typename T>
void f1() {}
template void f1<decltype(nullptr)>();
// CHECK: !DISubprogram(name: "f1<std::nullptr_t>",
} // namespace Nullptr_t
DebugInfo: Don't suppress inline namespaces when printing template template parameter names
2021-09-22 10:25:33 +08:00
namespace TemplateTemplateParamInlineNamespace {
inline namespace inl {
template<typename>
struct t1 { };
} // namespace inl
template<template<typename> class> void f1() { }
template void f1<t1>();
// CHECK: !DISubprogram(name: "f1<TemplateTemplateParamInlineNamespace::inl::t1>",
// CHECK-SAME: templateParams: ![[TEMP_TEMP_INL_ARGS:[0-9]*]],
// CHECK: ![[TEMP_TEMP_INL_ARGS]] = !{![[TEMP_TEMP_INL_ARGS_T:[0-9]*]]}
// CHECK: ![[TEMP_TEMP_INL_ARGS_T]] = !DITemplateValueParameter(tag: DW_TAG_GNU_template_template_param, value: !"TemplateTemplateParamInlineNamespace::inl::t1")
} // namespace TemplateTemplateParamInlineNamespace
DebugInfo: Don't use preferred template names in debug info Using the preferred name creates a mismatch between the textual name of a type and the DWARF tags describing the parameters as well as possible inconsistency between DWARF producers (like Clang and GCC, or older/newer Clang versions, etc).
2021-09-20 11:34:45 +08:00
namespace NoPreferredNames {
template <typename T> struct t1;
using t1i = t1<int>;
template <typename T>
struct __attribute__((__preferred_name__(t1i))) t1 {};
template <typename T>
void f1() {}
template void f1<t1<int>>();
// CHECK: !DISubprogram(name: "f1<NoPreferredNames::t1<int> >",
} // namespace NoPreferredNames