X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode.c;h=47a5ce5a12671f8161702f0fba8498a4351d92d3;hb=637542932dc27dcdfc7def09b58d9d5d4c34fb77;hp=8334e4fee9d8a20931363648e98eaff635753f9d;hpb=1ec228b37ec7cf59f6984d359b61559730dc1b71;p=libfirm diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c index 8334e4fee..47a5ce5a1 100644 --- a/ir/ir/irnode.c +++ b/ir/ir/irnode.c @@ -27,8 +27,9 @@ #include "irdump.h" #include "irop_t.h" #include "irprog_t.h" +#include "iredges_t.h" -#include "firmstat.h" +#include "irhooks.h" /* some constants fixing the positions of nodes predecessors in the in array */ @@ -52,32 +53,44 @@ const char *get_pnc_string(int pnc) { return pnc_name_arr[pnc]; } -/** +/* * Calculates the negated pnc condition. */ int get_negated_pnc(int pnc) { switch (pnc) { - case False: return True; break; - case Eq: return Ne; break; - case Lt: return Uge; break; - case Le: return Ug; break; - case Gt: return Ule; break; - case Ge: return Ul; break; - case Lg: return Ue; break; - case Leg: return Uo; break; - case Uo: return Leg; break; - case Ue: return Lg; break; - case Ul: return Ge; break; - case Ule: return Gt; break; - case Ug: return Le; break; - case Uge: return Lt; break; - case Ne: return Eq; break; - case True: return False; break; + case pn_Cmp_False: return pn_Cmp_True; + case pn_Cmp_Eq: return pn_Cmp_Ne; + case pn_Cmp_Lt: return pn_Cmp_Uge; + case pn_Cmp_Le: return pn_Cmp_Ug; + case pn_Cmp_Gt: return pn_Cmp_Ule; + case pn_Cmp_Ge: return pn_Cmp_Ul; + case pn_Cmp_Lg: return pn_Cmp_Ue; + case pn_Cmp_Leg: return pn_Cmp_Uo; + case pn_Cmp_Uo: return pn_Cmp_Leg; + case pn_Cmp_Ue: return pn_Cmp_Lg; + case pn_Cmp_Ul: return pn_Cmp_Ge; + case pn_Cmp_Ule: return pn_Cmp_Gt; + case pn_Cmp_Ug: return pn_Cmp_Le; + case pn_Cmp_Uge: return pn_Cmp_Lt; + case pn_Cmp_Ne: return pn_Cmp_Eq; + case pn_Cmp_True: return pn_Cmp_False; } return 99; /* to shut up gcc */ } +/* Calculates the swapped pnc condition, i.e., "<" --> ">" */ +int +get_swapped_pnc(int pnc) { + int code = pnc & ~(pn_Cmp_Lt|pn_Cmp_Gt); + int lesser = pnc & pn_Cmp_Lt; + int greater = pnc & pn_Cmp_Gt; + + code |= (lesser ? pn_Cmp_Gt : 0) | (greater ? pn_Cmp_Lt : 0); + + return code; +} + const char *pns_name_arr [] = { "initial_exec", "global_store", "frame_base", "globals", "args" @@ -147,6 +160,7 @@ new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mo res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1)); memcpy (&res->in[1], in, sizeof (ir_node *) * arity); } + res->in[0] = block; set_irn_dbg_info(res, db); res->out = NULL; @@ -155,7 +169,19 @@ 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 - stat_new_node(res); +#if FIRM_EDGES_INPLACE + { + int i, n; + int not_a_block = is_no_Block(res); + + INIT_LIST_HEAD(&res->edge_info.outs_head); + + for (i = 0, n = arity + not_a_block; i < n; ++i) + edges_notify_edge(res, i - not_a_block, res->in[i], NULL, irg); + } +#endif + + hook_new_node(irg, res); return res; } @@ -164,24 +190,24 @@ new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mo int (is_ir_node)(const void *thing) { - return __is_ir_node(thing); + return _is_ir_node(thing); } int (get_irn_intra_arity)(const ir_node *node) { - return __get_irn_intra_arity(node); + return _get_irn_intra_arity(node); } int (get_irn_inter_arity)(const ir_node *node) { - return __get_irn_inter_arity(node); + return _get_irn_inter_arity(node); } -int (*__get_irn_arity)(const ir_node *node) = __get_irn_intra_arity; +int (*_get_irn_arity)(const ir_node *node) = _get_irn_intra_arity; int (get_irn_arity)(const ir_node *node) { - return __get_irn_arity(node); + return _get_irn_arity(node); } /* Returns the array with ins. This array is shifted with respect to the @@ -232,25 +258,28 @@ set_irn_in (ir_node *node, int arity, ir_node **in) { ir_node * (get_irn_intra_n)(const ir_node *node, int n) { - return __get_irn_intra_n (node, n); + return _get_irn_intra_n (node, n); } ir_node * (get_irn_inter_n)(const ir_node *node, int n) { - return __get_irn_inter_n (node, n); + return _get_irn_inter_n (node, n); } -ir_node *(*__get_irn_n)(const ir_node *node, int n) = __get_irn_intra_n; +ir_node *(*_get_irn_n)(const ir_node *node, int n) = _get_irn_intra_n; ir_node * (get_irn_n)(const ir_node *node, int n) { - return __get_irn_n(node, n); + return _get_irn_n(node, n); } void set_irn_n (ir_node *node, int n, ir_node *in) { - assert(node && node->kind == k_ir_node && -1 <= n && n < get_irn_arity(node)); + assert(node && node->kind == k_ir_node); + assert(-1 <= n); + assert(n < get_irn_arity(node)); assert(in && in->kind == k_ir_node); + if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) { /* Change block pred in both views! */ node->in[n + 1] = in; @@ -269,18 +298,25 @@ set_irn_n (ir_node *node, int n, ir_node *in) { } /* else fall through */ } + + /* Call the hook */ + hook_set_irn_n(node, n, in, node->in[n + 1]); + + /* Here, we rely on src and tgt being in the current ir graph */ + edges_notify_edge(node, n, in, node->in[n + 1], current_ir_graph); + node->in[n + 1] = in; } ir_mode * (get_irn_mode)(const ir_node *node) { - return __get_irn_mode(node); + return _get_irn_mode(node); } void (set_irn_mode)(ir_node *node, ir_mode *mode) { - __set_irn_mode(node, mode); + _set_irn_mode(node, mode); } modecode @@ -308,7 +344,7 @@ get_irn_modeident (const ir_node *node) ir_op * (get_irn_op)(const ir_node *node) { - return __get_irn_op(node); + return _get_irn_op(node); } /* should be private to the library: */ @@ -322,7 +358,7 @@ set_irn_op (ir_node *node, ir_op *op) opcode (get_irn_opcode)(const ir_node *node) { - return __get_irn_opcode(node); + return _get_irn_opcode(node); } const char * @@ -345,43 +381,43 @@ get_irn_opident (const ir_node *node) unsigned long (get_irn_visited)(const ir_node *node) { - return __get_irn_visited(node); + return _get_irn_visited(node); } void (set_irn_visited)(ir_node *node, unsigned long visited) { - __set_irn_visited(node, visited); + _set_irn_visited(node, visited); } void (mark_irn_visited)(ir_node *node) { - __mark_irn_visited(node); + _mark_irn_visited(node); } int (irn_not_visited)(const ir_node *node) { - return __irn_not_visited(node); + return _irn_not_visited(node); } int (irn_visited)(const ir_node *node) { - return __irn_visited(node); + return _irn_visited(node); } void (set_irn_link)(ir_node *node, void *link) { - __set_irn_link(node, link); + _set_irn_link(node, link); } void * (get_irn_link)(const ir_node *node) { - return __get_irn_link(node); + return _get_irn_link(node); } op_pin_state (get_irn_pinned)(const ir_node *node) { - return __get_irn_pinned(node); + return _get_irn_pinned(node); } void set_irn_pinned(ir_node *node, op_pin_state state) { @@ -452,11 +488,11 @@ get_irn_alloc_attr (ir_node *node) return node->attr.a; } -type * +free_attr get_irn_free_attr (ir_node *node) { assert (node->op == op_Free); - return node->attr.f = skip_tid(node->attr.f); + return node->attr.f; } symconst_attr @@ -578,7 +614,6 @@ get_Block_cfgpred_arr (ir_node *node) return (ir_node **)&(get_irn_in(node)[1]); } - int get_Block_n_cfgpreds (ir_node *node) { assert ((node->op == op_Block)); @@ -609,29 +644,26 @@ set_Block_matured (ir_node *node, bool matured) { assert (node->op == op_Block); node->attr.block.matured = matured; } + unsigned long -get_Block_block_visited (ir_node *node) { - assert (node->op == op_Block); - return node->attr.block.block_visited; +(get_Block_block_visited)(ir_node *node) { + return _get_Block_block_visited(node); } void -set_Block_block_visited (ir_node *node, unsigned long visit) { - assert (node->op == op_Block); - node->attr.block.block_visited = visit; +(set_Block_block_visited)(ir_node *node, unsigned long visit) { + _set_Block_block_visited(node, visit); } /* For this current_ir_graph must be set. */ void -mark_Block_block_visited (ir_node *node) { - assert (node->op == op_Block); - node->attr.block.block_visited = get_irg_block_visited(current_ir_graph); +(mark_Block_block_visited)(ir_node *node) { + _mark_Block_block_visited(node); } int -Block_not_block_visited(ir_node *node) { - assert (node->op == op_Block); - return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph)); +(Block_not_block_visited)(ir_node *node) { + return _Block_not_block_visited(node); } ir_node * @@ -692,11 +724,21 @@ void remove_Block_cg_cfgpred_arr(ir_node * node) { } ir_node *(set_Block_dead)(ir_node *block) { - return __set_Block_dead(block); + return _set_Block_dead(block); } int (is_Block_dead)(const ir_node *block) { - return __is_Block_dead(block); + return _is_Block_dead(block); +} + +ir_extblk *get_Block_extbb(const ir_node *block) { + assert(is_Block(block)); + return block->attr.block.extblk; +} + +void set_Block_extbb(ir_node *block, ir_extblk *extblk) { + assert(is_Block(block)); + block->attr.block.extblk = extblk; } void @@ -873,9 +915,8 @@ set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) { set_irn_n(node, 1, exo_ptr); } -tarval *get_Const_tarval (ir_node *node) { - assert (node->op == op_Const); - return node->attr.con.tv; +tarval *(get_Const_tarval)(ir_node *node) { + return _get_Const_tarval(node); } void @@ -884,6 +925,11 @@ set_Const_tarval (ir_node *node, tarval *con) { node->attr.con.tv = con; } +cnst_classify_t (classify_Const)(ir_node *node) +{ + return _classify_Const(node); +} + /* The source language type. Must be an atomic type. Mode of type must be mode of node. For tarvals from entities type must be pointer to @@ -1165,7 +1211,7 @@ get_Call_type (ir_node *node) { void set_Call_type (ir_node *node, type *tp) { assert (node->op == op_Call); - assert ((get_unknown_type() == tp) || is_method_type(tp)); + assert ((get_unknown_type() == tp) || is_Method_type(tp)); node->attr.call.cld_tp = tp; } @@ -1329,9 +1375,55 @@ set_Cast_type (ir_node *node, type *to_tp) { node->attr.cast.totype = to_tp; } + +/* Checks for upcast. + * + * Returns true if the Cast node casts a class type to a super type. + */ +int is_Cast_upcast(ir_node *node) { + type *totype = get_Cast_type(node); + type *fromtype = get_irn_typeinfo_type(get_Cast_op(node)); + ir_graph *myirg = get_irn_irg(node); + + assert(get_irg_typeinfo_state(myirg) == ir_typeinfo_consistent); + assert(fromtype); + + while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) { + totype = get_pointer_points_to_type(totype); + fromtype = get_pointer_points_to_type(fromtype); + } + + assert(fromtype); + + if (!is_Class_type(totype)) return false; + return is_subclass_of(fromtype, totype); +} + +/* Checks for downcast. + * + * Returns true if the Cast node casts a class type to a sub type. + */ +int is_Cast_downcast(ir_node *node) { + type *totype = get_Cast_type(node); + type *fromtype = get_irn_typeinfo_type(get_Cast_op(node)); + + assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent); + assert(fromtype); + + while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) { + totype = get_pointer_points_to_type(totype); + fromtype = get_pointer_points_to_type(fromtype); + } + + assert(fromtype); + + if (!is_Class_type(totype)) return false; + return is_subclass_of(totype, fromtype); +} + int (is_unop)(const ir_node *node) { - return __is_unop(node); + return _is_unop(node); } ir_node * @@ -1353,7 +1445,7 @@ set_unop_op (ir_node *node, ir_node *op) { int (is_binop)(const ir_node *node) { - return __is_binop(node); + return _is_binop(node); } ir_node * @@ -1654,13 +1746,25 @@ set_Free_size (ir_node *node, ir_node *size) { type * get_Free_type (ir_node *node) { assert (node->op == op_Free); - return node->attr.f = skip_tid(node->attr.f); + return node->attr.f.type = skip_tid(node->attr.f.type); } void set_Free_type (ir_node *node, type *tp) { assert (node->op == op_Free); - node->attr.f = tp; + node->attr.f.type = tp; +} + +where_alloc +get_Free_where (ir_node *node) { + assert (node->op == op_Free); + return node->attr.f.where; +} + +void +set_Free_where (ir_node *node, where_alloc where) { + assert (node->op == op_Free); + node->attr.f.where = where; } ir_node ** @@ -1694,8 +1798,40 @@ set_Sync_pred (ir_node *node, int pos, ir_node *pred) { set_irn_n(node, pos, pred); } +type *get_Proj_type(ir_node *n) +{ + type *tp = NULL; + ir_node *pred = get_Proj_pred(n); + + switch (get_irn_opcode(pred)) { + case iro_Proj: { + ir_node *pred_pred; + /* Deal with Start / Call here: we need to know the Proj Nr. */ + assert(get_irn_mode(pred) == mode_T); + pred_pred = get_Proj_pred(pred); + if (get_irn_op(pred_pred) == op_Start) { + type *mtp = get_entity_type(get_irg_entity(get_irn_irg(pred_pred))); + tp = get_method_param_type(mtp, get_Proj_proj(n)); + } else if (get_irn_op(pred_pred) == op_Call) { + type *mtp = get_Call_type(pred_pred); + tp = get_method_res_type(mtp, get_Proj_proj(n)); + } + } break; + case iro_Start: break; + case iro_Call: break; + case iro_Load: { + ir_node *a = get_Load_ptr(pred); + if (get_irn_op(a) == op_Sel) + tp = get_entity_type(get_Sel_entity(a)); + } break; + default: + break; + } + return tp; +} + ir_node * -get_Proj_pred (ir_node *node) { +get_Proj_pred (const ir_node *node) { assert (is_Proj(node)); return get_irn_n(node, 0); } @@ -1707,7 +1843,7 @@ set_Proj_pred (ir_node *node, ir_node *pred) { } long -get_Proj_proj (ir_node *node) { +get_Proj_proj (const ir_node *node) { assert (is_Proj(node)); if (get_irn_opcode(node) == iro_Proj) { return node->attr.proj; @@ -1909,19 +2045,31 @@ skip_Tuple (ir_node *node) { pred = skip_Id(get_Proj_pred(node)); if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */ pred = skip_Id(skip_Tuple(pred)); - if (get_irn_op(pred) == op_Tuple) + else if (get_irn_op(pred) == op_Tuple) return get_Tuple_pred(pred, get_Proj_proj(node)); } return node; } -/** returns operand of node if node is a Cast */ +/* returns operand of node if node is a Cast */ ir_node *skip_Cast (ir_node *node) { - if (node && get_irn_op(node) == op_Cast) { - return skip_Id(get_irn_n(node, 0)); - } else { - return node; - } + if (node && get_irn_op(node) == op_Cast) + return get_Cast_op(node); + return node; +} + +/* returns operand of node if node is a Confirm */ +ir_node *skip_Confirm (ir_node *node) { + if (node && get_irn_op(node) == op_Confirm) + return get_Confirm_value(node); + return node; +} + +/* skip all high-level ops */ +ir_node *skip_HighLevel(ir_node *node) { + if (node && is_op_highlevel(get_irn_op(node))) + return get_irn_n(node, 0); + return node; } #if 0 @@ -1993,24 +2141,28 @@ skip_Id (ir_node *node) { int (is_Bad)(const ir_node *node) { - return __is_Bad(node); + return _is_Bad(node); +} + +int +(is_Const)(const ir_node *node) { + return _is_Const(node); } int (is_no_Block)(const ir_node *node) { - return __is_no_Block(node); + return _is_no_Block(node); } int (is_Block)(const ir_node *node) { - return __is_Block(node); + return _is_Block(node); } /* returns true if node is a Unknown node. */ int -is_Unknown (const ir_node *node) { - assert(node); - return (get_irn_op(node) == op_Unknown); +(is_Unknown)(const ir_node *node) { + return _is_Unknown(node); } int @@ -2068,6 +2220,27 @@ is_forking_op(const ir_node *node) { return is_op_forking(get_irn_op(node)); } +type *(get_irn_type)(ir_node *node) { + return _get_irn_type(node); +} + +/** the get_type operation must be always implemented */ +static type *get_Null_type(ir_node *n) { + return NULL; +} + +/* set the get_type operation */ +ir_op *firm_set_default_get_type(ir_op *op) +{ + switch (op->code) { + case iro_Const: op->get_type = get_Const_type; break; + case iro_SymConst: op->get_type = get_SymConst_value_type; break; + case iro_Cast: op->get_type = get_Cast_type; break; + case iro_Proj: op->get_type = get_Proj_type; break; + default: op->get_type = get_Null_type; break; + } + return op; +} #ifdef DEBUG_libfirm void dump_irn (ir_node *n) {