[arc] Move isARCInertBB into ProgramTerminationAnalysis.cpp from ARCAnalysis.cpp.

Author: gottesmm

include/swift/SILAnalysis/ARCAnalysis.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_SILANALYSIS_ARCANALYSIS_H
 #define SWIFT_SILANALYSIS_ARCANALYSIS_H
 
+#include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILValue.h"
 #include "swift/SIL/SILBasicBlock.h"
 #include "llvm/ADT/SmallPtrSet.h"
@@ -102,9 +103,6 @@ valueHasARCDecrementOrCheckInInstructionRange(SILValue Op,
                                               SILBasicBlock::iterator End,
                                               AliasAnalysis *AA);
 
-/// Match a call to a trap BB with no ARC relevant side effects.
-bool isARCInertTrapBB(SILBasicBlock *BB);
-
 /// A class that attempts to match owned arguments and corresponding epilogue
 /// releases for a specific function.
 ///

include/swift/SILAnalysis/ProgramTerminationAnalysis.h

@@ -35,18 +35,12 @@
 namespace swift {
 
 class ProgramTerminationFunctionInfo {
-  llvm::SmallPtrSet<SILBasicBlock *, 4> ProgramTerminatingBlocks;
+  llvm::SmallPtrSet<const SILBasicBlock *, 4> ProgramTerminatingBlocks;
 
 public:
-  ProgramTerminationFunctionInfo(SILFunction *F) {
-    for (auto &BB : *F) {
-      if (!isARCInertTrapBB(&BB))
-        continue;
-      ProgramTerminatingBlocks.insert(&BB);
-    }
-  }
+  ProgramTerminationFunctionInfo(const SILFunction *F);
 
-  bool isProgramTerminatingBlock(SILBasicBlock *BB) {
+  bool isProgramTerminatingBlock(const SILBasicBlock *BB) const {
     return ProgramTerminatingBlocks.count(BB);
   }
 };

lib/SILAnalysis/ARCAnalysis.cpp

@@ -503,78 +503,6 @@ mayGuaranteedUseValue(SILInstruction *User, SILValue Ptr, AliasAnalysis *AA) {
 //           Utilities for recognizing trap BBs that are ARC inert
 //===----------------------------------------------------------------------===//
 
-static bool ignoreableApplyInstInUnreachableBlock(ApplyInst *AI) {
-  const char *fatalName =
-    "_TFs18_fatalErrorMessageFTVs12StaticStringS_S_Su_T_";
-  auto *Fn = AI->getCalleeFunction();
-
-  // We use endswith here since if we specialize fatal error we will always
-  // prepend the specialization records to fatalName.
-  if (!Fn || !Fn->getName().endswith(fatalName))
-    return false;
-
-  return true;
-}
-
-static bool ignoreableBuiltinInstInUnreachableBlock(BuiltinInst *BI) {
-  const BuiltinInfo &BInfo = BI->getBuiltinInfo();
-  if (BInfo.ID == BuiltinValueKind::CondUnreachable)
-    return true;
-
-  const IntrinsicInfo &IInfo = BI->getIntrinsicInfo();
-  if (IInfo.ID == llvm::Intrinsic::trap)
-    return true;
-  
-  return false;
-}
-
-/// Match a call to a trap BB with no ARC relevant side effects.
-bool swift::isARCInertTrapBB(SILBasicBlock *BB) {
-  // Do a quick check at the beginning to make sure that our terminator is
-  // actually an unreachable. This ensures that in many cases this function will
-  // exit early and quickly.
-  auto II = BB->rbegin();
-  if (!isa<UnreachableInst>(*II))
-    return false;
-
-  auto IE = BB->rend();
-  while (II != IE) {
-    // Ignore any instructions without side effects.
-    if (!II->mayHaveSideEffects()) {
-      ++II;
-      continue;
-    }
-
-    // Ignore cond fail.
-    if (isa<CondFailInst>(*II)) {
-      ++II;
-      continue;
-    }
-
-    // Check for apply insts that we can ignore.
-    if (auto *AI = dyn_cast<ApplyInst>(&*II)) {
-      if (ignoreableApplyInstInUnreachableBlock(AI)) {
-        ++II;
-        continue;
-      }
-    }
-
-    // Check for builtins that we can ignore.
-    if (auto *BI = dyn_cast<BuiltinInst>(&*II)) {
-      if (ignoreableBuiltinInstInUnreachableBlock(BI)) {
-        ++II;
-        continue;
-      }
-    }
-
-    // If we can't ignore the instruction, return false.
-    return false;
-  }
-
-  // Otherwise, we have an unreachable and every instruction is inert from an
-  // ARC perspective in an unreachable BB.
-  return true;
-}
 
 //===----------------------------------------------------------------------===//
 //                          Owned Argument Utilities

lib/SILAnalysis/Analysis.cpp

@@ -61,7 +61,3 @@ SILAnalysis *swift::createClassHierarchyAnalysis(SILModule *M) {
 SILAnalysis *swift::createBasicCalleeAnalysis(SILModule *M) {
   return new BasicCalleeAnalysis(M);
 }
-
-SILAnalysis *swift::createProgramTerminationAnalysis(SILModule *M) {
-  return new ProgramTerminationAnalysis(M);
-}

lib/SILAnalysis/CMakeLists.txt

@@ -15,6 +15,7 @@ add_swift_library(swiftSILAnalysis
   LoopAnalysis.cpp
   LoopRegionAnalysis.cpp
   MemoryBehavior.cpp
+  ProgramTerminationAnalysis.cpp
   RCIdentityAnalysis.cpp
   SideEffectAnalysis.cpp
   SimplifyInstruction.cpp

lib/SILAnalysis/ProgramTerminationAnalysis.cpp

@@ -0,0 +1,114 @@
+//===--- ProgramTerminationAnalysis.cpp -----------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "program-termination-analysis"
+#include "swift/SILAnalysis/ProgramTerminationAnalysis.h"
+#include "swift/SIL/SILFunction.h"
+
+using namespace swift;
+
+//===----------------------------------------------------------------------===//
+//                                  Utility
+//===----------------------------------------------------------------------===//
+
+static bool ignoreableApplyInstInUnreachableBlock(const ApplyInst *AI) {
+  const char *fatalName = "_TFs18_fatalErrorMessageFTVs12StaticStringS_S_Su_T_";
+  const auto *Fn = AI->getCalleeFunction();
+
+  // We use endswith here since if we specialize fatal error we will always
+  // prepend the specialization records to fatalName.
+  if (!Fn || !Fn->getName().endswith(fatalName))
+    return false;
+
+  return true;
+}
+
+static bool ignoreableBuiltinInstInUnreachableBlock(const BuiltinInst *BI) {
+  const BuiltinInfo &BInfo = BI->getBuiltinInfo();
+  if (BInfo.ID == BuiltinValueKind::CondUnreachable)
+    return true;
+
+  const IntrinsicInfo &IInfo = BI->getIntrinsicInfo();
+  if (IInfo.ID == llvm::Intrinsic::trap)
+    return true;
+
+  return false;
+}
+
+/// Match a call to a trap BB with no ARC relevant side effects.
+static bool isARCInertTrapBB(const SILBasicBlock *BB) {
+  // Do a quick check at the beginning to make sure that our terminator is
+  // actually an unreachable. This ensures that in many cases this function will
+  // exit early and quickly.
+  auto II = BB->rbegin();
+  if (!isa<UnreachableInst>(*II))
+    return false;
+
+  auto IE = BB->rend();
+  while (II != IE) {
+    // Ignore any instructions without side effects.
+    if (!II->mayHaveSideEffects()) {
+      ++II;
+      continue;
+    }
+
+    // Ignore cond fail.
+    if (isa<CondFailInst>(*II)) {
+      ++II;
+      continue;
+    }
+
+    // Check for apply insts that we can ignore.
+    if (auto *AI = dyn_cast<ApplyInst>(&*II)) {
+      if (ignoreableApplyInstInUnreachableBlock(AI)) {
+        ++II;
+        continue;
+      }
+    }
+
+    // Check for builtins that we can ignore.
+    if (auto *BI = dyn_cast<BuiltinInst>(&*II)) {
+      if (ignoreableBuiltinInstInUnreachableBlock(BI)) {
+        ++II;
+        continue;
+      }
+    }
+
+    // If we can't ignore the instruction, return false.
+    return false;
+  }
+
+  // Otherwise, we have an unreachable and every instruction is inert from an
+  // ARC perspective in an unreachable BB.
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+//                       ProgramTerminationFunctionInfo
+//===----------------------------------------------------------------------===//
+
+ProgramTerminationFunctionInfo::ProgramTerminationFunctionInfo(
+    const SILFunction *F) {
+  for (const auto &BB : *F) {
+    if (!isARCInertTrapBB(&BB))
+      continue;
+    ProgramTerminatingBlocks.insert(&BB);
+  }
+}
+
+//===----------------------------------------------------------------------===//
+//                            Top level Entrypoint
+//===----------------------------------------------------------------------===//
+
+SILAnalysis *swift::createProgramTerminationAnalysis(SILModule *M) {
+  return new ProgramTerminationAnalysis(M);
+}