[JitDiff X64] [EgorBo] Optimize Dictionary.FindValue for constant keys (no c ...

[MihuBot]

Job completed in 15 minutes 39 seconds (remote runner delay: 39 seconds).
dotnet/runtime#117427

Diffs

Found 83 files with textual diffs.

Summary of Code Size diffs:
(Lower is better)

Total bytes of base: 40845302
Total bytes of diff: 40845208
Total bytes of delta: -94 (-0.00 % of base)
Total relative delta: 0.58
    diff is an improvement.
    relative diff is a regression.


Total byte diff includes -127 bytes from reconciling methods
	Base had    1 unique methods,      127 unique bytes
	Diff had    0 unique methods,        0 unique bytes

Top file improvements (bytes):
         -94 : System.Private.CoreLib.dasm (-0.00 % of base)

1 total files with Code Size differences (1 improved, 0 regressed), 259 unchanged.

Top method regressions (bytes):
          23 (5.18 % of base) : System.Private.CoreLib.dasm - System.Collections.Generic.Dictionary`2[System.Numerics.Vector`1[float],System.Nullable`1[int]]:FindValue(System.Numerics.Vector`1[float]):byref:this (FullOpts)
           5 (26.32 % of base) : System.Private.CoreLib.dasm - System.Collections.Generic.NonRandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer:Equals(System.String,System.String):bool:this (FullOpts)
           5 (26.32 % of base) : System.Private.CoreLib.dasm - System.Collections.Generic.RandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer:Equals(System.String,System.String):bool:this (FullOpts)

Top method improvements (bytes):
        -127 (-100.00 % of base) : System.Private.CoreLib.dasm - System.String:EqualsOrdinalIgnoreCase(System.String,System.String):bool (FullOpts) (1 base, 0 diff methods)

Top method regressions (percentages):
           5 (26.32 % of base) : System.Private.CoreLib.dasm - System.Collections.Generic.NonRandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer:Equals(System.String,System.String):bool:this (FullOpts)
           5 (26.32 % of base) : System.Private.CoreLib.dasm - System.Collections.Generic.RandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer:Equals(System.String,System.String):bool:this (FullOpts)
          23 (5.18 % of base) : System.Private.CoreLib.dasm - System.Collections.Generic.Dictionary`2[System.Numerics.Vector`1[float],System.Nullable`1[int]]:FindValue(System.Numerics.Vector`1[float]):byref:this (FullOpts)

Top method improvements (percentages):
        -127 (-100.00 % of base) : System.Private.CoreLib.dasm - System.String:EqualsOrdinalIgnoreCase(System.String,System.String):bool (FullOpts) (1 base, 0 diff methods)

4 total methods with Code Size differences (1 improved, 3 regressed), 247909 unchanged.

--------------------------------------------------------------------------------

Artifacts:

• build-clr-checked-main.zip (88 MB)
• build-artifacts-main.zip (678 MB)
• build-clr-checked-pr.zip (88 MB)
• build-artifacts-pr.zip (679 MB)
• jit-diffs-pr.zip (136 MB)
• jit-diffs-main.zip (136 MB)
• diff-frameworks.txt (2 KB)
• ShortDiffsRegressions.md (18 KB)

[MihuBot]

Top method regressions

23 (5.18 % of base) - System.Collections.Generic.Dictionary`2[System.Numerics.Vector`1[float],System.Nullable`1[int]]:FindValue(System.Numerics.Vector`1[float]):byref:this

 ; Assembly listing for method System.Collections.Generic.Dictionary`2[System.Numerics.Vector`1[float],System.Nullable`1[int]]:FindValue(System.Numerics.Vector`1[float]):byref:this (FullOpts)
 ; Emitting BLENDED_CODE for generic X64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rbp based frame
 ; fully interruptible
 ; No PGO data
-; 0 inlinees with PGO data; 5 single block inlinees; 2 inlinees without PGO data
+; 0 inlinees with PGO data; 6 single block inlinees; 3 inlinees without PGO data
 ; Final local variable assignments
 ;
 ;  V00 this         [V00,T07] ( 10,  6.50)     ref  ->  rbx         this class-hnd single-def <System.Collections.Generic.Dictionary`2[System.Numerics.Vector`1[float],System.Nullable`1[int]]>
-;  V01 arg1         [V01    ] (  4,  5   )  simd32  ->  [rbp+0x10]  do-not-enreg[XS] addr-exposed ld-addr-op single-def <System.Numerics.Vector`1[float]>
+;  V01 arg1         [V01,T23] (  6,  9   )  simd32  ->  [rbp+0x10]  single-def <System.Numerics.Vector`1[float]>
 ;  V02 loc0         [V02,T00] (  9, 28.50)   byref  ->  r13        
 ;  V03 loc1         [V03,T15] (  3,  2   )   byref  ->  rax        
 ;  V04 loc2         [V04,T12] (  4,  3.50)     ref  ->  r15         class-hnd single-def <System.Collections.Generic.IEqualityComparer`1[System.Numerics.Vector`1[float]]>
 ;  V05 loc3         [V05,T10] (  3,  5   )     int  ->  rax        
 ;  V06 loc4         [V06,T01] (  7, 14   )     int  ->  rcx        
 ;  V07 loc5         [V07,T08] (  3,  5   )     ref  ->  rdx         class-hnd exact single-def <System.Collections.Generic.Dictionary`2+Entry[System.Numerics.Vector`1[float],System.Nullable`1[int]][]>
 ;  V08 loc6         [V08,T03] (  4, 12.50)     int  ->  rdi        
 ;  V09 loc7         [V09,T11] (  3,  5   )     int  ->  r14        
 ;  V10 loc8         [V10,T02] (  7, 14   )     int  ->  r13        
 ;  V11 loc9         [V11,T09] (  3,  5   )     ref  ->  rbx         class-hnd exact single-def <System.Collections.Generic.Dictionary`2+Entry[System.Numerics.Vector`1[float],System.Nullable`1[int]][]>
 ;  V12 loc10        [V12,T04] (  4, 12.50)     int  ->  r12        
 ;  V13 OutArgs      [V13    ] (  1,  1   )  struct (64) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <UNNAMED>
-;  V14 tmp1         [V14,T20] (  2,  1   )   byref  ->  rcx         single-def "Inline return value spill temp"
-;  V15 tmp2         [V15,T16] (  3,  1.50)     ref  ->  rcx         class-hnd single-def "Inline stloc first use temp" <int[]>
-;* V16 tmp3         [V16    ] (  0,  0   )    long  ->  zero-ref    "Inlining Arg"
-;* V17 tmp4         [V17    ] (  0,  0   )     int  ->  zero-ref    "Inlining Arg"
-;* V18 tmp5         [V18    ] (  0,  0   )   ubyte  ->  zero-ref    "Inline return value spill temp"
-;  V19 tmp6         [V19,T22] (  4, 16   )  simd32  ->  mm0         ld-addr-op "Inlining Arg" <System.Numerics.Vector`1[float]>
-;  V20 tmp7         [V20,T23] (  4, 16   )  simd32  ->  mm1         "Inlining Arg" <System.Numerics.Vector`1[float]>
-;* V21 tmp8         [V21    ] (  0,  0   )   ubyte  ->  zero-ref    "Inline return value spill temp"
-;  V22 tmp9         [V22,T21] (  2,  1   )   byref  ->  rdi         single-def "Inline return value spill temp"
-;  V23 tmp10        [V23,T17] (  3,  1.50)     ref  ->  rdi         class-hnd single-def "Inline stloc first use temp" <int[]>
-;* V24 tmp11        [V24    ] (  0,  0   )    long  ->  zero-ref    "Inlining Arg"
-;* V25 tmp12        [V25    ] (  0,  0   )     int  ->  zero-ref    "Inlining Arg"
-;  V26 tmp13        [V26,T13] (  3,  3   )     int  ->  r11         "index expr"
-;  V27 tmp14        [V27,T14] (  3,  3   )     int  ->  rdx         "index expr"
-;  V28 cse0         [V28,T18] (  3,  1.50)     int  ->  rdi         "CSE #01: moderate"
-;  V29 cse1         [V29,T19] (  3,  1.50)     int  ->  rax         "CSE #03: moderate"
-;  V30 cse2         [V30,T05] (  4,  9   )     int  ->  rsi         "CSE #02: aggressive"
-;  V31 cse3         [V31,T06] (  4,  9   )     int  ->  [rbp-0x2C]  spill-single-def "CSE #04: aggressive"
+;* V14 tmp1         [V14    ] (  0,  0   )     int  ->  zero-ref    "Inline return value spill temp"
+;  V15 tmp2         [V15    ] (  2,  2   )  simd32  ->  [rbp-0x50]  do-not-enreg[XS] addr-exposed ld-addr-op "Inlining Arg" <System.Numerics.Vector`1[float]>
+;  V16 tmp3         [V16,T20] (  2,  1   )   byref  ->  rcx         single-def "Inline return value spill temp"
+;  V17 tmp4         [V17,T16] (  3,  1.50)     ref  ->  rcx         class-hnd single-def "Inline stloc first use temp" <int[]>
+;* V18 tmp5         [V18    ] (  0,  0   )    long  ->  zero-ref    "Inlining Arg"
+;* V19 tmp6         [V19    ] (  0,  0   )     int  ->  zero-ref    "Inlining Arg"
+;* V20 tmp7         [V20    ] (  0,  0   )   ubyte  ->  zero-ref    "Inline return value spill temp"
+;  V21 tmp8         [V21,T22] (  4, 16   )  simd32  ->  mm0         ld-addr-op "Inlining Arg" <System.Numerics.Vector`1[float]>
+;* V22 tmp9         [V22    ] (  0,  0   )   ubyte  ->  zero-ref    "Inline return value spill temp"
+;  V23 tmp10        [V23,T21] (  2,  1   )   byref  ->  rdi         single-def "Inline return value spill temp"
+;  V24 tmp11        [V24,T17] (  3,  1.50)     ref  ->  rdi         class-hnd single-def "Inline stloc first use temp" <int[]>
+;* V25 tmp12        [V25    ] (  0,  0   )    long  ->  zero-ref    "Inlining Arg"
+;* V26 tmp13        [V26    ] (  0,  0   )     int  ->  zero-ref    "Inlining Arg"
+;  V27 tmp14        [V27,T13] (  3,  3   )     int  ->  r11         "index expr"
+;  V28 tmp15        [V28,T14] (  3,  3   )     int  ->  rdx         "index expr"
+;  V29 cse0         [V29,T18] (  3,  1.50)     int  ->  rdi         "CSE #01: moderate"
+;  V30 cse1         [V30,T19] (  3,  1.50)     int  ->  rax         "CSE #03: moderate"
+;  V31 cse2         [V31,T05] (  4,  9   )     int  ->  rsi         "CSE #02: aggressive"
+;  V32 cse3         [V32,T06] (  4,  9   )     int  ->  [rbp-0x54]  spill-single-def "CSE #04: aggressive"
 ;
-; Lcl frame size = 72
+; Lcl frame size = 120
 
 G_M5314_IG01:
        push     rbp
        push     r15
        push     r14
        push     r13
        push     r12
        push     rbx
-       sub      rsp, 72
-       lea      rbp, [rsp+0x70]
+       sub      rsp, 120
+       lea      rbp, [rsp+0xA0]
        mov      rbx, rdi
-						;; size=22 bbWeight=1 PerfScore 7.00
+       vmovups  ymm0, ymmword ptr [rbp+0x10]
+						;; size=30 bbWeight=1 PerfScore 11.00
 G_M5314_IG02:
        cmp      gword ptr [rbx+0x08], 0
        je       G_M5314_IG07
 						;; size=11 bbWeight=1 PerfScore 4.00
 G_M5314_IG03:
        mov      r15, gword ptr [rbx+0x18]
        test     r15, r15
        je       G_M5314_IG09
-       vmovups  ymm0, ymmword ptr [rbp+0x10]
+       vmovups  ymmword ptr [rbp+0x10], ymm0
        vmovups  ymmword ptr [rsp], ymm0
        mov      rdi, r15
        mov      r11, 0xD1FFAB1E      ; code for System.Collections.Generic.IEqualityComparer`1[System.Numerics.Vector`1[float]]:GetHashCode(System.Numerics.Vector`1[float]):int:this
        call     [r11]System.Collections.Generic.IEqualityComparer`1[System.Numerics.Vector`1[float]]:GetHashCode(System.Numerics.Vector`1[float]):int:this
        mov      r14d, eax
        mov      rdi, gword ptr [rbx+0x08]
        mov      r11d, r14d
        imul     r11, qword ptr [rbx+0x30]
        shr      r11, 32
        inc      r11
        mov      eax, dword ptr [rdi+0x08]
        mov      ecx, eax
        imul     r11, rcx
        shr      r11, 32
        cmp      r11d, eax
        jae      G_M5314_IG15
        mov      r11d, r11d
        lea      rdi, bword ptr [rdi+4*r11+0x10]
        mov      r13d, dword ptr [rdi]
        mov      rbx, gword ptr [rbx+0x10]
        xor      r12d, r12d
        dec      r13d
        mov      eax, dword ptr [rbx+0x08]
-       mov      dword ptr [rbp-0x2C], eax
+       mov      dword ptr [rbp-0x54], eax
        cmp      eax, r13d
        jbe      SHORT G_M5314_IG07
-						;; size=115 bbWeight=0.50 PerfScore 18.00
+						;; size=115 bbWeight=0.50 PerfScore 16.50
 G_M5314_IG04:
        mov      edi, r13d
        imul     rdi, rdi, 48
        lea      r13, bword ptr [rbx+rdi+0x10]
        cmp      dword ptr [r13], r14d
        jne      SHORT G_M5314_IG06
 						;; size=18 bbWeight=4 PerfScore 29.00
 G_M5314_IG05:
        vmovups  ymm0, ymmword ptr [r13+0x08]
        vmovups  ymmword ptr [rsp], ymm0
        vmovups  ymm0, ymmword ptr [rbp+0x10]
        vmovups  ymmword ptr [rsp+0x20], ymm0
        mov      rdi, r15
        mov      r11, 0xD1FFAB1E      ; code for System.Collections.Generic.IEqualityComparer`1[System.Numerics.Vector`1[float]]:Equals(System.Numerics.Vector`1[float],System.Numerics.Vector`1[float]):bool:this
        call     [r11]System.Collections.Generic.IEqualityComparer`1[System.Numerics.Vector`1[float]]:Equals(System.Numerics.Vector`1[float],System.Numerics.Vector`1[float]):bool:this
        test     eax, eax
        jne      G_M5314_IG13
 						;; size=46 bbWeight=2 PerfScore 31.50
 G_M5314_IG06:
        mov      r13d, dword ptr [r13+0x04]
        inc      r12d
-       mov      eax, dword ptr [rbp-0x2C]
+       mov      eax, dword ptr [rbp-0x54]
        cmp      eax, r12d
        jb       G_M5314_IG14
        cmp      eax, r13d
        ja       SHORT G_M5314_IG04
 						;; size=24 bbWeight=4 PerfScore 23.00
 G_M5314_IG07:
        xor      rax, rax
 						;; size=2 bbWeight=0.50 PerfScore 0.12
 G_M5314_IG08:
        vzeroupper 
-       add      rsp, 72
+       add      rsp, 120
        pop      rbx
        pop      r12
        pop      r13
        pop      r14
        pop      r15
        pop      rbp
        ret      
 						;; size=18 bbWeight=1 PerfScore 5.25
 G_M5314_IG09:
-       lea      rdi, [rbp+0x10]
+       vmovups  ymmword ptr [rbp+0x10], ymm0
+       vmovups  ymmword ptr [rbp-0x50], ymm0
+       lea      rdi, [rbp-0x50]
        mov      rax, 0xD1FFAB1E      ; code for System.Numerics.Vector`1[float]:GetHashCode():int:this
        call     [rax]System.Numerics.Vector`1[float]:GetHashCode():int:this
        mov      rcx, gword ptr [rbx+0x08]
        mov      edx, eax
        imul     rdx, qword ptr [rbx+0x30]
        shr      rdx, 32
        inc      rdx
        mov      edi, dword ptr [rcx+0x08]
        mov      esi, edi
        imul     rdx, rsi
        shr      rdx, 32
        cmp      edx, edi
        jae      G_M5314_IG15
        mov      edx, edx
        lea      rcx, bword ptr [rcx+4*rdx+0x10]
        mov      ecx, dword ptr [rcx]
        mov      rdx, gword ptr [rbx+0x10]
        xor      edi, edi
        dec      ecx
        mov      esi, dword ptr [rdx+0x08]
        cmp      esi, ecx
        ja       SHORT G_M5314_IG11
        jmp      SHORT G_M5314_IG07
        align    [0 bytes for IG10]
-						;; size=81 bbWeight=0.50 PerfScore 14.38
+						;; size=91 bbWeight=0.50 PerfScore 15.38
 G_M5314_IG10:
        mov      ecx, dword ptr [r13+0x04]
        inc      edi
        cmp      esi, edi
        jb       SHORT G_M5314_IG14
        cmp      esi, ecx
        jbe      SHORT G_M5314_IG07
 						;; size=14 bbWeight=4 PerfScore 19.00
 G_M5314_IG11:
        mov      ecx, ecx
        imul     rcx, rcx, 48
        lea      r13, bword ptr [rdx+rcx+0x10]
        cmp      dword ptr [r13], eax
        jne      SHORT G_M5314_IG10
 						;; size=17 bbWeight=4 PerfScore 29.00
 G_M5314_IG12:
        vmovups  ymm0, ymmword ptr [r13+0x08]
-       vmovups  ymm1, ymmword ptr [rbp+0x10]
-       vcmpps   ymm2, ymm0, ymm0, 0
-       vcmpps   ymm3, ymm1, ymm1, 0
-       vpternlogd ymm2, ymm3, ymm2, 17
-       vcmpps   ymm0, ymm0, ymm1, 0
-       vorps    ymm0, ymm2, ymm0
+       vcmpps   ymm1, ymm0, ymm0, 0
+       vmovups  ymm2, ymmword ptr [rbp+0x10]
+       vcmpps   ymm3, ymm2, ymm2, 0
+       vpternlogd ymm1, ymm3, ymm1, 17
+       vcmpps   ymm0, ymm0, ymm2, 0
+       vorps    ymm0, ymm1, ymm0
        vpcmpeqd ymm1, ymm1, ymm1
        vptest   ymm0, ymm1
+       vmovups  ymmword ptr [rbp+0x10], ymm2
        jae      SHORT G_M5314_IG10
-						;; size=48 bbWeight=2 PerfScore 50.67
+						;; size=53 bbWeight=2 PerfScore 52.67
 G_M5314_IG13:
        lea      rax, bword ptr [r13+0x28]
        jmp      G_M5314_IG08
 						;; size=9 bbWeight=0.50 PerfScore 1.25
 G_M5314_IG14:
        mov      rax, 0xD1FFAB1E      ; code for System.ThrowHelper:ThrowInvalidOperationException_ConcurrentOperationsNotSupported()
        call     [rax]System.ThrowHelper:ThrowInvalidOperationException_ConcurrentOperationsNotSupported()
        int3     
 						;; size=13 bbWeight=0.50 PerfScore 1.75
 G_M5314_IG15:
        call     CORINFO_HELP_RNGCHKFAIL
        int3     
 						;; size=6 bbWeight=0 PerfScore 0.00
 
-; Total bytes of code 444, prolog size 22, PerfScore 233.92, instruction count 125, allocated bytes for code 448 (MethodHash=db3deb3d) for method System.Collections.Generic.Dictionary`2[System.Numerics.Vector`1[float],System.Nullable`1[int]]:FindValue(System.Numerics.Vector`1[float]):byref:this (FullOpts)
+; Total bytes of code 467, prolog size 30, PerfScore 239.42, instruction count 129, allocated bytes for code 471 (MethodHash=db3deb3d) for method System.Collections.Generic.Dictionary`2[System.Numerics.Vector`1[float],System.Nullable`1[int]]:FindValue(System.Numerics.Vector`1[float]):byref:this (FullOpts)
 ; ============================================================

5 (26.32 % of base) - System.Collections.Generic.NonRandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer:Equals(System.String,System.String):bool:this

 ; Assembly listing for method System.Collections.Generic.NonRandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer:Equals(System.String,System.String):bool:this (FullOpts)
 ; Emitting BLENDED_CODE for generic X64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rsp based frame
 ; fully interruptible
 ; No PGO data
 ; Final local variable assignments
 ;
 ;* V00 this         [V00    ] (  0,  0   )     ref  ->  zero-ref    this class-hnd single-def <System.Collections.Generic.NonRandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer>
 ;  V01 arg1         [V01,T00] (  3,  3   )     ref  ->  rsi         class-hnd single-def <System.String>
 ;  V02 arg2         [V02,T01] (  3,  3   )     ref  ->  rdx         class-hnd single-def <System.String>
 ;# V03 OutArgs      [V03    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
 ;
 ; Lcl frame size = 0
 
 G_M21738_IG01:
 						;; size=0 bbWeight=1 PerfScore 0.00
 G_M21738_IG02:
        mov      rdi, rsi
        mov      rsi, rdx
-       mov      rax, 0xD1FFAB1E      ; code for System.String:EqualsOrdinalIgnoreCase(System.String,System.String):bool
-						;; size=16 bbWeight=1 PerfScore 0.75
+       mov      edx, 5
+       mov      rax, 0xD1FFAB1E      ; code for System.String:Equals(System.String,System.String,int):bool
+						;; size=21 bbWeight=1 PerfScore 1.00
 G_M21738_IG03:
-       tail.jmp [rax]System.String:EqualsOrdinalIgnoreCase(System.String,System.String):bool
+       tail.jmp [rax]System.String:Equals(System.String,System.String,int):bool
 						;; size=3 bbWeight=1 PerfScore 4.00
 
-; Total bytes of code 19, prolog size 0, PerfScore 4.75, instruction count 4, allocated bytes for code 19 (MethodHash=1db3ab15) for method System.Collections.Generic.NonRandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer:Equals(System.String,System.String):bool:this (FullOpts)
+; Total bytes of code 24, prolog size 0, PerfScore 5.00, instruction count 5, allocated bytes for code 24 (MethodHash=1db3ab15) for method System.Collections.Generic.NonRandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer:Equals(System.String,System.String):bool:this (FullOpts)
 ; ============================================================

5 (26.32 % of base) - System.Collections.Generic.RandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer:Equals(System.String,System.String):bool:this

 ; Assembly listing for method System.Collections.Generic.RandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer:Equals(System.String,System.String):bool:this (FullOpts)
 ; Emitting BLENDED_CODE for generic X64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rsp based frame
 ; fully interruptible
 ; No PGO data
 ; Final local variable assignments
 ;
 ;* V00 this         [V00    ] (  0,  0   )     ref  ->  zero-ref    this class-hnd single-def <System.Collections.Generic.RandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer>
 ;  V01 arg1         [V01,T00] (  3,  3   )     ref  ->  rsi         class-hnd single-def <System.String>
 ;  V02 arg2         [V02,T01] (  3,  3   )     ref  ->  rdx         class-hnd single-def <System.String>
 ;# V03 OutArgs      [V03    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
 ;
 ; Lcl frame size = 0
 
 G_M43717_IG01:
 						;; size=0 bbWeight=1 PerfScore 0.00
 G_M43717_IG02:
        mov      rdi, rsi
        mov      rsi, rdx
-       mov      rax, 0xD1FFAB1E      ; code for System.String:EqualsOrdinalIgnoreCase(System.String,System.String):bool
-						;; size=16 bbWeight=1 PerfScore 0.75
+       mov      edx, 5
+       mov      rax, 0xD1FFAB1E      ; code for System.String:Equals(System.String,System.String,int):bool
+						;; size=21 bbWeight=1 PerfScore 1.00
 G_M43717_IG03:
-       tail.jmp [rax]System.String:EqualsOrdinalIgnoreCase(System.String,System.String):bool
+       tail.jmp [rax]System.String:Equals(System.String,System.String,int):bool
 						;; size=3 bbWeight=1 PerfScore 4.00
 
-; Total bytes of code 19, prolog size 0, PerfScore 4.75, instruction count 4, allocated bytes for code 19 (MethodHash=1cd7553a) for method System.Collections.Generic.RandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer:Equals(System.String,System.String):bool:this (FullOpts)
+; Total bytes of code 24, prolog size 0, PerfScore 5.00, instruction count 5, allocated bytes for code 24 (MethodHash=1cd7553a) for method System.Collections.Generic.RandomizedStringEqualityComparer+OrdinalIgnoreCaseComparer:Equals(System.String,System.String):bool:this (FullOpts)
 ; ============================================================

[MihuBot]

@EgorBo