| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
|
|
* Make it easier to iterate through an ArraySegment. See Make it easier to iterate through an ArraySegment
|
|
Fix to issue 8287.
|
|
Make ConditionalWeakTable reads lock-free
|
|
Adding StringBuilder.AppendJoin
|
|
|
|
FastGetDomain function (with __declspec(naked)) causes segmentation
fault.
|
|
Fix getcpuid(), getextcpuid() with STDCALL
Fix xmmYmmStateSupport() with STDCALL
|
|
* Strip more defines from CoreLib
Removes the rest of
FEATURE_CAS_POLICY
FEATURE_REMOTING
FEATURE_MACL
And another significant chunk of
!FEATURE_CORECLR
* Address feedback
|
|
The CoreRT implementation of ConditionalWeakTable that was ported back to CoreCLR uses a special scheme to make reads lock-free. When the container needs to grow, it allocates new arrays and duplicates all of the dependency handles from the previous array, rather than just copying them. This avoids issues stemming from a thread getting a dependency handle in an operation on the container, then having that handle destroyed, and then trying to use it; the handle won't be destroyed as long as the container is referenced.
However, this also leads to a significant cost in a certain situation. Every time the container grows, it allocates another N dependency handles where N is the current size of the container. So, for example, with an initial size of 8, if 64 objects are added to the container, it'll allocate 8 dependency handles, then another 16, then another 32, and then another 64, resulting in significantly more handles than in the old implementation, which would only allocate 64 handles total.
This commit fixes that by changing the scheme slightly. A container still frees its handles in its finalizer. However, rather than duplicating all handles, that responsibility for freeing is transferred from one container to the next. Then to avoid issues where, for example, the second container is released while the first is still in use, a reference is maintained from the first to the second, so that the second can't be finalized while the first is still in use.
The commit also fixes a race condition with resurrection and finalization, whereby dependency handles could be used while or after they're being freed by the finalizer. It's addressed by only freeing handles in a second finalization after clearing out state in the first finalization to guarantee no possible usage during the second.
|
|
The CoreRT ConditionalWeakTable was modified to support lock-free reads. This ports the implementation back to coreclr.
|
|
|
|
Fix unix unwind info
|
|
Fix unit test error for x86/Linux
- fix fail of exception_handling/pal_sxs/test1/paltest_pal_sxs_test1
|
|
* [x86/Linux] Revise asmhelper.S using macro
This commit revises asmhelper.S using macros that inserts CFI
directives.
|
|
Disable special put args for LIMIT_CALLER on x86.
|
|
Correct an assertion in LSRA.
|
|
TimeZoneInfo is immutable. Help enforce this by making its fields
readonly.
|
|
It's more efficient to concatenate the strings.
|
|
TransitionTime is immutable. Help enforce this by making its fields
readonly.
|
|
This commit adds SinglecastDelegateInvokeStub and VSD-related Stubs as NYI.
|
|
AdjustmentRule is immutable. Help enforce this by making its fields
readonly.
|
|
There doesn't appear to be a good reason why the TimeZoneInfo.Utc
instance needs to be cleared when TimeZoneInfo.ClearCachedData() is
called. Instead, we can pre-allocate and reuse a singleton instance,
obviating the need for the lazy-initialization/locking mechanics.
|
|
|
|
Use Comparison<T> instead of IComparer<T> to sort the list of
TimeZoneInfos, which moves the comparison code to the sole place where
it is used, and now that Array.Sort is implemented in terms of
Comparison<T> instead of IComparer<T>, avoids some unnecessary
intermediate allocations.
|
|
Windows uses offset from stack pointer, when unix has to use offset from
caninical frame address,
|
|
* Remove sscanf
* Remove sprintf
|
|
`verifyFinalAllocation` asserts that if a non-BB interval RefPosition
that is either spilled or is the interval's last use does not have a
register, then that ref position must be marked `AllocateIfProfitable`.
However, this situation can also arise in at least one other situation:
an unused parameter will have at least one ref position that may not be
allocated to a register. This change corrects the assertion to check
`RefPosition::RequiresRegister` rather than
`RefPosition::AllocateIfProfitable`.
Fixes VSO 299207.
|
|
On x86, `LSRA_LIMIT_CALLER` is too restrictive to allow the use of special
put args: this stress mode leaves only three registers allocatable--eax,
ecx, and edx--of which the latter two are also used for the first two
integral arguments to a call. This can leave us with too few registers to
succesfully allocate in situations like the following:
t1026 = lclVar ref V52 tmp35 u:3 REG NA <l:$3a1, c:$98d>
/--* t1026 ref
t1352 = * putarg_reg ref REG NA
t342 = lclVar int V14 loc6 u:4 REG NA $50c
t343 = const int 1 REG NA $41
/--* t342 int
+--* t343 int
t344 = * + int REG NA $495
t345 = lclVar int V04 arg4 u:2 REG NA $100
/--* t344 int
+--* t345 int
t346 = * % int REG NA $496
/--* t346 int
t1353 = * putarg_reg int REG NA
t1354 = lclVar ref V52 tmp35 (last use) REG NA
/--* t1354 ref
t1355 = * lea(b+0) byref REG NA
Here, the first `putarg_reg` would normally be considered a special put arg,
which would remove `ecx` from the set of allocatable registers, leaving
only `eax` and `edx`. The allocator will then fail to allocate a register
for the def of `t345` if arg4 is not a register candidate: the corresponding
ref position will be constrained to { `ecx`, `ebx`, `esi`, `edi` }, which
`LSRA_LIMIT_CALLER` will further constrain to `ecx`, which will not be
available due to the special put arg.
|
|
Avoid the intermediate ToUpper string allocation.
|
|
Equals(TimeZoneInfo) already handles null.
|
|
Set native search paths in AppDomain.Setup before doing the rest
of the setup steps to get ahead of potential P/Invoke calls.
|
|
In lowerxarch.cpp, local variable srcUns is defined but not used
at Lowering::LowerCast(GenTree* tree).
Signed-off-by: Hyung-Kyu Choi <hk0110.choi@samsung.com>
|
|
Removed:
FEATURE_FUSION
FEATURE_PATHCOMPAT
FEATURE_APPDOMAINMANAGER_INITOPTIONS
FEATURE_APTCA
FEATURE_CLICKONCE
FEATURE_IMPERSONATION
FEATURE_MULTIMODULE_ASSEMBLIES
Removed some:
FEATURE_CAS_POLICY
!FEATURE_CORECLR
FEATURE_REMOTING
|
|
* [x86/Linux] Fix inconsistency in GetCLRFunction definitions
GetCLRFunction is treated as pfnGetCLRFunction_t which has __stdcall
convention, but is implemented without __stdcall.
This inconsistency causes segmentaion fault while initializing CoreCLR
for x86/Linux.
This commit fixes such inconsistency via adding __stdcall to
GetCLRFunction implementation.
In addition, this commit declares GetCLRFuntion in 'utilcode.h' and
and revises .cpp files to include 'utilcode.h' instead of declaring
'GetCLRFunction'.
* Remove unnecessary includes
* Remove another unnecessay include
|
|
Merge changes from TFS
|
|
- Introduce internal ByReference<T> type for byref fields and change Span to use it
- Generalize handling of byref-like types in the type loader
- Make DangerousGetPinnableReference public while I was on it
|
|
Use a left-leaning comma tree when morphing a stelem.ref helper.
|
|
[tfs-changeset: 1640669]
|
|
Change ArraySortHelper to use Comparison<T>
|
|
Use only lower floats for Vector3 dot and equality
|
|
Fix to issue 8356.
|
|
fgMorphCall may change a call to the stelem.ref helper that is storing a
null value into a simple store. This transformation needs to construct a
comma tree to hold the argument setup nodes present on the call if any
exist. Originally this tree was constructed in right-leaning fashion
(i.e. the first comma node was the root of the tree and each successive
comma node was the RHS of its parent). Unfortunately, this construction
did not automatically propagate the flags of a comma node's children to
the comma node, since not all of each comma node's actual children were
available at the time it was constructed. Constructing the tree in
left-leaning fashion (i.e. the first comma node is the left-most child
and the final comma node is the root of the tree) allows the flag
propagation to be performed correctly by constrution.
Fixes VSO 297215.
|
|
Remove a use of `gtGetOp` in earlyprop.
|
|
These are never used in CoreCLR
|
|
The Array/List.Sort overloads that take a Comparison<T> have worse performance than the ones that take a IComparer<T>. That's because sorting is implemented around IComparer<T> and a Comparison<T> needs to be wrapped in a comparer object to be used.
At the same time, interface calls are slower than delegate calls so the existing implementation doesn't offer the best performance even when the IComparer<T> based overloads are used.
By changing the implementation to use Comparison<T> we avoid interface calls in both cases.
When IComparer<T> overloads are used a Comparison<T> delegate is created from IComparer<T>.Compare, that's an extra object allocation but sorting is faster and we avoid having two separate sorting implementations.
|
|
Instead, use `GenTreeIndir::Addr`, as some indirections are not simple
operators.
Fixes VSO 289704.
|
|
|
|
For both dot product and comparisons that produce a boolean result, we need to use only the lower 3 floats. The bug was exposed by a case where the result of a call was being used in one of these operations without being stored to a local (which would have caused the upper bits to be cleared).
Fix #8220
|
|
CMakeLists.txt file of lldbplugin (#8499)
|
