X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode.c;h=47a5ce5a12671f8161702f0fba8498a4351d92d3;hb=637542932dc27dcdfc7def09b58d9d5d4c34fb77;hp=231d6a28c7e29066d7b929bb995ccfcbe7849163;hpb=1a20dabf9c97a7f321f71b7aa79ef404aaa904a8;p=libfirm

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index 231d6a28c..47a5ce5a1 100644
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -27,6 +27,7 @@
 #include "irdump.h"
 #include "irop_t.h"
 #include "irprog_t.h"
+#include "iredges_t.h"
 
 #include "irhooks.h"
 
@@ -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
 
-  hook_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;
 }
@@ -249,7 +275,9 @@ ir_node *
 
 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)) {
@@ -270,6 +298,13 @@ 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;
 }
 
@@ -579,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));
@@ -610,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 *
@@ -700,6 +731,16 @@ int (is_Block_dead)(const ir_node *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
 set_Start_irg(ir_node *node, ir_graph *irg) {
   assert(node->op == op_Start);
@@ -874,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
@@ -885,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
@@ -1330,6 +1375,52 @@ 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);
@@ -1707,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);
 }
@@ -1720,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;
@@ -1922,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
@@ -2009,6 +2144,11 @@ int
   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);
@@ -2021,9 +2161,8 @@ int
 
 /* 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
@@ -2081,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) {