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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
| // RUN: %clang_cc1 %s -Wno-private-extern -triple i386-pc-linux-gnu -verify -fsyntax-only
void f() {
int i;
asm ("foo\n" : : "a" (i + 2));
asm ("foo\n" : : "a" (f())); // expected-error {{invalid type 'void' in asm input}}
asm ("foo\n" : "=a" (f())); // expected-error {{invalid lvalue in asm output}}
asm ("foo\n" : "=a" (i + 2)); // expected-error {{invalid lvalue in asm output}}
asm ("foo\n" : [symbolic_name] "=a" (i) : "[symbolic_name]" (i));
asm ("foo\n" : "=a" (i) : "[" (i)); // expected-error {{invalid input constraint '[' in asm}}
asm ("foo\n" : "=a" (i) : "[foo" (i)); // expected-error {{invalid input constraint '[foo' in asm}}
asm ("foo\n" : "=a" (i) : "[symbolic_name]" (i)); // expected-error {{invalid input constraint '[symbolic_name]' in asm}}
asm ("foo\n" : : "" (i)); // expected-error {{invalid input constraint '' in asm}}
asm ("foo\n" : "=a" (i) : "" (i)); // expected-error {{invalid input constraint '' in asm}}
}
void clobbers() {
asm ("nop" : : : "ax", "#ax", "%ax");
asm ("nop" : : : "eax", "rax", "ah", "al");
asm ("nop" : : : "0", "%0", "#0");
asm ("nop" : : : "foo"); // expected-error {{unknown register name 'foo' in asm}}
asm ("nop" : : : "52");
asm ("nop" : : : "204"); // expected-error {{unknown register name '204' in asm}}
asm ("nop" : : : "-1"); // expected-error {{unknown register name '-1' in asm}}
asm ("nop" : : : "+1"); // expected-error {{unknown register name '+1' in asm}}
register void *clobber_conflict asm ("%rcx");
register void *no_clobber_conflict asm ("%rax");
int a,b,c;
asm ("nop" : "=r" (no_clobber_conflict) : "r" (clobber_conflict) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
asm ("nop" : "=r" (clobber_conflict) : "r" (no_clobber_conflict) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
asm ("nop" : "=r" (clobber_conflict) : "r" (clobber_conflict) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
asm ("nop" : "=c" (a) : "r" (no_clobber_conflict) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
asm ("nop" : "=r" (no_clobber_conflict) : "c" (c) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
asm ("nop" : "=r" (clobber_conflict) : "c" (c) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
asm ("nop" : "=a" (a) : "b" (b) : "%rcx", "%rbx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
}
// rdar://6094010
void test3() {
int x;
asm(L"foo" : "=r"(x)); // expected-error {{wide string}}
asm("foo" : L"=r"(x)); // expected-error {{wide string}}
}
// <rdar://problem/6156893>
void test4(const volatile void *addr)
{
asm ("nop" : : "r"(*addr)); // expected-error {{invalid type 'const volatile void' in asm input for constraint 'r'}}
asm ("nop" : : "m"(*addr));
asm ("nop" : : "r"(test4(addr))); // expected-error {{invalid type 'void' in asm input for constraint 'r'}}
asm ("nop" : : "m"(test4(addr))); // expected-error {{invalid lvalue in asm input for constraint 'm'}}
asm ("nop" : : "m"(f())); // expected-error {{invalid lvalue in asm input for constraint 'm'}}
}
// <rdar://problem/6512595>
void test5() {
asm("nop" : : "X" (8));
}
// PR3385
void test6(long i) {
asm("nop" : : "er"(i));
}
void asm_string_tests(int i) {
asm("%!"); // simple asm string, %! is not an error.
asm("%!" : ); // expected-error {{invalid % escape in inline assembly string}}
asm("xyz %" : ); // expected-error {{invalid % escape in inline assembly string}}
asm ("%[somename]" :: [somename] "i"(4)); // ok
asm ("%[somename]" :: "i"(4)); // expected-error {{unknown symbolic operand name in inline assembly string}}
asm ("%[somename" :: "i"(4)); // expected-error {{unterminated symbolic operand name in inline assembly string}}
asm ("%[]" :: "i"(4)); // expected-error {{empty symbolic operand name in inline assembly string}}
// PR3258
asm("%9" :: "i"(4)); // expected-error {{invalid operand number in inline asm string}}
asm("%1" : "+r"(i)); // ok, referring to input.
}
// PR4077
int test7(unsigned long long b) {
int a;
asm volatile("foo %0 %1" : "=a" (a) :"0" (b)); // expected-error {{input with type 'unsigned long long' matching output with type 'int'}}
return a;
}
// <rdar://problem/7574870>
asm volatile (""); // expected-warning {{meaningless 'volatile' on asm outside function}}
// PR3904
void test8(int i) {
// A number in an input constraint can't point to a read-write constraint.
asm("" : "+r" (i), "=r"(i) : "0" (i)); // expected-error{{invalid input constraint '0' in asm}}
}
// PR3905
void test9(int i) {
asm("" : [foo] "=r" (i), "=r"(i) : "1[foo]"(i)); // expected-error{{invalid input constraint '1[foo]' in asm}}
asm("" : [foo] "=r" (i), "=r"(i) : "[foo]1"(i)); // expected-error{{invalid input constraint '[foo]1' in asm}}
}
void test10(void){
static int g asm ("g_asm") = 0;
extern int gg asm ("gg_asm");
__private_extern__ int ggg asm ("ggg_asm");
int a asm ("a_asm"); // expected-warning{{ignored asm label 'a_asm' on automatic variable}}
auto int aa asm ("aa_asm"); // expected-warning{{ignored asm label 'aa_asm' on automatic variable}}
register int r asm ("cx");
register int rr asm ("rr_asm"); // expected-error{{unknown register name 'rr_asm' in asm}}
register int rrr asm ("%"); // expected-error{{unknown register name '%' in asm}}
}
// This is just an assert because of the boolean conversion.
// Feel free to change the assembly to something sensible if it causes a problem.
// rdar://problem/9414925
void test11(void) {
_Bool b;
asm volatile ("movb %%gs:%P2,%b0" : "=q"(b) : "0"(0), "i"(5L));
}
void test12(void) {
register int cc __asm ("cc"); // expected-error{{unknown register name 'cc' in asm}}
}
// PR10223
void test13(void) {
void *esp;
__asm__ volatile ("mov %%esp, %o" : "=r"(esp) : : ); // expected-error {{invalid % escape in inline assembly string}}
}
// <rdar://problem/12700799>
struct S; // expected-note 2 {{forward declaration of 'struct S'}}
void test14(struct S *s) {
__asm("": : "a"(*s)); // expected-error {{dereference of pointer to incomplete type 'struct S'}}
__asm("": "=a" (*s) :); // expected-error {{dereference of pointer to incomplete type 'struct S'}}
}
// PR15759.
double test15() {
double ret = 0;
__asm("0.0":"="(ret)); // expected-error {{invalid output constraint '=' in asm}}
__asm("0.0":"=&"(ret)); // expected-error {{invalid output constraint '=&' in asm}}
__asm("0.0":"+?"(ret)); // expected-error {{invalid output constraint '+?' in asm}}
__asm("0.0":"+!"(ret)); // expected-error {{invalid output constraint '+!' in asm}}
__asm("0.0":"+#"(ret)); // expected-error {{invalid output constraint '+#' in asm}}
__asm("0.0":"+*"(ret)); // expected-error {{invalid output constraint '+*' in asm}}
__asm("0.0":"=%"(ret)); // expected-error {{invalid output constraint '=%' in asm}}
__asm("0.0":"=,="(ret)); // expected-error {{invalid output constraint '=,=' in asm}}
__asm("0.0":"=,g"(ret)); // no-error
__asm("0.0":"=g"(ret)); // no-error
return ret;
}
void iOutputConstraint(int x){
__asm ("nop" : "=ir" (x) : :); // no-error
__asm ("nop" : "=ri" (x) : :); // no-error
__asm ("nop" : "=ig" (x) : :); // no-error
__asm ("nop" : "=im" (x) : :); // no-error
__asm ("nop" : "=imr" (x) : :); // no-error
__asm ("nop" : "=i" (x) : :); // expected-error{{invalid output constraint '=i' in asm}}
__asm ("nop" : "+i" (x) : :); // expected-error{{invalid output constraint '+i' in asm}}
__asm ("nop" : "=ii" (x) : :); // expected-error{{invalid output constraint '=ii' in asm}}
__asm ("nop" : "=nr" (x) : :); // no-error
__asm ("nop" : "=rn" (x) : :); // no-error
__asm ("nop" : "=ng" (x) : :); // no-error
__asm ("nop" : "=nm" (x) : :); // no-error
__asm ("nop" : "=nmr" (x) : :); // no-error
__asm ("nop" : "=n" (x) : :); // expected-error{{invalid output constraint '=n' in asm}}
__asm ("nop" : "+n" (x) : :); // expected-error{{invalid output constraint '+n' in asm}}
__asm ("nop" : "=nn" (x) : :); // expected-error{{invalid output constraint '=nn' in asm}}
__asm ("nop" : "=Fr" (x) : :); // no-error
__asm ("nop" : "=rF" (x) : :); // no-error
__asm ("nop" : "=Fg" (x) : :); // no-error
__asm ("nop" : "=Fm" (x) : :); // no-error
__asm ("nop" : "=Fmr" (x) : :); // no-error
__asm ("nop" : "=F" (x) : :); // expected-error{{invalid output constraint '=F' in asm}}
__asm ("nop" : "+F" (x) : :); // expected-error{{invalid output constraint '+F' in asm}}
__asm ("nop" : "=FF" (x) : :); // expected-error{{invalid output constraint '=FF' in asm}}
__asm ("nop" : "=Er" (x) : :); // no-error
__asm ("nop" : "=rE" (x) : :); // no-error
__asm ("nop" : "=Eg" (x) : :); // no-error
__asm ("nop" : "=Em" (x) : :); // no-error
__asm ("nop" : "=Emr" (x) : :); // no-error
__asm ("nop" : "=E" (x) : :); // expected-error{{invalid output constraint '=E' in asm}}
__asm ("nop" : "+E" (x) : :); // expected-error{{invalid output constraint '+E' in asm}}
__asm ("nop" : "=EE" (x) : :); // expected-error{{invalid output constraint '=EE' in asm}}
}
// PR19837
struct foo {
int a;
};
register struct foo bar asm("esp"); // expected-error {{bad type for named register variable}}
register float baz asm("esp"); // expected-error {{bad type for named register variable}}
register int r0 asm ("edi"); // expected-error {{register 'edi' unsuitable for global register variables on this target}}
register long long r1 asm ("esp"); // expected-error {{size of register 'esp' does not match variable size}}
register int r2 asm ("esp");
double f_output_constraint(void) {
double result;
__asm("foo1": "=f" (result)); // expected-error {{invalid output constraint '=f' in asm}}
return result;
}
void fn1() {
int l;
__asm__(""
: [l] "=r"(l)
: "[l],m"(l)); // expected-error {{asm constraint has an unexpected number of alternatives: 1 vs 2}}
}
void fn2() {
int l;
__asm__(""
: "+&m"(l)); // expected-error {{invalid output constraint '+&m' in asm}}
}
void fn3() {
int l;
__asm__(""
: "+#r"(l)); // expected-error {{invalid output constraint '+#r' in asm}}
}
void fn4() {
int l;
__asm__(""
: "=r"(l)
: "m#"(l));
}
void fn5() {
int l;
__asm__(""
: [g] "+r"(l)
: "[g]"(l)); // expected-error {{invalid input constraint '[g]' in asm}}
}
void fn6() {
int a;
__asm__(""
: "=rm"(a), "=rm"(a)
: "11m"(a)); // expected-error {{invalid input constraint '11m' in asm}}
}
// PR14269
typedef struct test16_foo {
unsigned int field1 : 1;
unsigned int field2 : 2;
unsigned int field3 : 3;
} test16_foo;
typedef __attribute__((vector_size(16))) int test16_bar;
register int test16_baz asm("esp");
void test16()
{
test16_foo a;
test16_bar b;
__asm__("movl $5, %0"
: "=rm" (a.field2)); // expected-error {{reference to a bit-field in asm input with a memory constraint '=rm'}}
__asm__("movl $5, %0"
:
: "m" (a.field3)); // expected-error {{reference to a bit-field in asm output with a memory constraint 'm'}}
__asm__("movl $5, %0"
: "=rm" (b[2])); // expected-error {{reference to a vector element in asm input with a memory constraint '=rm'}}
__asm__("movl $5, %0"
:
: "m" (b[3])); // expected-error {{reference to a vector element in asm output with a memory constraint 'm'}}
__asm__("movl $5, %0"
: "=rm" (test16_baz)); // expected-error {{reference to a global register variable in asm input with a memory constraint '=rm'}}
__asm__("movl $5, %0"
:
: "m" (test16_baz)); // expected-error {{reference to a global register variable in asm output with a memory constraint 'm'}}
}
int test17(int t0)
{
int r0, r1;
__asm ("addl %2, %2\n\t"
"movl $123, %0"
: "=a" (r0),
"=&r" (r1)
: "1" (t0), // expected-note {{constraint '1' is already present here}}
"1" (t0)); // expected-error {{more than one input constraint matches the same output '1'}}
return r0 + r1;
}
void test18()
{
// expected-error@+2 {{duplicate use of asm operand name "lab"}}
// expected-note@+1 {{asm operand name "lab" first referenced here}}
asm goto ("" : : : : lab, lab, lab2, lab);
// expected-error@+2 {{duplicate use of asm operand name "lab"}}
// expected-note@+1 {{asm operand name "lab" first referenced here}}
asm goto ("xorw %[lab], %[lab]; je %l[lab]" : : [lab] "i" (0) : : lab);
lab:;
lab2:;
int x,x1;
// expected-error@+2 {{duplicate use of asm operand name "lab"}}
// expected-note@+1 {{asm operand name "lab" first referenced here}}
asm ("" : [lab] "=r" (x),[lab] "+r" (x) : [lab1] "r" (x));
// expected-error@+2 {{duplicate use of asm operand name "lab"}}
// expected-note@+1 {{asm operand name "lab" first referenced here}}
asm ("" : [lab] "=r" (x1) : [lab] "r" (x));
// expected-error@+1 {{invalid operand number in inline asm string}}
asm ("jne %l0":::);
asm goto ("jne %l0"::::lab);
}
|