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
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);
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;
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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;
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);
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);
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);
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;
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;
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;
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;
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
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
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. */
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;
}
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;
}
/** 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
# include <stdlib.h>
-# include "irnode.h"
+# include "irnode_t.h"
# include "irgraph.h" /* visited flag */
# include "irprog.h"
# include "irgwalk.h"
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);
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));
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;
/********************************************************************/
typedef struct walk_env {
- void *pre;
- void *post;
+ irg_walk_func *pre;
+ irg_walk_func *post;
void *env;
} walk_env;
# include <stddef.h>
# include <string.h>
# include "tv.h"
-# include "array.h"
+# include "obst.h"
+# include "misc.h"
#if 0
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;
/**
* 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;
*/
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
* 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;
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 */
}
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;
}
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)
{
assert(get_mode_modecode(mode) < num_modes);
assert(mode_is_data(mode));
- return modes_min[get_mode_modecode(mode)];
+ return mode->min;
}
tarval *
assert(get_mode_modecode(mode) < num_modes);
assert(mode_is_data(mode));
- return modes_max[get_mode_modecode(mode)];
+ return mode->max;
}
tarval *
assert(get_mode_modecode(mode) < num_modes);
assert(mode_is_data(mode));
- return modes_null[get_mode_modecode(mode)];
+ return mode->null;
}
tarval *
assert(get_mode_modecode(mode) < num_modes);
assert(mode_is_data(mode));
- return modes_one[get_mode_modecode(mode)];
+ return mode->one;
}
tarval *
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
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);
}
*/
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.
* @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
* 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 *********** */
/** 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.
*
# 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
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"
};
/* 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. */
# 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"
/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
-* All rights reserved.
-*
-* Authors: Christian Schaefer
-*
-*
-*/
+ * All rights reserved.
+ *
+ * Authors: Christian Schaefer
+ *
+ *
+ */
/* $Id$ */
# 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. */
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 */
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;
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) {
} 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 */
projects / libfirm / commitdiff