ObjCARC.h revision 36b56886974eae4f9c5ebc96befd3e7bfe5de338
1//===- ObjCARC.h - ObjC ARC Optimization --------------*- C++ -*-----------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9/// \file 10/// This file defines common definitions/declarations used by the ObjC ARC 11/// Optimizer. ARC stands for Automatic Reference Counting and is a system for 12/// managing reference counts for objects in Objective C. 13/// 14/// WARNING: This file knows about certain library functions. It recognizes them 15/// by name, and hardwires knowledge of their semantics. 16/// 17/// WARNING: This file knows about how certain Objective-C library functions are 18/// used. Naive LLVM IR transformations which would otherwise be 19/// behavior-preserving may break these assumptions. 20/// 21//===----------------------------------------------------------------------===// 22 23#ifndef LLVM_TRANSFORMS_SCALAR_OBJCARC_H 24#define LLVM_TRANSFORMS_SCALAR_OBJCARC_H 25 26#include "llvm/ADT/StringSwitch.h" 27#include "llvm/Analysis/AliasAnalysis.h" 28#include "llvm/Analysis/Passes.h" 29#include "llvm/Analysis/ValueTracking.h" 30#include "llvm/IR/CallSite.h" 31#include "llvm/IR/InstIterator.h" 32#include "llvm/IR/Module.h" 33#include "llvm/Pass.h" 34#include "llvm/Transforms/ObjCARC.h" 35#include "llvm/Transforms/Utils/Local.h" 36 37namespace llvm { 38class raw_ostream; 39} 40 41namespace llvm { 42namespace objcarc { 43 44/// \brief A handy option to enable/disable all ARC Optimizations. 45extern bool EnableARCOpts; 46 47/// \brief Test if the given module looks interesting to run ARC optimization 48/// on. 49static inline bool ModuleHasARC(const Module &M) { 50 return 51 M.getNamedValue("objc_retain") || 52 M.getNamedValue("objc_release") || 53 M.getNamedValue("objc_autorelease") || 54 M.getNamedValue("objc_retainAutoreleasedReturnValue") || 55 M.getNamedValue("objc_retainBlock") || 56 M.getNamedValue("objc_autoreleaseReturnValue") || 57 M.getNamedValue("objc_autoreleasePoolPush") || 58 M.getNamedValue("objc_loadWeakRetained") || 59 M.getNamedValue("objc_loadWeak") || 60 M.getNamedValue("objc_destroyWeak") || 61 M.getNamedValue("objc_storeWeak") || 62 M.getNamedValue("objc_initWeak") || 63 M.getNamedValue("objc_moveWeak") || 64 M.getNamedValue("objc_copyWeak") || 65 M.getNamedValue("objc_retainedObject") || 66 M.getNamedValue("objc_unretainedObject") || 67 M.getNamedValue("objc_unretainedPointer") || 68 M.getNamedValue("clang.arc.use"); 69} 70 71/// \enum InstructionClass 72/// \brief A simple classification for instructions. 73enum InstructionClass { 74 IC_Retain, ///< objc_retain 75 IC_RetainRV, ///< objc_retainAutoreleasedReturnValue 76 IC_RetainBlock, ///< objc_retainBlock 77 IC_Release, ///< objc_release 78 IC_Autorelease, ///< objc_autorelease 79 IC_AutoreleaseRV, ///< objc_autoreleaseReturnValue 80 IC_AutoreleasepoolPush, ///< objc_autoreleasePoolPush 81 IC_AutoreleasepoolPop, ///< objc_autoreleasePoolPop 82 IC_NoopCast, ///< objc_retainedObject, etc. 83 IC_FusedRetainAutorelease, ///< objc_retainAutorelease 84 IC_FusedRetainAutoreleaseRV, ///< objc_retainAutoreleaseReturnValue 85 IC_LoadWeakRetained, ///< objc_loadWeakRetained (primitive) 86 IC_StoreWeak, ///< objc_storeWeak (primitive) 87 IC_InitWeak, ///< objc_initWeak (derived) 88 IC_LoadWeak, ///< objc_loadWeak (derived) 89 IC_MoveWeak, ///< objc_moveWeak (derived) 90 IC_CopyWeak, ///< objc_copyWeak (derived) 91 IC_DestroyWeak, ///< objc_destroyWeak (derived) 92 IC_StoreStrong, ///< objc_storeStrong (derived) 93 IC_IntrinsicUser, ///< clang.arc.use 94 IC_CallOrUser, ///< could call objc_release and/or "use" pointers 95 IC_Call, ///< could call objc_release 96 IC_User, ///< could "use" a pointer 97 IC_None ///< anything else 98}; 99 100raw_ostream &operator<<(raw_ostream &OS, const InstructionClass Class); 101 102/// \brief Test if the given class is a kind of user. 103inline static bool IsUser(InstructionClass Class) { 104 return Class == IC_User || 105 Class == IC_CallOrUser || 106 Class == IC_IntrinsicUser; 107} 108 109/// \brief Test if the given class is objc_retain or equivalent. 110static inline bool IsRetain(InstructionClass Class) { 111 return Class == IC_Retain || 112 Class == IC_RetainRV; 113} 114 115/// \brief Test if the given class is objc_autorelease or equivalent. 116static inline bool IsAutorelease(InstructionClass Class) { 117 return Class == IC_Autorelease || 118 Class == IC_AutoreleaseRV; 119} 120 121/// \brief Test if the given class represents instructions which return their 122/// argument verbatim. 123static inline bool IsForwarding(InstructionClass Class) { 124 return Class == IC_Retain || 125 Class == IC_RetainRV || 126 Class == IC_Autorelease || 127 Class == IC_AutoreleaseRV || 128 Class == IC_NoopCast; 129} 130 131/// \brief Test if the given class represents instructions which do nothing if 132/// passed a null pointer. 133static inline bool IsNoopOnNull(InstructionClass Class) { 134 return Class == IC_Retain || 135 Class == IC_RetainRV || 136 Class == IC_Release || 137 Class == IC_Autorelease || 138 Class == IC_AutoreleaseRV || 139 Class == IC_RetainBlock; 140} 141 142/// \brief Test if the given class represents instructions which are always safe 143/// to mark with the "tail" keyword. 144static inline bool IsAlwaysTail(InstructionClass Class) { 145 // IC_RetainBlock may be given a stack argument. 146 return Class == IC_Retain || 147 Class == IC_RetainRV || 148 Class == IC_AutoreleaseRV; 149} 150 151/// \brief Test if the given class represents instructions which are never safe 152/// to mark with the "tail" keyword. 153static inline bool IsNeverTail(InstructionClass Class) { 154 /// It is never safe to tail call objc_autorelease since by tail calling 155 /// objc_autorelease, we also tail call -[NSObject autorelease] which supports 156 /// fast autoreleasing causing our object to be potentially reclaimed from the 157 /// autorelease pool which violates the semantics of __autoreleasing types in 158 /// ARC. 159 return Class == IC_Autorelease; 160} 161 162/// \brief Test if the given class represents instructions which are always safe 163/// to mark with the nounwind attribute. 164static inline bool IsNoThrow(InstructionClass Class) { 165 // objc_retainBlock is not nounwind because it calls user copy constructors 166 // which could theoretically throw. 167 return Class == IC_Retain || 168 Class == IC_RetainRV || 169 Class == IC_Release || 170 Class == IC_Autorelease || 171 Class == IC_AutoreleaseRV || 172 Class == IC_AutoreleasepoolPush || 173 Class == IC_AutoreleasepoolPop; 174} 175 176/// Test whether the given instruction can autorelease any pointer or cause an 177/// autoreleasepool pop. 178static inline bool 179CanInterruptRV(InstructionClass Class) { 180 switch (Class) { 181 case IC_AutoreleasepoolPop: 182 case IC_CallOrUser: 183 case IC_Call: 184 case IC_Autorelease: 185 case IC_AutoreleaseRV: 186 case IC_FusedRetainAutorelease: 187 case IC_FusedRetainAutoreleaseRV: 188 return true; 189 default: 190 return false; 191 } 192} 193 194/// \brief Determine if F is one of the special known Functions. If it isn't, 195/// return IC_CallOrUser. 196InstructionClass GetFunctionClass(const Function *F); 197 198/// \brief Determine which objc runtime call instruction class V belongs to. 199/// 200/// This is similar to GetInstructionClass except that it only detects objc 201/// runtime calls. This allows it to be faster. 202/// 203static inline InstructionClass GetBasicInstructionClass(const Value *V) { 204 if (const CallInst *CI = dyn_cast<CallInst>(V)) { 205 if (const Function *F = CI->getCalledFunction()) 206 return GetFunctionClass(F); 207 // Otherwise, be conservative. 208 return IC_CallOrUser; 209 } 210 211 // Otherwise, be conservative. 212 return isa<InvokeInst>(V) ? IC_CallOrUser : IC_User; 213} 214 215/// \brief Determine what kind of construct V is. 216InstructionClass GetInstructionClass(const Value *V); 217 218/// \brief This is a wrapper around getUnderlyingObject which also knows how to 219/// look through objc_retain and objc_autorelease calls, which we know to return 220/// their argument verbatim. 221static inline const Value *GetUnderlyingObjCPtr(const Value *V) { 222 for (;;) { 223 V = GetUnderlyingObject(V); 224 if (!IsForwarding(GetBasicInstructionClass(V))) 225 break; 226 V = cast<CallInst>(V)->getArgOperand(0); 227 } 228 229 return V; 230} 231 232/// \brief This is a wrapper around Value::stripPointerCasts which also knows 233/// how to look through objc_retain and objc_autorelease calls, which we know to 234/// return their argument verbatim. 235static inline const Value *StripPointerCastsAndObjCCalls(const Value *V) { 236 for (;;) { 237 V = V->stripPointerCasts(); 238 if (!IsForwarding(GetBasicInstructionClass(V))) 239 break; 240 V = cast<CallInst>(V)->getArgOperand(0); 241 } 242 return V; 243} 244 245/// \brief This is a wrapper around Value::stripPointerCasts which also knows 246/// how to look through objc_retain and objc_autorelease calls, which we know to 247/// return their argument verbatim. 248static inline Value *StripPointerCastsAndObjCCalls(Value *V) { 249 for (;;) { 250 V = V->stripPointerCasts(); 251 if (!IsForwarding(GetBasicInstructionClass(V))) 252 break; 253 V = cast<CallInst>(V)->getArgOperand(0); 254 } 255 return V; 256} 257 258/// \brief Assuming the given instruction is one of the special calls such as 259/// objc_retain or objc_release, return the argument value, stripped of no-op 260/// casts and forwarding calls. 261static inline Value *GetObjCArg(Value *Inst) { 262 return StripPointerCastsAndObjCCalls(cast<CallInst>(Inst)->getArgOperand(0)); 263} 264 265static inline bool IsNullOrUndef(const Value *V) { 266 return isa<ConstantPointerNull>(V) || isa<UndefValue>(V); 267} 268 269static inline bool IsNoopInstruction(const Instruction *I) { 270 return isa<BitCastInst>(I) || 271 (isa<GetElementPtrInst>(I) && 272 cast<GetElementPtrInst>(I)->hasAllZeroIndices()); 273} 274 275 276/// \brief Erase the given instruction. 277/// 278/// Many ObjC calls return their argument verbatim, 279/// so if it's such a call and the return value has users, replace them with the 280/// argument value. 281/// 282static inline void EraseInstruction(Instruction *CI) { 283 Value *OldArg = cast<CallInst>(CI)->getArgOperand(0); 284 285 bool Unused = CI->use_empty(); 286 287 if (!Unused) { 288 // Replace the return value with the argument. 289 assert((IsForwarding(GetBasicInstructionClass(CI)) || 290 (IsNoopOnNull(GetBasicInstructionClass(CI)) && 291 isa<ConstantPointerNull>(OldArg))) && 292 "Can't delete non-forwarding instruction with users!"); 293 CI->replaceAllUsesWith(OldArg); 294 } 295 296 CI->eraseFromParent(); 297 298 if (Unused) 299 RecursivelyDeleteTriviallyDeadInstructions(OldArg); 300} 301 302/// \brief Test whether the given value is possible a retainable object pointer. 303static inline bool IsPotentialRetainableObjPtr(const Value *Op) { 304 // Pointers to static or stack storage are not valid retainable object 305 // pointers. 306 if (isa<Constant>(Op) || isa<AllocaInst>(Op)) 307 return false; 308 // Special arguments can not be a valid retainable object pointer. 309 if (const Argument *Arg = dyn_cast<Argument>(Op)) 310 if (Arg->hasByValAttr() || 311 Arg->hasInAllocaAttr() || 312 Arg->hasNestAttr() || 313 Arg->hasStructRetAttr()) 314 return false; 315 // Only consider values with pointer types. 316 // 317 // It seemes intuitive to exclude function pointer types as well, since 318 // functions are never retainable object pointers, however clang occasionally 319 // bitcasts retainable object pointers to function-pointer type temporarily. 320 PointerType *Ty = dyn_cast<PointerType>(Op->getType()); 321 if (!Ty) 322 return false; 323 // Conservatively assume anything else is a potential retainable object 324 // pointer. 325 return true; 326} 327 328static inline bool IsPotentialRetainableObjPtr(const Value *Op, 329 AliasAnalysis &AA) { 330 // First make the rudimentary check. 331 if (!IsPotentialRetainableObjPtr(Op)) 332 return false; 333 334 // Objects in constant memory are not reference-counted. 335 if (AA.pointsToConstantMemory(Op)) 336 return false; 337 338 // Pointers in constant memory are not pointing to reference-counted objects. 339 if (const LoadInst *LI = dyn_cast<LoadInst>(Op)) 340 if (AA.pointsToConstantMemory(LI->getPointerOperand())) 341 return false; 342 343 // Otherwise assume the worst. 344 return true; 345} 346 347/// \brief Helper for GetInstructionClass. Determines what kind of construct CS 348/// is. 349static inline InstructionClass GetCallSiteClass(ImmutableCallSite CS) { 350 for (ImmutableCallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end(); 351 I != E; ++I) 352 if (IsPotentialRetainableObjPtr(*I)) 353 return CS.onlyReadsMemory() ? IC_User : IC_CallOrUser; 354 355 return CS.onlyReadsMemory() ? IC_None : IC_Call; 356} 357 358/// \brief Return true if this value refers to a distinct and identifiable 359/// object. 360/// 361/// This is similar to AliasAnalysis's isIdentifiedObject, except that it uses 362/// special knowledge of ObjC conventions. 363static inline bool IsObjCIdentifiedObject(const Value *V) { 364 // Assume that call results and arguments have their own "provenance". 365 // Constants (including GlobalVariables) and Allocas are never 366 // reference-counted. 367 if (isa<CallInst>(V) || isa<InvokeInst>(V) || 368 isa<Argument>(V) || isa<Constant>(V) || 369 isa<AllocaInst>(V)) 370 return true; 371 372 if (const LoadInst *LI = dyn_cast<LoadInst>(V)) { 373 const Value *Pointer = 374 StripPointerCastsAndObjCCalls(LI->getPointerOperand()); 375 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(Pointer)) { 376 // A constant pointer can't be pointing to an object on the heap. It may 377 // be reference-counted, but it won't be deleted. 378 if (GV->isConstant()) 379 return true; 380 StringRef Name = GV->getName(); 381 // These special variables are known to hold values which are not 382 // reference-counted pointers. 383 if (Name.startswith("\01L_OBJC_SELECTOR_REFERENCES_") || 384 Name.startswith("\01L_OBJC_CLASSLIST_REFERENCES_") || 385 Name.startswith("\01L_OBJC_CLASSLIST_SUP_REFS_$_") || 386 Name.startswith("\01L_OBJC_METH_VAR_NAME_") || 387 Name.startswith("\01l_objc_msgSend_fixup_")) 388 return true; 389 } 390 } 391 392 return false; 393} 394 395} // end namespace objcarc 396} // end namespace llvm 397 398#endif // LLVM_TRANSFORMS_SCALAR_OBJCARC_H 399