change pn_XXX_max enum to really be the maximum pn and not maximum+1, add n_XXX_max...

diff --git a/ir/be/arm/arm_transform.c b/ir/be/arm/arm_transform.c
index 3ba7820..2aa3e04 100644 (file)
--- a/ir/be/arm/arm_transform.c
+++ b/ir/be/arm/arm_transform.c
@@ -1432,9 +1432,6 @@ static ir_node *gen_Proj_Start(ir_node *node)
 
        case pn_Start_P_frame_base:
                return be_prolog_get_reg_value(abihelper, sp_reg);
-
-       case pn_Start_max:
-               break;
        }
        panic("unexpected start proj: %ld\n", proj);
 }
@@ -1560,7 +1557,6 @@ static ir_node *gen_Proj_Call(ir_node *node)
        case pn_Call_X_regular:
        case pn_Call_X_except:
        case pn_Call_T_result:
-       case pn_Call_max:
                break;
        }
        panic("Unexpected Call proj %ld\n", pn);

diff --git a/ir/be/benode.h b/ir/be/benode.h
index b809078..f6b00ff 100644 (file)
--- a/ir/be/benode.h
+++ b/ir/be/benode.h
@@ -286,7 +286,7 @@ enum {
  */
 typedef enum {
        pn_be_Call_M_regular = pn_Call_M,    /**< The memory result of a be_Call. */
-       pn_be_Call_sp        = pn_Call_max,
+       pn_be_Call_sp        = pn_Call_max+1,
        pn_be_Call_first_res                 /**< The first result proj number of a
                                                  be_Call. */
 } pn_be_Call;

diff --git a/ir/be/ia32/ia32_intrinsics.c b/ir/be/ia32/ia32_intrinsics.c
index d5282df..4495c9c 100644 (file)
--- a/ir/be/ia32/ia32_intrinsics.c
+++ b/ir/be/ia32/ia32_intrinsics.c
@@ -154,7 +154,6 @@ static void resolve_call(ir_node *call, ir_node *l_res, ir_node *h_res, ir_graph
                        res = new_r_Tuple(block, 2, in);
                }
 
-               turn_into_tuple(call, pn_Call_max);
                /*
                 * Beware:
                 * We do not check here if this call really has exception and regular Proj's.
@@ -167,6 +166,7 @@ static void resolve_call(ir_node *call, ir_node *l_res, ir_node *h_res, ir_graph
                jmp = new_r_Jmp(block);
                set_opt_cse(old_cse);
 
+               turn_into_tuple(call, pn_Call_max+1);
                set_Tuple_pred(call, pn_Call_M,         nomem);
                set_Tuple_pred(call, pn_Call_X_regular, jmp);
                set_Tuple_pred(call, pn_Call_X_except,  new_r_Bad(irg, mode_X));

diff --git a/ir/be/ia32/ia32_transform.c b/ir/be/ia32/ia32_transform.c
index 7732598..b32cd8d 100644 (file)
--- a/ir/be/ia32/ia32_transform.c
+++ b/ir/be/ia32/ia32_transform.c
@@ -4538,8 +4538,6 @@ static ir_node *gen_Proj_Load(ir_node *node)
                        return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_Load_X_except);
                case pn_Load_X_regular:
                        return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_Load_X_regular);
-               case pn_Load_max:
-                       break;
                }
        } else if (is_ia32_Conv_I2I(new_pred) ||
                   is_ia32_Conv_I2I8Bit(new_pred)) {
@@ -4561,8 +4559,6 @@ static ir_node *gen_Proj_Load(ir_node *node)
                        return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_xLoad_X_except);
                case pn_Load_X_regular:
                        return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_xLoad_X_regular);
-               case pn_Load_max:
-                       break;
                }
        } else if (is_ia32_vfld(new_pred)) {
                switch ((pn_Load)proj) {
@@ -4576,8 +4572,6 @@ static ir_node *gen_Proj_Load(ir_node *node)
                        return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_vfld_X_except);
                case pn_Load_X_regular:
                        return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_vfld_X_regular);
-               case pn_Load_max:
-                       break;
                }
        } else {
                /* can happen for ProJMs when source address mode happened for the
@@ -4634,8 +4628,6 @@ static ir_node *gen_Proj_Div(ir_node *node)
                return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_Div_X_except);
        case pn_Div_X_regular:
                return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_Div_X_regular);
-       case pn_Div_max:
-               break;
        }
 
        panic("No idea how to transform proj->Div");
@@ -4665,8 +4657,6 @@ static ir_node *gen_Proj_Mod(ir_node *node)
                return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_Div_X_except);
        case pn_Mod_X_regular:
                return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_Div_X_regular);
-       case pn_Mod_max:
-               break;
        }
        panic("No idea how to transform proj->Mod");
 }

diff --git a/ir/be/sparc/sparc_transform.c b/ir/be/sparc/sparc_transform.c
index 669c05b..16fa11e 100644 (file)
--- a/ir/be/sparc/sparc_transform.c
+++ b/ir/be/sparc/sparc_transform.c
@@ -1926,8 +1926,6 @@ static ir_node *gen_Proj_Start(ir_node *node)
                return new_r_Bad(get_irn_irg(block), mode_T);
        case pn_Start_P_frame_base:
                return get_frame_base();
-       case pn_Start_max:
-               break;
        }
        panic("Unexpected start proj: %ld\n", pn);
 }
@@ -2006,7 +2004,6 @@ static ir_node *gen_Proj_Call(ir_node *node)
        case pn_Call_X_regular:
        case pn_Call_X_except:
        case pn_Call_T_result:
-       case pn_Call_max:
                break;
        }
        panic("Unexpected Call proj %ld\n", pn);

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index d276225..7a6fb31 100644 (file)
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -49,10 +49,10 @@
 
 /* some constants fixing the positions of nodes predecessors
    in the in array */
-#define CALL_PARAM_OFFSET     2
-#define BUILDIN_PARAM_OFFSET  1
-#define SEL_INDEX_OFFSET      2
-#define RETURN_RESULT_OFFSET  1  /* mem is not a result */
+#define CALL_PARAM_OFFSET     (n_Call_max+1)
+#define BUILTIN_PARAM_OFFSET  (n_Builtin_max+1)
+#define SEL_INDEX_OFFSET      (n_Sel_max+1)
+#define RETURN_RESULT_OFFSET  (n_Return_max+1)
 #define END_KEEPALIVE_OFFSET  0
 
 static const char *relation_names [] = {
@@ -989,25 +989,25 @@ void set_Call_param(ir_node *node, int pos, ir_node *param)
 ir_node **get_Builtin_param_arr(ir_node *node)
 {
        assert(is_Builtin(node));
-       return &get_irn_in(node)[BUILDIN_PARAM_OFFSET + 1];
+       return &get_irn_in(node)[BUILTIN_PARAM_OFFSET + 1];
 }
 
 int get_Builtin_n_params(const ir_node *node)
 {
        assert(is_Builtin(node));
-       return (get_irn_arity(node) - BUILDIN_PARAM_OFFSET);
+       return (get_irn_arity(node) - BUILTIN_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);
+       return get_irn_n(node, pos + BUILTIN_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);
+       set_irn_n(node, pos + BUILTIN_PARAM_OFFSET, param);
 }
 
 /* Returns a human readable string for the ir_builtin_kind. */

diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c
index 3c89c50..90c491a 100644 (file)
--- a/ir/ir/iropt.c
+++ b/ir/ir/iropt.c
@@ -2665,7 +2665,7 @@ make_tuple:
 
                /* skip a potential Pin */
                mem = skip_Pin(mem);
-               turn_into_tuple(n, pn_Div_max);
+               turn_into_tuple(n, pn_Div_max+1);
                set_Tuple_pred(n, pn_Div_M,         mem);
                set_Tuple_pred(n, pn_Div_X_regular, new_r_Jmp(blk));
                set_Tuple_pred(n, pn_Div_X_except,  new_r_Bad(irg, mode_X));
@@ -2757,7 +2757,7 @@ make_tuple:
 
                /* skip a potential Pin */
                mem = skip_Pin(mem);
-               turn_into_tuple(n, pn_Mod_max);
+               turn_into_tuple(n, pn_Mod_max+1);
                set_Tuple_pred(n, pn_Mod_M,         mem);
                set_Tuple_pred(n, pn_Mod_X_regular, new_r_Jmp(blk));
                set_Tuple_pred(n, pn_Mod_X_except,  new_r_Bad(irg, mode_X));
@@ -2791,7 +2791,7 @@ static ir_node *transform_node_Cond(ir_node *n)
                   Replace it by a tuple (Bad, Jmp) or (Jmp, Bad) */
                ir_node *blk = get_nodes_block(n);
                jmp = new_r_Jmp(blk);
-               turn_into_tuple(n, pn_Cond_max);
+               turn_into_tuple(n, pn_Cond_max+1);
                if (ta == tarval_b_true) {
                        set_Tuple_pred(n, pn_Cond_false, new_r_Bad(irg, mode_X));
                        set_Tuple_pred(n, pn_Cond_true, jmp);
@@ -5833,7 +5833,7 @@ static ir_node *transform_node_Load(ir_node *n)
                        ir_node  *bad   = new_r_Bad(irg, mode_X);
                        ir_mode  *mode  = get_Load_mode(n);
                        ir_node  *res   = new_r_Proj(pred_load, mode, pn_Load_res);
-                       ir_node  *in[pn_Load_max] = { mem, jmp, bad, res };
+                       ir_node  *in[pn_Load_max+1] = { mem, jmp, bad, res };
                        ir_node  *tuple = new_r_Tuple(block, ARRAY_SIZE(in), in);
                        return tuple;
                }
@@ -5853,7 +5853,7 @@ static ir_node *transform_node_Load(ir_node *n)
                        ir_graph *irg   = get_irn_irg(n);
                        ir_node  *bad   = new_r_Bad(irg, mode_X);
                        ir_node  *res   = value;
-                       ir_node  *in[pn_Load_max] = { mem, jmp, bad, res };
+                       ir_node  *in[pn_Load_max+1] = { mem, jmp, bad, res };
                        ir_node  *tuple = new_r_Tuple(block, ARRAY_SIZE(in), in);
                        return tuple;
                }

diff --git a/ir/lower/lower_calls.c b/ir/lower/lower_calls.c
index 5cd3afa..a3eca0b 100644 (file)
--- a/ir/lower/lower_calls.c
+++ b/ir/lower/lower_calls.c
@@ -497,7 +497,7 @@ static void add_hidden_param(ir_graph *irg, size_t n_com, ir_node **ins, cl_entr
                blk      = get_nodes_block(p);
 
                /* get rid of the CopyB */
-               turn_into_tuple(p, pn_CopyB_max);
+               turn_into_tuple(p, pn_CopyB_max+1);
                set_Tuple_pred(p, pn_CopyB_M,         mem);
                set_Tuple_pred(p, pn_CopyB_X_regular, new_r_Jmp(blk));
                set_Tuple_pred(p, pn_CopyB_X_except,  new_r_Bad(irg, mode_X));

diff --git a/ir/lower/lower_copyb.c b/ir/lower/lower_copyb.c
index 8da195e..d18afa7 100644 (file)
--- a/ir/lower/lower_copyb.c
+++ b/ir/lower/lower_copyb.c
@@ -118,7 +118,7 @@ static void lower_copyb_nodes(ir_node *irn, unsigned mode_bytes)
                mode_bytes /= 2;
        }
 
-       turn_into_tuple(irn, pn_CopyB_max);
+       turn_into_tuple(irn, pn_CopyB_max+1);
        set_Tuple_pred(irn, pn_CopyB_M,         mem);
        set_Tuple_pred(irn, pn_CopyB_X_regular, new_r_Bad(irg, mode_X));
        set_Tuple_pred(irn, pn_CopyB_X_except,  new_r_Bad(irg, mode_X));

diff --git a/ir/lower/lower_intrinsics.c b/ir/lower/lower_intrinsics.c
index d7858e9..88cd138 100644 (file)
--- a/ir/lower/lower_intrinsics.c
+++ b/ir/lower/lower_intrinsics.c
@@ -225,7 +225,7 @@ static void replace_call(ir_node *irn, ir_node *call, ir_node *mem, ir_node *reg
        }
        irn = new_r_Tuple(block, 1, &irn);
 
-       turn_into_tuple(call, pn_Call_max);
+       turn_into_tuple(call, pn_Call_max+1);
        set_Tuple_pred(call, pn_Call_M, mem);
        set_Tuple_pred(call, pn_Call_X_regular, reg_jmp);
        set_Tuple_pred(call, pn_Call_X_except, exc_jmp);

diff --git a/ir/opt/escape_ana.c b/ir/opt/escape_ana.c
index d4c6f4d..901ac42 100644 (file)
--- a/ir/opt/escape_ana.c
+++ b/ir/opt/escape_ana.c
@@ -393,7 +393,7 @@ static void transform_allocs(ir_graph *irg, walk_env_t *env)
 
                mem = get_Alloc_mem(alloc);
                blk = get_nodes_block(alloc);
-               turn_into_tuple(alloc, pn_Alloc_max);
+               turn_into_tuple(alloc, pn_Alloc_max+1);
                set_Tuple_pred(alloc, pn_Alloc_M, mem);
                set_Tuple_pred(alloc, pn_Alloc_X_regular, new_r_Jmp(blk));
                set_Tuple_pred(alloc, pn_Alloc_X_except, new_r_Bad(irg, mode_X));
@@ -438,7 +438,7 @@ static void transform_allocs(ir_graph *irg, walk_env_t *env)
                        sel = new_rd_simpleSel(dbg, get_nodes_block(alloc), get_irg_no_mem(irg), get_irg_frame(irg), ent);
                        mem = get_Alloc_mem(alloc);
 
-                       turn_into_tuple(alloc, pn_Alloc_max);
+                       turn_into_tuple(alloc, pn_Alloc_max+1);
                        set_Tuple_pred(alloc, pn_Alloc_M, mem);
                        set_Tuple_pred(alloc, pn_Alloc_X_regular, new_r_Jmp(blk));
                        set_Tuple_pred(alloc, pn_Alloc_X_except, new_r_Bad(irg, mode_X));
@@ -481,7 +481,7 @@ static void transform_alloc_calls(ir_graph *irg, walk_env_t *env)
 
                mem = get_Call_mem(call);
                blk = get_nodes_block(call);
-               turn_into_tuple(call, pn_Call_max);
+               turn_into_tuple(call, pn_Call_max+1);
                set_Tuple_pred(call, pn_Call_M,         mem);
                set_Tuple_pred(call, pn_Call_X_regular, new_r_Jmp(blk));
                set_Tuple_pred(call, pn_Call_X_except,  new_r_Bad(irg, mode_X));

diff --git a/ir/opt/ldstopt.c b/ir/opt/ldstopt.c
index 6fd5f49..aaf784f 100644 (file)
--- a/ir/opt/ldstopt.c
+++ b/ir/opt/ldstopt.c
@@ -74,7 +74,7 @@ typedef struct walk_env_t {
 
 /** A Load/Store info. */
 typedef struct ldst_info_t {
-       ir_node  *projs[MAX_PROJ];    /**< list of Proj's of this node */
+       ir_node  *projs[MAX_PROJ+1];  /**< list of Proj's of this node */
        ir_node  *exc_block;          /**< the exception block if available */
        int      exc_idx;             /**< predecessor index in the exception block */
        unsigned visited;             /**< visited counter for breaking loops */

diff --git a/ir/opt/opt_inline.c b/ir/opt/opt_inline.c
index 6c3c38d..df5fbb0 100644 (file)
--- a/ir/opt/opt_inline.c
+++ b/ir/opt/opt_inline.c
@@ -299,7 +299,7 @@ int inline_method(ir_node *call, ir_graph *called_graph)
 {
        ir_node       *pre_call;
        ir_node       *post_call, *post_bl;
-       ir_node       *in[pn_Start_max];
+       ir_node       *in[pn_Start_max+1];
        ir_node       *end, *end_bl, *block;
        ir_node       **res_pred;
        ir_node       **cf_pred;
@@ -392,7 +392,7 @@ int inline_method(ir_node *call, ir_graph *called_graph)
        in[pn_Start_X_initial_exec] = new_r_Jmp(post_bl);
        in[pn_Start_P_frame_base]   = get_irg_frame(irg);
        in[pn_Start_T_args]         = new_r_Tuple(post_bl, n_params, args_in);
-       pre_call = new_r_Tuple(post_bl, pn_Start_max, in);
+       pre_call = new_r_Tuple(post_bl, pn_Start_max+1, in);
        post_call = call;
 
        /* --
@@ -485,7 +485,7 @@ int inline_method(ir_node *call, ir_graph *called_graph)
 
        /* build a Tuple for all results of the method.
         * add Phi node if there was more than one Return. */
-       turn_into_tuple(post_call, pn_Call_max);
+       turn_into_tuple(post_call, pn_Call_max+1);
        /* First the Memory-Phi */
        n_mem_phi = 0;
        for (i = 0; i < arity; i++) {

diff --git a/ir/opt/opt_ldst.c b/ir/opt/opt_ldst.c
index 6c3d116..5279d6b 100644 (file)
--- a/ir/opt/opt_ldst.c
+++ b/ir/opt/opt_ldst.c
@@ -90,7 +90,7 @@ struct memop_t {
        memop_t  *next;      /**< links to the next memory op in the block in forward order. */
        memop_t  *prev;      /**< links to the previous memory op in the block in forward order. */
        unsigned flags;      /**< memop flags */
-       ir_node  *projs[MAX_PROJ]; /**< Projs of this memory op */
+       ir_node  *projs[MAX_PROJ+1]; /**< Projs of this memory op */
 };
 
 /**

diff --git a/ir/opt/scalar_replace.c b/ir/opt/scalar_replace.c
index d13f96e..33d7857 100644 (file)
--- a/ir/opt/scalar_replace.c
+++ b/ir/opt/scalar_replace.c
@@ -608,7 +608,7 @@ static void topologic_walker(ir_node *node, void *ctx)
                        val = new_rd_Conv(get_irn_dbg_info(node), block, val, mode);
 
                mem = get_Load_mem(node);
-               turn_into_tuple(node, pn_Load_max);
+               turn_into_tuple(node, pn_Load_max+1);
                set_Tuple_pred(node, pn_Load_M,         mem);
                set_Tuple_pred(node, pn_Load_res,       val);
                set_Tuple_pred(node, pn_Load_X_regular, new_r_Jmp(block));
@@ -645,7 +645,7 @@ static void topologic_walker(ir_node *node, void *ctx)
                set_value(vnum, val);
 
                mem = get_Store_mem(node);
-               turn_into_tuple(node, pn_Store_max);
+               turn_into_tuple(node, pn_Store_max+1);
                set_Tuple_pred(node, pn_Store_M,         mem);
                set_Tuple_pred(node, pn_Store_X_regular, new_r_Jmp(block));
                set_Tuple_pred(node, pn_Store_X_except,  new_r_Bad(irg, mode_X));

diff --git a/ir/opt/tailrec.c b/ir/opt/tailrec.c
index 35cfa01..3712193 100644 (file)
--- a/ir/opt/tailrec.c
+++ b/ir/opt/tailrec.c
@@ -337,7 +337,7 @@ static void do_opt_tail_rec(ir_graph *irg, tr_env *env)
                        /* create a new tuple for the return values */
                        tuple = new_r_Tuple(block, env->n_ress, in);
 
-                       turn_into_tuple(call, pn_Call_max);
+                       turn_into_tuple(call, pn_Call_max+1);
                        set_Tuple_pred(call, pn_Call_M,         mem);
                        set_Tuple_pred(call, pn_Call_X_regular, jmp);
                        set_Tuple_pred(call, pn_Call_X_except,  new_r_Bad(irg, mode_X));

diff --git a/scripts/gen_ir.py b/scripts/gen_ir.py
index bceca3a..690da1f 100755 (executable)
--- a/scripts/gen_ir.py
+++ b/scripts/gen_ir.py
@@ -493,6 +493,7 @@ typedef enum {
        {%- for input in node.ins %}
        n_{{node.name}}_{{input[0]}},
        {%- endfor %}
+       n_{{node.name}}_max = n_{{node.name}}_{{node.ins[-1][0]}}
 } n_{{node.name}};
 {% endif %}
 {% if node.outs %}
@@ -504,7 +505,7 @@ typedef enum {
        pn_{{node.name}}_{{out[0]}}
        {%- if out.__len__() > 2 %} = {{out[2]}}{% endif %}, /**< {{out[1]}} */
        {% endfor -%}
-       pn_{{node.name}}_max
+       pn_{{node.name}}_max = pn_{{node.name}}_{{node.outs[-1][0]}}
 } pn_{{node.name}};
 {% endif %}
 {%- endfor %}