Merge branch 'WasmTestOnChrome' into firefox_ci

# Conflicts:
#	src/libraries/sendtohelix-browser.targets
#	src/mono/wasm/Wasm.Build.Tests/Wasm.Build.Tests.csproj

Author: pavelsavara

.github/workflows/bump-chrome-version.yml

@@ -27,7 +27,7 @@ jobs:
         run: >-
           make -C src/mono/wasm build-tasks &&
           PATH=$PWD/.dotnet:$PATH dotnet build eng/testing/bump-chrome-version.proj -p:Configuration=Release &&
-          git add eng/testing/ChromeVersions.props &&
+          git add eng/testing/BrowserVersions.props &&
           cat eng/testing/bump-chrome-pr.env >> "$GITHUB_ENV"
 
       - name: Check for changes

eng/pipelines/common/evaluate-default-paths.yml

@@ -7,7 +7,7 @@ parameters:
   _const_paths:
     _wasm_specific_only: [
         eng/testing/bump-chrome-version.proj
-        eng/testing/ChromeVersions.props
+        eng/testing/BrowserVersions.props
         eng/testing/WasmRunner*
         eng/testing/WasiRunner*
         eng/testing/scenarios/BuildWasiAppsJobsList.txt
@@ -58,7 +58,7 @@ parameters:
     ]
     _wasm_chrome: [
         eng/testing/bump-chrome-version.proj
-        eng/testing/ChromeVersions.props
+        eng/testing/BrowserVersions.props
     ]
     _perf_pipeline_specific_only: [
         eng/pipelines/runtime-wasm-perf.yml

eng/pipelines/common/templates/wasm-library-aot-tests.yml

@@ -35,7 +35,5 @@ jobs:
           - WasmTestOnV8
         - ${{ if eq(platform, 'browser_wasm_win') }}:
           - WasmTestOnChrome
-        - ${{ if eq(platform, 'wasi_wasm_win') }}:
-          - WasmTestOnWasmtime
-        - ${{ if eq(platform, 'wasi_wasm') }}:
+        - ${{ if or(eq(platform, 'wasi_wasm_win'), eq(platform, 'wasi_wasm')) }}:
           - WasmTestOnWasmtime

eng/pipelines/runtime-wasm-perf.yml

@@ -16,7 +16,7 @@ pr:
     - eng/pipelines/coreclr/templates/run-perf*
     - eng/pipelines/coreclr/templates/run-scenarios-job.yml
     - eng/testing/performance/*
-    - eng/testing/ChromeVersions.props
+    - eng/testing/BrowserVersions.props
 
 variables:
   - template: /eng/pipelines/common/variables.yml

eng/testing/ChromeVersions.props renamed to eng/testing/BrowserVersions.props

@@ -3,7 +3,7 @@
   <Import Project="..\..\Directory.Build.props" />
   <UsingTask AssemblyFile="$(WasmBuildTasksAssemblyPath)" TaskName="Microsoft.WebAssembly.Build.Tasks.UpdateChromeVersions" />
   <PropertyGroup>
-    <ChromeVersionsPath>$(RepositoryEngineeringDir)testing\ChromeVersions.props</ChromeVersionsPath>
+    <ChromeVersionsPath>$(RepositoryEngineeringDir)testing\BrowserVersions.props</ChromeVersionsPath>
     <EnvVarsForPRPath>$(RepositoryEngineeringDir)testing\bump-chrome-pr.env</EnvVarsForPRPath>
   </PropertyGroup>
 

eng/testing/bump-chrome-version.proj

@@ -451,7 +451,7 @@ if [[ -n "$wasm_bundle_directory" ]]; then
 
         # get required version
         if [[ -z "$v8_version" ]]; then
-            v8_version=`grep linux_V8Version $source_directory/eng/testing/ChromeVersions.props | sed -e 's,.*>\([^\<]*\)<.*,\1,g' | cut -d. -f 1-3`
+            v8_version=`grep linux_V8Version $source_directory/eng/testing/BrowserVersions.props | sed -e 's,.*>\([^\<]*\)<.*,\1,g' | cut -d. -f 1-3`
             echo "V8 version: $v8_version"
         fi
         if [[ -z "$javascript_engine_path" ]]; then

eng/testing/performance/performance-setup.sh

@@ -19,7 +19,7 @@
     <WasmProvisionAfterTarget Condition="'$(WasmProvisionAfterTarget)' == ''">Build</WasmProvisionAfterTarget>
   </PropertyGroup>
 
-  <Import Project="$(MSBuildThisFileDirectory)ChromeVersions.props" />
+  <Import Project="$(MSBuildThisFileDirectory)BrowserVersions.props" />
 
   <PropertyGroup Condition="'$(BrowserHost)' != 'windows'">
     <FirefoxUrl>https://ftp.mozilla.org/pub/firefox/releases/$(linux_FirefoxRevision)/linux-x86_64/en-US/firefox-$(linux_FirefoxRevision).tar.bz2</FirefoxUrl>
@@ -100,7 +100,7 @@
     <Error Condition="!$([MSBuild]::IsOSPlatform('linux')) and !$([MSBuild]::IsOSPlatform('windows'))"
            Text="Chrome provisioning only supported on Linux, and windows." />
     <Error Condition="'$(ChromeVersion)' == ''"
-           Text="No %24(ChromeVersion) set. This can be set in eng/testing/ChromeVersions.props" />
+           Text="No %24(ChromeVersion) set. This can be set in eng/testing/BrowserVersions.props" />
 
     <RemoveDir Directories="$(ChromeDir)" />
 
@@ -128,7 +128,7 @@
     <Error Condition="!$([MSBuild]::IsOSPlatform('linux')) and !$([MSBuild]::IsOSPlatform('windows'))"
            Text="ChromeDriver provisioning only supported on Linux, and windows." />
     <Error Condition="'$(ChromeVersion)' == ''"
-           Text="No %24(ChromeVersion) set. This can be set in eng/testing/ChromeVersions.props" />
+           Text="No %24(ChromeVersion) set. This can be set in eng/testing/BrowserVersions.props" />
 
     <RemoveDir Directories="$(ChromeDriverDir)" />
 

eng/testing/wasm-provisioning.targets

@@ -281,10 +281,7 @@ bool ABIPassingInformation::IsSplitAcrossRegistersAndStack() const
 //
 ABIPassingInformation ABIPassingInformation::FromSegment(Compiler* comp, const ABIPassingSegment& segment)
 {
-    ABIPassingInformation info;
-    info.NumSegments = 1;
-    info.Segments    = new (comp, CMK_ABI) ABIPassingSegment(segment);
-    return info;
+    return {1, new (comp, CMK_ABI) ABIPassingSegment(segment)};
 }
 
 #ifdef DEBUG

src/coreclr/jit/abi.cpp

@@ -48,9 +48,16 @@ struct ABIPassingInformation
     // multiple register segments and a struct segment.
     // - On Windows x64, all parameters always fit into one stack slot or
     // register, and thus always have NumSegments == 1
+    // - On RISC-V, structs can be split out over 2 segments, each can be an integer/float register or a stack slot
     unsigned           NumSegments = 0;
     ABIPassingSegment* Segments    = nullptr;
 
+    ABIPassingInformation(unsigned numSegments = 0, ABIPassingSegment* segments = nullptr)
+        : NumSegments(numSegments)
+        , Segments(segments)
+    {
+    }
+
     bool HasAnyRegisterSegment() const;
     bool HasAnyStackSegment() const;
     bool HasExactlyOneRegisterSegment() const;
@@ -77,7 +84,7 @@ class RegisterQueue
     {
     }
 
-    unsigned Count()
+    unsigned Count() const
     {
         return m_numRegs - m_index;
     }
@@ -179,6 +186,22 @@ class Arm32Classifier
                                    WellKnownArg wellKnownParam);
 };
 
+class RiscV64Classifier
+{
+    const ClassifierInfo& m_info;
+    RegisterQueue         m_intRegs;
+    RegisterQueue         m_floatRegs;
+    unsigned              m_stackArgSize = 0;
+
+public:
+    RiscV64Classifier(const ClassifierInfo& info);
+
+    ABIPassingInformation Classify(Compiler*    comp,
+                                   var_types    type,
+                                   ClassLayout* structLayout,
+                                   WellKnownArg wellKnownParam);
+};
+
 #if defined(TARGET_X86)
 typedef X86Classifier PlatformClassifier;
 #elif defined(WINDOWS_AMD64_ABI)
@@ -189,6 +212,8 @@ typedef SysVX64Classifier PlatformClassifier;
 typedef Arm64Classifier PlatformClassifier;
 #elif defined(TARGET_ARM)
 typedef Arm32Classifier PlatformClassifier;
+#elif defined(TARGET_RISCV64)
+typedef RiscV64Classifier PlatformClassifier;
 #endif
 
 #ifdef SWIFT_SUPPORT

src/coreclr/jit/abi.h

@@ -769,9 +769,9 @@ void Compiler::optPrintAssertion(AssertionDsc* curAssertion, AssertionIndex asse
     }
     else if (curAssertion->op1.kind == O1K_ARR_BND)
     {
-        printf("[idx:");
+        printf("[idx: " FMT_VN, curAssertion->op1.bnd.vnIdx);
         vnStore->vnDump(this, curAssertion->op1.bnd.vnIdx);
-        printf(";len:");
+        printf("; len: " FMT_VN, curAssertion->op1.bnd.vnLen);
         vnStore->vnDump(this, curAssertion->op1.bnd.vnLen);
         printf("]");
     }

src/coreclr/jit/assertionprop.cpp

@@ -1804,7 +1804,8 @@ void Compiler::lvaClassifyParameterABI()
     }
     else
 #endif
-#if defined(TARGET_X86) || defined(TARGET_AMD64) || defined(TARGET_ARM64) || defined(TARGET_ARM)
+#if defined(TARGET_X86) || defined(TARGET_AMD64) || defined(TARGET_ARM64) || defined(TARGET_ARM) ||                    \
+    defined(TARGET_RISCV64)
     {
         PlatformClassifier classifier(cInfo);
         lvaClassifyParameterABI(classifier);

src/coreclr/jit/lclvars.cpp

@@ -353,7 +353,7 @@ void RangeCheck::OptimizeRangeCheck(BasicBlock* block, Statement* stmt, GenTree*
         return;
     }
 
-    if (DoesOverflow(block, treeIndex))
+    if (DoesOverflow(block, treeIndex, range))
     {
         JITDUMP("Method determined to overflow.\n");
         return;
@@ -773,6 +773,22 @@ void RangeCheck::MergeEdgeAssertions(ValueNum normalLclVN, ASSERT_VALARG_TP asse
 
             isConstantAssertion = true;
         }
+        // Current assertion asserts a bounds check does not throw
+        else if (curAssertion->IsBoundsCheckNoThrow())
+        {
+            ValueNum indexVN = curAssertion->op1.bnd.vnIdx;
+            ValueNum lenVN   = curAssertion->op1.bnd.vnLen;
+            if (normalLclVN == indexVN)
+            {
+                isUnsigned = true;
+                cmpOper    = GT_LT;
+                limit      = Limit(Limit::keBinOpArray, lenVN, 0);
+            }
+            else
+            {
+                continue;
+            }
+        }
         // Current assertion is not supported, ignore it
         else
         {
@@ -782,7 +798,8 @@ void RangeCheck::MergeEdgeAssertions(ValueNum normalLclVN, ASSERT_VALARG_TP asse
         assert(limit.IsBinOpArray() || limit.IsConstant());
 
         // Make sure the assertion is of the form != 0 or == 0 if it isn't a constant assertion.
-        if (!isConstantAssertion && (curAssertion->op2.vn != m_pCompiler->vnStore->VNZeroForType(TYP_INT)))
+        if (!isConstantAssertion && (curAssertion->assertionKind != Compiler::OAK_NO_THROW) &&
+            (curAssertion->op2.vn != m_pCompiler->vnStore->VNZeroForType(TYP_INT)))
         {
             continue;
         }
@@ -1235,17 +1252,17 @@ bool RangeCheck::MultiplyOverflows(Limit& limit1, Limit& limit2)
 }
 
 // Does the bin operation overflow.
-bool RangeCheck::DoesBinOpOverflow(BasicBlock* block, GenTreeOp* binop)
+bool RangeCheck::DoesBinOpOverflow(BasicBlock* block, GenTreeOp* binop, const Range& range)
 {
     GenTree* op1 = binop->gtGetOp1();
     GenTree* op2 = binop->gtGetOp2();
 
-    if (!m_pSearchPath->Lookup(op1) && DoesOverflow(block, op1))
+    if (!m_pSearchPath->Lookup(op1) && DoesOverflow(block, op1, range))
     {
         return true;
     }
 
-    if (!m_pSearchPath->Lookup(op2) && DoesOverflow(block, op2))
+    if (!m_pSearchPath->Lookup(op2) && DoesOverflow(block, op2, range))
     {
         return true;
     }
@@ -1279,7 +1296,7 @@ bool RangeCheck::DoesBinOpOverflow(BasicBlock* block, GenTreeOp* binop)
 }
 
 // Check if the var definition the rhs involves arithmetic that overflows.
-bool RangeCheck::DoesVarDefOverflow(GenTreeLclVarCommon* lcl)
+bool RangeCheck::DoesVarDefOverflow(BasicBlock* block, GenTreeLclVarCommon* lcl, const Range& range)
 {
     LclSsaVarDsc* ssaDef = GetSsaDefStore(lcl);
     if (ssaDef == nullptr)
@@ -1291,10 +1308,25 @@ bool RangeCheck::DoesVarDefOverflow(GenTreeLclVarCommon* lcl)
         }
         return true;
     }
-    return DoesOverflow(ssaDef->GetBlock(), ssaDef->GetDefNode()->Data());
+
+    // We can use intermediate assertions about the local to prove that any
+    // overflow on this path does not matter for the range computed.
+    Range assertionRange = Range(Limit(Limit::keUnknown));
+    MergeAssertion(block, lcl, &assertionRange DEBUGARG(0));
+
+    // But only if the range from the assertion is more strict than the global
+    // range computed; otherwise we might still have used the def's value to
+    // tighten the range of the global range.
+    Range merged = RangeOps::Merge(range, assertionRange, false);
+    if (merged.LowerLimit().Equals(range.LowerLimit()) && merged.UpperLimit().Equals(range.UpperLimit()))
+    {
+        return false;
+    }
+
+    return DoesOverflow(ssaDef->GetBlock(), ssaDef->GetDefNode()->Data(), range);
 }
 
-bool RangeCheck::DoesPhiOverflow(BasicBlock* block, GenTree* expr)
+bool RangeCheck::DoesPhiOverflow(BasicBlock* block, GenTree* expr, const Range& range)
 {
     for (GenTreePhi::Use& use : expr->AsPhi()->Uses())
     {
@@ -1303,25 +1335,38 @@ bool RangeCheck::DoesPhiOverflow(BasicBlock* block, GenTree* expr)
         {
             continue;
         }
-        if (DoesOverflow(block, arg))
+        if (DoesOverflow(block, arg, range))
         {
             return true;
         }
     }
     return false;
 }
 
-bool RangeCheck::DoesOverflow(BasicBlock* block, GenTree* expr)
+//------------------------------------------------------------------------
+// DoesOverflow: Check if the computation of "expr" may have overflowed.
+//
+// Arguments:
+//   block - the block that contains `expr`
+//   expr  - expression to check overflow of
+//   range - range that we believe "expr" to be in without accounting for
+//           overflow; used to ignore potential overflow on paths where
+//           we can prove the value is in this range regardless.
+//
+// Return value:
+//   True if the computation may have involved an impactful overflow.
+//
+bool RangeCheck::DoesOverflow(BasicBlock* block, GenTree* expr, const Range& range)
 {
     bool overflows = false;
     if (!GetOverflowMap()->Lookup(expr, &overflows))
     {
-        overflows = ComputeDoesOverflow(block, expr);
+        overflows = ComputeDoesOverflow(block, expr, range);
     }
     return overflows;
 }
 
-bool RangeCheck::ComputeDoesOverflow(BasicBlock* block, GenTree* expr)
+bool RangeCheck::ComputeDoesOverflow(BasicBlock* block, GenTree* expr, const Range& range)
 {
     JITDUMP("Does overflow [%06d]?\n", Compiler::dspTreeID(expr));
     m_pSearchPath->Set(expr, block, SearchPath::Overwrite);
@@ -1343,17 +1388,17 @@ bool RangeCheck::ComputeDoesOverflow(BasicBlock* block, GenTree* expr)
     }
     else if (expr->OperIs(GT_COMMA))
     {
-        overflows = ComputeDoesOverflow(block, expr->gtEffectiveVal());
+        overflows = ComputeDoesOverflow(block, expr->gtEffectiveVal(), range);
     }
     // Check if the var def has rhs involving arithmetic that overflows.
     else if (expr->IsLocal())
     {
-        overflows = DoesVarDefOverflow(expr->AsLclVarCommon());
+        overflows = DoesVarDefOverflow(block, expr->AsLclVarCommon(), range);
     }
     // Check if add overflows.
     else if (expr->OperIs(GT_ADD, GT_MUL))
     {
-        overflows = DoesBinOpOverflow(block, expr->AsOp());
+        overflows = DoesBinOpOverflow(block, expr->AsOp(), range);
     }
     // These operators don't overflow.
     // Actually, GT_LSH can overflow so it depends on the analysis done in ComputeRangeForBinOp
@@ -1364,11 +1409,11 @@ bool RangeCheck::ComputeDoesOverflow(BasicBlock* block, GenTree* expr)
     // Walk through phi arguments to check if phi arguments involve arithmetic that overflows.
     else if (expr->OperIs(GT_PHI))
     {
-        overflows = DoesPhiOverflow(block, expr);
+        overflows = DoesPhiOverflow(block, expr, range);
     }
     else if (expr->OperIs(GT_CAST))
     {
-        overflows = ComputeDoesOverflow(block, expr->gtGetOp1());
+        overflows = ComputeDoesOverflow(block, expr->gtGetOp1(), range);
     }
     GetOverflowMap()->Set(expr, overflows, OverflowMap::Overwrite);
     m_pSearchPath->Remove(expr);