Optimize Vector128<long> multiplication for arm64 (#104177)

Author: EgorBo

src/coreclr/jit/gentree.cpp

@@ -21909,7 +21909,6 @@ GenTree* Compiler::gtNewSimdBinOpNode(
 
         case GT_MUL:
         {
-            assert(!varTypeIsLong(simdBaseType));
             GenTree** scalarOp = nullptr;
 
             if (varTypeIsArithmetic(op1))
@@ -21973,6 +21972,42 @@ GenTree* Compiler::gtNewSimdBinOpNode(
                     break;
                 }
 
+                case TYP_LONG:
+                case TYP_ULONG:
+                {
+                    if (simdSize == 8)
+                    {
+                        // Vector64<long> vec = Vector64.CreateScalar(op1.ToScalar() * op2.ToScalar())
+                        op1            = gtNewBitCastNode(TYP_LONG, op1);
+                        op2            = gtNewBitCastNode(TYP_LONG, op2);
+                        GenTreeOp* mul = gtNewOperNode(GT_MUL, TYP_LONG, op1, op2);
+                        return gtNewSimdCreateScalarNode(TYP_SIMD8, mul, simdBaseJitType, 8);
+                    }
+
+                    // Make op1 and op2 multi-use:
+                    GenTree* op1Dup = fgMakeMultiUse(&op1);
+                    GenTree* op2Dup = fgMakeMultiUse(&op2);
+
+                    // long left0  = op1.GetElement(0)
+                    // long right0 = op2.GetElement(0)
+                    GenTree* left0 = gtNewSimdToScalarNode(TYP_LONG, op1, simdBaseJitType, 16);
+                    GenTree* right0 =
+                        scalarOp != nullptr ? op2 : gtNewSimdToScalarNode(TYP_LONG, op2, simdBaseJitType, 16);
+
+                    // long left1  = op1.GetElement(1)
+                    // long right1 = op2.GetElement(1)
+                    GenTree* left1  = gtNewSimdGetElementNode(TYP_LONG, op1Dup, gtNewIconNode(1), simdBaseJitType, 16);
+                    GenTree* right1 = scalarOp != nullptr ? op2Dup
+                                                          : gtNewSimdGetElementNode(TYP_LONG, op2Dup, gtNewIconNode(1),
+                                                                                    simdBaseJitType, 16);
+
+                    // Vector128<long> vec = Vector128.Create(left0 * right0, left1 * right1)
+                    op1          = gtNewOperNode(GT_MUL, TYP_LONG, left0, right0);
+                    op2          = gtNewOperNode(GT_MUL, TYP_LONG, left1, right1);
+                    GenTree* vec = gtNewSimdCreateScalarUnsafeNode(type, op1, simdBaseJitType, 16);
+                    return gtNewSimdWithElementNode(type, vec, gtNewIconNode(1), op2, simdBaseJitType, 16);
+                }
+
                 default:
                 {
                     unreached();

src/coreclr/jit/hwintrinsicarm64.cpp

@@ -1773,12 +1773,6 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
         {
             assert(sig->numArgs == 2);
 
-            if (varTypeIsLong(simdBaseType))
-            {
-                // TODO-ARM64-CQ: We should support long/ulong multiplication.
-                break;
-            }
-
             CORINFO_ARG_LIST_HANDLE arg1     = sig->args;
             CORINFO_ARG_LIST_HANDLE arg2     = info.compCompHnd->getArgNext(arg1);
             var_types               argType  = TYP_UNKNOWN;