upstream main merge 2021 11 29 #5

* Delete unused mono_unbox_int * Fix gcc step display name * Match command invocation order

…e to be blittable (dotnet#61071)

Create a new `runtime-coreclr superpmi-asmdiffs` pipeline that runs SuperPMI asmdiffs for every change in the JIT directory. The diffs are run on two platforms: Windows x64 and Windows x86. Linux, and Arm64 and Arm32, asm diffs are done using cross-compilers, as follows: | Platform | Asm diffs | | -- | -- | | Windows x64 | win-x64, win-arm64, linux-x64, linux-arm64 | | Windows x86 | win-x86, linux-arm | The resulting summary .md files are uploaded into the pipeline artifacts, one .md file per platform (so, one for the Windows x64 runs and one for the Windows x86 runs). The results are also displayed in "Extensions" page of the AzDO pipeline. The runs take about 50 minutes to complete (assuming not much waiting for machines). The asm diffs pipeline is similar to the "superpmi-replay" pipeline, except: 1. It determines what an appropriate baseline JIT would be based on the PR commit and how it merges with the `main` branch. Given this, it downloads the matching baseline JITs from the JIT rolling build artifacts in Azure Storage. 2. It clones the `jitutils` repo and builds the `jit-analyze` tool, needed to generate the summary .md file. 3. It downloads and adds to the Helix machine payload a "portable" `git` installation, as `git diff` is used by `jit-analyze` for analyzing the generated .dasm files of the diff. 4. It collects all the various summary.md files into one per platform on which the runs are done, and publishes that to the artifacts and the `Extensions` page. 5. It only does one replay (asmdiffs) run, not one for each of a set of multiple stress modes. As part of this implementation, a. The `azdo_pipelines_util.py` was renamed to `jitutil.py`, and a lot of utility functions from superpmi.py were moved over to it. This was mostly to share the code for downloading and uncompressing .zip files. (There is a slight change to the output from the `superpmi.py download` command as a result.) However, I also moved a bunch of simple, more general helpers, for possible future sharing. b. `jitrollingbuild.py download` can now take no arguments and download a baseline JIT (from the JIT rolling build Azure Storage location), for the current enlistment, to the default location. Previously, it required a specific git_hash and target directory. There is similar logic in superpmi.py, but not quite the same. c. The `superpmi.py --no_progress` option was made global, and applied in a few more places. This was necessary because `superpmi.py asmdiffs` will download a coredistools binary from the JIT Azure Storage if one isn't found in the Core_Root folder. Fixes dotnet#59445

… dotnet/hotreload-utils dotnet/llvm-project (dotnet#61365) Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com> Co-authored-by: Ankit Jain <[email protected]>

…#61431)

Previously the Directory.Build.targets script used to automatically infer that OutputType=Library without a CLRTestKind implies SharedLibrary. This is however hard to consolidate with the planned test merging - as the SDK script set OutputType=Library by default, we need the combination Library+(implicit)BuildAndRun to indicate the "new-style" [Fact]-based tests. For this reason I propose to remove this automatic inference and manually fix the handful of tests that are missing an explicit CLRTestKind=SharedLibrary property. In light of this description we can theoretically remove the OutputType=Library specification from all test projects but even if we decide to do that, I believe it will be easier to do that as a separate mechanical change, not as part of this relatively small change that has a different purpose. Additionally in the one case of the GitHub_22583 regression test, I removed the explicit setting of GenerateRunScript=false because that's the default. Fix OutputType=exe in OpenDelegate.csproj I believe this was a pre-existing bug - previously, with the special clause regarding SharedLibrary, the test just got silently skipped because it was considered to be a shared library. Thanks Tomas

* coreclr/ Make sure integral types respect sign extension during widen operation for Invoke Array ctor. Remove always false IsStructRequiringStackAllocRetBuf(). * mono/ Create macro define for SPAN_T. * libraries/ Add tests for Reflection Binder type conversion support during Invoke.

Catch patterns like the one in dotnet#37904 where a trinary compare feeds a binary compare.

Fixes dotnet#61322 Fixes dotnet#61299

* We were not recording precise info in inlinees except for at IL offset 0 because most of the logic that handles determining when to attach debug info did not run for inlinees. There are no changes in what the EE sees since we were normalizing debug info back to the root anyway. * Propagate debug info even further than just until rationalization, to make it simpler to dump the precise debug info. This means we create some more GT_IL_OFFSET nodes, in particular when the inlinee debug info is valid but the root info is invalid. This is currently happening for newobj IL instructions when the constructor is inlined. We generate two statements: GT_ASG(GT_LCL_VAR(X), ALLOCOBJ(CLS)); GT_CALL(CTOR, GT_LCL_VAR(X)) and the first statement ends up "consuming" the debug info, meaning we end up with no debug info for the GT_CALL, which eventually propagates into the inline tree. I have held off on fixing this for now since it causes debug info diffs in the data reported back to the EE. The additional nodes in LIR result in 0.15% more memory use and 0.015% more instructions retired for SPMI over libraries. There is also a small fix in gtlist.h for GT_BFIZ when MEASURE_NODE_SIZES is defined. No SPMI diffs.

There are connectivity issues on some physical Android devices. We should disable the affected tests until the issue isn't resolved. Ref dotnet#61343

…net#60966) We reference entry #0 in the pinned plug queue even if there are no pinned plugs at all and thus the pinned plug queue contains left-over data from the mark phase. The fix is to initialize saved_pinned_plug_index to a value that is invalid as a pinned plug queue index, and only use saved_pinned_plug_index as an index if is valid.

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

…et#61389)

Don't run if the JIT-EE GUID has changed, since there won't be any collections to download, so the downloads will fail. Also update the superpmi-asmdiffs trigger comment.

…otnet#61199) (dotnet#61449)

… annotate individual methods as requiring AVX (dotnet#61259) * Updating src/tests/Interop/PInvoke/Generics/GenericsNative.Vector* to annotate individual methods as requiring AVX * Always use __m256i on XARCH

* XARCH: Remove redudant tests for GT_LT/GT_GE relops. We can now optimize cases such as `(x + y < 0)` or `for (int x = v; x >= 0; x--)` using the flag tracking logic during the emit stage. Notably, cases that would generate... ``` add reg0, reg1 test reg0, reg0 jge LABEL ``` now transform to ``` add reg0, reg1 jns LABEL ``` This transform is valid for signed GE and signed LT only. * Add a few asserts related to flag reuse optimizations.

* Moving Narrow to implemented using SIMDAsHWIntrinsic * Moving Widen to implemented using SIMDAsHWIntrinsic * Fix some handling of Narrow/Widen hwintrinsics * Ensure that Vector.Widen is still treated as an intrinsic * Fixing NI_VectorT128_WidenUpper on ARM64 to actually call gtNewSimdWidenUpper

Measure browser app start times, 2 measurements implemented. First to measure till the JS window.pageshow event, second to measure time when we reach managed C# code. Example ouput: | measurement | time | |-:|-:| | AppStart, Page show | 108.1400ms | | AppStart, Reach managed | 240.2174ms |

* Environment.SystemPageSize returns cached value * we are no longer shipping MS.IO.Redist, so we can use Array.MaxLength directly * we are no longer shipping MS.IO.Redist, there is no need for File to be partial * we are no longer shipping MS.IO.Redist, there is no need for FileInfo to be partial * there is no need for .Win32.cs and .Windows.cs file anymore

…otnet#61479)

* Remove all DLLIMPORTGENERATOR_ENABLED usage. * Explicitly set EnableDllImportGenerator to true in test project.

… the receiver is a gshared type constrained to a primitive type/enum. (dotnet#61513)

…trained types. (dotnet#61514) These are used for example in Span<T>:.ctor ().

This was preventing block compaction with loop entry blocks in loops that had been previously optimized away (and thus removed from the loop table). There are a few cases where we now delete dead code that was previously left in the function. There are a number of spurious local weighting and IG textual asm diffs changes, possibly due to how PerfScore is implemented (there are some surprisingly large PerfScore changes in a few cases, despite no change in (most) generated code).

…ardless of what they point at (dotnet#61538)

Implement method name wildcard matching for method descriptions Globbing doesn't work because we don't have g_pattern_match_simple in eglib. But a plain '*' wildcard does work.

When both OSR and PGO are enabled: * Enable instrumenting OSR methods, so that the combined profile data from Tier0 plus any OSR variants provide a full picture for subsequent Tier1 optimization. * Use block profiles for both Tier0 methods that are likely to have patchpoints and OSR methods. * Fix phase ordering so partially jitted methods don't lose probes. * A few more fixes for partial compilation, because the number of things we think we might instrument and the number of things we end up instrumenting can differ. * Also improve the DumpJittedMethod output for OSR, and allow selective dumping of a particular OSR variant by specifying its IL offset. The updates on the runtime side are to pass BBINSTR to OSR methods, and to handle the (typical) case where the OSR method instrumentation schema is a subset of the Tier0 method schema. We are still allowing OSR methods to read the profile data. So they are both profile instrumented and profile optimized. Not clear if this is going to work well as the Tier0 data will be incomplete and optimization quality may be poor. Something to revisit down the road.

Emit it in the interpreter when a method is inlined or replaced with an intrinsic. This is needed so the AOT profiler can track these methods.

…traints. (dotnet#59437) If a generic argument is a primitive type, and it has an interface constraint that enums don't implement, then partial sharing for that instance is not useful, since only the specific primitive type instance will be able to use the shared version. Fixes dotnet#54910.

* Enable new analyzers in global configs * Address PR feedback

For now there's no functional change to the behavior of the tests, I have just copied the bits to inject from Jeremy's example in his pending PR. Thanks Tomas

* embedded size * next array * read consistency while rehashing * comments * remove CRST_UNSAFE_ANYMODE and COOP mode in the callers * typo * fix 32bit builds * couple changes from review. * Walk the buckets in resize. * remove a `REVIEW:` comment. * Update src/coreclr/vm/dacenumerablehash.inl PR review suggestion Co-authored-by: Jan Kotas <[email protected]> * remove use of `auto` * DAC stuff * Constructor and GrowTable are not called by DAC, no need for DPTR, added a comment about a cast. * SKIP_SPECIAL_SLOTS * More compact dac_cast in GetNext Co-authored-by: Jan Kotas <[email protected]>

For now there's no functional change to the behavior of the tests, I have just copied the bits to inject from Jeremy's example in his pending PR. Thanks Tomas Contributes to: dotnet#54512

For now there's no functional change to the behavior of the tests, I have just copied the bits to inject from Jeremy's example in his pending PR. I have spot-checked that some of the tests use Main with the command-line args argument. I'm not changing them in this PR, the signature only becomes important once we start actually merging the IL tests and I presume we'll clean that up at that point. Thanks Tomas Contributes to: dotnet#54512

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

* Add JsonSerializerOptions.Default * address feedback * address feedback

`__DoCrossgen2` appears to be redundant with `__TestBuildMode=crossgen2`.

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

The issue was that VNApplySelectors uses the types of fields when selecting, but that's not valid for "the first field" maps. Mirror how the stores to fields are numbered.

For very large structs (> 64K in size) poisoning could end up generating instructions requiring larger local var offsets than we can handle. This hits IMPL_LIMIT that throws InvalidProgramException. Turn off poisoning for larger structs that require more than 16 movs to also avoid the significant code bloat by the singular movs. This is a less risky version of dotnet#61521 for backporting to .NET 6. Fix dotnet#60852

…tValueAtIndex (dotnet#60520) * SortedList<TKey, TValue> added GetKeyAtIndex, GetValueAtIndex, and SetValueAtIndex * Update src/libraries/System.Collections/src/System/Collections/Generic/SortedList.cs Co-authored-by: Eirik Tsarpalis <[email protected]>

This optimization is only legal if: 1) "Anything" is a sufficiently small constant itself. 2) We are in a context where we know the address will in fact be used for an indirection. It is the second point that is problematic - one would like to use MorphAddrContext, but it is not suitable for this purpose, as an unknown context is counted as an indirecting one. Additionally, the value of this optimization is rather low. I am guessing it was meant to support the legacy nullchecks, before GT_NULLCHECK was introduced, and had higher impact then. So, just remove the optimization and leave the 5 small regressions across all of SPMI be.

* Apply suggestions from code review Co-authored-by: Adam Sitnik <[email protected]> Co-authored-by: Jeremy Koritzinsky <[email protected]>

…Process, System.Diagnostics.Process, System.Diagnostics.FileVersionInfo, System.Runtime.InteropServices.RuntimeInformation (dotnet#61532)

* FileSystem.Unix: improve CopyFile. Like the upcoming version of GNU coreutils 'cp' prefer a copy-on-write clone. This shares the physical storage between files, which means no data needs to copied. CoW-clones are supported by a number of Linux file systems, like Btrfs, XFS, and overlayfs. Eliminate a 'stat' call that is always performed for checking if the target is a directory by only performing the check when the 'open' syscall reports an error. Eliminate a 'stat' call for retrieving the file size of the source by passing through the length that was retrieved when checking the opened file is not a directory. Create the destination with file permissions that match the source. We still need to fchmod due to umask being applied to the open mode. When performing a manual copy, limit the allocated buffer for small files. And, avoid the last 'read' call by checking when we've copied the expected nr of bytes. * Don't FICLONE for zero sourceLength * PR feedback * When using sendfile, don't loop when source file gets truncated. * Fall through when FICLONE fails. * Don't stop CopyFile_ReadWrite until read returns zero. * Revert all changes to CopyFile_ReadWrite * Move comment a few lines up. * Fix unused error.

Since libproc is a private Apple API, it is not available on iOS/tvOS and should be excluded (see dotnet#61265 (comment) and above for more details). This PR excludes $(CommonPath)Interop\OSX\Interop.libproc.cs on the iOS/tvOS as well as makes some methods in Process, ProcessManager, and ProcessThread classes calling that API throw PNSE so that for iOS/tvOS it's possible to re-use the respective *.UnknownUnix.cs parts.

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.)

…dotnet#52639) * Implement most of the fix for dotnet#38824 Reverts the changes in the seperate PR dotnet@a617a01 to fix dotnet#38824. Does not re-enable the test because that relies on dotnet#49555, will add a seperate commit to whichever is merged last to enable the SettingUpdatesPropertiesOnSymlink test. * Most of the code for PR dotnet#52639 to fix dotnet#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 dotnet#52639 (comment) (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

by removing obvious warnings

* 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.

- 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.

…net#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

* Adding support for X86Base.Pause() and ArmBase.Yield() * Applying formatting patch * Ensure NI_ArmBase_Yield actually gets through to codegen on arm64

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.

)

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.

* Obsolete thumbtacked AssemblyName properties Fix dotnet#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 <[email protected]> Co-authored-by: Jeff Handley <[email protected]>

) * 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

* Provide locations for src-gen diagnostic output * Fix tests and address feedback * Add defensive check for context type location

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.

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.

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

@lewing

…xpressions (dotnet#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 <[email protected]> * Fixing tests. * Adding another test case. Thanks @lewing. * Reuse the script. Co-authored-by: Larry Ewing <[email protected]>

@lewing

…0983) * 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.

* Update WASM README.md

…on, System.IO.Compression.Brotli, System.Net.Http, System.Net.NameResolution (dotnet#61638)

… Build ID 1472678 (dotnet#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

… convert to GeneratedDllImport (dotnet#61678)

…codespace with prebuilt (dotnet#61684)

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.

* Update SPCL to use GeneratedDllImport where possible.

- 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

…d AOT. (dotnet#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.

…rrent namespace for evaluation (dotnet#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 <[email protected]>

* 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 <[email protected]>

…et#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

* 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

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

Co-authored-by: kronic <[email protected]>

…otnet#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

…tem.Runtime.CompilerServices.Unsafe (dotnet#61704)

…tChar (dotnet#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

* 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

…net#61621)

…tography

* 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

Co-authored-by: Alexander Köplinger <[email protected]> Co-authored-by: Jan Kotas <[email protected]> Co-authored-by: Santiago Fernandez Madero <[email protected]> Co-authored-by: Tomas <[email protected]>

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

* 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 3ef7adb. * fix the parameter retainOnlyTopFiles * add missing - * Revert "Temp change to disable align loop" This reverts commit b1de5c4. * Revert "download specific artifacts" This reverts commit db3de57. * Review comments

…implify the api (dotnet#61392) * Make SMonoSdbHelper part of the execution context

* 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 <[email protected]> Co-authored-by: Bruce Forstall <[email protected]>

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

* Convert Crypto P/Invokes to GeneratedDllImport.

…erviceProcess.ServiceController (dotnet#61741)

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

…leted. (dotnet#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.

…#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.

* 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.

…t#61698) * Reduce atomic single char lazy loops * Add single char lazy loop support to simplified code gen

These checks appears to be redundant.

This is a follow up PR for dotnet#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 dotnet#60588 as well)

…guration.Binder` (dotnet#57418) * Annotate * Update Microsoft.Extensions.Configuration.Binder.csproj * DisableImplicitAssemblyReferences * Nullablity fix * configureOptions are non-nullable * Revert "configureOptions are non-nullable" This reverts commit 5dac613. * 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 <[email protected]>

…61711)

)" (dotnet#61799)

…tnet#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 dotnet#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

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.

* Apply BuiltInComInterop feature switch to managed code * Feedback * Remove two more

…guration.EnvironmentVariables` (dotnet#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 <[email protected]>

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.

…gedType (dotnet#61808)

* 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

…stenerTests on iOS/tvOS (dotnet#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 dotnet#61590.

Fix typo

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.

* 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 <[email protected]> Co-authored-by: Alexander Köplinger <[email protected]>

* 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 <[email protected]>

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).

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 )

…net#61655)

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

… be present (dotnet#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.

…guration.CommandLine` (dotnet#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 fbfb3ba. * Fix NetCoreAppMinimum build Co-authored-by: Eric Erhardt <[email protected]>

* 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 <[email protected]>

…1803)

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 <[email protected]>

* Introducing GenTreeMultiOp * Rewrite gtNewSIMDNode * Rewrite gtNewSIMDVectorZero * Rewrite gtNewHWIntrinsicNode * Rewrite GenTreeSIMD::OperIsMemoryLoad * Rewrite GenTreeHWIntrinsic::OperIsMemoryLoad * Rewrite GenTreeHWIntrinsic::OperIsMemoryStore * Rewrite GenTree::IsIntegralConstVector * Rewrite GenTree::NullOp1Legal * Rewrite GenTree::IsSIMDZero * Rewrite GenTree::isCommutativeSIMDIntrinsic * Rewrite GenTree::isCommutativeHWIntrinsic * Rewrite GenTree::isContainableHWIntrinsic * Rewrite GenTree::isRMWHWIntrinsic * Rewrite GenTreeVisitor * Rewrite GenTreeUseEdgeIterator * Rewrite GenTree::VisitOperands * Rewrite GenTree::TryGetUse * Rewrite gtGetChildPointer * Rewrite gtHasRef * Rewrite fgSetTreeSeqHelper * Rewrite GenTree::NumChildren * Rewrite GenTree::GetChild * Rewrite GenTree::Compare * Rewrite gtCloneExpr * Rewrite gtSetEvalOrder * Rewrite gtHashValue * Rewrite gtDispTree * Rewrite fgDebugCheckFlags * Add genConsumeMultiOpOperands * Rewrite genConsumeRegs * Rewrite HWIntrinsic::HWIntrinsic * Rewrite HWIntrinsic::InitializeOperands * Delete HWIntrinsicInfo::lookupNumArgs * Delete HWIntrinsicInfo::lookupLastOp * Rewrite HWIntrinsicImmOpHelper ARM64 * Rewrite inst_RV_TT_IV * Rewrite inst_RV_RV_TT * Rewrite genSIMDIntrinsic XARCH * Rewrite genSIMDIntrinsicInit XARCH * Rewrite genSIMDIntrinsicInitN XARCH * Rewrite genSIMDIntrinsicUnOp XARCH * Rewrite genSIMDIntrinsic32BitConvert XARCH * Rewrite genSIMDIntrinsic64BitConvert XARCH * Rewrite genSIMDIntrinsicWiden XARCH * Rewrite genSIMDIntrinsicNarrow XARCH * Rewrite genSIMDIntrinsicBinOp XARCH * Rewrite genSIMDIntrinsicRelOp XARCH * Rewrite genSIMDIntrinsicShuffleSSE2 XARCH * Rewrite genSIMDIntrinsicUpperSave XARCH * Rewrite genSIMDIntrinsicUpperRestore XARCH * Rewrite genSIMDIntrinsic ARM64 * Rewrite genSIMDIntrinsicInit ARM64 * Rewrite genSIMDIntrinsicInitN ARM64 * Rewrite genSIMDIntrinsicUnOp ARM64 * Rewrite genSIMDIntrinsicWiden ARM64 * Rewrite genSIMDIntrinsicNarrow ARM64 * Rewrite genSIMDIntrinsicBinOp ARM64 * Rewrite genSIMDIntrinsicUpperSave ARM64 * Rewrite genSIMDIntrinsicUpperRestore ARM64 * Rewrite genHWIntrinsic_R_RM XARCH * Rewrite genHWIntrinsic_R_RM_I XARCH * Rewrite genHWIntrinsic_R_R_RM XARCH * Rewrite genHWIntrinsic_R_R_RM_I XARCH * Rewrite genHWIntrinsic_R_R_RM_R XARCH * Rewrite genHWIntrinsic_R_R_R_RM XARCH * Rewrite genHWIntrinsic XARCH * Rewrite genBaseIntrinsic XARCH * Rewrite genX86BaseIntrinsic XARCH * Rewrite genSSEIntrinsic XARCH * Rewrite genSSE2Intrinsic XARCH * Rewrite genSSE41Intrinsic XARCH * Rewrite genSSE42Intrinsic XARCH * Rewrite genAvxOrAvx2Intrinsic XARCH * Rewrite genBMI1OrBMI2Intrinsic XARCH * Rewrite genFMAIntrinsic XARCH * Rewrite genLZCNTIntrinsic XARCH * Rewrite genPOPCNTIntrinsic XARCH * Rewrite genXCNTIntrinsic XARCH * Rewrite genHWIntrinsic ARM64 * Rewrite insertUpperVectorSave * Rewrite insertUpperVectorRestore * Rewrite getKillSetForHWIntrinsic * Rewrite BuildSIMD XARCH * Rewrite BuildOperandUses/BuildDelayFreeUses * Rewrite BuildSIMD ARM64 * Rewrite BuildHWIntrinsic XARCH * Rewrite LowerSIMD XARCH * Rewrite ContainCheckSIMD XARCH * Rewrite LowerHWIntrinsicCC XARCH * Rewrite LowerFusedMultiplyAdd XARCH * Rewrite LowerHWIntrinsic XARCH * Rewrite LowerHWIntrinsicCmpOp XARCH * Rewrite LowerHWIntrinsicGetElement XARCH * Rewrite LowerHWIntrinsicWithElement XARCH * Rewrite LowerHWIntrinsicCreate XARCH * Rewrite LowerHWIntrinsicDot XARCH * Rewrite LowerHWIntrinsicToScalar XARCH * Rewrite IsContainableHWIntrinsicOp XARCH * Rewrite ContainCheckHWIntrinsic XARCH * Rewrite IsValidConstForMovImm ARM64 * Rewrite LowerHWIntrinsic ARM64 * Rewrite LowerHWIntrinsicFusedMultiplyAddScalar ARM64 * Rewrite LowerHWIntrinsicCmpOp ARM64 * Rewrite LowerHWIntrinsicCreate ARM64 * Rewrite LowerHWIntrinsicDot ARM64 * Rewrite ContainCheckStoreLoc ARM64 * Rewrite ContainCheckSIMD ARM64 * Rewrite ContainCheckHWIntrinsic ARM64 * Rewrite DecomposeHWIntrinsicGetElement X86 * Rewrite DecomposeHWIntrinsic X86 * Rewrite Rationalizer::RewriteNode * Rewrite optIsCSEcandidate * Rewrite fgValueNumberTree * Rewrite fgValueNumberSimd * Rewrite fgValueNumberHWIntrinsic * Rewrite GetVNFuncForNode * Rewrite fgMorphTree & fgMorphSmpOpOptional * Rewrite fgMorphFieldToSimdGetElement/fgMorphField * Rewrite fgMorphOneAsgBlockOp * Rewrite impInlineFetchArg * Rewrite impSIMDRelOp * Rewrite impSIMDIntrinsic * Rewrite impBaseIntrinsic XARCH * Rewrite impAvxOrAvx2Intrinsic XARCH * Rewrite impSpecialIntrinsic ARM64 * Fix SSA Builder comments * Delete GT_LIST * Support GTF_REVERSE_OPS for GenTreeMultiOp It turns out that in the time this change has been sitting there, 3 new methods in the SPMI benchmarks collection appeared, and it turns out they regress because of the lack of GTF_REVERSE_OPS. So, implement support for it.... This makes me quite sad, but it does make this change a pure zero-diff one, which is good. * Fix Linux x86 build break * Fix formatting * Improve readability through the use of a local * Support external operand arrays in GenTreeMultiOp * Fix formatting * Tweak a constructor call

…alling (dotnet#61539) * Update GetPinnableReference() usage in multi-step custom tyep marshalling Change GetPinnableReference() on a marshaller type to be used as a side effect when marshalling in all cases when a fixed() statement is usable. Use the Value property getter to get the value to pass to native in all cases. Update our marshallers and tests to follow this design update. * Apply suggestions from code review Co-authored-by: Aaron Robinson <[email protected]> * Don't emit the assingment to the Value property in the Unmarshal stage when using [Out] * Fix the unmarshalling conditions * Fix Utf16StringMarshaller to correctly handle the "null pointer" case now that we're using spans internally for storage in all cases. Co-authored-by: Aaron Robinson <[email protected]>

…posed corelib types. (dotnet#61802) Co-authored-by: Aaron Robinson <[email protected]>

We started doing devir in unoptimized builds. I assume that was an unintended consequence of dotnet#61453.

…et#61758) * Remove CLRTestExecutionArguments from OOMException01 Test entrypoint is parameterless and so it ignores the argument * The test entrypoint for 347011 is parameterless so the property is ignored * Remove project-driven command line arguments from the polyrec test The test just passes a pair of integers that are used as internal parameters for the test. Refactor the test so that the entrypoint accepts the parameters as arguments and call it once from Main the way we used to do based on the CLRTestExecutionArguments. Thanks Tomas

…#58227) Co-authored-by: Jeff Handley <[email protected]>

* Guard pool scavenging callback from parallel execution when it takes longer than the timer interval gets triggered * Dispose connection from the pool in a serate task to not to block the caller (scavenge timer callback) * feedback

…et#61907) The current name is causing confusion

dotnet#61805)

…otnet#61760)

When OSR is enabled, the jit may still need to switch to optimized codegen if there is something in the method that OSR cannot handle. Examples include: * localloc * loops in handlers * reverse pinvoke (currently bypasses Tiering so somewhat moot) * tail. prefixes (currently tolerated as Tiering should suffice) When OSR is enabled, rework the "switch to optimize logic" in the jit to check for these cases up front before we start importing code. When both QuickJitForLoops and OnStackReplacement are enabled, this should ensure that if we can't transition out of long-running Tier0 code (via OSR) then we will instead optimize the method. Very few methods overall should opt-out of Tier0. Note some of these unhandled constructs can eventually be handled by OSR, with additional work. For explicit tail calls: this should replicate the current logic where we always optimize methods with explicit tail calls unless we're instrumenting them. To make this work with OSR we simply won't put patchpoints in methods with explicit tail calls, instead trusting that tiering can get us to optimized versions.

Originally there was only one eventpipe test, and eventpipe_readevents was added in dotnet#37002. Both should be skipped for the same reason.

This reverts commit 8ad84e8.

* Fix type checks in fgValueNumberArrIndexAssign The code was trying to obtain the value of the location to store to from the updated map for the element. This is simply incorrect for all but the trivial case of an empty field sequence. * Do not explicitly pass type to VNForMapStore It must always be equal to the type of the map being updated, not having redundancy eliminates the possibility for mistakes.

Co-authored-by: Günther Foidl <[email protected]> Co-authored-by: Dan Moseley <[email protected]>

We don't need these tests (the Debug flag is only compiled into Debug builds and is there for diagnostic purposes), and it seems these have been taking too long sporadically. Closes dotnet#61794

We could overwrite the candidate VN relation kind with one from an earlier tree that did not necessarily end up as a candidate. Fix dotnet#61908

* Don't special case "Experimental" projects We only have one experimental project, System.Runtime.Experimental and we want it to behave like any other package. * Make coreclr packages use `IsShipping`

* Add a JsonWriterOptions.MaxDepth property * remove depth checks from the converter layer * Revert "remove depth checks from the converter layer" This reverts commit 0e43092.

* Adding support for the X86Base.Pause intrinsic on Mono * Re-enable the pause hwintrinsic test on Mono

Mark EndsWith and StartsWith as NoInlining

…o Regex "simplified" code gen (dotnet#61906) * Add a few tests for captures inside various constructs * Slightly optimize creation of multis that don't participate in case conversion * Add simple codegen support for backtracking Loops * Add simple codegen support for backreferences * Add simple codegen support for if-then-else backreference conditionals * Add simple codegen support for if-then-else expression conditionals * Flip default on MarkLabel emitting semicolon Labels need to be followed by something other than a closing brace. Previously I was trying to opt labels in to emitting a semi-colon, but it's too error prone. Instead, we now by default emit a semicolon, and only skip it from call sites that opt-out because it's obvious they'll always be followed by code. * Add simple codegen support for balancing groups * Address PR feedback

… Build ID 1482158 (dotnet#61858)

… stress (dotnet#61951) * Disable converting nop padding to breakpoints for arm64 under jit stress. Workaround for issue dotnet#61944. * disable differently * fix

…s, System.Drawing.Primitives, System.Management, System.Security.Cryptography.ProtectedData, System.Speech, System.Windows.Extensions (dotnet#61949)

Co-authored-by: Eric Erhardt <[email protected]>

…dotnet#61172) * added AsReadOnly extension methods for IDictionary and IList (not compiling) * added AsReadOnly methods to ref assembly * revert changes in MatchingRefApiCompatBaseline.txt * fixed spelling * added notnull constraint for TKey on AsReadOnly on IDictionary, fixed typo * Move ReadOnlyDictionary from System.ObjectModel to System.Private.CoreLib * Add TypeForwards * Added XML-Doc comments * added tests for null arguments to AsReadOnly extensions * added parameter names to null argument tests Co-authored-by: mrxx99 <[email protected]> Co-authored-by: Eirik Tsarpalis <[email protected]>

RFC4559 does not specify that the Proxy-Support header value used to determine if the proxy server will honour client server authentication integrity is case sensitive. Updating the check to be case insensitive to prevent failures when value is supplied using differences in case. Fix dotnet#61414

* xharness bump * more logging in unit test

…net#61746) * Replace occurrences of inlined throws with ThrowHelper calls * remove NoInlining from ThrowHelpers.Throw* methods * address feedback * remove NoInlining attribute from local throw method * Incorporate changes from dotnet#61608

…9520) * FileSystem.Unix: Directory.Delete: remove per item syscall. By recursing using FileSystemEnumerable we know the file type and can omit the stat calls made by DirectoryInfo.Exists. For the top level path, we can omit the call also and handle non-directories when rmdir errno is ENOTDIR. For the recursive case we can avoid recursion when the top level path rmdir succeeds immediately. FileSystemEntry is updated so IsSymbolicLink remembers the file is symbolic link and does not make a syscall for it.

…1950) Add tests for the scenario.

The tests were failing on iOS/tvOS device runs. dotnet#61920 was created to track them. Co-authored-by: Steve Pfister <[email protected]>

Implements dotnet#60266 Avoid deep recursion in `mono_ssa_rename_vars`, change the way we traverse dominated bb's. Instead of using recursion, use stack-like array to store information about stack history and the traversal. The performance remains the same (or is slightly better) than before. Times for the compilation of repro from dotnet#57141 (JIT time minimum from 5 runs): Before: LLVM output file: './Uno.UI.FluentTheme.dll.bc.tmp'. JIT time: 4810 ms, Generation time: 2040 ms, Assembly+Link time: 2 ms. After: LLVM output file: './Uno.UI.FluentTheme.dll.bc.tmp'. JIT time: 4781 ms, Generation time: 2017 ms, Assembly+Link time: 2 ms. * Fix assignment * Apply suggestions from code review Co-authored-by: imhameed <[email protected]> * Remove casts we don't need Co-authored-by: imhameed <[email protected]>

* removed argument requestId * removed requestId in LoopbackServer.cs * Update src/libraries/Common/tests/System/Net/Http/GenericLoopbackServer.cs Co-authored-by: Karel Zikmund <[email protected]> * commit after changes * removed requestId from LoopbackServer * removed requestId from Http2 and Http3 LoopbackConnection * removed requestId from HttpClientHandlerTest.Http2.cs * commit after modifying http2 test * created new function in http2 * Update src/libraries/Common/tests/System/Net/Http/Http2LoopbackConnection.cs Co-authored-by: Katya Sokolova <[email protected]> * Update src/libraries/Common/tests/System/Net/Http/Http2LoopbackConnection.cs Co-authored-by: Karel Zikmund <[email protected]> * Update src/libraries/Common/tests/System/Net/Http/Http2LoopbackConnection.cs Co-authored-by: Karel Zikmund <[email protected]> * Update src/libraries/Common/tests/System/Net/Http/Http2LoopbackConnection.cs Co-authored-by: Karel Zikmund <[email protected]> * removed async keyword Co-authored-by: Karel Zikmund <[email protected]> Co-authored-by: Katya Sokolova <[email protected]>

dotnet#61930) - Otherwise timer callbacks may not run when worker threads are continually starved - Fix for dotnet#61804 in main

The method's only caller is InferOpSizeAlign. That is in turn only used in LCL_FLD stress, which only looks at locals with non-struct types. And "fgInitArgInfo", which only allows 3 nodes with TYP_STRUCT: OBJ, LCL_VAR and MKREFANY. Thus, this code is dead. Not surprising, considering it was looking for the old GT_COPYBLK representation.

…optimization, and add newer platforms. (dotnet#61989) We haven't supported Classic mode for Xamarin for quite a few years now (monotouch, MonoMac), so that code is not needed anymore. However, we've added support for more platforms (tvOS, Mac Catalyst), so add support for those.

- Update chrome+chromedriver for helix tests to latest stable (`96.0.4664.45`) - Enable library tests to run on Windows, for manual runs - Disable windows/AOT builds completely due to dotnet#61721 - Disable failing WBT tests on windows due to dotnet#61725 - Disable JS interop tests failing with new chrome - dotnet#61945 Co-authored-by: Radek Doulik <[email protected]>

Including the version with a `GenTreeLclVarCommon*` overload. I mostly replaced `&lvaTable[varNum]` and `lvaTable + varNum` expressions, leaving `lvaTable[varNum].xxx`. Made many resulting `varDsc*` const. Removed unused `lvaRefCount`. Simplifies code, and centralizes assert checking. Added new `lvaGetLclNum(LclVarDsc*)` function to map back to a varNum. This deletes many `noway_assert` in favor of the lvaGetDesc `assert`; I'm not worried about removing asserts from the Release build.

…net#62001) I hit this problem locally when working on the test merging - I made a change in Jeremy's Roslyn generator logic adding a hard FailFast and the tests continued building normally even when specifying the rebuild option because the XUnitWrapperGenerator project remained in the intermediate test folder and didn't get actually rebuilt. Thanks Tomas

…agnostics.Process (dotnet#61871)

This fixes three asserts that were started occurring in the native Android cryptographic primitives. - One shot hashing now tolerates empty/null input. - Hashing and HMAC will now no-op if the append is empty. - RSA encryption now tolerates empty/null input.

* Add RequiresDynamicCodeAttribute to runtime * Delete nullable enable * Add test file to compilation for RequiresDynamicCode and RequiresAssemblyFiles * Fix RequiresAssemblyFiles tests

) Validate the debug mappings generated by the JIT using the MethodILToNative event. Unfortunately we can not use EventListener as the event there does not contain the actual mappings (dotnet#12678) so this reuses some of the facilities from the tracing tests to use EventPipe and TraceEvent. This only adds the infrastructure and a small number of tests, but at least this should make it easier to add more tests in this area in the future. There are some more limitations, for example we cannot validate the CALL_INSTRUCTION mappings generated for the managed return value feature because the debugger filters them out of the table reported. I am hoping we can change these mappings to be included as normal in the future. The tests themselves are added by adding a method to tests.il with an ExpectedILMappings attribute that allows specifying a subset of IL offsets that we expect mappings to be generated for, with separate subsets under Debug and when optimizing. This was the best way I could think of to be able to refer to the right IL offsets.

* 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. * Tests for nested static classes. * Fix for nested static classes. * Fixed 9 tests from EvaluateOnCallFrame. * 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. * Revert merged nested evaluation changes. * Incorporate Ankit's changes from d020d36. * Fix - when both valuesare null we should keep checking (e.g. for nested static classes). * Added nested tests. * Redo changes after reverting them in merge. * Fixed - works with and without namespace. * Fix merge. * 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. * Extracting the check from the loop. One time check is enough. * Simplifying multiple test cases into one call. * Added test that was skipped by mistake. * Test for classes evaluated from different frames. * Tests for nested static classes. * Fix for nested static classes. * Fixing indentation and spaces. * Applied review comments for values evaluation. * Compressed two tests into one with MemberData. * Addressed Ankit advices from the review. * Revert merged nested evaluation changes. * Incorporate Ankit's changes from d020d36. * Fix - when both valuesare null we should keep checking (e.g. for nested static classes). * Fix merge. * Cleanup after rebase. * Added nested tests. * Fixed - works with and without namespace. * Clean-up after rebasing with fix-static-attribute-support. * Fixed 9 tests from EvaluateOnCallFrame. * Fixed 18 test types. * Fix test cases with spaces in the names, e.g. " this" evaluation. * Update src/mono/wasm/debugger/BrowserDebugProxy/MemberReferenceResolver.cs Co-authored-by: Larry Ewing <[email protected]> * Avoid resolving fields of a null value. * Fix for 4 failing tests of Count evaluation. * Update src/mono/wasm/debugger/BrowserDebugProxy/MemberReferenceResolver.cs Co-authored-by: Ankit Jain <[email protected]> * Update src/mono/wasm/debugger/BrowserDebugProxy/MemberReferenceResolver.cs Co-authored-by: Ankit Jain <[email protected]> * Add null safety. * Exchanged multiple trims for one. * Undo nested static changes that will be sumbitted in another PR. * Revert "Undo nested static changes that will be sumbitted in another PR." This reverts commit 6a1b7ad. * Hiding test that has to be fixed in the future. * Applying Ankit's suggestion about code simplification. Co-authored-by: DESKTOP-GEPIA6N\Thays <[email protected]> Co-authored-by: Larry Ewing <[email protected]> Co-authored-by: Ankit Jain <[email protected]>

* Enable nullable in project file. * Annotate SoundPlayer * Annotate remaining types * Update ref source * Events should be nullable * Fix assertion for NRE * Update nullability of SoundLocation. * Adjust nullability of SoundLocation and Stream. * Title and message should be nullable * Fix new NRT issue

Co-authored-by: JochemH <[email protected]>

* Unify ARRAY_SIZE/STRING_LENGTH-like macros * Cleanup trailing whitespaces in changeset files * Use ArrLen in the JIT * Keep using G_N_ELEMENTS in mono * Resolve name conflict in test

…#61985) managed valuetypes. This is an issue with field marshallers of nested non-blittable types.

…et#61973) * Splitting the hardware intrinsics into more test groupings * Don't split the hardware intrinsics into a separate XUnitWrapperGrouping

…dotnet#61388) Co-authored-by: Jose Perez Rodriguez <[email protected]>

)

…tem.IO.FileSystem.Watcher, System.IO.Pipes (dotnet#61996)

* Reorganize libs.native * Fix darwin build * Fix wasm-win32 build * Fix pipelines path evaluation

* New globalThis.getDotnetRuntime method, which takes runtimeId, essentially index of the runtime on the page. It returns the DotNetPublicAPI object of the instance {MONO, BINDING, Module, RuntimeId, RuntimeBuildInfo }. * Change the debugger to use the getDotnetRuntime() function when talking to the runtime on the page via CDP. * Use getDotnetRuntime() in unit tests, with runtimeId is zero as there is only one runtime in tests. * We add optional &runtimeId=0 to the initial URL which opens DebuggerProxy, so that MonoProxy could be created for specific runtime on the page. * Moved mono_wasm_add_dbg_command_received, mono_wasm_debugger_log and mono_wasm_trace_logger out of C macro into typescript * Introduced RuntimeBuildInfo: { ProductVersion, Configuration } into DotNetPublicAPI

* [interp] Improve logging on mobile devices Use a single g_print in bulk for every instruction. Otherwise, the instruction ends up being displayed on multiple lines. * [interp] Remove hack for nint/nfloat These structures are valuetypes, but their mint_type is a primitive. This means that a LDFLD applied on the type would have attempted to do a pointer dereference, because it saw that the current top of stack is not STACK_TYPE_VT. This was fixed in the past by passing the managed pointer to the valuetype rather than the valuetype itself, against the normal call convention, which lead to inconsistencies in the code. This commit removes that hack and fixes the problem by ignoring LDFLD applied to nint/nfloat valuetypes in the first place.

…net#62039)

…ls on SUBST'd drive (dotnet#59850) * Re-enable test that verifies DriveInfo.VolumeLabel setter fails on SUBST'd drive

Co-authored-by: Tratcher <[email protected]> Co-authored-by: James Newton-King <[email protected]>

* Add test for ignoring stepping into hidden function. * Corrected test to match Console App behaviour. * Corrected test logic. * Applied Thays's fix so that step into would work as step over in a hidden method. * Revert debugging changes. * Test for Debugger.Break(). * Col fix + checing the location after command execution. * Correct value of VisibleMethod entry line. * Move the breakpoint to the line 846. * Create tests that match behaviour of Console App. * Draft of Debugger.Break behaviour correction. * Draft: 2 pauses on hidden method with Debugger.Break inside. * Changed required behaviour to 2 pauses on the hidden method call.

Fix dotnet#62031

…net#62023) This fixes a new warning generated by trimming some apps which was introduced in dotnet#54056. The `ComVisibleAttribute` in this case is referenced, but if it's removed it doesn't change functionality in any way.

* Avoid switching GC mode in COM's HasValidTarget Co-authored-by: Jan Kotas <[email protected]>

Co-authored-by: JamesNK <[email protected]>

in high memory load situations, when we had to wait for a BGC to finish, we switched to preemptive mode which means GCs could have occurred and replenished the budget. but when we come back from the wait, we use the previous decision on whether the budget was exceeded or not. this causes us to trigger GC incorrect and you would see GCs triggered when the allocated bytes are tiny.

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com> Co-authored-by: Premek Vysoky <[email protected]> Co-authored-by: Alexander Köplinger <[email protected]>

* Fix miscellaneous typos * Cleanup trailing whitespaces ```sh # git remote add dotnet https://github.com/dotnet/runtime && git pull --rebase dotnet main if uname 2>/devnull | grep -q Darwin; then space=" " fi git show --name-only --pretty="" HEAD...dotnet/main |\ xargs -I{} sh -c "test -f {} && sed -i$space'' 's/[[:space:]]*$//' {}" ```

…62003) * mono_runtime_delegate_invoke wrapper with MONO_ENTER_GC_UNSAFE/MONO_EXIT_GC_UNSAFE; mono_runtime_delegate_invoke wrapper with MONO_ENTER_GC_UNSAFE/MONO_EXIT_GC_UNSAFE; * Update object.c

The CSE logic maintains a custom hashtable implementation. It triggers a resize at the same time as adding a new CSE, but forgets the hash of the new CSE needs to be updated from its pre-resize value. Failing to do so can lead to losing some CSEs, though not in a correctness-impacting way.

Otherwise we can end up not seeing the loop has memory havoc. Also added an assert that will prevent this issue from arising in the future.

…et#60054) * CI matrix change: add Windows.Server.Core.20H2 (dotnet#59572) * Add Windows.Server.Core.20H2 to CI matrix * add windows server 20H2 * Remove 20H2 from PR * Remove 20H2 from PR run * change helix queue for Windows.Server.Core.20H2

* Remove active issue. * Use --web-server-use-cop.

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

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

upstream main merge 2021 11 29 #5

upstream main merge 2021 11 29 #5

Commits on Nov 10, 2021

Commits on Nov 11, 2021

Commits on Nov 12, 2021

Commits on Nov 13, 2021

Commits on Nov 14, 2021

Commits on Nov 15, 2021

Commits on Nov 16, 2021

Commits on Nov 17, 2021

Commits on Nov 18, 2021

Commits on Nov 19, 2021

Commits on Nov 20, 2021

Commits on Nov 22, 2021

Commits on Nov 23, 2021

Commits on Nov 24, 2021

Commits on Nov 25, 2021

Commits on Nov 26, 2021

Commits on Nov 27, 2021

Commits on Nov 29, 2021