src/llvm/lib/Transforms/ObjCARC/ObjCARCUtil.cpp

   1 //===- ObjCARCUtil.cpp - ObjC ARC Optimization ----------------------------===//
   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 several utility functions used by various ARC
  11 /// optimizations which are IMHO too big to be in a header file.
  12 ///
  13 /// WARNING: This file knows about certain library functions. It recognizes them
  14 /// by name, and hardwires knowledge of their semantics.
  15 ///
  16 /// WARNING: This file knows about how certain Objective-C library functions are
  17 /// used. Naive LLVM IR transformations which would otherwise be
  18 /// behavior-preserving may break these assumptions.
  19 ///
  20 //===----------------------------------------------------------------------===//
  21
  22 #include "ObjCARC.h"
  23 #include "llvm/IR/Intrinsics.h"
  24
  25 using namespace llvm;
  26 using namespace llvm::objcarc;
  27
  28 raw_ostream &llvm::objcarc::operator<<(raw_ostream &OS,
  29                                        const InstructionClass Class) {
  30   switch (Class) {
  31   case IC_Retain:
  32     return OS << "IC_Retain";
  33   case IC_RetainRV:
  34     return OS << "IC_RetainRV";
  35   case IC_RetainBlock:
  36     return OS << "IC_RetainBlock";
  37   case IC_Release:
  38     return OS << "IC_Release";
  39   case IC_Autorelease:
  40     return OS << "IC_Autorelease";
  41   case IC_AutoreleaseRV:
  42     return OS << "IC_AutoreleaseRV";
  43   case IC_AutoreleasepoolPush:
  44     return OS << "IC_AutoreleasepoolPush";
  45   case IC_AutoreleasepoolPop:
  46     return OS << "IC_AutoreleasepoolPop";
  47   case IC_NoopCast:
  48     return OS << "IC_NoopCast";
  49   case IC_FusedRetainAutorelease:
  50     return OS << "IC_FusedRetainAutorelease";
  51   case IC_FusedRetainAutoreleaseRV:
  52     return OS << "IC_FusedRetainAutoreleaseRV";
  53   case IC_LoadWeakRetained:
  54     return OS << "IC_LoadWeakRetained";
  55   case IC_StoreWeak:
  56     return OS << "IC_StoreWeak";
  57   case IC_InitWeak:
  58     return OS << "IC_InitWeak";
  59   case IC_LoadWeak:
  60     return OS << "IC_LoadWeak";
  61   case IC_MoveWeak:
  62     return OS << "IC_MoveWeak";
  63   case IC_CopyWeak:
  64     return OS << "IC_CopyWeak";
  65   case IC_DestroyWeak:
  66     return OS << "IC_DestroyWeak";
  67   case IC_StoreStrong:
  68     return OS << "IC_StoreStrong";
  69   case IC_CallOrUser:
  70     return OS << "IC_CallOrUser";
  71   case IC_Call:
  72     return OS << "IC_Call";
  73   case IC_User:
  74     return OS << "IC_User";
  75   case IC_IntrinsicUser:
  76     return OS << "IC_IntrinsicUser";
  77   case IC_None:
  78     return OS << "IC_None";
  79   }
  80   llvm_unreachable("Unknown instruction class!");
  81 }
  82
  83 InstructionClass llvm::objcarc::GetFunctionClass(const Function *F) {
  84   Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
  85
  86   // No (mandatory) arguments.
  87   if (AI == AE)
  88     return StringSwitch<InstructionClass>(F->getName())
  89       .Case("objc_autoreleasePoolPush",  IC_AutoreleasepoolPush)
  90       .Case("clang.arc.use", IC_IntrinsicUser)
  91       .Default(IC_CallOrUser);
  92
  93   // One argument.
  94   const Argument *A0 = AI++;
  95   if (AI == AE)
  96     // Argument is a pointer.
  97     if (PointerType *PTy = dyn_cast<PointerType>(A0->getType())) {
  98       Type *ETy = PTy->getElementType();
  99       // Argument is i8*.
 100       if (ETy->isIntegerTy(8))
 101         return StringSwitch<InstructionClass>(F->getName())
 102           .Case("objc_retain",                IC_Retain)
 103           .Case("objc_retainAutoreleasedReturnValue", IC_RetainRV)
 104           .Case("objc_retainBlock",           IC_RetainBlock)
 105           .Case("objc_release",               IC_Release)
 106           .Case("objc_autorelease",           IC_Autorelease)
 107           .Case("objc_autoreleaseReturnValue", IC_AutoreleaseRV)
 108           .Case("objc_autoreleasePoolPop",    IC_AutoreleasepoolPop)
 109           .Case("objc_retainedObject",        IC_NoopCast)
 110           .Case("objc_unretainedObject",      IC_NoopCast)
 111           .Case("objc_unretainedPointer",     IC_NoopCast)
 112           .Case("objc_retain_autorelease",    IC_FusedRetainAutorelease)
 113           .Case("objc_retainAutorelease",     IC_FusedRetainAutorelease)
 114           .Case("objc_retainAutoreleaseReturnValue",IC_FusedRetainAutoreleaseRV)
 115           .Case("objc_sync_enter", IC_User)
 116           .Case("objc_sync_exit", IC_User)
 117           .Default(IC_CallOrUser);
 118
 119       // Argument is i8**
 120       if (PointerType *Pte = dyn_cast<PointerType>(ETy))
 121         if (Pte->getElementType()->isIntegerTy(8))
 122           return StringSwitch<InstructionClass>(F->getName())
 123             .Case("objc_loadWeakRetained",      IC_LoadWeakRetained)
 124             .Case("objc_loadWeak",              IC_LoadWeak)
 125             .Case("objc_destroyWeak",           IC_DestroyWeak)
 126             .Default(IC_CallOrUser);
 127     }
 128
 129   // Two arguments, first is i8**.
 130   const Argument *A1 = AI++;
 131   if (AI == AE)
 132     if (PointerType *PTy = dyn_cast<PointerType>(A0->getType()))
 133       if (PointerType *Pte = dyn_cast<PointerType>(PTy->getElementType()))
 134         if (Pte->getElementType()->isIntegerTy(8))
 135           if (PointerType *PTy1 = dyn_cast<PointerType>(A1->getType())) {
 136             Type *ETy1 = PTy1->getElementType();
 137             // Second argument is i8*
 138             if (ETy1->isIntegerTy(8))
 139               return StringSwitch<InstructionClass>(F->getName())
 140                 .Case("objc_storeWeak",             IC_StoreWeak)
 141                 .Case("objc_initWeak",              IC_InitWeak)
 142                 .Case("objc_storeStrong",           IC_StoreStrong)
 143                 .Default(IC_CallOrUser);
 144             // Second argument is i8**.
 145             if (PointerType *Pte1 = dyn_cast<PointerType>(ETy1))
 146               if (Pte1->getElementType()->isIntegerTy(8))
 147                 return StringSwitch<InstructionClass>(F->getName())
 148                   .Case("objc_moveWeak",              IC_MoveWeak)
 149                   .Case("objc_copyWeak",              IC_CopyWeak)
 150                   // Ignore annotation calls. This is important to stop the
 151                   // optimizer from treating annotations as uses which would
 152                   // make the state of the pointers they are attempting to
 153                   // elucidate to be incorrect.
 154                   .Case("llvm.arc.annotation.topdown.bbstart", IC_None)
 155                   .Case("llvm.arc.annotation.topdown.bbend", IC_None)
 156                   .Case("llvm.arc.annotation.bottomup.bbstart", IC_None)
 157                   .Case("llvm.arc.annotation.bottomup.bbend", IC_None)
 158                   .Default(IC_CallOrUser);
 159           }
 160
 161   // Anything else.
 162   return IC_CallOrUser;
 163 }
 164
 165 /// \brief Determine what kind of construct V is.
 166 InstructionClass
 167 llvm::objcarc::GetInstructionClass(const Value *V) {
 168   if (const Instruction *I = dyn_cast<Instruction>(V)) {
 169     // Any instruction other than bitcast and gep with a pointer operand have a
 170     // use of an objc pointer. Bitcasts, GEPs, Selects, PHIs transfer a pointer
 171     // to a subsequent use, rather than using it themselves, in this sense.
 172     // As a short cut, several other opcodes are known to have no pointer
 173     // operands of interest. And ret is never followed by a release, so it's
 174     // not interesting to examine.
 175     switch (I->getOpcode()) {
 176     case Instruction::Call: {
 177       const CallInst *CI = cast<CallInst>(I);
 178       // Check for calls to special functions.
 179       if (const Function *F = CI->getCalledFunction()) {
 180         InstructionClass Class = GetFunctionClass(F);
 181         if (Class != IC_CallOrUser)
 182           return Class;
 183
 184         // None of the intrinsic functions do objc_release. For intrinsics, the
 185         // only question is whether or not they may be users.
 186         switch (F->getIntrinsicID()) {
 187         case Intrinsic::returnaddress: case Intrinsic::frameaddress:
 188         case Intrinsic::stacksave: case Intrinsic::stackrestore:
 189         case Intrinsic::vastart: case Intrinsic::vacopy: case Intrinsic::vaend:
 190         case Intrinsic::objectsize: case Intrinsic::prefetch:
 191         case Intrinsic::stackprotector:
 192         case Intrinsic::eh_return_i32: case Intrinsic::eh_return_i64:
 193         case Intrinsic::eh_typeid_for: case Intrinsic::eh_dwarf_cfa:
 194         case Intrinsic::eh_sjlj_lsda: case Intrinsic::eh_sjlj_functioncontext:
 195         case Intrinsic::init_trampoline: case Intrinsic::adjust_trampoline:
 196         case Intrinsic::lifetime_start: case Intrinsic::lifetime_end:
 197         case Intrinsic::invariant_start: case Intrinsic::invariant_end:
 198         // Don't let dbg info affect our results.
 199         case Intrinsic::dbg_declare: case Intrinsic::dbg_value:
 200           // Short cut: Some intrinsics obviously don't use ObjC pointers.
 201           return IC_None;
 202         default:
 203           break;
 204         }
 205       }
 206       return GetCallSiteClass(CI);
 207     }
 208     case Instruction::Invoke:
 209       return GetCallSiteClass(cast<InvokeInst>(I));
 210     case Instruction::BitCast:
 211     case Instruction::GetElementPtr:
 212     case Instruction::Select: case Instruction::PHI:
 213     case Instruction::Ret: case Instruction::Br:
 214     case Instruction::Switch: case Instruction::IndirectBr:
 215     case Instruction::Alloca: case Instruction::VAArg:
 216     case Instruction::Add: case Instruction::FAdd:
 217     case Instruction::Sub: case Instruction::FSub:
 218     case Instruction::Mul: case Instruction::FMul:
 219     case Instruction::SDiv: case Instruction::UDiv: case Instruction::FDiv:
 220     case Instruction::SRem: case Instruction::URem: case Instruction::FRem:
 221     case Instruction::Shl: case Instruction::LShr: case Instruction::AShr:
 222     case Instruction::And: case Instruction::Or: case Instruction::Xor:
 223     case Instruction::SExt: case Instruction::ZExt: case Instruction::Trunc:
 224     case Instruction::IntToPtr: case Instruction::FCmp:
 225     case Instruction::FPTrunc: case Instruction::FPExt:
 226     case Instruction::FPToUI: case Instruction::FPToSI:
 227     case Instruction::UIToFP: case Instruction::SIToFP:
 228     case Instruction::InsertElement: case Instruction::ExtractElement:
 229     case Instruction::ShuffleVector:
 230     case Instruction::ExtractValue:
 231       break;
 232     case Instruction::ICmp:
 233       // Comparing a pointer with null, or any other constant, isn't an
 234       // interesting use, because we don't care what the pointer points to, or
 235       // about the values of any other dynamic reference-counted pointers.
 236       if (IsPotentialRetainableObjPtr(I->getOperand(1)))
 237         return IC_User;
 238       break;
 239     default:
 240       // For anything else, check all the operands.
 241       // Note that this includes both operands of a Store: while the first
 242       // operand isn't actually being dereferenced, it is being stored to
 243       // memory where we can no longer track who might read it and dereference
 244       // it, so we have to consider it potentially used.
 245       for (User::const_op_iterator OI = I->op_begin(), OE = I->op_end();
 246            OI != OE; ++OI)
 247         if (IsPotentialRetainableObjPtr(*OI))
 248           return IC_User;
 249     }
 250   }
 251
 252   // Otherwise, it's totally inert for ARC purposes.
 253   return IC_None;
 254 }