TargetConstantFolding: address review comments

* move the source file to SILOptimizer/IRGenTransforms
* add a file level comment
* document and verify that the pass runs after serialization
* catch overflows when truncating a constant value

Author: eeckstein

include/swift/SIL/SILModule.h

@@ -579,7 +579,12 @@ class SILModule {
   bool isOptimizedOnoneSupportModule() const;
 
   const SILOptions &getOptions() const { return Options; }
-  const IRGenOptions *getIRGenOptionsOrNull() const { return irgenOptions; }
+  const IRGenOptions *getIRGenOptionsOrNull() const {
+    // We don't want to serialize target specific SIL.
+    assert(isSerialized() &&
+           "Target specific options must not be used before serialization");
+    return irgenOptions;
+  }
 
   using iterator = FunctionListType::iterator;
   using const_iterator = FunctionListType::const_iterator;

lib/IRGen/CMakeLists.txt

@@ -57,7 +57,6 @@ add_swift_host_library(swiftIRGen STATIC
   Outlining.cpp
   StructLayout.cpp
   SwiftTargetInfo.cpp
-  TargetConstantFolding.cpp
   TypeLayout.cpp
   TypeLayoutDumper.cpp
   TypeLayoutVerifier.cpp

lib/SILOptimizer/CMakeLists.txt

@@ -9,6 +9,7 @@ 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

@@ -0,0 +1,3 @@
+target_sources(swiftSILOptimizer PRIVATE
+  TargetConstantFolding.cpp)
+

lib/IRGen/TargetConstantFolding.cpp renamed to lib/SILOptimizer/IRGenTransforms/TargetConstantFolding.cpp

@@ -15,9 +15,14 @@
 // It is a mandatory IRGen preparation pass (not a diagnostic pass).
 //
 //===----------------------------------------------------------------------===//
+///
+/// This file contains a pass for target specific constant folding:
+/// `TargetConstantFolding`. For details see the comments there.
+///
+//===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "target-constant-folding"
-#include "IRGenModule.h"
+#include "../../IRGen/IRGenModule.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SILOptimizer/Utils/InstructionDeleter.h"
@@ -43,22 +48,24 @@ class TargetConstantFolding : public SILModuleTransform {
 private:
   /// The entry point to the transformation.
   void run() override {
-    auto *irgenOpts = getModule()->getIRGenOptionsOrNull();
+    SILModule *module = getModule();
+
+    auto *irgenOpts = module->getIRGenOptionsOrNull();
     if (!irgenOpts)
       return;
 
     // We need an IRGenModule to get the actual sizes from type lowering.
     // Creating an IRGenModule involves some effort. Therefore this is a
     // module pass rather than a function pass so that this one-time setup
     // only needs to be done once and not for all functions in a module.
-    IRGenerator irgen(*irgenOpts, *getModule());
+    IRGenerator irgen(*irgenOpts, *module);
     auto targetMachine = irgen.createTargetMachine();
     if (!targetMachine)
       return;
     IRGenModule IGM(irgen, std::move(targetMachine));
 
     // Scan all instructions in the module for constant foldable instructions.
-    for (SILFunction &function : *getModule()) {
+    for (SILFunction &function : *module) {
 
       if (!function.shouldOptimize())
         continue;
@@ -118,6 +125,12 @@ class TargetConstantFolding : public SILModuleTransform {
     if (!intTy)
       return false;
 
+    // The bit widths can differ if we are compiling for a 32 bit target.
+    if (value.getActiveBits() > intTy->getGreatestWidth()) {
+      // It's unlikely that a size/stride overflows 32 bits, but let's be on
+      // the safe side and catch a potential overflow.
+      return false;
+    }
     value = value.sextOrTrunc(intTy->getGreatestWidth());
 
     // Replace the builtin by an integer literal.