diff --git a/src/coreclr/src/jit/hwintrinsic.cpp b/src/coreclr/src/jit/hwintrinsic.cpp
index 16332b859894b..ffa9cd5db1259 100644
--- a/src/coreclr/src/jit/hwintrinsic.cpp
+++ b/src/coreclr/src/jit/hwintrinsic.cpp
@@ -646,24 +646,26 @@ static bool isSupportedBaseType(NamedIntrinsic intrinsic, var_types baseType)
            (intrinsic == NI_Vector256_get_Zero) || (intrinsic == NI_Vector256_GetElement) ||
            (intrinsic == NI_Vector256_WithElement) || (intrinsic == NI_Vector256_GetLower) ||
            (intrinsic == NI_Vector256_ToScalar));
-#else
-    assert((intrinsic == NI_Vector64_AsByte) || (intrinsic == NI_Vector64_AsInt16) ||
-           (intrinsic == NI_Vector64_AsInt32) || (intrinsic == NI_Vector64_AsSByte) ||
+#endif // TARGET_XARCH
+#ifdef TARGET_ARM64
+    assert((intrinsic == NI_Vector64_AsByte) || (intrinsic == NI_Vector64_AsDouble) ||
+           (intrinsic == NI_Vector64_AsInt16) || (intrinsic == NI_Vector64_AsInt32) ||
+           (intrinsic == NI_Vector64_AsInt64) || (intrinsic == NI_Vector64_AsSByte) ||
            (intrinsic == NI_Vector64_AsSingle) || (intrinsic == NI_Vector64_AsUInt16) ||
-           (intrinsic == NI_Vector64_AsUInt32) || (intrinsic == NI_Vector64_get_AllBitsSet) ||
-           (intrinsic == NI_Vector64_get_Count) || (intrinsic == NI_Vector64_get_Zero) ||
-           (intrinsic == NI_Vector64_GetElement) || (intrinsic == NI_Vector64_ToScalar) ||
-           (intrinsic == NI_Vector64_ToVector128) || (intrinsic == NI_Vector64_ToVector128Unsafe) ||
-           (intrinsic == NI_Vector128_As) || (intrinsic == NI_Vector128_AsByte) ||
-           (intrinsic == NI_Vector128_AsDouble) || (intrinsic == NI_Vector128_AsInt16) ||
-           (intrinsic == NI_Vector128_AsInt32) || (intrinsic == NI_Vector128_AsInt64) ||
-           (intrinsic == NI_Vector128_AsSByte) || (intrinsic == NI_Vector128_AsSingle) ||
-           (intrinsic == NI_Vector128_AsUInt16) || (intrinsic == NI_Vector128_AsUInt32) ||
-           (intrinsic == NI_Vector128_AsUInt64) || (intrinsic == NI_Vector128_get_AllBitsSet) ||
-           (intrinsic == NI_Vector128_get_Count) || (intrinsic == NI_Vector128_get_Zero) ||
-           (intrinsic == NI_Vector128_GetElement) || (intrinsic == NI_Vector128_GetLower) ||
-           (intrinsic == NI_Vector128_ToScalar));
-#endif
+           (intrinsic == NI_Vector64_AsUInt32) || (intrinsic == NI_Vector64_AsUInt64) ||
+           (intrinsic == NI_Vector64_get_AllBitsSet) || (intrinsic == NI_Vector64_get_Count) ||
+           (intrinsic == NI_Vector64_get_Zero) || (intrinsic == NI_Vector64_GetElement) ||
+           (intrinsic == NI_Vector64_ToScalar) || (intrinsic == NI_Vector64_ToVector128) ||
+           (intrinsic == NI_Vector64_ToVector128Unsafe) || (intrinsic == NI_Vector128_As) ||
+           (intrinsic == NI_Vector128_AsByte) || (intrinsic == NI_Vector128_AsDouble) ||
+           (intrinsic == NI_Vector128_AsInt16) || (intrinsic == NI_Vector128_AsInt32) ||
+           (intrinsic == NI_Vector128_AsInt64) || (intrinsic == NI_Vector128_AsSByte) ||
+           (intrinsic == NI_Vector128_AsSingle) || (intrinsic == NI_Vector128_AsUInt16) ||
+           (intrinsic == NI_Vector128_AsUInt32) || (intrinsic == NI_Vector128_AsUInt64) ||
+           (intrinsic == NI_Vector128_get_AllBitsSet) || (intrinsic == NI_Vector128_get_Count) ||
+           (intrinsic == NI_Vector128_get_Zero) || (intrinsic == NI_Vector128_GetElement) ||
+           (intrinsic == NI_Vector128_GetLower) || (intrinsic == NI_Vector128_ToScalar));
+#endif // TARGET_ARM64
     return false;
 }
 
diff --git a/src/coreclr/src/jit/hwintrinsicarm64.cpp b/src/coreclr/src/jit/hwintrinsicarm64.cpp
index dc7bbcab49f04..f777076cb3313 100644
--- a/src/coreclr/src/jit/hwintrinsicarm64.cpp
+++ b/src/coreclr/src/jit/hwintrinsicarm64.cpp
@@ -359,12 +359,15 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
     switch (intrinsic)
     {
         case NI_Vector64_AsByte:
+        case NI_Vector64_AsDouble:
         case NI_Vector64_AsInt16:
         case NI_Vector64_AsInt32:
+        case NI_Vector64_AsInt64:
         case NI_Vector64_AsSByte:
         case NI_Vector64_AsSingle:
         case NI_Vector64_AsUInt16:
         case NI_Vector64_AsUInt32:
+        case NI_Vector64_AsUInt64:
         case NI_Vector128_As:
         case NI_Vector128_AsByte:
         case NI_Vector128_AsDouble:
diff --git a/src/coreclr/src/jit/hwintrinsiclistarm64.h b/src/coreclr/src/jit/hwintrinsiclistarm64.h
index be8a0d552da75..bee94748b4a8c 100644
--- a/src/coreclr/src/jit/hwintrinsiclistarm64.h
+++ b/src/coreclr/src/jit/hwintrinsiclistarm64.h
@@ -17,12 +17,15 @@
 // ***************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************
 //  Vector64 Intrinsics
 HARDWARE_INTRINSIC(Vector64,      AsByte,                                                      8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},           HW_Category_Helper,       HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector64,      AsDouble,                                                    8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},           HW_Category_Helper,       HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      AsInt16,                                                     8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},           HW_Category_Helper,       HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      AsInt32,                                                     8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},           HW_Category_Helper,       HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector64,      AsInt64,                                                     8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},           HW_Category_Helper,       HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      AsSByte,                                                     8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},           HW_Category_Helper,       HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      AsSingle,                                                    8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},           HW_Category_Helper,       HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      AsUInt16,                                                    8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},           HW_Category_Helper,       HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      AsUInt32,                                                    8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},           HW_Category_Helper,       HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector64,      AsUInt64,                                                    8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},           HW_Category_Helper,       HW_Flag_SpecialImport|HW_Flag_NoCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      Create,                                                      8,     -1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_mov,            INS_mov,            INS_invalid,        INS_invalid},           HW_Category_Helper,       HW_Flag_SpecialImport|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(Vector64,      CreateScalarUnsafe,                                          8,      1,     {INS_ins,            INS_ins,            INS_ins,            INS_ins,            INS_ins,            INS_ins,            INS_invalid,        INS_invalid,        INS_fmov,           INS_invalid},           HW_Category_SimpleSIMD,   HW_Flag_SupportsContainment|HW_Flag_SpecialCodeGen)
 HARDWARE_INTRINSIC(Vector64,      get_AllBitsSet,                                              8,      0,     {INS_mvni,           INS_mvni,           INS_mvni,           INS_mvni,           INS_mvni,           INS_mvni,           INS_mvni,           INS_mvni,           INS_mvni,           INS_mvni},              HW_Category_Helper,       HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs
index f2b4fe0ae6d9d..bb78662d38f03 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs
@@ -935,45 +935,78 @@ static Vector128<ulong> SoftwareFallback(ulong e0, ulong e1)
         /// <param name="lower">The value that the lower 64-bits will be initialized to.</param>
         /// <param name="upper">The value that the upper 64-bits will be initialized to.</param>
         /// <returns>A new <see cref="Vector128{Byte}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe Vector128<byte> Create(Vector64<byte> lower, Vector64<byte> upper)
         {
-            Vector128<byte> result128 = Vector128<byte>.Zero;
+            if (AdvSimd.IsSupported)
+            {
+                return lower.ToVector128Unsafe().WithUpper(upper);
+            }
+
+            return SoftwareFallback(lower, upper);
+
+            static Vector128<byte> SoftwareFallback(Vector64<byte> lower, Vector64<byte> upper)
+            {
+                Vector128<byte> result128 = Vector128<byte>.Zero;
 
-            ref Vector64<byte> result64 = ref Unsafe.As<Vector128<byte>, Vector64<byte>>(ref result128);
-            result64 = lower;
-            Unsafe.Add(ref result64, 1) = upper;
+                ref Vector64<byte> result64 = ref Unsafe.As<Vector128<byte>, Vector64<byte>>(ref result128);
+                result64 = lower;
+                Unsafe.Add(ref result64, 1) = upper;
 
-            return result128;
+                return result128;
+            }
         }
 
         /// <summary>Creates a new <see cref="Vector128{Double}" /> instance from two <see cref="Vector64{Double}" /> instances.</summary>
         /// <param name="lower">The value that the lower 64-bits will be initialized to.</param>
         /// <param name="upper">The value that the upper 64-bits will be initialized to.</param>
         /// <returns>A new <see cref="Vector128{Double}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe Vector128<double> Create(Vector64<double> lower, Vector64<double> upper)
         {
-            Vector128<double> result128 = Vector128<double>.Zero;
+            if (AdvSimd.IsSupported)
+            {
+                return lower.ToVector128Unsafe().WithUpper(upper);
+            }
+
+            return SoftwareFallback(lower, upper);
 
-            ref Vector64<double> result64 = ref Unsafe.As<Vector128<double>, Vector64<double>>(ref result128);
-            result64 = lower;
-            Unsafe.Add(ref result64, 1) = upper;
+            static Vector128<double> SoftwareFallback (Vector64<double> lower, Vector64<double> upper)
+            {
+                Vector128<double> result128 = Vector128<double>.Zero;
+
+                ref Vector64<double> result64 = ref Unsafe.As<Vector128<double>, Vector64<double>>(ref result128);
+                result64 = lower;
+                Unsafe.Add(ref result64, 1) = upper;
 
-            return result128;
+                return result128;
+            }
         }
 
         /// <summary>Creates a new <see cref="Vector128{Int16}" /> instance from two <see cref="Vector64{Int16}" /> instances.</summary>
         /// <param name="lower">The value that the lower 64-bits will be initialized to.</param>
         /// <param name="upper">The value that the upper 64-bits will be initialized to.</param>
         /// <returns>A new <see cref="Vector128{Int16}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe Vector128<short> Create(Vector64<short> lower, Vector64<short> upper)
         {
-            Vector128<short> result128 = Vector128<short>.Zero;
+            if (AdvSimd.IsSupported)
+            {
+                return lower.ToVector128Unsafe().WithUpper(upper);
+            }
 
-            ref Vector64<short> result64 = ref Unsafe.As<Vector128<short>, Vector64<short>>(ref result128);
-            result64 = lower;
-            Unsafe.Add(ref result64, 1) = upper;
+            return SoftwareFallback(lower, upper);
 
-            return result128;
+            static Vector128<short> SoftwareFallback(Vector64<short> lower, Vector64<short> upper)
+            {
+                Vector128<short> result128 = Vector128<short>.Zero;
+
+                ref Vector64<short> result64 = ref Unsafe.As<Vector128<short>, Vector64<short>>(ref result128);
+                result64 = lower;
+                Unsafe.Add(ref result64, 1) = upper;
+
+                return result128;
+            }
         }
 
         /// <summary>Creates a new <see cref="Vector128{Int32}" /> instance from two <see cref="Vector64{Int32}" /> instances.</summary>
@@ -981,30 +1014,52 @@ public static unsafe Vector128<short> Create(Vector64<short> lower, Vector64<sho
         /// <param name="upper">The value that the upper 64-bits will be initialized to.</param>
         /// <remarks>On x86, this method corresponds to __m128i _mm_setr_epi64</remarks>
         /// <returns>A new <see cref="Vector128{Int32}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe Vector128<int> Create(Vector64<int> lower, Vector64<int> upper)
         {
-            Vector128<int> result128 = Vector128<int>.Zero;
+            if (AdvSimd.IsSupported)
+            {
+                return lower.ToVector128Unsafe().WithUpper(upper);
+            }
 
-            ref Vector64<int> result64 = ref Unsafe.As<Vector128<int>, Vector64<int>>(ref result128);
-            result64 = lower;
-            Unsafe.Add(ref result64, 1) = upper;
+            return SoftwareFallback(lower, upper);
+
+            static Vector128<int> SoftwareFallback(Vector64<int> lower, Vector64<int> upper)
+            {
+                Vector128<int> result128 = Vector128<int>.Zero;
 
-            return result128;
+                ref Vector64<int> result64 = ref Unsafe.As<Vector128<int>, Vector64<int>>(ref result128);
+                result64 = lower;
+                Unsafe.Add(ref result64, 1) = upper;
+
+                return result128;
+            }
         }
 
         /// <summary>Creates a new <see cref="Vector128{Int64}" /> instance from two <see cref="Vector64{Int64}" /> instances.</summary>
         /// <param name="lower">The value that the lower 64-bits will be initialized to.</param>
         /// <param name="upper">The value that the upper 64-bits will be initialized to.</param>
         /// <returns>A new <see cref="Vector128{Int64}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe Vector128<long> Create(Vector64<long> lower, Vector64<long> upper)
         {
-            Vector128<long> result128 = Vector128<long>.Zero;
+            if (AdvSimd.IsSupported)
+            {
+                return lower.ToVector128Unsafe().WithUpper(upper);
+            }
+
+            return SoftwareFallback(lower, upper);
+
+            static Vector128<long> SoftwareFallback(Vector64<long> lower, Vector64<long> upper)
+            {
+                Vector128<long> result128 = Vector128<long>.Zero;
 
-            ref Vector64<long> result64 = ref Unsafe.As<Vector128<long>, Vector64<long>>(ref result128);
-            result64 = lower;
-            Unsafe.Add(ref result64, 1) = upper;
+                ref Vector64<long> result64 = ref Unsafe.As<Vector128<long>, Vector64<long>>(ref result128);
+                result64 = lower;
+                Unsafe.Add(ref result64, 1) = upper;
 
-            return result128;
+                return result128;
+            }
         }
 
         /// <summary>Creates a new <see cref="Vector128{SByte}" /> instance from two <see cref="Vector64{SByte}" /> instances.</summary>
@@ -1012,30 +1067,52 @@ public static unsafe Vector128<long> Create(Vector64<long> lower, Vector64<long>
         /// <param name="upper">The value that the upper 64-bits will be initialized to.</param>
         /// <returns>A new <see cref="Vector128{SByte}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns>
         [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe Vector128<sbyte> Create(Vector64<sbyte> lower, Vector64<sbyte> upper)
         {
-            Vector128<sbyte> result128 = Vector128<sbyte>.Zero;
+            if (AdvSimd.IsSupported)
+            {
+                return lower.ToVector128Unsafe().WithUpper(upper);
+            }
+
+            return SoftwareFallback(lower, upper);
 
-            ref Vector64<sbyte> result64 = ref Unsafe.As<Vector128<sbyte>, Vector64<sbyte>>(ref result128);
-            result64 = lower;
-            Unsafe.Add(ref result64, 1) = upper;
+            static Vector128<sbyte> SoftwareFallback(Vector64<sbyte> lower, Vector64<sbyte> upper)
+            {
+                Vector128<sbyte> result128 = Vector128<sbyte>.Zero;
 
-            return result128;
+                ref Vector64<sbyte> result64 = ref Unsafe.As<Vector128<sbyte>, Vector64<sbyte>>(ref result128);
+                result64 = lower;
+                Unsafe.Add(ref result64, 1) = upper;
+
+                return result128;
+            }
         }
 
         /// <summary>Creates a new <see cref="Vector128{Single}" /> instance from two <see cref="Vector64{Single}" /> instances.</summary>
         /// <param name="lower">The value that the lower 64-bits will be initialized to.</param>
         /// <param name="upper">The value that the upper 64-bits will be initialized to.</param>
         /// <returns>A new <see cref="Vector128{Single}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe Vector128<float> Create(Vector64<float> lower, Vector64<float> upper)
         {
-            Vector128<float> result128 = Vector128<float>.Zero;
+            if (AdvSimd.IsSupported)
+            {
+                return lower.ToVector128Unsafe().WithUpper(upper);
+            }
 
-            ref Vector64<float> result64 = ref Unsafe.As<Vector128<float>, Vector64<float>>(ref result128);
-            result64 = lower;
-            Unsafe.Add(ref result64, 1) = upper;
+            return SoftwareFallback(lower, upper);
 
-            return result128;
+            static Vector128<float> SoftwareFallback(Vector64<float> lower, Vector64<float> upper)
+            {
+                Vector128<float> result128 = Vector128<float>.Zero;
+
+                ref Vector64<float> result64 = ref Unsafe.As<Vector128<float>, Vector64<float>>(ref result128);
+                result64 = lower;
+                Unsafe.Add(ref result64, 1) = upper;
+
+                return result128;
+            }
         }
 
         /// <summary>Creates a new <see cref="Vector128{UInt16}" /> instance from two <see cref="Vector64{UInt16}" /> instances.</summary>
@@ -1043,15 +1120,26 @@ public static unsafe Vector128<float> Create(Vector64<float> lower, Vector64<flo
         /// <param name="upper">The value that the upper 64-bits will be initialized to.</param>
         /// <returns>A new <see cref="Vector128{UInt16}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns>
         [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe Vector128<ushort> Create(Vector64<ushort> lower, Vector64<ushort> upper)
         {
-            Vector128<ushort> result128 = Vector128<ushort>.Zero;
+            if (AdvSimd.IsSupported)
+            {
+                return lower.ToVector128Unsafe().WithUpper(upper);
+            }
+
+            return SoftwareFallback(lower, upper);
+
+            static Vector128<ushort> SoftwareFallback(Vector64<ushort> lower, Vector64<ushort> upper)
+            {
+                Vector128<ushort> result128 = Vector128<ushort>.Zero;
 
-            ref Vector64<ushort> result64 = ref Unsafe.As<Vector128<ushort>, Vector64<ushort>>(ref result128);
-            result64 = lower;
-            Unsafe.Add(ref result64, 1) = upper;
+                ref Vector64<ushort> result64 = ref Unsafe.As<Vector128<ushort>, Vector64<ushort>>(ref result128);
+                result64 = lower;
+                Unsafe.Add(ref result64, 1) = upper;
 
-            return result128;
+                return result128;
+            }
         }
 
         /// <summary>Creates a new <see cref="Vector128{UInt32}" /> instance from two <see cref="Vector64{UInt32}" /> instances.</summary>
@@ -1060,15 +1148,26 @@ public static unsafe Vector128<ushort> Create(Vector64<ushort> lower, Vector64<u
         /// <remarks>On x86, this method corresponds to __m128i _mm_setr_epi64</remarks>
         /// <returns>A new <see cref="Vector128{UInt32}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns>
         [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe Vector128<uint> Create(Vector64<uint> lower, Vector64<uint> upper)
         {
-            Vector128<uint> result128 = Vector128<uint>.Zero;
+            if (AdvSimd.IsSupported)
+            {
+                return lower.ToVector128Unsafe().WithUpper(upper);
+            }
 
-            ref Vector64<uint> result64 = ref Unsafe.As<Vector128<uint>, Vector64<uint>>(ref result128);
-            result64 = lower;
-            Unsafe.Add(ref result64, 1) = upper;
+            return SoftwareFallback(lower, upper);
 
-            return result128;
+            static Vector128<uint> SoftwareFallback(Vector64<uint> lower, Vector64<uint> upper)
+            {
+                Vector128<uint> result128 = Vector128<uint>.Zero;
+
+                ref Vector64<uint> result64 = ref Unsafe.As<Vector128<uint>, Vector64<uint>>(ref result128);
+                result64 = lower;
+                Unsafe.Add(ref result64, 1) = upper;
+
+                return result128;
+            }
         }
 
         /// <summary>Creates a new <see cref="Vector128{UInt64}" /> instance from two <see cref="Vector64{UInt64}" /> instances.</summary>
@@ -1076,15 +1175,26 @@ public static unsafe Vector128<uint> Create(Vector64<uint> lower, Vector64<uint>
         /// <param name="upper">The value that the upper 64-bits will be initialized to.</param>
         /// <returns>A new <see cref="Vector128{UInt64}" /> initialized from <paramref name="lower" /> and <paramref name="upper" />.</returns>
         [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe Vector128<ulong> Create(Vector64<ulong> lower, Vector64<ulong> upper)
         {
-            Vector128<ulong> result128 = Vector128<ulong>.Zero;
+            if (AdvSimd.IsSupported)
+            {
+                return lower.ToVector128Unsafe().WithUpper(upper);
+            }
+
+            return SoftwareFallback(lower, upper);
+
+            static Vector128<ulong> SoftwareFallback(Vector64<ulong> lower, Vector64<ulong> upper)
+            {
+                Vector128<ulong> result128 = Vector128<ulong>.Zero;
 
-            ref Vector64<ulong> result64 = ref Unsafe.As<Vector128<ulong>, Vector64<ulong>>(ref result128);
-            result64 = lower;
-            Unsafe.Add(ref result64, 1) = upper;
+                ref Vector64<ulong> result64 = ref Unsafe.As<Vector128<ulong>, Vector64<ulong>>(ref result128);
+                result64 = lower;
+                Unsafe.Add(ref result64, 1) = upper;
 
-            return result128;
+                return result128;
+            }
         }
 
         /// <summary>Creates a new <see cref="Vector128{Byte}" /> instance with the first element initialized to the specified value and the remaining elements initialized to zero.</summary>
@@ -1568,14 +1678,28 @@ public static Vector64<T> GetLower<T>(this Vector128<T> vector)
         /// <param name="value">The value of the lower 64-bits as a <see cref="Vector64{T}" />.</param>
         /// <returns>A new <see cref="Vector128{T}" /> with the lower 64-bits set to <paramref name="value" /> and the upper 64-bits set to the same value as that in <paramref name="vector" />.</returns>
         /// <exception cref="NotSupportedException">The type of <paramref name="vector" /> (<typeparamref name="T" />) is not supported.</exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector128<T> WithLower<T>(this Vector128<T> vector, Vector64<T> value)
             where T : struct
         {
-            ThrowHelper.ThrowForUnsupportedVectorBaseType<T>();
+            if (AdvSimd.IsSupported)
+            {
+                // Note: The 3rd operand GetElement() should be the argument to Insert(). Storing the
+                // result of GetElement() in a local variable and then passing local variable to Insert()
+                // would not merge insert/getelement in a single instruction.
+                return AdvSimd.Insert(vector.AsUInt64(), 0, value.AsUInt64().GetElement(0)).As<ulong, T>();
+            }
 
-            Vector128<T> result = vector;
-            Unsafe.As<Vector128<T>, Vector64<T>>(ref result) = value;
-            return result;
+            return SoftwareFallback(vector, value);
+
+            static Vector128<T> SoftwareFallback(Vector128<T> vector, Vector64<T> value)
+            {
+                ThrowHelper.ThrowForUnsupportedVectorBaseType<T>();
+
+                Vector128<T> result = vector;
+                Unsafe.As<Vector128<T>, Vector64<T>>(ref result) = value;
+                return result;
+            }
         }
 
         /// <summary>Gets the value of the upper 64-bits as a new <see cref="Vector64{T}" />.</summary>
@@ -1598,15 +1722,29 @@ public static Vector64<T> GetUpper<T>(this Vector128<T> vector)
         /// <param name="value">The value of the upper 64-bits as a <see cref="Vector64{T}" />.</param>
         /// <returns>A new <see cref="Vector128{T}" /> with the upper 64-bits set to <paramref name="value" /> and the lower 64-bits set to the same value as that in <paramref name="vector" />.</returns>
         /// <exception cref="NotSupportedException">The type of <paramref name="vector" /> (<typeparamref name="T" />) is not supported.</exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector128<T> WithUpper<T>(this Vector128<T> vector, Vector64<T> value)
             where T : struct
         {
-            ThrowHelper.ThrowForUnsupportedVectorBaseType<T>();
+            if (AdvSimd.IsSupported)
+            {
+                // Note: The 3rd operand GetElement() should be the argument to Insert(). Storing the
+                // result of GetElement() in a local variable and then passing local variable to Insert()
+                // would not merge insert/getelement in a single instruction.
+                return AdvSimd.Insert(vector.AsUInt64(), 1, value.AsUInt64().GetElement(0)).As<ulong, T>();
+            }
 
-            Vector128<T> result = vector;
-            ref Vector64<T> lower = ref Unsafe.As<Vector128<T>, Vector64<T>>(ref result);
-            Unsafe.Add(ref lower, 1) = value;
-            return result;
+            return SoftwareFallback(vector, value);
+
+            static Vector128<T> SoftwareFallback(Vector128<T> vector, Vector64<T> value)
+            {
+                ThrowHelper.ThrowForUnsupportedVectorBaseType<T>();
+
+                Vector128<T> result = vector;
+                ref Vector64<T> lower = ref Unsafe.As<Vector128<T>, Vector64<T>>(ref result);
+                Unsafe.Add(ref lower, 1) = value;
+                return result;
+            }
         }
 
         /// <summary>Converts the given vector to a scalar containing the value of the first element.</summary>