X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fopt_osr.c;h=275ee2e6914dad9c7106cd2fd26a69754eadf9ff;hb=64f5f0cf11fe4a0d4753060e45639604d725652d;hp=7144e18fed36bf2cc8c772549e11fdaccd1c5392;hpb=64b03ac67178882e7aae970ee8d8f55174ae4c3b;p=libfirm diff --git a/ir/opt/opt_osr.c b/ir/opt/opt_osr.c index 7144e18fe..275ee2e69 100644 --- a/ir/opt/opt_osr.c +++ b/ir/opt/opt_osr.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -22,15 +22,12 @@ * @brief Operator Strength Reduction. * @date 12.5.2006 * @author Michael Beck - * @version $Id$ - * @summary + * @brief * Implementation of the Operator Strength Reduction algorithm * by Keith D. Cooper, L. Taylor Simpson, Christopher A. Vick. * Extended version. */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif #include "adt/pdeq.h" #include "iroptimize.h" @@ -48,21 +45,23 @@ #include "set.h" #include "tv.h" #include "hashptr.h" +#include "util.h" #include "irtools.h" #include "irloop_t.h" #include "array.h" #include "firmstat.h" -#include "xmalloc.h" +#include "error.h" +#include "irpass_t.h" /** The debug handle. */ DEBUG_ONLY(static firm_dbg_module_t *dbg;) /** A scc. */ typedef struct scc { - ir_node *head; /**< the head of the list */ - tarval *init; /**< the init value iff only one exists. */ - tarval *incr; /**< the induction variable increment if only a single const exists. */ - unsigned code; /**< == iro_Add if +incr, iro_Sub if -incr, 0 if not analysed, iro_Bad else */ + ir_node *head; /**< the head of the list */ + ir_tarval *init; /**< the init value iff only one exists. */ + ir_tarval *incr; /**< the induction variable increment if only a single const exists. */ + unsigned code; /**< == iro_Add if +incr, iro_Sub if -incr, 0 if not analysed, iro_Bad else */ } scc; /** A node entry */ @@ -80,14 +79,15 @@ typedef struct node_entry { typedef struct iv_env { struct obstack obst; /**< an obstack for allocations */ ir_node **stack; /**< the node stack */ - int tos; /**< tos index */ + size_t tos; /**< tos index */ unsigned nextDFSnum; /**< the current DFS number */ unsigned POnum; /**< current post order number */ set *quad_map; /**< a map from (op, iv, rc) to node */ set *lftr_edges; /**< the set of lftr edges */ unsigned replaced; /**< number of replaced ops */ unsigned lftr_replaced; /**< number of applied linear function test replacements */ - unsigned flags; /**< additional flags */ + unsigned osr_flags; /**< additional flags steering the transformation */ + unsigned need_postpass; /**< set, if a post pass is needed to fix Add and Sub nodes */ /** Function called to process a SCC. */ void (*process_scc)(scc *pscc, struct iv_env *env); } iv_env; @@ -96,7 +96,7 @@ typedef struct iv_env { * An entry in the (op, node, node) -> node map. */ typedef struct quadruple_t { - ir_opcode code; /**< the opcode of the reduced operation */ + unsigned code; /**< the opcode of the reduced operation */ ir_node *op1; /**< the first operand the reduced operation */ ir_node *op2; /**< the second operand of the reduced operation */ @@ -109,7 +109,7 @@ typedef struct quadruple_t { typedef struct LFTR_edge { ir_node *src; /**< the source node */ ir_node *dst; /**< the destination node */ - ir_opcode code; /**< the opcode that must be applied */ + unsigned code; /**< the opcode that must be applied */ ir_node *rc; /**< the region const that must be applied */ } LFTR_edge; @@ -119,29 +119,40 @@ static ir_node *reduce(ir_node *orig, ir_node *iv, ir_node *rc, iv_env *env); /** * Compare two LFTR edges. */ -static int LFTR_cmp(const void *e1, const void *e2, size_t size) { - const LFTR_edge *l1 = e1; - const LFTR_edge *l2 = e2; +static int LFTR_cmp(const void *e1, const void *e2, size_t size) +{ + const LFTR_edge *l1 = (const LFTR_edge*)e1; + const LFTR_edge *l2 = (const LFTR_edge*)e2; (void) size; return l1->src != l2->src; -} +} /* LFTR_cmp */ /** * Find a LFTR edge. + * + * @param src the source node of the transition */ -static LFTR_edge *LFTR_find(ir_node *src, iv_env *env) { +static LFTR_edge *LFTR_find(ir_node *src, iv_env *env) +{ LFTR_edge key; key.src = src; - return set_find(env->lftr_edges, &key, sizeof(key), HASH_PTR(src)); -} + return set_find(LFTR_edge, env->lftr_edges, &key, sizeof(key), hash_ptr(src)); +} /* LFTR_find */ /** * Add a LFTR edge. + * + * @param src the source node of the edge + * @param dst the destination node of the edge + * @param code the opcode of the transformed transition + * @param rc the region const used in the transition + * @param env the environment */ -static void LFTR_add(ir_node *src, ir_node *dst, ir_opcode code, ir_node *rc, iv_env *env) { +static void LFTR_add(ir_node *src, ir_node *dst, unsigned code, ir_node *rc, iv_env *env) +{ LFTR_edge key; key.src = src; @@ -153,31 +164,37 @@ static void LFTR_add(ir_node *src, ir_node *dst, ir_opcode code, ir_node *rc, iv * There might be more than one edge here. This is rather bad * because we currently store only one. */ -// assert(LFTR_find(src, env) == NULL); - set_insert(env->lftr_edges, &key, sizeof(key), HASH_PTR(src)); -} + (void)set_insert(LFTR_edge, env->lftr_edges, &key, sizeof(key), hash_ptr(src)); +} /* LFTR_add */ /** - * Gets the node_entry of a node + * Gets the node_entry of a node. + * + * @param irn the node + * @param env the environment */ -static node_entry *get_irn_ne(ir_node *irn, iv_env *env) { - node_entry *e = get_irn_link(irn); +static node_entry *get_irn_ne(ir_node *irn, iv_env *env) +{ + node_entry *e = (node_entry*)get_irn_link(irn); - if (! e) { - e = obstack_alloc(&env->obst, sizeof(*e)); - memset(e, 0, sizeof(*e)); + if (e == NULL) { + e = OALLOCZ(&env->obst, node_entry); set_irn_link(irn, e); } return e; -} +} /* get_irn_ne */ /** - * Gets the scc from an IV. + * Gets the scc from an induction variable. + * + * @param iv any node of the induction variable + * @param env the environment */ -static scc *get_iv_scc(ir_node *iv, iv_env *env) { +static scc *get_iv_scc(ir_node *iv, iv_env *env) +{ node_entry *e = get_irn_ne(iv, env); return e->pscc; -} +} /* get_iv_scc */ /** * Check if irn is an IV. @@ -187,9 +204,10 @@ static scc *get_iv_scc(ir_node *iv, iv_env *env) { * * @returns the header if it is one, NULL else */ -static ir_node *is_iv(ir_node *irn, iv_env *env) { +static ir_node *is_iv(ir_node *irn, iv_env *env) +{ return get_irn_ne(irn, env)->header; -} +} /* is_iv */ /** * Check if irn is a region constant. @@ -198,22 +216,24 @@ static ir_node *is_iv(ir_node *irn, iv_env *env) { * @param irn the node to check * @param header_block the header block of the induction variable */ -static int is_rc(ir_node *irn, ir_node *header_block) { +static int is_rc(ir_node *irn, ir_node *header_block) +{ ir_node *block = get_nodes_block(irn); return (block != header_block) && block_dominates(block, header_block); -} +} /* is_rc */ /** * Set compare function for the quad set. */ -static int quad_cmp(const void *e1, const void *e2, size_t size) { - const quadruple_t *c1 = e1; - const quadruple_t *c2 = e2; +static int quad_cmp(const void *e1, const void *e2, size_t size) +{ + const quadruple_t *c1 = (const quadruple_t*)e1; + const quadruple_t *c2 = (const quadruple_t*)e2; (void) size; return c1->code != c2->code || c1->op1 != c2->op1 || c1->op2 != c2->op2; -} +} /* quad_cmp */ /** * Check if an reduced operation was already calculated. @@ -225,19 +245,19 @@ static int quad_cmp(const void *e1, const void *e2, size_t size) { * * @return the already reduced node or NULL if this operation is not yet reduced */ -static ir_node *search(ir_opcode code, ir_node *op1, ir_node *op2, iv_env *env) { +static ir_node *search(unsigned code, ir_node *op1, ir_node *op2, iv_env *env) +{ quadruple_t key, *entry; key.code = code; key.op1 = op1; key.op2 = op2; - entry = set_find(env->quad_map, &key, sizeof(key), - (code * 9) ^ HASH_PTR(op1) ^HASH_PTR(op2)); + entry = set_find(quadruple_t, env->quad_map, &key, sizeof(key), (code * 9) ^ hash_ptr(op1) ^ hash_ptr(op2)); if (entry) return entry->res; return NULL; -} +} /* search */ /** * Add an reduced operation. @@ -248,7 +268,8 @@ static ir_node *search(ir_opcode code, ir_node *op1, ir_node *op2, iv_env *env) * @param result the result of the reduced operation * @param env the environment */ -static void add(ir_opcode code, ir_node *op1, ir_node *op2, ir_node *result, iv_env *env) { +static void add(unsigned code, ir_node *op1, ir_node *op2, ir_node *result, iv_env *env) +{ quadruple_t key; key.code = code; @@ -256,9 +277,8 @@ static void add(ir_opcode code, ir_node *op1, ir_node *op2, ir_node *result, iv_ key.op2 = op2; key.res = result; - set_insert(env->quad_map, &key, sizeof(key), - (code * 9) ^ HASH_PTR(op1) ^HASH_PTR(op2)); -} + (void)set_insert(quadruple_t, env->quad_map, &key, sizeof(key), (code * 9) ^ hash_ptr(op1) ^ hash_ptr(op2)); +} /* add */ /** * Find a location where to place a bin-op whose operands are in @@ -271,12 +291,13 @@ static void add(ir_opcode code, ir_node *op1, ir_node *op2, ir_node *result, iv_ * that either block1 dominates block2 or vice versa. So, just return * the "smaller" one. */ -static ir_node *find_location(ir_node *block1, ir_node *block2) { +static ir_node *find_location(ir_node *block1, ir_node *block2) +{ if (block_dominates(block1, block2)) return block2; assert(block_dominates(block2, block1)); return block1; -} +} /* find_location */ /** * Create a node that executes an op1 code op1 operation. @@ -289,27 +310,26 @@ static ir_node *find_location(ir_node *block1, ir_node *block2) { * * @return the newly created node */ -static ir_node *do_apply(ir_opcode code, dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode) { - ir_graph *irg = current_ir_graph; +static ir_node *do_apply(unsigned code, dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode) +{ ir_node *result; ir_node *block = find_location(get_nodes_block(op1), get_nodes_block(op2)); switch (code) { case iro_Mul: - result = new_rd_Mul(db, irg, block, op1, op2, mode); + result = new_rd_Mul(db, block, op1, op2, mode); break; case iro_Add: - result = new_rd_Add(db, irg, block, op1, op2, mode); + result = new_rd_Add(db, block, op1, op2, mode); break; case iro_Sub: - result = new_rd_Sub(db, irg, block, op1, op2, mode); + result = new_rd_Sub(db, block, op1, op2, mode); break; default: - assert(0); - result = NULL; + panic("Unsupported opcode"); } return result; -} +} /* do_apply */ /** * The Apply operation. @@ -322,8 +342,9 @@ static ir_node *do_apply(ir_opcode code, dbg_info *db, ir_node *op1, ir_node *op * * @return the newly created node */ -static ir_node *apply(ir_node *header, ir_node *orig, ir_node *op1, ir_node *op2, iv_env *env) { - ir_opcode code = get_irn_opcode(orig); +static ir_node *apply(ir_node *header, ir_node *orig, ir_node *op1, ir_node *op2, iv_env *env) +{ + unsigned code = get_irn_opcode(orig); ir_node *result = search(code, op1, op2, env); if (result == NULL) { @@ -343,7 +364,7 @@ static ir_node *apply(ir_node *header, ir_node *orig, ir_node *op1, ir_node *op2 } } return result; -} +} /* apply */ /** * The Reduce operation. @@ -356,22 +377,31 @@ static ir_node *apply(ir_node *header, ir_node *orig, ir_node *op1, ir_node *op2 * * @return the reduced node */ -static ir_node *reduce(ir_node *orig, ir_node *iv, ir_node *rc, iv_env *env) { - ir_opcode code = get_irn_opcode(orig); +static ir_node *reduce(ir_node *orig, ir_node *iv, ir_node *rc, iv_env *env) +{ + unsigned code = get_irn_opcode(orig); ir_node *result = search(code, iv, rc, env); + /* check if we have already done this operation on the iv */ if (result == NULL) { node_entry *e, *iv_e; - int i, n; + int i; ir_mode *mode = get_irn_mode(orig); result = exact_copy(iv); - /* Beware: we must always create a new induction variable with the same mode - as the node we are replacing. Especially this means the mode might be changed - from P to I and back. This is always possible, because we have only Phi, Add - and Sub nodes. */ - set_irn_mode(result, mode); + if (get_irn_mode(result) != mode) { + /* + * Beware: we must always create a new induction variable with the same mode + * as the node we are replacing. Especially this means the mode might be changed + * from P to I and back. This is always possible, because we have only Phi, Add + * and Sub nodes. + * However, this might lead to AddIs(Iu,Is) which we must fix. The best way to do this + * seems to be a post-pass, or we might end with useless Conv's. + */ + set_irn_mode(result, mode); + env->need_postpass = 1; + } add(code, iv, rc, result, env); DB((dbg, LEVEL_3, " Created new %+F for %+F (%s %+F)\n", result, iv, get_irn_opname(orig), rc)); @@ -383,8 +413,7 @@ static ir_node *reduce(ir_node *orig, ir_node *iv, ir_node *rc, iv_env *env) { /* create the LFTR edge */ LFTR_add(iv, result, code, rc, env); - n = get_irn_arity(result); - for (i = 0; i < n; ++i) { + for (i = get_irn_arity(result) - 1; i >= 0; --i) { ir_node *o = get_irn_n(result, i); e = get_irn_ne(o, env); @@ -394,18 +423,18 @@ static ir_node *reduce(ir_node *orig, ir_node *iv, ir_node *rc, iv_env *env) { o = apply(iv_e->header, orig, o, rc, env); set_irn_n(result, i, o); } - } - else { + } else { DB((dbg, LEVEL_3, " Already Created %+F for %+F (%s %+F)\n", result, iv, get_irn_opname(orig), rc)); } return result; -} +} /* reduce */ /** * Update the scc for a newly created IV. */ -static void update_scc(ir_node *iv, node_entry *e, iv_env *env) { +static void update_scc(ir_node *iv, node_entry *e, iv_env *env) +{ scc *pscc = e->pscc; ir_node *header = e->header; waitq *wq = new_waitq(); @@ -414,7 +443,7 @@ static void update_scc(ir_node *iv, node_entry *e, iv_env *env) { pscc->head = NULL; waitq_put(wq, iv); do { - ir_node *irn = waitq_get(wq); + ir_node *irn = (ir_node*)waitq_get(wq); node_entry *ne = get_irn_ne(irn, env); int i; @@ -436,17 +465,20 @@ static void update_scc(ir_node *iv, node_entry *e, iv_env *env) { } while (! waitq_empty(wq)); del_waitq(wq); DB((dbg, LEVEL_2, "\n")); -} +} /* update_scc */ /** - * The Replace operation. + * The Replace operation. We found a node representing iv (+,-,*) rc + * that can be removed by replacing the induction variable iv by a new + * one that 'applies' the operation 'irn'. * * @param irn the node that will be replaced * @param iv the induction variable * @param rc the region constant * @param env the environment */ -static int replace(ir_node *irn, ir_node *iv, ir_node *rc, iv_env *env) { +static int replace(ir_node *irn, ir_node *iv, ir_node *rc, iv_env *env) +{ ir_node *result; DB((dbg, LEVEL_2, " Replacing %+F\n", irn)); @@ -455,25 +487,25 @@ static int replace(ir_node *irn, ir_node *iv, ir_node *rc, iv_env *env) { if (result != irn) { node_entry *e; - hook_strength_red(current_ir_graph, irn); + hook_strength_red(get_irn_irg(irn), irn); exchange(irn, result); e = get_irn_ne(result, env); if (e->pscc == NULL) { - e->pscc = obstack_alloc(&env->obst, sizeof(*e->pscc)); - memset(e->pscc, 0, sizeof(*e->pscc)); + e->pscc = OALLOCZ(&env->obst, scc); update_scc(result, e, env); } ++env->replaced; return 1; } return 0; -} +} /* replace */ #if 0 /** * check if a given node is a mul with 2, 4, 8 */ -static int is_x86_shift_const(ir_node *mul) { +static int is_x86_shift_const(ir_node *mul) +{ ir_node *rc; if (! is_Mul(mul)) @@ -482,7 +514,7 @@ static int is_x86_shift_const(ir_node *mul) { /* normalization put constants on the right side */ rc = get_Mul_right(mul); if (is_Const(rc)) { - tarval *tv = get_Const_tarval(rc); + ir_tarval *tv = get_Const_tarval(rc); if (tarval_is_long(tv)) { long value = get_tarval_long(tv); @@ -494,13 +526,17 @@ static int is_x86_shift_const(ir_node *mul) { } } return 0; -} +} /* is_x86_shift_const */ #endif /** * Check if an IV represents a counter with constant limits. + * + * @param iv any node of the induction variable + * @param env the environment */ -static int is_counter_iv(ir_node *iv, iv_env *env) { +static int is_counter_iv(ir_node *iv, iv_env *env) +{ node_entry *e = get_irn_ne(iv, env); scc *pscc = e->pscc; ir_node *have_init = NULL; @@ -557,22 +593,26 @@ static int is_counter_iv(ir_node *iv, iv_env *env) { pscc->incr = get_Const_tarval(have_incr); pscc->code = code; return code != iro_Bad; -} +} /* is_counter_iv */ /** * Check the users of an induction variable for register pressure. + * + * @param iv any node of the induction variable + * @param env the environment + * + * @return non-zero if the register pressure is estimated + * to not increase, zero else */ -static int check_users_for_reg_pressure(ir_node *iv, iv_env *env) { - ir_node *irn, *header; +static int check_users_for_reg_pressure(ir_node *iv, iv_env *env) +{ + ir_node *irn; ir_node *have_user = NULL; ir_node *have_cmp = NULL; node_entry *e = get_irn_ne(iv, env); scc *pscc = e->pscc; - header = e->header; for (irn = pscc->head; irn != NULL; irn = e->next) { - const ir_edge_t *edge; - foreach_out_edge(irn, edge) { ir_node *user = get_edge_src_irn(edge); node_entry *ne = get_irn_ne(user, env); @@ -614,7 +654,7 @@ static int check_users_for_reg_pressure(ir_node *iv, iv_env *env) { * * For now our capabilities for doing linear function test * are limited, so check if the iv has the right form: Only ONE - * phi, only one Add/Sub with a Const + * Phi, only one Add/Sub with a Const. */ if (! is_counter_iv(iv, env)) return 0; @@ -624,7 +664,7 @@ static int check_users_for_reg_pressure(ir_node *iv, iv_env *env) { * to do a linear function test replacement, so go on. */ return 1; -} +} /* check_users_for_reg_pressure */ /** * Check if a node can be replaced (+, -, *). @@ -634,10 +674,11 @@ static int check_users_for_reg_pressure(ir_node *iv, iv_env *env) { * * @return non-zero if irn should be Replace'd */ -static int check_replace(ir_node *irn, iv_env *env) { +static int check_replace(ir_node *irn, iv_env *env) +{ ir_node *left, *right, *iv, *rc; ir_op *op = get_irn_op(irn); - ir_opcode code = get_op_code(op); + unsigned code = get_op_code(op); ir_node *liv, *riv; switch (code) { @@ -660,7 +701,7 @@ static int check_replace(ir_node *irn, iv_env *env) { } if (iv) { - if (env->flags & osr_flag_keep_reg_pressure) { + if (env->osr_flags & osr_flag_keep_reg_pressure) { if (! check_users_for_reg_pressure(iv, env)) return 0; } @@ -671,7 +712,7 @@ static int check_replace(ir_node *irn, iv_env *env) { break; } return 0; -} +} /* check_replace */ /** * Check which SCC's are induction variables. @@ -679,7 +720,8 @@ static int check_replace(ir_node *irn, iv_env *env) { * @param pscc a SCC * @param env the environment */ -static void classify_iv(scc *pscc, iv_env *env) { +static void classify_iv(scc *pscc, iv_env *env) +{ ir_node *irn, *next, *header = NULL; node_entry *b, *h = NULL; int j, only_phi, num_outside; @@ -687,7 +729,7 @@ static void classify_iv(scc *pscc, iv_env *env) { /* find the header block for this scc */ for (irn = pscc->head; irn; irn = next) { - node_entry *e = get_irn_link(irn); + node_entry *e = (node_entry*)get_irn_link(irn); ir_node *block = get_nodes_block(irn); next = e->next; @@ -714,8 +756,26 @@ static void classify_iv(scc *pscc, iv_env *env) { next = e->next; switch (get_irn_opcode(irn)) { - case iro_Add: case iro_Sub: + only_phi = 0; + { + ir_node *left = get_Sub_left(irn); + node_entry *left_entry = get_irn_ne(left, env); + ir_node *right = get_Sub_right(irn); + node_entry *right_entry = get_irn_ne(right, env); + + if (left_entry->pscc != e->pscc || + (right_entry->pscc != e->pscc && !is_rc(right, header))) { + /* + * Not an induction variable. + * Region constant are only allowed on right hand side. + */ + goto fail; + } + } + break; + + case iro_Add: only_phi = 0; /* fall through */ case iro_Phi: @@ -776,25 +836,26 @@ fail: next = e->next; e->header = NULL; } -} +} /* classify_iv */ /** - * Process a SCC for the operator strength reduction. + * Process an SCC for the operator strength reduction. * * @param pscc the SCC * @param env the environment */ -static void process_scc(scc *pscc, iv_env *env) { +static void process_scc(scc *pscc, iv_env *env) +{ ir_node *head = pscc->head; - node_entry *e = get_irn_link(head); + node_entry *e = (node_entry*)get_irn_link(head); #ifdef DEBUG_libfirm { ir_node *irn, *next; DB((dbg, LEVEL_4, " SCC at %p:\n ", pscc)); - for (irn = pscc->head; irn; irn = next) { - node_entry *e = get_irn_link(irn); + for (irn = pscc->head; irn != NULL; irn = next) { + node_entry *e = (node_entry*)get_irn_link(irn); next = e->next; @@ -810,17 +871,21 @@ static void process_scc(scc *pscc, iv_env *env) { } else { classify_iv(pscc, env); } -} +} /* process_scc */ /** * If an SCC is a Phi only cycle, remove it. + * + * @param pscc an SCC that consists of Phi nodes only + * @param env the environment */ -static void remove_phi_cycle(scc *pscc, iv_env *env) { +static void remove_phi_cycle(scc *pscc, iv_env *env) +{ ir_node *irn, *next; int j; ir_node *out_rc; - /* check if this scc contains only Phi, Add or Sub nodes */ + /* check if this scc contains only Phi nodes */ out_rc = NULL; for (irn = pscc->head; irn; irn = next) { node_entry *e = get_irn_ne(irn, env); @@ -853,17 +918,18 @@ static void remove_phi_cycle(scc *pscc, iv_env *env) { exchange(irn, out_rc); } ++env->replaced; -} +} /* remove_phi_cycle */ /** - * Process a SCC for the Phi cycle removement. + * Process a SCC for the Phi cycle remove. * * @param pscc the SCC * @param env the environment */ -static void process_phi_only_scc(scc *pscc, iv_env *env) { +static void process_phi_only_scc(scc *pscc, iv_env *env) +{ ir_node *head = pscc->head; - node_entry *e = get_irn_link(head); + node_entry *e = (node_entry*)get_irn_link(head); #ifdef DEBUG_libfirm { @@ -871,7 +937,7 @@ static void process_phi_only_scc(scc *pscc, iv_env *env) { DB((dbg, LEVEL_4, " SCC at %p:\n ", pscc)); for (irn = pscc->head; irn; irn = next) { - node_entry *e = get_irn_link(irn); + node_entry *e = (node_entry*)get_irn_link(irn); next = e->next; @@ -883,7 +949,7 @@ static void process_phi_only_scc(scc *pscc, iv_env *env) { if (e->next != NULL) remove_phi_cycle(pscc, env); -} +} /* process_phi_only_scc */ /** @@ -892,20 +958,21 @@ static void process_phi_only_scc(scc *pscc, iv_env *env) { * @param env the environment * @param n the node to push */ -static void push(iv_env *env, ir_node *n) { +static void push(iv_env *env, ir_node *n) +{ node_entry *e; if (env->tos == ARR_LEN(env->stack)) { - int nlen = ARR_LEN(env->stack) * 2; + size_t nlen = ARR_LEN(env->stack) * 2; ARR_RESIZE(ir_node *, env->stack, nlen); } env->stack[env->tos++] = n; e = get_irn_ne(n, env); e->in_stack = 1; -} +} /* push */ /** - * pop a node from the stack + * Pop a node from the stack. * * @param env the environment * @@ -918,7 +985,7 @@ static ir_node *pop(iv_env *env) e->in_stack = 0; return n; -} +} /* pop */ /** * Do Tarjan's SCC algorithm and drive OSR. @@ -939,11 +1006,10 @@ static void dfs(ir_node *irn, iv_env *env) for (i = 0; i < n; ++i) { ir_node *pred = get_irn_n(irn, i); - if (irn_not_visited(pred)) + if (!irn_visited(pred)) dfs(pred, env); } - } - else { + } else { ir_node *block = get_nodes_block(irn); node->DFSnum = env->nextDFSnum++; @@ -951,7 +1017,7 @@ static void dfs(ir_node *irn, iv_env *env) push(env, irn); /* handle the block */ - if (irn_not_visited(block)) + if (!irn_visited(block)) dfs(block, env); n = get_irn_arity(irn); @@ -959,7 +1025,7 @@ static void dfs(ir_node *irn, iv_env *env) ir_node *pred = get_irn_n(irn, i); node_entry *o = get_irn_ne(pred, env); - if (irn_not_visited(pred)) { + if (!irn_visited(pred)) { dfs(pred, env); node->low = MIN(node->low, o->low); } @@ -967,10 +1033,9 @@ static void dfs(ir_node *irn, iv_env *env) node->low = MIN(o->DFSnum, node->low); } if (node->low == node->DFSnum) { - scc *pscc = obstack_alloc(&env->obst, sizeof(*pscc)); + scc *pscc = OALLOCZ(&env->obst, scc); ir_node *x; - memset(pscc, 0, sizeof(*pscc)); do { node_entry *e; @@ -984,7 +1049,7 @@ static void dfs(ir_node *irn, iv_env *env) env->process_scc(pscc, env); } } -} +} /* dfs */ /** * Do the DFS by starting at the End node of a graph. @@ -992,62 +1057,39 @@ static void dfs(ir_node *irn, iv_env *env) * @param irg the graph to process * @param env the environment */ -static void do_dfs(ir_graph *irg, iv_env *env) { - ir_graph *rem = current_ir_graph; - ir_node *end = get_irg_end(irg); - int i, n; +static void do_dfs(ir_graph *irg, iv_env *env) +{ + ir_node *end = get_irg_end(irg); + int i; - set_using_irn_visited(irg); + ir_reserve_resources(irg, IR_RESOURCE_IRN_VISITED); - current_ir_graph = irg; inc_irg_visited(irg); /* visit all visible nodes */ dfs(end, env); /* visit the keep-alives */ - n = get_End_n_keepalives(end); - for (i = 0; i < n; ++i) { + for (i = get_End_n_keepalives(end) - 1; i >= 0; --i) { ir_node *ka = get_End_keepalive(end, i); - if (irn_not_visited(ka)) + if (!irn_visited(ka)) dfs(ka, env); } - clear_using_irn_visited(irg); - - current_ir_graph = rem; -} + ir_free_resources(irg, IR_RESOURCE_IRN_VISITED); +} /* do_dfs */ /** * Post-block-walker: assign the post-order number. */ -static void assign_po(ir_node *block, void *ctx) { - iv_env *env = ctx; +static void assign_po(ir_node *block, void *ctx) +{ + iv_env *env = (iv_env*)ctx; node_entry *e = get_irn_ne(block, env); e->POnum = env->POnum++; -} - -/** - * Follows the LFTR edges and return the last node in the chain. - * - * @param irn the node that should be followed - * @param env the IV environment - * - * @note - * In the current implementation only the last edge is stored, so - * only one chain exists. That's why we might miss some opportunities. - */ -static ir_node *followEdges(ir_node *irn, iv_env *env) { - for (;;) { - LFTR_edge *e = LFTR_find(irn, env); - if (e) - irn = e->dst; - else - return irn; - } -} +} /* assign_po */ /** * Apply one LFTR edge operation. @@ -1066,11 +1108,13 @@ static ir_node *followEdges(ir_node *irn, iv_env *env) { * In the current implementation only the last edge is stored, so * only one chain exists. That's why we might miss some opportunities. */ -static ir_node *applyOneEdge(ir_node *iv, ir_node *rc, LFTR_edge *e, iv_env *env) { - if (env->flags & osr_flag_lftr_with_ov_check) { - tarval *tv_l, *tv_r, *tv, *tv_init, *tv_incr; +static ir_node *applyOneEdge(ir_node *iv, ir_node *rc, LFTR_edge *e, iv_env *env) +{ + if (env->osr_flags & osr_flag_lftr_with_ov_check) { + ir_tarval *tv_l, *tv_r, *tv, *tv_init, *tv_incr, *tv_end; tarval_int_overflow_mode_t ovmode; scc *pscc; + ir_graph *irg; if (! is_counter_iv(iv, env)) { DB((dbg, LEVEL_4, " not counter IV")); @@ -1079,6 +1123,11 @@ static ir_node *applyOneEdge(ir_node *iv, ir_node *rc, LFTR_edge *e, iv_env *env /* overflow can only be decided for Consts */ if (! is_Const(e->rc)) { + if (e->code == iro_Add && mode_is_reference(get_irn_mode(e->rc))) { + /* However we allow ONE Pointer Add, as pointer arithmetic with wrap + around is undefined anyway */ + return do_apply(e->code, NULL, rc, e->rc, get_irn_mode(e->rc)); + } DB((dbg, LEVEL_4, " = UNKNOWN (%+F)", e->rc)); return NULL; } @@ -1112,32 +1161,38 @@ static ir_node *applyOneEdge(ir_node *iv, ir_node *rc, LFTR_edge *e, iv_env *env DB((dbg, LEVEL_4, " + %+F", tv_r)); break; case iro_Sub: - tv = tarval_sub(tv_l, tv_r); - tv_init = tarval_sub(tv_init, tv_r); + tv = tarval_sub(tv_l, tv_r, NULL); + tv_init = tarval_sub(tv_init, tv_r, NULL); DB((dbg, LEVEL_4, " - %+F", tv_r)); break; default: - assert(0); - tv = tarval_bad; + panic("Unsupported opcode"); + } + + if (tv == tarval_bad || tv_init == tarval_bad) { + tarval_set_integer_overflow_mode(ovmode); + DB((dbg, LEVEL_4, " = OVERFLOW")); + return NULL; } if (pscc->code == iro_Add) { - tv = tarval_add(tv, tv_incr); + tv_end = tarval_add(tv, tv_incr); } else { assert(pscc->code == iro_Sub); - tv = tarval_sub(tv, tv_incr); + tv_end = tarval_sub(tv, tv_incr, NULL); } tarval_set_integer_overflow_mode(ovmode); - if (tv == tarval_bad || tv_init == tarval_bad) { + if (tv_end == tarval_bad) { DB((dbg, LEVEL_4, " = OVERFLOW")); return NULL; } - return new_r_Const(current_ir_graph, get_irn_n(rc, -1), get_tarval_mode(tv), tv); + irg = get_irn_irg(iv); + return new_r_Const(irg, tv); } - return do_apply(e->code, NULL, rc, e->rc, get_irn_mode(rc)); -} + return do_apply(e->code, NULL, rc, e->rc, get_irn_mode(e->dst)); +} /* applyOneEdge */ /** * Applies the operations represented by the LFTR edges to a @@ -1145,15 +1200,18 @@ static ir_node *applyOneEdge(ir_node *iv, ir_node *rc, LFTR_edge *e, iv_env *env * Return NULL if the transformation cannot be done safely without * an Overflow. * - * @param iv the IV node that starts the LFTR edge chain + * @param pIV points to the IV node that starts the LFTR edge chain + * after translation points to the new IV * @param rc the region constant that should be translated * @param env the IV environment * * @return the translated region constant or NULL * if the translation was not possible */ -static ir_node *applyEdges(ir_node *iv, ir_node *rc, iv_env *env) { - if (env->flags & osr_flag_lftr_with_ov_check) { +static ir_node *applyEdges(ir_node **pIV, ir_node *rc, iv_env *env) +{ + ir_node *iv = *pIV; + if (env->osr_flags & osr_flag_lftr_with_ov_check) { /* overflow can only be decided for Consts */ if (! is_counter_iv(iv, env)) { DB((dbg, LEVEL_4, "not counter IV\n", rc)); @@ -1168,28 +1226,29 @@ static ir_node *applyEdges(ir_node *iv, ir_node *rc, iv_env *env) { for (; rc;) { LFTR_edge *e = LFTR_find(iv, env); - if (e) { + if (e != NULL) { rc = applyOneEdge(iv, rc, e, env); iv = e->dst; - } - else + } else break; } DB((dbg, LEVEL_3, "\n")); + *pIV = iv; return rc; -} +} /* applyEdges */ /** * Walker, finds Cmp(iv, rc) or Cmp(rc, iv) * and tries to optimize them. */ -static void do_lftr(ir_node *cmp, void *ctx) { - iv_env *env = ctx; +static void do_lftr(ir_node *cmp, void *ctx) +{ + iv_env *env = (iv_env*)ctx; ir_node *left, *right, *liv, *riv; ir_node *iv, *rc; ir_node *nleft = NULL, *nright = NULL; - if (get_irn_op(cmp) != op_Cmp) + if (!is_Cmp(cmp)) return; left = get_Cmp_left(cmp); @@ -1200,18 +1259,14 @@ static void do_lftr(ir_node *cmp, void *ctx) { if (liv && is_rc(right, liv)) { iv = left; rc = right; - nright = applyEdges(iv, rc, env); - if (nright && nright != rc) { - nleft = followEdges(iv, env); - } + nright = applyEdges(&iv, rc, env); + nleft = iv; } else if (riv && is_rc(left, riv)) { iv = right; rc = left; - nleft = applyEdges(iv, rc, env); - if (nleft && nleft != rc) { - nright = followEdges(iv, env); - } + nleft = applyEdges(&iv, rc, env); + nright = iv; } if (nleft && nright) { @@ -1220,7 +1275,7 @@ static void do_lftr(ir_node *cmp, void *ctx) { set_Cmp_right(cmp, nright); ++env->lftr_replaced; } -} +} /* do_lftr */ /** * do linear function test replacement. @@ -1228,139 +1283,215 @@ static void do_lftr(ir_node *cmp, void *ctx) { * @param irg the graph that should be optimized * @param env the IV environment */ -static void lftr(ir_graph *irg, iv_env *env) { +static void lftr(ir_graph *irg, iv_env *env) +{ irg_walk_graph(irg, NULL, do_lftr, env); -} +} /* lftr */ -/** - * Pre-walker: set all node links to NULL and fix the - * block of Proj nodes. - */ -static void clear_and_fix(ir_node *irn, void *env) +/* Remove any Phi cycles with only one real input. */ +void remove_phi_cycles(ir_graph *irg) { - (void) env; - set_irn_link(irn, NULL); + iv_env env; - if (is_Proj(irn)) { - ir_node *pred = get_Proj_pred(irn); - set_nodes_block(irn, get_nodes_block(pred)); - } -} - -/* Performs Operator Strength Reduction for the passed graph. */ -void opt_osr(ir_graph *irg, unsigned flags) { - iv_env env; - ir_graph *rem; - int edges; - - if (! get_opt_strength_red()) { - /* only kill Phi cycles */ - remove_phi_cycles(irg); - return; - } + assure_irg_properties(irg, + IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE + | IR_GRAPH_PROPERTY_CONSISTENT_OUTS + | IR_GRAPH_PROPERTY_CONSISTENT_OUT_EDGES); - rem = current_ir_graph; - current_ir_graph = irg; - - FIRM_DBG_REGISTER(dbg, "firm.opt.osr"); + FIRM_DBG_REGISTER(dbg, "firm.opt.remove_phi"); - DB((dbg, LEVEL_1, "Doing Operator Strength Reduction for %+F\n", irg)); + DB((dbg, LEVEL_1, "Doing Phi cycle removement for %+F\n", irg)); obstack_init(&env.obst); env.stack = NEW_ARR_F(ir_node *, 128); env.tos = 0; env.nextDFSnum = 0; env.POnum = 0; - env.quad_map = new_set(quad_cmp, 64); - env.lftr_edges = new_set(LFTR_cmp, 64); + env.quad_map = NULL; + env.lftr_edges = NULL; env.replaced = 0; env.lftr_replaced = 0; - env.flags = flags; - env.process_scc = process_scc; + env.osr_flags = 0; + env.need_postpass = 0; + env.process_scc = process_phi_only_scc; /* Clear all links and move Proj nodes into the - the same block as it's predecessors. - This can improve the placement of new nodes. + * the same block as their predecessors. + * This can improve the placement of new nodes. */ - irg_walk_graph(irg, NULL, clear_and_fix, NULL); - - /* we need dominance */ - assure_doms(irg); - - edges = edges_assure(irg); + irg_walk_graph(irg, NULL, firm_clear_link, NULL); /* calculate the post order number for blocks. */ - irg_block_edges_walk(get_irg_start_block(irg), NULL, assign_po, &env); + irg_out_block_walk(get_irg_start_block(irg), NULL, assign_po, &env); /* calculate the SCC's and drive OSR. */ + ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK); do_dfs(irg, &env); + ir_free_resources(irg, IR_RESOURCE_IRN_LINK); if (env.replaced) { - /* try linear function test replacements */ - //lftr(irg, &env); // currently buggy :-( - (void) lftr; - - set_irg_outs_inconsistent(irg); - DB((dbg, LEVEL_1, "Replacements: %u + %u (lftr)\n\n", env.replaced, env.lftr_replaced)); + DB((dbg, LEVEL_1, "remove_phi_cycles: %u Cycles removed\n\n", + env.replaced)); } - del_set(env.lftr_edges); - del_set(env.quad_map); DEL_ARR_F(env.stack); obstack_free(&env.obst, NULL); - if (! edges) - edges_deactivate(irg); - - current_ir_graph = rem; + confirm_irg_properties(irg, IR_GRAPH_PROPERTIES_CONTROL_FLOW); } -/* Remove any Phi cycles with only one real input. */ -void remove_phi_cycles(ir_graph *irg) { - iv_env env; - ir_graph *rem; +ir_graph_pass_t *remove_phi_cycles_pass(const char *name) +{ + return def_graph_pass(name ? name : "remove_phi_cycles", remove_phi_cycles); +} /* remove_phi_cycles_pass */ + +/** + * Post-walker: fix Add and Sub nodes that where results of I<->P conversions. + */ +static void fix_adds_and_subs(ir_node *irn, void *ctx) +{ + (void) ctx; - rem = current_ir_graph; - current_ir_graph = irg; + if (is_Add(irn)) { + ir_mode *mode = get_irn_mode(irn); - FIRM_DBG_REGISTER(dbg, "firm.opt.remove_phi"); + if (mode_is_int(mode)) { + ir_node *pred; - DB((dbg, LEVEL_1, "Doing Phi cycle removement for %+F\n", irg)); + pred = get_Add_left(irn); + if (get_irn_mode(pred) != mode) { + ir_node *block = get_nodes_block(pred); + + pred = new_r_Conv(block, pred, mode); + set_Add_left(irn, pred); + } + pred = get_Add_right(irn); + if (get_irn_mode(pred) != mode) { + ir_node *block = get_nodes_block(pred); + + pred = new_r_Conv(block, pred, mode); + set_Add_right(irn, pred); + } + } + } else if (is_Sub(irn)) { + ir_mode *mode = get_irn_mode(irn); + + if (mode_is_int(mode)) { + ir_node *left = get_Sub_left(irn); + ir_node *right = get_Sub_right(irn); + ir_mode *l_mode = get_irn_mode(left); + ir_mode *r_mode = get_irn_mode(right); + + if (mode_is_int(l_mode) && mode_is_int(r_mode)) { + if (l_mode != mode) { + ir_node *block = get_nodes_block(left); + + left = new_r_Conv(block, left, mode); + set_Sub_left(irn, left); + } + if (r_mode != mode) { + ir_node *block = get_nodes_block(right); + + right = new_r_Conv(block, right, mode); + set_Sub_right(irn, right); + } + } + } else if (mode_is_reference(mode)) { + ir_node *left = get_Sub_left(irn); + ir_node *right = get_Sub_right(irn); + ir_mode *l_mode = get_irn_mode(left); + ir_mode *r_mode = get_irn_mode(right); + if (mode_is_int(l_mode)) { + /* Usually, Sub(I*,P) is an error, hence the verifier rejects it. + * However, it is correct in this case, so add Conv to make verifier happy. */ + ir_node *block = get_nodes_block(right); + ir_node *lconv = new_r_Conv(block, left, r_mode); + assert(mode_is_reference(r_mode)); + set_Sub_left(irn, lconv); + } + } + } +} /* fix_adds_and_subs */ + +/* Performs Operator Strength Reduction for the passed graph. */ +void opt_osr(ir_graph *irg, unsigned flags) +{ + iv_env env; + + FIRM_DBG_REGISTER(dbg, "firm.opt.osr"); + + assure_irg_properties(irg, + IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE + | IR_GRAPH_PROPERTY_CONSISTENT_OUTS + | IR_GRAPH_PROPERTY_CONSISTENT_OUT_EDGES); + + DB((dbg, LEVEL_1, "Doing Operator Strength Reduction for %+F\n", irg)); obstack_init(&env.obst); env.stack = NEW_ARR_F(ir_node *, 128); env.tos = 0; env.nextDFSnum = 0; env.POnum = 0; - env.quad_map = NULL; - env.lftr_edges = NULL; + env.quad_map = new_set(quad_cmp, 64); + env.lftr_edges = new_set(LFTR_cmp, 64); env.replaced = 0; env.lftr_replaced = 0; - env.flags = 0; - env.process_scc = process_phi_only_scc; + env.osr_flags = flags; + env.need_postpass = 0; + env.process_scc = process_scc; /* Clear all links and move Proj nodes into the - the same block as it's predecessors. - This can improve the placement of new nodes. + * the same block as its predecessors. + * This can improve the placement of new nodes. */ - irg_walk_graph(irg, NULL, clear_and_fix, NULL); + irg_walk_graph(irg, NULL, firm_clear_link, NULL); - /* we need outs for calculating the post order */ - assure_irg_outs(irg); - - /* calculate the post order number for blocks. */ - irg_out_block_walk(get_irg_start_block(irg), NULL, assign_po, &env); + irg_block_edges_walk(get_irg_start_block(irg), NULL, assign_po, &env); /* calculate the SCC's and drive OSR. */ + ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK); do_dfs(irg, &env); if (env.replaced) { - set_irg_outs_inconsistent(irg); - DB((dbg, LEVEL_1, "remove_phi_cycles: %u Cycles removed\n\n", env.replaced)); + if (env.need_postpass) + irg_walk_graph(irg, NULL, fix_adds_and_subs, &env); + + /* try linear function test replacements */ + lftr(irg, &env); + (void)lftr; + + DB((dbg, LEVEL_1, "Replacements: %u + %u (lftr)\n\n", env.replaced, env.lftr_replaced)); } + ir_free_resources(irg, IR_RESOURCE_IRN_LINK); + del_set(env.lftr_edges); + del_set(env.quad_map); DEL_ARR_F(env.stack); obstack_free(&env.obst, NULL); - current_ir_graph = rem; + confirm_irg_properties(irg, IR_GRAPH_PROPERTIES_NONE); } + +typedef struct pass_t { + ir_graph_pass_t pass; + unsigned flags; +} pass_t; + +/** +* Wrapper for running opt_osr() as an ir_graph pass. +*/ +static int pass_wrapper(ir_graph *irg, void *context) +{ + pass_t *pass = (pass_t*)context; + opt_osr(irg, pass->flags); + return 0; +} /* pass_wrapper */ + +ir_graph_pass_t *opt_osr_pass(const char *name, unsigned flags) +{ + pass_t *pass = XMALLOCZ(pass_t); + + pass->flags = flags; + return def_graph_pass_constructor( + &pass->pass, name ? name : "osr", pass_wrapper); +} /* opt_osr_pass */