X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fproc_cloning.c;h=569be28e1c382e2e2bd75ba61f6307367dd1b132;hb=060aa4c91666063f9bb70aaa76f5c819d256a15f;hp=524989c498ad5482158a8b6b03dae223eb79eb07;hpb=800e4d37cd161f66232656944211a718ce007a4b;p=libfirm

diff --git a/ir/opt/proc_cloning.c b/ir/opt/proc_cloning.c
index 524989c49..569be28e1 100644
--- a/ir/opt/proc_cloning.c
+++ b/ir/opt/proc_cloning.c
@@ -82,7 +82,8 @@ typedef struct q_set {
  *
  * @return zero if they are identically, non-zero else
  */
-static int entry_cmp(const void *elt, const void *key) {
+static int entry_cmp(const void *elt, const void *key)
+{
 	const entry_t *e1 = elt;
 	const entry_t *e2 = key;
 
@@ -94,14 +95,16 @@ static int entry_cmp(const void *elt, const void *key) {
  *
  * @param entry  The element to be hashed.
  */
-static int hash_entry(const entry_t *entry) {
+static int hash_entry(const entry_t *entry)
+{
 	return HASH_PTR(entry->q.ent) ^ HASH_PTR(entry->q.tv) ^ (entry->q.pos * 9);
 }
 
 /**
  * Free memory associated with a quadruplet.
  */
-static void kill_entry(entry_t *entry) {
+static void kill_entry(entry_t *entry)
+{
 	if (entry->q.calls) {
 		DEL_ARR_F(entry->q.calls);
 		entry->q.calls = NULL;
@@ -115,7 +118,8 @@ static void kill_entry(entry_t *entry) {
  * @param callee  The entity of the callee
  * @param hmap    The quadruple-set containing the calls with constant parameters
  */
-static void process_call(ir_node *call, ir_entity *callee, q_set *hmap) {
+static void process_call(ir_node *call, ir_entity *callee, q_set *hmap)
+{
 	ir_type *mtp;
 	entry_t *key, *entry;
 	ir_node *call_param;
@@ -142,7 +146,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;
@@ -173,7 +177,8 @@ static void process_call(ir_node *call, ir_entity *callee, q_set *hmap) {
  * @param call   A ir_node to be checked.
  * @param env   The quadruple-set containing the calls with constant parameters
  */
-static void collect_irg_calls(ir_node *call, void *env) {
+static void collect_irg_calls(ir_node *call, void *env)
+{
 	q_set *hmap = env;
 	ir_node *call_ptr;
 	ir_entity *callee;
@@ -187,12 +192,12 @@ static void collect_irg_calls(ir_node *call, void *env) {
 
 		callee = get_Global_entity(call_ptr);
 
-		/* we can only clone calls to existing entities */
-		if (get_entity_visibility(callee) == visibility_external_allocated)
+		/* we don't know which function gets finally bound to a weak symbol */
+		if (get_entity_linkage(callee) & IR_LINKAGE_WEAK)
 			return;
 
-		/* we cannot clone calls to weak functions */
-		if (get_entity_additional_properties(callee) & mtp_property_weak)
+		/* we can only clone calls to existing entities */
+		if (get_entity_irg(callee) == NULL)
 			return;
 
 		process_call(call, callee, hmap);
@@ -208,7 +213,8 @@ static void collect_irg_calls(ir_node *call, void *env) {
  * @param pos The "pos" from our quadruplet.
  * @param nr  A counter for the clones.
  */
-static ident *get_clone_ident(ident *id, int pos, unsigned nr) {
+static ident *get_clone_ident(ident *id, int pos, unsigned nr)
+{
 	char clone_postfix[32];
 
 	snprintf(clone_postfix, sizeof(clone_postfix), "_cl_%d_%u", pos, nr);
@@ -224,7 +230,8 @@ static ident *get_clone_ident(ident *id, int pos, unsigned nr) {
  * @param irn  A node from the original method graph.
  * @param env  The clone graph.
  */
-static void copy_nodes(ir_node *irn, void *env) {
+static void copy_nodes(ir_node *irn, void *env)
+{
 	ir_node *arg, *irg_args, *irn_copy;
 	int proj_nr;
 	ir_graph *clone_irg = env;
@@ -251,7 +258,8 @@ static void copy_nodes(ir_node *irn, void *env) {
  * The copied nodes are set as link of their original nodes. The links of
  * "irn" predecessors are the predecessors of copied node.
  */
-static void set_preds(ir_node *irn, void *env) {
+static void set_preds(ir_node *irn, void *env)
+{
 	int i;
 	ir_node *irn_copy, *pred, *arg;
 	ir_graph *clone_irg = env;
@@ -296,7 +304,8 @@ static void set_preds(ir_node *irn, void *env) {
  * @param irg  irg that must be cloned.
  * @param pos  The position of the argument.
  */
-static ir_node *get_irg_arg(ir_graph *irg, int pos) {
+static ir_node *get_irg_arg(ir_graph *irg, int pos)
+{
 	ir_node *irg_args = get_irg_args(irg), *arg = NULL;
 	int i;
 
@@ -330,7 +339,8 @@ static ir_node *get_irg_arg(ir_graph *irg, int pos) {
  * @param ent The entity of the method that must be cloned.
  * @param q   Our quadruplet.
  */
-static void create_clone_proc_irg(ir_entity *ent, quadruple_t *q) {
+static void create_clone_proc_irg(ir_entity *ent, quadruple_t *q)
+{
 	ir_graph *method_irg, *clone_irg;
 	ir_node *arg, *const_arg;
 
@@ -368,19 +378,18 @@ 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) {
@@ -405,10 +414,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;
@@ -419,23 +428,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;
@@ -451,9 +456,9 @@ static ir_entity *clone_method(quadruple_t *q) {
  * @param new_entity  The entity of the cloned function.
  * @param pos         The position of the replaced parameter of this call.
  **/
-static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, int pos) {
+static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, int pos)
+{
 	ir_node **in;
-	ir_type *mtp;
 	int i, n_params, new_params = 0;
 	ir_node *callee;
 	symconst_symbol sym;
@@ -463,7 +468,6 @@ static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, int pos) {
 	sym.entity_p = new_entity;
 	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);
 	NEW_ARR_A(ir_node *, in, n_params - 1);
 
@@ -485,7 +489,8 @@ static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, int pos) {
  * @param cloned_ent    The entity of the new function that must be called
  *                      from the new Call.
  */
-static void exchange_calls(quadruple_t *q, ir_entity *cloned_ent) {
+static void exchange_calls(quadruple_t *q, ir_entity *cloned_ent)
+{
 	int pos = q->pos;
 	ir_node *new_call, *call;
 	int i;
@@ -506,7 +511,8 @@ static void exchange_calls(quadruple_t *q, ir_entity *cloned_ent) {
  * We save one instruction in every caller and param_weight instructions
  * in the callee.
  */
-static float calculate_weight(const entry_t *entry) {
+static float calculate_weight(const entry_t *entry)
+{
 	return ARR_LEN(entry->q.calls) *
 		(float)(get_method_param_weight(entry->q.ent, entry->q.pos) + 1);
 }
@@ -516,7 +522,8 @@ static float calculate_weight(const entry_t *entry) {
  * the next cloned entity may get invalid, so we have to check
  * them and may even update the list of heavy uses.
  */
-static void reorder_weights(q_set *hmap, float threshold) {
+static void reorder_weights(q_set *hmap, float threshold)
+{
 	entry_t **adr, *p, *entry;
 	int i, len;
 	ir_entity *callee;
@@ -588,7 +595,8 @@ restart:
  * call(..., Const, ...). If the weight is bigger than threshold,
  * clone the entity and fix the calls.
  */
-void proc_cloning(float threshold) {
+void proc_cloning(float threshold)
+{
 	entry_t *entry = NULL, *p;
 	ir_graph *irg;
 	int i;
@@ -686,7 +694,8 @@ struct pass_t {
 /**
  * Wrapper to run proc_cloning() as an ir_prog pass.
  */
-static int proc_cloning_wrapper(ir_prog *irp, void *context) {
+static int proc_cloning_wrapper(ir_prog *irp, void *context)
+{
 	struct pass_t *pass = context;
 
 	(void)irp;
@@ -695,7 +704,8 @@ static int proc_cloning_wrapper(ir_prog *irp, void *context) {
 }
 
 /* create a ir_prog pass */
-ir_prog_pass_t *proc_cloning_pass(const char *name, float threshold) {
+ir_prog_pass_t *proc_cloning_pass(const char *name, float threshold)
+{
 	struct pass_t *pass = XMALLOCZ(struct pass_t);
 
 	pass->threshold = threshold;