place transformed StackParam nodes in the user Block

[libfirm] / ir / be / ia32 / ia32_transform.c

diff --git a/ir/be/ia32/ia32_transform.c b/ir/be/ia32/ia32_transform.c
index d28f900..c32c060 100644 (file)
--- a/ir/be/ia32/ia32_transform.c
+++ b/ir/be/ia32/ia32_transform.c
@@ -1177,21 +1177,36 @@ static ir_node *gen_Abs(ia32_transform_env_t *env, ir_node *op) {
  * @return the created ia32 Load node
  */
 static ir_node *gen_Load(ia32_transform_env_t *env) {
-       ir_node *node  = env->irn;
-       ir_node *noreg = ia32_new_NoReg_gp(env->cg);
-       ir_mode *mode  = get_Load_mode(node);
+       ir_node    *node  = env->irn;
+       ir_node    *noreg = ia32_new_NoReg_gp(env->cg);
+       ir_node    *ptr   = get_Load_ptr(node);
+       ir_mode    *mode  = get_Load_mode(node);
+       const char *offs  = NULL;
        ir_node *new_op;
+       ia32_am_flavour_t am_flav = ia32_B;
+
+       /* address might be a constant (symconst or absolute address) */
+       if (is_ia32_Const(ptr)) {
+               offs = get_ia32_cnst(ptr);
+               ptr  = noreg;
+       }
 
        if (mode_is_float(mode)) {
-               new_op = new_rd_ia32_fLoad(env->dbg, env->irg, env->block, get_Load_ptr(node), noreg, get_Load_mem(node), env->mode);
+               new_op = new_rd_ia32_fLoad(env->dbg, env->irg, env->block, ptr, noreg, get_Load_mem(node), env->mode);
        }
        else {
-               new_op = new_rd_ia32_Load(env->dbg, env->irg, env->block, get_Load_ptr(node), noreg, get_Load_mem(node), env->mode);
+               new_op = new_rd_ia32_Load(env->dbg, env->irg, env->block, ptr, noreg, get_Load_mem(node), env->mode);
+       }
+
+       /* base is an constant address */
+       if (offs) {
+               add_ia32_am_offs(new_op, offs);
+               am_flav = ia32_O;
        }
 
        set_ia32_am_support(new_op, ia32_am_Source);
        set_ia32_op_type(new_op, ia32_AddrModeS);
-       set_ia32_am_flavour(new_op, ia32_B);
+       set_ia32_am_flavour(new_op, am_flav);
        set_ia32_ls_mode(new_op, mode);
 
        SET_IA32_ORIG_NODE(new_op, get_old_node_name(env));
@@ -1211,20 +1226,40 @@ static ir_node *gen_Load(ia32_transform_env_t *env) {
  * @return the created ia32 Store node
  */
 static ir_node *gen_Store(ia32_transform_env_t *env) {
-       ir_node *node  = env->irn;
-       ir_node *noreg = ia32_new_NoReg_gp(env->cg);
-       ir_node *val   = get_Store_value(node);
-       ir_node *ptr   = get_Store_ptr(node);
-       ir_node *mem   = get_Store_mem(node);
-       ir_mode *mode  = get_irn_mode(val);
-       ir_node *sval  = val;
+       ir_node    *node  = env->irn;
+       ir_node    *noreg = ia32_new_NoReg_gp(env->cg);
+       ir_node    *val   = get_Store_value(node);
+       ir_node    *ptr   = get_Store_ptr(node);
+       ir_node    *mem   = get_Store_mem(node);
+       ir_mode    *mode  = get_irn_mode(val);
+       ir_node    *sval  = val;
+       const char *offs  = NULL;
        ir_node *new_op;
+       ia32_am_flavour_t am_flav = ia32_B;
+       ia32_immop_type_t immop   = ia32_ImmNone;
 
        /* in case of storing a const (but not a symconst) -> make it an attribute */
-       if (is_ia32_Const(val)) {
+       if (is_ia32_Cnst(val)) {
+               switch (get_ia32_op_type(val)) {
+                       case ia32_Const:
+                               immop = ia32_ImmConst;
+                               break;
+                       case ia32_SymConst:
+                               immop = ia32_ImmSymConst;
+                               break;
+                       default:
+                               assert(0 && "unsupported Const type");
+               }
+
                sval = noreg;
        }
 
+       /* address might be a constant (symconst or absolute address) */
+       if (is_ia32_Const(ptr)) {
+               offs = get_ia32_cnst(ptr);
+               ptr  = noreg;
+       }
+
        if (mode_is_float(mode)) {
                new_op = new_rd_ia32_fStore(env->dbg, env->irg, env->block, ptr, noreg, sval, mem, mode_T);
        }
@@ -1236,14 +1271,21 @@ static ir_node *gen_Store(ia32_transform_env_t *env) {
        }
 
        /* stored const is an attribute (saves a register) */
-       if (is_ia32_Const(val)) {
+       if (is_ia32_Cnst(val)) {
                set_ia32_Immop_attr(new_op, val);
        }
 
+       /* base is an constant address */
+       if (offs) {
+               add_ia32_am_offs(new_op, offs);
+               am_flav = ia32_O;
+       }
+
        set_ia32_am_support(new_op, ia32_am_Dest);
        set_ia32_op_type(new_op, ia32_AddrModeD);
-       set_ia32_am_flavour(new_op, ia32_B);
+       set_ia32_am_flavour(new_op, am_flav);
        set_ia32_ls_mode(new_op, get_irn_mode(val));
+       set_ia32_immop_type(new_op, immop);
 
        SET_IA32_ORIG_NODE(new_op, get_old_node_name(env));
 
@@ -1284,9 +1326,11 @@ static ir_node *gen_Cond(ia32_transform_env_t *env) {
                expr = get_expr_op(cmp_a, cmp_b);
 
                if (cnst && expr) {
-                       if (mode_is_int(get_irn_mode(expr))) {
+                       pn_Cmp pnc = get_Proj_proj(sel);
+
+                       if ((pnc == pn_Cmp_Eq || pnc == pn_Cmp_Lg) && mode_is_int(get_irn_mode(expr))) {
                                if (classify_tarval(get_ia32_Immop_tarval(cnst)) == TV_CLASSIFY_NULL) {
-                                       /* a Cmp A, 0 */
+                                       /* a Cmp A =/!= 0 */
                                        ir_node    *op1  = expr;
                                        ir_node    *op2  = expr;
                                        ir_node    *and  = skip_Proj(expr);
@@ -1574,6 +1618,12 @@ static ir_node *gen_StackParam(ia32_transform_env_t *env) {
        entity  *ent    = be_get_frame_entity(node);
        ir_mode *mode   = env->mode;
 
+       /* If the StackParam has only one user ->     */
+       /* put it in the Block where the user resides */
+       if (get_irn_n_edges(node) == 1) {
+               env->block = get_nodes_block(get_edge_src_irn(get_irn_out_edge_first(node)));
+       }
+
        if (mode_is_float(mode)) {
                new_op = new_rd_ia32_fLoad(env->dbg, env->irg, env->block, ptr, noreg, mem, mode_T);
        }