Move TargetConstantFolding pass to the simplification passes in Swift, enable using MemoryLayout's .size, .stride, .alignment fields in forced-const global initializers

Author: kubamracek

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift

@@ -28,6 +28,10 @@ extension BuiltinInst : OnoneSimplifyable {
         optimizeCanBeClass(context)
       case .AssertConf:
         optimizeAssertConfig(context)
+      case .Sizeof,
+           .Strideof,
+           .Alignof:
+        optimizeTargetTypeConst(context)
       default:
         if let literal = constantFold(context) {
           uses.replaceAll(with: literal, context)
@@ -131,6 +135,33 @@ private extension BuiltinInst {
     uses.replaceAll(with: literal, context)
     context.erase(instruction: self)
   }
+  
+  func optimizeTargetTypeConst(_ context: SimplifyContext) {
+    guard let ty = substitutionMap.replacementTypes[0] else {
+      return
+    }
+    
+    let value: Int?
+    switch id {
+    case .Sizeof:
+      value = ty.getStaticSize(context: context)
+    case .Strideof:
+      value = ty.getStaticStride(context: context)
+    case .Alignof:
+      value = ty.getStaticAlignment(context: context)
+    default:
+      fatalError()
+    }
+    
+    guard let value else {
+      return
+    }
+    
+    let builder = Builder(before: self, context)
+    let literal = builder.createIntegerLiteral(value, type: type)
+    uses.replaceAll(with: literal, context)
+    context.erase(instruction: self)
+  }
 }
 
 private func hasSideEffectForBuiltinOnce(_ instruction: Instruction) -> Bool {

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -279,6 +279,23 @@ struct SimplifyContext : MutatingContext {
   let preserveDebugInfo: Bool
 }
 
+extension Type {
+  func getStaticSize(context: SimplifyContext) -> Int? {
+    let v = context._bridged.getStaticSize(self.bridged)
+    return v == -1 ? nil : v
+  }
+  
+  func getStaticAlignment(context: SimplifyContext) -> Int? {
+    let v = context._bridged.getStaticAlignment(self.bridged)
+    return v == -1 ? nil : v
+  }
+  
+  func getStaticStride(context: SimplifyContext) -> Int? {
+    let v = context._bridged.getStaticStride(self.bridged)
+    return v == -1 ? nil : v
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //                          Builder initialization
 //===----------------------------------------------------------------------===//

include/swift/SIL/SILModule.h

@@ -589,9 +589,8 @@ class SILModule {
 
   const SILOptions &getOptions() const { return Options; }
   const IRGenOptions *getIRGenOptionsOrNull() const {
-    // We don't want to serialize target specific SIL.
-    assert(isSerialized() &&
-           "Target specific options must not be used before serialization");
+    // This exposes target specific information, therefore serialized SIL
+    // is also target specific.
     return irgenOptions;
   }
 

include/swift/SILOptimizer/OptimizerBridging.h

@@ -259,6 +259,14 @@ struct BridgedPassContext {
     return {swift::SILUndef::get(type, *invocation->getFunction())};
   }
 
+  // IRGen
+
+  SwiftInt getStaticSize(swift::SILType type) const;
+
+  SwiftInt getStaticAlignment(swift::SILType type) const;
+
+  SwiftInt getStaticStride(swift::SILType type) const;
+
   // Sets
 
   SWIFT_IMPORT_UNSAFE

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -41,6 +41,7 @@ class SILCombiner;
 
 namespace irgen {
 class IRGenModule;
+class IRGenerator;
 }
 
 /// The main entrypoint for executing a pipeline pass on a SIL module.
@@ -71,6 +72,12 @@ class SwiftPassInvocation {
 
   SILSSAUpdater *ssaUpdater = nullptr;
 
+  /// IRGen module for passes that request it (e.g. simplification pass)
+  irgen::IRGenModule *irgenModule = nullptr;
+
+  /// IRGenerator used by IRGenModule above
+  irgen::IRGenerator *irgen = nullptr;
+
   static constexpr int BlockSetCapacity = 8;
   char blockSetStorage[sizeof(BasicBlockSet) * BlockSetCapacity];
   bool aliveBlockSets[BlockSetCapacity];
@@ -101,6 +108,8 @@ class SwiftPassInvocation {
 
   SILFunction *getFunction() const { return function; }
 
+  irgen::IRGenModule *getIRGenModule();
+
   FixedSizeSlab *allocSlab(FixedSizeSlab *afterSlab);
 
   FixedSizeSlab *freeSlab(FixedSizeSlab *slab);

include/swift/SILOptimizer/PassManager/Passes.def

@@ -345,8 +345,6 @@ PASS(ReleaseHoisting, "release-hoisting",
      "SIL release Hoisting")
 PASS(LateReleaseHoisting, "late-release-hoisting",
      "Late SIL release Hoisting Preserving Epilogues")
-PASS(TargetConstantFolding, "target-constant-folding",
-     "Target specific constant folding")
 IRGEN_PASS(LoadableByAddress, "loadable-address",
      "SIL Large Loadable type by-address lowering.")
 PASS(MandatorySILLinker, "mandatory-linker",

lib/SILOptimizer/CMakeLists.txt

@@ -9,7 +9,6 @@ add_subdirectory(Analysis)
 add_subdirectory(Differentiation)
 add_subdirectory(FunctionSignatureTransforms)
 add_subdirectory(IPO)
-add_subdirectory(IRGenTransforms)
 add_subdirectory(LoopTransforms)
 add_subdirectory(Mandatory)
 add_subdirectory(PassManager)

lib/SILOptimizer/IRGenTransforms/CMakeLists.txt

@@ -17,6 +17,7 @@
 #include "swift/AST/SILOptimizerRequests.h"
 #include "swift/Basic/BridgingUtils.h"
 #include "swift/Demangling/Demangle.h"
+#include "../../IRGen/IRGenModule.h"
 #include "swift/SIL/ApplySite.h"
 #include "swift/SIL/SILCloner.h"
 #include "swift/SIL/SILFunction.h"
@@ -1378,6 +1379,27 @@ void SwiftPassInvocation::finishedInstructionPassRun() {
   endPass();
 }
 
+irgen::IRGenModule *SwiftPassInvocation::getIRGenModule() {
+  // We need an IRGenModule to get the actual sizes from type lowering.
+  // Creating an IRGenModule involves some effort, let's cache it for the
+  // whole pass.
+  if (irgenModule == nullptr && irgen == nullptr) {
+    SILModule *module = getPassManager()->getModule();
+
+    auto *irgenOpts = module->getIRGenOptionsOrNull();
+    if (!irgenOpts)
+      return nullptr;
+
+    irgen = new irgen::IRGenerator(*irgenOpts, *module);
+    auto targetMachine = irgen->createTargetMachine();
+    if (!targetMachine)
+      return nullptr;
+
+    irgenModule = new irgen::IRGenModule(*irgen, std::move(targetMachine));
+  }
+  return irgenModule;
+}
+
 void SwiftPassInvocation::endPass() {
   assert(allocatedSlabs.empty() && "StackList is leaking slabs");
   assert(numBlockSetsAllocated == 0 && "Not all BasicBlockSets deallocated");
@@ -1388,6 +1410,14 @@ void SwiftPassInvocation::endPass() {
     delete ssaUpdater;
     ssaUpdater = nullptr;
   }
+  if (irgenModule) {
+    delete irgenModule;
+    irgenModule = nullptr;
+  }
+  if (irgen) {
+    delete irgen;
+    irgen = nullptr;
+  }
 }
 
 void SwiftPassInvocation::beginTransformFunction(SILFunction *function) {
@@ -1474,6 +1504,46 @@ void BridgedPassContext::inlineFunction(BridgedInstruction apply, bool mandatory
                               deleter);
 }
 
+static const irgen::TypeInfo &getTypeInfoOfBuiltin(swift::SILType type, irgen::IRGenModule &IGM) {
+  SILType lowered = IGM.getLoweredType(swift::Lowering::AbstractionPattern::getOpaque(), type.getASTType());
+  return IGM.getTypeInfo(lowered);
+}
+
+static SwiftInt integerValueFromConstant(llvm::Constant *c, SwiftInt add = 0) {
+  auto *intConst = dyn_cast_or_null<llvm::ConstantInt>(c);
+  if (!intConst)
+    return -1;
+  APInt value = intConst->getValue();
+  return value.getLimitedValue() + add;
+}
+
+SwiftInt BridgedPassContext::getStaticSize(swift::SILType type) const {
+  irgen::IRGenModule *IGM = invocation->getIRGenModule();
+  if (!IGM)
+    return -1;
+  auto &ti = getTypeInfoOfBuiltin(type, *IGM);
+  llvm::Constant *c = ti.getStaticSize(*IGM);
+  return integerValueFromConstant(c);
+}
+
+SwiftInt BridgedPassContext::getStaticAlignment(swift::SILType type) const {
+  irgen::IRGenModule *IGM = invocation->getIRGenModule();
+  if (!IGM)
+    return -1;
+  auto &ti = getTypeInfoOfBuiltin(type, *IGM);
+  llvm::Constant *c = ti.getStaticAlignmentMask(*IGM);
+  return integerValueFromConstant(c, 1);
+}
+
+SwiftInt BridgedPassContext::getStaticStride(swift::SILType type) const {
+  irgen::IRGenModule *IGM = invocation->getIRGenModule();
+  if (!IGM)
+    return -1;
+  auto &ti = getTypeInfoOfBuiltin(type, *IGM);
+  llvm::Constant *c = ti.getStaticStride(*IGM);
+  return integerValueFromConstant(c);
+}
+
 bool BridgedPassContext::specializeAppliesInFunction(BridgedFunction function, bool isMandatory) const {
   return ::specializeAppliesInFunction(*function.getFunction(), invocation->getTransform(), isMandatory);
 }