JIT: Expand recognition of struct field offset pattern (#122297)

The JIT has an optimization to recognize recomputations of field
offsets, but this optimization failed to trigger in certain cases when
the struct was promoted with old promotion.

```csharp
public unsafe nint Test()
{
    MyStruct dummy;
    return (nint)((byte*)&dummy.Field - (byte*)&dummy);
}

private struct MyStruct
{
    public int A;
    public int Field;
}
```
Before:
```asm
G_M27992_IG01:  ;; offset=0x0000
       push     rax
       xor      eax, eax
       mov      qword ptr [rsp], rax
						;; size=7 bbWeight=1 PerfScore 2.25

G_M27992_IG02:  ;; offset=0x0007
       lea      rax, [rsp+0x04]
       lea      rcx, [rsp]
       sub      rax, rcx
						;; size=12 bbWeight=1 PerfScore 1.25

G_M27992_IG03:  ;; offset=0x0013
       add      rsp, 8
       ret
						;; size=5 bbWeight=1 PerfScore 1.25
```
After:
```asm
G_M27992_IG02:  ;; offset=0x0000
       mov      eax, 4
						;; size=5 bbWeight=1 PerfScore 0.25

G_M27992_IG03:  ;; offset=0x0005
       ret
						;; size=1 bbWeight=1 PerfScore 1.00
```

Author: jakobbotsch

src/coreclr/jit/lclmorph.cpp

@@ -1142,21 +1142,43 @@ class LocalAddressVisitor final : public GenTreeVisitor<LocalAddressVisitor>
             {
                 Value& rhs = TopValue(0);
                 Value& lhs = TopValue(1);
-                if (m_compiler->opts.OptimizationEnabled() && lhs.IsAddress() && rhs.IsAddress() &&
-                    (lhs.LclNum() == rhs.LclNum()) && (rhs.Offset() <= lhs.Offset()) &&
-                    FitsIn<int>(lhs.Offset() - rhs.Offset()))
+                if (m_compiler->opts.OptimizationEnabled() && lhs.IsAddress() && rhs.IsAddress())
                 {
-                    // TODO-Bug: Due to inlining we may end up with incorrectly typed SUB trees here.
-                    assert(node->TypeIs(TYP_I_IMPL, TYP_BYREF));
+                    LclVarDsc* lhsDsc = m_compiler->lvaGetDesc(lhs.LclNum());
+                    LclVarDsc* rhsDsc = m_compiler->lvaGetDesc(rhs.LclNum());
 
-                    ssize_t result = (ssize_t)(lhs.Offset() - rhs.Offset());
-                    node->BashToConst(result, TYP_I_IMPL);
-                    INDEBUG(lhs.Consume());
-                    INDEBUG(rhs.Consume());
-                    PopValue();
-                    PopValue();
-                    m_stmtModified = true;
-                    break;
+                    unsigned lhsLclNum = lhs.LclNum();
+                    unsigned rhsLclNum = rhs.LclNum();
+
+                    unsigned lhsOffset = lhs.Offset();
+                    unsigned rhsOffset = rhs.Offset();
+
+                    if (lhsDsc->lvIsStructField)
+                    {
+                        lhsLclNum = lhsDsc->lvParentLcl;
+                        lhsOffset += lhsDsc->lvFldOffset;
+                    }
+
+                    if (rhsDsc->lvIsStructField)
+                    {
+                        rhsLclNum = rhsDsc->lvParentLcl;
+                        rhsOffset += rhsDsc->lvFldOffset;
+                    }
+
+                    if ((lhsLclNum == rhsLclNum) && (rhsOffset <= lhsOffset) && FitsIn<int>(lhsOffset - rhsOffset))
+                    {
+                        // TODO-Bug: Due to inlining we may end up with incorrectly typed SUB trees here.
+                        assert(node->TypeIs(TYP_I_IMPL, TYP_BYREF));
+
+                        ssize_t result = (ssize_t)(lhsOffset - rhsOffset);
+                        node->BashToConst(result, TYP_I_IMPL);
+                        INDEBUG(lhs.Consume());
+                        INDEBUG(rhs.Consume());
+                        PopValue();
+                        PopValue();
+                        m_stmtModified = true;
+                        break;
+                    }
                 }
 
                 EscapeValue(TopValue(0), node);