Delete ObjCARCAPElim, as it is entirely superseded by ObjCARCOpts

The optimization can be completely superseded now

Author: AZero13

clang/lib/CodeGen/BackendUtil.cpp

@@ -1022,12 +1022,6 @@ void EmitAssemblyHelper::RunOptimizationPipeline(
               MPM.addPass(
                   createModuleToFunctionPassAdaptor(ObjCARCExpandPass()));
           });
-      PB.registerPipelineEarlySimplificationEPCallback(
-          [](ModulePassManager &MPM, OptimizationLevel Level,
-             ThinOrFullLTOPhase) {
-            if (Level != OptimizationLevel::O0)
-              MPM.addPass(ObjCARCAPElimPass());
-          });
       PB.registerScalarOptimizerLateEPCallback(
           [](FunctionPassManager &FPM, OptimizationLevel Level) {
             if (Level != OptimizationLevel::O0)

llvm/include/llvm/Transforms/ObjCARC.h

@@ -35,10 +35,6 @@ struct ObjCARCContractPass : public PassInfoMixin<ObjCARCContractPass> {
   LLVM_ABI PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
-struct ObjCARCAPElimPass : public PassInfoMixin<ObjCARCAPElimPass> {
-  LLVM_ABI PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
-};
-
 struct ObjCARCExpandPass : public PassInfoMixin<ObjCARCExpandPass> {
   LLVM_ABI PreservedAnalyses run(Function &M, FunctionAnalysisManager &AM);
 };

llvm/lib/Passes/PassRegistry.def

@@ -113,7 +113,6 @@ MODULE_PASS("module-inline", ModuleInlinerPass())
 MODULE_PASS("name-anon-globals", NameAnonGlobalPass())
 MODULE_PASS("no-op-module", NoOpModulePass())
 MODULE_PASS("nsan", NumericalStabilitySanitizerPass())
-MODULE_PASS("objc-arc-apelim", ObjCARCAPElimPass())
 MODULE_PASS("openmp-opt", OpenMPOptPass())
 MODULE_PASS("openmp-opt-postlink",
             OpenMPOptPass(ThinOrFullLTOPhase::FullLTOPostLink))

llvm/lib/Transforms/ObjCARC/CMakeLists.txt

@@ -2,7 +2,6 @@ add_llvm_component_library(LLVMObjCARCOpts
   ObjCARC.cpp
   ObjCARCOpts.cpp
   ObjCARCExpand.cpp
-  ObjCARCAPElim.cpp
   ObjCARCContract.cpp
   DependencyAnalysis.cpp
   ProvenanceAnalysis.cpp

llvm/lib/Transforms/ObjCARC/ObjCARCAPElim.cpp

@@ -2490,6 +2490,122 @@ bool ObjCARCOpt::run(Function &F, AAResults &AA) {
   return Changed;
 }
 
+/// Interprocedurally determine if calls made by the given call site can
+/// possibly produce autoreleases.
+bool MayAutorelease(const CallBase &CB, unsigned Depth = 0) {
+  if (CB.onlyReadsMemory())
+    return false;
+
+  // This recursion depth limit is arbitrary. It's just great
+  // enough to cover known interesting testcases.
+  if (Depth > 5)
+    return true;
+
+  if (const Function *Callee = CB.getCalledFunction()) {
+    if (!Callee->hasExactDefinition())
+      return true;
+    for (const BasicBlock &BB : *Callee) {
+      // If we come across an autoreleasepool push and a pop in the same block,
+      // we can ignore the instructions between them.
+      // TODO: Can we check inter-block autorelease pool pairs?
+      // This would involve tracking autorelease pool state across blocks.
+
+      // First pass: find all push/pop pairs and their positions in this basic
+      // block
+      SmallVector<std::pair<unsigned, unsigned>, 4>
+          ShadowedRegions; // (push_pos, pop_pos)
+      SmallVector<std::pair<unsigned, const Instruction*>, 4> PushStack; // (index, push_inst)
+
+      unsigned InstIndex = 0;
+      for (const Instruction &I : BB) {
+        if (GetBasicARCInstKind(&I) == ARCInstKind::AutoreleasepoolPush) {
+          PushStack.push_back({InstIndex, &I});
+        } else if (GetBasicARCInstKind(&I) == ARCInstKind::AutoreleasepoolPop) {
+          if (!PushStack.empty()) {
+            auto [PushIndex, PushInst] = PushStack.back();
+            // Verify this pop actually pops the corresponding push
+            const auto *PopCall = cast<CallInst>(&I);
+            if (PopCall->getArgOperand(0)->stripPointerCasts() == PushInst) {
+              // Valid push/pop pair - add to shadowed regions
+              ShadowedRegions.push_back({PushIndex, InstIndex});
+              PushStack.pop_back();
+            }
+            // If pop doesn't match the most recent push, it might be for an outer pool
+            // in a different basic block, so we leave the stack unchanged
+          }
+        }
+        InstIndex++;
+      }
+
+      // Second pass: check for autoreleases, ignoring shadowed regions
+      InstIndex = 0;
+      for (const Instruction &I : BB) {
+        // Check if this instruction is in a shadowed region (between inner
+        // push/pop pairs)
+        bool InShadowedRegion = false;
+        for (auto [PushIndex, PopIndex] : ShadowedRegions) {
+          if (InstIndex > PushIndex && InstIndex < PopIndex) {
+            InShadowedRegion = true;
+            break;
+          }
+        }
+
+        if (InShadowedRegion) {
+          InstIndex++;
+          continue; // Skip instructions in shadowed regions - they don't affect
+                    // outer pools
+        }
+
+        ARCInstKind InstKind = GetBasicARCInstKind(&I);
+        switch (InstKind) {
+        case ARCInstKind::Autorelease:
+        case ARCInstKind::AutoreleaseRV:
+        case ARCInstKind::FusedRetainAutorelease:
+        case ARCInstKind::FusedRetainAutoreleaseRV:
+        case ARCInstKind::LoadWeak:
+          // These may produce autoreleases
+          return true;
+
+        case ARCInstKind::Retain:
+        case ARCInstKind::RetainRV:
+        case ARCInstKind::UnsafeClaimRV:
+        case ARCInstKind::RetainBlock:
+        case ARCInstKind::Release:
+        case ARCInstKind::NoopCast:
+        case ARCInstKind::LoadWeakRetained:
+        case ARCInstKind::StoreWeak:
+        case ARCInstKind::InitWeak:
+        case ARCInstKind::MoveWeak:
+        case ARCInstKind::CopyWeak:
+        case ARCInstKind::DestroyWeak:
+        case ARCInstKind::StoreStrong:
+        case ARCInstKind::AutoreleasepoolPush:
+        case ARCInstKind::AutoreleasepoolPop:
+          // These ObjC runtime functions don't produce autoreleases
+          break;
+
+        case ARCInstKind::CallOrUser:
+        case ARCInstKind::Call:
+          // For non-ObjC function calls, recursively analyze
+          if (MayAutorelease(cast<CallBase>(I), Depth + 1))
+            return true;
+          break;
+
+        case ARCInstKind::IntrinsicUser:
+        case ARCInstKind::User:
+        case ARCInstKind::None:
+          // These are not relevant for autorelease analysis
+          break;
+        }
+        InstIndex++;
+      }
+    }
+    return false;
+  }
+
+  return true;
+}
+
 /// Optimize autorelease pools by eliminating empty push/pop pairs.
 void ObjCARCOpt::OptimizeAutoreleasePools(Function &F) {
   LLVM_DEBUG(dbgs() << "\n== ObjCARCOpt::OptimizeAutoreleasePools ==\n");
@@ -2558,6 +2674,9 @@ void ObjCARCOpt::OptimizeAutoreleasePools(Function &F) {
       }
       case ARCInstKind::CallOrUser:
       case ARCInstKind::Call:
+        if (!MayAutorelease(cast<CallBase>(Inst)))
+          break;
+        [[fallthrough]];
       case ARCInstKind::Autorelease:
       case ARCInstKind::AutoreleaseRV:
       case ARCInstKind::FusedRetainAutorelease:

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

@@ -1,4 +1,4 @@
-; RUN: opt -S -passes=objc-arc-apelim < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc < %s | FileCheck %s
 ; rdar://10227311
 
 @llvm.global_ctors = appending global [2 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @_GLOBAL__I_x, ptr null }, { i32, ptr, ptr } { i32 65535, ptr @_GLOBAL__I_y, ptr null }]

llvm/test/Transforms/ObjCARC/apelim.ll

@@ -1,4 +1,4 @@
-; RUN: opt -S -passes=objc-arc-apelim < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc < %s | FileCheck %s
 
 ; See PR26774