From d6b64e2574bb4bc3c19e472b83073ff4d8786df2 Mon Sep 17 00:00:00 2001 From: gus knight Date: Mon, 27 Jul 2015 14:14:41 -0400 Subject: [PATCH] Clean up lots of rogue tabs. Still some more tabs to be taken care of. arm-gen.c and tcccoff.c have so many style issues that I'm just going to throw clang-format at them. --- c67-gen.c | 38 +++---- coff.h | 2 +- libtcc.c | 18 ++-- tccasm.c | 34 +++--- tccelf.c | 280 ++++++++++++++++++++++++------------------------- tccgen.c | 338 +++++++++++++++++++++++++++++------------------------------ tccpe.c | 48 ++++----- tccpp.c | 8 +- tccrun.c | 18 ++-- x86_64-gen.c | 71 +++++++------ 10 files changed, 427 insertions(+), 428 deletions(-) diff --git a/c67-gen.c b/c67-gen.c index a5ec0883..88bfbb43 100644 --- a/c67-gen.c +++ b/c67-gen.c @@ -30,13 +30,13 @@ typedef int RegArgs; /* a register can belong to several classes. The classes must be sorted from more general to more precise (see gv2() code which does assumptions on it). */ -#define RC_INT 0x0001 /* generic integer register */ -#define RC_FLOAT 0x0002 /* generic float register */ +#define RC_INT 0x0001 /* generic integer register */ +#define RC_FLOAT 0x0002 /* generic float register */ #define RC_EAX 0x0004 #define RC_ST0 0x0008 #define RC_ECX 0x0010 #define RC_EDX 0x0020 -#define RC_INT_BSIDE 0x00000040 /* generic integer register on b side */ +#define RC_INT_BSIDE 0x00000040 /* generic integer register on b side */ #define RC_C67_A4 0x00000100 #define RC_C67_A5 0x00000200 #define RC_C67_B4 0x00000400 @@ -204,7 +204,7 @@ void C67_g(int c) #endif ind1 = ind + 4; if (ind1 > (int) cur_text_section->data_allocated) - section_realloc(cur_text_section, ind1); + section_realloc(cur_text_section, ind1); cur_text_section->data[ind] = c & 0xff; cur_text_section->data[ind + 1] = (c >> 8) & 0xff; cur_text_section->data[ind + 2] = (c >> 16) & 0xff; @@ -218,26 +218,26 @@ void gsym_addr(int t, int a) { int n, *ptr; while (t) { - ptr = (int *) (cur_text_section->data + t); - { - Sym *sym; + ptr = (int *) (cur_text_section->data + t); + { + Sym *sym; - // extract 32 bit address from MVKH/MVKL - n = ((*ptr >> 7) & 0xffff); - n |= ((*(ptr + 1) >> 7) & 0xffff) << 16; + // extract 32 bit address from MVKH/MVKL + n = ((*ptr >> 7) & 0xffff); + n |= ((*(ptr + 1) >> 7) & 0xffff) << 16; - // define a label that will be relocated + // define a label that will be relocated - sym = get_sym_ref(&char_pointer_type, cur_text_section, a, 0); - greloc(cur_text_section, sym, t, R_C60LO16); - greloc(cur_text_section, sym, t + 4, R_C60HI16); + sym = get_sym_ref(&char_pointer_type, cur_text_section, a, 0); + greloc(cur_text_section, sym, t, R_C60LO16); + greloc(cur_text_section, sym, t + 4, R_C60HI16); - // clear out where the pointer was + // clear out where the pointer was - *ptr &= ~(0xffff << 7); - *(ptr + 1) &= ~(0xffff << 7); - } - t = n; + *ptr &= ~(0xffff << 7); + *(ptr + 1) &= ~(0xffff << 7); + } + t = n; } } diff --git a/coff.h b/coff.h index b46701a0..63edfe28 100644 --- a/coff.h +++ b/coff.h @@ -370,7 +370,7 @@ struct syment #define INCREF_COFF(x) ((((x)&~N_BTMASK_COFF)<>N_TSHIFT_COFF)&~N_BTMASK_COFF)|((x)&N_BTMASK_COFF)) - + /*------------------------------------------------------------------------*/ /* AUXILIARY SYMBOL ENTRY */ /*------------------------------------------------------------------------*/ diff --git a/libtcc.c b/libtcc.c index 0537230b..f4f01c26 100644 --- a/libtcc.c +++ b/libtcc.c @@ -672,7 +672,7 @@ ST_FUNC void put_extern_sym2(Sym *sym, Section *section, } #else if (! (sym->type.t & VT_STATIC)) - other = (sym->type.t & VT_VIS_MASK) >> VT_VIS_SHIFT; + other = (sym->type.t & VT_VIS_MASK) >> VT_VIS_SHIFT; #endif if (tcc_state->leading_underscore && can_add_underscore) { buf1[0] = '_'; @@ -2101,11 +2101,11 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int argc, char **argv) s->static_link = 1; break; case TCC_OPTION_std: - /* silently ignore, a current purpose: - allow to use a tcc as a reference compiler for "make test" */ + /* silently ignore, a current purpose: + allow to use a tcc as a reference compiler for "make test" */ break; case TCC_OPTION_shared: - if (s->output_type) + if (s->output_type) tcc_warning("-shared: some compiler action already specified (%d)", s->output_type); s->output_type = TCC_OUTPUT_DLL; break; @@ -2124,7 +2124,7 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int argc, char **argv) break; case TCC_OPTION_r: /* generate a .o merging several output files */ - if (s->output_type) + if (s->output_type) tcc_warning("-r: some compiler action already specified (%d)", s->output_type); s->option_r = 1; s->output_type = TCC_OUTPUT_OBJ; @@ -2163,7 +2163,7 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int argc, char **argv) s->print_search_dirs = 1; break; case TCC_OPTION_run: - if (s->output_type) + if (s->output_type) tcc_warning("-run: some compiler action already specified (%d)", s->output_type); s->output_type = TCC_OUTPUT_MEMORY; tcc_set_options(s, optarg); @@ -2194,7 +2194,7 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int argc, char **argv) cstr_ccat(&linker_arg, '\0'); break; case TCC_OPTION_E: - if (s->output_type) + if (s->output_type) tcc_warning("-E: some compiler action already specified (%d)", s->output_type); s->output_type = TCC_OUTPUT_PREPROCESS; break; @@ -2251,13 +2251,13 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int argc, char **argv) } if (s->output_type == 0) - s->output_type = TCC_OUTPUT_EXE; + s->output_type = TCC_OUTPUT_EXE; if (pthread && s->output_type != TCC_OUTPUT_OBJ) tcc_set_options(s, "-lpthread"); if (s->output_type == TCC_OUTPUT_EXE) - tcc_set_linker(s, (const char *)linker_arg.data); + tcc_set_linker(s, (const char *)linker_arg.data); cstr_free(&linker_arg); return optind; diff --git a/tccasm.c b/tccasm.c index 9964ec9e..b184c88a 100644 --- a/tccasm.c +++ b/tccasm.c @@ -92,10 +92,10 @@ static void asm_expr_unary(TCCState *s1, ExprValue *pe) break; case TOK_CCHAR: case TOK_LCHAR: - pe->v = tokc.i; - pe->sym = NULL; - next(); - break; + pe->v = tokc.i; + pe->sym = NULL; + next(); + break; case '(': next(); asm_expr(s1, pe); @@ -493,7 +493,7 @@ static void asm_parse_directive(TCCState *s1) case TOK_ASM_weak: case TOK_ASM_hidden: tok1 = tok; - do { + do { Sym *sym; next(); @@ -502,15 +502,15 @@ static void asm_parse_directive(TCCState *s1) sym = label_push(&s1->asm_labels, tok, 0); sym->type.t = VT_VOID; } - if (tok1 != TOK_ASM_hidden) + if (tok1 != TOK_ASM_hidden) sym->type.t &= ~VT_STATIC; if (tok1 == TOK_ASM_weak) sym->type.t |= VT_WEAK; - else if (tok1 == TOK_ASM_hidden) - sym->type.t |= STV_HIDDEN << VT_VIS_SHIFT; + else if (tok1 == TOK_ASM_hidden) + sym->type.t |= STV_HIDDEN << VT_VIS_SHIFT; next(); - } while (tok == ','); - break; + } while (tok == ','); + break; case TOK_ASM_string: case TOK_ASM_ascii: case TOK_ASM_asciz: @@ -536,24 +536,24 @@ static void asm_parse_directive(TCCState *s1) break; } } - } - break; + } + break; case TOK_ASM_text: case TOK_ASM_data: case TOK_ASM_bss: - { + { char sname[64]; tok1 = tok; n = 0; next(); if (tok != ';' && tok != TOK_LINEFEED) { - n = asm_int_expr(s1); - next(); + n = asm_int_expr(s1); + next(); } sprintf(sname, (n?".%s%d":".%s"), get_tok_str(tok1, NULL), n); use_section(s1, sname); - } - break; + } + break; case TOK_ASM_file: { char filename[512]; diff --git a/tccelf.c b/tccelf.c index 5e68e93e..507b598b 100644 --- a/tccelf.c +++ b/tccelf.c @@ -451,7 +451,7 @@ ST_FUNC void relocate_syms(TCCState *s1, int do_resolve) if (addr) { sym->st_value = (addr_t)addr; #ifdef DEBUG_RELOC - printf ("relocate_sym: %s -> 0x%lx\n", name, sym->st_value); + printf ("relocate_sym: %s -> 0x%lx\n", name, sym->st_value); #endif goto found; } @@ -580,10 +580,10 @@ ST_FUNC void relocate_section(TCCState *s1, Section *s) { int x, is_thumb, is_call, h, blx_avail, is_bl, th_ko; x = (*(int *) ptr) & 0xffffff; - if (sym->st_shndx == SHN_UNDEF) - val = s1->plt->sh_addr; + if (sym->st_shndx == SHN_UNDEF) + val = s1->plt->sh_addr; #ifdef DEBUG_RELOC - printf ("reloc %d: x=0x%x val=0x%x ", type, x, val); + printf ("reloc %d: x=0x%x val=0x%x ", type, x, val); #endif (*(int *)ptr) &= 0xff000000; if (x & 0x800000) @@ -595,8 +595,8 @@ ST_FUNC void relocate_section(TCCState *s1, Section *s) is_call = (type == R_ARM_CALL || (type == R_ARM_PC24 && is_bl)); x += val - addr; #ifdef DEBUG_RELOC - printf (" newx=0x%x name=%s\n", x, - (char *) symtab_section->link->data + sym->st_name); + printf (" newx=0x%x name=%s\n", x, + (char *) symtab_section->link->data + sym->st_name); #endif h = x & 2; th_ko = (x & 3) && (!blx_avail || !is_call); @@ -797,21 +797,21 @@ ST_FUNC void relocate_section(TCCState *s1, Section *s) break; case R_AARCH64_JUMP26: case R_AARCH64_CALL26: - /* This check must match the one in build_got_entries, testing - if we really need a PLT slot. */ - if (sym->st_shndx == SHN_UNDEF) - /* We've put the PLT slot offset into r_addend when generating - it, and that's what we must use as relocation value (adjusted - by section offset of course). */ - val = s1->plt->sh_addr + rel->r_addend; + /* This check must match the one in build_got_entries, testing + if we really need a PLT slot. */ + if (sym->st_shndx == SHN_UNDEF) + /* We've put the PLT slot offset into r_addend when generating + it, and that's what we must use as relocation value (adjusted + by section offset of course). */ + val = s1->plt->sh_addr + rel->r_addend; #ifdef DEBUG_RELOC - printf ("reloc %d @ 0x%lx: val=0x%lx name=%s\n", type, addr, val, - (char *) symtab_section->link->data + sym->st_name); + printf ("reloc %d @ 0x%lx: val=0x%lx name=%s\n", type, addr, val, + (char *) symtab_section->link->data + sym->st_name); #endif if (((val - addr) + ((uint64_t)1 << 27)) & ~(uint64_t)0xffffffc) - { + { tcc_error("R_AARCH64_(JUMP|CALL)26 relocation failed (val=%lx, addr=%lx)", addr, val); - } + } *(uint32_t *)ptr = 0x14000000 | (type == R_AARCH64_CALL26) << 31 | ((val - addr) >> 2 & 0x3ffffff); break; @@ -836,9 +836,9 @@ ST_FUNC void relocate_section(TCCState *s1, Section *s) case R_AARCH64_JUMP_SLOT: /* They don't need addend */ #ifdef DEBUG_RELOC - printf ("reloc %d @ 0x%lx: val=0x%lx name=%s\n", type, addr, - val - rel->r_addend, - (char *) symtab_section->link->data + sym->st_name); + printf ("reloc %d @ 0x%lx: val=0x%lx name=%s\n", type, addr, + val - rel->r_addend, + (char *) symtab_section->link->data + sym->st_name); #endif *(addr_t *)ptr = val - rel->r_addend; break; @@ -879,12 +879,12 @@ ST_FUNC void relocate_section(TCCState *s1, Section *s) qrel->r_offset = rel->r_offset; if (esym_index) { qrel->r_info = ELFW(R_INFO)(esym_index, R_X86_64_64); - qrel->r_addend = rel->r_addend; + qrel->r_addend = rel->r_addend; qrel++; break; } else { - qrel->r_info = ELFW(R_INFO)(0, R_X86_64_RELATIVE); - qrel->r_addend = *(long long *)ptr + val; + qrel->r_info = ELFW(R_INFO)(0, R_X86_64_RELATIVE); + qrel->r_addend = *(long long *)ptr + val; qrel++; } } @@ -917,14 +917,14 @@ ST_FUNC void relocate_section(TCCState *s1, Section *s) goto plt32pc32; case R_X86_64_PLT32: - /* We've put the PLT slot offset into r_addend when generating - it, and that's what we must use as relocation value (adjusted - by section offset of course). */ - val = s1->plt->sh_addr + rel->r_addend; - /* fallthrough. */ - - plt32pc32: - { + /* We've put the PLT slot offset into r_addend when generating + it, and that's what we must use as relocation value (adjusted + by section offset of course). */ + val = s1->plt->sh_addr + rel->r_addend; + /* fallthrough. */ + + plt32pc32: + { long long diff; diff = (long long)val - addr; if (diff < -2147483648LL || diff > 2147483647LL) { @@ -1080,8 +1080,8 @@ static void build_got(TCCState *s1) and 'info' can be modifed if more precise info comes from the DLL. Returns offset of GOT or PLT slot. */ static unsigned long put_got_entry(TCCState *s1, - int reloc_type, unsigned long size, int info, - int sym_index) + int reloc_type, unsigned long size, int info, + int sym_index) { int index, need_plt_entry; const char *name; @@ -1107,18 +1107,18 @@ static unsigned long put_got_entry(TCCState *s1, #endif if (need_plt_entry && !s1->plt) { - /* add PLT */ - s1->plt = new_section(s1, ".plt", SHT_PROGBITS, - SHF_ALLOC | SHF_EXECINSTR); - s1->plt->sh_entsize = 4; + /* add PLT */ + s1->plt = new_section(s1, ".plt", SHT_PROGBITS, + SHF_ALLOC | SHF_EXECINSTR); + s1->plt->sh_entsize = 4; } /* If a got/plt entry already exists for that symbol, no need to add one */ if (sym_index < s1->nb_sym_attrs) { - if (need_plt_entry && s1->sym_attrs[sym_index].plt_offset) - return s1->sym_attrs[sym_index].plt_offset; - else if (!need_plt_entry && s1->sym_attrs[sym_index].got_offset) - return s1->sym_attrs[sym_index].got_offset; + if (need_plt_entry && s1->sym_attrs[sym_index].plt_offset) + return s1->sym_attrs[sym_index].plt_offset; + else if (!need_plt_entry && s1->sym_attrs[sym_index].got_offset) + return s1->sym_attrs[sym_index].got_offset; } symattr = alloc_sym_attr(s1, sym_index); @@ -1135,7 +1135,7 @@ static unsigned long put_got_entry(TCCState *s1, Section *plt; uint8_t *p; int modrm; - unsigned long relofs; + unsigned long relofs; #if defined(TCC_OUTPUT_DLL_WITH_PLT) modrm = 0x25; @@ -1160,10 +1160,10 @@ static unsigned long put_got_entry(TCCState *s1, put32(p + 8, PTR_SIZE * 2); } - /* The PLT slot refers to the relocation entry it needs - via offset. The reloc entry is created below, so its - offset is the current data_offset. */ - relofs = s1->got->reloc ? s1->got->reloc->data_offset : 0; + /* The PLT slot refers to the relocation entry it needs + via offset. The reloc entry is created below, so its + offset is the current data_offset. */ + relofs = s1->got->reloc ? s1->got->reloc->data_offset : 0; symattr->plt_offset = plt->data_offset; p = section_ptr_add(plt, 16); p[0] = 0xff; /* jmp *(got + x) */ @@ -1171,19 +1171,19 @@ static unsigned long put_got_entry(TCCState *s1, put32(p + 2, s1->got->data_offset); p[6] = 0x68; /* push $xxx */ #ifdef TCC_TARGET_X86_64 - /* On x86-64, the relocation is referred to by _index_. */ - put32(p + 7, relofs / sizeof (ElfW_Rel)); + /* On x86-64, the relocation is referred to by _index_. */ + put32(p + 7, relofs / sizeof (ElfW_Rel)); #else put32(p + 7, relofs); #endif p[11] = 0xe9; /* jmp plt_start */ put32(p + 12, -(plt->data_offset)); - /* If this was an UNDEF symbol set the offset in the - dynsymtab to the PLT slot, so that PC32 relocs to it - can be resolved. */ - if (sym->st_shndx == SHN_UNDEF) - offset = plt->data_offset - 16; + /* If this was an UNDEF symbol set the offset in the + dynsymtab to the PLT slot, so that PC32 relocs to it + can be resolved. */ + if (sym->st_shndx == SHN_UNDEF) + offset = plt->data_offset - 16; } #elif defined(TCC_TARGET_ARM) if (need_plt_entry) { @@ -1220,7 +1220,7 @@ static unsigned long put_got_entry(TCCState *s1, /* the symbol is modified so that it will be relocated to the PLT */ - if (sym->st_shndx == SHN_UNDEF) + if (sym->st_shndx == SHN_UNDEF) offset = plt->data_offset - 16; } #elif defined(TCC_TARGET_ARM64) @@ -1250,19 +1250,19 @@ static unsigned long put_got_entry(TCCState *s1, #error unsupported CPU #endif if (s1->dynsym) { - /* XXX This might generate multiple syms for name. */ + /* XXX This might generate multiple syms for name. */ index = put_elf_sym(s1->dynsym, offset, size, info, 0, sym->st_shndx, name); /* Create the relocation (it's against the GOT for PLT - and GOT relocs). */ + and GOT relocs). */ put_elf_reloc(s1->dynsym, s1->got, s1->got->data_offset, reloc_type, index); } else { - /* Without .dynsym (i.e. static link or memory output) we - still need relocs against the generated got, so as to fill - the entries with the symbol values (determined later). */ - put_elf_reloc(symtab_section, s1->got, + /* Without .dynsym (i.e. static link or memory output) we + still need relocs against the generated got, so as to fill + the entries with the symbol values (determined later). */ + put_elf_reloc(symtab_section, s1->got, s1->got->data_offset, reloc_type, sym_index); } @@ -1324,8 +1324,8 @@ ST_FUNC void build_got_entries(TCCState *s1) build_got(s1); sym_index = ELFW(R_SYM)(rel->r_info); sym = &((ElfW(Sym) *)symtab_section->data)[sym_index]; - if (type != R_ARM_GOTOFF && type != R_ARM_GOTPC - && sym->st_shndx == SHN_UNDEF) { + if (type != R_ARM_GOTOFF && type != R_ARM_GOTPC + && sym->st_shndx == SHN_UNDEF) { unsigned long ofs; /* look at the symbol got offset. If none, then add one */ if (type == R_ARM_GOT32) @@ -1333,27 +1333,27 @@ ST_FUNC void build_got_entries(TCCState *s1) else reloc_type = R_ARM_JUMP_SLOT; ofs = put_got_entry(s1, reloc_type, sym->st_size, - sym->st_info, sym_index); + sym->st_info, sym_index); #ifdef DEBUG_RELOC printf ("maybegot: %s, %d, %d --> ofs=0x%x\n", - (char *) symtab_section->link->data + sym->st_name, - type, sym->st_shndx, ofs); + (char *) symtab_section->link->data + sym->st_name, + type, sym->st_shndx, ofs); #endif - if (type != R_ARM_GOT32) { - addr_t *ptr = (addr_t*)(s1->sections[s->sh_info]->data - + rel->r_offset); - /* x must be signed! */ - int x = *ptr & 0xffffff; - x = (x << 8) >> 8; - x <<= 2; - x += ofs; - x >>= 2; + if (type != R_ARM_GOT32) { + addr_t *ptr = (addr_t*)(s1->sections[s->sh_info]->data + + rel->r_offset); + /* x must be signed! */ + int x = *ptr & 0xffffff; + x = (x << 8) >> 8; + x <<= 2; + x += ofs; + x >>= 2; #ifdef DEBUG_RELOC - printf ("insn=0x%x --> 0x%x (x==0x%x)\n", *ptr, - (*ptr & 0xff000000) | x, x); + printf ("insn=0x%x --> 0x%x (x==0x%x)\n", *ptr, + (*ptr & 0xff000000) | x, x); #endif - *ptr = (*ptr & 0xff000000) | x; - } + *ptr = (*ptr & 0xff000000) | x; + } } break; case R_ARM_THM_JUMP24: @@ -1397,22 +1397,22 @@ ST_FUNC void build_got_entries(TCCState *s1) sym_index); break; - case R_AARCH64_JUMP26: - case R_AARCH64_CALL26: + case R_AARCH64_JUMP26: + case R_AARCH64_CALL26: if (!s1->got) build_got(s1); sym_index = ELFW(R_SYM)(rel->r_info); sym = &((ElfW(Sym) *)symtab_section->data)[sym_index]; if (sym->st_shndx == SHN_UNDEF) { - unsigned long ofs; - reloc_type = R_AARCH64_JUMP_SLOT; + unsigned long ofs; + reloc_type = R_AARCH64_JUMP_SLOT; ofs = put_got_entry(s1, reloc_type, sym->st_size, - sym->st_info, sym_index); - /* We store the place of the generated PLT slot - in our addend. */ - rel->r_addend += ofs; + sym->st_info, sym_index); + /* We store the place of the generated PLT slot + in our addend. */ + rel->r_addend += ofs; } - break; + break; #elif defined(TCC_TARGET_C67) case R_C60_GOT32: case R_C60_GOTOFF: @@ -1439,29 +1439,29 @@ ST_FUNC void build_got_entries(TCCState *s1) case R_X86_64_PLT32: sym_index = ELFW(R_SYM)(rel->r_info); sym = &((ElfW(Sym) *)symtab_section->data)[sym_index]; - if (type == R_X86_64_PLT32 && - ELFW(ST_VISIBILITY)(sym->st_other) != STV_DEFAULT) - { - rel->r_info = ELFW(R_INFO)(sym_index, R_X86_64_PC32); - break; - } + if (type == R_X86_64_PLT32 && + ELFW(ST_VISIBILITY)(sym->st_other) != STV_DEFAULT) + { + rel->r_info = ELFW(R_INFO)(sym_index, R_X86_64_PC32); + break; + } if (!s1->got) build_got(s1); if (type == R_X86_64_GOT32 || type == R_X86_64_GOTPCREL || type == R_X86_64_PLT32) { - unsigned long ofs; + unsigned long ofs; /* look at the symbol got offset. If none, then add one */ if (type == R_X86_64_GOT32 || type == R_X86_64_GOTPCREL) reloc_type = R_X86_64_GLOB_DAT; else reloc_type = R_X86_64_JUMP_SLOT; ofs = put_got_entry(s1, reloc_type, sym->st_size, - sym->st_info, sym_index); - if (type == R_X86_64_PLT32) - /* We store the place of the generated PLT slot - in our addend. */ - rel->r_addend += ofs; + sym->st_info, sym_index); + if (type == R_X86_64_PLT32) + /* We store the place of the generated PLT slot + in our addend. */ + rel->r_addend += ofs; } break; #else @@ -1546,21 +1546,21 @@ static int tcc_add_support(TCCState *s1, const char *filename) snprintf(buf, sizeof(buf), "%s/%s/%s", s1->tcc_lib_path, /* an cpu specific path inside tcc_lib_path, mainly for keeping libtcc1.a */ #ifdef TCC_TARGET_I386 - "i386" + "i386" #endif #ifdef TCC_TARGET_X86_64 "x86-64" #endif #ifdef TCC_TARGET_ARM - "arm" + "arm" #endif #ifdef TCC_TARGET_ARM64 - "arm64" + "arm64" #endif #ifdef TCC_TARGET_C67 - "C67" + "C67" #endif - ,filename); + ,filename); return tcc_add_file(s1, buf, TCC_FILETYPE_BINARY); } @@ -1587,17 +1587,17 @@ ST_FUNC void tcc_add_bcheck(TCCState *s1) when __bound_ptr_add, __bound_new_region, __bound_delete_region called */ - int sym_index = find_elf_sym(symtab_section, "__bound_init"); - if (sym_index) { - Section *init_section = find_section(s1, ".init"); - unsigned char *pinit = section_ptr_add(init_section, 5); - pinit[0] = 0xe8; - put32(pinit + 1, -4); - put_elf_reloc(symtab_section, init_section, + int sym_index = find_elf_sym(symtab_section, "__bound_init"); + if (sym_index) { + Section *init_section = find_section(s1, ".init"); + unsigned char *pinit = section_ptr_add(init_section, 5); + pinit[0] = 0xe8; + put32(pinit + 1, -4); + put_elf_reloc(symtab_section, init_section, init_section->data_offset - 4, R_386_PC32, sym_index); - } - else - tcc_warning("__bound_init not defined"); + } + else + tcc_warning("__bound_init not defined"); } #endif } @@ -1905,11 +1905,11 @@ static void export_global_syms(TCCState *s1) s1->symtab_to_dynsym = tcc_mallocz(sizeof(int) * nb_syms); for_each_elem(symtab_section, 1, sym, ElfW(Sym)) { if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) { - name = (char *) symtab_section->link->data + sym->st_name; - dynindex = put_elf_sym(s1->dynsym, sym->st_value, sym->st_size, - sym->st_info, 0, sym->st_shndx, name); - index = sym - (ElfW(Sym) *) symtab_section->data; - s1->symtab_to_dynsym[index] = dynindex; + name = (char *) symtab_section->link->data + sym->st_name; + dynindex = put_elf_sym(s1->dynsym, sym->st_value, sym->st_size, + sym->st_info, 0, sym->st_shndx, name); + index = sym - (ElfW(Sym) *) symtab_section->data; + s1->symtab_to_dynsym[index] = dynindex; } } } @@ -2179,15 +2179,15 @@ static int layout_sections(TCCState *s1, ElfW(Phdr) *phdr, int phnum, file_offset += s->sh_size; } } - if (j == 0) { - /* Make the first PT_LOAD segment include the program - headers itself (and the ELF header as well), it'll - come out with same memory use but will make various - tools like binutils strip work better. */ - ph->p_offset &= ~(ph->p_align - 1); - ph->p_vaddr &= ~(ph->p_align - 1); - ph->p_paddr &= ~(ph->p_align - 1); - } + if (j == 0) { + /* Make the first PT_LOAD segment include the program + headers itself (and the ELF header as well), it'll + come out with same memory use but will make various + tools like binutils strip work better. */ + ph->p_offset &= ~(ph->p_align - 1); + ph->p_vaddr &= ~(ph->p_align - 1); + ph->p_paddr &= ~(ph->p_align - 1); + } ph->p_filesz = file_offset - ph->p_offset; ph->p_memsz = addr - ph->p_vaddr; ph++; @@ -2662,10 +2662,10 @@ static int elf_output_file(TCCState *s1, const char *filename) for_each_elem(s1->dynsym, 1, sym, ElfW(Sym)) { if (sym->st_shndx == SHN_UNDEF) { /* relocate to PLT if symbol corresponds to a PLT entry, - but not if it's a weak symbol */ - if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK) - sym->st_value = 0; - else if (sym->st_value) + but not if it's a weak symbol */ + if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK) + sym->st_value = 0; + else if (sym->st_value) sym->st_value += s1->plt->sh_addr; } else if (sym->st_shndx < SHN_LORESERVE) { /* do symbol relocation */ @@ -2690,14 +2690,14 @@ static int elf_output_file(TCCState *s1, const char *filename) /* Create the ELF file with name 'filename' */ ret = tcc_write_elf_file(s1, filename, phnum, phdr, file_offset, sec_order); if (s1->do_strip) { - int rc; - const char *strip_cmd = "sstrip "; // super strip utility from ELFkickers - const char *null_dev = " 2> /dev/null"; - char buf[1050]; - snprintf(buf, sizeof(buf), "%s%s%s", strip_cmd, filename, null_dev); - rc = system(buf); - if (rc) - system(buf+1); // call a strip utility from binutils + int rc; + const char *strip_cmd = "sstrip "; // super strip utility from ELFkickers + const char *null_dev = " 2> /dev/null"; + char buf[1050]; + snprintf(buf, sizeof(buf), "%s%s%s", strip_cmd, filename, null_dev); + rc = system(buf); + if (rc) + system(buf+1); // call a strip utility from binutils } the_end: tcc_free(s1->symtab_to_dynsym); diff --git a/tccgen.c b/tccgen.c index 9b5e49ff..cf97d1fa 100644 --- a/tccgen.c +++ b/tccgen.c @@ -323,7 +323,7 @@ static void apply_visibility(Sym *sym, CType *type) ElfW(Sym) *esym; esym = &((ElfW(Sym) *)symtab_section->data)[sym->c]; - vis >>= VT_VIS_SHIFT; + vis >>= VT_VIS_SHIFT; esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1)) | vis; } } @@ -1631,7 +1631,7 @@ static inline int is_null_pointer(SValue *p) return 0; return ((p->type.t & VT_BTYPE) == VT_INT && p->c.i == 0) || ((p->type.t & VT_BTYPE) == VT_LLONG && p->c.ll == 0) || - ((p->type.t & VT_BTYPE) == VT_PTR && p->c.ptr_offset == 0); + ((p->type.t & VT_BTYPE) == VT_PTR && p->c.ptr_offset == 0); } static inline int is_integer_btype(int bt) @@ -1761,18 +1761,18 @@ ST_FUNC void gen_op(int op) #if 0 /* #ifdef CONFIG_TCC_BCHECK The main reason to removing this code: - #include - int main () - { - int v[10]; - int i = 10; - int j = 9; - fprintf(stderr, "v+i-j = %p\n", v+i-j); - fprintf(stderr, "v+(i-j) = %p\n", v+(i-j)); - } + #include + int main () + { + int v[10]; + int i = 10; + int j = 9; + fprintf(stderr, "v+i-j = %p\n", v+i-j); + fprintf(stderr, "v+(i-j) = %p\n", v+(i-j)); + } When this code is on. then the output looks like - v+i-j = 0xfffffffe - v+(i-j) = 0xbff84000 + v+i-j = 0xfffffffe + v+(i-j) = 0xbff84000 */ /* if evaluating constant expression, no code should be generated, so no bound check */ @@ -2450,18 +2450,18 @@ static void gen_assign_cast(CType *dt) dbt = dt->t & VT_BTYPE; sbt = st->t & VT_BTYPE; if (sbt == VT_VOID || dbt == VT_VOID) { - if (sbt == VT_VOID && dbt == VT_VOID) - ; /* - It is Ok if both are void - A test program: - void func1() {} - void func2() { - return func1(); - } - gcc accepts this program - */ - else - tcc_error("cannot cast from/to void"); + if (sbt == VT_VOID && dbt == VT_VOID) + ; /* + It is Ok if both are void + A test program: + void func1() {} + void func2() { + return func1(); + } + gcc accepts this program + */ + else + tcc_error("cannot cast from/to void"); } if (dt->t & VT_CONSTANT) tcc_warning("assignment of read-only location"); @@ -2542,7 +2542,7 @@ ST_FUNC void vstore(void) dbt = ft & VT_BTYPE; if ((((sbt == VT_INT || sbt == VT_SHORT) && dbt == VT_BYTE) || (sbt == VT_INT && dbt == VT_SHORT)) - && !(vtop->type.t & VT_BITFIELD)) { + && !(vtop->type.t & VT_BITFIELD)) { /* optimize char/short casts */ delayed_cast = VT_MUSTCAST; vtop->type.t = ft & (VT_TYPE & ~(VT_BITFIELD | (-1 << VT_STRUCT_SHIFT))); @@ -2764,20 +2764,20 @@ static void parse_attribute(AttributeDef *ad) next(); skip(')'); break; - case TOK_VISIBILITY1: - case TOK_VISIBILITY2: + case TOK_VISIBILITY1: + case TOK_VISIBILITY2: skip('('); if (tok != TOK_STR) expect("visibility(\"default|hidden|internal|protected\")"); - if (!strcmp (tokc.cstr->data, "default")) - ad->a.visibility = STV_DEFAULT; - else if (!strcmp (tokc.cstr->data, "hidden")) - ad->a.visibility = STV_HIDDEN; - else if (!strcmp (tokc.cstr->data, "internal")) - ad->a.visibility = STV_INTERNAL; - else if (!strcmp (tokc.cstr->data, "protected")) - ad->a.visibility = STV_PROTECTED; - else + if (!strcmp (tokc.cstr->data, "default")) + ad->a.visibility = STV_DEFAULT; + else if (!strcmp (tokc.cstr->data, "hidden")) + ad->a.visibility = STV_HIDDEN; + else if (!strcmp (tokc.cstr->data, "internal")) + ad->a.visibility = STV_INTERNAL; + else if (!strcmp (tokc.cstr->data, "protected")) + ad->a.visibility = STV_PROTECTED; + else expect("visibility(\"default|hidden|internal|protected\")"); next(); skip(')'); @@ -2973,8 +2973,8 @@ static void struct_decl(CType *type, int u, int tdef) while (tok != '}') { parse_btype(&btype, &ad); while (1) { - if (flexible) - tcc_error("flexible array member '%s' not at the end of struct", + if (flexible) + tcc_error("flexible array member '%s' not at the end of struct", get_tok_str(v, NULL)); bit_size = -1; v = 0; @@ -2982,21 +2982,21 @@ static void struct_decl(CType *type, int u, int tdef) if (tok != ':') { type_decl(&type1, &ad, &v, TYPE_DIRECT | TYPE_ABSTRACT); if (v == 0) { - if ((type1.t & VT_BTYPE) != VT_STRUCT) - expect("identifier"); - else { - int v = btype.ref->v; - if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) { - if (tcc_state->ms_extensions == 0) - expect("identifier"); - } - } + if ((type1.t & VT_BTYPE) != VT_STRUCT) + expect("identifier"); + else { + int v = btype.ref->v; + if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) { + if (tcc_state->ms_extensions == 0) + expect("identifier"); + } + } } if (type_size(&type1, &align) < 0) { - if ((a == TOK_STRUCT) && (type1.t & VT_ARRAY) && c) - flexible = 1; - else - tcc_error("field '%s' has incomplete type", + if ((a == TOK_STRUCT) && (type1.t & VT_ARRAY) && c) + flexible = 1; + else + tcc_error("field '%s' has incomplete type", get_tok_str(v, NULL)); } if ((type1.t & VT_BTYPE) == VT_FUNC || @@ -3807,11 +3807,11 @@ ST_FUNC void unary(void) gen_cast(&type); } } else if (tok == '{') { - /* + /* if (nocode_wanted) tcc_error("statement expression in global scope"); */ - /* this check breaks compilation of the linux 2.4.26 with the meesage: - linux/include/net/tcp.h:945: error: statement expression in global scope */ + /* this check breaks compilation of the linux 2.4.26 with the meesage: + linux/include/net/tcp.h:945: error: statement expression in global scope */ /* save all registers */ save_regs(0); @@ -3872,12 +3872,12 @@ ST_FUNC void unary(void) if ((vtop->type.t & VT_BTYPE) == VT_PTR) tcc_error("pointer not accepted for unary plus"); /* In order to force cast, we add zero, except for floating point - where we really need an noop (otherwise -0.0 will be transformed - into +0.0). */ - if (!is_float(vtop->type.t)) { - vpushi(0); - gen_op('+'); - } + where we really need an noop (otherwise -0.0 will be transformed + into +0.0). */ + if (!is_float(vtop->type.t)) { + vpushi(0); + gen_op('+'); + } break; case TOK_SIZEOF: case TOK_ALIGNOF1: @@ -4050,20 +4050,20 @@ ST_FUNC void unary(void) next(); unary(); t = vtop->type.t & VT_BTYPE; - if (is_float(t)) { + if (is_float(t)) { /* In IEEE negate(x) isn't subtract(0,x), but rather - subtract(-0, x). */ - vpush(&vtop->type); - if (t == VT_FLOAT) - vtop->c.f = -0.0f; - else if (t == VT_DOUBLE) - vtop->c.d = -0.0; - else - vtop->c.ld = -0.0; - } else - vpushi(0); - vswap(); - gen_op('-'); + subtract(-0, x). */ + vpush(&vtop->type); + if (t == VT_FLOAT) + vtop->c.f = -0.0f; + else if (t == VT_DOUBLE) + vtop->c.d = -0.0; + else + vtop->c.ld = -0.0; + } else + vpushi(0); + vswap(); + gen_op('-'); break; case TOK_LAND: if (!gnu_ext) @@ -4142,7 +4142,7 @@ ST_FUNC void unary(void) /* if forward reference, we must point to s */ if (vtop->r & VT_SYM) { vtop->sym = s; - vtop->c.ptr_offset = 0; + vtop->c.ptr_offset = 0; } break; } @@ -4312,10 +4312,10 @@ ST_FUNC void unary(void) size = type_size(&s->type, &align); - /* We're writing whole regs often, make sure there's enough - space. Assume register size is power of 2. */ - if (regsize > align) - align = regsize; + /* We're writing whole regs often, make sure there's enough + space. Assume register size is power of 2. */ + if (regsize > align) + align = regsize; loc = (loc - size) & -align; addr = loc; #if defined(TCC_TARGET_X86_64) && !defined(TCC_TARGET_PE) @@ -4610,16 +4610,16 @@ static void expr_cond(void) (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED)) type.t |= VT_UNSIGNED; } else if (bt1 == VT_PTR || bt2 == VT_PTR) { - /* If one is a null ptr constant the result type - is the other. */ - if (is_null_pointer (vtop)) - type = type1; - else if (is_null_pointer (&sv)) - type = type2; + /* If one is a null ptr constant the result type + is the other. */ + if (is_null_pointer (vtop)) + type = type1; + else if (is_null_pointer (&sv)) + type = type2; /* XXX: test pointer compatibility, C99 has more elaborate - rules here. */ - else - type = type1; + rules here. */ + else + type = type1; } else if (bt1 == VT_FUNC || bt2 == VT_FUNC) { /* XXX: test function pointer compatibility */ type = bt1 == VT_FUNC ? type1 : type2; @@ -4785,14 +4785,14 @@ static void label_or_decl(int l) /* fast test first */ if (tok >= TOK_UIDENT) { - /* no need to save tokc because tok is an identifier */ - last_tok = tok; - next(); - if (tok == ':') { - unget_tok(last_tok); - return; - } - unget_tok(last_tok); + /* no need to save tokc because tok is an identifier */ + last_tok = tok; + next(); + if (tok == ':') { + unget_tok(last_tok); + return; + } + unget_tok(last_tok); } decl(l); } @@ -4891,10 +4891,10 @@ static void block(int *bsym, int *csym, int *case_sym, int *def_sym, Sym *p; switch(vtop->type.t & VT_BTYPE) { /* case VT_PTR: */ - /* this breaks a compilation of the linux kernel v2.4.26 */ - /* pmd_t *new = ({ __asm__ __volatile__("ud2\n") ; ((pmd_t *)1); }); */ - /* Look a commit a80acab: Display error on statement expressions with complex return type */ - /* A pointer is not a complex return type */ + /* this breaks a compilation of the linux kernel v2.4.26 */ + /* pmd_t *new = ({ __asm__ __volatile__("ud2\n") ; ((pmd_t *)1); }); */ + /* Look a commit a80acab: Display error on statement expressions with complex return type */ + /* A pointer is not a complex return type */ case VT_STRUCT: case VT_ENUM: case VT_FUNC: @@ -5642,38 +5642,38 @@ static void decl_initializer(CType *type, Section *sec, unsigned long c, AttributeDef ad1; CType type1; next(); - if (tcc_state->old_struct_init_code) { - /* an old version of struct initialization. - It have a problems. But with a new version - linux 2.4.26 can't load ramdisk. - */ - while (tok == '(') { - par_count++; - next(); - } - if (!parse_btype(&type1, &ad1)) - expect("cast"); - type_decl(&type1, &ad1, &n, TYPE_ABSTRACT); - #if 0 - if (!is_assignable_types(type, &type1)) - tcc_error("invalid type for cast"); - #endif - skip(')'); - } - else - { + if (tcc_state->old_struct_init_code) { + /* an old version of struct initialization. + It have a problems. But with a new version + linux 2.4.26 can't load ramdisk. + */ + while (tok == '(') { + par_count++; + next(); + } + if (!parse_btype(&type1, &ad1)) + expect("cast"); + type_decl(&type1, &ad1, &n, TYPE_ABSTRACT); + #if 0 + if (!is_assignable_types(type, &type1)) + tcc_error("invalid type for cast"); + #endif + skip(')'); + } + else + { if (tok != '(') { - if (!parse_btype(&type1, &ad1)) - expect("cast"); - type_decl(&type1, &ad1, &n, TYPE_ABSTRACT); - #if 0 - if (!is_assignable_types(type, &type1)) - tcc_error("invalid type for cast"); - #endif - skip(')'); - } else - unget_tok(tok); - } + if (!parse_btype(&type1, &ad1)) + expect("cast"); + type_decl(&type1, &ad1, &n, TYPE_ABSTRACT); + #if 0 + if (!is_assignable_types(type, &type1)) + tcc_error("invalid type for cast"); + #endif + skip(')'); + } else + unget_tok(tok); + } } no_oblock = 1; @@ -5699,28 +5699,28 @@ static void decl_initializer(CType *type, Section *sec, unsigned long c, /* gr: skip fields from same union - ugly. */ while (f->next) { - int align = 0; - int f_size = type_size(&f->type, &align); - int f_type = (f->type.t & VT_BTYPE); + int align = 0; + int f_size = type_size(&f->type, &align); + int f_type = (f->type.t & VT_BTYPE); ///printf("index: %2d %08x -- %2d %08x\n", f->c, f->type.t, f->next->c, f->next->type.t); /* test for same offset */ if (f->next->c != f->c) break; if ((f_type == VT_STRUCT) && (f_size == 0)) { - /* - Lets assume a structure of size 0 can't be a member of the union. - This allow to compile the following code from a linux kernel v2.4.26 - typedef struct { } rwlock_t; - struct fs_struct { - int count; - rwlock_t lock; - int umask; - }; - struct fs_struct init_fs = { { (1) }, (rwlock_t) {}, 0022, }; - tcc-0.9.23 can succesfully compile this version of the kernel. - gcc don't have problems with this code too. - */ + /* + Lets assume a structure of size 0 can't be a member of the union. + This allow to compile the following code from a linux kernel v2.4.26 + typedef struct { } rwlock_t; + struct fs_struct { + int count; + rwlock_t lock; + int umask; + }; + struct fs_struct init_fs = { { (1) }, (rwlock_t) {}, 0022, }; + tcc-0.9.23 can succesfully compile this version of the kernel. + gcc don't have problems with this code too. + */ break; } /* if yes, test for bitfield shift */ @@ -5760,21 +5760,21 @@ static void decl_initializer(CType *type, Section *sec, unsigned long c, /* just skip expression */ parlevel = parlevel1 = 0; while ((parlevel > 0 || parlevel1 > 0 || - (tok != '}' && tok != ',')) && tok != -1) { + (tok != '}' && tok != ',')) && tok != -1) { if (tok == '(') parlevel++; else if (tok == ')') { - if (parlevel == 0 && parlevel1 == 0) - break; + if (parlevel == 0 && parlevel1 == 0) + break; parlevel--; } - else if (tok == '{') - parlevel1++; - else if (tok == '}') { - if (parlevel == 0 && parlevel1 == 0) - break; - parlevel1--; - } + else if (tok == '{') + parlevel1++; + else if (tok == '}') { + if (parlevel == 0 && parlevel1 == 0) + break; + parlevel1--; + } next(); } } else { @@ -5995,12 +5995,12 @@ static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, } else { /* push global reference */ sym = get_sym_ref(type, sec, addr, size); - vpushsym(type, sym); + vpushsym(type, sym); } /* patch symbol weakness */ if (type->t & VT_WEAK) weaken_symbol(sym); - apply_visibility(sym, type); + apply_visibility(sym, type); #ifdef CONFIG_TCC_BCHECK /* handles bounds now because the symbol must be defined before for the relocation */ @@ -6236,11 +6236,11 @@ static int decl0(int l, int is_for_loop_init) if (((btype.t & VT_BTYPE) == VT_ENUM || (btype.t & VT_BTYPE) == VT_STRUCT) && tok == ';') { - if ((btype.t & VT_BTYPE) == VT_STRUCT) { - int v = btype.ref->v; - if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) >= SYM_FIRST_ANOM) - tcc_warning("unnamed struct/union that defines no instances"); - } + if ((btype.t & VT_BTYPE) == VT_STRUCT) { + int v = btype.ref->v; + if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) >= SYM_FIRST_ANOM) + tcc_warning("unnamed struct/union that defines no instances"); + } next(); continue; } @@ -6286,7 +6286,7 @@ static int decl0(int l, int is_for_loop_init) if (ad.a.func_export) type.t |= VT_EXPORT; #endif - type.t |= ad.a.visibility << VT_VIS_SHIFT; + type.t |= ad.a.visibility << VT_VIS_SHIFT; if (tok == '{') { if (l == VT_LOCAL) @@ -6327,10 +6327,10 @@ static int decl0(int l, int is_for_loop_init) if (sym->type.t & VT_STATIC) type.t = (type.t & ~VT_EXTERN) | VT_STATIC; - /* If the definition has no visibility use the - one from prototype. */ - if (! (type.t & VT_VIS_MASK)) - type.t |= sym->type.t & VT_VIS_MASK; + /* If the definition has no visibility use the + one from prototype. */ + if (! (type.t & VT_VIS_MASK)) + type.t |= sym->type.t & VT_VIS_MASK; if (!is_compatible_types(&sym->type, &type)) { func_error1: diff --git a/tccpe.c b/tccpe.c index 3af2047b..a13eac77 100644 --- a/tccpe.c +++ b/tccpe.c @@ -398,22 +398,22 @@ static int pe_find_import(TCCState * s1, ElfW(Sym) *sym) s = pe_export_name(s1, sym); if (n) { /* second try: */ - if (sym->st_other & ST_PE_STDCALL) { + if (sym->st_other & ST_PE_STDCALL) { /* try w/0 stdcall deco (windows API convention) */ - p = strrchr(s, '@'); - if (!p || s[0] != '_') - break; - strcpy(buffer, s+1)[p-s-1] = 0; - } else if (s[0] != '_') { /* try non-ansi function */ - buffer[0] = '_', strcpy(buffer + 1, s); - } else if (0 == memcmp(s, "__imp__", 7)) { /* mingw 2.0 */ - strcpy(buffer, s + 6); - } else if (0 == memcmp(s, "_imp___", 7)) { /* mingw 3.7 */ - strcpy(buffer, s + 6); - } else { - break; - } - s = buffer; + p = strrchr(s, '@'); + if (!p || s[0] != '_') + break; + strcpy(buffer, s+1)[p-s-1] = 0; + } else if (s[0] != '_') { /* try non-ansi function */ + buffer[0] = '_', strcpy(buffer + 1, s); + } else if (0 == memcmp(s, "__imp__", 7)) { /* mingw 2.0 */ + strcpy(buffer, s + 6); + } else if (0 == memcmp(s, "_imp___", 7)) { /* mingw 3.7 */ + strcpy(buffer, s + 6); + } else { + break; + } + s = buffer; } sym_index = find_elf_sym(s1->dynsymtab_section, s); // printf("find (%d) %d %s\n", n, sym_index, s); @@ -565,9 +565,9 @@ static int pe_write(struct pe_info *pe) #endif /* NT additional fields. */ #if defined(TCC_TARGET_ARM) - 0x00100000, /*DWORD ImageBase; */ + 0x00100000, /*DWORD ImageBase; */ #else - 0x00400000, /*DWORD ImageBase; */ + 0x00400000, /*DWORD ImageBase; */ #endif 0x00001000, /*DWORD SectionAlignment; */ 0x00000200, /*DWORD FileAlignment; */ @@ -1841,13 +1841,13 @@ ST_FUNC int pe_output_file(TCCState * s1, const char *filename) pe.subsystem = s1->pe_subsystem; /* set default file/section alignment */ - if (pe.subsystem == 1) { - pe.section_align = 0x20; - pe.file_align = 0x20; - } else { - pe.section_align = 0x1000; - pe.file_align = 0x200; - } + if (pe.subsystem == 1) { + pe.section_align = 0x20; + pe.file_align = 0x20; + } else { + pe.section_align = 0x1000; + pe.file_align = 0x200; + } if (s1->section_align != 0) pe.section_align = s1->section_align; diff --git a/tccpp.c b/tccpp.c index 9fa5f84a..eed09b56 100644 --- a/tccpp.c +++ b/tccpp.c @@ -786,7 +786,7 @@ redo_start: else if (tok == TOK_LINEFEED) goto redo_start; } else if (parse_flags & PARSE_FLAG_ASM_FILE) - p = parse_line_comment(p); + p = parse_line_comment(p); break; _default: default: @@ -1786,7 +1786,7 @@ _line_num: total_lines += file->line_num - n; file->line_num = n; if (s1->do_debug) - put_stabs(file->filename, N_BINCL, 0, 0, 0); + put_stabs(file->filename, N_BINCL, 0, 0, 0); break; case TOK_ERROR: case TOK_WARNING: @@ -2272,7 +2272,7 @@ static void parse_number(const char *p) if (n & 0xffffffff00000000LL || must_64bit) { tok = TOK_CLLONG; n1 = n >> 32; - } else { + } else { tok = TOK_CINT; n1 = n; } @@ -2538,7 +2538,7 @@ maybe_newline: } else if (c == '.') { PEEKC(c, p); if (c != '.') - expect("'.'"); + expect("'.'"); PEEKC(c, p); tok = TOK_DOTS; } else { diff --git a/tccrun.c b/tccrun.c index 55db3109..cb983923 100644 --- a/tccrun.c +++ b/tccrun.c @@ -127,7 +127,7 @@ LIBTCCAPI int tcc_run(TCCState *s1, int argc, char **argv) for (i=0; iEbp; #endif if (level > 0) { - for(i=1;i= 0xc0000000) - return -1; - fp = ((addr_t*)fp)[0]; - } + for(i = 1; i < level; i++) { + /* XXX: check address validity with program info */ + if (fp <= 0x1000 || fp >= 0xc0000000) + return -1; + fp = ((addr_t*)fp)[0]; + } pc = ((addr_t*)fp)[1]; } *paddr = pc; diff --git a/x86_64-gen.c b/x86_64-gen.c index debbdabe..4a486041 100644 --- a/x86_64-gen.c +++ b/x86_64-gen.c @@ -477,18 +477,17 @@ void load(int r, SValue *sv) gen_modrm(r, VT_LOCAL, sv->sym, fc); } else if (v == VT_CMP) { orex(0,r,0,0); - if ((fc & ~0x100) != TOK_NE) - oad(0xb8 + REG_VALUE(r), 0); /* mov $0, r */ - else - oad(0xb8 + REG_VALUE(r), 1); /* mov $1, r */ - if (fc & 0x100) - { - /* This was a float compare. If the parity bit is - set the result was unordered, meaning false for everything - except TOK_NE, and true for TOK_NE. */ - fc &= ~0x100; - o(0x037a + (REX_BASE(r) << 8)); - } + if ((fc & ~0x100) != TOK_NE) + oad(0xb8 + REG_VALUE(r), 0); /* mov $0, r */ + else + oad(0xb8 + REG_VALUE(r), 1); /* mov $1, r */ + if (fc & 0x100) { + /* This was a float compare. If the parity bit is + * set the result was unordered, meaning false for everything + * except TOK_NE, and true for TOK_NE. */ + fc &= ~0x100; + o(0x037a + (REX_BASE(r) << 8)); + } orex(0,r,0, 0x0f); /* setxx %br */ o(fc); o(0xc0 + REG_VALUE(r)); @@ -619,7 +618,7 @@ static void gcall_or_jmp(int is_jmp) { int r; if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST && - ((vtop->r & VT_SYM) || (vtop->c.ll-4) == (int)(vtop->c.ll-4))) { + ((vtop->r & VT_SYM) || (vtop->c.ll-4) == (int)(vtop->c.ll-4))) { /* constant case */ if (vtop->r & VT_SYM) { /* relocation case */ @@ -1705,7 +1704,7 @@ void gfunc_prolog(CType *func_type) param_addr = addr; addr += size; break; - default: break; /* nothing to be done for x86_64_mode_none */ + default: break; /* nothing to be done for x86_64_mode_none */ } sym_push(sym->v & ~SYM_FIELD, type, VT_LOCAL | VT_LVAL, param_addr); @@ -1717,8 +1716,8 @@ void gfunc_prolog(CType *func_type) func_bound_offset = lbounds_section->data_offset; func_bound_ind = ind; oad(0xb8, 0); /* lbound section pointer */ - o(0xc78948); /* mov %rax,%rdi ## first arg in %rdi, this must be ptr */ - oad(0xb8, 0); /* call to function */ + o(0xc78948); /* mov %rax,%rdi ## first arg in %rdi, this must be ptr */ + oad(0xb8, 0); /* call to function */ } #endif } @@ -1730,7 +1729,7 @@ void gfunc_epilog(void) #ifdef CONFIG_TCC_BCHECK if (tcc_state->do_bounds_check - && func_bound_offset != lbounds_section->data_offset) + && func_bound_offset != lbounds_section->data_offset) { addr_t saved_ind; addr_t *bounds_ptr; @@ -1754,7 +1753,7 @@ void gfunc_epilog(void) o(0x5250); /* save returned value, if any */ greloc(cur_text_section, sym_data, ind + 1, R_386_32); oad(0xb8, 0); /* mov xxx, %rax */ - o(0xc78948); /* mov %rax,%rdi ## first arg in %rdi, this must be ptr */ + o(0xc78948); /* mov %rax,%rdi ## first arg in %rdi, this must be ptr */ gen_static_call(TOK___bound_local_delete); o(0x585a); /* restore returned value, if any */ } @@ -1806,24 +1805,24 @@ int gtst(int inv, int t) v = vtop->r & VT_VALMASK; if (v == VT_CMP) { /* fast case : can jump directly since flags are set */ - if (vtop->c.i & 0x100) - { - /* This was a float compare. If the parity flag is set - the result was unordered. For anything except != this - means false and we don't jump (anding both conditions). - For != this means true (oring both). - Take care about inverting the test. We need to jump - to our target if the result was unordered and test wasn't NE, - otherwise if unordered we don't want to jump. */ - vtop->c.i &= ~0x100; - if (!inv == (vtop->c.i != TOK_NE)) - o(0x067a); /* jp +6 */ - else - { - g(0x0f); - t = psym(0x8a, t); /* jp t */ - } - } + if (vtop->c.i & 0x100) + { + /* This was a float compare. If the parity flag is set + the result was unordered. For anything except != this + means false and we don't jump (anding both conditions). + For != this means true (oring both). + Take care about inverting the test. We need to jump + to our target if the result was unordered and test wasn't NE, + otherwise if unordered we don't want to jump. */ + vtop->c.i &= ~0x100; + if (!inv == (vtop->c.i != TOK_NE)) + o(0x067a); /* jp +6 */ + else + { + g(0x0f); + t = psym(0x8a, t); /* jp t */ + } + } g(0x0f); t = psym((vtop->c.i - 16) ^ inv, t); } else if (v == VT_JMP || v == VT_JMPI) { -- 2.11.4.GIT