diff mbox series

[v2,02/51] tcg/optimize: Split out fold_affected_mask

Message ID 20241220041104.53105-3-richard.henderson@linaro.org (mailing list archive)
State New
Headers show
Series tcg: Remove in-flight mask data from OptContext | expand

Commit Message

Richard Henderson Dec. 20, 2024, 4:10 a.m. UTC 
There are only a few logical operations which can compute
an "affected" mask.  Split out handling of this optimization
to a separate function, only to be called when applicable.

Remove the a_mask field from OptContext, as the mask is
no longer stored anywhere.

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 tcg/optimize.c | 42 +++++++++++++++++++++++++++---------------
 1 file changed, 27 insertions(+), 15 deletions(-)

Comments

Pierrick Bouvier Dec. 20, 2024, 8:13 p.m. UTC | #1 
On 12/19/24 20:10, Richard Henderson wrote:
> There are only a few logical operations which can compute
> an "affected" mask.  Split out handling of this optimization
> to a separate function, only to be called when applicable.
> 
> Remove the a_mask field from OptContext, as the mask is
> no longer stored anywhere.
> 
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
>   tcg/optimize.c | 42 +++++++++++++++++++++++++++---------------
>   1 file changed, 27 insertions(+), 15 deletions(-)
> 
> diff --git a/tcg/optimize.c b/tcg/optimize.c
> index 453e8c43bd..6757fe0036 100644
> --- a/tcg/optimize.c
> +++ b/tcg/optimize.c
> @@ -64,7 +64,6 @@ typedef struct OptContext {
>       QSIMPLEQ_HEAD(, MemCopyInfo) mem_free;
>   
>       /* In flight values from optimization. */
> -    uint64_t a_mask;  /* mask bit is 0 iff value identical to first input */
>       uint64_t z_mask;  /* mask bit is 0 iff value bit is 0 */
>       uint64_t s_mask;  /* mask of clrsb(value) bits */
>       TCGType type;
> @@ -1047,7 +1046,6 @@ static bool fold_const2_commutative(OptContext *ctx, TCGOp *op)
>   
>   static bool fold_masks(OptContext *ctx, TCGOp *op)
>   {
> -    uint64_t a_mask = ctx->a_mask;
>       uint64_t z_mask = ctx->z_mask;
>       uint64_t s_mask = ctx->s_mask;
>   
> @@ -1059,7 +1057,6 @@ static bool fold_masks(OptContext *ctx, TCGOp *op)
>        * type changing opcodes.
>        */
>       if (ctx->type == TCG_TYPE_I32) {
> -        a_mask = (int32_t)a_mask;
>           z_mask = (int32_t)z_mask;
>           s_mask |= MAKE_64BIT_MASK(32, 32);
>           ctx->z_mask = z_mask;
> @@ -1069,6 +1066,19 @@ static bool fold_masks(OptContext *ctx, TCGOp *op)
>       if (z_mask == 0) {
>           return tcg_opt_gen_movi(ctx, op, op->args[0], 0);
>       }
> +    return false;
> +}
> +
> +/*
> + * An "affected" mask bit is 0 if and only if the result is identical
> + * to the first input.  Thus if the entire mask is 0, the operation
> + * is equivalent to a copy.
> + */
> +static bool fold_affected_mask(OptContext *ctx, TCGOp *op, uint64_t a_mask)
> +{
> +    if (ctx->type == TCG_TYPE_I32) {
> +        a_mask = (uint32_t)a_mask;
> +    }
>       if (a_mask == 0) {
>           return tcg_opt_gen_mov(ctx, op, op->args[0], op->args[1]);
>       }
> @@ -1305,8 +1315,9 @@ static bool fold_and(OptContext *ctx, TCGOp *op)
>        * Known-zeros does not imply known-ones.  Therefore unless
>        * arg2 is constant, we can't infer affected bits from it.
>        */
> -    if (arg_is_const(op->args[2])) {
> -        ctx->a_mask = z1 & ~z2;
> +    if (arg_is_const(op->args[2]) &&
> +        fold_affected_mask(ctx, op, z1 & ~z2)) {
> +        return true;
>       }
>   
>       return fold_masks(ctx, op);
> @@ -1331,7 +1342,9 @@ static bool fold_andc(OptContext *ctx, TCGOp *op)
>        */
>       if (arg_is_const(op->args[2])) {
>           uint64_t z2 = ~arg_info(op->args[2])->z_mask;
> -        ctx->a_mask = z1 & ~z2;
> +        if (fold_affected_mask(ctx, op, z1 & ~z2)) {
> +            return true;
> +        }
>           z1 &= z2;
>       }
>       ctx->z_mask = z1;
> @@ -1709,8 +1722,8 @@ static bool fold_extract(OptContext *ctx, TCGOp *op)
>   
>       z_mask_old = arg_info(op->args[1])->z_mask;
>       z_mask = extract64(z_mask_old, pos, len);
> -    if (pos == 0) {
> -        ctx->a_mask = z_mask_old ^ z_mask;
> +    if (pos == 0 && fold_affected_mask(ctx, op, z_mask_old ^ z_mask)) {
> +        return true;
>       }
>       ctx->z_mask = z_mask;
>       ctx->s_mask = smask_from_zmask(z_mask);
> @@ -1777,8 +1790,8 @@ static bool fold_exts(OptContext *ctx, TCGOp *op)
>   
>       ctx->z_mask = z_mask;
>       ctx->s_mask = s_mask;
> -    if (!type_change) {
> -        ctx->a_mask = s_mask & ~s_mask_old;
> +    if (!type_change && fold_affected_mask(ctx, op, s_mask & ~s_mask_old)) {
> +        return true;
>       }
>   
>       return fold_masks(ctx, op);
> @@ -1819,8 +1832,8 @@ static bool fold_extu(OptContext *ctx, TCGOp *op)
>   
>       ctx->z_mask = z_mask;
>       ctx->s_mask = smask_from_zmask(z_mask);
> -    if (!type_change) {
> -        ctx->a_mask = z_mask_old ^ z_mask;
> +    if (!type_change && fold_affected_mask(ctx, op, z_mask_old ^ z_mask)) {
> +        return true;
>       }
>       return fold_masks(ctx, op);
>   }
> @@ -2482,8 +2495,8 @@ static bool fold_sextract(OptContext *ctx, TCGOp *op)
>       s_mask |= MAKE_64BIT_MASK(len, 64 - len);
>       ctx->s_mask = s_mask;
>   
> -    if (pos == 0) {
> -        ctx->a_mask = s_mask & ~s_mask_old;
> +    if (pos == 0 && fold_affected_mask(ctx, op, s_mask & ~s_mask_old)) {
> +        return true;
>       }
>   
>       return fold_masks(ctx, op);
> @@ -2843,7 +2856,6 @@ void tcg_optimize(TCGContext *s)
>           }
>   
>           /* Assume all bits affected, no bits known zero, no sign reps. */
> -        ctx.a_mask = -1;
>           ctx.z_mask = -1;
>           ctx.s_mask = 0;
>   

Reviewed-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
diff mbox series

Patch

diff --git a/tcg/optimize.c b/tcg/optimize.c
index 453e8c43bd..6757fe0036 100644
--- a/tcg/optimize.c
+++ b/tcg/optimize.c
@@ -64,7 +64,6 @@  typedef struct OptContext {
     QSIMPLEQ_HEAD(, MemCopyInfo) mem_free;
 
     /* In flight values from optimization. */
-    uint64_t a_mask;  /* mask bit is 0 iff value identical to first input */
     uint64_t z_mask;  /* mask bit is 0 iff value bit is 0 */
     uint64_t s_mask;  /* mask of clrsb(value) bits */
     TCGType type;
@@ -1047,7 +1046,6 @@  static bool fold_const2_commutative(OptContext *ctx, TCGOp *op)
 
 static bool fold_masks(OptContext *ctx, TCGOp *op)
 {
-    uint64_t a_mask = ctx->a_mask;
     uint64_t z_mask = ctx->z_mask;
     uint64_t s_mask = ctx->s_mask;
 
@@ -1059,7 +1057,6 @@  static bool fold_masks(OptContext *ctx, TCGOp *op)
      * type changing opcodes.
      */
     if (ctx->type == TCG_TYPE_I32) {
-        a_mask = (int32_t)a_mask;
         z_mask = (int32_t)z_mask;
         s_mask |= MAKE_64BIT_MASK(32, 32);
         ctx->z_mask = z_mask;
@@ -1069,6 +1066,19 @@  static bool fold_masks(OptContext *ctx, TCGOp *op)
     if (z_mask == 0) {
         return tcg_opt_gen_movi(ctx, op, op->args[0], 0);
     }
+    return false;
+}
+
+/*
+ * An "affected" mask bit is 0 if and only if the result is identical
+ * to the first input.  Thus if the entire mask is 0, the operation
+ * is equivalent to a copy.
+ */
+static bool fold_affected_mask(OptContext *ctx, TCGOp *op, uint64_t a_mask)
+{
+    if (ctx->type == TCG_TYPE_I32) {
+        a_mask = (uint32_t)a_mask;
+    }
     if (a_mask == 0) {
         return tcg_opt_gen_mov(ctx, op, op->args[0], op->args[1]);
     }
@@ -1305,8 +1315,9 @@  static bool fold_and(OptContext *ctx, TCGOp *op)
      * Known-zeros does not imply known-ones.  Therefore unless
      * arg2 is constant, we can't infer affected bits from it.
      */
-    if (arg_is_const(op->args[2])) {
-        ctx->a_mask = z1 & ~z2;
+    if (arg_is_const(op->args[2]) &&
+        fold_affected_mask(ctx, op, z1 & ~z2)) {
+        return true;
     }
 
     return fold_masks(ctx, op);
@@ -1331,7 +1342,9 @@  static bool fold_andc(OptContext *ctx, TCGOp *op)
      */
     if (arg_is_const(op->args[2])) {
         uint64_t z2 = ~arg_info(op->args[2])->z_mask;
-        ctx->a_mask = z1 & ~z2;
+        if (fold_affected_mask(ctx, op, z1 & ~z2)) {
+            return true;
+        }
         z1 &= z2;
     }
     ctx->z_mask = z1;
@@ -1709,8 +1722,8 @@  static bool fold_extract(OptContext *ctx, TCGOp *op)
 
     z_mask_old = arg_info(op->args[1])->z_mask;
     z_mask = extract64(z_mask_old, pos, len);
-    if (pos == 0) {
-        ctx->a_mask = z_mask_old ^ z_mask;
+    if (pos == 0 && fold_affected_mask(ctx, op, z_mask_old ^ z_mask)) {
+        return true;
     }
     ctx->z_mask = z_mask;
     ctx->s_mask = smask_from_zmask(z_mask);
@@ -1777,8 +1790,8 @@  static bool fold_exts(OptContext *ctx, TCGOp *op)
 
     ctx->z_mask = z_mask;
     ctx->s_mask = s_mask;
-    if (!type_change) {
-        ctx->a_mask = s_mask & ~s_mask_old;
+    if (!type_change && fold_affected_mask(ctx, op, s_mask & ~s_mask_old)) {
+        return true;
     }
 
     return fold_masks(ctx, op);
@@ -1819,8 +1832,8 @@  static bool fold_extu(OptContext *ctx, TCGOp *op)
 
     ctx->z_mask = z_mask;
     ctx->s_mask = smask_from_zmask(z_mask);
-    if (!type_change) {
-        ctx->a_mask = z_mask_old ^ z_mask;
+    if (!type_change && fold_affected_mask(ctx, op, z_mask_old ^ z_mask)) {
+        return true;
     }
     return fold_masks(ctx, op);
 }
@@ -2482,8 +2495,8 @@  static bool fold_sextract(OptContext *ctx, TCGOp *op)
     s_mask |= MAKE_64BIT_MASK(len, 64 - len);
     ctx->s_mask = s_mask;
 
-    if (pos == 0) {
-        ctx->a_mask = s_mask & ~s_mask_old;
+    if (pos == 0 && fold_affected_mask(ctx, op, s_mask & ~s_mask_old)) {
+        return true;
     }
 
     return fold_masks(ctx, op);
@@ -2843,7 +2856,6 @@  void tcg_optimize(TCGContext *s)
         }
 
         /* Assume all bits affected, no bits known zero, no sign reps. */
-        ctx.a_mask = -1;
         ctx.z_mask = -1;
         ctx.s_mask = 0;