fix-mixed-struct (patch by Pip Cet)
[tinycc.git] / tccasm.c
blob3cbae1987bc77cd83124c4f6419a9b38497a04f5
1 /*
2 * GAS like assembler for TCC
3 *
4 * Copyright (c) 2001-2004 Fabrice Bellard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
21 #include "tcc.h"
22 #ifdef CONFIG_TCC_ASM
24 ST_FUNC int asm_get_local_label_name(TCCState *s1, unsigned int n)
25 {
26 char buf[64];
27 TokenSym *ts;
29 snprintf(buf, sizeof(buf), "L..%u", n);
30 ts = tok_alloc(buf, strlen(buf));
31 return ts->tok;
32 }
34 ST_FUNC void asm_expr(TCCState *s1, ExprValue *pe);
36 /* We do not use the C expression parser to handle symbols. Maybe the
37 C expression parser could be tweaked to do so. */
39 static void asm_expr_unary(TCCState *s1, ExprValue *pe)
40 {
41 Sym *sym;
42 int op, n, label;
43 const char *p;
45 switch(tok) {
46 case TOK_PPNUM:
47 p = tokc.cstr->data;
48 n = strtoul(p, (char **)&p, 0);
49 if (*p == 'b' || *p == 'f') {
50 /* backward or forward label */
51 label = asm_get_local_label_name(s1, n);
52 sym = label_find(label);
53 if (*p == 'b') {
54 /* backward : find the last corresponding defined label */
55 if (sym && sym->r == 0)
56 sym = sym->prev_tok;
57 if (!sym)
58 tcc_error("local label '%d' not found backward", n);
59 } else {
60 /* forward */
61 if (!sym || sym->r) {
62 /* if the last label is defined, then define a new one */
63 sym = label_push(&s1->asm_labels, label, 0);
64 sym->type.t = VT_STATIC | VT_VOID;
65 }
66 }
67 pe->v = 0;
68 pe->sym = sym;
69 } else if (*p == '\0') {
70 pe->v = n;
71 pe->sym = NULL;
72 } else {
73 tcc_error("invalid number syntax");
74 }
75 next();
76 break;
77 case '+':
78 next();
79 asm_expr_unary(s1, pe);
80 break;
81 case '-':
82 case '~':
83 op = tok;
84 next();
85 asm_expr_unary(s1, pe);
86 if (pe->sym)
87 tcc_error("invalid operation with label");
88 if (op == '-')
89 pe->v = -pe->v;
90 else
91 pe->v = ~pe->v;
92 break;
93 case TOK_CCHAR:
94 case TOK_LCHAR:
95 pe->v = tokc.i;
96 pe->sym = NULL;
97 next();
98 break;
99 case '(':
100 next();
101 asm_expr(s1, pe);
102 skip(')');
103 break;
104 default:
105 if (tok >= TOK_IDENT) {
106 /* label case : if the label was not found, add one */
107 sym = label_find(tok);
108 if (!sym) {
109 sym = label_push(&s1->asm_labels, tok, 0);
110 /* NOTE: by default, the symbol is global */
111 sym->type.t = VT_VOID;
113 if (sym->r == SHN_ABS) {
114 /* if absolute symbol, no need to put a symbol value */
115 pe->v = sym->jnext;
116 pe->sym = NULL;
117 } else {
118 pe->v = 0;
119 pe->sym = sym;
121 next();
122 } else {
123 tcc_error("bad expression syntax [%s]", get_tok_str(tok, &tokc));
125 break;
129 static void asm_expr_prod(TCCState *s1, ExprValue *pe)
131 int op;
132 ExprValue e2;
134 asm_expr_unary(s1, pe);
135 for(;;) {
136 op = tok;
137 if (op != '*' && op != '/' && op != '%' &&
138 op != TOK_SHL && op != TOK_SAR)
139 break;
140 next();
141 asm_expr_unary(s1, &e2);
142 if (pe->sym || e2.sym)
143 tcc_error("invalid operation with label");
144 switch(op) {
145 case '*':
146 pe->v *= e2.v;
147 break;
148 case '/':
149 if (e2.v == 0) {
150 div_error:
151 tcc_error("division by zero");
153 pe->v /= e2.v;
154 break;
155 case '%':
156 if (e2.v == 0)
157 goto div_error;
158 pe->v %= e2.v;
159 break;
160 case TOK_SHL:
161 pe->v <<= e2.v;
162 break;
163 default:
164 case TOK_SAR:
165 pe->v >>= e2.v;
166 break;
171 static void asm_expr_logic(TCCState *s1, ExprValue *pe)
173 int op;
174 ExprValue e2;
176 asm_expr_prod(s1, pe);
177 for(;;) {
178 op = tok;
179 if (op != '&' && op != '|' && op != '^')
180 break;
181 next();
182 asm_expr_prod(s1, &e2);
183 if (pe->sym || e2.sym)
184 tcc_error("invalid operation with label");
185 switch(op) {
186 case '&':
187 pe->v &= e2.v;
188 break;
189 case '|':
190 pe->v |= e2.v;
191 break;
192 default:
193 case '^':
194 pe->v ^= e2.v;
195 break;
200 static inline void asm_expr_sum(TCCState *s1, ExprValue *pe)
202 int op;
203 ExprValue e2;
205 asm_expr_logic(s1, pe);
206 for(;;) {
207 op = tok;
208 if (op != '+' && op != '-')
209 break;
210 next();
211 asm_expr_logic(s1, &e2);
212 if (op == '+') {
213 if (pe->sym != NULL && e2.sym != NULL)
214 goto cannot_relocate;
215 pe->v += e2.v;
216 if (pe->sym == NULL && e2.sym != NULL)
217 pe->sym = e2.sym;
218 } else {
219 pe->v -= e2.v;
220 /* NOTE: we are less powerful than gas in that case
221 because we store only one symbol in the expression */
222 if (!pe->sym && !e2.sym) {
223 /* OK */
224 } else if (pe->sym && !e2.sym) {
225 /* OK */
226 } else if (pe->sym && e2.sym) {
227 if (pe->sym == e2.sym) {
228 /* OK */
229 } else if (pe->sym->r == e2.sym->r && pe->sym->r != 0) {
230 /* we also accept defined symbols in the same section */
231 pe->v += pe->sym->jnext - e2.sym->jnext;
232 } else {
233 goto cannot_relocate;
235 pe->sym = NULL; /* same symbols can be subtracted to NULL */
236 } else {
237 cannot_relocate:
238 tcc_error("invalid operation with label");
244 ST_FUNC void asm_expr(TCCState *s1, ExprValue *pe)
246 asm_expr_sum(s1, pe);
249 ST_FUNC int asm_int_expr(TCCState *s1)
251 ExprValue e;
252 asm_expr(s1, &e);
253 if (e.sym)
254 expect("constant");
255 return e.v;
258 /* NOTE: the same name space as C labels is used to avoid using too
259 much memory when storing labels in TokenStrings */
260 static void asm_new_label1(TCCState *s1, int label, int is_local,
261 int sh_num, int value)
263 Sym *sym;
265 sym = label_find(label);
266 if (sym) {
267 if (sym->r) {
268 /* the label is already defined */
269 if (!is_local) {
270 tcc_error("assembler label '%s' already defined",
271 get_tok_str(label, NULL));
272 } else {
273 /* redefinition of local labels is possible */
274 goto new_label;
277 } else {
278 new_label:
279 sym = label_push(&s1->asm_labels, label, 0);
280 sym->type.t = VT_STATIC | VT_VOID;
282 sym->r = sh_num;
283 sym->jnext = value;
286 static void asm_new_label(TCCState *s1, int label, int is_local)
288 asm_new_label1(s1, label, is_local, cur_text_section->sh_num, ind);
291 static void asm_free_labels(TCCState *st)
293 Sym *s, *s1;
294 Section *sec;
296 for(s = st->asm_labels; s != NULL; s = s1) {
297 s1 = s->prev;
298 /* define symbol value in object file */
299 if (s->r) {
300 if (s->r == SHN_ABS)
301 sec = SECTION_ABS;
302 else
303 sec = st->sections[s->r];
304 put_extern_sym2(s, sec, s->jnext, 0, 0);
306 /* remove label */
307 table_ident[s->v - TOK_IDENT]->sym_label = NULL;
308 sym_free(s);
310 st->asm_labels = NULL;
313 static void use_section1(TCCState *s1, Section *sec)
315 cur_text_section->data_offset = ind;
316 cur_text_section = sec;
317 ind = cur_text_section->data_offset;
320 static void use_section(TCCState *s1, const char *name)
322 Section *sec;
323 sec = find_section(s1, name);
324 use_section1(s1, sec);
327 static void asm_parse_directive(TCCState *s1)
329 int n, offset, v, size, tok1;
330 Section *sec;
331 uint8_t *ptr;
333 /* assembler directive */
334 next();
335 sec = cur_text_section;
336 switch(tok) {
337 case TOK_ASM_align:
338 case TOK_ASM_p2align:
339 case TOK_ASM_skip:
340 case TOK_ASM_space:
341 tok1 = tok;
342 next();
343 n = asm_int_expr(s1);
344 if (tok1 == TOK_ASM_p2align)
346 if (n < 0 || n > 30)
347 tcc_error("invalid p2align, must be between 0 and 30");
348 n = 1 << n;
349 tok1 = TOK_ASM_align;
351 if (tok1 == TOK_ASM_align) {
352 if (n < 0 || (n & (n-1)) != 0)
353 tcc_error("alignment must be a positive power of two");
354 offset = (ind + n - 1) & -n;
355 size = offset - ind;
356 /* the section must have a compatible alignment */
357 if (sec->sh_addralign < n)
358 sec->sh_addralign = n;
359 } else {
360 size = n;
362 v = 0;
363 if (tok == ',') {
364 next();
365 v = asm_int_expr(s1);
367 zero_pad:
368 if (sec->sh_type != SHT_NOBITS) {
369 sec->data_offset = ind;
370 ptr = section_ptr_add(sec, size);
371 memset(ptr, v, size);
373 ind += size;
374 break;
375 case TOK_ASM_quad:
376 next();
377 for(;;) {
378 uint64_t vl;
379 const char *p;
381 p = tokc.cstr->data;
382 if (tok != TOK_PPNUM) {
383 error_constant:
384 tcc_error("64 bit constant");
386 vl = strtoll(p, (char **)&p, 0);
387 if (*p != '\0')
388 goto error_constant;
389 next();
390 if (sec->sh_type != SHT_NOBITS) {
391 /* XXX: endianness */
392 gen_le32(vl);
393 gen_le32(vl >> 32);
394 } else {
395 ind += 8;
397 if (tok != ',')
398 break;
399 next();
401 break;
402 case TOK_ASM_byte:
403 size = 1;
404 goto asm_data;
405 case TOK_ASM_word:
406 case TOK_SHORT:
407 size = 2;
408 goto asm_data;
409 case TOK_LONG:
410 case TOK_INT:
411 size = 4;
412 asm_data:
413 next();
414 for(;;) {
415 ExprValue e;
416 asm_expr(s1, &e);
417 if (sec->sh_type != SHT_NOBITS) {
418 if (size == 4) {
419 gen_expr32(&e);
420 } else {
421 if (e.sym)
422 expect("constant");
423 if (size == 1)
424 g(e.v);
425 else
426 gen_le16(e.v);
428 } else {
429 ind += size;
431 if (tok != ',')
432 break;
433 next();
435 break;
436 case TOK_ASM_fill:
438 int repeat, size, val, i, j;
439 uint8_t repeat_buf[8];
440 next();
441 repeat = asm_int_expr(s1);
442 if (repeat < 0) {
443 tcc_error("repeat < 0; .fill ignored");
444 break;
446 size = 1;
447 val = 0;
448 if (tok == ',') {
449 next();
450 size = asm_int_expr(s1);
451 if (size < 0) {
452 tcc_error("size < 0; .fill ignored");
453 break;
455 if (size > 8)
456 size = 8;
457 if (tok == ',') {
458 next();
459 val = asm_int_expr(s1);
462 /* XXX: endianness */
463 repeat_buf[0] = val;
464 repeat_buf[1] = val >> 8;
465 repeat_buf[2] = val >> 16;
466 repeat_buf[3] = val >> 24;
467 repeat_buf[4] = 0;
468 repeat_buf[5] = 0;
469 repeat_buf[6] = 0;
470 repeat_buf[7] = 0;
471 for(i = 0; i < repeat; i++) {
472 for(j = 0; j < size; j++) {
473 g(repeat_buf[j]);
477 break;
478 case TOK_ASM_org:
480 unsigned long n;
481 next();
482 /* XXX: handle section symbols too */
483 n = asm_int_expr(s1);
484 if (n < ind)
485 tcc_error("attempt to .org backwards");
486 v = 0;
487 size = n - ind;
488 goto zero_pad;
490 break;
491 case TOK_ASM_globl:
492 case TOK_ASM_global:
493 case TOK_ASM_weak:
494 case TOK_ASM_hidden:
495 tok1 = tok;
496 do {
497 Sym *sym;
499 next();
500 sym = label_find(tok);
501 if (!sym) {
502 sym = label_push(&s1->asm_labels, tok, 0);
503 sym->type.t = VT_VOID;
505 if (tok1 != TOK_ASM_hidden)
506 sym->type.t &= ~VT_STATIC;
507 if (tok1 == TOK_ASM_weak)
508 sym->type.t |= VT_WEAK;
509 else if (tok1 == TOK_ASM_hidden)
510 sym->type.t |= STV_HIDDEN << VT_VIS_SHIFT;
511 next();
512 } while (tok == ',');
513 break;
514 case TOK_ASM_string:
515 case TOK_ASM_ascii:
516 case TOK_ASM_asciz:
518 const uint8_t *p;
519 int i, size, t;
521 t = tok;
522 next();
523 for(;;) {
524 if (tok != TOK_STR)
525 expect("string constant");
526 p = tokc.cstr->data;
527 size = tokc.cstr->size;
528 if (t == TOK_ASM_ascii && size > 0)
529 size--;
530 for(i = 0; i < size; i++)
531 g(p[i]);
532 next();
533 if (tok == ',') {
534 next();
535 } else if (tok != TOK_STR) {
536 break;
540 break;
541 case TOK_ASM_text:
542 case TOK_ASM_data:
543 case TOK_ASM_bss:
544 {
545 char sname[64];
546 tok1 = tok;
547 n = 0;
548 next();
549 if (tok != ';' && tok != TOK_LINEFEED) {
550 n = asm_int_expr(s1);
551 next();
553 sprintf(sname, (n?".%s%d":".%s"), get_tok_str(tok1, NULL), n);
554 use_section(s1, sname);
556 break;
557 case TOK_ASM_file:
559 char filename[512];
561 filename[0] = '\0';
562 next();
564 if (tok == TOK_STR)
565 pstrcat(filename, sizeof(filename), tokc.cstr->data);
566 else
567 pstrcat(filename, sizeof(filename), get_tok_str(tok, NULL));
569 if (s1->warn_unsupported)
570 tcc_warning("ignoring .file %s", filename);
572 next();
574 break;
575 case TOK_ASM_ident:
577 char ident[256];
579 ident[0] = '\0';
580 next();
582 if (tok == TOK_STR)
583 pstrcat(ident, sizeof(ident), tokc.cstr->data);
584 else
585 pstrcat(ident, sizeof(ident), get_tok_str(tok, NULL));
587 if (s1->warn_unsupported)
588 tcc_warning("ignoring .ident %s", ident);
590 next();
592 break;
593 case TOK_ASM_size:
594 {
595 Sym *sym;
597 next();
598 sym = label_find(tok);
599 if (!sym) {
600 tcc_error("label not found: %s", get_tok_str(tok, NULL));
603 /* XXX .size name,label2-label1 */
604 if (s1->warn_unsupported)
605 tcc_warning("ignoring .size %s,*", get_tok_str(tok, NULL));
607 next();
608 skip(',');
609 while (tok != '\n' && tok != CH_EOF) {
610 next();
613 break;
614 case TOK_ASM_type:
615 {
616 Sym *sym;
617 const char *newtype;
619 next();
620 sym = label_find(tok);
621 if (!sym) {
622 sym = label_push(&s1->asm_labels, tok, 0);
623 sym->type.t = VT_VOID;
626 next();
627 skip(',');
628 if (tok == TOK_STR) {
629 newtype = tokc.cstr->data;
630 } else {
631 if (tok == '@' || tok == '%')
632 skip(tok);
633 newtype = get_tok_str(tok, NULL);
636 if (!strcmp(newtype, "function") || !strcmp(newtype, "STT_FUNC")) {
637 sym->type.t = (sym->type.t & ~VT_BTYPE) | VT_FUNC;
639 else if (s1->warn_unsupported)
640 tcc_warning("change type of '%s' from 0x%x to '%s' ignored",
641 get_tok_str(sym->v, NULL), sym->type.t, newtype);
643 next();
645 break;
646 case TOK_SECTION1:
648 char sname[256];
650 /* XXX: support more options */
651 next();
652 sname[0] = '\0';
653 while (tok != ';' && tok != TOK_LINEFEED && tok != ',') {
654 if (tok == TOK_STR)
655 pstrcat(sname, sizeof(sname), tokc.cstr->data);
656 else
657 pstrcat(sname, sizeof(sname), get_tok_str(tok, NULL));
658 next();
660 if (tok == ',') {
661 /* skip section options */
662 next();
663 if (tok != TOK_STR)
664 expect("string constant");
665 next();
667 last_text_section = cur_text_section;
668 use_section(s1, sname);
670 break;
671 case TOK_ASM_previous:
672 {
673 Section *sec;
674 next();
675 if (!last_text_section)
676 tcc_error("no previous section referenced");
677 sec = cur_text_section;
678 use_section1(s1, last_text_section);
679 last_text_section = sec;
681 break;
682 #ifdef TCC_TARGET_I386
683 case TOK_ASM_code16:
685 next();
686 s1->seg_size = 16;
688 break;
689 case TOK_ASM_code32:
691 next();
692 s1->seg_size = 32;
694 break;
695 #endif
696 #ifdef TCC_TARGET_X86_64
697 /* added for compatibility with GAS */
698 case TOK_ASM_code64:
699 next();
700 break;
701 #endif
702 default:
703 tcc_error("unknown assembler directive '.%s'", get_tok_str(tok, NULL));
704 break;
709 /* assemble a file */
710 static int tcc_assemble_internal(TCCState *s1, int do_preprocess)
712 int opcode;
714 #if 0
715 /* print stats about opcodes */
717 const ASMInstr *pa;
718 int freq[4];
719 int op_vals[500];
720 int nb_op_vals, i, j;
722 nb_op_vals = 0;
723 memset(freq, 0, sizeof(freq));
724 for(pa = asm_instrs; pa->sym != 0; pa++) {
725 freq[pa->nb_ops]++;
726 for(i=0;i<pa->nb_ops;i++) {
727 for(j=0;j<nb_op_vals;j++) {
728 if (pa->op_type[i] == op_vals[j])
729 goto found;
731 op_vals[nb_op_vals++] = pa->op_type[i];
732 found: ;
735 for(i=0;i<nb_op_vals;i++) {
736 int v = op_vals[i];
737 if ((v & (v - 1)) != 0)
738 printf("%3d: %08x\n", i, v);
740 printf("size=%d nb=%d f0=%d f1=%d f2=%d f3=%d\n",
741 sizeof(asm_instrs), sizeof(asm_instrs) / sizeof(ASMInstr),
742 freq[0], freq[1], freq[2], freq[3]);
744 #endif
746 /* XXX: undefine C labels */
748 ch = file->buf_ptr[0];
749 tok_flags = TOK_FLAG_BOL | TOK_FLAG_BOF;
750 parse_flags = PARSE_FLAG_ASM_FILE | PARSE_FLAG_TOK_STR;
751 if (do_preprocess)
752 parse_flags |= PARSE_FLAG_PREPROCESS;
753 next();
754 for(;;) {
755 if (tok == TOK_EOF)
756 break;
757 parse_flags |= PARSE_FLAG_LINEFEED; /* XXX: suppress that hack */
758 redo:
759 if (tok == '#') {
760 /* horrible gas comment */
761 while (tok != TOK_LINEFEED)
762 next();
763 } else if (tok == '.') {
764 asm_parse_directive(s1);
765 } else if (tok == TOK_PPNUM) {
766 const char *p;
767 int n;
768 p = tokc.cstr->data;
769 n = strtoul(p, (char **)&p, 10);
770 if (*p != '\0')
771 expect("':'");
772 /* new local label */
773 asm_new_label(s1, asm_get_local_label_name(s1, n), 1);
774 next();
775 skip(':');
776 goto redo;
777 } else if (tok >= TOK_IDENT) {
778 /* instruction or label */
779 opcode = tok;
780 next();
781 if (tok == ':') {
782 /* new label */
783 asm_new_label(s1, opcode, 0);
784 next();
785 goto redo;
786 } else if (tok == '=') {
787 int n;
788 next();
789 n = asm_int_expr(s1);
790 asm_new_label1(s1, opcode, 0, SHN_ABS, n);
791 goto redo;
792 } else {
793 asm_opcode(s1, opcode);
796 /* end of line */
797 if (tok != ';' && tok != TOK_LINEFEED){
798 expect("end of line");
800 parse_flags &= ~PARSE_FLAG_LINEFEED; /* XXX: suppress that hack */
801 next();
804 asm_free_labels(s1);
806 return 0;
809 /* Assemble the current file */
810 ST_FUNC int tcc_assemble(TCCState *s1, int do_preprocess)
812 Sym *define_start;
813 int ret;
815 preprocess_init(s1);
817 /* default section is text */
818 cur_text_section = text_section;
819 ind = cur_text_section->data_offset;
821 define_start = define_stack;
823 /* an elf symbol of type STT_FILE must be put so that STB_LOCAL
824 symbols can be safely used */
825 put_elf_sym(symtab_section, 0, 0,
826 ELFW(ST_INFO)(STB_LOCAL, STT_FILE), 0,
827 SHN_ABS, file->filename);
829 ret = tcc_assemble_internal(s1, do_preprocess);
831 cur_text_section->data_offset = ind;
833 free_defines(define_start);
835 return ret;
838 /********************************************************************/
839 /* GCC inline asm support */
841 /* assemble the string 'str' in the current C compilation unit without
842 C preprocessing. NOTE: str is modified by modifying the '\0' at the
843 end */
844 static void tcc_assemble_inline(TCCState *s1, char *str, int len)
846 int saved_parse_flags;
847 const int *saved_macro_ptr;
849 saved_parse_flags = parse_flags;
850 saved_macro_ptr = macro_ptr;
852 tcc_open_bf(s1, ":asm:", len);
853 memcpy(file->buffer, str, len);
855 macro_ptr = NULL;
856 tcc_assemble_internal(s1, 0);
857 tcc_close();
859 parse_flags = saved_parse_flags;
860 macro_ptr = saved_macro_ptr;
863 /* find a constraint by its number or id (gcc 3 extended
864 syntax). return -1 if not found. Return in *pp in char after the
865 constraint */
866 ST_FUNC int find_constraint(ASMOperand *operands, int nb_operands,
867 const char *name, const char **pp)
869 int index;
870 TokenSym *ts;
871 const char *p;
873 if (isnum(*name)) {
874 index = 0;
875 while (isnum(*name)) {
876 index = (index * 10) + (*name) - '0';
877 name++;
879 if ((unsigned)index >= nb_operands)
880 index = -1;
881 } else if (*name == '[') {
882 name++;
883 p = strchr(name, ']');
884 if (p) {
885 ts = tok_alloc(name, p - name);
886 for(index = 0; index < nb_operands; index++) {
887 if (operands[index].id == ts->tok)
888 goto found;
890 index = -1;
891 found:
892 name = p + 1;
893 } else {
894 index = -1;
896 } else {
897 index = -1;
899 if (pp)
900 *pp = name;
901 return index;
904 static void subst_asm_operands(ASMOperand *operands, int nb_operands,
905 int nb_outputs,
906 CString *out_str, CString *in_str)
908 int c, index, modifier;
909 const char *str;
910 ASMOperand *op;
911 SValue sv;
913 cstr_new(out_str);
914 str = in_str->data;
915 for(;;) {
916 c = *str++;
917 if (c == '%') {
918 if (*str == '%') {
919 str++;
920 goto add_char;
922 modifier = 0;
923 if (*str == 'c' || *str == 'n' ||
924 *str == 'b' || *str == 'w' || *str == 'h')
925 modifier = *str++;
926 index = find_constraint(operands, nb_operands, str, &str);
927 if (index < 0)
928 tcc_error("invalid operand reference after %%");
929 op = &operands[index];
930 sv = *op->vt;
931 if (op->reg >= 0) {
932 sv.r = op->reg;
933 if ((op->vt->r & VT_VALMASK) == VT_LLOCAL && op->is_memory)
934 sv.r |= VT_LVAL;
936 subst_asm_operand(out_str, &sv, modifier);
937 } else {
938 add_char:
939 cstr_ccat(out_str, c);
940 if (c == '\0')
941 break;
947 static void parse_asm_operands(ASMOperand *operands, int *nb_operands_ptr,
948 int is_output)
950 ASMOperand *op;
951 int nb_operands;
953 if (tok != ':') {
954 nb_operands = *nb_operands_ptr;
955 for(;;) {
956 if (nb_operands >= MAX_ASM_OPERANDS)
957 tcc_error("too many asm operands");
958 op = &operands[nb_operands++];
959 op->id = 0;
960 if (tok == '[') {
961 next();
962 if (tok < TOK_IDENT)
963 expect("identifier");
964 op->id = tok;
965 next();
966 skip(']');
968 if (tok != TOK_STR)
969 expect("string constant");
970 op->constraint = tcc_malloc(tokc.cstr->size);
971 strcpy(op->constraint, tokc.cstr->data);
972 next();
973 skip('(');
974 gexpr();
975 if (is_output) {
976 test_lvalue();
977 } else {
978 /* we want to avoid LLOCAL case, except when the 'm'
979 constraint is used. Note that it may come from
980 register storage, so we need to convert (reg)
981 case */
982 if ((vtop->r & VT_LVAL) &&
983 ((vtop->r & VT_VALMASK) == VT_LLOCAL ||
984 (vtop->r & VT_VALMASK) < VT_CONST) &&
985 !strchr(op->constraint, 'm')) {
986 gv(RC_INT);
989 op->vt = vtop;
990 skip(')');
991 if (tok == ',') {
992 next();
993 } else {
994 break;
997 *nb_operands_ptr = nb_operands;
1001 /* parse the GCC asm() instruction */
1002 ST_FUNC void asm_instr(void)
1004 CString astr, astr1;
1005 ASMOperand operands[MAX_ASM_OPERANDS];
1006 int nb_outputs, nb_operands, i, must_subst, out_reg;
1007 uint8_t clobber_regs[NB_ASM_REGS];
1009 next();
1010 /* since we always generate the asm() instruction, we can ignore
1011 volatile */
1012 if (tok == TOK_VOLATILE1 || tok == TOK_VOLATILE2 || tok == TOK_VOLATILE3) {
1013 next();
1015 parse_asm_str(&astr);
1016 nb_operands = 0;
1017 nb_outputs = 0;
1018 must_subst = 0;
1019 memset(clobber_regs, 0, sizeof(clobber_regs));
1020 if (tok == ':') {
1021 next();
1022 must_subst = 1;
1023 /* output args */
1024 parse_asm_operands(operands, &nb_operands, 1);
1025 nb_outputs = nb_operands;
1026 if (tok == ':') {
1027 next();
1028 if (tok != ')') {
1029 /* input args */
1030 parse_asm_operands(operands, &nb_operands, 0);
1031 if (tok == ':') {
1032 /* clobber list */
1033 /* XXX: handle registers */
1034 next();
1035 for(;;) {
1036 if (tok != TOK_STR)
1037 expect("string constant");
1038 asm_clobber(clobber_regs, tokc.cstr->data);
1039 next();
1040 if (tok == ',') {
1041 next();
1042 } else {
1043 break;
1050 skip(')');
1051 /* NOTE: we do not eat the ';' so that we can restore the current
1052 token after the assembler parsing */
1053 if (tok != ';')
1054 expect("';'");
1056 /* save all values in the memory */
1057 save_regs(0);
1059 /* compute constraints */
1060 asm_compute_constraints(operands, nb_operands, nb_outputs,
1061 clobber_regs, &out_reg);
1063 /* substitute the operands in the asm string. No substitution is
1064 done if no operands (GCC behaviour) */
1065 #ifdef ASM_DEBUG
1066 printf("asm: \"%s\"\n", (char *)astr.data);
1067 #endif
1068 if (must_subst) {
1069 subst_asm_operands(operands, nb_operands, nb_outputs, &astr1, &astr);
1070 cstr_free(&astr);
1071 } else {
1072 astr1 = astr;
1074 #ifdef ASM_DEBUG
1075 printf("subst_asm: \"%s\"\n", (char *)astr1.data);
1076 #endif
1078 /* generate loads */
1079 asm_gen_code(operands, nb_operands, nb_outputs, 0,
1080 clobber_regs, out_reg);
1082 /* assemble the string with tcc internal assembler */
1083 tcc_assemble_inline(tcc_state, astr1.data, astr1.size - 1);
1085 /* restore the current C token */
1086 next();
1088 /* store the output values if needed */
1089 asm_gen_code(operands, nb_operands, nb_outputs, 1,
1090 clobber_regs, out_reg);
1092 /* free everything */
1093 for(i=0;i<nb_operands;i++) {
1094 ASMOperand *op;
1095 op = &operands[i];
1096 tcc_free(op->constraint);
1097 vpop();
1099 cstr_free(&astr1);
1102 ST_FUNC void asm_global_instr(void)
1104 CString astr;
1106 next();
1107 parse_asm_str(&astr);
1108 skip(')');
1109 /* NOTE: we do not eat the ';' so that we can restore the current
1110 token after the assembler parsing */
1111 if (tok != ';')
1112 expect("';'");
1114 #ifdef ASM_DEBUG
1115 printf("asm_global: \"%s\"\n", (char *)astr.data);
1116 #endif
1117 cur_text_section = text_section;
1118 ind = cur_text_section->data_offset;
1120 /* assemble the string with tcc internal assembler */
1121 tcc_assemble_inline(tcc_state, astr.data, astr.size - 1);
1123 cur_text_section->data_offset = ind;
1125 /* restore the current C token */
1126 next();
1128 cstr_free(&astr);
1130 #endif /* CONFIG_TCC_ASM */