fix verifier crash in case of no register assigned errors

[libfirm] / ir / opt / proc_cloning.c

diff --git a/ir/opt/proc_cloning.c b/ir/opt/proc_cloning.c
index 3bb0458..bf602a6 100644 (file)
--- a/ir/opt/proc_cloning.c
+++ b/ir/opt/proc_cloning.c
@@ -22,7 +22,7 @@
  * @brief   Procedure cloning.
  * @author  Beyhan Veliev, Michael Beck
  * @version $Id$
- * @summary
+ * @brief
  *
  * The purpose is first to find and analyze functions, that are called
  * with constant parameter(s).
@@ -31,9 +31,7 @@
  * aren't be constant. The constant parameters of the function are placed
  * in the function graph. They aren't be passed as parameters.
  */
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
 #include <string.h>
 
@@ -50,11 +48,8 @@
 #include "irnode_t.h"
 #include "irtools.h"
 #include "irgmod.h"
-#include "array.h"
-#include "xmalloc.h"
-
-/* A macro to iterate sets.*/
-#define ITERATE_SET(set_entries, entry) for(entry = set_first(set_entries); entry; entry = set_next(set_entries))
+#include "array_t.h"
+#include "irpass_t.h"
 
 /**
  * This struct contains the information quadruple for a Call, which we need to
@@ -147,7 +142,7 @@ static void process_call(ir_node *call, ir_entity *callee, q_set *hmap) {
                        if (! hmap->map)
                                hmap->map = new_pset(entry_cmp, 8);
 
-                       key = obstack_alloc(&hmap->obst, sizeof(*key));
+                       key = OALLOC(&hmap->obst, entry_t);
 
                        key->q.ent   = callee;
                        key->q.pos   = i;
@@ -187,15 +182,19 @@ static void collect_irg_calls(ir_node *call, void *env) {
        if (is_Call(call)) {
                call_ptr = get_Call_ptr(call);
 
-               if (! is_SymConst_addr_ent(call_ptr))
+               if (! is_Global(call_ptr))
                        return;
 
-               callee = get_SymConst_entity(call_ptr);
+               callee = get_Global_entity(call_ptr);
 
                /* we can only clone calls to existing entities */
                if (get_entity_visibility(callee) == visibility_external_allocated)
                        return;
 
+               /* we cannot clone calls to weak functions */
+               if (get_entity_additional_properties(callee) & mtp_property_weak)
+                       return;
+
                process_call(call, callee, hmap);
        }
 }
@@ -214,7 +213,7 @@ static ident *get_clone_ident(ident *id, int pos, unsigned nr) {
 
        snprintf(clone_postfix, sizeof(clone_postfix), "_cl_%d_%u", pos, nr);
 
-       return mangle(id, new_id_from_str(clone_postfix));
+       return id_mangle(id, new_id_from_str(clone_postfix));
 }
 
 /**
@@ -265,7 +264,7 @@ static void set_preds(ir_node *irn, void *env) {
        irn_copy  = get_irn_link(irn);
 
        if (is_Block(irn)) {
-               set_Block_MacroBlock(irn_copy, get_irn_link(get_Block_MacroBlock(irn)))
+               set_Block_MacroBlock(irn_copy, get_irn_link(get_Block_MacroBlock(irn)));
                for (i = get_Block_n_cfgpreds(irn) - 1; i >= 0; i--) {
                        pred = get_Block_cfgpred(irn, i);
                        /* "End" block must be handled extra, because it is not matured.*/
@@ -277,7 +276,7 @@ static void set_preds(ir_node *irn, void *env) {
        } else {
                /* First we set the block our copy if it is not a block.*/
                set_nodes_block(irn_copy, get_irn_link(get_nodes_block(irn)));
-               if (get_irn_op(irn) == op_End) {
+               if (is_End(irn)) {
                        /* Handle the keep-alives. This must be done separately, because
                           the End node was NOT copied */
                        for (i = 0; i < get_End_n_keepalives(irn); ++i)
@@ -314,7 +313,7 @@ static ir_node *get_irg_arg(ir_graph *irg, int pos) {
                                 * We rely on the fact the only one arg exists, so do
                                 * a cheap CSE in this case.
                                 */
-                               set_irn_out(irg_args, i, arg);
+                               set_irn_out(irg_args, i, arg, 0);
                                exchange(proj, arg);
                        } else
                                arg = proj;
@@ -343,7 +342,7 @@ static void create_clone_proc_irg(ir_entity *ent, quadruple_t *q) {
        arg        = get_irg_arg(get_entity_irg(q->ent), q->pos);
        /* we will replace the argument in position "q->pos" by this constant. */
        const_arg  = new_r_Const_type(
-               clone_irg, get_nodes_block(arg), get_irn_mode(arg), q->tv,
+               clone_irg, q->tv,
                get_method_param_type(get_entity_type(q->ent), q->pos));
 
        /* args copy in the cloned graph will be the const. */
@@ -462,7 +461,7 @@ static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, int pos) {
        ir_node *bl = get_nodes_block(call);
 
        sym.entity_p = new_entity;
-       callee = new_r_SymConst(irg, bl, mode_P_code, sym, symconst_addr_ent);
+       callee = new_r_SymConst(irg, mode_P_code, sym, symconst_addr_ent);
 
        mtp      = get_entity_type(new_entity);
        n_params = get_Call_n_params(call);
@@ -475,7 +474,7 @@ static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, int pos) {
                        in[new_params++] = get_Call_param(call, i);
        }
        /* Create and return the new Call. */
-       return new_r_Call(irg, bl, get_Call_mem(call),
+       return new_r_Call(bl, get_Call_mem(call),
                callee, n_params - 1, in, get_entity_type(new_entity));
 }
 
@@ -509,7 +508,7 @@ static void exchange_calls(quadruple_t *q, ir_entity *cloned_ent) {
  */
 static float calculate_weight(const entry_t *entry) {
        return ARR_LEN(entry->q.calls) *
-               (get_method_param_weight(entry->q.ent, entry->q.pos) + 1);
+               (float)(get_method_param_weight(entry->q.ent, entry->q.pos) + 1);
 }
 
 /**
@@ -536,7 +535,7 @@ restart:
 
                /* we know, that a SymConst is here */
                ptr = get_Call_ptr(call);
-               assert(get_irn_op(ptr) == op_SymConst);
+               assert(is_SymConst(ptr));
 
                callee = get_SymConst_entity(ptr);
                if (callee != entry->q.ent) {
@@ -678,3 +677,28 @@ void proc_cloning(float threshold) {
        }
        obstack_free(&hmap.obst, NULL);
 }
+
+struct pass_t {
+       ir_prog_pass_t pass;
+       float          threshold;
+};
+
+/**
+ * Wrapper to run proc_cloning() as an ir_prog pass.
+ */
+static int proc_cloning_wrapper(ir_prog *irp, void *context) {
+       struct pass_t *pass = context;
+
+       (void)irp;
+       proc_cloning(pass->threshold);
+       return 0;
+}
+
+/* create a ir_prog pass */
+ir_prog_pass_t *proc_cloning_pass(const char *name, float threshold) {
+       struct pass_t *pass = XMALLOCZ(struct pass_t);
+
+       pass->threshold = threshold;
+       return def_prog_pass_constructor(
+               &pass->pass, name ? name : "cloning", proc_cloning_wrapper);
+}