* [runtime] NOHANDLES for ves_icall_System_Threading_Thread_GetCurrentThread
This function (and its call to mono_handle_new) was showing up in the
flamegraph for some async-heavy benchmarks
CoreCLR has a managed cache surrounding this, but for the moment the naive implementation will suffice. We can later move their managed cache to shared on top of this PR with minimal trouble.
We can't guarantee the id will be [0..CpuCount) for a variety of reasons, and a followup PR to the dotnet docs will clarify this. I've chosen not to intentionally add an offset, but no one should be relying on that behavior, and if someone thinks adding an offset would drive the point home the perf cost is irrelevant.
* Set thread pool thread name just based on string pointer check.
When the generation-based solution went in, there were not
yet constant thread names, so a pointer based approach could fail
due to reuse. We can do slightly simpler now.
* Remove the generation field which is no longer needed.
Remove the duplicated knowledge of how to set a constant and put
it behind a funny sounding but perhaps reasonable flag.
Revise corlib version.
* [System.Private.CoreLib] Cleanup intrinsic tracking
1. Removed icalls where intrinsic version for the method exists
2. Add [Intrinsic] attribute to methods which have runtime intrinsic
to make them easier to track and to tell linker not to analyze them
3. Use recursive syntax for any intrinsic which can be called via
reflection to correctly apply the intrinsic when invoked.
```c#
public static bool IsSupported { get => IsSupported; }
```
When one calls X86.IsSupported, the call gets replaced by an
intrinsics. When one calls it with an Invoke, the body of IsSupported
gets replaced by intrinsics. It's just a hack to get Invoke support for free.
* [interp] implement System.Type::op_Equality
* Undo changes which are not yet supported by interpreter
* [interp] Implement System.Runtime.CompilerServices.RuntimeHelpers::OffsetToStringData
Co-authored-by: Bernhard Urban-Forster <[email protected]>
* [wasm] Compile corelib as 32 bit.
* [wasm] Add a netcore cross compiler.
* [wasm] Add netcore+aot support.
* [aot] Load the dedup module lazily instead of at startup.
The previous version didn't work on netcore because it couldn't resolve references to corlib etc.
since they were not yet registered in the root domain at the time of loading.
* Add more icall trampoline signatures.
* Add more netcore pinvokes.
* Fix the build.
* Add more icall trampoline signatures.
* Add an --embed-file option to the packager.
* Add more netcore pinvokes.
* [interp] Return FALSE for IsDynamicCodeCompiled.
* Add a netcore project and targets for running BenchmarkDotNet.
* Fix pinvoke tables.
* Add missing files.
* Fix make clean.
* Add a comment.
* Revert "Fix pinvoke tables."
This reverts commit 998065e77614b7e621d2873510aabc3930669ca9.
* Make xunit-runner into a dotnet project. Add a netcore version.
It looks like the mirror didn't fully quiesce prior to snapping coreclr/corefx for the runtime consolidation. As a result the libraries build is breaking.
Signed-off-by: dotnet-bot <[email protected]>
Fix NetStandard issue in System.IO.FileSystem.AccessControl
We built the fix incorrectly so that it would only apply for netcoreapp3.0 but customer needs it on netstandard2.0 (desktop + core). Customer impact is that they’ll see a PlatformNotSupported exception rather than the new API.
Signed-off-by: dotnet-bot <[email protected]>
* Updating Vector128.AsVector3 to have a functioning implementation
* Adding test template metadata covering the new methods for converting between S.Numerics and S.R.Intrinsics
* Regenerating the existing tests
* Generating the new Vector conversion tests
Signed-off-by: dotnet-bot <[email protected]>
* Add span-based CopyTo and CopyToAsync methods
* Update according to feedback
* Add span-based CopyTo overrides for MemoryStream
* Improve span-based CopyTo arguments validation
To avoid code duplication
* Update according to second review
Stream API is changed
* Resolve InternalReadSpan/Memory inlining
* Refactor ValidateCopyToArgs
* Update according to third review
* Update after fourth review
* Override span CopyTo for UnmanagedMemoryStream
* Apply suggestions from code review
Co-Authored-By: Stephen Toub <[email protected]>
* Update after fifth review
* Add cross sync/async support for span-based CopyTo
* Call sync action directly in async context
* Rework cross sync/async support for span-based CopyTo
Co-Authored-By: Stephen Toub <[email protected]>
Signed-off-by: dotnet-bot <[email protected]>
* Method Add(ref BigInteger lhs, uint value, ref BigInteger result) would store most of the result blocks into lhs instead of result.
* Method ShiftLeft(ulong input, uint shift, ref BigInteger output) with a shift argument exceeding 32 would generally compute the higher blocks incorrectly.
* Multiply(ref BigInteger lhs, uint value, ref BigInteger result) would not set result._length in some cases.
* IsZero() would incorrectly return false for non-canonical zeros with _length > 0.
Fix:
* Inline Add(ref BigInteger, uint, ref BigInteger) into Add(uint).
* Inline ShiftLeft(ulong, uint, ref BigInteger) into Pow2.
* Inline ExtendBlock and ExtendBlocks into Pow2.
* Properly handle 0 in SetUInt32 and SetUInt64.
Signed-off-by: dotnet-bot <[email protected]>
FileStream has two modes, decided upon at construction time. When it's created in non-async mode, the Read/WriteAsync methods end up queueing work items to invoke the synchronous Read/Write methods. To do this, the base methods on Stream delegate to Begin/EndRead/Write (since they were around first) and then the resulting IAsyncResult is wrapped. However, Stream has an optimization that checks to see whether the derived stream actually overrides Begin/EndXx, and if it doesn't, then it skips using those and goes straight to queueing a work item to Read/Write. However, FileStream does override those, but when it delegates to the base implementation because it's in non-async mode (rather than because it's a type derived from FileStream), going through Begin/EndXx is just unnecessary overhead. So, in the right circumstances, we can call to Stream's special helper instead.
Signed-off-by: dotnet-bot <[email protected]>
* [wasm] Change netcore support to use a prebuilt corefx runtime.
* [wasm] Build and test netcore support on CI.
* [wasm] Disable netcore tests on CI for now.
* [wasm] Add an error check.
* [wasm] Add a linker exclusion.
* [wasm] Add netcore runtimes to the nupkg.
* Rewrite the rest of the array non-generic fast paths in C# (#27703)
* Rewrite the rest of the array non-generic fast paths in C#
* Add missing resource string
* Use CorElementType and handle native ints to match the unmanaged implementation
* Avoid try pattern for Sort and Reverse
* Match the native implementation more closely
Signed-off-by: dotnet-bot <[email protected]>
* Rewrite Enum.CompareTo in C# (dotnet/coreclr#27792)
* Rewrite Enum.CompareTo in C#
* Handle floating point too for match the existing native implementation
Signed-off-by: dotnet-bot <[email protected]>
* Remove unused argument from GetRegionDisplayName (dotnet/coreclr#27806)
* Remove unused argument from GetRegionDisplayName
* Address race conditions in CultureData
While most of the race conditions in this file are benign, in these cases, a thread could end up returning an intermediate value due to multiple potential writes to the same field.
Signed-off-by: dotnet-bot <[email protected]>
* Fix StyleCop rule SA1129 ("Do not use default value type constructor") (#27716)
Will enable the rule in corefx once these changes have propagated.
Signed-off-by: dotnet-bot <[email protected]>
* Remove non-shared Enum.CompareTo/InternalCompareTo implementation, add new Array icalls used by shared code
It tried to use dynamic codegen which is not available in FullAOT.
We can use the `RuntimeFeature.IsDynamicCodeSupported` to check for this, added a JIT intrinsic which returns false in FullAOT.
Used a linker friendly way to check for TypeBuilder by adding an `internal virtual IsTypeBuilder` method in the `Type` class which returns false, and overwrote it in `TypeBuilder`.
* Add EventWaitHandle creation extension method that takes an ACL (#42213)
* Add EventWaitHandle creation extension method that takes an ACL
* Call OpenExisting, add basic unit tests, move MAX_PATH in csproj for all Windows platforms, ensure same exceptions are thrown in both netcore and netfx.
* Address suggestions: using for the created handle, simplify try finally, merge methods, remove an unnecessary Debug.Assert
* simplify using, reorganize PInvokes a bit, let VS format resx as it expects it, remove BOM from csproj
* Add more unit tests
* Save basic access rights in a constant, generate name randomly
* Use FullControl (EVENT_ALL_ACCESS); update unit tests to use EventWaitHandleRights
* Apply suggestion of creating an EWH, then replacing its SWH.
* Remove using causing chaos, add more unit tests, remove null string unit test.
* spacing
* Address comments
* Remove unnecessary checks/exceptions, update unit tests
* Fix netfx x86 ut failure - different exception for mode validation.
* Small documentation fix
* Remove documentation for exception thrown with null security
* more documentation fixes
* New file for unit tests
* Dispose and remove windows only attributes in tests
* suggestion to not use var
* Remove duplicate resx after merge
* Readd cs files lost during merge
* Remove resx modification since it was untouched for this PR
* Address test comments
Signed-off-by: dotnet-bot <[email protected]>
* Move NativeLibrary.Free null check to managed (dotnet/coreclr#27744)
Signed-off-by: dotnet-bot <[email protected]>
* Arm64: Add S.P.CoreLib instrinsics UnzipEven and UnzipOdd (#27731)
Signed-off-by: dotnet-bot <[email protected]>
Approved API Proposal: #41662
Description
We don't currently have a way to create a Semaphore with a given ACL in .NET Core. We can modify the ACL, but it would be more secure to have the proper ACL on the object from the start.
Customer impact
Before this change, customers had to create a Semaphore, then set its ACLs. This presents a few problems:
- Potential security hole as semaphores can be accessed between creation and modification.
- Porting difficulties as there isn't a 1-1 API replacement
This change addresses those problems by adding a new extension method that allows creating a Semaphore and ensuring the provided ACLs are set during creation.
Signed-off-by: dotnet-bot <[email protected]>