* [runtime] Treat calling a non-virtual method through an open delegate the same as the normal case instead of the OPEN_VIRTUAL case.
* [amd64] Fix the return value mapping in gsharedvt calls, the return address might be in different registers in the caller and callee.
* [runtime] Always initialize del->method_ptr even if interp_method is set, JITted code makes calls through it in mixed mode.
* Add a test for open delegates and gsharedvt.
* Increase nrgctx trampoline count, its needed by dynamic-method-churn.exe in full-aot-interp mode.
* Initial commit to migrate libgc to bdwgc.
* Fix submodule url
* Don't force Boehm as runtime wrapper. Was just for testing locally.
* Build bdwgc as single object file. Helps with performance.
* Bump bdwgc submodule.
* Attempt to fix windows MSVC based build.
* Remove any references to GC_INSIDE_DLL as we manually managed threads on Windows.
* Allow building boehm on Windows amd64.
* Allow building boehm with msvc.
* Bump bdwgc to fix line endings
* Use LF for sh, am, m4, and ac files in bdwgc
* Bump bdwgc & libatomic_ops with fix for cygwin
* Bump bdwgc to fix mono-boehm being generated as libtool wrapper script.
* Link the static boehm library.
* Revert "Link the static boehm library."
This reverts commit 1f90d81d08308a61c890743cd79d8f6bb791bc99.
* Use --export-all-symbols on cygwin/mingw to fix issues with boehm causing mono symbols not to be exported.
* Fix
* [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.
[interp] fix array_element_size intrinsic
`mono_class_array_element_size` gives us the size of the provided MonoClass if it would be an array element. But here we want the element size of a given array's MonoClass. That's what `mono_array_element_size` is returning.
This leads to all kind of weird crashes otherwise, specifically here:
https://github.com/mono/mono/blob/2c20649539ac16e069a65f2a750c793eb341e50f/netcore/System.Private.CoreLib/src/System/Array.Mono.cs#L64
Which is then used later to compute the size to memset in order to clear the content of an array. If it's larger than it should be, then this will cause memory corruption. For example this would crash eventually:
```csharp
using System;
using System.Collections.Generic;
namespace HelloWorld {
class Program {
static void Main(string[] args) {
for (int j = 0; j < 0x1000; j++) {
var d = new Dictionary<string, string> ();
for (int i = 0; i < 197; i++)
d.Add (i + "", i + "foo");
d.Clear ();
}
}
}
}
```
Thanks to @EgorBo for reporting.
`remove_gc_finalizing` wasn't initialized so its value is undefined.
The `count_thread_check_gc_finalizer()` function only sets it in some cases so we could end up with the variable having an undefined (and probably not 0) value.
This resulted in the returned thread count from the debuggee being wrong because we'd decrement `count` even though we shouldn't.
Regression from https://github.com/mono/mono/pull/15618
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]>
* Forced filesystem creation
* [Wasm] Added new hello-io sample
- Goal is testing file preloading through System.IO
- Filesystem is now always forced to support later file preloading
- build-io-sample target showcases such
* Added --enable-fs flag to packager.exe
* Update packager.md
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]>
* When we try to call a method to get the async_id to do an async debug and we are trying to do this in a generic method like this:
async Task<T> ExecuteAsync_Broken<T>()
{
await Task.Delay(2);
return default;
}
We need to inflate the generic type before call the method or we will get the error: Could not execute the method because the containing type 'System.Runtime.CompilerServices.AsyncTaskMethodBuilder1[T_REF]’, is not fully instantiated.
Fixes#17549Fixes#17569
* [llvm] Use explicit null checks with LLVM.
When the LLVM backend is used for a method, explicit null checks will
unconditionally be used at the mini IR level. We had previously used
implicit null checks at the mini IR level combined with llvm-volatile
loads and stores to avoid mis-optimization of the generated code.
During AOT compilation, LLVM's `ImplicitNullChecks` pass is enabled.
This conservatively elides these explicit null checks. This pass only
modifies branches tagged with `make.implicit` metadata.
Null check branches are now tagged with `make.implicit` metadata, with
three exceptions:
1. For platforms with backends that do not support zero page fault
handling, null check branches are not tagged with `make.implicit`.
2. This commit also adds a `MONO_DEBUG` option:
`llvm-disable-implicit-null-checks`. When it is enabled, null check
branches are not tagged with `make.implicit`.
3. This commit alters the behavior of the `explicit-null-checks`
`MONO_DEBUG` option. Enabling `explicit-null-checks` also implies
`llvm-disable-implicit-null-checks`, because this option is documented
(e.g. in https://www.mono-project.com/docs/debug+profile/debug/) to
completely disable signal/seh-based null checks.
* Add llvm-disable-implicit-null-checks to the MONO_DEBUG help string.
* Add llvm-disable-implicit-null-checks to mono.1.
* Don't tag null checks in EH regions with `make.implicit`.
This relocates the logic formerly used to guard individual LLVM-level
loads and stores with explicit null checks inside EH regions.
* Use atomic/volatile loads and stores for the terimation flag in thread-suspend-suspended.
LLVM was hoisting the load of and branch against `finished` out of
thread t1's loop, resulting in an infinite spin.
* Use ImplicitNullChecks with LLVM JIT.
* Suppress emission of the .llvm_faultmaps section.
Bump external/llvm to release_60
(7a8dc89adbe7e123220e070a527e096ee91e66d5).
* [ci] use LLVM built from repository
* [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