- add ir_bk_outport and ir_bk_inport

[libfirm] / ir / ir / irnode.c

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index 20376d6..3fb0473 100644 (file)
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -48,7 +48,7 @@
 /* some constants fixing the positions of nodes predecessors
    in the in array */
 #define CALL_PARAM_OFFSET     2
-#define FUNCCALL_PARAM_OFFSET 1
+#define BUILDIN_PARAM_OFFSET  1
 #define SEL_INDEX_OFFSET      2
 #define RETURN_RESULT_OFFSET  1  /* mem is not a result */
 #define END_KEEPALIVE_OFFSET  0
@@ -571,6 +571,11 @@ divmod_attr *get_irn_divmod_attr(ir_node *node) {
        return &node->attr.divmod;
 }
 
+builtin_attr *get_irn_builtin_attr(ir_node *node) {
+       assert(is_Builtin(node));
+       return &node->attr.builtin;
+}
+
 void *(get_irn_generic_attr)(ir_node *node) {
        assert(is_ir_node(node));
        return _get_irn_generic_attr(node);
@@ -923,7 +928,7 @@ found:
        ARR_RESIZE(ir_node *, end->in, (n - 1) + 1 + END_KEEPALIVE_OFFSET);
 }
 
-/* remove Bads and doublets from the keep-alive set */
+/* remove Bads, NoMems and doublets from the keep-alive set */
 void remove_End_Bads_and_doublets(ir_node *end) {
        pset_new_t keeps;
        int        idx, n = get_End_n_keepalives(end);
@@ -938,7 +943,7 @@ void remove_End_Bads_and_doublets(ir_node *end) {
        for (idx = n - 1; idx >= 0; --idx) {
                ir_node *ka = get_End_keepalive(end, idx);
 
-               if (is_Bad(ka) || pset_new_contains(&keeps, ka)) {
+               if (is_Bad(ka) || is_NoMem(ka) || pset_new_contains(&keeps, ka)) {
                        /* remove the edge */
                        edges_notify_edge(end, idx, NULL, ka, irg);
 
@@ -1343,18 +1348,6 @@ get_Call_n_params(const ir_node *node)  {
        return (get_irn_arity(node) - CALL_PARAM_OFFSET);
 }
 
-int
-get_Call_arity(const ir_node *node) {
-       assert(is_Call(node));
-       return get_Call_n_params(node);
-}
-
-/* void
-set_Call_arity(ir_node *node, ir_node *arity) {
-       assert(is_Call(node));
-}
-*/
-
 ir_node *
 get_Call_param(const ir_node *node, int pos) {
        assert(is_Call(node));
@@ -1380,6 +1373,90 @@ set_Call_type(ir_node *node, ir_type *tp) {
        node->attr.call.cld_tp = tp;
 }
 
+ir_node *
+get_Builtin_mem(const ir_node *node) {
+       assert(is_Builtin(node));
+       return get_irn_n(node, 0);
+}
+
+void
+set_Builin_mem(ir_node *node, ir_node *mem) {
+       assert(is_Builtin(node));
+       set_irn_n(node, 0, mem);
+}
+
+ir_builtin_kind
+get_Builtin_kind(const ir_node *node) {
+       assert(is_Builtin(node));
+       return node->attr.builtin.kind;
+}
+
+void
+set_Builtin_kind(ir_node *node, ir_builtin_kind kind) {
+       assert(is_Builtin(node));
+       node->attr.builtin.kind = kind;
+}
+
+ir_node **
+get_Builtin_param_arr(ir_node *node) {
+       assert(is_Builtin(node));
+       return &get_irn_in(node)[BUILDIN_PARAM_OFFSET + 1];
+}
+
+int
+get_Builtin_n_params(const ir_node *node)  {
+       assert(is_Builtin(node));
+       return (get_irn_arity(node) - BUILDIN_PARAM_OFFSET);
+}
+
+ir_node *
+get_Builtin_param(const ir_node *node, int pos) {
+       assert(is_Builtin(node));
+       return get_irn_n(node, pos + BUILDIN_PARAM_OFFSET);
+}
+
+void
+set_Builtin_param(ir_node *node, int pos, ir_node *param) {
+       assert(is_Builtin(node));
+       set_irn_n(node, pos + BUILDIN_PARAM_OFFSET, param);
+}
+
+ir_type *
+get_Builtin_type(ir_node *node) {
+       assert(is_Builtin(node));
+       return node->attr.builtin.builtin_tp = skip_tid(node->attr.builtin.builtin_tp);
+}
+
+void
+set_Builtin_type(ir_node *node, ir_type *tp) {
+       assert(is_Builtin(node));
+       assert((get_unknown_type() == tp) || is_Method_type(tp));
+       node->attr.builtin.builtin_tp = tp;
+}
+
+/* Returns a human readable string for the ir_builtin_kind. */
+const char *get_builtin_kind_name(ir_builtin_kind kind) {
+#define X(a)    case a: return #a + 6;
+       switch (kind) {
+               X(ir_bk_trap);
+               X(ir_bk_debugbreak);
+               X(ir_bk_return_address);
+               X(ir_bk_frame_addess);
+               X(ir_bk_prefetch);
+               X(ir_bk_ffs);
+               X(ir_bk_clz);
+               X(ir_bk_ctz);
+               X(ir_bk_popcount);
+               X(ir_bk_parity);
+               X(ir_bk_bswap);
+               X(ir_bk_inport);
+               X(ir_bk_outport);
+       }
+       return "<unknown>";
+#undef X
+}
+
+
 int Call_has_callees(const ir_node *node) {
        assert(is_Call(node));
        return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
@@ -2488,10 +2565,8 @@ skip_Tuple(ir_node *node) {
   ir_node *pred;
   ir_op   *op;
 
-  if (!get_opt_normalize()) return node;
-
 restart:
-       if (get_irn_op(node) == op_Proj) {
+       if (is_Proj(node)) {
            pred = get_Proj_pred(node);
            op   = get_irn_op(pred);
 
@@ -2501,9 +2576,8 @@ restart:
                 */
                if (op == op_Proj) { /* nested Tuple ? */
                    pred = skip_Tuple(pred);
-                   op   = get_irn_op(pred);
 
-                       if (op == op_Tuple) {
+                       if (is_Tuple(pred)) {
                                node = get_Tuple_pred(pred, get_Proj_proj(node));
                                goto restart;
                        }
@@ -2771,6 +2845,12 @@ int
        return _is_Call(node);
 }
 
+/* returns true if node is a Builtin node. */
+int
+(is_Builtin)(const ir_node *node) {
+       return _is_Builtin(node);
+}
+
 /* returns true if node is a CallBegin node. */
 int
 (is_CallBegin)(const ir_node *node) {