JIT: Fold more always failing type checks

[jakobbotsch]

Folding x isinst B where x is statically of type A is currently done via a call to compareTypesForCast. If it returns TypeCompareState::Must then we know that A can be cast to B, which also means any class derived from A can be cast to B, so we can always fold that. However, if it returns TypeCompareState::MustNot we only learn something if we know x is exactly A; otherwise, if x is more derived than A, it could still potentially be cast to B.

In cases where the type hierarchies are disjoint, however, we can still know that some type checks will fail. To detect the case add a query in the opposite direction; that is, if B cannot be cast to A, then the type hierarchies are disjoint, so in that case we can fold it, regardless of having exact knowledge. This also requires some explicit checks for interface types, but perhaps we can move those to the EE side.

Fix #97000

[MethodImpl(MethodImplOptions.NoInlining)]
static bool Test(List<int> x) => Foo(x);

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static bool Foo<TSource>(IEnumerable<TSource> x) => x is TSource[];

Before:

G_M10367_IG01:  ;; offset=0x0000
       4883EC28             sub      rsp, 40
						;; size=4 bbWeight=1 PerfScore 0.25

G_M10367_IG02:  ;; offset=0x0004
       488BD1               mov      rdx, rcx
       48B9E88DCCB6FB7F0000 mov      rcx, 0x7FFBB6CC8DE8      ; int[]
       E8EAF6165E           call     CORINFO_HELP_ISINSTANCEOFARRAY
       4885C0               test     rax, rax
       0F95C0               setne    al
       0FB6C0               movzx    rax, al
						;; size=27 bbWeight=1 PerfScore 3.00

G_M10367_IG03:  ;; offset=0x001F
       4883C428             add      rsp, 40
       C3                   ret      
						;; size=5 bbWeight=1 PerfScore 1.25
; Total bytes of code: 36

After:

G_M10367_IG02:  ;; offset=0x0000
       33C0                 xor      eax, eax
						;; size=2 bbWeight=1 PerfScore 0.25

G_M10367_IG03:  ;; offset=0x0002
       C3                   ret      
						;; size=1 bbWeight=1 PerfScore 1.00
; Total bytes of code: 3

[ghost]

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

Issue Details

---

Folding x isinst B where x is statically of type A is currently done via a call to compareTypesForCast. If it returns TypeCompareState::Must then we know that A can be cast to B, which also means any class derived from A can be cast to B, so we can always fold that. However, if it returns TypeCompareState::MustNot we only learn something if we know x is exactly A; otherwise, if x is more derived than A, it could still potentially be cast to B.

In cases where the type hierarchies are distinct, however, we can still know that some type checks will fail. To detect the case add a query in the opposite direction; that is, if B cannot be cast to A, then the type hierarchies are distinct, so in that case we can fold it, regardless of having exact knowledge. This also requires some explicit checks for interface types, but perhaps we can move those to the EE side.

Fix #97000

Author:	jakobbotsch
Assignees:	-
Labels:	area-CodeGen-coreclr
Milestone:	-

[jakobbotsch]

@jkotas do you think it makes sense to change this in compareTypesForCast? From what I understand, the current semantics of compareTypesForCast is "if I have an object of exact type A, can it be cast to type B" -- which is a meaningless question when A is an interface type. Alternatively, do you have any suggestions on better ways to check what we're after here?

[jakobbotsch]

Hmm, looks like we fold Type.IsAssignableFrom/Type.IsAssignableTo using compareTypesForCast as well, so seems like we cannot really change its behavior.

[jkotas]

do you think it makes sense to change this in compareTypesForCast?

Yes, I think this logic should be better done on the EE side.

looks like we fold Type.IsAssignableFrom/Type.IsAssignableTo using compareTypesForCast as well, so seems like we cannot really change its behavior.

You can add a flag to the compareTypesForCast or add a new JIT/EE interface method.

[jakobbotsch]

@MihuBot

[jakobbotsch]

/azp run runtime-coreclr superpmi-diffs

[azure-pipelines]

Azure Pipelines successfully started running 1 pipeline(s).

[jakobbotsch]

Diffs after a collection on this branch. Pretty minor overall and mostly in tests. Doesn't seem worth the throughput cost or complexity of changing the JIT-EE interface.