X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fppc32%2Fppc32_transform.c;h=66e21bf6d79555cf9d8ffb0d64afb0bb9f83ef3a;hb=8d07d17eb2ade0b6b4aef0ebd68d6af3cc368b06;hp=055f29ff75bbffb83fc18002790329969cfa7a3c;hpb=ea64ddabccc512b21b425e4d89fda5e4ffe124a6;p=libfirm diff --git a/ir/be/ppc32/ppc32_transform.c b/ir/be/ppc32/ppc32_transform.c index 055f29ff7..66e21bf6d 100644 --- a/ir/be/ppc32/ppc32_transform.c +++ b/ir/be/ppc32/ppc32_transform.c @@ -1,6 +1,28 @@ -/* The codegenerator (transform FIRM into ppc FIRM) */ -/* $Id$ */ +/* + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * + * This file is part of libFirm. + * + * This file may be distributed and/or modified under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation and appearing in the file LICENSE.GPL included in the + * packaging of this file. + * + * Licensees holding valid libFirm Professional Edition licenses may use + * this file in accordance with the libFirm Commercial License. + * Agreement provided with the Software. + * + * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE + * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE. + */ +/** + * @file + * @brief The codegenerator (transform FIRM into ppc FIRM) + * @author Moritz Kroll, Jens Mueller + * @version $Id$ + */ #ifdef HAVE_CONFIG_H #include "config.h" #endif @@ -13,25 +35,24 @@ #include "iredges_t.h" #include "irvrfy.h" #include "ircons.h" -#include "dbginfo.h" #include "iropt_t.h" +#include "irprintf.h" #include "debug.h" #include "../benode_t.h" #include "bearch_ppc32_t.h" #include "ppc32_nodes_attr.h" -#include "../arch/archop.h" /* we need this for Min and Max nodes */ +#include "archop.h" #include "ppc32_transform.h" #include "ppc32_new_nodes.h" #include "ppc32_map_regs.h" #include "gen_ppc32_regalloc_if.h" -extern pset *symbol_pset; extern ir_op *get_op_Mulh(void); -int is_direct_entity(entity *ent); +int is_direct_entity(ir_entity *ent); ir_mode* ppc32_mode_Cond = NULL; @@ -56,17 +77,17 @@ ir_mode *get_ppc32_mode_Cond(void) { if (ppc32_mode_Cond) return ppc32_mode_Cond; else { - ppc32_mode_Cond = new_ir_mode("mode_Cond", irms_character, 4, 0, irma_none, 0); + ppc32_mode_Cond = new_ir_mode("mode_Cond", irms_int_number, 4, 0, irma_none, 0); return ppc32_mode_Cond; } } /** - * Calculates the modecode with size, sort and signed attributes + * Calculates the ir_modecode with size, sort and signed attributes */ -modecode get_nice_modecode(ir_mode *irmode) +ir_modecode get_nice_modecode(ir_mode *irmode) { - modecode mode = irm_max; + ir_modecode mode = irm_max; int sign = mode_is_signed(irmode); int bits = get_mode_size_bits(irmode); if(mode_is_int(irmode)) @@ -221,11 +242,12 @@ int is_16bit_unsigned_const(ir_node *node) * Creates an ppc Add. * * @param env The transformation environment - * @param op1 first operator - * @param op2 second operator * @return the created ppc Add node */ -static ir_node *gen_Add(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_Add(ppc32_transform_env_t *env) { + ir_node *op1 = get_Add_left(env->irn); + ir_node *op2 = get_Add_right(env->irn); + switch(get_nice_modecode(env->mode)){ case irm_D: return new_rd_ppc32_fAdd(env->dbg, env->irg, env->block, op1, op2, env->mode); @@ -258,23 +280,20 @@ static ir_node *gen_Add(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) default: fprintf(stderr, "Mode for Add not supported: %s\n", get_mode_name(env->mode)); assert(0); - return 0; + return NULL; } } - - /** * Creates an ppc Mul. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Mul node */ -static ir_node *gen_Mul(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_Mul(ppc32_transform_env_t *env) { + ir_node *op1 = get_Mul_left(env->irn); + ir_node *op2 = get_Mul_right(env->irn); + switch(get_nice_modecode(env->mode)){ case irm_D: return new_rd_ppc32_fMul(env->dbg, env->irg, env->block, op1, op2, env->mode); @@ -292,21 +311,20 @@ static ir_node *gen_Mul(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) default: fprintf(stderr, "Mode for Mul not supported: %s\n", get_mode_name(env->mode)); assert(0); - return 0; + return NULL; } } /** * Creates an ppc Mulh. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Mulh node */ -static ir_node *gen_Mulh(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_Mulh(ppc32_transform_env_t *env) { + ir_node *op1 = get_irn_n(env->irn, 0); + ir_node *op2 = get_irn_n(env->irn, 1); + switch(get_nice_modecode(env->mode)){ case irm_Is: case irm_Hs: @@ -324,70 +342,59 @@ static ir_node *gen_Mulh(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) default: fprintf(stderr, "Mode for Mulh not supported: %s\n", get_mode_name(env->mode)); assert(0); - return 0; + return NULL; } } - /** * Creates an ppc And. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc And node */ -static ir_node *gen_And(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_And(ppc32_transform_env_t *env) { + ir_node *op1 = get_And_left(env->irn); + ir_node *op2 = get_And_right(env->irn); + return new_rd_ppc32_And(env->dbg, env->irg, env->block, op1, op2, env->mode); } - - /** * Creates an ppc Or. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Or node */ -static ir_node *gen_Or(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_Or(ppc32_transform_env_t *env) { + ir_node *op1 = get_Or_left(env->irn); + ir_node *op2 = get_Or_right(env->irn); + return new_rd_ppc32_Or(env->dbg, env->irg, env->block, op1, op2, env->mode); } - - /** * Creates an ppc Xor. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Xor node */ -static ir_node *gen_Eor(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_Eor(ppc32_transform_env_t *env) { + ir_node *op1 = get_Eor_left(env->irn); + ir_node *op2 = get_Eor_right(env->irn); + return new_rd_ppc32_Xor(env->dbg, env->irg, env->block, op1, op2, env->mode); } - - /** * Creates an ppc Sub. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Sub node */ -static ir_node *gen_Sub(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_Sub(ppc32_transform_env_t *env) { + ir_node *op1 = get_Sub_left(env->irn); + ir_node *op2 = get_Sub_right(env->irn); + switch(get_nice_modecode(env->mode)){ case irm_D: return new_rd_ppc32_fSub(env->dbg, env->irg, env->block, op1, op2, env->mode); @@ -405,23 +412,20 @@ static ir_node *gen_Sub(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) default: fprintf(stderr, "Mode for Sub not supported: %s\n", get_mode_name(env->mode)); assert(0); - return 0; + return NULL; } } - - /** * Creates an ppc floating Div. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc fDiv node */ -static ir_node *gen_Quot(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_Quot(ppc32_transform_env_t *env) { + ir_node *op1 = get_Quot_left(env->irn); + ir_node *op2 = get_Quot_right(env->irn); + switch(get_nice_modecode(env->mode)){ case irm_D: return new_rd_ppc32_fDiv(env->dbg, env->irg, env->block, op1, op2, env->mode); @@ -431,32 +435,21 @@ static ir_node *gen_Quot(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) default: fprintf(stderr, "Mode for Quot not supported: %s\n", get_mode_name(env->mode)); assert(0); - return 0; + return NULL; } } - /** * Creates an ppc integer Div. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Div node */ -static ir_node *gen_Div(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { - ir_node *proj_div = NULL; - const ir_edge_t *edge; - - foreach_out_edge(env->irn, edge) - { - if (is_Proj(edge->src) && get_Proj_proj(edge->src) == pn_DivMod_res_div) - proj_div = edge->src; - } +static ir_node *gen_Div(ppc32_transform_env_t *env) { + ir_node *op1 = get_Div_left(env->irn); + ir_node *op2 = get_Div_right(env->irn); - switch(get_nice_modecode(get_irn_mode(proj_div))){ + switch(get_nice_modecode(get_irn_mode(op1))){ case irm_Is: case irm_Hs: case irm_Bs: @@ -468,23 +461,21 @@ static ir_node *gen_Div(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) return new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T); default: - fprintf(stderr, "Mode for Div not supported: %s\n", get_mode_name(get_irn_mode(proj_div))); + fprintf(stderr, "Mode for Div not supported: %s\n", get_mode_name(get_irn_mode(op1))); assert(0); - return 0; + return NULL; } } /** * Creates an ppc integer Div and Mod. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Div node */ -static ir_node *gen_DivMod(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_DivMod(ppc32_transform_env_t *env) { + ir_node *op1 = get_DivMod_left(env->irn); + ir_node *op2 = get_DivMod_right(env->irn); ir_node *proj_div = NULL, *proj_mod = NULL; ir_node *div_result; const ir_edge_t *edge; @@ -551,14 +542,12 @@ static ir_node *gen_DivMod(ppc32_transform_env_t *env, ir_node *op1, ir_node *op /** * Creates an ppc integer Mod. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Mod result node */ -static ir_node *gen_Mod(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_Mod(ppc32_transform_env_t *env) { + ir_node *op1 = get_Mod_left(env->irn); + ir_node *op2 = get_Mod_right(env->irn); ir_node *proj_div = NULL, *proj_mod = NULL; ir_node *div_result; ir_mode *res_mode; @@ -567,7 +556,7 @@ static ir_node *gen_Mod(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) proj_mod = get_succ_Proj(env->irn, pn_Mod_res); - assert(proj_mod!=NULL); + assert(proj_mod != NULL); res_mode = get_irn_mode(proj_mod); switch(get_nice_modecode(res_mode)) @@ -587,7 +576,7 @@ static ir_node *gen_Mod(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) default: fprintf(stderr, "Mode for Mod not supported: %s\n", get_mode_name(res_mode)); assert(0); - return 0; + return NULL; } @@ -598,23 +587,19 @@ static ir_node *gen_Mod(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) exchange(proj_mod, mod_result); - - return div_result; } - /** * Creates an ppc Shl. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Shl node */ -static ir_node *gen_Shl(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_Shl(ppc32_transform_env_t *env) { + ir_node *op1 = get_Shl_left(env->irn); + ir_node *op2 = get_Shl_right(env->irn); + if(is_ppc32_Const(op2)) { ir_node *shift = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode); @@ -627,19 +612,16 @@ static ir_node *gen_Shl(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) return new_rd_ppc32_Slw(env->dbg, env->irg, env->block, op1, op2, env->mode); } - - /** * Creates an ppc Srw. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Shr node */ -static ir_node *gen_Shr(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_Shr(ppc32_transform_env_t *env) { + ir_node *op1 = get_Shr_left(env->irn); + ir_node *op2 = get_Shr_right(env->irn); + if(is_ppc32_Const(op2)) { ir_node *shift = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode); @@ -652,24 +634,23 @@ static ir_node *gen_Shr(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) return new_rd_ppc32_Srw(env->dbg, env->irg, env->block, op1, op2, env->mode); } - /** * Creates an ppc Sraw. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Sraw node */ -static ir_node *gen_Shrs(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_Shrs(ppc32_transform_env_t *env) { + ir_node *op1 = get_Shrs_left(env->irn); + ir_node *op2 = get_Shrs_right(env->irn); + if(is_ppc32_Const(op2)) { ir_node *shift = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op1, env->mode); tarval *tv_const = get_ppc32_constant_tarval(op2); int sh = get_tarval_long(tv_const); assert(0<=sh && sh<=31); + (void) sh; set_ppc32_constant_tarval(shift, tv_const); set_ppc32_offset_mode(shift, ppc32_ao_None); return shift; @@ -677,18 +658,16 @@ static ir_node *gen_Shrs(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) return new_rd_ppc32_Sraw(env->dbg, env->irg, env->block, op1, op2, env->mode); } - /** - * Creates an ppc RotL. + * Creates an ppc Rotl. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode - * @return the created ppc RotL node + * @param env The transformation environment + * @return the created ppc Rotl node */ -static ir_node *gen_Rot(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_Rotl(ppc32_transform_env_t *env) { + ir_node *op1 = get_Rotl_left(env->irn); + ir_node *op2 = get_Rotl_right(env->irn); + if(is_ppc32_Const(op2)) { ir_node *rot = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode); @@ -701,18 +680,16 @@ static ir_node *gen_Rot(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) return new_rd_ppc32_Rlwnm(env->dbg, env->irg, env->block, op1, op2, env->mode); } - /** * Creates an ppc Cmp. * - * @param dbg firm node dbg - * @param block the block the new node should belong to - * @param op1 first operator - * @param op2 second operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Cmp node */ -static ir_node *gen_Cmp(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) { +static ir_node *gen_Cmp(ppc32_transform_env_t *env) { + ir_node *op1 = get_Cmp_left(env->irn); + ir_node *op2 = get_Cmp_right(env->irn); + const ir_edge_t *edge; foreach_out_edge(env->irn, edge) { @@ -755,18 +732,15 @@ static ir_node *gen_Cmp(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) } } - /** * Transforms a Minus node. * - * @param mod the debug module - * @param block the block the new node should belong to - * @param node the ir Minus node - * @param op operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Minus node */ -static ir_node *gen_Minus(ppc32_transform_env_t *env, ir_node *op) { +static ir_node *gen_Minus(ppc32_transform_env_t *env) { + ir_node *op = get_Minus_op(env->irn); + switch(get_nice_modecode(env->mode)){ case irm_D: case irm_F: @@ -783,24 +757,18 @@ static ir_node *gen_Minus(ppc32_transform_env_t *env, ir_node *op) { default: fprintf(stderr, "Mode for Neg not supported: %s\n", get_mode_name(env->mode)); assert(0); - return 0; + return NULL; } } - - /** * Transforms a Not node. * - * @param mod the debug module - * @param block the block the new node should belong to - * @param node the ir Not node - * @param op operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Not node */ -static ir_node *gen_Not(ppc32_transform_env_t *env, ir_node *op) { - return new_rd_ppc32_Not(env->dbg, env->irg, env->block, op, env->mode); +static ir_node *gen_Not(ppc32_transform_env_t *env) { + return new_rd_ppc32_Not(env->dbg, env->irg, env->block, get_Not_op(env->irn), env->mode); } @@ -818,18 +786,15 @@ static ir_node *own_gen_Andi_dot_lo16(ppc32_transform_env_t *env, ir_node *op, i /** * Transforms a Conv node. * - * @param mod the debug module - * @param block the block the new node should belong to - * @param node the ir Conv node - * @param op operator - * @param mode node mode + * @param env The transformation environment * @return the created ppc Conv node */ -static ir_node *gen_Conv(ppc32_transform_env_t *env, ir_node *op) { - modecode from_mode=get_nice_modecode(get_irn_mode(get_irn_n(env->irn,0))); - modecode to_mode=get_nice_modecode(env->mode); +static ir_node *gen_Conv(ppc32_transform_env_t *env) { + ir_node *op = get_Conv_op(env->irn); + ir_modecode from_mode=get_nice_modecode(get_irn_mode(op)); + ir_modecode to_mode=get_nice_modecode(env->mode); -#define SKIP return get_irn_n(env->irn, 0) +#define SKIP return op if(from_mode == to_mode) SKIP; @@ -922,23 +887,19 @@ static ir_node *gen_Conv(ppc32_transform_env_t *env, ir_node *op) { fprintf(stderr, "Mode for Conv not supported: %s -> %s\n", get_mode_name(get_irn_mode(get_irn_n(env->irn,0))),get_mode_name(env->mode)); assert(0); - return 0; -} + return NULL; #undef SKIP - +} /** * Transforms an Abs node. * - * @param mod the debug module - * @param block the block the new node should belong to - * @param node the ir Not node - * @param op operator - * @param mode node mode + * @param env The transformation environment * @return the ppc node generating the absolute value */ -static ir_node *gen_Abs(ppc32_transform_env_t *env, ir_node *op) { +static ir_node *gen_Abs(ppc32_transform_env_t *env) { + ir_node *op = get_Abs_op(env->irn); int shift = 7; ir_node *n1,*n2; @@ -951,7 +912,7 @@ static ir_node *gen_Abs(ppc32_transform_env_t *env, ir_node *op) { shift += 16; case irm_Hs: shift += 8; - case irm_Bs: ; + case irm_Bs: n1 = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op, env->mode); set_ppc32_constant_tarval(n1, new_tarval_from_long(shift, mode_Is)); set_ppc32_offset_mode(n1, ppc32_ao_None); @@ -962,17 +923,13 @@ static ir_node *gen_Abs(ppc32_transform_env_t *env, ir_node *op) { } fprintf(stderr, "Mode for Abs not supported: %s\n", get_mode_name(env->mode)); assert(0); - return 0; + return NULL; } /** * Transforms an Cond node. * - * @param mod the debug module - * @param block the block the new node should belong to - * @param node the ir Not node - * @param op operator - * @param mode node mode + * @param env The transformation environment * @return a ppc branch node */ static ir_node *gen_Cond(ppc32_transform_env_t *env) { @@ -996,17 +953,12 @@ static ir_node *gen_Cond(ppc32_transform_env_t *env) { return switch_node; } - } /** * Transforms an Unknown node. * - * @param mod the debug module - * @param block the block the new node should belong to - * @param node the ir Not node - * @param op operator - * @param mode node mode + * @param env The transformation environment * @return a ppc Unknown node */ static ir_node *gen_Unknown(ppc32_transform_env_t *env) { @@ -1033,7 +985,7 @@ static ir_node *ldst_insert_const(ir_node *ptr, tarval **ptv, ident **pid, ppc32 } else if(is_ppc32_SymConst(ptr)) { - entity *ent = get_ppc32_frame_entity(ptr); + ir_entity *ent = get_ppc32_frame_entity(ptr); if(is_direct_entity(ent)) { id_symconst = get_entity_ident(ent); @@ -1048,10 +1000,7 @@ static ir_node *ldst_insert_const(ir_node *ptr, tarval **ptv, ident **pid, ppc32 /** * Transforms a Load. * - * @param mod the debug module - * @param block the block the new node should belong to - * @param node the ir Load node - * @param mode node mode + * @param env The transformation environment * @return the created ppc Load node */ static ir_node *gen_Load(ppc32_transform_env_t *env) { @@ -1065,13 +1014,13 @@ static ir_node *gen_Load(ppc32_transform_env_t *env) { loadptr = ldst_insert_const(loadptr, &tv_const, &id_symconst, env); switch(get_nice_modecode(mode)){ case irm_Bu: - load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode); + load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node)); break; case irm_Bs: { ir_node *proj_load, *extsb_node; - load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode); + load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node)); proj_load = new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res); extsb_node = new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, proj_load, mode); exchange(get_succ_Proj(env->irn, pn_Load_res), extsb_node); @@ -1080,22 +1029,22 @@ static ir_node *gen_Load(ppc32_transform_env_t *env) { case irm_Hu: - load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode); + load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node)); break; case irm_Hs: - load =new_rd_ppc32_Lha(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode); + load =new_rd_ppc32_Lha(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node)); break; case irm_Is: case irm_Iu: case irm_P: - load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode); + load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node)); break; case irm_D: - load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode); + load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node)); break; case irm_F: - load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode); + load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node)); break; default: @@ -1122,10 +1071,7 @@ static ir_node *gen_Load(ppc32_transform_env_t *env) { /** * Transforms a Store. * - * @param mod the debug module - * @param block the block the new node should belong to - * @param node the ir Store node - * @param mode node mode + * @param env The transformation environment * @return the created ppc Store node */ static ir_node *gen_Store(ppc32_transform_env_t *env) { @@ -1142,24 +1088,24 @@ static ir_node *gen_Store(ppc32_transform_env_t *env) { switch(get_nice_modecode(mode)){ case irm_Bu: case irm_Bs: - store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode); + store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node)); break; case irm_Hu: case irm_Hs: - store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode); + store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node)); break; case irm_Is: case irm_Iu: case irm_P: - store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode); + store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node)); break; case irm_D: - store = new_rd_ppc32_Stfd(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode); + store = new_rd_ppc32_Stfd(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node)); break; case irm_F: - store = new_rd_ppc32_Stfs(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode); + store = new_rd_ppc32_Stfs(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node)); break; default: @@ -1183,10 +1129,7 @@ static ir_node *gen_Store(ppc32_transform_env_t *env) { /** * Transforms a CopyB. * - * @param mod the debug module - * @param block the block the new node should belong to - * @param node the ir Store node - * @param mode node mode + * @param env The transformation environment * @return the created ppc CopyB node */ static ir_node *gen_CopyB(ppc32_transform_env_t *env) { @@ -1197,34 +1140,34 @@ static ir_node *gen_CopyB(ppc32_transform_env_t *env) { int size = get_type_size_bytes(type); int offset = 0; - ir_node *load, *store; + ir_node *load, *store = NULL; - if(size/4>=1) + if(size/4 >= 1) { ir_node *res; tarval *offset0 = new_tarval_from_long(0, mode_Is); tarval *offset4 = new_tarval_from_long(4, mode_Is); - load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem, mode_T); + load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem); set_ppc32_constant_tarval(load, offset0); set_ppc32_offset_mode(load, ppc32_ao_None); mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M); res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res); - store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem, mode_T); + store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem); set_ppc32_constant_tarval(store, offset0); set_ppc32_offset_mode(store, ppc32_ao_None); mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M); if(size/4==2) { - load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem, mode_T); + load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem); set_ppc32_constant_tarval(load, offset4); set_ppc32_offset_mode(load, ppc32_ao_None); mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M); res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res); - store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem, mode_T); + store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem); set_ppc32_constant_tarval(store, offset4); set_ppc32_offset_mode(store, ppc32_ao_None); mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M); @@ -1257,7 +1200,7 @@ static ir_node *gen_CopyB(ppc32_transform_env_t *env) { in[0] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 1); // src in[1] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 2); // dest in[2] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 4); // temp - be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_general_purpose], env->irg, env->block, 3, in); + be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_gp], env->irg, env->block, 3, in); in[0] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 3); // ctr be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_count], env->irg, env->block, 1, in); @@ -1267,17 +1210,17 @@ static ir_node *gen_CopyB(ppc32_transform_env_t *env) { } } - if((size & 2) == 2) + if(size & 2) { ir_node *res; tarval* offset_tarval = new_tarval_from_long(offset, mode_Is); - load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, src, mem, mode_T); + load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, src, mem); set_ppc32_constant_tarval(load, offset_tarval); set_ppc32_offset_mode(load, ppc32_ao_None); mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M); res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res); - store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, dest, res, mem, mode_T); + store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, dest, res, mem); set_ppc32_constant_tarval(store, offset_tarval); set_ppc32_offset_mode(store, ppc32_ao_None); mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M); @@ -1285,17 +1228,17 @@ static ir_node *gen_CopyB(ppc32_transform_env_t *env) { offset += 2; } - if((size & 1) == 1) + if(size & 1) { ir_node *res; tarval* offset_tarval = new_tarval_from_long(offset, mode_Is); - load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, src, mem, mode_T); + load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, src, mem); set_ppc32_constant_tarval(load, offset_tarval); set_ppc32_offset_mode(load, ppc32_ao_None); mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M); res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res); - store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, dest, res, mem, mode_T); + store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, dest, res, mem); set_ppc32_constant_tarval(store, offset_tarval); set_ppc32_offset_mode(store, ppc32_ao_None); // mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M); @@ -1306,24 +1249,16 @@ static ir_node *gen_CopyB(ppc32_transform_env_t *env) { /** * Transforms a FrameAddr into a ppc Add. + * + * @param env The transformation environment */ -static ir_node *gen_FrameAddr(ppc32_transform_env_t *env) { +static ir_node *gen_be_FrameAddr(ppc32_transform_env_t *env) { ir_node *op = get_irn_n(env->irn, 0); ir_node *add = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op, mode_P); set_ppc32_frame_entity(add, be_get_frame_entity(env->irn)); return add; } -/** - * Transforms a StackParam into a ppc Load - */ -static ir_node *gen_StackParam(ppc32_transform_env_t *env) { - ir_node *load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, get_irn_n(env->irn, 0), new_NoMem(), mode_T); - ir_node *proj = new_rd_Proj(env->dbg, env->irg, env->block, load, env->mode, pn_Load_res); - set_ppc32_frame_entity(load, be_get_frame_entity(env->irn)); - return proj; -} - /********************************************************* * _ _ _ @@ -1335,7 +1270,102 @@ static ir_node *gen_StackParam(ppc32_transform_env_t *env) { * *********************************************************/ +/** + * the BAD transformer. + */ +static ir_node *bad_transform(ppc32_transform_env_t *env) { + ir_fprintf(stderr, "Not implemented: %+F\n", env->irn); + assert(0); + return NULL; +} + +/** + * Enters all transform functions into the generic pointer + */ +void ppc32_register_transformers(void) { + ir_op *op_Max, *op_Min, *op_Mulh; + + /* first clear the generic function pointer for all ops */ + clear_irp_opcodes_generic_func(); + +#define FIRM_OP(a) op_##a->ops.generic = (op_func)gen_##a +#define BAD(a) op_##a->ops.generic = (op_func)bad_transform +#define IGN(a) + + FIRM_OP(Add); + FIRM_OP(Mul); + FIRM_OP(And); + FIRM_OP(Or); + FIRM_OP(Eor); + + FIRM_OP(Sub); + FIRM_OP(Shl); + FIRM_OP(Shr); + FIRM_OP(Shrs); + FIRM_OP(Rotl); + FIRM_OP(Quot); + FIRM_OP(Div); + FIRM_OP(DivMod); + FIRM_OP(Mod); + FIRM_OP(Cmp); + + FIRM_OP(Minus); + FIRM_OP(Not); + FIRM_OP(Conv); + FIRM_OP(Abs); + + FIRM_OP(Load); + FIRM_OP(Store); + FIRM_OP(Cond); + FIRM_OP(Unknown); + FIRM_OP(CopyB); + + /* TODO: implement these nodes */ + BAD(Mux); + + /* You probably don't need to handle the following nodes */ + + IGN(Call); + IGN(Proj); + IGN(Alloc); + + IGN(Block); + IGN(Start); + IGN(End); + IGN(NoMem); + IGN(Phi); + IGN(IJmp); + IGN(Jmp); + IGN(Break); + IGN(Sync); + + BAD(Raise); + BAD(Sel); + BAD(InstOf); + BAD(Cast); + BAD(Free); + BAD(Tuple); + BAD(Id); + BAD(Bad); + BAD(Confirm); + BAD(Filter); + BAD(CallBegin); + BAD(EndReg); + BAD(EndExcept); + + FIRM_OP(be_FrameAddr); + op_Mulh = get_op_Mulh(); + if (op_Mulh) + FIRM_OP(Mulh); + op_Max = get_op_Max(); + if (op_Max) + BAD(Max); + op_Min = get_op_Min(); + if (op_Min) + BAD(Min); +} +typedef ir_node *(transform_func)(ppc32_transform_env_t *env); /** * Transforms the given firm node (and maybe some other related nodes) @@ -1345,123 +1375,36 @@ static ir_node *gen_StackParam(ppc32_transform_env_t *env) { * @param env the debug module */ void ppc32_transform_node(ir_node *node, void *env) { - ppc32_code_gen_t *cgenv = (ppc32_code_gen_t *)env; - opcode code = get_irn_opcode(node); - ir_node *asm_node = NULL; - ppc32_transform_env_t tenv; + ppc32_code_gen_t *cg = (ppc32_code_gen_t *)env; + ir_op *op = get_irn_op(node); + ir_node *asm_node = NULL; + (void) cg; - if (is_Block(node)) + if (op == op_Block) return; - tenv.block = get_nodes_block(node); - tenv.dbg = get_irn_dbg_info(node); - tenv.irg = current_ir_graph; - tenv.irn = node; - DEBUG_ONLY(tenv.mod = cgenv->mod;) - tenv.mode = get_irn_mode(node); - -#define UNOP(a) case iro_##a: asm_node = gen_##a(&tenv, get_##a##_op(node)); break -#define BINOP(a) case iro_##a: asm_node = gen_##a(&tenv, get_##a##_left(node), get_##a##_right(node)); break -#define GEN(a) case iro_##a: asm_node = gen_##a(&tenv); break -#define IGN(a) case iro_##a: break -#define BAD(a) case iro_##a: goto bad -#define OTHER_BIN(a) \ - if (get_irn_op(node) == get_op_##a()) { \ - asm_node = gen_##a(&tenv, get_irn_n(node, 0), get_irn_n(node, 1)); \ - break; \ - } -#define BE_GEN(a) \ - if (be_is_##a(node)) { \ - asm_node = gen_##a(&tenv); \ - break; \ - } + DBG((cg->mod, LEVEL_1, "check %+F ... ", node)); - DBG((tenv.mod, LEVEL_1, "check %+F ... ", node)); + if (op->ops.generic) { + ppc32_transform_env_t tenv; + transform_func *transform = (transform_func *)op->ops.generic; - switch (code) { - BINOP(Add); - BINOP(Mul); - BINOP(And); - BINOP(Or); - BINOP(Eor); - - BINOP(Sub); - BINOP(Shl); - BINOP(Shr); - BINOP(Shrs); - BINOP(Rot); - BINOP(Quot); - BINOP(Div); - BINOP(DivMod); - BINOP(Mod); - BINOP(Cmp); - - UNOP(Minus); - UNOP(Not); - UNOP(Conv); - UNOP(Abs); - - GEN(Load); - GEN(Store); - GEN(Cond); - GEN(Unknown); - GEN(CopyB); - - /* TODO: implement these nodes */ - IGN(Mux); - - /* You probably don't need to handle the following nodes */ - - IGN(Call); - IGN(Proj); - IGN(Alloc); - - IGN(Block); - IGN(Start); - IGN(End); - IGN(NoMem); - IGN(Phi); - IGN(IJmp); - IGN(Jmp); - IGN(Break); - IGN(Sync); - - BAD(Raise); - BAD(Sel); - BAD(InstOf); - BAD(Cast); - BAD(Free); - BAD(Tuple); - BAD(Id); - BAD(Bad); - BAD(Confirm); - BAD(Filter); - BAD(CallBegin); - BAD(EndReg); - BAD(EndExcept); + tenv.block = get_nodes_block(node); + tenv.dbg = get_irn_dbg_info(node); + tenv.irg = current_ir_graph; + tenv.irn = node; + tenv.mode = get_irn_mode(node); + DEBUG_ONLY(tenv.mod = cg->mod;) - default: - OTHER_BIN(Mulh); - BE_GEN(FrameAddr); - BE_GEN(StackParam); - if (get_irn_op(node) == get_op_Max() || - get_irn_op(node) == get_op_Min()) - { - /* TODO: implement */ - /* ignore for now */ - } - break; -bad: - fprintf(stderr, "Not implemented: %s\n", get_irn_opname(node)); - assert(0); + asm_node = (*transform)(&tenv); } if (asm_node) { exchange(node, asm_node); - DB((tenv.mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node)); + DB((cg->mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node)); } else { - DB((tenv.mod, LEVEL_1, "ignored\n")); + DB((cg->mod, LEVEL_1, "ignored\n")); } } @@ -1470,7 +1413,7 @@ bad: */ struct tv_ent { - entity *ent; + ir_entity *ent; tarval *tv; }; @@ -1478,6 +1421,7 @@ struct tv_ent { static int cmp_tv_ent(const void *a, const void *b, size_t len) { const struct tv_ent *e1 = a; const struct tv_ent *e2 = b; + (void) len; return !(e1->tv == e2->tv); } @@ -1490,7 +1434,7 @@ static ir_node *gen_fp_known_symconst(ppc32_transform_env_t *env, tarval *known_ struct tv_ent *entry; ir_node *cnst,*symcnst; ir_graph *rem; - entity *ent; + ir_entity *ent = NULL; if(!const_set) const_set = new_set(cmp_tv_ent, 10); @@ -1630,7 +1574,7 @@ static ir_node *gen_ppc32_fConst(ppc32_transform_env_t *env) { { ir_node *addr, *load; ir_mode *mode = env->mode; - entity *ent; + ir_entity *ent; env->irn = gen_fp_known_symconst(env, tv_const); env->mode = mode_P; ent = get_ppc32_frame_entity(env->irn); @@ -1640,9 +1584,9 @@ static ir_node *gen_ppc32_fConst(ppc32_transform_env_t *env) { ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst); if(mode==mode_D) - load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, node_addis, new_NoMem(), mode_T); + load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, node_addis, new_NoMem()); else // mode_F - load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, node_addis, new_NoMem(), mode_T); + load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, node_addis, new_NoMem()); set_ppc32_symconst_ident(load, id_symconst); set_ppc32_offset_mode(load, ppc32_ao_Lo16); @@ -1651,9 +1595,9 @@ static ir_node *gen_ppc32_fConst(ppc32_transform_env_t *env) { { addr = gen_ppc32_SymConst (env); if(mode==mode_D) - load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, addr, new_NoMem(), mode_T); + load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, addr, new_NoMem()); else // mode_F - load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, addr, new_NoMem(), mode_T); + load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, addr, new_NoMem()); } return new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res); } @@ -1671,8 +1615,8 @@ static ir_node *gen_ppc32_fConst(ppc32_transform_env_t *env) { * Returns true, if the entity can be accessed directly, * or false, if the address must be loaded first */ -int is_direct_entity(entity *ent) { - return get_entity_visibility(ent)!=visibility_external_allocated; +int is_direct_entity(ir_entity *ent) { + return get_entity_visibility(ent) != visibility_external_allocated; /* visibility vis = get_entity_visibility(ent); if(is_Method_type(get_entity_type(ent))) { @@ -1694,7 +1638,7 @@ int is_direct_entity(entity *ent) { * @return the created ppc Load immediate node */ static ir_node *gen_ppc32_SymConst(ppc32_transform_env_t *env) { - entity *ent = get_ppc32_frame_entity(env->irn); + ir_entity *ent = get_ppc32_frame_entity(env->irn); ident *id_symconst = get_entity_ident(ent); ir_node *node; switch(get_nice_modecode(env->mode)){ @@ -1710,11 +1654,10 @@ static ir_node *gen_ppc32_SymConst(ppc32_transform_env_t *env) { else { ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst); - node = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, node_addis, new_NoMem(), mode_T); + node = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, node_addis, new_NoMem()); set_ppc32_symconst_ident(node, id_symconst); set_ppc32_offset_mode(node, ppc32_ao_Lo16); node = new_rd_Proj(env->dbg, env->irg, env->block, node, env->mode, pn_Load_res); -// pset_insert_ptr(symbol_pset, ent); } break; } @@ -1738,6 +1681,7 @@ void ppc32_transform_const(ir_node *node, void *env) { ppc32_code_gen_t *cgenv = (ppc32_code_gen_t *)env; ir_node *asm_node = NULL; ppc32_transform_env_t tenv; + (void) cgenv; if (is_Block(node)) return;