| Age | Commit message (Collapse) | Author |
|---|
|
configs (#74636)
It was only disabled on interpreter.
Closes https://github.com/dotnet/runtime/issues/74049
Co-authored-by: Alexander Köplinger <alex.koeplinger@outlook.com>
|
|
applying DIM overrides (#74519)
* do we need to inflate here? it seems like we always get the right class
* use member access, not type punning
* Add regression test for #70190
* Assert code from #64102 is unreachable
In https://github.com/dotnet/runtime/pull/64102#discussion_r790019545
we concluded that this branch is never taken.
* Assert that overrides are already inflated how we expect
* try to enable some disabled DIM tests
* remove unused var
* Don't assert - code is reachable, there's just nothing to do
* Add link to issue for failing tests
Co-authored-by: Aleksey Kliger <alklig@microsoft.com>
Co-authored-by: Aleksey Kliger <aleksey@lambdageek.org>
|
|
* Disable tests failing on Android
* Disable test failing on iOS and MacCatalyst
* Disable failing System.Formats.Tar tests on Android
* Fix JIT.Directed aliasing_retbuf test exclusion on Android
* Disable failing TraceSource tests on tvOS
* Remove unnecessary formatting changes
* Fix skipping failing tests on Android
* Skip tests failing on tvOS
* Revert "Disable failing System.Formats.Tar tests on Android"
This reverts commit bfc295833e825ad9a7269b458ef0455c76bd72ae.
* Link to specific issues
Co-authored-by: Simon Rozsival <simon@rozsival.com>
|
|
field layout behavior (#74279)
* First stab at support for proper 128bit integer layout and abi
* Add ABI tests for Int128 covering interesting scenarios
* Fix bugs so that at least Windows Arm64 works
* Add more types to the ABI tester, so that we cover the Int128 scenarios
* Revert changes which attempted to enable by value passing for Int128
* Make Int128 have layout match the expected unmanaged field layout - On Unix platforms (64 bit) use 16 byte alignment - On Arm32 use 8 byte alignment matching the 128 byte vector type - On other Windows platforms the 128 bit integer type isn't defined by the C compiler, but match the behavior of other 128 bit types (16 byte alignment)
Add tests to call down to native that should pass with these rules
- Disable use of Int128 as p/invoke parameter passed by value
* Mark Int128 types as not having a stable abi - This disables use of these types for parameter passing in R2R images
* Address all known issues
* Try to fix PR job
* Should fix the test issues
* Apply suggestions from code review
Co-authored-by: Jeremy Koritzinsky <jkoritzinsky@gmail.com>
Co-authored-by: David Wrighton <davidwr@microsoft.com>
Co-authored-by: Jeremy Koritzinsky <jkoritzinsky@gmail.com>
|
|
correctly (#74091)
* New test
* Fix auto layout algorithm to compute structure alignment correctly - In particular: 1. The alignment requirement imposed by of a non-primitive, non-enum valuetype field is the alignment of that field 2. The alignment requirement imposed by a primitive is the pointer size of the target platform, unless running on Arm32, in which case if the primitive or enum is 8 bytes in size, the alignment requirement is 8.
- The previous implementation produced an alignment of pointer size, unless running on Arm32 and one of the fields had an alignment requirement of 8 (in which case the alignment requirement computed for the structure would be 8)
In addition, add a test which verifies that the instance field layout test types are actually producing R2R compatible results at runtime.
- This test shows that we have some issues around explicit layout, so I was forced to disable that portion of the test for now.
Fixes #65281
* Re-enable disabled test
* Remove file that shouldn't be added as part of the new test
* Make a few test types public to silence unassigned field errors
* Update comments and add more testing
Co-authored-by: David Wrighton <davidwr@microsoft.com>
Co-authored-by: Tomas Rylek <trylek@microsoft.com>
|
|
|
|
This reverts commit 9865cc7a89a4a613a47986b8268a10bc37adbd65.
We believe the problematic change has been reverted so the test can be re-enabled.
|
|
so that accessing the result address throws exception.
Fixes https://github.com/dotnet/runtime/issues/54359
|
|
* Enable test only when LLVM is enabled
* Add back SIMD intrinsics support for X86Base.Pause
* Disable test for llvm
|
|
not match native runtime (#73406)
- We didn't check to make sure that the type of the Vector<T> was a primitive numeric as the runtime does
- Re-enable test
Fixes #60036
|
|
|
|
Re: https://github.com/dotnet/runtime/issues/69832.
|
|
* Disambiguate calli thunks based on full calling conventions
Fixes dotnet/runtimelab#153
* Add smoke test
Co-authored-by: Michal Strehovský <MichalStrehovsky@users.noreply.github.com>
|
|
As Andy Ayers suggested in the issue #72822 and I confirmed,
Crossgen2 signature emitter was missing the code path for
emitting function pointer signatures. This change fixes this
deficiency. The change also removes the issues.targets exclusion
of the affected test that Andy originally merged in to mitigate
the issue.
Thanks
Tomas
|
|
Native calling conventions disallow the return buffer from aliasing
anything else. The managed ABI allows this so we need to handle
unmanaged calls specially.
Fix #72270
|
|
Fixes https://github.com/dotnet/runtime/issues/54382
|
|
Fixes https://github.com/dotnet/runtime/issues/72827.
|
|
Co-authored-by: Jan Kotas <jkotas@microsoft.com>
|
|
Closes #72845.
|
|
|
|
|
|
See #72822.
|
|
Teach VN to fold some comparisons involving calls to `TypeHandleToRuntimeType`.
Closes #71909.
|
|
|
|
We were only supporting default interface methods in the sense of non-abstract virtuals. We now also support overrides.
What's missing is support for diamond/reabstraction. I thin we need to make throwing stubs that we can dispatch to - it doesn't look like the strategy used in the VM (`callsiteCalloutHelper`) can be used for prejit. I don't want to increase the scope of this pull request, so we invalidate the entire method that has such dispatch.
|
|
* Do not assume calling conventions match
When importing GT_RETURN.
* Add a test
* Disable the test on Mono
|
|
(#72517)
* Fix infrequent infinite loop on Mono EventPipe streaming thread.
As observed by https://github.com/dotnet/runtime/issues/59296, EventPipe
streaming thread could infrequently cause an infinite loop on Mono
when cleaning up stack hash map, ep_rt_stack_hash_remove_all called
from ep_file_write_sequence_point, flushing buffer memory into file stream.
Issue only occurred on Release builds and so far, only observed on OSX,
and reproduced in 1 of around 100 runs of the test suite.
After debugging the assembler when hitting the hang, it turns out that
one item in the hash map has a hash key, that doesn't correspond
to its hash bucket, this scenario should not be possible
since items get placed into buckets based on hash key value that
doesn't change for the lifetime of the item. This indicates that
there is some sort of corruption happening to the key, after it
has been added to the hash map.
After some more instrumentation it turns out that insert into the
hash map infrequently triggers a replace, but Mono hash table used in
EventPipe is setup to insert without replace, meaning it will keep old
key but switch and free old value. Stack has map uses same memory
for its key and value, so freeing the old value will also free the key,
but since old key is kept, it will point into freed memory and future
reuse of that memory region will cause corruption of the hash table key.
This scenario should not be possible since EventPipe code will only add
to the hash map, if the item is not already in the hash map. After some
further investigation it turns out that the call to ep_rt_stack_hash_lookup
reports false, while call to ep_rt_stack_hash_add for the same key
will hit replace scenario in g_hash_table_insert_replace.
g_hash_table_insert_replace finds item in the hash map, using callbacks for
hash and equal of hash keys. It turns out that the equal callback is defined to return
gboolean, while the callback implementation used in EventPipe is defined to return
bool. gboolean is typed as int32_t on Mono and this is the root cause of the complete issue.
On optimized OSX build (potential on other platforms) the callback will do a memcmp
(updating full eax register) and when returning from callback, callback will only update
first byte of eax register to 0/1, keeping upper bits, so if memcmp returns negative value
or a positive value bigger than first byte, eax will contains garbage in byte 2, 3 and 4,
but since Mono's g_hash_table_insert_replace expects gboolean, it will
look at complete eax content meaning if any of the bits in byte 2, 3 or 4 are still set,
condition will still be true, even if byte 1 is 0, representing false, incorrectly trigger the
replace logic, freeing the old value and key opening up for future corruption of the key,
now reference freed memory.
Fix is to make sure the callback signatures used with hash map callbacks,
match expected signatures of underlying container implementation.
Fix also adds a checked build assert into hash map’s add implementation
on Mono validating that the added key is not already contained in the hash map
enforcing callers to check for existence before calling add on hash map.
|
|
* [mono] ThisCall with no arguments is invalid
* Disable test on llvmfullaot
|
|
Re-enable the test that was disabled against https://github.com/dotnet/runtime/issues/64419. It looks like one of the many layout fixes this release already fixed this test locally.
Fixes #64419
|
|
(#71882)
Fix #71874
|
|
|
|
|
|
* Removing UnmanagedCallersOnly_MonoAot due to duplication
* Reverting removal of UnmanagedCallersOnly_MonoAotTest
* Renaming the test to *Basic and reusing the native component
* Moving basic tests from the general test project into the basic one
* Utilizing source generator for test methods
|
|
* Regression test for GitHub issue #71319
* Fix runtime assertion failure due to wrong GC mode
* Disable the new regression test on Mono with issue #71910
|
|
Native varargs is not supported on win-arm32: #12979
|
|
This change only affects Windows/arm64 with varargs.
For incoming structs split between register and stack, handle the splitting
correctly.
Fixes #57606
|
|
native int index (#71571)
Add support for native int indices in stelem.ref and ldelema helper functions. This required changing the abi of these functions, which required bumping the major R2R version number. As we have already done that for .NET 7, this is a minor cost. Note that this is still broken on Mono, and that bug is #71656
Fixes #52817
|
|
(#69906)
* Support long pdata unwinding and save_next for floating point regs in ARM64
* Fix typo
* Restore FP pairs when unwinding in ARM64 (#69359)
* Add regression test
* Restore FP pairs when unwinding in ARM64
* Exclude UnwindFpBleedTest from win-arm64
|
|
* Spill split args on non-ARM targets
* Add a test
* Work around vectors in varargs being broken
|
|
* Remove enum_flag_Unrestored usage in boxing stubs.
* Add AND instruction (21h) to x86 decoder.
* Update mono for null ref in interpreter paths.
* Disable test on llvmfullaot and wasm
* Handle null destination for intrinsics.
|
|
|
|
|
|
|
|
* Re-enable the pause intrinsic test for x86/x64 CoreCLR
* Ensure we don't skip base intrinsics when only SSE/SSE2 are disabled
* Ensure InstructionSet_Vector64/128/256 are handled correctly in lookupId
|
|
* JIT ARM32: Fix odd sized structs from arbitrary sources
ARM32 ABI allows passing structs in register even when their sizes are
not divisible by 4. This means we sometimes need to pass 3 bytes in the
last register. The JIT would not handle this when the source was an
arbitrary memory location (this would require multiple loads and
shifts). The fix is to just force a copy into the local stack frame for
this case.
Fix #61168
* Reenable ABI tests
Fix #68837
Fix #70042
|
|
* Always use portable tailcalling mechanism for delegate tailcalls
It is rare but possible to have delegates that point to VSD stubs. Since
VSD stubs on x86 may disassemble the call-site we cannot allow tail
calling these with the old mechanism.
Fix #70259
* Add regression test
* Calm down the test
Tailcall through built-in delegates is best-effort. Instantiating stubs
may break the chain and on ARM32 so may wrapper delegate stubs. The
latter happens for this particular test. Change the test so that it is
just verifying we do not hit the assert.
* Disable regression test on Mono
* Clean up some ildasm output
|
|
Tracking: https://github.com/dotnet/runtime/issues/67870
|
|
The assert it was disabled for has since been deleted.
|
|
* [wasm] Fix runtime test failing due to the app running in debug mode
Fixes https://github.com/dotnet/runtime/issues/69517
- Recent [wasm-app-host commit](6b3ea401ca20c26dbb5497b0fbbf77b3afc73374) changed `WasmApp.targets` so
`WasmDebugLevel` would be set to enable debugging if
`Configuration==Debug`.
- this broke some runtime tests which depend on tail call
optimizations, which get disabled when debugging is enabled in the
runtime.
- And the wasm apps for the runtime tests are being built with no
configuration set, which defaults to `Debug`. Instead, propogate the
config for the build to the wasm proxy (`WasmTestRunner`) projects too.
Fixes https://github.com/dotnet/runtime/issues/69517 .
* Revert "[wasm] Disable runtime test failing due to stack overflow (#69863)"
This reverts commit 61441fae579149181dc973ae4e58eccd4beef728.
|
|
compiler (#69759)
- mono_reflection_create_custom_attr_data_args_noalloc now supports decoding array type parameters of custom attributes
- mono_reflection_create_custom_attr_data_args_noalloc is refactored to use MonoDecodeCustomAttr
- MonoDecodeCustomAttr encapsulates all the information of the decoded custom attribute parameters
- initial support for UnmanagedCallConvAttribute: native-to-managed wrapper generation now takes into account applied custom attributes by updating the method's signature
Fixes [#52977](https://github.com/dotnet/runtime/issues/52977)
|
