Optimize typeof(T).IsValueType

src/coreclr/src/jit/importer.cpp

@@ -4015,6 +4015,36 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
                 break;
             }
 
+            case NI_System_Type_get_IsValueType:
+            {
+                // Optimize
+                //
+                //   call Type.GetTypeFromHandle (which is replaced with CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE)
+                //   call Type.IsValueType
+                //
+                // to `true` or `false`
+                // e.g. `typeof(int).IsValueType` => `true`
+                if (impStackTop().val->IsCall())
+                {
+                    GenTreeCall* call = impStackTop().val->AsCall();
+                    if (call->gtCallMethHnd == eeFindHelper(CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE))
+                    {
+                        CORINFO_CLASS_HANDLE hClass = gtGetHelperArgClassHandle(call->gtCallArgs->GetNode());
+                        if (hClass != NO_CLASS_HANDLE)
+                        {
+                            retNode =
+                                gtNewIconNode((eeIsValueClass(hClass) &&
+                                               // pointers are not value types (e.g. typeof(int*).IsValueType is false)
+                                               info.compCompHnd->asCorInfoType(hClass) != CORINFO_TYPE_PTR)
+                                                  ? 1
+                                                  : 0);
+                            impPopStack(); // drop CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE call
+                        }
+                    }
+                }
+                break;
+            }
+
 #ifdef FEATURE_HW_INTRINSICS
             case NI_System_Math_FusedMultiplyAdd:
             case NI_System_MathF_FusedMultiplyAdd:
@@ -4306,6 +4336,13 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
                 result = NI_System_GC_KeepAlive;
             }
         }
+        else if (strcmp(className, "Type") == 0)
+        {
+            if (strcmp(methodName, "get_IsValueType") == 0)
+            {
+                result = NI_System_Type_get_IsValueType;
+            }
+        }
     }
 #if defined(_TARGET_XARCH_) // We currently only support BSWAP on x86
     else if (strcmp(namespaceName, "System.Buffers.Binary") == 0)

src/coreclr/src/jit/namedintrinsiclist.h

@@ -19,6 +19,7 @@ enum NamedIntrinsic : unsigned short
     NI_System_Collections_Generic_EqualityComparer_get_Default,
     NI_System_Buffers_Binary_BinaryPrimitives_ReverseEndianness,
     NI_System_GC_KeepAlive,
+    NI_System_Type_get_IsValueType,
 
 #ifdef FEATURE_HW_INTRINSICS
     NI_IsSupported_True,

src/coreclr/tests/src/JIT/Intrinsics/TypeIntrinsics.cs

@@ -0,0 +1,177 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+
+public class Program
+{
+    private static int _errors = 0;
+
+    public static int Main(string[] args)
+    {
+        IsTrue (typeof(byte).IsValueType);
+        IsTrue (typeof(int).IsValueType);
+        IsTrue (typeof(int?).IsValueType);
+        IsFalse(typeof(int*).IsValueType);
+        IsFalse(typeof(int**).IsValueType);
+        IsFalse(typeof(void*).IsValueType);
+        IsFalse(typeof(void**).IsValueType);
+        IsFalse(typeof(GenericStruct<int>*).IsValueType);
+        IsTrue (typeof(IntPtr).IsValueType);
+        IsTrue (typeof(decimal).IsValueType);
+        IsTrue (typeof(double).IsValueType);
+        IsFalse(typeof(string).IsValueType);
+        IsFalse(typeof(object).IsValueType);
+        IsFalse(typeof(object[]).IsValueType);
+        IsFalse(typeof(int[]).IsValueType);
+        IsFalse(typeof(int[,,]).IsValueType);
+        IsFalse(typeof(IEnumerable<int>).IsValueType);
+        IsFalse(typeof(Action<int>).IsValueType);
+        IsTrue (typeof(GenericStruct<int>).IsValueType);
+        IsTrue (typeof(GenericStruct<string>).IsValueType);
+        IsTrue (typeof(GenericStruct<string>).IsValueType);
+        IsTrue (typeof(KeyValuePair<int, string>).IsValueType);
+        IsTrue (typeof(KeyValuePair<Program, string>).IsValueType);
+        IsTrue (typeof(SimpleEnum).IsValueType);
+        IsTrue (typeof(void).IsValueType);
+        IsFalse(typeof(ValueType).IsValueType);
+        IsFalse(typeof(List<>).IsValueType);
+        IsFalse(typeof(IDictionary<,>).IsValueType);
+        IsTrue (typeof(Vector128<>).IsValueType);
+        IsTrue (typeof(Vector128<byte>).IsValueType);
+
+        // Test __Canon
+        IsFalse(IsValueType<IEnumerable<int>>());
+        IsFalse(IsValueType<IEnumerable<string>>());
+        IsFalse(IsValueType<IEnumerable<IDisposable>>());
+        IsFalse(IsValueType<IDictionary<int, string>>());
+        IsFalse(IsValueType<IDictionary<IConvertible, IComparer<int>>>());
+        IsFalse(IsValueType<Dictionary<int, int>>());
+        IsFalse(IsValueType<Dictionary<string, IEnumerable>>());
+
+        // Test `x.GetType().IsX`
+        IsTrue (IsValueType<int>(42));
+        IsTrue (IsValueType<int?>(new Nullable<int>(42)));
+        IsTrue (IsValueType<decimal>(42M));
+        IsFalse(IsValueType<string>("42"));
+        IsFalse(IsValueType<object>(new object()));
+        IsFalse(IsValueType<IEnumerable<int>>(new int[10]));
+        IsFalse(IsValueType<Action<int>>(_ => { }));
+        IsTrue (IsValueType<GenericStruct<int>>(default));
+        IsTrue (IsValueType<GenericStruct<string>>(default));
+        IsTrue (IsValueType(SimpleEnum.B));
+        IsTrue (IsValueType(CreateDynamic1()));
+        IsFalse(IsValueType(CreateDynamic2()));
+
+        IsTrue (IsValueTypeObj(42));
+        IsTrue (IsValueTypeObj(new Nullable<int>(42)));
+        IsTrue (IsValueTypeObj(42M));
+        IsFalse(IsValueTypeObj("42"));
+        IsFalse(IsValueTypeObj(new object()));
+        IsFalse(IsValueTypeObj(new int[10]));
+        IsFalse(IsValueTypeObj((Action<int>)(_ => { })));
+        IsTrue (IsValueTypeObj(new GenericStruct<int>()));
+        IsTrue (IsValueTypeObj(new GenericStruct<string>()));
+        IsTrue (IsValueTypeObj(SimpleEnum.B));
+        IsTrue (IsValueTypeObj(CreateDynamic1()));
+        IsFalse(IsValueTypeObj(CreateDynamic2()));
+
+        IsTrue (IsValueTypeRef(ref _varInt));
+        IsTrue (IsValueTypeRef(ref _varNullableInt));
+        IsTrue (IsValueTypeRef(ref _varDecimal));
+        IsFalse(IsValueTypeRef(ref _varString));
+        IsFalse(IsValueTypeRef(ref _varObject));
+        IsFalse(IsValueTypeRef(ref _varArrayOfInt));
+        IsFalse(IsValueTypeRef(ref _varAction));
+        IsTrue (IsValueTypeRef(ref _varGenericStructInt));
+        IsTrue (IsValueTypeRef(ref _varGenericStructStr));
+        IsTrue (IsValueTypeRef(ref _varEnum));
+
+        ThrowsNRE(() => { IsValueType(_varNullableIntNull); });
+        ThrowsNRE(() => { IsValueType(_varStringNull); });
+        ThrowsNRE(() => { IsValueTypeRef(ref _varNullableIntNull); });
+        ThrowsNRE(() => { IsValueTypeRef(ref _varStringNull); });
+
+        return 100 + _errors;
+    }
+
+    private static int _varInt = 42;
+    private static int? _varNullableInt = 42;
+    private static decimal _varDecimal = 42M;
+    private static string _varString = "42";
+    private static object _varObject = new object();
+    private static int[] _varArrayOfInt = new int[10];
+    private static Action<int> _varAction = _ => { };
+    private static GenericStruct<int> _varGenericStructInt = new GenericStruct<int> { field = 42 };
+    private static GenericStruct<string> _varGenericStructStr = new GenericStruct<string> { field = "42" };
+    private static SimpleEnum _varEnum = SimpleEnum.B;
+
+    private static int? _varNullableIntNull = null;
+    private static string _varStringNull = null;
+
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static bool IsValueType<T>() => typeof(T).IsValueType;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool IsValueType<T>(T val) => val.GetType().IsValueType;
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static bool IsValueTypeRef<T>(ref T val) => val.GetType().IsValueType;
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static bool IsValueTypeObj(object val) => val.GetType().IsValueType;
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static dynamic CreateDynamic1() => 42;
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static dynamic CreateDynamic2() => new { Name = "Test" };
+
+
+    static void IsTrue(bool expression, [CallerLineNumber] int line = 0)
+    {
+        if (!expression)
+        {
+            Console.WriteLine($"Line {line}: test failed (expected: true).");
+            _errors++;
+        }
+    }
+
+    static void IsFalse(bool expression, [CallerLineNumber] int line = 0)
+    {
+        if (expression)
+        {
+            Console.WriteLine($"Line {line}: test failed (expected: false).");
+            _errors++;
+        }
+    }
+
+    static void ThrowsNRE(Action action, [CallerLineNumber] int line = 0)
+    {
+        try
+        {
+            action();
+        }
+        catch (NullReferenceException)
+        {
+            return;
+        }
+        catch (Exception exc)
+        {
+            Console.WriteLine($"Line {line}: {exc}");
+        }
+        Console.WriteLine($"Line {line}: test failed (expected: NullReferenceException)");
+    }
+}
+
+public struct GenericStruct<T>
+{
+    public T field;
+}
+
+public enum SimpleEnum
+{
+    A,B,C
+}

src/coreclr/tests/src/JIT/Intrinsics/TypeIntrinsics_il.il

@@ -0,0 +1,47 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+.assembly extern mscorlib { }
+
+.assembly TypeIntrinsicsTests
+{
+  .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) 
+}
+
+.class private auto ansi beforefieldinit Test
+       extends [mscorlib]System.Object
+{
+  .method private hidebysig static int32 Main() cil managed
+  {
+    .entrypoint
+    .maxstack  1
+    // it's not currently possible to produce `ldtoken string&` in C#
+    ldtoken    [System.Runtime]System.String&
+    call       class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle)
+    call       instance bool [System.Runtime]System.Type::get_IsValueType()
+    brtrue     FAILED
+
+    ldtoken    [System.Runtime]System.Int16&
+    call       class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle)
+    call       instance bool [System.Runtime]System.Type::get_IsValueType()
+    brfalse.s  FAILED
+
+    ldtoken    [System.Runtime]System.Object&
+    call       class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle)
+    call       instance bool [System.Runtime]System.Type::get_IsValueType()
+    brtrue.s   FAILED
+
+    ldtoken    [System.Runtime]System.Decimal&
+    call       class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle)
+    call       instance bool [System.Runtime]System.Type::get_IsValueType()
+    brfalse.s  FAILED
+
+    ldc.i4.s   100
+    ret
+
+FAILED:
+    ldc.i4.s   42
+    ret
+  }
+}

src/coreclr/tests/src/JIT/Intrinsics/TypeIntrinsics_il.ilproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk.IL">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <CLRTestPriority>1</CLRTestPriority>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DebugType>PdbOnly</DebugType>
+    <Optimize>True</Optimize>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="TypeIntrinsics_il.il" />
+  </ItemGroup>
+</Project>

src/coreclr/tests/src/JIT/Intrinsics/TypeIntrinsics_r.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <DebugType>None</DebugType>
+    <Optimize />
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="TypeIntrinsics.cs" />
+  </ItemGroup>
+</Project>

src/coreclr/tests/src/JIT/Intrinsics/TypeIntrinsics_ro.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <DebugType>None</DebugType>
+    <Optimize>True</Optimize>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="TypeIntrinsics.cs" />
+  </ItemGroup>
+</Project>

src/libraries/System.Private.CoreLib/src/System/Type.cs

@@ -6,6 +6,7 @@
 using System.Reflection;
 using System.Diagnostics;
 using System.Globalization;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace System
@@ -107,7 +108,7 @@ public virtual Type[] GetGenericParameterConstraints()
         protected virtual bool IsMarshalByRefImpl() => false;
         public bool IsPrimitive => IsPrimitiveImpl();
         protected abstract bool IsPrimitiveImpl();
-        public bool IsValueType => IsValueTypeImpl();
+        public bool IsValueType { [Intrinsic] get => IsValueTypeImpl(); }
         protected virtual bool IsValueTypeImpl() => IsSubclassOf(typeof(ValueType));
 
         public virtual bool IsSignatureType => false;