1//===---- IRBuilder.cpp - Builder for LLVM Instrs -------------------------===//
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 file implements the IRBuilder class, which is used as a convenient way
11// to create LLVM instructions with a consistent and simplified interface.
12//
13//===----------------------------------------------------------------------===//
14
15#include "llvm/IR/Function.h"
16#include "llvm/IR/GlobalVariable.h"
17#include "llvm/IR/IRBuilder.h"
18#include "llvm/IR/Intrinsics.h"
19#include "llvm/IR/LLVMContext.h"
20#include "llvm/IR/Statepoint.h"
21using namespace llvm;
22
23/// CreateGlobalString - Make a new global variable with an initializer that
24/// has array of i8 type filled in with the nul terminated string value
25/// specified.  If Name is specified, it is the name of the global variable
26/// created.
27GlobalVariable *IRBuilderBase::CreateGlobalString(StringRef Str,
28                                                  const Twine &Name,
29                                                  unsigned AddressSpace) {
30  Constant *StrConstant = ConstantDataArray::getString(Context, Str);
31  Module &M = *BB->getParent()->getParent();
32  GlobalVariable *GV = new GlobalVariable(M, StrConstant->getType(),
33                                          true, GlobalValue::PrivateLinkage,
34                                          StrConstant, Name, nullptr,
35                                          GlobalVariable::NotThreadLocal,
36                                          AddressSpace);
37  GV->setUnnamedAddr(true);
38  return GV;
39}
40
41Type *IRBuilderBase::getCurrentFunctionReturnType() const {
42  assert(BB && BB->getParent() && "No current function!");
43  return BB->getParent()->getReturnType();
44}
45
46Value *IRBuilderBase::getCastedInt8PtrValue(Value *Ptr) {
47  PointerType *PT = cast<PointerType>(Ptr->getType());
48  if (PT->getElementType()->isIntegerTy(8))
49    return Ptr;
50
51  // Otherwise, we need to insert a bitcast.
52  PT = getInt8PtrTy(PT->getAddressSpace());
53  BitCastInst *BCI = new BitCastInst(Ptr, PT, "");
54  BB->getInstList().insert(InsertPt, BCI);
55  SetInstDebugLocation(BCI);
56  return BCI;
57}
58
59static CallInst *createCallHelper(Value *Callee, ArrayRef<Value *> Ops,
60                                  IRBuilderBase *Builder,
61                                  const Twine& Name="") {
62  CallInst *CI = CallInst::Create(Callee, Ops, Name);
63  Builder->GetInsertBlock()->getInstList().insert(Builder->GetInsertPoint(),CI);
64  Builder->SetInstDebugLocation(CI);
65  return CI;
66}
67
68static InvokeInst *createInvokeHelper(Value *Invokee, BasicBlock *NormalDest,
69                                      BasicBlock *UnwindDest,
70                                      ArrayRef<Value *> Ops,
71                                      IRBuilderBase *Builder,
72                                      const Twine &Name = "") {
73  InvokeInst *II =
74      InvokeInst::Create(Invokee, NormalDest, UnwindDest, Ops, Name);
75  Builder->GetInsertBlock()->getInstList().insert(Builder->GetInsertPoint(),
76                                                  II);
77  Builder->SetInstDebugLocation(II);
78  return II;
79}
80
81CallInst *IRBuilderBase::
82CreateMemSet(Value *Ptr, Value *Val, Value *Size, unsigned Align,
83             bool isVolatile, MDNode *TBAATag, MDNode *ScopeTag,
84             MDNode *NoAliasTag) {
85  Ptr = getCastedInt8PtrValue(Ptr);
86  Value *Ops[] = { Ptr, Val, Size, getInt32(Align), getInt1(isVolatile) };
87  Type *Tys[] = { Ptr->getType(), Size->getType() };
88  Module *M = BB->getParent()->getParent();
89  Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memset, Tys);
90
91  CallInst *CI = createCallHelper(TheFn, Ops, this);
92
93  // Set the TBAA info if present.
94  if (TBAATag)
95    CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
96
97  if (ScopeTag)
98    CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
99
100  if (NoAliasTag)
101    CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
102
103  return CI;
104}
105
106CallInst *IRBuilderBase::
107CreateMemCpy(Value *Dst, Value *Src, Value *Size, unsigned Align,
108             bool isVolatile, MDNode *TBAATag, MDNode *TBAAStructTag,
109             MDNode *ScopeTag, MDNode *NoAliasTag) {
110  Dst = getCastedInt8PtrValue(Dst);
111  Src = getCastedInt8PtrValue(Src);
112
113  Value *Ops[] = { Dst, Src, Size, getInt32(Align), getInt1(isVolatile) };
114  Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() };
115  Module *M = BB->getParent()->getParent();
116  Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memcpy, Tys);
117
118  CallInst *CI = createCallHelper(TheFn, Ops, this);
119
120  // Set the TBAA info if present.
121  if (TBAATag)
122    CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
123
124  // Set the TBAA Struct info if present.
125  if (TBAAStructTag)
126    CI->setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag);
127
128  if (ScopeTag)
129    CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
130
131  if (NoAliasTag)
132    CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
133
134  return CI;
135}
136
137CallInst *IRBuilderBase::
138CreateMemMove(Value *Dst, Value *Src, Value *Size, unsigned Align,
139              bool isVolatile, MDNode *TBAATag, MDNode *ScopeTag,
140              MDNode *NoAliasTag) {
141  Dst = getCastedInt8PtrValue(Dst);
142  Src = getCastedInt8PtrValue(Src);
143
144  Value *Ops[] = { Dst, Src, Size, getInt32(Align), getInt1(isVolatile) };
145  Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() };
146  Module *M = BB->getParent()->getParent();
147  Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memmove, Tys);
148
149  CallInst *CI = createCallHelper(TheFn, Ops, this);
150
151  // Set the TBAA info if present.
152  if (TBAATag)
153    CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
154
155  if (ScopeTag)
156    CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
157
158  if (NoAliasTag)
159    CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
160
161  return CI;
162}
163
164CallInst *IRBuilderBase::CreateLifetimeStart(Value *Ptr, ConstantInt *Size) {
165  assert(isa<PointerType>(Ptr->getType()) &&
166         "lifetime.start only applies to pointers.");
167  Ptr = getCastedInt8PtrValue(Ptr);
168  if (!Size)
169    Size = getInt64(-1);
170  else
171    assert(Size->getType() == getInt64Ty() &&
172           "lifetime.start requires the size to be an i64");
173  Value *Ops[] = { Size, Ptr };
174  Module *M = BB->getParent()->getParent();
175  Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::lifetime_start);
176  return createCallHelper(TheFn, Ops, this);
177}
178
179CallInst *IRBuilderBase::CreateLifetimeEnd(Value *Ptr, ConstantInt *Size) {
180  assert(isa<PointerType>(Ptr->getType()) &&
181         "lifetime.end only applies to pointers.");
182  Ptr = getCastedInt8PtrValue(Ptr);
183  if (!Size)
184    Size = getInt64(-1);
185  else
186    assert(Size->getType() == getInt64Ty() &&
187           "lifetime.end requires the size to be an i64");
188  Value *Ops[] = { Size, Ptr };
189  Module *M = BB->getParent()->getParent();
190  Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::lifetime_end);
191  return createCallHelper(TheFn, Ops, this);
192}
193
194CallInst *IRBuilderBase::CreateAssumption(Value *Cond) {
195  assert(Cond->getType() == getInt1Ty() &&
196         "an assumption condition must be of type i1");
197
198  Value *Ops[] = { Cond };
199  Module *M = BB->getParent()->getParent();
200  Value *FnAssume = Intrinsic::getDeclaration(M, Intrinsic::assume);
201  return createCallHelper(FnAssume, Ops, this);
202}
203
204/// Create a call to a Masked Load intrinsic.
205/// Ptr      - the base pointer for the load
206/// Align    - alignment of the source location
207/// Mask     - an vector of booleans which indicates what vector lanes should
208///            be accessed in memory
209/// PassThru - a pass-through value that is used to fill the masked-off lanes
210///            of the result
211/// Name     - name of the result variable
212CallInst *IRBuilderBase::CreateMaskedLoad(Value *Ptr, unsigned Align,
213                                          Value *Mask, Value *PassThru,
214                                          const Twine &Name) {
215  assert(Ptr->getType()->isPointerTy() && "Ptr must be of pointer type");
216  // DataTy is the overloaded type
217  Type *DataTy = cast<PointerType>(Ptr->getType())->getElementType();
218  assert(DataTy->isVectorTy() && "Ptr should point to a vector");
219  if (!PassThru)
220    PassThru = UndefValue::get(DataTy);
221  Value *Ops[] = { Ptr, getInt32(Align), Mask,  PassThru};
222  return CreateMaskedIntrinsic(Intrinsic::masked_load, Ops, DataTy, Name);
223}
224
225/// Create a call to a Masked Store intrinsic.
226/// Val   - the data to be stored,
227/// Ptr   - the base pointer for the store
228/// Align - alignment of the destination location
229/// Mask  - an vector of booleans which indicates what vector lanes should
230///         be accessed in memory
231CallInst *IRBuilderBase::CreateMaskedStore(Value *Val, Value *Ptr,
232                                           unsigned Align, Value *Mask) {
233  Value *Ops[] = { Val, Ptr, getInt32(Align), Mask };
234  // Type of the data to be stored - the only one overloaded type
235  return CreateMaskedIntrinsic(Intrinsic::masked_store, Ops, Val->getType());
236}
237
238/// Create a call to a Masked intrinsic, with given intrinsic Id,
239/// an array of operands - Ops, and one overloaded type - DataTy
240CallInst *IRBuilderBase::CreateMaskedIntrinsic(Intrinsic::ID Id,
241                                               ArrayRef<Value *> Ops,
242                                               Type *DataTy,
243                                               const Twine &Name) {
244  Module *M = BB->getParent()->getParent();
245  Type *OverloadedTypes[] = { DataTy };
246  Value *TheFn = Intrinsic::getDeclaration(M, Id, OverloadedTypes);
247  return createCallHelper(TheFn, Ops, this, Name);
248}
249
250template <typename T0, typename T1, typename T2, typename T3>
251static std::vector<Value *>
252getStatepointArgs(IRBuilderBase &B, uint64_t ID, uint32_t NumPatchBytes,
253                  Value *ActualCallee, uint32_t Flags, ArrayRef<T0> CallArgs,
254                  ArrayRef<T1> TransitionArgs, ArrayRef<T2> DeoptArgs,
255                  ArrayRef<T3> GCArgs) {
256  std::vector<Value *> Args;
257  Args.push_back(B.getInt64(ID));
258  Args.push_back(B.getInt32(NumPatchBytes));
259  Args.push_back(ActualCallee);
260  Args.push_back(B.getInt32(CallArgs.size()));
261  Args.push_back(B.getInt32(Flags));
262  Args.insert(Args.end(), CallArgs.begin(), CallArgs.end());
263  Args.push_back(B.getInt32(TransitionArgs.size()));
264  Args.insert(Args.end(), TransitionArgs.begin(), TransitionArgs.end());
265  Args.push_back(B.getInt32(DeoptArgs.size()));
266  Args.insert(Args.end(), DeoptArgs.begin(), DeoptArgs.end());
267  Args.insert(Args.end(), GCArgs.begin(), GCArgs.end());
268
269  return Args;
270}
271
272template <typename T0, typename T1, typename T2, typename T3>
273static CallInst *CreateGCStatepointCallCommon(
274    IRBuilderBase *Builder, uint64_t ID, uint32_t NumPatchBytes,
275    Value *ActualCallee, uint32_t Flags, ArrayRef<T0> CallArgs,
276    ArrayRef<T1> TransitionArgs, ArrayRef<T2> DeoptArgs, ArrayRef<T3> GCArgs,
277    const Twine &Name) {
278  // Extract out the type of the callee.
279  PointerType *FuncPtrType = cast<PointerType>(ActualCallee->getType());
280  assert(isa<FunctionType>(FuncPtrType->getElementType()) &&
281         "actual callee must be a callable value");
282
283  Module *M = Builder->GetInsertBlock()->getParent()->getParent();
284  // Fill in the one generic type'd argument (the function is also vararg)
285  Type *ArgTypes[] = { FuncPtrType };
286  Function *FnStatepoint =
287    Intrinsic::getDeclaration(M, Intrinsic::experimental_gc_statepoint,
288                              ArgTypes);
289
290  std::vector<llvm::Value *> Args =
291      getStatepointArgs(*Builder, ID, NumPatchBytes, ActualCallee, Flags,
292                        CallArgs, TransitionArgs, DeoptArgs, GCArgs);
293  return createCallHelper(FnStatepoint, Args, Builder, Name);
294}
295
296CallInst *IRBuilderBase::CreateGCStatepointCall(
297    uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee,
298    ArrayRef<Value *> CallArgs, ArrayRef<Value *> DeoptArgs,
299    ArrayRef<Value *> GCArgs, const Twine &Name) {
300  return CreateGCStatepointCallCommon<Value *, Value *, Value *, Value *>(
301      this, ID, NumPatchBytes, ActualCallee, uint32_t(StatepointFlags::None),
302      CallArgs, None /* No Transition Args */, DeoptArgs, GCArgs, Name);
303}
304
305CallInst *IRBuilderBase::CreateGCStatepointCall(
306    uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee, uint32_t Flags,
307    ArrayRef<Use> CallArgs, ArrayRef<Use> TransitionArgs,
308    ArrayRef<Use> DeoptArgs, ArrayRef<Value *> GCArgs, const Twine &Name) {
309  return CreateGCStatepointCallCommon<Use, Use, Use, Value *>(
310      this, ID, NumPatchBytes, ActualCallee, Flags, CallArgs, TransitionArgs,
311      DeoptArgs, GCArgs, Name);
312}
313
314CallInst *IRBuilderBase::CreateGCStatepointCall(
315    uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee,
316    ArrayRef<Use> CallArgs, ArrayRef<Value *> DeoptArgs,
317    ArrayRef<Value *> GCArgs, const Twine &Name) {
318  return CreateGCStatepointCallCommon<Use, Value *, Value *, Value *>(
319      this, ID, NumPatchBytes, ActualCallee, uint32_t(StatepointFlags::None),
320      CallArgs, None, DeoptArgs, GCArgs, Name);
321}
322
323template <typename T0, typename T1, typename T2, typename T3>
324static InvokeInst *CreateGCStatepointInvokeCommon(
325    IRBuilderBase *Builder, uint64_t ID, uint32_t NumPatchBytes,
326    Value *ActualInvokee, BasicBlock *NormalDest, BasicBlock *UnwindDest,
327    uint32_t Flags, ArrayRef<T0> InvokeArgs, ArrayRef<T1> TransitionArgs,
328    ArrayRef<T2> DeoptArgs, ArrayRef<T3> GCArgs, const Twine &Name) {
329  // Extract out the type of the callee.
330  PointerType *FuncPtrType = cast<PointerType>(ActualInvokee->getType());
331  assert(isa<FunctionType>(FuncPtrType->getElementType()) &&
332         "actual callee must be a callable value");
333
334  Module *M = Builder->GetInsertBlock()->getParent()->getParent();
335  // Fill in the one generic type'd argument (the function is also vararg)
336  Function *FnStatepoint = Intrinsic::getDeclaration(
337      M, Intrinsic::experimental_gc_statepoint, {FuncPtrType});
338
339  std::vector<llvm::Value *> Args =
340      getStatepointArgs(*Builder, ID, NumPatchBytes, ActualInvokee, Flags,
341                        InvokeArgs, TransitionArgs, DeoptArgs, GCArgs);
342  return createInvokeHelper(FnStatepoint, NormalDest, UnwindDest, Args, Builder,
343                            Name);
344}
345
346InvokeInst *IRBuilderBase::CreateGCStatepointInvoke(
347    uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
348    BasicBlock *NormalDest, BasicBlock *UnwindDest,
349    ArrayRef<Value *> InvokeArgs, ArrayRef<Value *> DeoptArgs,
350    ArrayRef<Value *> GCArgs, const Twine &Name) {
351  return CreateGCStatepointInvokeCommon<Value *, Value *, Value *, Value *>(
352      this, ID, NumPatchBytes, ActualInvokee, NormalDest, UnwindDest,
353      uint32_t(StatepointFlags::None), InvokeArgs, None /* No Transition Args*/,
354      DeoptArgs, GCArgs, Name);
355}
356
357InvokeInst *IRBuilderBase::CreateGCStatepointInvoke(
358    uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
359    BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags,
360    ArrayRef<Use> InvokeArgs, ArrayRef<Use> TransitionArgs,
361    ArrayRef<Use> DeoptArgs, ArrayRef<Value *> GCArgs, const Twine &Name) {
362  return CreateGCStatepointInvokeCommon<Use, Use, Use, Value *>(
363      this, ID, NumPatchBytes, ActualInvokee, NormalDest, UnwindDest, Flags,
364      InvokeArgs, TransitionArgs, DeoptArgs, GCArgs, Name);
365}
366
367InvokeInst *IRBuilderBase::CreateGCStatepointInvoke(
368    uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
369    BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs,
370    ArrayRef<Value *> DeoptArgs, ArrayRef<Value *> GCArgs, const Twine &Name) {
371  return CreateGCStatepointInvokeCommon<Use, Value *, Value *, Value *>(
372      this, ID, NumPatchBytes, ActualInvokee, NormalDest, UnwindDest,
373      uint32_t(StatepointFlags::None), InvokeArgs, None, DeoptArgs, GCArgs,
374      Name);
375}
376
377CallInst *IRBuilderBase::CreateGCResult(Instruction *Statepoint,
378                                       Type *ResultType,
379                                       const Twine &Name) {
380 Intrinsic::ID ID = Intrinsic::experimental_gc_result;
381 Module *M = BB->getParent()->getParent();
382 Type *Types[] = {ResultType};
383 Value *FnGCResult = Intrinsic::getDeclaration(M, ID, Types);
384
385 Value *Args[] = {Statepoint};
386 return createCallHelper(FnGCResult, Args, this, Name);
387}
388
389CallInst *IRBuilderBase::CreateGCRelocate(Instruction *Statepoint,
390                                         int BaseOffset,
391                                         int DerivedOffset,
392                                         Type *ResultType,
393                                         const Twine &Name) {
394 Module *M = BB->getParent()->getParent();
395 Type *Types[] = {ResultType};
396 Value *FnGCRelocate =
397   Intrinsic::getDeclaration(M, Intrinsic::experimental_gc_relocate, Types);
398
399 Value *Args[] = {Statepoint,
400                  getInt32(BaseOffset),
401                  getInt32(DerivedOffset)};
402 return createCallHelper(FnGCRelocate, Args, this, Name);
403}
404