[wasm] Run AOT, and Wasm.Build.Tests on windows (#59479)

Adds two new jobs to runtime-staging for Windows - AOT, and Wasm.Build.Tests.

AOT - runs with the same conditions as the one in runtime
Wasm.Build.Tests - run for rolling builds, or when a narrow set of paths related to wasm build change
And do this for corresponding job in runtime for linux

Co-authored-by: Alexander Köplinger <alex.koeplinger@outlook.com>

[wasm] Disable System.Text.RegularExpressions.Tests for AOT (#61803)

Update area-owners to reflect Libraries Area Pod changes (#61642)

* Update area-owners to reflect Libraries Area Pod changes

* Swap area leads between 2 libraries pods

* Remove Anipik from area ownership

Co-authored-by: Jeff Handley <1031940+jeffhandley@users.noreply.github.com>

[Group 4] Enable nullable annotations for `Microsoft.Extensions.Configuration.CommandLine` (#57432)

* Annotate

* Add net6 to parent projects

* DisableImplicitAssemblyReferences

* NetCoreAppMinimum

* configureSource is nullable

* Add NetCoreAppMinimum to System.Runtime and System.Collections

* Revert "Add NetCoreAppMinimum to System.Runtime and System.Collections"

This reverts commit fbfb3ba2b936588215b5ea45cdc50fd6cd861d8c.

* Fix NetCoreAppMinimum build

Co-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>

Create empty zip files (#61828)

Allow runtimeconfig StartupHooks and Environment StartupHooks to both be present (#61461)

Allow both env. variable `DOTNET_STARTUP_HOOKS` and the `.runtimeconfig.json` property `STARTUP_HOOKS` to be specified at the same time. The new behavior is to concatenate the two lists, with the env. variable content going first.

Enable DD117522 test (#61585)

Caught my attention because this is disabled outside issues.targets. This is apparently blocked on https://github.com/dotnet/runtime/issues/5907 which is a crossgen bug. I tried to /p:PublishReadyToRun=true this test locally and it seems to work fine with crossgen2.

Integration of changes in shared files from runtimelab/NativeAOT (#61655)

Switch IP mapping lists to use jitstd::list (#61822)

We may want to change the logic around how IP mappings are reported to
the EE, and the manually maintained singly-linked lists made it hard to
understand the logic that goes on here. Switch to jitstd::list which
allows us to simplify the logic by directly removing the mappings we do
not want to emit.

There are two small behavior changes here:
1. The previous logic would record superfluous IL offset 0 mappings
   under the assumption that the previous mapping was the prolog; this
   is not always the case, so check this explicitly
2. The previous logic would record _all_ CALL_INSTRUCTION mappings and
   would not use these to check whether to remove NO_MAP mappings.  This
   is superfluous as well, if we have a regular mapping at a native
   offset it does not give any information to add a NO_MAP mapping at
   the same native offset.

All diffs therefore look like the following. Case 1:
-IP mapping count : 7
+IP mapping count : 6
 IL offs PROLOG : 0x00000000 ( STACK_EMPTY )
 IL offs 0x0000 : 0x00000009 ( STACK_EMPTY )
 IL offs 0x0000 : 0x000000F4 ( STACK_EMPTY )
-IL offs 0x0000 : 0x000000F4 ( STACK_EMPTY )
 IL offs NO_MAP : 0x00000114 ( STACK_EMPTY )
 IL offs EPILOG : 0x0000011D ( STACK_EMPTY )
 IL offs 0x0000 : 0x00000124 ( STACK_EMPTY )

Case 2:
 IL offs 0x0000 : 0x000000D7 ( STACK_EMPTY )
 IL offs 0x0001 : 0x000000DE ( CALL_INSTRUCTION )
-IL offs NO_MAP : 0x000000E9 ( STACK_EMPTY )
 IL offs 0x000B : 0x000000E9 ( CALL_INSTRUCTION )
 IL offs NO_MAP : 0x000000F7 ( STACK_EMPTY )

Expand One/Notone/Setlazy support to Lazy (#61784)

The logic added in a recent PR to support simplified code generation for a Regex with {One/Notone/Set}lazy nodes is almost sufficient to support Lazy as well.  This fills the gap.  It also deletes an erroneous optimization added in .NET 5 that removed top-level Atomic nodes; the idea behind it was that such nodes are meaningless as, at the top-level, nothing can backtrack in anyway, but it then means that any node which is paying attention to whether its parent is Atomic may no longer find it (and that's needed by Lazy).

Reduce allocations for CreateDirectory (#61777)

* introduce an overload that accepts ROS<char> instead of a string

* remove dead code

* avoid string allocations

* remove List<int> allocation

* Apply suggestions from code review

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

Disable several failing tests on iOSSimulator arm64 (#61826)

* Disable several failing tests on iOSSimulator arm64

A few tests popped up as failures on the rolling build due to parts of System.Diagnostics.Process throwing PNSE.  Disabled the functional tests from running on arm64 as mlaunch can't detect the return code.

* Update src/libraries/System.Runtime.Extensions/tests/System/EnvironmentTests.cs

Co-authored-by: Steve Pfister <steve.pfister@microsoft.com>
Co-authored-by: Alexander Köplinger <alex.koeplinger@outlook.com>

Include arch specific headers in standalone JITs (#61800)

Change CMake build for JIT to include headers and arch-specific headers
in the same way as sources. This makes arch-specific headers appear in
the correct standalone jit (clrjit_universel_arm64_x64 etc.) projects.

Try to skip pause_* tests again (#61793)

Fix typo

Skip System.Diagnostics.TextWriterTraceListenerTests.XmlWriterTraceListenerTests on iOS/tvOS (#61807)

This marks System.Diagnostics.TextWriterTraceListenerTests.XmlWriterTraceListenerTests withSkipOnPlatform attribute for iOS/tvOS as those tests try to create a process info, which throws PNSE after S.D.Process API's around libproc have been excluded in #61590.

Improve superpmi-asmdiffs AzDO pipeline robustness (#61819)

* Improve superpmi-asmdiffs AzDO pipeline robustness

1. When git fetching origin/main, use `--depth=500` to try to ensure
there is enough context to allow finding a JIT change in the history.
2. Add some error checking in pipeline setup so failures in setting
up the pipeline should fail the jobs early.

* Remove unneeded `success` variable from jitrollingbuild.py

[DllImportGenerator] Don't flag methods with known unsupported UnmanagedType (#61808)

Add JitDisasmWithDebugInfo (#61780)

Add COMPlus_JitDisasmWithDebugInfo. When set and in verbose/disasm mode,
JIT will display inline comments with debug information before the
instructions that debug info applies to. Change superpmi with
--debuginfo to use this mode. Also small change to dotnet-pgo flow graph
dump to write offsets in the same format.

[Group 4] Enable nullable annotations for `Microsoft.Extensions.Configuration.EnvironmentVariables` (#57433)

* Annotate

* Add net6 to parent projects

* Prefix can be null in AddEnvironmentVariables

* DisableImplicitAssemblyReferences

* Address PR feedback

- Add necessary TFMs
- Make configureSource action nullable

Co-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>

Apply BuiltInComInterop feature switch to managed code (#54056)

* Apply BuiltInComInterop feature switch to managed code

* Feedback

* Remove two more

JIT: support OSR for synchronized methods (#61712)

OSR methods share the "monitor acquired" flag with the original method.
The monitor acquired flag is s bit of non-IL live state that must be
recorded in the patchpoint.

Also, OSR methods only need to release the monitor as acquisition can
only happen in the original method.

Convert System.Net.* over to GeneratedDllImport (#61765)

Fix building DllImportGeneratorSample (#61806)

Fix the only ilproj test that uses multiple command-line variants (#61750)

I believe that despite its singular nature this is worth a separate
review to make sure we're in agreement regarding the conversion
principles. There are several things worth noting here:

1) According to the current plan we're continuously documenting in
https://github.com/dotnet/runtime/issues/54512 we want to remove
command-line parameters from all test entrypoints. Variant tests
driven by command-line parameters should be turned into multiple
test cases marked with separate [Fact] attributes.

2) For ilproj tests, to facilitate local debugging, our current plan
is to keep them runnable as standalone executables. This implies that
ilproj tests comprising several [Fact] test entrypoints require a
new entrypoint that just calls into the individual test cases.

3) The Roslyn-generated merged wrapper for the tests won't care about
the "composite" main (that is for local debugging only), it will
directly identify and use the individual test cases marked with
[Fact] attributes.

4) In accordance with this scheme, such composite ILPROJ tests are
specific in not having their entrypoint method itself marked with
the [Fact] attribute.

5) Funnily enough this example nicely demonstrates the implied
cleanup - the entire command-line machinery is only used for a
handwritten switch to choose one of the three variants; moreover
we only exercised two out of the three variants, possibly due to
an authoring bug when creating the variant test, potentially caused
by previous complexity of such endeavor.

Thanks

Tomas

Revert "Actually use TargetOS=AnyOS in the build-test-job. (#61745)" (#61799)

Add tests verifying fast-path semantics for nullable structs (#61711)

Add ThrowIfNull overload for pointers (#61633)

Actually use TargetOS=AnyOS in the build-test-job. (#61745)

[Group 4] Enable nullable annotations for `Microsoft.Extensions.Configuration.Binder` (#57418)

* Annotate

* Update Microsoft.Extensions.Configuration.Binder.csproj

* DisableImplicitAssemblyReferences

* Nullablity fix

* configureOptions are non-nullable

* Revert "configureOptions are non-nullable"

This reverts commit 5dac6136c32714414c964ce0445b5e31b3c78ead.

* NetCoreAppMinimum TFM

* Revert non-nullable changes

* Remove not needed project references

* Refactor while

* Revert non-nullable changes

* Fix up csproj files to build for necessary TFMs

Co-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>

[iOS] Follow up changes for 61590 (#61670)

This is a follow up PR for #61590.

It includes:

 - additional UnsupportedOSPlatform annotations for some System.Diagnostics.Process APIs throwing PNSE on iOS/tvOS (they started doing so after excluding some managed logic around librpoc )

 - fixing a bit ugly workaround for CS0649 (see https://github.com/dotnet/runtime/pull/61590/files#r749525127) - used a local pragma in the ThreadInfo class.

 - skipping the respective S.D.P. tests ( it will address [iOS/tvOS] System.Diagnostics.Tests.ProcessTests.TestGetProcesses fails on devices #60588 as well)

Remove duplicate checks (#61766)

These checks appears to be redundant.

Update Area Owners for System.Data (#61748)

Add single char lazy loop support to simplified Regex code gen (#61698)

* Reduce atomic single char lazy loops

* Add single char lazy loop support to simplified code gen

Add support for dumping and using precise debug info (#61735)

* In the JIT, add support for dumping the precise debug info out through
  an environment variable `DOTNET_JitDumpPreciseDebugInfoFile` in a
  simple JSON format. This is a stopgap until we expose the extra
  information through ETW events.

* In dotnet-pgo, add an argument --precise-debug-info-file which can
  point to the file produced by the JIT. When used, dotnet-pgo will get
  native<->IL mappings from this file instead of through ETW events.

* In dotnet-pgo, add support for attributing samples to inlinees when
  that information is present. This changes the attribution process a
  bit: previously, we would group all LBR data/samples and then
  construct the profile from all the data. We now do it in a more
  streaming way where there is a SampleCorrelator that can handle
  individual LBR records and individual samples.

* In dotnet-pgo, add an argument --dump-worst-overlap-graphs-to which
  can be used in the compare-mibc command to dump out a .dot file
  containing the flow graph of the methods with the worst overlap
  measures, and showing the relative weight count on each basic block
  and edge for the two profiles being compared. This is particular
  useful to find out where we are producing incorrect debug mappings, by
  comparing spgo.mibc and instrumented.mibc files.

FileStatus.Unix/Process.Unix: align caching of user identity. (#60160)

* FileStatus.Unix/Process.Unix: align implementation.

Process: remove the user identity caching and extend the logic
to avoid retrieving the identity in most cases by checking
if all x-bits are set or not set.

FileStatus: use same group check as Process.

FileStatus: cache the read only flag instead of caching the
identity.

FileSystemEntry.Unix: ensure properties are available when file is deleted. (#60214)

* FileSystemEntry.Unix: ensure attributes are available when file is deleted.

When the file no longer exists, we create attributes based on what we know.

The test for this was passing because it cached the attributes before the
item was deleted due to enumerating with skipping FileAttributes.Hidden.

* GetLength: fix reading from uninitialized cache.

CreateDirectory: eliminate some syscalls. (#58799)

Reduce the output from tests. (#61593)

- Do not printout exceptions from failing task tests.
- Remove default MONO_LOG_MASK=gc from debug configuration.

Use GeneratedDllImport in System.Data.Odbc, System.IO.Ports, System.ServiceProcess.ServiceController (#61741)

Convert Crypto P/Invokes to GeneratedDllImport. (#61742)

* Convert Crypto P/Invokes to GeneratedDllImport.

Update DNNE version (#61738)

Create runtime clone to manually kick off full test runs (#61641)

This change allows devs to manually kick off full test runs on the configurations that only execute smoke tests per PR.

To kick things off, you can run /azp run runtime-manual

Hide 'align' instruction behind jmp (#60787)

* Hide align behind a jmp

fix the alignBytesRemoved

Some fixes and working model

Some fixes and redesign

Some more fixes

more fixes

fix

Add the check  for fgFirstBB

misc changes

code cleanup + JitHideAlignBehindJmp switch

validatePadding only if align are before the loop IG

More cleanup, remove commented code

jit format

* Fix a problem where curIG==0 and loop might be emitted in curIG, adjust the targetIG to prevIG

Add IGF_REMOVED_ALIGN flag for special scenarios

* Add stress mode to emit int3 for xarch

* Add stress mode to emit bkpt for arm64

* Add a loop align instruction placement phase

* review comments

* Change from unsigned short to unsigned

* review comments around cleanup

* emitForceNewIG

* Remove emitPrevIG

* Revert change to forceNewIG for align instruction

* Use loopAlignCandidates

* Use loopHeadIG reference

* jit format

* Remove unneeded method

* Misc changes

* Review feedback

* Do not include align behind Jmp in PerfScore calculation

* jit format and fix a bug

* fix the loopCandidates == 0 scenario

* Add unmarkLoopAlign(), add check for fgFirstBB

* merge conflict fix

* Add missing }

* Grammar nit

Co-authored-by: Bruce Forstall <brucefo@microsoft.com>
Co-authored-by: Bruce Forstall <brucefo@microsoft.com>

Remove race condition from DllImportGenerator build (#61695)

[wasm][debugger] Tie sdb agent lifetime to the ExecutionContext and simplify the api (#61392)

* Make SMonoSdbHelper part of the execution context

Upload dasm files as artifacts for "asmdiffs pipeline" (#61700)

* Temp change to disable align loop

* download specific artifacts

to squash:

* Upload .dasm files

* fix the build id

* Add ci_run and retainOnlyTopFiles

* Rename ci_run to retainOnlyTop

* Disable struct promo to test asmdiff

* Revert "Disable struct promo to test asmdiff"

This reverts commit 3ef7adb931c703e46628881335150ad3a6fa8bd8.

* fix the parameter retainOnlyTopFiles

* add missing -

* Revert "Temp change to disable align loop"

This reverts commit b1de5c4f9c15a6a61eba070908d2b6eb796fd8b1.

* Revert "download specific artifacts"

This reverts commit db3de57ef952137eb3eec24cf4ff73d6a1968762.

* Review comments

Remove `DisableImplicitNamespaceImports_DotNet` (#61656)

Global usings no longer means "global breaking" after RC1.

src/tests tree test xunit-based source generated runner (#60846)

Co-authored-by: Alexander Köplinger <alex.koeplinger@outlook.com>
Co-authored-by: Jan Kotas <jkotas@microsoft.com>
Co-authored-by: Santiago Fernandez Madero <safern@microsoft.com>
Co-authored-by: Tomas <trylek@microsoft.com>

Update docker image (#61217)

* Add support for custom container for Linux Arm64

Update platform_matrix.yml to allow custom containers for Arm64 Linux runs.
This is required for our performance runs as we need a newer version of the
python runtime. This change follows the same pattern as https://github.com/dotnet/runtime/pull/59202/files

* Update perf_slow.yml with correct container values

Skip HardwareIntrinsics/x86base/Pause tests on Mono (#61743)

Merge System.Security.Cryptography.Algorithms to System.Security.Cryptography

HostFactoryResolver - Increase default timeout to thirty seconds (#61621)

A few follow up changes to LookupTypeKey change (#61718)

* re-enable optimization when a token is replaced by corresponding type handle

* compute "isNested" ony when we need it.

* no need to make more than 2 attempts at reading

Factor out and improve the vectorization of RegexInterpreter.FindFirstChar (#61490)

* Factor out and improve the vectorization of RegexInterpreter.FindFirstChar

This change started with the "simple" goal of factoring out the FindFirstChar logic from RegexInterpreter and consuming it in SymbolicRegexMatcher.  The existing engines use FindFirstChar to quickly skip ahead to the next location that might possibly match, at which point they fall back to analyzing the whole pattern at that location.  SymbolicRegexMatcher (used by RegexOptions.NonBacktracking) had its own implementation for this, which it used any time it entered a start state.  This required non-trivial additional code to maintain, and there's no good reason it should be separate from the other engines.

However, what started out as a simple change grew due to regressions that resulted from differences in the implementations.  In particular, SymbolicRegexMatcher already works off of precomputed equivalence tables for casing, which gives it very different characteristics in this regard from the existing engines.  For example, SymbolicRegexMatcher's existing "skip ahead to the next possible match start location" logic already evaluated all the characters that could possibly start a match, which included variations of the same character when using IgnoreCase, but the existing RegexInterpreter logic didn't.  That discrepancy then results in a significant IgnoreCase regression for NonBacktracking due to losing the ability to use a vectorized search for the next starting location.  We already plan to shift the existing engines over to a plan where all of these equivalences are computed at construction time rather than using ToLower at both construction time and match time, so this PR takes some steps in that direction, doing so for most of ASCII.  This has added some temporary cruft, which we'll be able to delete once we fully shift the implementations over (which we should do in the near future).

Another difference was SymbolicRegexMatcher was enabling use of IndexOfAny for up to 5 characters, whereas RegexOptions.Compiled was only doing up to 3 characters, and RegexInterpreter wasn't doing for any number.  The PR now uses 5 everywhere.

However, the more characters involved, the more overhead there is to IndexOfAny, and for some inputs, the higher the chances are that IndexOfAny will find a match sooner, which means its overhead compounds more.  To help with that, we now not only compute the possible characters that might match at the beginning of the pattern, but also characters that might match at a fixed offset from the beginning of the pattern (e.g. in \d{3}-\d{2}-\d{4}, it will find the '-' at offset 3 and be able to vectorize a search for that and then back off by the relevant distance.  That then also means we might end up with multiple sets to choose to search for, and this PR borrows an idea from Rust, which is to use some rough frequency analysis to determine which set should be targeted.  It's not perfect, and we can update the texts use to seed the analysis (right now I based it primarily on *.cs files in dotnet/runtime and some Project Gutenberg texts), but it's good enough for these purposes for now.

We'd previously switched to using IndexOf for a case-sensitive prefix string, but still were using Boyer-Moore for case-insensitive.  Now that we're able to also vectorize a search for case-insensitive values (right now just ASCII letter, but that'll be fixed soon), we can just get rid of Boyer-Moore entirely.  This saves all the costs to do with constructing the Boyer-Moore tables and also avoids having to generate the Boyer-Moore implementations in RegexOptions.Compiled and the source generator.

The casing change also defeated some other optimizations already present.  For example, in .NET 5 we added an optimization whereby an alternation like `abcef|abcgh` would be transformed into `abc(?:ef|gh)`, and that would apply whether case-sensitive or case-insensitive.  But by transforming the expression at construction now for case-insensitive into `[Aa][Bb][Cc][Ee][Ff]|[Aa][Bb][Cc][Gg][Hh]`, that optimization was defeated.  I've added a new optimization pass for alternations that will detect common prefixes even if they're sets.

The casing change also revealed some cosmetic issues.  As part of the change, when we encounter a "multi" (a multi-character string in the pattern), we convert that single case-insensitive RegexNode to instead be one case-sensitive RegexNode per character, with a set for all the equivalent characters that can match.  This then defeats some of the nice formatting we had for multis in the source generator, so as part of this change, the source generator has been augmented to output nicer code for concatenations.  And because sets like [Ee] are now way more common (since e.g. a case-insensitive 'e' will be transformed into such a set), we also special-case that in both the source generator and RegexOptions.Compiled, to spit out the equivalent of `(c | 0x20) == 'e'` rather than `(c == 'E'| c == 'e')`.

Along the way, I cleaned up a few things as well, such as passing around a CultureInfo more rather than repeatedly calling CultureInfo.CurrentCulture, using CollectionsMarshal.GetValueRefOrAddDefault on a hot path to do with interning strings in a lookup table, tweaking SymbolicRegexRunnerFactory's Runner to itself be generic to avoid an extra layer of virtual dispatch per operation, and cleaning up code / comments in SymbolicRegexMatcher along the way.

For the most part the purpose of the change wasn't to improve perf, and in fact I was willing to accept some regressions in the name of consolidation.  There are a few regressions here, mostly small, and mostly for cases where we're simply paying an overhead for vectorization, e.g. where the current location is fine to match, or where the target character being searched for is very frequent.  Overall, though, there are some substantial improvements.

* Fix missing condition in RegexCompiler

* Try to fix mono failures and address comment feedback

* Delete more now dead code

* Fix dead code emitting after refactoring

Previously return statements while emitting anchors were short-circuiting the rest of the emitting code, but when I moved that code into a helper, the returns stopped having that impact, such that we'd end up emitting a return statement and then emit dead code after it.  Fix it.

* Remove some now dead code

[DllImportGenerator] Enable on projects without System.Memory and System.Runtime.CompilerServices.Unsafe (#61704)

Remove XUnit reference metadata from tests I switched over last week (#61691)

During code review of my latest PR Bruce raised the concern that
hard-coding public key values and version ID for the xunit.core
reference will cause enormous maintenance pain if we decide to
upgrade to a newer version of the module in the future. As Jeremy
verified that the metadata is not really needed, I'm deleting it
from all tests I switched over last week.

Thanks

Tomas

refactoring (#60074)

Co-authored-by: kronic <kronic@softland.ru>

Ignore missing data result from superpmi-replay run (#61699)

* Ignore missing data result

* Move result = false only if error Code is other than 2/3

Remove some unnecessary slicing from generated Regex code (#61701)

* Remove some unnecessary slicing from generated Regex code

When we're outputting code to match a "multi" (a sequence of multiple characters), we're currently issuing a Slice for the known tracked offset even if that offset is 0.  We can skip that nop.

* Address PR feedback

Extend RegexCharClass.Canonicalize range inversion optimization (#61562)

* Extend RegexCharClass.Canonicalize range inversion optimization

There's a simple optimization in RegexCharClass.Canonicalize that was added in .NET 5, with the goal of taking a set that's made up of exactly two ranges and seeing whether those ranges were leaving out exactly one character.  If they were, the set can instead be rewritten as that character negated, which is a normalized form used downstream and optimized.  We can extend this normalization ever so slightly to be for two ranges separated not just be a single character but by more than that as well.

* Update TODO comment

* Add some more reduction tests

Minor File.ReadAllBytes* improvements (#61519)

* switch from FileStream to RandomAccess

* use Array.MaxLength as a limit for File.ReadAllBytes and fix an edge case bug for files: Array.MaxLength < Length < int.MaxValue

* there is no gain of using FileOptions.SequentialScan on Unix, as it requires an additional sys call

Co-authored-by: Dan Moseley <danmose@microsoft.com>

[wasm][debugger] Fix evaluation of a static class attribute; using current namespace for evaluation (#61252)

* Using current namespace as the default place to serach for the resolved class.

* Add tests for static class, static fields and pausing in async method.

* Added tests for class evaluation.

* Fixing support to the current namespace and adding tests for it

* Assuing that we search within the current assembly first. Removed tests that fail in Consol App.

* Remove a test-duplicate that was not testing static class or static fields.

* Fixing indentation.

* Refixing indentation.

* Refix indentations again.

* Applied the advice about adding new blank lines.

* Changed the current assembly check.

* Extracting the check from the loop. One time check is enough.

* Simplifying multiple test cases into one call.

* Using local function as per review suggestion.

* Added test that was skipped by mistake.

* Added looking for the namespace in all assemblies because there is a chance it will be located out of the current assembly.

* Extracting value based on the current frame, not the top of stack location.

* Test for classes evaluated from different frames.

* Fixing indentation and spaces.

* Applied review comments for values evaluation.

* Compressed two tests into one with MemberData.

* Added test case of type without namespace (failing).

* Addressed Ankit advices from the review.

Co-authored-by: DESKTOP-GEPIA6N\Thays <thaystg@gmail.com>

[mono][aot] Fix the inclusion of generic instances when doing profiled AOT. (#61627)

If a profile contained a method like List<AnInst>:.ctor () and the
'profile-only' option was used, the fully shared version of the method
needs to be added to the aot image.

[wasm] renames and cleanup before modularization (#61596)

- no imports from outer scope
- move dotnet to -extern-pre-js
- re-enable JS minification with ES2018
- rename main javaScript files to main.js and test-main.js
- sample and test script cleanup
- rename set_exit_code method
- rewrite test start as async method
- improve script loading via script element on page in test
- use BINDING.bind_static_method instead of INTERNAL where possible
- better .d.ts exports
- formatted html files
- renamed modules.ts to imports.ts which makes more sense
- improved error propagation
- renamed __initializeImportsAndExports
- delayed exit and stdout flush

Update SPCL to use GeneratedDllImport where possible. (#61640)

* Update SPCL to use GeneratedDllImport where possible.

JIT: don't import IL for partial compilation blocks (#61572)

Adjust partial comp not to import IL instead of importing it and then
deleting the IR. Saves some time and also sometimes a bit of stack
space as we won't create as many temps.

Update both PC and OSR to check for blocks in handlers early, rather
than pretending to support these and then backing out later.

Add [Fact] attributes to all remaining ilproj tests (#61625)

Add .runsettings file to be able to run and debug tests on vscode in codespace with prebuilt (#61684)

[DllImportGenerator] Stop ignoring QCalls when looking for methods to convert to GeneratedDllImport (#61678)

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

* Localized file check-in by OneLocBuild Task: Build definition ID 679: Build ID 1472242

* Localized file check-in by OneLocBuild Task: Build definition ID 679: Build ID 1472678

Use GeneratedDllImport for blittable p/invokes in System.IO.Compression, System.IO.Compression.Brotli, System.Net.Http, System.Net.NameResolution (#61638)

Update WASM README.md (#61681)

* Update WASM README.md

[wasm][debugger] View multidimensional array when debugging (#60983)

* It's working when debug from chrome but not when debug from VS, because it uses callFunctionOn

* Remove unrelated change.

* Working also on VS.

* Working also on VS.

* Addressing @lewing and @radical comments

* Change ArrayDimensions to be a record and not a class as suggested by @radical.

* Addressing @radical comments.

[wasm][debugger] Improvement of memory consumption while Evaluating Expressions (#61470)

* Fix memory consumption.

* Fix debugger-tests

* Fix compilation.

* Addressing @lewing PR.

* Address @lewing comment

* Addressing @radical comment.

* Addressing comments.

* Addressing @radical comments.

* missing return.

* Addressing @radical comments

* Adding test case

Co-authored-by: Larry Ewing <lewing@microsoft.com>
* Fixing tests.

* Adding another test case. Thanks @lewing.

* Reuse the script.

Co-authored-by: Larry Ewing <lewing@microsoft.com>

[wasm] Rework fetch (#61639)

* Unify some code and load mono-config.json using our _fetch_asset

Fix poisoning for very large structs (#61521)

For very large structs poisoning could end up generating instructions
requiring larger local var offsets than we can handle which would hit an
IMPL_LIMIT that throws InvalidProgramException. Switch to using rep
stosd (x86/x64)/memset helper (other platforms) when a local needs more
than a certain number of mov instructions to poison.

Also includes a register allocator change to mark killed registers as
modified in addRefsForPhysRegMask instead of by the (usually) calling
function, since this function is used directly in the change.

Disable fgMorphCastedBitwiseOp opt for floats (#61657)

[arm64] JIT: Make 0.0 containable for fcmp (#61617)

Give create codespaces prebuild action right permissions (#61651)

Fix SuperPMI Python script Azure usage (#61650)

The on-demand Azure module load was refactored to jitutil.py,
but that requires some cross-module importing to work. Do the
minimal required to make this work.

Provide locations for src-gen diagnostic output (#61430)

* Provide locations for src-gen diagnostic output

* Fix tests and address feedback

* Add defensive check for context type location

XArch: Trim the code block to match the actual code length (#61523)

* Trim the hot code size to the actual code length

* Remove allocatedHotCodeSize field

* Remove verbose logging

* Perform trimming only for xarch

* Include more comment about armarch

* Fix the condition for arm64

Add tests for CNG symmetric key algorithm mismatches

Obsolete thumbtacked AssemblyName properties (#59522)

* Obsolete thumbtacked AssemblyName properties

Fix #59061

* Ignore obsoletion

* Fix pragma

* Merge the AssemblyName member obsoletions into a single diagnostic id

* Fix pragma to use updated diagnostic id

* Suppress SYSLIB0037 in reflection tests

* Suppress SYSLIB0037 warnings

Co-authored-by: Jeff Handley <jeffhandley@users.noreply.github.com>
Co-authored-by: Jeff Handley <jeff.handley@microsoft.com>

Only run JIT formatting job if there are JIT changes (#61632)

Allow for backport to report progress to PR (#61637)

Restrict GITHUB_TOKEN in markdownlint action (#61622)

Currently, Actions in the dotnet/runtime repository have read/write
access by default, unless their permissions have been explicitly declared.

The markdownlint workflow can be restricted from all access except the
repository contents. This limits what the 3rd party `markdownlint-cli`
npm package can do which is installed as part of the workflow.

Use GeneratedDllImport in Microsoft.Win32.SystemEvents (#61609)

Enable SymbolicRegexNode.IsNullableFor fast path to inline (#61605)

Delete impCheckForNullPointer (#61576)

The comment above the method mentions "many problems" with leaving
null pointers around, but it is unclear what kind of problems. I can
only speculate those were the problems in legacy codegen which "could
not handle constant op1".

It also mentions that "we cannot even fold (null+offset)", which is
incorrect: "gtFoldExprConst" does in fact fold such expressions to
zero byrefs. It is also the case that spilling the null into a local
affects little as local assertion propagation happily propagates the
null back into its original place.

There was also a little bug associated with the method that got fixed:
morph was trying to use it, and in the process created uses of a local
that was not initialized, since the statement list used by the method
is the importer's one, invalid in morph.

[wasm] parallel asset loading (#61610)

Adding support for X86Base.Pause() and ArmBase.Yield() (#61065)

* Adding support for X86Base.Pause() and ArmBase.Yield()

* Applying formatting patch

* Ensure NI_ArmBase_Yield actually gets through to codegen on arm64

Create runtime staging clone to manually kick off full test runs (#61443)

This change allows devs to manually kick off full test runs on the configurations that only execute smoke tests per PR.

/azp runtime-staging-manual will do the trick

Give write access to backport action explicitly (#61626)

Loop refactoring and commenting improvements (#61496)

- Remove unneeded FIRST concept in loop table; it was always equal to TOP.
- Rename optMarkLoopsBlocks to optScaleLoopBlocks to more accurately describe
what it does. More consistently report block scaling in the dump
- Create optMarkLoopHeads. This was refactored out of fgRemoveUnreachableBlocks so
it can be called in a more logical location (at the beginning of optFindLoops),
and only does one thing.
- fgMakeOutgoingStructArgCopy: remove unused `argIndex` argument; reorder calls to
fgMightHaveLoop.
- Update and write a bunch of comments; convert away from `/* */` style comments.

There shouldn't be a 'lib' prefix on Windows .lib files (#61618)

Delete dead code (#61533)

* Delete regArgList

Unused.

* Delete CountSharedStaticHelper

Unused.

* Delete GTF_RELOP_QMARK

Unused.

* Delete lvaPromotedStructAssemblyScratchVar

Unused.

* Delete dead code from fgMorphSmpOp

The conditions tested constitute invalid IR.

* Delete gtCompareTree

Unused.

* Delete gtAssertColonCond

Unused.

* Delete IsSuperPMIException

Unused.

Improve System.Speech trimmability (#61566)

by removing obvious warnings

Fix LastWriteTime and LastAccessTime of a symlink on Windows and Unix (#52639)

* Implement most of the fix for #38824

Reverts the changes in the seperate PR https://github.com/dotnet/runtime/commit/a617a01195b4dad3cb5f300962ad843b46d4f175 to fix #38824.
Does not re-enable the test because that relies on #49555, will add a seperate commit to whichever is merged last to enable the SettingUpdatesPropertiesOnSymlink test.

* Most of the code for PR #52639 to fix #38824

• Deal with merge conflicts
• Add FSOPT_NOFOLLOW for macOS and use it in setattrlist
• Use AT_SYMLINK_NOFOLLOW with utimensat (note: there doesn't seem to be an equivalent for utimes)
• Add SettingUpdatesPropertiesOnSymlink test to test if it actually sets it on the symlink itself (to the best that we can anyway ie. write + read the times)
• Specify FILE_FLAG_OPEN_REPARSE_POINT for CreateFile in FileSystem.Windows.cs (is there any other CreateFile calls that need this?)

* Remove additional FILE_FLAG_OPEN_REPARSE_POINT

I added FILE_FLAG_OPEN_REPARSE_POINT before and it was then added in another PR, this removes the duplicate entry.

* Add missing override keywords

Add missing override keywords for abstract members in the tests.

* Fix access modifiers

Fix access modifiers for tests - were meant to be protected rather than public

* Add more symlink tests, rearrange files

• Move symlink creation api to better spot in non-base files
• Add IsDirectory property for some of the new tests
• Change abstract symlink api to CreateSymlink that accepts path and target
• Create a CreateSymlinkToItem method that creates a symlink to an item that may be relative that uses the new/modified abstract CreateSymlink method
• Add SettingUpdatesPropertiesCore to avoid code duplication
• Add tests for the following variants: normal/symlink, target exists/doesn't exist, absolute/relative target
• Exclude nonexistent symlink target tests on Unix for Directories since they are counted as files

* Fix return type of CreateSymlink in File/GetSetTimes.cs

* Remove browser from new symlink tests as it doesn't support creation of symlinks

Remove browser from new symlink tests as it doesn't support creation of symlinks

* Use lutimes, improve code readability, simplify tests

• Use lutimes when it's available
• Extract dwFlagsAndAttributes to a variable
• Use same year for all tests
• Checking to delete old symlink is unnecessary, so don't
• Replace var with explicit type

* Change year in test to 2014 to reduce diff

* Rename symlink tests, use 1 core symlink times function, and check that target times don't change

Rename symlink tests, use 1 core symlink times function, and check that target times don't change

* Inline RunSymlinkTestPart 'function'

Inline RunSymlinkTestPart 'function' so that the code can be reordered so the access time test can be valid.

* Share CreateSymlinkToItem call in tests and update comment for clarity

* Update symlink time tests

• Make SettingUpdatesPropertiesOnSymlink a theory
• Remove special case for Unix due to https://github.com/dotnet/runtime/pull/52639#discussion_r739009259 (will revert if fails)
• Rename isRelative to targetIsRelative for clarity

* Remove unnecessary Assert.All

* Changes to SettingUpdatesPropertiesOnSymlink test

• Rename item field to link field
• Don't use if one-liner
• Use all time functions since only using UTC isn't necessary
• Remove the now-defunct IsDirectory property since we aren't checking it anymore

* Remove unnecessary fsi.Refresh()

• Remove unnecessary fsi.Refresh() since atime is only updated when reading a file

* Updates to test and pal_time.c

• Remove targetIsRelative cases
• Multi-line if statement
• Combine HAVE_LUTIMES and #else conditions to allow more code charing

* Remove trailing space

Fix CharInClass reference in regex emitter (#61559)

We've tried to consistently use global:: whenever referring to core library types in the regex generator emitted code.  I'd missed these two.

(That said, these make the code a lot harder to read, especially in places where we're unable to use extension methods as extensions, so we'll want to revisit this policy.)