Home | History | Annotate | Download | only in ObjCARC 
      1 //===- ObjCARCUtil.cpp - ObjC ARC Optimization --------*- mode: 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 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_None:
     76     return OS << "IC_None";
     77   }
     78   llvm_unreachable("Unknown instruction class!");
     79 }
     80 
     81 InstructionClass llvm::objcarc::GetFunctionClass(const Function *F) {
     82   Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
     83 
     84   // No arguments.
     85   if (AI == AE)
     86     return StringSwitch<InstructionClass>(F->getName())
     87       .Case("objc_autoreleasePoolPush",  IC_AutoreleasepoolPush)
     88       .Default(IC_CallOrUser);
     89 
     90   // One argument.
     91   const Argument *A0 = AI++;
     92   if (AI == AE)
     93     // Argument is a pointer.
     94     if (PointerType *PTy = dyn_cast<PointerType>(A0->getType())) {
     95       Type *ETy = PTy->getElementType();
     96       // Argument is i8*.
     97       if (ETy->isIntegerTy(8))
     98         return StringSwitch<InstructionClass>(F->getName())
     99           .Case("objc_retain",                IC_Retain)
    100           .Case("objc_retainAutoreleasedReturnValue", IC_RetainRV)
    101           .Case("objc_retainBlock",           IC_RetainBlock)
    102           .Case("objc_release",               IC_Release)
    103           .Case("objc_autorelease",           IC_Autorelease)
    104           .Case("objc_autoreleaseReturnValue", IC_AutoreleaseRV)
    105           .Case("objc_autoreleasePoolPop",    IC_AutoreleasepoolPop)
    106           .Case("objc_retainedObject",        IC_NoopCast)
    107           .Case("objc_unretainedObject",      IC_NoopCast)
    108           .Case("objc_unretainedPointer",     IC_NoopCast)
    109           .Case("objc_retain_autorelease",    IC_FusedRetainAutorelease)
    110           .Case("objc_retainAutorelease",     IC_FusedRetainAutorelease)
    111           .Case("objc_retainAutoreleaseReturnValue",IC_FusedRetainAutoreleaseRV)
    112           .Default(IC_CallOrUser);
    113 
    114       // Argument is i8**
    115       if (PointerType *Pte = dyn_cast<PointerType>(ETy))
    116         if (Pte->getElementType()->isIntegerTy(8))
    117           return StringSwitch<InstructionClass>(F->getName())
    118             .Case("objc_loadWeakRetained",      IC_LoadWeakRetained)
    119             .Case("objc_loadWeak",              IC_LoadWeak)
    120             .Case("objc_destroyWeak",           IC_DestroyWeak)
    121             .Default(IC_CallOrUser);
    122     }
    123 
    124   // Two arguments, first is i8**.
    125   const Argument *A1 = AI++;
    126   if (AI == AE)
    127     if (PointerType *PTy = dyn_cast<PointerType>(A0->getType()))
    128       if (PointerType *Pte = dyn_cast<PointerType>(PTy->getElementType()))
    129         if (Pte->getElementType()->isIntegerTy(8))
    130           if (PointerType *PTy1 = dyn_cast<PointerType>(A1->getType())) {
    131             Type *ETy1 = PTy1->getElementType();
    132             // Second argument is i8*
    133             if (ETy1->isIntegerTy(8))
    134               return StringSwitch<InstructionClass>(F->getName())
    135                 .Case("objc_storeWeak",             IC_StoreWeak)
    136                 .Case("objc_initWeak",              IC_InitWeak)
    137                 .Case("objc_storeStrong",           IC_StoreStrong)
    138                 .Default(IC_CallOrUser);
    139             // Second argument is i8**.
    140             if (PointerType *Pte1 = dyn_cast<PointerType>(ETy1))
    141               if (Pte1->getElementType()->isIntegerTy(8))
    142                 return StringSwitch<InstructionClass>(F->getName())
    143                   .Case("objc_moveWeak",              IC_MoveWeak)
    144                   .Case("objc_copyWeak",              IC_CopyWeak)
    145                   .Default(IC_CallOrUser);
    146           }
    147 
    148   // Anything else.
    149   return IC_CallOrUser;
    150 }
    151 
    152 /// \brief Determine what kind of construct V is.
    153 InstructionClass
    154 llvm::objcarc::GetInstructionClass(const Value *V) {
    155   if (const Instruction *I = dyn_cast<Instruction>(V)) {
    156     // Any instruction other than bitcast and gep with a pointer operand have a
    157     // use of an objc pointer. Bitcasts, GEPs, Selects, PHIs transfer a pointer
    158     // to a subsequent use, rather than using it themselves, in this sense.
    159     // As a short cut, several other opcodes are known to have no pointer
    160     // operands of interest. And ret is never followed by a release, so it's
    161     // not interesting to examine.
    162     switch (I->getOpcode()) {
    163     case Instruction::Call: {
    164       const CallInst *CI = cast<CallInst>(I);
    165       // Check for calls to special functions.
    166       if (const Function *F = CI->getCalledFunction()) {
    167         InstructionClass Class = GetFunctionClass(F);
    168         if (Class != IC_CallOrUser)
    169           return Class;
    170 
    171         // None of the intrinsic functions do objc_release. For intrinsics, the
    172         // only question is whether or not they may be users.
    173         switch (F->getIntrinsicID()) {
    174         case Intrinsic::returnaddress: case Intrinsic::frameaddress:
    175         case Intrinsic::stacksave: case Intrinsic::stackrestore:
    176         case Intrinsic::vastart: case Intrinsic::vacopy: case Intrinsic::vaend:
    177         case Intrinsic::objectsize: case Intrinsic::prefetch:
    178         case Intrinsic::stackprotector:
    179         case Intrinsic::eh_return_i32: case Intrinsic::eh_return_i64:
    180         case Intrinsic::eh_typeid_for: case Intrinsic::eh_dwarf_cfa:
    181         case Intrinsic::eh_sjlj_lsda: case Intrinsic::eh_sjlj_functioncontext:
    182         case Intrinsic::init_trampoline: case Intrinsic::adjust_trampoline:
    183         case Intrinsic::lifetime_start: case Intrinsic::lifetime_end:
    184         case Intrinsic::invariant_start: case Intrinsic::invariant_end:
    185         // Don't let dbg info affect our results.
    186         case Intrinsic::dbg_declare: case Intrinsic::dbg_value:
    187           // Short cut: Some intrinsics obviously don't use ObjC pointers.
    188           return IC_None;
    189         default:
    190           break;
    191         }
    192       }
    193       return GetCallSiteClass(CI);
    194     }
    195     case Instruction::Invoke:
    196       return GetCallSiteClass(cast<InvokeInst>(I));
    197     case Instruction::BitCast:
    198     case Instruction::GetElementPtr:
    199     case Instruction::Select: case Instruction::PHI:
    200     case Instruction::Ret: case Instruction::Br:
    201     case Instruction::Switch: case Instruction::IndirectBr:
    202     case Instruction::Alloca: case Instruction::VAArg:
    203     case Instruction::Add: case Instruction::FAdd:
    204     case Instruction::Sub: case Instruction::FSub:
    205     case Instruction::Mul: case Instruction::FMul:
    206     case Instruction::SDiv: case Instruction::UDiv: case Instruction::FDiv:
    207     case Instruction::SRem: case Instruction::URem: case Instruction::FRem:
    208     case Instruction::Shl: case Instruction::LShr: case Instruction::AShr:
    209     case Instruction::And: case Instruction::Or: case Instruction::Xor:
    210     case Instruction::SExt: case Instruction::ZExt: case Instruction::Trunc:
    211     case Instruction::IntToPtr: case Instruction::FCmp:
    212     case Instruction::FPTrunc: case Instruction::FPExt:
    213     case Instruction::FPToUI: case Instruction::FPToSI:
    214     case Instruction::UIToFP: case Instruction::SIToFP:
    215     case Instruction::InsertElement: case Instruction::ExtractElement:
    216     case Instruction::ShuffleVector:
    217     case Instruction::ExtractValue:
    218       break;
    219     case Instruction::ICmp:
    220       // Comparing a pointer with null, or any other constant, isn't an
    221       // interesting use, because we don't care what the pointer points to, or
    222       // about the values of any other dynamic reference-counted pointers.
    223       if (IsPotentialRetainableObjPtr(I->getOperand(1)))
    224         return IC_User;
    225       break;
    226     default:
    227       // For anything else, check all the operands.
    228       // Note that this includes both operands of a Store: while the first
    229       // operand isn't actually being dereferenced, it is being stored to
    230       // memory where we can no longer track who might read it and dereference
    231       // it, so we have to consider it potentially used.
    232       for (User::const_op_iterator OI = I->op_begin(), OE = I->op_end();
    233            OI != OE; ++OI)
    234         if (IsPotentialRetainableObjPtr(*OI))
    235           return IC_User;
    236     }
    237   }
    238 
    239   // Otherwise, it's totally inert for ARC purposes.
    240   return IC_None;
    241 }
    242