From c95f47de2ccac176b992bfac14eb594ac9090a72 Mon Sep 17 00:00:00 2001 From: Michael Beck Date: Tue, 16 Oct 2007 12:52:42 +0000 Subject: [PATCH] - removed identical is_downconv() - used new ia32_skip_downconv() - add ia32_prefix to global function [r16232] --- ir/be/ia32/ia32_address_mode.c | 52 ++++------------------------- ir/be/ia32/ia32_transform.c | 60 +++++++++++++++++----------------- 2 files changed, 36 insertions(+), 76 deletions(-) diff --git a/ir/be/ia32/ia32_address_mode.c b/ir/be/ia32/ia32_address_mode.c index d27acd8ac..1a3352c3e 100644 --- a/ir/be/ia32/ia32_address_mode.c +++ b/ir/be/ia32/ia32_address_mode.c @@ -20,7 +20,7 @@ /** * @file * @brief This file contains functions for matching firm graphs for - * nodes that can be used as addressmode for x86 commands + * nodes that can be used as address mode for x86 instructions * @author Matthias Braun * @version $Id$ */ @@ -282,46 +282,6 @@ static INLINE int mode_needs_gp_reg(ir_mode *mode) { return mode_is_int(mode) || mode_is_reference(mode) || mode == mode_b; } -/** - * Check, if a given node is a Down-Conv, ie. a integer Conv - * from a mode with a mode with more bits to a mode with lesser bits. - * Moreover, we return only true if the node has not more than 1 user. - * - * @param node the node - * @return non-zero if node is a Down-Conv - */ -static int is_downconv(const ir_node *node) -{ - ir_mode *src_mode; - ir_mode *dest_mode; - - if(!is_Conv(node)) - return 0; - - /* we only want to skip the conv when we're the only user - * (not optimal but for now...) - */ - if(get_irn_n_edges(node) > 1) - return 0; - - src_mode = get_irn_mode(get_Conv_op(node)); - dest_mode = get_irn_mode(node); - return mode_needs_gp_reg(src_mode) - && mode_needs_gp_reg(dest_mode) - && get_mode_size_bits(dest_mode) < get_mode_size_bits(src_mode); -} - -/** - * Skip all Down-Conv's on a given node and return the resulting node. - */ -static ir_node *skip_downconv(ir_node *node) -{ - while(is_downconv(node)) - node = get_Conv_op(node); - - return node; -} - /* Create an address mode for a given node. */ void ia32_create_address_mode(ia32_address_t *addr, ir_node *node, int force) { @@ -348,7 +308,7 @@ void ia32_create_address_mode(ia32_address_t *addr, ir_node *node, int force) eat_imms = eat_immediates(addr, node, force); if(eat_imms != node) { if(force) { - eat_imms = skip_downconv(eat_imms); + eat_imms = ia32_skip_downconv(eat_imms); } res = 1; @@ -384,8 +344,8 @@ void ia32_create_address_mode(ia32_address_t *addr, ir_node *node, int force) ir_node *right = get_Add_right(node); if(force) { - left = skip_downconv(left); - right = skip_downconv(right); + left = ia32_skip_downconv(left); + right = ia32_skip_downconv(right); } assert(force || !is_immediate(addr, left, 0)); @@ -475,8 +435,8 @@ static void mark_non_address_nodes(ir_node *node, void *env) /* if we can do source address mode then we will never fold the add * into address mode */ if(!mode_is_float(get_irn_mode(node)) && (is_immediate_simple(right) || - (!use_source_address_mode(get_nodes_block(node), left, right) - && !use_source_address_mode(get_nodes_block(node), right, left)))) + (!ia32_use_source_address_mode(get_nodes_block(node), left, right) + && !ia32_use_source_address_mode(get_nodes_block(node), right, left)))) { break; } diff --git a/ir/be/ia32/ia32_transform.c b/ir/be/ia32/ia32_transform.c index 3e0ee5127..fab1d4e56 100644 --- a/ir/be/ia32/ia32_transform.c +++ b/ir/be/ia32/ia32_transform.c @@ -463,7 +463,7 @@ const char *ia32_get_old_node_name(ia32_code_gen_t *cg, ir_node *irn) { } #endif /* NDEBUG */ -int use_source_address_mode(ir_node *block, ir_node *node, ir_node *other) +int ia32_use_source_address_mode(ir_node *block, ir_node *node, ir_node *other) { ir_mode *mode = get_irn_mode(node); ir_node *load; @@ -589,6 +589,14 @@ static void set_am_attributes(ir_node *node, ia32_address_mode_t *am) set_ia32_commutative(node); } +/** + * Check, if a given node is a Down-Conv, ie. a integer Conv + * from a mode with a mode with more bits to a mode with lesser bits. + * Moreover, we return only true if the node has not more than 1 user. + * + * @param node the node + * @return non-zero if node is a Down-Conv + */ static int is_downconv(const ir_node *node) { ir_mode *src_mode; @@ -610,6 +618,15 @@ static int is_downconv(const ir_node *node) && get_mode_size_bits(dest_mode) < get_mode_size_bits(src_mode); } +/* Skip all Down-Conv's on a given node and return the resulting node. */ +ir_node *ia32_skip_downconv(ir_node *node) { + while (is_downconv(node)) + node = get_Conv_op(node); + + return node; +} + + typedef enum { match_commutative = 1 << 0, match_am_and_immediates = 1 << 1, @@ -653,17 +670,12 @@ static void match_arguments(ia32_address_mode_t *am, ir_node *block, use_am = 0; } - while(is_downconv(op2)) { - op2 = get_Conv_op(op2); - } - if(op1 != NULL) { - while(is_downconv(op1)) { - op1 = get_Conv_op(op1); - } - } + op2 = ia32_skip_downconv(op2); + if(op1 != NULL) + op1 = ia32_skip_downconv(op1); new_op2 = (use_immediate ? try_create_Immediate(op2, 0) : NULL); - if(new_op2 == NULL && use_am && use_source_address_mode(block, op2, op1)) { + if(new_op2 == NULL && use_am && ia32_use_source_address_mode(block, op2, op1)) { build_address(am, op2); new_op1 = (op1 == NULL ? NULL : be_transform_node(op1)); if(mode_is_float(mode)) { @@ -673,7 +685,7 @@ static void match_arguments(ia32_address_mode_t *am, ir_node *block, } am->op_type = ia32_AddrModeS; } else if(commutative && (new_op2 == NULL || use_am_and_immediates) && - use_am && use_source_address_mode(block, op1, op2)) { + use_am && ia32_use_source_address_mode(block, op1, op2)) { ir_node *noreg; build_address(am, op1); @@ -1024,12 +1036,8 @@ static ir_node *gen_Add(ir_node *node) { return gen_binop_x87_float(node, op1, op2, new_rd_ia32_vfadd, match_commutative); } - while(is_downconv(op2)) { - op2 = get_Conv_op(op2); - } - while(is_downconv(op1)) { - op1 = get_Conv_op(op1); - } + op2 = ia32_skip_downconv(op2); + op1 = ia32_skip_downconv(op1); /** * Rules for an Add: @@ -1414,10 +1422,7 @@ static ir_node *gen_Shl(ir_node *node) { ir_node *left = get_Shl_left(node); ir_node *right = get_Shl_right(node); - while(is_downconv(left)) { - left = get_Conv_op(left); - } - + left = ia32_skip_downconv(left); return gen_shift_binop(node, left, right, new_rd_ia32_Shl); } @@ -1611,9 +1616,7 @@ static ir_node *gen_Minus(ir_node *node) res = new_rd_ia32_vfchs(dbgi, irg, block, new_op); } } else { - while(is_downconv(op)) { - op = get_Conv_op(op); - } + op = ia32_skip_downconv(op); res = gen_unop(node, op, new_rd_ia32_Neg); } @@ -1633,10 +1636,7 @@ static ir_node *gen_Not(ir_node *node) { assert(get_irn_mode(node) != mode_b); /* should be lowered already */ assert (! mode_is_float(get_irn_mode(node))); - while(is_downconv(node)) { - node = get_Conv_op(node); - } - + node = ia32_skip_downconv(node); return gen_unop(node, op, new_rd_ia32_Not); } @@ -2412,8 +2412,8 @@ static ir_node *gen_Cmp(ir_node *node) /* we prefer the Test instruction where possible except cases where * we can use SourceAM */ - if(!use_source_address_mode(block, left, right) && - !use_source_address_mode(block, right, left)) { + if(!ia32_use_source_address_mode(block, left, right) && + !ia32_use_source_address_mode(block, right, left)) { res = try_create_Test(node); if(res != NULL) return res; -- 2.20.1