diff --git a/src/arm/arm-gen.c b/src/arm/arm-gen.c index f31fb88..cf2d968 100644 --- a/src/arm/arm-gen.c +++ b/src/arm/arm-gen.c @@ -43,26 +43,26 @@ 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_R0 0x0004 -#define RC_R1 0x0008 -#define RC_R2 0x0010 -#define RC_R3 0x0020 -#define RC_R12 0x0040 -#define RC_F0 0x0080 -#define RC_F1 0x0100 -#define RC_F2 0x0200 -#define RC_F3 0x0400 +#define RC_INT 0x0001 /* generic integer register */ +#define RC_FLOAT 0x0002 /* generic float register */ +#define RC_R0 0x0004 +#define RC_R1 0x0008 +#define RC_R2 0x0010 +#define RC_R3 0x0020 +#define RC_R12 0x0040 +#define RC_F0 0x0080 +#define RC_F1 0x0100 +#define RC_F2 0x0200 +#define RC_F3 0x0400 #ifdef TCC_ARM_VFP -#define RC_F4 0x0800 -#define RC_F5 0x1000 -#define RC_F6 0x2000 -#define RC_F7 0x4000 +#define RC_F4 0x0800 +#define RC_F5 0x1000 +#define RC_F6 0x2000 +#define RC_F7 0x4000 #endif -#define RC_IRET RC_R0 /* function return: integer register */ -#define RC_LRET RC_R1 /* function return: second integer register */ -#define RC_FRET RC_F0 /* function return: float register */ +#define RC_IRET RC_R0 /* function return: integer register */ +#define RC_LRET RC_R1 /* function return: second integer register */ +#define RC_FRET RC_F0 /* function return: float register */ /* pretty names for the registers */ enum { @@ -1716,12 +1716,12 @@ void gen_opf(int op) } if (is_zero(-1)) { vswap(); - switch(op) { - case TOK_LT: op = TOK_GT; break; - case TOK_GE: op = TOK_ULE; break; - case TOK_LE: op = TOK_GE; break; - case TOK_GT: op = TOK_ULT; break; - } + switch(op) { + case TOK_LT: op = TOK_GT; break; + case TOK_GE: op = TOK_ULE; break; + case TOK_LE: op = TOK_GE; break; + case TOK_GT: op = TOK_ULT; break; + } } x |= 0xB40040; /* fcmpX */ if (op != TOK_EQ && op != TOK_NE) @@ -1738,12 +1738,12 @@ void gen_opf(int op) } o(0xEEF1FA10); /* fmstat */ - switch(op) { + switch(op) { case TOK_LE: op = TOK_ULE; break; case TOK_LT: op = TOK_ULT; break; case TOK_UGE: op = TOK_GE; break; case TOK_UGT: op = TOK_GT; break; - } + } vtop->r = VT_CMP; vtop->c.i = op; diff --git a/src/libtcc.c b/src/libtcc.c index f600280..1497637 100644 --- a/src/libtcc.c +++ b/src/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] = '_'; @@ -2257,7 +2257,7 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int argc, char **argv) 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/src/tccasm.c b/src/tccasm.c index b184c88..be34ef4 100644 --- a/src/tccasm.c +++ b/src/tccasm.c @@ -492,25 +492,25 @@ static void asm_parse_directive(TCCState *s1) case TOK_ASM_global: case TOK_ASM_weak: case TOK_ASM_hidden: - tok1 = tok; - do { - Sym *sym; + tok1 = tok; + do { + Sym *sym; - next(); - sym = label_find(tok); - if (!sym) { - sym = label_push(&s1->asm_labels, tok, 0); - sym->type.t = VT_VOID; - } - 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; - next(); - } while (tok == ','); - break; + next(); + sym = label_find(tok); + if (!sym) { + sym = label_push(&s1->asm_labels, tok, 0); + sym->type.t = VT_VOID; + } + 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; + next(); + } while (tok == ','); + break; case TOK_ASM_string: case TOK_ASM_ascii: case TOK_ASM_asciz: @@ -536,12 +536,12 @@ 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; @@ -552,8 +552,8 @@ static void asm_parse_directive(TCCState *s1) } 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/src/tcccoff.c b/src/tcccoff.c index 6ef9759..1964bed 100644 --- a/src/tcccoff.c +++ b/src/tcccoff.c @@ -21,9 +21,9 @@ #include "tcc.h" -#define MAXNSCNS 255 /* MAXIMUM NUMBER OF SECTIONS */ +#define MAXNSCNS 255 /* MAXIMUM NUMBER OF SECTIONS */ #define MAX_STR_TABLE 1000000 -AOUTHDR o_filehdr; /* OPTIONAL (A.OUT) FILE HEADER */ +AOUTHDR o_filehdr; /* OPTIONAL (A.OUT) FILE HEADER */ SCNHDR section_header[MAXNSCNS]; @@ -94,21 +94,21 @@ ST_FUNC int tcc_output_coff(TCCState* s1, FILE* f) nb_syms = symtab_section->data_offset / sizeof(Elf32_Sym); coff_nb_syms = FindCoffSymbolIndex("XXXXXXXXXX1"); - file_hdr.f_magic = COFF_C67_MAGIC; /* magic number */ - file_hdr.f_timdat = 0; /* time & date stamp */ - file_hdr.f_opthdr = sizeof(AOUTHDR); /* sizeof(optional hdr) */ - file_hdr.f_flags = 0x1143; /* flags (copied from what code composer does) */ - file_hdr.f_TargetID = 0x99; /* for C6x = 0x0099 */ + file_hdr.f_magic = COFF_C67_MAGIC; /* magic number */ + file_hdr.f_timdat = 0; /* time & date stamp */ + file_hdr.f_opthdr = sizeof(AOUTHDR); /* sizeof(optional hdr) */ + file_hdr.f_flags = 0x1143; /* flags (copied from what code composer does) */ + file_hdr.f_TargetID = 0x99; /* for C6x = 0x0099 */ - o_filehdr.magic = 0x0108; /* see magic.h */ - o_filehdr.vstamp = 0x0190; /* version stamp */ + o_filehdr.magic = 0x0108; /* see magic.h */ + o_filehdr.vstamp = 0x0190; /* version stamp */ o_filehdr.tsize = - stext->data_offset; /* text size in bytes, padded to FW bdry */ - o_filehdr.dsize = sdata->data_offset; /* initialized data " " */ - o_filehdr.bsize = sbss->data_offset; /* uninitialized data " " */ + stext->data_offset; /* text size in bytes, padded to FW bdry */ + o_filehdr.dsize = sdata->data_offset; /* initialized data " " */ + o_filehdr.bsize = sbss->data_offset; /* uninitialized data " " */ o_filehdr.entrypt = C67_main_entry_point; /* entry pt. */ - o_filehdr.text_start = stext->sh_addr; /* base of text used for this file */ - o_filehdr.data_start = sdata->sh_addr; /* base of data used for this file */ + o_filehdr.text_start = stext->sh_addr; /* base of text used for this file */ + o_filehdr.data_start = sdata->sh_addr; /* base of data used for this file */ // create all the section headers diff --git a/src/tccelf.c b/src/tccelf.c index d00fadd..2bbf479 100644 --- a/src/tccelf.c +++ b/src/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); @@ -801,17 +801,17 @@ ST_FUNC void relocate_section(TCCState *s1, Section *s) 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; + 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,21 +917,21 @@ 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. */ + /* 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) { - tcc_error("internal error: relocation failed"); + plt32pc32: + { + long long diff; + diff = (long long)val - addr; + if (diff < -2147483648LL || diff > 2147483647LL) { + tcc_error("internal error: relocation failed"); + } + *(int *)ptr += diff; } - *(int *)ptr += diff; - } break; case R_X86_64_GLOB_DAT: case R_X86_64_JUMP_SLOT: @@ -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,20 +1171,20 @@ 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) { Section *plt; @@ -1220,9 +1220,9 @@ 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) if (need_plt_entry) { Section *plt; @@ -1250,29 +1250,29 @@ 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, - s1->got->data_offset, - reloc_type, sym_index); + /* 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); } /* And now create the GOT slot itself. */ ptr = section_ptr_add(s1->got, PTR_SIZE); *ptr = 0; if (need_plt_entry) - return symattr->plt_offset; + return symattr->plt_offset; else - return symattr->got_offset; + return symattr->got_offset; } /* build GOT and PLT entries */ @@ -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); + printf("maybegot: %s, %d, %d --> ofs=0x%x\n", + (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,20 +1397,20 @@ 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; #elif defined(TCC_TARGET_C67) @@ -1455,7 +1455,7 @@ ST_FUNC void build_got_entries(TCCState *s1) 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; + 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) @@ -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" + "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,16 +1587,16 @@ 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, - init_section->data_offset - 4, R_386_PC32, sym_index); - } - else + 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"); } #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/src/tccgen.c b/src/tccgen.c index cf97d1f..981e991 100644 --- a/src/tccgen.c +++ b/src/tccgen.c @@ -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; @@ -2990,14 +2990,14 @@ static void struct_decl(CType *type, int u, int tdef) 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", - get_tok_str(v, NULL)); + 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 || (type1.t & (VT_TYPEDEF | VT_STATIC | VT_EXTERN | VT_INLINE))) @@ -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; @@ -4783,17 +4783,16 @@ static void label_or_decl(int l) int last_tok; /* fast test first */ - if (tok >= TOK_UIDENT) - { - /* no need to save tokc because tok is an identifier */ - last_tok = tok; - next(); - if (tok == ':') { + 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); - return; } - unget_tok(last_tok); - } decl(l); } @@ -4891,10 +4890,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 +5641,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 (tok != '(') { + 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); - } + 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 +5698,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 +5759,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 +5994,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 +6235,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 +6285,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 +6326,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/src/tccpe.c b/src/tccpe.c index 479d084..ec2bcb1 100644 --- a/src/tccpe.c +++ b/src/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) { - /* try w/0 stdcall deco (windows API convention) */ - p = strrchr(s, '@'); - if (!p || s[0] != '_') + 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; - 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; + } + 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; */ diff --git a/src/tms320c67/c67-gen.c b/src/tms320c67/c67-gen.c index 84ff78c..9548dca 100644 --- a/src/tms320c67/c67-gen.c +++ b/src/tms320c67/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/src/x86/x86_64-gen.c b/src/x86/x86_64-gen.c index 0ce5846..ab2eb6a 100644 --- a/src/x86/x86_64-gen.c +++ b/src/x86/x86_64-gen.c @@ -618,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 */ @@ -1806,7 +1806,7 @@ int gtst(int inv, int t) 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). @@ -1816,13 +1816,12 @@ int gtst(int inv, int t) 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 - { + 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) {