Eliminate redundant abs on zero extension
Bug: b/74026074
Test: test-art-host,target
Change-Id: Ic97c866e3843cd172dfae9652104efe33fced8e5
diff --git a/compiler/optimizing/data_type.h b/compiler/optimizing/data_type.h
index 4a6c914..be26e67 100644
--- a/compiler/optimizing/data_type.h
+++ b/compiler/optimizing/data_type.h
@@ -210,6 +210,12 @@
static bool IsTypeConversionImplicit(Type input_type, Type result_type);
static bool IsTypeConversionImplicit(int64_t value, Type result_type);
+ static bool IsZeroExtension(Type input_type, Type result_type) {
+ return IsIntOrLongType(result_type) &&
+ IsUnsignedType(input_type) &&
+ Size(result_type) > Size(input_type);
+ }
+
static const char* PrettyDescriptor(Type type);
private:
diff --git a/compiler/optimizing/instruction_simplifier.cc b/compiler/optimizing/instruction_simplifier.cc
index 676fe6b..da37037 100644
--- a/compiler/optimizing/instruction_simplifier.cc
+++ b/compiler/optimizing/instruction_simplifier.cc
@@ -67,7 +67,6 @@
bool TryCombineVecMultiplyAccumulate(HVecMul* mul);
void VisitShift(HBinaryOperation* shift);
-
void VisitEqual(HEqual* equal) OVERRIDE;
void VisitNotEqual(HNotEqual* equal) OVERRIDE;
void VisitBooleanNot(HBooleanNot* bool_not) OVERRIDE;
@@ -78,6 +77,7 @@
void VisitNullCheck(HNullCheck* instruction) OVERRIDE;
void VisitArrayLength(HArrayLength* instruction) OVERRIDE;
void VisitCheckCast(HCheckCast* instruction) OVERRIDE;
+ void VisitAbs(HAbs* instruction) OVERRIDE;
void VisitAdd(HAdd* instruction) OVERRIDE;
void VisitAnd(HAnd* instruction) OVERRIDE;
void VisitCondition(HCondition* instruction) OVERRIDE;
@@ -1241,6 +1241,17 @@
}
}
+void InstructionSimplifierVisitor::VisitAbs(HAbs* instruction) {
+ HInstruction* input = instruction->GetInput();
+ if (DataType::IsZeroExtension(input->GetType(), instruction->GetResultType())) {
+ // Zero extension from narrow to wide can never set sign bit in the wider
+ // operand, making the subsequent Abs redundant (e.g., abs(b & 0xff) for byte b).
+ instruction->ReplaceWith(input);
+ instruction->GetBlock()->RemoveInstruction(instruction);
+ RecordSimplification();
+ }
+}
+
void InstructionSimplifierVisitor::VisitAdd(HAdd* instruction) {
HConstant* input_cst = instruction->GetConstantRight();
HInstruction* input_other = instruction->GetLeastConstantLeft();
diff --git a/test/645-checker-abs-simd/src/Main.java b/test/645-checker-abs-simd/src/Main.java
index 870a403..819304a 100644
--- a/test/645-checker-abs-simd/src/Main.java
+++ b/test/645-checker-abs-simd/src/Main.java
@@ -48,10 +48,7 @@
}
/// CHECK-START: void Main.doitChar(char[]) loop_optimization (before)
- /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
- /// CHECK-DAG: ArrayGet loop:<<Loop>> outer_loop:none
- /// CHECK-DAG: Abs loop:<<Loop>> outer_loop:none
- /// CHECK-DAG: ArraySet loop:<<Loop>> outer_loop:none
+ /// CHECK-NOT: Abs
//
/// CHECK-START: void Main.doitChar(char[]) loop_optimization (after)
/// CHECK-NOT: VecAbs
diff --git a/test/681-checker-abs/src/Main.java b/test/681-checker-abs/src/Main.java
index 8064b1d..d1ba7c6 100644
--- a/test/681-checker-abs/src/Main.java
+++ b/test/681-checker-abs/src/Main.java
@@ -19,6 +19,38 @@
*/
public class Main {
+ /// CHECK-START: int Main.absI(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Par:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Abs:i\d+>> InvokeStaticOrDirect [<<Par>>] intrinsic:MathAbsInt
+ /// CHECK-DAG: Return [<<Abs>>]
+ //
+ /// CHECK-START: int Main.absI(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Par:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
+ /// CHECK-DAG: Return [<<Abs>>]
+ //
+ /// CHECK-START: int Main.absI(int) instruction_simplifier (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
+ public static int absI(int a) {
+ return Math.abs(a);
+ }
+
+ /// CHECK-START: long Main.absL(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Par:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Abs:j\d+>> InvokeStaticOrDirect [<<Par>>] intrinsic:MathAbsLong
+ /// CHECK-DAG: Return [<<Abs>>]
+ //
+ /// CHECK-START: long Main.absL(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Par:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Abs:j\d+>> Abs [<<Par>>]
+ /// CHECK-DAG: Return [<<Abs>>]
+ //
+ /// CHECK-START: long Main.absL(long) instruction_simplifier (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
+ public static long absL(long a) {
+ return Math.abs(a);
+ }
+
/// CHECK-START: int Main.abs1(int) instruction_simplifier$after_inlining (before)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
@@ -152,7 +184,74 @@
return a >= 0 ? a : -a;
}
+ //
+ // Nop zero extension.
+ //
+
+ /// CHECK-START: int Main.zabs1(byte) instruction_simplifier (before)
+ /// CHECK-DAG: <<Par:b\d+>> ParameterValue
+ /// CHECK-DAG: <<Msk:i\d+>> IntConstant 255
+ /// CHECK-DAG: <<And:i\d+>> [<<Par>>,<<Msk>>]
+ /// CHECK-DAG: <<Abs:i\d+>> InvokeStaticOrDirect [<<And>>] intrinsic:MathAbsInt
+ /// CHECK-DAG: Return [<<Abs>>]
+ //
+ /// CHECK-START: int Main.zabs1(byte) instruction_simplifier (after)
+ /// CHECK-DAG: <<Par:b\d+>> ParameterValue
+ /// CHECK-DAG: <<Cnv:a\d+>> TypeConversion [<<Par>>]
+ /// CHECK-DAG: Return [<<Cnv>>]
+ //
+ /// CHECK-START: int Main.zabs1(byte) instruction_simplifier (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-NOT: Abs
+ public static int zabs1(byte a) {
+ return Math.abs(a & 0xff);
+ }
+
+ /// CHECK-START: int Main.zabs2(short) instruction_simplifier (before)
+ /// CHECK-DAG: <<Par:s\d+>> ParameterValue
+ /// CHECK-DAG: <<Msk:i\d+>> IntConstant 65535
+ /// CHECK-DAG: <<And:i\d+>> [<<Msk>>,<<Par>>]
+ /// CHECK-DAG: <<Abs:i\d+>> InvokeStaticOrDirect [<<And>>] intrinsic:MathAbsInt
+ /// CHECK-DAG: Return [<<Abs>>]
+ //
+ /// CHECK-START: int Main.zabs2(short) instruction_simplifier (after)
+ /// CHECK-DAG: <<Par:s\d+>> ParameterValue
+ /// CHECK-DAG: <<Cnv:c\d+>> TypeConversion [<<Par>>]
+ /// CHECK-DAG: Return [<<Cnv>>]
+ //
+ /// CHECK-START: int Main.zabs2(short) instruction_simplifier (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-NOT: Abs
+ public static int zabs2(short a) {
+ return Math.abs(a & 0xffff);
+ }
+
+ /// CHECK-START: int Main.zabs3(char) instruction_simplifier (before)
+ /// CHECK-DAG: <<Par:c\d+>> ParameterValue
+ /// CHECK-DAG: <<Abs:i\d+>> InvokeStaticOrDirect [<<Par>>] intrinsic:MathAbsInt
+ /// CHECK-DAG: Return [<<Abs>>]
+ //
+ /// CHECK-START: int Main.zabs3(char) instruction_simplifier (after)
+ /// CHECK-DAG: <<Par:c\d+>> ParameterValue
+ /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
+ /// CHECK-DAG: Return [<<Abs>>]
+ //
+ /// CHECK-START: int Main.zabs3(char) instruction_simplifier$after_inlining (after)
+ /// CHECK-DAG: <<Par:c\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Par>>]
+ //
+ /// CHECK-START: int Main.zabs3(char) instruction_simplifier$after_inlining (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-NOT: Abs
+ public static int zabs3(char a) {
+ return Math.abs(a);
+ }
+
public static void main(String[] args) {
+ expectEquals(10, absI(-10));
+ expectEquals(20, absI(20));
+ expectEquals(10L, absL(-10L));
+ expectEquals(20L, absL(20L));
expectEquals(10, abs1(-10));
expectEquals(20, abs1(20));
expectEquals(10, abs2(-10));
@@ -167,6 +266,12 @@
expectEquals(20, abs6((byte) 20));
expectEquals(10L, abs7(-10L));
expectEquals(20L, abs7(20L));
+ expectEquals(1, zabs1((byte) 1));
+ expectEquals(0xff, zabs1((byte) -1));
+ expectEquals(1, zabs2((short) 1));
+ expectEquals(0xffff, zabs2((short) -1));
+ expectEquals(1, zabs3((char) 1));
+ expectEquals(0xffff, zabs3((char) -1));
System.out.println("passed");
}