X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=util%2Fromcc%2Fromcc.c;h=c7ef22366751613d40174a3170b1bd900d74b84e;hb=f31abe31f0dd47a9b99a4cabecd5f414a07418d4;hp=5712f34040d2b98fc96c04bc49db95d54c5a90e8;hpb=1bb68289001f95b49499ac8eb483a7a10e64cc52;p=coreboot.git diff --git a/util/romcc/romcc.c b/util/romcc/romcc.c index 5712f3404..c7ef22366 100644 --- a/util/romcc/romcc.c +++ b/util/romcc/romcc.c @@ -3,8 +3,8 @@ #undef RELEASE_DATE #undef VERSION #define VERSION_MAJOR "0" -#define VERSION_MINOR "71" -#define RELEASE_DATE "03 April 2009" +#define VERSION_MINOR "72" +#define RELEASE_DATE "10 February 2010" #define VERSION VERSION_MAJOR "." VERSION_MINOR #include @@ -25,9 +25,9 @@ #define MAX_CWD_SIZE 4096 #define MAX_ALLOCATION_PASSES 100 -/* NOTE: Before you even start thinking to touch anything +/* NOTE: Before you even start thinking to touch anything * in this code, set DEBUG_ROMCC_WARNINGS to 1 to get an - * insight on the original author's thoughts. We introduced + * insight on the original author's thoughts. We introduced * this switch as romcc was about the only thing producing * massive warnings in our code.. */ @@ -61,7 +61,7 @@ #endif /* Control flow graph of a loop without goto. - * + * * AAA * +---/ * / @@ -74,31 +74,31 @@ * |\ GGG HHH | continue; * | \ \ | | * | \ III | / - * | \ | / / - * | vvv / - * +----BBB / + * | \ | / / + * | vvv / + * +----BBB / * | / * vv * JJJ * - * + * * AAA * +-----+ | +----+ * | \ | / | * | BBB +-+ | * | / \ / | | * | CCC JJJ / / - * | / \ / / - * | DDD EEE / / + * | / \ / / + * | DDD EEE / / * | | +-/ / - * | FFF / - * | / \ / - * | GGG HHH / + * | FFF / + * | / \ / + * | GGG HHH / * | | +-/ * | III - * +--+ + * +--+ + * * - * * DFlocal(X) = { Y <- Succ(X) | idom(Y) != X } * DFup(Z) = { Y <- DF(Z) | idom(Y) != X } * @@ -117,7 +117,7 @@ * DDD EEE DDD: [ ] ( BBB ) EEE: [ JJJ ] () * | * FFF FFF: [ ] ( BBB ) - * / \ + * / \ * GGG HHH GGG: [ ] ( BBB ) HHH: [ BBB ] () * | * III III: [ BBB ] () @@ -125,9 +125,17 @@ * * BBB and JJJ are definitely the dominance frontier. * Where do I place phi functions and how do I make that decision. - * + * */ -static void die(char *fmt, ...) + +struct filelist { + const char *filename; + struct filelist *next; +}; + +struct filelist *include_filelist = NULL; + +static void __attribute__((noreturn)) die(char *fmt, ...) { va_list args; @@ -223,7 +231,7 @@ static char *slurp_file(const char *dirname, const char *filename, off_t *r_size off_t size, progress; ssize_t result; FILE* file; - + if (!filename) { *r_size = 0; return 0; @@ -398,14 +406,14 @@ struct token { #define OP_SUB 9 #define OP_SL 10 #define OP_USR 11 -#define OP_SSR 12 -#define OP_AND 13 +#define OP_SSR 12 +#define OP_AND 13 #define OP_XOR 14 #define OP_OR 15 #define OP_POS 16 /* Dummy positive operator don't use it */ #define OP_NEG 17 #define OP_INVERT 18 - + #define OP_EQ 20 #define OP_NOTEQ 21 #define OP_SLESS 22 @@ -416,7 +424,7 @@ struct token { #define OP_ULESSEQ 27 #define OP_SMOREEQ 28 #define OP_UMOREEQ 29 - + #define OP_LFALSE 30 /* Test if the expression is logically false */ #define OP_LTRUE 31 /* Test if the expression is logcially true */ @@ -475,7 +483,7 @@ struct token { * assigned yet, or variables whose value we simply do not know. */ -#define OP_WRITE 60 +#define OP_WRITE 60 /* OP_WRITE moves one pseudo register to another. * MISC(0) holds the destination pseudo register, which must be an OP_DECL. * RHS(0) holds the psuedo to move. @@ -544,10 +552,10 @@ struct token { * The value represented by an OP_TUPLE is held in N registers. * LHS(0..N-1) refer to those registers. * ->use is a list of statements that use the value. - * + * * Although OP_TUPLE always has register sized pieces they are not * used until structures are flattened/decomposed into their register - * components. + * components. * ???? registers ???? */ @@ -561,10 +569,10 @@ struct token { #define OP_FCALL 72 -/* OP_FCALL performs a procedure call. +/* OP_FCALL performs a procedure call. * MISC(0) holds a pointer to the OP_LIST of a function * RHS(x) holds argument x of a function - * + * * Currently not seen outside of expressions. */ #define OP_PROG 73 @@ -614,16 +622,16 @@ struct token { * ->use is the list of all branches that use this label. */ -#define OP_ADECL 87 +#define OP_ADECL 87 /* OP_ADECL is a triple that establishes an lvalue for assignments. * A variable takes N registers to contain. * LHS(0..N-1) refer to an OP_PIECE triple that represents * the Xth register that the variable is stored in. * ->use is a list of statements that use the variable. - * + * * Although OP_ADECL always has register sized pieces they are not * used until structures are flattened/decomposed into their register - * components. + * components. */ #define OP_SDECL 88 @@ -635,12 +643,12 @@ struct token { #define OP_PHI 89 -/* OP_PHI is a triple used in SSA form code. +/* OP_PHI is a triple used in SSA form code. * It is used when multiple code paths merge and a variable needs * a single assignment from any of those code paths. * The operation is a cross between OP_DECL and OP_WRITE, which * is what OP_PHI is generated from. - * + * * RHS(x) points to the value from code path x * The number of RHS entries is the number of control paths into the block * in which OP_PHI resides. The elements of the array point to point @@ -653,12 +661,12 @@ struct token { /* continuation helpers */ #define OP_CPS_BRANCH 90 /* an unconditional branch */ -/* OP_CPS_BRANCH calls a continuation +/* OP_CPS_BRANCH calls a continuation * RHS(x) holds argument x of the function * TARG(0) holds OP_CPS_START target */ #define OP_CPS_CBRANCH 91 /* a conditional branch */ -/* OP_CPS_CBRANCH conditionally calls one of two continuations +/* OP_CPS_CBRANCH conditionally calls one of two continuations * RHS(0) holds the branch condition * RHS(x + 1) holds argument x of the function * TARG(0) holds the OP_CPS_START to jump to when true @@ -672,7 +680,7 @@ struct token { * ->next holds where the OP_CPS_RET will return to. */ #define OP_CPS_RET 93 -/* OP_CPS_RET conditionally calls one of two continuations +/* OP_CPS_RET conditionally calls one of two continuations * RHS(0) holds the variable with the return function address * RHS(x + 1) holds argument x of the function * The branch target may be any OP_CPS_START @@ -813,7 +821,7 @@ static const struct op_info table_ops[] = { [OP_CONVERT ] = OP( 0, 1, 0, 0, PURE | DEF | BLOCK, "convert"), [OP_PIECE ] = OP( 0, 0, 1, 0, PURE | DEF | STRUCTURAL | PART, "piece"), [OP_ASM ] = OP(-1, -1, 0, 0, PURE, "asm"), -[OP_DEREF ] = OP( 0, 1, 0, 0, 0 | DEF | BLOCK, "deref"), +[OP_DEREF ] = OP( 0, 1, 0, 0, 0 | DEF | BLOCK, "deref"), [OP_DOT ] = OP( 0, 0, 1, 0, PURE | DEF | PART, "dot"), [OP_INDEX ] = OP( 0, 0, 1, 0, PURE | DEF | PART, "index"), @@ -884,7 +892,7 @@ static const struct op_info table_ops[] = { #undef OP #define OP_MAX (sizeof(table_ops)/sizeof(table_ops[0])) -static const char *tops(int index) +static const char *tops(int index) { static const char unknown[] = "unknown op"; if (index < 0) { @@ -995,7 +1003,7 @@ struct block { struct block_set *ipdomfrontier; struct block *ipdom; int vertex; - + }; struct symbol { @@ -1075,6 +1083,7 @@ struct compile_state { struct hash_entry *i_break; struct hash_entry *i_default; struct hash_entry *i_return; + struct hash_entry *i_noreturn; /* Additional hash entries for predefined macros */ struct hash_entry *i_defined; struct hash_entry *i___VA_ARGS__; @@ -1170,11 +1179,11 @@ struct compile_state { * make up the union. * type->elements hold the length of the linked list */ -#define TYPE_POINTER 0x1200 +#define TYPE_POINTER 0x1200 /* For TYPE_POINTER: * type->left holds the type pointed to. */ -#define TYPE_FUNCTION 0x1300 +#define TYPE_FUNCTION 0x1300 /* For TYPE_FUNCTION: * type->left holds the return type. * type->right holds the type of the arguments @@ -1196,7 +1205,7 @@ struct compile_state { * type->elements holds the number of elements. */ #define TYPE_TUPLE 0x1900 -/* TYPE_TUPLE is a basic building block when defining +/* TYPE_TUPLE is a basic building block when defining * positionally reference type conglomerations. (i.e. closures) * In essence it is a wrapper for TYPE_PRODUCT, like TYPE_STRUCT * except it has no field names. @@ -1205,7 +1214,7 @@ struct compile_state { * type->elements hold the number of elements in the closure. */ #define TYPE_JOIN 0x1a00 -/* TYPE_JOIN is a basic building block when defining +/* TYPE_JOIN is a basic building block when defining * positionally reference type conglomerations. (i.e. closures) * In essence it is a wrapper for TYPE_OVERLAP, like TYPE_UNION * except it has no field names. @@ -1298,9 +1307,9 @@ static struct reg_info arch_reg_constraint( struct compile_state *state, struct type *type, const char *constraint); static struct reg_info arch_reg_clobber( struct compile_state *state, const char *clobber); -static struct reg_info arch_reg_lhs(struct compile_state *state, +static struct reg_info arch_reg_lhs(struct compile_state *state, struct triple *ins, int index); -static struct reg_info arch_reg_rhs(struct compile_state *state, +static struct reg_info arch_reg_rhs(struct compile_state *state, struct triple *ins, int index); static int arch_reg_size(int reg); static struct triple *transform_to_arch_instruction( @@ -1481,9 +1490,9 @@ static int set_arg( } return result; } - -static void flag_usage(FILE *fp, const struct compiler_flag *ptr, + +static void flag_usage(FILE *fp, const struct compiler_flag *ptr, const char *prefix, const char *invert_prefix) { for(;ptr->name; ptr++) { @@ -1500,7 +1509,7 @@ static void arg_usage(FILE *fp, const struct compiler_arg *ptr, for(;ptr->name; ptr++) { const struct compiler_flag *flag; for(flag = &ptr->flags[0]; flag->name; flag++) { - fprintf(fp, "%s%s=%s\n", + fprintf(fp, "%s%s=%s\n", prefix, ptr->name, flag->name); } } @@ -1513,7 +1522,7 @@ static int append_string(size_t *max, const char ***vec, const char *str, count = ++(*max); *vec = xrealloc(*vec, sizeof(char *)*count, "name"); (*vec)[count -1] = 0; - (*vec)[count -2] = str; + (*vec)[count -2] = str; return 0; } @@ -1544,7 +1553,7 @@ static int append_define(struct compiler_state *compiler, const char *str) rest = identifier(str, end); if (rest != end) { int len = end - str - 1; - arg_error("Invalid name cannot define macro: `%*.*s'\n", + arg_error("Invalid name cannot define macro: `%*.*s'\n", len, len, str); } result = append_string(&compiler->define_count, @@ -1561,7 +1570,7 @@ static int append_undef(struct compiler_state *compiler, const char *str) rest = identifier(str, end); if (rest != end) { int len = end - str - 1; - arg_error("Invalid name cannot undefine macro: `%*.*s'\n", + arg_error("Invalid name cannot undefine macro: `%*.*s'\n", len, len, str); } result = append_string(&compiler->undef_count, @@ -1733,7 +1742,7 @@ static int get_col(struct file_state *file) for(col = 0; ptr < end; ptr++) { if (*ptr != '\t') { col++; - } + } else { col = (col & ~7) + 8; } @@ -1747,7 +1756,7 @@ static void loc(FILE *fp, struct compile_state *state, struct triple *triple) if (triple && triple->occurance) { struct occurance *spot; for(spot = triple->occurance; spot; spot = spot->parent) { - fprintf(fp, "%s:%d.%d: ", + fprintf(fp, "%s:%d.%d: ", spot->filename, spot->line, spot->col); } return; @@ -1756,11 +1765,11 @@ static void loc(FILE *fp, struct compile_state *state, struct triple *triple) return; } col = get_col(state->file); - fprintf(fp, "%s:%d.%d: ", + fprintf(fp, "%s:%d.%d: ", state->file->report_name, state->file->report_line, col); } -static void __attribute__ ((noreturn)) internal_error(struct compile_state *state, struct triple *ptr, +static void __attribute__ ((noreturn)) internal_error(struct compile_state *state, struct triple *ptr, const char *fmt, ...) { FILE *fp = state->errout; @@ -1780,7 +1789,7 @@ static void __attribute__ ((noreturn)) internal_error(struct compile_state *stat } -static void internal_warning(struct compile_state *state, struct triple *ptr, +static void internal_warning(struct compile_state *state, struct triple *ptr, const char *fmt, ...) { FILE *fp = state->errout; @@ -1798,7 +1807,7 @@ static void internal_warning(struct compile_state *state, struct triple *ptr, -static void __attribute__ ((noreturn)) error(struct compile_state *state, struct triple *ptr, +static void __attribute__ ((noreturn)) error(struct compile_state *state, struct triple *ptr, const char *fmt, ...) { FILE *fp = state->errout; @@ -1819,14 +1828,14 @@ static void __attribute__ ((noreturn)) error(struct compile_state *state, struct exit(1); } -static void warning(struct compile_state *state, struct triple *ptr, +static void warning(struct compile_state *state, struct triple *ptr, const char *fmt, ...) { FILE *fp = state->errout; va_list args; va_start(args, fmt); loc(fp, state, ptr); - fprintf(fp, "warning: "); + fprintf(fp, "warning: "); if (ptr && (state->compiler->debug & DEBUG_ABORT_ON_ERROR)) { fprintf(fp, "%p %-10s ", ptr, tops(ptr->op)); } @@ -1894,7 +1903,7 @@ static void use_triple(struct triple *used, struct triple *user) } ptr = &(*ptr)->next; } - /* Append new to the head of the list, + /* Append new to the head of the list, * copy_func and rename_block_variables * depends on this. */ @@ -1969,7 +1978,7 @@ static struct occurance *new_occurance(struct compile_state *state) (last->line == line) && (last->function == function) && ((last->filename == filename) || - (strcmp(last->filename, filename) == 0))) + (strcmp(last->filename, filename) == 0))) { get_occurance(last); return last; @@ -2065,7 +2074,7 @@ static struct triple unknown_triple = { static size_t registers_of(struct compile_state *state, struct type *type); -static struct triple *alloc_triple(struct compile_state *state, +static struct triple *alloc_triple(struct compile_state *state, int op, struct type *type, int lhs_wanted, int rhs_wanted, struct occurance *occurance) { @@ -2165,7 +2174,7 @@ static struct triple *copy_triple(struct compile_state *state, struct triple *sr return copy; } -static struct triple *new_triple(struct compile_state *state, +static struct triple *new_triple(struct compile_state *state, int op, struct type *type, int lhs, int rhs) { struct triple *ret; @@ -2175,7 +2184,7 @@ static struct triple *new_triple(struct compile_state *state, return ret; } -static struct triple *build_triple(struct compile_state *state, +static struct triple *build_triple(struct compile_state *state, int op, struct type *type, struct triple *left, struct triple *right, struct occurance *occurance) { @@ -2192,7 +2201,7 @@ static struct triple *build_triple(struct compile_state *state, return ret; } -static struct triple *triple(struct compile_state *state, +static struct triple *triple(struct compile_state *state, int op, struct type *type, struct triple *left, struct triple *right) { struct triple *ret; @@ -2208,7 +2217,7 @@ static struct triple *triple(struct compile_state *state, return ret; } -static struct triple *branch(struct compile_state *state, +static struct triple *branch(struct compile_state *state, struct triple *targ, struct triple *test) { struct triple *ret; @@ -2251,7 +2260,7 @@ static void insert_triple(struct compile_state *state, static int triple_stores_block(struct compile_state *state, struct triple *ins) { - /* This function is used to determine if u.block + /* This function is used to determine if u.block * is utilized to store the current block number. */ int stores_block; @@ -2261,7 +2270,7 @@ static int triple_stores_block(struct compile_state *state, struct triple *ins) } static int triple_is_branch(struct compile_state *state, struct triple *ins); -static struct block *block_of_triple(struct compile_state *state, +static struct block *block_of_triple(struct compile_state *state, struct triple *ins) { struct triple *first; @@ -2270,8 +2279,8 @@ static struct block *block_of_triple(struct compile_state *state, } first = state->first; while(ins != first && !triple_is_branch(state, ins->prev) && - !triple_stores_block(state, ins)) - { + !triple_stores_block(state, ins)) + { if (ins == ins->prev) { internal_error(state, ins, "ins == ins->prev?"); } @@ -2447,30 +2456,30 @@ static void display_triple(FILE *fp, struct triple *ins) } else if (ins->op == OP_INTCONST) { fprintf(fp, "(%p) %c%c%c %-7s %-2d %-10s <0x%08lx> ", - ins, pre, post, vol, reg, ins->template_id, tops(ins->op), + ins, pre, post, vol, reg, ins->template_id, tops(ins->op), (unsigned long)(ins->u.cval)); } else if (ins->op == OP_ADDRCONST) { fprintf(fp, "(%p) %c%c%c %-7s %-2d %-10s %-10p <0x%08lx>", - ins, pre, post, vol, reg, ins->template_id, tops(ins->op), + ins, pre, post, vol, reg, ins->template_id, tops(ins->op), MISC(ins, 0), (unsigned long)(ins->u.cval)); } else if (ins->op == OP_INDEX) { fprintf(fp, "(%p) %c%c%c %-7s %-2d %-10s %-10p <0x%08lx>", - ins, pre, post, vol, reg, ins->template_id, tops(ins->op), + ins, pre, post, vol, reg, ins->template_id, tops(ins->op), RHS(ins, 0), (unsigned long)(ins->u.cval)); } else if (ins->op == OP_PIECE) { fprintf(fp, "(%p) %c%c%c %-7s %-2d %-10s %-10p <0x%08lx>", - ins, pre, post, vol, reg, ins->template_id, tops(ins->op), + ins, pre, post, vol, reg, ins->template_id, tops(ins->op), MISC(ins, 0), (unsigned long)(ins->u.cval)); } else { int i, count; - fprintf(fp, "(%p) %c%c%c %-7s %-2d %-10s", + fprintf(fp, "(%p) %c%c%c %-7s %-2d %-10s", ins, pre, post, vol, reg, ins->template_id, tops(ins->op)); if (table_ops[ins->op].flags & BITFIELD) { - fprintf(fp, " <%2d-%2d:%2d>", + fprintf(fp, " <%2d-%2d:%2d>", ins->u.bitfield.offset, ins->u.bitfield.offset + ins->u.bitfield.size, ins->u.bitfield.size); @@ -2500,9 +2509,9 @@ static void display_triple(FILE *fp, struct triple *ins) fprintf(fp, " @"); for(ptr = ins->occurance; ptr; ptr = ptr->parent) { fprintf(fp, " %s,%s:%d.%d", - ptr->function, + ptr->function, ptr->filename, - ptr->line, + ptr->line, ptr->col); } if (ins->op == OP_ASM) { @@ -2523,9 +2532,9 @@ static void display_triple_changes( orig_count = TRIPLE_SIZE(orig); if ((new->op != orig->op) || (new_count != orig_count) || - (memcmp(orig->param, new->param, + (memcmp(orig->param, new->param, orig_count * sizeof(orig->param[0])) != 0) || - (memcmp(&orig->u, &new->u, sizeof(orig->u)) != 0)) + (memcmp(&orig->u, &new->u, sizeof(orig->u)) != 0)) { struct occurance *ptr; int i, min_count, indent; @@ -2533,7 +2542,7 @@ static void display_triple_changes( if (orig->op == new->op) { fprintf(fp, " %-11s", tops(orig->op)); } else { - fprintf(fp, " [%-10s %-10s]", + fprintf(fp, " [%-10s %-10s]", tops(new->op), tops(orig->op)); } min_count = new_count; @@ -2542,12 +2551,12 @@ static void display_triple_changes( } for(indent = i = 0; i < min_count; i++) { if (orig->param[i] == new->param[i]) { - fprintf(fp, " %-11p", + fprintf(fp, " %-11p", orig->param[i]); indent += 12; } else { fprintf(fp, " [%-10p %-10p]", - new->param[i], + new->param[i], orig->param[i]); indent += 24; } @@ -2562,7 +2571,7 @@ static void display_triple_changes( } if ((new->op == OP_INTCONST)|| (new->op == OP_ADDRCONST)) { - fprintf(fp, " <0x%08lx>", + fprintf(fp, " <0x%08lx>", (unsigned long)(new->u.cval)); indent += 13; } @@ -2583,11 +2592,11 @@ static void display_triple_changes( fprintf(fp, " @"); for(ptr = orig->occurance; ptr; ptr = ptr->parent) { fprintf(fp, " %s,%s:%d.%d", - ptr->function, + ptr->function, ptr->filename, - ptr->line, + ptr->line, ptr->col); - + } fprintf(fp, "\n"); fflush(fp); @@ -2597,7 +2606,7 @@ static void display_triple_changes( static int triple_is_pure(struct compile_state *state, struct triple *ins, unsigned id) { /* Does the triple have no side effects. - * I.e. Rexecuting the triple with the same arguments + * I.e. Rexecuting the triple with the same arguments * gives the same value. */ unsigned pure; @@ -2610,7 +2619,7 @@ static int triple_is_pure(struct compile_state *state, struct triple *ins, unsig return (pure == PURE) && !(id & TRIPLE_FLAG_VOLATILE); } -static int triple_is_branch_type(struct compile_state *state, +static int triple_is_branch_type(struct compile_state *state, struct triple *ins, unsigned type) { /* Is this one of the passed branch types? */ @@ -2651,7 +2660,7 @@ static int triple_is_ret(struct compile_state *state, struct triple *ins) /* Is this triple a return instruction? */ return triple_is_branch_type(state, ins, RETBRANCH); } - + #if DEBUG_ROMCC_WARNING static int triple_is_simple_ubranch(struct compile_state *state, struct triple *ins) { @@ -2732,27 +2741,27 @@ static struct triple **triple_iter(struct compile_state *state, } } return ret; - + } static struct triple **triple_lhs(struct compile_state *state, struct triple *ins, struct triple **last) { - return triple_iter(state, ins->lhs, &LHS(ins,0), + return triple_iter(state, ins->lhs, &LHS(ins,0), ins, last); } static struct triple **triple_rhs(struct compile_state *state, struct triple *ins, struct triple **last) { - return triple_iter(state, ins->rhs, &RHS(ins,0), + return triple_iter(state, ins->rhs, &RHS(ins,0), ins, last); } static struct triple **triple_misc(struct compile_state *state, struct triple *ins, struct triple **last) { - return triple_iter(state, ins->misc, &MISC(ins,0), + return triple_iter(state, ins->misc, &MISC(ins,0), ins, last); } @@ -2820,7 +2829,7 @@ static struct triple **triple_targ(struct compile_state *state, static struct triple **triple_edge_targ(struct compile_state *state, struct triple *ins, struct triple **last) { - return do_triple_targ(state, ins, last, + return do_triple_targ(state, ins, last, state->functions_joined, !state->functions_joined); } @@ -2851,7 +2860,7 @@ static struct triple *after_lhs(struct compile_state *state, struct triple *ins) } /* Function piece accessor functions */ -static struct triple *do_farg(struct compile_state *state, +static struct triple *do_farg(struct compile_state *state, struct triple *func, unsigned index) { struct type *ftype; @@ -2880,7 +2889,7 @@ static struct triple *fretaddr(struct compile_state *state, struct triple *func) { return do_farg(state, func, 1); } -static struct triple *farg(struct compile_state *state, +static struct triple *farg(struct compile_state *state, struct triple *func, unsigned index) { return do_farg(state, func, index + 2); @@ -2929,7 +2938,7 @@ static void verify_use(struct compile_state *state, } } -static int find_rhs_use(struct compile_state *state, +static int find_rhs_use(struct compile_state *state, struct triple *user, struct triple *used) { struct triple **param; @@ -3162,7 +3171,7 @@ static void print_blocks(struct compile_state *state, const char *func, FILE *fp #define TOK_FIRST_MACRO TOK_MDEFINE #define TOK_LAST_MACRO TOK_MENDIF - + #define TOK_MIF 112 #define TOK_MELSE 113 #define TOK_MIDENT 114 @@ -3282,7 +3291,7 @@ static const char *tokens[] = { [TOK_MIF ] = "#if", [TOK_MELSE ] = "#else", [TOK_MIDENT ] = "#:ident:", -[TOK_EOL ] = "EOL", +[TOK_EOL ] = "EOL", [TOK_EOF ] = "EOF", }; @@ -3306,7 +3315,7 @@ static struct hash_entry *lookup( unsigned int index; index = hash(name, name_len); entry = state->hash_table[index]; - while(entry && + while(entry && ((entry->name_len != name_len) || (memcmp(entry->name, name, name_len) != 0))) { entry = entry->next; @@ -3336,7 +3345,7 @@ static void ident_to_keyword(struct compile_state *state, struct token *tk) entry = tk->ident; if (entry && ((entry->tok == TOK_TYPE_NAME) || (entry->tok == TOK_ENUM_CONST) || - ((entry->tok >= TOK_FIRST_KEYWORD) && + ((entry->tok >= TOK_FIRST_KEYWORD) && (entry->tok <= TOK_LAST_KEYWORD)))) { tk->tok = entry->tok; } @@ -3397,7 +3406,7 @@ static void symbol( romcc_symbol(state, ident, chain, def, type, state->scope_depth); } -static void var_symbol(struct compile_state *state, +static void var_symbol(struct compile_state *state, struct hash_entry *ident, struct triple *def) { if ((def->type->type & TYPE_MASK) == TYPE_PRODUCT) { @@ -3406,7 +3415,7 @@ static void var_symbol(struct compile_state *state, symbol(state, ident, &ident->sym_ident, def, def->type); } -static void label_symbol(struct compile_state *state, +static void label_symbol(struct compile_state *state, struct hash_entry *ident, struct triple *label, int depth) { romcc_symbol(state, ident, &ident->sym_label, label, &void_type, depth); @@ -3435,7 +3444,7 @@ static void end_scope(struct compile_state *state) int i; int depth; /* Walk through the hash table and remove all symbols - * in the current scope. + * in the current scope. */ depth = state->scope_depth; for(i = 0; i < HASH_TABLE_SIZE; i++) { @@ -3518,7 +3527,7 @@ static void undef_macro(struct compile_state *state, struct hash_entry *ident) struct macro_arg *arg, *anext; macro = ident->sym_define; ident->sym_define = 0; - + /* Free the macro arguments... */ anext = macro->args; while(anext) { @@ -3535,8 +3544,8 @@ static void undef_macro(struct compile_state *state, struct hash_entry *ident) } } -static void do_define_macro(struct compile_state *state, - struct hash_entry *ident, const char *body, +static void do_define_macro(struct compile_state *state, + struct hash_entry *ident, const char *body, int argc, struct macro_arg *args) { struct macro *macro; @@ -3550,7 +3559,7 @@ static void do_define_macro(struct compile_state *state, int identical_bodies, identical_args; struct macro_arg *oarg; /* Explicitly allow identical redfinitions of the same macro */ - identical_bodies = + identical_bodies = (macro->buf_len == body_len) && (memcmp(macro->buf, body, body_len) == 0); identical_args = macro->argc == argc; @@ -3580,7 +3589,7 @@ static void do_define_macro(struct compile_state *state, ident->sym_define = macro; } - + static void define_macro( struct compile_state *state, struct hash_entry *ident, @@ -3616,7 +3625,6 @@ static void register_builtin_macros(struct compile_state *state) tm = localtime(&now); register_builtin_macro(state, "__ROMCC__", VERSION_MAJOR); - register_builtin_macro(state, "__PRE_RAM__", VERSION_MAJOR); register_builtin_macro(state, "__ROMCC_MINOR__", VERSION_MINOR); register_builtin_macro(state, "__FILE__", "\"This should be the filename\""); register_builtin_macro(state, "__LINE__", "54321"); @@ -3633,7 +3641,7 @@ static void register_builtin_macros(struct compile_state *state) register_builtin_macro(state, "__STDC__", "0"); /* In particular I don't conform to C99 */ register_builtin_macro(state, "__STDC_VERSION__", "199901L"); - + } static void process_cmdline_macros(struct compile_state *state) @@ -3680,7 +3688,7 @@ static int digitp(int c) { int ret = 0; switch(c) { - case '0': case '1': case '2': case '3': case '4': + case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': ret = 1; break; @@ -3700,7 +3708,7 @@ static int hexdigitp(int c) { int ret = 0; switch(c) { - case '0': case '1': case '2': case '3': case '4': + case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': @@ -3709,7 +3717,7 @@ static int hexdigitp(int c) } return ret; } -static int hexdigval(int c) +static int hexdigval(int c) { int val = -1; if ((c >= '0') && (c <= '9')) { @@ -3728,7 +3736,7 @@ static int octdigitp(int c) { int ret = 0; switch(c) { - case '0': case '1': case '2': case '3': + case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': ret = 1; break; @@ -3801,7 +3809,7 @@ static int char_value(struct compile_state *state, case '?': c = '?'; str++; break; case '\'': c = '\''; str++; break; case '"': c = '"'; str++; break; - case 'x': + case 'x': c = 0; str++; while((str < end) && hexdigitp(*str)) { @@ -3810,7 +3818,7 @@ static int char_value(struct compile_state *state, str++; } break; - case '0': case '1': case '2': case '3': + case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': c = 0; while((str < end) && octdigitp(*str)) { @@ -3837,7 +3845,7 @@ static const char *next_char(struct file_state *file, const char *pos, int index int c = *pos; /* Is this a trigraph? */ if (file->trigraphs && - (c == '?') && ((end - pos) >= 3) && (pos[1] == '?')) + (c == '?') && ((end - pos) >= 3) && (pos[1] == '?')) { switch(pos[2]) { case '=': c = '#'; break; @@ -3891,7 +3899,7 @@ static int get_char(struct file_state *file, const char *pos) c = *pos; /* If it is a trigraph get the trigraph value */ if (file->trigraphs && - (c == '?') && ((end - pos) >= 3) && (pos[1] == '?')) + (c == '?') && ((end - pos) >= 3) && (pos[1] == '?')) { switch(pos[2]) { case '=': c = '#'; break; @@ -3936,7 +3944,7 @@ static size_t char_strlen(struct file_state *file, const char *src, const char * return len; } -static void char_strcpy(char *dest, +static void char_strcpy(char *dest, struct file_state *file, const char *src, const char *end) { while(src < end) { @@ -3947,7 +3955,7 @@ static void char_strcpy(char *dest, } } -static char *char_strdup(struct file_state *file, +static char *char_strdup(struct file_state *file, const char *start, const char *end, const char *id) { char *str; @@ -4007,7 +4015,7 @@ static void save_string(struct file_state *file, tk->str_len = strlen(str); } -static void raw_next_token(struct compile_state *state, +static void raw_next_token(struct compile_state *state, struct file_state *file, struct token *tk) { const char *token; @@ -4044,7 +4052,7 @@ static void raw_next_token(struct compile_state *state, tokp = next_char(file, tokp, 1); while((c = get_char(file, tokp)) != -1) { /* Advance to the next character only after we verify - * the current character is not a newline. + * the current character is not a newline. * EOL is special to the preprocessor so we don't * want to loose any. */ @@ -4072,12 +4080,10 @@ static void raw_next_token(struct compile_state *state, } /* string constants */ else if ((c == '"') || ((c == 'L') && (c1 == '"'))) { - int wchar, multiline; + int multiline; - wchar = 0; multiline = 0; if (c == 'L') { - wchar = 1; tokp = next_char(file, tokp, 1); } while((c = get_char(file, tokp)) != -1) { @@ -4105,12 +4111,10 @@ static void raw_next_token(struct compile_state *state, } /* character constants */ else if ((c == '\'') || ((c == 'L') && (c1 == '\''))) { - int wchar, multiline; + int multiline; - wchar = 0; multiline = 0; if (c == 'L') { - wchar = 1; tokp = next_char(file, tokp, 1); } while((c = get_char(file, tokp)) != -1) { @@ -4136,12 +4140,12 @@ static void raw_next_token(struct compile_state *state, /* Save the character value */ save_string(file, tk, token, tokp, "literal character"); } - /* integer and floating constants + /* integer and floating constants * Integer Constants * {digits} * 0[Xx]{hexdigits} * 0{octdigit}+ - * + * * Floating constants * {digits}.{digits}[Ee][+-]?{digits} * {digits}.{digits} @@ -4251,9 +4255,9 @@ static void raw_next_token(struct compile_state *state, } } /* C99 alternate macro characters */ - else if ((c == '%') && (c1 == ':') && (c2 == '%') && (c3 == ':')) { + else if ((c == '%') && (c1 == ':') && (c2 == '%') && (c3 == ':')) { eat += 3; - tok = TOK_CONCATENATE; + tok = TOK_CONCATENATE; } else if ((c == '.') && (c1 == '.') && (c2 == '.')) { eat += 2; tok = TOK_DOTS; } else if ((c == '<') && (c1 == '<') && (c2 == '=')) { eat += 2; tok = TOK_SLEQ; } @@ -4336,7 +4340,7 @@ struct macro_arg_value { size_t len; }; static struct macro_arg_value *read_macro_args( - struct compile_state *state, struct macro *macro, + struct compile_state *state, struct macro *macro, struct file_state *file, struct token *tk) { struct macro_arg_value *argv; @@ -4358,15 +4362,15 @@ static struct macro_arg_value *read_macro_args( } paren_depth = 0; i = 0; - + for(;;) { const char *start; size_t len; start = file->pos; raw_next_token(state, file, tk); - + if (!paren_depth && (tk->tok == TOK_COMMA) && - (argv[i].ident != state->i___VA_ARGS__)) + (argv[i].ident != state->i___VA_ARGS__)) { i++; if (i >= macro->argc) { @@ -4375,11 +4379,11 @@ static struct macro_arg_value *read_macro_args( } continue; } - + if (tk->tok == TOK_LPAREN) { paren_depth++; } - + if (tk->tok == TOK_RPAREN) { if (paren_depth == 0) { break; @@ -4397,7 +4401,7 @@ static struct macro_arg_value *read_macro_args( argv[i].len += len; } if (i != macro->argc -1) { - error(state, 0, "missing %s arg %d\n", + error(state, 0, "missing %s arg %d\n", macro->ident->name, i +2); } return argv; @@ -4459,14 +4463,14 @@ static void append_macro_chars(struct compile_state *state, buf->pos += flen; } -static int compile_macro(struct compile_state *state, +static int compile_macro(struct compile_state *state, struct file_state **filep, struct token *tk); -static void macro_expand_args(struct compile_state *state, +static void macro_expand_args(struct compile_state *state, struct macro *macro, struct macro_arg_value *argv, struct token *tk) { int i; - + for(i = 0; i < macro->argc; i++) { struct file_state fmacro, *file; struct macro_buf buf; @@ -4493,7 +4497,7 @@ static void macro_expand_args(struct compile_state *state, file = &fmacro; for(;;) { raw_next_token(state, file, tk); - + /* If we have recursed into another macro body * get out of it. */ @@ -4519,7 +4523,7 @@ static void macro_expand_args(struct compile_state *state, append_macro_chars(state, macro->ident->name, &buf, file, tk->pos, file->pos); } - + xfree(argv[i].value); argv[i].value = buf.str; argv[i].len = buf.pos; @@ -4552,12 +4556,12 @@ static void expand_macro(struct compile_state *state, fmacro.macro = 1; fmacro.trigraphs = 0; fmacro.join_lines = 0; - + /* Allocate a buffer to hold the macro expansion */ buf->len = macro->buf_len + 3; buf->str = xmalloc(buf->len, macro->ident->name); buf->pos = 0; - + fstart = fmacro.pos; raw_next_token(state, &fmacro, tk); while(tk->tok != TOK_EOF) { @@ -4601,7 +4605,7 @@ static void expand_macro(struct compile_state *state, if (*str == '\\') { str = "\\"; len = 2; - } + } else if (*str == '"') { str = "\\\""; len = 2; @@ -4643,7 +4647,7 @@ static void expand_macro(struct compile_state *state, } append_macro_text(state, macro->ident->name, buf, fstart, flen); - + fstart = fmacro.pos; raw_next_token(state, &fmacro, tk); } @@ -4675,19 +4679,19 @@ static void tag_macro_name(struct compile_state *state, fmacro.macro = 1; fmacro.trigraphs = 0; fmacro.join_lines = 0; - + /* Allocate a new macro expansion buffer */ buf->len = macro->buf_len + 3; buf->str = xmalloc(buf->len, macro->ident->name); buf->pos = 0; - + fstart = fmacro.pos; raw_next_token(state, &fmacro, tk); while(tk->tok != TOK_EOF) { flen = fmacro.pos - fstart; if ((tk->tok == TOK_IDENT) && (tk->ident == macro->ident) && - (tk->val.notmacro == 0)) + (tk->val.notmacro == 0)) { append_macro_text(state, macro->ident->name, buf, fstart, flen); fstart = "$"; @@ -4695,14 +4699,14 @@ static void tag_macro_name(struct compile_state *state, } append_macro_text(state, macro->ident->name, buf, fstart, flen); - + fstart = fmacro.pos; raw_next_token(state, &fmacro, tk); } xfree(fmacro.buf); } -static int compile_macro(struct compile_state *state, +static int compile_macro(struct compile_state *state, struct file_state **filep, struct token *tk) { struct file_state *file; @@ -4809,7 +4813,7 @@ static int if_value(struct compile_state *state) offset = state->if_depth % CHAR_BIT; return !!(state->if_bytes[index] & (1 << (offset))); } -static void set_if_value(struct compile_state *state, int value) +static void set_if_value(struct compile_state *state, int value) { int index, offset; index = state->if_depth / CHAR_BIT; @@ -4872,8 +4876,8 @@ static void raw_token(struct compile_state *state, struct token *tk) rescan = 0; file = state->file; /* Exit out of an include directive or macro call */ - if ((tk->tok == TOK_EOF) && - (file != state->macro_file) && file->prev) + if ((tk->tok == TOK_EOF) && + (file != state->macro_file) && file->prev) { state->file = file->prev; /* file->basename is used keep it */ @@ -4889,13 +4893,11 @@ static void raw_token(struct compile_state *state, struct token *tk) static void pp_token(struct compile_state *state, struct token *tk) { - struct file_state *file; int rescan; raw_token(state, tk); do { rescan = 0; - file = state->file; if (tk->tok == TOK_SPACE) { raw_token(state, tk); rescan = 1; @@ -4940,8 +4942,8 @@ static void token(struct compile_state *state, struct token *tk) pp_token(state, tk); } } - /* Eat tokens disabled by the preprocessor - * (Unless we are parsing a preprocessor directive + /* Eat tokens disabled by the preprocessor + * (Unless we are parsing a preprocessor directive */ else if (if_eat(state) && (state->token_base == 0)) { pp_token(state, tk); @@ -4975,7 +4977,7 @@ static struct token *do_eat_token(struct compile_state *state, int tok) struct token *tk; int i; check_tok(state, get_token(state, 1), tok); - + /* Free the old token value */ tk = get_token(state, 0); if (tk->str_len) { @@ -5153,7 +5155,7 @@ static void preprocess(struct compile_state *state, struct token *current_token) */ int old_token_base; int tok; - + state->macro_file = state->file; old_token_base = state->token_base; @@ -5237,7 +5239,7 @@ static void preprocess(struct compile_state *state, struct token *current_token) pp_eat(state, TOK_MUNDEF); if (if_eat(state)) /* quit early when #if'd out */ break; - + ident = pp_eat(state, TOK_MIDENT)->ident; undef_macro(state, ident); @@ -5247,7 +5249,7 @@ static void preprocess(struct compile_state *state, struct token *current_token) pp_eat(state, TOK_MPRAGMA); if (if_eat(state)) /* quit early when #if'd out */ break; - warning(state, 0, "Ignoring pragma"); + warning(state, 0, "Ignoring pragma"); break; case TOK_MELIF: pp_eat(state, TOK_MELIF); @@ -5258,7 +5260,7 @@ static void preprocess(struct compile_state *state, struct token *current_token) if (if_value(state)) { eat_tokens(state, TOK_MENDIF); } - /* If the previous #if was not taken see if the #elif enables the + /* If the previous #if was not taken see if the #elif enables the * trailing code. */ else { @@ -5350,11 +5352,11 @@ static void preprocess(struct compile_state *state, struct token *current_token) else if (tok == TOK_DOTS) { pp_eat(state, TOK_DOTS); aident = state->i___VA_ARGS__; - } + } else { aident = pp_eat(state, TOK_MIDENT)->ident; } - + narg = xcmalloc(sizeof(*arg), "macro arg"); narg->ident = aident; @@ -5396,7 +5398,7 @@ static void preprocess(struct compile_state *state, struct token *current_token) mend = get_token(state, 1)->pos; } } - + /* Now that I have found the body defined the token */ do_define_macro(state, ident, char_strdup(state->file, mstart, mend, "macro buf"), @@ -5407,7 +5409,7 @@ static void preprocess(struct compile_state *state, struct token *current_token) { const char *start, *end; int len; - + pp_eat(state, TOK_MERROR); /* Find the start of the line */ raw_peek(state); @@ -5428,13 +5430,13 @@ static void preprocess(struct compile_state *state, struct token *current_token) { const char *start, *end; int len; - + pp_eat(state, TOK_MWARNING); /* Find the start of the line */ raw_peek(state); start = get_token(state, 1)->pos; - + /* Find the end of the line */ while((tok = raw_peek(state)) != TOK_EOL) { raw_eat(state, tok); @@ -5528,7 +5530,7 @@ static void preprocess(struct compile_state *state, struct token *current_token) if (tok == TOK_MIDENT) { name2 = get_token(state, 1)->ident->name; } - error(state, 0, "Invalid preprocessor directive: %s %s", + error(state, 0, "Invalid preprocessor directive: %s %s", name1, name2); break; } @@ -5613,7 +5615,7 @@ static struct type *invalid_type(struct compile_state *state, struct type *type) case TYPE_STRUCT: case TYPE_TUPLE: member = type->left; - while(member && (invalid == 0) && + while(member && (invalid == 0) && ((member->type & TYPE_MASK) == TYPE_PRODUCT)) { invalid = invalid_type(state, member->left); member = member->right; @@ -5639,7 +5641,7 @@ static struct type *invalid_type(struct compile_state *state, struct type *type) break; } return invalid; - + } #define MASK_UCHAR(X) ((X) & ((ulong_t)0xff)) @@ -5674,7 +5676,7 @@ static struct type void_ptr_type = { }; #if DEBUG_ROMCC_WARNING -static struct type void_func_type = { +static struct type void_func_type = { .type = TYPE_FUNCTION, .left = &void_type, .right = &void_type, @@ -5807,19 +5809,19 @@ static void name_of(FILE *fp, struct type *type) name_of(fp, type->right); break; case TYPE_ENUM: - fprintf(fp, "enum %s", + fprintf(fp, "enum %s", (type->type_ident)? type->type_ident->name : ""); qual_of(fp, type); break; case TYPE_STRUCT: - fprintf(fp, "struct %s { ", + fprintf(fp, "struct %s { ", (type->type_ident)? type->type_ident->name : ""); name_of(fp, type->left); fprintf(fp, " } "); qual_of(fp, type); break; case TYPE_UNION: - fprintf(fp, "union %s { ", + fprintf(fp, "union %s { ", (type->type_ident)? type->type_ident->name : ""); name_of(fp, type->left); fprintf(fp, " } "); @@ -5836,7 +5838,7 @@ static void name_of(FILE *fp, struct type *type) fprintf(fp, " [%ld]", (long)(type->elements)); break; case TYPE_TUPLE: - fprintf(fp, "tuple { "); + fprintf(fp, "tuple { "); name_of(fp, type->left); fprintf(fp, " } "); qual_of(fp, type); @@ -5983,7 +5985,7 @@ static size_t align_of_in_bytes(struct compile_state *state, struct type *type) static size_t size_of(struct compile_state *state, struct type *type); static size_t reg_size_of(struct compile_state *state, struct type *type); -static size_t needed_padding(struct compile_state *state, +static size_t needed_padding(struct compile_state *state, struct type *type, size_t offset) { size_t padding, align; @@ -6005,7 +6007,7 @@ static size_t needed_padding(struct compile_state *state, return padding; } -static size_t reg_needed_padding(struct compile_state *state, +static size_t reg_needed_padding(struct compile_state *state, struct type *type, size_t offset) { size_t padding, align; @@ -6014,7 +6016,7 @@ static size_t reg_needed_padding(struct compile_state *state, * fit into the current register. */ if (((type->type & TYPE_MASK) == TYPE_BITFIELD) && - (((offset + type->elements)/REG_SIZEOF_REG) != (offset/REG_SIZEOF_REG))) + (((offset + type->elements)/REG_SIZEOF_REG) != (offset/REG_SIZEOF_REG))) { align = REG_SIZEOF_REG; } @@ -6211,7 +6213,7 @@ static size_t size_of_in_bytes(struct compile_state *state, struct type *type) return bits_to_bytes(size_of(state, type)); } -static size_t field_offset(struct compile_state *state, +static size_t field_offset(struct compile_state *state, struct type *type, struct hash_entry *field) { struct type *member; @@ -6252,7 +6254,7 @@ static size_t field_offset(struct compile_state *state, return size; } -static size_t field_reg_offset(struct compile_state *state, +static size_t field_reg_offset(struct compile_state *state, struct type *type, struct hash_entry *field) { struct type *member; @@ -6293,7 +6295,7 @@ static size_t field_reg_offset(struct compile_state *state, return size; } -static struct type *field_type(struct compile_state *state, +static struct type *field_type(struct compile_state *state, struct type *type, struct hash_entry *field) { struct type *member; @@ -6322,14 +6324,14 @@ static struct type *field_type(struct compile_state *state, else { internal_error(state, 0, "field_type only works on structures and unions"); } - + if (!member || (member->field_ident != field)) { error(state, 0, "member %s not present", field->name); } return member; } -static size_t index_offset(struct compile_state *state, +static size_t index_offset(struct compile_state *state, struct type *type, ulong_t index) { struct type *member; @@ -6375,14 +6377,14 @@ static size_t index_offset(struct compile_state *state, } } else { - internal_error(state, 0, + internal_error(state, 0, "request for index %u in something not an array, tuple or join", index); } return size; } -static size_t index_reg_offset(struct compile_state *state, +static size_t index_reg_offset(struct compile_state *state, struct type *type, ulong_t index) { struct type *member; @@ -6409,7 +6411,7 @@ static size_t index_reg_offset(struct compile_state *state, if (i != index) { internal_error(state, 0, "Missing member index: %u", index); } - + } else if ((type->type & TYPE_MASK) == TYPE_JOIN) { ulong_t i; @@ -6429,7 +6431,7 @@ static size_t index_reg_offset(struct compile_state *state, } } else { - internal_error(state, 0, + internal_error(state, 0, "request for index %u in something not an array, tuple or join", index); } @@ -6480,7 +6482,7 @@ static struct type *index_type(struct compile_state *state, } else { member = 0; - internal_error(state, 0, + internal_error(state, 0, "request for index %u in something not an array, tuple or join", index); } @@ -6705,7 +6707,7 @@ static struct type *reg_type( name_of(state->errout, type); fprintf(state->errout, "\n"); internal_error(state, 0, "reg_type not yet defined for type"); - + } } /* If I have a single register compound type not a bit-field @@ -6733,7 +6735,7 @@ static struct type *reg_type( } static struct type *next_field(struct compile_state *state, - struct type *type, struct type *prev_member) + struct type *type, struct type *prev_member) { struct type *member; if ((type->type & TYPE_MASK) != TYPE_STRUCT) { @@ -6754,13 +6756,13 @@ static struct type *next_field(struct compile_state *state, prev_member = 0; } if (prev_member) { - internal_error(state, 0, "prev_member %s not present", + internal_error(state, 0, "prev_member %s not present", prev_member->field_ident->name); } return member; } -typedef void (*walk_type_fields_cb_t)(struct compile_state *state, struct type *type, +typedef void (*walk_type_fields_cb_t)(struct compile_state *state, struct type *type, size_t ret_offset, size_t mem_offset, void *arg); static void walk_type_fields(struct compile_state *state, @@ -6783,15 +6785,15 @@ static void walk_struct_fields(struct compile_state *state, if ((mtype->type & TYPE_MASK) == TYPE_PRODUCT) { mtype = mtype->left; } - walk_type_fields(state, mtype, - reg_offset + + walk_type_fields(state, mtype, + reg_offset + field_reg_offset(state, type, mtype->field_ident), - mem_offset + + mem_offset + field_offset(state, type, mtype->field_ident), cb, arg); tptr = tptr->right; } - + } static void walk_type_fields(struct compile_state *state, @@ -7078,7 +7080,7 @@ static struct type *compatible_ptrs(struct type *left, struct type *right) result = new_type(qual_type, result, 0); } return result; - + } static struct triple *integral_promotion( struct compile_state *state, struct triple *def) @@ -7098,7 +7100,7 @@ static struct triple *integral_promotion( def->type = new_type(int_type, 0, 0); } else { - def = triple(state, OP_CONVERT, + def = triple(state, OP_CONVERT, new_type(int_type, 0, 0), def, 0); } } @@ -7157,7 +7159,7 @@ static int is_compound_type(struct type *type) case TYPE_STRUCT: case TYPE_TUPLE: case TYPE_UNION: - case TYPE_JOIN: + case TYPE_JOIN: is_compound = 1; break; default: @@ -7197,8 +7199,8 @@ static int is_lvalue(struct compile_state *state, struct triple *def) if (!def) { return 0; } - if ((def->op == OP_ADECL) || - (def->op == OP_SDECL) || + if ((def->op == OP_ADECL) || + (def->op == OP_SDECL) || (def->op == OP_DEREF) || (def->op == OP_BLOBCONST) || (def->op == OP_LIST)) { @@ -7215,7 +7217,7 @@ static void clvalue(struct compile_state *state, struct triple *def) if (!def) { internal_error(state, def, "nothing where lvalue expected?"); } - if (!is_lvalue(state, def)) { + if (!is_lvalue(state, def)) { error(state, def, "lvalue expected"); } } @@ -7259,7 +7261,7 @@ static struct triple *int_const( static struct triple *read_expr(struct compile_state *state, struct triple *def); -static struct triple *do_mk_addr_expr(struct compile_state *state, +static struct triple *do_mk_addr_expr(struct compile_state *state, struct triple *expr, struct type *type, ulong_t offset) { struct triple *result; @@ -7268,7 +7270,7 @@ static struct triple *do_mk_addr_expr(struct compile_state *state, ptr_type = new_type(TYPE_POINTER | (type->type & QUAL_MASK), type, 0); - + result = 0; if (expr->op == OP_ADECL) { error(state, expr, "address of auto variables not supported"); @@ -7444,7 +7446,7 @@ static struct triple *read_expr(struct compile_state *state, struct triple *def) return def; } -int is_write_compatible(struct compile_state *state, +int is_write_compatible(struct compile_state *state, struct type *dest, struct type *rval) { int compatible = 0; @@ -7501,7 +7503,6 @@ static struct triple *write_expr( struct compile_state *state, struct triple *dest, struct triple *rval) { struct triple *def; - int op; def = 0; if (!rval) { @@ -7524,7 +7525,6 @@ static struct triple *write_expr( } /* Now figure out which assignment operator to use */ - op = -1; if (is_in_reg(state, dest)) { def = triple(state, OP_WRITE, dest->type, rval, dest); if (MISC(def, 0) != dest) { @@ -7596,7 +7596,7 @@ struct type *ptr_arithmetic_result( /* Sanity checks to ensure I am working with the proper types */ ptr_arithmetic(state, left); arithmetic(state, right); - if (TYPE_ARITHMETIC(left->type->type) && + if (TYPE_ARITHMETIC(left->type->type) && TYPE_ARITHMETIC(right->type->type)) { type = arithmetic_result(state, left, right); } @@ -7612,7 +7612,7 @@ struct type *ptr_arithmetic_result( /* boolean helper function */ -static struct triple *ltrue_expr(struct compile_state *state, +static struct triple *ltrue_expr(struct compile_state *state, struct triple *expr) { switch(expr->op) { @@ -7628,7 +7628,7 @@ static struct triple *ltrue_expr(struct compile_state *state, return expr; } -static struct triple *lfalse_expr(struct compile_state *state, +static struct triple *lfalse_expr(struct compile_state *state, struct triple *expr) { return triple(state, OP_LFALSE, &int_type, expr, 0); @@ -7644,15 +7644,15 @@ static struct triple *mkland_expr( /* Generate some intermediate triples */ end = label(state); var = variable(state, &int_type); - + /* Store the left hand side value */ lstore = write_expr(state, var, left); /* Jump if the value is false */ - jmp = branch(state, end, + jmp = branch(state, end, lfalse_expr(state, read_expr(state, var))); mid = label(state); - + /* Store the right hand side value */ rstore = write_expr(state, var, right); @@ -7661,7 +7661,7 @@ static struct triple *mkland_expr( /* Generate the prog for a logical and */ def = mkprog(state, var, lstore, jmp, mid, rstore, end, val, 0UL); - + return def; } @@ -7674,17 +7674,17 @@ static struct triple *mklor_expr( /* Generate some intermediate triples */ end = label(state); var = variable(state, &int_type); - + /* Store the left hand side value */ left = write_expr(state, var, left); - + /* Jump if the value is true */ jmp = branch(state, end, read_expr(state, var)); mid = label(state); - + /* Store the right hand side value */ right = write_expr(state, var, right); - + /* An expression for the computed value*/ val = read_expr(state, var); @@ -7695,7 +7695,7 @@ static struct triple *mklor_expr( } static struct triple *mkcond_expr( - struct compile_state *state, + struct compile_state *state, struct triple *test, struct triple *left, struct triple *right) { struct triple *def, *val, *var, *jmp1, *jmp2, *top, *mid, *end; @@ -7750,7 +7750,7 @@ static struct triple *mkcond_expr( /* Store the right hand side value */ right = write_expr(state, var, right); - + /* An expression for the computed value */ val = read_expr(state, var); @@ -7842,7 +7842,7 @@ static struct triple *flatten_generic( insert_triple(state, first, ptr); ptr->id |= TRIPLE_FLAG_FLATTENED; ptr->id &= ~TRIPLE_FLAG_LOCAL; - + /* Now flatten the lhs elements */ for(i = 0; i < lhs; i++) { struct triple **ins = &LHS(ptr, i); @@ -7873,7 +7873,7 @@ static struct triple *flatten_prog( unuse_triple(first, body->prev); use_triple(body, body->prev); } - + if (!(val->id & TRIPLE_FLAG_FLATTENED)) { internal_error(state, val, "val not flattened?"); } @@ -7985,7 +7985,7 @@ static struct triple *flatten( base = MISC(ptr, 0); offset = bits_to_bytes(field_offset(state, base->type, ptr->u.field)); left = RHS(base, 0); - ptr = triple(state, OP_ADD, left->type, + ptr = triple(state, OP_ADD, left->type, read_expr(state, left), int_const(state, &ulong_type, offset)); free_triple(state, base); @@ -8206,8 +8206,8 @@ static struct triple *mk_add_expr( if (!equiv_types(right->type, ptr_math)) { right = mk_cast_expr(state, ptr_math, right); } - right = triple(state, op, ptr_math, right, - int_const(state, ptr_math, + right = triple(state, op, ptr_math, right, + int_const(state, ptr_math, size_of_in_bytes(state, left->type->left))); } return triple(state, OP_ADD, result_type, left, right); @@ -8233,8 +8233,8 @@ static struct triple *mk_sub_expr( if (!equiv_types(right->type, ptr_math)) { right = mk_cast_expr(state, ptr_math, right); } - right = triple(state, op, ptr_math, right, - int_const(state, ptr_math, + right = triple(state, op, ptr_math, right, + int_const(state, ptr_math, size_of_in_bytes(state, left->type->left))); } return triple(state, OP_SUB, result_type, left, right); @@ -8280,7 +8280,7 @@ static struct triple *mk_post_dec_expr( struct triple *val; lvalue(state, def); val = read_expr(state, def); - return triple(state, OP_VAL, def->type, + return triple(state, OP_VAL, def->type, write_expr(state, def, mk_sub_expr(state, val, int_const(state, &int_type, 1))) , val); @@ -8312,12 +8312,12 @@ static int is_simple_const(struct triple *ins) /* Is this a constant that u.cval has the value. * Or equivalently is this a constant that read_const * works on. - * So far only OP_INTCONST qualifies. + * So far only OP_INTCONST qualifies. */ return (ins->op == OP_INTCONST); } -static int constants_equal(struct compile_state *state, +static int constants_equal(struct compile_state *state, struct triple *left, struct triple *right) { int equal; @@ -8394,7 +8394,7 @@ static long_t bit_count(ulong_t value) } } return count; - + } #endif @@ -8457,12 +8457,12 @@ static ulong_t read_const(struct compile_state *state, struct triple *ins, struct triple *rhs) { switch(rhs->type->type &TYPE_MASK) { - case TYPE_CHAR: + case TYPE_CHAR: case TYPE_SHORT: case TYPE_INT: case TYPE_LONG: - case TYPE_UCHAR: - case TYPE_USHORT: + case TYPE_UCHAR: + case TYPE_USHORT: case TYPE_UINT: case TYPE_ULONG: case TYPE_POINTER: @@ -8512,7 +8512,7 @@ int const_eq(struct compile_state *state, struct triple *ins, rval = read_const(state, ins, right); result = (lval == rval); } - else if ((left->op == OP_ADDRCONST) && + else if ((left->op == OP_ADDRCONST) && (right->op == OP_ADDRCONST)) { result = (MISC(left, 0) == MISC(right, 0)) && (left->u.cval == right->u.cval); @@ -8522,7 +8522,7 @@ int const_eq(struct compile_state *state, struct triple *ins, result = -1; } return result; - + } int const_ucmp(struct compile_state *state, struct triple *ins, @@ -8547,7 +8547,7 @@ int const_ucmp(struct compile_state *state, struct triple *ins, result = -1; } } - else if ((left->op == OP_ADDRCONST) && + else if ((left->op == OP_ADDRCONST) && (right->op == OP_ADDRCONST) && (MISC(left, 0) == MISC(right, 0))) { result = 0; @@ -8644,7 +8644,7 @@ static void check_lhs(struct compile_state *state, struct triple *ins) for(;expr;expr = triple_lhs(state, ins, expr)) { internal_error(state, ins, "unexpected lhs"); } - + } #endif @@ -8702,7 +8702,7 @@ static void wipe_branch(struct compile_state *state, struct triple *ins) } #endif -static void mkcopy(struct compile_state *state, +static void mkcopy(struct compile_state *state, struct triple *ins, struct triple *rhs) { struct block *block; @@ -8724,7 +8724,7 @@ static void mkcopy(struct compile_state *state, use_triple(RHS(ins, 0), ins); } -static void mkconst(struct compile_state *state, +static void mkconst(struct compile_state *state, struct triple *ins, ulong_t value) { if (!is_integral(ins) && !is_pointer(ins)) { @@ -8754,7 +8754,7 @@ static void mkaddr_const(struct compile_state *state, } #if DEBUG_DECOMPOSE_PRINT_TUPLES -static void print_tuple(struct compile_state *state, +static void print_tuple(struct compile_state *state, struct triple *ins, struct triple *tuple) { FILE *fp = state->dbgout; @@ -8765,11 +8765,11 @@ static void print_tuple(struct compile_state *state, name_of(fp, LHS(tuple, 0)->type); } fprintf(fp, "\n"); - + } #endif -static struct triple *decompose_with_tuple(struct compile_state *state, +static struct triple *decompose_with_tuple(struct compile_state *state, struct triple *ins, struct triple *tuple) { struct triple *next; @@ -8791,7 +8791,7 @@ static struct triple *decompose_with_tuple(struct compile_state *state, propogate_use(state, ins, tuple); release_triple(state, ins); - + return next; } @@ -8809,7 +8809,7 @@ static struct triple *decompose_unknownval(struct compile_state *state, #endif get_occurance(ins->occurance); - tuple = alloc_triple(state, OP_TUPLE, ins->type, -1, -1, + tuple = alloc_triple(state, OP_TUPLE, ins->type, -1, -1, ins->occurance); for(i = 0; i < tuple->lhs; i++) { @@ -8826,7 +8826,7 @@ static struct triple *decompose_unknownval(struct compile_state *state, } -static struct triple *decompose_read(struct compile_state *state, +static struct triple *decompose_read(struct compile_state *state, struct triple *ins) { struct triple *tuple, *lval; @@ -8842,7 +8842,7 @@ static struct triple *decompose_read(struct compile_state *state, ins->occurance); if ((tuple->lhs != lval->lhs) && - (!triple_is_def(state, lval) || (tuple->lhs != 1))) + (!triple_is_def(state, lval) || (tuple->lhs != 1))) { internal_error(state, ins, "lhs size inconsistency?"); } @@ -8862,7 +8862,7 @@ static struct triple *decompose_read(struct compile_state *state, } get_occurance(tuple->occurance); - read = alloc_triple(state, OP_READ, piece->type, -1, -1, + read = alloc_triple(state, OP_READ, piece->type, -1, -1, tuple->occurance); RHS(read, 0) = piece; @@ -8889,12 +8889,12 @@ static struct triple *decompose_read(struct compile_state *state, return decompose_with_tuple(state, ins, tuple); } -static struct triple *decompose_write(struct compile_state *state, +static struct triple *decompose_write(struct compile_state *state, struct triple *ins) { struct triple *tuple, *lval, *val; ulong_t i; - + lval = MISC(ins, 0); val = RHS(ins, 0); get_occurance(ins->occurance); @@ -8902,7 +8902,7 @@ static struct triple *decompose_write(struct compile_state *state, ins->occurance); if ((tuple->lhs != lval->lhs) && - (!triple_is_def(state, lval) || tuple->lhs != 1)) + (!triple_is_def(state, lval) || tuple->lhs != 1)) { internal_error(state, ins, "lhs size inconsistency?"); } @@ -8922,7 +8922,7 @@ static struct triple *decompose_write(struct compile_state *state, } pval = LHS(val, i); } - + /* See if the piece is really a bitref */ bitref = 0; if (piece->op == OP_BITREF) { @@ -8950,7 +8950,7 @@ static struct triple *decompose_write(struct compile_state *state, } get_occurance(tuple->occurance); - write = alloc_triple(state, OP_WRITE, piece->type, -1, -1, + write = alloc_triple(state, OP_WRITE, piece->type, -1, -1, tuple->occurance); MISC(write, 0) = piece; RHS(write, 0) = pval; @@ -8969,7 +8969,7 @@ static void decompose_load_cb(struct compile_state *state, { struct decompose_load_info *info = arg; struct triple *load; - + if (reg_offset > info->tuple->lhs) { internal_error(state, info->tuple, "lhs to small?"); } @@ -8979,7 +8979,7 @@ static void decompose_load_cb(struct compile_state *state, LHS(info->tuple, reg_offset/REG_SIZEOF_REG) = load; } -static struct triple *decompose_load(struct compile_state *state, +static struct triple *decompose_load(struct compile_state *state, struct triple *ins) { struct triple *tuple; @@ -9012,7 +9012,7 @@ static void decompose_store_cb(struct compile_state *state, { struct decompose_store_info *info = arg; struct triple *store; - + if (reg_offset > info->tuple->lhs) { internal_error(state, info->tuple, "lhs to small?"); } @@ -9023,7 +9023,7 @@ static void decompose_store_cb(struct compile_state *state, LHS(info->tuple, reg_offset/REG_SIZEOF_REG) = store; } -static struct triple *decompose_store(struct compile_state *state, +static struct triple *decompose_store(struct compile_state *state, struct triple *ins) { struct triple *tuple; @@ -9045,7 +9045,7 @@ static struct triple *decompose_store(struct compile_state *state, return decompose_with_tuple(state, ins, tuple); } -static struct triple *decompose_dot(struct compile_state *state, +static struct triple *decompose_dot(struct compile_state *state, struct triple *ins) { struct triple *tuple, *lval; @@ -9067,7 +9067,7 @@ static struct triple *decompose_dot(struct compile_state *state, #endif get_occurance(ins->occurance); - tuple = alloc_triple(state, OP_TUPLE, type, -1, -1, + tuple = alloc_triple(state, OP_TUPLE, type, -1, -1, ins->occurance); if (((ins->type->type & TYPE_MASK) == TYPE_BITFIELD) && @@ -9102,7 +9102,7 @@ static struct triple *decompose_dot(struct compile_state *state, piece->u.bitfield.offset = reg_offset % REG_SIZEOF_REG; } else if ((reg_offset % REG_SIZEOF_REG) != 0) { - internal_error(state, ins, + internal_error(state, ins, "request for a nonbitfield sub register?"); } @@ -9112,7 +9112,7 @@ static struct triple *decompose_dot(struct compile_state *state, return decompose_with_tuple(state, ins, tuple); } -static struct triple *decompose_index(struct compile_state *state, +static struct triple *decompose_index(struct compile_state *state, struct triple *ins) { struct triple *tuple, *lval; @@ -9132,7 +9132,7 @@ static struct triple *decompose_index(struct compile_state *state, #endif get_occurance(ins->occurance); - tuple = alloc_triple(state, OP_TUPLE, type, -1, -1, + tuple = alloc_triple(state, OP_TUPLE, type, -1, -1, ins->occurance); for(i = 0; i < tuple->lhs; i++, idx++) { @@ -9160,8 +9160,10 @@ static struct triple *decompose_index(struct compile_state *state, static void decompose_compound_types(struct compile_state *state) { struct triple *ins, *next, *first; +#if DEBUG_DECOMPOSE_HIRES FILE *fp; fp = state->dbgout; +#endif first = state->first; ins = first; @@ -9202,7 +9204,7 @@ static void decompose_compound_types(struct compile_state *state) case OP_INDEX: next = decompose_index(state, ins); break; - + } #if DEBUG_DECOMPOSE_HIRES fprintf(fp, "decompose next: %p \n", next); @@ -9226,7 +9228,7 @@ static void decompose_compound_types(struct compile_state *state) else { release_triple(state, ins); } - } + } ins = next; } while(ins != first); ins = first; @@ -9235,7 +9237,7 @@ static void decompose_compound_types(struct compile_state *state) if (ins->op == OP_BITREF) { if (ins->use) { internal_error(state, ins, "bitref used"); - } + } else { release_triple(state, ins); } @@ -9965,7 +9967,7 @@ static void simplify_sextract(struct compile_state *state, struct triple *ins) val &= mask; val <<= (SIZEOF_LONG - ins->u.bitfield.size); sval = val; - sval >>= (SIZEOF_LONG - ins->u.bitfield.size); + sval >>= (SIZEOF_LONG - ins->u.bitfield.size); mkconst(state, ins, sval); } } @@ -10086,7 +10088,7 @@ static struct triple *branch_target(struct compile_state *state, struct triple * * loop back onto themselves. If I see one don't advance the * target. */ - while(triple_is_structural(state, targ) && + while(triple_is_structural(state, targ) && (targ->next != targ) && (targ->next != state->first)) { targ = targ->next; } @@ -10103,7 +10105,7 @@ static void simplify_branch(struct compile_state *state, struct triple *ins) if (ins->use != 0) { internal_error(state, ins, "branch use"); } - /* The challenge here with simplify branch is that I need to + /* The challenge here with simplify branch is that I need to * make modifications to the control flow graph as well * as to the branch instruction itself. That is handled * by rebuilding the basic blocks after simplify all is called. @@ -10120,7 +10122,7 @@ static void simplify_branch(struct compile_state *state, struct triple *ins) struct triple *targ; simplified = 0; targ = branch_target(state, ins); - if ((targ != ins) && (targ->op == OP_BRANCH) && + if ((targ != ins) && (targ->op == OP_BRANCH) && !phi_dependency(targ->u.block)) { unuse_triple(TARG(ins, 0), ins); @@ -10200,7 +10202,7 @@ static void simplify_label(struct compile_state *state, struct triple *ins) unuse_triple(ins, use); use_triple(ins->prev, use); } - + } } if (ins->use) { @@ -10237,7 +10239,7 @@ static void simplify_phi(struct compile_state *state, struct triple *ins) return; } } - + /* See if all of rhs members of a phi are the same */ value = slot[0]; for(i = 1; i < zrhs; i++) { @@ -10365,11 +10367,11 @@ static const struct simplify_table { [OP_BSF ] = { simplify_bsf, COMPILER_SIMPLIFY_OP }, [OP_BSR ] = { simplify_bsr, COMPILER_SIMPLIFY_OP }, [OP_RDMSR ] = { simplify_noop, COMPILER_SIMPLIFY_OP }, -[OP_WRMSR ] = { simplify_noop, COMPILER_SIMPLIFY_OP }, +[OP_WRMSR ] = { simplify_noop, COMPILER_SIMPLIFY_OP }, [OP_HLT ] = { simplify_noop, COMPILER_SIMPLIFY_OP }, }; -static inline void debug_simplify(struct compile_state *state, +static inline void debug_simplify(struct compile_state *state, simplify_t do_simplify, struct triple *ins) { #if DEBUG_SIMPLIFY_HIRES @@ -10404,14 +10406,14 @@ static void simplify(struct compile_state *state, struct triple *ins) else { do_simplify = table_simplify[op].func; } - if (do_simplify && + if (do_simplify && !(state->compiler->flags & table_simplify[op].flag)) { do_simplify = simplify_noop; } if (do_simplify && (ins->id & TRIPLE_FLAG_VOLATILE)) { do_simplify = simplify_noop; } - + if (!do_simplify) { internal_error(state, ins, "cannot simplify op: %d %s", op, tops(op)); @@ -10454,7 +10456,7 @@ static void register_builtin_function(struct compile_state *state, const char *name, int op, struct type *rtype, ...) { struct type *ftype, *atype, *ctype, *crtype, *param, **next; - struct triple *def, *arg, *result, *work, *last, *first, *retvar, *ret; + struct triple *def, *result, *work, *first, *retvar, *ret; struct hash_entry *ident; struct file_state file; int parameters; @@ -10522,7 +10524,7 @@ static void register_builtin_function(struct compile_state *state, } else { atype = param; } - arg = flatten(state, first, variable(state, atype)); + flatten(state, first, variable(state, atype)); param = param->right; } work = new_triple(state, op, rtype, -1, parameters); @@ -10534,13 +10536,13 @@ static void register_builtin_function(struct compile_state *state, work = write_expr(state, deref_index(state, result, 1), work); } work = flatten(state, first, work); - last = flatten(state, first, label(state)); + flatten(state, first, label(state)); ret = flatten(state, first, ret); name_len = strlen(name); ident = lookup(state, name, name_len); ftype->type_ident = ident; symbol(state, ident, &ident->sym_ident, def, ftype); - + state->file = file.prev; state->function = 0; state->main_function = 0; @@ -10587,7 +10589,7 @@ static struct type *register_builtin_type(struct compile_state *state, name_len = strlen(name); ident = lookup(state, name, name_len); - + if ((type->type & TYPE_MASK) == TYPE_PRODUCT) { ulong_t elements = 0; struct type *field; @@ -10636,23 +10638,23 @@ static void register_builtins(struct compile_state *state) register_builtin_function(state, "__builtin_uldiv", OP_UDIVT, uldiv_type, &ulong_type, &ulong_type); - register_builtin_function(state, "__builtin_inb", OP_INB, &uchar_type, + register_builtin_function(state, "__builtin_inb", OP_INB, &uchar_type, &ushort_type); register_builtin_function(state, "__builtin_inw", OP_INW, &ushort_type, &ushort_type); - register_builtin_function(state, "__builtin_inl", OP_INL, &uint_type, + register_builtin_function(state, "__builtin_inl", OP_INL, &uint_type, &ushort_type); - register_builtin_function(state, "__builtin_outb", OP_OUTB, &void_type, + register_builtin_function(state, "__builtin_outb", OP_OUTB, &void_type, &uchar_type, &ushort_type); - register_builtin_function(state, "__builtin_outw", OP_OUTW, &void_type, + register_builtin_function(state, "__builtin_outw", OP_OUTW, &void_type, &ushort_type, &ushort_type); - register_builtin_function(state, "__builtin_outl", OP_OUTL, &void_type, + register_builtin_function(state, "__builtin_outl", OP_OUTL, &void_type, &uint_type, &ushort_type); - - register_builtin_function(state, "__builtin_bsf", OP_BSF, &int_type, + + register_builtin_function(state, "__builtin_bsf", OP_BSF, &int_type, &int_type); - register_builtin_function(state, "__builtin_bsr", OP_BSR, &int_type, + register_builtin_function(state, "__builtin_bsr", OP_BSR, &int_type, &int_type); msr_type = register_builtin_type(state, "__builtin_msr_t", @@ -10663,13 +10665,13 @@ static void register_builtins(struct compile_state *state) &ulong_type); register_builtin_function(state, "__builtin_wrmsr", OP_WRMSR, &void_type, &ulong_type, &ulong_type, &ulong_type); - - register_builtin_function(state, "__builtin_hlt", OP_HLT, &void_type, + + register_builtin_function(state, "__builtin_hlt", OP_HLT, &void_type, &void_type); } static struct type *declarator( - struct compile_state *state, struct type *type, + struct compile_state *state, struct type *type, struct hash_entry **ident, int need_ident); static void decl(struct compile_state *state, struct triple *first); static struct type *specifier_qualifier_list(struct compile_state *state); @@ -10775,6 +10777,9 @@ static struct triple *string_constant(struct compile_state *state) if (str_len < 0) { error(state, 0, "negative string constant length"); } + /* ignore empty string tokens */ + if ('"' == *str && 0 == str[1]) + continue; end = str + str_len; ptr = buf; buf = xmalloc(type->elements + str_len + 1, "string_constant"); @@ -11197,8 +11202,8 @@ static struct triple *shift_expr(struct compile_state *state) right = read_expr(state, add_expr(state)); integral(state, right); right = integral_promotion(state, right); - - op = (tok == TOK_SL)? OP_SL : + + op = (tok == TOK_SL)? OP_SL : is_signed(left->type)? OP_SSR: OP_USR; def = triple(state, op, left->type, left, right); @@ -11372,7 +11377,7 @@ static struct triple *lor_expr(struct compile_state *state) right = read_expr(state, land_expr(state)); bool(state, right); - def = mklor_expr(state, + def = mklor_expr(state, ltrue_expr(state, left), ltrue_expr(state, right)); } @@ -11446,7 +11451,7 @@ static struct triple *eval_const_expr( do { valid_ins(state, ptr); if ((ptr->op == OP_PHI) || (ptr->op == OP_LIST)) { - internal_error(state, ptr, + internal_error(state, ptr, "unexpected %s in constant expression", tops(ptr->op)); } @@ -11461,8 +11466,8 @@ static struct triple *eval_const_expr( else if (triple_is_cbranch(state, ptr)) { struct triple *cond_val; cond_val = get_cv(state, cv, RHS(ptr, 0)); - if (!cond_val || !is_const(cond_val) || - (cond_val->op != OP_INTCONST)) + if (!cond_val || !is_const(cond_val) || + (cond_val->op != OP_INTCONST)) { internal_error(state, ptr, "bad branch condition"); } @@ -11478,16 +11483,16 @@ static struct triple *eval_const_expr( else if (ptr->op == OP_WRITE) { struct triple *val; val = get_cv(state, cv, RHS(ptr, 0)); - - set_cv(state, cv, MISC(ptr, 0), + + set_cv(state, cv, MISC(ptr, 0), copy_triple(state, val)); - set_cv(state, cv, ptr, + set_cv(state, cv, ptr, copy_triple(state, val)); ptr = ptr->next; } else if (ptr->op == OP_READ) { - set_cv(state, cv, ptr, - copy_triple(state, + set_cv(state, cv, ptr, + copy_triple(state, get_cv(state, cv, RHS(ptr, 0)))); ptr = ptr->next; } @@ -11508,7 +11513,7 @@ static struct triple *eval_const_expr( else { error(state, ptr, "impure operation in constant expression"); } - + } while(ptr != head); /* Get the result value */ @@ -11554,7 +11559,7 @@ static struct triple *assignment_expr(struct compile_state *state) * a larger set of statements than standard C. As long * as the subset of the grammar that is standard C behaves * correctly this should cause no problems. - * + * * For the extra token strings accepted by the grammar * none of them should produce a valid lvalue, so they * should not produce functioning programs. @@ -11567,7 +11572,7 @@ static struct triple *assignment_expr(struct compile_state *state) case TOK_EQ: lvalue(state, left); eat(state, TOK_EQ); - def = write_expr(state, left, + def = write_expr(state, left, read_expr(state, assignment_expr(state))); break; case TOK_TIMESEQ: @@ -11587,7 +11592,7 @@ static struct triple *assignment_expr(struct compile_state *state) case TOK_MODEQ: op = sign? OP_SMOD : OP_UMOD; break; } def = write_expr(state, left, - triple(state, op, left->type, + triple(state, op, left->type, read_expr(state, left), right)); break; case TOK_PLUSEQ: @@ -11623,7 +11628,7 @@ static struct triple *assignment_expr(struct compile_state *state) case TOK_OREQ: op = OP_OR; break; } def = write_expr(state, left, - triple(state, op, left->type, + triple(state, op, left->type, read_expr(state, left), right)); break; } @@ -11700,7 +11705,7 @@ static void for_statement(struct compile_state *state, struct triple *first) head = test = tail = jmp1 = jmp2 = 0; if (peek(state) != TOK_SEMI) { head = expr(state); - } + } eat(state, TOK_SEMI); if (peek(state) != TOK_SEMI) { test = expr(state); @@ -11832,7 +11837,7 @@ static void return_statement(struct compile_state *state, struct triple *first) eat(state, TOK_SEMI); /* See if this last statement in a function */ - last = ((peek(state) == TOK_RBRACE) && + last = ((peek(state) == TOK_RBRACE) && (state->scope_depth == GLOBAL_SCOPE_DEPTH +2)); /* Find the return variable */ @@ -12175,7 +12180,7 @@ static void asm_statement(struct compile_state *state, struct triple *first) for(i = 0; i < out; i++) { struct triple *constraint; constraint = out_param[i].constraint; - info->tmpl.lhs[i] = arch_reg_constraint(state, + info->tmpl.lhs[i] = arch_reg_constraint(state, out_param[i].expr->type, constraint->u.blob); free_triple(state, constraint); } @@ -12205,9 +12210,9 @@ static void asm_statement(struct compile_state *state, struct triple *first) } info->tmpl.lhs[val] = cinfo; info->tmpl.rhs[i] = cinfo; - + } else { - info->tmpl.rhs[i] = arch_reg_constraint(state, + info->tmpl.rhs[i] = arch_reg_constraint(state, in_param[i].expr->type, str); } free_triple(state, constraint); @@ -12227,7 +12232,7 @@ static void asm_statement(struct compile_state *state, struct triple *first) size_t size = arch_reg_size(info->tmpl.lhs[i].reg); if (size >= SIZEOF_LONG) { type = &ulong_type; - } + } else if (size >= SIZEOF_INT) { type = &uint_type; } @@ -12304,7 +12309,7 @@ static void statement(struct compile_state *state, struct triple *first) compound_statement(state, first); } else if (tok == TOK_IF) { - if_statement(state, first); + if_statement(state, first); } else if (tok == TOK_FOR) { for_statement(state, first); @@ -12334,7 +12339,7 @@ static void statement(struct compile_state *state, struct triple *first) asm_statement(state, first); } else if ((tok == TOK_IDENT) && (peek2(state) == TOK_COLON)) { - labeled_statement(state, first); + labeled_statement(state, first); } else if (tok == TOK_CASE) { case_statement(state, first); @@ -12356,7 +12361,7 @@ static struct type *param_decl(struct compile_state *state) struct type *type; struct hash_entry *ident; /* Cheat so the declarator will know we are not global */ - start_scope(state); + start_scope(state); ident = 0; type = decl_specifiers(state); type = declarator(state, type, &ident, 0); @@ -12396,7 +12401,7 @@ static struct type *type_name(struct compile_state *state) } static struct type *direct_declarator( - struct compile_state *state, struct type *type, + struct compile_state *state, struct type *type, struct hash_entry **pident, int need_ident) { struct hash_entry *ident; @@ -12474,7 +12479,7 @@ static struct type *direct_declarator( } static struct type *declarator( - struct compile_state *state, struct type *type, + struct compile_state *state, struct type *type, struct hash_entry **pident, int need_ident) { while(peek(state) == TOK_STAR) { @@ -12493,7 +12498,7 @@ static struct type *typedef_name( ident = eat(state, TOK_TYPE_NAME)->ident; type = ident->sym_ident->type; specifiers |= type->type & QUAL_MASK; - if ((specifiers & (STOR_MASK | QUAL_MASK)) != + if ((specifiers & (STOR_MASK | QUAL_MASK)) != (type->type & (STOR_MASK | QUAL_MASK))) { type = clone_type(specifiers, type); } @@ -12527,7 +12532,7 @@ static struct type *enum_specifier( struct type *entry; eident = eat(state, TOK_IDENT)->ident; if (eident->sym_ident) { - error(state, 0, "%s already declared", + error(state, 0, "%s already declared", eident->name); } eident->tok = TOK_ENUM_CONST; @@ -12660,13 +12665,13 @@ static struct type *struct_or_union_specifier( symbol(state, ident, &ident->sym_tag, 0, struct_type); } } - if (ident && ident->sym_tag && - ident->sym_tag->type && + if (ident && ident->sym_tag && + ident->sym_tag->type && ((ident->sym_tag->type->type & TYPE_MASK) == type_main)) { struct_type = clone_type(spec, ident->sym_tag->type); } else if (ident && !struct_type) { - error(state, 0, "%s %s undeclared", + error(state, 0, "%s %s undeclared", (type_main == TYPE_STRUCT)?"struct" : "union", ident->name); } @@ -12748,6 +12753,9 @@ static unsigned int attrib(struct compile_state *state, unsigned int attributes) } attributes |= ATTRIB_ALWAYS_INLINE; } + else if (ident == state->i_noreturn) { + // attribute((noreturn)) does nothing (yet?) + } else { error(state, 0, "Unknown attribute:%s", ident->name); } @@ -12951,7 +12959,7 @@ static struct type *type_specifier( type = typedef_name(state, spec); break; default: - error(state, 0, "bad type specifier %s", + error(state, 0, "bad type specifier %s", tokens[tok]); break; } @@ -13131,7 +13139,7 @@ static struct triple *initializer( (equiv_types(type->left, result->type->left))) { type->elements = result->type->elements; } - if (is_lvalue(state, result) && + if (is_lvalue(state, result) && ((result->type->type & TYPE_MASK) == TYPE_ARRAY) && (type->type & TYPE_MASK) != TYPE_ARRAY) { @@ -13197,7 +13205,7 @@ static struct triple *initializer( } dest = ((char *)buf) + bits_to_bytes(info.offset); #if DEBUG_INITIALIZER - fprintf(state->errout, "dest = buf + %d max_offset: %d value_size: %d op: %d\n", + fprintf(state->errout, "dest = buf + %d max_offset: %d value_size: %d op: %d\n", dest - buf, bits_to_bytes(max_offset), bits_to_bytes(value_size), @@ -13229,7 +13237,7 @@ static struct triple *initializer( info.offset += value_size; if ((type->type & TYPE_MASK) == TYPE_STRUCT) { info.type = next_field(state, type, info.type); - info.offset = field_offset(state, type, + info.offset = field_offset(state, type, info.type->field_ident); } } while(comma && (peek(state) != TOK_RBRACE)); @@ -13295,7 +13303,7 @@ static void resolve_branches(struct compile_state *state, struct triple *first) static struct triple *function_definition( struct compile_state *state, struct type *type) { - struct triple *def, *tmp, *first, *end, *retvar, *result, *ret; + struct triple *def, *tmp, *first, *end, *retvar, *ret; struct triple *fname; struct type *fname_type; struct hash_entry *ident; @@ -13324,7 +13332,7 @@ static struct triple *function_definition( if (((param->type & TYPE_MASK) != TYPE_VOID) && !param->field_ident) { error(state, 0, "No identifier for paramter %d\n", i); } - + /* Get a list of statements for this function. */ def = triple(state, OP_LIST, type, 0, 0); @@ -13347,11 +13355,11 @@ static struct triple *function_definition( ctype->elements = 1; /* Add a variable for the return value */ - crtype = new_type(TYPE_TUPLE, + crtype = new_type(TYPE_TUPLE, /* Remove all type qualifiers from the return type */ new_type(TYPE_PRODUCT, ctype, clone_type(0, type->left)), 0); crtype->elements = 2; - result = flatten(state, end, variable(state, crtype)); + flatten(state, end, variable(state, crtype)); /* Allocate a variable for the return address */ retvar = flatten(state, end, variable(state, &void_ptr_type)); @@ -13380,7 +13388,7 @@ static struct triple *function_definition( } /* Add the declaration static const char __func__ [] = "func-name" */ - fname_type = new_type(TYPE_ARRAY, + fname_type = new_type(TYPE_ARRAY, clone_type(QUAL_CONST | STOR_STATIC, &char_type), 0); fname_type->type |= QUAL_CONST | STOR_STATIC; fname_type->elements = strlen(state->function) + 1; @@ -13425,7 +13433,7 @@ static struct triple *function_definition( return def; } -static struct triple *do_decl(struct compile_state *state, +static struct triple *do_decl(struct compile_state *state, struct type *type, struct hash_entry *ident) { struct triple *def; @@ -13459,7 +13467,11 @@ static struct triple *do_decl(struct compile_state *state, if ((type->type & TYPE_MASK) == TYPE_FUNCTION) { error(state, 0, "Function prototypes not supported"); } - if (ident && + if (ident && + ((type->type & TYPE_MASK) == TYPE_ARRAY) && + ((type->type & STOR_MASK) != STOR_STATIC)) + error(state, 0, "non static arrays not supported"); + if (ident && ((type->type & STOR_MASK) == STOR_STATIC) && ((type->type & QUAL_CONST) == 0)) { error(state, 0, "non const static variables not supported"); @@ -13502,8 +13514,8 @@ static void decl(struct compile_state *state, struct triple *first) } eat(state, TOK_EQ); flatten(state, first, - init_expr(state, - ident->sym_ident->def, + init_expr(state, + ident->sym_ident->def, initializer(state, type))); } arrays_complete(state, type); @@ -13539,7 +13551,7 @@ static void decls(struct compile_state *state) } } -/* +/* * Function inlining */ struct triple_reg_set { @@ -13562,21 +13574,21 @@ static void walk_blocks(struct compile_state *state, struct basic_blocks *bb, void *arg); static void print_block( struct compile_state *state, struct block *block, void *arg); -static int do_triple_set(struct triple_reg_set **head, +static int do_triple_set(struct triple_reg_set **head, struct triple *member, struct triple *new_member); static void do_triple_unset(struct triple_reg_set **head, struct triple *member); static struct reg_block *compute_variable_lifetimes( struct compile_state *state, struct basic_blocks *bb); -static void free_variable_lifetimes(struct compile_state *state, +static void free_variable_lifetimes(struct compile_state *state, struct basic_blocks *bb, struct reg_block *blocks); #if DEBUG_EXPLICIT_CLOSURES -static void print_live_variables(struct compile_state *state, +static void print_live_variables(struct compile_state *state, struct basic_blocks *bb, struct reg_block *rb, FILE *fp); #endif static struct triple *call(struct compile_state *state, - struct triple *retvar, struct triple *ret_addr, + struct triple *retvar, struct triple *ret_addr, struct triple *targ, struct triple *ret) { struct triple *call; @@ -13655,19 +13667,19 @@ static void mark_live(struct compile_state *state, struct triple *func, void *ar static void mark_live_functions(struct compile_state *state) { - /* Ensure state->main_function is the last function in + /* Ensure state->main_function is the last function in * the list of functions. */ if ((state->main_function->next != state->functions) || (state->functions->prev != state->main_function)) { - internal_error(state, 0, + internal_error(state, 0, "state->main_function is not at the end of the function list "); } state->main_function->u.cval = 1; reverse_walk_functions(state, mark_live, 0); } -static int local_triple(struct compile_state *state, +static int local_triple(struct compile_state *state, struct triple *func, struct triple *ins) { int local = (ins->id & TRIPLE_FLAG_LOCAL); @@ -13681,7 +13693,7 @@ static int local_triple(struct compile_state *state, return local; } -struct triple *copy_func(struct compile_state *state, struct triple *ofunc, +struct triple *copy_func(struct compile_state *state, struct triple *ofunc, struct occurance *base_occurance) { struct triple *nfunc; @@ -13724,7 +13736,7 @@ struct triple *copy_func(struct compile_state *state, struct triple *ofunc, } new->id |= TRIPLE_FLAG_FLATTENED; new->id |= old->id & TRIPLE_FLAG_COPY; - + /* During the copy remember new as user of old */ use_triple(old, new); @@ -13763,7 +13775,7 @@ struct triple *copy_func(struct compile_state *state, struct triple *ofunc, old = old->next; new = new->next; } while((old != ofirst) && (new != nfirst)); - + /* Make a third pass to cleanup the extra useses */ old = ofirst; new = nfirst; @@ -13812,7 +13824,7 @@ static void expand_inline_call( } result = 0; if ((nfunc->type->left->type & TYPE_MASK) != TYPE_VOID) { - result = read_expr(state, + result = read_expr(state, deref_index(state, fresult(state, nfunc), 1)); } if (state->compiler->debug & DEBUG_INLINE) { @@ -13824,8 +13836,8 @@ static void expand_inline_call( fprintf(fp, "__________ %s _________ done\n\n", __FUNCTION__); } - /* - * Get rid of the extra triples + /* + * Get rid of the extra triples */ /* Remove the read of the return address */ ins = RHS(nfunc, 0)->prev->prev; @@ -13841,7 +13853,7 @@ static void expand_inline_call( release_triple(state, ins); /* Remove the retaddres variable */ retvar = fretaddr(state, nfunc); - if ((retvar->lhs != 1) || + if ((retvar->lhs != 1) || (retvar->op != OP_ADECL) || (retvar->next->op != OP_PIECE) || (MISC(retvar->next, 0) != retvar)) { @@ -13884,7 +13896,7 @@ static void expand_inline_call( /* * * Type of the result variable. - * + * * result * | * +----------+------------+ @@ -13894,7 +13906,7 @@ static void expand_inline_call( * +------------------+---------------+ * | | * closure1 ... closuerN - * | | + * | | * +----+--+-+--------+-----+ +----+----+---+-----+ * | | | | | | | | | * var1 var2 var3 ... varN result var1 var2 ... varN result @@ -13912,7 +13924,7 @@ static void expand_inline_call( * var1 var2 ... varN result var1 var2 ... varN result */ -static int add_closure_type(struct compile_state *state, +static int add_closure_type(struct compile_state *state, struct triple *func, struct type *closure_type) { struct type *type, *ctype, **next; @@ -13945,19 +13957,19 @@ static int add_closure_type(struct compile_state *state, fprintf(fp, "new_type: "); name_of(fp, type); fprintf(fp, "\n"); - fprintf(fp, "ctype: %p %d bits: %d ", + fprintf(fp, "ctype: %p %d bits: %d ", ctype, ctype->elements, reg_size_of(state, ctype)); name_of(fp, ctype); fprintf(fp, "\n"); #endif - + /* Regenerate the variable with the new type definition */ new_var = pre_triple(state, var, OP_ADECL, type, 0, 0); new_var->id |= TRIPLE_FLAG_FLATTENED; for(i = 0; i < new_var->lhs; i++) { LHS(new_var, i)->id |= TRIPLE_FLAG_FLATTENED; } - + /* Point everyone at the new variable */ propogate_use(state, var, new_var); @@ -13966,7 +13978,7 @@ static int add_closure_type(struct compile_state *state, release_triple(state, LHS(var, i)); } release_triple(state, var); - + /* Return the index of the added closure type */ return ctype->elements - 1; } @@ -14061,7 +14073,7 @@ static int lookup_closure_index(struct compile_state *state, for(index0 = ins->next->next; (index0->op == OP_INDEX) && (MISC(index0, 0) == result) && - (index0->u.cval == 0) ; + (index0->u.cval == 0) ; index0 = write->next) { index1 = index0->next; @@ -14105,12 +14117,12 @@ static void compute_closure_variables(struct compile_state *state, int i, max_index; #define MAX_INDICIES (sizeof(used_indicies)*CHAR_BIT) #define ID_BITS(X) ((X) & (TRIPLE_FLAG_LOCAL -1)) - struct { + struct { unsigned id; int index; } *info; - + /* Find the basic blocks of this function */ bb.func = me; bb.first = RHS(me, 0); @@ -14159,7 +14171,7 @@ static void compute_closure_variables(struct compile_state *state, ins = ins->next; } while(ins != first); - /* + /* * Build the list of variables to enclose. * * A target it to put the same variable in the @@ -14308,8 +14320,7 @@ static void expand_function_call( struct triple *func, *func_first, *func_last, *retvar; struct triple *first; struct type *ptype, *rtype; - struct triple *jmp; - struct triple *ret_addr, *ret_loc, *ret_set; + struct triple *ret_addr, *ret_loc; struct triple_reg_set *enclose, *set; int closure_idx, pvals, i; @@ -14344,7 +14355,7 @@ static void expand_function_call( if (!*closure_next) { *closure_next = type; } else { - *closure_next = new_type(TYPE_PRODUCT, *closure_next, + *closure_next = new_type(TYPE_PRODUCT, *closure_next, type); closure_next = &(*closure_next)->right; } @@ -14404,22 +14415,22 @@ static void expand_function_call( /* Initialize the return value */ if ((rtype->type & TYPE_MASK) != TYPE_VOID) { - flatten(state, ret_loc, - write_expr(state, + flatten(state, ret_loc, + write_expr(state, deref_index(state, fresult(state, func), 1), new_triple(state, OP_UNKNOWNVAL, rtype, 0, 0))); } ret_addr = flatten(state, ret_loc, ret_addr); - ret_set = flatten(state, ret_loc, write_expr(state, retvar, ret_addr)); - jmp = flatten(state, ret_loc, + flatten(state, ret_loc, write_expr(state, retvar, ret_addr)); + flatten(state, ret_loc, call(state, retvar, ret_addr, func_first, func_last)); /* Find the result */ if ((rtype->type & TYPE_MASK) != TYPE_VOID) { struct triple * result; - result = flatten(state, first, - read_expr(state, + result = flatten(state, first, + read_expr(state, deref_index(state, fresult(state, func), 1))); propogate_use(state, fcall, result); @@ -14438,7 +14449,7 @@ static void expand_function_call( } /* Generate an expression for the value */ new = flatten(state, first, - read_expr(state, + read_expr(state, closure_expr(state, func, closure_idx, i))); @@ -14451,7 +14462,7 @@ static void expand_function_call( /* * If the original is a value update the dominated uses. */ - + /* Analyze the basic blocks so I can see who dominates whom */ bb.func = me; bb.first = RHS(me, 0); @@ -14459,7 +14470,7 @@ static void expand_function_call( bb.func = 0; } analyze_basic_blocks(state, &bb); - + #if DEBUG_EXPLICIT_CLOSURES fprintf(state->errout, "Updating domindated uses: %p -> %p\n", @@ -14467,7 +14478,7 @@ static void expand_function_call( #endif /* If fcall dominates the use update the expression */ for(use = set->member->use; use; use = next) { - /* Replace use modifies the use chain and + /* Replace use modifies the use chain and * removes use, so I must take a copy of the * next entry early. */ @@ -14660,7 +14671,7 @@ static void insert_function(struct compile_state *state, if (state->compiler->debug & DEBUG_INLINE) { FILE *fp = state->errout; - fprintf(fp, "%s func count: %d\n", + fprintf(fp, "%s func count: %d\n", func->type->type_ident->name, func->u.cval); } if (func->u.cval == 0) { @@ -14685,7 +14696,7 @@ struct triple *input_asm(struct compile_state *state) struct asm_info *info; struct triple *def; int i, out; - + info = xcmalloc(sizeof(*info), "asm_info"); info->str = ""; @@ -14695,7 +14706,7 @@ struct triple *input_asm(struct compile_state *state) def = new_triple(state, OP_ASM, &void_type, out, 0); def->u.ainfo = info; def->id |= TRIPLE_FLAG_VOLATILE; - + for(i = 0; i < out; i++) { struct triple *piece; piece = triple(state, OP_PIECE, &int_type, def, 0); @@ -14711,7 +14722,7 @@ struct triple *output_asm(struct compile_state *state) struct asm_info *info; struct triple *def; int in; - + info = xcmalloc(sizeof(*info), "asm_info"); info->str = ""; @@ -14721,13 +14732,13 @@ struct triple *output_asm(struct compile_state *state) def = new_triple(state, OP_ASM, &void_type, 0, in); def->u.ainfo = info; def->id |= TRIPLE_FLAG_VOLATILE; - + return def; } static void join_functions(struct compile_state *state) { - struct triple *jmp, *start, *end, *call, *in, *out, *func; + struct triple *start, *end, *call, *in, *out, *func; struct file_state file; struct type *pnext, *param; struct type *result_type, *args_type; @@ -14758,11 +14769,11 @@ static void join_functions(struct compile_state *state) /* Verify the external arguments */ if (registers_of(state, args_type) > ARCH_INPUT_REGS) { - error(state, state->main_function, + error(state, state->main_function, "Too many external input arguments"); } if (registers_of(state, result_type) > ARCH_OUTPUT_REGS) { - error(state, state->main_function, + error(state, state->main_function, "Too many external output arguments"); } @@ -14792,8 +14803,8 @@ static void join_functions(struct compile_state *state) param = param->left; } if (registers_of(state, param) != 1) { - error(state, state->main_function, - "Arg: %d %s requires multiple registers", + error(state, state->main_function, + "Arg: %d %s requires multiple registers", idx + 1, param->field_ident->name); } expr = read_expr(state, LHS(in, idx)); @@ -14801,7 +14812,7 @@ static void join_functions(struct compile_state *state) expr = flatten(state, call, expr); use_triple(expr, call); - idx++; + idx++; } @@ -14840,7 +14851,7 @@ static void join_functions(struct compile_state *state) } /* Allocate a dummy containing function */ - func = triple(state, OP_LIST, + func = triple(state, OP_LIST, new_type(TYPE_FUNCTION, &void_type, &void_type), 0, 0); func->type->type_ident = lookup(state, "", 0); RHS(func, 0) = state->first; @@ -14852,7 +14863,7 @@ static void join_functions(struct compile_state *state) walk_functions(state, insert_function, end); if (start->next != end) { - jmp = flatten(state, start, branch(state, end, 0)); + flatten(state, start, branch(state, end, 0)); } /* OK now the functions have been joined. */ @@ -14869,7 +14880,7 @@ static void join_functions(struct compile_state *state) static int do_use_block( - struct block *used, struct block_set **head, struct block *user, + struct block *used, struct block_set **head, struct block *user, int front) { struct block_set **ptr, *new; @@ -14924,13 +14935,13 @@ static void use_block(struct block *used, struct block *user) /* Append new to the head of the list, print_block * depends on this. */ - count = do_use_block(used, &used->use, user, 1); + count = do_use_block(used, &used->use, user, 1); used->users += count; } static void unuse_block(struct block *used, struct block *unuser) { int count; - count = do_unuse_block(used, &used->use, unuser); + count = do_unuse_block(used, &used->use, unuser); used->users -= count; } @@ -14989,7 +15000,7 @@ static void unipdomf_block(struct block *block, struct block *unipdomf) } static int walk_triples( - struct compile_state *state, + struct compile_state *state, int (*cb)(struct compile_state *state, struct triple *ptr, void *arg), void *arg) { @@ -15022,7 +15033,7 @@ static int do_print_triple(struct compile_state *state, struct triple *ins, void } display_triple(fp, ins); - if (triple_is_branch(state, ins) && ins->use && + if (triple_is_branch(state, ins) && ins->use && (ins->op != OP_RET) && (ins->op != OP_FCALL)) { internal_error(state, ins, "branch used?"); } @@ -15143,7 +15154,7 @@ static void free_basic_block(struct compile_state *state, struct block *block) while((edge = block->edges)) { child = edge->member; remove_block_edge(block, child); - + if (child && (child->vertex != -1)) { free_basic_block(state, child); } @@ -15154,7 +15165,7 @@ static void free_basic_block(struct compile_state *state, struct block *block) #endif } -static void free_basic_blocks(struct compile_state *state, +static void free_basic_blocks(struct compile_state *state, struct basic_blocks *bb) { struct triple *first, *ins; @@ -15169,10 +15180,10 @@ static void free_basic_blocks(struct compile_state *state, } ins = ins->next; } while(ins != first); - + } -static struct block *basic_block(struct compile_state *state, +static struct block *basic_block(struct compile_state *state, struct basic_blocks *bb, struct triple *first) { struct block *block; @@ -15191,7 +15202,7 @@ static struct block *basic_block(struct compile_state *state, block->vertex = bb->last_vertex; ptr = first; do { - if ((ptr != first) && triple_is_label(state, ptr) && (ptr->use)) { + if ((ptr != first) && triple_is_label(state, ptr) && (ptr->use)) { break; } block->last = ptr; @@ -15206,7 +15217,7 @@ static struct block *basic_block(struct compile_state *state, } while (ptr != bb->first); if ((ptr == bb->first) || ((ptr->next == bb->first) && ( - triple_is_end(state, ptr) || + triple_is_end(state, ptr) || triple_is_ret(state, ptr)))) { /* The block has no outflowing edges */ @@ -15271,7 +15282,7 @@ static struct block *basic_block(struct compile_state *state, struct block_set *edge; FILE *fp = state->errout; fprintf(fp, "basic_block: %10p [%2d] ( %10p - %10p )", - block, block->vertex, + block, block->vertex, block->first, block->last); for(edge = block->edges; edge; edge = edge->next) { fprintf(fp, " %10p [%2d]", @@ -15315,7 +15326,7 @@ static void print_block( FILE *fp = arg; fprintf(fp, "\nblock: %p (%d) ", - block, + block, block->vertex); for(edge = block->edges; edge; edge = edge->next) { @@ -15339,7 +15350,7 @@ static void print_block( } fprintf(fp, "users %d: ", block->users); for(user = block->use; user; user = user->next) { - fprintf(fp, "%p (%d) ", + fprintf(fp, "%p (%d) ", user->member, user->member->vertex); } @@ -15365,7 +15376,7 @@ static void print_blocks(struct compile_state *state, const char *func, FILE *fp } } -static void prune_nonblock_triples(struct compile_state *state, +static void prune_nonblock_triples(struct compile_state *state, struct basic_blocks *bb) { struct block *block; @@ -15397,7 +15408,7 @@ static void prune_nonblock_triples(struct compile_state *state, } while(ins != first); } -static void setup_basic_blocks(struct compile_state *state, +static void setup_basic_blocks(struct compile_state *state, struct basic_blocks *bb) { if (!triple_stores_block(state, bb->first)) { @@ -15412,8 +15423,8 @@ static void setup_basic_blocks(struct compile_state *state, bb->first_block = basic_block(state, bb, bb->first); /* Be certain the last instruction of a function, or the - * entire program is in a basic block. When it is not find - * the start of the block, insert a label if necessary and build + * entire program is in a basic block. When it is not find + * the start of the block, insert a label if necessary and build * basic block. Then add a fake edge from the start block * to the final block. */ @@ -15429,7 +15440,7 @@ static void setup_basic_blocks(struct compile_state *state, add_block_edge(bb->first_block, tail, 0); use_block(tail, bb->first_block); } - + /* Find the last basic block. */ bb->last_block = block_of_triple(state, bb->first->prev); @@ -15530,7 +15541,7 @@ static int initialize_spdblock( return vertex; } -static int setup_spdblocks(struct compile_state *state, +static int setup_spdblocks(struct compile_state *state, struct basic_blocks *bb, struct sdom_block *sd) { struct block *block; @@ -15540,7 +15551,7 @@ static int setup_spdblocks(struct compile_state *state, /* Walk through the graph and find unconnected blocks. Add a * fake edge from the unconnected blocks to the end of the - * graph. + * graph. */ block = bb->first_block->last->next->u.block; for(; block && block != bb->first_block; block = block->last->next->u.block) { @@ -15584,16 +15595,16 @@ static void compress_ancestors(struct sdom_block *v) } } -static void compute_sdom(struct compile_state *state, +static void compute_sdom(struct compile_state *state, struct basic_blocks *bb, struct sdom_block *sd) { int i; - /* // step 2 + /* // step 2 * for each v <= pred(w) { * u = EVAL(v); - * if (semi[u] < semi[w] { - * semi[w] = semi[u]; - * } + * if (semi[u] < semi[w] { + * semi[w] = semi[u]; + * } * } * add w to bucket(vertex(semi[w])); * LINK(parent(w), w); @@ -15628,22 +15639,22 @@ static void compute_sdom(struct compile_state *state, next = v->sdom_next; unsdom_block(v); u = (!v->ancestor) ? v : (compress_ancestors(v), v->label); - v->block->idom = (u->sdom->vertex < v->sdom->vertex)? + v->block->idom = (u->sdom->vertex < v->sdom->vertex)? u->block : parent->block; } } } -static void compute_spdom(struct compile_state *state, +static void compute_spdom(struct compile_state *state, struct basic_blocks *bb, struct sdom_block *sd) { int i; - /* // step 2 + /* // step 2 * for each v <= pred(w) { * u = EVAL(v); - * if (semi[u] < semi[w] { - * semi[w] = semi[u]; - * } + * if (semi[u] < semi[w] { + * semi[w] = semi[u]; + * } * } * add w to bucket(vertex(semi[w])); * LINK(parent(w), w); @@ -15677,13 +15688,13 @@ static void compute_spdom(struct compile_state *state, next = v->sdom_next; unsdom_block(v); u = (!v->ancestor) ? v : (compress_ancestors(v), v->label); - v->block->ipdom = (u->sdom->vertex < v->sdom->vertex)? + v->block->ipdom = (u->sdom->vertex < v->sdom->vertex)? u->block : parent->block; } } } -static void compute_idom(struct compile_state *state, +static void compute_idom(struct compile_state *state, struct basic_blocks *bb, struct sdom_block *sd) { int i; @@ -15698,7 +15709,7 @@ static void compute_idom(struct compile_state *state, sd[1].block->idom = 0; } -static void compute_ipdom(struct compile_state *state, +static void compute_ipdom(struct compile_state *state, struct basic_blocks *bb, struct sdom_block *sd) { int i; @@ -15715,13 +15726,13 @@ static void compute_ipdom(struct compile_state *state, /* Theorem 1: * Every vertex of a flowgraph G = (V, E, r) except r has - * a unique immediate dominator. + * a unique immediate dominator. * The edges {(idom(w), w) |w <= V - {r}} form a directed tree - * rooted at r, called the dominator tree of G, such that + * rooted at r, called the dominator tree of G, such that * v dominates w if and only if v is a proper ancestor of w in * the dominator tree. */ - /* Lemma 1: + /* Lemma 1: * If v and w are vertices of G such that v <= w, * than any path from v to w must contain a common ancestor * of v and w in T. @@ -15734,7 +15745,7 @@ static void compute_ipdom(struct compile_state *state, * sdom(u) >= sdom(w). Then idom(w) = sdom(w). */ /* Theorem 3: - * Let w != r and let u be a vertex for which sdom(u) is + * Let w != r and let u be a vertex for which sdom(u) is * minimum amoung vertices u satisfying sdom(w) -> u -> w. * Then sdom(u) <= sdom(w) and idom(u) = idom(w). */ @@ -15752,11 +15763,11 @@ static void find_immediate_dominators(struct compile_state *state, /* Theorem 4: * For any vertex w != r. * sdom(w) = min( - * {v|(v,w) <= E and v < w } U + * {v|(v,w) <= E and v < w } U * {sdom(u) | u > w and there is an edge (v, w) such that u -> v}) */ /* Corollary 1: - * Let w != r and let u be a vertex for which sdom(u) is + * Let w != r and let u be a vertex for which sdom(u) is * minimum amoung vertices u satisfying sdom(w) -> u -> w. * Then: * { sdom(w) if sdom(w) = sdom(u), @@ -15764,7 +15775,7 @@ static void find_immediate_dominators(struct compile_state *state, * { idom(u) otherwise */ /* The algorithm consists of the following 4 steps. - * Step 1. Carry out a depth-first search of the problem graph. + * Step 1. Carry out a depth-first search of the problem graph. * Number the vertices from 1 to N as they are reached during * the search. Initialize the variables used in succeeding steps. * Step 2. Compute the semidominators of all vertices by applying @@ -15904,7 +15915,7 @@ static void print_dominated2( for(i = 0; i < depth; i++) { fprintf(fp, " "); } - fprintf(fp, "%3d: %p (%p - %p) @", + fprintf(fp, "%3d: %p (%p - %p) @", block->vertex, block, block->first, block->last); ins = block->first; while(ins != block->last && (ins->occurance->line == 0)) { @@ -15955,7 +15966,7 @@ static int print_frontiers( fprintf(fp, " %d", user->member->vertex); } fprintf(fp, "\n"); - + for(edge = block->edges; edge; edge = edge->next) { vertex = print_frontiers(state, fp, edge->member, vertex); } @@ -15966,7 +15977,7 @@ static void print_dominance_frontiers(struct compile_state *state, { fprintf(fp, "\ndominance frontiers\n"); print_frontiers(state, fp, bb->first_block, 0); - + } static void analyze_idominators(struct compile_state *state, struct basic_blocks *bb) @@ -16032,7 +16043,7 @@ static void print_ipdominance_frontiers(struct compile_state *state, { fprintf(fp, "\nipdominance frontiers\n"); print_pfrontiers(state, fp, bb->last_block, 0); - + } static void analyze_ipdominators(struct compile_state *state, @@ -16068,7 +16079,7 @@ static int tdominates(struct compile_state *state, bsub = block_of_triple(state, sub); if (bdom != bsub) { result = bdominates(state, bdom, bsub); - } + } else { struct triple *ins; if (!bdom || !bsub) { @@ -16114,7 +16125,7 @@ static void insert_phi_operations(struct compile_state *state) if (!triple_is_auto_var(state, var) || !var->use) { continue; } - + iter += 1; work_list = 0; work_list_tail = &work_list; @@ -16127,7 +16138,7 @@ static void insert_phi_operations(struct compile_state *state) continue; } if (user->member->op != OP_WRITE) { - internal_error(state, user->member, + internal_error(state, user->member, "bad variable access"); } block = user->member->u.block; @@ -16160,7 +16171,7 @@ static void insert_phi_operations(struct compile_state *state) /* Insert a phi function for this variable */ get_occurance(var->occurance); phi = alloc_triple( - state, OP_PHI, var->type, -1, in_edges, + state, OP_PHI, var->type, -1, in_edges, var->occurance); phi->u.block = front; MISC(phi, 0) = var; @@ -16563,7 +16574,7 @@ static void prune_unused_phis(struct compile_state *state) struct triple *first, *phi; struct phi_triple *live; int phis, i; - + /* Find the first instruction */ first = state->first; @@ -16574,7 +16585,7 @@ static void prune_unused_phis(struct compile_state *state) phis += 1; } } - + /* Mark them all dead */ live = xcmalloc(sizeof(*live) * (phis + 1), "phi_triple"); phis = 0; @@ -16588,7 +16599,7 @@ static void prune_unused_phis(struct compile_state *state) phi->id = phis; phis += 1; } - + /* Mark phis alive that are used by non phis */ for(i = 0; i < phis; i++) { struct triple_set *set; @@ -16621,7 +16632,7 @@ static void prune_unused_phis(struct compile_state *state) slot[j] = unknown; use_triple(unknown, phi); transform_to_arch_instruction(state, unknown); -#if 0 +#if 0 warning(state, phi, "variable not set at index %d on all paths to use", j); #endif } @@ -16755,7 +16766,7 @@ static void transform_from_ssa_form(struct compile_state *state) } var = post_triple(state, phi, OP_ADECL, phi->type, 0, 0); var = var->next; /* point at the var */ - + /* Replaces use of phi with var */ propogate_use(state, phi, var); @@ -16808,7 +16819,7 @@ static void transform_from_ssa_form(struct compile_state *state) if (!eblock->first) { internal_error(state, 0, "empty block?"); } - + /* Make certain the write is placed in the edge block... */ /* Walk through the edge block backwards to find an * appropriate location for the OP_WRITE. @@ -16855,7 +16866,7 @@ static void transform_from_ssa_form(struct compile_state *state) /* Release the phi function */ release_triple(state, phi); } - + /* Walk all of the operations to find the adecls */ for(var = first->next; var != first ; var = var->next) { struct triple_set *use, *use_next; @@ -16872,7 +16883,7 @@ static void transform_from_ssa_form(struct compile_state *state) int zrhs, i, used; use_next = use->next; user = use->member; - + /* Generate a read of var */ read = pre_triple(state, user, OP_READ, var->type, var, 0); use_triple(var, read); @@ -16891,7 +16902,7 @@ static void transform_from_ssa_form(struct compile_state *state) if (used) { unuse_triple(var, user); use_triple(read, user); - } + } /* If we didn't use it release the extra triple */ else { release_triple(state, read); @@ -16903,7 +16914,7 @@ static void transform_from_ssa_form(struct compile_state *state) #define HI() if (state->compiler->debug & DEBUG_REBUILD_SSA_FORM) { \ FILE *fp = state->dbgout; \ fprintf(fp, "@ %s:%d\n", __FILE__, __LINE__); romcc_print_blocks(state, fp); \ - } + } static void rebuild_ssa_form(struct compile_state *state) { @@ -16918,7 +16929,7 @@ HI(); HI(); rename_variables(state); HI(); - + prune_block_variables(state, state->bb.first_block); HI(); prune_unused_phis(state); @@ -16926,7 +16937,7 @@ HI(); } #undef HI -/* +/* * Register conflict resolution * ========================================================= */ @@ -16956,7 +16967,7 @@ static struct reg_info find_def_color( if (tinfo.reg >= MAX_REGISTERS) { tinfo.reg = REG_UNSET; } - if ((tinfo.reg != REG_UNSET) && + if ((tinfo.reg != REG_UNSET) && (info.reg != REG_UNSET) && (tinfo.reg != info.reg)) { internal_error(state, def, "register conflict"); @@ -17209,7 +17220,7 @@ static struct triple *typed_pre_copy( use_triple(in, ins); transform_to_arch_instruction(state, in); return in; - + } static struct triple *pre_copy( struct compile_state *state, struct triple *ins, int index) @@ -17266,7 +17277,7 @@ static void insert_copies_to_phi(struct compile_state *state) move->u.block = eblock; move->id |= TRIPLE_FLAG_PRE_SPLIT; use_triple(val, move); - + slot[edge] = move; unuse_triple(val, phi); use_triple(move, phi); @@ -17323,7 +17334,7 @@ struct triple_reg_set; struct reg_block; -static int do_triple_set(struct triple_reg_set **head, +static int do_triple_set(struct triple_reg_set **head, struct triple *member, struct triple *new_member) { struct triple_reg_set **ptr, *new; @@ -17441,7 +17452,7 @@ static struct triple *part_to_piece(struct compile_state *state, struct triple * return ins; } -static int this_def(struct compile_state *state, +static int this_def(struct compile_state *state, struct triple *ins, struct triple *other) { if (ins == other) { @@ -17619,7 +17630,7 @@ static struct reg_block *compute_variable_lifetimes( return blocks; } -static void free_variable_lifetimes(struct compile_state *state, +static void free_variable_lifetimes(struct compile_state *state, struct basic_blocks *bb, struct reg_block *blocks) { int i; @@ -17642,16 +17653,16 @@ static void free_variable_lifetimes(struct compile_state *state, } typedef void (*wvl_cb_t)( - struct compile_state *state, - struct reg_block *blocks, struct triple_reg_set *live, + struct compile_state *state, + struct reg_block *blocks, struct triple_reg_set *live, struct reg_block *rb, struct triple *ins, void *arg); static void walk_variable_lifetimes(struct compile_state *state, - struct basic_blocks *bb, struct reg_block *blocks, + struct basic_blocks *bb, struct reg_block *blocks, wvl_cb_t cb, void *arg) { int i; - + for(i = 1; i <= state->bb.last_vertex; i++) { struct triple_reg_set *live; struct triple_reg_set *entry, *next; @@ -17686,7 +17697,7 @@ static void walk_variable_lifetimes(struct compile_state *state, * going on. */ cb(state, blocks, live, rb, ptr, arg); - + /* Remove the current definition from live */ do_triple_unset(&live, ptr); @@ -17739,7 +17750,7 @@ static void print_live_variables_block( block, block->vertex); for(edge = block->edges; edge; edge = edge->next) { fprintf(fp, " %p<-%p", - edge->member, + edge->member, edge->member && edge->member->use?edge->member->use->member : 0); } fprintf(fp, "\n"); @@ -17793,7 +17804,7 @@ static void print_live_variables_block( fprintf(fp, "\n"); } -static void print_live_variables(struct compile_state *state, +static void print_live_variables(struct compile_state *state, struct basic_blocks *bb, struct reg_block *rb, FILE *fp) { struct print_live_variable_info info; @@ -17829,7 +17840,7 @@ struct dead_triple { #define TRIPLE_FLAG_FREE 1 }; -static void print_dead_triples(struct compile_state *state, +static void print_dead_triples(struct compile_state *state, struct dead_triple *dtriple) { struct triple *first, *ins; @@ -17847,7 +17858,7 @@ static void print_dead_triples(struct compile_state *state, if ((ins->op == OP_LABEL) && (ins->use)) { fprintf(fp, "\n%p:\n", ins); } - fprintf(fp, "%c", + fprintf(fp, "%c", (dt->flags & TRIPLE_FLAG_ALIVE)?' ': '-'); display_triple(fp, ins); if (triple_is_branch(state, ins)) { @@ -17893,10 +17904,9 @@ static void awaken( static void eliminate_inefectual_code(struct compile_state *state) { - struct block *block; struct dead_triple *dtriple, *work_list, **work_list_tail, *dt; int triples, i; - struct triple *first, *final, *ins; + struct triple *first, *ins; if (!(state->compiler->flags & COMPILER_ELIMINATE_INEFECTUAL_CODE)) { return; @@ -17907,17 +17917,15 @@ static void eliminate_inefectual_code(struct compile_state *state) work_list_tail = &work_list; first = state->first; - final = state->first->prev; /* Count how many triples I have */ triples = count_triples(state); /* Now put then in an array and mark all of the triples dead */ dtriple = xcmalloc(sizeof(*dtriple) * (triples + 1), "dtriples"); - + ins = first; i = 1; - block = 0; do { dtriple[i].triple = ins; dtriple[i].block = block_of_triple(state, ins); @@ -17985,7 +17993,7 @@ static void eliminate_inefectual_code(struct compile_state *state) } print_dead_triples(state, dtriple); for(dt = &dtriple[1]; dt <= &dtriple[triples]; dt++) { - if ((dt->triple->op == OP_NOOP) && + if ((dt->triple->op == OP_NOOP) && (dt->flags & TRIPLE_FLAG_ALIVE)) { internal_error(state, dt->triple, "noop effective?"); } @@ -18044,13 +18052,13 @@ static void insert_mandatory_copies(struct compile_state *state) if (i < 0) { continue; } - + /* Find the users color requirements */ rinfo = arch_reg_rhs(state, entry->member, i); if (rinfo.reg >= MAX_REGISTERS) { rinfo.reg = REG_UNSET; } - + /* See if I need a pre_copy */ if (rinfo.reg != REG_UNSET) { if ((reg != REG_UNSET) && (reg != rinfo.reg)) { @@ -18067,14 +18075,14 @@ static void insert_mandatory_copies(struct compile_state *state) * They do not take up any registers until a * copy places them in one. */ - if ((info.reg == REG_UNNEEDED) && + if ((info.reg == REG_UNNEEDED) && (rinfo.reg != REG_UNNEEDED)) { do_pre_copy = 1; } } do_post_copy = !do_pre_copy && - (((info.reg != REG_UNSET) && + (((info.reg != REG_UNSET) && (reg != REG_UNSET) && (info.reg != reg)) || ((info.regcm & regcm) == 0)); @@ -18090,7 +18098,7 @@ static void insert_mandatory_copies(struct compile_state *state) if (i < 0) { continue; } - + /* Find the users color requirements */ rinfo = arch_reg_rhs(state, entry->member, i); if (rinfo.reg >= MAX_REGISTERS) { @@ -18139,7 +18147,7 @@ static void insert_mandatory_copies(struct compile_state *state) } } regcm &= rinfo.regcm; - + } if (do_post_copy) { struct reg_info pre, post; @@ -18233,7 +18241,7 @@ static void print_interference_block( block, block->vertex); for(edge = block->edges; edge; edge = edge->next) { fprintf(fp, " %p<-%p", - edge->member, + edge->member, edge->member && edge->member->use?edge->member->use->member : 0); } fprintf(fp, "\n"); @@ -18275,11 +18283,9 @@ static void print_interference_block( for(done = 0, ptr = block->first; !done; ptr = ptr->next) { struct live_range *lr; unsigned id; - int op; - op = ptr->op; done = (ptr == block->last); lr = rstate->lrd[ptr->id].lr; - + id = ptr->id; ptr->id = rstate->lrd[id].orig_id; SET_REG(ptr->id, lr->color); @@ -18444,7 +18450,7 @@ static struct lre_hash **lre_probe(struct reg_state *rstate, right = tmp; } index = hash_live_edge(left, right); - + ptr = &rstate->hash[index]; while(*ptr) { if (((*ptr)->left == left) && ((*ptr)->right == right)) { @@ -18463,7 +18469,7 @@ static int interfere(struct reg_state *rstate, return ptr && *ptr; } -static void add_live_edge(struct reg_state *rstate, +static void add_live_edge(struct reg_state *rstate, struct live_range *left, struct live_range *right) { /* FIXME the memory allocation overhead is noticeable here... */ @@ -18502,7 +18508,7 @@ static void add_live_edge(struct reg_state *rstate, edge->node = right; left->edges = edge; left->degree += 1; - + edge = xmalloc(sizeof(*edge), "live_range_edge"); edge->next = right->edges; edge->node = left; @@ -18554,7 +18560,7 @@ static void remove_live_edges(struct reg_state *rstate, struct live_range *range } } -static void transfer_live_edges(struct reg_state *rstate, +static void transfer_live_edges(struct reg_state *rstate, struct live_range *dest, struct live_range *src) { struct live_range_edge *edge, *next; @@ -18569,7 +18575,7 @@ static void transfer_live_edges(struct reg_state *rstate, /* Interference graph... - * + * * new(n) --- Return a graph with n nodes but no edges. * add(g,x,y) --- Return a graph including g with an between x and y * interfere(g, x, y) --- Return true if there exists an edge between the nodes @@ -18582,11 +18588,11 @@ static void transfer_live_edges(struct reg_state *rstate, * The adjacency vectors support an efficient implementation of neighbors. */ -/* +/* * +---------------------------------------------------+ * | +--------------+ | * v v | | - * renumber -> build graph -> colalesce -> spill_costs -> simplify -> select + * renumber -> build graph -> colalesce -> spill_costs -> simplify -> select * * -- In simplify implment optimistic coloring... (No backtracking) * -- Implement Rematerialization it is the only form of spilling we can perform @@ -18602,7 +18608,7 @@ static void transfer_live_edges(struct reg_state *rstate, #if DEBUG_ROMCC_WARNING static void different_colored( - struct compile_state *state, struct reg_state *rstate, + struct compile_state *state, struct reg_state *rstate, struct triple *parent, struct triple *ins) { struct live_range *lr; @@ -18638,13 +18644,13 @@ static struct live_range *coalesce_ranges( } if ((lr1->color == REG_UNNEEDED) || (lr2->color == REG_UNNEEDED)) { - internal_error(state, 0, + internal_error(state, 0, "cannot coalesce live ranges without a possible color"); } if ((lr1->color != lr2->color) && (lr1->color != REG_UNSET) && (lr2->color != REG_UNSET)) { - internal_error(state, lr1->defs->def, + internal_error(state, lr1->defs->def, "cannot coalesce live ranges of different colors"); } color = lr1->color; @@ -18675,7 +18681,7 @@ static struct live_range *coalesce_ranges( /* If there is a clear dominate live range put it in lr1, * For purposes of this test phi functions are * considered dominated by the definitions that feed into - * them. + * them. */ if ((lr1->defs->prev->def->op == OP_PHI) || ((lr2->defs->prev->def->op != OP_PHI) && @@ -18706,12 +18712,12 @@ static struct live_range *coalesce_ranges( lr2->defs->def, lr2->color); #endif - + /* Append lr2 onto lr1 */ #if DEBUG_ROMCC_WARNINGS #warning "FIXME should this be a merge instead of a splice?" #endif - /* This FIXME item applies to the correctness of live_range_end + /* This FIXME item applies to the correctness of live_range_end * and to the necessity of making multiple passes of coalesce_live_ranges. * A failure to find some coalesce opportunities in coaleace_live_ranges * does not impact the correct of the compiler just the efficiency with @@ -18721,7 +18727,7 @@ static struct live_range *coalesce_ranges( mid1 = lr1->defs->prev; mid2 = lr2->defs; end = lr2->defs->prev; - + head->prev = end; end->next = head; @@ -18826,7 +18832,7 @@ static void initialize_live_ranges( rstate->lr[i].classes = info.regcm; rstate->lr[i].degree = 0; rstate->lrd[j].lr = &rstate->lr[i]; - } + } /* Otherwise give the triple the dummy live range. */ else { rstate->lrd[j].lr = &rstate->lr[0]; @@ -18853,7 +18859,7 @@ static void initialize_live_ranges( if (ins->id > rstate->defs) { internal_error(state, ins, "bad id"); } - + /* Walk through the template of ins and coalesce live ranges */ zlhs = ins->lhs; if ((zlhs == 0) && triple_is_def(state, ins)) { @@ -18899,7 +18905,7 @@ static void initialize_live_ranges( } if (rinfo.reg == linfo.reg) { - coalesce_ranges(state, rstate, + coalesce_ranges(state, rstate, lhs->lr, rhs->lr); } } @@ -18909,8 +18915,8 @@ static void initialize_live_ranges( } static void graph_ins( - struct compile_state *state, - struct reg_block *blocks, struct triple_reg_set *live, + struct compile_state *state, + struct reg_block *blocks, struct triple_reg_set *live, struct reg_block *rb, struct triple *ins, void *arg) { struct reg_state *rstate = arg; @@ -18925,7 +18931,7 @@ static void graph_ins( return; } def = rstate->lrd[ins->id].lr; - + /* Create an edge between ins and everything that is * alive, unless the live_range cannot share * a physical register with ins. @@ -18973,8 +18979,8 @@ static struct live_range *get_verify_live_range( } static void verify_graph_ins( - struct compile_state *state, - struct reg_block *blocks, struct triple_reg_set *live, + struct compile_state *state, + struct reg_block *blocks, struct triple_reg_set *live, struct reg_block *rb, struct triple *ins, void *arg) { struct reg_state *rstate = arg; @@ -18995,17 +19001,17 @@ static void verify_graph_ins( } lr2 = get_verify_live_range(state, rstate, entry2->member); if (lr1 == lr2) { - internal_error(state, entry2->member, + internal_error(state, entry2->member, "live range with 2 values simultaneously alive"); } if (!arch_regcm_intersect(lr1->classes, lr2->classes)) { continue; } if (!interfere(rstate, lr1, lr2)) { - internal_error(state, entry2->member, + internal_error(state, entry2->member, "edges don't interfere?"); } - + lr1_found = 0; lr2_degree = 0; for(edge2 = lr2->edges; edge2; edge2 = edge2->next) { @@ -19029,8 +19035,8 @@ static void verify_graph_ins( #endif static void print_interference_ins( - struct compile_state *state, - struct reg_block *blocks, struct triple_reg_set *live, + struct compile_state *state, + struct reg_block *blocks, struct triple_reg_set *live, struct reg_block *rb, struct triple *ins, void *arg) { struct reg_state *rstate = arg; @@ -19100,7 +19106,7 @@ static int coalesce_live_ranges( * Forcing a value to stay in a single register * for an extended period of time does have * limitations when applied to non homogenous - * register pool. + * register pool. * * The two cases I have identified are: * 1) Two forced register assignments may @@ -19118,7 +19124,7 @@ static int coalesce_live_ranges( * functions. This creates a 2 headed live * range that cannot be sanely split. * - * - phi functions (coalesced in initialize_live_ranges) + * - phi functions (coalesced in initialize_live_ranges) * are handled as pre split live ranges so we will * never attempt to split them. */ @@ -19168,7 +19174,7 @@ static int coalesce_live_ranges( if ((lr1->classes & lr2->classes) == 0) { continue; } - + if (interfere(rstate, lr1, lr2)) { continue; } @@ -19243,7 +19249,7 @@ static int correct_coalesce_conflicts( { int conflicts; conflicts = 0; - walk_variable_lifetimes(state, &state->bb, blocks, + walk_variable_lifetimes(state, &state->bb, blocks, fix_coalesce_conflicts, &conflicts); return conflicts; } @@ -19259,7 +19265,7 @@ static void replace_set_use(struct compile_state *state, } } -static void replace_block_use(struct compile_state *state, +static void replace_block_use(struct compile_state *state, struct reg_block *blocks, struct triple *orig, struct triple *new) { int i; @@ -19351,7 +19357,7 @@ static struct triple *resolve_tangle( } info = find_lhs_color(state, tangle, 0); SET_INFO(tangle->id, info); - + return copy; } @@ -19377,7 +19383,7 @@ static void fix_tangles(struct compile_state *state, } reg_inc_used(state, used, info.reg); } - + /* Now find the least dominated definition of a register in * conflict I have seen so far. */ @@ -19390,7 +19396,7 @@ static void fix_tangles(struct compile_state *state, /* Changing copies that feed into phi functions * is incorrect. */ - if (set->member->use && + if (set->member->use && (set->member->use->member->op == OP_PHI)) { continue; } @@ -19420,7 +19426,7 @@ static int correct_tangles( int tangles; tangles = 0; color_instructions(state); - walk_variable_lifetimes(state, &state->bb, blocks, + walk_variable_lifetimes(state, &state->bb, blocks, fix_tangles, &tangles); return tangles; } @@ -19451,7 +19457,7 @@ struct triple *find_constrained_def( if (regcm == info.regcm) { continue; } - + /* If there is just one use. * That use cannot accept a larger register class. * There are no intervening definitions except @@ -19462,7 +19468,7 @@ struct triple *find_constrained_def( #if DEBUG_ROMCC_WARNINGS #warning "FIXME ignore cases that cannot be fixed (a definition followed by a use)" #endif - + /* Of the constrained live ranges deal with the * least dominated one first. @@ -19471,7 +19477,7 @@ struct triple *find_constrained_def( fprintf(state->errout, "canidate: %p %-8s regcm: %x %x\n", lrd->def, tops(lrd->def->op), regcm, info.regcm); } - if (!constrained || + if (!constrained || tdominates(state, lrd->def, constrained)) { constrained = lrd->def; @@ -19481,13 +19487,13 @@ struct triple *find_constrained_def( } static int split_constrained_ranges( - struct compile_state *state, struct reg_state *rstate, + struct compile_state *state, struct reg_state *rstate, struct live_range *range) { /* Walk through the edges in conflict and our current live * range, and find definitions that are more severly constrained * than they type of data they contain require. - * + * * Then pick one of those ranges and relax the constraints. */ struct live_range_edge *edge; @@ -19515,14 +19521,14 @@ static int split_constrained_ranges( } return !!constrained; } - + static int split_ranges( struct compile_state *state, struct reg_state *rstate, char *used, struct live_range *range) { int split; if (state->compiler->debug & DEBUG_RANGE_CONFLICTS) { - fprintf(state->errout, "split_ranges %d %s %p\n", + fprintf(state->errout, "split_ranges %d %s %p\n", rstate->passes, tops(range->defs->def->op), range->defs->def); } if ((range->color == REG_UNNEEDED) || @@ -19532,7 +19538,7 @@ static int split_ranges( split = split_constrained_ranges(state, rstate, range); /* Ideally I would split the live range that will not be used - * for the longest period of time in hopes that this will + * for the longest period of time in hopes that this will * (a) allow me to spill a register or * (b) allow me to place a value in another register. * @@ -19546,7 +19552,7 @@ static int split_ranges( #if DEBUG_ROMCC_WARNINGS #warning "WISHLIST implement live range splitting..." #endif - + if (!split && (state->compiler->debug & DEBUG_RANGE_CONFLICTS2)) { FILE *fp = state->errout; print_interference_blocks(state, rstate, fp, 0); @@ -19598,7 +19604,7 @@ static void cgdebug_loc(struct compile_state *state, struct triple *ins) } } -static int select_free_color(struct compile_state *state, +static int select_free_color(struct compile_state *state, struct reg_state *rstate, struct live_range *range) { struct triple_set *entry; @@ -19628,7 +19634,7 @@ static int select_free_color(struct compile_state *state, for(edge = range->edges; edge; edge = edge->next) { i++; } - cgdebug_printf(state, "\n%s edges: %d", + cgdebug_printf(state, "\n%s edges: %d", tops(range->defs->def->op), i); cgdebug_loc(state, range->defs->def); cgdebug_printf(state, "\n"); @@ -19638,7 +19644,7 @@ static int select_free_color(struct compile_state *state, arch_reg_str(i)); } } - } + } /* If a color is already assigned see if it will work */ if (range->color != REG_UNSET) { @@ -19766,7 +19772,7 @@ static int select_free_color(struct compile_state *state, * pick the first color that is free. */ if (range->color == REG_UNSET) { - range->color = + range->color = arch_select_free_register(state, used, range->classes); } if (range->color == REG_UNSET) { @@ -19792,7 +19798,7 @@ static int select_free_color(struct compile_state *state, tops(lrd->def->op), lrd->def); lrd = lrd->next; } while(lrd != range->defs); - + warning(state, range->defs->def, "classes: %x", range->classes); for(i = 0; i < MAX_REGISTERS; i++) { @@ -19905,7 +19911,7 @@ static void verify_colors(struct compile_state *state, struct reg_state *rstate) do { if (triple_is_def(state, ins)) { if ((ins->id < 0) || (ins->id > rstate->defs)) { - internal_error(state, ins, + internal_error(state, ins, "triple without a live range def"); } lr = rstate->lrd[ins->id].lr; @@ -19940,7 +19946,7 @@ static void color_triples(struct compile_state *state, struct reg_state *rstate) ins = first; do { if ((ins->id < 0) || (ins->id > rstate->defs)) { - internal_error(state, ins, + internal_error(state, ins, "triple without a live range"); } lrd = &rstate->lrd[ins->id]; @@ -19961,7 +19967,7 @@ static struct live_range *merge_sort_lr( mid = first + size/2; first = merge_sort_lr(first, mid -1); mid = merge_sort_lr(mid, last); - + join = 0; join_tail = &join; /* merge the two lists */ @@ -19990,7 +19996,7 @@ static struct live_range *merge_sort_lr( /* Splice the remaining list */ pick = (first)? first : mid; *join_tail = pick; - if (pick) { + if (pick) { pick->group_prev = join_tail; } } @@ -20003,7 +20009,7 @@ static struct live_range *merge_sort_lr( return join; } -static void ids_from_rstate(struct compile_state *state, +static void ids_from_rstate(struct compile_state *state, struct reg_state *rstate) { struct triple *ins, *first; @@ -20067,7 +20073,6 @@ static void allocate_registers(struct compile_state *state) do { struct live_range **point, **next; - int conflicts; int tangles; int coalesced; @@ -20087,7 +20092,7 @@ static void allocate_registers(struct compile_state *state) rstate.blocks = compute_variable_lifetimes(state, &state->bb); /* Fix invalid mandatory live range coalesce conflicts */ - conflicts = correct_coalesce_conflicts(state, rstate.blocks); + correct_coalesce_conflicts(state, rstate.blocks); /* Fix two simultaneous uses of the same register. * In a few pathlogical cases a partial untangle moves @@ -20099,14 +20104,14 @@ static void allocate_registers(struct compile_state *state) tangles = correct_tangles(state, rstate.blocks); } while(tangles); - + print_blocks(state, "resolve_tangles", state->dbgout); verify_consistency(state); - + /* Allocate and initialize the live ranges */ initialize_live_ranges(state, &rstate); - /* Note currently doing coalescing in a loop appears to + /* Note currently doing coalescing in a loop appears to * buys me nothing. The code is left this way in case * there is some value in it. Or if a future bugfix * yields some benefit. @@ -20121,18 +20126,18 @@ static void allocate_registers(struct compile_state *state) /* Compute the interference graph */ walk_variable_lifetimes( - state, &state->bb, rstate.blocks, + state, &state->bb, rstate.blocks, graph_ins, &rstate); - + /* Display the interference graph if desired */ if (state->compiler->debug & DEBUG_INTERFERENCE) { print_interference_blocks(state, &rstate, state->dbgout, 1); fprintf(state->dbgout, "\nlive variables by instruction\n"); walk_variable_lifetimes( - state, &state->bb, rstate.blocks, + state, &state->bb, rstate.blocks, print_interference_ins, &rstate); } - + coalesced = coalesce_live_ranges(state, &rstate); if (state->compiler->debug & DEBUG_COALESCING) { @@ -20146,13 +20151,13 @@ static void allocate_registers(struct compile_state *state) # endif /* Verify the interference graph */ walk_variable_lifetimes( - state, &state->bb, rstate.blocks, + state, &state->bb, rstate.blocks, verify_graph_ins, &rstate); # if 0 fprintf(state->errout, "verify_graph_ins done\n"); #endif #endif - + /* Build the groups low and high. But with the nodes * first sorted by degree order. */ @@ -20172,13 +20177,13 @@ static void allocate_registers(struct compile_state *state) struct live_range *range; next = &(*point)->group_next; range = *point; - + /* If it has a low degree or it already has a color * place the node in low. */ if ((range->degree < regc_max_size(state, range->classes)) || (range->color != REG_UNSET)) { - cgdebug_printf(state, "Lo: %5d degree %5d%s\n", + cgdebug_printf(state, "Lo: %5d degree %5d%s\n", range - rstate.lr, range->degree, (range->color != REG_UNSET) ? " (colored)": ""); *range->group_prev = range->group_next; @@ -20195,7 +20200,7 @@ static void allocate_registers(struct compile_state *state) next = point; } else { - cgdebug_printf(state, "hi: %5d degree %5d%s\n", + cgdebug_printf(state, "hi: %5d degree %5d%s\n", range - rstate.lr, range->degree, (range->color != REG_UNSET) ? " (colored)": ""); } @@ -20288,7 +20293,7 @@ static int is_lattice_lo(struct compile_state *state, struct lattice_node *lnode return (lnode->val != lnode->def) && !is_scc_const(state, lnode->val); } -static void scc_add_fedge(struct compile_state *state, struct scc_state *scc, +static void scc_add_fedge(struct compile_state *state, struct scc_state *scc, struct flow_edge *fedge) { if (state->compiler->debug & DEBUG_SCC_TRANSFORM2) { @@ -20418,12 +20423,12 @@ static void initialize_scc_state( ins_count, ssa_edge_count, state->bb.last_vertex); } scc->ins_count = ins_count; - scc->lattice = + scc->lattice = xcmalloc(sizeof(*scc->lattice)*(ins_count + 1), "lattice"); - scc->ssa_edges = + scc->ssa_edges = xcmalloc(sizeof(*scc->ssa_edges)*(ssa_edge_count + 1), "ssa_edges"); - scc->flow_blocks = - xcmalloc(sizeof(*scc->flow_blocks)*(state->bb.last_vertex + 1), + scc->flow_blocks = + xcmalloc(sizeof(*scc->flow_blocks)*(state->bb.last_vertex + 1), "flow_blocks"); /* Initialize pass one collect up the nodes */ @@ -20562,7 +20567,7 @@ static void initialize_scc_state( fedge->out_next = 0; fedge->executable = 0; fedge->dst->in = fedge; - + /* Initialize the work lists */ scc->flow_work_list = 0; scc->ssa_work_list = 0; @@ -20574,7 +20579,7 @@ static void initialize_scc_state( } } - + static void free_scc_state( struct compile_state *state, struct scc_state *scc) { @@ -20590,7 +20595,7 @@ static void free_scc_state( xfree(scc->flow_blocks); xfree(scc->ssa_edges); xfree(scc->lattice); - + } static struct lattice_node *triple_to_lattice( @@ -20619,7 +20624,7 @@ static struct triple *preserve_lval( return old; } -static int lval_changed(struct compile_state *state, +static int lval_changed(struct compile_state *state, struct triple *old, struct lattice_node *lnode) { int changed; @@ -20654,7 +20659,7 @@ static void scc_debug_lnode( struct triple *val, **expr; val = lnode->val? lnode->val : lnode->def; fprintf(fp, "%p %s %3d %10s (", - lnode->def, + lnode->def, ((lnode->def->op == OP_PHI)? "phi: ": "expr:"), lnode->def->id, tops(lnode->def->op)); @@ -20682,7 +20687,7 @@ static int compute_lnode_val(struct compile_state *state, struct scc_state *scc, struct triple *old, *scratch; struct triple **dexpr, **vexpr; int count, i; - + /* Store the original value */ old = preserve_lval(state, lnode); @@ -20739,9 +20744,9 @@ static int compute_lnode_val(struct compile_state *state, struct scc_state *scc, lnode->val = 0; /* Lattice low by definition */ } /* Find the case when I am lattice high */ - if (lnode->val && + if (lnode->val && (lnode->val->op == lnode->def->op) && - (memcmp(lnode->val->param, lnode->def->param, + (memcmp(lnode->val->param, lnode->def->param, count * sizeof(lnode->val->param[0])) == 0) && (memcmp(&lnode->val->u, &lnode->def->u, sizeof(lnode->def->u)) == 0)) { lnode->val = lnode->def; @@ -20764,7 +20769,7 @@ static int compute_lnode_val(struct compile_state *state, struct scc_state *scc, } } /* Find the cases that are always lattice lo */ - if (lnode->val && + if (lnode->val && triple_is_def(state, lnode->val) && !triple_is_pure(state, lnode->val, lnode->old_id)) { lnode->val = 0; @@ -20772,7 +20777,7 @@ static int compute_lnode_val(struct compile_state *state, struct scc_state *scc, /* See if the lattice value has changed */ changed = lval_changed(state, old, lnode); /* See if this value should not change */ - if ((lnode->val != lnode->def) && + if ((lnode->val != lnode->def) && (( !triple_is_def(state, lnode->def) && !triple_is_cbranch(state, lnode->def)) || (lnode->def->op == OP_PIECE))) { @@ -20789,7 +20794,7 @@ static int compute_lnode_val(struct compile_state *state, struct scc_state *scc, if (lnode->val != scratch) { xfree(scratch); } - + return changed; } @@ -20816,7 +20821,7 @@ static void scc_visit_cbranch(struct compile_state *state, struct scc_state *scc fprintf(fp, "%s: %d (", tops(lnode->def->op), lnode->def->id); - + for(fedge = lnode->fblock->out; fedge; fedge = fedge->out_next) { fprintf(fp, " %d", fedge->dst->block->vertex); } @@ -20864,7 +20869,7 @@ static void scc_visit_cbranch(struct compile_state *state, struct scc_state *scc } -static void scc_add_sedge_dst(struct compile_state *state, +static void scc_add_sedge_dst(struct compile_state *state, struct scc_state *scc, struct ssa_edge *sedge) { if (triple_is_cbranch(state, sedge->dst->def)) { @@ -20875,7 +20880,7 @@ static void scc_add_sedge_dst(struct compile_state *state, } } -static void scc_visit_phi(struct compile_state *state, struct scc_state *scc, +static void scc_visit_phi(struct compile_state *state, struct scc_state *scc, struct lattice_node *lnode) { struct lattice_node *tmp; @@ -20895,7 +20900,7 @@ static void scc_visit_phi(struct compile_state *state, struct scc_state *scc, index = 0; for(fedge = lnode->fblock->in; fedge; index++, fedge = fedge->in_next) { if (state->compiler->debug & DEBUG_SCC_TRANSFORM) { - fprintf(state->errout, "Examining edge: %d vertex: %d executable: %d\n", + fprintf(state->errout, "Examining edge: %d vertex: %d executable: %d\n", index, fedge->dst->block->vertex, fedge->executable @@ -20983,14 +20988,14 @@ static void scc_writeback_values( struct flow_edge *fedge; int executable; executable = 0; - for(fedge = lnode->fblock->in; + for(fedge = lnode->fblock->in; !executable && fedge; fedge = fedge->in_next) { executable |= fedge->executable; } if (executable) { internal_warning(state, lnode->def, "lattice node %d %s->%s still high?", - ins->id, + ins->id, tops(lnode->def->op), tops(lnode->val->op)); } @@ -21006,7 +21011,7 @@ static void scc_writeback_values( mkconst(state, ins, lnode->val->u.cval); break; case OP_ADDRCONST: - mkaddr_const(state, ins, + mkaddr_const(state, ins, MISC(lnode->val, 0), lnode->val->u.cval); break; default: @@ -21065,9 +21070,9 @@ static void scc_transform(struct compile_state *state) reps++; } } - + if (state->compiler->debug & DEBUG_SCC_TRANSFORM) { - fprintf(state->errout, "vertex: %d reps: %d\n", + fprintf(state->errout, "vertex: %d reps: %d\n", block->vertex, reps); } @@ -21100,7 +21105,7 @@ static void scc_transform(struct compile_state *state) if (state->compiler->debug & DEBUG_SCC_TRANSFORM) { fprintf(state->errout, "sedge: %5ld (%5d -> %5d)\n", - sedge - scc.ssa_edges, + (unsigned long)sedge - (unsigned long)scc.ssa_edges, sedge->src->def->id, sedge->dst->def->id); } @@ -21120,11 +21125,11 @@ static void scc_transform(struct compile_state *state) } } } - + scc_writeback_values(state, &scc); free_scc_state(state, &scc); rebuild_ssa_form(state); - + print_blocks(state, __func__, state->dbgout); } @@ -21137,7 +21142,7 @@ static void transform_to_arch_instructions(struct compile_state *state) do { ins = transform_to_arch_instruction(state, ins); } while(ins != first); - + print_blocks(state, __func__, state->dbgout); } @@ -21208,7 +21213,7 @@ static void verify_uses(struct compile_state *state) } ins = ins->next; } while(ins != first); - + } static void verify_blocks_present(struct compile_state *state) { @@ -21222,14 +21227,14 @@ static void verify_blocks_present(struct compile_state *state) valid_ins(state, ins); if (triple_stores_block(state, ins)) { if (!ins->u.block) { - internal_error(state, ins, + internal_error(state, ins, "%p not in a block?", ins); } } ins = ins->next; } while(ins != first); - - + + } static int edge_present(struct compile_state *state, struct block *block, struct triple *edge) @@ -21314,12 +21319,12 @@ static void verify_blocks(struct compile_state *state) } } if (block->users != users) { - internal_error(state, block->first, + internal_error(state, block->first, "computed users %d != stored users %d", users, block->users); } if (!triple_stores_block(state, block->last->next)) { - internal_error(state, block->last->next, + internal_error(state, block->last->next, "cannot find next block"); } block = block->last->next->u.block; @@ -21341,7 +21346,7 @@ static void verify_domination(struct compile_state *state) if (!state->bb.first_block) { return; } - + first = state->first; ins = first; do { @@ -21368,7 +21373,7 @@ static void verify_domination(struct compile_state *state) bset = bset->next; } if (!bset) { - internal_error(state, set->member, + internal_error(state, set->member, "no edge for phi rhs %d", i); } use_point = bset->member->last; @@ -21377,11 +21382,11 @@ static void verify_domination(struct compile_state *state) if (use_point && !tdominates(state, ins, use_point)) { if (is_const(ins)) { - internal_warning(state, ins, + internal_warning(state, ins, "non dominated rhs use point %p?", use_point); } else { - internal_error(state, ins, + internal_error(state, ins, "non dominated rhs use point %p?", use_point); } } @@ -21446,7 +21451,7 @@ static void verify_piece(struct compile_state *state) static void verify_ins_colors(struct compile_state *state) { struct triple *first, *ins; - + first = state->first; ins = first; do { @@ -21563,7 +21568,7 @@ static void verify_consistency(struct compile_state *state) fprintf(state->dbgout, "consistency verified\n"); } } -#else +#else static void verify_consistency(struct compile_state *state) {} #endif /* DEBUG_CONSISTENCY */ @@ -21676,7 +21681,7 @@ static void print_op_asm(struct compile_state *state, param); } piece = (param < lhs)? LHS(ins, param) : RHS(ins, param - lhs); - fprintf(fp, "%s", + fprintf(fp, "%s", arch_reg_str(ID_REG(piece->id))); ptr = next -1; } @@ -21936,14 +21941,14 @@ static int arch_regcm_intersect(unsigned regcm1, unsigned regcm2) { /* See if two register classes may have overlapping registers */ unsigned gpr_mask = REGCM_GPR8 | REGCM_GPR8_LO | REGCM_GPR16_8 | REGCM_GPR16 | - REGCM_GPR32_8 | REGCM_GPR32 | + REGCM_GPR32_8 | REGCM_GPR32 | REGCM_DIVIDEND32 | REGCM_DIVIDEND64; /* Special case for the immediates */ if ((regcm1 & (REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8)) && ((regcm1 & ~(REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8)) == 0) && (regcm2 & (REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8)) && - ((regcm2 & ~(REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8)) == 0)) { + ((regcm2 & ~(REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8)) == 0)) { return 0; } return (regcm1 & regcm2) || @@ -21976,7 +21981,7 @@ static void arch_reg_equivs( *equiv++ = REG_DXAX; *equiv++ = REG_EDXEAX; break; - case REG_BL: + case REG_BL: #if X86_4_8BIT_GPRS *equiv++ = REG_BH; #endif @@ -22036,19 +22041,19 @@ static void arch_reg_equivs( *equiv++ = REG_BH; *equiv++ = REG_EBX; break; - case REG_CX: + case REG_CX: *equiv++ = REG_CL; *equiv++ = REG_CH; *equiv++ = REG_ECX; break; - case REG_DX: + case REG_DX: *equiv++ = REG_DL; *equiv++ = REG_DH; *equiv++ = REG_EDX; *equiv++ = REG_DXAX; *equiv++ = REG_EDXEAX; break; - case REG_SI: + case REG_SI: *equiv++ = REG_ESI; break; case REG_DI: @@ -22084,19 +22089,19 @@ static void arch_reg_equivs( *equiv++ = REG_DXAX; *equiv++ = REG_EDXEAX; break; - case REG_ESI: + case REG_ESI: *equiv++ = REG_SI; break; - case REG_EDI: + case REG_EDI: *equiv++ = REG_DI; break; - case REG_EBP: + case REG_EBP: *equiv++ = REG_BP; break; - case REG_ESP: + case REG_ESP: *equiv++ = REG_SP; break; - case REG_DXAX: + case REG_DXAX: *equiv++ = REG_AL; *equiv++ = REG_AH; *equiv++ = REG_DL; @@ -22107,7 +22112,7 @@ static void arch_reg_equivs( *equiv++ = REG_EDX; *equiv++ = REG_EDXEAX; break; - case REG_EDXEAX: + case REG_EDXEAX: *equiv++ = REG_AL; *equiv++ = REG_AH; *equiv++ = REG_DL; @@ -22119,15 +22124,15 @@ static void arch_reg_equivs( *equiv++ = REG_DXAX; break; } - *equiv++ = REG_UNSET; + *equiv++ = REG_UNSET; } static unsigned arch_avail_mask(struct compile_state *state) { unsigned avail_mask; /* REGCM_GPR8 is not available */ - avail_mask = REGCM_GPR8_LO | REGCM_GPR16_8 | REGCM_GPR16 | - REGCM_GPR32 | REGCM_GPR32_8 | + avail_mask = REGCM_GPR8_LO | REGCM_GPR16_8 | REGCM_GPR16 | + REGCM_GPR32 | REGCM_GPR32_8 | REGCM_DIVIDEND32 | REGCM_DIVIDEND64 | REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8 | REGCM_FLAGS; if (state->arch->features & X86_MMX_REGS) { @@ -22170,7 +22175,7 @@ static unsigned arch_regcm_reg_normalize(struct compile_state *state, unsigned r /* Remove the immediate register classes */ regcm &= ~(REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8); return regcm; - + } static unsigned arch_reg_regcm(struct compile_state *state, int reg) @@ -22314,7 +22319,7 @@ static struct reg_info arch_reg_clobber( return result; } -static int do_select_reg(struct compile_state *state, +static int do_select_reg(struct compile_state *state, char *used, int reg, unsigned classes) { unsigned mask; @@ -22339,7 +22344,7 @@ static int arch_select_free_register( * increase the odds the register allocator will work when * it guesses first give out registers from register classes * least likely to run out of registers. - * + * */ int i, reg; reg = REG_UNSET; @@ -22374,7 +22379,7 @@ static int arch_select_free_register( } -static unsigned arch_type_to_regcm(struct compile_state *state, struct type *type) +static unsigned arch_type_to_regcm(struct compile_state *state, struct type *type) { #if DEBUG_ROMCC_WARNINGS @@ -22384,13 +22389,13 @@ static unsigned arch_type_to_regcm(struct compile_state *state, struct type *typ mask = 0; switch(type->type & TYPE_MASK) { case TYPE_ARRAY: - case TYPE_VOID: - mask = 0; + case TYPE_VOID: + mask = 0; break; case TYPE_CHAR: case TYPE_UCHAR: mask = REGCM_GPR8 | REGCM_GPR8_LO | - REGCM_GPR16 | REGCM_GPR16_8 | + REGCM_GPR16 | REGCM_GPR16_8 | REGCM_GPR32 | REGCM_GPR32_8 | REGCM_DIVIDEND32 | REGCM_DIVIDEND64 | REGCM_MMX | REGCM_XMM | @@ -22439,9 +22444,12 @@ static unsigned arch_type_to_regcm(struct compile_state *state, struct type *typ static int is_imm32(struct triple *imm) { - return ((imm->op == OP_INTCONST) && (imm->u.cval <= 0xffffffffUL)) || + // second condition commented out to prevent compiler warning: + // imm->u.cval is always 32bit unsigned, so the comparison is + // always true. + return ((imm->op == OP_INTCONST) /* && (imm->u.cval <= 0xffffffffUL) */ ) || (imm->op == OP_ADDRCONST); - + } static int is_imm16(struct triple *imm) { @@ -22557,13 +22565,13 @@ static int get_imm8(struct triple *ins, struct triple **expr) #endif #define COPY8_REGCM (REGCM_DIVIDEND64 | REGCM_DIVIDEND32 | REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO | REGCM_MMX | REGCM_XMM) -#define COPY16_REGCM (REGCM_DIVIDEND64 | REGCM_DIVIDEND32 | REGCM_GPR32 | REGCM_GPR16 | REGCM_MMX | REGCM_XMM) +#define COPY16_REGCM (REGCM_DIVIDEND64 | REGCM_DIVIDEND32 | REGCM_GPR32 | REGCM_GPR16 | REGCM_MMX | REGCM_XMM) #define COPY32_REGCM (REGCM_DIVIDEND64 | REGCM_DIVIDEND32 | REGCM_GPR32 | REGCM_MMX | REGCM_XMM) static struct ins_template templates[] = { [TEMPLATE_NOP] = { - .lhs = { + .lhs = { [ 0] = { REG_UNNEEDED, REGCM_IMMALL }, [ 1] = { REG_UNNEEDED, REGCM_IMMALL }, [ 2] = { REG_UNNEEDED, REGCM_IMMALL }, @@ -22630,10 +22638,10 @@ static struct ins_template templates[] = { [63] = { REG_UNNEEDED, REGCM_IMMALL }, }, }, - [TEMPLATE_INTCONST8] = { + [TEMPLATE_INTCONST8] = { .lhs = { [0] = { REG_UNNEEDED, REGCM_IMM8 } }, }, - [TEMPLATE_INTCONST32] = { + [TEMPLATE_INTCONST32] = { .lhs = { [0] = { REG_UNNEEDED, REGCM_IMM32 } }, }, [TEMPLATE_UNKNOWNVAL] = { @@ -22663,32 +22671,32 @@ static struct ins_template templates[] = { .lhs = { [0] = { REG_UNSET, COPY32_REGCM } }, .rhs = { [0] = { REG_UNNEEDED, REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8 } }, }, - [TEMPLATE_PHI8] = { + [TEMPLATE_PHI8] = { .lhs = { [0] = { REG_VIRT0, COPY8_REGCM } }, .rhs = { [0] = { REG_VIRT0, COPY8_REGCM } }, }, - [TEMPLATE_PHI16] = { + [TEMPLATE_PHI16] = { .lhs = { [0] = { REG_VIRT0, COPY16_REGCM } }, - .rhs = { [0] = { REG_VIRT0, COPY16_REGCM } }, + .rhs = { [0] = { REG_VIRT0, COPY16_REGCM } }, }, - [TEMPLATE_PHI32] = { + [TEMPLATE_PHI32] = { .lhs = { [0] = { REG_VIRT0, COPY32_REGCM } }, - .rhs = { [0] = { REG_VIRT0, COPY32_REGCM } }, + .rhs = { [0] = { REG_VIRT0, COPY32_REGCM } }, }, [TEMPLATE_STORE8] = { - .rhs = { + .rhs = { [0] = { REG_UNSET, REGCM_GPR32 }, [1] = { REG_UNSET, REGCM_GPR8_LO }, }, }, [TEMPLATE_STORE16] = { - .rhs = { + .rhs = { [0] = { REG_UNSET, REGCM_GPR32 }, [1] = { REG_UNSET, REGCM_GPR16 }, }, }, [TEMPLATE_STORE32] = { - .rhs = { + .rhs = { [0] = { REG_UNSET, REGCM_GPR32 }, [1] = { REG_UNSET, REGCM_GPR32 }, }, @@ -22707,84 +22715,84 @@ static struct ins_template templates[] = { }, [TEMPLATE_BINARY8_REG] = { .lhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } }, - .rhs = { + .rhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO }, [1] = { REG_UNSET, REGCM_GPR8_LO }, }, }, [TEMPLATE_BINARY16_REG] = { .lhs = { [0] = { REG_VIRT0, REGCM_GPR16 } }, - .rhs = { + .rhs = { [0] = { REG_VIRT0, REGCM_GPR16 }, [1] = { REG_UNSET, REGCM_GPR16 }, }, }, [TEMPLATE_BINARY32_REG] = { .lhs = { [0] = { REG_VIRT0, REGCM_GPR32 } }, - .rhs = { + .rhs = { [0] = { REG_VIRT0, REGCM_GPR32 }, [1] = { REG_UNSET, REGCM_GPR32 }, }, }, [TEMPLATE_BINARY8_IMM] = { .lhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } }, - .rhs = { + .rhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO }, [1] = { REG_UNNEEDED, REGCM_IMM8 }, }, }, [TEMPLATE_BINARY16_IMM] = { .lhs = { [0] = { REG_VIRT0, REGCM_GPR16 } }, - .rhs = { + .rhs = { [0] = { REG_VIRT0, REGCM_GPR16 }, [1] = { REG_UNNEEDED, REGCM_IMM16 }, }, }, [TEMPLATE_BINARY32_IMM] = { .lhs = { [0] = { REG_VIRT0, REGCM_GPR32 } }, - .rhs = { + .rhs = { [0] = { REG_VIRT0, REGCM_GPR32 }, [1] = { REG_UNNEEDED, REGCM_IMM32 }, }, }, [TEMPLATE_SL8_CL] = { .lhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } }, - .rhs = { + .rhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO }, [1] = { REG_CL, REGCM_GPR8_LO }, }, }, [TEMPLATE_SL16_CL] = { .lhs = { [0] = { REG_VIRT0, REGCM_GPR16 } }, - .rhs = { + .rhs = { [0] = { REG_VIRT0, REGCM_GPR16 }, [1] = { REG_CL, REGCM_GPR8_LO }, }, }, [TEMPLATE_SL32_CL] = { .lhs = { [0] = { REG_VIRT0, REGCM_GPR32 } }, - .rhs = { + .rhs = { [0] = { REG_VIRT0, REGCM_GPR32 }, [1] = { REG_CL, REGCM_GPR8_LO }, }, }, [TEMPLATE_SL8_IMM] = { .lhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } }, - .rhs = { + .rhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO }, [1] = { REG_UNNEEDED, REGCM_IMM8 }, }, }, [TEMPLATE_SL16_IMM] = { .lhs = { [0] = { REG_VIRT0, REGCM_GPR16 } }, - .rhs = { + .rhs = { [0] = { REG_VIRT0, REGCM_GPR16 }, [1] = { REG_UNNEEDED, REGCM_IMM8 }, }, }, [TEMPLATE_SL32_IMM] = { .lhs = { [0] = { REG_VIRT0, REGCM_GPR32 } }, - .rhs = { + .rhs = { [0] = { REG_VIRT0, REGCM_GPR32 }, [1] = { REG_UNNEEDED, REGCM_IMM8 }, }, @@ -22866,19 +22874,19 @@ static struct ins_template templates[] = { .rhs = { [0] = { REG_UNSET, REGCM_GPR32 } }, }, [TEMPLATE_INB_DX] = { - .lhs = { [0] = { REG_AL, REGCM_GPR8_LO } }, + .lhs = { [0] = { REG_AL, REGCM_GPR8_LO } }, .rhs = { [0] = { REG_DX, REGCM_GPR16 } }, }, [TEMPLATE_INB_IMM] = { - .lhs = { [0] = { REG_AL, REGCM_GPR8_LO } }, + .lhs = { [0] = { REG_AL, REGCM_GPR8_LO } }, .rhs = { [0] = { REG_UNNEEDED, REGCM_IMM8 } }, }, - [TEMPLATE_INW_DX] = { - .lhs = { [0] = { REG_AX, REGCM_GPR16 } }, + [TEMPLATE_INW_DX] = { + .lhs = { [0] = { REG_AX, REGCM_GPR16 } }, .rhs = { [0] = { REG_DX, REGCM_GPR16 } }, }, - [TEMPLATE_INW_IMM] = { - .lhs = { [0] = { REG_AX, REGCM_GPR16 } }, + [TEMPLATE_INW_IMM] = { + .lhs = { [0] = { REG_AX, REGCM_GPR16 } }, .rhs = { [0] = { REG_UNNEEDED, REGCM_IMM8 } }, }, [TEMPLATE_INL_DX] = { @@ -22889,19 +22897,19 @@ static struct ins_template templates[] = { .lhs = { [0] = { REG_EAX, REGCM_GPR32 } }, .rhs = { [0] = { REG_UNNEEDED, REGCM_IMM8 } }, }, - [TEMPLATE_OUTB_DX] = { + [TEMPLATE_OUTB_DX] = { .rhs = { [0] = { REG_AL, REGCM_GPR8_LO }, [1] = { REG_DX, REGCM_GPR16 }, }, }, - [TEMPLATE_OUTB_IMM] = { + [TEMPLATE_OUTB_IMM] = { .rhs = { - [0] = { REG_AL, REGCM_GPR8_LO }, + [0] = { REG_AL, REGCM_GPR8_LO }, [1] = { REG_UNNEEDED, REGCM_IMM8 }, }, }, - [TEMPLATE_OUTW_DX] = { + [TEMPLATE_OUTW_DX] = { .rhs = { [0] = { REG_AX, REGCM_GPR16 }, [1] = { REG_DX, REGCM_GPR16 }, @@ -22909,19 +22917,19 @@ static struct ins_template templates[] = { }, [TEMPLATE_OUTW_IMM] = { .rhs = { - [0] = { REG_AX, REGCM_GPR16 }, + [0] = { REG_AX, REGCM_GPR16 }, [1] = { REG_UNNEEDED, REGCM_IMM8 }, }, }, - [TEMPLATE_OUTL_DX] = { + [TEMPLATE_OUTL_DX] = { .rhs = { [0] = { REG_EAX, REGCM_GPR32 }, [1] = { REG_DX, REGCM_GPR16 }, }, }, - [TEMPLATE_OUTL_IMM] = { + [TEMPLATE_OUTL_IMM] = { .rhs = { - [0] = { REG_EAX, REGCM_GPR32 }, + [0] = { REG_EAX, REGCM_GPR32 }, [1] = { REG_UNNEEDED, REGCM_IMM8 }, }, }, @@ -22930,7 +22938,7 @@ static struct ins_template templates[] = { .rhs = { [0] = { REG_UNSET, REGCM_GPR32 } }, }, [TEMPLATE_RDMSR] = { - .lhs = { + .lhs = { [0] = { REG_EAX, REGCM_GPR32 }, [1] = { REG_EDX, REGCM_GPR32 }, }, @@ -22945,27 +22953,27 @@ static struct ins_template templates[] = { }, [TEMPLATE_UMUL8] = { .lhs = { [0] = { REG_AX, REGCM_GPR16 } }, - .rhs = { + .rhs = { [0] = { REG_AL, REGCM_GPR8_LO }, [1] = { REG_UNSET, REGCM_GPR8_LO }, }, }, [TEMPLATE_UMUL16] = { .lhs = { [0] = { REG_DXAX, REGCM_DIVIDEND32 } }, - .rhs = { + .rhs = { [0] = { REG_AX, REGCM_GPR16 }, [1] = { REG_UNSET, REGCM_GPR16 }, }, }, [TEMPLATE_UMUL32] = { .lhs = { [0] = { REG_EDXEAX, REGCM_DIVIDEND64 } }, - .rhs = { + .rhs = { [0] = { REG_EAX, REGCM_GPR32 }, [1] = { REG_UNSET, REGCM_GPR32 }, }, }, [TEMPLATE_DIV8] = { - .lhs = { + .lhs = { [0] = { REG_AL, REGCM_GPR8_LO }, [1] = { REG_AH, REGCM_GPR8 }, }, @@ -22975,7 +22983,7 @@ static struct ins_template templates[] = { }, }, [TEMPLATE_DIV16] = { - .lhs = { + .lhs = { [0] = { REG_AX, REGCM_GPR16 }, [1] = { REG_DX, REGCM_GPR16 }, }, @@ -22985,7 +22993,7 @@ static struct ins_template templates[] = { }, }, [TEMPLATE_DIV32] = { - .lhs = { + .lhs = { [0] = { REG_EAX, REGCM_GPR32 }, [1] = { REG_EDX, REGCM_GPR32 }, }, @@ -23006,7 +23014,7 @@ static void fixup_branch(struct compile_state *state, } test = pre_triple(state, branch, cmp_op, cmp_type, left, right); - test->template_id = TEMPLATE_TEST32; + test->template_id = TEMPLATE_TEST32; if (cmp_op == OP_CMP) { test->template_id = TEMPLATE_CMP32_REG; if (get_imm32(test, &RHS(test, 1))) { @@ -23040,13 +23048,13 @@ static void fixup_branches(struct compile_state *state, right = RHS(cmp, 1); } branch = entry->member; - fixup_branch(state, branch, jmp_op, + fixup_branch(state, branch, jmp_op, cmp->op, cmp->type, left, right); } } } -static void bool_cmp(struct compile_state *state, +static void bool_cmp(struct compile_state *state, struct triple *ins, int cmp_op, int jmp_op, int set_op) { struct triple_set *entry, *next; @@ -23113,7 +23121,7 @@ struct reg_info arch_reg_lhs(struct compile_state *state, struct triple *ins, in break; default: if (ins->template_id > LAST_TEMPLATE) { - internal_error(state, ins, "bad template number %d", + internal_error(state, ins, "bad template number %d", ins->template_id); } template = &templates[ins->template_id]; @@ -23148,7 +23156,7 @@ struct reg_info arch_reg_rhs(struct compile_state *state, struct triple *ins, in /* Fall through */ default: if (ins->template_id > LAST_TEMPLATE) { - internal_error(state, ins, "bad template number %d", + internal_error(state, ins, "bad template number %d", ins->template_id); } template = &templates[ins->template_id]; @@ -23165,13 +23173,12 @@ struct reg_info arch_reg_rhs(struct compile_state *state, struct triple *ins, in static struct triple *mod_div(struct compile_state *state, struct triple *ins, int div_op, int index) { - struct triple *div, *piece0, *piece1; - + struct triple *div, *piece1; + /* Generate the appropriate division instruction */ div = post_triple(state, ins, div_op, ins->type, 0, 0); RHS(div, 0) = RHS(ins, 0); RHS(div, 1) = RHS(ins, 1); - piece0 = LHS(div, 0); piece1 = LHS(div, 1); div->template_id = TEMPLATE_DIV32; use_triple(RHS(div, 0), div); @@ -23476,8 +23483,8 @@ static struct triple *transform_to_arch_instruction( case OP_NEG: ins->template_id = TEMPLATE_UNARY32; break; - case OP_EQ: - bool_cmp(state, ins, OP_CMP, OP_JMP_EQ, OP_SET_EQ); + case OP_EQ: + bool_cmp(state, ins, OP_CMP, OP_JMP_EQ, OP_SET_EQ); break; case OP_NOTEQ: bool_cmp(state, ins, OP_CMP, OP_JMP_NOTEQ, OP_SET_NOTEQ); @@ -23517,7 +23524,7 @@ static struct triple *transform_to_arch_instruction( ins->template_id = TEMPLATE_NOP; break; case OP_CBRANCH: - fixup_branch(state, ins, OP_JMP_NOTEQ, OP_TEST, + fixup_branch(state, ins, OP_JMP_NOTEQ, OP_TEST, RHS(ins, 0)->type, RHS(ins, 0), 0); break; case OP_CALL: @@ -23623,20 +23630,20 @@ static void generate_local_labels(struct compile_state *state) first = state->first; label = first; do { - if ((label->op == OP_LABEL) || + if ((label->op == OP_LABEL) || (label->op == OP_SDECL)) { if (label->use) { label->u.cval = next_label(state); } else { label->u.cval = 0; } - + } label = label->next; } while(label != first); } -static int check_reg(struct compile_state *state, +static int check_reg(struct compile_state *state, struct triple *triple, int classes) { unsigned mask; @@ -23667,7 +23674,7 @@ static const char *arch_regs[] = { "%edx:%eax", "%dx:%ax", "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7", - "%xmm0", "%xmm1", "%xmm2", "%xmm3", + "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6", "%xmm7", }; static const char *arch_reg_str(int reg) @@ -23726,7 +23733,7 @@ static int reg_size(struct compile_state *state, struct triple *ins) } return arch_reg_size(reg); } - + const char *type_suffix(struct compile_state *state, struct type *type) @@ -23749,7 +23756,7 @@ static void print_const_val( { switch(ins->op) { case OP_INTCONST: - fprintf(fp, " $%ld ", + fprintf(fp, " $%ld ", (long)(ins->u.cval)); break; case OP_ADDRCONST: @@ -23762,7 +23769,7 @@ static void print_const_val( internal_error(state, ins, "unlabeled constant"); } fprintf(fp, " $L%s%lu+%lu ", - state->compiler->label_prefix, + state->compiler->label_prefix, (unsigned long)(MISC(ins, 0)->u.cval), (unsigned long)(ins->u.cval)); break; @@ -23780,12 +23787,12 @@ static void print_const(struct compile_state *state, switch(ins->type->type & TYPE_MASK) { case TYPE_CHAR: case TYPE_UCHAR: - fprintf(fp, ".byte 0x%02lx\n", + fprintf(fp, ".byte 0x%02lx\n", (unsigned long)(ins->u.cval)); break; case TYPE_SHORT: case TYPE_USHORT: - fprintf(fp, ".short 0x%04lx\n", + fprintf(fp, ".short 0x%04lx\n", (unsigned long)(ins->u.cval)); break; case TYPE_INT: @@ -23793,7 +23800,7 @@ static void print_const(struct compile_state *state, case TYPE_LONG: case TYPE_ULONG: case TYPE_POINTER: - fprintf(fp, ".int %lu\n", + fprintf(fp, ".int %lu\n", (unsigned long)(ins->u.cval)); break; default: @@ -23803,7 +23810,7 @@ static void print_const(struct compile_state *state, internal_error(state, ins, "Unknown constant type. Val: %lu", (unsigned long)(ins->u.cval)); } - + break; case OP_ADDRCONST: if ((MISC(ins, 0)->op != OP_SDECL) && @@ -23875,7 +23882,7 @@ static long get_mask_pool_ref( } static void print_binary_op(struct compile_state *state, - const char *op, struct triple *ins, FILE *fp) + const char *op, struct triple *ins, FILE *fp) { unsigned mask; mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO; @@ -23902,7 +23909,7 @@ static void print_binary_op(struct compile_state *state, reg(state, RHS(ins, 0), mask)); } } -static void print_unary_op(struct compile_state *state, +static void print_unary_op(struct compile_state *state, const char *op, struct triple *ins, FILE *fp) { unsigned mask; @@ -23966,7 +23973,7 @@ static void print_op_in(struct compile_state *state, struct triple *ins, FILE *f internal_error(state, ins, "src != %%dx"); } fprintf(fp, "\t%s %s, %s\n", - op, + op, reg(state, RHS(ins, 0), REGCM_GPR16), reg(state, ins, mask)); } @@ -23992,7 +23999,7 @@ static void print_op_out(struct compile_state *state, struct triple *ins, FILE * internal_error(state, ins, "src != %%eax"); } if (is_const(RHS(ins, 1))) { - fprintf(fp, "\t%s %s,", + fprintf(fp, "\t%s %s,", op, reg(state, RHS(ins, 0), mask)); print_const_val(state, RHS(ins, 1), fp); fprintf(fp, "\n"); @@ -24004,7 +24011,7 @@ static void print_op_out(struct compile_state *state, struct triple *ins, FILE * internal_error(state, ins, "dst != %%dx"); } fprintf(fp, "\t%s %s, %s\n", - op, + op, reg(state, RHS(ins, 0), mask), reg(state, RHS(ins, 1), REGCM_GPR16)); } @@ -24054,7 +24061,7 @@ static void print_op_move(struct compile_state *state, src_regcm = arch_reg_regcm(state, src_reg); dst_regcm = arch_reg_regcm(state, dst_reg); /* If the class is the same just move the register */ - if (src_regcm & dst_regcm & + if (src_regcm & dst_regcm & (REGCM_GPR8_LO | REGCM_GPR16 | REGCM_GPR32)) { if ((src_reg != dst_reg) || !omit_copy) { fprintf(fp, "\tmov %s, %s\n", @@ -24068,7 +24075,7 @@ static void print_op_move(struct compile_state *state, src_reg = (src_reg - REGC_GPR32_FIRST) + REGC_GPR16_FIRST; if ((src_reg != dst_reg) || !omit_copy) { fprintf(fp, "\tmovw %s, %s\n", - arch_reg_str(src_reg), + arch_reg_str(src_reg), arch_reg_str(dst_reg)); } } @@ -24105,7 +24112,7 @@ static void print_op_move(struct compile_state *state, } } /* Move 8/16bit to 16/32bit */ - else if ((src_regcm & (REGCM_GPR8_LO | REGCM_GPR16)) && + else if ((src_regcm & (REGCM_GPR8_LO | REGCM_GPR16)) && (dst_regcm & (REGCM_GPR16 | REGCM_GPR32))) { const char *op; op = is_signed(src->type)? "movsx": "movzx"; @@ -24177,7 +24184,7 @@ static void print_op_move(struct compile_state *state, const char *extend; extend = is_signed(src->type)? "cltd":"movl $0, %edx"; fprintf(fp, "\tmov %s, %%eax\n\t%s\n", - arch_reg_str(src_reg), + arch_reg_str(src_reg), extend); } /* Move from 64bit gpr to gpr */ @@ -24185,7 +24192,7 @@ static void print_op_move(struct compile_state *state, (dst_regcm & (REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO))) { if (dst_regcm & REGCM_GPR32) { src_reg = REG_EAX; - } + } else if (dst_regcm & REGCM_GPR16) { src_reg = REG_AX; } @@ -24372,11 +24379,10 @@ static void print_op_move(struct compile_state *state, if ((size_of(state, src->type) < size_of(state, dst->type)) && (is_signed(src->type))) { - int bits, reg_bits, shift_bits; + int reg_bits, shift_bits; int dst_reg; int dst_regcm; - bits = size_of(state, src->type); reg_bits = reg_size(state, dst); if (reg_bits > 32) { reg_bits = 32; @@ -24390,19 +24396,19 @@ static void print_op_move(struct compile_state *state, } if (dst_regcm & (REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO)) { - fprintf(fp, "\tshl $%d, %s\n", - shift_bits, + fprintf(fp, "\tshl $%d, %s\n", + shift_bits, reg(state, dst, REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO)); - fprintf(fp, "\tsar $%d, %s\n", - shift_bits, + fprintf(fp, "\tsar $%d, %s\n", + shift_bits, reg(state, dst, REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO)); } else if (dst_regcm & (REGCM_MMX | REGCM_XMM)) { fprintf(fp, "\tpslld $%d, %s\n", - shift_bits, + shift_bits, reg(state, dst, REGCM_MMX | REGCM_XMM)); fprintf(fp, "\tpsrad $%d, %s\n", - shift_bits, + shift_bits, reg(state, dst, REGCM_MMX | REGCM_XMM)); } else { @@ -24433,7 +24439,7 @@ static void print_op_load(struct compile_state *state, case TYPE_INT: case TYPE_UINT: case TYPE_LONG: case TYPE_ULONG: case TYPE_POINTER: - op = "movl"; + op = "movl"; break; default: internal_error(state, ins, "unknown type in load"); @@ -24441,7 +24447,7 @@ static void print_op_load(struct compile_state *state, break; } fprintf(fp, "\t%s (%s), %s\n", - op, + op, reg(state, src, REGCM_GPR32), reg(state, dst, REGCM_GPR32)); } @@ -24476,8 +24482,8 @@ static void print_op_store(struct compile_state *state, reg(state, src, REGCM_GPR8_LO | REGCM_GPR16 | REGCM_GPR32), reg(state, dst, REGCM_GPR32)); } - - + + } static void print_op_smul(struct compile_state *state, @@ -24578,7 +24584,7 @@ static void print_op_branch(struct compile_state *state, internal_error(state, branch, "Invalid branch op"); break; } - + } #if 1 if (branch->op == OP_CALL) { @@ -24586,7 +24592,7 @@ static void print_op_branch(struct compile_state *state, } #endif fprintf(fp, "\t%s L%s%lu\n", - bop, + bop, state->compiler->label_prefix, (unsigned long)(TARG(branch, 0)->u.cval)); } @@ -24632,19 +24638,19 @@ static void print_op_set(struct compile_state *state, sop, reg(state, set, REGCM_GPR8_LO)); } -static void print_op_bit_scan(struct compile_state *state, - struct triple *ins, FILE *fp) +static void print_op_bit_scan(struct compile_state *state, + struct triple *ins, FILE *fp) { const char *op; switch(ins->op) { case OP_BSF: op = "bsf"; break; case OP_BSR: op = "bsr"; break; - default: + default: internal_error(state, ins, "unknown bit scan"); op = 0; break; } - fprintf(fp, + fprintf(fp, "\t%s %s, %s\n" "\tjnz 1f\n" "\tmovl $-1, %s\n" @@ -24661,18 +24667,18 @@ static void print_sdecl(struct compile_state *state, { fprintf(fp, ".section \"" DATA_SECTION "\"\n"); fprintf(fp, ".balign %ld\n", (long int)align_of_in_bytes(state, ins->type)); - fprintf(fp, "L%s%lu:\n", + fprintf(fp, "L%s%lu:\n", state->compiler->label_prefix, (unsigned long)(ins->u.cval)); print_const(state, MISC(ins, 0), fp); fprintf(fp, ".section \"" TEXT_SECTION "\"\n"); - + } static void print_instruction(struct compile_state *state, struct triple *ins, FILE *fp) { /* Assumption: after I have exted the register allocator - * everything is in a valid register. + * everything is in a valid register. */ switch(ins->op) { case OP_ASM: @@ -24704,7 +24710,7 @@ static void print_instruction(struct compile_state *state, case OP_SDECL: print_sdecl(state, ins, fp); break; - case OP_COPY: + case OP_COPY: case OP_CONVERT: print_op_move(state, ins, fp); break; @@ -24739,10 +24745,10 @@ static void print_instruction(struct compile_state *state, print_op_set(state, ins, fp); break; case OP_INB: case OP_INW: case OP_INL: - print_op_in(state, ins, fp); + print_op_in(state, ins, fp); break; case OP_OUTB: case OP_OUTW: case OP_OUTL: - print_op_out(state, ins, fp); + print_op_out(state, ins, fp); break; case OP_BSF: case OP_BSR: @@ -24771,7 +24777,7 @@ static void print_instruction(struct compile_state *state, if (!ins->use) { return; } - fprintf(fp, "L%s%lu:\n", + fprintf(fp, "L%s%lu:\n", state->compiler->label_prefix, (unsigned long)(ins->u.cval)); break; case OP_ADECL: @@ -24818,7 +24824,7 @@ static void print_instructions(struct compile_state *state) first = state->first; ins = first; do { - if (print_location && + if (print_location && last_occurance != ins->occurance) { if (!ins->occurance->parent) { fprintf(fp, "\t/* %s,%s:%d.%d */\n", @@ -24865,7 +24871,7 @@ static void generate_code(struct compile_state *state) { generate_local_labels(state); print_instructions(state); - + } static void print_preprocessed_tokens(struct compile_state *state) @@ -24886,7 +24892,7 @@ static void print_preprocessed_tokens(struct compile_state *state) break; } tk = eat(state, tok); - token_str = + token_str = tk->ident ? tk->ident->name : tk->str_len ? tk->val.str : tokens[tk->tok]; @@ -24895,8 +24901,8 @@ static void print_preprocessed_tokens(struct compile_state *state) while(file->macro && file->prev) { file = file->prev; } - if (!file->macro && - ((file->line != line) || (file->basename != filename))) + if (!file->macro && + ((file->line != line) || (file->basename != filename))) { int i, col; if ((file->basename == filename) && @@ -24917,9 +24923,9 @@ static void print_preprocessed_tokens(struct compile_state *state) fprintf(fp, " "); } } - + fprintf(fp, "%s ", token_str); - + if (state->compiler->debug & DEBUG_TOKENS) { loc(state->dbgout, state, 0); fprintf(state->dbgout, "%s <- `%s'\n", @@ -24928,12 +24934,13 @@ static void print_preprocessed_tokens(struct compile_state *state) } } -static void compile(const char *filename, const char *includefile, +static void compile(const char *filename, struct compiler_state *compiler, struct arch_state *arch) { int i; struct compile_state state; struct triple *ptr; + struct filelist *includes = include_filelist; memset(&state, 0, sizeof(state)); state.compiler = compiler; state.arch = arch; @@ -24946,10 +24953,14 @@ static void compile(const char *filename, const char *includefile, state.errout = stderr; state.dbgout = stdout; /* Remember the output filename */ - state.output = fopen(state.compiler->ofilename, "w"); - if (!state.output) { - error(&state, 0, "Cannot open output file %s\n", - state.compiler->ofilename); + if ((state.compiler->flags & COMPILER_PP_ONLY) && (strcmp("auto.inc",state.compiler->ofilename) == 0)) { + state.output = stdout; + } else { + state.output = fopen(state.compiler->ofilename, "w"); + if (!state.output) { + error(&state, 0, "Cannot open output file %s\n", + state.compiler->ofilename); + } } /* Make certain a good cleanup happens */ exit_state = &state; @@ -24980,6 +24991,7 @@ static void compile(const char *filename, const char *includefile, /* Memorize where some attribute keywords are. */ state.i_noinline = lookup(&state, "noinline", 8); state.i_always_inline = lookup(&state, "always_inline", 13); + state.i_noreturn = lookup(&state, "noreturn", 8); /* Process the command line macros */ process_cmdline_macros(&state); @@ -25003,8 +25015,11 @@ static void compile(const char *filename, const char *includefile, register_builtins(&state); compile_file(&state, filename, 1); - if (includefile) - compile_file(&state, includefile, 1); + + while (includes) { + compile_file(&state, includes->filename, 1); + includes=includes->next; + } /* Stop if all we want is preprocessor output */ if (state.compiler->flags & COMPILER_PP_ONLY) { @@ -25017,8 +25032,8 @@ static void compile(const char *filename, const char *includefile, /* Exit the global definition scope */ end_scope(&state); - /* Now that basic compilation has happened - * optimize the intermediate code + /* Now that basic compilation has happened + * optimize the intermediate code */ optimize(&state); @@ -25071,12 +25086,11 @@ static void arg_error(char *fmt, ...) int main(int argc, char **argv) { const char *filename; - const char *includefile = NULL; struct compiler_state compiler; struct arch_state arch; int all_opts; - - + + /* I don't want any surprises */ setlocale(LC_ALL, "C"); @@ -25121,15 +25135,23 @@ int main(int argc, char **argv) else if (strncmp(argv[1], "-m", 2) == 0) { result = arch_encode_flag(&arch, argv[1]+2); } + else if (strncmp(argv[1], "-c", 2) == 0) { + result = 0; + } + else if (strncmp(argv[1], "-S", 2) == 0) { + result = 0; + } else if (strncmp(argv[1], "-include", 10) == 0) { - if (includefile) { - arg_error("Only one -include option may be specified.\n"); - } else { - argv++; - argc--; - includefile = argv[1]; - result = 0; + struct filelist *old_head = include_filelist; + include_filelist = malloc(sizeof(struct filelist)); + if (!include_filelist) { + die("Out of memory.\n"); } + argv++; + argc--; + include_filelist->filename = strdup(argv[1]); + include_filelist->next = old_head; + result = 0; } if (result < 0) { arg_error("Invalid option specified: %s\n", @@ -25150,7 +25172,7 @@ int main(int argc, char **argv) if (!filename) { arg_error("No filename specified\n"); } - compile(filename, includefile, &compiler, &arch); + compile(filename, &compiler, &arch); return 0; }