blob: 2cee581b49c1c57dc4721afac237437d0c7eb5d7 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
namespace test1 {
int x; // expected-note {{previous definition is here}}
static int y;
void f() {} // expected-note {{previous definition is here}}
extern "C" {
extern int x; // expected-error {{declaration of 'x' has a different language linkage}}
extern int y; // OK, has internal linkage, so no language linkage.
void f(); // expected-error {{declaration of 'f' has a different language linkage}}
}
}
// This is OK. Both test2_f don't have language linkage since they have
// internal linkage.
extern "C" {
static void test2_f() {
}
static void test2_f(int x) {
}
}
namespace test3 {
extern "C" {
namespace {
extern int x2;
void f2();
}
}
namespace {
int x2;
void f2() {}
}
}
namespace test4 {
void dummy() {
void Bar();
class A {
friend void Bar();
};
}
}
namespace test5 {
static void g();
void f()
{
void g();
}
}
// pr14898
namespace test6 {
template <class _Rp>
class __attribute__ ((__visibility__("default"))) shared_future;
template <class _Rp>
class future {
template <class> friend class shared_future;
shared_future<_Rp> share();
};
template <class _Rp> future<_Rp>
get_future();
template <class _Rp>
struct shared_future<_Rp&> {
shared_future(future<_Rp&>&& __f); // expected-warning {{rvalue references are a C++11 extension}}
};
void f() {
typedef int T;
get_future<int>();
typedef int& U;
shared_future<int&> f1 = get_future<int&>();
}
}
// This is OK. The variables have internal linkage and therefore no language
// linkage.
extern "C" {
static int test7_x;
}
extern "C++" {
extern int test7_x;
}
extern "C++" {
static int test7_y;
}
extern "C" {
extern int test7_y;
}
extern "C" { typedef int test7_F(); static test7_F test7_f; }
extern "C++" { extern test7_F test7_f; }
// FIXME: This should be invalid. The function has no language linkage, but
// the function type has, so this is redeclaring the function with a different
// type.
extern "C++" {
static void test8_f();
}
extern "C" {
extern void test8_f();
}
extern "C" {
static void test8_g();
}
extern "C++" {
extern void test8_g();
}
extern "C" {
void __attribute__((overloadable)) test9_f(int c); // expected-note {{previous declaration is here}}
}
extern "C++" {
void __attribute__((overloadable)) test9_f(int c); // expected-error {{declaration of 'test9_f' has a different language linkage}}
}
extern "C" {
void __attribute__((overloadable)) test10_f(int);
void __attribute__((overloadable)) test10_f(double);
}
extern "C" {
void test11_f() {
void __attribute__((overloadable)) test11_g(int);
void __attribute__((overloadable)) test11_g(double);
}
}
|
