[constant-folding] Visit struct, tuple when we initialize our worklist as well as when we are processing the worklist.

This simplifies the IR and eliminates in a certain sense "constant information"
from the IR by allowing us to remove extract, nominal literal round trips.

NOTE: I had to modify the pound_assert test slightly on the location of a note
that it emits. The reason that I did this is that the test output is technically
correct. The instruction we are interpreting when we error is (after this
commit), a debug_value in the prelude of the function (and thus has the new
location). I am going to talk with Ravi and others on what to do with this.

Author: gottesmm

lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -1526,55 +1526,71 @@ constantFoldGlobalStringTablePointerBuiltin(BuiltinInst *bi,
 }
 
 /// Initialize the worklist to all of the constant instructions.
-void ConstantFolder::initializeWorklist(SILFunction &F) {
-  for (auto &BB : F) {
-    for (auto &I : BB) {
+void ConstantFolder::initializeWorklist(SILFunction &f) {
+  for (auto &block : f) {
+    for (auto ii = block.begin(), ie = block.end(); ii != ie; ) {
+      auto *inst = &*ii;
+      ++ii;
+
+      // TODO: Eliminate trivially dead instructions here.
+
       // If `I` is a floating-point literal instruction where the literal is
       // inf, it means the input has a literal that overflows even
       // MaxBuiltinFloatType. Diagnose this error, but allow this instruction
       // to be folded, if needed.
-      if (auto floatLit = dyn_cast<FloatLiteralInst>(&I)) {
+      if (auto *floatLit = dyn_cast<FloatLiteralInst>(inst)) {
         APFloat fpVal = floatLit->getValue();
         if (EnableDiagnostics && fpVal.isInfinity()) {
           SmallString<10> litStr;
           tryExtractLiteralText(floatLit, litStr);
-          diagnose(I.getModule().getASTContext(), I.getLoc().getSourceLoc(),
+          diagnose(inst->getModule().getASTContext(), inst->getLoc().getSourceLoc(),
                    diag::warning_float_overflows_maxbuiltin, litStr,
                    fpVal.isNegative());
         }
       }
 
-      if (isFoldable(&I) && I.hasUsesOfAnyResult()) {
-        WorkList.insert(&I);
+      if (isFoldable(inst) && inst->hasUsesOfAnyResult()) {
+        WorkList.insert(inst);
         continue;
       }
 
       // - Should we replace calls to assert_configuration by the assert
       // configuration and fold calls to any cond_unreachable.
       if (AssertConfiguration != SILOptions::DisableReplacement &&
-          (isApplyOfBuiltin(I, BuiltinValueKind::AssertConf) ||
-           isApplyOfBuiltin(I, BuiltinValueKind::CondUnreachable))) {
-        WorkList.insert(&I);
+          (isApplyOfBuiltin(*inst, BuiltinValueKind::AssertConf) ||
+           isApplyOfBuiltin(*inst, BuiltinValueKind::CondUnreachable))) {
+        WorkList.insert(inst);
+        continue;
+      }
+
+      if (isApplyOfBuiltin(*inst, BuiltinValueKind::GlobalStringTablePointer)) {
+        WorkList.insert(inst);
         continue;
       }
 
-      if (isApplyOfBuiltin(I, BuiltinValueKind::GlobalStringTablePointer)) {
-        WorkList.insert(&I);
+      if (isa<CheckedCastBranchInst>(inst) ||
+          isa<CheckedCastAddrBranchInst>(inst) ||
+          isa<UnconditionalCheckedCastInst>(inst) ||
+          isa<UnconditionalCheckedCastAddrInst>(inst)) {
+        WorkList.insert(inst);
         continue;
       }
 
-      if (isa<CheckedCastBranchInst>(&I) ||
-          isa<CheckedCastAddrBranchInst>(&I) ||
-          isa<UnconditionalCheckedCastInst>(&I) ||
-          isa<UnconditionalCheckedCastAddrInst>(&I)) {
-        WorkList.insert(&I);
+      if (isApplyOfStringConcat(*inst)) {
+        WorkList.insert(inst);
         continue;
       }
 
-      if (!isApplyOfStringConcat(I)) {
+      // If we have nominal type literals like struct, tuple, enum visit them
+      // like we do in the worklist to see if we can fold any projection
+      // manipulation operations.
+      if (isa<StructInst>(inst) || isa<TupleInst>(inst)) {
+        // TODO: Enum.
+        WorkList.insert(inst);
         continue;
       }
-      WorkList.insert(&I);
+
+      // ...
     }
   }
 }

test/SILOptimizer/constant_propagation.sil

@@ -1004,3 +1004,23 @@ bb0(%0 : $Builtin.Int1):
   %9999 = tuple()
   return %9999 : $()
 }
+
+// CHECK-LABEL: sil @simplify_struct_test : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+// CHECK-NOT: struct
+// CHECK: } // end sil function 'simplify_struct_test'
+sil @simplify_struct_test : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+  %1 = struct $Int64 (%0 : $Builtin.Int64)
+  %2 = struct_extract %1 : $Int64, #Int64.value
+  return %2 : $Builtin.Int64
+}
+
+// CHECK-LABEL: sil @simplify_tuple_test : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+// CHECK-NOT: tuple
+// CHECK: } // end sil function 'simplify_tuple_test'
+sil @simplify_tuple_test : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+  %1 = tuple(%0 : $Builtin.Int64, %0 : $Builtin.Int64)
+  %2 = tuple_extract %1 : $(Builtin.Int64, Builtin.Int64), 0
+  return %2 : $Builtin.Int64
+}

test/SILOptimizer/pound_assert.swift

@@ -67,8 +67,9 @@ func test_loops() {
   #assert(infiniteLoop() == 1)
 }
 
-func recursive(a: Int) -> Int {
-   // expected-note@+1 {{limit exceeded here}}
+// NOTE: We currently hit the limit of 512 on a debug_value in the prelude of
+// this function. TODO: What is the right thing to do here?
+func recursive(a: Int) -> Int {  // expected-note {{limit exceeded here}}
   return a == 0 ? 0 : recursive(a: a-1)
 }