diff --git a/src/jit/compiler.h b/src/jit/compiler.h
index 5cca1a404fe3..c51a8c69d9a9 100644
--- a/src/jit/compiler.h
+++ b/src/jit/compiler.h
@@ -9569,14 +9569,6 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
             return false;
         }
 
-        if (indir->gtOp1->OperIs(GT_INDEX_ADDR))
-        {
-            GenTreeIndexAddr* const indexAddr = indir->gtOp1->AsIndexAddr();
-            *arrayInfo = ArrayInfo(indexAddr->gtElemType, indexAddr->gtElemSize, indexAddr->gtElemOffset,
-                                   indexAddr->gtStructElemClass);
-            return true;
-        }
-
         bool found = GetArrayInfoMap()->Lookup(indir, arrayInfo);
         assert(found);
         return true;
diff --git a/src/jit/gentree.cpp b/src/jit/gentree.cpp
index cc0eca617067..4a6910454316 100644
--- a/src/jit/gentree.cpp
+++ b/src/jit/gentree.cpp
@@ -245,7 +245,7 @@ void GenTree::InitNodeSize()
     GenTree::s_gtNodeSizes[GT_FTN_ADDR]         = TREE_NODE_SZ_LARGE;
     GenTree::s_gtNodeSizes[GT_BOX]              = TREE_NODE_SZ_LARGE;
     GenTree::s_gtNodeSizes[GT_INDEX]            = TREE_NODE_SZ_LARGE;
-    GenTree::s_gtNodeSizes[GT_INDEX_ADDR]       = TREE_NODE_SZ_LARGE;
+    GenTree::s_gtNodeSizes[GT_INDEX_ADDR] = TREE_NODE_SZ_LARGE;
     GenTree::s_gtNodeSizes[GT_ARR_BOUNDS_CHECK] = TREE_NODE_SZ_LARGE;
 #ifdef FEATURE_SIMD
     GenTree::s_gtNodeSizes[GT_SIMD_CHK] = TREE_NODE_SZ_LARGE;
@@ -7038,9 +7038,8 @@ GenTree* Compiler::gtCloneExpr(
                 GenTreeIndexAddr* asIndAddr = tree->AsIndexAddr();
 
                 copy = new (this, GT_INDEX_ADDR)
-                    GenTreeIndexAddr(asIndAddr->Arr(), asIndAddr->Index(), asIndAddr->gtElemType,
-                                     asIndAddr->gtStructElemClass, asIndAddr->gtElemSize, asIndAddr->gtLenOffset,
-                                     asIndAddr->gtElemOffset);
+                    GenTreeIndexAddr(asIndAddr->Arr(), asIndAddr->Index(), asIndAddr->gtElemType, asIndAddr->gtElemSize,
+                                     asIndAddr->gtLenOffset, asIndAddr->gtElemOffset);
                 copy->AsIndexAddr()->gtIndRngFailBB = asIndAddr->gtIndRngFailBB;
             }
             break;
@@ -16426,9 +16425,6 @@ CORINFO_CLASS_HANDLE Compiler::gtGetStructHandleIfPresent(GenTree* tree)
             case GT_INDEX:
                 structHnd = tree->gtIndex.gtStructElemClass;
                 break;
-            case GT_INDEX_ADDR:
-                structHnd = tree->AsIndexAddr()->gtStructElemClass;
-                break;
             case GT_FIELD:
                 info.compCompHnd->getFieldType(tree->gtField.gtFldHnd, &structHnd);
                 break;
@@ -16450,8 +16446,14 @@ CORINFO_CLASS_HANDLE Compiler::gtGetStructHandleIfPresent(GenTree* tree)
                 structHnd = gtGetStructHandleIfPresent(tree->gtOp.gtOp1);
                 break;
             case GT_IND:
+                if (tree->AsIndir()->Addr()->OperIs(GT_INDEX_ADDR))
+                {
+                    // There's no way to recover the handle from a IND(GT_INDEX_ADDR) tree and
+                    // that should not be needed.
+                }
+                else
 #ifdef FEATURE_SIMD
-                if (varTypeIsSIMD(tree))
+                    if (varTypeIsSIMD(tree))
                 {
                     structHnd = gtGetStructHandleForSIMD(tree->gtType, TYP_FLOAT);
 #ifdef FEATURE_HW_INTRINSICS
diff --git a/src/jit/gentree.h b/src/jit/gentree.h
index 0142a7724b25..f7b93540991c 100644
--- a/src/jit/gentree.h
+++ b/src/jit/gentree.h
@@ -4321,8 +4321,6 @@ struct GenTreeIndexAddr : public GenTreeOp
         return gtOp2;
     }
 
-    CORINFO_CLASS_HANDLE gtStructElemClass; // If the element type is a struct, this is the struct type.
-
     BasicBlock* gtIndRngFailBB; // Basic block to jump to for array-index-out-of-range
 
     var_types gtElemType;   // The element type of the array.
@@ -4330,15 +4328,9 @@ struct GenTreeIndexAddr : public GenTreeOp
     unsigned  gtLenOffset;  // The offset from the array's base address to its length.
     unsigned  gtElemOffset; // The offset from the array's base address to its first element.
 
-    GenTreeIndexAddr(GenTree*             arr,
-                     GenTree*             ind,
-                     var_types            elemType,
-                     CORINFO_CLASS_HANDLE structElemClass,
-                     unsigned             elemSize,
-                     unsigned             lenOffset,
-                     unsigned             elemOffset)
+    GenTreeIndexAddr(
+        GenTree* arr, GenTree* ind, var_types elemType, unsigned elemSize, unsigned lenOffset, unsigned elemOffset)
         : GenTreeOp(GT_INDEX_ADDR, TYP_BYREF, arr, ind)
-        , gtStructElemClass(structElemClass)
         , gtIndRngFailBB(nullptr)
         , gtElemType(elemType)
         , gtElemSize(elemSize)
diff --git a/src/jit/morph.cpp b/src/jit/morph.cpp
index 9579d13d12f1..49265b504c1e 100644
--- a/src/jit/morph.cpp
+++ b/src/jit/morph.cpp
@@ -5656,8 +5656,8 @@ GenTree* Compiler::fgMorphArrayIndex(GenTree* tree)
         GenTree* const index = fgMorphTree(asIndex->Index());
 
         GenTreeIndexAddr* const indexAddr =
-            new (this, GT_INDEX_ADDR) GenTreeIndexAddr(array, index, elemTyp, elemStructType, elemSize,
-                                                       static_cast<unsigned>(lenOffs), static_cast<unsigned>(elemOffs));
+            new (this, GT_INDEX_ADDR) GenTreeIndexAddr(array, index, elemTyp, elemSize, static_cast<unsigned>(lenOffs),
+                                                       static_cast<unsigned>(elemOffs));
         indexAddr->gtFlags |= (array->gtFlags | index->gtFlags) & GTF_ALL_EFFECT;
 
         // Mark the indirection node as needing a range check if necessary.
@@ -5667,15 +5667,21 @@ GenTree* Compiler::fgMorphArrayIndex(GenTree* tree)
             fgSetRngChkTarget(indexAddr);
         }
 
-        // Change `tree` into an indirection and return.
-        tree->ChangeOper(GT_IND);
+        if (elemStructType == NO_CLASS_HANDLE)
+        {
+            tree->ChangeOper(GT_IND);
+        }
+        else
+        {
+            tree->ChangeOper(GT_OBJ);
+            tree->AsObj()->SetLayout(typGetObjLayout(elemStructType));
+        }
+
         GenTreeIndir* const indir = tree->AsIndir();
         indir->Addr()             = indexAddr;
-        indir->gtFlags            = GTF_IND_ARR_INDEX | (indexAddr->gtFlags & GTF_ALL_EFFECT);
+        indir->gtFlags            = indexAddr->gtFlags & GTF_ALL_EFFECT;
 
-#ifdef DEBUG
-        indexAddr->gtDebugFlags |= GTF_DEBUG_NODE_MORPHED;
-#endif // DEBUG
+        INDEBUG(indexAddr->gtDebugFlags |= GTF_DEBUG_NODE_MORPHED;)
 
         return indir;
     }