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-explici...

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

129 lines
3.3 KiB
C++
Raw Normal View History

Temporarily Revert "[DebugInfo] Move constructor homing case in shouldOmitDefinition." as it's causing test failures. This reverts commit 589ce5f7050dd83fd3f7dbc182ea0fb051ece994.
2020-08-25 12:51:31 +08:00
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -debug-info-kind=limited %s -o - | FileCheck %s
Add a test case for r202888, which boiled down to -gline-tables-only clang-cl defaults to -gline-tables-only, because that's the only CodeView debug info that LLVM knows how to emit. llvm-svn: 202891
2014-03-05 05:33:26 +08:00
Reland "[DebugInfo] Move constructor homing case in shouldOmitDefinition." For some reason the ctor homing case was before the template specialization case, and could have returned false too early. I moved the code out into a separate function to avoid this. This reverts commit 05777ab941063192b9ccb1775358a83a2700ccc1.
2020-08-26 01:36:03 +08:00
// Make sure this still works with constructor homing.
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -debug-info-kind=constructor %s -o - | FileCheck %s
[DEBUGINFO] Add support for emission of the debug directives only. Summary: Added option -gline-directives-only to support emission of the debug directives only. It behaves very similar to -gline-tables-only, except that it sets llvm debug info emission kind to llvm::DICompileUnit::DebugDirectivesOnly. Reviewers: echristo Subscribers: aprantl, fedor.sergeev, JDevlieghere, cfe-commits Differential Revision: https://reviews.llvm.org/D51177 llvm-svn: 341212
2018-08-31 21:56:14 +08:00
// Run again with -gline-tables-only or -gline-directives-only and verify we don't crash. We won't output
Add a test case for r202888, which boiled down to -gline-tables-only clang-cl defaults to -gline-tables-only, because that's the only CodeView debug info that LLVM knows how to emit. llvm-svn: 202891
2014-03-05 05:33:26 +08:00
// type info at all.
Stop messing with the 'g' group of options in CompilerInvocation. With this change, most 'g' options are rejected by CompilerInvocation. They remain only as Driver options. The new way to request debug info from cc1 is with "-debug-info-kind={line-tables-only|limited|standalone}" and "-dwarf-version={2|3|4}". In the absence of a command-line option to specify Dwarf version, the Toolchain decides it, rather than placing Toolchain-specific logic in CompilerInvocation. Also fix a bug in the Windows compatibility argument parsing in which the "rightmost argument wins" principle failed. Differential Revision: http://reviews.llvm.org/D13221 llvm-svn: 249655
2015-10-08 12:24:12 +08:00
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -debug-info-kind=line-tables-only %s -o - | FileCheck %s -check-prefix LINES-ONLY
[DEBUGINFO] Add support for emission of the debug directives only. Summary: Added option -gline-directives-only to support emission of the debug directives only. It behaves very similar to -gline-tables-only, except that it sets llvm debug info emission kind to llvm::DICompileUnit::DebugDirectivesOnly. Reviewers: echristo Subscribers: aprantl, fedor.sergeev, JDevlieghere, cfe-commits Differential Revision: https://reviews.llvm.org/D51177 llvm-svn: 341212
2018-08-31 21:56:14 +08:00
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -debug-info-kind=line-directives-only %s -o - | FileCheck %s -check-prefix LINES-ONLY
Add a test case for r202888, which boiled down to -gline-tables-only clang-cl defaults to -gline-tables-only, because that's the only CodeView debug info that LLVM knows how to emit. llvm-svn: 202891
2014-03-05 05:33:26 +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
// LINES-ONLY-NOT: !DICompositeType(tag: DW_TAG_structure_type
DebugInfo: Emit only the declaration of a class template that has an explicit instantiation declaration (& always emit such a type when there's an explicit instantiation definition) We should only have this optimization fire when the explicit instantiation definition would cause at least one member function to be emitted, thus ensuring that even a compiler not performing this optimization would still emit the full type information elsewhere. But we should also pessimize output still by always emitting the definition when the explicit instantiation definition appears so that at some point in the future we can depend on that information even when no code had to be emitted in that TU. (this shouldn't happen very often, since people mostly use explicit spec decl/defs to reduce code size - but perhaps one day they could use it to explicitly reduce debug info size too) This was worth about 2% for Clang and LLVM - so not a huge win, but a win. It looks really great for simple STL programs (include <string> and just declare a string - 14k -> 1.4k of .dwo) llvm-svn: 202769
2014-03-04 07:48:23 +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
// "h" is at the top because it's in the compile unit's retainedTypes: list.
// CHECK: DICompositeType(tag: DW_TAG_structure_type, name: "h<int>"
// CHECK-NOT: DIFlagFwdDecl
// CHECK-SAME: ){{$}}
DebugInfo: Emit only the declaration of a class template that has an explicit instantiation declaration (& always emit such a type when there's an explicit instantiation definition) We should only have this optimization fire when the explicit instantiation definition would cause at least one member function to be emitted, thus ensuring that even a compiler not performing this optimization would still emit the full type information elsewhere. But we should also pessimize output still by always emitting the definition when the explicit instantiation definition appears so that at some point in the future we can depend on that information even when no code had to be emitted in that TU. (this shouldn't happen very often, since people mostly use explicit spec decl/defs to reduce code size - but perhaps one day they could use it to explicitly reduce debug info size too) This was worth about 2% for Clang and LLVM - so not a huge win, but a win. It looks really great for simple STL programs (include <string> and just declare a string - 14k -> 1.4k of .dwo) llvm-svn: 202769
2014-03-04 07:48:23 +08:00
template <typename T>
struct a {
};
extern template class a<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-NOT: DICompositeType(tag: DW_TAG_structure_type, name: "a<int>"
DebugInfo: Emit only the declaration of a class template that has an explicit instantiation declaration (& always emit such a type when there's an explicit instantiation definition) We should only have this optimization fire when the explicit instantiation definition would cause at least one member function to be emitted, thus ensuring that even a compiler not performing this optimization would still emit the full type information elsewhere. But we should also pessimize output still by always emitting the definition when the explicit instantiation definition appears so that at some point in the future we can depend on that information even when no code had to be emitted in that TU. (this shouldn't happen very often, since people mostly use explicit spec decl/defs to reduce code size - but perhaps one day they could use it to explicitly reduce debug info size too) This was worth about 2% for Clang and LLVM - so not a huge win, but a win. It looks really great for simple STL programs (include <string> and just declare a string - 14k -> 1.4k of .dwo) llvm-svn: 202769
2014-03-04 07:48:23 +08:00
template <typename T>
struct b {
};
extern template class b<int>;
b<int> bi;
template <typename T>
struct c {
void f() {}
};
extern template class c<int>;
c<int> ci;
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: DICompositeType(tag: DW_TAG_structure_type, name: "c<int>"
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: DIFlagFwdDecl
DebugInfo: Emit only the declaration of a class template that has an explicit instantiation declaration (& always emit such a type when there's an explicit instantiation definition) We should only have this optimization fire when the explicit instantiation definition would cause at least one member function to be emitted, thus ensuring that even a compiler not performing this optimization would still emit the full type information elsewhere. But we should also pessimize output still by always emitting the definition when the explicit instantiation definition appears so that at some point in the future we can depend on that information even when no code had to be emitted in that TU. (this shouldn't happen very often, since people mostly use explicit spec decl/defs to reduce code size - but perhaps one day they could use it to explicitly reduce debug info size too) This was worth about 2% for Clang and LLVM - so not a huge win, but a win. It looks really great for simple STL programs (include <string> and just declare a string - 14k -> 1.4k of .dwo) llvm-svn: 202769
2014-03-04 07:48:23 +08:00
template <typename T>
struct d {
void f();
};
extern template class d<int>;
d<int> di;
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: DICompositeType(tag: DW_TAG_structure_type, name: "d<int>"
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: DIFlagFwdDecl
// CHECK-SAME: ){{$}}
DebugInfo: Emit only the declaration of a class template that has an explicit instantiation declaration (& always emit such a type when there's an explicit instantiation definition) We should only have this optimization fire when the explicit instantiation definition would cause at least one member function to be emitted, thus ensuring that even a compiler not performing this optimization would still emit the full type information elsewhere. But we should also pessimize output still by always emitting the definition when the explicit instantiation definition appears so that at some point in the future we can depend on that information even when no code had to be emitted in that TU. (this shouldn't happen very often, since people mostly use explicit spec decl/defs to reduce code size - but perhaps one day they could use it to explicitly reduce debug info size too) This was worth about 2% for Clang and LLVM - so not a huge win, but a win. It looks really great for simple STL programs (include <string> and just declare a string - 14k -> 1.4k of .dwo) llvm-svn: 202769
2014-03-04 07:48:23 +08:00
template <typename T>
struct e {
void f();
};
template <typename T>
void e<T>::f() {
}
extern template class e<int>;
e<int> ei;
DebugInfo: Improvements/corrections to conservative emission of types in explicit template instantiation declarations * detect out of line definitions correctly * detect member function explicit specializations correctly llvm-svn: 202779
2014-03-04 11:08:14 +08:00
// There's no guarantee that the out of line definition will appear before the
// explicit template instantiation definition, so conservatively emit the type
// definition here.
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: DICompositeType(tag: DW_TAG_structure_type, name: "e<int>"
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: DIFlagFwdDecl
// CHECK-SAME: ){{$}}
DebugInfo: Emit only the declaration of a class template that has an explicit instantiation declaration (& always emit such a type when there's an explicit instantiation definition) We should only have this optimization fire when the explicit instantiation definition would cause at least one member function to be emitted, thus ensuring that even a compiler not performing this optimization would still emit the full type information elsewhere. But we should also pessimize output still by always emitting the definition when the explicit instantiation definition appears so that at some point in the future we can depend on that information even when no code had to be emitted in that TU. (this shouldn't happen very often, since people mostly use explicit spec decl/defs to reduce code size - but perhaps one day they could use it to explicitly reduce debug info size too) This was worth about 2% for Clang and LLVM - so not a huge win, but a win. It looks really great for simple STL programs (include <string> and just declare a string - 14k -> 1.4k of .dwo) llvm-svn: 202769
2014-03-04 07:48:23 +08:00
template <typename T>
struct f {
void g();
};
extern template class f<int>;
template <typename T>
void f<T>::g() {
}
f<int> fi;
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: DICompositeType(tag: DW_TAG_structure_type, name: "f<int>"
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: DIFlagFwdDecl
// CHECK-SAME: ){{$}}
DebugInfo: Emit only the declaration of a class template that has an explicit instantiation declaration (& always emit such a type when there's an explicit instantiation definition) We should only have this optimization fire when the explicit instantiation definition would cause at least one member function to be emitted, thus ensuring that even a compiler not performing this optimization would still emit the full type information elsewhere. But we should also pessimize output still by always emitting the definition when the explicit instantiation definition appears so that at some point in the future we can depend on that information even when no code had to be emitted in that TU. (this shouldn't happen very often, since people mostly use explicit spec decl/defs to reduce code size - but perhaps one day they could use it to explicitly reduce debug info size too) This was worth about 2% for Clang and LLVM - so not a huge win, but a win. It looks really great for simple STL programs (include <string> and just declare a string - 14k -> 1.4k of .dwo) llvm-svn: 202769
2014-03-04 07:48:23 +08:00
template <typename T>
struct g {
void f();
};
template <>
void g<int>::f();
extern template class g<int>;
g<int> gi;
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: DICompositeType(tag: DW_TAG_structure_type, name: "g<int>"
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: DIFlagFwdDecl
// CHECK-SAME: ){{$}}
DebugInfo: Emit only the declaration of a class template that has an explicit instantiation declaration (& always emit such a type when there's an explicit instantiation definition) We should only have this optimization fire when the explicit instantiation definition would cause at least one member function to be emitted, thus ensuring that even a compiler not performing this optimization would still emit the full type information elsewhere. But we should also pessimize output still by always emitting the definition when the explicit instantiation definition appears so that at some point in the future we can depend on that information even when no code had to be emitted in that TU. (this shouldn't happen very often, since people mostly use explicit spec decl/defs to reduce code size - but perhaps one day they could use it to explicitly reduce debug info size too) This was worth about 2% for Clang and LLVM - so not a huge win, but a win. It looks really great for simple STL programs (include <string> and just declare a string - 14k -> 1.4k of .dwo) llvm-svn: 202769
2014-03-04 07:48:23 +08:00
template <typename T>
struct h {
};
template class h<int>;
DebugInfo: Improvements/corrections to conservative emission of types in explicit template instantiation declarations * detect out of line definitions correctly * detect member function explicit specializations correctly llvm-svn: 202779
2014-03-04 11:08:14 +08:00
template <typename T>
struct i {
void f() {}
};
template<> void i<int>::f();
extern template class i<int>;
i<int> ii;
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: DICompositeType(tag: DW_TAG_structure_type, name: "i<int>"
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: DIFlagFwdDecl
// CHECK-SAME: ){{$}}
DebugInfo: Include default template arguments in template type names This was committed 4 years ago in 108916 with insufficient testing to explain why the "getTypeAsWritten" case was appropriate. Experience says that it isn't - the presence or absence of an explicit instantiation declaration was causing this code to generate either i<int> or i<int, int>. That didn't seem to be a useful distinction, and omitting the template arguments was destructive to debuggers being able to associate the two types across translation units or across compilers (GCC, reasonably, never omitted the arguments). llvm-svn: 205447
2014-04-03 02:21:09 +08:00
template <typename T1, typename T2 = T1>
struct j {
};
extern template class j<int>;
j<int> jj;
DebugInfo: Render the canonical name of a class template specialization, even when nested in another class template specialization Differential Revision: https://reviews.llvm.org/D63031 llvm-svn: 375304
2019-10-19 07:58:34 +08:00
template <typename T>
struct j_wrap {
};
j_wrap<j<int>> j_wrap_j;
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: DICompositeType(tag: DW_TAG_structure_type, name: "j<int, int>"
[DebugInfo] Use SplitTemplateClosers (foo<bar<baz> >) in DWARF too Summary: D76801 caused some regressions in debuginfo compatibility by changing how certain functions were named. For CodeView we try to mirror MSVC exactly: this was fixed in a549c0d00486 For DWARF the situation is murkier. Per David Blaikie: > In general DWARF doesn't specify this at all. > [...] > This isn't the only naming divergence between GCC and Clang Nevertheless, including the space seems to provide better compatibility with GCC and GDB. E.g. cpexprs.cc in the GDB testsuite requires this formatting. And there was no particular desire to change the printing of names in debug info in the first place (just in diagnostics and other more user-facing text). Fixes PR46052 Reviewers: dblaikie, labath Subscribers: aprantl, cfe-commits, dyung Tags: #clang Differential Revision: https://reviews.llvm.org/D80554
2020-05-26 21:43:52 +08:00
// CHECK: DICompositeType(tag: DW_TAG_structure_type, name: "j_wrap<j<int, int> >"
PR21909: Don't try (and crash) to generate debug info for explicit instantiations of explicit specializations. llvm-svn: 224394
2014-12-17 07:49:18 +08:00
template <typename T>
struct k {
};
template <>
struct k<int>;
template struct k<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-NOT: !DICompositeType(tag: DW_TAG_structure_type, name: "k<int>"
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: DICompositeType(tag: DW_TAG_structure_type, name: "b<int>"
// CHECK-NOT: DIFlagFwdDecl
// CHECK-SAME: ){{$}}