From: Till Riedel Date: Mon, 23 Jun 2003 17:13:34 +0000 (+0000) Subject: intoduced kind field to mode node graph X-Git-Url: http://nsz.repo.hu/git/?a=commitdiff_plain;h=1d265ff57b0137d181368d97cdbd93f3c14d94aa;p=libfirm intoduced kind field to mode node graph added mode.arithmetic put modes on obstack eliminated compiler wearnings beautified code :-) [r1387] --- diff --git a/ir/ir/Makefile.in b/ir/ir/Makefile.in index a3e51092f..8066aae24 100644 --- a/ir/ir/Makefile.in +++ b/ir/ir/Makefile.in @@ -20,7 +20,7 @@ SOURCES += Makefile.in \ ircons.c irgmod.c irgraph_t.h irnode.c iropt.c irvrfy.c \ irgwalk.c irdump.c irgopt.c irnode_t.h iropt_t.h \ irmode.c irop.c irprog.c irflag.c irgraph.c irmode_t.h \ - irop_t.h irprog_t.h iropt_dbg.c ircgcons.c ircgopt.c + irop_t.h irprog_t.h ircgcons.c ircgopt.c include $(topdir)/MakeRules diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c index 0d4420dda..af309d28f 100644 --- a/ir/ir/ircons.c +++ b/ir/ir/ircons.c @@ -137,8 +137,9 @@ new_rd_Const (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval INLINE ir_node * new_rd_Id (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode) { - ir_node *in[1] = {val}; + ir_node *in[1]; ir_node *res; + in[0]=val; res = new_ir_node (db, irg, block, op_Id, mode, 1, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -149,8 +150,9 @@ INLINE ir_node * new_rd_Proj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode, long proj) { - ir_node *in[1] = {arg}; + ir_node *in[1]; ir_node *res; + in[0]=arg; res = new_ir_node (db, irg, block, op_Proj, mode, 1, in); res->attr.proj = proj; @@ -180,8 +182,9 @@ new_rd_defaultProj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, INLINE ir_node * new_rd_Conv (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode) { - ir_node *in[1] = {op}; + ir_node *in[1]; ir_node *res; + in[0]=op; res = new_ir_node (db, irg, block, op_Conv, mode, 1, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -204,8 +207,10 @@ INLINE ir_node * new_rd_Add (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode) { - ir_node *in[2] = {op1, op2}; + ir_node *in[2]; ir_node *res; + in[0] = op1; + in[1] = op2; res = new_ir_node (db, irg, block, op_Add, mode, 2, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -216,8 +221,10 @@ INLINE ir_node * new_rd_Sub (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode) { - ir_node *in[2] = {op1, op2}; + ir_node *in[2]; ir_node *res; + in[0] = op1; + in[1] = op2; res = new_ir_node (db, irg, block, op_Sub, mode, 2, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -228,8 +235,9 @@ INLINE ir_node * new_rd_Minus (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode) { - ir_node *in[1] = {op}; + ir_node *in[1]; ir_node *res; + in[0]=op; res = new_ir_node (db, irg, block, op_Minus, mode, 1, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -240,8 +248,10 @@ INLINE ir_node * new_rd_Mul (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode) { - ir_node *in[2] = {op1, op2}; + ir_node *in[2]; ir_node *res; + in[0] = op1; + in[1] = op2; res = new_ir_node (db, irg, block, op_Mul, mode, 2, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -252,8 +262,11 @@ INLINE ir_node * new_rd_Quot (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *memop, ir_node *op1, ir_node *op2) { - ir_node *in[3] = {memop, op1, op2}; + ir_node *in[3] ; ir_node *res; + in[0] = memop; + in[1] = op1; + in[2] = op2; res = new_ir_node (db, irg, block, op_Quot, mode_T, 3, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -264,8 +277,11 @@ INLINE ir_node * new_rd_DivMod (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *memop, ir_node *op1, ir_node *op2) { - ir_node *in[3] = {memop, op1, op2}; + ir_node *in[3]; ir_node *res; + in[0] = memop; + in[1] = op1; + in[2] = op2; res = new_ir_node (db, irg, block, op_DivMod, mode_T, 3, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -276,8 +292,11 @@ INLINE ir_node * new_rd_Div (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *memop, ir_node *op1, ir_node *op2) { - ir_node *in[3] = {memop, op1, op2}; + ir_node *in[3]; ir_node *res; + in[0] = memop; + in[1] = op1; + in[2] = op2; res = new_ir_node (db, irg, block, op_Div, mode_T, 3, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -288,8 +307,11 @@ INLINE ir_node * new_rd_Mod (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *memop, ir_node *op1, ir_node *op2) { - ir_node *in[3] = {memop, op1, op2}; + ir_node *in[3]; ir_node *res; + in[0] = memop; + in[1] = op1; + in[2] = op2; res = new_ir_node (db, irg, block, op_Mod, mode_T, 3, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -300,8 +322,10 @@ INLINE ir_node * new_rd_And (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode) { - ir_node *in[2] = {op1, op2}; + ir_node *in[2]; ir_node *res; + in[0] = op1; + in[1] = op2; res = new_ir_node (db, irg, block, op_And, mode, 2, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -312,8 +336,10 @@ INLINE ir_node * new_rd_Or (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode) { - ir_node *in[2] = {op1, op2}; + ir_node *in[2]; ir_node *res; + in[0] = op1; + in[1] = op2; res = new_ir_node (db, irg, block, op_Or, mode, 2, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -324,8 +350,10 @@ INLINE ir_node * new_rd_Eor (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode) { - ir_node *in[2] = {op1, op2}; + ir_node *in[2]; ir_node *res; + in[0] = op1; + in[1] = op2; res = new_ir_node (db, irg, block, op_Eor, mode, 2, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -336,8 +364,9 @@ INLINE ir_node * new_rd_Not (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode) { - ir_node *in[1] = {op}; + ir_node *in[1]; ir_node *res; + in[0] = op; res = new_ir_node (db, irg, block, op_Not, mode, 1, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -348,8 +377,10 @@ INLINE ir_node * new_rd_Shl (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_node *k, ir_mode *mode) { - ir_node *in[2] = {op, k}; + ir_node *in[2]; ir_node *res; + in[0] = op; + in[1] = k; res = new_ir_node (db, irg, block, op_Shl, mode, 2, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -360,8 +391,10 @@ INLINE ir_node * new_rd_Shr (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_node *k, ir_mode *mode) { - ir_node *in[2] = {op, k}; + ir_node *in[2]; ir_node *res; + in[0] = op; + in[1] = k; res = new_ir_node (db, irg, block, op_Shr, mode, 2, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -372,8 +405,10 @@ INLINE ir_node * new_rd_Shrs (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_node *k, ir_mode *mode) { - ir_node *in[2] = {op, k}; + ir_node *in[2]; ir_node *res; + in[0] = op; + in[1] = k; res = new_ir_node (db, irg, block, op_Shrs, mode, 2, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -384,8 +419,10 @@ INLINE ir_node * new_rd_Rot (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_node *k, ir_mode *mode) { - ir_node *in[2] = {op, k}; + ir_node *in[2]; ir_node *res; + in[0] = op; + in[1] = k; res = new_ir_node (db, irg, block, op_Rot, mode, 2, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -396,8 +433,9 @@ INLINE ir_node * new_rd_Abs (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode) { - ir_node *in[1] = {op}; + ir_node *in[1]; ir_node *res; + in[0] = op; res = new_ir_node (db, irg, block, op_Abs, mode, 1, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -408,8 +446,10 @@ INLINE ir_node * new_rd_Cmp (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op1, ir_node *op2) { - ir_node *in[2] = {op1, op2}; + ir_node *in[2]; ir_node *res; + in[0] = op1; + in[1] = op2; res = new_ir_node (db, irg, block, op_Cmp, mode_T, 2, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -429,8 +469,9 @@ new_rd_Jmp (dbg_info* db, ir_graph *irg, ir_node *block) INLINE ir_node * new_rd_Cond (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *c) { - ir_node *in[1] = {c}; + ir_node *in[1]; ir_node *res; + in[0] = c; res = new_ir_node (db, irg, block, op_Cond, mode_T, 1, in); res->attr.c.kind = dense; res->attr.c.default_proj = 0; @@ -484,8 +525,10 @@ new_rd_Return (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Raise (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj) { - ir_node *in[2] = {store, obj}; + ir_node *in[2]; ir_node *res; + in[0] = store; + in[1] = obj; res = new_ir_node (db, irg, block, op_Raise, mode_T, 2, in); res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -496,8 +539,10 @@ INLINE ir_node * new_rd_Load (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *adr) { - ir_node *in[2] = {store, adr}; + ir_node *in[2]; ir_node *res; + in[0] = store; + in[1] = adr; res = new_ir_node (db, irg, block, op_Load, mode_T, 2, in); res = optimize_node (res); @@ -509,8 +554,11 @@ INLINE ir_node * new_rd_Store (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *adr, ir_node *val) { - ir_node *in[3] = {store, adr, val}; + ir_node *in[3]; ir_node *res; + in[0] = store; + in[1] = adr; + in[2] = val; res = new_ir_node (db, irg, block, op_Store, mode_T, 3, in); res = optimize_node (res); @@ -523,8 +571,10 @@ INLINE ir_node * new_rd_Alloc (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *size, type *alloc_type, where_alloc where) { - ir_node *in[2] = {store, size}; + ir_node *in[2]; ir_node *res; + in[0] = store; + in[1] = size; res = new_ir_node (db, irg, block, op_Alloc, mode_T, 2, in); res->attr.a.where = where; @@ -539,8 +589,11 @@ INLINE ir_node * new_rd_Free (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *ptr, ir_node *size, type *free_type) { - ir_node *in[3] = {store, ptr, size}; + ir_node *in[3]; ir_node *res; + in[0] = store; + in[1] = ptr; + in[2] = size; res = new_ir_node (db, irg, block, op_Free, mode_T, 3, in); res->attr.f = free_type; @@ -647,8 +700,9 @@ new_rd_Unknown (ir_graph *irg) INLINE ir_node * new_rd_CallBegin (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call) { - ir_node *in[1] = { get_Call_ptr(call) }; + ir_node *in[1]; ir_node *res; + in[0] = get_Call_ptr(call); res = new_ir_node (db, irg, block, op_CallBegin, mode_T, 1, in); res->attr.callbegin.irg = irg; res->attr.callbegin.call = call; @@ -695,8 +749,9 @@ INLINE ir_node * new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode, long proj) { - ir_node *in[1] = {arg}; + ir_node *in[1]; ir_node *res; + in[0] = arg; res = new_ir_node (db, irg, block, op_Filter, mode, 1, in); res->attr.filter.proj = proj; res->attr.filter.in_cg = NULL; diff --git a/ir/ir/irgopt.c b/ir/ir/irgopt.c index 2116345fa..6bf712b11 100644 --- a/ir/ir/irgopt.c +++ b/ir/ir/irgopt.c @@ -210,7 +210,7 @@ copy_preds (ir_node *n, void *env) { for (i = 0; i < get_irn_arity(n); i++) if (get_irn_opcode(get_irn_n(n, i)) != iro_Bad) { set_irn_n (nn, j, get_new_node(get_irn_n(n, i))); - //if (is_backedge(n, i)) set_backedge(nn, j); + /*if (is_backedge(n, i)) set_backedge(nn, j);*/ j++; } /* repair the block visited flag from above misuse. Repair it in both @@ -234,7 +234,7 @@ copy_preds (ir_node *n, void *env) { for (i = 0; i < get_irn_arity(n); i++) if (get_irn_opcode(get_irn_n(block, i)) != iro_Bad) { set_irn_n (nn, j, get_new_node(get_irn_n(n, i))); - //if (is_backedge(n, i)) set_backedge(nn, j); + /*if (is_backedge(n, i)) set_backedge(nn, j);*/ j++; } /* If the pre walker reached this Phi after the post walker visited the diff --git a/ir/ir/irgraph.c b/ir/ir/irgraph.c index c4d6c20f3..4c60503d6 100644 --- a/ir/ir/irgraph.c +++ b/ir/ir/irgraph.c @@ -68,6 +68,8 @@ new_ir_graph (entity *ent, int n_loc) ir_node *projX; res = (ir_graph *) malloc (sizeof (ir_graph)); + res->kind=k_ir_graph; + current_ir_graph = res; add_irp_irg(res); /* remember this graph global. */ @@ -522,9 +524,11 @@ inc_irg_visited (ir_graph *irg) unsigned long get_max_irg_visited(void) { - //int i; - //for(i = 0; i < get_irp_n_irgs(); i++) - // assert(max_irg_visited >= get_irg_visited(get_irp_irg(i))); + /* + int i; + for(i = 0; i < get_irp_n_irgs(); i++) + assert(max_irg_visited >= get_irg_visited(get_irp_irg(i))); + */ return max_irg_visited; } @@ -535,9 +539,11 @@ void set_max_irg_visited(int val) { unsigned long inc_max_irg_visited(void) { - //int i; - // for(i = 0; i < get_irp_n_irgs(); i++) - //assert(max_irg_visited >= get_irg_visited(get_irp_irg(i))); + /* + int i; + for(i = 0; i < get_irp_n_irgs(); i++) + assert(max_irg_visited >= get_irg_visited(get_irp_irg(i))); + */ max_irg_visited++; return max_irg_visited; } diff --git a/ir/ir/irgraph_t.h b/ir/ir/irgraph_t.h index 6aeb1b7f1..6a466c658 100644 --- a/ir/ir/irgraph_t.h +++ b/ir/ir/irgraph_t.h @@ -23,6 +23,7 @@ /** ir_graph holds all information for a procedure */ struct ir_graph { + firm_kind kind; /**< always set to k_ir_graph*/ /* -- Basics of the representation -- */ struct entity *ent; /**< The entity of this procedure, i.e., the type of the procedure and the diff --git a/ir/ir/irgwalk.c b/ir/ir/irgwalk.c index 105232bd4..5b1016208 100644 --- a/ir/ir/irgwalk.c +++ b/ir/ir/irgwalk.c @@ -16,7 +16,7 @@ # include -# include "irnode.h" +# include "irnode_t.h" # include "irgraph.h" /* visited flag */ # include "irprog.h" # include "irgwalk.h" @@ -32,7 +32,7 @@ static void irg_walk_cg(ir_node * node, int visited, eset * irg_set, ir_graph * rem = current_ir_graph; ir_node * pred; - assert(node); + assert(node && node->kind==k_ir_node); if (get_irn_visited(node) >= visited) return; set_irn_visited(node, visited); @@ -109,7 +109,7 @@ static void irg_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void * env) { int i; - assert(node); + assert(node && node->kind==k_ir_node); if (get_irn_visited(node) < get_irg_visited(current_ir_graph)) { set_irn_visited(node, get_irg_visited(current_ir_graph)); @@ -129,7 +129,7 @@ irg_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void * env) void irg_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env) { - assert(node); + assert(node && node->kind==k_ir_node); if (interprocedural_view) { eset * irg_set = eset_create(); int visited; @@ -337,8 +337,8 @@ void irg_block_walk_graph(ir_graph *irg, irg_walk_func *pre, /********************************************************************/ typedef struct walk_env { - void *pre; - void *post; + irg_walk_func *pre; + irg_walk_func *post; void *env; } walk_env; diff --git a/ir/ir/irmode.c b/ir/ir/irmode.c index a09ffbd3a..de777e008 100644 --- a/ir/ir/irmode.c +++ b/ir/ir/irmode.c @@ -17,7 +17,8 @@ # include # include # include "tv.h" -# include "array.h" +# include "obst.h" +# include "misc.h" #if 0 static long long count = 0; @@ -32,12 +33,7 @@ static long long count = 0; /** dynamic array to hold all modes */ -static ir_mode * modes; -/* dynamic arrays to hold special modes' values */ -static tarval** modes_min; -static tarval** modes_max; -static tarval** modes_null; -static tarval** modes_one; +static struct obstack modes; /** number of defined modes */ static int num_modes; @@ -49,31 +45,39 @@ static int num_modes; /** * Compare modes that don't need to have their code field * correctly set - */ -static int modes_are_equal(const ir_mode *m, const ir_mode *n) + * + * TODO: Add other fields + **/ +inline static int modes_are_equal(const ir_mode *m, const ir_mode *n) { if (m == n) return 1; - if ( (m->sort == n->sort) && (m->size == n->size) && - (m->align == n->align) && (m->sign == n->sign) && - (m->name == n->name) - ) - return 1; + if(!bcmp( m + offsetof(ir_mode,sort) , n + offsetof(ir_mode,sort), offsetof(ir_mode,min)-offsetof(ir_mode,min))) return 1; return 0; } /** - * searches the modes array for the given mode and returns + * searches the modes obstack for the given mode and returns * a pointer on an equal mode already in the array, NULL if * none found */ -static ir_mode *find_mode(ir_mode *m) +static ir_mode *find_mode(const ir_mode *m) { - int i; + ir_mode *n; + struct _obstack_chunk *p; + + p=modes.chunk; + for( n=(ir_mode*) p->contents; (char *)n < modes.next_free; n+=sizeof(ir_mode) ) + { + if(modes_are_equal(n,m)) return n; + } - for (i = 0; i < num_modes; i++) + for (p = p->prev; p; p = p->prev) { - if (modes_are_equal(m, &modes[i])) return &modes[i]; + for( n=(ir_mode*) p->contents; (char *)n < p->limit; n+=sizeof(ir_mode) ) + { + if(modes_are_equal(n,m)) return n; + } } return NULL; @@ -84,10 +88,10 @@ static ir_mode *find_mode(ir_mode *m) */ static void set_mode_values(ir_mode* mode) { - modes_min[get_mode_modecode(mode)] = get_tarval_min(mode); - modes_max[get_mode_modecode(mode)] = get_tarval_max(mode); - modes_null[get_mode_modecode(mode)] = get_tarval_null(mode); - modes_one[get_mode_modecode(mode)] = get_tarval_one(mode); + mode->min = get_tarval_min(mode); + mode->max= get_tarval_max(mode); + mode->null= get_tarval_null(mode); + mode->one= get_tarval_one(mode); } /* * * * globals defined in irmode.h @@ -153,21 +157,41 @@ INLINE ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; } * Registers a new mode if not defined yet, else returns * the "equivalent" one. */ -static ir_mode *register_mode(ir_mode* new_mode) +static ir_mode *register_mode(const ir_mode* new_mode) { - ir_mode *mode; + ir_mode *mode = NULL; ANNOUNCE(); assert(new_mode); - /* first check if there already is a matching mode */ - mode = find_mode(new_mode); - if (mode) return mode; + + + /* copy mode struct to modes array */ + mode=(ir_mode*) obstack_copy(&modes, new_mode, sizeof(ir_mode)); + + mode->kind = k_ir_mode; + if(num_modes>=irm_max) mode->code = num_modes; + num_modes++; + + if(mode->sort==irms_int_number || mode->sort==irms_float_number || mode->sort==irms_character) set_mode_values(mode); + + return mode; +} + +/* + * Creates a new mode. + */ +ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign, mode_arithmetic arithmetic ) +{ + ir_mode mode_tmpl; + ir_mode *mode; /* sanity checks */ - switch (new_mode->sort) + switch (sort) { case irms_auxiliary: + case irms_control_flow: + case irms_memory: case irms_internal_boolean: assert(0 && "internal modes cannot be user defined"); return NULL; @@ -182,44 +206,25 @@ static ir_mode *register_mode(ir_mode* new_mode) case irms_reference: case irms_character: break; - - default: - assert(0 && "wrong mode sort"); - return NULL; } + mode_tmpl.name = new_id_from_str(name); + mode_tmpl.sort = sort; + mode_tmpl.size = bit_size; + mode_tmpl.align = align; + mode_tmpl.sign = sign ? 1 : 0; + mode_tmpl.arithmetic = arithmetic; + mode_tmpl.tv_priv = NULL; - /* copy mode struct to modes array */ - ARR_EXTEND(ir_mode, modes, 1); - ARR_EXTEND(tarval*, modes_min, 1); - ARR_EXTEND(tarval*, modes_max, 1); - ARR_EXTEND(tarval*, modes_null, 1); - ARR_EXTEND(tarval*, modes_one, 1); - mode = &modes[num_modes]; - - memcpy(mode, new_mode, sizeof(ir_mode)); - mode->code = num_modes; - num_modes++; - - set_mode_values(mode); - - return mode; -} - -/* - * Creates a new mode. - */ -ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign) -{ - ir_mode mode_tmpl; - - mode_tmpl.name = new_id_from_str(name); - mode_tmpl.sort = sort; - mode_tmpl.size = bit_size; - mode_tmpl.align = align; - mode_tmpl.sign = sign ? 1 : 0; - mode_tmpl.tv_priv = NULL; - - return register_mode(&mode_tmpl); + /* first check if there already is a matching mode */ + mode = find_mode(&mode_tmpl); + if (mode) + { + return mode; + } + else + { + return register_mode(&mode_tmpl); + } } /* Functions for the direct access to all attributes od a ir_mode */ @@ -259,8 +264,8 @@ get_mode_size_bits(const ir_mode *mode) } int get_mode_size_bytes(const ir_mode *mode) { - ANNOUNCE(); int size = get_mode_size_bits(mode); + ANNOUNCE(); if ((size & 7) != 0) return -1; return size >> 3; } @@ -279,6 +284,24 @@ get_mode_sign (const ir_mode *mode) return mode->sign; } +int get_mode_arithmetic (const ir_mode *mode) +{ + ANNOUNCE(); + return mode->arithmetic; +} + +void* get_mode_link(const ir_mode *mode) +{ + ANNOUNCE(); + return mode->link; +} + +void set_mode_link(ir_mode *mode, void *l) +{ + mode->link=l; + return; +} + tarval * get_mode_min (ir_mode *mode) { @@ -287,7 +310,7 @@ get_mode_min (ir_mode *mode) assert(get_mode_modecode(mode) < num_modes); assert(mode_is_data(mode)); - return modes_min[get_mode_modecode(mode)]; + return mode->min; } tarval * @@ -298,7 +321,7 @@ get_mode_max (ir_mode *mode) assert(get_mode_modecode(mode) < num_modes); assert(mode_is_data(mode)); - return modes_max[get_mode_modecode(mode)]; + return mode->max; } tarval * @@ -309,7 +332,7 @@ get_mode_null (ir_mode *mode) assert(get_mode_modecode(mode) < num_modes); assert(mode_is_data(mode)); - return modes_null[get_mode_modecode(mode)]; + return mode->null; } tarval * @@ -320,7 +343,7 @@ get_mode_one (ir_mode *mode) assert(get_mode_modecode(mode) < num_modes); assert(mode_is_data(mode)); - return modes_one[get_mode_modecode(mode)]; + return mode->one; } tarval * @@ -345,6 +368,15 @@ get_mode_NAN(ir_mode *mode) return get_tarval_nan(mode); } +int +is_mode (void *thing) { + assert(thing); + if (get_kind(thing) == k_ir_mode) + return 1; + else + return 0; +} + /* Functions to check, whether a modecode is signed, float, int, num, data, datab or dataM. For more exact definitions read the corresponding pages in the firm documentation or the followingenumeration @@ -539,250 +571,218 @@ smaller_mode(const ir_mode *sm, const ir_mode *lm) void init_mode (void) { + ir_mode newmode; ANNOUNCE(); /* init flexible array */ - modes = NEW_ARR_F(ir_mode, irm_max); - modes_min = NEW_ARR_F(tarval*, irm_max); - modes_max = NEW_ARR_F(tarval*, irm_max); - modes_null = NEW_ARR_F(tarval*, irm_max); - modes_one = NEW_ARR_F(tarval*, irm_max); + obstack_init(&modes); + + num_modes = 0; /* initialize predefined modes */ + + /* Internal Modes */ + newmode.arithmetic = irma_none; + newmode.size = 0; + newmode.align = 0; + newmode.sign = 0; + newmode.tv_priv = NULL; + + /* Control Flow Modes*/ + newmode.sort = irms_control_flow; + /* Basic Block */ - mode_BB = &modes[irm_BB]; - mode_BB->name = id_from_str("BB", 2); - mode_BB->code = irm_BB; - mode_BB->sort = irms_auxiliary; - mode_BB->size = 0; - mode_BB->align = 0; - mode_BB->sign = 0; - mode_BB->tv_priv = NULL; - - /* eXecution */ - mode_X = &modes[irm_X]; - mode_X->name = id_from_str("X", 1); - mode_X->code = irm_X; - mode_X->sort = irms_auxiliary; - mode_X->size = 0; - mode_X->align = 0; - mode_X->sign = 0; - mode_X->tv_priv = NULL; + newmode.name = id_from_str("BB", 2); + newmode.code = irm_BB; + + mode_BB = register_mode(&newmode); + +/* eXecution */ + newmode.name = id_from_str("X", 1); + newmode.code = irm_X; + + mode_X = register_mode(&newmode); + + /* Memory Modes */ + newmode.sort = irms_memory; /* Memory */ - mode_M = &modes[irm_M]; - mode_M->name = id_from_str("M", 1); - mode_M->code = irm_M; - mode_M->sort = irms_auxiliary; - mode_M->size = 0; - mode_M->align = 0; - mode_M->sign = 0; - mode_M->tv_priv = NULL; + newmode.name = id_from_str("M", 1); + newmode.code = irm_M; + + mode_M = register_mode(&newmode); + + /* Auxiliary Modes */ + newmode.sort = irms_auxiliary, /* Tuple */ - mode_T = &modes[irm_T]; - mode_T->name = id_from_str("T", 1); - mode_T->code = irm_T; - mode_T->sort = irms_auxiliary, - mode_T->size = 0; - mode_T->align = 0; - mode_T->sign = 0; - mode_T->tv_priv = NULL; + newmode.name = id_from_str("T", 1); + newmode.code = irm_T; + + mode_T = register_mode(&newmode); /* ANY */ - mode_ANY = &modes[irm_ANY]; - mode_ANY->name = id_from_str("ANY", 3); - mode_ANY->code = irm_ANY; - mode_ANY->sort = irms_auxiliary; - mode_ANY->sign = 0; - mode_ANY->align = 0; - mode_ANY->size = 0; - mode_ANY->tv_priv = NULL; + newmode.name = id_from_str("ANY", 3); + newmode.code = irm_ANY; + + mode_ANY = register_mode(&newmode); /* BAD */ - mode_BAD = &modes[irm_BAD]; - mode_BAD->name = id_from_str("BAD", 3); - mode_BAD->code = irm_BAD; - mode_BAD->sort = irms_auxiliary; - mode_BAD->sign = 0; - mode_BAD->align = 0; - mode_BAD->size = 0; - mode_BAD->tv_priv = NULL; + newmode.name = id_from_str("BAD", 3); + newmode.code = irm_BAD; + + mode_BAD = register_mode(&newmode); + + /* Internal Boolean Modes */ + newmode.sort = irms_internal_boolean; /* boolean */ - mode_b = &modes[irm_b]; - mode_b->name = id_from_str("b", 1); - mode_b->code = irm_b; - mode_b->sort = irms_internal_boolean; - mode_b->size = 0; - mode_b->align = 0; - mode_b->sign = 0; - mode_b->tv_priv = NULL; + newmode.name = id_from_str("b", 1); + newmode.code = irm_b; + + mode_b = register_mode(&newmode); + +/* Data Modes */ + + /* Float Number Modes */ + newmode.sort = irms_float_number; + newmode.arithmetic = irma_ieee754; /* float */ - mode_F = &modes[irm_F]; - mode_F->name = id_from_str("F", 1); - mode_F->code = irm_F; - mode_F->sort = irms_float_number; - mode_F->sign = 1; - mode_F->align = 4; - mode_F->size = 32; - mode_F->tv_priv = NULL; + newmode.name = id_from_str("F", 1); + newmode.code = irm_F; + newmode.sign = 1; + newmode.align = 4; + newmode.size = 32; - set_mode_values(mode_F); + mode_F = register_mode(&newmode); /* double */ - mode_D = &modes[irm_D]; - mode_D->name = id_from_str("D", 1); - mode_D->code = irm_D; - mode_D->sort = irms_float_number; - mode_D->sign = 1; - mode_D->align = 4; - mode_D->size = 64; - mode_D->tv_priv = NULL; + newmode.name = id_from_str("D", 1); + newmode.code = irm_D; + newmode.sign = 1; + newmode.align = 4; + newmode.size = 64; - set_mode_values(mode_D); + mode_D = register_mode(&newmode); /* extended */ - mode_E = &modes[irm_E]; - mode_E->name = id_from_str("E", 1); - mode_E->code = irm_E; - mode_E->sort = irms_float_number; - mode_E->sign = 1; - mode_E->align = 4; - mode_E->size = 80; - mode_E->tv_priv = NULL; + newmode.name = id_from_str("E", 1); + newmode.code = irm_E; + newmode.sign = 1; + newmode.align = 4; + newmode.size = 80; + + mode_E = register_mode(&newmode); - set_mode_values(mode_E); + /* Integer Number Modes */ + newmode.sort = irms_int_number; + newmode.arithmetic = irma_twos_complement; /* signed byte */ - mode_Bs = &modes[irm_Bs]; - mode_Bs->name = id_from_str("Bs", 2); - mode_Bs->code = irm_Bs; - mode_Bs->sort = irms_int_number; - mode_Bs->sign = 1; - mode_Bs->align = 1; - mode_Bs->size = 8; - mode_Bs->tv_priv = NULL; + newmode.name = id_from_str("Bs", 2); + newmode.code = irm_Bs; + newmode.sign = 1; + newmode.align = 1; + newmode.size = 8; - set_mode_values(mode_Bs); + mode_Bs = register_mode(&newmode); /* unsigned byte */ - mode_Bu = &modes[irm_Bu]; - mode_Bu->name = id_from_str("Bu", 2); - mode_Bu->code = irm_Bu; - mode_Bu->sort = irms_int_number; - mode_Bu->sign = 0; - mode_Bu->align = 1; - mode_Bu->size = 8; - mode_Bu->tv_priv = NULL; + newmode.name = id_from_str("Bu", 2); + newmode.code = irm_Bu; + newmode.arithmetic = irma_twos_complement; + newmode.sign = 0; + newmode.align = 1; + newmode.size = 8; - set_mode_values(mode_Bu); + mode_Bu = register_mode(&newmode); /* signed short integer */ - mode_Hs = &modes[irm_Hs]; - mode_Hs->name = id_from_str("Hs", 2); - mode_Hs->code = irm_Hs; - mode_Hs->sort = irms_int_number; - mode_Hs->sign = 1; - mode_Hs->align = 2; - mode_Hs->size = 16; - mode_Hs->tv_priv = NULL; + newmode.name = id_from_str("Hs", 2); + newmode.code = irm_Hs; + newmode.sign = 1; + newmode.align = 2; + newmode.size = 16; - set_mode_values(mode_Hs); + mode_Hs = register_mode(&newmode); /* unsigned short integer */ - mode_Hu = &modes[irm_Hu]; - mode_Hu->name = id_from_str("Hu", 2); - mode_Hu->code = irm_Hu; - mode_Hu->sort = irms_int_number; - mode_Hu->sign = 0; - mode_Hu->align = 2; - mode_Hu->size = 16; - mode_Hu->tv_priv = NULL; + newmode.name = id_from_str("Hu", 2); + newmode.code = irm_Hu; + newmode.sign = 0; + newmode.align = 2; + newmode.size = 16; - set_mode_values(mode_Hu); + mode_Hu = register_mode(&newmode); /* signed integer */ - mode_Is = &modes[irm_Is]; - mode_Is->name = id_from_str("Is", 2); - mode_Is->code = irm_Is; - mode_Is->sort = irms_int_number; - mode_Is->sign = 1; - mode_Is->align = 4; - mode_Is->size = 32; - mode_Is->tv_priv = NULL; + newmode.name = id_from_str("Is", 2); + newmode.code = irm_Is; + newmode.sign = 1; + newmode.align = 4; + newmode.size = 32; - set_mode_values(mode_Is); + mode_Is = register_mode(&newmode); /* unsigned integer */ - mode_Iu = &modes[irm_Iu]; - mode_Iu->name = id_from_str("Iu", 2); - mode_Iu->code = irm_Iu; - mode_Iu->sort = irms_int_number; - mode_Iu->sign = 0; - mode_Iu->align = 4; - mode_Iu->size = 32; - mode_Iu->tv_priv = NULL; + newmode.name = id_from_str("Iu", 2); + newmode.code = irm_Iu; + newmode.sign = 0; + newmode.align = 4; + newmode.size = 32; - set_mode_values(mode_Iu); + mode_Iu = register_mode(&newmode); /* signed long integer */ - mode_Ls = &modes[irm_Ls]; - mode_Ls->name = id_from_str("Ls", 2); - mode_Ls->code = irm_Ls; - mode_Ls->sort = irms_int_number; - mode_Ls->sign = 1; - mode_Ls->align = 4; - mode_Ls->size = 64; - mode_Ls->tv_priv = NULL; + newmode.name = id_from_str("Ls", 2); + newmode.code = irm_Ls; + newmode.sign = 1; + newmode.align = 4; + newmode.size = 64; - set_mode_values(mode_Ls); + mode_Ls = register_mode(&newmode); /* unsigned long integer */ - mode_Lu = &modes[irm_Lu]; - mode_Lu->name = id_from_str("Lu", 2); - mode_Lu->code = irm_Lu; - mode_Lu->sort = irms_int_number; - mode_Lu->sign = 0; - mode_Lu->align = 4; - mode_Lu->size = 64; - mode_Lu->tv_priv = NULL; + newmode.name = id_from_str("Lu", 2); + newmode.code = irm_Lu; + newmode.sign = 0; + newmode.align = 4; + newmode.size = 64; + + mode_Lu = register_mode(&newmode); - set_mode_values(mode_Lu); + /* Integer Number Modes */ + newmode.sort = irms_character; + newmode.arithmetic = irma_none; /* Character */ - mode_C = &modes[irm_C]; - mode_C->name = id_from_str("C", 1); - mode_C->code = irm_C; - mode_C->sort = irms_character; - mode_C->sign = 0; - mode_C->align = 1; - mode_C->size = 8; - mode_C->tv_priv = NULL; + newmode.name = id_from_str("C", 1); + newmode.code = irm_C; + newmode.sign = 0; + newmode.align = 1; + newmode.size = 8; - set_mode_values(mode_C); + mode_C = register_mode(&newmode); /* Unicode character */ - mode_U = &modes[irm_U]; - mode_U->name = id_from_str("U", 1); - mode_U->code = irm_U; - mode_U->sort = irms_character; - mode_U->sign = 0; - mode_U->align = 2; - mode_U->size = 16; - mode_U->tv_priv = NULL; + newmode.name = id_from_str("U", 1); + newmode.code = irm_U; + newmode.sign = 0; + newmode.align = 2; + newmode.size = 16; - set_mode_values(mode_U); + mode_U = register_mode(&newmode); + + /* Reference Modes */ + newmode.sort = irms_reference; + newmode.arithmetic = irma_twos_complement; /* pointer */ - mode_P = &modes[irm_P]; - mode_P->name = id_from_str("P", 1); - mode_P->code = irm_P; - mode_P->sort = irms_reference; - mode_P->sign = 0; - mode_P->align = 4; - mode_P->size = 32; - mode_P->tv_priv = NULL; - - num_modes = irm_max; + newmode.name = id_from_str("P", 1); + newmode.code = irm_P; + newmode.sign = 0; + newmode.align = 4; + newmode.size = 32; + + mode_P = register_mode(&newmode); } diff --git a/ir/ir/irmode.h b/ir/ir/irmode.h index c97345e77..6ea0aad17 100644 --- a/ir/ir/irmode.h +++ b/ir/ir/irmode.h @@ -84,12 +84,12 @@ typedef enum { /* irm is short for `ir mode' */ */ typedef enum { /* Predefined sorts of modes */ - irms_auxiliary, /**< Only for Firm use. Not extensible. (irm_T, irm_ANY, irm_BAD) */ - /* irms_control_flow **< Marks all control flow modes. Not extensible. (irm_BB, irm_X) */ - /* irms_memory **< Marks the memory mode. Not extensible. (irm_M) */ + irms_auxiliary, /**< Only for Firm use. Not extensible. (irm_T) */ + irms_control_flow, /**< Marks all control flow modes. Not extensible. (irm_BB, irm_X) */ + irms_memory, /**< Marks the memory mode. Not extensible. (irm_M) */ irms_internal_boolean, /**< Internal boolean representation. Storing to memory impossible, convert first. (irm_b) */ - /** user-extensible sorts of modes **/ + /** user-extensible sorts of modes **/ irms_int_number, /**< A mode to represent int numbers. Integer computations can be performed. */ irms_float_number, /**< A mode to represent float numbers. @@ -132,6 +132,7 @@ typedef enum { * @param bit_size number of bits this mode allocate * @param align the byte alignment for an entity of this mode (in bits) * @param sign non-zero if this is a signed mode + * @param arithmetic arithmetic operations possible with a mode * * This function constructs a new mode given by the parameters. * If the parameters match an already defined mode, this mode is returned @@ -147,7 +148,17 @@ typedef enum { * It is allowed to construct the default modes. So, a call * new_ir_mode("Is", irms_int_number, 32, 4, 1) will return mode_Is. */ -ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign); +ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign, mode_arithmetic arithmetic); + +/** + * Checks whether a pointer points to a mode. + * + * @param thing an arbitrary pointer + * + * @return + * true if the thing is a mode, else false + */ +int is_mode (void *thing); /* ********** Access methods to read mode information *********** */ @@ -176,6 +187,15 @@ int get_mode_align(const ir_mode *mode); /** Returns the signess of a mode */ int get_mode_sign (const ir_mode *mode); +/** Returns the arithmetic of a mode */ +int get_mode_arithmetic (const ir_mode *mode); + +/** Returns the stored intermediate information. */ +void* get_mode_link(const ir_mode *mode); + +/** Stores new intermediate information. */ +void set_mode_link(ir_mode *mode, void *l); + /** * Returns the smallest representable value of a given mode. * diff --git a/ir/ir/irmode_t.h b/ir/ir/irmode_t.h index f64dcba48..6cd07b406 100644 --- a/ir/ir/irmode_t.h +++ b/ir/ir/irmode_t.h @@ -9,19 +9,27 @@ # define _IRMODE_T_H_ # include "irmode.h" +# include "tv.h" /** This struct is supposed to completely define a mode. **/ struct ir_mode { - firm_kind kind; /**< is set to k_ir_mode */ - modecode code; /**< unambiguous identifier of a mode */ - ident *name; /**< Name ident of this mode */ - mode_sort sort; /**< coarse classification of this mode: - int, float, reference ... - (see irmode.h) */ - int size; /**< size of the mode in Bits. */ - int align; /**< byte alignment */ - unsigned sign:1; /**< signedness of this mode */ - const void *tv_priv; /**< tarval module will save private data here */ + firm_kind kind; /**< distinguishes this node from others */ + modecode code; /**< unambiguous identifier of a mode */ + ident *name; /**< Name ident of this mode */ + mode_sort sort; /**< coarse classification of this mode: + int, float, reference ... + (see irmode.h) */ + mode_arithmetic arithmetic; /**< different arithmetic operations possible with a mode */ + int size; /**< size of the mode in Bits. */ + int align; /**< byte alignment */ + unsigned sign:1; /**< signedness of this mode */ + + tarval *min; + tarval *max; + tarval *null; + tarval *one; + void *link; /**< To store some intermediate information */ + const void *tv_priv; /**< tarval module will save private data here */ }; #endif diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c index fef3dcb8f..671170402 100644 --- a/ir/ir/irnode.c +++ b/ir/ir/irnode.c @@ -78,12 +78,12 @@ get_negated_pnc(int pnc) { return 99; /* to shut up gcc */ } -static const char *pns_name_arr [] = { +const char *pns_name_arr [] = { "initial_exec", "global_store", "frame_base", "globals", "args" }; -static const char *symconst_name_arr [] = { +const char *symconst_name_arr [] = { "type_tag", "size", "linkage_ptr_info" }; diff --git a/ir/ir/irnode.h b/ir/ir/irnode.h index 1cc751786..79a5ea035 100644 --- a/ir/ir/irnode.h +++ b/ir/ir/irnode.h @@ -102,6 +102,8 @@ INLINE void set_irn_in (ir_node *node, int arity, /* get_irn_n removes Id predecessors. */ INLINE ir_node *get_irn_n (ir_node *node, int n); INLINE void set_irn_n (ir_node *node, int n, ir_node *in); +/** Sets the mode struct of node */ +INLINE void set_irn_mode (ir_node *node, ir_mode *mode); /** Gets the mode struct. */ INLINE ir_mode *get_irn_mode (const ir_node *node); /** Gets the mode-enum modecode. */ diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c index 4ce8c62cd..7da9a0b5c 100644 --- a/ir/ir/iropt.c +++ b/ir/ir/iropt.c @@ -21,7 +21,7 @@ # include "tv.h" # include "tune.h" # include "dbginfo_t.h" -# include "iropt_dbg.c" +# include "iropt_dbg.h" /* Make types visible to allow most efficient access */ # include "entity_t.h" diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c index 795de286c..99bdf4e45 100644 --- a/ir/ir/irvrfy.c +++ b/ir/ir/irvrfy.c @@ -1,10 +1,10 @@ /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe -* All rights reserved. -* -* Authors: Christian Schaefer -* -* -*/ + * All rights reserved. + * + * Authors: Christian Schaefer + * + * + */ /* $Id$ */ @@ -17,9 +17,9 @@ # include "irgwalk.h" #ifdef NDEBUG -#define ASSERT_AND_RET(expr, string, ret) if (!(expr)) return (ret) +#define ASSERT_AND_RET(expr, string, ret) if (!(expr)) return (ret) #else -#define ASSERT_AND_RET(expr, string, ret) do { assert((expr) && string); if (!(expr)) return (ret); } while(0) +#define ASSERT_AND_RET(expr, string, ret) do { assert((expr) && string); if (!(expr)) return (ret); } while(0) #endif /* @@@ replace use of array "in" by access functions. */ @@ -37,132 +37,163 @@ vrfy_Proj_proj(ir_node *p, ir_graph *irg) { proj = get_Proj_proj(p); switch (get_irn_opcode(pred)) { - case iro_Start: - ASSERT_AND_RET( - ((proj == 0 && mode == mode_X) || - (proj == 1 && mode == mode_M) || - (proj == 2 && mode == mode_P) || - (proj == 3 && mode == mode_P) || - (proj == 4 && mode == mode_T)), - "wrong Proj from Start", 0); - break; - case iro_Cond: - ASSERT_AND_RET( (proj >= 0 && mode == mode_X), "wrong Proj from Cond", 0); - break; - case iro_Raise: - ASSERT_AND_RET( ((proj == 0 && mode == mode_X) || (proj == 1 && mode == mode_M)), - "wrong Proj from Raise", 0); - break; - case iro_InstOf: - ASSERT_AND_RET( (proj >= 0 && mode == mode_X), "wrong Proj from InstOf", 0); - break; - case iro_Call: - ASSERT_AND_RET( - ((proj == 0 && mode == mode_M) || - (proj == 1 && mode == mode_X) || - (proj == 2 && mode == mode_T) || - (proj == 3 && mode == mode_M)), - "wrong Proj from Call", 0); - break; - case iro_Quot: - ASSERT_AND_RET( - ((proj == 0 && mode == mode_M) || - (proj == 1 && mode == mode_X) || - (proj == 2 && mode_is_float(mode))), - "wrong Proj from Quot", 0); - break; - case iro_DivMod: - ASSERT_AND_RET( - ((proj == 0 && mode == mode_M) || - (proj == 1 && mode == mode_X) || - (proj == 2 && mode == mode_Is) || - (proj == 3 && mode == mode_Is)), - "wrong Proj from DivMod", 0); - break; - case iro_Div: - case iro_Mod: - ASSERT_AND_RET( - ((proj == 0 && mode == mode_M) || - (proj == 1 && mode == mode_X) || - (proj == 2 && mode == mode_Is)), - "wrong Proj from Div or Mod", 0); - break; - case iro_Cmp: - ASSERT_AND_RET( - (proj >= 0 && proj <= 15 && mode == mode_b), - "wrong Proj from Cmp", 0); - break; - case iro_Load: - ASSERT_AND_RET( - ((proj == 0 && mode == mode_M) || - (proj == 1 && mode == mode_X) || - (proj == 2 && mode_is_data(mode))), - "wrong Proj from Load", 0); - break; - case iro_Store: - ASSERT_AND_RET( - ((proj == 0 && mode == mode_M) || - (proj == 1 && mode == mode_X)), - "wrong Proj from Store", 0); - break; - case iro_Alloc: - ASSERT_AND_RET( - ((proj == 0 && mode == mode_M) || - (proj == 1 /* && mode == mode_X*/) || - (proj == 2 && mode == mode_P)), - "wrong Proj from Alloc", 0); - break; - case iro_Proj: { - type *mt; /* A method type */ - pred = skip_nop(get_Proj_pred(pred)); - ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0); - switch (get_irn_opcode(pred)) { - case iro_Start: { - ASSERT_AND_RET( - (proj >= 0 && mode_is_data(mode)), - "wrong Proj from Proj from Start", 0); - mt = get_entity_type(get_irg_ent(irg)); + case iro_Start: + ASSERT_AND_RET( + ((proj == 0 && mode == mode_X) || + (proj == 1 && mode == mode_M) || + (proj == 2 && mode == mode_P) || + (proj == 3 && mode == mode_P) || + (proj == 4 && mode == mode_T)), + "wrong Proj from Start", 0); + break; + + case iro_Cond: + ASSERT_AND_RET( (proj >= 0 && mode == mode_X), "wrong Proj from Cond", 0); + break; + + case iro_Raise: ASSERT_AND_RET( - (proj < get_method_n_params(mt)), - "More Projs for args than args in type", 0); - if ((mode == mode_P) && is_compound_type(get_method_param_type(mt, proj))) - /* value argument */ break; - ASSERT_AND_RET( - (mode == get_type_mode(get_method_param_type(mt, proj))), - "Mode of Proj from Start doesn't match mode of param type.", 0); - } break; - case iro_Call: { - ASSERT_AND_RET( - (proj >= 0 && mode_is_data(mode)), - "wrong Proj from Proj from Call", 0); - mt = get_Call_type(pred); - ASSERT_AND_RET( - (proj < get_method_n_ress(mt)), - "More Projs for results than results in type.", 0); - if ((mode == mode_P) && is_compound_type(get_method_res_type(mt, proj))) - /* value result */ break; - ASSERT_AND_RET( - (mode == get_type_mode(get_method_res_type(mt, proj))), - "Mode of Proj from Call doesn't match mode of result type.", 0); - } break; - case iro_Tuple: ; + ((proj == 0 && mode == mode_X) || + (proj == 1 && mode == mode_M)), + "wrong Proj from Raise", 0); + break; + + case iro_InstOf: + ASSERT_AND_RET( (proj >= 0 && mode == mode_X), "wrong Proj from InstOf", 0); + break; + + case iro_Call: + ASSERT_AND_RET( + ((proj == 0 && mode == mode_M) || + (proj == 1 && mode == mode_X) || + (proj == 2 && mode == mode_T) || + (proj == 3 && mode == mode_M)), + "wrong Proj from Call", 0); + break; + + case iro_Quot: + ASSERT_AND_RET( + ((proj == 0 && mode == mode_M) || + (proj == 1 && mode == mode_X) || + (proj == 2 && mode_is_float(mode))), + "wrong Proj from Quot", 0); + break; + + case iro_DivMod: + ASSERT_AND_RET( + ((proj == 0 && mode == mode_M) || + (proj == 1 && mode == mode_X) || + (proj == 2 && mode == mode_Is) || + (proj == 3 && mode_is_int(mode))), + "wrong Proj from DivMod", 0); + break; + + case iro_Div: + case iro_Mod: + ASSERT_AND_RET( + ((proj == 0 && mode == mode_M) || + (proj == 1 && mode == mode_X) || + (proj == 2 && mode_is_int(mode))), + "wrong Proj from Div or Mod", 0); + break; + + case iro_Cmp: + ASSERT_AND_RET( + (proj >= 0 && proj <= 15 && mode == mode_b), + "wrong Proj from Cmp", 0); + break; + + case iro_Load: + ASSERT_AND_RET( + ((proj == 0 && mode == mode_M) || + (proj == 1 && mode == mode_X) || + (proj == 2 && mode_is_data(mode))), + "wrong Proj from Load", 0); + break; + + case iro_Store: + ASSERT_AND_RET( + ((proj == 0 && mode == mode_M) || + (proj == 1 && mode == mode_X)), + "wrong Proj from Store", 0); + break; + + case iro_Alloc: + ASSERT_AND_RET( + ((proj == 0 && mode == mode_M) || + (proj == 1 /* && mode == mode_X*/) || + (proj == 2 && mode == mode_P)), + "wrong Proj from Alloc", 0); + break; + + case iro_Proj: + { + type *mt; /* A method type */ + pred = skip_nop(get_Proj_pred(pred)); + ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0); + switch (get_irn_opcode(pred)) + { + case iro_Start: + { + ASSERT_AND_RET( + (proj >= 0 && mode_is_data(mode)), + "wrong Proj from Proj from Start", 0); + mt = get_entity_type(get_irg_ent(irg)); + ASSERT_AND_RET( + (proj < get_method_n_params(mt)), + "More Projs for args than args in type", 0); + if ((mode == mode_P) && is_compound_type(get_method_param_type(mt, proj))) + /* value argument */ break; + + ASSERT_AND_RET( + (mode == get_type_mode(get_method_param_type(mt, proj))), + "Mode of Proj from Start doesn't match mode of param type.", 0); + } + break; + + case iro_Call: + { + ASSERT_AND_RET( + (proj >= 0 && mode_is_data(mode)), + "wrong Proj from Proj from Call", 0); + mt = get_Call_type(pred); + ASSERT_AND_RET( + (proj < get_method_n_ress(mt)), + "More Projs for results than results in type.", 0); + if ((mode == mode_P) && is_compound_type(get_method_res_type(mt, proj))) + /* value result */ break; + + ASSERT_AND_RET( + (mode == get_type_mode(get_method_res_type(mt, proj))), + "Mode of Proj from Call doesn't match mode of result type.", 0); + } + break; + + case iro_Tuple: + /* We don't test */ + break; + + default: + ASSERT_AND_RET(0, "Unknown opcode", 0); + } + break; + + } + case iro_Tuple: /* We don't test */ break; + + case iro_CallBegin: + break; + + case iro_EndReg: + break; + + case iro_EndExcept: + break; + default: ASSERT_AND_RET(0, "Unknown opcode", 0); - } break; - } - case iro_Tuple: - /* We don't test */ - break; - case iro_CallBegin: - break; - case iro_EndReg: - break; - case iro_EndExcept: - break; - default: - ASSERT_AND_RET(0, "Unknown opcode", 0); } /* all went ok */ @@ -174,9 +205,9 @@ int irn_vrfy_irg(ir_node *n, ir_graph *irg) int i; int opcode, opcode1; ir_mode *mymode, *op1mode = NULL, *op2mode, *op3mode; - int op_is_symmetric = 1; /* 0: asymmetric - 1: operands have identical modes - 2: modes of operands == mode of this node */ + int op_is_symmetric = 1; /* 0: asymmetric +1: operands have identical modes +2: modes of operands == mode of this node */ type *mt; /* A method type */ ir_node **in; @@ -197,168 +228,180 @@ int irn_vrfy_irg(ir_node *n, ir_graph *irg) for (i = 0; i < get_irn_arity(n); i++) { opcode1 = get_irn_opcode(get_irn_n(n, i)); if (opcode1 == iro_Bad || opcode1 == iro_Unknown) - return 1; + return 1; } mymode = get_irn_mode (n); in = get_irn_in (n); - switch (opcode) { - - case iro_Start: - ASSERT_AND_RET( - /* Start: BB --> X x M x P x data1 x ... x datan */ - mymode == mode_T, "Start node", 0 - ); - break; - case iro_Jmp: - ASSERT_AND_RET( - /* Jmp: BB --> X */ - mymode == mode_X, "Jmp node", 0 - ); - break; - case iro_Break: - ASSERT_AND_RET( - /* Jmp: BB --> X */ - mymode == mode_X, "Jmp node", 0 - ); - break; - case iro_Cond: - op1mode = get_irn_mode(in[1]); - ASSERT_AND_RET( - /* Cond: BB x b --> X x X */ - (op1mode == mode_b - /* Cond: BB x Iu --> X^n */ - || op1mode == mode_Iu), "Cond node", 0 - ); - ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0); - break; - case iro_Return: - op1mode = get_irn_mode(in[1]); - /* Return: BB x M x data1 x ... x datan --> X */ - /* printf("mode: %s, code %s\n", ID_TO_STR(n->mode->name), ID_TO_STR(n->op->name));*/ - ASSERT_AND_RET( op1mode == mode_M, "Return node", 0 ); /* operand M */ - for (i=2; i < get_irn_arity(n); i++) { - ASSERT_AND_RET( mode_is_data(get_irn_mode(in[i])), "Return node", 0 ); /* operand datai */ - }; - ASSERT_AND_RET( mymode == mode_X, "Result X", 0 ); /* result X */ - /* Compare returned results with result types of method type */ - mt = get_entity_type(get_irg_ent(irg)); - ASSERT_AND_RET( get_Return_n_ress(n) == get_method_n_ress(mt), - "Number of results for Return doesn't match number of results in type.", 0 ); - for (i = 0; i < get_Return_n_ress(n); i++) - ASSERT_AND_RET( - get_irn_mode(get_Return_res(n, i)) == get_type_mode(get_method_res_type(mt, i)), - "Mode of result for Return doesn't match mode of result type.", 0); - break; - case iro_Raise: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - ASSERT_AND_RET( - /* Sel: BB x M x P --> X x M */ - op1mode == mode_M && op2mode == mode_P - && mymode == mode_T, "Raise node", 0 - ); - break; - case iro_Const: - ASSERT_AND_RET( - /* Const: BB --> data */ - (mode_is_data (mymode) || - mymode == mode_b) /* we want boolean constants for static evaluation */ - ,"Const node", 0 /* of Cmp. */ - ); - break; - case iro_SymConst: - ASSERT_AND_RET( - /* SymConst: BB --> Iu or - BB --> P */ - ((mymode == mode_Iu) || (mymode == mode_P)), "SymConst node", 0 - ); - break; - case iro_Sel: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - ASSERT_AND_RET( - /* Sel: BB x M x P x Iu^n --> P */ - op1mode == mode_M && op2mode == mode_P - && mymode == mode_P, "Sel node", 0 - ); - for (i=3; i < get_irn_arity(n); i++) { - ASSERT_AND_RET(get_irn_mode(in[i]) == mode_Iu, "Sel node", 0); - } - break; - case iro_InstOf: - ASSERT_AND_RET(mode_T == mymode, "mode of Instof is not a tuple", 0); - ASSERT_AND_RET(mode_is_data(op1mode), "Instof not on data", 0); - break; - case iro_Call: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); + switch (opcode) + { + case iro_Start: + ASSERT_AND_RET( + /* Start: BB --> X x M x P x data1 x ... x datan */ + mymode == mode_T, "Start node", 0 + ); + break; + + case iro_Jmp: + ASSERT_AND_RET( + /* Jmp: BB --> X */ + mymode == mode_X, "Jmp node", 0 + ); + break; + + case iro_Break: + ASSERT_AND_RET( + /* Jmp: BB --> X */ + mymode == mode_X, "Jmp node", 0 + ); + break; + + case iro_Cond: + op1mode = get_irn_mode(in[1]); + ASSERT_AND_RET( + /* Cond: BB x b --> X x X */ + (op1mode == mode_b || + /* Cond: BB x int --> X^n */ + mode_is_int(op1mode) ), "Cond node", 0 + ); + ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0); + break; + + case iro_Return: + op1mode = get_irn_mode(in[1]); + /* Return: BB x M x data1 x ... x datan --> X */ + /* printf("mode: %s, code %s\n", ID_TO_STR(n->mode->name), ID_TO_STR(n->op->name));*/ + ASSERT_AND_RET( op1mode == mode_M, "Return node", 0 ); /* operand M */ + for (i=2; i < get_irn_arity(n); i++) { + ASSERT_AND_RET( mode_is_data(get_irn_mode(in[i])), "Return node", 0 ); /* operand datai */ + }; + ASSERT_AND_RET( mymode == mode_X, "Result X", 0 ); /* result X */ + /* Compare returned results with result types of method type */ + mt = get_entity_type(get_irg_ent(irg)); + ASSERT_AND_RET( get_Return_n_ress(n) == get_method_n_ress(mt), + "Number of results for Return doesn't match number of results in type.", 0 ); + for (i = 0; i < get_Return_n_ress(n); i++) + ASSERT_AND_RET( + get_irn_mode(get_Return_res(n, i)) == get_type_mode(get_method_res_type(mt, i)), + "Mode of result for Return doesn't match mode of result type.", 0); + break; + + case iro_Raise: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + ASSERT_AND_RET( + /* Sel: BB x M x P --> X x M */ + op1mode == mode_M && op2mode == mode_P && + mymode == mode_T, "Raise node", 0 + ); + break; + + case iro_Const: + ASSERT_AND_RET( + /* Const: BB --> data */ + (mode_is_data (mymode) || + mymode == mode_b) /* we want boolean constants for static evaluation */ + ,"Const node", 0 /* of Cmp. */ + ); + break; + + case iro_SymConst: + ASSERT_AND_RET( + /* SymConst: BB --> int*/ + (mode_is_int(mymode) || + /* SymConst: BB --> P*/ + mymode == mode_P) + ,"SymConst node", 0); + break; + + case iro_Sel: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + ASSERT_AND_RET( + /* Sel: BB x M x P x int^n --> P */ + op1mode == mode_M && op2mode == mode_P && + mymode == mode_P, "Sel node", 0 + ); + for (i=3; i < get_irn_arity(n); i++) + { + ASSERT_AND_RET(mode_is_int(get_irn_mode(in[i])), "Sel node", 0); + } + break; + + case iro_InstOf: + ASSERT_AND_RET(mode_T == mymode, "mode of Instof is not a tuple", 0); + ASSERT_AND_RET(mode_is_data(op1mode), "Instof not on data", 0); + break; + + case iro_Call: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); /* Call: BB x M x P x data1 x ... x datan - --> M x datan+1 x ... x data n+m */ - ASSERT_AND_RET( op1mode == mode_M && op2mode == mode_P, "Call node", 0 ); /* operand M x P */ - for (i=3; i < get_irn_arity(n); i++) { - ASSERT_AND_RET( mode_is_data(get_irn_mode(in[i])), "Call node", 0 ); /* operand datai */ - }; - ASSERT_AND_RET( mymode == mode_T, "Call result not a tuple", 0 ); /* result T */ - /* Compare arguments of node with those of type */ - mt = get_Call_type(n); - - if (get_method_variadicity(mt) == variadic) { - ASSERT_AND_RET( - get_Call_n_params(n) >= get_method_n_params(mt), - "Number of args for Call doesn't match number of args in variadic type.", - 0); + --> M x datan+1 x ... x data n+m */ + ASSERT_AND_RET( op1mode == mode_M && op2mode == mode_P, "Call node", 0 ); /* operand M x P */ + for (i=3; i < get_irn_arity(n); i++) { + ASSERT_AND_RET( mode_is_data(get_irn_mode(in[i])), "Call node", 0 ); /* operand datai */ + }; + ASSERT_AND_RET( mymode == mode_T, "Call result not a tuple", 0 ); /* result T */ + /* Compare arguments of node with those of type */ + mt = get_Call_type(n); + + if (get_method_variadicity(mt) == variadic) { + ASSERT_AND_RET( + get_Call_n_params(n) >= get_method_n_params(mt), + "Number of args for Call doesn't match number of args in variadic type.", + 0); } - else { - ASSERT_AND_RET( - get_Call_n_params(n) == get_method_n_params(mt), - "Number of args for Call doesn't match number of args in non variadic type.", - 0); + else { + ASSERT_AND_RET( + get_Call_n_params(n) == get_method_n_params(mt), + "Number of args for Call doesn't match number of args in non variadic type.", + 0); } - for (i = 0; i < get_method_n_params(mt); i++) { + for (i = 0; i < get_method_n_params(mt); i++) { + ASSERT_AND_RET( + get_irn_mode(get_Call_param(n, i)) == get_type_mode(get_method_param_type(mt, i)), + "Mode of arg for Call doesn't match mode of arg type.", 0); + } + break; + + case iro_Add: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); ASSERT_AND_RET( - get_irn_mode(get_Call_param(n, i)) == get_type_mode(get_method_param_type(mt, i)), - "Mode of arg for Call doesn't match mode of arg type.", 0); - } - break; - case iro_Add: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - ASSERT_AND_RET( - /* common Add: BB x num x num --> num */ - ((mymode == op1mode && mymode == op2mode - && (mode_is_num(mymode) || mymode == mode_P)) - || /* Pointer Add: BB x P x Is --> P */ - (op1mode == mode_P && op2mode == mode_Is && mymode == mode_P) - || /* Pointer Add: BB x Is x P --> P */ - (op1mode == mode_Is && op2mode == mode_P && mymode == mode_P)), - "Add node", 0 - ); + /* common Add: BB x num x num --> num */ + (( op1mode == mymode && op2mode == op1mode && mode_is_num(mymode)) || + /* Pointer Add: BB x P x int --> P */ + (op1mode == mode_P && mode_is_int(op2mode) && mymode == mode_P) || + /* Pointer Add: BB x int x P --> P */ + (mode_is_int(op1mode) && op2mode == mode_P && mymode == mode_P)), + "Add node", 0 + ); if (op1mode == mode_P || op2mode == mode_P) { - /* BB x P x Is --> P or BB x Is x P --> P */ + /* BB x P x int --> P or BB x int x P --> P */ op_is_symmetric = 0; /* ArmRoq */ } else { - /* BB x num x num --> num */ + /* BB x num x num --> num */ op_is_symmetric = 2; } - break; - case iro_Sub: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - ASSERT_AND_RET( - /* common Sub: BB x num x num --> num */ - ((mymode ==op1mode && mymode == op2mode - && mode_is_num(op1mode)) - || /* Pointer Sub: BB x P x Is --> P */ - (op1mode == mode_P && op2mode == mode_Is && mymode == mode_P) - || /* Pointer Sub: BB x Is x P --> P */ - (op1mode == mode_Is && op2mode == mode_P && mymode == mode_P) - || /* Pointer Sub: BB x P x P --> Is */ - (op1mode == mode_P && op2mode == mode_P && mymode == mode_Is)), - "Sub node", 0 - ); + break; + + case iro_Sub: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + ASSERT_AND_RET( + /* common Sub: BB x num x num --> num */ + ((mymode ==op1mode && mymode == op2mode && mode_is_num(op1mode)) || + /* Pointer Sub: BB x P x int --> P */ + (op1mode == mode_P && mode_is_int(op2mode) && mymode == mode_P) || + /* Pointer Sub: BB x int x P --> P */ + (mode_is_int(op1mode) && op2mode == mode_P && mymode == mode_P) || + /* Pointer Sub: BB x P x P --> int */ + (op1mode == mode_P && op2mode == mode_P && mode_is_int(mymode))), + "Sub node", 0 + ); if (op1mode == mode_P && op2mode == mode_P) { op_is_symmetric = 1; /* ArmRoq */ } else if (op1mode == mode_P || op2mode == mode_P) { @@ -366,181 +409,232 @@ int irn_vrfy_irg(ir_node *n, ir_graph *irg) } else { op_is_symmetric = 2; } - break; - case iro_Minus: - op1mode = get_irn_mode(in[1]); - ASSERT_AND_RET( - /* Minus: BB x float --> float */ - op1mode == mymode && mode_is_float(op1mode), "Minus node", 0 - ); - op_is_symmetric = 2; - break; - case iro_Mul: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - ASSERT_AND_RET( - /* Mul: BB x num x num --> num */ - mymode == op1mode && mymode == op2mode && mode_is_num(op1mode), - "Mul node", 0 - ); - op_is_symmetric = 2; - break; - case iro_Quot: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - op3mode = get_irn_mode(in[3]); - ASSERT_AND_RET( - /* Quot: BB x M x float x float --> M x X x float */ - op1mode == mode_M && op2mode == op3mode - && mode_is_float(op2mode) && mymode == mode_T, - "Quot node", 0 - ); - op_is_symmetric = 2; - break; - case iro_DivMod:; - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - op3mode = get_irn_mode(in[3]); - ASSERT_AND_RET( - /* DivMod: BB x M x num x num --> M x X x Is x Is */ - op1mode == mode_M && op2mode == op3mode - && mode_is_num (op2mode) && mymode == mode_T, - "DivMod node", 0 - ); - op_is_symmetric = 1; - break; - case iro_Div: - case iro_Mod: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - op3mode = get_irn_mode(in[3]); - ASSERT_AND_RET( - /* Div or Mod: BB x M x num x num --> M x X x Is */ - op1mode == mode_M && op2mode == op3mode && - mode_is_num (op2mode) && mymode == mode_T, - "Div or Mod node", 0 - ); - op_is_symmetric = 1; - break; - case iro_Abs: - op1mode = get_irn_mode(in[1]); - ASSERT_AND_RET( - /* Abs: BB x num --> num */ - op1mode == mymode && mode_is_num (op1mode), "Abs node", 0 - ); - op_is_symmetric = 2; - break; - case iro_And: - case iro_Or: - case iro_Eor: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - ASSERT_AND_RET( - /* And or Or or Eor: BB x int x int --> int */ - mymode == op1mode && mymode == op2mode && mode_is_int(mymode), - "And, Or or Eor node", 0 - ); - op_is_symmetric = 2; - break; - case iro_Not: - op1mode = get_irn_mode(in[1]); - ASSERT_AND_RET( - /* Not: BB x int --> int */ - mymode == op1mode && mode_is_int(mymode), - "Not node", 0 - ); - op_is_symmetric = 2; - break; - - case iro_Cmp: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - ASSERT_AND_RET( - /* Cmp: BB x datab x datab --> b16 */ - op1mode == op2mode && mode_is_data(op1mode) && mymode == mode_T, - "Cmp node", 0 - ); - break; - case iro_Shl: - case iro_Shr: - case iro_Shrs: - case iro_Rot: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - ASSERT_AND_RET( - /* Shl, Shr, Shrs or Rot: BB x int x Iu --> int */ - mode_is_int(op1mode) && op2mode == mode_Iu && op1mode == mymode, - "Shl, Shr, Shr or Rot node", 0 - ); - break; - case iro_Conv: - op1mode = get_irn_mode(in[1]); - ASSERT_AND_RET( - /* Conv: BB x datab1 --> datab2 */ - mode_is_datab(op1mode) && mode_is_data(mymode), - "Conv node", 0 - ); - break; - case iro_Phi: - /* Phi: BB x dataM^n --> dataM */ - /* for some reason "<=" aborts. Is there a problem with get_store? */ - for (i=1; i < get_irn_arity(n); i++) { - if (!is_Bad(in[i]) && (get_irn_op(in[i]) != op_Unknown)) - ASSERT_AND_RET( get_irn_mode(in[i]) == mymode, "Phi node", 0); - }; - ASSERT_AND_RET( mode_is_dataM(mymode), "Phi node", 0 ); - break; - case iro_Load: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - ASSERT_AND_RET( - /* Load: BB x M x P --> M x X x data */ - op1mode == mode_M && op2mode == mode_P, - "Load node", 0 - ); - ASSERT_AND_RET( mymode == mode_T, "Load node", 0 ); - break; - case iro_Store: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - op3mode = get_irn_mode(in[3]); - ASSERT_AND_RET( - /* Load: BB x M x P x data --> M x X */ - op1mode == mode_M && op2mode == mode_P && mode_is_data(op3mode), - "Store node", 0 - ); - ASSERT_AND_RET(mymode == mode_T, "Store node", 0); - break; - case iro_Alloc: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - ASSERT_AND_RET( - /* Alloc: BB x M x Iu --> M x X x P */ - op1mode == mode_M && op2mode == mode_Iu && mymode == mode_T, - "Alloc node", 0 - ); - break; - case iro_Free: - op1mode = get_irn_mode(in[1]); - op2mode = get_irn_mode(in[2]); - op3mode = get_irn_mode(in[3]); - ASSERT_AND_RET( - /* Free: BB x M x P x Iu --> M */ - op1mode == mode_M && op2mode == mode_P && op3mode == mode_Iu && mymode == mode_M, - "Free node", 0 - ); - break; - case iro_Sync: - /* Sync: BB x M^n --> M */ - for (i=1; i < get_irn_arity(n); i++) { - ASSERT_AND_RET( get_irn_mode(in[i]) == mode_M, "Sync node", 0 ); - }; - ASSERT_AND_RET( mymode == mode_M, "Sync node", 0 ); - break; - case iro_Proj: - return vrfy_Proj_proj(n, irg); - break; - default: ; + break; + + case iro_Minus: + op1mode = get_irn_mode(in[1]); + ASSERT_AND_RET( + /* Minus: BB x float --> float */ + op1mode == mymode && get_mode_sort(op1mode) == irms_float_number, "Minus node", 0 + ); + op_is_symmetric = 2; + break; + + case iro_Mul: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + ASSERT_AND_RET( + /* Mul: BB x int1 x int1 --> int2 */ + mode_is_int(op1mode) && + op2mode == op1mode && + mode_is_int(mymode), + "Mul node",0 + ); + op_is_symmetric = 2; + break; + + case iro_Quot: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + op3mode = get_irn_mode(in[3]); + ASSERT_AND_RET( + /* Quot: BB x M x float x float --> M x X x float */ + op1mode == mode_M && op2mode == op3mode && + get_mode_sort(op2mode) == irms_float_number && + mymode == mode_T, + "Quot node",0 + ); + op_is_symmetric = 2; + break; + + case iro_DivMod: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + op3mode = get_irn_mode(in[3]); + ASSERT_AND_RET( + /* DivMod: BB x M x int x int --> M x X x int x int */ + op1mode == mode_M && + mode_is_int(op2mode) && + op3mode == op2mode && + mymode == mode_T, + "DivMod node", 0 + ); + op_is_symmetric = 1; + break; + + case iro_Div: + case iro_Mod: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + op3mode = get_irn_mode(in[3]); + ASSERT_AND_RET( + /* Div or Mod: BB x M x int x int --> M x X x int */ + op1mode == mode_M && + op2mode == op3mode && + mode_is_int(op2mode) && + mymode == mode_T, + "Div or Mod node", 0 + ); + op_is_symmetric = 1; + break; + + case iro_Abs: + op1mode = get_irn_mode(in[1]); + ASSERT_AND_RET( + /* Abs: BB x num --> num */ + op1mode == mymode && + mode_is_num (op1mode), + "Abs node",0 + ); + op_is_symmetric = 2; + break; + + case iro_And: + case iro_Or: + case iro_Eor: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + ASSERT_AND_RET( + /* And or Or or Eor: BB x int x int --> int */ + mode_is_int(mymode) && + op2mode == op1mode && + mymode == op2mode, + "And, Or or Eor node", 0 + ); + op_is_symmetric = 2; + break; + + case iro_Not: + op1mode = get_irn_mode(in[1]); + ASSERT_AND_RET( + /* Not: BB x int --> int */ + mode_is_int(mymode) && + mymode == op1mode, + "Not node", 0 + ); + op_is_symmetric = 2; + break; + + + case iro_Cmp: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + ASSERT_AND_RET( + /* Cmp: BB x datab x datab --> b16 */ + mode_is_data (op1mode) && + op2mode == op1mode && + mymode == mode_T, + "Cmp node", 0 + ); + break; + + case iro_Shl: + case iro_Shr: + case iro_Shrs: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + assert( + /* Shl, Shr or Shrs: BB x int x int_u --> int */ + mode_is_int(op1mode) && + mode_is_int(op2mode) && + !mode_is_signed(op2mode) && + mymode == op1mode && + "Shl, Shr, Shr or Rot node" + ); + break; + + case iro_Rot: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + ASSERT_AND_RET( + /* Rot: BB x int x int --> int */ + mode_is_int(op1mode) && + mode_is_int(op2mode) && + mymode == op1mode, + "Rot node",0 + ); + break; + + case iro_Conv: + op1mode = get_irn_mode(in[1]); + ASSERT_AND_RET( + /* Conv: BB x datab1 --> datab2 */ + mode_is_datab(op1mode) && mode_is_data(mymode), + "Conv node", 0 + ); + break; + + case iro_Phi: + /* Phi: BB x dataM^n --> dataM */ + /* for some reason "<=" aborts. int there a problem with get_store? */ + for (i=1; i < get_irn_arity(n); i++) { + if (!is_Bad(in[i]) && (get_irn_op(in[i]) != op_Unknown)) + ASSERT_AND_RET( get_irn_mode(in[i]) == mymode, "Phi node", 0); + }; + ASSERT_AND_RET( mode_is_dataM(mymode), "Phi node", 0 ); + break; + + case iro_Load: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + ASSERT_AND_RET( + /* Load: BB x M x P --> M x X x data */ + op1mode == mode_M && op2mode == mode_P, + "Load node", 0 + ); + ASSERT_AND_RET( mymode == mode_T, "Load node", 0 ); + break; + + case iro_Store: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + op3mode = get_irn_mode(in[3]); + ASSERT_AND_RET( + /* Load: BB x M x P x data --> M x X */ + op1mode == mode_M && op2mode == mode_P && mode_is_data(op3mode), + "Store node", 0 + ); + ASSERT_AND_RET(mymode == mode_T, "Store node", 0); + break; + + case iro_Alloc: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + ASSERT_AND_RET( + /* Alloc: BB x M x int_u --> M x X x P */ + op1mode == mode_M && + mode_is_int(op2mode) && + !mode_is_signed(op2mode) && + mymode == mode_T, + "Alloc node", 0 + ); + break; + + case iro_Free: + op1mode = get_irn_mode(in[1]); + op2mode = get_irn_mode(in[2]); + ASSERT_AND_RET( + /* Free: BB x M x P --> M */ + op1mode == mode_M && op2mode == mode_P && + mymode == mode_M, + "Free node",0 + ); + break; + + case iro_Sync: + /* Sync: BB x M^n --> M */ + for (i=1; i < get_irn_arity(n); i++) { + ASSERT_AND_RET( get_irn_mode(in[i]) == mode_M, "Sync node", 0 ); + }; + ASSERT_AND_RET( mymode == mode_M, "Sync node", 0 ); + break; + + case iro_Proj: + return vrfy_Proj_proj(n, irg); + break; + + default: + break; } /* All went ok */