X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Fir%2Firnode.c;h=57c661ef2aca02e37b65881dcbbccde9dfcb2635;hb=92869d69702fc0fd8e77832b9b68c60cb0d3e82a;hp=10813eeecd6c74c4e57e6a0d6f35b01fd92fc94e;hpb=eb08138c6b80c169945568e4414f491a9bc20388;p=libfirm diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c index 10813eeec..57c661ef2 100644 --- a/ir/ir/irnode.c +++ b/ir/ir/irnode.c @@ -17,17 +17,12 @@ * PURPOSE. */ -/* - * Project: libFIRM - * File name: ir/ir/irnode.c - * Purpose: Representation of an intermediate operation. - * Author: Martin Trapp, Christian Schaefer - * Modified by: Goetz Lindenmaier, Michael Beck - * Created: - * CVS-ID: $Id$ - * Copyright: (c) 1998-2006 Universität Karlsruhe +/** + * @file + * @brief Representation of an intermediate operation. + * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck + * @version $Id$ */ - #ifdef HAVE_CONFIG_H # include "config.h" #endif @@ -40,7 +35,6 @@ #include "irnode_t.h" #include "irgraph_t.h" #include "irmode_t.h" -#include "typegmod.h" #include "irbackedge_t.h" #include "irdump.h" #include "irop_t.h" @@ -70,6 +64,8 @@ static const char *pnc_name_arr [] = { * returns the pnc name from an pnc constant */ const char *get_pnc_string(int pnc) { + assert(pnc >= 0 && pnc < + (int) (sizeof(pnc_name_arr)/sizeof(pnc_name_arr[0]))); return pnc_name_arr[pnc]; } @@ -112,7 +108,7 @@ unsigned firm_add_node_size = 0; /* register new space for every node */ -unsigned register_additional_node_data(unsigned size) { +unsigned firm_register_additional_node_data(unsigned size) { assert(!forbid_new_data && "Too late to register additional node data"); if (forbid_new_data) @@ -135,8 +131,8 @@ init_irnode(void) { * If arity is negative, a node with a dynamic array is created. */ ir_node * -new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode, - int arity, ir_node **in) +new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode, + int arity, ir_node **in) { ir_node *res; size_t node_size = offsetof(ir_node, attr) + op->attr_size + firm_add_node_size; @@ -144,9 +140,9 @@ new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mo int i; assert(irg && op && mode); - p = obstack_alloc (irg->obst, node_size); + p = obstack_alloc(irg->obst, node_size); memset(p, 0, node_size); - res = (ir_node *) (p + firm_add_node_size); + res = (ir_node *)(p + firm_add_node_size); res->kind = k_ir_node; res->op = op; @@ -157,10 +153,10 @@ new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mo res->deps = NULL; if (arity < 0) { - res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */ + res->in = NEW_ARR_F(ir_node *, 1); /* 1: space for block */ } else { - res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1)); - memcpy (&res->in[1], in, sizeof (ir_node *) * arity); + res->in = NEW_ARR_D(ir_node *, irg->obst, (arity+1)); + memcpy(&res->in[1], in, sizeof(ir_node *) * arity); } res->in[0] = block; @@ -171,10 +167,10 @@ new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mo res->node_nr = get_irp_new_node_nr(); #endif - for(i = 0; i < EDGE_KIND_LAST; ++i) + for (i = 0; i < EDGE_KIND_LAST; ++i) INIT_LIST_HEAD(&res->edge_info[i].outs_head); - // don't put this into the for loop, arity is -1 for some nodes! + /* don't put this into the for loop, arity is -1 for some nodes! */ edges_notify_edge(res, -1, res->in[0], NULL, irg); for (i = 1; i <= arity; ++i) edges_notify_edge(res, i - 1, res->in[i], NULL, irg); @@ -387,11 +383,10 @@ int add_irn_dep(ir_node *node, ir_node *dep) return res; } -void add_irn_deps(ir_node *tgt, ir_node *src) -{ +void add_irn_deps(ir_node *tgt, ir_node *src) { int i, n; - for(i = 0, n = get_irn_deps(src); i < n; ++i) + for (i = 0, n = get_irn_deps(src); i < n; ++i) add_irn_dep(tgt, get_irn_dep(src, i)); } @@ -436,7 +431,7 @@ void _set_irn_op(node, op); } -ir_opcode +unsigned (get_irn_opcode)(const ir_node *node) { return _get_irn_opcode(node); } @@ -444,9 +439,7 @@ ir_opcode const char * get_irn_opname(const ir_node *node) { assert(node); - if ((get_irn_op((ir_node *)node) == op_Phi) && - (get_irg_phase_state(get_irn_irg((ir_node *)node)) == phase_building) && - (get_irn_arity((ir_node *)node) == 0)) return "Phi0"; + if (is_Phi0(node)) return "Phi0"; return get_id_str(node->op->name); } @@ -530,10 +523,22 @@ void firm_set_irn_section(ir_node *n, struct section *s) { } #else /* Dummies needed for firmjni. */ -struct abstval *get_irn_abst_value(ir_node *n) { return NULL; } -void set_irn_abst_value(ir_node *n, struct abstval *os) {} -struct section *firm_get_irn_section(ir_node *n) { return NULL; } -void firm_set_irn_section(ir_node *n, struct section *s) {} +struct abstval *get_irn_abst_value(ir_node *n) { + (void) n; + return NULL; +} +void set_irn_abst_value(ir_node *n, struct abstval *os) { + (void) n; + (void) os; +} +struct section *firm_get_irn_section(ir_node *n) { + (void) n; + return NULL; +} +void firm_set_irn_section(ir_node *n, struct section *s) { + (void) n; + (void) s; +} #endif /* DO_HEAPANALYSIS */ @@ -547,10 +552,10 @@ long get_irn_node_nr(const ir_node *node) { #endif } -const_attr +const_attr * get_irn_const_attr(ir_node *node) { assert(node->op == op_Const); - return node->attr.con; + return &node->attr.con; } long @@ -559,22 +564,22 @@ get_irn_proj_attr(ir_node *node) { return node->attr.proj; } -alloc_attr +alloc_attr * get_irn_alloc_attr(ir_node *node) { assert(node->op == op_Alloc); - return node->attr.alloc; + return &node->attr.alloc; } -free_attr +free_attr * get_irn_free_attr(ir_node *node) { assert(node->op == op_Free); - return node->attr.free; + return &node->attr.free; } -symconst_attr +symconst_attr * get_irn_symconst_attr(ir_node *node) { assert(node->op == op_SymConst); - return node->attr.symc; + return &node->attr.symc; } ir_type * @@ -583,48 +588,51 @@ get_irn_call_attr(ir_node *node) { return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp); } -sel_attr +sel_attr * get_irn_sel_attr(ir_node *node) { assert(node->op == op_Sel); - return node->attr.sel; + return &node->attr.sel; } int -get_irn_phi_attr(ir_node *node) { - assert(node->op == op_Phi); - return node->attr.phi0_pos; +get_irn_phi0_attr(ir_node *node) { + assert(is_Phi0(node)); + return node->attr.phi0.pos; } -block_attr +block_attr * get_irn_block_attr(ir_node *node) { assert(node->op == op_Block); - return node->attr.block; + return &node->attr.block; } -load_attr -get_irn_load_attr(ir_node *node) -{ - assert(node->op == op_Load); - return node->attr.load; +load_attr * +get_irn_load_attr(ir_node *node) { + assert(node->op == op_Load); + return &node->attr.load; } -store_attr -get_irn_store_attr(ir_node *node) -{ - assert(node->op == op_Store); - return node->attr.store; +store_attr * +get_irn_store_attr(ir_node *node) { + assert(node->op == op_Store); + return &node->attr.store; } -except_attr +except_attr * get_irn_except_attr(ir_node *node) { assert(node->op == op_Div || node->op == op_Quot || node->op == op_DivMod || node->op == op_Mod || node->op == op_Call || node->op == op_Alloc); - return node->attr.except; + return &node->attr.except; } -void * -get_irn_generic_attr(ir_node *node) { - return &node->attr; +void *(get_irn_generic_attr)(ir_node *node) { + assert(is_ir_node(node)); + return _get_irn_generic_attr(node); +} + +const void *(get_irn_generic_attr_const)(const ir_node *node) { + assert(is_ir_node(node)); + return _get_irn_generic_attr_const(node); } unsigned (get_irn_idx)(const ir_node *node) { @@ -647,7 +655,6 @@ int get_irn_pred_pos(ir_node *node, ir_node *arg) { ir_node * get_nodes_block(const ir_node *node) { assert(node->op != op_Block); - assert(is_irn_pinned_in_irg(node) && "block info may be incorrect"); return get_irn_n(node, -1); } @@ -737,13 +744,13 @@ ir_node * int get_Block_matured(ir_node *node) { assert(node->op == op_Block); - return (int)node->attr.block.matured; + return (int)node->attr.block.is_matured; } void set_Block_matured(ir_node *node, int matured) { assert(node->op == op_Block); - node->attr.block.matured = matured; + node->attr.block.is_matured = matured; } unsigned long @@ -784,7 +791,7 @@ set_Block_graph_arr (ir_node *node, int pos, ir_node *value) { node->attr.block.graph_arr[pos+1] = value; } -void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) { +void set_Block_cg_cfgpred_arr(ir_node *node, int arity, ir_node *in[]) { assert(node->op == op_Block); if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) { node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1); @@ -802,29 +809,29 @@ void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) { memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity); } -void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) { +void set_Block_cg_cfgpred(ir_node *node, int pos, ir_node *pred) { assert(node->op == op_Block && node->attr.block.in_cg && 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1); node->attr.block.in_cg[pos + 1] = pred; } -ir_node **get_Block_cg_cfgpred_arr(ir_node * node) { +ir_node **get_Block_cg_cfgpred_arr(ir_node *node) { assert(node->op == op_Block); return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1; } -int get_Block_cg_n_cfgpreds(ir_node * node) { +int get_Block_cg_n_cfgpreds(ir_node *node) { assert(node->op == op_Block); return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1; } -ir_node *get_Block_cg_cfgpred(ir_node * node, int pos) { +ir_node *get_Block_cg_cfgpred(ir_node *node, int pos) { assert(node->op == op_Block && node->attr.block.in_cg); return node->attr.block.in_cg[pos + 1]; } -void remove_Block_cg_cfgpred_arr(ir_node * node) { +void remove_Block_cg_cfgpred_arr(ir_node *node) { assert(node->op == op_Block); node->attr.block.in_cg = NULL; } @@ -851,6 +858,18 @@ void set_Block_extbb(ir_node *block, ir_extblk *extblk) { block->attr.block.extblk = extblk; } +/* returns the macro block header of a block. */ +ir_node *get_Block_MacroBlock(const ir_node *block) { + assert(is_Block(block)); + return get_irn_n(block, -1); +} + +/* returns the graph of a Block. */ +ir_graph *get_Block_irg(const ir_node *block) { + assert(is_Block(block)); + return block->attr.block.irg; +} + int get_End_n_keepalives(ir_node *end) { assert(end->op == op_End); @@ -864,8 +883,9 @@ get_End_keepalive(ir_node *end, int pos) { } void -add_End_keepalive (ir_node *end, ir_node *ka) { +add_End_keepalive(ir_node *end, ir_node *ka) { assert(end->op == op_End); + assert((is_Phi(ka) || is_Proj(ka) || is_Block(ka) || is_irn_keep(ka)) && "Only Phi, Block or Keep nodes can be kept alive!"); add_irn_n(end, ka); } @@ -1041,7 +1061,7 @@ set_Return_res(ir_node *node, int pos, ir_node *res){ set_irn_n(node, pos + RETURN_RESULT_OFFSET, res); } -tarval *(get_Const_tarval)(ir_node *node) { +tarval *(get_Const_tarval)(const ir_node *node) { return _get_Const_tarval(node); } @@ -1103,7 +1123,7 @@ set_SymConst_type(ir_node *node, ir_type *tp) { } ident * -get_SymConst_name(ir_node *node) { +get_SymConst_name(const ir_node *node) { assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node))); return node->attr.symc.sym.ident_p; } @@ -1116,7 +1136,7 @@ set_SymConst_name(ir_node *node, ident *name) { /* Only to access SymConst of kind symconst_addr_ent. Else assertion: */ -ir_entity *get_SymConst_entity(ir_node *node) { +ir_entity *get_SymConst_entity(const ir_node *node) { assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node))); return node->attr.symc.sym.entity_p; } @@ -1126,7 +1146,7 @@ void set_SymConst_entity(ir_node *node, ir_entity *ent) { node->attr.symc.sym.entity_p = ent; } -ir_enum_const *get_SymConst_enum(ir_node *node) { +ir_enum_const *get_SymConst_enum(const ir_node *node) { assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node))); return node->attr.symc.sym.enum_p; } @@ -1137,7 +1157,7 @@ void set_SymConst_enum(ir_node *node, ir_enum_const *ec) { } union symconst_symbol -get_SymConst_symbol(ir_node *node) { +get_SymConst_symbol(const ir_node *node) { assert(node->op == op_SymConst); return node->attr.symc.sym; } @@ -1357,7 +1377,7 @@ void set_CallBegin_call(ir_node *node, ir_node *call) { #define BINOP(OP) \ -ir_node * get_##OP##_left(ir_node *node) { \ +ir_node * get_##OP##_left(const ir_node *node) { \ assert(node->op == op_##OP); \ return get_irn_n(node, node->op->op_index); \ } \ @@ -1365,7 +1385,7 @@ void set_##OP##_left(ir_node *node, ir_node *left) { \ assert(node->op == op_##OP); \ set_irn_n(node, node->op->op_index, left); \ } \ -ir_node *get_##OP##_right(ir_node *node) { \ +ir_node *get_##OP##_right(const ir_node *node) { \ assert(node->op == op_##OP); \ return get_irn_n(node, node->op->op_index + 1); \ } \ @@ -1375,7 +1395,7 @@ void set_##OP##_right(ir_node *node, ir_node *right) { \ } #define UNOP(OP) \ -ir_node *get_##OP##_op(ir_node *node) { \ +ir_node *get_##OP##_op(const ir_node *node) { \ assert(node->op == op_##OP); \ return get_irn_n(node, node->op->op_index); \ } \ @@ -1399,14 +1419,28 @@ set_##OP##_mem(ir_node *node, ir_node *mem) { \ set_irn_n(node, 0, mem); \ } +#define DIVOP(OP) \ +BINOP_MEM(OP) \ + \ +ir_mode *get_##OP##_resmode(const ir_node *node) { \ + assert(node->op == op_##OP); \ + return node->attr.divmod.res_mode; \ +} \ + \ +void set_##OP##_resmode(ir_node *node, ir_mode *mode) { \ + assert(node->op == op_##OP); \ + node->attr.divmod.res_mode = mode; \ +} + + BINOP(Add) BINOP(Sub) UNOP(Minus) BINOP(Mul) -BINOP_MEM(Quot) -BINOP_MEM(DivMod) -BINOP_MEM(Div) -BINOP_MEM(Mod) +DIVOP(Quot) +DIVOP(DivMod) +DIVOP(Div) +DIVOP(Mod) UNOP(Abs) BINOP(And) BINOP(Or) @@ -1494,7 +1528,7 @@ int } ir_node * -get_unop_op(ir_node *node) { +get_unop_op(const ir_node *node) { if (node->op->opar == oparity_unary) return get_irn_n(node, node->op->op_index); @@ -1516,7 +1550,7 @@ int } ir_node * -get_binop_left(ir_node *node) { +get_binop_left(const ir_node *node) { assert(node->op->opar == oparity_binary); return get_irn_n(node, node->op->op_index); } @@ -1528,7 +1562,7 @@ set_binop_left(ir_node *node, ir_node *left) { } ir_node * -get_binop_right(ir_node *node) { +get_binop_right(const ir_node *node) { assert(node->op->opar == oparity_binary); return get_irn_n(node, node->op->op_index + 1); } @@ -1569,7 +1603,7 @@ get_Phi_preds_arr(ir_node *node) { } int -get_Phi_n_preds(ir_node *node) { +get_Phi_n_preds(const ir_node *node) { assert(is_Phi(node) || is_Phi0(node)); return (get_irn_arity(node)); } @@ -1581,7 +1615,7 @@ void set_Phi_n_preds(ir_node *node, int n_preds) { */ ir_node * -get_Phi_pred(ir_node *node, int pos) { +get_Phi_pred(const ir_node *node, int pos) { assert(is_Phi(node) || is_Phi0(node)); return get_irn_n(node, pos); } @@ -1900,16 +1934,6 @@ set_Proj_pred(ir_node *node, ir_node *pred) { set_irn_n(node, 0, pred); } -long get_VProj_proj(const ir_node *node) -{ - return node->attr.proj; -} - -void set_VProj_proj(ir_node *node, long value) -{ - node->attr.proj = value; -} - long get_Proj_proj(const ir_node *node) { assert(is_Proj(node)); @@ -1990,17 +2014,16 @@ void set_Confirm_bound(ir_node *node, ir_node *bound) { set_irn_n(node, 0, bound); } -pn_Cmp get_Confirm_cmp(ir_node *node) { +pn_Cmp get_Confirm_cmp(const ir_node *node) { assert(node->op == op_Confirm); - return node->attr.confirm_cmp; + return node->attr.confirm.cmp; } void set_Confirm_cmp(ir_node *node, pn_Cmp cmp) { assert(node->op == op_Confirm); - node->attr.confirm_cmp = cmp; + node->attr.confirm.cmp = cmp; } - ir_node * get_Filter_pred(ir_node *node) { assert(node->op == op_Filter); @@ -2311,7 +2334,7 @@ void set_Bound_upper(ir_node *bound, ir_node *upper) { } /* Return the operand of a Pin node. */ -ir_node *get_Pin_op(ir_node *pin) { +ir_node *get_Pin_op(const ir_node *pin) { assert(pin->op == op_Pin); return get_irn_n(pin, 0); } @@ -2321,6 +2344,47 @@ void set_Pin_op(ir_node *pin, ir_node *node) { set_irn_n(pin, 0, node); } +/* Return the assembler text of an ASM pseudo node. */ +ident *get_ASM_text(const ir_node *node) { + assert(node->op == op_ASM); + return node->attr.assem.asm_text; +} + +/* Return the number of input constraints for an ASM node. */ +int get_ASM_n_input_constraints(const ir_node *node) { + assert(node->op == op_ASM); + return ARR_LEN(node->attr.assem.inputs); +} + +/* Return the input constraints for an ASM node. This is a flexible array. */ +const ir_asm_constraint *get_ASM_input_constraints(const ir_node *node) { + assert(node->op == op_ASM); + return node->attr.assem.inputs; +} + +/* Return the number of output constraints for an ASM node. */ +int get_ASM_n_output_constraints(const ir_node *node) { + assert(node->op == op_ASM); + return ARR_LEN(node->attr.assem.outputs); +} + +/* Return the output constraints for an ASM node. */ +const ir_asm_constraint *get_ASM_output_constraints(const ir_node *node) { + assert(node->op == op_ASM); + return node->attr.assem.outputs; +} + +/* Return the number of clobbered registers for an ASM node. */ +int get_ASM_n_clobbers(const ir_node *node) { + assert(node->op == op_ASM); + return ARR_LEN(node->attr.assem.clobber); +} + +/* Return the list of clobbered registers for an ASM node. */ +ident **get_ASM_clobbers(const ir_node *node) { + assert(node->op == op_ASM); + return node->attr.assem.clobber; +} /* returns the graph of a node */ ir_graph * @@ -2483,6 +2547,11 @@ int return _is_NoMem(node); } +int +(is_Minus)(const ir_node *node) { + return _is_Minus(node); +} + int (is_Mod)(const ir_node *node) { return _is_Mod(node); @@ -2503,6 +2572,46 @@ int return _is_Quot(node); } +int +(is_Add)(const ir_node *node) { + return _is_Add(node); +} + +int +(is_And)(const ir_node *node) { + return _is_And(node); +} + +int +(is_Or)(const ir_node *node) { + return _is_Or(node); +} + +int +(is_Eor)(const ir_node *node) { + return _is_Eor(node); +} + +int +(is_Sub)(const ir_node *node) { + return _is_Sub(node); +} + +int +(is_Not)(const ir_node *node) { + return _is_Not(node); +} + +int +(is_Psi)(const ir_node *node) { + return _is_Psi(node); +} + +int +(is_Tuple)(const ir_node *node) { + return _is_Tuple(node); +} + int (is_Start)(const ir_node *node) { return _is_Start(node); @@ -2518,6 +2627,11 @@ int return _is_Const(node); } +int +(is_Conv)(const ir_node *node) { + return _is_Conv(node); +} + int (is_no_Block)(const ir_node *node) { return _is_no_Block(node); @@ -2629,6 +2743,12 @@ int return _is_Raise(node); } +/* returns true if a node is an ASM node. */ +int +(is_ASM)(const ir_node *node) { + return _is_ASM(node); +} + int is_Proj(const ir_node *node) { assert(node); @@ -2659,7 +2779,7 @@ is_fragile_op(const ir_node *node) { ir_node *get_fragile_op_mem(ir_node *node) { assert(node && is_fragile_op(node)); - switch (get_irn_opcode (node)) { + switch (get_irn_opcode(node)) { case iro_Call : case iro_Quot : case iro_DivMod: @@ -2679,6 +2799,19 @@ ir_node *get_fragile_op_mem(ir_node *node) { } } +/* Returns the result mode of a Div operation. */ +ir_mode *get_divop_resmod(const ir_node *node) { + switch (get_irn_opcode(node)) { + case iro_Quot : return get_Quot_resmode(node); + case iro_DivMod: return get_DivMod_resmode(node); + case iro_Div : return get_Div_resmode(node); + case iro_Mod : return get_Mod_resmode(node); + default: ; + assert(0 && "should not be reached"); + return NULL; + } +} + /* Returns true if the operation is a forking control flow operation. */ int (is_irn_forking)(const ir_node *node) { return _is_irn_forking(node); @@ -2749,7 +2882,7 @@ const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred) { } /* Returns the conditional jump prediction of a Cond node. */ -cond_jmp_predicate (get_Cond_jmp_pred)(ir_node *cond) { +cond_jmp_predicate (get_Cond_jmp_pred)(const ir_node *cond) { return _get_Cond_jmp_pred(cond); } @@ -2760,6 +2893,7 @@ void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) { /** the get_type operation must be always implemented and return a firm type */ static ir_type *get_Default_type(ir_node *n) { + (void) n; return get_unknown_type(); } @@ -2797,6 +2931,7 @@ static ir_entity *get_SymConst_attr_entity(ir_node *self) { /** the get_type_attr operation must be always implemented */ static ir_type *get_Null_type(ir_node *n) { + (void) n; return firm_unknown_type; } @@ -2819,6 +2954,7 @@ ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops) { /** the get_entity_attr operation must be always implemented */ static ir_entity *get_Null_ent(ir_node *n) { + (void) n; return NULL; } @@ -2836,6 +2972,22 @@ ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops) { return ops; } +/* Sets the debug information of a node. */ +void (set_irn_dbg_info)(ir_node *n, dbg_info *db) { + _set_irn_dbg_info(n, db); +} + +/** + * Returns the debug information of an node. + * + * @param n The node. + */ +dbg_info *(get_irn_dbg_info)(const ir_node *n) { + return _get_irn_dbg_info(n); +} + + + #ifdef DEBUG_libfirm void dump_irn(ir_node *n) { int i, arity = get_irn_arity(n);