[llvm-commits] [llvm] r172371 - /llvm/trunk/lib/Transforms/Scalar/ObjCARC.cpp
Michael Gottesman
mgottesman at apple.com
Sun Jan 13 16:40:44 PST 2013
(And now my boredom has been satisfied).
On Jan 13, 2013, at 4:35 PM, Michael Gottesman <mgottesman at apple.com> wrote:
> Author: mgottesman
> Date: Sun Jan 13 18:35:14 2013
> New Revision: 172371
>
> URL: http://llvm.org/viewvc/llvm-project?rev=172371&view=rev
> Log:
> Updated the documentation in ObjCARC.cpp to fit the style guide better (i.e. use doxygen). Still some work to do though.
>
> Modified:
> llvm/trunk/lib/Transforms/Scalar/ObjCARC.cpp
>
> Modified: llvm/trunk/lib/Transforms/Scalar/ObjCARC.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/ObjCARC.cpp?rev=172371&r1=172370&r2=172371&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/ObjCARC.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/ObjCARC.cpp Sun Jan 13 18:35:14 2013
> @@ -6,26 +6,26 @@
> // License. See LICENSE.TXT for details.
> //
> //===----------------------------------------------------------------------===//
> -//
> -// This file defines ObjC ARC optimizations. ARC stands for
> -// Automatic Reference Counting and is a system for managing reference counts
> -// for objects in Objective C.
> -//
> -// The optimizations performed include elimination of redundant, partially
> -// redundant, and inconsequential reference count operations, elimination of
> -// redundant weak pointer operations, pattern-matching and replacement of
> -// low-level operations into higher-level operations, and numerous minor
> -// simplifications.
> -//
> -// This file also defines a simple ARC-aware AliasAnalysis.
> -//
> -// WARNING: This file knows about certain library functions. It recognizes them
> -// by name, and hardwires knowledge of their semantics.
> -//
> -// WARNING: This file knows about how certain Objective-C library functions are
> -// used. Naive LLVM IR transformations which would otherwise be
> -// behavior-preserving may break these assumptions.
> -//
> +/// \file
> +/// This file defines ObjC ARC optimizations. ARC stands for Automatic
> +/// Reference Counting and is a system for managing reference counts for objects
> +/// in Objective C.
> +///
> +/// The optimizations performed include elimination of redundant, partially
> +/// redundant, and inconsequential reference count operations, elimination of
> +/// redundant weak pointer operations, pattern-matching and replacement of
> +/// low-level operations into higher-level operations, and numerous minor
> +/// simplifications.
> +///
> +/// This file also defines a simple ARC-aware AliasAnalysis.
> +///
> +/// WARNING: This file knows about certain library functions. It recognizes them
> +/// by name, and hardwires knowledge of their semantics.
> +///
> +/// WARNING: This file knows about how certain Objective-C library functions are
> +/// used. Naive LLVM IR transformations which would otherwise be
> +/// behavior-preserving may break these assumptions.
> +///
> //===----------------------------------------------------------------------===//
>
> #define DEBUG_TYPE "objc-arc"
> @@ -36,25 +36,23 @@
> #include "llvm/Support/raw_ostream.h"
> using namespace llvm;
>
> -// A handy option to enable/disable all optimizations in this file.
> +/// \brief A handy option to enable/disable all optimizations in this file.
> static cl::opt<bool> EnableARCOpts("enable-objc-arc-opts", cl::init(true));
>
> -//===----------------------------------------------------------------------===//
> -// Misc. Utilities
> -//===----------------------------------------------------------------------===//
> +/// \defgroup MiscUtils Miscellaneous utilities that are not ARC specific.
> +/// @{
>
> namespace {
> - /// MapVector - An associative container with fast insertion-order
> - /// (deterministic) iteration over its elements. Plus the special
> - /// blot operation.
> + /// \brief An associative container with fast insertion-order (deterministic)
> + /// iteration over its elements. Plus the special blot operation.
> template<class KeyT, class ValueT>
> class MapVector {
> - /// Map - Map keys to indices in Vector.
> + /// Map keys to indices in Vector.
> typedef DenseMap<KeyT, size_t> MapTy;
> MapTy Map;
>
> - /// Vector - Keys and values.
> typedef std::vector<std::pair<KeyT, ValueT> > VectorTy;
> + /// Keys and values.
> VectorTy Vector;
>
> public:
> @@ -112,10 +110,9 @@
> return Vector.begin() + It->second;
> }
>
> - /// blot - This is similar to erase, but instead of removing the element
> - /// from the vector, it just zeros out the key in the vector. This leaves
> - /// iterators intact, but clients must be prepared for zeroed-out keys when
> - /// iterating.
> + /// This is similar to erase, but instead of removing the element from the
> + /// vector, it just zeros out the key in the vector. This leaves iterators
> + /// intact, but clients must be prepared for zeroed-out keys when iterating.
> void blot(const KeyT &Key) {
> typename MapTy::iterator It = Map.find(Key);
> if (It == Map.end()) return;
> @@ -130,9 +127,10 @@
> };
> }
>
> -//===----------------------------------------------------------------------===//
> -// ARC Utilities.
> -//===----------------------------------------------------------------------===//
> +/// @}
> +///
> +/// \defgroup ARCUtilities Utility declarations/definitions specific to ARC.
> +/// @{
>
> #include "llvm/ADT/StringSwitch.h"
> #include "llvm/Analysis/ValueTracking.h"
> @@ -142,7 +140,8 @@
> #include "llvm/Transforms/Utils/Local.h"
>
> namespace {
> - /// InstructionClass - A simple classification for instructions.
> + /// \enum InstructionClass
> + /// \brief A simple classification for instructions.
> enum InstructionClass {
> IC_Retain, ///< objc_retain
> IC_RetainRV, ///< objc_retainAutoreleasedReturnValue
> @@ -170,8 +169,7 @@
> };
> }
>
> -/// IsPotentialUse - Test whether the given value is possible a
> -/// reference-counted pointer.
> +/// \brief Test whether the given value is possible a reference-counted pointer.
> static bool IsPotentialUse(const Value *Op) {
> // Pointers to static or stack storage are not reference-counted pointers.
> if (isa<Constant>(Op) || isa<AllocaInst>(Op))
> @@ -194,8 +192,7 @@
> return true;
> }
>
> -/// GetCallSiteClass - Helper for GetInstructionClass. Determines what kind
> -/// of construct CS is.
> +/// \brief Helper for GetInstructionClass. Determines what kind of construct CS is.
> static InstructionClass GetCallSiteClass(ImmutableCallSite CS) {
> for (ImmutableCallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end();
> I != E; ++I)
> @@ -205,8 +202,8 @@
> return CS.onlyReadsMemory() ? IC_None : IC_Call;
> }
>
> -/// GetFunctionClass - Determine if F is one of the special known Functions.
> -/// If it isn't, return IC_CallOrUser.
> +/// \brief Determine if F is one of the special known Functions. If it isn't,
> +/// return IC_CallOrUser.
> static InstructionClass GetFunctionClass(const Function *F) {
> Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
>
> @@ -278,7 +275,7 @@
> return IC_CallOrUser;
> }
>
> -/// GetInstructionClass - Determine what kind of construct V is.
> +/// \brief Determine what kind of construct V is.
> static InstructionClass GetInstructionClass(const Value *V) {
> if (const Instruction *I = dyn_cast<Instruction>(V)) {
> // Any instruction other than bitcast and gep with a pointer operand have a
> @@ -368,9 +365,11 @@
> return IC_None;
> }
>
> -/// GetBasicInstructionClass - Determine what kind of construct V is. This is
> -/// similar to GetInstructionClass except that it only detects objc runtine
> -/// calls. This allows it to be faster.
> +/// \brief Determine which objc runtime call instruction class V belongs to.
> +///
> +/// This is similar to GetInstructionClass except that it only detects objc
> +/// runtime calls. This allows it to be faster.
> +///
> static InstructionClass GetBasicInstructionClass(const Value *V) {
> if (const CallInst *CI = dyn_cast<CallInst>(V)) {
> if (const Function *F = CI->getCalledFunction())
> @@ -383,22 +382,20 @@
> return isa<InvokeInst>(V) ? IC_CallOrUser : IC_User;
> }
>
> -/// IsRetain - Test if the given class is objc_retain or
> -/// equivalent.
> +/// \brief Test if the given class is objc_retain or equivalent.
> static bool IsRetain(InstructionClass Class) {
> return Class == IC_Retain ||
> Class == IC_RetainRV;
> }
>
> -/// IsAutorelease - Test if the given class is objc_autorelease or
> -/// equivalent.
> +/// \brief Test if the given class is objc_autorelease or equivalent.
> static bool IsAutorelease(InstructionClass Class) {
> return Class == IC_Autorelease ||
> Class == IC_AutoreleaseRV;
> }
>
> -/// IsForwarding - Test if the given class represents instructions which return
> -/// their argument verbatim.
> +/// \brief Test if the given class represents instructions which return their
> +/// argument verbatim.
> static bool IsForwarding(InstructionClass Class) {
> // objc_retainBlock technically doesn't always return its argument
> // verbatim, but it doesn't matter for our purposes here.
> @@ -410,8 +407,8 @@
> Class == IC_NoopCast;
> }
>
> -/// IsNoopOnNull - Test if the given class represents instructions which do
> -/// nothing if passed a null pointer.
> +/// \brief Test if the given class represents instructions which do nothing if
> +/// passed a null pointer.
> static bool IsNoopOnNull(InstructionClass Class) {
> return Class == IC_Retain ||
> Class == IC_RetainRV ||
> @@ -421,8 +418,8 @@
> Class == IC_RetainBlock;
> }
>
> -/// IsAlwaysTail - Test if the given class represents instructions which are
> -/// always safe to mark with the "tail" keyword.
> +/// \brief Test if the given class represents instructions which are always safe to
> +/// mark with the "tail" keyword.
> static bool IsAlwaysTail(InstructionClass Class) {
> // IC_RetainBlock may be given a stack argument.
> return Class == IC_Retain ||
> @@ -441,8 +438,8 @@
> return Class == IC_Autorelease;
> }
>
> -/// IsNoThrow - Test if the given class represents instructions which are always
> -/// safe to mark with the nounwind attribute..
> +/// \brief Test if the given class represents instructions which are always safe
> +/// to mark with the nounwind attribute.
> static bool IsNoThrow(InstructionClass Class) {
> // objc_retainBlock is not nounwind because it calls user copy constructors
> // which could theoretically throw.
> @@ -455,9 +452,12 @@
> Class == IC_AutoreleasepoolPop;
> }
>
> -/// EraseInstruction - 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.
> +/// \brief 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.
> +///
> static void EraseInstruction(Instruction *CI) {
> Value *OldArg = cast<CallInst>(CI)->getArgOperand(0);
>
> @@ -476,9 +476,9 @@
> RecursivelyDeleteTriviallyDeadInstructions(OldArg);
> }
>
> -/// GetUnderlyingObjCPtr - This is a wrapper around getUnderlyingObject which
> -/// also knows how to look through objc_retain and objc_autorelease calls, which
> -/// we know to return their argument verbatim.
> +/// \brief This is a wrapper around getUnderlyingObject which also knows how to
> +/// look through objc_retain and objc_autorelease calls, which we know to return
> +/// their argument verbatim.
> static const Value *GetUnderlyingObjCPtr(const Value *V) {
> for (;;) {
> V = GetUnderlyingObject(V);
> @@ -490,9 +490,9 @@
> return V;
> }
>
> -/// StripPointerCastsAndObjCCalls - This is a wrapper around
> -/// Value::stripPointerCasts which also knows how to look through objc_retain
> -/// and objc_autorelease calls, which we know to return their argument verbatim.
> +/// \brief This is a wrapper around Value::stripPointerCasts which also knows
> +/// how to look through objc_retain and objc_autorelease calls, which we know to
> +/// return their argument verbatim.
> static const Value *StripPointerCastsAndObjCCalls(const Value *V) {
> for (;;) {
> V = V->stripPointerCasts();
> @@ -503,9 +503,9 @@
> return V;
> }
>
> -/// StripPointerCastsAndObjCCalls - This is a wrapper around
> -/// Value::stripPointerCasts which also knows how to look through objc_retain
> -/// and objc_autorelease calls, which we know to return their argument verbatim.
> +/// \brief This is a wrapper around Value::stripPointerCasts which also knows
> +/// how to look through objc_retain and objc_autorelease calls, which we know to
> +/// return their argument verbatim.
> static Value *StripPointerCastsAndObjCCalls(Value *V) {
> for (;;) {
> V = V->stripPointerCasts();
> @@ -516,16 +516,15 @@
> return V;
> }
>
> -/// GetObjCArg - Assuming the given instruction is one of the special calls such
> -/// as objc_retain or objc_release, return the argument value, stripped of no-op
> +/// \brief Assuming the given instruction is one of the special calls such as
> +/// objc_retain or objc_release, return the argument value, stripped of no-op
> /// casts and forwarding calls.
> static Value *GetObjCArg(Value *Inst) {
> return StripPointerCastsAndObjCCalls(cast<CallInst>(Inst)->getArgOperand(0));
> }
>
> -/// IsObjCIdentifiedObject - This is similar to AliasAnalysis'
> -/// isObjCIdentifiedObject, except that it uses special knowledge of
> -/// ObjC conventions...
> +/// \brief This is similar to AliasAnalysis's isObjCIdentifiedObject, except
> +/// that it uses special knowledge of ObjC conventions.
> static bool IsObjCIdentifiedObject(const Value *V) {
> // Assume that call results and arguments have their own "provenance".
> // Constants (including GlobalVariables) and Allocas are never
> @@ -558,9 +557,8 @@
> return false;
> }
>
> -/// FindSingleUseIdentifiedObject - This is similar to
> -/// StripPointerCastsAndObjCCalls but it stops as soon as it finds a value
> -/// with multiple uses.
> +/// \brief This is similar to StripPointerCastsAndObjCCalls but it stops as soon
> +/// as it finds a value with multiple uses.
> static const Value *FindSingleUseIdentifiedObject(const Value *Arg) {
> if (Arg->hasOneUse()) {
> if (const BitCastInst *BC = dyn_cast<BitCastInst>(Arg))
> @@ -592,8 +590,8 @@
> return 0;
> }
>
> -/// ModuleHasARC - Test if the given module looks interesting to run ARC
> -/// optimization on.
> +/// \brief Test if the given module looks interesting to run ARC optimization
> +/// on.
> static bool ModuleHasARC(const Module &M) {
> return
> M.getNamedValue("objc_retain") ||
> @@ -615,10 +613,12 @@
> M.getNamedValue("objc_unretainedPointer");
> }
>
> -/// DoesObjCBlockEscape - Test whether the given pointer, which is an
> -/// Objective C block pointer, does not "escape". This differs from regular
> -/// escape analysis in that a use as an argument to a call is not considered
> -/// an escape.
> +/// \brief Test whether the given pointer, which is an Objective C block pointer, does
> +/// not "escape".
> +///
> +/// This differs from regular escape analysis in that a use as an
> +/// argument to a call is not considered an escape.
> +///
> static bool DoesObjCBlockEscape(const Value *BlockPtr) {
>
> DEBUG(dbgs() << "DoesObjCBlockEscape: Target: " << *BlockPtr << "\n");
> @@ -694,17 +694,18 @@
> return false;
> }
>
> -//===----------------------------------------------------------------------===//
> -// ARC AliasAnalysis.
> -//===----------------------------------------------------------------------===//
> +/// @}
> +///
> +/// \defgroup ARCAA An extension of alias analysis using ObjC specific knowledge.
> +/// @{
>
> #include "llvm/Analysis/AliasAnalysis.h"
> #include "llvm/Analysis/Passes.h"
> #include "llvm/Pass.h"
>
> namespace {
> - /// ObjCARCAliasAnalysis - This is a simple alias analysis
> - /// implementation that uses knowledge of ARC constructs to answer queries.
> + /// \brief This is a simple alias analysis implementation that uses knowledge
> + /// of ARC constructs to answer queries.
> ///
> /// TODO: This class could be generalized to know about other ObjC-specific
> /// tricks. Such as knowing that ivars in the non-fragile ABI are non-aliasing
> @@ -722,10 +723,9 @@
> InitializeAliasAnalysis(this);
> }
>
> - /// getAdjustedAnalysisPointer - This method is used when a pass implements
> - /// an analysis interface through multiple inheritance. If needed, it
> - /// should override this to adjust the this pointer as needed for the
> - /// specified pass info.
> + /// This method is used when a pass implements an analysis interface through
> + /// multiple inheritance. If needed, it should override this to adjust the
> + /// this pointer as needed for the specified pass info.
> virtual void *getAdjustedAnalysisPointer(const void *PI) {
> if (PI == &AliasAnalysis::ID)
> return static_cast<AliasAnalysis *>(this);
> @@ -869,21 +869,22 @@
> return AliasAnalysis::getModRefInfo(CS1, CS2);
> }
>
> -//===----------------------------------------------------------------------===//
> -// ARC expansion.
> -//===----------------------------------------------------------------------===//
> +/// @}
> +///
> +/// \defgroup ARCExpansion Early ARC Optimizations.
> +/// @{
>
> #include "llvm/Support/InstIterator.h"
> #include "llvm/Transforms/Scalar.h"
>
> namespace {
> - /// ObjCARCExpand - Early ARC transformations.
> + /// \brief Early ARC transformations.
> class ObjCARCExpand : public FunctionPass {
> virtual void getAnalysisUsage(AnalysisUsage &AU) const;
> virtual bool doInitialization(Module &M);
> virtual bool runOnFunction(Function &F);
>
> - /// Run - A flag indicating whether this optimization pass should run.
> + /// A flag indicating whether this optimization pass should run.
> bool Run;
>
> public:
> @@ -956,15 +957,16 @@
> return Changed;
> }
>
> -//===----------------------------------------------------------------------===//
> -// ARC autorelease pool elimination.
> -//===----------------------------------------------------------------------===//
> +/// @}
> +///
> +/// \defgroup ARCAPElim ARC Autorelease Pool Elimination.
> +/// @{
>
> #include "llvm/ADT/STLExtras.h"
> #include "llvm/IR/Constants.h"
>
> namespace {
> - /// ObjCARCAPElim - Autorelease pool elimination.
> + /// \brief Autorelease pool elimination.
> class ObjCARCAPElim : public ModulePass {
> virtual void getAnalysisUsage(AnalysisUsage &AU) const;
> virtual bool runOnModule(Module &M);
> @@ -994,8 +996,8 @@
> AU.setPreservesCFG();
> }
>
> -/// MayAutorelease - Interprocedurally determine if calls made by the
> -/// given call site can possibly produce autoreleases.
> +/// Interprocedurally determine if calls made by the given call site can
> +/// possibly produce autoreleases.
> bool ObjCARCAPElim::MayAutorelease(ImmutableCallSite CS, unsigned Depth) {
> if (const Function *Callee = CS.getCalledFunction()) {
> if (Callee->isDeclaration() || Callee->mayBeOverridden())
> @@ -1102,9 +1104,10 @@
> return Changed;
> }
>
> -//===----------------------------------------------------------------------===//
> -// ARC optimization.
> -//===----------------------------------------------------------------------===//
> +/// @}
> +///
> +/// \defgroup ARCOpt ARC Optimization.
> +/// @{
>
> // TODO: On code like this:
> //
> @@ -1158,9 +1161,9 @@
> STATISTIC(NumPeeps, "Number of calls peephole-optimized");
>
> namespace {
> - /// ProvenanceAnalysis - This is similar to BasicAliasAnalysis, and it
> - /// uses many of the same techniques, except it uses special ObjC-specific
> - /// reasoning about pointer relationships.
> + /// \brief This is similar to BasicAliasAnalysis, and it uses many of the same
> + /// techniques, except it uses special ObjC-specific reasoning about pointer
> + /// relationships.
> class ProvenanceAnalysis {
> AliasAnalysis *AA;
>
> @@ -1228,8 +1231,8 @@
> return false;
> }
>
> -/// isStoredObjCPointer - Test if the value of P, or any value covered by its
> -/// provenance, is ever stored within the function (not counting callees).
> +/// Test if the value of P, or any value covered by its provenance, is ever
> +/// stored within the function (not counting callees).
> static bool isStoredObjCPointer(const Value *P) {
> SmallPtrSet<const Value *, 8> Visited;
> SmallVector<const Value *, 8> Worklist;
> @@ -1333,8 +1336,10 @@
> }
>
> namespace {
> - // Sequence - A sequence of states that a pointer may go through in which an
> - // objc_retain and objc_release are actually needed.
> + /// \enum Sequence
> + ///
> + /// \brief A sequence of states that a pointer may go through in which an
> + /// objc_retain and objc_release are actually needed.
> enum Sequence {
> S_None,
> S_Retain, ///< objc_retain(x)
> @@ -1375,11 +1380,11 @@
> }
>
> namespace {
> - /// RRInfo - Unidirectional information about either a
> + /// \brief Unidirectional information about either a
> /// retain-decrement-use-release sequence or release-use-decrement-retain
> /// reverese sequence.
> struct RRInfo {
> - /// KnownSafe - After an objc_retain, the reference count of the referenced
> + /// After an objc_retain, the reference count of the referenced
> /// object is known to be positive. Similarly, before an objc_release, the
> /// reference count of the referenced object is known to be positive. If
> /// there are retain-release pairs in code regions where the retain count
> @@ -1393,24 +1398,23 @@
> /// KnownSafe is true when either of these conditions is satisfied.
> bool KnownSafe;
>
> - /// IsRetainBlock - True if the Calls are objc_retainBlock calls (as
> - /// opposed to objc_retain calls).
> + /// True if the Calls are objc_retainBlock calls (as opposed to objc_retain
> + /// calls).
> bool IsRetainBlock;
>
> - /// IsTailCallRelease - True of the objc_release calls are all marked
> - /// with the "tail" keyword.
> + /// True of the objc_release calls are all marked with the "tail" keyword.
> bool IsTailCallRelease;
>
> - /// ReleaseMetadata - If the Calls are objc_release calls and they all have
> - /// a clang.imprecise_release tag, this is the metadata tag.
> + /// If the Calls are objc_release calls and they all have a
> + /// clang.imprecise_release tag, this is the metadata tag.
> MDNode *ReleaseMetadata;
>
> - /// Calls - For a top-down sequence, the set of objc_retains or
> + /// For a top-down sequence, the set of objc_retains or
> /// objc_retainBlocks. For bottom-up, the set of objc_releases.
> SmallPtrSet<Instruction *, 2> Calls;
>
> - /// ReverseInsertPts - The set of optimal insert positions for
> - /// moving calls in the opposite sequence.
> + /// The set of optimal insert positions for moving calls in the opposite
> + /// sequence.
> SmallPtrSet<Instruction *, 2> ReverseInsertPts;
>
> RRInfo() :
> @@ -1432,23 +1436,22 @@
> }
>
> namespace {
> - /// PtrState - This class summarizes several per-pointer runtime properties
> - /// which are propogated through the flow graph.
> + /// \brief This class summarizes several per-pointer runtime properties which
> + /// are propogated through the flow graph.
> class PtrState {
> - /// KnownPositiveRefCount - True if the reference count is known to
> - /// be incremented.
> + /// True if the reference count is known to be incremented.
> bool KnownPositiveRefCount;
>
> - /// Partial - True of we've seen an opportunity for partial RR elimination,
> - /// such as pushing calls into a CFG triangle or into one side of a
> - /// CFG diamond.
> + /// True of we've seen an opportunity for partial RR elimination, such as
> + /// pushing calls into a CFG triangle or into one side of a CFG diamond.
> bool Partial;
>
> - /// Seq - The current position in the sequence.
> + /// The current position in the sequence.
> Sequence Seq : 8;
>
> public:
> - /// RRI - Unidirectional information about the current sequence.
> + /// Unidirectional information about the current sequence.
> + ///
> /// TODO: Encapsulate this better.
> RRInfo RRI;
>
> @@ -1529,30 +1532,31 @@
> }
>
> namespace {
> - /// BBState - Per-BasicBlock state.
> + /// \brief Per-BasicBlock state.
> class BBState {
> - /// TopDownPathCount - The number of unique control paths from the entry
> - /// which can reach this block.
> + /// The number of unique control paths from the entry which can reach this
> + /// block.
> unsigned TopDownPathCount;
>
> - /// BottomUpPathCount - The number of unique control paths to exits
> - /// from this block.
> + /// The number of unique control paths to exits from this block.
> unsigned BottomUpPathCount;
>
> - /// MapTy - A type for PerPtrTopDown and PerPtrBottomUp.
> + /// A type for PerPtrTopDown and PerPtrBottomUp.
> typedef MapVector<const Value *, PtrState> MapTy;
>
> - /// PerPtrTopDown - The top-down traversal uses this to record information
> - /// known about a pointer at the bottom of each block.
> + /// The top-down traversal uses this to record information known about a
> + /// pointer at the bottom of each block.
> MapTy PerPtrTopDown;
>
> - /// PerPtrBottomUp - The bottom-up traversal uses this to record information
> - /// known about a pointer at the top of each block.
> + /// The bottom-up traversal uses this to record information known about a
> + /// pointer at the top of each block.
> MapTy PerPtrBottomUp;
>
> - /// Preds, Succs - Effective successors and predecessors of the current
> - /// block (this ignores ignorable edges and ignored backedges).
> + /// Effective predecessors of the current block ignoring ignorable edges and
> + /// ignored backedges.
> SmallVector<BasicBlock *, 2> Preds;
> + /// Effective successors of the current block ignoring ignorable edges and
> + /// ignored backedges.
> SmallVector<BasicBlock *, 2> Succs;
>
> public:
> @@ -1579,12 +1583,12 @@
> return PerPtrBottomUp.end();
> }
>
> - /// SetAsEntry - Mark this block as being an entry block, which has one
> - /// path from the entry by definition.
> + /// Mark this block as being an entry block, which has one path from the
> + /// entry by definition.
> void SetAsEntry() { TopDownPathCount = 1; }
>
> - /// SetAsExit - Mark this block as being an exit block, which has one
> - /// path to an exit by definition.
> + /// Mark this block as being an exit block, which has one path to an exit by
> + /// definition.
> void SetAsExit() { BottomUpPathCount = 1; }
>
> PtrState &getPtrTopDownState(const Value *Arg) {
> @@ -1608,9 +1612,9 @@
> void MergePred(const BBState &Other);
> void MergeSucc(const BBState &Other);
>
> - /// GetAllPathCount - Return the number of possible unique paths from an
> - /// entry to an exit which pass through this block. This is only valid
> - /// after both the top-down and bottom-up traversals are complete.
> + /// Return the number of possible unique paths from an entry to an exit
> + /// which pass through this block. This is only valid after both the
> + /// top-down and bottom-up traversals are complete.
> unsigned GetAllPathCount() const {
> assert(TopDownPathCount != 0);
> assert(BottomUpPathCount != 0);
> @@ -1641,8 +1645,8 @@
> BottomUpPathCount = Other.BottomUpPathCount;
> }
>
> -/// MergePred - The top-down traversal uses this to merge information about
> -/// predecessors to form the initial state for a new block.
> +/// The top-down traversal uses this to merge information about predecessors to
> +/// form the initial state for a new block.
> void BBState::MergePred(const BBState &Other) {
> // Other.TopDownPathCount can be 0, in which case it is either dead or a
> // loop backedge. Loop backedges are special.
> @@ -1672,8 +1676,8 @@
> MI->second.Merge(PtrState(), /*TopDown=*/true);
> }
>
> -/// MergeSucc - The bottom-up traversal uses this to merge information about
> -/// successors to form the initial state for a new block.
> +/// The bottom-up traversal uses this to merge information about successors to
> +/// form the initial state for a new block.
> void BBState::MergeSucc(const BBState &Other) {
> // Other.BottomUpPathCount can be 0, in which case it is either dead or a
> // loop backedge. Loop backedges are special.
> @@ -1704,34 +1708,43 @@
> }
>
> namespace {
> - /// ObjCARCOpt - The main ARC optimization pass.
> + /// \brief The main ARC optimization pass.
> class ObjCARCOpt : public FunctionPass {
> bool Changed;
> ProvenanceAnalysis PA;
>
> - /// Run - A flag indicating whether this optimization pass should run.
> + /// A flag indicating whether this optimization pass should run.
> bool Run;
>
> - /// RetainRVCallee, etc. - Declarations for ObjC runtime
> - /// functions, for use in creating calls to them. These are initialized
> - /// lazily to avoid cluttering up the Module with unused declarations.
> - Constant *RetainRVCallee, *AutoreleaseRVCallee, *ReleaseCallee,
> - *RetainCallee, *RetainBlockCallee, *AutoreleaseCallee;
> + /// Declarations for ObjC runtime functions, for use in creating calls to
> + /// them. These are initialized lazily to avoid cluttering up the Module
> + /// with unused declarations.
> +
> + /// Declaration for ObjC runtime function
> + /// objc_retainAutoreleasedReturnValue.
> + Constant *RetainRVCallee;
> + /// Declaration for ObjC runtime function objc_autoreleaseReturnValue.
> + Constant *AutoreleaseRVCallee;
> + /// Declaration for ObjC runtime function objc_release.
> + Constant *ReleaseCallee;
> + /// Declaration for ObjC runtime function objc_retain.
> + Constant *RetainCallee;
> + /// Declaration for ObjC runtime function objc_retainBlock.
> + Constant *RetainBlockCallee;
> + /// Declaration for ObjC runtime function objc_autorelease.
> + Constant *AutoreleaseCallee;
>
> - /// UsedInThisFunciton - Flags which determine whether each of the
> - /// interesting runtine functions is in fact used in the current function.
> + /// Flags which determine whether each of the interesting runtine functions
> + /// is in fact used in the current function.
> unsigned UsedInThisFunction;
>
> - /// ImpreciseReleaseMDKind - The Metadata Kind for clang.imprecise_release
> - /// metadata.
> + /// The Metadata Kind for clang.imprecise_release metadata.
> unsigned ImpreciseReleaseMDKind;
>
> - /// CopyOnEscapeMDKind - The Metadata Kind for clang.arc.copy_on_escape
> - /// metadata.
> + /// The Metadata Kind for clang.arc.copy_on_escape metadata.
> unsigned CopyOnEscapeMDKind;
>
> - /// NoObjCARCExceptionsMDKind - The Metadata Kind for
> - /// clang.arc.no_objc_arc_exceptions metadata.
> + /// The Metadata Kind for clang.arc.no_objc_arc_exceptions metadata.
> unsigned NoObjCARCExceptionsMDKind;
>
> Constant *getRetainRVCallee(Module *M);
> @@ -1929,8 +1942,8 @@
> return AutoreleaseCallee;
> }
>
> -/// IsPotentialUse - Test whether the given value is possible a
> -/// reference-counted pointer, including tests which utilize AliasAnalysis.
> +/// Test whether the given value is possible a reference-counted pointer,
> +/// including tests which utilize AliasAnalysis.
> static bool IsPotentialUse(const Value *Op, AliasAnalysis &AA) {
> // First make the rudimentary check.
> if (!IsPotentialUse(Op))
> @@ -1949,9 +1962,8 @@
> return true;
> }
>
> -/// CanAlterRefCount - Test whether the given instruction can result in a
> -/// reference count modification (positive or negative) for the pointer's
> -/// object.
> +/// Test whether the given instruction can result in a reference count
> +/// modification (positive or negative) for the pointer's object.
> static bool
> CanAlterRefCount(const Instruction *Inst, const Value *Ptr,
> ProvenanceAnalysis &PA, InstructionClass Class) {
> @@ -1985,8 +1997,8 @@
> return true;
> }
>
> -/// CanUse - Test whether the given instruction can "use" the given pointer's
> -/// object in a way that requires the reference count to be positive.
> +/// Test whether the given instruction can "use" the given pointer's object in a
> +/// way that requires the reference count to be positive.
> static bool
> CanUse(const Instruction *Inst, const Value *Ptr, ProvenanceAnalysis &PA,
> InstructionClass Class) {
> @@ -2030,8 +2042,8 @@
> return false;
> }
>
> -/// CanInterruptRV - Test whether the given instruction can autorelease
> -/// any pointer or cause an autoreleasepool pop.
> +/// Test whether the given instruction can autorelease any pointer or cause an
> +/// autoreleasepool pop.
> static bool
> CanInterruptRV(InstructionClass Class) {
> switch (Class) {
> @@ -2049,8 +2061,11 @@
> }
>
> namespace {
> - /// DependenceKind - There are several kinds of dependence-like concepts in
> - /// use here.
> + /// \enum DependenceKind
> + /// \brief Defines different dependence kinds among various ARC constructs.
> + ///
> + /// There are several kinds of dependence-like concepts in use here.
> + ///
> enum DependenceKind {
> NeedsPositiveRetainCount,
> AutoreleasePoolBoundary,
> @@ -2061,8 +2076,8 @@
> };
> }
>
> -/// Depends - Test if there can be dependencies on Inst through Arg. This
> -/// function only tests dependencies relevant for removing pairs of calls.
> +/// Test if there can be dependencies on Inst through Arg. This function only
> +/// tests dependencies relevant for removing pairs of calls.
> static bool
> Depends(DependenceKind Flavor, Instruction *Inst, const Value *Arg,
> ProvenanceAnalysis &PA) {
> @@ -2147,8 +2162,9 @@
> llvm_unreachable("Invalid dependence flavor");
> }
>
> -/// FindDependencies - Walk up the CFG from StartPos (which is in StartBB) and
> -/// find local and non-local dependencies on Arg.
> +/// Walk up the CFG from StartPos (which is in StartBB) and find local and
> +/// non-local dependencies on Arg.
> +///
> /// TODO: Cache results?
> static void
> FindDependencies(DependenceKind Flavor,
> @@ -2220,8 +2236,8 @@
> cast<GetElementPtrInst>(I)->hasAllZeroIndices());
> }
>
> -/// OptimizeRetainCall - Turn objc_retain into
> -/// objc_retainAutoreleasedReturnValue if the operand is a return value.
> +/// Turn objc_retain into objc_retainAutoreleasedReturnValue if the operand is a
> +/// return value.
> void
> ObjCARCOpt::OptimizeRetainCall(Function &F, Instruction *Retain) {
> ImmutableCallSite CS(GetObjCArg(Retain));
> @@ -2252,9 +2268,9 @@
> << *Retain << "\n");
> }
>
> -/// OptimizeRetainRVCall - Turn objc_retainAutoreleasedReturnValue into
> -/// objc_retain if the operand is not a return value. Or, if it can be paired
> -/// with an objc_autoreleaseReturnValue, delete the pair and return true.
> +/// Turn objc_retainAutoreleasedReturnValue into objc_retain if the operand is
> +/// not a return value. Or, if it can be paired with an
> +/// objc_autoreleaseReturnValue, delete the pair and return true.
> bool
> ObjCARCOpt::OptimizeRetainRVCall(Function &F, Instruction *RetainRV) {
> // Check for the argument being from an immediately preceding call or invoke.
> @@ -2316,8 +2332,8 @@
> return false;
> }
>
> -/// OptimizeAutoreleaseRVCall - Turn objc_autoreleaseReturnValue into
> -/// objc_autorelease if the result is not used as a return value.
> +/// Turn objc_autoreleaseReturnValue into objc_autorelease if the result is not
> +/// used as a return value.
> void
> ObjCARCOpt::OptimizeAutoreleaseRVCall(Function &F, Instruction *AutoreleaseRV,
> InstructionClass &Class) {
> @@ -2358,8 +2374,8 @@
>
> }
>
> -/// OptimizeIndividualCalls - Visit each call, one at a time, and make
> -/// simplifications without doing any additional analysis.
> +/// Visit each call, one at a time, and make simplifications without doing any
> +/// additional analysis.
> void ObjCARCOpt::OptimizeIndividualCalls(Function &F) {
> // Reset all the flags in preparation for recomputing them.
> UsedInThisFunction = 0;
> @@ -2635,9 +2651,9 @@
> DEBUG(dbgs() << "ObjCARCOpt::OptimizeIndividualCalls: Finished List.\n");
> }
>
> -/// CheckForCFGHazards - Check for critical edges, loop boundaries, irreducible
> -/// control flow, or other CFG structures where moving code across the edge
> -/// would result in it being executed more.
> +/// Check for critical edges, loop boundaries, irreducible control flow, or
> +/// other CFG structures where moving code across the edge would result in it
> +/// being executed more.
> void
> ObjCARCOpt::CheckForCFGHazards(const BasicBlock *BB,
> DenseMap<const BasicBlock *, BBState> &BBStates,
> @@ -3158,7 +3174,7 @@
> SmallVectorImpl<BasicBlock *> &ReverseCFGPostOrder,
> unsigned NoObjCARCExceptionsMDKind,
> DenseMap<const BasicBlock *, BBState> &BBStates) {
> - /// Visited - The visited set, for doing DFS walks.
> + /// The visited set, for doing DFS walks.
> SmallPtrSet<BasicBlock *, 16> Visited;
>
> // Do DFS, computing the PostOrder.
> @@ -3244,7 +3260,7 @@
> }
> }
>
> -// Visit - Visit the function both top-down and bottom-up.
> +// Visit the function both top-down and bottom-up.
> bool
> ObjCARCOpt::Visit(Function &F,
> DenseMap<const BasicBlock *, BBState> &BBStates,
> @@ -3279,7 +3295,7 @@
> return TopDownNestingDetected && BottomUpNestingDetected;
> }
>
> -/// MoveCalls - Move the calls in RetainsToMove and ReleasesToMove.
> +/// Move the calls in RetainsToMove and ReleasesToMove.
> void ObjCARCOpt::MoveCalls(Value *Arg,
> RRInfo &RetainsToMove,
> RRInfo &ReleasesToMove,
> @@ -3355,8 +3371,8 @@
> }
> }
>
> -/// PerformCodePlacement - Identify pairings between the retains and releases,
> -/// and delete and/or move them.
> +/// Identify pairings between the retains and releases, and delete and/or move
> +/// them.
> bool
> ObjCARCOpt::PerformCodePlacement(DenseMap<const BasicBlock *, BBState>
> &BBStates,
> @@ -3569,7 +3585,7 @@
> return AnyPairsCompletelyEliminated;
> }
>
> -/// OptimizeWeakCalls - Weak pointer optimizations.
> +/// Weak pointer optimizations.
> void ObjCARCOpt::OptimizeWeakCalls(Function &F) {
> // First, do memdep-style RLE and S2L optimizations. We can't use memdep
> // itself because it uses AliasAnalysis and we need to do provenance
> @@ -3730,8 +3746,8 @@
>
> }
>
> -/// OptimizeSequences - Identify program paths which execute sequences of
> -/// retains and releases which can be eliminated.
> +/// Identify program paths which execute sequences of retains and releases which
> +/// can be eliminated.
> bool ObjCARCOpt::OptimizeSequences(Function &F) {
> /// Releases, Retains - These are used to store the results of the main flow
> /// analysis. These use Value* as the key instead of Instruction* so that the
> @@ -3740,7 +3756,7 @@
> DenseMap<Value *, RRInfo> Releases;
> MapVector<Value *, RRInfo> Retains;
>
> - /// BBStates, This is used during the traversal of the function to track the
> + /// This is used during the traversal of the function to track the
> /// states for each identified object at each block.
> DenseMap<const BasicBlock *, BBState> BBStates;
>
> @@ -3752,7 +3768,7 @@
> NestingDetected;
> }
>
> -/// OptimizeReturns - Look for this pattern:
> +/// Look for this pattern:
> /// \code
> /// %call = call i8* @something(...)
> /// %2 = call i8* @objc_retain(i8* %call)
> @@ -3963,9 +3979,10 @@
> PA.clear();
> }
>
> -//===----------------------------------------------------------------------===//
> -// ARC contraction.
> -//===----------------------------------------------------------------------===//
> +/// @}
> +///
> +/// \defgroup ARCContract ARC Contraction.
> +/// @{
>
> // TODO: ObjCARCContract could insert PHI nodes when uses aren't
> // dominated by single calls.
> @@ -3977,30 +3994,37 @@
> STATISTIC(NumStoreStrongs, "Number objc_storeStrong calls formed");
>
> namespace {
> - /// ObjCARCContract - Late ARC optimizations. These change the IR in a way
> - /// that makes it difficult to be analyzed by ObjCARCOpt, so it's run late.
> + /// \brief Late ARC optimizations
> + ///
> + /// These change the IR in a way that makes it difficult to be analyzed by
> + /// ObjCARCOpt, so it's run late.
> class ObjCARCContract : public FunctionPass {
> bool Changed;
> AliasAnalysis *AA;
> DominatorTree *DT;
> ProvenanceAnalysis PA;
>
> - /// Run - A flag indicating whether this optimization pass should run.
> + /// A flag indicating whether this optimization pass should run.
> bool Run;
>
> - /// StoreStrongCallee, etc. - Declarations for ObjC runtime
> - /// functions, for use in creating calls to them. These are initialized
> - /// lazily to avoid cluttering up the Module with unused declarations.
> - Constant *StoreStrongCallee,
> - *RetainAutoreleaseCallee, *RetainAutoreleaseRVCallee;
> + /// Declarations for ObjC runtime functions, for use in creating calls to
> + /// them. These are initialized lazily to avoid cluttering up the Module
> + /// with unused declarations.
> +
> + /// Declaration for objc_storeStrong().
> + Constant *StoreStrongCallee;
> + /// Declaration for objc_retainAutorelease().
> + Constant *RetainAutoreleaseCallee;
> + /// Declaration for objc_retainAutoreleaseReturnValue().
> + Constant *RetainAutoreleaseRVCallee;
>
> - /// RetainRVMarker - The inline asm string to insert between calls and
> - /// RetainRV calls to make the optimization work on targets which need it.
> + /// The inline asm string to insert between calls and RetainRV calls to make
> + /// the optimization work on targets which need it.
> const MDString *RetainRVMarker;
>
> - /// StoreStrongCalls - The set of inserted objc_storeStrong calls. If
> - /// at the end of walking the function we have found no alloca
> - /// instructions, these calls can be marked "tail".
> + /// The set of inserted objc_storeStrong calls. If at the end of walking the
> + /// function we have found no alloca instructions, these calls can be marked
> + /// "tail".
> SmallPtrSet<CallInst *, 8> StoreStrongCalls;
>
> Constant *getStoreStrongCallee(Module *M);
> @@ -4099,7 +4123,7 @@
> return RetainAutoreleaseRVCallee;
> }
>
> -/// ContractAutorelease - Merge an autorelease with a retain into a fused call.
> +/// Merge an autorelease with a retain into a fused call.
> bool
> ObjCARCContract::ContractAutorelease(Function &F, Instruction *Autorelease,
> InstructionClass Class,
> @@ -4155,10 +4179,10 @@
> return true;
> }
>
> -/// ContractRelease - Attempt to merge an objc_release with a store, load, and
> -/// objc_retain to form an objc_storeStrong. This can be a little tricky because
> -/// the instructions don't always appear in order, and there may be unrelated
> -/// intervening instructions.
> +/// Attempt to merge an objc_release with a store, load, and objc_retain to form
> +/// an objc_storeStrong. This can be a little tricky because the instructions
> +/// don't always appear in order, and there may be unrelated intervening
> +/// instructions.
> void ObjCARCContract::ContractRelease(Instruction *Release,
> inst_iterator &Iter) {
> LoadInst *Load = dyn_cast<LoadInst>(GetObjCArg(Release));
> @@ -4462,3 +4486,6 @@
>
> return Changed;
> }
> +
> +/// @}
> +///
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list