Commit 97a79eb7 authored by Aurelien Jarno's avatar Aurelien Jarno Committed by Richard Henderson
Browse files

tcg/optimize: fold constant test in tcg_opt_gen_mov 



Most of the calls to tcg_opt_gen_mov are preceeded by a test to check if
the source temp is a constant. Fold that into the tcg_opt_gen_mov
function.

Cc: Richard Henderson <rth@twiddle.net>
Signed-off-by: default avatarAurelien Jarno <aurelien@aurel32.net>
Message-Id: <1433495958-9508-1-git-send-email-aurelien@aurel32.net>
Signed-off-by: default avatarRichard Henderson <rth@twiddle.net>
parent 5365718a

tcg/optimize.c

+36 −53
Original line number Diff line number Diff line
@@ -193,6 +193,28 @@ static bool temps_are_copies(TCGArg arg1, TCGArg arg2) 
    return false;

}



static void tcg_opt_gen_movi(TCGContext *s, TCGOp *op, TCGArg *args,

                             TCGArg dst, TCGArg val)

{

    TCGOpcode new_op = op_to_movi(op->opc);

    tcg_target_ulong mask;



    op->opc = new_op;



    reset_temp(dst);

    temps[dst].state = TCG_TEMP_CONST;

    temps[dst].val = val;

    mask = val;

    if (TCG_TARGET_REG_BITS > 32 && new_op == INDEX_op_mov_i32) {

        /* High bits of the destination are now garbage.  */

        mask |= ~0xffffffffull;

    }

    temps[dst].mask = mask;



    args[0] = dst;

    args[1] = val;

}



static void tcg_opt_gen_mov(TCGContext *s, TCGOp *op, TCGArg *args,

                            TCGArg dst, TCGArg src)

{
@@ -201,6 +223,11 @@ static void tcg_opt_gen_mov(TCGContext *s, TCGOp *op, TCGArg *args, 
        return;

    }



    if (temps[src].state == TCG_TEMP_CONST) {

        tcg_opt_gen_movi(s, op, args, dst, temps[src].val);

        return;

    }



    TCGOpcode new_op = op_to_mov(op->opc);

    tcg_target_ulong mask;
@@ -233,28 +260,6 @@ static void tcg_opt_gen_mov(TCGContext *s, TCGOp *op, TCGArg *args, 
    args[1] = src;

}



static void tcg_opt_gen_movi(TCGContext *s, TCGOp *op, TCGArg *args,

                             TCGArg dst, TCGArg val)

{

    TCGOpcode new_op = op_to_movi(op->opc);

    tcg_target_ulong mask;



    op->opc = new_op;



    reset_temp(dst);

    temps[dst].state = TCG_TEMP_CONST;

    temps[dst].val = val;

    mask = val;

    if (TCG_TARGET_REG_BITS > 32 && new_op == INDEX_op_mov_i32) {

        /* High bits of the destination are now garbage.  */

        mask |= ~0xffffffffull;

    }

    temps[dst].mask = mask;



    args[0] = dst;

    args[1] = val;

}



static TCGArg do_constant_folding_2(TCGOpcode op, TCGArg x, TCGArg y)

{

    uint64_t l64, h64;
@@ -780,7 +785,8 @@ static void tcg_constant_folding(TCGContext *s) 
            if (temps[args[1]].state != TCG_TEMP_CONST

                && temps[args[2]].state == TCG_TEMP_CONST

                && temps[args[2]].val == 0) {

                goto do_mov3;

                tcg_opt_gen_mov(s, op, args, args[0], args[1]);

                continue;

            }

            break;

        CASE_OP_32_64(and):
@@ -789,12 +795,10 @@ static void tcg_constant_folding(TCGContext *s) 
            if (temps[args[1]].state != TCG_TEMP_CONST

                && temps[args[2]].state == TCG_TEMP_CONST

                && temps[args[2]].val == -1) {

                goto do_mov3;

            }

            break;

        do_mov3:

                tcg_opt_gen_mov(s, op, args, args[0], args[1]);

                continue;

            }

            break;

        default:

            break;

        }
@@ -948,12 +952,7 @@ static void tcg_constant_folding(TCGContext *s) 
        }

        if (affected == 0) {

            assert(nb_oargs == 1);

            if (temps[args[1]].state != TCG_TEMP_CONST) {

            tcg_opt_gen_mov(s, op, args, args[0], args[1]);

            } else {

                tcg_opt_gen_movi(s, op, args,

                                 args[0], temps[args[1]].val);

            }

            continue;

        }
@@ -978,12 +977,7 @@ static void tcg_constant_folding(TCGContext *s) 
        CASE_OP_32_64(or):

        CASE_OP_32_64(and):

            if (temps_are_copies(args[1], args[2])) {

                if (temps[args[1]].state != TCG_TEMP_CONST) {

                tcg_opt_gen_mov(s, op, args, args[0], args[1]);

                } else {

                    tcg_opt_gen_movi(s, op, args,

                                     args[0], temps[args[1]].val);

                }

                continue;

            }

            break;
@@ -1010,14 +1004,8 @@ static void tcg_constant_folding(TCGContext *s) 
           allocator where needed and possible.  Also detect copies. */

        switch (opc) {

        CASE_OP_32_64(mov):

            if (temps[args[1]].state != TCG_TEMP_CONST) {

            tcg_opt_gen_mov(s, op, args, args[0], args[1]);

            break;

            }

            /* Source argument is constant.  Rewrite the operation and

               let movi case handle it. */

            args[1] = temps[args[1]].val;

            /* fallthrough */

        CASE_OP_32_64(movi):

            tcg_opt_gen_movi(s, op, args, args[0], args[1]);

            break;
@@ -1111,12 +1099,7 @@ static void tcg_constant_folding(TCGContext *s) 
        CASE_OP_32_64(movcond):

            tmp = do_constant_folding_cond(opc, args[1], args[2], args[5]);

            if (tmp != 2) {

                if (temps[args[4-tmp]].state == TCG_TEMP_CONST) {

                    tcg_opt_gen_movi(s, op, args,

                                     args[0], temps[args[4-tmp]].val);

                } else {

                tcg_opt_gen_mov(s, op, args, args[0], args[4-tmp]);

                }

                break;

            }

            goto do_default;