Enable more intrinsics for tier0 (#83002)

Update Microsoft.NETCore.Native.targets (#83024)

Initial support for zmm in .NET (#80960)

* Adding simd64 and zmm types.

* Adding other infrastructure to lower/emit code for simd64.

* Lowering + workarounds for simd64 constants.

* Fix lowering logic for Create().

* Save/restore for zmm

* Add ToDo comments for AVX512BW

* Separate AVX512F and AVX512BW + Fix disassembly.

* Review changes.

* Fixing throughput issue.

* Additional Review comments.

* Setting 'EnableIncompleteISAClass="1"' for relevant CI runs.

* Removing 64 bit flags + correcting check.

* Apply formatting patch

---------

Co-authored-by: Tanner Gooding <tagoo@outlook.com>

[JIT] Fixed improper peephole zero-extension removal when cdq/cwde instructions are involved (#82733)

* Fixed improper peephole zero-extension removal when cdq/cdqe/cwde instructions are involved

* Update regression test

* Formatting

* Handle cdq differently

* Handle cdq differently

* Handle cdq differently

* Take into account cmpxchg

* Take into account cmpxchg

* Feedback

* Added emitIsInstrWritingToReg. Removed the previously added function.

* Remove function from header

* Quick fix

* Added comment

* Formatting

* Feedback

* Fix build

Fix BitConverter.ToXx error message (#82987)

The current message ("Destination array is not long enough to copy all the items in the collection. Check array index and length."), which is otherwise used by CopyTo methods, makes no sense in these APIs. :)

Add NT_SIGINFO NOTE to ELF dumps (#82449)

* Add NT_SIGINFO NOTE to ELF dumps

Linux Watson needs this to better triage ELF dumps.

Add CreateDumpOptions helper struct to pass all the command options around. Add the
"--code", "--errno", "--address" command line options used to fill the NT_SIGINFO
NOTE. The runtime passes to createdump on a crash.

Added "ExceptionType" field to "Parameters" section of the Linux crash report json.

* Add NT_SIGINFO define

* Code review feedback

Replace remaining instances of COMPlus with DOTNET (#82985)

* Replace remaining instances of COMPlus with DOTNET

* Fix heading in RyuJIT tutorial

Replace some unnecessary use of CompareInfo (#82988)

Anywhere we're explicitly passing Ordinal or OrdinalIgnoreCase, the actual culture data is ignored.  We can just use the relevant string/span methods directly.

Update dependencies from https://github.com/dotnet/msquic build 20230303.1 (#82979)

System.Net.MsQuic.Transport
 From Version 8.0.0-alpha.1.23124.1 -> To Version 8.0.0-alpha.1.23153.1

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>

Clean up run.sh documentation (#82983)

Add line about build configuration.

Fix illink syntax help.

Simplify a couple cases that just set environment variables.

Update dependencies from https://github.com/dotnet/roslyn build 20230304.2 (#82980)

Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.6.0-3.23153.1 -> To Version 4.6.0-3.23154.2

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>

Fix invariant check in DateTimeParse (#82971)

Update dependencies from https://github.com/dotnet/arcade build 20230303.1 (#82978)

Microsoft.DotNet.Arcade.Sdk , Microsoft.DotNet.Build.Tasks.Archives , Microsoft.DotNet.Build.Tasks.Feed , Microsoft.DotNet.Build.Tasks.Installers , Microsoft.DotNet.Build.Tasks.Packaging , Microsoft.DotNet.Build.Tasks.TargetFramework , Microsoft.DotNet.Build.Tasks.Templating , Microsoft.DotNet.Build.Tasks.Workloads , Microsoft.DotNet.CodeAnalysis , Microsoft.DotNet.GenAPI , Microsoft.DotNet.GenFacades , Microsoft.DotNet.Helix.Sdk , Microsoft.DotNet.PackageTesting , Microsoft.DotNet.RemoteExecutor , Microsoft.DotNet.SharedFramework.Sdk , Microsoft.DotNet.VersionTools.Tasks , Microsoft.DotNet.XUnitConsoleRunner , Microsoft.DotNet.XUnitExtensions
 From Version 8.0.0-beta.23152.1 -> To Version 8.0.0-beta.23153.1

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>

[mono] Fix Hello World sample. (#82977)

Remove dead link (#82972)

Enable JitDasmWithAlignmentBoundaries and JitDasmWithAddress in Release (#82666)

Add RID for Fedora 39 (#82185)

The changes to runtime.json and runtime.compatibility.json were
generated by tooling.

Fix the multicore performance of mapping from an instruction pointer to a MethodDesc (#79021)

Mapping from an instruction pointer to a MethodDesc is a critical component of the runtime used in many places, notably diagnostics, slow path delegate creation, and stackwalking.

This change provides a dramatic improvement in the performance of that logic through several techniques.

1. The mapping from IP to range of interesting memory is done via a tree structure resembling that of a page table. The result of this is that in addition to reducing the locking logic, the cost of looking up in the presence of many different loaded assemblies will be reduced to a nearly constant time.
2. That tree structure is configured so that when accessing memory which will never be freed in the lifetime of the process, the memory can be accessed without taking any locks whatsoever.
3. The code map is enhanced to include not only the code generated by the JIT/R2R code, but also to include the fixup and stub precode stubs.
4. In addition, performance improvement was done to improve the performance of slow path delegate creation in particular, by reordering which checks are done, and by writing a simplified signature parse routine for computing the number of arguments to a function.

Performance of this was tested in both the EH stackwalking scenario as well as the delegate slow path creation scenario, but the delegate logic is what will be most visible when this is checked in. (See PR #79471 for details of the additional changes necessary to take advantage of this work when doing EH) (#8393 describes the potential product impact of just improving the delegate slow path creation code)

For the delegate creation scenario the perf impact was measured to be quite substantial. These numbers are in ms to create a constant number of delegates on each thread used. Smaller is better. The test was run on a 6 core machine.

| Threads | Without fix | With this PR
| ------------- | ------------- | ----- |
| 1  | 840 |  313|
| 2 | 1977 | 316 |
| 3 | 3290 | 325 |
| 4| 4259 | 344 |
| 5 | 5140 | 351 |
| 6 | 5872 | 374|
| 7 | 6463 | 442|
| 8 | 7046 | 499|
| 9 | 7648 | 547|
| 10 | 8241 | 627|
| 11 | 8851 | 749|
| 12 | 9595 | 773|

Fixes #8393

[wasm] Improve jiterpreter trace entry point selection heuristic (#82604)

This PR adjusts the jiterpreter's heuristic that decides where it's best to put entry points:
* Adds a requirement that entry points be at least a certain distance apart, since in some cases we can end up with trace entry points right next to each other, which isn't very useful and adds overhead. (Backwards branch targets are exempted from this so loops will still JIT properly).
* If we fail to create a trace exactly located at a backwards branch target, continue trying at blocks afterward. This should help in the rare case where the body of a loop begins with an unsupported instruction.
* When considering how long a trace actually is, we treat conditional aborts (like calls and throws) separately from ignored and supported instructions, so they don't count towards the overall size of the trace. These instructions aren't actually doing any useful work and if executed the trace will exit, so it's better not to consider them when deciding whether a trace is worth compiling.
This PR also manually inlines trace entry logic.

Trim some overheads for "r"/"o" DateTime parsing (#82925)

We were doing some unnecessary work on these fast paths.

I also noticed and cleaned up an unnecessary delegate involved in Hebrew number parsing.

Implement managed SegmentCommandLine (#82883)

* Implement managed version of SegmentCommandLine

* Remove P/Invoke for CommandLineToArgv

* Update parsing to latest UCRT

* Add test and fix trailing space in command

* Fix test cases

[wasm] Debugger tests - fix build (#82958)

* [wasm] Debugger tests - fix build

`/workspaces/runtime/src/mono/wasm/debugger/DebuggerTestSuite/TestHarnessProxy.cs(135,44): error CS8601: Possible null reference assignment`

Started being hit with https://github.com/dotnet/runtime/pull/82479 .
The other instances of this were fixed in
https://github.com/dotnet/runtime/pull/82803 .

* CI: Trigger all the wasm jobs, when roslyn is updated

And this includes the debugger tests

JIT: fix fgDfsReversePostorder (#82950)

This method was not doing a proper depth first search, so the reverse postorder
it created was flawed.

Fix patterns that defeat resource string optimizations in CoreLib (#82947)

Replace the resource string keys with enums

Fixes #82759

Fix trim warning in ComponentActivator (#82952)

* Fix trim warning in ComponentActivator

* Add UnsupportedOSPlatform attributes

[wasm] Fix min/max in the jiterpreter (#82955)

The math intrinsics table had a typo

use PlatformSpecific attribute to supress platform specific Quic tests (#82933)

* use PlatformSpecific attribute to supress platform specific Quic tests

* Update src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicPlatformDetectionTests.cs

Co-authored-by: Stephen Toub <stoub@microsoft.com>
---------

Co-authored-by: Stephen Toub <stoub@microsoft.com>

add RID for Ubuntu 23.04 (#82284)

* add RID for Ubuntu 23.04

* fix resolve

[browser] legacy JS interop optional via WasmEnableLegacyJsInterop - native part (#82834)

[main] Update dependencies from dotnet/roslyn (#82479)

* Update dependencies from https://github.com/dotnet/roslyn build 20230221.6

Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.6.0-2.23120.1 -> To Version 4.6.0-2.23121.6

* Update dependencies from https://github.com/dotnet/roslyn build 20230222.3

Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.6.0-1.23073.4 -> To Version 4.6.0-2.23122.3

* Update dependencies from https://github.com/dotnet/roslyn build 20230223.15

Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.6.0-1.23073.4 -> To Version 4.6.0-2.23123.15

* Update dependencies from https://github.com/dotnet/roslyn build 20230225.1

Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.6.0-1.23073.4 -> To Version 4.6.0-2.23125.1

* Update dependencies from https://github.com/dotnet/roslyn build 20230226.1

Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.6.0-1.23073.4 -> To Version 4.6.0-2.23126.1

* Update dependencies from https://github.com/dotnet/roslyn build 20230226.2

Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.6.0-1.23073.4 -> To Version 4.6.0-2.23126.2

* Update dependencies from https://github.com/dotnet/roslyn build 20230228.2

Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.6.0-1.23073.4 -> To Version 4.6.0-2.23128.2

* Update dependencies from https://github.com/dotnet/roslyn build 20230301.1

Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.6.0-1.23073.4 -> To Version 4.6.0-2.23151.1

* Update dependencies from https://github.com/dotnet/roslyn build 20230302.1

Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.6.0-1.23073.4 -> To Version 4.6.0-3.23152.1

* Update dependencies from https://github.com/dotnet/roslyn build 20230303.1

Microsoft.CodeAnalysis , Microsoft.CodeAnalysis.CSharp , Microsoft.Net.Compilers.Toolset
 From Version 4.6.0-1.23073.4 -> To Version 4.6.0-3.23153.1

---------

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>
Co-authored-by: Larry Ewing <lewing@microsoft.com>

[wasm] Implement more jiterpreter opcodes (#82940)

* Implement a bunch of missing math opcodes like exp, log and pow
* Implement STELEM_VT

[main] Update dependencies from 9 repositories (#82600)

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>
Co-authored-by: Ankit Jain <radical@gmail.com>

Guard more COM interop related code (#82882)

Nullable annotation fixes (#82803)

* Nullable annotation fixes

Once runtime merges to a Roslyn toolset that has the fix for [issue
50782](https://github.com/dotnet/roslyn/issues/50782) these annotations
will be necessary. Front loading the work here with this change.

* Apply suggestions from code review

Co-authored-by: Stephen Toub <stoub@microsoft.com>
---------

Co-authored-by: Stephen Toub <stoub@microsoft.com>

[main] Update dependencies from dotnet/arcade (#82764)

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>

Remove cached RW mapping when the corresponding RX one is released (#82841)

When a RX mapping in the ExecutableAllocation is released and there is a
RW mapping cached for it, it incorrectly stays in the cache. So when the
same virtual address range that was just released gets reserved again
and a request to get RW mapping comes in, the cached RW mapping is used.
But it is likely that the new RX mapping has a different offset in the
underlying file mapping and thus the RW mapping is unrelated to the new
RX mapping. Using this RW mapping results either in an overwrite of a
different block of memory or just a silent dropping of what's written.

This was discovered when investigating a GC reliability framework crash.
It turned out it was also the culprit behind the #75244 issue that I
was unable to reproduce and it kept  occuring in the CI on x86 only for
quite some time.

In addition to the fix, I've found that there was an off by one
condition in the ExecutableAllocator::FindRWBlock so I've fixed that.
And I've also noticed that in UnlockedLoaderHeap::UnlockedReservePages,
if the allocation of LoaderHeapBlock failed, we would leave the data
block incorrectly on the m_pRangeList. I've fixed that too.

Close #75244

Fix typo in SingleEntry.targets property (#82935)

Support raw ECDH key agreements

[browser] Calculate hash for runtime assets (#82891)

* hash assets and IL check
* @thaystg feedback about webcil hash
* @radical feedback

Issue correct Enable/Disable commands for EventSources with EventPipe (#81867)

Allow default AsyncFlowControls rather than throwing (#82912)

ExecutionContext.SuppressFlow currently throws an exception if flow is already suppressed.  This makes it complicated to use, as you need to check whether IsFlowSuppressed first and take two different paths based on the result.  If we instead just allow SuppressFlow to return a default AsyncFlowControl rather than throwing, and have AsyncFlowControl's Undo nop rather than throw if it doesn't contain a Thread, we can again make it simple to just always use SuppressFlow without any of the other complications.

[Mono] Enable runtime tests running on arm64 with mini JIT (#82814)

* Enable runtime tests running on arm64 with mini JIT

* Disable failed tests

* Add tracking issue link

* Disable one more failing test

[jiterp] Perform a single unsigned bounds check for ldelema1 (#82919)

Array and Span both have a uint32_t length field (at least as far as wasm is concerned). If index is signed and we do an unsigned index <= length then any negative index will be treated as a massive value. For arrays it appears to be safe to exploit this and not do the >= 0 check, and interp.c doesn't do it.

Fixing a bug that causes us to mistakenly demote a gen2 region to gen0 (#82413)

We are seeing a gen0 region that's almost fully occupied (< 24 bytes free) with one giant plug (ie, no free objects at all in the region). This causes allocate_in_condemned_generations to go into an infinite loop because in ephemeral generations we expect short plugs, ie, we should be able to allocate a min free object in front of each plug. And normally we can because when we allocate objects in gen0 we make sure to break up the allocation contexts with min free objects and when we compact into gen1 we form short plugs.

We are in this situation when all of the following conditions are true -

+ we did a gen2 compacting GC that generates a pinned plug in a gen2 region almost as big as the whole region. my guess for the reason why there's this giant pinned plug is because that gen2 region was already really compact so when we called allocate_in_condemned_generations on the non pinned plugs that are next to some pinned plugs in it we discovered we can't move the non pinned plugs anyway so we artificially pinned them and formed a giant pinned plug. and during this GC those objects were no longer pinned so we have one giant non pinned plug.
+ this gen2 region needs to be the last region with pinned plugs;
+ this gen2 region hasn't been consumed by allocate_in_condemned_generations yet so it was processed by process_remaining_regions;

Then in process_remaining_regions we'll set the plan_gen_num for that gen2 region to 0 because we are doing

set_region_plan_gen_num_sip (current_region, current_plan_gen_num);

and next time we do a GC, this plug is no longer pinned (and still survived) so we call  allocate_in_condemned_generations on it which causes the infinite loop.

instead of going through the demotion logic to decide whether we should demote this region or not.

Implement interfaces in the non-generic enumerator base (#82923)

* Implement IDisposable in the non-generic enumerator base

...so that the interface implementation details go to the non-generic dispatch map.

Saves 1.5 kB on BasicMinimalApi.

* f

Fix a few async void tests to be async Task (#82914)

Revert "Enable symbol stripping for crossgen2 (#82698)" (#82881)

This reverts commit 6a218ab799e56d4ebaffda550de06a9a73a88b14.

Improve DateTime.ParseExact perf for invariant culture (#82877)

* Improve DateTime parsing perf for invariant culture

Speed up the handling of ddd, dddd, MMM, and MMMM parts of a date time format string when using the invariant culture, which is very commonly used in parsing.  Today, when one of these is encountered, the relevant array of comparison strings is retrieved from the DateTimeFormatInfo, and each is compared as a prefix against the current position in the input, using a linguistic ignore-case comparison.  But for the invariant culture, we don't need to consult any arrays, and can do the comparison much more quickly.  These parts dominate the processing of a format like that for RFC1123.

* Address PR feedback

Substitute out geopolitical term in TimeZoneInfo (#82916)

Disable SupportedWindowsPlatforms_IsSupportedIsTrue on Windows Arm64 (#82902)

[mono][aot] Emit cctor instantiations for classes referenced by gshared methods. (#82900)

[mono][aot] Emit a list of exported methods into the AOT image and load them when the image is loaded. (#82809)

If there is a runtime attach function specified, these methods can call into the runtime
before its initialized. In order for this to work, the runtime attach function needs
to load all the AOT images containing such methods, and load_aot_module () will
load and initialize these methods using the newly emitted table.

EventPipe env var to disable stack collection (#82470)

Mark some internal/private structs as readonly (#82415)

* Mark some internal/private structs as readonly

* Address PR feedback

[wasi] CI: Provision `wasi-sdk`, and `wasmtime` only when needed (#82454)

* [wasm] Install wasi-sdk, and wasmtime on CI only if needed

* Add generic support for staging helix payloads

For a directory specified as a helix correlation payload, the helix
tasks will attempt to write a `.payload` file to the directory. But if the
directory is not writable then we need to stage the payload in a
writable location, before passing the path to helix.

For example, if we have `wasi-sdk` installed on the system as:
    `WASI_SDK_PATH=/usr/local/wasi-sdk`

.. then we can stage it by copying to
`artifacts/obj/helix-staging/wasi-sdk`, and then using that staging path
for the helix correlation payload.

This was already being done for `EMSDK`, and `WasiSdk` in two separate
targets. And now needs to be done for `wasmtime` also. Instead of having
completely separate targets for all this, add a new mechanism to specify
helix dependencies to stage.

For example:
```xml
  <ItemGroup>
    <HelixDependenciesToStage Condition="'$(NeedsWasmtime)' == 'true'" SourcePath="$(WasmtimeDir)"   Include="$(WasmtimeDirForHelixPayload)" />
  </ItemGroup>
```

.. and the payload can use specified as
```xml
<HelixCorrelationPayload Include="$(WasmtimeDirForHelixPayload)" Destination="wasmtime" Condition="'$(NeedsWasmtime)' == 'true'" />
```

* [wasm] CI: Fix path for wasi artifacts

These were getting created with all the wasi builds sharing the same
prefixes causing them to get overwritten.

[wasm] Fix tests substitution conditions (#82901)

PR #82886 fixed it for user builds, we should fix it for tests as well.

Add dedicated empty array enumerator for footprint reduction (#82899)

* Add dedicated empty array enumerator for footprint reduction

Its singleton can be used in places where it's less likely the consumer will otherwise be using a T[], such that it's less likely we'll need to generate code for T[].

* Address PR feedback

Introducing  ValidateOptionsResultBuilder (#82749)

Mark Microsoft.NET.ILLink as non-shipping (#82905)

This package should not be published to nuget. It is only used by xamarin, and contains the API surface for custom illink steps.

[iOS][maccatalyst] Disable MacCatalyst and Simulator CI runs (#82915)

The work items for these configurations are failing at a high rate and causing numerous retries. Disabling temporarily to see if that helps queue traffic stabilize.

Fix string allocation in DateTimeParse.ParseByFormat (#82861)

If a quote is encountered, the parser searches for the ending quote while also handling escaped characters.  It does by adding the interim characters to a temporary ValueStringBuilder.  But it then ToString's that builder to produce a temporary string that's examined.  This is unnecessary: we can just examine the span from the VSB directly.

Store Parallel.ForEachAsync exceptions from cancellation callbacks (#82434)

* Store Parallel.ForEachAsync exceptions from cancellation callbacks

If a cancellation callback erroneously throws an exception, make sure we store it into the list of exceptions used to complete the resulting task. In most cases, this just means we may not be returning _all_ exceptions when there are multiple.  If, however, disposal of the enumerator throws an exception and a cancellation callback throws an exception and no exceptions were thrown from the loop body, without this change the task returned from ForEachAsync likely won't be marked completed.

* Update src/libraries/System.Threading.Tasks.Parallel/tests/ParallelForEachAsyncTests.cs

Stop storing the parsed RID fallback graph (#82811)

After startup, we only need the RID fallback graph from the root framework for component dependency resolution (AssemblyDependencyResolver). This change stops storing that graph (which is decently large for portable linux) for all applications and switches to re-populating it on demand.

Removing this stored value also lines up with the plan to move to algorithmic RID selection rather than reading from the .deps.json.

disable tests on Server 2022 with spanish locale (#82578)

* disable tests on Server 2022 with spanish locale

* update name

Append version to RID only with valid characters (#81497)

This is the `init-distro-rid.sh` counterpart of 31e4f404c218eae7ba999c4df5346d30f971451c.

In `amd64/archlinux` docker container, the non-portable RID auto-detection (without explicit `-p:TargetRid=arch-x64` arg or `__DistroRid=arch-x64` env var) looks like this:

Before: `__DistroRid: arch.TEMPLATE_VERSION_ID-x64`
After: `__DistroRid: arch-x64`

[workloads] Upstream workload fixes from 7.0 (#82069)

Upstreamed from #75486

- The updated task now provides metadata that will allow us to split the VSDROP generation into two separate archives.
  One which only contains workload packs (needed to share DROPs across VS versions to support multi-targeting) and
  another that only contains the manifest installers and workload components.

- The ZIP archive names have been updated to disambiguate its contents and support automatic drop creation during
   staging.

Most of the changes are in eng due to the Arcade update to obtain the latest copy of the workload build tasks. Those changes are unrelated to the workload fix, but appears to be necessary.

Co-authored-by: Jacques Eloff <joeloff@users.noreply.github.com>

EventPipe lock implementation (#82790)

* EventPipe lock implementation

* FB

Fix Icon(Stream) handling of partial reads (#82621)

Icon's ctor assumes Read on a stream will always produce as much data as was asked for, and that's not guaranteed to be the case.

Fix SoundPlayer handling of partial reads on streams (#82612)

SoundPlayer assumes that a Read on a stream will return everything asked for, and that's not the case.

[wasm] Avoid unnecessary relinking when publishing a blazor project for AOT (#82748)

* [wasm] Wasm.Build.Tests: Add blazor+aot run test

* cleanup

* [wasm] Wasm.Build.Tests: Use $(_IsPublishing) to avoid unncessary

.. relinking during "Build", when publishing.

`Publish` target triggers `Build` target to run. When publishing, we
don't want to run relinking step during the `Build`, as it will be run
for `Publish` anyway. Earlier there wasn't a good way to differentiate
the two cases of `build` when building, and `build` when publishing, but
now the sdk sets `$(_IsPublishing)=true`, which can be used here.

* fix blazor tests

* Wasm.Build.Tests: Add support for running published blazor projects

`dotnet run` uses the regular build output. Published blazor app, like
when using AOT, needs to be run more "manually" by starting a web server
in the publish folder. This is accomplished here by using the new
xharness command `wasm webserver`.

* Detect runtime assertions in blazor runs

* Update test to track changes

* cleanup

* Disable BlazorPublishRunTest because of https://github.com/dotnet/runtime/issues/82481

* Update test to track changes

* Update xharness dependency

Updating 'Microsoft.DotNet.XHarness.CLI': '1.0.0-prerelease.23117.1' => '1.0.0-prerelease.23151.1' (from build '20230301.1' of 'https://github.com/dotnet/xharness')
Updating 'Microsoft.DotNet.XHarness.TestRunners.Common': '1.0.0-prerelease.23117.1' => '1.0.0-prerelease.23151.1' (from build '20230301.1' of 'https://github.com/dotnet/xharness')
Updating 'Microsoft.DotNet.XHarness.TestRunners.Xunit': '1.0.0-prerelease.23117.1' => '1.0.0-prerelease.23151.1' (from build '20230301.1' of 'https://github.com/dotnet/xharness')

Add PeriodicTimer.Period property (#82560)

Move throw out of inlined CompositeFormat helper (#82543)

Either this helper isn't getting inlined because of the throw, or it's getting inlined and increasing the size of all call sites where it is.

Combine ExecutionContext/CapturedContext fields in ManualResetValueTaskSourceCore (#82181)

There's currently an _executionContext field and a _capturedContext field.  Both of these are for non-fast-path.  This not only means the struct is larger than is necessary for the common case, it also means when we reset the instance between operations we need to clear an extra field, and it means we have an extra branch on some paths to check both fields.

We can instead combine them into a single field.  We allocate an extra tuple object if there's both an ExecutionContext and a scheduler, but this is exceedingly rare: when used as part of awaits, there will never be an ExecutionContext, so this will only happen in situations where someone is directly using the awaiter's OnCompleted (not UnsafeOnCompleted) method and there's a scheduler and ConfigureAwait(false) wasn't used.  Such a situation not only is rare, it also already has additional overheads.

This also cleans up a bit about how exceptions are handled and moves more logic out of the generic type to avoid code bloat with generic instantiations.

Glossary: Change SoS link to documentation and describe origin in description. (Was: Change source for SoS to Wayback Machine link) (#81178)

* Glossary: Change source for SoS to Wayback Machine link

The page seems to have disappeared in the currently archived version of Jason Zander's blog at https://learn.microsoft.com/en-us/archive/blogs/jasonz/ - so replace it with a Wayback Machine link to an archived version.

* Link to official documentation for SOS instead and mention origin of name in the description.

disable SendFileGetsCanceledByDispose also on Catalyst (#82782)

* disable SendFileGetsCanceledByDispose also on Catalyst

* Update src/libraries/System.Net.Sockets/tests/FunctionalTests/SendFile.cs

Co-authored-by: Radek Zikmund <32671551+rzikm@users.noreply.github.com>
* fix build

---------

Co-authored-by: Radek Zikmund <32671551+rzikm@users.noreply.github.com>

Use shared IValueTaskSource implementation in AwaitableSocketAsyncEventArgs (#82147)

The upside here is we don't need a dedicated implementation with complicated logic inside of Socket.  The downside is this effectively increases the allocation for a Socket by a few fields, as the shared implementation has a few extra fields that go unused.

Pass wasi invariant mode through env variable (#82707)

Pass wasi invariant mode through env variable

[mono][interp] Fix incorrect masking (#82890)

* [mono][interp] Fix incorrect masking

* [mono][interp] Fix warning

ActiveIssue for BuildInvalidSignatureTwice on mono interpreter. (#82864)

Update keywords. (#82896)

Add MemoryExtensions.AsSpan(string, Index/Range) (#82794)

Simplify IndexOfAnyAsciiByteValues for needles with 0 on X86 (#82866)

Have bool and string implement ISpanParsable<T> (#82836)

[wasm] Fix intrinsics substitution condition (#82886)

Enable substitutions for SIMD only for AOT and not interpreter

Avoid trying to get callstack[0] when it's empty like in an instrumentation pause (#82852)

[mono] Move networking code to debugger component (#82785)

The debugger is the only component left in Mono using the networking code, move the code there so we can avoid compiling it into the main runtime and also simplify it a bit.

[browser] remove unused methods (#82865)

Enable symbol stripping for crossgen2 (#82698)

Add OS/architecture specific CLRDEBUGINFO resource (#82863)

Issue: https://github.com/dotnet/runtime/issues/78282

Unify Array enumerators between CoreCLR and NativeAOT (#82751)

* Unify Array enumerators between CoreCLR and NativeAOT

Contributes to #82732

Reduces BasicMinimalApi native AOT size on Windows x64 by 68kB

* Update AOT compiler

* Naming convention

Co-authored-by: Stephen Toub <stoub@microsoft.com>

Fixed name of frozen string dictionary files (#82482)

* Fixed name of frozen string dictionary types

* Add missing file renames

Localized file check-in by OneLocBuild Task: Build definition ID 679: Build ID 2125925 (#82869)

Try skipping generation of empty method dictionaries (#82591)

Say we're compiling `Foo<__Canon>.Method` for:

```csharp
class Foo<T>
{
    static void Method() => GenericMethod<List<T>>();
    static void GenericMethod<T>() { }
}
```

In the method body, we're generating a call to `GenericMethod<__Canon>` with a generic dictionary that we looked up from `Foo`s dictionary. But as you can see, the dictionary is empty because `GenericMethod` doesn't do anything with it's T. RyuJIT might even inline it.

The problem is that we computed how the dictionary will look like during scanning and we're forever stuck with instruction to generate a generic dictionary for every `Foo<T>` instantiation.

This is adding an optimization - if during scanning we find out that the dictionary layout of the target method is empty, we instruct RyuJIT to generate a null generic context pointer.

Saves 1.5% on BasicMinimalApi.

Cc @dotnet/ilc-contrib

Localized file check-in by OneLocBuild Task: Build definition ID 679: Build ID 2122151 (#81871)

Co-authored-by: Jeremy Koritzinsky <jekoritz@microsoft.com>

Implement load_assembly delegate for hosting API (#82797)

[wasm] Implement more jiterpreter opcodes (#82849)

Implement the following opcodes:
* MINT_NEWSTR
* MINT_ARRAY_ELEMENT_SIZE
* MINT_DIV_I8
* MINT_REM_I8

JIT: Unify arm64 and x64 GT_SELECT handling (#82610)

This unifies GT_SELECT/GT_SELECTCC handling between arm64 and x64. The
arm64 backend no longer uses containment for compare chains; instead,
there is a new GT_CCMP node that both produces and consumes flags, and
lowering can lower GT_AND(op, relop) down to this node.

Check for pending IO in the portable thread pool's worker threads (#82245)

* Check for pending IO in the portable thread pool's worker threads

- When Resource Monitor is attached, some async IO operations are bound to the thread that issued it even though the IO handle is bound to an IOCP. If the thread exits, the async IO operation is aborted. This can lead to hangs or unexpected exceptions.
- Added a check that was missing in the portable thread pool implementation to prevent exiting a worker thread when it has pending IO

Fixes https://github.com/dotnet/runtime/issues/82207

[wasm] Enable SIMD (#80797)

* [wasm] Enable SIMD

* Let old V8 use simd

Co-authored-by: Ankit Jain <radical@gmail.com>
* [wasm] ManagedToNativeGenerator: Skip unmanaged dlls

.. instead crashing with an exception like:

```
src/mono/wasm/build/WasmApp.Native.targets(296,5): error MSB4018: (NETCORE_ENGINEERING_TELEMETRY=Build) The "ManagedToNativeGenerator" task failed unexpectedly.
System.BadImageFormatException: This PE image is not a managed executable.
   at System.Reflection.MetadataLoadContext.LoadFromStreamCore(Stream peStream)
   at System.Reflection.MetadataLoadContext.LoadFromAssemblyPath(String assemblyPath)
   at PInvokeTableGenerator.Generate(String[] pinvokeModules, String[] assemblies, String outputPath) in /_/src/tasks/WasmAppBuilder/PInvokeTableGenerator.cs:line 42
   at ManagedToNativeGenerator.ExecuteInternal() in /_/src/tasks/WasmAppBuilder/ManagedToNativeGenerator.cs:line 68
   at ManagedToNativeGenerator.Execute() in /_/src/tasks/WasmAppBuilder/ManagedToNativeGenerator.cs:line 53
   at Microsoft.Build.BackEnd.TaskExecutionHost.Microsoft.Build.BackEnd.ITaskExecutionHost.Execute()
   at Microsoft.Build.BackEnd.TaskBuilder.ExecuteInstantiatedTask(ITaskExecutionHost taskExecutionHost, TaskLoggingContext taskLoggingContext, TaskHost taskHost, ItemBucket bucket, TaskExecutionMode howToExecuteTask)
```

The wasm targets currently are not able to differentiate the managed
assemblies from the unmanaged ones. so it needs to be handled here.

* [wasm] WasmApp.Native.targets: do not trigger relinking when WasmEnableSIMD=true

Instead, let the property be effective only for the AOT case.

* Use staging image with newer v8

* [wasm] WasmAppHost: Add support for host arguments

* [wasm] console template: Add --experimental-wasm-simd to node, and remove v8 config as that isn't supported

* [wasm] Pass --experiment-wasm-simd for aot library tests too

* Try to pass full path to v8

Also remove --experimental-wasm-simd option, which shouldn't be needed
for newer v8

* Use docker image for all wasm helix jobs

As we need newer v8

* Set DOTNET_CLI_HOME under workitem payload

The correlation payload is read only

* Revert "Try to pass full path to v8"

This reverts commit a15b3ef5dcab31b0abe2bc914eee6299df7cf56f.

* Use DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1

Let see whether it will avoid all the writes to correlation payload
path

* Set NeedsEMSDKNode to false

To try if we can use newer node in path

* Revert "Set DOTNET_CLI_HOME under workitem payload"

This reverts commit 5dec1aaab403f4cbbd7b0e9f03d965e96efde51c.

* Set DOTNET_CLI_HOME under workitem payload

The correlation payload is read only. And even with
`export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1` we have still many
failures.

* Reverse the test here as we don't relink anymore

* Set _ExtraTrimmerArgs for tests

So that linker substitution files are used

* Put the SIMD/trim related props in separate group

More changes from Ankit

* Add dynamic dependency

* Disable Vector128IsHardwareAcceleratedTest

Til we have the interpreter support in place

* Disable GenericVectorTests.IsHardwareAcceleratedTest

Til we have the interpreter support in place

* Disable check_no_intrinsic_cattr in emit_vector_2_3_4

And add note about opened issue

* [mono] Disable few quaternion intrinsics

For * and / operators as these are not the same as vector operations.
Opened https://github.com/dotnet/runtime/issues/82408 to implement
correct ones in future.

* Change comparison order

* Use stable images

* WBT: Add --engine-arg=--experimental-wasm-simd for node, and v8

* Do not skip dotnet 1st time experience anymore

---------

Co-authored-by: Ankit Jain <radical@gmail.com>

[wasm] Add an internal GC lock API  (#82646)

The goal is to provide an API that can be called from JS to block a background GC from moving objects that may be accessed unsafely from JS.  Blazor does this during rendering - it traverses a set of rendering objects from JS in order to apply changes to the DOM.

Important notes for consumers of this API:
1. While the runtime GC lock is locked, calling any C# function or doing anything that may trigger managed allocation will block the runtime.
2. In a threaded build, only the main browser thread is allowed to call the `mono_wasm_gc_lock` function
3. The runtime lock is not recursive
4. Background threads initially continue running, so the managed object graph may change even while the GC lock is held (although objects may not move).  Background threads could mutate valuetype fields of reachable objects, even while the GC lock is held. However background threads will block as soon as they try to do any allocation.
5. The main browser thread may assume that managed heap objects will not move while the lock is held.

The corresponding aspnetcore API is https://github.com/dotnet/aspnetcore/pull/46909

* add wasm entrypoints to lock the GC from JS
* move gc lock api to INTERNAL object
* enter GC Unsafe before manipulating the locks

   This is an exported API, so we're normally in GC Safe mode on entry