SIL: move the SILInstruction::MemoryBehavior enum out of SILInstruction into the swift namespace

eeckstein · eeckstein · commit 8c05024ea652 · 2023-03-21T15:33:09.000+01:00
diff --git a/include/swift/SIL/SILFunction.h b/include/swift/SIL/SILFunction.h
@@ -1091,7 +1091,7 @@ class SILFunction
   void copyEffects(SILFunction *from);
   bool hasArgumentEffects() const;
   void visitArgEffects(std::function<void(int, int, bool)> c) const;
-  SILInstruction::MemoryBehavior getMemoryBehavior(bool observeRetains);
+  MemoryBehavior getMemoryBehavior(bool observeRetains);
 
   Purpose getSpecialPurpose() const { return specialPurpose; }
 
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -135,6 +135,28 @@ class SILPrintContext;
 
 template <typename ImplClass> class SILClonerWithScopes;
 
+enum class MemoryBehavior {
+  None,
+  /// The instruction may read memory.
+  MayRead,
+  /// The instruction may write to memory.
+  /// This includes destroying or taking from memory (e.g. destroy_addr,
+  /// copy_addr [take], load [take]).
+  /// Although, physically, destroying or taking does not modify the memory,
+  /// it is important to model it is a write. Optimizations must not assume
+  /// that the value stored in memory is still available for loading after
+  /// the memory is destroyed or taken.
+  MayWrite,
+  /// The instruction may read or write memory.
+  MayReadWrite,
+  /// The instruction may have side effects not captured
+  ///        solely by its users. Specifically, it can return,
+  ///        release memory, or store. Note, alloc is not considered
+  ///        to have side effects because its result/users represent
+  ///        its effect.
+  MayHaveSideEffects,
+};
+
 // An enum class for SILInstructions that enables exhaustive switches over
 // instructions.
 enum class SILInstructionKind : std::underlying_type<SILNodeKind>::type {
@@ -445,28 +467,6 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   /// scheduled to be deleted.
   bool isDeleted() const { return asSILNode()->isMarkedAsDeleted(); }
 
-  enum class MemoryBehavior {
-    None,
-    /// The instruction may read memory.
-    MayRead,
-    /// The instruction may write to memory.
-    /// This includes destroying or taking from memory (e.g. destroy_addr,
-    /// copy_addr [take], load [take]).
-    /// Although, physically, destroying or taking does not modify the memory,
-    /// it is important to model it is a write. Optimizations must not assume
-    /// that the value stored in memory is still available for loading after
-    /// the memory is destroyed or taken.
-    MayWrite,
-    /// The instruction may read or write memory.
-    MayReadWrite,
-    /// The instruction may have side effects not captured
-    ///        solely by its users. Specifically, it can return,
-    ///        release memory, or store. Note, alloc is not considered
-    ///        to have side effects because its result/users represent
-    ///        its effect.
-    MayHaveSideEffects,
-  };
-
   /// Enumeration representing whether the execution of an instruction can
   /// result in memory being released.
   enum class ReleasingBehavior {
@@ -776,7 +776,7 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   /// Returns true if the instruction may write to memory, deinitialize memory,
   /// or have other unknown side effects.
   ///
-  /// For details see SILInstruction::MemoryBehavior.
+  /// For details see MemoryBehavior.
   bool mayWriteToMemory() const {
     MemoryBehavior B = getMemoryBehavior();
     return B == MemoryBehavior::MayWrite ||
@@ -787,7 +787,7 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   /// Returns true if the instruction may read from memory, or have other
   /// unknown side effects.
   ///
-  /// For details see SILInstruction::MemoryBehavior.
+  /// For details see MemoryBehavior.
   bool mayReadFromMemory() const {
     MemoryBehavior B = getMemoryBehavior();
     return B == MemoryBehavior::MayRead ||
@@ -798,7 +798,7 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   /// Returns true if the instruction may read from memory, write to memory,
   /// deinitialize memory, or have other unknown side effects.
   ///
-  /// For details see SILInstruction::MemoryBehavior.
+  /// For details see MemoryBehavior.
   bool mayReadOrWriteMemory() const {
     return getMemoryBehavior() != MemoryBehavior::None;
   }
@@ -1061,23 +1061,23 @@ inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
 }
 
 /// Returns the combined behavior of \p B1 and \p B2.
-inline SILInstruction::MemoryBehavior
-combineMemoryBehavior(SILInstruction::MemoryBehavior B1,
-                  SILInstruction::MemoryBehavior B2) {
+inline MemoryBehavior
+combineMemoryBehavior(MemoryBehavior B1,
+                  MemoryBehavior B2) {
   // Basically the combined behavior is the maximum of both operands.
   auto Result = std::max(B1, B2);
 
   // With one exception: MayRead, MayWrite -> MayReadWrite.
-  if (Result == SILInstruction::MemoryBehavior::MayWrite &&
-        (B1 == SILInstruction::MemoryBehavior::MayRead ||
-         B2 == SILInstruction::MemoryBehavior::MayRead))
-    return SILInstruction::MemoryBehavior::MayReadWrite;
+  if (Result == MemoryBehavior::MayWrite &&
+        (B1 == MemoryBehavior::MayRead ||
+         B2 == MemoryBehavior::MayRead))
+    return MemoryBehavior::MayReadWrite;
   return Result;
 }
 
 /// Pretty-print the MemoryBehavior.
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
-                              SILInstruction::MemoryBehavior B);
+                              MemoryBehavior B);
 /// Pretty-print the ReleasingBehavior.
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                               SILInstruction::ReleasingBehavior B);
diff --git a/include/swift/SILOptimizer/Analysis/AliasAnalysis.h b/include/swift/SILOptimizer/Analysis/AliasAnalysis.h
@@ -85,7 +85,7 @@ class AliasAnalysis {
   /// The alias() method uses this map to cache queries.
   llvm::DenseMap<AliasCacheKey, AliasResult> AliasCache;
 
-  using MemoryBehavior = SILInstruction::MemoryBehavior;
+  using MemoryBehavior = MemoryBehavior;
 
   /// MemoryBehavior value cache.
   ///
@@ -169,7 +169,7 @@ class AliasAnalysis {
 
   /// Returns true if \p Inst may read from memory at address \p V.
   ///
-  /// For details see SILInstruction::MemoryBehavior::MayRead.
+  /// For details see MemoryBehavior::MayRead.
   bool mayReadFromMemory(SILInstruction *Inst, SILValue V) {
     auto B = computeMemoryBehavior(Inst, V);
     return B == MemoryBehavior::MayRead ||
@@ -180,7 +180,7 @@ class AliasAnalysis {
   /// Returns true if \p Inst may write to memory or deinitialize memory at
   /// address \p V.
   ///
-  /// For details see SILInstruction::MemoryBehavior::MayWrite.
+  /// For details see MemoryBehavior::MayWrite.
   bool mayWriteToMemory(SILInstruction *Inst, SILValue V) {
     auto B = computeMemoryBehavior(Inst, V);
     return B == MemoryBehavior::MayWrite ||
@@ -191,7 +191,7 @@ class AliasAnalysis {
   /// Returns true if \p Inst may read from memory, write to memory or
   /// deinitialize memory at address \p V.
   ///
-  /// For details see SILInstruction::MemoryBehavior.
+  /// For details see MemoryBehavior.
   bool mayReadOrWriteMemory(SILInstruction *Inst, SILValue V) {
     auto B = computeMemoryBehavior(Inst, V);
     return MemoryBehavior::None != B;
diff --git a/include/swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h b/include/swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h
@@ -234,7 +234,7 @@ class BasicCalleeAnalysis : public SILAnalysis {
     return Cache->getDestructors(type, isExactType);
   }
 
-  SILInstruction::MemoryBehavior getMemoryBehavior(ApplySite as, bool observeRetains);
+  MemoryBehavior getMemoryBehavior(ApplySite as, bool observeRetains);
 };
 
 bool isDeinitBarrier(SILInstruction *const instruction,
diff --git a/lib/SIL/IR/SILFunction.cpp b/lib/SIL/IR/SILFunction.cpp
@@ -1045,10 +1045,10 @@ visitArgEffects(std::function<void(int, int, bool)> c) const {
   }
 }
 
-SILInstruction::MemoryBehavior SILFunction::getMemoryBehavior(bool observeRetains) {
+MemoryBehavior SILFunction::getMemoryBehavior(bool observeRetains) {
   if (!getMemBehvaiorFunction)
-    return SILInstruction::MemoryBehavior::MayHaveSideEffects;
+    return MemoryBehavior::MayHaveSideEffects;
 
   auto b = getMemBehvaiorFunction({this}, observeRetains);
-  return (SILInstruction::MemoryBehavior)b;
+  return (MemoryBehavior)b;
 }
diff --git a/lib/SIL/IR/SILInstruction.cpp b/lib/SIL/IR/SILInstruction.cpp
@@ -973,7 +973,7 @@ unsigned Operand::getOperandNumber() const {
   return this - &cast<SILInstruction>(getUser())->getAllOperands()[0];
 }
 
-SILInstruction::MemoryBehavior SILInstruction::getMemoryBehavior() const {
+MemoryBehavior SILInstruction::getMemoryBehavior() const {
 
   if (auto *BI = dyn_cast<BuiltinInst>(this)) {
     // Handle Swift builtin functions.
@@ -1374,17 +1374,17 @@ unsigned SILInstruction::getCachedCaseIndex(EnumElementDecl *enumElement) {
 //===----------------------------------------------------------------------===//
 
 llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &OS,
-                                     SILInstruction::MemoryBehavior B) {
+                                     MemoryBehavior B) {
   switch (B) {
-    case SILInstruction::MemoryBehavior::None:
+    case MemoryBehavior::None:
       return OS << "None";
-    case SILInstruction::MemoryBehavior::MayRead:
+    case MemoryBehavior::MayRead:
       return OS << "MayRead";
-    case SILInstruction::MemoryBehavior::MayWrite:
+    case MemoryBehavior::MayWrite:
       return OS << "MayWrite";
-    case SILInstruction::MemoryBehavior::MayReadWrite:
+    case MemoryBehavior::MayReadWrite:
       return OS << "MayReadWrite";
-    case SILInstruction::MemoryBehavior::MayHaveSideEffects:
+    case MemoryBehavior::MayHaveSideEffects:
       return OS << "MayHaveSideEffects";
   }
 
diff --git a/lib/SILOptimizer/Analysis/AccessStorageAnalysis.cpp b/lib/SILOptimizer/Analysis/AccessStorageAnalysis.cpp
@@ -359,15 +359,15 @@ bool FunctionAccessStorage::summarizeFunction(SILFunction *F) {
   // If FunctionSideEffects can be summarized, use that information.
 
   auto b = F->getMemoryBehavior(/*observeRetains*/ false);
-  if (b == SILInstruction::MemoryBehavior::MayHaveSideEffects) {
+  if (b == MemoryBehavior::MayHaveSideEffects) {
     setWorstEffects();
     // May as well consider this a successful summary since there are no
     // instructions to visit anyway.
     return true;
   }
-  if (b >= SILInstruction::MemoryBehavior::MayWrite) {
+  if (b >= MemoryBehavior::MayWrite) {
     accessResult.setUnidentifiedAccess(SILAccessKind::Modify);
-  } else if (b == SILInstruction::MemoryBehavior::MayRead) {
+  } else if (b == MemoryBehavior::MayRead) {
     accessResult.setUnidentifiedAccess(SILAccessKind::Read);
   }
 
diff --git a/lib/SILOptimizer/Analysis/AliasAnalysis.cpp b/lib/SILOptimizer/Analysis/AliasAnalysis.cpp
@@ -724,7 +724,7 @@ void AliasAnalysis_register(AliasAnalysisGetMemEffectFn getMemEffectsFn,
   canReferenceSameFieldFunction = canReferenceSameFieldFn;
 }
 
-SILInstruction::MemoryBehavior AliasAnalysis::getMemoryBehaviorOfInst(
+MemoryBehavior AliasAnalysis::getMemoryBehaviorOfInst(
             SILValue addr, SILInstruction *toInst) {
   if (getMemEffectsFunction) {
     return (MemoryBehavior)getMemEffectsFunction({PM->getSwiftPassInvocation()}, {addr},
diff --git a/lib/SILOptimizer/Analysis/BasicCalleeAnalysis.cpp b/lib/SILOptimizer/Analysis/BasicCalleeAnalysis.cpp
@@ -377,15 +377,15 @@ void CalleeAnalysis_register(
   getMemBehvaiorFunction = getMemBehvaiorFn;
 }
 
-SILInstruction::MemoryBehavior BasicCalleeAnalysis::
+MemoryBehavior BasicCalleeAnalysis::
 getMemoryBehavior(ApplySite as, bool observeRetains) {
   if (getMemBehvaiorFunction) {
     auto b = getMemBehvaiorFunction({pm->getSwiftPassInvocation()},
                                     {as.getInstruction()->asSILNode()},
                                     observeRetains);
-    return (SILInstruction::MemoryBehavior)b;
+    return (MemoryBehavior)b;
   }
-  return SILInstruction::MemoryBehavior::MayHaveSideEffects;
+  return MemoryBehavior::MayHaveSideEffects;
 }
 
 bool swift::isDeinitBarrier(SILInstruction *const instruction,
diff --git a/lib/SILOptimizer/Analysis/MemoryBehavior.cpp b/lib/SILOptimizer/Analysis/MemoryBehavior.cpp
@@ -29,7 +29,7 @@ using namespace swift;
 
 namespace {
 
-using MemBehavior = SILInstruction::MemoryBehavior;
+using MemBehavior = MemoryBehavior;
 
 /// Visitor that determines the memory behavior of an instruction relative to a
 /// specific SILValue (i.e. can the instruction cause the value to be read,
@@ -136,7 +136,7 @@ class MemoryBehaviorVisitor
     case SILAccessKind::Deinit:
       // For the same reason we treat a ``load [take]`` or a ``destroy_addr``
       // as a memory write, we do that for a ``begin_access [deinit]`` as well.
-      // See SILInstruction::MemoryBehavior.
+      // See MemoryBehavior.
       return MemBehavior::MayReadWrite;
     case SILAccessKind::Read:
       return MemBehavior::MayRead;
diff --git a/lib/SILOptimizer/LoopTransforms/LICM.cpp b/lib/SILOptimizer/LoopTransforms/LICM.cpp
@@ -170,7 +170,7 @@ static bool mayWriteTo(AliasAnalysis *AA, BasicCalleeAnalysis *BCA,
                        InstSet &SideEffectInsts, ApplyInst *AI) {
 
   if (BCA->getMemoryBehavior(FullApplySite::isa(AI), /*observeRetains*/true) ==
-      SILInstruction::MemoryBehavior::None) {
+      MemoryBehavior::None) {
     return false;
   }
 
@@ -197,7 +197,7 @@ static bool mayWriteTo(AliasAnalysis *AA, BasicCalleeAnalysis *BCA,
       case SILInstructionKind::BeginApplyInst:
       case SILInstructionKind::TryApplyInst: {
         if (BCA->getMemoryBehavior(FullApplySite::isa(inst), /*observeRetains*/false) >
-            SILInstruction::MemoryBehavior::MayRead)
+            MemoryBehavior::MayRead)
           return true;
         break;
       }
@@ -700,7 +700,7 @@ bool LoopTreeOptimization::isSafeReadOnlyApply(BasicCalleeAnalysis *BCA, ApplyIn
   }
 
   return BCA->getMemoryBehavior(AI, /*observeRetains*/false) <=
-         SILInstruction::MemoryBehavior::MayRead;
+         MemoryBehavior::MayRead;
 }
 
 static void checkSideEffects(swift::SILInstruction &Inst,
@@ -746,7 +746,7 @@ static bool canHoistUpDefault(SILInstruction *inst, SILLoop *Loop,
       break;
   }
 
-  if (inst->getMemoryBehavior() == SILInstruction::MemoryBehavior::None) {
+  if (inst->getMemoryBehavior() == MemoryBehavior::None) {
     return true;
   }
   return false;
diff --git a/lib/SILOptimizer/Transforms/CSE.cpp b/lib/SILOptimizer/Transforms/CSE.cpp
@@ -1154,7 +1154,7 @@ bool CSE::canHandle(SILInstruction *Inst) {
     // functions which are read-none and have a retain, e.g. functions which
     // _convert_ a global_addr to a reference and retain it.
     auto MB = BCA->getMemoryBehavior(ApplySite(AI), /*observeRetains*/false);
-    if (MB == SILInstruction::MemoryBehavior::None)
+    if (MB == MemoryBehavior::None)
       return true;
     
     if (isLazyPropertyGetter(AI))
diff --git a/lib/SILOptimizer/Transforms/ConditionForwarding.cpp b/lib/SILOptimizer/Transforms/ConditionForwarding.cpp
@@ -125,7 +125,7 @@ class ConditionForwarding : public SILFunctionTransform {
 /// across other code.
 static bool hasNoRelevantSideEffects(SILBasicBlock *BB) {
   for (SILInstruction &I : *BB) {
-    if (I.getMemoryBehavior() == SILInstruction::MemoryBehavior::None)
+    if (I.getMemoryBehavior() == MemoryBehavior::None)
       continue;
     if (auto *CF = dyn_cast<CondFailInst>(&I)) {
       // Allow cond_fail if the condition is "produced" by a builtin in the
@@ -221,7 +221,7 @@ bool ConditionForwarding::tryOptimize(SwitchEnumInst *SEI) {
   // This optimization works with all kind of terminators, except those which
   // have side-effects, like try_apply.
   TermInst *Condition = CommonBranchBlock->getTerminator();
-  if (Condition->getMemoryBehavior() != SILInstruction::MemoryBehavior::None)
+  if (Condition->getMemoryBehavior() != MemoryBehavior::None)
     return false;
 
   // Are there any other branch block successors beside the predecessors which
diff --git a/lib/SILOptimizer/Transforms/PhiArgumentOptimizations.cpp b/lib/SILOptimizer/Transforms/PhiArgumentOptimizations.cpp
@@ -265,7 +265,7 @@ bool RedundantPhiEliminationPass::valuesAreEqual(SILValue val1, SILValue val2) {
     
     if (auto *inst1 = dyn_cast<SingleValueInstruction>(val1)) {
       // Bail if the instructions have any side effects.
-      if (inst1->getMemoryBehavior() != SILInstruction::MemoryBehavior::None)
+      if (inst1->getMemoryBehavior() != MemoryBehavior::None)
         return false;
 
       // Allocation instructions are defined to have no side-effects.
diff --git a/lib/SILOptimizer/Utils/PerformanceInlinerUtils.cpp b/lib/SILOptimizer/Utils/PerformanceInlinerUtils.cpp
@@ -883,7 +883,7 @@ static bool hasInterestingSideEffect(SILInstruction *I) {
     case swift::SILInstructionKind::DeallocRefInst:
       return false;
     default:
-      return I->getMemoryBehavior() != SILInstruction::MemoryBehavior::None;
+      return I->getMemoryBehavior() != MemoryBehavior::None;
   }
 }
 
@@ -937,7 +937,7 @@ bool swift::isPureCall(FullApplySite AI, BasicCalleeAnalysis *BCA) {
   // If a call has only constant arguments and the call is pure, i.e. has
   // no side effects, then we should always inline it.
   // This includes arguments which are objects initialized with constant values.
-  if (BCA->getMemoryBehavior(AI, /*observeRetains*/ true) != SILInstruction::MemoryBehavior::None)
+  if (BCA->getMemoryBehavior(AI, /*observeRetains*/ true) != MemoryBehavior::None)
     return false;
   // Check if all parameters are constant.
   auto Args = AI.getArgumentOperands().slice(AI.getNumIndirectSILResults());

Original file line number	Diff line number	Diff line change
`@@ -234,7 +234,7 @@ class BasicCalleeAnalysis : public SILAnalysis {`
`234`	`234`	`return Cache->getDestructors(type, isExactType);`
`235`	`235`	`}`
`236`	`236`
`237`		`- SILInstruction::MemoryBehavior getMemoryBehavior(ApplySite as, bool observeRetains);`
	`237`	`+ MemoryBehavior getMemoryBehavior(ApplySite as, bool observeRetains);`
`238`	`238`	`};`
`239`	`239`
`240`	`240`	`bool isDeinitBarrier(SILInstruction *const instruction,`
Original file line number	Diff line number	Diff line change
`@@ -1045,10 +1045,10 @@ visitArgEffects(std::function<void(int, int, bool)> c) const {`
`1045`	`1045`	`}`
`1046`	`1046`	`}`
`1047`	`1047`
`1048`		`-SILInstruction::MemoryBehavior SILFunction::getMemoryBehavior(bool observeRetains) {`
	`1048`	`+MemoryBehavior SILFunction::getMemoryBehavior(bool observeRetains) {`
`1049`	`1049`	`if (!getMemBehvaiorFunction)`
`1050`		`- return SILInstruction::MemoryBehavior::MayHaveSideEffects;`
	`1050`	`+ return MemoryBehavior::MayHaveSideEffects;`
`1051`	`1051`
`1052`	`1052`	`auto b = getMemBehvaiorFunction({this}, observeRetains);`
`1053`		`- return (SILInstruction::MemoryBehavior)b;`
	`1053`	`+ return (MemoryBehavior)b;`
`1054`	`1054`	`}`
Original file line number	Diff line number	Diff line change
`@@ -724,7 +724,7 @@ void AliasAnalysis_register(AliasAnalysisGetMemEffectFn getMemEffectsFn,`
`724`	`724`	`canReferenceSameFieldFunction = canReferenceSameFieldFn;`
`725`	`725`	`}`
`726`	`726`
`727`		`-SILInstruction::MemoryBehavior AliasAnalysis::getMemoryBehaviorOfInst(`
	`727`	`+MemoryBehavior AliasAnalysis::getMemoryBehaviorOfInst(`
`728`	`728`	`SILValue addr, SILInstruction *toInst) {`
`729`	`729`	`if (getMemEffectsFunction) {`
`730`	`730`	`return (MemoryBehavior)getMemEffectsFunction({PM->getSwiftPassInvocation()}, {addr},`
Original file line number	Diff line number	Diff line change
`@@ -377,15 +377,15 @@ void CalleeAnalysis_register(`
`377`	`377`	`getMemBehvaiorFunction = getMemBehvaiorFn;`
`378`	`378`	`}`
`379`	`379`
`380`		`-SILInstruction::MemoryBehavior BasicCalleeAnalysis::`
	`380`	`+MemoryBehavior BasicCalleeAnalysis::`
`381`	`381`	`getMemoryBehavior(ApplySite as, bool observeRetains) {`
`382`	`382`	`if (getMemBehvaiorFunction) {`
`383`	`383`	`auto b = getMemBehvaiorFunction({pm->getSwiftPassInvocation()},`
`384`	`384`	`{as.getInstruction()->asSILNode()},`
`385`	`385`	`observeRetains);`
`386`		`- return (SILInstruction::MemoryBehavior)b;`
	`386`	`+ return (MemoryBehavior)b;`
`387`	`387`	`}`
`388`		`- return SILInstruction::MemoryBehavior::MayHaveSideEffects;`
	`388`	`+ return MemoryBehavior::MayHaveSideEffects;`
`389`	`389`	`}`
`390`	`390`
`391`	`391`	`bool swift::isDeinitBarrier(SILInstruction *const instruction,`