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/cxx11-exception-spec.cpp

130 lines
4.0 KiB
C++
Raw Normal View History

Remove 'not' from some CodeGen tests These were just missing an expected-no-diagnostics directive. Also add -std=c++11 to a test warning noisly about extensions. llvm-svn: 197308
2013-12-14 12:49:06 +08:00
// RUN: %clang_cc1 -std=c++11 -emit-llvm %s -o - -verify -fexceptions -fcxx-exceptions -triple x86_64-linux-gnu | FileCheck %s
// expected-no-diagnostics
Implement DR1330 in C++11 mode, to support libstdc++4.7 which uses it. We have a new flavor of exception specification, EST_Uninstantiated. A function type with this exception specification carries a pointer to a FunctionDecl, and the exception specification for that FunctionDecl is instantiated (if needed) and used in the place of the function type's exception specification. When a function template declaration with a non-trivial exception specification is instantiated, the specialization's exception specification is set to this new 'uninstantiated' kind rather than being instantiated immediately. Expr::CanThrow has migrated onto Sema, so it can instantiate exception specs on-demand. Also, any odr-use of a function triggers the instantiation of its exception specification (the exception specification could be needed by IRGen). In passing, fix two places where a DeclRefExpr was created but the corresponding function was not actually marked odr-used. We used to get away with this, but don't any more. Also fix a bug where instantiating an exception specification which refers to function parameters resulted in a crash. We still have the same bug in default arguments, which I'll be looking into next. This, plus a tiny patch to fix libstdc++'s common_type, is enough for clang to parse (and, in very limited testing, support) all of libstdc++4.7's standard headers. llvm-svn: 154886
2012-04-17 08:58:00 +08:00
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
void h();
template<typename T> void f() noexcept(sizeof(T) == 4) { h(); }
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
template<typename T> void g() noexcept(sizeof(T) == 4);
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
template<typename T> struct S {
static void f() noexcept(sizeof(T) == 4) { h(); }
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
static void g() noexcept(sizeof(T) == 4);
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
};
Add more of the command line options as attribute flags. These can be easily queried by the back-end. llvm-svn: 176304
2013-03-01 06:49:57 +08:00
// CHECK: define {{.*}} @_Z1fIsEvv() [[NONE:#[0-9]+]] {
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
template<> void f<short>() { h(); }
Update clang to take into account the changes to personality fns llvm-svn: 239941
2015-06-18 04:53:19 +08:00
// CHECK: define {{.*}} @_Z1fIA2_sEvv() [[NUW:#[0-9]+]] personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
template<> void f<short[2]>() noexcept { h(); }
// CHECK: define {{.*}} @_ZN1SIsE1fEv()
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK-NOT: [[NUW]]
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
template<> void S<short>::f() { h(); }
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK: define {{.*}} @_ZN1SIA2_sE1fEv() [[NUW]]
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
template<> void S<short[2]>::f() noexcept { h(); }
[patch][pr19848] Produce explicit comdats in clang. The llvm IR until recently had no support for comdats. This was a problem when targeting C++ on ELF/COFF as just using weak linkage would cause quite a bit of dead bits to remain on the executable (unless -ffunction-sections, -fdata-sections and --gc-sections were used). To fix the problem, llvm's codegen will just assume that any weak or linkonce that is not in an explicit comdat should be output in one with the same name as the global. This unfortunately breaks cases like pr19848 where a weak symbol is not xpected to be part of any comdat. Now that we have explicit comdats in the IR, we can finally get both cases right. This first patch just makes clang give explicit comdats to GlobalValues where t is allowed to. A followup patch to llvm will then stop implicitly producing comdats. llvm-svn: 225705
2015-01-13 06:13:53 +08:00
// CHECK: define {{.*}} @_Z1fIDsEvv() [[NONE]] comdat {
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
template void f<char16_t>();
Update clang to take into account the changes to personality fns llvm-svn: 239941
2015-06-18 04:53:19 +08:00
// CHECK: define {{.*}} @_Z1fIA2_DsEvv() [[NUW]] comdat personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
template void f<char16_t[2]>();
// CHECK: define {{.*}} @_ZN1SIDsE1fEv()
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK-NOT: [[NUW]]
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
template void S<char16_t>::f();
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK: define {{.*}} @_ZN1SIA2_DsE1fEv() [[NUW]]
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
template void S<char16_t[2]>::f();
Implement DR1330 in C++11 mode, to support libstdc++4.7 which uses it. We have a new flavor of exception specification, EST_Uninstantiated. A function type with this exception specification carries a pointer to a FunctionDecl, and the exception specification for that FunctionDecl is instantiated (if needed) and used in the place of the function type's exception specification. When a function template declaration with a non-trivial exception specification is instantiated, the specialization's exception specification is set to this new 'uninstantiated' kind rather than being instantiated immediately. Expr::CanThrow has migrated onto Sema, so it can instantiate exception specs on-demand. Also, any odr-use of a function triggers the instantiation of its exception specification (the exception specification could be needed by IRGen). In passing, fix two places where a DeclRefExpr was created but the corresponding function was not actually marked odr-used. We used to get away with this, but don't any more. Also fix a bug where instantiating an exception specification which refers to function parameters resulted in a crash. We still have the same bug in default arguments, which I'll be looking into next. This, plus a tiny patch to fix libstdc++'s common_type, is enough for clang to parse (and, in very limited testing, support) all of libstdc++4.7's standard headers. llvm-svn: 154886
2012-04-17 08:58:00 +08:00
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
void h() {
Update clang to take into account the changes to personality fns llvm-svn: 239941
2015-06-18 04:53:19 +08:00
// CHECK: define {{.*}} @_Z1fIiEvv() [[NUW]] comdat personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
Implement DR1330 in C++11 mode, to support libstdc++4.7 which uses it. We have a new flavor of exception specification, EST_Uninstantiated. A function type with this exception specification carries a pointer to a FunctionDecl, and the exception specification for that FunctionDecl is instantiated (if needed) and used in the place of the function type's exception specification. When a function template declaration with a non-trivial exception specification is instantiated, the specialization's exception specification is set to this new 'uninstantiated' kind rather than being instantiated immediately. Expr::CanThrow has migrated onto Sema, so it can instantiate exception specs on-demand. Also, any odr-use of a function triggers the instantiation of its exception specification (the exception specification could be needed by IRGen). In passing, fix two places where a DeclRefExpr was created but the corresponding function was not actually marked odr-used. We used to get away with this, but don't any more. Also fix a bug where instantiating an exception specification which refers to function parameters resulted in a crash. We still have the same bug in default arguments, which I'll be looking into next. This, plus a tiny patch to fix libstdc++'s common_type, is enough for clang to parse (and, in very limited testing, support) all of libstdc++4.7's standard headers. llvm-svn: 154886
2012-04-17 08:58:00 +08:00
f<int>();
[patch][pr19848] Produce explicit comdats in clang. The llvm IR until recently had no support for comdats. This was a problem when targeting C++ on ELF/COFF as just using weak linkage would cause quite a bit of dead bits to remain on the executable (unless -ffunction-sections, -fdata-sections and --gc-sections were used). To fix the problem, llvm's codegen will just assume that any weak or linkonce that is not in an explicit comdat should be output in one with the same name as the global. This unfortunately breaks cases like pr19848 where a weak symbol is not xpected to be part of any comdat. Now that we have explicit comdats in the IR, we can finally get both cases right. This first patch just makes clang give explicit comdats to GlobalValues where t is allowed to. A followup patch to llvm will then stop implicitly producing comdats. llvm-svn: 225705
2015-01-13 06:13:53 +08:00
// CHECK: define {{.*}} @_Z1fIA2_iEvv() [[NONE]] comdat {
Implement DR1330 in C++11 mode, to support libstdc++4.7 which uses it. We have a new flavor of exception specification, EST_Uninstantiated. A function type with this exception specification carries a pointer to a FunctionDecl, and the exception specification for that FunctionDecl is instantiated (if needed) and used in the place of the function type's exception specification. When a function template declaration with a non-trivial exception specification is instantiated, the specialization's exception specification is set to this new 'uninstantiated' kind rather than being instantiated immediately. Expr::CanThrow has migrated onto Sema, so it can instantiate exception specs on-demand. Also, any odr-use of a function triggers the instantiation of its exception specification (the exception specification could be needed by IRGen). In passing, fix two places where a DeclRefExpr was created but the corresponding function was not actually marked odr-used. We used to get away with this, but don't any more. Also fix a bug where instantiating an exception specification which refers to function parameters resulted in a crash. We still have the same bug in default arguments, which I'll be looking into next. This, plus a tiny patch to fix libstdc++'s common_type, is enough for clang to parse (and, in very limited testing, support) all of libstdc++4.7's standard headers. llvm-svn: 154886
2012-04-17 08:58:00 +08:00
f<int[2]>();
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK: define {{.*}} @_ZN1SIiE1fEv() [[NUW]]
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
S<int>::f();
// CHECK: define {{.*}} @_ZN1SIA2_iE1fEv()
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK-NOT: [[NUW]]
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
S<int[2]>::f();
Update clang to take into account the changes to personality fns llvm-svn: 239941
2015-06-18 04:53:19 +08:00
// CHECK: define {{.*}} @_Z1fIfEvv() [[NUW]] comdat personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
Implement DR1330 in C++11 mode, to support libstdc++4.7 which uses it. We have a new flavor of exception specification, EST_Uninstantiated. A function type with this exception specification carries a pointer to a FunctionDecl, and the exception specification for that FunctionDecl is instantiated (if needed) and used in the place of the function type's exception specification. When a function template declaration with a non-trivial exception specification is instantiated, the specialization's exception specification is set to this new 'uninstantiated' kind rather than being instantiated immediately. Expr::CanThrow has migrated onto Sema, so it can instantiate exception specs on-demand. Also, any odr-use of a function triggers the instantiation of its exception specification (the exception specification could be needed by IRGen). In passing, fix two places where a DeclRefExpr was created but the corresponding function was not actually marked odr-used. We used to get away with this, but don't any more. Also fix a bug where instantiating an exception specification which refers to function parameters resulted in a crash. We still have the same bug in default arguments, which I'll be looking into next. This, plus a tiny patch to fix libstdc++'s common_type, is enough for clang to parse (and, in very limited testing, support) all of libstdc++4.7's standard headers. llvm-svn: 154886
2012-04-17 08:58:00 +08:00
void (*f1)() = &f<float>;
[patch][pr19848] Produce explicit comdats in clang. The llvm IR until recently had no support for comdats. This was a problem when targeting C++ on ELF/COFF as just using weak linkage would cause quite a bit of dead bits to remain on the executable (unless -ffunction-sections, -fdata-sections and --gc-sections were used). To fix the problem, llvm's codegen will just assume that any weak or linkonce that is not in an explicit comdat should be output in one with the same name as the global. This unfortunately breaks cases like pr19848 where a weak symbol is not xpected to be part of any comdat. Now that we have explicit comdats in the IR, we can finally get both cases right. This first patch just makes clang give explicit comdats to GlobalValues where t is allowed to. A followup patch to llvm will then stop implicitly producing comdats. llvm-svn: 225705
2015-01-13 06:13:53 +08:00
// CHECK: define {{.*}} @_Z1fIdEvv() [[NONE]] comdat {
Implement DR1330 in C++11 mode, to support libstdc++4.7 which uses it. We have a new flavor of exception specification, EST_Uninstantiated. A function type with this exception specification carries a pointer to a FunctionDecl, and the exception specification for that FunctionDecl is instantiated (if needed) and used in the place of the function type's exception specification. When a function template declaration with a non-trivial exception specification is instantiated, the specialization's exception specification is set to this new 'uninstantiated' kind rather than being instantiated immediately. Expr::CanThrow has migrated onto Sema, so it can instantiate exception specs on-demand. Also, any odr-use of a function triggers the instantiation of its exception specification (the exception specification could be needed by IRGen). In passing, fix two places where a DeclRefExpr was created but the corresponding function was not actually marked odr-used. We used to get away with this, but don't any more. Also fix a bug where instantiating an exception specification which refers to function parameters resulted in a crash. We still have the same bug in default arguments, which I'll be looking into next. This, plus a tiny patch to fix libstdc++'s common_type, is enough for clang to parse (and, in very limited testing, support) all of libstdc++4.7's standard headers. llvm-svn: 154886
2012-04-17 08:58:00 +08:00
void (*f2)() = &f<double>;
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK: define {{.*}} @_ZN1SIfE1fEv() [[NUW]]
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
void (*f3)() = &S<float>::f;
// CHECK: define {{.*}} @_ZN1SIdE1fEv()
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK-NOT: [[NUW]]
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
void (*f4)() = &S<double>::f;
Update clang to take into account the changes to personality fns llvm-svn: 239941
2015-06-18 04:53:19 +08:00
// CHECK: define {{.*}} @_Z1fIA4_cEvv() [[NUW]] comdat personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
Implement DR1330 in C++11 mode, to support libstdc++4.7 which uses it. We have a new flavor of exception specification, EST_Uninstantiated. A function type with this exception specification carries a pointer to a FunctionDecl, and the exception specification for that FunctionDecl is instantiated (if needed) and used in the place of the function type's exception specification. When a function template declaration with a non-trivial exception specification is instantiated, the specialization's exception specification is set to this new 'uninstantiated' kind rather than being instantiated immediately. Expr::CanThrow has migrated onto Sema, so it can instantiate exception specs on-demand. Also, any odr-use of a function triggers the instantiation of its exception specification (the exception specification could be needed by IRGen). In passing, fix two places where a DeclRefExpr was created but the corresponding function was not actually marked odr-used. We used to get away with this, but don't any more. Also fix a bug where instantiating an exception specification which refers to function parameters resulted in a crash. We still have the same bug in default arguments, which I'll be looking into next. This, plus a tiny patch to fix libstdc++'s common_type, is enough for clang to parse (and, in very limited testing, support) all of libstdc++4.7's standard headers. llvm-svn: 154886
2012-04-17 08:58:00 +08:00
(void)&f<char[4]>;
[patch][pr19848] Produce explicit comdats in clang. The llvm IR until recently had no support for comdats. This was a problem when targeting C++ on ELF/COFF as just using weak linkage would cause quite a bit of dead bits to remain on the executable (unless -ffunction-sections, -fdata-sections and --gc-sections were used). To fix the problem, llvm's codegen will just assume that any weak or linkonce that is not in an explicit comdat should be output in one with the same name as the global. This unfortunately breaks cases like pr19848 where a weak symbol is not xpected to be part of any comdat. Now that we have explicit comdats in the IR, we can finally get both cases right. This first patch just makes clang give explicit comdats to GlobalValues where t is allowed to. A followup patch to llvm will then stop implicitly producing comdats. llvm-svn: 225705
2015-01-13 06:13:53 +08:00
// CHECK: define {{.*}} @_Z1fIcEvv() [[NONE]] comdat {
Implement DR1330 in C++11 mode, to support libstdc++4.7 which uses it. We have a new flavor of exception specification, EST_Uninstantiated. A function type with this exception specification carries a pointer to a FunctionDecl, and the exception specification for that FunctionDecl is instantiated (if needed) and used in the place of the function type's exception specification. When a function template declaration with a non-trivial exception specification is instantiated, the specialization's exception specification is set to this new 'uninstantiated' kind rather than being instantiated immediately. Expr::CanThrow has migrated onto Sema, so it can instantiate exception specs on-demand. Also, any odr-use of a function triggers the instantiation of its exception specification (the exception specification could be needed by IRGen). In passing, fix two places where a DeclRefExpr was created but the corresponding function was not actually marked odr-used. We used to get away with this, but don't any more. Also fix a bug where instantiating an exception specification which refers to function parameters resulted in a crash. We still have the same bug in default arguments, which I'll be looking into next. This, plus a tiny patch to fix libstdc++'s common_type, is enough for clang to parse (and, in very limited testing, support) all of libstdc++4.7's standard headers. llvm-svn: 154886
2012-04-17 08:58:00 +08:00
(void)&f<char>;
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK: define {{.*}} @_ZN1SIA4_cE1fEv() [[NUW]]
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
(void)&S<char[4]>::f;
// CHECK: define {{.*}} @_ZN1SIcE1fEv()
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK-NOT: [[NUW]]
PR12569: Instantiate exception specifications of explicit instantiations and explicit specializations of function templates appropriately. llvm-svn: 154956
2012-04-18 06:30:01 +08:00
(void)&S<char>::f;
Implement DR1330 in C++11 mode, to support libstdc++4.7 which uses it. We have a new flavor of exception specification, EST_Uninstantiated. A function type with this exception specification carries a pointer to a FunctionDecl, and the exception specification for that FunctionDecl is instantiated (if needed) and used in the place of the function type's exception specification. When a function template declaration with a non-trivial exception specification is instantiated, the specialization's exception specification is set to this new 'uninstantiated' kind rather than being instantiated immediately. Expr::CanThrow has migrated onto Sema, so it can instantiate exception specs on-demand. Also, any odr-use of a function triggers the instantiation of its exception specification (the exception specification could be needed by IRGen). In passing, fix two places where a DeclRefExpr was created but the corresponding function was not actually marked odr-used. We used to get away with this, but don't any more. Also fix a bug where instantiating an exception specification which refers to function parameters resulted in a crash. We still have the same bug in default arguments, which I'll be looking into next. This, plus a tiny patch to fix libstdc++'s common_type, is enough for clang to parse (and, in very limited testing, support) all of libstdc++4.7's standard headers. llvm-svn: 154886
2012-04-17 08:58:00 +08:00
}
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
// CHECK: define {{.*}} @_Z1iv
void i() {
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK: declare {{.*}} @_Z1gIiEvv() [[NUW]]
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
g<int>();
// CHECK: declare {{.*}} @_Z1gIA2_iEvv()
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK-NOT: [[NUW]]
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
g<int[2]>();
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK: declare {{.*}} @_ZN1SIiE1gEv() [[NUW]]
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
S<int>::g();
// CHECK: declare {{.*}} @_ZN1SIA2_iE1gEv()
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK-NOT: [[NUW]]
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
S<int[2]>::g();
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK: declare {{.*}} @_Z1gIfEvv() [[NUW]]
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
void (*g1)() = &g<float>;
// CHECK: declare {{.*}} @_Z1gIdEvv()
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK-NOT: [[NUW]]
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
void (*g2)() = &g<double>;
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK: declare {{.*}} @_ZN1SIfE1gEv() [[NUW]]
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
void (*g3)() = &S<float>::g;
// CHECK: declare {{.*}} @_ZN1SIdE1gEv()
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK-NOT: [[NUW]]
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
void (*g4)() = &S<double>::g;
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK: declare {{.*}} @_Z1gIA4_cEvv() [[NUW]]
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
(void)&g<char[4]>;
// CHECK: declare {{.*}} @_Z1gIcEvv()
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK-NOT: [[NUW]]
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
(void)&g<char>;
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK: declare {{.*}} @_ZN1SIA4_cE1gEv() [[NUW]]
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
(void)&S<char[4]>::g;
// CHECK: declare {{.*}} @_ZN1SIcE1gEv()
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK-NOT: [[NUW]]
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
(void)&S<char>::g;
}
template<typename T> struct Nested {
template<bool b, typename U> void f() noexcept(sizeof(T) == sizeof(U));
};
// CHECK: define {{.*}} @_Z1jv
void j() {
// CHECK: declare {{.*}} @_ZN6NestedIiE1fILb1EcEEvv(
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK-NOT: [[NUW]]
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
Nested<int>().f<true, char>();
Reapply r176133 with testcase fixes. llvm-svn: 176145
2013-02-27 08:06:04 +08:00
// CHECK: declare {{.*}} @_ZN6NestedIlE1fILb0ElEEvv({{.*}}) [[NUW]]
PR 12586: Fix assert while running libc++ testsuite: deal with exception specifications on member function templates of class templates and other such nested beasties. Store the function template from which we are to instantiate an exception specification rather than trying to deduce it. Plus some additional test cases. llvm-svn: 155076
2012-04-19 08:08:28 +08:00
Nested<long>().f<false, long>();
}
Modify the tests to use attribute group references instead of listing the function attributes. llvm-svn: 175606
2013-02-20 15:22:19 +08:00
Add more of the command line options as attribute flags. These can be easily queried by the back-end. llvm-svn: 176304
2013-03-01 06:49:57 +08:00
// CHECK: attributes [[NONE]] = { {{.*}} }
// CHECK: attributes [[NUW]] = { nounwind{{.*}} }
Call ResolveExceptionSpec for non-OdrUsed functions. In C++11, instantiation of exception specs is deferred. The instantiation is done in MarkFunctionReferenced(), which wasn't called for non-OdrUsed functions, which then caused an assert in codegen. Fixes PR19190, see the bug for details. llvm-svn: 216562
2014-08-28 01:04:39 +08:00
namespace PR19190 {
template <class T> struct DWFIterator { virtual void get() throw(int) = 0; };
void foo(DWFIterator<int> *foo) { foo->get(); }
}