| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
Signed-off-by: Vyacheslav Cherkashin <v.cherkashin@samsung.com>
|
|
Signed-off-by: Vyacheslav Cherkashin <v.cherkashin@samsung.com>
|
|
Use DispatchToken::CreateDispatchToken to get token to resolve
virtual method in case of non interface MT.
|
|
|
|
Avoids having to compare names of all types in CoreLib to see if they're HW intrinsics.
|
|
Fixes #22059.
|
|
* Move MemoryFailPoint to shared CoreLib partition.
* Split MemoryFailPoint into Unix and Windows versions.
* Replace MemoryFailPoint.GetMemorySettings FCall with GC.GetSegmentSize to make sharing with CoreRT easier.
|
|
* Cleanup Array FCalls
* Disable outdated CoreFX tests
https://github.com/dotnet/corefx/pull/34700
|
|
This function was recently changed to just return the
MethodDesc::GetLoaderAllocator. This is a cleanup that removes the
function completely and replaces all of its usages.
|
|
As fair as I can tell `ECWGCFCrawlCallBack(..)` is not wired-up anywhere (I've successfully compiled CoreCLR locally with this change under `x86` and `x64`)
|
|
Add Per-assembly Load Native Library callbacks
This Change implements the Native Library resolution
Call-backs proposed in https://github.com/dotnet/corefx/issues/32015
|
|
This adds handling for the interface dispatch corner case where:
* We have a constrained callsite to a method on a generic interface in shared code
* The callsite cannot be statically resolved because the result of dispatch depends on the generic context
* At runtime, the dispatch resolves to a default interface method
This would require us to have infrastructure to build "boxing thunks" - thunks that would box their first argument before dispatching to the default interface method implementation.
Since this is a corner case and the fix is actually quite involved, we're making the runtime just throw in this situation.
The test is written so that it should pass both if the runtime chooses to throw, or if the runtime makes the boxing thunk (we're not hardcoding the implementation limitation).
|
|
We need to use the module of the interface.
Fixes #22021.
|
|
this next (#22054)
* Add comments on headers that gets parsed by Mono linker for whoever touches this next
* add more comments to the targets file
|
|
* On SIGTERM default to a non-zero exit code
* Fix Windows builds
* Improve SIG_DFL/SIG_IGN handling
* Remove PAL_GetTerminationExitCode
* Use sa_handler/sa_sigaction based on SA_SIGINFO; remove HAVE_SIGINFO_T.
* configure.cmake: remove siginfo_t check
* Move restore_signal_and_resend so OSX can use it; add function documentation
* Fix OSX build: include pal/process.h for gPID
* Check SIG_IGN and SIG_DFL against sa_handler
* Don't use sa_handler when SA_SIGINFO is set
* Fix equality check
* Swap order of checking SA_SIGINFO and SIG_IGN/SIG_DFL
|
|
* Preliminary Changes
* Module Index Resolution
* Change infoModule encoding
* Change referencing module in R2R
* Pre-condition Check
* Virtual Method Module Resolution
* Remove Workarounds and add conditional import loading
* Add signature kind module override
* Add ELEMENT_TYPE_MODULE_ZAPSIG
* Add switch to enable large version bubble
* Cleanup
* Change Native header check
* Add large version bubble test
* Add Large Version Bubble Checks
* Cleanup
* Revert unnecessary check
* Change EncodeMethod Version Bubble Condition
* Add Large Version Bubble asserts
* Cleanup
* Add default argument to runtests.py
* Change test PreCommands
* Revert whitespace changes
* Change breaking conditional check
* Streamline Version Bubble test
* Address PR Feedback
* Address PR Feedback #2
* Remove dead code
* Add crossgen-time ifdef
|
|
* Use GetInternalSystemDirectory() as the directory for standalone GC
* Use GetInternalSystemDirectory() as the directory for coredistools
|
|
switch (#21987)
|
|
from crossing ALCs (#21606)
* Create repro for dotnet/coreclr#19654
* Update ICustomMarshaler.csproj
* Update ICustomMarshaler.csproj
* Clean up repro per feedback.
* Add test case for different assemblies with the same CustomMarshaler name.
* Move EEMarshalingData cache from AppDomain to LoaderAllocator. This fixes the custom-marshaler conflict when using unloadable assembly contexts.
* Internalize the LoaderHeap* parameter.
* Add the pointer to the requesting assembly to the hashtable key.
* Fix linux-musl build break.
* Move Crst out of FEATURE_COMINTEROP block.
* Make sure to copy over the assembly pointer to the key that's actually stored in the hash table.
* Add comment for m_invokingAssembly.
* Move all usages of EEMarshallingData to hang off the correct loader allocator instead of always the global one.
* Change to m_InteropDataCrst since this EEMarshallingData can be used in preemptive GC mode.
* Always init m_InteropDataCrst (since it's used by EEMarshallingData as well as COM).
* PR Feedback.
* Remove extraneous inlines.
|
|
This change adds the Native library resolving event, to be raised as the last attempt to resolve a native DLL in an AssemblyLoadContext.
With this change, the DllImport resolution sequence is as follows (stopping at any step with successful resolution):
* If the invoking-assembly is not in the default load context, call AssemblyLoadContext.LoadUnmanagedDll()
* Run the default load logic, try loading from:
* AppDomain cache
* NATIVE_DLL_SEARCH_DIRECTORIES
* Invoking-assembly directory, System32, etc. based on DllImportSearchPaths
* Raise the ResolvingUnmanagedDll event
API Review: https://github.com/dotnet/corefx/issues/32850
The ResolveEventTests triggered a pre-existing bug in the exception handling code (#21964).
Disabling the test on ARM64 Windows until the issue is fixed.
|
|
Patch vtable slots and similar when tiering is enabled
For a method eligible for code versioning and vtable slot backpatch:
- It does not have a precode (`HasPrecode()` returns false)
- It does not have a stable entry point (`HasStableEntryPoint()` returns false)
- A call to the method may be:
- An indirect call through the `MethodTable`'s backpatchable vtable slot
- A direct call to a backpatchable `FuncPtrStub`, perhaps through a `JumpStub`
- For interface methods, an indirect call through the virtual stub dispatch (VSD) indirection cell to a backpatchable `DispatchStub` or a `ResolveStub` that refers to a backpatchable `ResolveCacheEntry`
- The purpose is that typical calls to the method have no additional overhead when code versioning is enabled
Recording and backpatching slots:
- In order for all vtable slots for the method to be backpatchable:
- A vtable slot initially points to the `MethodDesc`'s temporary entry point, even when the method is inherited by a derived type (the slot's value is not copied from the parent)
- The temporary entry point always points to the prestub and is never backpatched, in order to be able to discover new vtable slots through which the method may be called
- The prestub, as part of `DoBackpatch()`, records any slots that are transitioned from the temporary entry point to the method's at-the-time current, non-prestub entry point
- Any further changes to the method's entry point cause recorded slots to be backpatched in `BackpatchEntryPointSlots()`
- In order for the `FuncPtrStub` to be backpatchable:
- After the `FuncPtrStub` is created and exposed, it is patched to point to the method's at-the-time current entry point if necessary
- Any further changes to the method's entry point cause the `FuncPtrStub` to be backpatched in `BackpatchEntryPointSlots()`
- In order for VSD entities to be backpatchable:
- A `DispatchStub`'s entry point target is aligned and recorded for backpatching in `BackpatchEntryPointSlots()`
- The `DispatchStub` was modified on x86 and x64 such that the entry point target is aligned to a pointer to make it backpatchable
- A `ResolveCacheEntry`'s entry point target is recorded for backpatching in `BackpatchEntryPointSlots()`
Slot lifetime and management of recorded slots:
- A slot is recorded in the `LoaderAllocator` in which the slot is allocated, see `RecordAndBackpatchEntryPointSlot()`
- An inherited slot that has a shorter lifetime than the `MethodDesc`, when recorded, needs to be accessible by the `MethodDesc` for backpatching, so the dependent `LoaderAllocator` with the slot to backpatch is also recorded in the `MethodDesc`'s `LoaderAllocator`, see `MethodDescBackpatchInfo::AddDependentLoaderAllocator_Locked()`
- At the end of a `LoaderAllocator`'s lifetime, the `LoaderAllocator` is unregistered from dependency `LoaderAllocators`, see `MethodDescBackpatchInfoTracker::ClearDependencyMethodDescEntryPointSlots()`
- When a `MethodDesc`'s entry point changes, backpatching also includes iterating over recorded dependent `LoaderAllocators` to backpatch the relevant slots recorded there, see `BackpatchEntryPointSlots()`
Synchronization between entry point changes and backpatching slots
- A global lock is used to ensure that all recorded backpatchable slots corresponding to a `MethodDesc` point to the same entry point, see `DoBackpatch()` and `BackpatchEntryPointSlots()` for examples
Due to startup time perf issues:
- `IsEligibleForTieredCompilation()` is called more frequently with this change and in hotter paths. I chose to use a `MethodDesc` flag to store that information for fast retreival. The flag is initialized by `DetermineAndSetIsEligibleForTieredCompilation()`.
- Initially, I experimented with allowing a method versionable with vtable slot backpatch to have a precode, and allocated a new precode that would also be the stable entry point when a direct call is necessary. That also allows recording a new slot to be optional - in the event of an OOM, the slot may just point to the stable entry point. There are a large number of such methods and the allocations were slowing down startup perf. So, I had to eliminate precodes for methods versionable with vtable slot backpatch and that in turn means that recording slots is necessary for versionability.
|
|
* Add test verifying behavior in dotnet/coreclr#19676.
* Clean up test code.
* Test what happens if we enable returning structures by value.
* Use braced initializer.
* Update Decimal tests to expect that returning a decimal by LPStruct or Currency works.
* Change handle-in-struct marshalling to expect a NotSupportedException thrown at marshal time instead of expecting a MarshalDirectiveException at signature time.
* Update Decimal Reverse-PInvoke tests.
* Disable some previously disabled return marshalling types and add a nice comment block explaining why they're disabled.
* Enable marshalling DateTime return values and add a test.
* Rename IsUnuspportedValueTypeReturn
* Add return test for ArrayWithOffset
* Remove extraneous P/Invoke.
* Fix spelling.
* Add test for successfully returning a struct that has one field of a type that is return-type blocked.
* Add explicit struct return test.
* Clean up tests.
* Fix grammer.
* Add test for struct whose managed layout doesn't require a stdcall return buffer but whose native layout does.
* Add test verifying HandleRef behavior.
* Clean up IsUnsupportedTypedefReturn per PR feedback.
|
|
|
|
The TypeIDMap is stored in the AppDomain and contains two hash maps -
id to MethodTable and MethodTable to id. We were missing removing
entries for MethodTables that belong to a LoaderAllocator that's being
destroyed. Thus we were leaking some memory, but also causing potential
issue. When at some point after the LoaderAllocator destruction a
MethodTable gets the same address as one of the MethodTables that was
destroyed in the past and was also recorded in the TypeIDMap, we would
incorrectly reuse the id. That is problematic in case the old
MethodTable didn't require fat id and the new does or vice versa.
I've hit assert due to that while running System.Numerics.Vectors.Tests
inside an unloadable AssemblyLoadContext.
The implementation of the fix is very primitive. It is expected that we
will be able to get rid of the TypeIDMap in a near future and so it is
not worth optimizing.
|
|
Normalize a few more spin-wait loops
- Fixed a few more spin-waits to normalize the spin-wait duration between processors
- These spin-waits have so far not needed to be retuned to avoid unreasonably long spin-wait durations. They can be retuned as necessary in the future.
- Added a version of YieldProcessorNormalized() that normalizes based on spin-wait counts tuned for pre-Skylake processors for spin-wait loops that have not been retuned.
- Moved some files around to make YieldProcessorNormalized() and the like available in more places. Initialization is still only done in the VM. Uses outside the VM will use the defaults, where there would be no significant change from before.
- Made YieldProcessor() private outside of the GC and added System_YieldProcessor() for when the system-defined implementation is intended to be used
|
|
The DynamicMethodTable::AddMethodsToList was incorrectly allocating the
MethodDescChunk from the domain's LoaderAllocator instead of the context
specific one. Thus the allocated memory was leaking after a collectible
AssemblyLoadContext was collected.
There was also a problem with the DynamicMethodDesc::Destroy being
called twice for collectible classes - once by
RuntimeMethodHandle::Destroy() and once when the DomainFile destructor
was called. Due to the primary issue, this problem was not visible,
since the domain's LoaderAllocator is never unmapped. But it started to
cause AV after the primary issue was fixed.
|
|
* Remove extraneous eightbytes check and add tests.
* Interger -> Integer
* Missed Helper.cs
* Handle field sizes larger than 8 bytes in AssignClassifiedEightByteTypes
* Move CoreFX test case into CoreCLR. Fix the SystemV eightbyte classifier to correctly classify the second eightbyte when a single field crosses the eightbyte boundary (such as an in-place array of three 4-byte enums).
* Enable passing user defined structs in in-place arrays in a structure if SystemV ABI expects it.
* Correctly handle a field spanning two full eightbytes.
* Just directly assign 0 to accumulatedSizeForEightByte
* Change multi-eightbyte field handling to be a loop as per PR feedback.
* Remove extraneous whitespace.
|
|
Fix write barrier bounds checks for ARM64 Unix.
|
|
* Cleanup changes from #21793.
* Emit the data pointer offset directly into the IL stream (and calculate it as needed instead of passing it through)
* Fix broken assumption that OverrideProcArgs::na::m_pMT is the array type instead of the element type (which it was).
|
|
|
|
|
|
|
|
Move APIs that manipulate native libraries from
System.Runtime.InteropServices.Marshal class to the new
System.Runtime.InteropServices.NativeLibrary class.
In API review: #32015,
The LoadLibrary APIs were originally Approved to live in
System.Runtime.InteropServices.Marshal class.
However, recently the decision was changed such that the APIs are
in a new NativeLibrary class.
|
|
|
|
* Avoid passing stack crawl mark unnecessarily deep in the call stack.
* Move stack crawl from TypeName::GetTypeManaged to RuntimeTypeHandle::GetTypeByName.
|
|
* Remove some commented out code.
* Add test verifying that we put a null terminator 2-past the end of the native buffer allocated for a StringBuilder.
|
|
* Adds portable version of EncodingTable
Most of the implementation is extracted from CoreRT
* Use string comparer directly
* Remove no longer used COMNlsInfo
* Adds localization support
* Removes FeatureCoreFxGlobalization configuration
* Remove redudant encodings look up from GetEncoding
* Keep Hashtable for nameToCodePage as it does not lock on read
* Replace locked dictionary lookup with short switch
* Include comment with msbuild task link used to generate the data file
|
|
Large portion of the current culture handling in the unmanaged runtime inherited from desktop has been no-op. The nativeInitCultureAccessors QCall that it used to depend on desktop got (almost) never called in CoreCLR.
- Delete resetting of current culture on threadpool threads. It was needed in desktop because of a very tricky flow of current culture between appdomains. It is superseded by the flowing the current culture via AsyncLocal in CoreCLR.
- Comment out fetch of managed current culture for unmanaged resource lookup. It has number of problems that are not easy to fix. We are not localizing the unmanaged runtime currently anyway, so it is ok to just comment it out.
- Fix the rest to call CultureInfo directly without going through Thread.CurrentThread
|
|
|
|
strlen/wcslen works just fine.
|
|
- Delete unnecessary CheckStringLength calls for result of string.Length. Managed strings are guaranteed to be under 2GB bytes, so these checks were unnecessary.
- Add `checked(...)` around buffer size computations that may hit potential integer overflow. It does not look like any of these would cause a bug that would lead to buffer overrun, but it is better to catch these early.
|
|
|
|
|
|
* Move MdUtf8String::EqualsCaseSensitive to managed code
* Move MdUtf8String.ToString to safe code
* Use Encoding.UTF8.GetString
|
|
|
|
* Move thread CurrentCulture and CurrentUICulture variables to CultureInfo.
* Move CultureInfo to shared CoreLib
* Code style fixes for consistency.
* Fold down APPX code into CultureInfo.CurrentCulture/CurrentUICulture.
* Remove unnecessary parentheses around return statements.
* Remove GetCurrentUICultureNoAppX.
|
|
|
|
+alloc lock split into SOH and LOH
+provisional mode to fix too many gen2 GCs triggered in low mem situation when the heap has heavy pinning fragmentation
+better free list usage
+premature OOM fixes
+3 new configs: GCHeapAffinitizeMask, GCHighMemPercent, GCLOHThreshold (will be documented)
YieldProcessor scaling factor is different on core due to the different implementation on core.
|
|
|
|
This change improves detection of allocators with side effects.
Allocators can cause side effects if the allocated object may have a finalizer.
This change adds a pHasSideEffects parameter to getNewHelper JitEE interface
method. It's used by the jit to check for allocator side effects instead of
guessing from helper ids.
Fixes #21530.
|
