made code C89 compliant (changed unnamed union in attributes)

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

diff --git a/ir/be/ia32/ia32_transform.c b/ir/be/ia32/ia32_transform.c
index 7399fb9..4cdcfa5 100644 (file)
--- a/ir/be/ia32/ia32_transform.c
+++ b/ir/be/ia32/ia32_transform.c
@@ -449,6 +449,7 @@ static ir_node *gen_Add(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
                if (USE_SSE2(env->cg))
                        return gen_binop(env, op1, op2, new_rd_ia32_fAdd);
                else {
+                       env->cg->used_x87 = 1;
                        return gen_binop(env, op1, op2, new_rd_ia32_vfadd);
                }
        }
@@ -458,15 +459,35 @@ static ir_node *gen_Add(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
                        /* No expr_op means, that we have two const - one symconst and */
                        /* one tarval or another symconst - because this case is not   */
                        /* covered by constant folding                                 */
+                       /* We need to check for:                                       */
+                       /*  1) symconst + const    -> becomes a LEA                    */
+                       /*  2) symconst + symconst -> becomes a const + LEA as the elf */
+                       /*        linker doesn't support two symconsts                 */
+
+                       if (get_ia32_op_type(op1) == ia32_SymConst && get_ia32_op_type(op2) == ia32_SymConst) {
+                               /* this is the 2nd case */
+                               new_op = new_rd_ia32_Lea(dbg, irg, block, op1, noreg, mode);
+                               set_ia32_am_sc(new_op, get_ia32_id_cnst(op2));
+                               set_ia32_am_flavour(new_op, ia32_am_OB);
+                       }
+                       else {
+                               /* this is the 1st case */
+                               new_op = new_rd_ia32_Lea(dbg, irg, block, noreg, noreg, mode);
 
-                       new_op = new_rd_ia32_Lea(dbg, irg, block, noreg, noreg, mode);
-                       add_ia32_am_offs(new_op, get_ia32_cnst(op1));
-                       add_ia32_am_offs(new_op, get_ia32_cnst(op2));
+                               if (get_ia32_op_type(op1) == ia32_SymConst) {
+                                       set_ia32_am_sc(new_op, get_ia32_id_cnst(op1));
+                                       add_ia32_am_offs(new_op, get_ia32_cnst(op2));
+                               }
+                               else {
+                                       add_ia32_am_offs(new_op, get_ia32_cnst(op1));
+                                       set_ia32_am_sc(new_op, get_ia32_id_cnst(op2));
+                               }
+                               set_ia32_am_flavour(new_op, ia32_am_O);
+                       }
 
                        /* set AM support */
                        set_ia32_am_support(new_op, ia32_am_Source);
                        set_ia32_op_type(new_op, ia32_AddrModeS);
-                       set_ia32_am_flavour(new_op, ia32_am_O);
 
                        /* Lea doesn't need a Proj */
                        return new_op;
@@ -512,8 +533,10 @@ static ir_node *gen_Mul(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
        if (mode_is_float(env->mode)) {
                if (USE_SSE2(env->cg))
                        new_op = gen_binop(env, op1, op2, new_rd_ia32_fMul);
-               else
+               else {
+                       env->cg->used_x87 = 1;
                        new_op = gen_binop(env, op1, op2, new_rd_ia32_vfmul);
+               }
        }
        else {
                new_op = gen_binop(env, op1, op2, new_rd_ia32_Mul);
@@ -622,7 +645,12 @@ static ir_node *gen_Max(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
        ir_node *new_op;
 
        if (mode_is_float(env->mode)) {
-               new_op = gen_binop(env, op1, op2, new_rd_ia32_fMax);
+               if (USE_SSE2(env->cg))
+                       new_op = gen_binop(env, op1, op2, new_rd_ia32_fMax);
+               else {
+                       env->cg->used_x87 = 1;
+                       assert(0);
+               }
        }
        else {
                new_op = new_rd_ia32_Max(env->dbg, env->irg, env->block, op1, op2, env->mode);
@@ -647,7 +675,12 @@ static ir_node *gen_Min(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
        ir_node *new_op;
 
        if (mode_is_float(env->mode)) {
-               new_op = gen_binop(env, op1, op2, new_rd_ia32_fMin);
+               if (USE_SSE2(env->cg))
+                       new_op = gen_binop(env, op1, op2, new_rd_ia32_fMin);
+               else {
+                       env->cg->used_x87 = 1;
+                       assert(0);
+               }
        }
        else {
                new_op = new_rd_ia32_Min(env->dbg, env->irg, env->block, op1, op2, env->mode);
@@ -734,8 +767,10 @@ static ir_node *gen_Sub(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
        if (mode_is_float(mode)) {
                if (USE_SSE2(env->cg))
                        return gen_binop(env, op1, op2, new_rd_ia32_fSub);
-               else
+               else {
+                       env->cg->used_x87 = 1;
                        return gen_binop(env, op1, op2, new_rd_ia32_vfsub);
+               }
        }
        else {
                /* integer SUB */
@@ -743,15 +778,37 @@ static ir_node *gen_Sub(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
                        /* No expr_op means, that we have two const - one symconst and */
                        /* one tarval or another symconst - because this case is not   */
                        /* covered by constant folding                                 */
+                       /* We need to check for:                                       */
+                       /*  1) symconst + const    -> becomes a LEA                    */
+                       /*  2) symconst + symconst -> becomes a const + LEA as the elf */
+                       /*        linker doesn't support two symconsts                 */
+
+                       if (get_ia32_op_type(op1) == ia32_SymConst && get_ia32_op_type(op2) == ia32_SymConst) {
+                               /* this is the 2nd case */
+                               new_op = new_rd_ia32_Lea(dbg, irg, block, op1, noreg, mode);
+                               set_ia32_am_sc(new_op, get_ia32_id_cnst(op2));
+                               set_ia32_am_sc_sign(new_op);
+                               set_ia32_am_flavour(new_op, ia32_am_OB);
+                       }
+                       else {
+                               /* this is the 1st case */
+                               new_op = new_rd_ia32_Lea(dbg, irg, block, noreg, noreg, mode);
 
-                       new_op = new_rd_ia32_Lea(dbg, irg, block, noreg, noreg, mode);
-                       add_ia32_am_offs(new_op, get_ia32_cnst(op1));
-                       sub_ia32_am_offs(new_op, get_ia32_cnst(op2));
+                               if (get_ia32_op_type(op1) == ia32_SymConst) {
+                                       set_ia32_am_sc(new_op, get_ia32_id_cnst(op1));
+                                       sub_ia32_am_offs(new_op, get_ia32_cnst(op2));
+                               }
+                               else {
+                                       add_ia32_am_offs(new_op, get_ia32_cnst(op1));
+                                       set_ia32_am_sc(new_op, get_ia32_id_cnst(op2));
+                                       set_ia32_am_sc_sign(new_op);
+                               }
+                               set_ia32_am_flavour(new_op, ia32_am_O);
+                       }
 
                        /* set AM support */
                        set_ia32_am_support(new_op, ia32_am_Source);
                        set_ia32_op_type(new_op, ia32_AddrModeS);
-                       set_ia32_am_flavour(new_op, ia32_am_O);
 
                        /* Lea doesn't need a Proj */
                        return new_op;
@@ -1076,6 +1133,7 @@ static ir_node *gen_Minus(ia32_transform_env_t *env, ir_node *op) {
                        new_op = new_rd_Proj(env->dbg, env->irg, env->block, new_op, env->mode, 0);
                }
                else {
+                       env->cg->used_x87 = 1;
                        new_op = new_rd_ia32_vfchs(env->dbg, env->irg, env->block, op, env->mode);
                        SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env));
                }
@@ -1139,6 +1197,7 @@ static ir_node *gen_Abs(ia32_transform_env_t *env, ir_node *op) {
                        res = new_rd_Proj(dbg, irg, block, res, mode, 0);
                }
                else {
+                       env->cg->used_x87 = 1;
                        res = new_rd_ia32_vfabs(dbg, irg, block, op, mode);
                        SET_IA32_ORIG_NODE(res, ia32_get_old_node_name(env));
                }
@@ -1182,30 +1241,39 @@ 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_node    *ptr   = get_Load_ptr(node);
+       ir_node    *lptr  = ptr;
        ir_mode    *mode  = get_Load_mode(node);
-       const char *offs  = NULL;
+       int        is_imm = 0;
        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;
+               lptr   = noreg;
+               is_imm = 1;
        }
 
        if (mode_is_float(mode)) {
                if (USE_SSE2(env->cg))
-                       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_vfld(env->dbg, env->irg, env->block, ptr, noreg, get_Load_mem(node), env->mode);
+                       new_op = new_rd_ia32_fLoad(env->dbg, env->irg, env->block, lptr, noreg, get_Load_mem(node), env->mode);
+               else {
+                       env->cg->used_x87 = 1;
+                       new_op = new_rd_ia32_vfld(env->dbg, env->irg, env->block, lptr, noreg, get_Load_mem(node), env->mode);
+               }
        }
        else {
-               new_op = new_rd_ia32_Load(env->dbg, env->irg, env->block, ptr, noreg, get_Load_mem(node), env->mode);
+               new_op = new_rd_ia32_Load(env->dbg, env->irg, env->block, lptr, noreg, get_Load_mem(node), env->mode);
        }
 
        /* base is an constant address */
-       if (offs) {
-               add_ia32_am_offs(new_op, offs);
+       if (is_imm) {
+               if (get_ia32_immop_type(ptr) == ia32_ImmSymConst) {
+                       set_ia32_am_sc(new_op, get_ia32_id_cnst(ptr));
+               }
+               else {
+                       add_ia32_am_offs(new_op, get_ia32_cnst(ptr));
+               }
+
                am_flav = ia32_O;
        }
 
@@ -1235,56 +1303,67 @@ static ir_node *gen_Store(ia32_transform_env_t *env) {
        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 *sptr    = ptr;
        ir_node *mem     = get_Store_mem(node);
        ir_mode *mode    = get_irn_mode(val);
        ir_node *sval    = val;
-       const char *offs = NULL;
+       int      is_imm  = 0;
        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_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");
+       ia32_immop_type_t immop   = ia32_ImmNone;
+
+       if (! mode_is_float(mode)) {
+               /* in case of storing a const (but not a symconst) -> make it an attribute */
+               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;
                }
-               sval = noreg;
        }
 
        /* address might be a constant (symconst or absolute address) */
        if (is_ia32_Const(ptr)) {
-               offs = get_ia32_cnst(ptr);
-               ptr  = noreg;
+               sptr   = noreg;
+               is_imm = 0;
        }
 
        if (mode_is_float(mode)) {
                if (USE_SSE2(env->cg))
-                       new_op = new_rd_ia32_fStore(env->dbg, env->irg, env->block, ptr, noreg, sval, mem, mode_T);
-               else
-                       new_op = new_rd_ia32_vfst(env->dbg, env->irg, env->block, ptr, noreg, sval, mem, mode_T);
+                       new_op = new_rd_ia32_fStore(env->dbg, env->irg, env->block, sptr, noreg, sval, mem, mode_T);
+               else {
+                       env->cg->used_x87 = 1;
+                       new_op = new_rd_ia32_vfst(env->dbg, env->irg, env->block, sptr, noreg, sval, mem, mode_T);
+               }
        }
        else if (get_mode_size_bits(mode) == 8) {
-               new_op = new_rd_ia32_Store8Bit(env->dbg, env->irg, env->block, ptr, noreg, sval, mem, mode_T);
+               new_op = new_rd_ia32_Store8Bit(env->dbg, env->irg, env->block, sptr, noreg, sval, mem, mode_T);
        }
        else {
                new_op = new_rd_ia32_Store(env->dbg, env->irg, env->block, ptr, noreg, sval, mem, mode_T);
        }
 
        /* stored const is an attribute (saves a register) */
-       if (is_ia32_Cnst(val)) {
+       if (! mode_is_float(mode) && 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);
+       if (is_imm) {
+               if (get_ia32_immop_type(ptr) == ia32_ImmSymConst) {
+                       set_ia32_am_sc(new_op, get_ia32_id_cnst(ptr));
+               }
+               else {
+                       add_ia32_am_offs(new_op, get_ia32_cnst(ptr));
+               }
+
                am_flav = ia32_O;
        }
 
@@ -1364,7 +1443,12 @@ static ir_node *gen_Cond(ia32_transform_env_t *env) {
                        }
 
                        if (mode_is_float(get_irn_mode(expr))) {
-                               res = new_rd_ia32_fCondJmp(dbg, irg, block, noreg, noreg, expr, noreg, nomem, mode_T);
+                               if (USE_SSE2(env->cg))
+                                       res = new_rd_ia32_fCondJmp(dbg, irg, block, noreg, noreg, expr, noreg, nomem, mode_T);
+                               else {
+                                       env->cg->used_x87 = 1;
+                                       assert(0);
+                               }
                        }
                        else {
                                res = new_rd_ia32_CondJmp(dbg, irg, block, noreg, noreg, expr, noreg, nomem, mode_T);
@@ -1374,7 +1458,12 @@ static ir_node *gen_Cond(ia32_transform_env_t *env) {
                }
                else {
                        if (mode_is_float(get_irn_mode(cmp_a))) {
-                               res = new_rd_ia32_fCondJmp(dbg, irg, block, noreg, noreg, cmp_a, cmp_b, nomem, mode_T);
+                               if (USE_SSE2(env->cg))
+                                       res = new_rd_ia32_fCondJmp(dbg, irg, block, noreg, noreg, cmp_a, cmp_b, nomem, mode_T);
+                               else {
+                                       env->cg->used_x87 = 1;
+                                       assert(0);
+                               }
                        }
                        else {
                                res = new_rd_ia32_CondJmp(dbg, irg, block, noreg, noreg, cmp_a, cmp_b, nomem, mode_T);
@@ -1646,8 +1735,10 @@ static ir_node *gen_StackParam(ia32_transform_env_t *env) {
        if (mode_is_float(mode)) {
                if (USE_SSE2(env->cg))
                        new_op = new_rd_ia32_fLoad(env->dbg, env->irg, env->block, ptr, noreg, mem, mode_T);
-               else
+               else {
+                       env->cg->used_x87 = 1;
                        new_op = new_rd_ia32_vfld(env->dbg, env->irg, env->block, ptr, noreg, mem, mode_T);
+               }
        }
        else {
                new_op = new_rd_ia32_Load(env->dbg, env->irg, env->block, ptr, noreg, mem, mode_T);
@@ -1702,8 +1793,10 @@ static ir_node *gen_FrameLoad(ia32_transform_env_t *env) {
        if (mode_is_float(mode)) {
                if (USE_SSE2(env->cg))
                        new_op = new_rd_ia32_fLoad(env->dbg, env->irg, env->block, ptr, noreg, mem, mode_T);
-               else
+               else {
+                       env->cg->used_x87 = 1;
                        new_op = new_rd_ia32_vfld(env->dbg, env->irg, env->block, ptr, noreg, mem, mode_T);
+               }
        }
        else {
                new_op = new_rd_ia32_Load(env->dbg, env->irg, env->block, ptr, noreg, mem, mode_T);
@@ -1739,8 +1832,10 @@ static ir_node *gen_FrameStore(ia32_transform_env_t *env) {
        if (mode_is_float(mode)) {
                if (USE_SSE2(env->cg))
                        new_op = new_rd_ia32_fStore(env->dbg, env->irg, env->block, ptr, noreg, val, mem, mode_T);
-               else
+               else {
+                       env->cg->used_x87 = 1;
                        new_op = new_rd_ia32_vfst(env->dbg, env->irg, env->block, ptr, noreg, val, mem, mode_T);
+               }
        }
        else if (get_mode_size_bits(mode) == 8) {
                new_op = new_rd_ia32_Store8Bit(env->dbg, env->irg, env->block, ptr, noreg, val, mem, mode_T);