Merge pull request #14028 from eeckstein/option-set

Optimization changes to completely fold OptionSet literals (2nd try)

Author: eeckstein

include/swift/SILOptimizer/Analysis/SideEffectAnalysis.h

@@ -247,6 +247,9 @@ class SideEffectAnalysis : public BottomUpIPAnalysis {
     /// Get the array of parameter effects. If a side-effect can be associated
     /// to a specific parameter, it is contained here instead of the global
     /// effects.
+    /// Note that if a parameter effect is mayRelease(), it means that the
+    /// global function effects can be anything, because the destructor of an
+    /// object can have arbitrary side effects.
     ArrayRef<Effects> getParameterEffects() const { return ParamEffects; }
 
     /// Merge effects from \p RHS.

include/swift/SILOptimizer/PassManager/Passes.def

@@ -200,6 +200,8 @@ PASS(MoveCondFailToPreds, "move-cond-fail-to-preds",
      "Move SIL cond_fail by Hoisting Checks")
 PASS(NoReturnFolding, "noreturn-folding",
      "Prune Control Flow at No-Return Calls Using SIL unreachable")
+PASS(ObjectOutliner, "object-outliner",
+     "Outlining of Global Objects")
 PASS(Outliner, "outliner",
      "Function Outlining Optimization")
 PASS(OwnershipModelEliminator, "ownership-model-eliminator",

include/swift/SILOptimizer/Utils/ConstantFolding.h

@@ -18,6 +18,9 @@
 #define SWIFT_SIL_CONSTANTFOLDING_H
 
 #include "swift/SIL/SILInstruction.h"
+#include "swift/SILOptimizer/Analysis/Analysis.h"
+#include "llvm/ADT/SetVector.h"
+#include <functional>
 
 namespace swift {
 
@@ -47,6 +50,52 @@ APInt constantFoldDiv(APInt lhs, APInt rhs, bool &Overflow, BuiltinValueKind ID)
   /// The \p ID must be the ID of a trunc/sext/zext builtin.
 APInt constantFoldCast(APInt val, const BuiltinInfo &BI);
 
+
+/// A utility class to do constant folding.
+class ConstantFolder {
+private:
+  /// The worklist of the constants that could be folded into their users.
+  llvm::SetVector<SILInstruction *> WorkList;
+
+  /// The assert configuration of SILOptions.
+  unsigned AssertConfiguration;
+
+  /// Print diagnostics as part of mandatory constant propagation.
+  bool EnableDiagnostics;
+
+  /// Called for each constant folded instruction.
+  std::function<void (SILInstruction *)> Callback;
+
+  bool constantFoldStringConcatenation(ApplyInst *AI);
+
+public:
+  /// The constructor.
+  ///
+  /// \param AssertConfiguration The assert configuration of SILOptions.
+  /// \param EnableDiagnostics Print diagnostics as part of mandatory constant
+  ///                          propagation.
+  /// \param Callback Called for each constant folded instruction.
+  ConstantFolder(unsigned AssertConfiguration,
+                 bool EnableDiagnostics = false,
+                 std::function<void (SILInstruction *)> Callback =
+                   [](SILInstruction *){}) :
+    AssertConfiguration(AssertConfiguration),
+    EnableDiagnostics(EnableDiagnostics),
+    Callback(Callback) { }
+
+  /// Initialize the worklist with all instructions of the function \p F.
+  void initializeWorklist(SILFunction &F);
+
+  /// Initialize the worklist with a single instruction \p I.
+  void addToWorklist(SILInstruction *I) {
+    WorkList.insert(I);
+  }
+
+  /// Constant fold everything in the worklist and transitively all uses of
+  /// folded instructions.
+  SILAnalysis::InvalidationKind processWorkList();
+};
+
 } // end namespace swift
 
 #endif

include/swift/SILOptimizer/Utils/Local.h

@@ -616,6 +616,48 @@ SILType getExactDynamicTypeOfUnderlyingObject(SILValue S, SILModule &M,
 void hoistAddressProjections(Operand &Op, SILInstruction *InsertBefore,
                              DominanceInfo *DomTree);
 
+/// Utility class for cloning init values into the static initializer of a
+/// SILGlobalVariable.
+class StaticInitCloner : public SILCloner<StaticInitCloner> {
+  friend class SILInstructionVisitor<StaticInitCloner>;
+  friend class SILCloner<StaticInitCloner>;
+
+  /// The number of not yet cloned operands for each instruction.
+  llvm::DenseMap<SILInstruction *, int> NumOpsToClone;
+
+  /// List of instructions for which all operands are already cloned (or which
+  /// don't have any operands).
+  llvm::SmallVector<SILInstruction *, 8> ReadyToClone;
+
+public:
+  StaticInitCloner(SILGlobalVariable *GVar)
+      : SILCloner<StaticInitCloner>(GVar) { }
+
+  /// Add \p InitVal and all its operands (transitively) for cloning.
+  ///
+  /// Note: all init values must are added, before calling clone().
+  void add(SILInstruction *InitVal);
+
+  /// Clone \p InitVal and all its operands into the initializer of the
+  /// SILGlobalVariable.
+  ///
+  /// \return Returns the cloned instruction in the SILGlobalVariable.
+  SingleValueInstruction *clone(SingleValueInstruction *InitVal);
+
+  /// Convenience function to clone a single \p InitVal.
+  static void appendToInitializer(SILGlobalVariable *GVar,
+                                  SingleValueInstruction *InitVal) {
+    StaticInitCloner Cloner(GVar);
+    Cloner.add(InitVal);
+    Cloner.clone(InitVal);
+  }
+
+protected:
+  SILLocation remapLocation(SILLocation Loc) {
+    return ArtificialUnreachableLocation();
+  }
+};
+
 } // end namespace swift
 
 #endif

lib/SILOptimizer/Analysis/MemoryBehavior.cpp

@@ -268,6 +268,10 @@ MemBehavior MemoryBehaviorVisitor::visitApplyInst(ApplyInst *AI) {
          Idx < End && Behavior < MemBehavior::MayHaveSideEffects; ++Idx) {
       auto &ArgEffect = ApplyEffects.getParameterEffects()[Idx];
       auto ArgBehavior = ArgEffect.getMemBehavior(InspectionMode);
+      if (ArgEffect.mayRelease()) {
+        Behavior = MemBehavior::MayHaveSideEffects;
+        break;
+      }
       auto NewBehavior = combineMemoryBehavior(Behavior, ArgBehavior);
       if (NewBehavior != Behavior) {
         SILValue Arg = AI->getArgument(Idx);

lib/SILOptimizer/Analysis/SideEffectAnalysis.cpp

@@ -120,6 +120,7 @@ static SILValue skipValueProjections(SILValue V) {
       case ValueKind::TupleExtractInst:
       case ValueKind::UncheckedEnumDataInst:
       case ValueKind::UncheckedTrivialBitCastInst:
+      case ValueKind::UncheckedRefCastInst:
         V = cast<SingleValueInstruction>(V)->getOperand(0);
         break;
       default:
@@ -346,10 +347,6 @@ void SideEffectAnalysis::analyzeInstruction(FunctionInfo *FInfo,
     case SILInstructionKind::ReleaseValueInst:
     case SILInstructionKind::UnownedReleaseInst:
       FInfo->FE.getEffectsOn(I->getOperand(0))->Releases = true;
-      
-      // TODO: Check the call graph to be less conservative about what
-      // destructors might be called.
-      FInfo->FE.setWorstEffects();
       return;
     case SILInstructionKind::UnconditionalCheckedCastInst:
       FInfo->FE.getEffectsOn(cast<UnconditionalCheckedCastInst>(I)->getOperand())->Reads = true;