1//===- llvm/IRBuilder.h - Builder for LLVM Instructions ---------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the IRBuilder class, which is used as a convenient way
10// to create LLVM instructions with a consistent and simplified interface.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_IR_IRBUILDER_H
15#define LLVM_IR_IRBUILDER_H
16
17#include "llvm-c/Types.h"
18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/None.h"
20#include "llvm/ADT/STLExtras.h"
21#include "llvm/ADT/StringRef.h"
22#include "llvm/ADT/Twine.h"
23#include "llvm/IR/BasicBlock.h"
24#include "llvm/IR/Constant.h"
25#include "llvm/IR/ConstantFolder.h"
26#include "llvm/IR/Constants.h"
27#include "llvm/IR/DataLayout.h"
28#include "llvm/IR/DebugInfoMetadata.h"
29#include "llvm/IR/DebugLoc.h"
30#include "llvm/IR/DerivedTypes.h"
31#include "llvm/IR/Function.h"
32#include "llvm/IR/GlobalVariable.h"
33#include "llvm/IR/InstrTypes.h"
34#include "llvm/IR/Instruction.h"
35#include "llvm/IR/Instructions.h"
36#include "llvm/IR/IntrinsicInst.h"
37#include "llvm/IR/LLVMContext.h"
38#include "llvm/IR/Module.h"
39#include "llvm/IR/Operator.h"
40#include "llvm/IR/Type.h"
41#include "llvm/IR/Value.h"
42#include "llvm/IR/ValueHandle.h"
43#include "llvm/Support/AtomicOrdering.h"
44#include "llvm/Support/CBindingWrapping.h"
45#include "llvm/Support/Casting.h"
46#include <cassert>
47#include <cstddef>
48#include <cstdint>
49#include <functional>
50#include <utility>
51
52namespace llvm {
53
54class APInt;
55class MDNode;
56class Use;
57
58/// This provides the default implementation of the IRBuilder
59/// 'InsertHelper' method that is called whenever an instruction is created by
60/// IRBuilder and needs to be inserted.
61///
62/// By default, this inserts the instruction at the insertion point.
63class IRBuilderDefaultInserter {
64public:
65 virtual ~IRBuilderDefaultInserter();
66
67 virtual void InsertHelper(Instruction *I, const Twine &Name,
68 BasicBlock *BB,
69 BasicBlock::iterator InsertPt) const {
70 if (BB) BB->getInstList().insert(InsertPt, I);
71 I->setName(Name);
72 }
73};
74
75/// Provides an 'InsertHelper' that calls a user-provided callback after
76/// performing the default insertion.
77class IRBuilderCallbackInserter : public IRBuilderDefaultInserter {
78 std::function<void(Instruction *)> Callback;
79
80public:
81 virtual ~IRBuilderCallbackInserter();
82
83 IRBuilderCallbackInserter(std::function<void(Instruction *)> Callback)
84 : Callback(std::move(Callback)) {}
85
86 void InsertHelper(Instruction *I, const Twine &Name,
87 BasicBlock *BB,
88 BasicBlock::iterator InsertPt) const override {
89 IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);
90 Callback(I);
91 }
92};
93
94/// Common base class shared among various IRBuilders.
95class IRBuilderBase {
96 /// Pairs of (metadata kind, MDNode *) that should be added to all newly
97 /// created instructions, like !dbg metadata.
98 SmallVector<std::pair<unsigned, MDNode *>, 2> MetadataToCopy;
99
100 /// Add or update the an entry (Kind, MD) to MetadataToCopy, if \p MD is not
101 /// null. If \p MD is null, remove the entry with \p Kind.
102 void AddOrRemoveMetadataToCopy(unsigned Kind, MDNode *MD) {
103 if (!MD) {
104 erase_if(MetadataToCopy, [Kind](const std::pair<unsigned, MDNode *> &KV) {
105 return KV.first == Kind;
106 });
107 return;
108 }
109
110 for (auto &KV : MetadataToCopy)
111 if (KV.first == Kind) {
112 KV.second = MD;
113 return;
114 }
115
116 MetadataToCopy.emplace_back(Kind, MD);
117 }
118
119protected:
120 BasicBlock *BB;
121 BasicBlock::iterator InsertPt;
122 LLVMContext &Context;
123 const IRBuilderFolder &Folder;
124 const IRBuilderDefaultInserter &Inserter;
125
126 MDNode *DefaultFPMathTag;
127 FastMathFlags FMF;
128
129 bool IsFPConstrained;
130 fp::ExceptionBehavior DefaultConstrainedExcept;
131 RoundingMode DefaultConstrainedRounding;
132
133 ArrayRef<OperandBundleDef> DefaultOperandBundles;
134
135public:
136 IRBuilderBase(LLVMContext &context, const IRBuilderFolder &Folder,
137 const IRBuilderDefaultInserter &Inserter,
138 MDNode *FPMathTag, ArrayRef<OperandBundleDef> OpBundles)
139 : Context(context), Folder(Folder), Inserter(Inserter),
140 DefaultFPMathTag(FPMathTag), IsFPConstrained(false),
141 DefaultConstrainedExcept(fp::ebStrict),
142 DefaultConstrainedRounding(RoundingMode::Dynamic),
143 DefaultOperandBundles(OpBundles) {
144 ClearInsertionPoint();
145 }
146
147 /// Insert and return the specified instruction.
148 template<typename InstTy>
149 InstTy *Insert(InstTy *I, const Twine &Name = "") const {
150 Inserter.InsertHelper(I, Name, BB, InsertPt);
151 AddMetadataToInst(I);
152 return I;
153 }
154
155 /// No-op overload to handle constants.
156 Constant *Insert(Constant *C, const Twine& = "") const {
157 return C;
158 }
159
160 Value *Insert(Value *V, const Twine &Name = "") const {
161 if (Instruction *I = dyn_cast<Instruction>(V))
162 return Insert(I, Name);
163 assert(isa<Constant>(V));
164 return V;
165 }
166
167 //===--------------------------------------------------------------------===//
168 // Builder configuration methods
169 //===--------------------------------------------------------------------===//
170
171 /// Clear the insertion point: created instructions will not be
172 /// inserted into a block.
173 void ClearInsertionPoint() {
174 BB = nullptr;
175 InsertPt = BasicBlock::iterator();
176 }
177
178 BasicBlock *GetInsertBlock() const { return BB; }
179 BasicBlock::iterator GetInsertPoint() const { return InsertPt; }
180 LLVMContext &getContext() const { return Context; }
181
182 /// This specifies that created instructions should be appended to the
183 /// end of the specified block.
184 void SetInsertPoint(BasicBlock *TheBB) {
185 BB = TheBB;
186 InsertPt = BB->end();
187 }
188
189 /// This specifies that created instructions should be inserted before
190 /// the specified instruction.
191 void SetInsertPoint(Instruction *I) {
192 BB = I->getParent();
193 InsertPt = I->getIterator();
194 assert(InsertPt != BB->end() && "Can't read debug loc from end()");
195 SetCurrentDebugLocation(I->getDebugLoc());
196 }
197
198 /// This specifies that created instructions should be inserted at the
199 /// specified point.
200 void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {
201 BB = TheBB;
202 InsertPt = IP;
203 if (IP != TheBB->end())
204 SetCurrentDebugLocation(IP->getDebugLoc());
205 }
206
207 /// Set location information used by debugging information.
208 void SetCurrentDebugLocation(DebugLoc L) {
209 AddOrRemoveMetadataToCopy(LLVMContext::MD_dbg, L.getAsMDNode());
210 }
211
212 /// Collect metadata with IDs \p MetadataKinds from \p Src which should be
213 /// added to all created instructions. Entries present in MedataDataToCopy but
214 /// not on \p Src will be dropped from MetadataToCopy.
215 void CollectMetadataToCopy(Instruction *Src,
216 ArrayRef<unsigned> MetadataKinds) {
217 for (unsigned K : MetadataKinds)
218 AddOrRemoveMetadataToCopy(K, Src->getMetadata(K));
219 }
220
221 /// Get location information used by debugging information.
222 DebugLoc getCurrentDebugLocation() const {
223 for (auto &KV : MetadataToCopy)
224 if (KV.first == LLVMContext::MD_dbg)
225 return {cast<DILocation>(KV.second)};
226
227 return {};
228 }
229
230 /// If this builder has a current debug location, set it on the
231 /// specified instruction.
232 void SetInstDebugLocation(Instruction *I) const {
233 for (const auto &KV : MetadataToCopy)
234 if (KV.first == LLVMContext::MD_dbg) {
235 I->setDebugLoc(DebugLoc(KV.second));
236 return;
237 }
238 }
239
240 /// Add all entries in MetadataToCopy to \p I.
241 void AddMetadataToInst(Instruction *I) const {
242 for (auto &KV : MetadataToCopy)
243 I->setMetadata(KV.first, KV.second);
244 }
245
246 /// Get the return type of the current function that we're emitting
247 /// into.
248 Type *getCurrentFunctionReturnType() const;
249
250 /// InsertPoint - A saved insertion point.
251 class InsertPoint {
252 BasicBlock *Block = nullptr;
253 BasicBlock::iterator Point;
254
255 public:
256 /// Creates a new insertion point which doesn't point to anything.
257 InsertPoint() = default;
258
259 /// Creates a new insertion point at the given location.
260 InsertPoint(BasicBlock *InsertBlock, BasicBlock::iterator InsertPoint)
261 : Block(InsertBlock), Point(InsertPoint) {}
262
263 /// Returns true if this insert point is set.
264 bool isSet() const { return (Block != nullptr); }
265
266 BasicBlock *getBlock() const { return Block; }
267 BasicBlock::iterator getPoint() const { return Point; }
268 };
269
270 /// Returns the current insert point.
271 InsertPoint saveIP() const {
272 return InsertPoint(GetInsertBlock(), GetInsertPoint());
273 }
274
275 /// Returns the current insert point, clearing it in the process.
276 InsertPoint saveAndClearIP() {
277 InsertPoint IP(GetInsertBlock(), GetInsertPoint());
278 ClearInsertionPoint();
279 return IP;
280 }
281
282 /// Sets the current insert point to a previously-saved location.
283 void restoreIP(InsertPoint IP) {
284 if (IP.isSet())
285 SetInsertPoint(IP.getBlock(), IP.getPoint());
286 else
287 ClearInsertionPoint();
288 }
289
290 /// Get the floating point math metadata being used.
291 MDNode *getDefaultFPMathTag() const { return DefaultFPMathTag; }
292
293 /// Get the flags to be applied to created floating point ops
294 FastMathFlags getFastMathFlags() const { return FMF; }
295
296 FastMathFlags &getFastMathFlags() { return FMF; }
297
298 /// Clear the fast-math flags.
299 void clearFastMathFlags() { FMF.clear(); }
300
301 /// Set the floating point math metadata to be used.
302 void setDefaultFPMathTag(MDNode *FPMathTag) { DefaultFPMathTag = FPMathTag; }
303
304 /// Set the fast-math flags to be used with generated fp-math operators
305 void setFastMathFlags(FastMathFlags NewFMF) { FMF = NewFMF; }
306
307 /// Enable/Disable use of constrained floating point math. When
308 /// enabled the CreateF<op>() calls instead create constrained
309 /// floating point intrinsic calls. Fast math flags are unaffected
310 /// by this setting.
311 void setIsFPConstrained(bool IsCon) { IsFPConstrained = IsCon; }
312
313 /// Query for the use of constrained floating point math
314 bool getIsFPConstrained() { return IsFPConstrained; }
315
316 /// Set the exception handling to be used with constrained floating point
317 void setDefaultConstrainedExcept(fp::ExceptionBehavior NewExcept) {
318#ifndef NDEBUG
319 Optional<StringRef> ExceptStr = ExceptionBehaviorToStr(NewExcept);
320 assert(ExceptStr.hasValue() && "Garbage strict exception behavior!");
321#endif
322 DefaultConstrainedExcept = NewExcept;
323 }
324
325 /// Set the rounding mode handling to be used with constrained floating point
326 void setDefaultConstrainedRounding(RoundingMode NewRounding) {
327#ifndef NDEBUG
328 Optional<StringRef> RoundingStr = RoundingModeToStr(NewRounding);
329 assert(RoundingStr.hasValue() && "Garbage strict rounding mode!");
330#endif
331 DefaultConstrainedRounding = NewRounding;
332 }
333
334 /// Get the exception handling used with constrained floating point
335 fp::ExceptionBehavior getDefaultConstrainedExcept() {
336 return DefaultConstrainedExcept;
337 }
338
339 /// Get the rounding mode handling used with constrained floating point
340 RoundingMode getDefaultConstrainedRounding() {
341 return DefaultConstrainedRounding;
342 }
343
344 void setConstrainedFPFunctionAttr() {
345 assert(BB && "Must have a basic block to set any function attributes!");
346
347 Function *F = BB->getParent();
348 if (!F->hasFnAttribute(Attribute::StrictFP)) {
349 F->addFnAttr(Attribute::StrictFP);
350 }
351 }
352
353 void setConstrainedFPCallAttr(CallBase *I) {
354 I->addAttribute(AttributeList::FunctionIndex, Attribute::StrictFP);
355 }
356
357 void setDefaultOperandBundles(ArrayRef<OperandBundleDef> OpBundles) {
358 DefaultOperandBundles = OpBundles;
359 }
360
361 //===--------------------------------------------------------------------===//
362 // RAII helpers.
363 //===--------------------------------------------------------------------===//
364
365 // RAII object that stores the current insertion point and restores it
366 // when the object is destroyed. This includes the debug location.
367 class InsertPointGuard {
368 IRBuilderBase &Builder;
369 AssertingVH<BasicBlock> Block;
370 BasicBlock::iterator Point;
371 DebugLoc DbgLoc;
372
373 public:
374 InsertPointGuard(IRBuilderBase &B)
375 : Builder(B), Block(B.GetInsertBlock()), Point(B.GetInsertPoint()),
376 DbgLoc(B.getCurrentDebugLocation()) {}
377
378 InsertPointGuard(const InsertPointGuard &) = delete;
379 InsertPointGuard &operator=(const InsertPointGuard &) = delete;
380
381 ~InsertPointGuard() {
382 Builder.restoreIP(InsertPoint(Block, Point));
383 Builder.SetCurrentDebugLocation(DbgLoc);
384 }
385 };
386
387 // RAII object that stores the current fast math settings and restores
388 // them when the object is destroyed.
389 class FastMathFlagGuard {
390 IRBuilderBase &Builder;
391 FastMathFlags FMF;
392 MDNode *FPMathTag;
393 bool IsFPConstrained;
394 fp::ExceptionBehavior DefaultConstrainedExcept;
395 RoundingMode DefaultConstrainedRounding;
396
397 public:
398 FastMathFlagGuard(IRBuilderBase &B)
399 : Builder(B), FMF(B.FMF), FPMathTag(B.DefaultFPMathTag),
400 IsFPConstrained(B.IsFPConstrained),
401 DefaultConstrainedExcept(B.DefaultConstrainedExcept),
402 DefaultConstrainedRounding(B.DefaultConstrainedRounding) {}
403
404 FastMathFlagGuard(const FastMathFlagGuard &) = delete;
405 FastMathFlagGuard &operator=(const FastMathFlagGuard &) = delete;
406
407 ~FastMathFlagGuard() {
408 Builder.FMF = FMF;
409 Builder.DefaultFPMathTag = FPMathTag;
410 Builder.IsFPConstrained = IsFPConstrained;
411 Builder.DefaultConstrainedExcept = DefaultConstrainedExcept;
412 Builder.DefaultConstrainedRounding = DefaultConstrainedRounding;
413 }
414 };
415
416 // RAII object that stores the current default operand bundles and restores
417 // them when the object is destroyed.
418 class OperandBundlesGuard {
419 IRBuilderBase &Builder;
420 ArrayRef<OperandBundleDef> DefaultOperandBundles;
421
422 public:
423 OperandBundlesGuard(IRBuilderBase &B)
424 : Builder(B), DefaultOperandBundles(B.DefaultOperandBundles) {}
425
426 OperandBundlesGuard(const OperandBundlesGuard &) = delete;
427 OperandBundlesGuard &operator=(const OperandBundlesGuard &) = delete;
428
429 ~OperandBundlesGuard() {
430 Builder.DefaultOperandBundles = DefaultOperandBundles;
431 }
432 };
433
434
435 //===--------------------------------------------------------------------===//
436 // Miscellaneous creation methods.
437 //===--------------------------------------------------------------------===//
438
439 /// Make a new global variable with initializer type i8*
440 ///
441 /// Make a new global variable with an initializer that has array of i8 type
442 /// filled in with the null terminated string value specified. The new global
443 /// variable will be marked mergable with any others of the same contents. If
444 /// Name is specified, it is the name of the global variable created.
445 ///
446 /// If no module is given via \p M, it is take from the insertion point basic
447 /// block.
448 GlobalVariable *CreateGlobalString(StringRef Str, const Twine &Name = "",
449 unsigned AddressSpace = 0,
450 Module *M = nullptr);
451
452 /// Get a constant value representing either true or false.
453 ConstantInt *getInt1(bool V) {
454 return ConstantInt::get(getInt1Ty(), V);
455 }
456
457 /// Get the constant value for i1 true.
458 ConstantInt *getTrue() {
459 return ConstantInt::getTrue(Context);
460 }
461
462 /// Get the constant value for i1 false.
463 ConstantInt *getFalse() {
464 return ConstantInt::getFalse(Context);
465 }
466
467 /// Get a constant 8-bit value.
468 ConstantInt *getInt8(uint8_t C) {
469 return ConstantInt::get(getInt8Ty(), C);
470 }
471
472 /// Get a constant 16-bit value.
473 ConstantInt *getInt16(uint16_t C) {
474 return ConstantInt::get(getInt16Ty(), C);
475 }
476
477 /// Get a constant 32-bit value.
478 ConstantInt *getInt32(uint32_t C) {
479 return ConstantInt::get(getInt32Ty(), C);
480 }
481
482 /// Get a constant 64-bit value.
483 ConstantInt *getInt64(uint64_t C) {
484 return ConstantInt::get(getInt64Ty(), C);
485 }
486
487 /// Get a constant N-bit value, zero extended or truncated from
488 /// a 64-bit value.
489 ConstantInt *getIntN(unsigned N, uint64_t C) {
490 return ConstantInt::get(getIntNTy(N), C);
491 }
492
493 /// Get a constant integer value.
494 ConstantInt *getInt(const APInt &AI) {
495 return ConstantInt::get(Context, AI);
496 }
497
498 //===--------------------------------------------------------------------===//
499 // Type creation methods
500 //===--------------------------------------------------------------------===//
501
502 /// Fetch the type representing a single bit
503 IntegerType *getInt1Ty() {
504 return Type::getInt1Ty(Context);
505 }
506
507 /// Fetch the type representing an 8-bit integer.
508 IntegerType *getInt8Ty() {
509 return Type::getInt8Ty(Context);
510 }
511
512 /// Fetch the type representing a 16-bit integer.
513 IntegerType *getInt16Ty() {
514 return Type::getInt16Ty(Context);
515 }
516
517 /// Fetch the type representing a 32-bit integer.
518 IntegerType *getInt32Ty() {
519 return Type::getInt32Ty(Context);
520 }
521
522 /// Fetch the type representing a 64-bit integer.
523 IntegerType *getInt64Ty() {
524 return Type::getInt64Ty(Context);
525 }
526
527 /// Fetch the type representing a 128-bit integer.
528 IntegerType *getInt128Ty() { return Type::getInt128Ty(Context); }
529
530 /// Fetch the type representing an N-bit integer.
531 IntegerType *getIntNTy(unsigned N) {
532 return Type::getIntNTy(Context, N);
533 }
534
535 /// Fetch the type representing a 16-bit floating point value.
536 Type *getHalfTy() {
537 return Type::getHalfTy(Context);
538 }
539
540 /// Fetch the type representing a 16-bit brain floating point value.
541 Type *getBFloatTy() {
542 return Type::getBFloatTy(Context);
543 }
544
545 /// Fetch the type representing a 32-bit floating point value.
546 Type *getFloatTy() {
547 return Type::getFloatTy(Context);
548 }
549
550 /// Fetch the type representing a 64-bit floating point value.
551 Type *getDoubleTy() {
552 return Type::getDoubleTy(Context);
553 }
554
555 /// Fetch the type representing void.
556 Type *getVoidTy() {
557 return Type::getVoidTy(Context);
558 }
559
560 /// Fetch the type representing a pointer to an 8-bit integer value.
561 PointerType *getInt8PtrTy(unsigned AddrSpace = 0) {
562 return Type::getInt8PtrTy(Context, AddrSpace);
563 }
564
565 /// Fetch the type representing a pointer to an integer value.
566 IntegerType *getIntPtrTy(const DataLayout &DL, unsigned AddrSpace = 0) {
567 return DL.getIntPtrType(Context, AddrSpace);
568 }
569
570 //===--------------------------------------------------------------------===//
571 // Intrinsic creation methods
572 //===--------------------------------------------------------------------===//
573
574 /// Create and insert a memset to the specified pointer and the
575 /// specified value.
576 ///
577 /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is
578 /// specified, it will be added to the instruction. Likewise with alias.scope
579 /// and noalias tags.
580 CallInst *CreateMemSet(Value *Ptr, Value *Val, uint64_t Size,
581 MaybeAlign Align, bool isVolatile = false,
582 MDNode *TBAATag = nullptr, MDNode *ScopeTag = nullptr,
583 MDNode *NoAliasTag = nullptr) {
584 return CreateMemSet(Ptr, Val, getInt64(Size), Align, isVolatile,
585 TBAATag, ScopeTag, NoAliasTag);
586 }
587
588 CallInst *CreateMemSet(Value *Ptr, Value *Val, Value *Size, MaybeAlign Align,
589 bool isVolatile = false, MDNode *TBAATag = nullptr,
590 MDNode *ScopeTag = nullptr,
591 MDNode *NoAliasTag = nullptr);
592
593 /// Create and insert an element unordered-atomic memset of the region of
594 /// memory starting at the given pointer to the given value.
595 ///
596 /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is
597 /// specified, it will be added to the instruction. Likewise with alias.scope
598 /// and noalias tags.
599 CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,
600 uint64_t Size, Align Alignment,
601 uint32_t ElementSize,
602 MDNode *TBAATag = nullptr,
603 MDNode *ScopeTag = nullptr,
604 MDNode *NoAliasTag = nullptr) {
605 return CreateElementUnorderedAtomicMemSet(Ptr, Val, getInt64(Size),
606 Align(Alignment), ElementSize,
607 TBAATag, ScopeTag, NoAliasTag);
608 }
609
610 CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,
611 Value *Size, Align Alignment,
612 uint32_t ElementSize,
613 MDNode *TBAATag = nullptr,
614 MDNode *ScopeTag = nullptr,
615 MDNode *NoAliasTag = nullptr);
616
617 /// Create and insert a memcpy between the specified pointers.
618 ///
619 /// If the pointers aren't i8*, they will be converted. If a TBAA tag is
620 /// specified, it will be added to the instruction. Likewise with alias.scope
621 /// and noalias tags.
622 CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src,
623 MaybeAlign SrcAlign, uint64_t Size,
624 bool isVolatile = false, MDNode *TBAATag = nullptr,
625 MDNode *TBAAStructTag = nullptr,
626 MDNode *ScopeTag = nullptr,
627 MDNode *NoAliasTag = nullptr) {
628 return CreateMemCpy(Dst, DstAlign, Src, SrcAlign, getInt64(Size),
629 isVolatile, TBAATag, TBAAStructTag, ScopeTag,
630 NoAliasTag);
631 }
632
633 CallInst *CreateMemTransferInst(
634 Intrinsic::ID IntrID, Value *Dst, MaybeAlign DstAlign, Value *Src,
635 MaybeAlign SrcAlign, Value *Size, bool isVolatile = false,
636 MDNode *TBAATag = nullptr, MDNode *TBAAStructTag = nullptr,
637 MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr);
638
639 CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src,
640 MaybeAlign SrcAlign, Value *Size,
641 bool isVolatile = false, MDNode *TBAATag = nullptr,
642 MDNode *TBAAStructTag = nullptr,
643 MDNode *ScopeTag = nullptr,
644 MDNode *NoAliasTag = nullptr) {
645 return CreateMemTransferInst(Intrinsic::memcpy, Dst, DstAlign, Src,
646 SrcAlign, Size, isVolatile, TBAATag,
647 TBAAStructTag, ScopeTag, NoAliasTag);
648 }
649
650 CallInst *CreateMemCpyInline(Value *Dst, MaybeAlign DstAlign, Value *Src,
651 MaybeAlign SrcAlign, Value *Size);
652
653 /// Create and insert an element unordered-atomic memcpy between the
654 /// specified pointers.
655 ///
656 /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers, respectively.
657 ///
658 /// If the pointers aren't i8*, they will be converted. If a TBAA tag is
659 /// specified, it will be added to the instruction. Likewise with alias.scope
660 /// and noalias tags.
661 CallInst *CreateElementUnorderedAtomicMemCpy(
662 Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size,
663 uint32_t ElementSize, MDNode *TBAATag = nullptr,
664 MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
665 MDNode *NoAliasTag = nullptr);
666
667 CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,
668 MaybeAlign SrcAlign, uint64_t Size,
669 bool isVolatile = false, MDNode *TBAATag = nullptr,
670 MDNode *ScopeTag = nullptr,
671 MDNode *NoAliasTag = nullptr) {
672 return CreateMemMove(Dst, DstAlign, Src, SrcAlign, getInt64(Size),
673 isVolatile, TBAATag, ScopeTag, NoAliasTag);
674 }
675
676 CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,
677 MaybeAlign SrcAlign, Value *Size,
678 bool isVolatile = false, MDNode *TBAATag = nullptr,
679 MDNode *ScopeTag = nullptr,
680 MDNode *NoAliasTag = nullptr);
681
682 /// \brief Create and insert an element unordered-atomic memmove between the
683 /// specified pointers.
684 ///
685 /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers,
686 /// respectively.
687 ///
688 /// If the pointers aren't i8*, they will be converted. If a TBAA tag is
689 /// specified, it will be added to the instruction. Likewise with alias.scope
690 /// and noalias tags.
691 CallInst *CreateElementUnorderedAtomicMemMove(
692 Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size,
693 uint32_t ElementSize, MDNode *TBAATag = nullptr,
694 MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
695 MDNode *NoAliasTag = nullptr);
696
697 /// Create a vector fadd reduction intrinsic of the source vector.
698 /// The first parameter is a scalar accumulator value for ordered reductions.
699 CallInst *CreateFAddReduce(Value *Acc, Value *Src);
700
701 /// Create a vector fmul reduction intrinsic of the source vector.
702 /// The first parameter is a scalar accumulator value for ordered reductions.
703 CallInst *CreateFMulReduce(Value *Acc, Value *Src);
704
705 /// Create a vector int add reduction intrinsic of the source vector.
706 CallInst *CreateAddReduce(Value *Src);
707
708 /// Create a vector int mul reduction intrinsic of the source vector.
709 CallInst *CreateMulReduce(Value *Src);
710
711 /// Create a vector int AND reduction intrinsic of the source vector.
712 CallInst *CreateAndReduce(Value *Src);
713
714 /// Create a vector int OR reduction intrinsic of the source vector.
715 CallInst *CreateOrReduce(Value *Src);
716
717 /// Create a vector int XOR reduction intrinsic of the source vector.
718 CallInst *CreateXorReduce(Value *Src);
719
720 /// Create a vector integer max reduction intrinsic of the source
721 /// vector.
722 CallInst *CreateIntMaxReduce(Value *Src, bool IsSigned = false);
723
724 /// Create a vector integer min reduction intrinsic of the source
725 /// vector.
726 CallInst *CreateIntMinReduce(Value *Src, bool IsSigned = false);
727
728 /// Create a vector float max reduction intrinsic of the source
729 /// vector.
730 CallInst *CreateFPMaxReduce(Value *Src);
731
732 /// Create a vector float min reduction intrinsic of the source
733 /// vector.
734 CallInst *CreateFPMinReduce(Value *Src);
735
736 /// Create a lifetime.start intrinsic.
737 ///
738 /// If the pointer isn't i8* it will be converted.
739 CallInst *CreateLifetimeStart(Value *Ptr, ConstantInt *Size = nullptr);
740
741 /// Create a lifetime.end intrinsic.
742 ///
743 /// If the pointer isn't i8* it will be converted.
744 CallInst *CreateLifetimeEnd(Value *Ptr, ConstantInt *Size = nullptr);
745
746 /// Create a call to invariant.start intrinsic.
747 ///
748 /// If the pointer isn't i8* it will be converted.
749 CallInst *CreateInvariantStart(Value *Ptr, ConstantInt *Size = nullptr);
750
751 /// Create a call to Masked Load intrinsic
752 CallInst *CreateMaskedLoad(Value *Ptr, Align Alignment, Value *Mask,
753 Value *PassThru = nullptr, const Twine &Name = "");
754
755 /// Create a call to Masked Store intrinsic
756 CallInst *CreateMaskedStore(Value *Val, Value *Ptr, Align Alignment,
757 Value *Mask);
758
759 /// Create a call to Masked Gather intrinsic
760 CallInst *CreateMaskedGather(Value *Ptrs, Align Alignment,
761 Value *Mask = nullptr, Value *PassThru = nullptr,
762 const Twine &Name = "");
763
764 /// Create a call to Masked Scatter intrinsic
765 CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, Align Alignment,
766 Value *Mask = nullptr);
767
768 /// Create an assume intrinsic call that allows the optimizer to
769 /// assume that the provided condition will be true.
770 ///
771 /// The optional argument \p OpBundles specifies operand bundles that are
772 /// added to the call instruction.
773 CallInst *CreateAssumption(Value *Cond,
774 ArrayRef<OperandBundleDef> OpBundles = llvm::None);
775
776 /// Create a llvm.experimental.noalias.scope.decl intrinsic call.
777 Instruction *CreateNoAliasScopeDeclaration(Value *Scope);
778 Instruction *CreateNoAliasScopeDeclaration(MDNode *ScopeTag) {
779 return CreateNoAliasScopeDeclaration(
780 MetadataAsValue::get(Context, ScopeTag));
781 }
782
783 /// Create a call to the experimental.gc.statepoint intrinsic to
784 /// start a new statepoint sequence.
785 CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
786 Value *ActualCallee,
787 ArrayRef<Value *> CallArgs,
788 Optional<ArrayRef<Value *>> DeoptArgs,
789 ArrayRef<Value *> GCArgs,
790 const Twine &Name = "");
791
792 /// Create a call to the experimental.gc.statepoint intrinsic to
793 /// start a new statepoint sequence.
794 CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
795 Value *ActualCallee, uint32_t Flags,
796 ArrayRef<Value *> CallArgs,
797 Optional<ArrayRef<Use>> TransitionArgs,
798 Optional<ArrayRef<Use>> DeoptArgs,
799 ArrayRef<Value *> GCArgs,
800 const Twine &Name = "");
801
802 /// Conveninence function for the common case when CallArgs are filled
803 /// in using makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be
804 /// .get()'ed to get the Value pointer.
805 CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
806 Value *ActualCallee, ArrayRef<Use> CallArgs,
807 Optional<ArrayRef<Value *>> DeoptArgs,
808 ArrayRef<Value *> GCArgs,
809 const Twine &Name = "");
810
811 /// Create an invoke to the experimental.gc.statepoint intrinsic to
812 /// start a new statepoint sequence.
813 InvokeInst *
814 CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
815 Value *ActualInvokee, BasicBlock *NormalDest,
816 BasicBlock *UnwindDest, ArrayRef<Value *> InvokeArgs,
817 Optional<ArrayRef<Value *>> DeoptArgs,
818 ArrayRef<Value *> GCArgs, const Twine &Name = "");
819
820 /// Create an invoke to the experimental.gc.statepoint intrinsic to
821 /// start a new statepoint sequence.
822 InvokeInst *CreateGCStatepointInvoke(
823 uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
824 BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags,
825 ArrayRef<Value *> InvokeArgs, Optional<ArrayRef<Use>> TransitionArgs,
826 Optional<ArrayRef<Use>> DeoptArgs, ArrayRef<Value *> GCArgs,
827 const Twine &Name = "");
828
829 // Convenience function for the common case when CallArgs are filled in using
830 // makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be .get()'ed to
831 // get the Value *.
832 InvokeInst *
833 CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
834 Value *ActualInvokee, BasicBlock *NormalDest,
835 BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs,
836 Optional<ArrayRef<Value *>> DeoptArgs,
837 ArrayRef<Value *> GCArgs, const Twine &Name = "");
838
839 /// Create a call to the experimental.gc.result intrinsic to extract
840 /// the result from a call wrapped in a statepoint.
841 CallInst *CreateGCResult(Instruction *Statepoint,
842 Type *ResultType,
843 const Twine &Name = "");
844
845 /// Create a call to the experimental.gc.relocate intrinsics to
846 /// project the relocated value of one pointer from the statepoint.
847 CallInst *CreateGCRelocate(Instruction *Statepoint,
848 int BaseOffset,
849 int DerivedOffset,
850 Type *ResultType,
851 const Twine &Name = "");
852
853 /// Create a call to llvm.vscale, multiplied by \p Scaling. The type of VScale
854 /// will be the same type as that of \p Scaling.
855 Value *CreateVScale(Constant *Scaling, const Twine &Name = "");
856
857 /// Creates a vector of type \p DstType with the linear sequence <0, 1, ...>
858 Value *CreateStepVector(Type *DstType, const Twine &Name = "");
859
860 /// Create a call to intrinsic \p ID with 1 operand which is mangled on its
861 /// type.
862 CallInst *CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V,
863 Instruction *FMFSource = nullptr,
864 const Twine &Name = "");
865
866 /// Create a call to intrinsic \p ID with 2 operands which is mangled on the
867 /// first type.
868 CallInst *CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS,
869 Instruction *FMFSource = nullptr,
870 const Twine &Name = "");
871
872 /// Create a call to intrinsic \p ID with \p args, mangled using \p Types. If
873 /// \p FMFSource is provided, copy fast-math-flags from that instruction to
874 /// the intrinsic.
875 CallInst *CreateIntrinsic(Intrinsic::ID ID, ArrayRef<Type *> Types,
876 ArrayRef<Value *> Args,
877 Instruction *FMFSource = nullptr,
878 const Twine &Name = "");
879
880 /// Create call to the minnum intrinsic.
881 CallInst *CreateMinNum(Value *LHS, Value *RHS, const Twine &Name = "") {
882 return CreateBinaryIntrinsic(Intrinsic::minnum, LHS, RHS, nullptr, Name);
883 }
884
885 /// Create call to the maxnum intrinsic.
886 CallInst *CreateMaxNum(Value *LHS, Value *RHS, const Twine &Name = "") {
887 return CreateBinaryIntrinsic(Intrinsic::maxnum, LHS, RHS, nullptr, Name);
888 }
889
890 /// Create call to the minimum intrinsic.
891 CallInst *CreateMinimum(Value *LHS, Value *RHS, const Twine &Name = "") {
892 return CreateBinaryIntrinsic(Intrinsic::minimum, LHS, RHS, nullptr, Name);
893 }
894
895 /// Create call to the maximum intrinsic.
896 CallInst *CreateMaximum(Value *LHS, Value *RHS, const Twine &Name = "") {
897 return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name);
898 }
899
900 /// Create a call to the experimental.vector.extract intrinsic.
901 CallInst *CreateExtractVector(Type *DstType, Value *SrcVec, Value *Idx,
902 const Twine &Name = "") {
903 return CreateIntrinsic(Intrinsic::experimental_vector_extract,
904 {DstType, SrcVec->getType()}, {SrcVec, Idx}, nullptr,
905 Name);
906 }
907
908 /// Create a call to the experimental.vector.insert intrinsic.
909 CallInst *CreateInsertVector(Type *DstType, Value *SrcVec, Value *SubVec,
910 Value *Idx, const Twine &Name = "") {
911 return CreateIntrinsic(Intrinsic::experimental_vector_insert,
912 {DstType, SubVec->getType()}, {SrcVec, SubVec, Idx},
913 nullptr, Name);
914 }
915
916private:
917 /// Create a call to a masked intrinsic with given Id.
918 CallInst *CreateMaskedIntrinsic(Intrinsic::ID Id, ArrayRef<Value *> Ops,
919 ArrayRef<Type *> OverloadedTypes,
920 const Twine &Name = "");
921
922 Value *getCastedInt8PtrValue(Value *Ptr);
923
924 //===--------------------------------------------------------------------===//
925 // Instruction creation methods: Terminators
926 //===--------------------------------------------------------------------===//
927
928private:
929 /// Helper to add branch weight and unpredictable metadata onto an
930 /// instruction.
931 /// \returns The annotated instruction.
932 template <typename InstTy>
933 InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
934 if (Weights)
935 I->setMetadata(LLVMContext::MD_prof, Weights);
936 if (Unpredictable)
937 I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
938 return I;
939 }
940
941public:
942 /// Create a 'ret void' instruction.
943 ReturnInst *CreateRetVoid() {
944 return Insert(ReturnInst::Create(Context));
945 }
946
947 /// Create a 'ret <val>' instruction.
948 ReturnInst *CreateRet(Value *V) {
949 return Insert(ReturnInst::Create(Context, V));
950 }
951
952 /// Create a sequence of N insertvalue instructions,
953 /// with one Value from the retVals array each, that build a aggregate
954 /// return value one value at a time, and a ret instruction to return
955 /// the resulting aggregate value.
956 ///
957 /// This is a convenience function for code that uses aggregate return values
958 /// as a vehicle for having multiple return values.
959 ReturnInst *CreateAggregateRet(Value *const *retVals, unsigned N) {
960 Value *V = UndefValue::get(getCurrentFunctionReturnType());
961 for (unsigned i = 0; i != N; ++i)
962 V = CreateInsertValue(V, retVals[i], i, "mrv");
963 return Insert(ReturnInst::Create(Context, V));
964 }
965
966 /// Create an unconditional 'br label X' instruction.
967 BranchInst *CreateBr(BasicBlock *Dest) {
968 return Insert(BranchInst::Create(Dest));
969 }
970
971 /// Create a conditional 'br Cond, TrueDest, FalseDest'
972 /// instruction.
973 BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
974 MDNode *BranchWeights = nullptr,
975 MDNode *Unpredictable = nullptr) {
976 return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
977 BranchWeights, Unpredictable));
978 }
979
980 /// Create a conditional 'br Cond, TrueDest, FalseDest'
981 /// instruction. Copy branch meta data if available.
982 BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
983 Instruction *MDSrc) {
984 BranchInst *Br = BranchInst::Create(True, False, Cond);
985 if (MDSrc) {
986 unsigned WL[4] = {LLVMContext::MD_prof, LLVMContext::MD_unpredictable,
987 LLVMContext::MD_make_implicit, LLVMContext::MD_dbg};
988 Br->copyMetadata(*MDSrc, makeArrayRef(&WL[0], 4));
989 }
990 return Insert(Br);
991 }
992
993 /// Create a switch instruction with the specified value, default dest,
994 /// and with a hint for the number of cases that will be added (for efficient
995 /// allocation).
996 SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10,
997 MDNode *BranchWeights = nullptr,
998 MDNode *Unpredictable = nullptr) {
999 return Insert(addBranchMetadata(SwitchInst::Create(V, Dest, NumCases),
1000 BranchWeights, Unpredictable));
1001 }
1002
1003 /// Create an indirect branch instruction with the specified address
1004 /// operand, with an optional hint for the number of destinations that will be
1005 /// added (for efficient allocation).
1006 IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) {
1007 return Insert(IndirectBrInst::Create(Addr, NumDests));
1008 }
1009
1010 /// Create an invoke instruction.
1011 InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
1012 BasicBlock *NormalDest, BasicBlock *UnwindDest,
1013 ArrayRef<Value *> Args,
1014 ArrayRef<OperandBundleDef> OpBundles,
1015 const Twine &Name = "") {
1016 InvokeInst *II =
1017 InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles);
1018 if (IsFPConstrained)
1019 setConstrainedFPCallAttr(II);
1020 return Insert(II, Name);
1021 }
1022 InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
1023 BasicBlock *NormalDest, BasicBlock *UnwindDest,
1024 ArrayRef<Value *> Args = None,
1025 const Twine &Name = "") {
1026 InvokeInst *II =
1027 InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args);
1028 if (IsFPConstrained)
1029 setConstrainedFPCallAttr(II);
1030 return Insert(II, Name);
1031 }
1032
1033 InvokeInst *CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest,
1034 BasicBlock *UnwindDest, ArrayRef<Value *> Args,
1035 ArrayRef<OperandBundleDef> OpBundles,
1036 const Twine &Name = "") {
1037 return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
1038 NormalDest, UnwindDest, Args, OpBundles, Name);
1039 }
1040
1041 InvokeInst *CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest,
1042 BasicBlock *UnwindDest,
1043 ArrayRef<Value *> Args = None,
1044 const Twine &Name = "") {
1045 return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
1046 NormalDest, UnwindDest, Args, Name);
1047 }
1048
1049 /// \brief Create a callbr instruction.
1050 CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee,
1051 BasicBlock *DefaultDest,
1052 ArrayRef<BasicBlock *> IndirectDests,
1053 ArrayRef<Value *> Args = None,
1054 const Twine &Name = "") {
1055 return Insert(CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests,
1056 Args), Name);
1057 }
1058 CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee,
1059 BasicBlock *DefaultDest,
1060 ArrayRef<BasicBlock *> IndirectDests,
1061 ArrayRef<Value *> Args,
1062 ArrayRef<OperandBundleDef> OpBundles,
1063 const Twine &Name = "") {
1064 return Insert(
1065 CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests, Args,
1066 OpBundles), Name);
1067 }
1068
1069 CallBrInst *CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest,
1070 ArrayRef<BasicBlock *> IndirectDests,
1071 ArrayRef<Value *> Args = None,
1072 const Twine &Name = "") {
1073 return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
1074 DefaultDest, IndirectDests, Args, Name);
1075 }
1076 CallBrInst *CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest,
1077 ArrayRef<BasicBlock *> IndirectDests,
1078 ArrayRef<Value *> Args,
1079 ArrayRef<OperandBundleDef> OpBundles,
1080 const Twine &Name = "") {
1081 return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
1082 DefaultDest, IndirectDests, Args, Name);
1083 }
1084
1085 ResumeInst *CreateResume(Value *Exn) {
1086 return Insert(ResumeInst::Create(Exn));
1087 }
1088
1089 CleanupReturnInst *CreateCleanupRet(CleanupPadInst *CleanupPad,
1090 BasicBlock *UnwindBB = nullptr) {
1091 return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB));
1092 }
1093
1094 CatchSwitchInst *CreateCatchSwitch(Value *ParentPad, BasicBlock *UnwindBB,
1095 unsigned NumHandlers,
1096 const Twine &Name = "") {
1097 return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers),
1098 Name);
1099 }
1100
1101 CatchPadInst *CreateCatchPad(Value *ParentPad, ArrayRef<Value *> Args,
1102 const Twine &Name = "") {
1103 return Insert(CatchPadInst::Create(ParentPad, Args), Name);
1104 }
1105
1106 CleanupPadInst *CreateCleanupPad(Value *ParentPad,
1107 ArrayRef<Value *> Args = None,
1108 const Twine &Name = "") {
1109 return Insert(CleanupPadInst::Create(ParentPad, Args), Name);
1110 }
1111
1112 CatchReturnInst *CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB) {
1113 return Insert(CatchReturnInst::Create(CatchPad, BB));
1114 }
1115
1116 UnreachableInst *CreateUnreachable() {
1117 return Insert(new UnreachableInst(Context));
1118 }
1119
1120 //===--------------------------------------------------------------------===//
1121 // Instruction creation methods: Binary Operators
1122 //===--------------------------------------------------------------------===//
1123private:
1124 BinaryOperator *CreateInsertNUWNSWBinOp(BinaryOperator::BinaryOps Opc,
1125 Value *LHS, Value *RHS,
1126 const Twine &Name,
1127 bool HasNUW, bool HasNSW) {
1128 BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
1129 if (HasNUW) BO->setHasNoUnsignedWrap();
1130 if (HasNSW) BO->setHasNoSignedWrap();
1131 return BO;
1132 }
1133
1134 Instruction *setFPAttrs(Instruction *I, MDNode *FPMD,
1135 FastMathFlags FMF) const {
1136 if (!FPMD)
1137 FPMD = DefaultFPMathTag;
1138 if (FPMD)
1139 I->setMetadata(LLVMContext::MD_fpmath, FPMD);
1140 I->setFastMathFlags(FMF);
1141 return I;
1142 }
1143
1144 Value *foldConstant(Instruction::BinaryOps Opc, Value *L,
1145 Value *R, const Twine &Name) const {
1146 auto *LC = dyn_cast<Constant>(L);
1147 auto *RC = dyn_cast<Constant>(R);
1148 return (LC && RC) ? Insert(Folder.CreateBinOp(Opc, LC, RC), Name) : nullptr;
1149 }
1150
1151 Value *getConstrainedFPRounding(Optional<RoundingMode> Rounding) {
1152 RoundingMode UseRounding = DefaultConstrainedRounding;
1153
1154 if (Rounding.hasValue())
1155 UseRounding = Rounding.getValue();
1156
1157 Optional<StringRef> RoundingStr = RoundingModeToStr(UseRounding);
1158 assert(RoundingStr.hasValue() && "Garbage strict rounding mode!");
1159 auto *RoundingMDS = MDString::get(Context, RoundingStr.getValue());
1160
1161 return MetadataAsValue::get(Context, RoundingMDS);
1162 }
1163
1164 Value *getConstrainedFPExcept(Optional<fp::ExceptionBehavior> Except) {
1165 fp::ExceptionBehavior UseExcept = DefaultConstrainedExcept;
1166
1167 if (Except.hasValue())
1168 UseExcept = Except.getValue();
1169
1170 Optional<StringRef> ExceptStr = ExceptionBehaviorToStr(UseExcept);
1171 assert(ExceptStr.hasValue() && "Garbage strict exception behavior!");
1172 auto *ExceptMDS = MDString::get(Context, ExceptStr.getValue());
1173
1174 return MetadataAsValue::get(Context, ExceptMDS);
1175 }
1176
1177 Value *getConstrainedFPPredicate(CmpInst::Predicate Predicate) {
1178 assert(CmpInst::isFPPredicate(Predicate) &&
1179 Predicate != CmpInst::FCMP_FALSE &&
1180 Predicate != CmpInst::FCMP_TRUE &&
1181 "Invalid constrained FP comparison predicate!");
1182
1183 StringRef PredicateStr = CmpInst::getPredicateName(Predicate);
1184 auto *PredicateMDS = MDString::get(Context, PredicateStr);
1185
1186 return MetadataAsValue::get(Context, PredicateMDS);
1187 }
1188
1189public:
1190 Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "",
1191 bool HasNUW = false, bool HasNSW = false) {
1192 if (auto *LC = dyn_cast<Constant>(LHS))
1193 if (auto *RC = dyn_cast<Constant>(RHS))
1194 return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name);
1195 return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name,
1196 HasNUW, HasNSW);
1197 }
1198
1199 Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1200 return CreateAdd(LHS, RHS, Name, false, true);
1201 }
1202
1203 Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1204 return CreateAdd(LHS, RHS, Name, true, false);
1205 }
1206
1207 Value *CreateSub(Value *LHS, Value *RHS, const Twine &Name = "",
1208 bool HasNUW = false, bool HasNSW = false) {
1209 if (auto *LC = dyn_cast<Constant>(LHS))
1210 if (auto *RC = dyn_cast<Constant>(RHS))
1211 return Insert(Folder.CreateSub(LC, RC, HasNUW, HasNSW), Name);
1212 return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name,
1213 HasNUW, HasNSW);
1214 }
1215
1216 Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
1217 return CreateSub(LHS, RHS, Name, false, true);
1218 }
1219
1220 Value *CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
1221 return CreateSub(LHS, RHS, Name, true, false);
1222 }
1223
1224 Value *CreateMul(Value *LHS, Value *RHS, const Twine &Name = "",
1225 bool HasNUW = false, bool HasNSW = false) {
1226 if (auto *LC = dyn_cast<Constant>(LHS))
1227 if (auto *RC = dyn_cast<Constant>(RHS))
1228 return Insert(Folder.CreateMul(LC, RC, HasNUW, HasNSW), Name);
1229 return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name,
1230 HasNUW, HasNSW);
1231 }
1232
1233 Value *CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
1234 return CreateMul(LHS, RHS, Name, false, true);
1235 }
1236
1237 Value *CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
1238 return CreateMul(LHS, RHS, Name, true, false);
1239 }
1240
1241 Value *CreateUDiv(Value *LHS, Value *RHS, const Twine &Name = "",
1242 bool isExact = false) {
1243 if (auto *LC = dyn_cast<Constant>(LHS))
1244 if (auto *RC = dyn_cast<Constant>(RHS))
1245 return Insert(Folder.CreateUDiv(LC, RC, isExact), Name);
1246 if (!isExact)
1247 return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
1248 return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name);
1249 }
1250
1251 Value *CreateExactUDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
1252 return CreateUDiv(LHS, RHS, Name, true);
1253 }
1254
1255 Value *CreateSDiv(Value *LHS, Value *RHS, const Twine &Name = "",
1256 bool isExact = false) {
1257 if (auto *LC = dyn_cast<Constant>(LHS))
1258 if (auto *RC = dyn_cast<Constant>(RHS))
1259 return Insert(Folder.CreateSDiv(LC, RC, isExact), Name);
1260 if (!isExact)
1261 return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
1262 return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
1263 }
1264
1265 Value *CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
1266 return CreateSDiv(LHS, RHS, Name, true);
1267 }
1268
1269 Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") {
1270 if (Value *V = foldConstant(Instruction::URem, LHS, RHS, Name)) return V;
1271 return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
1272 }
1273
1274 Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") {
1275 if (Value *V = foldConstant(Instruction::SRem, LHS, RHS, Name)) return V;
1276 return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
1277 }
1278
1279 Value *CreateShl(Value *LHS, Value *RHS, const Twine &Name = "",
1280 bool HasNUW = false, bool HasNSW = false) {
1281 if (auto *LC = dyn_cast<Constant>(LHS))
1282 if (auto *RC = dyn_cast<Constant>(RHS))
1283 return Insert(Folder.CreateShl(LC, RC, HasNUW, HasNSW), Name);
1284 return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name,
1285 HasNUW, HasNSW);
1286 }
1287
1288 Value *CreateShl(Value *LHS, const APInt &RHS, const Twine &Name = "",
1289 bool HasNUW = false, bool HasNSW = false) {
1290 return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1291 HasNUW, HasNSW);
1292 }
1293
1294 Value *CreateShl(Value *LHS, uint64_t RHS, const Twine &Name = "",
1295 bool HasNUW = false, bool HasNSW = false) {
1296 return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1297 HasNUW, HasNSW);
1298 }
1299
1300 Value *CreateLShr(Value *LHS, Value *RHS, const Twine &Name = "",
1301 bool isExact = false) {
1302 if (auto *LC = dyn_cast<Constant>(LHS))
1303 if (auto *RC = dyn_cast<Constant>(RHS))
1304 return Insert(Folder.CreateLShr(LC, RC, isExact), Name);
1305 if (!isExact)
1306 return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
1307 return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
1308 }
1309
1310 Value *CreateLShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
1311 bool isExact = false) {
1312 return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1313 }
1314
1315 Value *CreateLShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
1316 bool isExact = false) {
1317 return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1318 }
1319
1320 Value *CreateAShr(Value *LHS, Value *RHS, const Twine &Name = "",
1321 bool isExact = false) {
1322 if (auto *LC = dyn_cast<Constant>(LHS))
1323 if (auto *RC = dyn_cast<Constant>(RHS))
1324 return Insert(Folder.CreateAShr(LC, RC, isExact), Name);
1325 if (!isExact)
1326 return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
1327 return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name);
1328 }
1329
1330 Value *CreateAShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
1331 bool isExact = false) {
1332 return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1333 }
1334
1335 Value *CreateAShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
1336 bool isExact = false) {
1337 return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1338 }
1339
1340 Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
1341 if (auto *RC = dyn_cast<Constant>(RHS)) {
1342 if (isa<ConstantInt>(RC) && cast<ConstantInt>(RC)->isMinusOne())
1343 return LHS; // LHS & -1 -> LHS
1344 if (auto *LC = dyn_cast<Constant>(LHS))
1345 return Insert(Folder.CreateAnd(LC, RC), Name);
1346 }
1347 return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
1348 }
1349
1350 Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1351 return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1352 }
1353
1354 Value *CreateAnd(Value *LHS, uint64_t RHS, const Twine &Name = "") {
1355 return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1356 }
1357
1358 Value *CreateAnd(ArrayRef<Value*> Ops) {
1359 assert(!Ops.empty());
1360 Value *Accum = Ops[0];
1361 for (unsigned i = 1; i < Ops.size(); i++)
1362 Accum = CreateAnd(Accum, Ops[i]);
1363 return Accum;
1364 }
1365
1366 Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
1367 if (auto *RC = dyn_cast<Constant>(RHS)) {
1368 if (RC->isNullValue())
1369 return LHS; // LHS | 0 -> LHS
1370 if (auto *LC = dyn_cast<Constant>(LHS))
1371 return Insert(Folder.CreateOr(LC, RC), Name);
1372 }
1373 return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
1374 }
1375
1376 Value *CreateOr(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1377 return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1378 }
1379
1380 Value *CreateOr(Value *LHS, uint64_t RHS, const Twine &Name = "") {
1381 return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1382 }
1383
1384 Value *CreateOr(ArrayRef<Value*> Ops) {
1385 assert(!Ops.empty());
1386 Value *Accum = Ops[0];
1387 for (unsigned i = 1; i < Ops.size(); i++)
1388 Accum = CreateOr(Accum, Ops[i]);
1389 return Accum;
1390 }
1391
1392 Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") {
1393 if (Value *V = foldConstant(Instruction::Xor, LHS, RHS, Name)) return V;
1394 return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
1395 }
1396
1397 Value *CreateXor(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1398 return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1399 }
1400
1401 Value *CreateXor(Value *LHS, uint64_t RHS, const Twine &Name = "") {
1402 return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1403 }
1404
1405 Value *CreateFAdd(Value *L, Value *R, const Twine &Name = "",
1406 MDNode *FPMD = nullptr) {
1407 if (IsFPConstrained)
1408 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1409 L, R, nullptr, Name, FPMD);
1410
1411 if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) return V;
1412 Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
1413 return Insert(I, Name);
1414 }
1415
1416 /// Copy fast-math-flags from an instruction rather than using the builder's
1417 /// default FMF.
1418 Value *CreateFAddFMF(Value *L, Value *R, Instruction *FMFSource,
1419 const Twine &Name = "") {
1420 if (IsFPConstrained)
1421 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1422 L, R, FMFSource, Name);
1423
1424 if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) return V;
1425 Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), nullptr,
1426 FMFSource->getFastMathFlags());
1427 return Insert(I, Name);
1428 }
1429
1430 Value *CreateFSub(Value *L, Value *R, const Twine &Name = "",
1431 MDNode *FPMD = nullptr) {
1432 if (IsFPConstrained)
1433 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1434 L, R, nullptr, Name, FPMD);
1435
1436 if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) return V;
1437 Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF);
1438 return Insert(I, Name);
1439 }
1440
1441 /// Copy fast-math-flags from an instruction rather than using the builder's
1442 /// default FMF.
1443 Value *CreateFSubFMF(Value *L, Value *R, Instruction *FMFSource,
1444 const Twine &Name = "") {
1445 if (IsFPConstrained)
1446 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1447 L, R, FMFSource, Name);
1448
1449 if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) return V;
1450 Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), nullptr,
1451 FMFSource->getFastMathFlags());
1452 return Insert(I, Name);
1453 }
1454
1455 Value *CreateFMul(Value *L, Value *R, const Twine &Name = "",
1456 MDNode *FPMD = nullptr) {
1457 if (IsFPConstrained)
1458 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1459 L, R, nullptr, Name, FPMD);
1460
1461 if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) return V;
1462 Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF);
1463 return Insert(I, Name);
1464 }
1465
1466 /// Copy fast-math-flags from an instruction rather than using the builder's
1467 /// default FMF.
1468 Value *CreateFMulFMF(Value *L, Value *R, Instruction *FMFSource,
1469 const Twine &Name = "") {
1470 if (IsFPConstrained)
1471 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1472 L, R, FMFSource, Name);
1473
1474 if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) return V;
1475 Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), nullptr,
1476 FMFSource->getFastMathFlags());
1477 return Insert(I, Name);
1478 }
1479
1480 Value *CreateFDiv(Value *L, Value *R, const Twine &Name = "",
1481 MDNode *FPMD = nullptr) {
1482 if (IsFPConstrained)
1483 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
1484 L, R, nullptr, Name, FPMD);
1485
1486 if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) return V;
1487 Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF);
1488 return Insert(I, Name);
1489 }
1490
1491 /// Copy fast-math-flags from an instruction rather than using the builder's
1492 /// default FMF.
1493 Value *CreateFDivFMF(Value *L, Value *R, Instruction *FMFSource,
1494 const Twine &Name = "") {
1495 if (IsFPConstrained)
1496 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
1497 L, R, FMFSource, Name);
1498
1499 if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) return V;
1500 Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), nullptr,
1501 FMFSource->getFastMathFlags());
1502 return Insert(I, Name);
1503 }
1504
1505 Value *CreateFRem(Value *L, Value *R, const Twine &Name = "",
1506 MDNode *FPMD = nullptr) {
1507 if (IsFPConstrained)
1508 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
1509 L, R, nullptr, Name, FPMD);
1510
1511 if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V;
1512 Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMF);
1513 return Insert(I, Name);
1514 }
1515
1516 /// Copy fast-math-flags from an instruction rather than using the builder's
1517 /// default FMF.
1518 Value *CreateFRemFMF(Value *L, Value *R, Instruction *FMFSource,
1519 const Twine &Name = "") {
1520 if (IsFPConstrained)
1521 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
1522 L, R, FMFSource, Name);
1523
1524 if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V;
1525 Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), nullptr,
1526 FMFSource->getFastMathFlags());
1527 return Insert(I, Name);
1528 }
1529
1530 Value *CreateBinOp(Instruction::BinaryOps Opc,
1531 Value *LHS, Value *RHS, const Twine &Name = "",
1532 MDNode *FPMathTag = nullptr) {
1533 if (Value *V = foldConstant(Opc, LHS, RHS, Name)) return V;
1534 Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
1535 if (isa<FPMathOperator>(BinOp))
1536 setFPAttrs(BinOp, FPMathTag, FMF);
1537 return Insert(BinOp, Name);
1538 }
1539
1540 Value *CreateLogicalAnd(Value *Cond1, Value *Cond2, const Twine &Name = "") {
1541 assert(Cond2->getType()->isIntOrIntVectorTy(1));
1542 return CreateSelect(Cond1, Cond2,
1543 ConstantInt::getNullValue(Cond2->getType()), Name);
1544 }
1545
1546 Value *CreateLogicalOr(Value *Cond1, Value *Cond2, const Twine &Name = "") {
1547 assert(Cond2->getType()->isIntOrIntVectorTy(1));
1548 return CreateSelect(Cond1, ConstantInt::getAllOnesValue(Cond2->getType()),
1549 Cond2, Name);
1550 }
1551
1552 CallInst *CreateConstrainedFPBinOp(
1553 Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource = nullptr,
1554 const Twine &Name = "", MDNode *FPMathTag = nullptr,
1555 Optional<RoundingMode> Rounding = None,
1556 Optional<fp::ExceptionBehavior> Except = None);
1557
1558 Value *CreateNeg(Value *V, const Twine &Name = "",
1559 bool HasNUW = false, bool HasNSW = false) {
1560 if (auto *VC = dyn_cast<Constant>(V))
1561 return Insert(Folder.CreateNeg(VC, HasNUW, HasNSW), Name);
1562 BinaryOperator *BO = Insert(BinaryOperator::CreateNeg(V), Name);
1563 if (HasNUW) BO->setHasNoUnsignedWrap();
1564 if (HasNSW) BO->setHasNoSignedWrap();
1565 return BO;
1566 }
1567
1568 Value *CreateNSWNeg(Value *V, const Twine &Name = "") {
1569 return CreateNeg(V, Name, false, true);
1570 }
1571
1572 Value *CreateNUWNeg(Value *V, const Twine &Name = "") {
1573 return CreateNeg(V, Name, true, false);
1574 }
1575
1576 Value *CreateFNeg(Value *V, const Twine &Name = "",
1577 MDNode *FPMathTag = nullptr) {
1578 if (auto *VC = dyn_cast<Constant>(V))
1579 return Insert(Folder.CreateFNeg(VC), Name);
1580 return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), FPMathTag, FMF),
1581 Name);
1582 }
1583
1584 /// Copy fast-math-flags from an instruction rather than using the builder's
1585 /// default FMF.
1586 Value *CreateFNegFMF(Value *V, Instruction *FMFSource,
1587 const Twine &Name = "") {
1588 if (auto *VC = dyn_cast<Constant>(V))
1589 return Insert(Folder.CreateFNeg(VC), Name);
1590 return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), nullptr,
1591 FMFSource->getFastMathFlags()),
1592 Name);
1593 }
1594
1595 Value *CreateNot(Value *V, const Twine &Name = "") {
1596 if (auto *VC = dyn_cast<Constant>(V))
1597 return Insert(Folder.CreateNot(VC), Name);
1598 return Insert(BinaryOperator::CreateNot(V), Name);
1599 }
1600
1601 Value *CreateUnOp(Instruction::UnaryOps Opc,
1602 Value *V, const Twine &Name = "",
1603 MDNode *FPMathTag = nullptr) {
1604 if (auto *VC = dyn_cast<Constant>(V))
1605 return Insert(Folder.CreateUnOp(Opc, VC), Name);
1606 Instruction *UnOp = UnaryOperator::Create(Opc, V);
1607 if (isa<FPMathOperator>(UnOp))
1608 setFPAttrs(UnOp, FPMathTag, FMF);
1609 return Insert(UnOp, Name);
1610 }
1611
1612 /// Create either a UnaryOperator or BinaryOperator depending on \p Opc.
1613 /// Correct number of operands must be passed accordingly.
1614 Value *CreateNAryOp(unsigned Opc, ArrayRef<Value *> Ops,
1615 const Twine &Name = "", MDNode *FPMathTag = nullptr);
1616
1617 //===--------------------------------------------------------------------===//
1618 // Instruction creation methods: Memory Instructions
1619 //===--------------------------------------------------------------------===//
1620
1621 AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace,
1622 Value *ArraySize = nullptr, const Twine &Name = "") {
1623 const DataLayout &DL = BB->getModule()->getDataLayout();
1624 Align AllocaAlign = DL.getPrefTypeAlign(Ty);
1625 return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name);
1626 }
1627
1628 AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = nullptr,
1629 const Twine &Name = "") {
1630 const DataLayout &DL = BB->getModule()->getDataLayout();
1631 Align AllocaAlign = DL.getPrefTypeAlign(Ty);
1632 unsigned AddrSpace = DL.getAllocaAddrSpace();
1633 return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name);
1634 }
1635
1636 /// Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of
1637 /// converting the string to 'bool' for the isVolatile parameter.
1638 LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
1639 return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name);
1640 }
1641
1642 LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1643 return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name);
1644 }
1645
1646 LoadInst *CreateLoad(Type *Ty, Value *Ptr, bool isVolatile,
1647 const Twine &Name = "") {
1648 return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), isVolatile, Name);
1649 }
1650
1651 // Deprecated [opaque pointer types]
1652 LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateLoad(Value *Ptr,
1653 const char *Name),
1654 "Use the version that explicitly specifies the "
1655 "loaded type instead") {
1656 return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name);
1657 }
1658
1659 // Deprecated [opaque pointer types]
1660 LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateLoad(Value *Ptr,
1661 const Twine &Name = ""),
1662 "Use the version that explicitly specifies the "
1663 "loaded type instead") {
1664 return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name);
1665 }
1666
1667 // Deprecated [opaque pointer types]
1668 LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateLoad(Value *Ptr,
1669 bool isVolatile,
1670 const Twine &Name = ""),
1671 "Use the version that explicitly specifies the "
1672 "loaded type instead") {
1673 return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, isVolatile,
1674 Name);
1675 }
1676
1677 StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
1678 return CreateAlignedStore(Val, Ptr, MaybeAlign(), isVolatile);
1679 }
1680
1681 LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
1682 const char *Name) {
1683 return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
1684 }
1685
1686 LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
1687 const Twine &Name = "") {
1688 return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
1689 }
1690
1691 LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
1692 bool isVolatile, const Twine &Name = "") {
1693 if (!Align) {
1694 const DataLayout &DL = BB->getModule()->getDataLayout();
1695 Align = DL.getABITypeAlign(Ty);
1696 }
1697 return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile, *Align), Name);
1698 }
1699
1700 // Deprecated [opaque pointer types]
1701 LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr,
1702 MaybeAlign Align,
1703 const char *Name),
1704 "Use the version that explicitly specifies the "
1705 "loaded type instead") {
1706 return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1707 Align, Name);
1708 }
1709 // Deprecated [opaque pointer types]
1710 LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr,
1711 MaybeAlign Align,
1712 const Twine &Name = ""),
1713 "Use the version that explicitly specifies the "
1714 "loaded type instead") {
1715 return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1716 Align, Name);
1717 }
1718 // Deprecated [opaque pointer types]
1719 LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr,
1720 MaybeAlign Align,
1721 bool isVolatile,
1722 const Twine &Name = ""),
1723 "Use the version that explicitly specifies the "
1724 "loaded type instead") {
1725 return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1726 Align, isVolatile, Name);
1727 }
1728
1729 StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, MaybeAlign Align,
1730 bool isVolatile = false) {
1731 if (!Align) {
1732 const DataLayout &DL = BB->getModule()->getDataLayout();
1733 Align = DL.getABITypeAlign(Val->getType());
1734 }
1735 return Insert(new StoreInst(Val, Ptr, isVolatile, *Align));
1736 }
1737 FenceInst *CreateFence(AtomicOrdering Ordering,
1738 SyncScope::ID SSID = SyncScope::System,
1739 const Twine &Name = "") {
1740 return Insert(new FenceInst(Context, Ordering, SSID), Name);
1741 }
1742
1743 AtomicCmpXchgInst *
1744 CreateAtomicCmpXchg(Value *Ptr, Value *Cmp, Value *New, MaybeAlign Align,
1745 AtomicOrdering SuccessOrdering,
1746 AtomicOrdering FailureOrdering,
1747 SyncScope::ID SSID = SyncScope::System) {
1748 if (!Align) {
1749 const DataLayout &DL = BB->getModule()->getDataLayout();
1750 Align = llvm::Align(DL.getTypeStoreSize(New->getType()));
1751 }
1752
1753 return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, *Align, SuccessOrdering,
1754 FailureOrdering, SSID));
1755 }
1756
1757 AtomicRMWInst *CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr,
1758 Value *Val, MaybeAlign Align,
1759 AtomicOrdering Ordering,
1760 SyncScope::ID SSID = SyncScope::System) {
1761 if (!Align) {
1762 const DataLayout &DL = BB->getModule()->getDataLayout();
1763 Align = llvm::Align(DL.getTypeStoreSize(Val->getType()));
1764 }
1765
1766 return Insert(new AtomicRMWInst(Op, Ptr, Val, *Align, Ordering, SSID));
1767 }
1768
1769 Value *CreateGEP(Value *Ptr, ArrayRef<Value *> IdxList,
1770 const Twine &Name = "") {
1771 return CreateGEP(nullptr, Ptr, IdxList, Name);
1772 }
1773
1774 Value *CreateGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
1775 const Twine &Name = "") {
1776 if (auto *PC = dyn_cast<Constant>(Ptr)) {
1777 // Every index must be constant.
1778 size_t i, e;
1779 for (i = 0, e = IdxList.size(); i != e; ++i)
1780 if (!isa<Constant>(IdxList[i]))
1781 break;
1782 if (i == e)
1783 return Insert(Folder.CreateGetElementPtr(Ty, PC, IdxList), Name);
1784 }
1785 return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name);
1786 }
1787
1788 Value *CreateInBoundsGEP(Value *Ptr, ArrayRef<Value *> IdxList,
1789 const Twine &Name = "") {
1790 return CreateInBoundsGEP(nullptr, Ptr, IdxList, Name);
1791 }
1792
1793 Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
1794 const Twine &Name = "") {
1795 if (auto *PC = dyn_cast<Constant>(Ptr)) {
1796 // Every index must be constant.
1797 size_t i, e;
1798 for (i = 0, e = IdxList.size(); i != e; ++i)
1799 if (!isa<Constant>(IdxList[i]))
1800 break;
1801 if (i == e)
1802 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList),
1803 Name);
1804 }
1805 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name);
1806 }
1807
1808 Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = "") {
1809 return CreateGEP(nullptr, Ptr, Idx, Name);
1810 }
1811
1812 Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") {
1813 if (auto *PC = dyn_cast<Constant>(Ptr))
1814 if (auto *IC = dyn_cast<Constant>(Idx))
1815 return Insert(Folder.CreateGetElementPtr(Ty, PC, IC), Name);
1816 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1817 }
1818
1819 Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, Value *Idx,
1820 const Twine &Name = "") {
1821 if (auto *PC = dyn_cast<Constant>(Ptr))
1822 if (auto *IC = dyn_cast<Constant>(Idx))
1823 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IC), Name);
1824 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1825 }
1826
1827 Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const Twine &Name = "") {
1828 return CreateConstGEP1_32(nullptr, Ptr, Idx0, Name);
1829 }
1830
1831 Value *CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1832 const Twine &Name = "") {
1833 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1834
1835 if (auto *PC = dyn_cast<Constant>(Ptr))
1836 return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);
1837
1838 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1839 }
1840
1841 Value *CreateConstInBoundsGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1842 const Twine &Name = "") {
1843 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1844
1845 if (auto *PC = dyn_cast<Constant>(Ptr))
1846 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1847
1848 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1849 }
1850
1851 Value *CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1,
1852 const Twine &Name = "") {
1853 Value *Idxs[] = {
1854 ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1855 ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1856 };
1857
1858 if (auto *PC = dyn_cast<Constant>(Ptr))
1859 return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);
1860
1861 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1862 }
1863
1864 Value *CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0,
1865 unsigned Idx1, const Twine &Name = "") {
1866 Value *Idxs[] = {
1867 ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1868 ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1869 };
1870
1871 if (auto *PC = dyn_cast<Constant>(Ptr))
1872 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1873
1874 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1875 }
1876
1877 Value *CreateConstGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1878 const Twine &Name = "") {
1879 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1880
1881 if (auto *PC = dyn_cast<Constant>(Ptr))
1882 return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);
1883
1884 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1885 }
1886
1887 Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const Twine &Name = "") {
1888 return CreateConstGEP1_64(nullptr, Ptr, Idx0, Name);
1889 }
1890
1891 Value *CreateConstInBoundsGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1892 const Twine &Name = "") {
1893 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1894
1895 if (auto *PC = dyn_cast<Constant>(Ptr))
1896 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1897
1898 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1899 }
1900
1901 Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0,
1902 const Twine &Name = "") {
1903 return CreateConstInBoundsGEP1_64(nullptr, Ptr, Idx0, Name);
1904 }
1905
1906 Value *CreateConstGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1907 const Twine &Name = "") {
1908 Value *Idxs[] = {
1909 ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1910 ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1911 };
1912
1913 if (auto *PC = dyn_cast<Constant>(Ptr))
1914 return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);
1915
1916 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1917 }
1918
1919 Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1920 const Twine &Name = "") {
1921 return CreateConstGEP2_64(nullptr, Ptr, Idx0, Idx1, Name);
1922 }
1923
1924 Value *CreateConstInBoundsGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1925 uint64_t Idx1, const Twine &Name = "") {
1926 Value *Idxs[] = {
1927 ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1928 ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1929 };
1930
1931 if (auto *PC = dyn_cast<Constant>(Ptr))
1932 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1933
1934 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1935 }
1936
1937 Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1938 const Twine &Name = "") {
1939 return CreateConstInBoundsGEP2_64(nullptr, Ptr, Idx0, Idx1, Name);
1940 }
1941
1942 Value *CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx,
1943 const Twine &Name = "") {
1944 return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name);
1945 }
1946
1947 Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine &Name = "") {
1948 return CreateConstInBoundsGEP2_32(nullptr, Ptr, 0, Idx, Name);
1949 }
1950
1951 /// Same as CreateGlobalString, but return a pointer with "i8*" type
1952 /// instead of a pointer to array of i8.
1953 ///
1954 /// If no module is given via \p M, it is take from the insertion point basic
1955 /// block.
1956 Constant *CreateGlobalStringPtr(StringRef Str, const Twine &Name = "",
1957 unsigned AddressSpace = 0,
1958 Module *M = nullptr) {
1959 GlobalVariable *GV = CreateGlobalString(Str, Name, AddressSpace, M);
1960 Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
1961 Constant *Indices[] = {Zero, Zero};
1962 return ConstantExpr::getInBoundsGetElementPtr(GV->getValueType(), GV,
1963 Indices);
1964 }
1965
1966 //===--------------------------------------------------------------------===//
1967 // Instruction creation methods: Cast/Conversion Operators
1968 //===--------------------------------------------------------------------===//
1969
1970 Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
1971 return CreateCast(Instruction::Trunc, V, DestTy, Name);
1972 }
1973
1974 Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "") {
1975 return CreateCast(Instruction::ZExt, V, DestTy, Name);
1976 }
1977
1978 Value *CreateSExt(Value *V, Type *DestTy, const Twine &Name = "") {
1979 return CreateCast(Instruction::SExt, V, DestTy, Name);
1980 }
1981
1982 /// Create a ZExt or Trunc from the integer value V to DestTy. Return
1983 /// the value untouched if the type of V is already DestTy.
1984 Value *CreateZExtOrTrunc(Value *V, Type *DestTy,
1985 const Twine &Name = "") {
1986 assert(V->getType()->isIntOrIntVectorTy() &&
1987 DestTy->isIntOrIntVectorTy() &&
1988 "Can only zero extend/truncate integers!");
1989 Type *VTy = V->getType();
1990 if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
1991 return CreateZExt(V, DestTy, Name);
1992 if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
1993 return CreateTrunc(V, DestTy, Name);
1994 return V;
1995 }
1996
1997 /// Create a SExt or Trunc from the integer value V to DestTy. Return
1998 /// the value untouched if the type of V is already DestTy.
1999 Value *CreateSExtOrTrunc(Value *V, Type *DestTy,
2000 const Twine &Name = "") {
2001 assert(V->getType()->isIntOrIntVectorTy() &&
2002 DestTy->isIntOrIntVectorTy() &&
2003 "Can only sign extend/truncate integers!");
2004 Type *VTy = V->getType();
2005 if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
2006 return CreateSExt(V, DestTy, Name);
2007 if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
2008 return CreateTrunc(V, DestTy, Name);
2009 return V;
2010 }
2011
2012 Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = "") {
2013 if (IsFPConstrained)
2014 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptoui,
2015 V, DestTy, nullptr, Name);
2016 return CreateCast(Instruction::FPToUI, V, DestTy, Name);
2017 }
2018
2019 Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = "") {
2020 if (IsFPConstrained)
2021 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptosi,
2022 V, DestTy, nullptr, Name);
2023 return CreateCast(Instruction::FPToSI, V, DestTy, Name);
2024 }
2025
2026 Value *CreateUIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
2027 if (IsFPConstrained)
2028 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_uitofp,
2029 V, DestTy, nullptr, Name);
2030 return CreateCast(Instruction::UIToFP, V, DestTy, Name);
2031 }
2032
2033 Value *CreateSIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
2034 if (IsFPConstrained)
2035 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_sitofp,
2036 V, DestTy, nullptr, Name);
2037 return CreateCast(Instruction::SIToFP, V, DestTy, Name);
2038 }
2039
2040 Value *CreateFPTrunc(Value *V, Type *DestTy,
2041 const Twine &Name = "") {
2042 if (IsFPConstrained)
2043 return CreateConstrainedFPCast(
2044 Intrinsic::experimental_constrained_fptrunc, V, DestTy, nullptr,
2045 Name);
2046 return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
2047 }
2048
2049 Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "") {
2050 if (IsFPConstrained)
2051 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fpext,
2052 V, DestTy, nullptr, Name);
2053 return CreateCast(Instruction::FPExt, V, DestTy, Name);
2054 }
2055
2056 Value *CreatePtrToInt(Value *V, Type *DestTy,
2057 const Twine &Name = "") {
2058 return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
2059 }
2060
2061 Value *CreateIntToPtr(Value *V, Type *DestTy,
2062 const Twine &Name = "") {
2063 return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
2064 }
2065
2066 Value *CreateBitCast(Value *V, Type *DestTy,
2067 const Twine &Name = "") {
2068 return CreateCast(Instruction::BitCast, V, DestTy, Name);
2069 }
2070
2071 Value *CreateAddrSpaceCast(Value *V, Type *DestTy,
2072 const Twine &Name = "") {
2073 return CreateCast(Instruction::AddrSpaceCast, V, DestTy, Name);
2074 }
2075
2076 Value *CreateZExtOrBitCast(Value *V, Type *DestTy,
2077 const Twine &Name = "") {
2078 if (V->getType() == DestTy)
2079 return V;
2080 if (auto *VC = dyn_cast<Constant>(V))
2081 return Insert(Folder.CreateZExtOrBitCast(VC, DestTy), Name);
2082 return Insert(CastInst::CreateZExtOrBitCast(V, DestTy), Name);
2083 }
2084
2085 Value *CreateSExtOrBitCast(Value *V, Type *DestTy,
2086 const Twine &Name = "") {
2087 if (V->getType() == DestTy)
2088 return V;
2089 if (auto *VC = dyn_cast<Constant>(V))
2090 return Insert(Folder.CreateSExtOrBitCast(VC, DestTy), Name);
2091 return Insert(CastInst::CreateSExtOrBitCast(V, DestTy), Name);
2092 }
2093
2094 Value *CreateTruncOrBitCast(Value *V, Type *DestTy,
2095 const Twine &Name = "") {
2096