1 // RUN: %clang_cc1 %s -Wno-private-extern -triple i386-pc-linux-gnu -verify -fsyntax-only
2 
3 
f()4 void f() {
5   int i;
6 
7   asm ("foo\n" : : "a" (i + 2));
8   asm ("foo\n" : : "a" (f())); // expected-error {{invalid type 'void' in asm input}}
9 
10   asm ("foo\n" : "=a" (f())); // expected-error {{invalid lvalue in asm output}}
11   asm ("foo\n" : "=a" (i + 2)); // expected-error {{invalid lvalue in asm output}}
12 
13   asm ("foo\n" : [symbolic_name] "=a" (i) : "[symbolic_name]" (i));
14   asm ("foo\n" : "=a" (i) : "[" (i)); // expected-error {{invalid input constraint '[' in asm}}
15   asm ("foo\n" : "=a" (i) : "[foo" (i)); // expected-error {{invalid input constraint '[foo' in asm}}
16   asm ("foo\n" : "=a" (i) : "[symbolic_name]" (i)); // expected-error {{invalid input constraint '[symbolic_name]' in asm}}
17 
18   asm ("foo\n" : : "" (i)); // expected-error {{invalid input constraint '' in asm}}
19   asm ("foo\n" : "=a" (i) : "" (i)); // expected-error {{invalid input constraint '' in asm}}
20 }
21 
clobbers()22 void clobbers() {
23   asm ("nop" : : : "ax", "#ax", "%ax");
24   asm ("nop" : : : "eax", "rax", "ah", "al");
25   asm ("nop" : : : "0", "%0", "#0");
26   asm ("nop" : : : "foo"); // expected-error {{unknown register name 'foo' in asm}}
27   asm ("nop" : : : "52");
28   asm ("nop" : : : "204"); // expected-error {{unknown register name '204' in asm}}
29   asm ("nop" : : : "-1"); // expected-error {{unknown register name '-1' in asm}}
30   asm ("nop" : : : "+1"); // expected-error {{unknown register name '+1' in asm}}
31   register void *clobber_conflict asm ("%rcx");
32   register void *no_clobber_conflict asm ("%rax");
33   int a,b,c;
34   asm ("nop" : "=r" (no_clobber_conflict) : "r" (clobber_conflict) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
35   asm ("nop" : "=r" (clobber_conflict) : "r" (no_clobber_conflict) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
36   asm ("nop" : "=r" (clobber_conflict) : "r" (clobber_conflict) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
37   asm ("nop" : "=c" (a) : "r" (no_clobber_conflict) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
38   asm ("nop" : "=r" (no_clobber_conflict) : "c" (c) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
39   asm ("nop" : "=r" (clobber_conflict) : "c" (c) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
40   asm ("nop" : "=a" (a) : "b" (b) : "%rcx", "%rbx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
41 }
42 
43 // rdar://6094010
test3()44 void test3() {
45   int x;
46   asm(L"foo" : "=r"(x)); // expected-error {{wide string}}
47   asm("foo" : L"=r"(x)); // expected-error {{wide string}}
48 }
49 
50 // <rdar://problem/6156893>
test4(const volatile void * addr)51 void test4(const volatile void *addr)
52 {
53     asm ("nop" : : "r"(*addr)); // expected-error {{invalid type 'const volatile void' in asm input for constraint 'r'}}
54     asm ("nop" : : "m"(*addr));
55 
56     asm ("nop" : : "r"(test4(addr))); // expected-error {{invalid type 'void' in asm input for constraint 'r'}}
57     asm ("nop" : : "m"(test4(addr))); // expected-error {{invalid lvalue in asm input for constraint 'm'}}
58 
59     asm ("nop" : : "m"(f())); // expected-error {{invalid lvalue in asm input for constraint 'm'}}
60 }
61 
62 // <rdar://problem/6512595>
test5()63 void test5() {
64   asm("nop" : : "X" (8));
65 }
66 
67 // PR3385
test6(long i)68 void test6(long i) {
69   asm("nop" : : "er"(i));
70 }
71 
asm_string_tests(int i)72 void asm_string_tests(int i) {
73   asm("%!");   // simple asm string, %! is not an error.
74   asm("%!" : );   // expected-error {{invalid % escape in inline assembly string}}
75   asm("xyz %" : );   // expected-error {{invalid % escape in inline assembly string}}
76 
77   asm ("%[somename]" :: [somename] "i"(4)); // ok
78   asm ("%[somename]" :: "i"(4)); // expected-error {{unknown symbolic operand name in inline assembly string}}
79   asm ("%[somename" :: "i"(4)); // expected-error {{unterminated symbolic operand name in inline assembly string}}
80   asm ("%[]" :: "i"(4)); // expected-error {{empty symbolic operand name in inline assembly string}}
81 
82   // PR3258
83   asm("%9" :: "i"(4)); // expected-error {{invalid operand number in inline asm string}}
84   asm("%1" : "+r"(i)); // ok, referring to input.
85 }
86 
87 // PR4077
test7(unsigned long long b)88 int test7(unsigned long long b) {
89   int a;
90   asm volatile("foo %0 %1" : "=a" (a) :"0" (b)); // expected-error {{input with type 'unsigned long long' matching output with type 'int'}}
91   return a;
92 }
93 
94 // <rdar://problem/7574870>
95 asm volatile (""); // expected-warning {{meaningless 'volatile' on asm outside function}}
96 
97 // PR3904
test8(int i)98 void test8(int i) {
99   // A number in an input constraint can't point to a read-write constraint.
100   asm("" : "+r" (i), "=r"(i) :  "0" (i)); // expected-error{{invalid input constraint '0' in asm}}
101 }
102 
103 // PR3905
test9(int i)104 void test9(int i) {
105   asm("" : [foo] "=r" (i), "=r"(i) : "1[foo]"(i)); // expected-error{{invalid input constraint '1[foo]' in asm}}
106   asm("" : [foo] "=r" (i), "=r"(i) : "[foo]1"(i)); // expected-error{{invalid input constraint '[foo]1' in asm}}
107 }
108 
test10(void)109 void test10(void){
110   static int g asm ("g_asm") = 0;
111   extern int gg asm ("gg_asm");
112   __private_extern__ int ggg asm ("ggg_asm");
113 
114   int a asm ("a_asm"); // expected-warning{{ignored asm label 'a_asm' on automatic variable}}
115   auto int aa asm ("aa_asm"); // expected-warning{{ignored asm label 'aa_asm' on automatic variable}}
116 
117   register int r asm ("cx");
118   register int rr asm ("rr_asm"); // expected-error{{unknown register name 'rr_asm' in asm}}
119   register int rrr asm ("%"); // expected-error{{unknown register name '%' in asm}}
120 }
121 
122 // This is just an assert because of the boolean conversion.
123 // Feel free to change the assembly to something sensible if it causes a problem.
124 // rdar://problem/9414925
test11(void)125 void test11(void) {
126   _Bool b;
127   asm volatile ("movb %%gs:%P2,%b0" : "=q"(b) : "0"(0), "i"(5L));
128 }
129 
test12(void)130 void test12(void) {
131   register int cc __asm ("cc"); // expected-error{{unknown register name 'cc' in asm}}
132 }
133 
134 // PR10223
test13(void)135 void test13(void) {
136   void *esp;
137   __asm__ volatile ("mov %%esp, %o" : "=r"(esp) : : ); // expected-error {{invalid % escape in inline assembly string}}
138 }
139 
140 // <rdar://problem/12700799>
141 struct S;  // expected-note 2 {{forward declaration of 'struct S'}}
test14(struct S * s)142 void test14(struct S *s) {
143   __asm("": : "a"(*s)); // expected-error {{dereference of pointer to incomplete type 'struct S'}}
144   __asm("": "=a" (*s) :); // expected-error {{dereference of pointer to incomplete type 'struct S'}}
145 }
146 
147 // PR15759.
test15()148 double test15() {
149   double ret = 0;
150   __asm("0.0":"="(ret)); // expected-error {{invalid output constraint '=' in asm}}
151   __asm("0.0":"=&"(ret)); // expected-error {{invalid output constraint '=&' in asm}}
152   __asm("0.0":"+?"(ret)); // expected-error {{invalid output constraint '+?' in asm}}
153   __asm("0.0":"+!"(ret)); // expected-error {{invalid output constraint '+!' in asm}}
154   __asm("0.0":"+#"(ret)); // expected-error {{invalid output constraint '+#' in asm}}
155   __asm("0.0":"+*"(ret)); // expected-error {{invalid output constraint '+*' in asm}}
156   __asm("0.0":"=%"(ret)); // expected-error {{invalid output constraint '=%' in asm}}
157   __asm("0.0":"=,="(ret)); // expected-error {{invalid output constraint '=,=' in asm}}
158   __asm("0.0":"=,g"(ret)); // no-error
159   __asm("0.0":"=g"(ret)); // no-error
160   return ret;
161 }
162 
iOutputConstraint(int x)163 void iOutputConstraint(int x){
164   __asm ("nop" : "=ir" (x) : :); // no-error
165   __asm ("nop" : "=ri" (x) : :); // no-error
166   __asm ("nop" : "=ig" (x) : :); // no-error
167   __asm ("nop" : "=im" (x) : :); // no-error
168   __asm ("nop" : "=imr" (x) : :); // no-error
169   __asm ("nop" : "=i" (x) : :); // expected-error{{invalid output constraint '=i' in asm}}
170   __asm ("nop" : "+i" (x) : :); // expected-error{{invalid output constraint '+i' in asm}}
171   __asm ("nop" : "=ii" (x) : :); // expected-error{{invalid output constraint '=ii' in asm}}
172   __asm ("nop" : "=nr" (x) : :); // no-error
173   __asm ("nop" : "=rn" (x) : :); // no-error
174   __asm ("nop" : "=ng" (x) : :); // no-error
175   __asm ("nop" : "=nm" (x) : :); // no-error
176   __asm ("nop" : "=nmr" (x) : :); // no-error
177   __asm ("nop" : "=n" (x) : :); // expected-error{{invalid output constraint '=n' in asm}}
178   __asm ("nop" : "+n" (x) : :); // expected-error{{invalid output constraint '+n' in asm}}
179   __asm ("nop" : "=nn" (x) : :); // expected-error{{invalid output constraint '=nn' in asm}}
180   __asm ("nop" : "=Fr" (x) : :); // no-error
181   __asm ("nop" : "=rF" (x) : :); // no-error
182   __asm ("nop" : "=Fg" (x) : :); // no-error
183   __asm ("nop" : "=Fm" (x) : :); // no-error
184   __asm ("nop" : "=Fmr" (x) : :); // no-error
185   __asm ("nop" : "=F" (x) : :); // expected-error{{invalid output constraint '=F' in asm}}
186   __asm ("nop" : "+F" (x) : :); // expected-error{{invalid output constraint '+F' in asm}}
187   __asm ("nop" : "=FF" (x) : :); // expected-error{{invalid output constraint '=FF' in asm}}
188   __asm ("nop" : "=Er" (x) : :); // no-error
189   __asm ("nop" : "=rE" (x) : :); // no-error
190   __asm ("nop" : "=Eg" (x) : :); // no-error
191   __asm ("nop" : "=Em" (x) : :); // no-error
192   __asm ("nop" : "=Emr" (x) : :); // no-error
193   __asm ("nop" : "=E" (x) : :); // expected-error{{invalid output constraint '=E' in asm}}
194   __asm ("nop" : "+E" (x) : :); // expected-error{{invalid output constraint '+E' in asm}}
195   __asm ("nop" : "=EE" (x) : :); // expected-error{{invalid output constraint '=EE' in asm}}
196 }
197 
198 // PR19837
199 struct foo {
200   int a;
201 };
202 register struct foo bar asm("esp"); // expected-error {{bad type for named register variable}}
203 register float baz asm("esp"); // expected-error {{bad type for named register variable}}
204 
205 register int r0 asm ("edi"); // expected-error {{register 'edi' unsuitable for global register variables on this target}}
206 register long long r1 asm ("esp"); // expected-error {{size of register 'esp' does not match variable size}}
207 register int r2 asm ("esp");
208 
f_output_constraint(void)209 double f_output_constraint(void) {
210   double result;
211   __asm("foo1": "=f" (result)); // expected-error {{invalid output constraint '=f' in asm}}
212   return result;
213 }
214 
fn1()215 void fn1() {
216   int l;
217   __asm__(""
218           : [l] "=r"(l)
219           : "[l],m"(l)); // expected-error {{asm constraint has an unexpected number of alternatives: 1 vs 2}}
220 }
221 
fn2()222 void fn2() {
223   int l;
224  __asm__(""
225           : "+&m"(l)); // expected-error {{invalid output constraint '+&m' in asm}}
226 }
227 
fn3()228 void fn3() {
229   int l;
230  __asm__(""
231           : "+#r"(l)); // expected-error {{invalid output constraint '+#r' in asm}}
232 }
233 
fn4()234 void fn4() {
235   int l;
236  __asm__(""
237           : "=r"(l)
238           : "m#"(l));
239 }
240 
fn5()241 void fn5() {
242   int l;
243     __asm__(""
244           : [g] "+r"(l)
245           : "[g]"(l)); // expected-error {{invalid input constraint '[g]' in asm}}
246 }
247 
fn6()248 void fn6() {
249     int a;
250   __asm__(""
251             : "=rm"(a), "=rm"(a)
252             : "11m"(a)) // expected-error {{invalid input constraint '11m' in asm}}
253 }
254 
255 // PR14269
256 typedef struct test16_foo {
257   unsigned int field1 : 1;
258   unsigned int field2 : 2;
259   unsigned int field3 : 3;
260 } test16_foo;
261 typedef __attribute__((vector_size(16))) int test16_bar;
262 register int test16_baz asm("esp");
263 
test16()264 void test16()
265 {
266   test16_foo a;
267   test16_bar b;
268 
269   __asm__("movl $5, %0"
270           : "=rm" (a.field2)); // expected-error {{reference to a bit-field in asm input with a memory constraint '=rm'}}
271   __asm__("movl $5, %0"
272           :
273           : "m" (a.field3)); // expected-error {{reference to a bit-field in asm output with a memory constraint 'm'}}
274   __asm__("movl $5, %0"
275           : "=rm" (b[2])); // expected-error {{reference to a vector element in asm input with a memory constraint '=rm'}}
276   __asm__("movl $5, %0"
277           :
278           : "m" (b[3])); // expected-error {{reference to a vector element in asm output with a memory constraint 'm'}}
279   __asm__("movl $5, %0"
280           : "=rm" (test16_baz)); // expected-error {{reference to a global register variable in asm input with a memory constraint '=rm'}}
281   __asm__("movl $5, %0"
282           :
283           : "m" (test16_baz)); // expected-error {{reference to a global register variable in asm output with a memory constraint 'm'}}
284 }
285 
test17(int t0)286 int test17(int t0)
287 {
288   int r0, r1;
289   __asm ("addl %2, %2\n\t"
290          "movl $123, %0"
291          : "=a" (r0),
292            "=&r" (r1)
293          : "1" (t0),   // expected-note {{constraint '1' is already present here}}
294            "1" (t0));  // expected-error {{more than one input constraint matches the same output '1'}}
295   return r0 + r1;
296 }
297 
298