void fix_backedges(struct obstack *obst, ir_node *n) {
int *arr = mere_get_backarray(n);
- opcode opc;
+ ir_opcode opc;
if (! arr)
return;
static void rta_act (ir_node *node, void *env)
{
int *change = (int*) env;
- opcode op = get_irn_opcode (node);
+ ir_opcode op = get_irn_opcode (node);
if (iro_Call == op) { /* CALL */
ir_entity *ent = NULL;
/*
* $Log$
+ * Revision 1.40 2007/01/16 15:45:15 beck
+ * renamed type opcode to ir_opcode
+ *
* Revision 1.39 2006/12/13 13:15:12 beck
* renamed entity -> ir_entity
*
static void irg_walk_mem_node (ir_node *node,
walk_mem_env_t *walk_env)
{
- const opcode op = get_irn_opcode (node);
+ const ir_opcode op = get_irn_opcode (node);
ir_node *in = NULL;
if (get_irn_visited (node) >= walk_env->visited) {
/*
$Log$
+ Revision 1.12 2007/01/16 15:45:42 beck
+ renamed type opcode to ir_opcode
+
Revision 1.11 2005/01/26 12:20:20 beck
gnu_ext.h included
{
ir_node *proj_in = get_Proj_pred (proj);
const long proj_proj = get_Proj_proj (proj);
- const opcode in_op = get_irn_opcode (proj_in);
+ const ir_opcode in_op = get_irn_opcode (proj_in);
pto_t *in_pto = NULL;
pto_t *proj_pto = NULL; /* get_node_pto (proj); */
return (NULL);
case (iro_Proj): { /* ProjT (Start), ProjT (Call) */
- opcode in_in_op;
+ ir_opcode in_in_op;
long proj_in_proj;
proj_in_in = get_Proj_pred (proj_in);
/* Dispatch to propagate PTO values */
static pto_t *get_pto (ir_node *node, pto_env_t *env)
{
- const opcode op = get_irn_opcode (node);
+ const ir_opcode op = get_irn_opcode (node);
DBGPRINT (2, (stdout, "%s (%s[%li])\n",
__FUNCTION__,
/* Perform the appropriate action on the given node */
static void pto_node_node(ir_node *node, pto_env_t *pto_env)
{
- opcode op = get_irn_opcode (node);
+ ir_opcode op = get_irn_opcode (node);
DBGPRINT (1, (stdout, "%s (%s[%li])\n",
__FUNCTION__, OPNAME (node), OPNUM (node)));
\f
/*
$Log$
+ Revision 1.20 2007/01/16 15:45:42 beck
+ renamed type opcode to ir_opcode
+
Revision 1.19 2006/12/13 19:46:47 beck
rename type entity into ir_entity
{
reset_env_t *reset_env = (reset_env_t*) env;
int ctx_idx = reset_env->ctx_idx;
- opcode op = get_irn_opcode (node);
+ ir_opcode op = get_irn_opcode (node);
/* HERE ("start"); */
init_env_t *init_env = (init_env_t*) env;
int n_ctxs = init_env->n_ctxs;
- opcode op = get_irn_opcode (node);
+ ir_opcode op = get_irn_opcode (node);
switch (op) {
case (iro_SymConst): {
\f
/*
$Log$
+ Revision 1.23 2007/01/16 15:45:42 beck
+ renamed type opcode to ir_opcode
+
Revision 1.22 2006/12/13 19:46:47 beck
rename type entity into ir_entity
ir_entity *get_ptr_ent (ir_node *ptr)
{
ir_entity *ent = NULL;
- const opcode ptr_op = get_irn_opcode (ptr);
+ const ir_opcode ptr_op = get_irn_opcode (ptr);
switch (ptr_op) {
case (iro_Cast): {
ent = get_ptr_ent (get_Cast_op (ptr));
/* Check whether the load of the given ptr is a dummy */
int is_dummy_load_ptr (ir_node *ptr)
{
- const opcode ptr_op = get_irn_opcode (ptr);
+ const ir_opcode ptr_op = get_irn_opcode (ptr);
switch (ptr_op) {
case (iro_Cast): {
\f
/*
$Log$
+ Revision 1.19 2007/01/16 15:45:42 beck
+ renamed type opcode to ir_opcode
+
Revision 1.18 2006/12/13 19:46:47 beck
rename type entity into ir_entity
cough_and_die (proj_in);
}
} else {
- opcode op = get_irn_opcode (proj_in);
+ ir_opcode op = get_irn_opcode (proj_in);
if ((iro_Load != op) && (iro_Alloc != op) && (iro_Call != op)) {
fprintf (stdout, "\n Proj (%s) not handled\n",
get_op_name (get_irn_op (proj_in)));
*/
typalise_t *typalise (ir_node *node)
{
- opcode op = get_irn_opcode (node);
+ ir_opcode op = get_irn_opcode (node);
typalise_t *res = NULL;
switch (op) {
\f
/*
$Log$
+ Revision 1.14 2007/01/16 15:45:42 beck
+ renamed type opcode to ir_opcode
+
Revision 1.13 2006/12/13 19:46:47 beck
rename type entity into ir_entity
/**
* Add a Conv node where needed on input
*/
-static ir_node *fix_irn_input(opcode code, ir_node *block, ir_node *pred, ir_mode *mode)
+static ir_node *fix_irn_input(ir_opcode code, ir_node *block, ir_node *pred, ir_mode *mode)
{
switch (code) {
case iro_DivMod:
*/
static void fix_mode(ir_node *n, ir_mode *mode)
{
- opcode code = get_irn_opcode(n);
+ ir_opcode code = get_irn_opcode(n);
if (code == iro_Proj) {
code = get_irn_opcode(get_Proj_pred(n));
walker_t *wenv = env;
ir_mode *mode = get_irn_mode(n);
ir_node *block;
- opcode code;
+ ir_opcode code;
/* save the old mode, we need this info later */
set_irn_link(n, mode);
*/
static INLINE unsigned get_node_realizer(ir_node *node) {
unsigned realizer;
- opcode opc = get_irn_opcode(node);
+ ir_opcode opc = get_irn_opcode(node);
switch (opc) {
case iro_Block:
int addr_is_alloc(ir_node *acc) {
ir_node *addr = NULL;
- opcode addr_op;
+ ir_opcode addr_op;
if (is_memop(acc)) {
addr = get_memop_ptr(acc);
} else {
_set_irn_op(node, op);
}
-opcode
+ir_opcode
(get_irn_opcode)(const ir_node *node)
{
return _get_irn_opcode(node);
}
/* Sets the get_type operation for an ir_op_ops. */
-ir_op_ops *firm_set_default_get_type(opcode code, ir_op_ops *ops)
+ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops)
{
switch (code) {
case iro_Const: ops->get_type = get_Const_type; break;
}
/* Sets the get_type operation for an ir_op_ops. */
-ir_op_ops *firm_set_default_get_type_attr(opcode code, ir_op_ops *ops)
+ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops)
{
switch (code) {
case iro_SymConst: ops->get_type_attr = get_SymConst_attr_type; break;
}
/* Sets the get_type operation for an ir_op_ops. */
-ir_op_ops *firm_set_default_get_entity_attr(opcode code, ir_op_ops *ops)
+ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops)
{
switch (code) {
case iro_SymConst: ops->get_entity_attr = get_SymConst_attr_entity; break;
/** Sets the opcode struct of the node. */
void set_irn_op(ir_node *node, ir_op *op);
/** Gets the opcode-enum of the node. */
-opcode get_irn_opcode(const ir_node *node);
+ir_opcode get_irn_opcode(const ir_node *node);
/** Get the string representation of the opcode. */
const char *get_irn_opname(const ir_node *node);
/** Get the ident for a string representation of the opcode. */
* @return
* The operations.
*/
-ir_op_ops *firm_set_default_get_type(opcode code, ir_op_ops *ops);
+ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops);
/**
* Sets the get_type_attr operation for an ir_op_ops.
* @return
* The operations.
*/
-ir_op_ops *firm_set_default_get_type_attr(opcode code, ir_op_ops *ops);
+ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops);
/**
* Sets the get_entity_attr operation for an ir_op_ops.
* @return
* The operations.
*/
-ir_op_ops *firm_set_default_get_entity_attr(opcode code, ir_op_ops *ops);
+ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops);
/*-------------------------------------------------------------------*/
/* These function are most used in libfirm. Give them as static */
* Gets the opcode of a node.
* Intern version for libFirm.
*/
-static INLINE opcode
+static INLINE ir_opcode
_get_irn_opcode(const ir_node *node) {
assert(k_ir_node == get_kind(node));
assert(node->op);
* @return
* The operations.
*/
-static ir_op_ops *firm_set_default_copy_attr(opcode code, ir_op_ops *ops) {
+static ir_op_ops *firm_set_default_copy_attr(ir_opcode code, ir_op_ops *ops) {
if (code == iro_Call)
ops->copy_attr = call_copy_attr;
else if (code == iro_Block)
/* Creates a new ir operation. */
ir_op *
-new_ir_op(opcode code, const char *name, op_pin_state p,
+new_ir_op(ir_opcode code, const char *name, op_pin_state p,
unsigned flags, op_arity opar, int op_index, size_t attr_size,
const ir_op_ops *ops)
{
return get_id_str(op->name);
} /* get_op_name */
-opcode (get_op_code)(const ir_op *op){
+ir_opcode (get_op_code)(const ir_op *op){
return _get_op_code(op);
} /* get_op_code */
iro_InstOf, iro_Raise, iro_Bound,
iro_Pin,
iro_MaxOpcode
-} opcode;
+} ir_opcode;
#ifndef _IR_OP_TYPEDEF_
#define _IR_OP_TYPEDEF_
const char *get_op_name(const ir_op *op);
/** Returns the enum for the opcode */
-opcode get_op_code(const ir_op *op);
+ir_opcode get_op_code(const ir_op *op);
/** op_pin_state_pinned states */
typedef enum {
* This function can create all standard Firm opcode as well as new ones.
* The behavior of new opcode depends on the operations \c ops and the \c flags.
*/
-ir_op * new_ir_op(opcode code, const char *name, op_pin_state p,
- unsigned flags, op_arity opar, int op_index, size_t attr_size,
+ir_op *new_ir_op(ir_opcode code, const char *name, op_pin_state p,
+ unsigned flags, op_arity opar, int op_index, size_t attr_size,
const ir_op_ops *ops);
/** Returns the ir_op_ops of an ir_op. */
/** The type of an ir_op. */
struct ir_op {
- opcode code; /**< The unique opcode of the op. */
+ ir_opcode code; /**< The unique opcode of the op. */
ident *name; /**< The name of the op. */
size_t attr_size; /**< Space needed in memory for private attributes. */
op_pin_state op_pin_state_pinned; /**< How to deal with the node in CSE, PRE. */
return op->flags & (irop_flag_user << n);
}
-static INLINE opcode _get_op_code(const ir_op *op) {
+static INLINE ir_opcode _get_op_code(const ir_op *op) {
return op->code;
}
* @return
* The operations.
*/
-static ir_op_ops *firm_set_default_computed_value(opcode code, ir_op_ops *ops)
+static ir_op_ops *firm_set_default_computed_value(ir_opcode code, ir_op_ops *ops)
{
#define CASE(a) \
case iro_##a: \
* @return
* The operations.
*/
-static ir_op_ops *firm_set_default_equivalent_node(opcode code, ir_op_ops *ops)
+static ir_op_ops *firm_set_default_equivalent_node(ir_opcode code, ir_op_ops *ops)
{
#define CASE(a) \
case iro_##a: \
* @return
* The operations.
*/
-static ir_op_ops *firm_set_default_transform_node(opcode code, ir_op_ops *ops)
+static ir_op_ops *firm_set_default_transform_node(ir_opcode code, ir_op_ops *ops)
{
#define CASE(a) \
case iro_##a: \
* @return
* The operations.
*/
-static ir_op_ops *firm_set_default_node_cmp_attr(opcode code, ir_op_ops *ops)
+static ir_op_ops *firm_set_default_node_cmp_attr(ir_opcode code, ir_op_ops *ops)
{
#define CASE(a) \
case iro_##a: \
{
tarval *tv;
ir_node *oldn = n;
- opcode iro = get_irn_opcode(n);
+ ir_opcode iro = get_irn_opcode(n);
/* Always optimize Phi nodes: part of the construction. */
if ((!get_opt_optimize()) && (iro != iro_Phi)) return n;
{
tarval *tv;
ir_node *oldn = n;
- opcode iro = get_irn_opcode(n);
+ ir_opcode iro = get_irn_opcode(n);
if (!get_opt_optimize() && (get_irn_op(n) != op_Phi)) return n;
/*
* Sets the default operation for an ir_ops.
*/
-ir_op_ops *firm_set_default_operations(opcode code, ir_op_ops *ops) {
+ir_op_ops *firm_set_default_operations(ir_opcode code, ir_op_ops *ops) {
ops = firm_set_default_computed_value(code, ops);
ops = firm_set_default_equivalent_node(code, ops);
ops = firm_set_default_transform_node(code, ops);
* @return
* The operations.
*/
-ir_op_ops *firm_set_default_operations(opcode code, ir_op_ops *ops);
+ir_op_ops *firm_set_default_operations(ir_opcode code, ir_op_ops *ops);
#endif /* _IROPT_T_H_ */
} rflct_args_t;
typedef struct {
- opcode opc;
+ ir_opcode opc;
const char *name;
int commutative;
int sig_count;
return RFLCT_MC(None);
}
-static INLINE const rflct_opcode_t *get_opcode(opcode opc) {
+static INLINE const rflct_opcode_t *get_opcode(ir_opcode opc) {
assert(opc >= 0 && opc < OPCODES_COUNT && "Invalid opcode");
return opcodes[opc];
}
-static INLINE const rflct_arg_t *get_args(opcode opc, int sig) {
+static INLINE const rflct_arg_t *get_args(ir_opcode opc, int sig) {
const rflct_opcode_t *opcode = get_opcode(opc);
assert(sig >= 0 && sig < opcode->sig_count
&& "Invalid signature");
#define GET_OPCODE(opc) get_opcode(opc)
#define GET_ARGS(opc,args) get_args(opc, args)
-int rflct_get_signature_count(opcode opc) {
+int rflct_get_signature_count(ir_opcode opc) {
const rflct_opcode_t *opcode = GET_OPCODE(opc);
return opcode->sig_count;
}
-int rflct_get_in_args_count(opcode opc, int sig) {
+int rflct_get_in_args_count(ir_opcode opc, int sig) {
const rflct_arg_t *args = GET_ARGS(opc, sig);
int res = 0, i = 0;
return res;
}
-int rflct_get_out_args_count(opcode opc, int sig) {
+int rflct_get_out_args_count(ir_opcode opc, int sig) {
const rflct_arg_t *args = GET_ARGS(opc, sig);
int i = 0;
for(i = 0; args[i].name != NULL; i++);
}
-const rflct_arg_t *rflct_get_in_args(opcode opc, int sig) {
+const rflct_arg_t *rflct_get_in_args(ir_opcode opc, int sig) {
const rflct_arg_t *args = GET_ARGS(opc, sig);
int i;
return &args[i + 1];
}
-const rflct_arg_t *rflct_get_out_args(opcode opc, int sig) {
+const rflct_arg_t *rflct_get_out_args(ir_opcode opc, int sig) {
return GET_ARGS(opc, sig);
}
int rflct_signature_match(const ir_node *irn, int sig) {
- opcode op = get_irn_opcode(irn);
+ ir_opcode op = get_irn_opcode(irn);
const rflct_arg_t *args = rflct_get_in_args(op, sig);
int dst = 0;
int i, j;
}
-char *rflct_to_string(char *buf, int n, opcode opc, int sig) {
+char *rflct_to_string(char *buf, int n, ir_opcode opc, int sig) {
struct obstack obst;
char *s;
const rflct_opcode_t *opcode = GET_OPCODE(opc);
arg->is_variadic = _var; \
arg->mode_equals = _me;
-void rflct_new_opcode(opcode opc, const char *name, int commutative)
+void rflct_new_opcode(ir_opcode opc, const char *name, int commutative)
{
rflct_opcode_t *ropc = obstack_alloc(&obst, sizeof(*ropc));
opcodes[opc] = ropc;
}
-int rflct_opcode_add_signature(opcode opc, rflct_sig_t *sig)
+int rflct_opcode_add_signature(ir_opcode opc, rflct_sig_t *sig)
{
rflct_arg_t *args = sig->args;
rflct_opcode_t *op = opcodes[opc];
* @param opc The opcode.
* @return The number of signatures for this opcode.
*/
-int rflct_get_signature_count(opcode opc);
+int rflct_get_signature_count(ir_opcode opc);
/**
* Try to get the signature, that matches to a given instance
* @param sig The signature you are refering to.
* @return The number of arguments.
*/
-int rflct_get_in_args_count(opcode opc, int sig);
+int rflct_get_in_args_count(ir_opcode opc, int sig);
/**
* Get the number of out arguments.
* @param sig The signature you are refering to.
* @return The number of arguments.
*/
-int rflct_get_out_args_count(opcode opc, int sig);
+int rflct_get_out_args_count(ir_opcode opc, int sig);
#define rflct_get_args_count(opc, sig, use) \
((use) ? rflct_get_in_args_count(opc, sig) : rflct_get_out_args_count(opc, sig))
* 0 and the signature count).
* @return The array.
*/
-const rflct_arg_t *rflct_get_in_args(opcode opc, int sig);
+const rflct_arg_t *rflct_get_in_args(ir_opcode opc, int sig);
/**
* Get the array of def args.
* 0 and the signature count).
* @return The array.
*/
-const rflct_arg_t *rflct_get_out_args(opcode opc, int sig);
+const rflct_arg_t *rflct_get_out_args(ir_opcode opc, int sig);
#define rflct_get_args(opc, sig, use) \
((use) ? rflct_get_in_args(opc, sig) : rflct_get_out_args(opc, sig))
* @param sig The signature.
* @return buf.
*/
-char *rflct_to_string(char *buf, int n, opcode opc, int sig);
+char *rflct_to_string(char *buf, int n, ir_opcode opc, int sig);
/**
* Get a string representation of a mode class.
* @param name A name.
* @param commutative non-zero, if the opcode is commutative.
*/
-void rflct_new_opcode(opcode opc, const char *name, int commutative);
+void rflct_new_opcode(ir_opcode opc, const char *name, int commutative);
/**
* Add a signature to the opcode.
* @return non-zero, if the signature was added successfully, false if no
* more signatures can be added to the opcode.
*/
-int rflct_opcode_add_signature(opcode opc, rflct_sig_t *sig);
+int rflct_opcode_add_signature(ir_opcode opc, rflct_sig_t *sig);
/**
* Allocate a new signature.
/*
* set the default verify operation
*/
-void firm_set_default_verifyer(opcode code, ir_op_ops *ops)
+void firm_set_default_verifyer(ir_opcode code, ir_op_ops *ops)
{
#define CASE(a) \
case iro_##a: \
/**
* Set the default verify_node and verify_proj_node operation for an ir_op_ops.
*/
-void firm_set_default_verifyer(opcode code, ir_op_ops *ops);
+void firm_set_default_verifyer(ir_opcode code, ir_op_ops *ops);
#endif /* _IRVRFY_T_H_ */
/**
* check for opcodes that must always be lowered.
*/
-static int always_lower(opcode code) {
+static int always_lower(ir_opcode code) {
switch (code) {
case iro_Proj:
case iro_Start:
* An entry in the (op, node, node) -> node map.
*/
typedef struct quadruple_t {
- opcode code; /**< the opcode of the reduced operation */
- ir_node *op1; /**< the first operand the reduced operation */
- ir_node *op2; /**< the second operand of the reduced operation */
+ ir_opcode code; /**< the opcode of the reduced operation */
+ ir_node *op1; /**< the first operand the reduced operation */
+ ir_node *op2; /**< the second operand of the reduced operation */
- ir_node *res; /**< the reduced operation */
+ ir_node *res; /**< the reduced operation */
} quadruple_t;
/**
* A LFTR edge.
*/
typedef struct LFTR_edge {
- ir_node *src; /**< the source node */
- ir_node *dst; /**< the destination node */
- opcode code; /**< the opcode that must be applied */
- ir_node *rc; /**< the region const that must be applied */
+ ir_node *src; /**< the source node */
+ ir_node *dst; /**< the destination node */
+ ir_opcode code; /**< the opcode that must be applied */
+ ir_node *rc; /**< the region const that must be applied */
} LFTR_edge;
/* forward */
/**
* Add a LFTR edge.
*/
-static void LFTR_add(ir_node *src, ir_node *dst, opcode code, ir_node *rc, iv_env *env) {
+static void LFTR_add(ir_node *src, ir_node *dst, ir_opcode code, ir_node *rc, iv_env *env) {
LFTR_edge key;
key.src = src;
*
* @return the already reduced node or NULL if this operation is not yet reduced
*/
-static ir_node *search(opcode code, ir_node *op1, ir_node *op2, iv_env *env) {
+static ir_node *search(ir_opcode code, ir_node *op1, ir_node *op2, iv_env *env) {
quadruple_t key, *entry;
key.code = code;
* @param result the result of the reduced operation
* @param env the environment
*/
-static void add(opcode code, ir_node *op1, ir_node *op2, ir_node *result, iv_env *env) {
+static void add(ir_opcode code, ir_node *op1, ir_node *op2, ir_node *result, iv_env *env) {
quadruple_t key;
key.code = code;
*
* @return the newly created node
*/
-static ir_node *do_apply(opcode code, dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode) {
+static ir_node *do_apply(ir_opcode code, dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode) {
ir_graph *irg = current_ir_graph;
ir_node *result;
ir_node *block = find_location(get_nodes_block(op1), get_nodes_block(op2));
* @return the newly created node
*/
static ir_node *apply(ir_node *orig, ir_node *op1, ir_node *op2, iv_env *env) {
- opcode code = get_irn_opcode(orig);
+ ir_opcode code = get_irn_opcode(orig);
ir_node *result = search(code, op1, op2, env);
if (! result) {
* @return the reduced node
*/
static ir_node *reduce(ir_node *orig, ir_node *iv, ir_node *rc, iv_env *env) {
- opcode code = get_irn_opcode(orig);
+ ir_opcode code = get_irn_opcode(orig);
ir_node *result = search(code, iv, rc, env);
if (! result) {
* @return non-zero if irn should be Replace'd
*/
static int check_replace(ir_node *irn, iv_env *env) {
- ir_node *left, *right, *iv, *rc;
- ir_op *op = get_irn_op(irn);
- opcode code = get_op_code(op);
- ir_node *liv, *riv;
+ ir_node *left, *right, *iv, *rc;
+ ir_op *op = get_irn_op(irn);
+ ir_opcode code = get_op_code(op);
+ ir_node *liv, *riv;
switch (code) {
case iro_Mul:
/* skip Cast and Confirm nodes */
for (;;) {
- opcode code = get_irn_opcode(ptr);
+ ir_opcode code = get_irn_opcode(ptr);
switch (code) {
case iro_Cast:
}
/* Sets the default reassociation operation for an ir_op_ops. */
-ir_op_ops *firm_set_default_reassoc(opcode code, ir_op_ops *ops)
+ir_op_ops *firm_set_default_reassoc(ir_opcode code, ir_op_ops *ops)
{
#define CASE(a) case iro_##a: ops->reassociate = reassoc_##a; break
* @return
* The operations.
*/
-ir_op_ops *firm_set_default_reassoc(opcode code, ir_op_ops *ops);
+ir_op_ops *firm_set_default_reassoc(ir_opcode code, ir_op_ops *ops);
/** Initialise the ressociation optimization */
void firm_init_reassociation(void);
* @param code the IR opcode
* @param hmap the hash map containing opcode -> ir_op*
*/
-static ir_op *opcode_find_entry(opcode code, hmap_ir_op *hmap) {
+static ir_op *opcode_find_entry(ir_opcode code, hmap_ir_op *hmap) {
ir_op key;
key.code = code;
/*
* Helper: get an ir_op from an opcode.
*/
-ir_op *stat_get_op_from_opcode(opcode code) {
+ir_op *stat_get_op_from_opcode(ir_opcode code) {
return opcode_find_entry(code, status->ir_op_hash);
} /* stat_get_op_from_opcode */
/**
* helper: get an ir_op from an opcode
*/
-ir_op *stat_get_op_from_opcode(opcode code);
+ir_op *stat_get_op_from_opcode(ir_opcode code);
/* API for distribution tables */
int i, preds;
int res, depth;
- opcode code = get_irn_opcode(node);
+ ir_opcode code = get_irn_opcode(node);
/* insert the node into our ID map */
entry.addr = node;