Don't give up on folding obj.GetType if obj can be null (#129371)

This PR:
* in vn when we call `gtGetClassHandle` to fold `obj.GetType()` into a
constant (on VN level) we shouldn't give up if `gtGetClassHandle` is
unsure about `obj` being never null
* `gtGetClassHandle` now calls `fgAddrCouldBeNull` and
`vnStore->IsKnownNonNull` for its `isNonNull` out param.

Example:

```cs
string _fld;

Type Foo() => _fld.GetType();
```
Was:
```asm
; Method Proga:Foo():System.Type:this (FullOpts)
       sub      rsp, 40
       mov      rcx, gword ptr [rcx+0x08]
       call     [System.Object:GetType():System.Type:this]
       nop
       add      rsp, 40
       ret      
```

Now:

```asm
; Method Proga:Foo():System.Type:this (FullOpts)
       mov      eax, dword ptr [rcx+0x08] ;; nullcheck
       mov      rax, 0x2BC495400E0      ; 'System.String'
       ret      
```

[diffs](MihuBot/runtime-utils#1978)

Author: EgorBo

src/coreclr/jit/gentree.cpp

@@ -21022,6 +21022,18 @@ CORINFO_CLASS_HANDLE Compiler::gtGetClassHandle(GenTree* tree, bool* pIsExact, b
         }
     }
 
+    if ((objClass != NO_CLASS_HANDLE) && !*pIsNonNull)
+    {
+        // NOTE: We probably want to incorporate vnStore->IsKnownNonNull into fgAddrCouldBeNull,
+        // but that would make fgAddrCouldBeNull's behavior phase-dependent, whereas it is
+        // actively used in various diagnostic asserts (e.g., checking for no extra flags on a tree).
+        if (!fgAddrCouldBeNull(tree) ||
+            ((vnStore != nullptr) && vnStore->IsKnownNonNull(optConservativeNormalVN(tree))))
+        {
+            *pIsNonNull = true;
+        }
+    }
+
     return objClass;
 }
 

src/coreclr/jit/valuenum.cpp

@@ -13707,13 +13707,22 @@ void Compiler::fgValueNumberIntrinsic(GenTree* tree)
         bool                 isExact   = false;
         bool                 isNonNull = false;
         CORINFO_CLASS_HANDLE cls       = gtGetClassHandle(tree->gtGetOp1(), &isExact, &isNonNull);
-        if ((cls != NO_CLASS_HANDLE) && isExact && isNonNull)
+        if ((cls != NO_CLASS_HANDLE) && isExact)
         {
             CORINFO_OBJECT_HANDLE typeObj = info.compCompHnd->getRuntimeTypePointer(cls);
             if (typeObj != nullptr)
             {
-                ValueNum handleVN   = vnStore->VNForHandle((ssize_t)typeObj, GTF_ICON_OBJ_HDL);
-                intrinsic->gtVNPair = vnStore->VNPWithExc(ValueNumPair(handleVN, handleVN), arg0VNPx);
+                ValueNum     handleVN = vnStore->VNForHandle((ssize_t)typeObj, GTF_ICON_OBJ_HDL);
+                ValueNumPair excSet   = arg0VNPx;
+                if (!isNonNull)
+                {
+                    // We know the exact type, but not that obj is non-null, so obj.GetType() may still
+                    // throw a NullReferenceException. Fold the (non-exceptional) result to the exact
+                    // runtime type handle while preserving the null check in the exception set - otherwise
+                    // the constant value would suppress the NRE (see fgValueNumberAddExceptionSetForIndirection).
+                    excSet = vnStore->VNPExcSetUnion(excSet, fgValueNumberIndirNullCheckExceptions(tree->gtGetOp1()));
+                }
+                intrinsic->gtVNPair = vnStore->VNPWithExc(ValueNumPair(handleVN, handleVN), excSet);
                 return;
             }
         }