[mandatory-combine] Just like SILCombine, perform SIL canonicialization while performing mandatory combining.

Author: gottesmm

lib/SILOptimizer/Mandatory/MandatoryCombine.cpp

@@ -31,6 +31,7 @@
 #include "swift/SIL/SILVisitor.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "swift/SILOptimizer/Utils/CanonicalizeInstruction.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
 #include "swift/SILOptimizer/Utils/StackNesting.h"
 #include "llvm/ADT/STLExtras.h"
@@ -53,6 +54,54 @@ static bool areAllValuesTrivial(Values values, SILFunction &function) {
   });
 }
 
+//===----------------------------------------------------------------------===//
+//      CanonicalizeInstruction subclass for use in Mandatory Combiner.
+//===----------------------------------------------------------------------===//
+
+namespace {
+
+class MandatoryCombineCanonicalize final : CanonicalizeInstruction {
+public:
+  using Worklist = SmallSILInstructionWorklist<256>;
+
+private:
+  Worklist &worklist;
+  bool changed = false;
+
+public:
+  MandatoryCombineCanonicalize(Worklist &worklist)
+      : CanonicalizeInstruction(DEBUG_TYPE), worklist(worklist) {}
+
+  void notifyNewInstruction(SILInstruction *inst) override {
+    worklist.add(inst);
+    worklist.addUsersOfAllResultsToWorklist(inst);
+    changed = true;
+  }
+
+  // Just delete the given 'inst' and record its operands. The callback isn't
+  // allowed to mutate any other instructions.
+  void killInstruction(SILInstruction *inst) override {
+    worklist.eraseSingleInstFromFunction(*inst,
+                                         /*AddOperandsToWorklist*/ true);
+    changed = true;
+  }
+
+  void notifyHasNewUsers(SILValue value) override {
+    if (worklist.size() < 10000) {
+      worklist.addUsersToWorklist(value);
+    }
+    changed = true;
+  }
+
+  bool tryCanonicalize(SILInstruction *inst) {
+    changed = false;
+    canonicalize(inst);
+    return changed;
+  }
+};
+
+} // anonymous namespace
+
 //===----------------------------------------------------------------------===//
 //                        MandatoryCombiner Interface
 //===----------------------------------------------------------------------===//
@@ -177,13 +226,19 @@ bool MandatoryCombiner::doOneIteration(SILFunction &function,
   madeChange = false;
 
   addReachableCodeToWorklist(function);
+  MandatoryCombineCanonicalize mcCanonicialize(worklist);
 
   while (!worklist.isEmpty()) {
     auto *instruction = worklist.pop_back_val();
     if (instruction == nullptr) {
       continue;
     }
 
+    if (mcCanonicialize.tryCanonicalize(instruction)) {
+      madeChange = true;
+      continue;
+    }
+
 #ifndef NDEBUG
     std::string instructionDescription;
 #endif

test/SILGen/addressors.swift

@@ -1,4 +1,3 @@
-
 // RUN: %target-swift-emit-sil -parse-stdlib %s | %FileCheck %s
 // RUN: %target-swift-emit-silgen -parse-stdlib %s | %FileCheck %s -check-prefix=SILGEN
 // RUN: %target-swift-emit-ir -parse-stdlib %s
@@ -60,7 +59,8 @@ func test0() {
 // CHECK: [[T2:%.*]] = struct_extract [[T1]] : $UnsafePointer<Int32>, #UnsafePointer._rawValue
 // CHECK: [[T3:%.*]] = pointer_to_address [[T2]] : $Builtin.RawPointer to [strict] $*Int32
 // CHECK: [[ACCESS:%.*]] = begin_access [read] [unsafe] [[T3]] : $*Int32
-// CHECK: [[Z:%.*]] = load [[ACCESS]] : $*Int32
+// CHECK: [[ACCESS_GEP:%.*]] = struct_element_addr [[ACCESS]]
+// CHECK: [[Z:%.*]] = load [[ACCESS_GEP]]
   let z = a[10]
 
 // CHECK: [[WRITE:%.*]] = begin_access [modify] [static] [[A]] : $*A
@@ -106,8 +106,8 @@ var global: Int32 {
   }
 // CHECK-LABEL: sil hidden @$s10addressors6globals5Int32Vvlu : $@convention(thin) () -> UnsafePointer<Int32> {
 // CHECK:   [[T0:%.*]] = global_addr @$s10addressors10uninitAddrSpys5Int32VGvp : $*UnsafeMutablePointer<Int32>
-// CHECK:   [[T1:%.*]] = load [[T0]] : $*UnsafeMutablePointer<Int32>
-// CHECK:   [[T2:%.*]] = struct_extract [[T1]] : $UnsafeMutablePointer<Int32>, #UnsafeMutablePointer._rawValue
+// CHECK:   [[T1:%.*]] = struct_element_addr [[T0]]
+// CHECK:   [[T2:%.*]] = load [[T1]]
 // CHECK:   [[T3:%.*]] = struct $UnsafePointer<Int32> ([[T2]] : $Builtin.RawPointer)
 // CHECK:   return [[T3]] : $UnsafePointer<Int32>
 }

test/SILGen/unmanaged.swift

@@ -24,7 +24,8 @@ func set(holder holder: inout Holder) {
 // CHECK-NEXT:   [[WRITE:%.*]] = begin_access [modify] [static] [[ADDR]] : $*Holder
 // CHECK-NEXT:   [[T0:%.*]] = struct_element_addr [[WRITE]] : $*Holder, #Holder.value
 // CHECK-NEXT:   [[T1:%.*]] = ref_to_unmanaged [[C]]
-// CHECK-NEXT:   store [[T1]] to [[T0]]
+// CHECK-NEXT:   [[T2:%.*]] = struct $Holder ([[T1]] : $@sil_unmanaged C)
+// CHECK-NEXT:   store [[T2]] to [[WRITE]]
 // CHECK-NEXT:   strong_release [[C]]
 // CHECK-NEXT:   end_access [[WRITE]] : $*Holder
 // CHECK-NEXT:   tuple ()

test/SILOptimizer/mandatory_combiner.sil

@@ -918,3 +918,15 @@ bb0(%0 : @guaranteed $Klass, %1 : @guaranteed $Klass, %2 : @guaranteed $Klass):
   %9999 = tuple ()
   return %9999 : $()
 }
+
+// CHECK-LABEL: sil [ossa] @eliminate_simple_arc_traffic : $@convention(thin) (@guaranteed Klass) -> () {
+// CHECK-NOT: copy_value
+// CHECK-NOT: destroy_value
+// CHECK: } // end sil function 'eliminate_simple_arc_traffic'
+sil [ossa] @eliminate_simple_arc_traffic : $@convention(thin) (@guaranteed Klass) -> () {
+bb0(%0 : @guaranteed $Klass):
+  %1 = copy_value %0 : $Klass
+  destroy_value %1 : $Klass
+  %9999 = tuple()
+  return %9999 : $()
+}

test/stdlib/Inputs/CommonArrayTests.gyb

@@ -5,6 +5,9 @@
 % #   - Suite -- an identifier for the test suite to append tests to.
 % #   - ArrayType -- the type being tested.
 
+// We use this global array to prevent ARC from eliminating temporary ARC
+// traffic in nonUniqueCode below. It is only ever assigned to.
+var globalArrayForNonUnique = ${ArrayType}<Int>()
 
 extension ${ArrayType} {
   typealias _BufferID = UnsafeRawPointer?
@@ -107,7 +110,7 @@ ${Suite}.test("${ArrayType}/appendNonUnique")
   x.reserveCapacity(10002)
   let capacity = x.capacity
   for _ in 1...100 {
-    let y = x
+    globalArrayForNonUnique = x
     x.append(1)
     expectTrue(x.capacity == capacity)
   }
@@ -120,7 +123,7 @@ ${Suite}.test("${ArrayType}/removeNonUnique")
     var x = ${ArrayType}<Int>(repeating: 27, count: 200)
     x.reserveCapacity(10002)
     for _ in 1...100 {
-      let y = x
+      globalArrayForNonUnique = x
       x.remove(at: 0)
       expectTrue(x.capacity < 1000)
     }
@@ -133,7 +136,7 @@ ${Suite}.test("${ArrayType}/mutateNonUnique")
   var x = ${ArrayType}<Int>(repeating: 27, count: 200)
   x.reserveCapacity(10002)
   for _ in 1...100 {
-    let y = x
+    globalArrayForNonUnique = x
     x[0] = 0
     expectTrue(x.capacity < 1000)
   }