diff options
Diffstat (limited to 'tccasm.c')
| -rw-r--r-- | tccasm.c | 838 |
1 files changed, 420 insertions, 418 deletions
@@ -22,16 +22,18 @@ #include "tcc.h" #ifdef CONFIG_TCC_ASM -ST_FUNC int asm_get_local_label_name(TCCState *S, unsigned int n) +static Section *last_text_section; /* to handle .previous asm directive */ + +ST_FUNC int asm_get_local_label_name(TCCState *s1, unsigned int n) { char buf[64]; snprintf(buf, sizeof(buf), "L..%u", n); - return tok_alloc_const(S, buf); + return tok_alloc_const(buf); } -static int tcc_assemble_internal(TCCState *S, int do_preprocess, int global); -static Sym* asm_new_label(TCCState *S, int label, int is_local); -static Sym* asm_new_label1(TCCState *S, int label, int is_local, int sh_num, int value); +static int tcc_assemble_internal(TCCState *s1, int do_preprocess, int global); +static Sym* asm_new_label(TCCState *s1, int label, int is_local); +static Sym* asm_new_label1(TCCState *s1, int label, int is_local, int sh_num, int value); /* If a C name has an _ prepended then only asm labels that start with _ are representable in C, by removing the first _. ASM names @@ -39,44 +41,44 @@ static Sym* asm_new_label1(TCCState *S, int label, int is_local, int sh_num, int the global C symbol table to track ASM names as well, so we need to transform those into ones that don't conflict with a C name, so prepend a '.' for them, but force the ELF asm name to be set. */ -static int asm2cname(TCCState* S, int v, int *addeddot) +static int asm2cname(int v, int *addeddot) { const char *name; *addeddot = 0; - if (!S->leading_underscore) + if (!tcc_state->leading_underscore) return v; - name = get_tok_str(S, v, NULL); + name = get_tok_str(v, NULL); if (!name) return v; if (name[0] == '_') { - v = tok_alloc_const(S, name + 1); + v = tok_alloc_const(name + 1); } else if (!strchr(name, '.')) { char newname[256]; snprintf(newname, sizeof newname, ".%s", name); - v = tok_alloc_const(S, newname); + v = tok_alloc_const(newname); *addeddot = 1; } return v; } -static Sym *asm_label_find(TCCState* S, int v) +static Sym *asm_label_find(int v) { Sym *sym; int addeddot; - v = asm2cname(S, v, &addeddot); - sym = sym_find(S, v); + v = asm2cname(v, &addeddot); + sym = sym_find(v); while (sym && sym->sym_scope && !(sym->type.t & VT_STATIC)) sym = sym->prev_tok; return sym; } -static Sym *asm_label_push(TCCState* S, int v) +static Sym *asm_label_push(int v) { - int addeddot, v2 = asm2cname(S, v, &addeddot); + int addeddot, v2 = asm2cname(v, &addeddot); /* We always add VT_EXTERN, for sym definition that's tentative (for .set, removed for real defs), for mere references it's correct as is. */ - Sym *sym = global_identifier_push(S, v2, VT_ASM | VT_EXTERN | VT_STATIC, 0); + Sym *sym = global_identifier_push(v2, VT_ASM | VT_EXTERN | VT_STATIC, 0); if (addeddot) sym->asm_label = v; return sym; @@ -92,55 +94,55 @@ static Sym *asm_label_push(TCCState* S, int v) are anonymous in C, in this case CSYM can be used to transfer all information from that symbol to the (possibly newly created) asm symbol. */ -ST_FUNC Sym* get_asm_sym(TCCState* S, int name, Sym *csym) +ST_FUNC Sym* get_asm_sym(int name, Sym *csym) { - Sym *sym = asm_label_find(S, name); + Sym *sym = asm_label_find(name); if (!sym) { - sym = asm_label_push(S, name); + sym = asm_label_push(name); if (csym) sym->c = csym->c; } return sym; } -static Sym* asm_section_sym(TCCState *S, Section *sec) +static Sym* asm_section_sym(TCCState *s1, Section *sec) { char buf[100]; int label; Sym *sym; snprintf(buf, sizeof buf, "L.%s", sec->name); - label = tok_alloc_const(S, buf); - sym = asm_label_find(S, label); - return sym ? sym : asm_new_label1(S, label, 1, sec->sh_num, 0); + label = tok_alloc_const(buf); + sym = asm_label_find(label); + return sym ? sym : asm_new_label1(s1, label, 1, sec->sh_num, 0); } /* We do not use the C expression parser to handle symbols. Maybe the C expression parser could be tweaked to do so. */ -static void asm_expr_unary(TCCState *S, ExprValue *pe) +static void asm_expr_unary(TCCState *s1, ExprValue *pe) { Sym *sym; int op, label; uint64_t n; const char *p; - switch(S->tccpp_tok) { + switch(tok) { case TOK_PPNUM: - p = S->tccpp_tokc.str.data; + p = tokc.str.data; n = strtoull(p, (char **)&p, 0); if (*p == 'b' || *p == 'f') { /* backward or forward label */ - label = asm_get_local_label_name(S, n); - sym = asm_label_find(S, label); + label = asm_get_local_label_name(s1, n); + sym = asm_label_find(label); if (*p == 'b') { /* backward : find the last corresponding defined label */ - if (sym && (!sym->c || elfsym(S, sym)->st_shndx == SHN_UNDEF)) + if (sym && (!sym->c || elfsym(sym)->st_shndx == SHN_UNDEF)) sym = sym->prev_tok; if (!sym) - tcc_error(S, "local label '%d' not found backward", (int)n); + tcc_error("local label '%d' not found backward", (int)n); } else { /* forward */ - if (!sym || (sym->c && elfsym(S, sym)->st_shndx != SHN_UNDEF)) { + if (!sym || (sym->c && elfsym(sym)->st_shndx != SHN_UNDEF)) { /* if the last label is defined, then define a new one */ - sym = asm_label_push(S, label); + sym = asm_label_push(label); } } pe->v = 0; @@ -151,21 +153,21 @@ static void asm_expr_unary(TCCState *S, ExprValue *pe) pe->sym = NULL; pe->pcrel = 0; } else { - tcc_error(S, "invalid number syntax"); + tcc_error("invalid number syntax"); } - next(S); + next(); break; case '+': - next(S); - asm_expr_unary(S, pe); + next(); + asm_expr_unary(s1, pe); break; case '-': case '~': - op = S->tccpp_tok; - next(S); - asm_expr_unary(S, pe); + op = tok; + next(); + asm_expr_unary(s1, pe); if (pe->sym) - tcc_error(S, "invalid operation with label"); + tcc_error("invalid operation with label"); if (op == '-') pe->v = -pe->v; else @@ -173,28 +175,28 @@ static void asm_expr_unary(TCCState *S, ExprValue *pe) break; case TOK_CCHAR: case TOK_LCHAR: - pe->v = S->tccpp_tokc.i; + pe->v = tokc.i; pe->sym = NULL; pe->pcrel = 0; - next(S); + next(); break; case '(': - next(S); - asm_expr(S, pe); - skip(S, ')'); + next(); + asm_expr(s1, pe); + skip(')'); break; case '.': - pe->v = S->tccgen_ind; - pe->sym = asm_section_sym(S, cur_text_section); + pe->v = ind; + pe->sym = asm_section_sym(s1, cur_text_section); pe->pcrel = 0; - next(S); + next(); break; default: - if (S->tccpp_tok >= TOK_IDENT) { + if (tok >= TOK_IDENT) { ElfSym *esym; /* label case : if the label was not found, add one */ - sym = get_asm_sym(S, S->tccpp_tok, NULL); - esym = elfsym(S, sym); + sym = get_asm_sym(tok, NULL); + esym = elfsym(sym); if (esym && esym->st_shndx == SHN_ABS) { /* if absolute symbol, no need to put a symbol value */ pe->v = esym->st_value; @@ -205,29 +207,29 @@ static void asm_expr_unary(TCCState *S, ExprValue *pe) pe->sym = sym; pe->pcrel = 0; } - next(S); + next(); } else { - tcc_error(S, "bad expression syntax [%s]", get_tok_str(S, S->tccpp_tok, &S->tccpp_tokc)); + tcc_error("bad expression syntax [%s]", get_tok_str(tok, &tokc)); } break; } } -static void asm_expr_prod(TCCState *S, ExprValue *pe) +static void asm_expr_prod(TCCState *s1, ExprValue *pe) { int op; ExprValue e2; - asm_expr_unary(S, pe); + asm_expr_unary(s1, pe); for(;;) { - op = S->tccpp_tok; + op = tok; if (op != '*' && op != '/' && op != '%' && op != TOK_SHL && op != TOK_SAR) break; - next(S); - asm_expr_unary(S, &e2); + next(); + asm_expr_unary(s1, &e2); if (pe->sym || e2.sym) - tcc_error(S, "invalid operation with label"); + tcc_error("invalid operation with label"); switch(op) { case '*': pe->v *= e2.v; @@ -235,7 +237,7 @@ static void asm_expr_prod(TCCState *S, ExprValue *pe) case '/': if (e2.v == 0) { div_error: - tcc_error(S, "division by zero"); + tcc_error("division by zero"); } pe->v /= e2.v; break; @@ -255,20 +257,20 @@ static void asm_expr_prod(TCCState *S, ExprValue *pe) } } -static void asm_expr_logic(TCCState *S, ExprValue *pe) +static void asm_expr_logic(TCCState *s1, ExprValue *pe) { int op; ExprValue e2; - asm_expr_prod(S, pe); + asm_expr_prod(s1, pe); for(;;) { - op = S->tccpp_tok; + op = tok; if (op != '&' && op != '|' && op != '^') break; - next(S); - asm_expr_prod(S, &e2); + next(); + asm_expr_prod(s1, &e2); if (pe->sym || e2.sym) - tcc_error(S, "invalid operation with label"); + tcc_error("invalid operation with label"); switch(op) { case '&': pe->v &= e2.v; @@ -284,18 +286,18 @@ static void asm_expr_logic(TCCState *S, ExprValue *pe) } } -static inline void asm_expr_sum(TCCState *S, ExprValue *pe) +static inline void asm_expr_sum(TCCState *s1, ExprValue *pe) { int op; ExprValue e2; - asm_expr_logic(S, pe); + asm_expr_logic(s1, pe); for(;;) { - op = S->tccpp_tok; + op = tok; if (op != '+' && op != '-') break; - next(S); - asm_expr_logic(S, &e2); + next(); + asm_expr_logic(s1, &e2); if (op == '+') { if (pe->sym != NULL && e2.sym != NULL) goto cannot_relocate; @@ -313,8 +315,8 @@ static inline void asm_expr_sum(TCCState *S, ExprValue *pe) pe->sym = NULL; /* same symbols can be subtracted to NULL */ } else { ElfSym *esym1, *esym2; - esym1 = elfsym(S, pe->sym); - esym2 = elfsym(S, e2.sym); + esym1 = elfsym(pe->sym); + esym2 = elfsym(e2.sym); if (esym1 && esym1->st_shndx == esym2->st_shndx && esym1->st_shndx != SHN_UNDEF) { /* we also accept defined symbols in the same section */ @@ -323,33 +325,33 @@ static inline void asm_expr_sum(TCCState *S, ExprValue *pe) } else if (esym2->st_shndx == cur_text_section->sh_num) { /* When subtracting a defined symbol in current section this actually makes the value PC-relative. */ - pe->v -= esym2->st_value - S->tccgen_ind - 4; + pe->v -= esym2->st_value - ind - 4; pe->pcrel = 1; e2.sym = NULL; } else { cannot_relocate: - tcc_error(S, "invalid operation with label"); + tcc_error("invalid operation with label"); } } } } } -static inline void asm_expr_cmp(TCCState *S, ExprValue *pe) +static inline void asm_expr_cmp(TCCState *s1, ExprValue *pe) { int op; ExprValue e2; - asm_expr_sum(S, pe); + asm_expr_sum(s1, pe); for(;;) { - op = S->tccpp_tok; + op = tok; if (op != TOK_EQ && op != TOK_NE && (op > TOK_GT || op < TOK_ULE)) break; - next(S); - asm_expr_sum(S, &e2); + next(); + asm_expr_sum(s1, &e2); if (pe->sym || e2.sym) - tcc_error(S, "invalid operation with label"); + tcc_error("invalid operation with label"); switch(op) { case TOK_EQ: pe->v = pe->v == e2.v; @@ -377,29 +379,29 @@ static inline void asm_expr_cmp(TCCState *S, ExprValue *pe) } } -ST_FUNC void asm_expr(TCCState *S, ExprValue *pe) +ST_FUNC void asm_expr(TCCState *s1, ExprValue *pe) { - asm_expr_cmp(S, pe); + asm_expr_cmp(s1, pe); } -ST_FUNC int asm_int_expr(TCCState *S) +ST_FUNC int asm_int_expr(TCCState *s1) { ExprValue e; - asm_expr(S, &e); + asm_expr(s1, &e); if (e.sym) - expect(S, "constant"); + expect("constant"); return e.v; } -static Sym* asm_new_label1(TCCState *S, int label, int is_local, +static Sym* asm_new_label1(TCCState *s1, int label, int is_local, int sh_num, int value) { Sym *sym; ElfSym *esym; - sym = asm_label_find(S, label); + sym = asm_label_find(label); if (sym) { - esym = elfsym(S, sym); + esym = elfsym(sym); /* A VT_EXTERN symbol, even if it has a section is considered overridable. This is how we "define" .set targets. Real definitions won't have VT_EXTERN set. */ @@ -409,16 +411,16 @@ static Sym* asm_new_label1(TCCState *S, int label, int is_local, && (is_local == 1 || (sym->type.t & VT_EXTERN))) goto new_label; if (!(sym->type.t & VT_EXTERN)) - tcc_error(S, "assembler label '%s' already defined", - get_tok_str(S, label, NULL)); + tcc_error("assembler label '%s' already defined", + get_tok_str(label, NULL)); } } else { new_label: - sym = asm_label_push(S, label); + sym = asm_label_push(label); } if (!sym->c) - put_extern_sym2(S, sym, SHN_UNDEF, 0, 0, 1); - esym = elfsym(S, sym); + put_extern_sym2(sym, SHN_UNDEF, 0, 0, 1); + esym = elfsym(sym); esym->st_shndx = sh_num; esym->st_value = value; if (is_local != 2) @@ -426,61 +428,61 @@ static Sym* asm_new_label1(TCCState *S, int label, int is_local, return sym; } -static Sym* asm_new_label(TCCState *S, int label, int is_local) +static Sym* asm_new_label(TCCState *s1, int label, int is_local) { - return asm_new_label1(S, label, is_local, cur_text_section->sh_num, S->tccgen_ind); + return asm_new_label1(s1, label, is_local, cur_text_section->sh_num, ind); } /* Set the value of LABEL to that of some expression (possibly involving other symbols). LABEL can be overwritten later still. */ -static Sym* set_symbol(TCCState *S, int label) +static Sym* set_symbol(TCCState *s1, int label) { long n; ExprValue e; Sym *sym; ElfSym *esym; - next(S); - asm_expr(S, &e); + next(); + asm_expr(s1, &e); n = e.v; - esym = elfsym(S, e.sym); + esym = elfsym(e.sym); if (esym) n += esym->st_value; - sym = asm_new_label1(S, label, 2, esym ? esym->st_shndx : SHN_ABS, n); - elfsym(S, sym)->st_other |= ST_ASM_SET; + sym = asm_new_label1(s1, label, 2, esym ? esym->st_shndx : SHN_ABS, n); + elfsym(sym)->st_other |= ST_ASM_SET; return sym; } -static void use_section1(TCCState *S, Section *sec) +static void use_section1(TCCState *s1, Section *sec) { - cur_text_section->data_offset = S->tccgen_ind; + cur_text_section->data_offset = ind; cur_text_section = sec; - S->tccgen_ind = cur_text_section->data_offset; + ind = cur_text_section->data_offset; } -static void use_section(TCCState *S, const char *name) +static void use_section(TCCState *s1, const char *name) { Section *sec; - sec = find_section(S, name); - use_section1(S, sec); + sec = find_section(s1, name); + use_section1(s1, sec); } -static void push_section(TCCState *S, const char *name) +static void push_section(TCCState *s1, const char *name) { - Section *sec = find_section(S, name); + Section *sec = find_section(s1, name); sec->prev = cur_text_section; - use_section1(S, sec); + use_section1(s1, sec); } -static void pop_section(TCCState *S) +static void pop_section(TCCState *s1) { Section *prev = cur_text_section->prev; if (!prev) - tcc_error(S, ".popsection without .pushsection"); + tcc_error(".popsection without .pushsection"); cur_text_section->prev = NULL; - use_section1(S, prev); + use_section1(s1, prev); } -static void asm_parse_directive(TCCState *S, int global) +static void asm_parse_directive(TCCState *s1, int global) { int n, offset, v, size, tok1; Section *sec; @@ -488,27 +490,27 @@ static void asm_parse_directive(TCCState *S, int global) /* assembler directive */ sec = cur_text_section; - switch(S->tccpp_tok) { + switch(tok) { case TOK_ASMDIR_align: case TOK_ASMDIR_balign: case TOK_ASMDIR_p2align: case TOK_ASMDIR_skip: case TOK_ASMDIR_space: - tok1 = S->tccpp_tok; - next(S); - n = asm_int_expr(S); + tok1 = tok; + next(); + n = asm_int_expr(s1); if (tok1 == TOK_ASMDIR_p2align) { if (n < 0 || n > 30) - tcc_error(S, "invalid p2align, must be between 0 and 30"); + tcc_error("invalid p2align, must be between 0 and 30"); n = 1 << n; tok1 = TOK_ASMDIR_align; } if (tok1 == TOK_ASMDIR_align || tok1 == TOK_ASMDIR_balign) { if (n < 0 || (n & (n-1)) != 0) - tcc_error(S, "alignment must be a positive power of two"); - offset = (S->tccgen_ind + n - 1) & -n; - size = offset - S->tccgen_ind; + tcc_error("alignment must be a positive power of two"); + offset = (ind + n - 1) & -n; + size = offset - ind; /* the section must have a compatible alignment */ if (sec->sh_addralign < n) sec->sh_addralign = n; @@ -518,47 +520,47 @@ static void asm_parse_directive(TCCState *S, int global) size = n; } v = 0; - if (S->tccpp_tok == ',') { - next(S); - v = asm_int_expr(S); + if (tok == ',') { + next(); + v = asm_int_expr(s1); } zero_pad: if (sec->sh_type != SHT_NOBITS) { - sec->data_offset = S->tccgen_ind; - ptr = section_ptr_add(S, sec, size); + sec->data_offset = ind; + ptr = section_ptr_add(sec, size); memset(ptr, v, size); } - S->tccgen_ind += size; + ind += size; break; case TOK_ASMDIR_quad: #ifdef TCC_TARGET_X86_64 size = 8; goto asm_data; #else - next(S); + next(); for(;;) { uint64_t vl; const char *p; - p = S->tccpp_tokc.str.data; - if (S->tccpp_tok != TOK_PPNUM) { + p = tokc.str.data; + if (tok != TOK_PPNUM) { error_constant: - tcc_error(S, "64 bit constant"); + tcc_error("64 bit constant"); } vl = strtoll(p, (char **)&p, 0); if (*p != '\0') goto error_constant; - next(S); + next(); if (sec->sh_type != SHT_NOBITS) { /* XXX: endianness */ - gen_le32(S, vl); - gen_le32(S, vl >> 32); + gen_le32(vl); + gen_le32(vl >> 32); } else { - S->tccgen_ind += 8; + ind += 8; } - if (S->tccpp_tok != ',') + if (tok != ',') break; - next(S); + next(); } break; #endif @@ -573,57 +575,57 @@ static void asm_parse_directive(TCCState *S, int global) case TOK_ASMDIR_int: size = 4; asm_data: - next(S); + next(); for(;;) { ExprValue e; - asm_expr(S, &e); + asm_expr(s1, &e); if (sec->sh_type != SHT_NOBITS) { if (size == 4) { - gen_expr32(S, &e); + gen_expr32(&e); #ifdef TCC_TARGET_X86_64 } else if (size == 8) { - gen_expr64(S, &e); + gen_expr64(&e); #endif } else { if (e.sym) - expect(S, "constant"); + expect("constant"); if (size == 1) - g(S, e.v); + g(e.v); else - gen_le16(S, e.v); + gen_le16(e.v); } } else { - S->tccgen_ind += size; + ind += size; } - if (S->tccpp_tok != ',') + if (tok != ',') break; - next(S); + next(); } break; case TOK_ASMDIR_fill: { int repeat, size, val, i, j; uint8_t repeat_buf[8]; - next(S); - repeat = asm_int_expr(S); + next(); + repeat = asm_int_expr(s1); if (repeat < 0) { - tcc_error(S, "repeat < 0; .fill ignored"); + tcc_error("repeat < 0; .fill ignored"); break; } size = 1; val = 0; - if (S->tccpp_tok == ',') { - next(S); - size = asm_int_expr(S); + if (tok == ',') { + next(); + size = asm_int_expr(s1); if (size < 0) { - tcc_error(S, "size < 0; .fill ignored"); + tcc_error("size < 0; .fill ignored"); break; } if (size > 8) size = 8; - if (S->tccpp_tok == ',') { - next(S); - val = asm_int_expr(S); + if (tok == ',') { + next(); + val = asm_int_expr(s1); } } /* XXX: endianness */ @@ -637,7 +639,7 @@ static void asm_parse_directive(TCCState *S, int global) repeat_buf[7] = 0; for(i = 0; i < repeat; i++) { for(j = 0; j < size; j++) { - g(S, repeat_buf[j]); + g(repeat_buf[j]); } } } @@ -646,24 +648,24 @@ static void asm_parse_directive(TCCState *S, int global) { int repeat; TokenString *init_str; - next(S); - repeat = asm_int_expr(S); - init_str = tok_str_alloc(S); - while (next(S), S->tccpp_tok != TOK_ASMDIR_endr) { - if (S->tccpp_tok == CH_EOF) - tcc_error(S, "we at end of file, .endr not found"); - tok_str_add_tok(S, init_str); + next(); + repeat = asm_int_expr(s1); + init_str = tok_str_alloc(); + while (next(), tok != TOK_ASMDIR_endr) { + if (tok == CH_EOF) + tcc_error("we at end of file, .endr not found"); + tok_str_add_tok(init_str); } - tok_str_add(S, init_str, -1); - tok_str_add(S, init_str, 0); - begin_macro(S, init_str, 1); + tok_str_add(init_str, -1); + tok_str_add(init_str, 0); + begin_macro(init_str, 1); while (repeat-- > 0) { - tcc_assemble_internal(S, (S->tccpp_parse_flags & PARSE_FLAG_PREPROCESS), + tcc_assemble_internal(s1, (parse_flags & PARSE_FLAG_PREPROCESS), global); - S->tccpp_macro_ptr = init_str->str; + macro_ptr = init_str->str; } - end_macro(S); - next(S); + end_macro(); + next(); break; } case TOK_ASMDIR_org: @@ -671,49 +673,49 @@ static void asm_parse_directive(TCCState *S, int global) unsigned long n; ExprValue e; ElfSym *esym; - next(S); - asm_expr(S, &e); + next(); + asm_expr(s1, &e); n = e.v; - esym = elfsym(S, e.sym); + esym = elfsym(e.sym); if (esym) { if (esym->st_shndx != cur_text_section->sh_num) - expect(S, "constant or same-section symbol"); + expect("constant or same-section symbol"); n += esym->st_value; } - if (n < S->tccgen_ind) - tcc_error(S, "attempt to .org backwards"); + if (n < ind) + tcc_error("attempt to .org backwards"); v = 0; - size = n - S->tccgen_ind; + size = n - ind; goto zero_pad; } break; case TOK_ASMDIR_set: - next(S); - tok1 = S->tccpp_tok; - next(S); + next(); + tok1 = tok; + next(); /* Also accept '.set stuff', but don't do anything with this. It's used in GAS to set various features like '.set mips16'. */ - if (S->tccpp_tok == ',') - set_symbol(S, tok1); + if (tok == ',') + set_symbol(s1, tok1); break; case TOK_ASMDIR_globl: case TOK_ASMDIR_global: case TOK_ASMDIR_weak: case TOK_ASMDIR_hidden: - tok1 = S->tccpp_tok; + tok1 = tok; do { Sym *sym; - next(S); - sym = get_asm_sym(S, S->tccpp_tok, NULL); + next(); + sym = get_asm_sym(tok, NULL); if (tok1 != TOK_ASMDIR_hidden) sym->type.t &= ~VT_STATIC; if (tok1 == TOK_ASMDIR_weak) sym->a.weak = 1; else if (tok1 == TOK_ASMDIR_hidden) sym->a.visibility = STV_HIDDEN; - update_storage(S, sym); - next(S); - } while (S->tccpp_tok == ','); + update_storage(sym); + next(); + } while (tok == ','); break; case TOK_ASMDIR_string: case TOK_ASMDIR_ascii: @@ -722,21 +724,21 @@ static void asm_parse_directive(TCCState *S, int global) const uint8_t *p; int i, size, t; - t = S->tccpp_tok; - next(S); + t = tok; + next(); for(;;) { - if (S->tccpp_tok != TOK_STR) - expect(S, "string constant"); - p = S->tccpp_tokc.str.data; - size = S->tccpp_tokc.str.size; + if (tok != TOK_STR) + expect("string constant"); + p = tokc.str.data; + size = tokc.str.size; if (t == TOK_ASMDIR_ascii && size > 0) size--; for(i = 0; i < size; i++) - g(S, p[i]); - next(S); - if (S->tccpp_tok == ',') { - next(S); - } else if (S->tccpp_tok != TOK_STR) { + g(p[i]); + next(); + if (tok == ',') { + next(); + } else if (tok != TOK_STR) { break; } } @@ -747,18 +749,18 @@ static void asm_parse_directive(TCCState *S, int global) case TOK_ASMDIR_bss: { char sname[64]; - tok1 = S->tccpp_tok; + tok1 = tok; n = 0; - next(S); - if (S->tccpp_tok != ';' && S->tccpp_tok != TOK_LINEFEED) { - n = asm_int_expr(S); - next(S); + next(); + if (tok != ';' && tok != TOK_LINEFEED) { + n = asm_int_expr(s1); + next(); } if (n) - sprintf(sname, "%s%d", get_tok_str(S, tok1, NULL), n); + sprintf(sname, "%s%d", get_tok_str(tok1, NULL), n); else - sprintf(sname, "%s", get_tok_str(S, tok1, NULL)); - use_section(S, sname); + sprintf(sname, "%s", get_tok_str(tok1, NULL)); + use_section(s1, sname); } break; case TOK_ASMDIR_file: @@ -766,13 +768,13 @@ static void asm_parse_directive(TCCState *S, int global) char filename[512]; filename[0] = '\0'; - next(S); - if (S->tccpp_tok == TOK_STR) - pstrcat(filename, sizeof(filename), S->tccpp_tokc.str.data); + next(); + if (tok == TOK_STR) + pstrcat(filename, sizeof(filename), tokc.str.data); else - pstrcat(filename, sizeof(filename), get_tok_str(S, S->tccpp_tok, NULL)); - tcc_warning_c(warn_unsupported)(S, "ignoring .file %s", filename); - next(S); + pstrcat(filename, sizeof(filename), get_tok_str(tok, NULL)); + tcc_warning_c(warn_unsupported)("ignoring .file %s", filename); + next(); } break; case TOK_ASMDIR_ident: @@ -780,30 +782,30 @@ static void asm_parse_directive(TCCState *S, int global) char ident[256]; ident[0] = '\0'; - next(S); - if (S->tccpp_tok == TOK_STR) - pstrcat(ident, sizeof(ident), S->tccpp_tokc.str.data); + next(); + if (tok == TOK_STR) + pstrcat(ident, sizeof(ident), tokc.str.data); else - pstrcat(ident, sizeof(ident), get_tok_str(S, S->tccpp_tok, NULL)); - tcc_warning_c(warn_unsupported)(S, "ignoring .ident %s", ident); - next(S); + pstrcat(ident, sizeof(ident), get_tok_str(tok, NULL)); + tcc_warning_c(warn_unsupported)("ignoring .ident %s", ident); + next(); } break; case TOK_ASMDIR_size: { Sym *sym; - next(S); - sym = asm_label_find(S, S->tccpp_tok); + next(); + sym = asm_label_find(tok); if (!sym) { - tcc_error(S, "label not found: %s", get_tok_str(S, S->tccpp_tok, NULL)); + tcc_error("label not found: %s", get_tok_str(tok, NULL)); } /* XXX .size name,label2-label1 */ - tcc_warning_c(warn_unsupported)(S, "ignoring .size %s,*", get_tok_str(S, S->tccpp_tok, NULL)); - next(S); - skip(S, ','); - while (S->tccpp_tok != TOK_LINEFEED && S->tccpp_tok != ';' && S->tccpp_tok != CH_EOF) { - next(S); + tcc_warning_c(warn_unsupported)("ignoring .size %s,*", get_tok_str(tok, NULL)); + next(); + skip(','); + while (tok != TOK_LINEFEED && tok != ';' && tok != CH_EOF) { + next(); } } break; @@ -812,182 +814,182 @@ static void asm_parse_directive(TCCState *S, int global) Sym *sym; const char *newtype; - next(S); - sym = get_asm_sym(S, S->tccpp_tok, NULL); - next(S); - skip(S, ','); - if (S->tccpp_tok == TOK_STR) { - newtype = S->tccpp_tokc.str.data; + next(); + sym = get_asm_sym(tok, NULL); + next(); + skip(','); + if (tok == TOK_STR) { + newtype = tokc.str.data; } else { - if (S->tccpp_tok == '@' || S->tccpp_tok == '%') - next(S); - newtype = get_tok_str(S, S->tccpp_tok, NULL); + if (tok == '@' || tok == '%') + next(); + newtype = get_tok_str(tok, NULL); } if (!strcmp(newtype, "function") || !strcmp(newtype, "STT_FUNC")) { sym->type.t = (sym->type.t & ~VT_BTYPE) | VT_FUNC; } else - tcc_warning_c(warn_unsupported)(S, "change type of '%s' from 0x%x to '%s' ignored", - get_tok_str(S, sym->v, NULL), sym->type.t, newtype); + tcc_warning_c(warn_unsupported)("change type of '%s' from 0x%x to '%s' ignored", + get_tok_str(sym->v, NULL), sym->type.t, newtype); - next(S); + next(); } break; case TOK_ASMDIR_pushsection: case TOK_ASMDIR_section: { char sname[256]; - int old_nb_section = S->nb_sections; + int old_nb_section = s1->nb_sections; - tok1 = S->tccpp_tok; + tok1 = tok; /* XXX: support more options */ - next(S); + next(); sname[0] = '\0'; - while (S->tccpp_tok != ';' && S->tccpp_tok != TOK_LINEFEED && S->tccpp_tok != ',') { - if (S->tccpp_tok == TOK_STR) - pstrcat(sname, sizeof(sname), S->tccpp_tokc.str.data); + while (tok != ';' && tok != TOK_LINEFEED && tok != ',') { + if (tok == TOK_STR) + pstrcat(sname, sizeof(sname), tokc.str.data); else - pstrcat(sname, sizeof(sname), get_tok_str(S, S->tccpp_tok, NULL)); - next(S); + pstrcat(sname, sizeof(sname), get_tok_str(tok, NULL)); + next(); } - if (S->tccpp_tok == ',') { + if (tok == ',') { /* skip section options */ - next(S); - if (S->tccpp_tok != TOK_STR) - expect(S, "string constant"); - next(S); - if (S->tccpp_tok == ',') { - next(S); - if (S->tccpp_tok == '@' || S->tccpp_tok == '%') - next(S); - next(S); + next(); + if (tok != TOK_STR) + expect("string constant"); + next(); + if (tok == ',') { + next(); + if (tok == '@' || tok == '%') + next(); + next(); } } - S->tccasm_last_text_section = cur_text_section; + last_text_section = cur_text_section; if (tok1 == TOK_ASMDIR_section) - use_section(S, sname); + use_section(s1, sname); else - push_section(S, sname); + push_section(s1, sname); /* If we just allocated a new section reset its alignment to 1. new_section normally acts for GCC compatibility and sets alignment to PTR_SIZE. The assembler behaves different. */ - if (old_nb_section != S->nb_sections) + if (old_nb_section != s1->nb_sections) cur_text_section->sh_addralign = 1; } break; case TOK_ASMDIR_previous: { Section *sec; - next(S); - if (!S->tccasm_last_text_section) - tcc_error(S, "no previous section referenced"); + next(); + if (!last_text_section) + tcc_error("no previous section referenced"); sec = cur_text_section; - use_section1(S, S->tccasm_last_text_section); - S->tccasm_last_text_section = sec; + use_section1(s1, last_text_section); + last_text_section = sec; } break; case TOK_ASMDIR_popsection: - next(S); - pop_section(S); + next(); + pop_section(s1); break; #ifdef TCC_TARGET_I386 case TOK_ASMDIR_code16: { - next(S); - S->seg_size = 16; + next(); + s1->seg_size = 16; } break; case TOK_ASMDIR_code32: { - next(S); - S->seg_size = 32; + next(); + s1->seg_size = 32; } break; #endif #ifdef TCC_TARGET_X86_64 /* added for compatibility with GAS */ case TOK_ASMDIR_code64: - next(S); + next(); break; #endif default: - tcc_error(S, "unknown assembler directive '.%s'", get_tok_str(S, S->tccpp_tok, NULL)); + tcc_error("unknown assembler directive '.%s'", get_tok_str(tok, NULL)); break; } } /* assemble a file */ -static int tcc_assemble_internal(TCCState *S, int do_preprocess, int global) +static int tcc_assemble_internal(TCCState *s1, int do_preprocess, int global) { int opcode; - int saved_parse_flags = S->tccpp_parse_flags; + int saved_parse_flags = parse_flags; - S->tccpp_parse_flags = PARSE_FLAG_ASM_FILE | PARSE_FLAG_TOK_STR; + parse_flags = PARSE_FLAG_ASM_FILE | PARSE_FLAG_TOK_STR; if (do_preprocess) - S->tccpp_parse_flags |= PARSE_FLAG_PREPROCESS; + parse_flags |= PARSE_FLAG_PREPROCESS; for(;;) { - next(S); - if (S->tccpp_tok == TOK_EOF) + next(); + if (tok == TOK_EOF) break; - S->tccpp_parse_flags |= PARSE_FLAG_LINEFEED; /* XXX: suppress that hack */ + parse_flags |= PARSE_FLAG_LINEFEED; /* XXX: suppress that hack */ redo: - if (S->tccpp_tok == '#') { + if (tok == '#') { /* horrible gas comment */ - while (S->tccpp_tok != TOK_LINEFEED) - next(S); - } else if (S->tccpp_tok >= TOK_ASMDIR_FIRST && S->tccpp_tok <= TOK_ASMDIR_LAST) { - asm_parse_directive(S, global); - } else if (S->tccpp_tok == TOK_PPNUM) { + while (tok != TOK_LINEFEED) + next(); + } else if (tok >= TOK_ASMDIR_FIRST && tok <= TOK_ASMDIR_LAST) { + asm_parse_directive(s1, global); + } else if (tok == TOK_PPNUM) { const char *p; int n; - p = S->tccpp_tokc.str.data; + p = tokc.str.data; n = strtoul(p, (char **)&p, 10); if (*p != '\0') - expect(S, "':'"); + expect("':'"); /* new local label */ - asm_new_label(S, asm_get_local_label_name(S, n), 1); - next(S); - skip(S, ':'); + asm_new_label(s1, asm_get_local_label_name(s1, n), 1); + next(); + skip(':'); goto redo; - } else if (S->tccpp_tok >= TOK_IDENT) { + } else if (tok >= TOK_IDENT) { /* instruction or label */ - opcode = S->tccpp_tok; - next(S); - if (S->tccpp_tok == ':') { + opcode = tok; + next(); + if (tok == ':') { /* new label */ - asm_new_label(S, opcode, 0); - next(S); + asm_new_label(s1, opcode, 0); + next(); goto redo; - } else if (S->tccpp_tok == '=') { - set_symbol(S, opcode); + } else if (tok == '=') { + set_symbol(s1, opcode); goto redo; } else { - asm_opcode(S, opcode); + asm_opcode(s1, opcode); } } /* end of line */ - if (S->tccpp_tok != ';' && S->tccpp_tok != TOK_LINEFEED) - expect(S, "end of line"); - S->tccpp_parse_flags &= ~PARSE_FLAG_LINEFEED; /* XXX: suppress that hack */ + if (tok != ';' && tok != TOK_LINEFEED) + expect("end of line"); + parse_flags &= ~PARSE_FLAG_LINEFEED; /* XXX: suppress that hack */ } - S->tccpp_parse_flags = saved_parse_flags; + parse_flags = saved_parse_flags; return 0; } /* Assemble the current file */ -ST_FUNC int tcc_assemble(TCCState *S, int do_preprocess) +ST_FUNC int tcc_assemble(TCCState *s1, int do_preprocess) { int ret; - tcc_debug_start(S); + tcc_debug_start(s1); /* default section is text */ cur_text_section = text_section; - S->tccgen_ind = cur_text_section->data_offset; - S->tccgen_nocode_wanted = 0; - ret = tcc_assemble_internal(S, do_preprocess, 1); - cur_text_section->data_offset = S->tccgen_ind; - tcc_debug_end(S); + ind = cur_text_section->data_offset; + nocode_wanted = 0; + ret = tcc_assemble_internal(s1, do_preprocess, 1); + cur_text_section->data_offset = ind; + tcc_debug_end(s1); return ret; } @@ -997,27 +999,27 @@ ST_FUNC int tcc_assemble(TCCState *S, int do_preprocess) /* assemble the string 'str' in the current C compilation unit without C preprocessing. NOTE: str is modified by modifying the '\0' at the end */ -static void tcc_assemble_inline(TCCState *S, char *str, int len, int global) +static void tcc_assemble_inline(TCCState *s1, char *str, int len, int global) { - const int *saved_macro_ptr = S->tccpp_macro_ptr; - int dotid = set_idnum(S, '.', IS_ID); - int dolid = set_idnum(S, '$', 0); - - tcc_open_bf(S, ":asm:", len); - memcpy(S->tccpp_file->buffer, str, len); - S->tccpp_macro_ptr = NULL; - tcc_assemble_internal(S, 0, global); - tcc_close(S); - - set_idnum(S, '$', dolid); - set_idnum(S, '.', dotid); - S->tccpp_macro_ptr = saved_macro_ptr; + const int *saved_macro_ptr = macro_ptr; + int dotid = set_idnum('.', IS_ID); + int dolid = set_idnum('$', 0); + + tcc_open_bf(s1, ":asm:", len); + memcpy(file->buffer, str, len); + macro_ptr = NULL; + tcc_assemble_internal(s1, 0, global); + tcc_close(); + + set_idnum('$', dolid); + set_idnum('.', dotid); + macro_ptr = saved_macro_ptr; } /* find a constraint by its number or id (gcc 3 extended syntax). return -1 if not found. Return in *pp in char after the constraint */ -ST_FUNC int find_constraint(TCCState* S, ASMOperand *operands, int nb_operands, +ST_FUNC int find_constraint(ASMOperand *operands, int nb_operands, const char *name, const char **pp) { int index; @@ -1036,7 +1038,7 @@ ST_FUNC int find_constraint(TCCState* S, ASMOperand *operands, int nb_operands, name++; p = strchr(name, ']'); if (p) { - ts = tok_alloc(S, name, p - name); + ts = tok_alloc(name, p - name); for(index = 0; index < nb_operands; index++) { if (operands[index].id == ts->tok) goto found; @@ -1055,7 +1057,7 @@ ST_FUNC int find_constraint(TCCState* S, ASMOperand *operands, int nb_operands, return index; } -static void subst_asm_operands(TCCState* S, ASMOperand *operands, int nb_operands, +static void subst_asm_operands(ASMOperand *operands, int nb_operands, CString *out_str, CString *in_str) { int c, index, modifier; @@ -1063,7 +1065,7 @@ static void subst_asm_operands(TCCState* S, ASMOperand *operands, int nb_operand ASMOperand *op; SValue sv; - cstr_new(S, out_str); + cstr_new(out_str); str = in_str->data; for(;;) { c = *str++; @@ -1080,9 +1082,9 @@ static void subst_asm_operands(TCCState* S, ASMOperand *operands, int nb_operand and make literal operands not be decorated with '$'. */ *str == 'P') modifier = *str++; - index = find_constraint(S, operands, nb_operands, str, &str); + index = find_constraint(operands, nb_operands, str, &str); if (index < 0) - tcc_error(S, "invalid operand reference after %%"); + tcc_error("invalid operand reference after %%"); op = &operands[index]; sv = *op->vt; if (op->reg >= 0) { @@ -1090,10 +1092,10 @@ static void subst_asm_operands(TCCState* S, ASMOperand *operands, int nb_operand if ((op->vt->r & VT_VALMASK) == VT_LLOCAL && op->is_memory) sv.r |= VT_LVAL; } - subst_asm_operand(S, out_str, &sv, modifier); + subst_asm_operand(out_str, &sv, modifier); } else { add_char: - cstr_ccat(S, out_str, c); + cstr_ccat(out_str, c); if (c == '\0') break; } @@ -1101,53 +1103,53 @@ static void subst_asm_operands(TCCState* S, ASMOperand *operands, int nb_operand } -static void parse_asm_operands(TCCState* S, ASMOperand *operands, int *nb_operands_ptr, +static void parse_asm_operands(ASMOperand *operands, int *nb_operands_ptr, int is_output) { ASMOperand *op; int nb_operands; - if (S->tccpp_tok != ':') { + if (tok != ':') { nb_operands = *nb_operands_ptr; for(;;) { CString astr; if (nb_operands >= MAX_ASM_OPERANDS) - tcc_error(S, "too many asm operands"); + tcc_error("too many asm operands"); op = &operands[nb_operands++]; op->id = 0; - if (S->tccpp_tok == '[') { - next(S); - if (S->tccpp_tok < TOK_IDENT) - expect(S, "identifier"); - op->id = S->tccpp_tok; - next(S); - skip(S, ']'); + if (tok == '[') { + next(); + if (tok < TOK_IDENT) + expect("identifier"); + op->id = tok; + next(); + skip(']'); } - parse_mult_str(S, &astr, "string constant"); - op->constraint = tcc_malloc(S, astr.size); + parse_mult_str(&astr, "string constant"); + op->constraint = tcc_malloc(astr.size); strcpy(op->constraint, astr.data); - cstr_free(S, &astr); - skip(S, '('); - gexpr(S); + cstr_free(&astr); + skip('('); + gexpr(); if (is_output) { - if (!(S->tccgen_vtop->type.t & VT_ARRAY)) - test_lvalue(S); + if (!(vtop->type.t & VT_ARRAY)) + test_lvalue(); } else { /* we want to avoid LLOCAL case, except when the 'm' constraint is used. Note that it may come from register storage, so we need to convert (reg) case */ - if ((S->tccgen_vtop->r & VT_LVAL) && - ((S->tccgen_vtop->r & VT_VALMASK) == VT_LLOCAL || - (S->tccgen_vtop->r & VT_VALMASK) < VT_CONST) && + if ((vtop->r & VT_LVAL) && + ((vtop->r & VT_VALMASK) == VT_LLOCAL || + (vtop->r & VT_VALMASK) < VT_CONST) && !strchr(op->constraint, 'm')) { - gv(S, RC_INT); + gv(RC_INT); } } - op->vt = S->tccgen_vtop; - skip(S, ')'); - if (S->tccpp_tok == ',') { - next(S); + op->vt = vtop; + skip(')'); + if (tok == ',') { + next(); } else { break; } @@ -1157,7 +1159,7 @@ static void parse_asm_operands(TCCState* S, ASMOperand *operands, int *nb_operan } /* parse the GCC asm() instruction */ -ST_FUNC void asm_instr(TCCState* S) +ST_FUNC void asm_instr(void) { CString astr, astr1; ASMOperand operands[MAX_ASM_OPERANDS]; @@ -1167,36 +1169,36 @@ ST_FUNC void asm_instr(TCCState* S) /* since we always generate the asm() instruction, we can ignore volatile */ - if (S->tccpp_tok == TOK_VOLATILE1 || S->tccpp_tok == TOK_VOLATILE2 || S->tccpp_tok == TOK_VOLATILE3) { - next(S); + if (tok == TOK_VOLATILE1 || tok == TOK_VOLATILE2 || tok == TOK_VOLATILE3) { + next(); } - parse_asm_str(S, &astr); + parse_asm_str(&astr); nb_operands = 0; nb_outputs = 0; must_subst = 0; memset(clobber_regs, 0, sizeof(clobber_regs)); - if (S->tccpp_tok == ':') { - next(S); + if (tok == ':') { + next(); must_subst = 1; /* output args */ - parse_asm_operands(S, operands, &nb_operands, 1); + parse_asm_operands(operands, &nb_operands, 1); nb_outputs = nb_operands; - if (S->tccpp_tok == ':') { - next(S); - if (S->tccpp_tok != ')') { + if (tok == ':') { + next(); + if (tok != ')') { /* input args */ - parse_asm_operands(S, operands, &nb_operands, 0); - if (S->tccpp_tok == ':') { + parse_asm_operands(operands, &nb_operands, 0); + if (tok == ':') { /* clobber list */ /* XXX: handle registers */ - next(S); + next(); for(;;) { - if (S->tccpp_tok != TOK_STR) - expect(S, "string constant"); - asm_clobber(S, clobber_regs, S->tccpp_tokc.str.data); - next(S); - if (S->tccpp_tok == ',') { - next(S); + if (tok != TOK_STR) + expect("string constant"); + asm_clobber(clobber_regs, tokc.str.data); + next(); + if (tok == ',') { + next(); } else { break; } @@ -1205,17 +1207,17 @@ ST_FUNC void asm_instr(TCCState* S) } } } - skip(S, ')'); + skip(')'); /* NOTE: we do not eat the ';' so that we can restore the current token after the assembler parsing */ - if (S->tccpp_tok != ';') - expect(S, "';'"); + if (tok != ';') + expect("';'"); /* save all values in the memory */ - save_regs(S, 0); + save_regs(0); /* compute constraints */ - asm_compute_constraints(S, operands, nb_operands, nb_outputs, + asm_compute_constraints(operands, nb_operands, nb_outputs, clobber_regs, &out_reg); /* substitute the operands in the asm string. No substitution is @@ -1224,8 +1226,8 @@ ST_FUNC void asm_instr(TCCState* S) printf("asm: \"%s\"\n", (char *)astr.data); #endif if (must_subst) { - subst_asm_operands(S, operands, nb_operands, &astr1, &astr); - cstr_free(S, &astr); + subst_asm_operands(operands, nb_operands, &astr1, &astr); + cstr_free(&astr); } else { astr1 = astr; } @@ -1234,83 +1236,83 @@ ST_FUNC void asm_instr(TCCState* S) #endif /* generate loads */ - asm_gen_code(S, operands, nb_operands, nb_outputs, 0, + asm_gen_code(operands, nb_operands, nb_outputs, 0, clobber_regs, out_reg); /* We don't allow switching section within inline asm to bleed out to surrounding code. */ sec = cur_text_section; /* assemble the string with tcc internal assembler */ - tcc_assemble_inline(S, astr1.data, astr1.size - 1, 0); + tcc_assemble_inline(tcc_state, astr1.data, astr1.size - 1, 0); if (sec != cur_text_section) { - tcc_warning(S, "inline asm tries to change current section"); - use_section1(S, sec); + tcc_warning("inline asm tries to change current section"); + use_section1(tcc_state, sec); } /* restore the current C token */ - next(S); + next(); /* store the output values if needed */ - asm_gen_code(S, operands, nb_operands, nb_outputs, 1, + asm_gen_code(operands, nb_operands, nb_outputs, 1, clobber_regs, out_reg); /* free everything */ for(i=0;i<nb_operands;i++) { ASMOperand *op; op = &operands[i]; - tcc_free(S, op->constraint); - vpop(S); + tcc_free(op->constraint); + vpop(); } - cstr_free(S, &astr1); + cstr_free(&astr1); } -ST_FUNC void asm_global_instr(TCCState* S) +ST_FUNC void asm_global_instr(void) { CString astr; - int saved_nocode_wanted = S->tccgen_nocode_wanted; + int saved_nocode_wanted = nocode_wanted; /* Global asm blocks are always emitted. */ - S->tccgen_nocode_wanted = 0; - next(S); - parse_asm_str(S, &astr); - skip(S, ')'); + nocode_wanted = 0; + next(); + parse_asm_str(&astr); + skip(')'); /* NOTE: we do not eat the ';' so that we can restore the current token after the assembler parsing */ - if (S->tccpp_tok != ';') - expect(S, "';'"); + if (tok != ';') + expect("';'"); #ifdef ASM_DEBUG printf("asm_global: \"%s\"\n", (char *)astr.data); #endif cur_text_section = text_section; - S->tccgen_ind = cur_text_section->data_offset; + ind = cur_text_section->data_offset; /* assemble the string with tcc internal assembler */ - tcc_assemble_inline(S, astr.data, astr.size - 1, 1); + tcc_assemble_inline(tcc_state, astr.data, astr.size - 1, 1); - cur_text_section->data_offset = S->tccgen_ind; + cur_text_section->data_offset = ind; /* restore the current C token */ - next(S); + next(); - cstr_free(S, &astr); - S->tccgen_nocode_wanted = saved_nocode_wanted; + cstr_free(&astr); + nocode_wanted = saved_nocode_wanted; } /********************************************************/ #else -ST_FUNC int tcc_assemble(TCCState *S, int do_preprocess) +ST_FUNC int tcc_assemble(TCCState *s1, int do_preprocess) { - tcc_error(S, "asm not supported"); + tcc_error("asm not supported"); } -ST_FUNC void asm_instr(S) +ST_FUNC void asm_instr(void) { - tcc_error(S, "inline asm() not supported"); + tcc_error("inline asm() not supported"); } -ST_FUNC void asm_global_instr(S) +ST_FUNC void asm_global_instr(void) { - tcc_error(S, "inline asm() not supported"); + tcc_error("inline asm() not supported"); } #endif /* CONFIG_TCC_ASM */ |