Enable optimization of structs

Remove many of the restrictions on structs that were added to preserve behavior of the old IR form.
Change the init block representation to not require changing the parent when a copy block is changed to an init.

1 files changed, 31 insertions, 51 deletions

diff --git a/src/jit/assertionprop.cpp b/src/jit/assertionprop.cpp
index 159aa293f4..747b032bee 100644
--- a/src/jit/assertionprop.cpp
+++ b/src/jit/assertionprop.cpp
@@ -1100,11 +1100,6 @@ Compiler::AssertionIndex Compiler::optCreateAssertion(GenTreePtr       op1,
 
                 CNS_COMMON:
                 {
-                    // TODO-1stClassStructs: handle constant propagation to struct types.
-                    if (varTypeIsStruct(lclVar))
-                    {
-                        goto DONE_ASSERTION;
-                    }
                     //
                     // Must either be an OAK_EQUAL or an OAK_NOT_EQUAL assertion
                     //
@@ -2034,12 +2029,7 @@ void Compiler::optAssertionGen(GenTreePtr tree)
     {
         case GT_ASG:
             // VN takes care of non local assertions for assignments and data flow.
-            // TODO-1stClassStructs: Enable assertion prop for struct types.
-            if (varTypeIsStruct(tree))
-            {
-                // Do nothing.
-            }
-            else if (optLocalAssertionProp)
+            if (optLocalAssertionProp)
             {
                 assertionIndex = optCreateAssertion(tree->gtOp.gtOp1, tree->gtOp.gtOp2, OAK_EQUAL);
             }
@@ -2052,26 +2042,15 @@ void Compiler::optAssertionGen(GenTreePtr tree)
         case GT_OBJ:
         case GT_BLK:
         case GT_DYN_BLK:
-            // TODO-1stClassStructs: These should always be considered to create a non-null
-            // assertion, but previously, when these indirections were implicit due to a block
-            // copy or init, they were not being considered to do so.
-            break;
         case GT_IND:
-            // TODO-1stClassStructs: All indirections should be considered to create a non-null
-            // assertion, but previously, when these indirections were implicit due to a block
-            // copy or init, they were not being considered to do so.
-            if (tree->gtType == TYP_STRUCT)
-            {
-                GenTree* parent = tree->gtGetParent(nullptr);
-                if ((parent != nullptr) && (parent->gtOper == GT_ASG))
-                {
-                    break;
-                }
-            }
         case GT_NULLCHECK:
+            // All indirections create non-null assertions
+            assertionIndex = optCreateAssertion(tree->AsIndir()->Addr(), nullptr, OAK_NOT_EQUAL);
+            break;
+
         case GT_ARR_LENGTH:
-            // An array length can create a non-null assertion
-            assertionIndex = optCreateAssertion(tree->gtOp.gtOp1, nullptr, OAK_NOT_EQUAL);
+            // An array length is an indirection (but doesn't derive from GenTreeIndir).
+            assertionIndex = optCreateAssertion(tree->AsArrLen()->ArrRef(), nullptr, OAK_NOT_EQUAL);
             break;
 
         case GT_ARR_BOUNDS_CHECK:
@@ -2629,9 +2608,29 @@ GenTreePtr Compiler::optConstantAssertionProp(AssertionDsc* curAssertion,
             else
             {
                 bool isArrIndex = ((tree->gtFlags & GTF_VAR_ARR_INDEX) != 0);
-                newTree->ChangeOperConst(GT_CNS_INT);
-                newTree->gtIntCon.gtIconVal = curAssertion->op2.u1.iconVal;
-                newTree->ClearIconHandleMask();
+                // If we have done constant propagation of a struct type, it is only valid for zero-init,
+                // and we have to ensure that we have the right zero for the type.
+                if (varTypeIsStruct(tree))
+                {
+                    assert(curAssertion->op2.u1.iconVal == 0);
+                }
+#ifdef FEATURE_SIMD
+                if (varTypeIsSIMD(tree))
+                {
+                    var_types simdType = tree->TypeGet();
+                    tree->ChangeOperConst(GT_CNS_DBL);
+                    GenTree* initVal = tree;
+                    initVal->gtType  = TYP_FLOAT;
+                    newTree =
+                        gtNewSIMDNode(simdType, initVal, nullptr, SIMDIntrinsicInit, TYP_FLOAT, genTypeSize(simdType));
+                }
+                else
+#endif // FEATURE_SIMD
+                {
+                    newTree->ChangeOperConst(GT_CNS_INT);
+                    newTree->gtIntCon.gtIconVal = curAssertion->op2.u1.iconVal;
+                    newTree->ClearIconHandleMask();
+                }
                 // If we're doing an array index address, assume any constant propagated contributes to the index.
                 if (isArrIndex)
                 {
@@ -3421,32 +3420,13 @@ GenTreePtr Compiler::optAssertionProp_Ind(ASSERT_VALARG_TP assertions, const Gen
 {
     assert(tree->OperIsIndir());
 
-    // TODO-1stClassStructs: All indirections should be handled here, but
-    // previously, when these indirections were GT_OBJ, or implicit due to a block
-    // copy or init, they were not being handled.
-    if (tree->TypeGet() == TYP_STRUCT)
-    {
-        if (tree->OperIsBlk())
-        {
-            return nullptr;
-        }
-        else
-        {
-            GenTree* parent = tree->gtGetParent(nullptr);
-            if ((parent != nullptr) && parent->OperIsBlkOp())
-            {
-                return nullptr;
-            }
-        }
-    }
-
     if (!(tree->gtFlags & GTF_EXCEPT))
     {
         return nullptr;
     }
 
     // Check for add of a constant.
-    GenTreePtr op1 = tree->gtOp.gtOp1;
+    GenTreePtr op1 = tree->AsIndir()->Addr();
     if ((op1->gtOper == GT_ADD) && (op1->gtOp.gtOp2->gtOper == GT_CNS_INT))
     {
         op1 = op1->gtOp.gtOp1;