| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
.Net -> .NET
|
|
The Amd64 GC Info parser is not complete in its implementation and
sometimes will index to a location beyond the size of the image.
If we fail to parse the GC info for a method, continue dumping the rest
of the image.
Emit a warning when this happens so we don't forget about this.
|
|
|
|
* Remove old use of signing package used to work around SPC signing now that arcade has bubbled up the version.
* Move dependency update for CoreFX and Core-setup dependencies to BAR/Darc/Maestro++ flow
* Update property references in tests.
* Version bump for CoreFX and Core-Setup dependencies.
* Update test Github_20958 to use revised System.Range constructor as surface area changed with #22331.
|
|
This SDK-style project is causing problems on some machines with VS
installs that can't build it. For now, move it to a place where it
doesn't build with the tests.
|
|
Thanks to tons of help from Jan Vorlicek I found out that a huge
failure bucket in the CoreCLR Pri#1 tests is caused by incorrect
GC info for generic methods causing failures in catch clauses
where the exception type is a generic referring to a generic
parameter of the method.
As part of investigation of this issue I'm adding provisions for
dumping the GC info alongside methods to make the differences
between CPAOT and Crossgen easier to analyze.
For now I have only implemented the AMD64 variant of the GC info.
Thankfully it turns out that the same GC info is used by both ARM32
and ARM64 so that the only remaining debt is supplying a variant
of the new code for X86.
Thanks
Tomas
|
|
* 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
|
|
|
|
Turns out there's a long-standing typo in CoreCLR that reverses
the helper enumeration values for DBL and FLT. This doesn't seem
to be a problem in the CoreCLR repo as such because it solely
uses the legacy identifiers CORINFO_HELP_DBLREM et al. We have
however ported the incorrect helper enumeration values into R2RDump
and ILCompiler. This change immediately fixes R2RDump as it resides
in the same repo, I'll send out the ILCompiler change in
a separate PR.
|
|
This was added to help debug work with large version bubbles. The changes should allow R2RDump to have some rudimentary understanding of ENCODE_METHOD_OVERRIDE.
The big TODO here is allow loading of external dependency assemblies to be able to resolve the tokens coming after the override.
|
|
This change adds basic field signature parsing support to R2RDump
and it improves parsing of two fixup types (FIELD_ADDRESS and
CCTOR_TRIGGER).
Thanks
Tomas
|
|
As part of my work on CPAOT implementation of GC ref map info
I have implemented decoder of the info so that it can be displayed
next to the import cell signatures.
This also uncovered one possible cause of R2RDump GcInfo-related
crashes that were observed by Andon and myself. It looks like Amy
in her initial implementation confused the various GC encodings
and used GC info to parse the import section auxiliary data which
actually contains the GC ref map info.
Thanks
Tomas
|
|
The initial impulse for this change was removing native offsets
from debug info that caused noise in naked R2R comparisons. Fixing
this required propagation of DumpOptions to some more call sites
prompting me to unify dumping logic to always use TextWriter
as the output medium. I have also fixed some minor bugs I noticed
around the naked disassembly.
Thanks
Tomas
|
|
|
|
* Initial support for normalized 'naked' R2RDump output
This change introduces a new option "--naked" that takes output
normalization even further - it intentionally leaves out any
position information to make the output easier to diff between
CPAOT and Crossgen.
One other new option is "--entrypoints" which dumps a plain
list of JITted methods in the R2R executable. This can be used
for comparisons between CPAOT and Crossgen and / or for static
analysis of what methods were actually emitted by the compiler.
* Addressed Zach's PR feedback
1) Added argument consistency check for the invalid combination
"--naked" + "--raw".
2) Added dump of multi-dimensional array lower bounds and sizes
when available.
Thanks
Tomas
|
|
1) Dump method signatures in the INSTANCE_METHOD_ENTRYPOINTS section;
2) Add logic for decoding generic lookups;
3) Add previously missing support for dumping MVAR index.
Thanks
Tomas
|
|
* Minor dump improvements in R2RDump
1) Don't silently unify available types;
2) Display RVA's for import cells to enable searching the cell by RVA
in the dump;
3) Display cell signatures for method precodes.
|
|
R2RDump fixes for dumping method instance entrypoint table
While investigating Michal's unit test demonstrating a bug in the
CPAOT compiler I found out that R2RDump is broken in multiple
aspects w.r.t. instantiated methods. Parsing of the method
signatures in the instance entrypoint table was just broken
and the R2RMethod was duplicating parts of the signature decoding
and name formatting process.
I created a new flag "normalize" that requests normalization of various R2R
tables in the dump aimed at improving diff quality. I have also
noticed and fixed somewhat weird formatting of method signatures.
As a slight cleanup I have lumped the various dump flags into
a helper class DumpOptions. Last but not least I have renamed "Canon"
to "__Canon".
Thanks
Tomas
|
|
1) X86 CoreDisTools disassembler has a bug in decoding absolute
indirections, interpreting them as RIP-relative offsets. I have
reused the logic that's already in place for patching X64
RIP-relative addresses to take care of this additional case.
2) the CoreDisTools disassembly apparently only produces newline
(0A) characters that don't work well in Notepad and other viewers;
I have forcibly replaced them with the platform newline separator.
3) I hit a bug in available type decoding - the logic wasn't
properly checking whether the type is exported or not.
Thanks
Tomas
|
|
|
|
Sign extension is done based on a 32-bit int. We were incorrectly basing it off the size of a byte.
|
|
Ready-to-run binaries don't always have an EH table. Fix r2rdump so it doesn't crash if the table isn't present.
|
|
* Add EH info support to R2RDump
This change expands runtime function dump to include the exception
handling info looked up via the EXCEPTION_INFO R2R header table.
* Address Zach's PR feedback
1) Base EHClause.Length on sizeof(uint) instead of sizeof(int)
for consistency with the asctual data types in the class.
2) Fix my overlooking that Zach spotted - in the EHLookupTable
ctor, we need to assign rva2 and eh2 to rva1 and eh1 at the end
of the loop block as we need to traverse consecutive pairs
of CORCOMPILE_EXCEPTION_LOOKUP_TABLE_ENTRY elements.
* Addressed Bruce Forstall's PR feedback
1) I modified the EH info method ctors to accept the R2RReader
instead of the raw byte[] image as the reader can be used to
provide textual representations of metadata tokens.
2) I changed the mask test to a switch that throws an exception
if multiple of the three lowest bits are set which is illegal
according to Bruce.
* Addressed additional Bruce Forstall's PR feedback
Remove interpretation of ClassTokenOrFilterOffset as it's not applicable
in the FINALLY and FAULT cases.
Thanks
Tomas
|
|
Display formatted debug info for each runtime function
|
|
* Import signature parsing and general improvements in R2RDump
GcInfo - fixed a bug where the machine architecture was stored in
the instance field later than it was used in the calculation of
SlotTable which subsequently ended up with the wrong register set
(ARM64 instead of AMD64).
GcTransition - changed register set selector to a switch as the
previous implementation was incorrect for AMD64.
UnwindInfo - bug fix: the 4-alignment padding should come before
the personality routine, not after it. I have also slightly
simplified the calculation of the padding size.
CoreDisTools - added support for annotating indirect calls with
symbol information for the import cells; fixed formatting of
short relative jumps and added some code comments.
DisassemblingTypeProvider - bumped up some visibilities and made
a few generalizations letting me use this helper in the general
signature parser.
R2RImportSection - replaced binary signature samples with the
actual parsed representation.
R2RReader - I removed special-casing for eager import signatures
that seems wrong - I don't see any equivalent code in the
CoreCLR runtime. Please let me know if anyone is aware of a reason
why this was put here in the first place.
TextDumper and elsewhere - I have removed all tabs from the
R2RDump tool output.
R2RConstants - I have merged the various CoreCLR and R2R constants
in this file - previously they were interspersed in multiple
classes - and I added a bunch of new stuff needed by the signature
parser.
R2RSignature - comprises the newly added R2R signature parser.
Thanks
Tomas
* Slight modification in signature formatting to make it easier to read
I have swapped the ordering of the signature content with the
signature name - based on analyzing actual disassembly produced
by the code I came to the conclusion that the parsed signature
is generally more important than the cell fixup type which is
often obvious just based on the code context.
Thanks
Tomas
* Add dump of unwind info and RVA translation for near jumps / calls
* Add code comment on GetInstruction return value per PR feedback
|
|
Set function size to -1 if sizing info unavailable
|
|
|
|
* Get machine architecture for non-Windows images
* Update readme
* Throw exception if machine is invalid, output OS
* Capitalization
|
|
(#19647)
* Fix error caused by exportedType in AvailableTypes section
* TypeDef and ExportedType can both have the same rid
* Use HashSet instead of Dictionary
|
|
* Determine if disasm is supported on architectures instead of match
* Readme changes
|
|
* UnwindInfo for Arm
* ARM64 unwindInfo, change Machine.Arm to Machine.ArmThumb2
* Fix incorrect location of UnwindCode and GcTransition in the disasm
* Use x64 GcInfo for Arm and Arm64
* Cleanup, update readme
|
|
1) In some situations, Crossgen emits a section with EntrySize = 0.
Apparently the engine defaults to size_t in such case.
2) Similarly, Crossgen sometimes emits a section with the UNKNOWN
kind. I have relaxed the section kind check to just treat all
non-eager section kinds the same.
Thanks
Tomas
|
|
* Interweave unwind codes into disasm, fix incorrect x64 register names
* Fix xml dump errors
|
|
* Add image describing R2R format
* Remove help message stating -v option dumps raw bytes
|
|
* Update Microsoft.NETCore.CoreDisTools to version 1.0.1-prerelease-00005. Temporarily add a direct reference to the win-x64 and win-x86 runtime packages
* Change Microsoft.NETCore.CoreDisTools package references to the identity package.
Improve formatting of R2RDump.csproj properties.
* Add an ArgumentException to explain the currently faulty behavior where disassembling an R2R image whose architecture is different than the coredistools.dll architecture.
* Add Issue #19564 to the R2RDump.cs Disassembler comment
|
|
* Initial support for R2R image diff
In this first cut I'm adding just three size diff statistics -
PE section size diff, R2R section size diff and method size diffs.
I assume we'll add more statistics as needed in the course of various
size investigations.
Thanks
Tomas
|
|
* Add comments
* Add README
* Use href links, disable disasm
|
|
(#19359)" (#19501)
This reverts commit d485659348af3528b688ac5b7e4c58dacba6de58.
|
|
x86 GcInfo headers
x86 GcSlotTable
x86 GcTransitions
Update expected xml for R2RDumpTests
Add license headers
Allow multiple GcTransitions with same codeOffset
Add index property in GcSlot, make GcSlot a class instead of struct, add missing spaces, update tests
Remove placeholder functions for parsing partially interruptible pointer tables
Implement partially interruptible GcInfo
Example GcInfo output:
CodeLength: 22 bytes
InfoHdr:
PrologSize: 7
EpilogSize: 4
EpilogCount: 1
EpilogAtEnd: yes
Callee-saved regs = EBP
EbpFrame: yes
Fully Interruptible: yes
DoubleAlign: no
Arguments Size: 0 DWORDs
Stack Frame Size: 1 DWORDs
UntrackedCnt: 1
VarPtrTableSize: 0
GenericsContext: 0
GenericsContextIsMethodDesc: 0
ReturnKind: RT_Scalar
RevPInvokeOffset: 0
Epilogs: 18
GcSlots:
-------------------------
[EBP-4]
Flags: GC_SLOT_UNTRACKED
LowBits:
-------------------------
28fc: 55 push ebp
28fd: 8b ec mov ebp, esp
28ff: 50 push eax
2900: 89 4d fc mov dword ptr [ebp - 4], ecx
2903: 8b 4d fc mov ecx, dword ptr [ebp - 4]
2906: ff 15 10 10 01 10 call dword ptr [268505104]
reg ECX becoming live
290c: 90 nop
reg ECX becoming dead
290d: 90 nop
290e: 8b e5 mov esp, ebp
2910: 5d pop ebp
2911: c3 ret
|
|
* Translate [rip +- offset] to absoluate RVA's in R2RDump
The existing logic for displaying rip-relative addressed on X64
make it very hard to calculate the final addresses. I have added
a horrendous hack using textual analysis of the disassembled
instruction to translate this notation to absolute RVA's.
As part of this effort I have also encapsulated the CorDisTools
helper in a new class Disassembler that also contains customizable
provisions for handling special assembly cases on the individual
architectures.
Thanks
Tomas
* Temporarily block out disassembly to make tests pass
In my initial commit I removed the line blocking out disassembly
however this ends up failing several lab tests so I'm putting the
line back.
Thanks
Tomas
|
|
* Change CoreLib native image to be R2R by default on all platforms
* Delete unused argument
|
|
* Ignore sensitive properties in tests
* Enable for JIT stress
* Keep logic for ignoreSensitive in XmlDumper
* Only ignoreSensitive when option is set
|
|
* Fix GenericFunctions and MultipleRuntimeFunctions tests, x86 nwindInfo tests
* Fix tests
* Avoid using rva as index
* Update expected xml
* Add count as an attribute
* Clean up and move rebaseline script to r2rdump test directory
* Remove R2RDumpTest warnings
* Use original test framework instead of netcoreapp2.0
|
|
* UnwindInfo for x86
* Update tests
|
|
* Partial R2R IBC fixes
- Log use method code access in all cases, not just when the method is JITed
- Add workaround for CONTRACT_VIOLATION that shows up in checked builds when collecting IBC data
- Make /ReadyToRun switch work for CoreLib
|
|
|
|
* Test infrastructure for R2RDump, compare xml and output diff
* Add R2RDumpTest to build-tests
* Fix errors causing tests to fail
* Create XUnitWrapper for R2RDumpTest
* Generate readytorun binaries from source code, copy expected xml output files to executable's directory
* Test R2RDump through commandline instead of calling R2RDump functions
* Fix errors
* Prevent duplicate xml tags
* Read test xml from string instead of file
* Fix test bugs
* Call dotnet r2rdump from msbuild
* Fix errors
* Use right slash for paths in bash
* Use different expected xml for different architectures
* R2RDumpTests for non-Windows
* Add more test cases
* Fix errors
* Supress warnings, avoid error when parsing x86 images
* Add license headers
|
|
* Initial implementation of method fixup parser
I'm working on this right now in the CoreRT R2R compiler so I'm
adding the relevant structures and algorithms to the dumper
to let me analyze various R2R files and their method fixups.
I have locally verified that this shows reasonable fixup info
for my Hello World repro compiled both using the CoreRT R2R
compiled and using crossgen.
Thanks
Tomas
* Improvements in signature dumping
Signature dumping was slightly imprecise - the signature field
was named "Section" in the dump and it was displaying a dword,
however signatures are logically arbitrary byte streams.
Sadly I'm aware of no easy way to detect the length of an
arbitrary signature without adding a multitude of dedicated
parsers for the different signature types used by different
fixup / helper types so for now I'm displaying an 8-byte sample.
I have also made the formatting of the import section entries
more compact to make the list easier to read in the presence
of a larger number of fixups and I added support for displaying
the entry offset (as this is what the method fixups indirectly
refer to via the fixup indices).
Thanks
Tomas
* Move NibbleReader into a separate source file
Based on Amy's PR feedback I'm moving NibbleReader into a separate
source file. After all, I have a counterpart NibbleWriter.cs
in the R2R compiler codebase.
Thanks
Tomas
* Remove unnecessary usings from the new NibbleReader.cs file
As an additional bit of cleanup I used the VS refactoring tool
to remove unnecessary usings from the new NibbleReader source file.
Thanks
Tomas
|
|
|
|
unneeded flags
|
