[JIT] X64/ARM64 - CAST removals for small types on ADD, SUB, MUL, AND, OR, XOR, NOT, NEG

src/coreclr/jit/compiler.h

@@ -4783,6 +4783,8 @@ class Compiler
     // lowering that is distributed between fgMorph and the lowering phase of LSRA.
     PhaseStatus fgSimpleLowering();
 
+    bool fgSimpleLowerCastOfSmpOp(LIR::Range& range, GenTreeCast* cast);
+
 #if FEATURE_LOOP_ALIGN
     PhaseStatus placeLoopAlignInstructions();
 #endif

src/coreclr/jit/flowgraph.cpp

@@ -2989,6 +2989,15 @@ PhaseStatus Compiler::fgSimpleLowering()
                 }
 #endif // FEATURE_FIXED_OUT_ARGS
 
+                case GT_CAST:
+                {
+                    if (tree->AsCast()->CastOp()->OperIsSimple() && fgSimpleLowerCastOfSmpOp(range, tree->AsCast()))
+                    {
+                        madeChanges = true;
+                    }
+                    break;
+                }
+
                 default:
                 {
                     // No other operators need processing.
@@ -3047,6 +3056,91 @@ PhaseStatus Compiler::fgSimpleLowering()
     return madeChanges ? PhaseStatus::MODIFIED_EVERYTHING : PhaseStatus::MODIFIED_NOTHING;
 }
 
+//------------------------------------------------------------------------
+// fgSimpleLowerCastOfSmpOp: Optimization to remove CAST nodes from operands of some simple ops that are safe to do so
+// since the upper bits do not affect the lower bits, and result of the simple op is zero/sign-extended via a CAST.
+// Example:
+//      CAST(ADD(CAST(x), CAST(y))) transforms to CAST(ADD(x, y))
+//
+// Returns:
+//      True or false, representing changes were made.
+//
+// Notes:
+//      This optimization could be done in morph, but it cannot because there are correctness
+//      problems with NOLs (normalized-on-load locals) and how they are handled in VN.
+//      Simple put, you cannot remove a CAST from CAST(LCL_VAR{nol}) in HIR.
+//
+//      Because the optimization happens after rationalization, turning into LIR, it is safe to remove the CAST.
+//
+bool Compiler::fgSimpleLowerCastOfSmpOp(LIR::Range& range, GenTreeCast* cast)
+{
+    GenTree*  castOp     = cast->CastOp();
+    var_types castToType = cast->CastToType();
+    var_types srcType    = castOp->TypeGet();
+
+    assert(castOp->OperIsSimple());
+
+    if (opts.OptimizationDisabled())
+        return false;
+
+    if (cast->gtOverflow())
+        return false;
+
+    if (castOp->OperMayOverflow() && castOp->gtOverflow())
+        return false;
+
+    // Only optimize if the castToType is a small integer type.
+    // Only optimize if the srcType is an integer type.
+    if (!varTypeIsSmall(castToType) || !varTypeIsIntegral(srcType))
+        return false;
+
+    // These are the only safe ops where the CAST is not necessary for the inputs.
+    if (castOp->OperIs(GT_ADD, GT_SUB, GT_MUL, GT_AND, GT_XOR, GT_OR, GT_NOT, GT_NEG))
+    {
+        bool madeChanges = false;
+
+        if (castOp->gtGetOp1()->OperIs(GT_CAST))
+        {
+            GenTreeCast* op1 = castOp->gtGetOp1()->AsCast();
+
+            if (!op1->gtOverflow() && (genActualType(op1->CastOp()) == genActualType(srcType)) &&
+                (castToType == op1->CastToType()))
+            {
+                // Removes the cast.
+                castOp->AsOp()->gtOp1 = op1->CastOp();
+                range.Remove(op1);
+                madeChanges = true;
+            }
+        }
+
+        if (castOp->OperIsBinary() && castOp->gtGetOp2()->OperIs(GT_CAST))
+        {
+            GenTreeCast* op2 = castOp->gtGetOp2()->AsCast();
+
+            if (!op2->gtOverflow() && (genActualType(op2->CastOp()) == genActualType(srcType)) &&
+                (castToType == op2->CastToType()))
+            {
+                // Removes the cast.
+                castOp->AsOp()->gtOp2 = op2->CastOp();
+                range.Remove(op2);
+                madeChanges = true;
+            }
+        }
+
+#ifdef DEBUG
+        if (madeChanges)
+        {
+            JITDUMP("Lower - Cast of Simple Op %s:\n", GenTree::OpName(cast->OperGet()));
+            DISPTREE(cast);
+        }
+#endif // DEBUG
+
+        return madeChanges;
+    }
+
+    return false;
+}
+
 /*****************************************************************************************************
  *
  *  Function to return the last basic block in the main part of the function. With funclets, it is

src/tests/JIT/opt/Add/IntAdd.cs

@@ -0,0 +1,150 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace CodeGenTests
+{
+    static class IntAdd
+    {
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static sbyte Int8_Add(sbyte x, sbyte y)
+        {
+            // X64-NOT: movsx
+
+            // X64:      add
+            // X64-NEXT: movsx
+
+            return (sbyte)(x + y);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static byte UInt8_Add(byte x, byte y)
+        {
+            // X64-NOT: movzx
+
+            // X64:      add
+            // X64-NEXT: movzx
+
+            return (byte)(x + y);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static short Int16_Add(short x, short y)
+        {
+            // X64-NOT: movsx
+
+            // X64:      add
+            // X64-NEXT: movsx
+
+            // X64-NOT: cwde
+
+            return (short)(x + y);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static ushort UInt16_Add(ushort x, ushort y)
+        {
+            // X64-NOT: movzx
+
+            // X64:      add
+            // X64-NEXT: movzx
+
+            return (ushort)(x + y);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static int Int32_Add(int x, int y)
+        {
+            // X64: lea
+
+            return x + y;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static uint UInt32_Add(uint x, uint y)
+        {
+            // X64: lea
+
+            return x + y;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static long Int64_Add(long x, long y)
+        {
+            // X64: lea
+
+            return x + y;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static ulong UInt64_Add(ulong x, ulong y)
+        {
+            // X64: lea
+
+            return x + y;
+        }
+
+        static int Main()
+        {
+            // Int8
+            if (Int8_Add(SByte.MaxValue, 15) != -114)
+                return 0;
+
+            if (Int8_Add(15, SByte.MaxValue) != -114)
+                return 0;
+
+            // UInt8
+            if (UInt8_Add(Byte.MaxValue, 15) != 14)
+                return 0;
+
+            if (UInt8_Add(15, Byte.MaxValue) != 14)
+                return 0;
+
+            // Int16
+            if (Int16_Add(Int16.MaxValue, 15) != -32754)
+                return 0;
+
+            if (Int16_Add(15, Int16.MaxValue) != -32754)
+                return 0;
+
+            // UInt16
+            if (UInt16_Add(UInt16.MaxValue, 15) != 14)
+                return 0;
+
+            if (UInt16_Add(15, UInt16.MaxValue) != 14)
+                return 0;
+
+            // Int32
+            if (Int32_Add(Int32.MaxValue, 15) != -2147483634)
+                return 0;
+
+            if (Int32_Add(15, Int32.MaxValue) != -2147483634)
+                return 0;
+
+            // UInt32
+            if (UInt32_Add(UInt32.MaxValue, 15) != 14)
+                return 0;
+
+            if (UInt32_Add(15, UInt32.MaxValue) != 14)
+                return 0;
+
+            // Int64
+            if (Int64_Add(Int64.MaxValue, 15) != -9223372036854775794)
+                return 0;
+
+            if (Int64_Add(15, Int64.MaxValue) != -9223372036854775794)
+                return 0;
+
+            // UInt64
+            if (UInt64_Add(UInt64.MaxValue, 15) != 14)
+                return 0;
+
+            if (UInt64_Add(15, UInt64.MaxValue) != 14)
+                return 0;
+
+            return 100;
+        }
+    }
+}

src/tests/JIT/opt/Add/IntAdd.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildProjectName).cs">
+      <HasDisasmCheck>true</HasDisasmCheck>
+    </Compile>
+
+    <CLRTestEnvironmentVariable Include="DOTNET_TieredCompilation" Value="0" />
+    <CLRTestEnvironmentVariable Include="DOTNET_JITMinOpts" Value="0" />
+  </ItemGroup>
+</Project>