return pnc_name_arr[pnc];
}
-/**
+/*
* Calculates the negated pnc condition.
*/
int
get_negated_pnc(int pnc) {
switch (pnc) {
- case pn_Cmp_False: return pn_Cmp_True; break;
- case pn_Cmp_Eq: return pn_Cmp_Ne; break;
- case pn_Cmp_Lt: return pn_Cmp_Uge; break;
- case pn_Cmp_Le: return pn_Cmp_Ug; break;
- case pn_Cmp_Gt: return pn_Cmp_Ule; break;
- case pn_Cmp_Ge: return pn_Cmp_Ul; break;
- case pn_Cmp_Lg: return pn_Cmp_Ue; break;
- case pn_Cmp_Leg: return pn_Cmp_Uo; break;
- case pn_Cmp_Uo: return pn_Cmp_Leg; break;
- case pn_Cmp_Ue: return pn_Cmp_Lg; break;
- case pn_Cmp_Ul: return pn_Cmp_Ge; break;
- case pn_Cmp_Ule: return pn_Cmp_Gt; break;
- case pn_Cmp_Ug: return pn_Cmp_Le; break;
- case pn_Cmp_Uge: return pn_Cmp_Lt; break;
- case pn_Cmp_Ne: return pn_Cmp_Eq; break;
- case pn_Cmp_True: return pn_Cmp_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"
return (ir_node **)&(get_irn_in(node)[1]);
}
-
int
get_Block_n_cfgpreds (ir_node *node) {
assert ((node->op == op_Block));
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 *
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
set_Start_irg(ir_node *node, ir_graph *irg) {
assert(node->op == op_Start);
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);
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);
}
}
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;
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
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);
/* 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
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) {