| Age | Commit message (Collapse) | Author |
|---|
|
This should take the code path that returns `ConstantReferenceValue`.
|
|
We were generating NamespaceReference hierarchy with an extra level of nesting. These are used very rarely, so we didn't notice before.
|
|
|
|
The stack trace metadata supplements reflection metadata to provide information about method names in stack traces (ex. obtained from `Exception.StackTrace` at runtime). I made the emission optional in the compiler. Enabling emission of this data increases the size of a HelloWord-style app by about 300 kB.
In this change:
* Actual emission of the data in the compiler. This is done by checking what compiled method bodies don't have reflection information and generating metadata for those.
* Making the mapping table cross platform. The Project X/N version of this emits `ADDR32NB` relocs (RVA) that are Windows-only. I'm switching to `RELPTR32` outside of N/X.
* Enabling S.P.StackTraceMetadata library initializer to run at startup to register a callback from CoreLib.
* Weakening an assert in MetadataTransfor to prevent generation of definition metadata for blocked types. We would have probably done this anyway with the work to enable poking random holes into metadata blocking.
|
|
- Pick up latest .NET Core 2.0 CLI and buildtools
- Remove all project.json references and convert everything to msbuild projects
- Stick to vanilla .NET CLI project shape as much as possible. Minimize dependencies on buildtools special behaviors
|
|
[tfs-changeset: 1662283]
|
|
The latest project templates do not have it, and it is only good for generating warnings like the following in the detailed build log:
Project file contains ToolsVersion="4.0". This toolset may be unknown or missing, in which case you may be able to resolve this by installing the appropriate version of MSBuild, or the build may have been forced to a particular ToolsVersion for policy reasons. Treating the project as if it had ToolsVersion="14.0". For more information, please see http://go.microsoft.com/fwlink/?LinkId=293424.
[tfs-changeset: 1662024]
|
|
CoreRT compiler side of 9557707d915b6c9ed497fd9b2885bafeb4d6fddc.
|
|
Reflection blocking is a size on disk optimization that prevents
generating native metadata for things that are considered
private implementation details of the runtime.
Since CoreRT is compiled ahead of time, a lot of things that
would be needed by a full VM (method names, custom attributes, etc.)
are no longer necessary at runtime. Metadata is strictly only necessary
to support reflection at runtime.
The policy I'm implementing is to consider everything private in our
implementation assemblies to be reflection blocked.
What this entails:
* Adding support for computing reflection blocked state in the compiler
* Tweak to blocking policy to allow us to express blocking state of MethodImpls
* Uncomment blocking table mapping table scanning (this broke the PInvoke test for CppCodegen and we needed a workaround)
* Opt in private assemblies to reflection blocking
|
|
object arrays
Four things:
* The actual schema update
* Update the CoreRT metadata emitter to emit the new schema
* Update the Project N metadata emitter to emit the new schema
* Update reflection codebase to read the new schema
Fixes dotnet/corert#3328.
[tfs-changeset: 1654618]
|
|
This is basically three things:
1. `ByReference<T>` support
2. General support infra in the type system for Byref-like types (to be
reused for e.g. `Span<T>`).
3. TypedReference
Fixes #367.
|
|
- UnwrapNullable, FieldOffset, VTableOffset, CallingConventionConverter
- Refactor nativelayout method signature stuff to be single instanced on MethodSignature not on MethodDesc (CallingConventionConverter path needs signature but does not have MethodDesc)
- Remaining lookups are constrained call lookup and type size lookup
- Added SupportsCanon and SupportsUniversalCanon apis to type system context
- Dependency tracking to ensure that usg vtables match vtables of all other types in the system (for both lazy and eager vtable generation processes)
- VTableOffset generic lookups inject a dependency into code which uses them
[tfs-changeset: 1651754]
|
|
The existing schema didn't allow it and we were crashing the compiler. Turns out this is popular in xUnit tests in the CoreFX tree.
Includes:
* Schema update that makes string[] more like object[] than arrays of primitive types
* Updates to both of our emitters
* Update to the reflection reader
* Unit test
[tfs-changeset: 1650932]
|
|
* Update BuildToolsVersion to latest
* Cleanup CLSCompliant warnings
* Delete workaround that is no longer needed
* Download .NET Core 1.1
* Fix Roslyn props
* MSBuild.exe was renamed to MSBuild.dll
* Fix CoreCLR tests
* Rename netcoreapp12 -> netcoreapp20
* Fix UnitTests runs
* Fix RemoveEmptyFinalizers CodeAnalysis warnings
* Port init-tools.sh cleanup from CoreCLR
|
|
|
|
* Add a few new node types used when the UTC compiler hosts ILCompiler:
`ThreadStaticsIndexNode`, `ThreadStaticsOffsetNode`, `GCStaticDescNode`,
`UtcDictionaryLayoutNode`.
* Add a UTC-specific `UtcNodeFactory`
* Various type visibility changes
|
|
This thing is useless in the VS Solution Explorer and has an annoying
warning sign.
|
|
|
|
- s/readonly static/static readonly/
- s/static internal/internal static/
- s/static private/private static/
- s/static public/public static/
- s/static protected/protected static/
- s/unsafe static/static unsafe/
- s/unsafe extern/extern unsafe/
- s/internal protected/protected internal/
|
|
|
|
Add support for representing EntryPoint and the global `<Module>` type.
Note: this does not include updates to the Project N metadata writer.
The schedule for that is TBD.
Fixes #1782.
|
|
Also:
* update `MetadataTransform` to emit the new metadata
* a simple unit test
|
|
|
|
Even though these can't be expressed in C#, we still have a bunch of test collateral that exercises them. Instead of coming up with excuses as to why we should just ignore the tests every time it shows up, I decided to just implement this.
Native metadata schema update and emission will follow later.
|
|
|
|
This is actually a simple change, but touches a lot of files.
ECMA-335 allows placing custom modifiers on element types of vectors and unmanaged pointers, but the native metadata format didn't allow it. I'm fixing that. As part of the fix, I'm getting rid of the ReturnTypeSignature and ParameterTypeSignature records. Their only purpose was to allow putting a modifier on types. Instead, I'm introducing a ModifiedType record type that can show up in many places where TypeDefOrRefOrSpec does. This way, we're not paying a 1 byte penalty just to say "this parameter has no modifiers".
I'm not emitting the modifiers in either transform since there's nobody who would consume them. I'm doing this because besides fixing correctness, this also has a size/perf benefit - makes SharedLibrary.dll 10 kB smaller.
[tfs-changeset: 1622393]
|
|
This makes signature variables easier to handle in various double
dispatch scenarios.
|
|
The motivation for this change is:
* To make the type name formatter general purpose (it can now handle
`NoMetadata` types)
* To make `NameMangler` able to mangle canon types and runtime
determined types without special casing
For situation where we have a NoMetadataType, the expectation is that
we're asking for the name for diagnostic purposes only (i.e. name
formatter wants it). In that case:
* In checked builds, the name can actually be retrieved from diagnostic
mapping tables, along with the owning type (we have a metadata TypeRef
for this).
* In the absence of diagnostic mapping tables, the name can be faked up
and the type pretended to be non-nested
("System.Runtime.NoMetadataTypes.EEType1234ABCD")
As an additional change, I'm also adding `Name` property on
`GenericParameterDesc`. We can compute a useful fallback value for this
in absence of metadata ("T" + index).
|
|
request - here's the checkin comment for that changeset:
Fix TODO in InitializeFieldDefinition - this caused incorrect field offsets in explicit layout types.
While investigating JIT test failures (jit\SIMD\BoxUnbox.csproj and jit\SIMD\VectorMatrix.csproj) I found that the dynamic type loader computes an incorrect size for structs with explicit layout. As it turns out, the native metadata is already wrong and doesn't contain the field offset specified in the source via the FieldOffset attribute (and present in EMCA metadata).
The fix is simply to get the offset from the ECMA metadata reader. That API however returns -1 for the case where no explicit offset was specified, so that needs to be checked for.
[tfs-changeset: 1617255]
|
|
|
|
[tfs-changeset: 1609348]
|
|
with null value.
[tfs-changeset: 1609323]
|
|
- implementation only for ECMA metadata as we don't have TypeSystem api surface that is general purpose enough to avoid using the ECMA metadata reader directly
- metadata transform tests for generic and non-generic scenarios
|
|
* Add support for ExplicitScopeAttribute to metadata generation
- Add new IMetadataPolicy member to control the defining module of a type
- Added mixin implementation that works for ExplicitScopeAttribute
- Added WinRT explicit scope defined types in both the primary metadata assembly and same metadata assembly
- Added single file and multi file tests to ensure that both definition and reference to these relocated types is correct
- New tests implemented in seperate assemblies to reduce impact on existing unittests
- Fix handling of throwIfNotFound parameter in ResolveAssembly in TestTypeSystemContext
|
|
Introduce distinction between modules and assemblies
|
|
|
|
Add ubuntu.14.04-x64 and osx.10.10-x64 to list of supported runtimes.
|
|
This version has the "make ILPROJ project buildable from VS" fix.
|
|
- Switch over to using standardized init-tools script used by other repos
- Update to recent buildtools
- Switch to running msbuild against CoreCLR instead of mono
- Make build scripts to be otherwise more similar to the ones used by other repos
|
|
|
|
|
|
Merge changes from TFS
|
|
Merge changes from TFS
|
|
[tfs-changeset: 1595273]
|
|
|
|
HandleQualifiedField; relax some assertions in HandleFieldReference to support fields on instantiated types; fix field reference to store uninstantiated signature; update the HandleQualifiedField code comment in MetadataTransform.cs to mention the new record type.
[tfs-changeset: 1595205]
|
|
HandleQualifiedField is bad too (no such thing as a FieldReference), but that one will likely go away in ProjNDev2, so I'm not touching it.
[tfs-changeset: 1594622]
|
|
While a PublicKey is a valid representation in a reference, its rarely/never desireable. PublicKeyTokens are all that are expected to be present during assembly resolution, and thus resolution algorithms ignore the extra data encoded in a PublicKey as opposed to a PublicKeyToken, and actually must perform conversion to a PublicKeyToken to function which can be costly.
|
|
LINQ Select operator uses generic virtual methods, which is both an
overkill, and prevents us from selfhosting the compiler.
Replacing all of LINQ with a lighter weight implementation for good
measure.
|
|
Drop xunit.netcore.extensions from test projects
|
