[Transforms] Forward declare classes & remove includes

[clemenswasser]

Summary

llvm/IR/Function.h and llvm/IR/Instructions.h were identified as quiet heavy by clang build analyzer.
Removing includes and forward declaring the relevant classes saves compilation time.

[clemenswasser]

Rebase patch

[nikic]

I think you submitted the diff the wrong way around?

[clemenswasser]

Wow, I was so confused... thanks!

[clemenswasser]

Fix Patch

[clemenswasser]

Update Patch. I reformatted but diffed the wrong commit hash, sorry :(

llvm/include/llvm/Transforms/Instrumentation/AddressSanitizer.h

 //===--------- Definition of the AddressSanitizer class ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the AddressSanitizer class which is a port of the legacy
 // AddressSanitizer pass to use the new PassManager infrastructure.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_TRANSFORMS_INSTRUMENTATION_ADDRESSSANITIZER_H
 #define LLVM_TRANSFORMS_INSTRUMENTATION_ADDRESSSANITIZER_H
 
+#include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 #include "llvm/Transforms/Instrumentation/AddressSanitizerOptions.h"
 
 namespace llvm {
 
 /// Frontend-provided metadata for source location.

llvm/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h

 //===--------- Definition of the HWAddressSanitizer class -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the Hardware AddressSanitizer class which is a port of the
 // legacy HWAddressSanitizer pass to use the new PassManager infrastructure.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_TRANSFORMS_INSTRUMENTATION_HWADDRESSSANITIZER_H
 #define LLVM_TRANSFORMS_INSTRUMENTATION_HWADDRESSSANITIZER_H
 
+#include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
 
 struct HWAddressSanitizerOptions {
   HWAddressSanitizerOptions()
       : HWAddressSanitizerOptions(false, false, false){};

llvm/include/llvm/Transforms/Instrumentation/MemProfiler.h

 //===--------- Definition of the MemProfiler class --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the MemProfiler class.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_TRANSFORMS_INSTRUMENTATION_MEMPROFILER_H
 #define LLVM_TRANSFORMS_INSTRUMENTATION_MEMPROFILER_H
 
+#include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
 
-class Function;
-
 /// Public interface to the memory profiler pass for instrumenting code to
 /// profile memory accesses.
 ///
 /// The profiler itself is a function pass that works by inserting various
 /// calls to the MemProfiler runtime library functions. The runtime library
 /// essentially replaces malloc() and free() with custom implementations that
 /// record data about the allocations.
 class MemProfilerPass : public PassInfoMixin<MemProfilerPass> {

llvm/include/llvm/Transforms/Scalar/BDCE.h

 // We track these dead bits and remove instructions that compute only these
 // dead bits.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_SCALAR_BDCE_H
 #define LLVM_TRANSFORMS_SCALAR_BDCE_H
 
+#include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 // The Bit-Tracking Dead Code Elimination pass.
 struct BDCEPass : PassInfoMixin<BDCEPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_BDCE_H

llvm/include/llvm/Transforms/Scalar/CallSiteSplitting.h

 //===- CallSiteSplitting..h - Callsite Splitting ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_SCALAR_CALLSITESPLITTING_H
 #define LLVM_TRANSFORMS_SCALAR_CALLSITESPLITTING_H
 
+#include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct CallSiteSplittingPass : PassInfoMixin<CallSiteSplittingPass> {
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_CALLSITESPLITTING_H

llvm/include/llvm/Transforms/Scalar/DCE.h

 //===- DCE.h - Dead code elimination ----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides the interface for the Dead Code Elimination pass.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_SCALAR_DCE_H
 #define LLVM_TRANSFORMS_SCALAR_DCE_H
 
+#include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 /// Basic Dead Code Elimination pass.
 class DCEPass : public PassInfoMixin<DCEPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);

llvm/include/llvm/Transforms/Scalar/DFAJumpThreading.h

 //===- DFAJumpThreading.h - Threads a switch statement inside a loop ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides the interface for the DFAJumpThreading pass.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_SCALAR_DFAJUMPTHREADING_H
 #define LLVM_TRANSFORMS_SCALAR_DFAJUMPTHREADING_H
 
+#include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
-class Function;
-
 struct DFAJumpThreadingPass : PassInfoMixin<DFAJumpThreadingPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_DFAJUMPTHREADING_H

llvm/include/llvm/Transforms/Scalar/LoopDataPrefetch.h

 //===-------- LoopDataPrefetch.h - Loop Data Prefetching Pass ---*- C++ -*-===//
 //
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 /// This file provides the interface for LLVM's Loop Data Prefetching Pass.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_SCALAR_LOOPDATAPREFETCH_H
 #define LLVM_TRANSFORMS_SCALAR_LOOPDATAPREFETCH_H
 
+#include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 /// An optimization pass inserting data prefetches in loops.
 class LoopDataPrefetchPass : public PassInfoMixin<LoopDataPrefetchPass> {
 public:
   LoopDataPrefetchPass() = default;
 
   /// Run the pass over the function.
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPDATAPREFETCH_H

llvm/include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h

 /// The header file for the LowerExpectIntrinsic pass as used by the new pass
 /// manager.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_SCALAR_LOWEREXPECTINTRINSIC_H
 #define LLVM_TRANSFORMS_SCALAR_LOWEREXPECTINTRINSIC_H
 
+#include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct LowerExpectIntrinsicPass : PassInfoMixin<LowerExpectIntrinsicPass> {
   /// Run the pass over the function.
   ///
   /// This will lower all of the expect intrinsic calls in this function into

llvm/include/llvm/Transforms/Scalar/Sink.h

 //===-- Sink.h - Code Sinking -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This pass moves instructions into successor blocks, when possible, so that
 // they aren't executed on paths where their results aren't needed.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_SCALAR_SINK_H
 #define LLVM_TRANSFORMS_SCALAR_SINK_H
 
+#include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
-class Function;
-
 /// Move instructions into successor blocks when possible.
 class SinkingPass : public PassInfoMixin<SinkingPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_SINK_H

llvm/include/llvm/Transforms/Scalar/TailRecursionElimination.h

 //  4. The algorithm we use to detect if callees access their caller stack
 //     frames is very primitive.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_SCALAR_TAILRECURSIONELIMINATION_H
 #define LLVM_TRANSFORMS_SCALAR_TAILRECURSIONELIMINATION_H
 
+#include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
-class Function;
-
 struct TailCallElimPass : PassInfoMixin<TailCallElimPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_TAILRECURSIONELIMINATION_H

llvm/include/llvm/Transforms/Utils/BreakCriticalEdges.h

 // forward declared.  This pass obviously invalidates the CFG, but can update
 // dominator trees.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_BREAKCRITICALEDGES_H
 #define LLVM_TRANSFORMS_UTILS_BREAKCRITICALEDGES_H
 
+#include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 struct BreakCriticalEdgesPass : public PassInfoMixin<BreakCriticalEdgesPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 } // namespace llvm
 #endif // LLVM_TRANSFORMS_UTILS_BREAKCRITICALEDGES_H

llvm/include/llvm/Transforms/Utils/EscapeEnumerator.h

 //===-- EscapeEnumerator.h --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines a helper class that enumerates all possible exits from a function,
 // including exception handling.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_ESCAPEENUMERATOR_H
 #define LLVM_TRANSFORMS_UTILS_ESCAPEENUMERATOR_H
 
+#include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 
 namespace llvm {
 
 class DomTreeUpdater;
 
 /// EscapeEnumerator - This is a little algorithm to find all escape points
 /// from a function so that "finally"-style code can be inserted. In addition

llvm/include/llvm/Transforms/Utils/GlobalStatus.h

 //===- GlobalStatus.h - Compute status info for globals ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_GLOBALSTATUS_H
 #define LLVM_TRANSFORMS_UTILS_GLOBALSTATUS_H
 
+#include "llvm/IR/Instructions.h"
 #include "llvm/Support/AtomicOrdering.h"
 
 namespace llvm {
 
 class Constant;
 class Function;
 class Value;
-class StoreInst;
 
 /// It is safe to destroy a constant iff it is only used by constants itself.
 /// Note that constants cannot be cyclic, so this test is pretty easy to
 /// implement recursively.
 ///
 bool isSafeToDestroyConstant(const Constant *C);
 
 /// As we analyze each global, keep track of some information about it.  If we
struct GlobalStatus {
   } StoredType = NotStored;
 
   /// If only one value (besides the initializer constant) is ever stored to
   /// this global, keep track of what value it is via the store instruction.
   const StoreInst *StoredOnceStore = nullptr;
 
   /// If only one value (besides the initializer constant) is ever stored to
   /// this global return the stored value.
-  Value *getStoredOnceValue() const;
+  Value *getStoredOnceValue() const {
+    return (StoredType == StoredOnce && StoredOnceStore)
+               ? StoredOnceStore->getOperand(0)
+               : nullptr;
+  }
 
   /// These start out null/false.  When the first accessing function is noticed,
   /// it is recorded. When a second different accessing function is noticed,
   /// HasMultipleAccessingFunctions is set to true.
   const Function *AccessingFunction = nullptr;
   bool HasMultipleAccessingFunctions = false;
 
   /// Set to the strongest atomic ordering requirement.

llvm/lib/Transforms/ObjCARC/DependencyAnalysis.h

 bool CanAlterRefCount(const Instruction *Inst, const Value *Ptr,
                       ProvenanceAnalysis &PA, ARCInstKind Class);
 
 /// Returns true if we can not conservatively prove that Inst can not decrement
 /// the reference count of Ptr. Returns false if we can.
 bool CanDecrementRefCount(const Instruction *Inst, const Value *Ptr,
                           ProvenanceAnalysis &PA, ARCInstKind Class);
 
-bool CanDecrementRefCount(const Instruction *Inst, const Value *Ptr,
-                          ProvenanceAnalysis &PA);
+static inline bool CanDecrementRefCount(const Instruction *Inst,
+                                        const Value *Ptr,
+                                        ProvenanceAnalysis &PA) {
+  return CanDecrementRefCount(Inst, Ptr, PA, GetARCInstKind(Inst));
+}
 
 } // namespace objcarc
 } // namespace llvm
 
 #endif

llvm/lib/Transforms/ObjCARC/DependencyAnalysis.cpp

 ///
 //===----------------------------------------------------------------------===//
 
 #include "DependencyAnalysis.h"
 #include "ObjCARC.h"
 #include "ProvenanceAnalysis.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/IR/CFG.h"
-#include "llvm/IR/Instructions.h"
 
 using namespace llvm;
 using namespace llvm::objcarc;
 
 #define DEBUG_TYPE "objc-arc-dependency"
 
 /// Test whether the given instruction can result in a reference count
 /// modification (positive or negative) for the pointer's object.
bool llvm::objcarc::CanDecrementRefCount(const Instruction *Inst,
   // First perform a quick check if Class can not touch ref counts.
   if (!CanDecrementRefCount(Class))
     return false;
 
   // Otherwise, just use CanAlterRefCount for now.
   return CanAlterRefCount(Inst, Ptr, PA, Class);
 }
 
-bool llvm::objcarc::CanDecrementRefCount(const Instruction *Inst, const Value *Ptr,
-                          ProvenanceAnalysis &PA) {
-  return CanDecrementRefCount(Inst, Ptr, PA, GetARCInstKind(Inst));
-}
-
 /// Test whether the given instruction can "use" the given pointer's object in a
 /// way that requires the reference count to be positive.
 bool llvm::objcarc::CanUse(const Instruction *Inst, const Value *Ptr,
                            ProvenanceAnalysis &PA, ARCInstKind Class) {
   // ARCInstKind::Call operations (as opposed to
   // ARCInstKind::CallOrUser) never "use" objc pointers.
   if (Class == ARCInstKind::Call)
     return false;

llvm/lib/Transforms/ObjCARC/ObjCARC.h

 namespace objcarc {
 
 /// Erase the given instruction.
 ///
 /// Many ObjC calls return their argument verbatim,
 /// so if it's such a call and the return value has users, replace them with the
 /// argument value.
 ///
-void EraseInstruction(Instruction *CI);
+static inline void EraseInstruction(Instruction *CI) {
+  Value *OldArg = cast<CallInst>(CI)->getArgOperand(0);
+
+  bool Unused = CI->use_empty();
+
+  if (!Unused) {
+    // Replace the return value with the argument.
+    assert((IsForwarding(GetBasicARCInstKind(CI)) ||
+            (IsNoopOnNull(GetBasicARCInstKind(CI)) &&
+             IsNullOrUndef(OldArg->stripPointerCasts()))) &&
+           "Can't delete non-forwarding instruction with users!");
+    CI->replaceAllUsesWith(OldArg);
+  }
+
+  CI->eraseFromParent();
+
+  if (Unused)
+    RecursivelyDeleteTriviallyDeadInstructions(OldArg);
+}
 
 /// If Inst is a ReturnRV and its operand is a call or invoke, return the
 /// operand. Otherwise return null.
-const Instruction *getreturnRVOperand(const Instruction &Inst,
-                                      ARCInstKind Class);
+static inline const Instruction *getreturnRVOperand(const Instruction &Inst,
+                                                    ARCInstKind Class) {
+  if (Class != ARCInstKind::RetainRV)
+    return nullptr;
+
+  const auto *Opnd = Inst.getOperand(0)->stripPointerCasts();
+  if (const auto *C = dyn_cast<CallInst>(Opnd))
+    return C;
+  return dyn_cast<InvokeInst>(Opnd);
+}
 
 /// Return the list of PHI nodes that are equivalent to PN.
-template <class PHINodeTy, class VectorTy>
+template<class PHINodeTy, class VectorTy>
 void getEquivalentPHIs(PHINodeTy &PN, VectorTy &PHIList) {
   auto *BB = PN.getParent();
   for (auto &P : BB->phis()) {
     if (&P == &PN) // Do not add PN to the list.
       continue;
     unsigned I = 0, E = PN.getNumIncomingValues();
     for (; I < E; ++I) {
       auto *BB = PN.getIncomingBlock(I);
public:
   CallInst *insertRVCall(Instruction *InsertPt, CallBase *AnnotatedCall);
 
   /// Insert a retainRV/claimRV call with colors.
   CallInst *insertRVCallWithColors(
       Instruction *InsertPt, CallBase *AnnotatedCall,
       const DenseMap<BasicBlock *, ColorVector> &BlockColors);
 
   /// See if an instruction is a bundled retainRV/claimRV call.
-  bool contains(const Instruction *I) const;
+  bool contains(const Instruction *I) const {
+    if (auto *CI = dyn_cast<CallInst>(I))
+      return RVCalls.count(CI);
+    return false;
+  }
 
   /// Remove a retainRV/claimRV call entirely.
-  void eraseInst(CallInst *CI);
+  void eraseInst(CallInst *CI) {
+    auto It = RVCalls.find(CI);
+    if (It != RVCalls.end()) {
+      // Remove call to @llvm.objc.clang.arc.noop.use.
+      for (auto U = It->second->user_begin(), E = It->second->user_end(); U != E; ++U)
+        if (auto *CI = dyn_cast<CallInst>(*U))
+          if (CI->getIntrinsicID() == Intrinsic::objc_clang_arc_noop_use) {
+            CI->eraseFromParent();
+            break;
+          }
+
+      auto *NewCall = CallBase::removeOperandBundle(
+          It->second, LLVMContext::OB_clang_arc_attachedcall, It->second);
+      NewCall->copyMetadata(*It->second);
+      It->second->replaceAllUsesWith(NewCall);
+      It->second->eraseFromParent();
+      RVCalls.erase(It);
+    }
+    EraseInstruction(CI);
+  }
 
 private:
   /// A map of inserted retainRV/claimRV calls to annotated calls/invokes.
   DenseMap<CallInst *, CallBase *> RVCalls;
 
   bool ContractPass;
 };
 
 } // end namespace objcarc
 } // end namespace llvm
 
 #endif

llvm/lib/Transforms/ObjCARC/ObjCARC.cpp

void llvm::initializeObjCARCOpts(PassRegistry &Registry) {
   initializeObjCARCOptLegacyPassPass(Registry);
   initializePAEvalPass(Registry);
 }
 
 void LLVMInitializeObjCARCOpts(LLVMPassRegistryRef R) {
   initializeObjCARCOpts(*unwrap(R));
 }
 
-void objcarc::EraseInstruction(Instruction *CI) {
-  Value *OldArg = cast<CallInst>(CI)->getArgOperand(0);
-
-  bool Unused = CI->use_empty();
-
-  if (!Unused) {
-    // Replace the return value with the argument.
-    assert((IsForwarding(GetBasicARCInstKind(CI)) ||
-            (IsNoopOnNull(GetBasicARCInstKind(CI)) &&
-             IsNullOrUndef(OldArg->stripPointerCasts()))) &&
-           "Can't delete non-forwarding instruction with users!");
-    CI->replaceAllUsesWith(OldArg);
-  }
-
-  CI->eraseFromParent();
-
-  if (Unused)
-    RecursivelyDeleteTriviallyDeadInstructions(OldArg);
-}
-
-const Instruction *objcarc::getreturnRVOperand(const Instruction &Inst,
-                                               ARCInstKind Class) {
-  if (Class != ARCInstKind::RetainRV)
-    return nullptr;
-
-  const auto *Opnd = Inst.getOperand(0)->stripPointerCasts();
-  if (const auto *C = dyn_cast<CallInst>(Opnd))
-    return C;
-  return dyn_cast<InvokeInst>(Opnd);
-}
-
 CallInst *objcarc::createCallInstWithColors(
     FunctionCallee Func, ArrayRef<Value *> Args, const Twine &NameStr,
     Instruction *InsertBefore,
     const DenseMap<BasicBlock *, ColorVector> &BlockColors) {
   FunctionType *FTy = Func.getFunctionType();
   Value *Callee = Func.getCallee();
   SmallVector<OperandBundleDef, 1> OpBundles;
 
CallInst *BundledRetainClaimRVs::insertRVCallWithColors(
   Type *ParamTy = Func->getArg(0)->getType();
   Value *CallArg = Builder.CreateBitCast(AnnotatedCall, ParamTy);
   auto *Call =
       createCallInstWithColors(Func, CallArg, "", InsertPt, BlockColors);
   RVCalls[Call] = AnnotatedCall;
   return Call;
 }
 
-bool BundledRetainClaimRVs::contains(const Instruction *I) const {
-  if (auto *CI = dyn_cast<CallInst>(I))
-    return RVCalls.count(CI);
-  return false;
-}
-
-void BundledRetainClaimRVs::eraseInst(CallInst *CI) {
-  auto It = RVCalls.find(CI);
-  if (It != RVCalls.end()) {
-    // Remove call to @llvm.objc.clang.arc.noop.use.
-    for (auto U = It->second->user_begin(), E = It->second->user_end(); U != E;
-         ++U)
-      if (auto *CI = dyn_cast<CallInst>(*U))
-        if (CI->getIntrinsicID() == Intrinsic::objc_clang_arc_noop_use) {
-          CI->eraseFromParent();
-          break;
-        }
-
-    auto *NewCall = CallBase::removeOperandBundle(
-        It->second, LLVMContext::OB_clang_arc_attachedcall, It->second);
-    NewCall->copyMetadata(*It->second);
-    It->second->replaceAllUsesWith(NewCall);
-    It->second->eraseFromParent();
-    RVCalls.erase(It);
-  }
-  EraseInstruction(CI);
-}
-
 BundledRetainClaimRVs::~BundledRetainClaimRVs() {
   for (auto P : RVCalls) {
     if (ContractPass) {
       CallBase *CB = P.second;
       // At this point, we know that the annotated calls can't be tail calls
       // as they are followed by marker instructions and retainRV/claimRV
       // calls. Mark them as notail so that the backend knows these calls
       // can't be tail calls.

llvm/lib/Transforms/ObjCARC/ObjCARCAPElim.cpp

 /// used. Naive LLVM IR transformations which would otherwise be
 /// behavior-preserving may break these assumptions.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ObjCARC.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/Constants.h"
-#include "llvm/IR/Instructions.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/ObjCARC.h"
 
 using namespace llvm;
 using namespace llvm::objcarc;

llvm/lib/Transforms/ObjCARC/ObjCARCContract.cpp

 #include "ProvenanceAnalysis.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/Analysis/ObjCARCUtil.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/InstIterator.h"
-#include "llvm/IR/Instructions.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/ObjCARC.h"
 

llvm/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp

 // This file implements a ScalarEvolution-based transformation to set
 // the alignments of load, stores and memory intrinsics based on the truth
 // expressions of assume intrinsics. The primary motivation is to handle
 // complex alignment assumptions that apply to vector loads and stores that
 // appear after vectorization and unrolling.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/IR/Instructions.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Transforms/Scalar/AlignmentFromAssumptions.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/LoopInfo.h"

llvm/lib/Transforms/Utils/GlobalStatus.cpp

if (const Constant *C = dyn_cast<Constant>(UR)) {
       // Otherwise must be some other user.
       return true;
     }
   }
 
   return false;
 }
 
-Value *GlobalStatus::getStoredOnceValue() const {
-  return (StoredType == StoredOnce && StoredOnceStore)
-             ? StoredOnceStore->getOperand(0)
-             : nullptr;
-}
-
 GlobalStatus::GlobalStatus() = default;
 
 bool GlobalStatus::analyzeGlobal(const Value *V, GlobalStatus &GS) {
   SmallPtrSet<const Value *, 16> VisitedUsers;
   return analyzeGlobalAux(V, GS, VisitedUsers);
 }

llvm/lib/Transforms/Utils/GuardUtils.cpp

 //===-- GuardUtils.cpp - Utils for work with guards -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // Utils that are used to perform transformations related to guards and their
 // conditions.
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Utils/GuardUtils.h"
 #include "llvm/Analysis/GuardUtils.h"
+#include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 
 using namespace llvm;

llvm/lib/Transforms/Utils/IntegerDivision.cpp

 //===-- IntegerDivision.cpp - Expand integer division ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains an implementation of 32bit and 64bit scalar integer
 // division for targets that don't have native support. It's largely derived
 // from compiler-rt's implementations of __udivsi3 and __udivmoddi4,
 // but hand-tuned for targets that prefer less control flow.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Utils/IntegerDivision.h"
+#include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include <utility>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "integer-division"