1 //===- PreISelIntrinsicLowering.cpp - Pre-ISel intrinsic lowering pass ----===//
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 //
10 // This pass implements IR lowering for the llvm.load.relative and llvm.objc.*
11 // intrinsics.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/CodeGen/PreISelIntrinsicLowering.h"
16 #include "llvm/CodeGen/Passes.h"
17 #include "llvm/IR/Function.h"
18 #include "llvm/IR/Intrinsics.h"
19 #include "llvm/IR/IRBuilder.h"
20 #include "llvm/IR/Instructions.h"
21 #include "llvm/IR/Module.h"
22 #include "llvm/IR/Type.h"
23 #include "llvm/IR/User.h"
24 #include "llvm/Pass.h"
25 #include "llvm/Support/Casting.h"
26 
27 using namespace llvm;
28 
29 static bool lowerLoadRelative(Function &F) {
30   if (F.use_empty())
31     return false;
32 
33   bool Changed = false;
34   Type *Int32Ty = Type::getInt32Ty(F.getContext());
35   Type *Int32PtrTy = Int32Ty->getPointerTo();
36   Type *Int8Ty = Type::getInt8Ty(F.getContext());
37 
38   for (auto I = F.use_begin(), E = F.use_end(); I != E;) {
39     auto CI = dyn_cast<CallInst>(I->getUser());
40     ++I;
41     if (!CI || CI->getCalledValue() != &F)
42       continue;
43 
44     IRBuilder<> B(CI);
45     Value *OffsetPtr =
46         B.CreateGEP(Int8Ty, CI->getArgOperand(0), CI->getArgOperand(1));
47     Value *OffsetPtrI32 = B.CreateBitCast(OffsetPtr, Int32PtrTy);
48     Value *OffsetI32 = B.CreateAlignedLoad(OffsetPtrI32, 4);
49 
50     Value *ResultPtr = B.CreateGEP(Int8Ty, CI->getArgOperand(0), OffsetI32);
51 
52     CI->replaceAllUsesWith(ResultPtr);
53     CI->eraseFromParent();
54     Changed = true;
55   }
56 
57   return Changed;
58 }
59 
60 static bool lowerObjCCall(Function &F, const char *NewFn,
61                           bool setNonLazyBind = false) {
62   if (F.use_empty())
63     return false;
64 
65   // If we haven't already looked up this function, check to see if the
66   // program already contains a function with this name.
67   Module *M = F.getParent();
68   Constant* FCache = M->getOrInsertFunction(NewFn, F.getFunctionType());
69 
70   if (Function* Fn = dyn_cast<Function>(FCache)) {
71     Fn->setLinkage(F.getLinkage());
72     if (setNonLazyBind && !Fn->isWeakForLinker()) {
73       // If we have Native ARC, set nonlazybind attribute for these APIs for
74       // performance.
75       Fn->addFnAttr(Attribute::NonLazyBind);
76     }
77   }
78 
79   for (auto I = F.use_begin(), E = F.use_end(); I != E;) {
80     auto *CI = dyn_cast<CallInst>(I->getUser());
81     assert(CI->getCalledFunction() && "Cannot lower an indirect call!");
82     ++I;
83 
84     IRBuilder<> Builder(CI->getParent(), CI->getIterator());
85     SmallVector<Value *, 8> Args(CI->arg_begin(), CI->arg_end());
86     CallInst *NewCI = Builder.CreateCall(FCache, Args);
87     NewCI->setName(CI->getName());
88     NewCI->setTailCallKind(CI->getTailCallKind());
89     if (!CI->use_empty())
90       CI->replaceAllUsesWith(NewCI);
91     CI->eraseFromParent();
92   }
93 
94   return true;
95 }
96 
97 static bool lowerIntrinsics(Module &M) {
98   bool Changed = false;
99   for (Function &F : M) {
100     if (F.getName().startswith("llvm.load.relative.")) {
101       Changed |= lowerLoadRelative(F);
102       continue;
103     }
104     switch (F.getIntrinsicID()) {
105     default:
106       break;
107     case Intrinsic::objc_autorelease:
108       Changed |= lowerObjCCall(F, "objc_autorelease");
109       break;
110     case Intrinsic::objc_autoreleasePoolPop:
111       Changed |= lowerObjCCall(F, "objc_autoreleasePoolPop");
112       break;
113     case Intrinsic::objc_autoreleasePoolPush:
114       Changed |= lowerObjCCall(F, "objc_autoreleasePoolPush");
115       break;
116     case Intrinsic::objc_autoreleaseReturnValue:
117       Changed |= lowerObjCCall(F, "objc_autoreleaseReturnValue");
118       break;
119     case Intrinsic::objc_copyWeak:
120       Changed |= lowerObjCCall(F, "objc_copyWeak");
121       break;
122     case Intrinsic::objc_destroyWeak:
123       Changed |= lowerObjCCall(F, "objc_destroyWeak");
124       break;
125     case Intrinsic::objc_initWeak:
126       Changed |= lowerObjCCall(F, "objc_initWeak");
127       break;
128     case Intrinsic::objc_loadWeak:
129       Changed |= lowerObjCCall(F, "objc_loadWeak");
130       break;
131     case Intrinsic::objc_loadWeakRetained:
132       Changed |= lowerObjCCall(F, "objc_loadWeakRetained");
133       break;
134     case Intrinsic::objc_moveWeak:
135       Changed |= lowerObjCCall(F, "objc_moveWeak");
136       break;
137     case Intrinsic::objc_release:
138       Changed |= lowerObjCCall(F, "objc_release", true);
139       break;
140     case Intrinsic::objc_retain:
141       Changed |= lowerObjCCall(F, "objc_retain", true);
142       break;
143     case Intrinsic::objc_retainAutorelease:
144       Changed |= lowerObjCCall(F, "objc_retainAutorelease");
145       break;
146     case Intrinsic::objc_retainAutoreleaseReturnValue:
147       Changed |= lowerObjCCall(F, "objc_retainAutoreleaseReturnValue");
148       break;
149     case Intrinsic::objc_retainAutoreleasedReturnValue:
150       Changed |= lowerObjCCall(F, "objc_retainAutoreleasedReturnValue");
151       break;
152     case Intrinsic::objc_retainBlock:
153       Changed |= lowerObjCCall(F, "objc_retainBlock");
154       break;
155     case Intrinsic::objc_storeStrong:
156       Changed |= lowerObjCCall(F, "objc_storeStrong");
157       break;
158     case Intrinsic::objc_storeWeak:
159       Changed |= lowerObjCCall(F, "objc_storeWeak");
160       break;
161     case Intrinsic::objc_unsafeClaimAutoreleasedReturnValue:
162       Changed |= lowerObjCCall(F, "objc_unsafeClaimAutoreleasedReturnValue");
163       break;
164     case Intrinsic::objc_retainedObject:
165       Changed |= lowerObjCCall(F, "objc_retainedObject");
166       break;
167     case Intrinsic::objc_unretainedObject:
168       Changed |= lowerObjCCall(F, "objc_unretainedObject");
169       break;
170     case Intrinsic::objc_unretainedPointer:
171       Changed |= lowerObjCCall(F, "objc_unretainedPointer");
172       break;
173     case Intrinsic::objc_retain_autorelease:
174       Changed |= lowerObjCCall(F, "objc_retain_autorelease");
175       break;
176     case Intrinsic::objc_sync_enter:
177       Changed |= lowerObjCCall(F, "objc_sync_enter");
178       break;
179     case Intrinsic::objc_sync_exit:
180       Changed |= lowerObjCCall(F, "objc_sync_exit");
181       break;
182     }
183   }
184   return Changed;
185 }
186 
187 namespace {
188 
189 class PreISelIntrinsicLoweringLegacyPass : public ModulePass {
190 public:
191   static char ID;
192 
193   PreISelIntrinsicLoweringLegacyPass() : ModulePass(ID) {}
194 
195   bool runOnModule(Module &M) override { return lowerIntrinsics(M); }
196 };
197 
198 } // end anonymous namespace
199 
200 char PreISelIntrinsicLoweringLegacyPass::ID;
201 
202 INITIALIZE_PASS(PreISelIntrinsicLoweringLegacyPass,
203                 "pre-isel-intrinsic-lowering", "Pre-ISel Intrinsic Lowering",
204                 false, false)
205 
206 ModulePass *llvm::createPreISelIntrinsicLoweringPass() {
207   return new PreISelIntrinsicLoweringLegacyPass;
208 }
209 
210 PreservedAnalyses PreISelIntrinsicLoweringPass::run(Module &M,
211                                                     ModuleAnalysisManager &AM) {
212   if (!lowerIntrinsics(M))
213     return PreservedAnalyses::all();
214   else
215     return PreservedAnalyses::none();
216 }
217