[clr-interp] Fix implicit promotion of I4 to I (#122319)

davidwrighton · Copilot · web-flow · commit faff92061615 · 2025-12-10T21:01:29.000Z
Ryujit does implicit promotion using zero-extending promotions for some
opcode and sign extending for others. I don't see a particularly good
rhyme or reason for the current behavior, but it does not match what the
interpreter does.

This PR adds a test for all the opcodes that experience promotion, and
attempts to test all the behaviors correctly. In building it, several
issues were found/fixed.

This is known to fix the GitHub13501 test. in addition to the various
issues found during test development.

---------

Co-authored-by: Copilot &lt;175728472+Copilot@users.noreply.github.com&gt;
diff --git a/src/coreclr/interpreter/compiler.cpp b/src/coreclr/interpreter/compiler.cpp
@@ -2505,6 +2505,26 @@ void InterpCompiler::EmitOneArgBranch(InterpOpcode opcode, int32_t ilOffset, int
     }
 }
 
+// Determines whether I4 to I8 promotion should use zero-extension (for unsigned operations)
+// or sign-extension (for signed operations), based on the opcode.
+InterpOpcode InterpOpForWideningArgForImplicitUpcast(InterpOpcode opcode)
+{
+    switch (opcode)
+    {
+        case INTOP_BNE_UN_I4:
+        case INTOP_BLE_UN_I4:
+        case INTOP_BLT_UN_I4:
+        case INTOP_BGE_UN_I4:
+        case INTOP_BGT_UN_I4:
+        case INTOP_ADD_OVF_UN_I4:
+        case INTOP_SUB_OVF_UN_I4:
+        case INTOP_MUL_OVF_UN_I4:
+            return INTOP_CONV_U8_U4;
+        default:
+            return INTOP_CONV_I8_I4;
+    }
+}
+
 void InterpCompiler::EmitTwoArgBranch(InterpOpcode opcode, int32_t ilOffset, int insSize)
 {
     CHECK_STACK(2);
@@ -2515,12 +2535,12 @@ void InterpCompiler::EmitTwoArgBranch(InterpOpcode opcode, int32_t ilOffset, int
     // emitting the conditional branch
     if (argType1 == StackTypeI4 && argType2 == StackTypeI8)
     {
-        EmitConv(m_pStackPointer - 1, StackTypeI8, INTOP_CONV_I8_I4);
+        EmitConv(m_pStackPointer - 1, StackTypeI8, InterpOpForWideningArgForImplicitUpcast(opcode));
         argType1 = StackTypeI8;
     }
     else if (argType1 == StackTypeI8 && argType2 == StackTypeI4)
     {
-        EmitConv(m_pStackPointer - 2, StackTypeI8, INTOP_CONV_I8_I4);
+        EmitConv(m_pStackPointer - 2, StackTypeI8, InterpOpForWideningArgForImplicitUpcast(opcode));
     }
     else if (argType1 == StackTypeR4 && argType2 == StackTypeR8)
     {
@@ -2756,12 +2776,12 @@ void InterpCompiler::EmitBinaryArithmeticOp(int32_t opBase)
 #if TARGET_64BIT
         if (type1 == StackTypeI8 && type2 == StackTypeI4)
         {
-            EmitConv(m_pStackPointer - 1, StackTypeI8, INTOP_CONV_I8_I4);
+            EmitConv(m_pStackPointer - 1, StackTypeI8, InterpOpForWideningArgForImplicitUpcast((InterpOpcode)opBase));
             type2 = StackTypeI8;
         }
         else if (type1 == StackTypeI4 && type2 == StackTypeI8)
         {
-            EmitConv(m_pStackPointer - 2, StackTypeI8, INTOP_CONV_I8_I4);
+            EmitConv(m_pStackPointer - 2, StackTypeI8, InterpOpForWideningArgForImplicitUpcast((InterpOpcode)opBase));
             type1 = StackTypeI8;
         }
 #endif
diff --git a/src/tests/JIT/Methodical/Methodical_d2.csproj b/src/tests/JIT/Methodical/Methodical_d2.csproj
@@ -12,6 +12,7 @@
     <MergedWrapperProjectReference Remove="e*/**/*_d.??proj" />
     <ProjectReference Include="../common/localloc_common.ilproj" />
     <ProjectReference Include="../common/eh_common.csproj" />
+    <ProjectReference Include="int64/unsigned/implicit_promotion_il.ilproj" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="FPtrunc\convr4a.cs" />
@@ -46,6 +47,7 @@
     <Compile Include="int64\signed\s_muldiv.cs" />
     <Compile Include="int64\superlong\superlong.cs" />
     <Compile Include="int64\unsigned\addsub.cs" />
+    <Compile Include="int64\unsigned\implicit_promotion.cs" />
     <Compile Include="int64\unsigned\ldc_mul.cs" />
     <Compile Include="int64\unsigned\ldc_mulovf.cs" />
     <Compile Include="int64\unsigned\ldfld_mul.cs" />
diff --git a/src/tests/JIT/Methodical/Methodical_do.csproj b/src/tests/JIT/Methodical/Methodical_do.csproj
@@ -11,6 +11,7 @@
     <ProjectReference Include="cctor/misc/testlib_misc.csproj" />
     <ProjectReference Include="Boxing/xlang/sinlib_cs.csproj" Aliases="sinlib_cs" />
     <ProjectReference Include="Boxing/xlang/sinlib_il.ilproj" Aliases="sinlib_il" />
+    <ProjectReference Include="int64/unsigned/implicit_promotion_il.ilproj" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Arrays\lcs\lcs.cs" />
@@ -185,6 +186,7 @@
     <Compile Include="int64\signed\s_muldiv.cs" />
     <Compile Include="int64\superlong\superlong.cs" />
     <Compile Include="int64\unsigned\addsub.cs" />
+    <Compile Include="int64\unsigned\implicit_promotion.cs" />
     <Compile Include="int64\unsigned\ldc_mul.cs" />
     <Compile Include="int64\unsigned\ldc_mulovf.cs" />
     <Compile Include="int64\unsigned\ldfld_mul.cs" />
diff --git a/src/tests/JIT/Methodical/Methodical_r2.csproj b/src/tests/JIT/Methodical/Methodical_r2.csproj
@@ -12,6 +12,7 @@
     <MergedWrapperProjectReference Remove="e*/**/*_r.??proj" />
     <ProjectReference Include="../common/localloc_common.ilproj" />
     <ProjectReference Include="../common/eh_common.csproj" />
+    <ProjectReference Include="int64/unsigned/implicit_promotion_il.ilproj" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="FPtrunc\convr4a.cs" />
@@ -46,6 +47,7 @@
     <Compile Include="int64\signed\s_muldiv.cs" />
     <Compile Include="int64\superlong\superlong.cs" />
     <Compile Include="int64\unsigned\addsub.cs" />
+    <Compile Include="int64\unsigned\implicit_promotion.cs" />
     <Compile Include="int64\unsigned\ldc_mul.cs" />
     <Compile Include="int64\unsigned\ldc_mulovf.cs" />
     <Compile Include="int64\unsigned\ldfld_mul.cs" />
diff --git a/src/tests/JIT/Methodical/Methodical_ro.csproj b/src/tests/JIT/Methodical/Methodical_ro.csproj
@@ -11,6 +11,7 @@
     <ProjectReference Include="cctor/misc/testlib_misc.csproj" />
     <ProjectReference Include="Boxing/xlang/sinlib_cs.csproj" Aliases="sinlib_cs" />
     <ProjectReference Include="Boxing/xlang/sinlib_il.ilproj" Aliases="sinlib_il" />
+    <ProjectReference Include="int64/unsigned/implicit_promotion_il.ilproj" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Arrays\lcs\lcs.cs" />
@@ -185,6 +186,7 @@
     <Compile Include="int64\signed\s_muldiv.cs" />
     <Compile Include="int64\superlong\superlong.cs" />
     <Compile Include="int64\unsigned\addsub.cs" />
+    <Compile Include="int64\unsigned\implicit_promotion.cs" />
     <Compile Include="int64\unsigned\ldc_mul.cs" />
     <Compile Include="int64\unsigned\ldc_mulovf.cs" />
     <Compile Include="int64\unsigned\ldfld_mul.cs" />
diff --git a/src/tests/JIT/Methodical/int64/unsigned/implicit_promotion.cs b/src/tests/JIT/Methodical/int64/unsigned/implicit_promotion.cs
@@ -0,0 +1,236 @@
+// 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 Xunit;
+using JitTest_implicit_promotion;
+using implicit_promotion;
+
+namespace JitTest_implicit_promotion
+{
+    public class Test
+    {
+        // These tests attempt to verify that the implicit upcasting from I4 to I which happens on 64 bit platforms
+        // is done in a consistent manner across all implementations.
+        // Notable details of interest:
+        // add.ovf.un, sub.ovf.un, mul.ovf.un upcast without sign-extension.
+        // div.un, and rem.un upcast with sign-extension.
+        // clt.un, cgt.un upcast without sign-extension
+        // bne.un, blt.un, ble.un, bgt.un, bge.un upcast without sign-extension
+        [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/122398", TestRuntimes.Mono)]
+        public static void TestUpcastBehavior()
+        {
+            unchecked
+            {
+                //////////////////////////////////////////////////////////////////
+                /// Test scenarios where the first operand is I and the second is i32
+                /////////////////////////////////////////////////////////////////
+
+                // add: (int)0x1 + -2
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(-1) : (nint)(-1), Operator.add_I_i32((nint)0x1, -2));
+
+                // add.ovf.un: (int)0x1 + -2
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(ulong)0x00000000FFFFFFFF : (nint)(-1), Operator.add_ovf_un_I_i32((nint)0x1, -2));
+
+                // add.ovf: (int)0x1 + -2
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(-1) : (nint)(-1), Operator.add_ovf_I_i32((nint)0x1, -2));
+
+                // sub: -1 - -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.sub_I_i32((nint)(-1), -1));
+
+                // sub.ovf: -1 - -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.sub_ovf_I_i32((nint)(-1), -1));
+
+                // sub.ovf.un: -1 - -1
+                Assert.Equal(Environment.Is64BitProcess ? unchecked((nint)(ulong)0xFFFFFFFF00000000) : (nint)0, Operator.sub_ovf_un_I_i32((nint)(-1), -1));
+
+                // mul: (int)0x2 * -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(-2) : (nint)(-2), Operator.mul_I_i32((nint)0x2, -1));
+
+                // mul.ovf: (int)0x2 * -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(-2) : (nint)(-2), Operator.mul_ovf_I_i32((nint)0x2, -1));
+
+                // mul.ovf.un: (int)0x2 * -1
+                if (!Environment.Is64BitProcess)
+                {
+                    Assert.Throws<OverflowException>(() => Operator.mul_ovf_un_I_i32((nint)0x2, -1));
+                }
+                else
+                {
+                    Assert.Equal((nint)(ulong)0x1FFFFFFFE, Operator.mul_ovf_un_I_i32((nint)0x2, -1));
+                }
+
+                // div: -1 / -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.div_I_i32((nint)(-1), -1));
+
+                // div.un: -1 / -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.div_un_I_i32((nint)(-1), -1));
+
+                // rem: -1 % -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.rem_I_i32((nint)(-1), -1));
+
+                // rem.un: -1 % -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.rem_un_I_i32((nint)(-1), -1));
+
+                // and: -1 & -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(-1) : (nint)(-1), Operator.and_I_i32((nint)(-1), -1));
+
+                // or: 0 | -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(-1) : (nint)(-1), Operator.or_I_i32((nint)0, -1));
+
+                // xor: -1 ^ -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.xor_I_i32((nint)(-1), -1));
+
+                // ceq: -1 == -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.ceq_I_i32((nint)(-1), -1));
+
+                // cgt: -2 > -3
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.cgt_I_i32((nint)(-2), -3));
+
+                // cgt.un: -2 > -1 (unsigned)
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.cgt_un_I_i32((nint)(-2), -1));
+
+                // clt: -1 < -2
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.clt_I_i32((nint)(-1), -2));
+
+                // clt.un: -2 < -1 (unsigned)
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.clt_un_I_i32((nint)(-2), -1));
+
+                // beq: -1 == -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.beq_I_i32((nint)(-1), -1));
+
+                // bne.un: -1 != -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)0, Operator.bne_un_I_i32((nint)(-1), -1));
+
+                // blt: -1 < -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.blt_I_i32((nint)(-1), -1));
+
+                // blt.un: -2 < -1 (unsigned)
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)1, Operator.blt_un_I_i32((nint)(-2), -1));
+
+                // ble: -1 <= -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.ble_I_i32((nint)(-1), -1));
+
+                // ble.un: -1 <= -1 (unsigned)
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)1, Operator.ble_un_I_i32((nint)(-1), -1));
+
+                // bgt: -1 > -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.bgt_I_i32((nint)(-1), -1));
+
+                // bgt.un: -1 > -1 (unsigned)
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)0, Operator.bgt_un_I_i32((nint)(-1), -1));
+
+                // bge: -1 >= -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.bge_I_i32((nint)(-1), -1));
+
+                // bge.un: 0xFFFFFFFF >= -2 (unsigned, special case)
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.bge_un_I_i32(unchecked((nint)(nuint)0xFFFFFFFF), -2));
+
+                //////////////////////////////////////////////////////////////////
+                /// Test scenarios where the first operand is i32 and the second is I
+                /////////////////////////////////////////////////////////////////
+
+                // add: -2 + 1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(-1) : (nint)(-1), Operator.add_i32_I(-2, (nint)1));
+
+                // add.ovf.un: -2 + 1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(ulong)0x00000000FFFFFFFF : (nint)(-1), Operator.add_ovf_un_i32_I(-2, (nint)1));
+
+                // add.ovf: -2 + 1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(-1) : (nint)(-1), Operator.add_ovf_i32_I(-2, (nint)1));
+
+                // sub: -1 - -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.sub_i32_I(-1, (nint)(-1)));
+
+                // sub.ovf: -1 - -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.sub_ovf_i32_I(-1, (nint)(-1)));
+
+                // sub.ovf.un: -1 - 1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(ulong)0xFFFFFFFE : (nint)(-2), Operator.sub_ovf_un_i32_I(-1, (nint)1));
+
+                // mul: -1 * 2
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(-2) : (nint)(-2), Operator.mul_i32_I(-1, (nint)2));
+
+                // mul.ovf: -1 * 2
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(-2) : (nint)(-2), Operator.mul_ovf_i32_I(-1, (nint)2));
+
+                // mul.ovf.un: -1 * 2
+                if (!Environment.Is64BitProcess)
+                {
+                    Assert.Throws<OverflowException>(() => Operator.mul_ovf_un_i32_I(-1, (nint)2));
+                }
+                else
+                {
+                    Assert.Equal((nint)(ulong)0x1FFFFFFFE, Operator.mul_ovf_un_i32_I(-1, (nint)2));
+                }
+
+                // div: -1 / -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.div_i32_I(-1, (nint)(-1)));
+
+                // div.un: -1 / -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.div_un_i32_I(-1, (nint)(-1)));
+
+                // rem: -1 % -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.rem_i32_I(-1, (nint)(-1)));
+
+                // rem.un: -1 % -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.rem_un_i32_I(-1, (nint)(-1)));
+
+                // and: -1 & -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(-1) : (nint)(-1), Operator.and_i32_I(-1, (nint)(-1)));
+
+                // or: -1 | 0
+                Assert.Equal(Environment.Is64BitProcess ? (nint)(-1) : (nint)(-1), Operator.or_i32_I(-1, (nint)0));
+
+                // xor: -1 ^ -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.xor_i32_I(-1, (nint)(-1)));
+
+                // ceq: -1 == -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.ceq_i32_I(-1, (nint)(-1)));
+
+                // cgt: -2 > -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.cgt_i32_I(-2, (nint)(-1)));
+
+                // cgt.un: -1 > -2 (unsigned)
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.cgt_un_i32_I(-1, (nint)(-2)));
+
+                // clt: -1 < -2
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)0, Operator.clt_i32_I(-1, (nint)(-2)));
+
+                // clt.un: -2 < -1 (unsigned)
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.clt_un_i32_I(-2, (nint)(-1)));
+
+                // beq: -1 == -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.beq_i32_I(-1, (nint)(-1)));
+
+                // bne.un: -1 != -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)0, Operator.bne_un_i32_I(-1, (nint)(-1)));
+
+                // blt: -2 < -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.blt_i32_I(-2, (nint)(-1)));
+
+                // blt.un: -1 < -2 (unsigned)
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)0, Operator.blt_un_i32_I(-1, (nint)(-2)));
+
+                // ble: -1 <= -1
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.ble_i32_I(-1, (nint)(-1)));
+
+                // ble.un: -1 <= -2 (unsigned)
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)0, Operator.ble_un_i32_I(-1, (nint)(-2)));
+
+                // bgt: -1 > -2
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.bgt_i32_I(-1, (nint)(-2)));
+
+                // bgt.un: -1 > -2 (unsigned)
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)1, Operator.bgt_un_i32_I(-1, (nint)(-2)));
+
+                // bge: -1 >= -2
+                Assert.Equal(Environment.Is64BitProcess ? (nint)1 : (nint)1, Operator.bge_i32_I(-1, (nint)(-2)));
+
+                // bge.un: -1 >= -2 (unsigned)
+                Assert.Equal(Environment.Is64BitProcess ? (nint)0 : (nint)1, Operator.bge_un_i32_I(-1, (nint)(-2)));
+            }
+        }
+    }
+}
diff --git a/src/tests/JIT/Methodical/int64/unsigned/implicit_promotion_il.il b/src/tests/JIT/Methodical/int64/unsigned/implicit_promotion_il.il
diff --git a/src/tests/JIT/Methodical/int64/unsigned/implicit_promotion_il.ilproj b/src/tests/JIT/Methodical/int64/unsigned/implicit_promotion_il.ilproj

Original file line number	Diff line number	Diff line change
`@@ -2505,6 +2505,26 @@ void InterpCompiler::EmitOneArgBranch(InterpOpcode opcode, int32_t ilOffset, int`
`2505`	`2505`	`}`
`2506`	`2506`	`}`
`2507`	`2507`
	`2508`	`+// Determines whether I4 to I8 promotion should use zero-extension (for unsigned operations)`
	`2509`	`+// or sign-extension (for signed operations), based on the opcode.`
	`2510`	`+InterpOpcode InterpOpForWideningArgForImplicitUpcast(InterpOpcode opcode)`
	`2511`	`+{`
	`2512`	`+ switch (opcode)`
	`2513`	`+ {`
	`2514`	`+ case INTOP_BNE_UN_I4:`
	`2515`	`+ case INTOP_BLE_UN_I4:`
	`2516`	`+ case INTOP_BLT_UN_I4:`
	`2517`	`+ case INTOP_BGE_UN_I4:`
	`2518`	`+ case INTOP_BGT_UN_I4:`
	`2519`	`+ case INTOP_ADD_OVF_UN_I4:`
	`2520`	`+ case INTOP_SUB_OVF_UN_I4:`
	`2521`	`+ case INTOP_MUL_OVF_UN_I4:`
	`2522`	`+ return INTOP_CONV_U8_U4;`
	`2523`	`+ default:`
	`2524`	`+ return INTOP_CONV_I8_I4;`
	`2525`	`+ }`
	`2526`	`+}`
	`2527`	`+`
`2508`	`2528`	`void InterpCompiler::EmitTwoArgBranch(InterpOpcode opcode, int32_t ilOffset, int insSize)`
`2509`	`2529`	`{`
`2510`	`2530`	`CHECK_STACK(2);`
`@@ -2515,12 +2535,12 @@ void InterpCompiler::EmitTwoArgBranch(InterpOpcode opcode, int32_t ilOffset, int`
`2515`	`2535`	`// emitting the conditional branch`
`2516`	`2536`	`if (argType1 == StackTypeI4 && argType2 == StackTypeI8)`
`2517`	`2537`	`{`
`2518`		`- EmitConv(m_pStackPointer - 1, StackTypeI8, INTOP_CONV_I8_I4);`
	`2538`	`+ EmitConv(m_pStackPointer - 1, StackTypeI8, InterpOpForWideningArgForImplicitUpcast(opcode));`
`2519`	`2539`	`argType1 = StackTypeI8;`
`2520`	`2540`	`}`
`2521`	`2541`	`else if (argType1 == StackTypeI8 && argType2 == StackTypeI4)`
`2522`	`2542`	`{`
`2523`		`- EmitConv(m_pStackPointer - 2, StackTypeI8, INTOP_CONV_I8_I4);`
	`2543`	`+ EmitConv(m_pStackPointer - 2, StackTypeI8, InterpOpForWideningArgForImplicitUpcast(opcode));`
`2524`	`2544`	`}`
`2525`	`2545`	`else if (argType1 == StackTypeR4 && argType2 == StackTypeR8)`
`2526`	`2546`	`{`
`@@ -2756,12 +2776,12 @@ void InterpCompiler::EmitBinaryArithmeticOp(int32_t opBase)`
`2756`	`2776`	`#if TARGET_64BIT`
`2757`	`2777`	`if (type1 == StackTypeI8 && type2 == StackTypeI4)`
`2758`	`2778`	`{`
`2759`		`- EmitConv(m_pStackPointer - 1, StackTypeI8, INTOP_CONV_I8_I4);`
	`2779`	`+ EmitConv(m_pStackPointer - 1, StackTypeI8, InterpOpForWideningArgForImplicitUpcast((InterpOpcode)opBase));`
`2760`	`2780`	`type2 = StackTypeI8;`
`2761`	`2781`	`}`
`2762`	`2782`	`else if (type1 == StackTypeI4 && type2 == StackTypeI8)`
`2763`	`2783`	`{`
`2764`		`- EmitConv(m_pStackPointer - 2, StackTypeI8, INTOP_CONV_I8_I4);`
	`2784`	`+ EmitConv(m_pStackPointer - 2, StackTypeI8, InterpOpForWideningArgForImplicitUpcast((InterpOpcode)opBase));`
`2765`	`2785`	`type1 = StackTypeI8;`
`2766`	`2786`	`}`
`2767`	`2787`	`#endif`