1 // RUN: %clang_cc1 -fsyntax-only -verify %s -triple x86_64-pc-linux-gnu
2 template<int I, int J>
3 struct Bitfields {
4 int simple : I; // expected-error{{bit-field 'simple' has zero width}}
5 int parens : (J);
6 };
7
test_Bitfields(Bitfields<0,5> * b)8 void test_Bitfields(Bitfields<0, 5> *b) {
9 (void)sizeof(Bitfields<10, 5>);
10 (void)sizeof(Bitfields<0, 1>); // expected-note{{in instantiation of template class 'Bitfields<0, 1>' requested here}}
11 }
12
13 template<int I, int J>
14 struct BitfieldPlus {
15 int bitfield : I + J; // expected-error{{bit-field 'bitfield' has zero width}}
16 };
17
test_BitfieldPlus()18 void test_BitfieldPlus() {
19 (void)sizeof(BitfieldPlus<0, 1>);
20 (void)sizeof(BitfieldPlus<-5, 5>); // expected-note{{in instantiation of template class 'BitfieldPlus<-5, 5>' requested here}}
21 }
22
23 template<int I, int J>
24 struct BitfieldMinus {
25 int bitfield : I - J; // expected-error{{bit-field 'bitfield' has negative width (-1)}} \
26 // expected-error{{bit-field 'bitfield' has zero width}}
27 };
28
test_BitfieldMinus()29 void test_BitfieldMinus() {
30 (void)sizeof(BitfieldMinus<5, 1>);
31 (void)sizeof(BitfieldMinus<0, 1>); // expected-note{{in instantiation of template class 'BitfieldMinus<0, 1>' requested here}}
32 (void)sizeof(BitfieldMinus<5, 5>); // expected-note{{in instantiation of template class 'BitfieldMinus<5, 5>' requested here}}
33 }
34
35 template<int I, int J>
36 struct BitfieldDivide {
37 int bitfield : I / J; // expected-error{{expression is not an integral constant expression}} \
38 // expected-note{{division by zero}}
39 };
40
test_BitfieldDivide()41 void test_BitfieldDivide() {
42 (void)sizeof(BitfieldDivide<5, 1>);
43 (void)sizeof(BitfieldDivide<5, 0>); // expected-note{{in instantiation of template class 'BitfieldDivide<5, 0>' requested here}}
44 }
45
46 template<typename T, T I, int J>
47 struct BitfieldDep {
48 int bitfield : I + J;
49 };
50
test_BitfieldDep()51 void test_BitfieldDep() {
52 (void)sizeof(BitfieldDep<int, 1, 5>);
53 }
54
55 template<int I>
56 struct BitfieldNeg {
57 int bitfield : (-I); // expected-error{{bit-field 'bitfield' has negative width (-5)}}
58 };
59
60 template<typename T, T I>
61 struct BitfieldNeg2 {
62 int bitfield : (-I); // expected-error{{bit-field 'bitfield' has negative width (-5)}}
63 };
64
test_BitfieldNeg()65 void test_BitfieldNeg() {
66 (void)sizeof(BitfieldNeg<-5>); // okay
67 (void)sizeof(BitfieldNeg<5>); // expected-note{{in instantiation of template class 'BitfieldNeg<5>' requested here}}
68 (void)sizeof(BitfieldNeg2<int, -5>); // okay
69 (void)sizeof(BitfieldNeg2<int, 5>); // expected-note{{in instantiation of template class 'BitfieldNeg2<int, 5>' requested here}}
70 }
71
72 template<typename T>
increment(T & x)73 void increment(T &x) {
74 (void)++x;
75 }
76
77 struct Incrementable {
78 Incrementable &operator++();
79 };
80
test_increment(Incrementable inc)81 void test_increment(Incrementable inc) {
82 increment(inc);
83 }
84
85 template<typename T>
add(const T & x)86 void add(const T &x) {
87 (void)(x + x);
88 }
89
90 namespace PR6237 {
91 template <typename T>
f(T t)92 void f(T t) {
93 t++;
94 }
95
96 struct B { };
97 B operator++(B &, int);
98
99 template void f(B);
100 }
101
102 struct Addable {
103 Addable operator+(const Addable&) const;
104 };
105
test_add(Addable & a)106 void test_add(Addable &a) {
107 add(a);
108 }
109
110 struct CallOperator {
111 int &operator()(int);
112 double &operator()(double);
113 };
114
115 template<typename Result, typename F, typename Arg1>
test_call_operator(F f,Arg1 arg1)116 Result test_call_operator(F f, Arg1 arg1) {
117 // PR5266: non-dependent invocations of a function call operator.
118 CallOperator call_op;
119 int &ir = call_op(17);
120 return f(arg1);
121 }
122
test_call_operator(CallOperator call_op,int i,double d)123 void test_call_operator(CallOperator call_op, int i, double d) {
124 int &ir = test_call_operator<int&>(call_op, i);
125 double &dr = test_call_operator<double&>(call_op, d);
126 }
127
128 template<typename T>
test_asm(T t)129 void test_asm(T t) {
130 asm ("nop" : "=r"(*t) : "r"(*t)); // expected-error {{indirection requires pointer operand ('int' invalid)}}
131 }
132
test_asm()133 void test_asm() {
134 int* a;
135 test_asm(a);
136
137 int b;
138 test_asm(b); // expected-note {{in instantiation of function template specialization 'test_asm<int>' requested here}}
139 }
140
141 namespace PR6424 {
142 template<int I> struct X {
XPR6424::X143 X() {
144 int *ip = I; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
145 }
146 };
147
148 template<int> struct Y {
149 typedef X<7> X7;
150
fPR6424::Y151 void f() { X7(); } // expected-note{{instantiation}}
152 };
153
154 template void Y<3>::f();
155
156 template<int I>
157 struct X2 {
operator newPR6424::X2158 void *operator new(__SIZE_TYPE__) {
159 int *ip = I; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
160 return ip;
161 }
162 };
163
164 template<int> struct Y2 {
165 typedef X2<7> X;
fPR6424::Y2166 void f() {
167 new X(); // expected-note{{instantiation of}}
168 }
169 };
170
171 template void Y2<3>::f();
172
173 template<typename T>
rdar10283928(int count)174 void rdar10283928(int count) {
175 (void)new char[count]();
176 }
177
178 template void rdar10283928<int>(int);
179 }
180
181 namespace PR10864 {
182 template<typename T> class Vals {};
183 template<> class Vals<int> { public: static const int i = 1; };
184 template<> class Vals<float> { public: static const double i; };
test_asm_tied(T o)185 template<typename T> void test_asm_tied(T o) {
186 __asm("addl $1, %0" : "=r" (o) : "0"(Vals<T>::i)); // expected-error {{input with type 'double' matching output with type 'float'}}
187 }
test_asm_tied()188 void test_asm_tied() {
189 test_asm_tied(1);
190 test_asm_tied(1.f); // expected-note {{instantiation of}}
191 }
192 }
193