LLVM  4.0.0
PreISelIntrinsicLowering.cpp
Go to the documentation of this file.
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 intrinsic.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/CodeGen/Passes.h"
16 #include "llvm/IR/Function.h"
17 #include "llvm/IR/IRBuilder.h"
18 #include "llvm/IR/Instructions.h"
19 #include "llvm/IR/Intrinsics.h"
20 #include "llvm/IR/Module.h"
21 #include "llvm/Pass.h"
22 
23 using namespace llvm;
24 
25 namespace {
26 
27 bool lowerLoadRelative(Function &F) {
28  if (F.use_empty())
29  return false;
30 
31  bool Changed = false;
33  Type *Int32PtrTy = Int32Ty->getPointerTo();
34  Type *Int8Ty = Type::getInt8Ty(F.getContext());
35 
36  for (auto I = F.use_begin(), E = F.use_end(); I != E;) {
37  auto CI = dyn_cast<CallInst>(I->getUser());
38  ++I;
39  if (!CI || CI->getCalledValue() != &F)
40  continue;
41 
42  IRBuilder<> B(CI);
43  Value *OffsetPtr =
44  B.CreateGEP(Int8Ty, CI->getArgOperand(0), CI->getArgOperand(1));
45  Value *OffsetPtrI32 = B.CreateBitCast(OffsetPtr, Int32PtrTy);
46  Value *OffsetI32 = B.CreateAlignedLoad(OffsetPtrI32, 4);
47 
48  Value *ResultPtr = B.CreateGEP(Int8Ty, CI->getArgOperand(0), OffsetI32);
49 
50  CI->replaceAllUsesWith(ResultPtr);
51  CI->eraseFromParent();
52  Changed = true;
53  }
54 
55  return Changed;
56 }
57 
58 bool lowerIntrinsics(Module &M) {
59  bool Changed = false;
60  for (Function &F : M) {
61  if (F.getName().startswith("llvm.load.relative."))
62  Changed |= lowerLoadRelative(F);
63  }
64  return Changed;
65 }
66 
67 class PreISelIntrinsicLoweringLegacyPass : public ModulePass {
68 public:
69  static char ID;
70  PreISelIntrinsicLoweringLegacyPass() : ModulePass(ID) {}
71 
72  bool runOnModule(Module &M) { return lowerIntrinsics(M); }
73 };
74 
76 }
77 
78 INITIALIZE_PASS(PreISelIntrinsicLoweringLegacyPass,
79  "pre-isel-intrinsic-lowering", "Pre-ISel Intrinsic Lowering",
80  false, false)
81 
82 namespace llvm {
84  return new PreISelIntrinsicLoweringLegacyPass;
85 }
86 
89  if (!lowerIntrinsics(M))
90  return PreservedAnalyses::all();
91  else
92  return PreservedAnalyses::none();
93 }
94 } // End llvm namespace
use_iterator use_end()
Definition: Value.h:318
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:226
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
This class represents a function call, abstracting a target machine's calling convention.
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:588
#define F(x, y, z)
Definition: MD5.cpp:51
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:264
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: PassManager.h:110
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:113
Module.h This file contains the declarations for the Module class.
use_iterator use_begin()
Definition: Value.h:310
INITIALIZE_PASS(PreISelIntrinsicLoweringLegacyPass,"pre-isel-intrinsic-lowering","Pre-ISel Intrinsic Lowering", false, false) namespace llvm
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:169
#define I(x, y, z)
Definition: MD5.cpp:54
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:235
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:287
bool use_empty() const
Definition: Value.h:299
LLVM Value Representation.
Definition: Value.h:71
ModulePass * createPreISelIntrinsicLoweringPass()
This pass lowers the .load.relative intrinsic to instructions.
PointerType * getPointerTo(unsigned AddrSpace=0) const
Return a pointer to the current type.
Definition: Type.cpp:678
A container for analyses that lazily runs them and caches their results.
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:167
IntegerType * Int32Ty