| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
Delete legacy netcf compat support (part 2)
|
|
Strip symbols on release builds into separate binaries
|
|
Issue #3669
Created a common cmake strip_symbols function that all the modules and programs
use to strip the symbols out of the main into a separate .dbg (Linux) or .dSYM (OSX)
file.
Added an install_clr cmake function to encapsulate the install logic.
Changed all the library module cmake install lines from a TARGETS to a FILES one. The
TARGETS based install directives caused cmake to relink the binary and copy the unstripped
version to the install path. Left the all programs like corerun or ildasm as TARGETS
installs because on OSX FILES type installs don't get marked as executable.
Need to use "get_property(strip_source_file TARGET ${targetName} PROPERTY LOCATION)" for
the older versions of cmake and "set(strip_source_file $<TARGET_FILE:${targetName}>)" on
newer versions (v3 or greater).
|
|
Merge changes from TFS
|
|
Fix exception to string in case of exception in callstack extraction
|
|
|
|
This change fixes a problem when exception happens while converting an exception
call stack to string. Without this change, Exception.ToString would fail and
if the exception was unhandled, it would just print "Cannot print exception string
because Exception.ToString() failed." without any details on what exception happened.
The problem happens e.g. in case when a method on the call stack has a parameter
that contains members of types from an assembly that cannot be resolved.
The fix was to catch exception from parameter info extraction and if it happens,
just exclude the parameter list from the reported frame.
|
|
CR: ericstj
[tfs-changeset: 1588560]
|
|
Fix for issue #3754 when passing struct as argument on ARM
|
|
Delete legacy netcf compat support (part 1)
|
|
Fix to Huffman benchmark decompression loop has unnecessary spills and reloads
|
|
Inliner: initial data gathering for code size estimates
|
|
Update SOS documentation
|
|
|
|
Merge changes from TFS
|
|
When enabling Unix AMD64 struct passing, we broke ARM we were need to
check if the register is an HFA one or not, and if so uses the HFA type
instead.
|
|
|
|
Fixes issue 3750 - passing fp arguments
|
|
Some initial work to gather data to drive the modelling of inline
code size impact. See #3775 for context.
Update the `DiscretionaryPolicy` to capture more observations.
Add a limit feature `JitInlineLimit` so the jit will stop inlining after
a given number of successful inlines.
Add a `DumpData` method to `InlinePolicy` which will display all the
observations that were made to evaluate an inline. Implement this for the
`DiscretionaryPolicy`. Add a matching `DumpSchema` that writes out
column headers for each of the observations.
Modify `InlineResult` to cache the last successful policy on the root
compiler instance. Use that along with the `JitInlineLimit` and
`DumpData` to display detailed information about the last sucessful
inline along with the code size for the method. All this is displayed
if `JitInlineDumpData ` is enabled.
This allows for isolating code size measurements as follows. Compile or
jit something with `JitInlineLimit = 0` and `JitInlineDumpData =1` (and
for now, `JitInlinePolicyDiscretionary = 1`, since other policies do not
implement any interesting data dumping).
Record the this root set of method sizes and IDs. Repeat with
`JitInlineLimit=1`. For each method where there was an inline, the size
impact of that inline can be computed by comparing this version versus
the version from the root set. Repeat with `JitInlineLimit=2`, comparing
versus the `=1` versions.
Currently the method token is used to identify the root method. This is
not sufficiently unique but unfortunately there currently aren't
substantially better alternatives. See #1957 for some discussion.
|
|
[tfs-changeset: 1588225]
|
|
Updated Tests.lst with 50 new passing tests
Updated this fix to be under #ifdef ARM64 only
|
|
CrossGen /CreatePDB command gives preference to the TPA list while loading assemblies. So if the TPA contains the IL version of the input assembly but not the NI version, we would end up loading the IL instead of NI. This causes the CreatePDB command to fail, since it can't operate on IL images. This is fixed by putting the input file as the first entry in the TPA list.
Another issue is when the above error does occur, the error message is very unclear (it only shows "Unspecified error"). This is fixed with a better error message.
[tfs-changeset: 1587876]
|
|
Fix inconsistent uint64-to-double cast
|
|
|
|
Fix instantiating stub for methods of value types
|
|
This change fixes a problem with instantiating stubs for methods of value types.
The problem was that the CreateInstantiatingILStub didn't take into account the
fact that methods of value types need to have "this" passed "byref".
The issue manifested itself as a rare corruption of references in array of structs
that were thin wrappers for string reference during GC stack scan. GC thought that
the reference to an array entry is an object reference that starts with method table.
GC marks method table pointers by setting their bit zero to 1. But in this case,
it has accidentally modified an object reference instead and a test was crashing
with wrong object address.
The root cause of the problem is that the instantiating stubs were placed on a global
singleton reference class no matter whether the target method was on a reference class
or a value type.
I have fixed it by putting the stubs on the instantiated target generic type instead.
|
|
|
|
Inliner: make more observations unconditional
|
|
Merge changes from TFS
|
|
Fix Stack Alignment Check
|
|
Fixed problem with bpmd not working sometimes.
|
|
Ensure proper spelling of COMPlus_xxx environment variables
|
|
Update out of date comment in List<T>
|
|
[tfs-changeset: 1586974]
|
|
This fixes https://github.com/dotnet/coreclr/issues/3747.
If JIT saves the first single store (not pair store) with stack adjustment
required (```spDelta != 0```), we expect the offset to be 8 to account for alignment.
This API ```genPrologSaveReg``` is invoked twice from INT and FP saving respectively
while JIT stores/allocates stacks once for these saving registers back to back.
So, the assertion is not quite right. For instance when we have 1 INT and
1 FP registers to be saved, JIT failed to assert the offset to be 8 in the
first invocation for INT. In fact, for this case, the offset should be 0
(no alignment is required) since we store 2 registers which are already
aligned on 16 byte.
We should consider whether or not the total number of saved registers is odd.
Not only that, even for the pair store, we should assert the offset either
0 or 8 depending on the total number of saved registers. For instance, 2
INT and 3 FP, we want the offset to be 8 when we store the first pair with
stack adjustment required (```spDelta != 0```).
I refactored the code to reflect this issue in ```genSaveCalleeSavedRegistersHelp``` while taking out the
existing assertion in ```genPrologSaveReg``` which is too local.
Similar change is made for the restore case.
|
|
There are still some observations within `fgFindJumpTargets` that are
only made when inlining. This change enables them to also be made for
the prejit root case. This partially addresses the inconsistencies
noted in #3482.
Most notably, the simple stack model is now fully enabled for the
prejit root case, and the policy is able to more broadly observe
things like `CALLEE_LOOKS_LIKE_WRAPPER` and
`CALLEE_ARG_FEEDS_CONSTANT_TEST`. As before, the `LegacyPolicy`
ignores these observations for the prejit root. Forthcoming policies
will likely behave differently.
Two observations that were fatal -- `CALLEE_UNSUPPORTED_OPCODE` and
`CALLEE_STORES_TO_ARGUMENT` -- are now conditionally fatal, since they
do not cause failure for the prejit root case (though arguably they
should).
The `CALLEE_IS_MOSTLY_LOAD_STORE` observation has been removed, and
the conditions under which it fired have been encapsulated within the
`LegacyPolicy`.
No change in behavior is expected. I verified crossgen of mscorlib
still makes all the same inline decisions for the same reasons.
|
|
Merge changes from TFS
|
|
Add back HostProtectionAttribute to mscorlib
|
|
Comment for parameterless constructor of List<T> claimed that
the default non-zero capacity was 16, even though _defaultCapacity
is actually 4.
Updated the comment to refer to _defaultCapacity,
to make sure it doesn't need to be updated again
if _defaultCapacity changes in the future.
|
|
CoreFX uses "debian.8" as the rid for debain packages, whereas CoreCLR
was still on "debian.8.2". Move to "debian.8" because it matches what's
in /etc/os-release and what the CLI will generate by default.
[tfs-changeset: 1586899]
|
|
|
|
Inliner: create DiscretionaryPolicy
|
|
Fix some too earlier SOS initialization problem. Now returns an error.
The DAC interface (IXCLRDataProcess) was being created everytime an command was run and the JIT and GC notification tables where being reinitialized each time losing any JIT notifications needed to resolve a breakpoint. Only create the DAC interface instance once. It does need to be flushed each time sos is entered though.
Enable the module load and unload and exception callbacks when the DAC instance is created. This is what windbg does on Windows (along with flushing the DAC each time the target is restarted). It simplifies the breakpoint code; it no longer needs to enable/disable these notification flags.
Cleaned up places where the DAC instance (direct calls to LoadClrDebugDll) and not released properly.
|
|
Merge changes from TFS
|
|
The `DiscretionaryPolicy` is similar to the `LegacyPolicy`, but does not
use size limits. So there is no "always" inline class and no "too big to
inline" class. Also, discretionary failures do not trigger noinline
stamping.
It is installed if `JitInlinePolicyDiscretionary` is set nonzero.
See #3775 for some background on where this new policy will be used.
This is a first cut and further refinement is likely.
Also removed the unused `NoteDouble` methods since the double-valued
observations now are kept internally within `LegacyPolicy` and it's
not very likely we'll introduce new cases where doubles are needed.
|
|
|
|
Move the initialization of compGenTreeID to earlier in Compiler::compCompileHelper
|
|
[tfs-changeset: 1586532]
|
|
Use root compiler instance for inline result and policy
|
|
Merge changes from TFS
|
