X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fproc_cloning.c;h=2f80cbce1d2bc5b84e3a6dfbf4c86d06cbc972b4;hb=6b124543aff56817fcfe6d5b5ff181ac5c790e73;hp=0e9f492d9203aeaf426bbe3f99f29f8405a37f77;hpb=6aac59aee3a4d2c1ec050af2b9a2ac12ded488f7;p=libfirm

diff --git a/ir/opt/proc_cloning.c b/ir/opt/proc_cloning.c
index 0e9f492d9..2f80cbce1 100644
--- 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,8 +48,8 @@
 #include "irnode_t.h"
 #include "irtools.h"
 #include "irgmod.h"
-#include "array.h"
-#include "xmalloc.h"
+#include "array_t.h"
+#include "irpass_t.h"
 
 /**
  * This struct contains the information quadruple for a Call, which we need to
@@ -144,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;
@@ -189,8 +187,12 @@ static void collect_irg_calls(ir_node *call, void *env) {
 
 		callee = get_Global_entity(call_ptr);
 
+		/* we don't know which function gets finally bound to a weak symbol */
+		if (get_entity_linkage(callee) & IR_LINKAGE_WEAK)
+			return;
+
 		/* we can only clone calls to existing entities */
-		if (get_entity_visibility(callee) == visibility_external_allocated)
+		if (get_entity_irg(callee) == NULL)
 			return;
 
 		process_call(call, callee, hmap);
@@ -211,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));
 }
 
 /**
@@ -274,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)
@@ -340,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. */
@@ -366,19 +368,17 @@ static void create_clone_proc_irg(ir_entity *ent, quadruple_t *q) {
  * @param ent The entity of the clone.
  * @param nr  A pointer to the counter of clones.
  **/
-static void change_entity_type(quadruple_t *q, ir_entity *ent, unsigned *nr) {
+static void change_entity_type(quadruple_t *q, ir_entity *ent) {
 	ir_type *mtp, *new_mtp, *tp;
-	ident   *tp_name;
 	int     i, j, n_params, n_ress;
 
 	mtp      = get_entity_type(q->ent);
-	tp_name  = get_clone_ident(get_type_ident(mtp), q->pos, (*nr)++);
 	n_params = get_method_n_params(mtp);
 	n_ress   = get_method_n_ress(mtp);
 
 	/* Create the new type for our clone. It must have one parameter
 	   less then the original.*/
-	new_mtp  = new_type_method(tp_name, n_params - 1, n_ress);
+	new_mtp  = new_type_method(n_params - 1, n_ress);
 
 	/* We must set the type of the methods parameters.*/
 	for (i = j = 0; i < n_params; ++i) {
@@ -403,10 +403,10 @@ static void change_entity_type(quadruple_t *q, ir_entity *ent, unsigned *nr) {
  *
  * @param q   Contains information for the method to clone.
  */
-static ir_entity *clone_method(quadruple_t *q) {
+static ir_entity *clone_method(quadruple_t *q)
+{
 	ir_entity *new_entity;
 	ident *clone_ident;
-	ir_graph *rem;
 	symconst_symbol sym;
 	/* A counter for the clones.*/
 	static unsigned nr = 0;
@@ -417,23 +417,19 @@ static ir_entity *clone_method(quadruple_t *q) {
 	new_entity  = copy_entity_name(q->ent, clone_ident);
 
 	/* a cloned entity is always local */
-	set_entity_visibility(new_entity, visibility_local);
+	set_entity_visibility(new_entity, ir_visibility_local);
 
 	/* set a ld name here: Should we mangle this ? */
 	set_entity_ld_ident(new_entity, get_entity_ident(new_entity));
 
 	/* set a new type here. */
-	change_entity_type(q, new_entity, &nr);
+	change_entity_type(q, new_entity);
 
 	/* We need now a new ir_graph for our clone method. */
 	create_clone_proc_irg(new_entity, q);
 
 	/* We must set the atomic value of our "new_entity". */
 	sym.entity_p = new_entity;
-	rem = current_ir_graph;
-	current_ir_graph =  get_const_code_irg();
-	new_entity->value = new_SymConst(mode_P_code, sym, symconst_addr_ent);
-	current_ir_graph = rem;
 
 	/* The "new_entity" don't have this information. */
 	new_entity->attr.mtd_attr.param_access = NULL;
@@ -459,7 +455,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);
@@ -472,7 +468,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));
 }
 
@@ -533,7 +529,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) {
@@ -675,3 +671,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);
+}