mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2025-02-11 04:06:20 +00:00
f623c96260
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
118 lines
2.7 KiB
C++
118 lines
2.7 KiB
C++
// RUN: %clang_cc1 -fsyntax-only -verify %s
|
|
namespace N {
|
|
struct Outer {
|
|
struct Inner {
|
|
template<typename T>
|
|
struct InnerTemplate {
|
|
struct VeryInner {
|
|
typedef T type;
|
|
|
|
static enum K1 { K1Val = sizeof(T) } Kind1;
|
|
static enum { K2Val = sizeof(T)*2 } Kind2;
|
|
enum { K3Val = sizeof(T)*2 } Kind3;
|
|
|
|
void foo() {
|
|
K1 k1 = K1Val;
|
|
Kind1 = K1Val;
|
|
Outer::Inner::InnerTemplate<type>::VeryInner::Kind2 = K2Val;
|
|
Kind3 = K3Val;
|
|
}
|
|
|
|
struct UeberInner {
|
|
void bar() {
|
|
K1 k1 = K1Val;
|
|
Kind1 = K1Val;
|
|
Outer::Inner::InnerTemplate<type>::VeryInner::Kind2 = K2Val;
|
|
|
|
InnerTemplate t;
|
|
InnerTemplate<type> t2;
|
|
}
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
}
|
|
|
|
typedef int INT;
|
|
template struct N::Outer::Inner::InnerTemplate<INT>::VeryInner;
|
|
template struct N::Outer::Inner::InnerTemplate<INT>::UeberInner; // expected-error{{no struct named 'UeberInner' in 'N::Outer::Inner::InnerTemplate<int>'}}
|
|
|
|
namespace N2 {
|
|
struct Outer2 {
|
|
template<typename T, typename U = T>
|
|
struct Inner {
|
|
void foo() {
|
|
enum { K1Val = sizeof(T) } k1;
|
|
enum K2 { K2Val = sizeof(T)*2 } k2a;
|
|
|
|
K2 k2b = K2Val;
|
|
|
|
struct S { T x, y; } s1;
|
|
struct { U x, y; } s2;
|
|
s1.x = s2.x; // expected-error{{incompatible}}
|
|
|
|
typedef T type;
|
|
type t2 = s1.x;
|
|
|
|
typedef struct { T z; } type2;
|
|
type2 t3 = { s1.x };
|
|
|
|
Inner i1;
|
|
i1.foo();
|
|
Inner<T> i2;
|
|
i2.foo();
|
|
}
|
|
};
|
|
};
|
|
}
|
|
|
|
template struct N2::Outer2::Inner<float>;
|
|
template struct N2::Outer2::Inner<int*, float*>; // expected-note{{instantiation}}
|
|
|
|
// Test dependent pointer-to-member expressions.
|
|
template<typename T>
|
|
struct smart_ptr {
|
|
struct safe_bool {
|
|
int member;
|
|
};
|
|
|
|
operator int safe_bool::*() const {
|
|
return ptr? &safe_bool::member : 0;
|
|
}
|
|
|
|
T* ptr;
|
|
};
|
|
|
|
void test_smart_ptr(smart_ptr<int> p) {
|
|
if (p) { }
|
|
}
|
|
|
|
// PR5517
|
|
namespace test0 {
|
|
template <int K> struct X {
|
|
X() { extern void x(); }
|
|
};
|
|
void g() { X<2>(); }
|
|
}
|
|
|
|
// <rdar://problem/8302161>
|
|
namespace test1 {
|
|
template <typename T> void f(T const &t) {
|
|
union { char c; T t_; };
|
|
c = 'a'; // <- this shouldn't silently fail to instantiate
|
|
T::foo(); // expected-error {{has no members}}
|
|
}
|
|
template void f(int const &); // expected-note {{requested here}}
|
|
}
|
|
|
|
namespace test2 {
|
|
template<typename T> void f() {
|
|
T::error; // expected-error {{no member}}
|
|
}
|
|
void g() {
|
|
// This counts as an odr-use, so should trigger the instantiation of f<int>.
|
|
(void)&f<int>; // expected-note {{here}}
|
|
}
|
|
}
|