run the TargetConstantFolding pass also at -Onone

This is important for performance diagnostics: it’s assumed that (non-generic) MemoryLayout constants do not need to create metadata at runtime. At Onone this is only guaranteed if the TargetConstantFolding pass runs.

rdar://94836837

Author: eeckstein

lib/SILOptimizer/IRGenTransforms/TargetConstantFolding.cpp

@@ -67,9 +67,6 @@ class TargetConstantFolding : public SILModuleTransform {
     // Scan all instructions in the module for constant foldable instructions.
     for (SILFunction &function : *module) {
 
-      if (!function.shouldOptimize())
-        continue;
-    
       bool changed = false;
       for (SILBasicBlock &block : function) {
         InstructionDeleter deleter;

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -978,6 +978,9 @@ SILPassPipelinePlan::getOnonePassPipeline(const SILOptions &Options) {
   P.startPipeline("Rest of Onone");
   P.addUsePrespecialized();
 
+  // Needed to fold MemoryLayout constants in performance-annotated functions.
+  P.addTargetConstantFolding();
+
   // Has only an effect if the -assume-single-thread option is specified.
   if (P.getOptions().AssumeSingleThreaded) {
     P.addAssumeSingleThreaded();

test/SILOptimizer/memory-layout.swift

@@ -0,0 +1,35 @@
+// RUN: %target-swift-frontend -experimental-performance-annotations %s -O -sil-verify-all -module-name=test -emit-sil | %FileCheck %s
+
+// Check that constant propagation of MemoryLayout is also done at -Onone to ensure that
+// no metadate is created at runtime - which would violate the performance annotation.
+
+// CHECK-LABEL: sil [no_locks] @$s4test7getSizeSiyF
+// CHECK:         [[I:%[0-9]+]] = integer_literal {{.*}}, 4
+// CHECK:         [[S:%[0-9]+]] = struct {{.*}}([[I]]
+// CHECK:         return [[S]]
+// CHECK:       } // end sil function '$s4test7getSizeSiyF'
+@_noLocks
+public func getSize() -> Int {
+  return MemoryLayout<Int32>.size
+}
+
+// CHECK-LABEL: sil [no_locks] @$s4test12getAlignmentSiyF
+// CHECK:         [[I:%[0-9]+]] = integer_literal {{.*}}, 4
+// CHECK:         [[S:%[0-9]+]] = struct {{.*}}([[I]]
+// CHECK:         return [[S]]
+// CHECK:       } // end sil function '$s4test12getAlignmentSiyF'
+@_noLocks
+public func getAlignment() -> Int {
+  return MemoryLayout<Int32>.alignment
+}
+
+// CHECK-LABEL: sil [no_locks] @$s4test9getStrideSiyF
+// CHECK:         [[I:%[0-9]+]] = integer_literal {{.*}}, 4
+// CHECK:         [[S:%[0-9]+]] = struct {{.*}}([[I]]
+// CHECK:         return [[S]]
+// CHECK:       } // end sil function '$s4test9getStrideSiyF'
+@_noLocks
+public func getStride() -> Int {
+  return MemoryLayout<Int32>.stride
+}
+

test/SILOptimizer/performance-annotations.swift

@@ -139,3 +139,12 @@ func callFuncWithMetatypeArg() {
   metatypeArg(Int.self, false)                // expected-note {{called from here}}
 }
 
+struct GenStruct<A> {
+  var a: A
+}
+
+@_noAllocation
+func memoryLayout() -> Int? {
+  return MemoryLayout<GenStruct<Int>>.size
+}
+

test/SILOptimizer/target-const-prop.swift

@@ -34,47 +34,46 @@ public func noConstantSize<T>(_ t: T.Type) -> Int {
   return MemoryLayout<T>.size
 }
 
-// Check that there is not constant propagation if optimizations are disabled.
-// This is important for the runtime check to make sure that we are comparing
+// It's important to not constant propagate here to make sure that we are comparing
 // SIL constant propagated values with IRGen values.
 
-// CHECK-LABEL: sil {{.*}} @$s4test7getSizeSiyF
-// CHECK:         builtin "sizeof"<S>
-// CHECK:       } // end sil function '$s4test7getSizeSiyF' 
+// CHECK-LABEL: sil {{.*}} @$s4test7getSizeySixmlF
+// CHECK:         builtin "sizeof"<T>
+// CHECK:       } // end sil function '$s4test7getSizeySixmlF' 
 @_optimize(none)
-func getSize() -> Int {
-  return MemoryLayout<S>.size
+func getSize<T>(_ t: T.Type) -> Int {
+  return MemoryLayout<T>.size
 }
 
-// CHECK-LABEL: sil {{.*}} @$s4test12getAlignmentSiyF
-// CHECK:         builtin "alignof"<S>
-// CHECK:       } // end sil function '$s4test12getAlignmentSiyF' 
+// CHECK-LABEL: sil {{.*}} @$s4test12getAlignmentySixmlF
+// CHECK:         builtin "alignof"<T>
+// CHECK:       } // end sil function '$s4test12getAlignmentySixmlF' 
 @_optimize(none)
-func getAlignment() -> Int {
-  return MemoryLayout<S>.alignment
+func getAlignment<T>(_ t: T.Type) -> Int {
+  return MemoryLayout<T>.alignment
 }
 
-// CHECK-LABEL: sil {{.*}} @$s4test9getStrideSiyF
-// CHECK:         builtin "strideof"<S>
-// CHECK:       } // end sil function '$s4test9getStrideSiyF' 
+// CHECK-LABEL: sil {{.*}} @$s4test9getStrideySixmlF
+// CHECK:         builtin "strideof"<T>
+// CHECK:       } // end sil function '$s4test9getStrideySixmlF' 
 @_optimize(none)
-func getStride() -> Int {
-  return MemoryLayout<S>.stride
+func getStride<T>(_ t: T.Type) -> Int {
+  return MemoryLayout<T>.stride
 }
 
 @inline(never)
 func testit() {
   // CHECK-OUTPUT: size: true
-  print("size: \(S.size == getSize())")
+  print("size: \(S.size == getSize(S.self))")
 
   // CHECK-OUTPUT: alignment: true
-  print("alignment: \(S.alignment == getAlignment())")
+  print("alignment: \(S.alignment == getAlignment(S.self))")
 
   // CHECK-OUTPUT: stride: true
-  print("stride: \(S.stride == getStride())")
+  print("stride: \(S.stride == getStride(S.self))")
 
   // CHECK-OUTPUT: doubleSize: true
-  print("doubleSize: \(S.doubleSize == getSize() * 2)")
+  print("doubleSize: \(S.doubleSize == getSize(S.self) * 2)")
 }
 
 testit()