diff --git a/docs/design/features/byreflike-generics.md b/docs/design/features/byreflike-generics.md index d529f18f140df..4bccfa85ef1b1 100644 --- a/docs/design/features/byreflike-generics.md +++ b/docs/design/features/byreflike-generics.md @@ -7,22 +7,26 @@ Using ByRefLike types in Generic parameters is possible by building upon support ## Runtime impact -Supporting ByRefLike type as Generic parameters will impact the following IL instructions: +Supporting ByRefLike types as Generic parameters will impact the following IL instructions. -- `box` – Types with ByRefLike parameters used in fields cannot be boxed. +The `constrained. callvirt` sequence is valid if a ByRefLike type is provided. A `NotSupportedException` will be thrown at the call-site, if the target resolves to a method implemented on `object` or a default interface method. + +Throws `InvalidProgramException` when passed a ByRefLike type: +- `box` – ByRefLike types cannot be allocated on the heap. + +Throws `TypeLoadException` when passed a ByRefLike type: - `stsfld` / `ldsfld` – Type fields of a ByRefLike parameter cannot be marked `static`. - `newarr` / `stelem` / `ldelem` / `ldelema` – Arrays are not able to contain ByRefLike types. - `newobj` – For multi-dimensional array construction. -- `constrained.callvirt` – If this IL sequence resolves to a method implemented on `object` or default interface method, an error will occur during the attempt to box the instance. - -If any of the above instructions are attempted to be used with a ByRefLike type, the runtime will throw an `InvalidProgramException`. Sequences involving some of the above instructions are considered optimizations and represent cases that will remain valid regardless of a `T` being ByRefLike. See "Special IL Sequences" section below for details. The following instructions are already set up to support this feature since their behavior will fail as currently defined due to the inability to box a ByRefLike type. -- `throw` – Requires an object reference to be on stack, which can never be a ByRefLike type. -- `unbox` / `unbox.any` – Requires an object reference to be on stack, which can never be a ByRefLike type. -- `isinst` – Will always place `null` on stack. -- `castclass` – Will always throw `InvalidCastException`. +- `throw` +- `unbox` / `unbox.any` +- `isinst` +- `castclass` + +**NOTE** There are sequences involving some of the above instructions that may remain valid regardless of a `T` being ByRefLike—see ["Options for invalid IL" section](#invalid_il_options) below for details. The expansion of ByRefLike types as Generic parameters does not relax restrictions on where ByRefLike types can be used. When `T` is ByRefLike, the use of `T` as a field will require the enclosing type to be ByRefLike. @@ -110,23 +114,123 @@ throw Adding `gpAcceptByRefLike` to the metadata of a Generic parameter will be considered a non-breaking binary change. -Enumerating of constructors/methods on `Span` and `ReadOnlySpan` may throw `TypeLoadException` if `T` is a ByRefLike type. See "Troublesome APIs" above for the list of APIs that cause this condition. +Enumerating of constructors/methods on `Span` and `ReadOnlySpan` may throw `TypeLoadException` if `T` is a ByRefLike type. See "Troublesome API mitigation" above for the list of APIs that cause this condition. + +## Options for invalid IL + +There are two potential options below for how to address this issue. Based on communication with the Roslyn team, option (1) is the current plan of record for .NET 10. + +The first indented IL sequences below represents the `is-type` sequence. Combining the first with the second indented section represents the "type pattern matching" scenario in C#. The below sequence performs a type check and then, if successful, consumes the unboxed instance. + +```IL +// Type check +ldarg.0 + box + isinst + brfalse.s NOT_INST + +// Unbox and store unboxed instance +ldarg.0 + box + isinst + unbox.any +stloc.X + +NOT_INST: +ret +``` + +With the above IL composition implemented, the following C# describes the following "type pattern matching" scenarios and what one might expect given current C# semantics. + +```csharp +struct S {} +struct S {} +ref struct RS {} +ref struct RS {} +interface I {} +class C {} +class C {} + +// Not currently valid C# +void M(T t) where T: allows ref struct +{ + // Valid + if (t is int i) + + if (t is S s) + if (t is S sc) + if (t is S su) + + if (t is RS rs) + if (t is RS rsc) + if (t is RS rsu) + + if (t is string str) + if (t is C c) + if (t is C ci) + if (t is C cu) + + // Can be made to work in IL. + if (t is I itf) // A new local "I" would not be used for ByRefLike scenarios. + // The local would be the ByRefLike type, not "I". + + // Invalid + if (t is object o) // ByRefLike types evaluate "true" for object. + if (t is U u) +} +``` + +### Option 1) Compiler helpers + +The following two helper functions could be introduced and would replace currently invalid `is-type` IL sequences when ByRefLike types are involved. Their behavior would broadly be defined to operate as if the ByRefLike aspect of either the `TFrom` and `TTo` is not present. An alternative approach would be consult with the Roslyn team and define the semantics of these functions to adhere to C# language rules. + +```csharp +namespace System.Runtime.CompilerServices +{ + public static class RuntimeHelpers + { + // Replacement for the [box; isinst; brfalse/true] sequence. + public static bool IsInstanceOf(TFrom source) + where TFrom: allows ref struct + where TTo: allows ref struct; + + // Replacement for the [box; isinst; unbox.any] sequence. + // Would throw InvalidCastException for invalid use at run-time. + // For example: + // TFrom: RS, TTo: object => always throws + // TFrom: RS, TTo: => always throws + public static TTo CastTo(TFrom source) + where TFrom: allows ref struct + where TTo: allows ref struct; + } +} +``` + +Example usage of the above methods. + +```csharp +TTo result; +if (RuntimeHelpers.IsInstanceOf(source)) +{ + result = RuntimeHelpers.CastTo(source); +} +``` -## Special IL Sequences +### Option 2) Special IL sequences -The following are IL sequences involving the `box` instruction. They are used for common C# language constructs and shall continue to be valid, even with ByRefLike types, in cases where the result can be computed at JIT time and elided safely. These sequences must now be elided when the target type is ByRefLike. The conditions where each sequence is elided are described below and each condition will be added to the ECMA-335 addendum. +The following are IL sequences involving the `box` instruction. They are used for common C# language constructs and would continue to be valid, even with ByRefLike types. These sequences would be **required** to be valid when the target type is ByRefLike. Each sequence would be added to the ECMA-335 addendum. -`box` ; `unbox.any` – The box target type is equal to the unboxed target type. +`box` ; `isinst` ; `br_true/false` – Passing a ByRefLike type as the argument to the `box` instruction is permitted to accomplish a type check, in C# `x is Y`. **Note** ByRefLike types would evaluate to `true` when compared against `System.Object`. -`box` ; `br_true/false` – The box target type is non-`Nullable`. +`box` ; `isinst` ; `unbox.any` – In order to permit "type pattern matching", in C# `x is Y y`, this sequence will permit use of a ByRefLike type on any instruction, but does not permit the use of generic parameters being exposed to `isinst` or `unbox.any`. -`box` ; `isinst` ; `unbox.any` – The box, `isint`, and unbox target types are all equal. +`box` ; `unbox.any` – Valid to use ByRefLike types. -`box` ; `isinst` ; `br_true/false` – The box target type is equal to the unboxed target type or the box target type is `Nullable` and target type equalities can be computed. +`box` ; `br_true/false` – Valid to use ByRefLike types. ## Examples -Below are valid and invalid examples of ByRefLike as Generic parameters. All examples use the **not official** syntax, `allows ref struct`, for indicating the Generic permits ByRefLike types. +Below are currently (.NET 9) valid and invalid examples of ByRefLike as Generic parameters. **1) Valid** ```csharp diff --git a/docs/design/specs/Ecma-335-Augments.md b/docs/design/specs/Ecma-335-Augments.md index f6b8f9b964eff..fd8a0fd93ca87 100644 --- a/docs/design/specs/Ecma-335-Augments.md +++ b/docs/design/specs/Ecma-335-Augments.md @@ -14,7 +14,8 @@ This is a list of additions and edits to be made in ECMA-335 specifications. It - [Covariant Return Types](#covariant-return-types) - [Function Pointer Type Identity](#function-pointer-type-identity) - [Unsigned data conversion with overflow detection](#unsigned-data-conversion-with-overflow-detection) -- [Ref field support](#ref-fields) +- [Ref fields support](#ref-fields) +- [ByRefLike types in generics](#byreflike-generics) - [Rules for IL rewriters](#rules-for-il-rewriters) - [Checked user-defined operators](#checked-user-defined-operators) - [Atomic reads and writes](#atomic-reads-and-writes) @@ -1026,6 +1027,31 @@ Changes to signatures: - Add a bullet point - Managed pointers which point at null, the address just past the end of an object, or the address where an element just past the end of an array would be stored, are permitted but not dereferenceable. +## ByRefLike types in generics + +ByRefLike types, defined in C# with the `ref struct` syntax, represent types that cannot escape to the managed heap and must remain on the stack. It is possible for these types to be used as generic parameters, but in order to improve utility certain affordances are required. + +### II.10.1.7 +An additional IL keyword, `byreflike`, is introduced to indicate use of ByRefLike types is permitted. This expands the set of permissible types used by this parameters, but limits the potential instructions that can be used on instances of this generic parameter type. + +### II.23.1.7 +Update the `SpecialConstraintMask` flag value and description, and add a new flag, `AllowByRefLike`. + +| Flag | Value | Description | +| --- | ----- | ----------- | +| `SpecialConstraintMask` | `0x3C` | These 4 bits contain one of the following values: | +| ... | ... | ... | +| `AllowByRefLike` | `0x20` | The generic parameter is allowed to be ByRefLike | + +### III.2.1 +The following case is added as the **third** cases in the "if _thisType_" sequence. + +> If _thisType_ is ByRefLike and _thisType_ does not implement _method_ then; a `NotSupportedException` is thrown at the callsite. + +The following is added to the paragraph starting with "This last case can only occur when _method_ was defined on `System.Object`, `System.ValueType`, or `System.Enum`". + +> The third case can only occur when _method_ was defined on `System.Object` or is a Default Interface Method. + ## Rules for IL Rewriters There are apis such as `System.Runtime.CompilerServices.RuntimeHelpers.CreateSpan(...)` which require that the PE file have a particular structure. In particular, that api requires that the associated RVA of a FieldDef which is used to create a span must be naturally aligned over the data type that `CreateSpan` is instantiated over. There are 2 major concerns. diff --git a/src/coreclr/inc/corinfo.h b/src/coreclr/inc/corinfo.h index 7333b15c7d5df..abc9eacef0b85 100644 --- a/src/coreclr/inc/corinfo.h +++ b/src/coreclr/inc/corinfo.h @@ -2402,7 +2402,7 @@ class ICorStaticInfo virtual size_t getClassThreadStaticDynamicInfo ( CORINFO_CLASS_HANDLE cls ) = 0; - + virtual bool getStaticBaseAddress( CORINFO_CLASS_HANDLE cls, bool isGc, diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/TypeCast.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/TypeCast.cs index 742c5092674b6..c3f92d067dd24 100644 --- a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/TypeCast.cs +++ b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/TypeCast.cs @@ -414,10 +414,10 @@ public static unsafe object CheckCastClass(MethodTable* pTargetType, object obj) [RuntimeExport("RhTypeCast_CheckCastClassSpecial")] private static unsafe object CheckCastClassSpecial(MethodTable* pTargetType, object obj) { - Debug.Assert(!pTargetType->IsParameterizedType, "CheckCastClass called with parameterized MethodTable"); - Debug.Assert(!pTargetType->IsFunctionPointer, "CheckCastClass called with function pointer MethodTable"); - Debug.Assert(!pTargetType->IsInterface, "CheckCastClass called with interface MethodTable"); - Debug.Assert(!pTargetType->HasGenericVariance, "CheckCastClass with variant MethodTable"); + Debug.Assert(!pTargetType->IsParameterizedType, "CheckCastClassSpecial called with parameterized MethodTable"); + Debug.Assert(!pTargetType->IsFunctionPointer, "CheckCastClassSpecial called with function pointer MethodTable"); + Debug.Assert(!pTargetType->IsInterface, "CheckCastClassSpecial called with interface MethodTable"); + Debug.Assert(!pTargetType->HasGenericVariance, "CheckCastClassSpecial with variant MethodTable"); MethodTable* mt = obj.GetMethodTable(); Debug.Assert(mt != pTargetType, "The check for the trivial cases should be inlined by the JIT"); diff --git a/src/tests/Loader/classloader/generics/ByRefLike/InvalidCSharp.il b/src/tests/Loader/classloader/generics/ByRefLike/InvalidCSharp.il index 02a9037ca10ae..1bfb367c6d000 100644 --- a/src/tests/Loader/classloader/generics/ByRefLike/InvalidCSharp.il +++ b/src/tests/Loader/classloader/generics/ByRefLike/InvalidCSharp.il @@ -93,14 +93,6 @@ ret } - .method public hidebysig - instance object BoxAsObject(!T) cil managed - { - ldarg.1 - box !T - ret - } - .method public hidebysig instance bool BoxUnboxAny(!T) cil managed { @@ -230,7 +222,7 @@ // Begin sequence box !T isinst ByRefLikeType - unbox.any !T + unbox.any ByRefLikeType // End sequence pop ldc.i4.1 @@ -334,22 +326,27 @@ } .method public hidebysig - instance bool BoxIsinstBranch_UsingTypeConstraints(class InvalidCSharp.EmptyInterface) cil managed + instance bool BoxIsinstBranch_CheckForSimpleInterface(!!U) cil managed { .locals init ( [0] !!U ) + ldarg.1 - isinst !!U - brfalse.s NOT_U + box !!U + isinst InvalidCSharp.SimpleInterface + brtrue.s IS_SIMPLEINTERFACE + + ldstr "All types should implement SimpleInterface" + newobj instance void [System.Runtime]System.Exception::.ctor(string) + throw + + IS_SIMPLEINTERFACE: ldarg.1 - isinst !!U - unbox.any !!U stloc.0 - ldc.i4.0 - ret - NOT_U: - ldc.i4.1 + ldloca.s 0 + constrained. !!U + callvirt instance int32 InvalidCSharp.SimpleInterface::Method() ret } @@ -363,17 +360,6 @@ ret } - .method public hidebysig - instance bool AllocMultiDimArrayOfT() cil managed - { - ldc.i4.1 - ldc.i4.1 - newobj instance void !T[0..., 0...]::.ctor(int32, int32) - ldnull - cgt.un - ret - } - .method public hidebysig instance bool InstanceOfT( object o @@ -465,17 +451,71 @@ ) } -.class interface public auto ansi abstract InvalidCSharp.EmptyInterface +.class public sequential ansi sealed beforefieldinit ByRefLikeType`1 + extends [System.Runtime]System.ValueType +{ + .custom instance void [System.Runtime]System.Runtime.CompilerServices.IsByRefLikeAttribute::.ctor() = ( + 01 00 00 00 + ) +} + +.class interface public auto ansi abstract InvalidCSharp.SimpleInterface +{ + .method public hidebysig newslot abstract virtual + instance int32 Method() cil managed + { + } +} + +.class public sequential ansi sealed beforefieldinit ByRefLikeTypeWithInterface + extends [System.Runtime]System.ValueType + implements InvalidCSharp.SimpleInterface +{ + .custom instance void [System.Runtime]System.Runtime.CompilerServices.IsByRefLikeAttribute::.ctor() = ( + 01 00 00 00 + ) + + .method public final hidebysig newslot virtual + instance int32 Method() cil managed + { + ldc.i4.1 + ret + } +} + +.class interface public auto ansi abstract InvalidCSharp.DefaultInterface { + .method public hidebysig newslot virtual + instance int32 Method() cil managed + { + ldc.i4.0 + ret + } +} + +.class public sequential ansi sealed beforefieldinit RS_DI1 + extends [System.Runtime]System.ValueType + implements InvalidCSharp.DefaultInterface +{ + .custom instance void [System.Runtime]System.Runtime.CompilerServices.IsByRefLikeAttribute::.ctor() = ( + 01 00 00 00 + ) } -.class public sequential ansi sealed beforefieldinit InvalidCSharp.ByRefLikeTypeWithInterface +.class public sequential ansi sealed beforefieldinit RS_DI2 extends [System.Runtime]System.ValueType - implements InvalidCSharp.EmptyInterface + implements InvalidCSharp.DefaultInterface { .custom instance void [System.Runtime]System.Runtime.CompilerServices.IsByRefLikeAttribute::.ctor() = ( 01 00 00 00 ) + + .method public hidebysig newslot virtual + instance int32 Method() cil managed + { + ldc.i4.1 + ret + } } .class public sequential ansi sealed beforefieldinit RegularValueType @@ -483,9 +523,9 @@ { } -.class public auto ansi beforefieldinit InvalidCSharp.ClassWithInterface +.class public auto ansi beforefieldinit ClassWithInterface extends [System.Runtime]System.Object - implements InvalidCSharp.EmptyInterface + implements InvalidCSharp.SimpleInterface { .method public hidebysig specialname rtspecialname instance void .ctor () cil managed @@ -494,6 +534,13 @@ call instance void [System.Runtime]System.Object::.ctor() ret } + + .method public final hidebysig newslot virtual + instance int32 Method() cil managed + { + ldc.i4.0 + ret + } } // Generic substitution of allow-byreflike with allow-byreflike @@ -662,14 +709,14 @@ .method public hidebysig static class [System.Runtime]System.Type GenericByRefLike_ConstraintsAreIndependent_Interface_ByRefLike_Invalid() cil managed { - newobj instance void class InvalidCSharp.GenericClass_IndependentConstraints`2::.ctor() + newobj instance void class InvalidCSharp.GenericClass_IndependentConstraints`2::.ctor() callvirt instance class [System.Runtime]System.Type [System.Runtime]System.Object::GetType() ret } .method public hidebysig static class [System.Runtime]System.Type GenericByRefLike_ConstraintsAreIndependent_ByRefLike_ByRefLike_Invalid() cil managed { - newobj instance void class InvalidCSharp.GenericClass_IndependentConstraints`2::.ctor() + newobj instance void class InvalidCSharp.GenericClass_IndependentConstraints`2::.ctor() callvirt instance class [System.Runtime]System.Type [System.Runtime]System.Object::GetType() ret } @@ -693,23 +740,15 @@ } .method public hidebysig static - object BoxAsObject() cil managed + object BoxAsObject(!!Y) cil managed noinlining { - .locals init ( - [0] valuetype InvalidCSharp.GenericByRefLike_Over`1 - ) - - ldloca.s 0 - initobj valuetype InvalidCSharp.GenericByRefLike_Over`1 - ldloca.s 0 - ldloc 0 - ldfld !0 valuetype InvalidCSharp.GenericByRefLike_Over`1::Field - call instance object valuetype InvalidCSharp.GenericByRefLike_Over`1::BoxAsObject(!0) + ldarg.0 + box !!Y ret } .method public hidebysig static - bool BoxUnboxAny() cil managed + void BoxUnboxAny() cil managed { .locals init ( [0] valuetype InvalidCSharp.GenericByRefLike_Over`1 @@ -721,15 +760,21 @@ ldloc 0 ldfld !0 valuetype InvalidCSharp.GenericByRefLike_Over`1::Field call instance bool valuetype InvalidCSharp.GenericByRefLike_Over`1::BoxUnboxAny(!0) + brtrue.s NEXT_1 + + ldstr "Failed: BoxUnboxAny for ByRefLikeType" + newobj instance void [System.Runtime]System.Exception::.ctor(string) + throw + + NEXT_1: ret } .method public hidebysig static - bool BoxBranch() cil managed + void BoxBranch() cil managed { .locals init ( - [0] valuetype InvalidCSharp.GenericByRefLike_Over`1, - [1] bool + [0] valuetype InvalidCSharp.GenericByRefLike_Over`1 ) ldloca.s 0 @@ -739,30 +784,51 @@ ldloc 0 ldfld !0 valuetype InvalidCSharp.GenericByRefLike_Over`1::Field call instance bool valuetype InvalidCSharp.GenericByRefLike_Over`1::BoxBranch(!0) - pop + brtrue.s NEXT_1 + + ldstr "Failed: BoxBranch for ByRefLikeType" + newobj instance void [System.Runtime]System.Exception::.ctor(string) + throw + NEXT_1: ldloca.s 0 ldloc 0 ldfld !0 valuetype InvalidCSharp.GenericByRefLike_Over`1::Field - call instance bool valuetype InvalidCSharp.GenericByRefLike_Over`1::BoxBranchToOther(!0) - pop + call instance bool valuetype InvalidCSharp.GenericByRefLike_Over`1::BoxBranchToOther(!0) + brtrue.s NEXT_2 + + ldstr "Failed: BoxBranchToOther for ByRefLikeTypeWithInterface" + newobj instance void [System.Runtime]System.Exception::.ctor(string) + throw + NEXT_2: ldloca.s 0 ldloc 0 ldfld !0 valuetype InvalidCSharp.GenericByRefLike_Over`1::Field call instance bool valuetype InvalidCSharp.GenericByRefLike_Over`1::BoxBranchToOther(!0) - pop + brtrue.s NEXT_3 + + ldstr "Failed: BoxBranchToOther for RegularValueType" + newobj instance void [System.Runtime]System.Exception::.ctor(string) + throw + NEXT_3: ldloca.s 0 ldloca.s 0 ldflda !0 valuetype InvalidCSharp.GenericByRefLike_Over`1::Field call instance bool valuetype InvalidCSharp.GenericByRefLike_Over`1::BoxBranch_WithSideEffects(!0&) + brtrue.s NEXT_4 + + ldstr "Failed: BoxBranch_WithSideEffects for ByRefLikeType" + newobj instance void [System.Runtime]System.Exception::.ctor(string) + throw + NEXT_4: ret } .method public hidebysig static - bool BoxIsinstUnboxAny() cil managed + void BoxIsinstUnboxAny() cil managed { .locals init ( [0] valuetype InvalidCSharp.GenericByRefLike_Over`1 @@ -774,6 +840,13 @@ ldloc 0 ldfld !0 valuetype InvalidCSharp.GenericByRefLike_Over`1::Field call instance bool valuetype InvalidCSharp.GenericByRefLike_Over`1::BoxIsinstUnboxAny(!0) + brtrue.s NEXT_1 + + ldstr "Failed: BoxIsinstUnboxAny for ByRefLikeType" + newobj instance void [System.Runtime]System.Exception::.ctor(string) + throw + + NEXT_1: ret } @@ -794,10 +867,11 @@ } .method public hidebysig static - bool BoxIsinstBranch() cil managed + void BoxIsinstBranchVarious() cil managed { .locals init ( - [0] valuetype InvalidCSharp.GenericByRefLike_Over`1 + [0] valuetype InvalidCSharp.GenericByRefLike_Over`1, + [1] valuetype ByRefLikeTypeWithInterface ) ldloca.s 0 @@ -807,48 +881,87 @@ ldloc 0 ldfld !0 valuetype InvalidCSharp.GenericByRefLike_Over`1::Field call instance bool valuetype InvalidCSharp.GenericByRefLike_Over`1::BoxIsinstBranch(!0) - pop + brtrue.s NEXT_1 + + ldstr "Failed: BoxIsinstBranch for ByRefLikeType" + newobj instance void [System.Runtime]System.Exception::.ctor(string) + throw + NEXT_1: ldloca.s 0 ldloca.s 0 ldflda !0 valuetype InvalidCSharp.GenericByRefLike_Over`1::Field call instance bool valuetype InvalidCSharp.GenericByRefLike_Over`1::BoxIsinstBranch_WithSideEffects(!0&) - pop + brtrue.s NEXT_2 + + ldstr "Failed: BoxIsinstBranch_WithSideEffects for ByRefLikeType" + newobj instance void [System.Runtime]System.Exception::.ctor(string) + throw + NEXT_2: + ldloca.s 0 + ldloca.s 1 + initobj valuetype ByRefLikeTypeWithInterface + ldloc.1 + call instance bool valuetype InvalidCSharp.GenericByRefLike_Over`1:: + BoxIsinstBranch_CheckForSimpleInterface(!!0) + brtrue.s NEXT_3 + + ldstr "Failed: BoxIsinstBranch_CheckForSimpleInterface for ByRefLikeTypeWithInterface" + newobj instance void [System.Runtime]System.Exception::.ctor(string) + throw + + NEXT_3: ldloca.s 0 - newobj instance void InvalidCSharp.ClassWithInterface::.ctor() - call instance bool valuetype InvalidCSharp.GenericByRefLike_Over`1::BoxIsinstBranch_UsingTypeConstraints(class InvalidCSharp.EmptyInterface) + newobj instance void ClassWithInterface::.ctor() + call instance bool valuetype InvalidCSharp.GenericByRefLike_Over`1:: + BoxIsinstBranch_CheckForSimpleInterface(!!0) + brfalse.s NEXT_4 + ldstr "The above is expected to be false since ClassWithInterface's interface implementation return 0." + newobj instance void [System.Runtime]System.Exception::.ctor(string) + throw + + NEXT_4: ret } .method public hidebysig static - void AllocArrayOfT_Invalid() cil managed + bool BoxIsinstBranch(!!T) cil managed noinlining { - .locals init ( - [0] valuetype InvalidCSharp.GenericByRefLike_Over`1 - ) + ldarg.0 + // Begin sequence + box !!T + isinst !!U + brfalse.s IS_FALSE + // End sequence - ldloca.s 0 - initobj valuetype InvalidCSharp.GenericByRefLike_Over`1 - ldloca.s 0 - call instance bool valuetype InvalidCSharp.GenericByRefLike_Over`1::AllocArrayOfT() - pop + ldc.i4.1 + ret + + IS_FALSE: + ldc.i4.0 ret } .method public hidebysig static - void AllocMultiDimArrayOfT_Invalid() cil managed + bool AllocArray() cil managed noinlining { - .locals init ( - [0] valuetype InvalidCSharp.GenericByRefLike_Over`1 - ) + ldc.i4.1 + newarr !!Y + ldnull + cgt.un + ret + } - ldloca.s 0 - initobj valuetype InvalidCSharp.GenericByRefLike_Over`1 - ldloca.s 0 - call instance bool valuetype InvalidCSharp.GenericByRefLike_Over`1::AllocMultiDimArrayOfT() - pop + .method public hidebysig static + bool AllocMultiDimArray() cil managed noinlining + { + ldc.i4.1 + ldc.i4.1 + newobj instance void !!Y[0..., 0...]::.ctor(int32, int32) + ldnull + cgt.un ret } @@ -861,6 +974,39 @@ ret } + .method public hidebysig static + string ConstrainedCallVirtToString(!!T t) cil managed noinlining + { + ldarga.s 0 + constrained. !!T + callvirt instance string [System.Runtime]System.Object::ToString() + ret + } + + .method public hidebysig static + int32 ConstrainedCallVirtMethod(!!T t) cil managed noinlining + { + ldarga.s 0 + constrained. !!T + callvirt instance int32 InvalidCSharp.DefaultInterface::Method() + ret + } + + .method public hidebysig static + int32 ConstrainedCallVirtMethod(!!T t, bool skipCall) cil managed noinlining + { + ldarg.1 + brfalse.s CALL + ldc.i4.m1 + ret + + CALL: + ldarga.s 0 + constrained. !!T + callvirt instance int32 InvalidCSharp.DefaultInterface::Method() + ret + } + .method public hidebysig static bool InstanceOfT(object) cil managed { diff --git a/src/tests/Loader/classloader/generics/ByRefLike/Validate.cs b/src/tests/Loader/classloader/generics/ByRefLike/Validate.cs index 280a567f2deb8..ced2fda3c95db 100644 --- a/src/tests/Loader/classloader/generics/ByRefLike/Validate.cs +++ b/src/tests/Loader/classloader/generics/ByRefLike/Validate.cs @@ -56,15 +56,67 @@ public static void Validate_Casting_Scenarios() Assert.Throws(() => { Exec.UnboxToT(new object()); }); } + interface I1 { } + + struct S {} + struct S {} + struct S_I1 : I1 {} + struct S_I1 : I1 {} + struct S_DI1 : InvalidCSharp.DefaultInterface {} + struct S_DI2 : InvalidCSharp.DefaultInterface { public int Method() => 1; } + + ref struct RS { } + ref struct RS { } + ref struct RS_I1 : I1 { } + ref struct RS_I1 : I1 { } + // ref struct RS_DI1 - See InvalidCSharp.il + // ref struct RS_DI2 - See InvalidCSharp.il + + sealed class Ignored { } + [Fact] - public static void Validate_RecognizedOpCodeSequences_Scenarios() + public static void Validate_RecognizedOpCodeSequences() { - Console.WriteLine($"{nameof(Validate_RecognizedOpCodeSequences_Scenarios)}..."); - - Assert.True(Exec.BoxUnboxAny()); - Assert.True(Exec.BoxBranch()); - Assert.True(Exec.BoxIsinstUnboxAny()); - Assert.True(Exec.BoxIsinstBranch()); + Console.WriteLine($"{nameof(Validate_RecognizedOpCodeSequences)}..."); + + Exec.BoxUnboxAny(); + Exec.BoxBranch(); + Exec.BoxIsinstUnboxAny(); + + // Exec.BoxIsinstBranchVarious(); + + Assert.True(Exec.BoxIsinstBranch(default)); + Assert.False(Exec.BoxIsinstBranch(default)); + Assert.False(Exec.BoxIsinstBranch(default)); + + Assert.True(Exec.BoxIsinstBranch(default)); + Assert.True(Exec.BoxIsinstBranch, object>(default)); + Assert.True(Exec.BoxIsinstBranch, object>(default)); + Assert.True(Exec.BoxIsinstBranch(default)); + Assert.True(Exec.BoxIsinstBranch, S>(default)); + Assert.True(Exec.BoxIsinstBranch, S>(default)); + Assert.False(Exec.BoxIsinstBranch(default)); + Assert.False(Exec.BoxIsinstBranch, I1>(default)); + Assert.False(Exec.BoxIsinstBranch, I1>(default)); + + Assert.True(Exec.BoxIsinstBranch(default)); + Assert.True(Exec.BoxIsinstBranch, object>(default)); + Assert.True(Exec.BoxIsinstBranch, object>(default)); + Assert.True(Exec.BoxIsinstBranch(default)); + Assert.True(Exec.BoxIsinstBranch, S_I1>(default)); + Assert.True(Exec.BoxIsinstBranch, S_I1>(default)); + Assert.True(Exec.BoxIsinstBranch(default)); + Assert.True(Exec.BoxIsinstBranch, I1>(default)); + Assert.True(Exec.BoxIsinstBranch, I1>(default)); + + Assert.Equal($"{nameof(Validate)}+{nameof(S)}", Exec.ConstrainedCallVirtToString(new S())); + Assert.Equal(0, Exec.ConstrainedCallVirtMethod(new S_DI1())); + Assert.Equal(1, Exec.ConstrainedCallVirtMethod(new S_DI2())); + Assert.Equal(1, Exec.ConstrainedCallVirtMethod(new RS_DI2())); + + Assert.Equal(-1, Exec.ConstrainedCallVirtMethod(new S_DI1(), skipCall: true)); + Assert.Equal(-1, Exec.ConstrainedCallVirtMethod(new S_DI2(), skipCall: true)); + Assert.Equal(-1, Exec.ConstrainedCallVirtMethod(new RS_DI2(), skipCall: true)); } [Fact] @@ -85,12 +137,18 @@ public static void Validate_InvalidOpCode_Scenarios() // These methods uses opcodes that are not able to handle ByRefLike type operands. // The TypeLoader prevents these invalid types from being constructed. We rely on // the failure to construct these invalid types to block opcode usage. - Assert.Throws(() => { Exec.AllocArrayOfT_Invalid(); }); - Assert.Throws(() => { Exec.AllocMultiDimArrayOfT_Invalid(); }); + Assert.Throws(() => { Exec.AllocArray(); }); + Assert.Throws(() => { Exec.AllocMultiDimArray(); }); Assert.Throws(() => { Exec.GenericClassWithStaticField_Invalid(); }); // Test that explicitly tries to box a ByRefLike type. - Assert.Throws(() => { Exec.BoxAsObject(); }); + Assert.Throws(() => { Exec.BoxAsObject(new RS()); }); + + // Test that implicitly tries to box a ByRefLike type. + // Assert.Throws(() => { Exec.ConstrainedCallVirtToString(new RS()); }); + // Assert.Throws(() => { Exec.ConstrainedCallVirtMethod(new RS_DI1()); }); + // Assert.Throws(() => { Exec.ConstrainedCallVirtMethod(new RS_DI1(), skipCall: false); }); + // Assert.Throws(() => { Exec.ConstrainedCallVirtMethod(new RS_DI1(), skipCall: true); }); } [Fact]