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");
   }