LLVM 20.0.0git
IRBuilder.h
Go to the documentation of this file.
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/STLExtras.h"
20#include "llvm/ADT/StringRef.h"
21#include "llvm/ADT/Twine.h"
22#include "llvm/IR/BasicBlock.h"
23#include "llvm/IR/Constant.h"
25#include "llvm/IR/Constants.h"
26#include "llvm/IR/DataLayout.h"
27#include "llvm/IR/DebugLoc.h"
29#include "llvm/IR/FPEnv.h"
30#include "llvm/IR/Function.h"
32#include "llvm/IR/InstrTypes.h"
33#include "llvm/IR/Instruction.h"
35#include "llvm/IR/Intrinsics.h"
36#include "llvm/IR/LLVMContext.h"
37#include "llvm/IR/Operator.h"
38#include "llvm/IR/Type.h"
39#include "llvm/IR/Value.h"
40#include "llvm/IR/ValueHandle.h"
44#include <cassert>
45#include <cstdint>
46#include <functional>
47#include <optional>
48#include <utility>
49
50namespace llvm {
51
52class APInt;
53class Use;
54
55/// This provides the default implementation of the IRBuilder
56/// 'InsertHelper' method that is called whenever an instruction is created by
57/// IRBuilder and needs to be inserted.
58///
59/// By default, this inserts the instruction at the insertion point.
61public:
63
64 virtual void InsertHelper(Instruction *I, const Twine &Name,
65 BasicBlock::iterator InsertPt) const {
66 if (InsertPt.isValid())
67 I->insertInto(InsertPt.getNodeParent(), InsertPt);
68 I->setName(Name);
69 }
70};
71
72/// Provides an 'InsertHelper' that calls a user-provided callback after
73/// performing the default insertion.
75 std::function<void(Instruction *)> Callback;
76
77public:
79
80 IRBuilderCallbackInserter(std::function<void(Instruction *)> Callback)
81 : Callback(std::move(Callback)) {}
82
84 BasicBlock::iterator InsertPt) const override {
86 Callback(I);
87 }
88};
89
90/// Common base class shared among various IRBuilders.
92 /// Pairs of (metadata kind, MDNode *) that should be added to all newly
93 /// created instructions, like !dbg metadata.
95
96 /// Add or update the an entry (Kind, MD) to MetadataToCopy, if \p MD is not
97 /// null. If \p MD is null, remove the entry with \p Kind.
98 void AddOrRemoveMetadataToCopy(unsigned Kind, MDNode *MD) {
99 if (!MD) {
100 erase_if(MetadataToCopy, [Kind](const std::pair<unsigned, MDNode *> &KV) {
101 return KV.first == Kind;
102 });
103 return;
104 }
105
106 for (auto &KV : MetadataToCopy)
107 if (KV.first == Kind) {
108 KV.second = MD;
109 return;
110 }
111
112 MetadataToCopy.emplace_back(Kind, MD);
113 }
114
115protected:
121
124
125 bool IsFPConstrained = false;
128
130
131public:
133 const IRBuilderDefaultInserter &Inserter, MDNode *FPMathTag,
135 : Context(context), Folder(Folder), Inserter(Inserter),
136 DefaultFPMathTag(FPMathTag), DefaultOperandBundles(OpBundles) {
138 }
139
140 /// Insert and return the specified instruction.
141 template<typename InstTy>
142 InstTy *Insert(InstTy *I, const Twine &Name = "") const {
145 return I;
146 }
147
148 /// No-op overload to handle constants.
149 Constant *Insert(Constant *C, const Twine& = "") const {
150 return C;
151 }
152
153 Value *Insert(Value *V, const Twine &Name = "") const {
154 if (Instruction *I = dyn_cast<Instruction>(V))
155 return Insert(I, Name);
156 assert(isa<Constant>(V));
157 return V;
158 }
159
160 //===--------------------------------------------------------------------===//
161 // Builder configuration methods
162 //===--------------------------------------------------------------------===//
163
164 /// Clear the insertion point: created instructions will not be
165 /// inserted into a block.
167 BB = nullptr;
169 }
170
171 BasicBlock *GetInsertBlock() const { return BB; }
173 LLVMContext &getContext() const { return Context; }
174
175 /// This specifies that created instructions should be appended to the
176 /// end of the specified block.
178 BB = TheBB;
179 InsertPt = BB->end();
180 }
181
182 /// This specifies that created instructions should be inserted before
183 /// the specified instruction.
185 BB = I->getParent();
186 InsertPt = I->getIterator();
187 assert(InsertPt != BB->end() && "Can't read debug loc from end()");
188 SetCurrentDebugLocation(I->getStableDebugLoc());
189 }
190
191 /// This specifies that created instructions should be inserted at the
192 /// specified point.
194 BB = TheBB;
195 InsertPt = IP;
196 if (IP != TheBB->end())
197 SetCurrentDebugLocation(IP->getStableDebugLoc());
198 }
199
200 /// This specifies that created instructions should be inserted at
201 /// the specified point, but also requires that \p IP is dereferencable.
203 BB = IP->getParent();
204 InsertPt = IP;
205 SetCurrentDebugLocation(IP->getStableDebugLoc());
206 }
207
208 /// This specifies that created instructions should inserted at the beginning
209 /// end of the specified function, but after already existing static alloca
210 /// instructions that are at the start.
212 BB = &F->getEntryBlock();
214 }
215
216 /// Set location information used by debugging information.
218 AddOrRemoveMetadataToCopy(LLVMContext::MD_dbg, L.getAsMDNode());
219 }
220
221 /// Set nosanitize metadata.
223 AddOrRemoveMetadataToCopy(llvm::LLVMContext::MD_nosanitize,
224 llvm::MDNode::get(getContext(), std::nullopt));
225 }
226
227 /// Collect metadata with IDs \p MetadataKinds from \p Src which should be
228 /// added to all created instructions. Entries present in MedataDataToCopy but
229 /// not on \p Src will be dropped from MetadataToCopy.
231 ArrayRef<unsigned> MetadataKinds) {
232 for (unsigned K : MetadataKinds)
233 AddOrRemoveMetadataToCopy(K, Src->getMetadata(K));
234 }
235
236 /// Get location information used by debugging information.
238
239 /// If this builder has a current debug location, set it on the
240 /// specified instruction.
242
243 /// Add all entries in MetadataToCopy to \p I.
245 for (const auto &KV : MetadataToCopy)
246 I->setMetadata(KV.first, KV.second);
247 }
248
249 /// Get the return type of the current function that we're emitting
250 /// into.
252
253 /// InsertPoint - A saved insertion point.
255 BasicBlock *Block = nullptr;
257
258 public:
259 /// Creates a new insertion point which doesn't point to anything.
260 InsertPoint() = default;
261
262 /// Creates a new insertion point at the given location.
264 : Block(InsertBlock), Point(InsertPoint) {}
265
266 /// Returns true if this insert point is set.
267 bool isSet() const { return (Block != nullptr); }
268
269 BasicBlock *getBlock() const { return Block; }
270 BasicBlock::iterator getPoint() const { return Point; }
271 };
272
273 /// Returns the current insert point.
276 }
277
278 /// Returns the current insert point, clearing it in the process.
282 return IP;
283 }
284
285 /// Sets the current insert point to a previously-saved location.
287 if (IP.isSet())
288 SetInsertPoint(IP.getBlock(), IP.getPoint());
289 else
291 }
292
293 /// Get the floating point math metadata being used.
295
296 /// Get the flags to be applied to created floating point ops
298
300
301 /// Clear the fast-math flags.
303
304 /// Set the floating point math metadata to be used.
305 void setDefaultFPMathTag(MDNode *FPMathTag) { DefaultFPMathTag = FPMathTag; }
306
307 /// Set the fast-math flags to be used with generated fp-math operators
308 void setFastMathFlags(FastMathFlags NewFMF) { FMF = NewFMF; }
309
310 /// Enable/Disable use of constrained floating point math. When
311 /// enabled the CreateF<op>() calls instead create constrained
312 /// floating point intrinsic calls. Fast math flags are unaffected
313 /// by this setting.
314 void setIsFPConstrained(bool IsCon) { IsFPConstrained = IsCon; }
315
316 /// Query for the use of constrained floating point math
318
319 /// Set the exception handling to be used with constrained floating point
321#ifndef NDEBUG
322 std::optional<StringRef> ExceptStr =
324 assert(ExceptStr && "Garbage strict exception behavior!");
325#endif
326 DefaultConstrainedExcept = NewExcept;
327 }
328
329 /// Set the rounding mode handling to be used with constrained floating point
331#ifndef NDEBUG
332 std::optional<StringRef> RoundingStr =
333 convertRoundingModeToStr(NewRounding);
334 assert(RoundingStr && "Garbage strict rounding mode!");
335#endif
336 DefaultConstrainedRounding = NewRounding;
337 }
338
339 /// Get the exception handling used with constrained floating point
342 }
343
344 /// Get the rounding mode handling used with constrained floating point
347 }
348
350 assert(BB && "Must have a basic block to set any function attributes!");
351
352 Function *F = BB->getParent();
353 if (!F->hasFnAttribute(Attribute::StrictFP)) {
354 F->addFnAttr(Attribute::StrictFP);
355 }
356 }
357
359 I->addFnAttr(Attribute::StrictFP);
360 }
361
363 DefaultOperandBundles = OpBundles;
364 }
365
366 //===--------------------------------------------------------------------===//
367 // RAII helpers.
368 //===--------------------------------------------------------------------===//
369
370 // RAII object that stores the current insertion point and restores it
371 // when the object is destroyed. This includes the debug location.
373 IRBuilderBase &Builder;
376 DebugLoc DbgLoc;
377
378 public:
380 : Builder(B), Block(B.GetInsertBlock()), Point(B.GetInsertPoint()),
381 DbgLoc(B.getCurrentDebugLocation()) {}
382
385
387 Builder.restoreIP(InsertPoint(Block, Point));
388 Builder.SetCurrentDebugLocation(DbgLoc);
389 }
390 };
391
392 // RAII object that stores the current fast math settings and restores
393 // them when the object is destroyed.
395 IRBuilderBase &Builder;
396 FastMathFlags FMF;
397 MDNode *FPMathTag;
398 bool IsFPConstrained;
399 fp::ExceptionBehavior DefaultConstrainedExcept;
400 RoundingMode DefaultConstrainedRounding;
401
402 public:
404 : Builder(B), FMF(B.FMF), FPMathTag(B.DefaultFPMathTag),
405 IsFPConstrained(B.IsFPConstrained),
406 DefaultConstrainedExcept(B.DefaultConstrainedExcept),
407 DefaultConstrainedRounding(B.DefaultConstrainedRounding) {}
408
411
413 Builder.FMF = FMF;
414 Builder.DefaultFPMathTag = FPMathTag;
415 Builder.IsFPConstrained = IsFPConstrained;
416 Builder.DefaultConstrainedExcept = DefaultConstrainedExcept;
417 Builder.DefaultConstrainedRounding = DefaultConstrainedRounding;
418 }
419 };
420
421 // RAII object that stores the current default operand bundles and restores
422 // them when the object is destroyed.
424 IRBuilderBase &Builder;
425 ArrayRef<OperandBundleDef> DefaultOperandBundles;
426
427 public:
429 : Builder(B), DefaultOperandBundles(B.DefaultOperandBundles) {}
430
433
435 Builder.DefaultOperandBundles = DefaultOperandBundles;
436 }
437 };
438
439
440 //===--------------------------------------------------------------------===//
441 // Miscellaneous creation methods.
442 //===--------------------------------------------------------------------===//
443
444 /// Make a new global variable with initializer type i8*
445 ///
446 /// Make a new global variable with an initializer that has array of i8 type
447 /// filled in with the null terminated string value specified. The new global
448 /// variable will be marked mergable with any others of the same contents. If
449 /// Name is specified, it is the name of the global variable created.
450 ///
451 /// If no module is given via \p M, it is take from the insertion point basic
452 /// block.
454 unsigned AddressSpace = 0,
455 Module *M = nullptr, bool AddNull = true);
456
457 /// Get a constant value representing either true or false.
459 return ConstantInt::get(getInt1Ty(), V);
460 }
461
462 /// Get the constant value for i1 true.
465 }
466
467 /// Get the constant value for i1 false.
470 }
471
472 /// Get a constant 8-bit value.
474 return ConstantInt::get(getInt8Ty(), C);
475 }
476
477 /// Get a constant 16-bit value.
479 return ConstantInt::get(getInt16Ty(), C);
480 }
481
482 /// Get a constant 32-bit value.
484 return ConstantInt::get(getInt32Ty(), C);
485 }
486
487 /// Get a constant 64-bit value.
489 return ConstantInt::get(getInt64Ty(), C);
490 }
491
492 /// Get a constant N-bit value, zero extended or truncated from
493 /// a 64-bit value.
495 return ConstantInt::get(getIntNTy(N), C);
496 }
497
498 /// Get a constant integer value.
500 return ConstantInt::get(Context, AI);
501 }
502
503 //===--------------------------------------------------------------------===//
504 // Type creation methods
505 //===--------------------------------------------------------------------===//
506
507 /// Fetch the type representing a single bit
509 return Type::getInt1Ty(Context);
510 }
511
512 /// Fetch the type representing an 8-bit integer.
514 return Type::getInt8Ty(Context);
515 }
516
517 /// Fetch the type representing a 16-bit integer.
520 }
521
522 /// Fetch the type representing a 32-bit integer.
525 }
526
527 /// Fetch the type representing a 64-bit integer.
530 }
531
532 /// Fetch the type representing a 128-bit integer.
534
535 /// Fetch the type representing an N-bit integer.
537 return Type::getIntNTy(Context, N);
538 }
539
540 /// Fetch the type representing a 16-bit floating point value.
542 return Type::getHalfTy(Context);
543 }
544
545 /// Fetch the type representing a 16-bit brain floating point value.
548 }
549
550 /// Fetch the type representing a 32-bit floating point value.
553 }
554
555 /// Fetch the type representing a 64-bit floating point value.
558 }
559
560 /// Fetch the type representing void.
562 return Type::getVoidTy(Context);
563 }
564
565 /// Fetch the type representing a pointer.
566 PointerType *getPtrTy(unsigned AddrSpace = 0) {
567 return PointerType::get(Context, AddrSpace);
568 }
569
570 /// Fetch the type of an integer with size at least as big as that of a
571 /// pointer in the given address space.
572 IntegerType *getIntPtrTy(const DataLayout &DL, unsigned AddrSpace = 0) {
573 return DL.getIntPtrType(Context, AddrSpace);
574 }
575
576 /// Fetch the type of an integer that should be used to index GEP operations
577 /// within AddressSpace.
578 IntegerType *getIndexTy(const DataLayout &DL, unsigned AddrSpace) {
579 return DL.getIndexType(Context, AddrSpace);
580 }
581
582 //===--------------------------------------------------------------------===//
583 // Intrinsic creation methods
584 //===--------------------------------------------------------------------===//
585
586 /// Create and insert a memset to the specified pointer and the
587 /// specified value.
588 ///
589 /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is
590 /// specified, it will be added to the instruction. Likewise with alias.scope
591 /// and noalias tags.
593 MaybeAlign Align, bool isVolatile = false,
594 MDNode *TBAATag = nullptr, MDNode *ScopeTag = nullptr,
595 MDNode *NoAliasTag = nullptr) {
596 return CreateMemSet(Ptr, Val, getInt64(Size), Align, isVolatile,
597 TBAATag, ScopeTag, NoAliasTag);
598 }
599
601 bool isVolatile = false, MDNode *TBAATag = nullptr,
602 MDNode *ScopeTag = nullptr,
603 MDNode *NoAliasTag = nullptr);
604
605 CallInst *CreateMemSetInline(Value *Dst, MaybeAlign DstAlign, Value *Val,
606 Value *Size, bool IsVolatile = false,
607 MDNode *TBAATag = nullptr,
608 MDNode *ScopeTag = nullptr,
609 MDNode *NoAliasTag = nullptr);
610
611 /// Create and insert an element unordered-atomic memset of the region of
612 /// memory starting at the given pointer to the given value.
613 ///
614 /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is
615 /// specified, it will be added to the instruction. Likewise with alias.scope
616 /// and noalias tags.
618 uint64_t Size, Align Alignment,
619 uint32_t ElementSize,
620 MDNode *TBAATag = nullptr,
621 MDNode *ScopeTag = nullptr,
622 MDNode *NoAliasTag = nullptr) {
624 Align(Alignment), ElementSize,
625 TBAATag, ScopeTag, NoAliasTag);
626 }
627
628 CallInst *CreateMalloc(Type *IntPtrTy, Type *AllocTy, Value *AllocSize,
629 Value *ArraySize, ArrayRef<OperandBundleDef> OpB,
630 Function *MallocF = nullptr, const Twine &Name = "");
631
632 /// CreateMalloc - Generate the IR for a call to malloc:
633 /// 1. Compute the malloc call's argument as the specified type's size,
634 /// possibly multiplied by the array size if the array size is not
635 /// constant 1.
636 /// 2. Call malloc with that argument.
637 CallInst *CreateMalloc(Type *IntPtrTy, Type *AllocTy, Value *AllocSize,
638 Value *ArraySize, Function *MallocF = nullptr,
639 const Twine &Name = "");
640 /// Generate the IR for a call to the builtin free function.
641 CallInst *CreateFree(Value *Source,
642 ArrayRef<OperandBundleDef> Bundles = std::nullopt);
643
645 Value *Size, Align Alignment,
646 uint32_t ElementSize,
647 MDNode *TBAATag = nullptr,
648 MDNode *ScopeTag = nullptr,
649 MDNode *NoAliasTag = nullptr);
650
651 /// Create and insert a memcpy between the specified pointers.
652 ///
653 /// If the pointers aren't i8*, they will be converted. If a TBAA tag is
654 /// specified, it will be added to the instruction. Likewise with alias.scope
655 /// and noalias tags.
657 MaybeAlign SrcAlign, uint64_t Size,
658 bool isVolatile = false, MDNode *TBAATag = nullptr,
659 MDNode *TBAAStructTag = nullptr,
660 MDNode *ScopeTag = nullptr,
661 MDNode *NoAliasTag = nullptr) {
662 return CreateMemCpy(Dst, DstAlign, Src, SrcAlign, getInt64(Size),
663 isVolatile, TBAATag, TBAAStructTag, ScopeTag,
664 NoAliasTag);
665 }
666
668 Intrinsic::ID IntrID, Value *Dst, MaybeAlign DstAlign, Value *Src,
669 MaybeAlign SrcAlign, Value *Size, bool isVolatile = false,
670 MDNode *TBAATag = nullptr, MDNode *TBAAStructTag = nullptr,
671 MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr);
672
674 MaybeAlign SrcAlign, Value *Size,
675 bool isVolatile = false, MDNode *TBAATag = nullptr,
676 MDNode *TBAAStructTag = nullptr,
677 MDNode *ScopeTag = nullptr,
678 MDNode *NoAliasTag = nullptr) {
679 return CreateMemTransferInst(Intrinsic::memcpy, Dst, DstAlign, Src,
680 SrcAlign, Size, isVolatile, TBAATag,
681 TBAAStructTag, ScopeTag, NoAliasTag);
682 }
683
684 CallInst *
686 MaybeAlign SrcAlign, Value *Size, bool isVolatile = false,
687 MDNode *TBAATag = nullptr, MDNode *TBAAStructTag = nullptr,
688 MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr) {
689 return CreateMemTransferInst(Intrinsic::memcpy_inline, Dst, DstAlign, Src,
690 SrcAlign, Size, isVolatile, TBAATag,
691 TBAAStructTag, ScopeTag, NoAliasTag);
692 }
693
694 /// Create and insert an element unordered-atomic memcpy between the
695 /// specified pointers.
696 ///
697 /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers, respectively.
698 ///
699 /// If the pointers aren't i8*, they will be converted. If a TBAA tag is
700 /// specified, it will be added to the instruction. Likewise with alias.scope
701 /// and noalias tags.
703 Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size,
704 uint32_t ElementSize, MDNode *TBAATag = nullptr,
705 MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
706 MDNode *NoAliasTag = nullptr);
707
709 MaybeAlign SrcAlign, uint64_t Size,
710 bool isVolatile = false, MDNode *TBAATag = nullptr,
711 MDNode *ScopeTag = nullptr,
712 MDNode *NoAliasTag = nullptr) {
713 return CreateMemMove(Dst, DstAlign, Src, SrcAlign, getInt64(Size),
714 isVolatile, TBAATag, ScopeTag, NoAliasTag);
715 }
716
718 MaybeAlign SrcAlign, Value *Size,
719 bool isVolatile = false, MDNode *TBAATag = nullptr,
720 MDNode *ScopeTag = nullptr,
721 MDNode *NoAliasTag = nullptr) {
722 return CreateMemTransferInst(Intrinsic::memmove, Dst, DstAlign, Src,
723 SrcAlign, Size, isVolatile, TBAATag,
724 /*TBAAStructTag=*/nullptr, ScopeTag,
725 NoAliasTag);
726 }
727
728 /// \brief Create and insert an element unordered-atomic memmove between the
729 /// specified pointers.
730 ///
731 /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers,
732 /// respectively.
733 ///
734 /// If the pointers aren't i8*, they will be converted. If a TBAA tag is
735 /// specified, it will be added to the instruction. Likewise with alias.scope
736 /// and noalias tags.
738 Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size,
739 uint32_t ElementSize, MDNode *TBAATag = nullptr,
740 MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
741 MDNode *NoAliasTag = nullptr);
742
743private:
744 CallInst *getReductionIntrinsic(Intrinsic::ID ID, Value *Src);
745
746public:
747 /// Create a sequential vector fadd reduction intrinsic of the source vector.
748 /// The first parameter is a scalar accumulator value. An unordered reduction
749 /// can be created by adding the reassoc fast-math flag to the resulting
750 /// sequential reduction.
752
753 /// Create a sequential vector fmul reduction intrinsic of the source vector.
754 /// The first parameter is a scalar accumulator value. An unordered reduction
755 /// can be created by adding the reassoc fast-math flag to the resulting
756 /// sequential reduction.
758
759 /// Create a vector int add reduction intrinsic of the source vector.
761
762 /// Create a vector int mul reduction intrinsic of the source vector.
764
765 /// Create a vector int AND reduction intrinsic of the source vector.
767
768 /// Create a vector int OR reduction intrinsic of the source vector.
770
771 /// Create a vector int XOR reduction intrinsic of the source vector.
773
774 /// Create a vector integer max reduction intrinsic of the source
775 /// vector.
776 CallInst *CreateIntMaxReduce(Value *Src, bool IsSigned = false);
777
778 /// Create a vector integer min reduction intrinsic of the source
779 /// vector.
780 CallInst *CreateIntMinReduce(Value *Src, bool IsSigned = false);
781
782 /// Create a vector float max reduction intrinsic of the source
783 /// vector.
785
786 /// Create a vector float min reduction intrinsic of the source
787 /// vector.
789
790 /// Create a vector float maximum reduction intrinsic of the source
791 /// vector. This variant follows the NaN and signed zero semantic of
792 /// llvm.maximum intrinsic.
794
795 /// Create a vector float minimum reduction intrinsic of the source
796 /// vector. This variant follows the NaN and signed zero semantic of
797 /// llvm.minimum intrinsic.
799
800 /// Create a lifetime.start intrinsic.
801 ///
802 /// If the pointer isn't i8* it will be converted.
804
805 /// Create a lifetime.end intrinsic.
806 ///
807 /// If the pointer isn't i8* it will be converted.
809
810 /// Create a call to invariant.start intrinsic.
811 ///
812 /// If the pointer isn't i8* it will be converted.
814
815 /// Create a call to llvm.threadlocal.address intrinsic.
817
818 /// Create a call to Masked Load intrinsic
819 CallInst *CreateMaskedLoad(Type *Ty, Value *Ptr, Align Alignment, Value *Mask,
820 Value *PassThru = nullptr, const Twine &Name = "");
821
822 /// Create a call to Masked Store intrinsic
823 CallInst *CreateMaskedStore(Value *Val, Value *Ptr, Align Alignment,
824 Value *Mask);
825
826 /// Create a call to Masked Gather intrinsic
827 CallInst *CreateMaskedGather(Type *Ty, Value *Ptrs, Align Alignment,
828 Value *Mask = nullptr, Value *PassThru = nullptr,
829 const Twine &Name = "");
830
831 /// Create a call to Masked Scatter intrinsic
832 CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, Align Alignment,
833 Value *Mask = nullptr);
834
835 /// Create a call to Masked Expand Load intrinsic
836 CallInst *CreateMaskedExpandLoad(Type *Ty, Value *Ptr, Value *Mask = nullptr,
837 Value *PassThru = nullptr,
838 const Twine &Name = "");
839
840 /// Create a call to Masked Compress Store intrinsic
842 Value *Mask = nullptr);
843
844 /// Return an all true boolean vector (mask) with \p NumElts lanes.
847 return Constant::getAllOnesValue(VTy);
848 }
849
850 /// Create an assume intrinsic call that allows the optimizer to
851 /// assume that the provided condition will be true.
852 ///
853 /// The optional argument \p OpBundles specifies operand bundles that are
854 /// added to the call instruction.
855 CallInst *
857 ArrayRef<OperandBundleDef> OpBundles = std::nullopt);
858
859 /// Create a llvm.experimental.noalias.scope.decl intrinsic call.
863 MetadataAsValue::get(Context, ScopeTag));
864 }
865
866 /// Create a call to the experimental.gc.statepoint intrinsic to
867 /// start a new statepoint sequence.
869 FunctionCallee ActualCallee,
870 ArrayRef<Value *> CallArgs,
871 std::optional<ArrayRef<Value *>> DeoptArgs,
872 ArrayRef<Value *> GCArgs,
873 const Twine &Name = "");
874
875 /// Create a call to the experimental.gc.statepoint intrinsic to
876 /// start a new statepoint sequence.
878 FunctionCallee ActualCallee, uint32_t Flags,
879 ArrayRef<Value *> CallArgs,
880 std::optional<ArrayRef<Use>> TransitionArgs,
881 std::optional<ArrayRef<Use>> DeoptArgs,
882 ArrayRef<Value *> GCArgs,
883 const Twine &Name = "");
884
885 /// Conveninence function for the common case when CallArgs are filled
886 /// in using ArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be
887 /// .get()'ed to get the Value pointer.
889 FunctionCallee ActualCallee,
890 ArrayRef<Use> CallArgs,
891 std::optional<ArrayRef<Value *>> DeoptArgs,
892 ArrayRef<Value *> GCArgs,
893 const Twine &Name = "");
894
895 /// Create an invoke to the experimental.gc.statepoint intrinsic to
896 /// start a new statepoint sequence.
897 InvokeInst *
899 FunctionCallee ActualInvokee, BasicBlock *NormalDest,
900 BasicBlock *UnwindDest, ArrayRef<Value *> InvokeArgs,
901 std::optional<ArrayRef<Value *>> DeoptArgs,
902 ArrayRef<Value *> GCArgs, const Twine &Name = "");
903
904 /// Create an invoke to the experimental.gc.statepoint intrinsic to
905 /// start a new statepoint sequence.
907 uint64_t ID, uint32_t NumPatchBytes, FunctionCallee ActualInvokee,
908 BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags,
909 ArrayRef<Value *> InvokeArgs, std::optional<ArrayRef<Use>> TransitionArgs,
910 std::optional<ArrayRef<Use>> DeoptArgs, ArrayRef<Value *> GCArgs,
911 const Twine &Name = "");
912
913 // Convenience function for the common case when CallArgs are filled in using
914 // ArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be .get()'ed to
915 // get the Value *.
916 InvokeInst *
918 FunctionCallee ActualInvokee, BasicBlock *NormalDest,
919 BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs,
920 std::optional<ArrayRef<Value *>> DeoptArgs,
921 ArrayRef<Value *> GCArgs, const Twine &Name = "");
922
923 /// Create a call to the experimental.gc.result intrinsic to extract
924 /// the result from a call wrapped in a statepoint.
926 Type *ResultType,
927 const Twine &Name = "");
928
929 /// Create a call to the experimental.gc.relocate intrinsics to
930 /// project the relocated value of one pointer from the statepoint.
932 int BaseOffset,
933 int DerivedOffset,
934 Type *ResultType,
935 const Twine &Name = "");
936
937 /// Create a call to the experimental.gc.pointer.base intrinsic to get the
938 /// base pointer for the specified derived pointer.
939 CallInst *CreateGCGetPointerBase(Value *DerivedPtr, const Twine &Name = "");
940
941 /// Create a call to the experimental.gc.get.pointer.offset intrinsic to get
942 /// the offset of the specified derived pointer from its base.
943 CallInst *CreateGCGetPointerOffset(Value *DerivedPtr, const Twine &Name = "");
944
945 /// Create a call to llvm.vscale, multiplied by \p Scaling. The type of VScale
946 /// will be the same type as that of \p Scaling.
947 Value *CreateVScale(Constant *Scaling, const Twine &Name = "");
948
949 /// Create an expression which evaluates to the number of elements in \p EC
950 /// at runtime.
952
953 /// Create an expression which evaluates to the number of units in \p Size
954 /// at runtime. This works for both units of bits and bytes.
956
957 /// Creates a vector of type \p DstType with the linear sequence <0, 1, ...>
958 Value *CreateStepVector(Type *DstType, const Twine &Name = "");
959
960 /// Create a call to intrinsic \p ID with 1 operand which is mangled on its
961 /// type.
963 Instruction *FMFSource = nullptr,
964 const Twine &Name = "");
965
966 /// Create a call to intrinsic \p ID with 2 operands which is mangled on the
967 /// first type.
969 Instruction *FMFSource = nullptr,
970 const Twine &Name = "");
971
972 /// Create a call to intrinsic \p ID with \p Args, mangled using \p Types. If
973 /// \p FMFSource is provided, copy fast-math-flags from that instruction to
974 /// the intrinsic.
977 Instruction *FMFSource = nullptr,
978 const Twine &Name = "");
979
980 /// Create a call to intrinsic \p ID with \p RetTy and \p Args. If
981 /// \p FMFSource is provided, copy fast-math-flags from that instruction to
982 /// the intrinsic.
985 Instruction *FMFSource = nullptr,
986 const Twine &Name = "");
987
988 /// Create call to the minnum intrinsic.
990 if (IsFPConstrained) {
992 Intrinsic::experimental_constrained_minnum, LHS, RHS, nullptr, Name);
993 }
994
995 return CreateBinaryIntrinsic(Intrinsic::minnum, LHS, RHS, nullptr, Name);
996 }
997
998 /// Create call to the maxnum intrinsic.
1000 if (IsFPConstrained) {
1002 Intrinsic::experimental_constrained_maxnum, LHS, RHS, nullptr, Name);
1003 }
1004
1005 return CreateBinaryIntrinsic(Intrinsic::maxnum, LHS, RHS, nullptr, Name);
1006 }
1007
1008 /// Create call to the minimum intrinsic.
1010 return CreateBinaryIntrinsic(Intrinsic::minimum, LHS, RHS, nullptr, Name);
1011 }
1012
1013 /// Create call to the maximum intrinsic.
1015 return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name);
1016 }
1017
1018 /// Create call to the minimumnum intrinsic.
1020 return CreateBinaryIntrinsic(Intrinsic::minimumnum, LHS, RHS, nullptr,
1021 Name);
1022 }
1023
1024 /// Create call to the maximum intrinsic.
1026 return CreateBinaryIntrinsic(Intrinsic::maximumnum, LHS, RHS, nullptr,
1027 Name);
1028 }
1029
1030 /// Create call to the copysign intrinsic.
1032 Instruction *FMFSource = nullptr,
1033 const Twine &Name = "") {
1034 return CreateBinaryIntrinsic(Intrinsic::copysign, LHS, RHS, FMFSource,
1035 Name);
1036 }
1037
1038 /// Create call to the ldexp intrinsic.
1039 Value *CreateLdexp(Value *Src, Value *Exp, Instruction *FMFSource = nullptr,
1040 const Twine &Name = "") {
1041 assert(!IsFPConstrained && "TODO: Support strictfp");
1042 return CreateIntrinsic(Intrinsic::ldexp, {Src->getType(), Exp->getType()},
1043 {Src, Exp}, FMFSource, Name);
1044 }
1045
1046 /// Create a call to the arithmetic_fence intrinsic.
1048 const Twine &Name = "") {
1049 return CreateIntrinsic(Intrinsic::arithmetic_fence, DstType, Val, nullptr,
1050 Name);
1051 }
1052
1053 /// Create a call to the vector.extract intrinsic.
1055 const Twine &Name = "") {
1056 return CreateIntrinsic(Intrinsic::vector_extract,
1057 {DstType, SrcVec->getType()}, {SrcVec, Idx}, nullptr,
1058 Name);
1059 }
1060
1061 /// Create a call to the vector.insert intrinsic.
1062 CallInst *CreateInsertVector(Type *DstType, Value *SrcVec, Value *SubVec,
1063 Value *Idx, const Twine &Name = "") {
1064 return CreateIntrinsic(Intrinsic::vector_insert,
1065 {DstType, SubVec->getType()}, {SrcVec, SubVec, Idx},
1066 nullptr, Name);
1067 }
1068
1069 /// Create a call to llvm.stacksave
1071 const DataLayout &DL = BB->getDataLayout();
1072 return CreateIntrinsic(Intrinsic::stacksave, {DL.getAllocaPtrType(Context)},
1073 {}, nullptr, Name);
1074 }
1075
1076 /// Create a call to llvm.stackrestore
1078 return CreateIntrinsic(Intrinsic::stackrestore, {Ptr->getType()}, {Ptr},
1079 nullptr, Name);
1080 }
1081
1082private:
1083 /// Create a call to a masked intrinsic with given Id.
1084 CallInst *CreateMaskedIntrinsic(Intrinsic::ID Id, ArrayRef<Value *> Ops,
1085 ArrayRef<Type *> OverloadedTypes,
1086 const Twine &Name = "");
1087
1088 //===--------------------------------------------------------------------===//
1089 // Instruction creation methods: Terminators
1090 //===--------------------------------------------------------------------===//
1091
1092private:
1093 /// Helper to add branch weight and unpredictable metadata onto an
1094 /// instruction.
1095 /// \returns The annotated instruction.
1096 template <typename InstTy>
1097 InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
1098 if (Weights)
1099 I->setMetadata(LLVMContext::MD_prof, Weights);
1100 if (Unpredictable)
1101 I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
1102 return I;
1103 }
1104
1105public:
1106 /// Create a 'ret void' instruction.
1109 }
1110
1111 /// Create a 'ret <val>' instruction.
1113 return Insert(ReturnInst::Create(Context, V));
1114 }
1115
1116 /// Create a sequence of N insertvalue instructions,
1117 /// with one Value from the retVals array each, that build a aggregate
1118 /// return value one value at a time, and a ret instruction to return
1119 /// the resulting aggregate value.
1120 ///
1121 /// This is a convenience function for code that uses aggregate return values
1122 /// as a vehicle for having multiple return values.
1123 ReturnInst *CreateAggregateRet(Value *const *retVals, unsigned N) {
1125 for (unsigned i = 0; i != N; ++i)
1126 V = CreateInsertValue(V, retVals[i], i, "mrv");
1127 return Insert(ReturnInst::Create(Context, V));
1128 }
1129
1130 /// Create an unconditional 'br label X' instruction.
1132 return Insert(BranchInst::Create(Dest));
1133 }
1134
1135 /// Create a conditional 'br Cond, TrueDest, FalseDest'
1136 /// instruction.
1138 MDNode *BranchWeights = nullptr,
1139 MDNode *Unpredictable = nullptr) {
1140 return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
1141 BranchWeights, Unpredictable));
1142 }
1143
1144 /// Create a conditional 'br Cond, TrueDest, FalseDest'
1145 /// instruction. Copy branch meta data if available.
1147 Instruction *MDSrc) {
1148 BranchInst *Br = BranchInst::Create(True, False, Cond);
1149 if (MDSrc) {
1150 unsigned WL[4] = {LLVMContext::MD_prof, LLVMContext::MD_unpredictable,
1151 LLVMContext::MD_make_implicit, LLVMContext::MD_dbg};
1152 Br->copyMetadata(*MDSrc, WL);
1153 }
1154 return Insert(Br);
1155 }
1156
1157 /// Create a switch instruction with the specified value, default dest,
1158 /// and with a hint for the number of cases that will be added (for efficient
1159 /// allocation).
1160 SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10,
1161 MDNode *BranchWeights = nullptr,
1162 MDNode *Unpredictable = nullptr) {
1163 return Insert(addBranchMetadata(SwitchInst::Create(V, Dest, NumCases),
1164 BranchWeights, Unpredictable));
1165 }
1166
1167 /// Create an indirect branch instruction with the specified address
1168 /// operand, with an optional hint for the number of destinations that will be
1169 /// added (for efficient allocation).
1170 IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) {
1171 return Insert(IndirectBrInst::Create(Addr, NumDests));
1172 }
1173
1174 /// Create an invoke instruction.
1176 BasicBlock *NormalDest, BasicBlock *UnwindDest,
1177 ArrayRef<Value *> Args,
1179 const Twine &Name = "") {
1180 InvokeInst *II =
1181 InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles);
1182 if (IsFPConstrained)
1184 return Insert(II, Name);
1185 }
1187 BasicBlock *NormalDest, BasicBlock *UnwindDest,
1188 ArrayRef<Value *> Args = std::nullopt,
1189 const Twine &Name = "") {
1190 InvokeInst *II =
1191 InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args);
1192 if (IsFPConstrained)
1194 return Insert(II, Name);
1195 }
1196
1198 BasicBlock *UnwindDest, ArrayRef<Value *> Args,
1200 const Twine &Name = "") {
1201 return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
1202 NormalDest, UnwindDest, Args, OpBundles, Name);
1203 }
1204
1206 BasicBlock *UnwindDest,
1207 ArrayRef<Value *> Args = std::nullopt,
1208 const Twine &Name = "") {
1209 return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
1210 NormalDest, UnwindDest, Args, Name);
1211 }
1212
1213 /// \brief Create a callbr instruction.
1215 BasicBlock *DefaultDest,
1216 ArrayRef<BasicBlock *> IndirectDests,
1217 ArrayRef<Value *> Args = std::nullopt,
1218 const Twine &Name = "") {
1219 return Insert(CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests,
1220 Args), Name);
1221 }
1223 BasicBlock *DefaultDest,
1224 ArrayRef<BasicBlock *> IndirectDests,
1225 ArrayRef<Value *> Args,
1227 const Twine &Name = "") {
1228 return Insert(
1229 CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests, Args,
1230 OpBundles), Name);
1231 }
1232
1234 ArrayRef<BasicBlock *> IndirectDests,
1235 ArrayRef<Value *> Args = std::nullopt,
1236 const Twine &Name = "") {
1237 return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
1238 DefaultDest, IndirectDests, Args, Name);
1239 }
1241 ArrayRef<BasicBlock *> IndirectDests,
1242 ArrayRef<Value *> Args,
1244 const Twine &Name = "") {
1245 return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
1246 DefaultDest, IndirectDests, Args, Name);
1247 }
1248
1250 return Insert(ResumeInst::Create(Exn));
1251 }
1252
1254 BasicBlock *UnwindBB = nullptr) {
1255 return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB));
1256 }
1257
1259 unsigned NumHandlers,
1260 const Twine &Name = "") {
1261 return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers),
1262 Name);
1263 }
1264
1266 const Twine &Name = "") {
1267 return Insert(CatchPadInst::Create(ParentPad, Args), Name);
1268 }
1269
1271 ArrayRef<Value *> Args = std::nullopt,
1272 const Twine &Name = "") {
1273 return Insert(CleanupPadInst::Create(ParentPad, Args), Name);
1274 }
1275
1277 return Insert(CatchReturnInst::Create(CatchPad, BB));
1278 }
1279
1281 return Insert(new UnreachableInst(Context));
1282 }
1283
1284 //===--------------------------------------------------------------------===//
1285 // Instruction creation methods: Binary Operators
1286 //===--------------------------------------------------------------------===//
1287private:
1288 BinaryOperator *CreateInsertNUWNSWBinOp(BinaryOperator::BinaryOps Opc,
1289 Value *LHS, Value *RHS,
1290 const Twine &Name,
1291 bool HasNUW, bool HasNSW) {
1293 if (HasNUW) BO->setHasNoUnsignedWrap();
1294 if (HasNSW) BO->setHasNoSignedWrap();
1295 return BO;
1296 }
1297
1298 Instruction *setFPAttrs(Instruction *I, MDNode *FPMD,
1299 FastMathFlags FMF) const {
1300 if (!FPMD)
1301 FPMD = DefaultFPMathTag;
1302 if (FPMD)
1303 I->setMetadata(LLVMContext::MD_fpmath, FPMD);
1304 I->setFastMathFlags(FMF);
1305 return I;
1306 }
1307
1308 Value *getConstrainedFPRounding(std::optional<RoundingMode> Rounding) {
1310
1311 if (Rounding)
1312 UseRounding = *Rounding;
1313
1314 std::optional<StringRef> RoundingStr =
1315 convertRoundingModeToStr(UseRounding);
1316 assert(RoundingStr && "Garbage strict rounding mode!");
1317 auto *RoundingMDS = MDString::get(Context, *RoundingStr);
1318
1319 return MetadataAsValue::get(Context, RoundingMDS);
1320 }
1321
1322 Value *getConstrainedFPExcept(std::optional<fp::ExceptionBehavior> Except) {
1323 std::optional<StringRef> ExceptStr = convertExceptionBehaviorToStr(
1324 Except.value_or(DefaultConstrainedExcept));
1325 assert(ExceptStr && "Garbage strict exception behavior!");
1326 auto *ExceptMDS = MDString::get(Context, *ExceptStr);
1327
1328 return MetadataAsValue::get(Context, ExceptMDS);
1329 }
1330
1331 Value *getConstrainedFPPredicate(CmpInst::Predicate Predicate) {
1332 assert(CmpInst::isFPPredicate(Predicate) &&
1333 Predicate != CmpInst::FCMP_FALSE &&
1334 Predicate != CmpInst::FCMP_TRUE &&
1335 "Invalid constrained FP comparison predicate!");
1336
1337 StringRef PredicateStr = CmpInst::getPredicateName(Predicate);
1338 auto *PredicateMDS = MDString::get(Context, PredicateStr);
1339
1340 return MetadataAsValue::get(Context, PredicateMDS);
1341 }
1342
1343public:
1345 bool HasNUW = false, bool HasNSW = false) {
1346 if (Value *V =
1347 Folder.FoldNoWrapBinOp(Instruction::Add, LHS, RHS, HasNUW, HasNSW))
1348 return V;
1349 return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name, HasNUW,
1350 HasNSW);
1351 }
1352
1354 return CreateAdd(LHS, RHS, Name, false, true);
1355 }
1356
1358 return CreateAdd(LHS, RHS, Name, true, false);
1359 }
1360
1362 bool HasNUW = false, bool HasNSW = false) {
1363 if (Value *V =
1364 Folder.FoldNoWrapBinOp(Instruction::Sub, LHS, RHS, HasNUW, HasNSW))
1365 return V;
1366 return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name, HasNUW,
1367 HasNSW);
1368 }
1369
1371 return CreateSub(LHS, RHS, Name, false, true);
1372 }
1373
1375 return CreateSub(LHS, RHS, Name, true, false);
1376 }
1377
1379 bool HasNUW = false, bool HasNSW = false) {
1380 if (Value *V =
1381 Folder.FoldNoWrapBinOp(Instruction::Mul, LHS, RHS, HasNUW, HasNSW))
1382 return V;
1383 return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name, HasNUW,
1384 HasNSW);
1385 }
1386
1388 return CreateMul(LHS, RHS, Name, false, true);
1389 }
1390
1392 return CreateMul(LHS, RHS, Name, true, false);
1393 }
1394
1396 bool isExact = false) {
1397 if (Value *V = Folder.FoldExactBinOp(Instruction::UDiv, LHS, RHS, isExact))
1398 return V;
1399 if (!isExact)
1400 return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
1401 return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name);
1402 }
1403
1405 return CreateUDiv(LHS, RHS, Name, true);
1406 }
1407
1409 bool isExact = false) {
1410 if (Value *V = Folder.FoldExactBinOp(Instruction::SDiv, LHS, RHS, isExact))
1411 return V;
1412 if (!isExact)
1413 return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
1414 return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
1415 }
1416
1418 return CreateSDiv(LHS, RHS, Name, true);
1419 }
1420
1422 if (Value *V = Folder.FoldBinOp(Instruction::URem, LHS, RHS))
1423 return V;
1424 return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
1425 }
1426
1428 if (Value *V = Folder.FoldBinOp(Instruction::SRem, LHS, RHS))
1429 return V;
1430 return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
1431 }
1432
1434 bool HasNUW = false, bool HasNSW = false) {
1435 if (Value *V =
1436 Folder.FoldNoWrapBinOp(Instruction::Shl, LHS, RHS, HasNUW, HasNSW))
1437 return V;
1438 return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name,
1439 HasNUW, HasNSW);
1440 }
1441
1442 Value *CreateShl(Value *LHS, const APInt &RHS, const Twine &Name = "",
1443 bool HasNUW = false, bool HasNSW = false) {
1444 return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1445 HasNUW, HasNSW);
1446 }
1447
1449 bool HasNUW = false, bool HasNSW = false) {
1450 return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1451 HasNUW, HasNSW);
1452 }
1453
1455 bool isExact = false) {
1456 if (Value *V = Folder.FoldExactBinOp(Instruction::LShr, LHS, RHS, isExact))
1457 return V;
1458 if (!isExact)
1459 return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
1460 return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
1461 }
1462
1463 Value *CreateLShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
1464 bool isExact = false) {
1465 return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1466 }
1467
1469 bool isExact = false) {
1470 return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1471 }
1472
1474 bool isExact = false) {
1475 if (Value *V = Folder.FoldExactBinOp(Instruction::AShr, LHS, RHS, isExact))
1476 return V;
1477 if (!isExact)
1478 return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
1479 return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name);
1480 }
1481
1482 Value *CreateAShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
1483 bool isExact = false) {
1484 return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1485 }
1486
1488 bool isExact = false) {
1489 return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1490 }
1491
1493 if (auto *V = Folder.FoldBinOp(Instruction::And, LHS, RHS))
1494 return V;
1495 return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
1496 }
1497
1498 Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1499 return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1500 }
1501
1503 return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1504 }
1505
1507 assert(!Ops.empty());
1508 Value *Accum = Ops[0];
1509 for (unsigned i = 1; i < Ops.size(); i++)
1510 Accum = CreateAnd(Accum, Ops[i]);
1511 return Accum;
1512 }
1513
1515 if (auto *V = Folder.FoldBinOp(Instruction::Or, LHS, RHS))
1516 return V;
1517 return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
1518 }
1519
1520 Value *CreateOr(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1521 return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1522 }
1523
1525 return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1526 }
1527
1529 assert(!Ops.empty());
1530 Value *Accum = Ops[0];
1531 for (unsigned i = 1; i < Ops.size(); i++)
1532 Accum = CreateOr(Accum, Ops[i]);
1533 return Accum;
1534 }
1535
1537 if (Value *V = Folder.FoldBinOp(Instruction::Xor, LHS, RHS))
1538 return V;
1539 return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
1540 }
1541
1542 Value *CreateXor(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1543 return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1544 }
1545
1547 return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1548 }
1549
1550 Value *CreateFAdd(Value *L, Value *R, const Twine &Name = "",
1551 MDNode *FPMD = nullptr) {
1552 if (IsFPConstrained)
1553 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1554 L, R, nullptr, Name, FPMD);
1555
1556 if (Value *V = Folder.FoldBinOpFMF(Instruction::FAdd, L, R, FMF))
1557 return V;
1558 Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
1559 return Insert(I, Name);
1560 }
1561
1562 /// Copy fast-math-flags from an instruction rather than using the builder's
1563 /// default FMF.
1565 const Twine &Name = "") {
1566 if (IsFPConstrained)
1567 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1568 L, R, FMFSource, Name);
1569
1570 FastMathFlags FMF = FMFSource->getFastMathFlags();
1571 if (Value *V = Folder.FoldBinOpFMF(Instruction::FAdd, L, R, FMF))
1572 return V;
1573 Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), nullptr, FMF);
1574 return Insert(I, Name);
1575 }
1576
1577 Value *CreateFSub(Value *L, Value *R, const Twine &Name = "",
1578 MDNode *FPMD = nullptr) {
1579 if (IsFPConstrained)
1580 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1581 L, R, nullptr, Name, FPMD);
1582
1583 if (Value *V = Folder.FoldBinOpFMF(Instruction::FSub, L, R, FMF))
1584 return V;
1585 Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF);
1586 return Insert(I, Name);
1587 }
1588
1589 /// Copy fast-math-flags from an instruction rather than using the builder's
1590 /// default FMF.
1592 const Twine &Name = "") {
1593 if (IsFPConstrained)
1594 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1595 L, R, FMFSource, Name);
1596
1597 FastMathFlags FMF = FMFSource->getFastMathFlags();
1598 if (Value *V = Folder.FoldBinOpFMF(Instruction::FSub, L, R, FMF))
1599 return V;
1600 Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), nullptr, FMF);
1601 return Insert(I, Name);
1602 }
1603
1604 Value *CreateFMul(Value *L, Value *R, const Twine &Name = "",
1605 MDNode *FPMD = nullptr) {
1606 if (IsFPConstrained)
1607 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1608 L, R, nullptr, Name, FPMD);
1609
1610 if (Value *V = Folder.FoldBinOpFMF(Instruction::FMul, L, R, FMF))
1611 return V;
1612 Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF);
1613 return Insert(I, Name);
1614 }
1615
1616 /// Copy fast-math-flags from an instruction rather than using the builder's
1617 /// default FMF.
1619 const Twine &Name = "") {
1620 if (IsFPConstrained)
1621 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1622 L, R, FMFSource, Name);
1623
1624 FastMathFlags FMF = FMFSource->getFastMathFlags();
1625 if (Value *V = Folder.FoldBinOpFMF(Instruction::FMul, L, R, FMF))
1626 return V;
1627 Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), nullptr, FMF);
1628 return Insert(I, Name);
1629 }
1630
1631 Value *CreateFDiv(Value *L, Value *R, const Twine &Name = "",
1632 MDNode *FPMD = nullptr) {
1633 if (IsFPConstrained)
1634 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
1635 L, R, nullptr, Name, FPMD);
1636
1637 if (Value *V = Folder.FoldBinOpFMF(Instruction::FDiv, L, R, FMF))
1638 return V;
1639 Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF);
1640 return Insert(I, Name);
1641 }
1642
1643 /// Copy fast-math-flags from an instruction rather than using the builder's
1644 /// default FMF.
1646 const Twine &Name = "") {
1647 if (IsFPConstrained)
1648 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
1649 L, R, FMFSource, Name);
1650
1651 FastMathFlags FMF = FMFSource->getFastMathFlags();
1652 if (Value *V = Folder.FoldBinOpFMF(Instruction::FDiv, L, R, FMF))
1653 return V;
1654 Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), nullptr, FMF);
1655 return Insert(I, Name);
1656 }
1657
1658 Value *CreateFRem(Value *L, Value *R, const Twine &Name = "",
1659 MDNode *FPMD = nullptr) {
1660 if (IsFPConstrained)
1661 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
1662 L, R, nullptr, Name, FPMD);
1663
1664 if (Value *V = Folder.FoldBinOpFMF(Instruction::FRem, L, R, FMF)) return V;
1665 Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMF);
1666 return Insert(I, Name);
1667 }
1668
1669 /// Copy fast-math-flags from an instruction rather than using the builder's
1670 /// default FMF.
1672 const Twine &Name = "") {
1673 if (IsFPConstrained)
1674 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
1675 L, R, FMFSource, Name);
1676
1677 FastMathFlags FMF = FMFSource->getFastMathFlags();
1678 if (Value *V = Folder.FoldBinOpFMF(Instruction::FRem, L, R, FMF)) return V;
1679 Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), nullptr, FMF);
1680 return Insert(I, Name);
1681 }
1682
1684 Value *LHS, Value *RHS, const Twine &Name = "",
1685 MDNode *FPMathTag = nullptr) {
1686 if (Value *V = Folder.FoldBinOp(Opc, LHS, RHS)) return V;
1687 Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
1688 if (isa<FPMathOperator>(BinOp))
1689 setFPAttrs(BinOp, FPMathTag, FMF);
1690 return Insert(BinOp, Name);
1691 }
1692
1693 Value *CreateLogicalAnd(Value *Cond1, Value *Cond2, const Twine &Name = "") {
1694 assert(Cond2->getType()->isIntOrIntVectorTy(1));
1695 return CreateSelect(Cond1, Cond2,
1697 }
1698
1699 Value *CreateLogicalOr(Value *Cond1, Value *Cond2, const Twine &Name = "") {
1700 assert(Cond2->getType()->isIntOrIntVectorTy(1));
1701 return CreateSelect(Cond1, ConstantInt::getAllOnesValue(Cond2->getType()),
1702 Cond2, Name);
1703 }
1704
1706 const Twine &Name = "") {
1707 switch (Opc) {
1708 case Instruction::And:
1709 return CreateLogicalAnd(Cond1, Cond2, Name);
1710 case Instruction::Or:
1711 return CreateLogicalOr(Cond1, Cond2, Name);
1712 default:
1713 break;
1714 }
1715 llvm_unreachable("Not a logical operation.");
1716 }
1717
1718 // NOTE: this is sequential, non-commutative, ordered reduction!
1720 assert(!Ops.empty());
1721 Value *Accum = Ops[0];
1722 for (unsigned i = 1; i < Ops.size(); i++)
1723 Accum = CreateLogicalOr(Accum, Ops[i]);
1724 return Accum;
1725 }
1726
1728 Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource = nullptr,
1729 const Twine &Name = "", MDNode *FPMathTag = nullptr,
1730 std::optional<RoundingMode> Rounding = std::nullopt,
1731 std::optional<fp::ExceptionBehavior> Except = std::nullopt);
1732
1734 Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource = nullptr,
1735 const Twine &Name = "", MDNode *FPMathTag = nullptr,
1736 std::optional<fp::ExceptionBehavior> Except = std::nullopt);
1737
1738 Value *CreateNeg(Value *V, const Twine &Name = "", bool HasNSW = false) {
1739 return CreateSub(Constant::getNullValue(V->getType()), V, Name,
1740 /*HasNUW=*/0, HasNSW);
1741 }
1742
1743 Value *CreateNSWNeg(Value *V, const Twine &Name = "") {
1744 return CreateNeg(V, Name, /*HasNSW=*/true);
1745 }
1746
1747 Value *CreateFNeg(Value *V, const Twine &Name = "",
1748 MDNode *FPMathTag = nullptr) {
1749 if (Value *Res = Folder.FoldUnOpFMF(Instruction::FNeg, V, FMF))
1750 return Res;
1751 return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), FPMathTag, FMF),
1752 Name);
1753 }
1754
1755 /// Copy fast-math-flags from an instruction rather than using the builder's
1756 /// default FMF.
1758 const Twine &Name = "") {
1759 FastMathFlags FMF = FMFSource->getFastMathFlags();
1760 if (Value *Res = Folder.FoldUnOpFMF(Instruction::FNeg, V, FMF))
1761 return Res;
1762 return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), nullptr, FMF),
1763 Name);
1764 }
1765
1766 Value *CreateNot(Value *V, const Twine &Name = "") {
1767 return CreateXor(V, Constant::getAllOnesValue(V->getType()), Name);
1768 }
1769
1771 Value *V, const Twine &Name = "",
1772 MDNode *FPMathTag = nullptr) {
1773 if (Value *Res = Folder.FoldUnOpFMF(Opc, V, FMF))
1774 return Res;
1775 Instruction *UnOp = UnaryOperator::Create(Opc, V);
1776 if (isa<FPMathOperator>(UnOp))
1777 setFPAttrs(UnOp, FPMathTag, FMF);
1778 return Insert(UnOp, Name);
1779 }
1780
1781 /// Create either a UnaryOperator or BinaryOperator depending on \p Opc.
1782 /// Correct number of operands must be passed accordingly.
1783 Value *CreateNAryOp(unsigned Opc, ArrayRef<Value *> Ops,
1784 const Twine &Name = "", MDNode *FPMathTag = nullptr);
1785
1786 //===--------------------------------------------------------------------===//
1787 // Instruction creation methods: Memory Instructions
1788 //===--------------------------------------------------------------------===//
1789
1790 AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace,
1791 Value *ArraySize = nullptr, const Twine &Name = "") {
1792 const DataLayout &DL = BB->getDataLayout();
1793 Align AllocaAlign = DL.getPrefTypeAlign(Ty);
1794 return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name);
1795 }
1796
1797 AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = nullptr,
1798 const Twine &Name = "") {
1799 const DataLayout &DL = BB->getDataLayout();
1800 Align AllocaAlign = DL.getPrefTypeAlign(Ty);
1801 unsigned AddrSpace = DL.getAllocaAddrSpace();
1802 return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name);
1803 }
1804
1805 /// Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of
1806 /// converting the string to 'bool' for the isVolatile parameter.
1807 LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
1808 return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name);
1809 }
1810
1811 LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1812 return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name);
1813 }
1814
1815 LoadInst *CreateLoad(Type *Ty, Value *Ptr, bool isVolatile,
1816 const Twine &Name = "") {
1817 return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), isVolatile, Name);
1818 }
1819
1820 StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
1821 return CreateAlignedStore(Val, Ptr, MaybeAlign(), isVolatile);
1822 }
1823
1825 const char *Name) {
1826 return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
1827 }
1828
1830 const Twine &Name = "") {
1831 return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
1832 }
1833
1835 bool isVolatile, const Twine &Name = "") {
1836 if (!Align) {
1837 const DataLayout &DL = BB->getDataLayout();
1838 Align = DL.getABITypeAlign(Ty);
1839 }
1840 return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile, *Align), Name);
1841 }
1842
1844 bool isVolatile = false) {
1845 if (!Align) {
1846 const DataLayout &DL = BB->getDataLayout();
1847 Align = DL.getABITypeAlign(Val->getType());
1848 }
1849 return Insert(new StoreInst(Val, Ptr, isVolatile, *Align));
1850 }
1853 const Twine &Name = "") {
1854 return Insert(new FenceInst(Context, Ordering, SSID), Name);
1855 }
1856
1859 AtomicOrdering SuccessOrdering,
1860 AtomicOrdering FailureOrdering,
1862 if (!Align) {
1863 const DataLayout &DL = BB->getDataLayout();
1864 Align = llvm::Align(DL.getTypeStoreSize(New->getType()));
1865 }
1866
1867 return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, *Align, SuccessOrdering,
1868 FailureOrdering, SSID));
1869 }
1870
1872 Value *Val, MaybeAlign Align,
1873 AtomicOrdering Ordering,
1875 if (!Align) {
1876 const DataLayout &DL = BB->getDataLayout();
1877 Align = llvm::Align(DL.getTypeStoreSize(Val->getType()));
1878 }
1879
1880 return Insert(new AtomicRMWInst(Op, Ptr, Val, *Align, Ordering, SSID));
1881 }
1882
1884 const Twine &Name = "",
1886 if (auto *V = Folder.FoldGEP(Ty, Ptr, IdxList, NW))
1887 return V;
1888 return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList, NW), Name);
1889 }
1890
1892 const Twine &Name = "") {
1893 return CreateGEP(Ty, Ptr, IdxList, Name, GEPNoWrapFlags::inBounds());
1894 }
1895
1896 Value *CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1897 const Twine &Name = "") {
1898 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1899
1900 if (auto *V = Folder.FoldGEP(Ty, Ptr, Idx, GEPNoWrapFlags::none()))
1901 return V;
1902
1904 }
1905
1907 const Twine &Name = "") {
1908 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1909
1910 if (auto *V = Folder.FoldGEP(Ty, Ptr, Idx, GEPNoWrapFlags::inBounds()))
1911 return V;
1912
1914 }
1915
1916 Value *CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1,
1917 const Twine &Name = "",
1919 Value *Idxs[] = {
1920 ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1921 ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1922 };
1923
1924 if (auto *V = Folder.FoldGEP(Ty, Ptr, Idxs, NWFlags))
1925 return V;
1926
1927 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs, NWFlags), Name);
1928 }
1929
1931 unsigned Idx1, const Twine &Name = "") {
1932 Value *Idxs[] = {
1933 ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1934 ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1935 };
1936
1937 if (auto *V = Folder.FoldGEP(Ty, Ptr, Idxs, GEPNoWrapFlags::inBounds()))
1938 return V;
1939
1941 }
1942
1944 const Twine &Name = "") {
1945 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1946
1947 if (auto *V = Folder.FoldGEP(Ty, Ptr, Idx, GEPNoWrapFlags::none()))
1948 return V;
1949
1951 }
1952
1954 const Twine &Name = "") {
1955 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1956
1957 if (auto *V = Folder.FoldGEP(Ty, Ptr, Idx, GEPNoWrapFlags::inBounds()))
1958 return V;
1959
1961 }
1962
1964 const Twine &Name = "") {
1965 Value *Idxs[] = {
1966 ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1967 ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1968 };
1969
1970 if (auto *V = Folder.FoldGEP(Ty, Ptr, Idxs, GEPNoWrapFlags::none()))
1971 return V;
1972
1973 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1974 }
1975
1977 uint64_t Idx1, const Twine &Name = "") {
1978 Value *Idxs[] = {
1979 ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1980 ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1981 };
1982
1983 if (auto *V = Folder.FoldGEP(Ty, Ptr, Idxs, GEPNoWrapFlags::inBounds()))
1984 return V;
1985
1987 }
1988
1990 const Twine &Name = "") {
1991 GEPNoWrapFlags NWFlags =
1993 return CreateConstGEP2_32(Ty, Ptr, 0, Idx, Name, NWFlags);
1994 }
1995
1998 return CreateGEP(getInt8Ty(), Ptr, Offset, Name, NW);
1999 }
2000
2002 const Twine &Name = "") {
2003 return CreateGEP(getInt8Ty(), Ptr, Offset, Name,
2005 }
2006
2007 /// Same as CreateGlobalString, but return a pointer with "i8*" type
2008 /// instead of a pointer to array of i8.
2009 ///
2010 /// If no module is given via \p M, it is take from the insertion point basic
2011 /// block.
2013 unsigned AddressSpace = 0,
2014 Module *M = nullptr, bool AddNull = true) {
2015 GlobalVariable *GV =
2016 CreateGlobalString(Str, Name, AddressSpace, M, AddNull);
2017 Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
2018 Constant *Indices[] = {Zero, Zero};
2020 Indices);
2021 }
2022
2023 //===--------------------------------------------------------------------===//
2024 // Instruction creation methods: Cast/Conversion Operators
2025 //===--------------------------------------------------------------------===//
2026
2027 Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "",
2028 bool IsNUW = false, bool IsNSW = false) {
2029 if (V->getType() == DestTy)
2030 return V;
2031 if (Value *Folded = Folder.FoldCast(Instruction::Trunc, V, DestTy))
2032 return Folded;
2033 Instruction *I = CastInst::Create(Instruction::Trunc, V, DestTy);
2034 if (IsNUW)
2035 I->setHasNoUnsignedWrap();
2036 if (IsNSW)
2037 I->setHasNoSignedWrap();
2038 return Insert(I, Name);
2039 }
2040
2041 Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "",
2042 bool IsNonNeg = false) {
2043 if (V->getType() == DestTy)
2044 return V;
2045 if (Value *Folded = Folder.FoldCast(Instruction::ZExt, V, DestTy))
2046 return Folded;
2047 Instruction *I = Insert(new ZExtInst(V, DestTy), Name);
2048 if (IsNonNeg)
2049 I->setNonNeg();
2050 return I;
2051 }
2052
2053 Value *CreateSExt(Value *V, Type *DestTy, const Twine &Name = "") {
2054 return CreateCast(Instruction::SExt, V, DestTy, Name);
2055 }
2056
2057 /// Create a ZExt or Trunc from the integer value V to DestTy. Return
2058 /// the value untouched if the type of V is already DestTy.
2060 const Twine &Name = "") {
2061 assert(V->getType()->isIntOrIntVectorTy() &&
2062 DestTy->isIntOrIntVectorTy() &&
2063 "Can only zero extend/truncate integers!");
2064 Type *VTy = V->getType();
2065 if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
2066 return CreateZExt(V, DestTy, Name);
2067 if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
2068 return CreateTrunc(V, DestTy, Name);
2069 return V;
2070 }
2071
2072 /// Create a SExt or Trunc from the integer value V to DestTy. Return
2073 /// the value untouched if the type of V is already DestTy.
2075 const Twine &Name = "") {
2076 assert(V->getType()->isIntOrIntVectorTy() &&
2077 DestTy->isIntOrIntVectorTy() &&
2078 "Can only sign extend/truncate integers!");
2079 Type *VTy = V->getType();
2080 if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
2081 return CreateSExt(V, DestTy, Name);
2082 if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
2083 return CreateTrunc(V, DestTy, Name);
2084 return V;
2085 }
2086
2087 Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = "") {
2088 if (IsFPConstrained)
2089 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptoui,
2090 V, DestTy, nullptr, Name);
2091 return CreateCast(Instruction::FPToUI, V, DestTy, Name);
2092 }
2093
2094 Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = "") {
2095 if (IsFPConstrained)
2096 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptosi,
2097 V, DestTy, nullptr, Name);
2098 return CreateCast(Instruction::FPToSI, V, DestTy, Name);
2099 }
2100
2101 Value *CreateUIToFP(Value *V, Type *DestTy, const Twine &Name = "",
2102 bool IsNonNeg = false) {
2103 if (IsFPConstrained)
2104 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_uitofp,
2105 V, DestTy, nullptr, Name);
2106 if (Value *Folded = Folder.FoldCast(Instruction::UIToFP, V, DestTy))
2107 return Folded;
2108 Instruction *I = Insert(new UIToFPInst(V, DestTy), Name);
2109 if (IsNonNeg)
2110 I->setNonNeg();
2111 return I;
2112 }
2113
2114 Value *CreateSIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
2115 if (IsFPConstrained)
2116 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_sitofp,
2117 V, DestTy, nullptr, Name);
2118 return CreateCast(Instruction::SIToFP, V, DestTy, Name);
2119 }
2120
2122 const Twine &Name = "") {
2123 if (IsFPConstrained)
2125 Intrinsic::experimental_constrained_fptrunc, V, DestTy, nullptr,
2126 Name);
2127 return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
2128 }
2129
2130 Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "") {
2131 if (IsFPConstrained)
2132 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fpext,
2133 V, DestTy, nullptr, Name);
2134 return CreateCast(Instruction::FPExt, V, DestTy, Name);
2135 }
2136
2138 const Twine &Name = "") {
2139 return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
2140 }
2141
2143 const Twine &Name = "") {
2144 return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
2145 }
2146
2148 const Twine &Name = "") {
2149 return CreateCast(Instruction::BitCast, V, DestTy, Name);
2150 }
2151
2153 const Twine &Name = "") {
2154 return CreateCast(Instruction::AddrSpaceCast, V, DestTy, Name);
2155 }
2156
2157 Value *CreateZExtOrBitCast(Value *V, Type *DestTy, const Twine &Name = "") {
2158 Instruction::CastOps CastOp =
2159 V->getType()->getScalarSizeInBits() == DestTy->getScalarSizeInBits()
2160 ? Instruction::BitCast
2161 : Instruction::ZExt;
2162 return CreateCast(CastOp, V, DestTy, Name);
2163 }
2164
2165 Value *CreateSExtOrBitCast(Value *V, Type *DestTy, const Twine &Name = "") {
2166 Instruction::CastOps CastOp =
2167 V->getType()->getScalarSizeInBits() == DestTy->getScalarSizeInBits()
2168 ? Instruction::BitCast
2169 : Instruction::SExt;
2170 return CreateCast(CastOp, V, DestTy, Name);
2171 }
2172
2173 Value *CreateTruncOrBitCast(Value *V, Type *DestTy, const Twine &Name = "") {
2174 Instruction::CastOps CastOp =
2175 V->getType()->getScalarSizeInBits() == DestTy->getScalarSizeInBits()
2176 ? Instruction::BitCast
2177 : Instruction::Trunc;
2178 return CreateCast(CastOp, V, DestTy, Name);
2179 }
2180
2182 const Twine &Name = "") {
2183 if (V->getType() == DestTy)
2184 return V;
2185 if (Value *Folded = Folder.FoldCast(Op, V, DestTy))
2186 return Folded;
2187 return Insert(CastInst::Create(Op, V, DestTy), Name);
2188 }
2189
2191 const Twine &Name = "") {
2192 if (V->getType() == DestTy)
2193 return V;
2194 if (auto *VC = dyn_cast<Constant>(V))
2195 return Insert(Folder.CreatePointerCast(VC, DestTy), Name);
2196 return Insert(CastInst::CreatePointerCast(V, DestTy), Name);
2197 }
2198
2199 // With opaque pointers enabled, this can be substituted with
2200 // CreateAddrSpaceCast.
2201 // TODO: Replace uses of this method and remove the method itself.
2203 const Twine &Name = "") {
2204 if (V->getType() == DestTy)
2205 return V;
2206
2207 if (auto *VC = dyn_cast<Constant>(V)) {
2209 Name);
2210 }
2211
2213 Name);
2214 }
2215
2217 const Twine &Name = "") {
2218 Instruction::CastOps CastOp =
2219 V->getType()->getScalarSizeInBits() > DestTy->getScalarSizeInBits()
2220 ? Instruction::Trunc
2221 : (isSigned ? Instruction::SExt : Instruction::ZExt);
2222 return CreateCast(CastOp, V, DestTy, Name);
2223 }
2224
2226 const Twine &Name = "") {
2227 if (V->getType() == DestTy)
2228 return V;
2229 if (V->getType()->isPtrOrPtrVectorTy() && DestTy->isIntOrIntVectorTy())
2230 return CreatePtrToInt(V, DestTy, Name);
2231 if (V->getType()->isIntOrIntVectorTy() && DestTy->isPtrOrPtrVectorTy())
2232 return CreateIntToPtr(V, DestTy, Name);
2233
2234 return CreateBitCast(V, DestTy, Name);
2235 }
2236
2237 Value *CreateFPCast(Value *V, Type *DestTy, const Twine &Name = "") {
2238 Instruction::CastOps CastOp =
2239 V->getType()->getScalarSizeInBits() > DestTy->getScalarSizeInBits()
2240 ? Instruction::FPTrunc
2241 : Instruction::FPExt;
2242 return CreateCast(CastOp, V, DestTy, Name);
2243 }
2244
2246 Intrinsic::ID ID, Value *V, Type *DestTy,
2247 Instruction *FMFSource = nullptr, const Twine &Name = "",
2248 MDNode *FPMathTag = nullptr,
2249 std::optional<RoundingMode> Rounding = std::nullopt,
2250 std::optional<fp::ExceptionBehavior> Except = std::nullopt);
2251
2252 // Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a
2253 // compile time error, instead of converting the string to bool for the
2254 // isSigned parameter.
2255 Value *CreateIntCast(Value *, Type *, const char *) = delete;
2256
2257 //===--------------------------------------------------------------------===//
2258 // Instruction creation methods: Compare Instructions
2259 //===--------------------------------------------------------------------===//
2260
2263 }
2264
2267 }
2268
2271 }
2272
2275 }
2276
2279 }
2280
2283 }
2284
2287 }
2288
2291 }
2292
2295 }
2296
2299 }
2300
2302 MDNode *FPMathTag = nullptr) {
2303 return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name, FPMathTag);
2304 }
2305
2307 MDNode *FPMathTag = nullptr) {
2308 return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name, FPMathTag);
2309 }
2310
2312 MDNode *FPMathTag = nullptr) {
2313 return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name, FPMathTag);
2314 }
2315
2317 MDNode *FPMathTag = nullptr) {
2318 return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name, FPMathTag);
2319 }
2320
2322 MDNode *FPMathTag = nullptr) {
2323 return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name, FPMathTag);
2324 }
2325
2327 MDNode *FPMathTag = nullptr) {
2328 return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name, FPMathTag);
2329 }
2330
2332 MDNode *FPMathTag = nullptr) {
2333 return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name, FPMathTag);
2334 }
2335
2337 MDNode *FPMathTag = nullptr) {
2338 return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name, FPMathTag);
2339 }
2340
2342 MDNode *FPMathTag = nullptr) {
2343 return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name, FPMathTag);
2344 }
2345
2347 MDNode *FPMathTag = nullptr) {
2348 return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name, FPMathTag);
2349 }
2350
2352 MDNode *FPMathTag = nullptr) {
2353 return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name, FPMathTag);
2354 }
2355
2357 MDNode *FPMathTag = nullptr) {
2358 return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name, FPMathTag);
2359 }
2360
2362 MDNode *FPMathTag = nullptr) {
2363 return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name, FPMathTag);
2364 }
2365
2367 MDNode *FPMathTag = nullptr) {
2368 return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name, FPMathTag);
2369 }
2370
2372 const Twine &Name = "") {
2373 if (auto *V = Folder.FoldCmp(P, LHS, RHS))
2374 return V;
2375 return Insert(new ICmpInst(P, LHS, RHS), Name);
2376 }
2377
2378 // Create a quiet floating-point comparison (i.e. one that raises an FP
2379 // exception only in the case where an input is a signaling NaN).
2380 // Note that this differs from CreateFCmpS only if IsFPConstrained is true.
2382 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2383 return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, false);
2384 }
2385
2387 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2388 return CmpInst::isFPPredicate(Pred)
2389 ? CreateFCmp(Pred, LHS, RHS, Name, FPMathTag)
2390 : CreateICmp(Pred, LHS, RHS, Name);
2391 }
2392
2393 // Create a signaling floating-point comparison (i.e. one that raises an FP
2394 // exception whenever an input is any NaN, signaling or quiet).
2395 // Note that this differs from CreateFCmp only if IsFPConstrained is true.
2397 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2398 return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, true);
2399 }
2400
2401private:
2402 // Helper routine to create either a signaling or a quiet FP comparison.
2403 Value *CreateFCmpHelper(CmpInst::Predicate P, Value *LHS, Value *RHS,
2404 const Twine &Name, MDNode *FPMathTag,
2405 bool IsSignaling);
2406
2407public:
2410 const Twine &Name = "",
2411 std::optional<fp::ExceptionBehavior> Except = std::nullopt);
2412
2413 //===--------------------------------------------------------------------===//
2414 // Instruction creation methods: Other Instructions
2415 //===--------------------------------------------------------------------===//
2416
2417 PHINode *CreatePHI(Type *Ty, unsigned NumReservedValues,
2418 const Twine &Name = "") {
2419 PHINode *Phi = PHINode::Create(Ty, NumReservedValues);
2420 if (isa<FPMathOperator>(Phi))
2421 setFPAttrs(Phi, nullptr /* MDNode* */, FMF);
2422 return Insert(Phi, Name);
2423 }
2424
2425private:
2426 CallInst *createCallHelper(Function *Callee, ArrayRef<Value *> Ops,
2427 const Twine &Name = "",
2428 Instruction *FMFSource = nullptr,
2429 ArrayRef<OperandBundleDef> OpBundles = {});
2430
2431public:
2433 ArrayRef<Value *> Args = std::nullopt,
2434 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2435 CallInst *CI = CallInst::Create(FTy, Callee, Args, DefaultOperandBundles);
2436 if (IsFPConstrained)
2438 if (isa<FPMathOperator>(CI))
2439 setFPAttrs(CI, FPMathTag, FMF);
2440 return Insert(CI, Name);
2441 }
2442
2445 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2446 CallInst *CI = CallInst::Create(FTy, Callee, Args, OpBundles);
2447 if (IsFPConstrained)
2449 if (isa<FPMathOperator>(CI))
2450 setFPAttrs(CI, FPMathTag, FMF);
2451 return Insert(CI, Name);
2452 }
2453
2455 ArrayRef<Value *> Args = std::nullopt,
2456 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2457 return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args, Name,
2458 FPMathTag);
2459 }
2460
2463 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2464 return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args,
2465 OpBundles, Name, FPMathTag);
2466 }
2467
2469 Function *Callee, ArrayRef<Value *> Args, const Twine &Name = "",
2470 std::optional<RoundingMode> Rounding = std::nullopt,
2471 std::optional<fp::ExceptionBehavior> Except = std::nullopt);
2472
2473 Value *CreateSelect(Value *C, Value *True, Value *False,
2474 const Twine &Name = "", Instruction *MDFrom = nullptr);
2475
2477 return Insert(new VAArgInst(List, Ty), Name);
2478 }
2479
2481 const Twine &Name = "") {
2482 if (Value *V = Folder.FoldExtractElement(Vec, Idx))
2483 return V;
2485 }
2486
2488 const Twine &Name = "") {
2489 return CreateExtractElement(Vec, getInt64(Idx), Name);
2490 }
2491
2493 const Twine &Name = "") {
2494 return CreateInsertElement(PoisonValue::get(VecTy), NewElt, Idx, Name);
2495 }
2496
2498 const Twine &Name = "") {
2499 return CreateInsertElement(PoisonValue::get(VecTy), NewElt, Idx, Name);
2500 }
2501
2503 const Twine &Name = "") {
2504 if (Value *V = Folder.FoldInsertElement(Vec, NewElt, Idx))
2505 return V;
2506 return Insert(InsertElementInst::Create(Vec, NewElt, Idx), Name);
2507 }
2508
2510 const Twine &Name = "") {
2511 return CreateInsertElement(Vec, NewElt, getInt64(Idx), Name);
2512 }
2513
2515 const Twine &Name = "") {
2516 SmallVector<int, 16> IntMask;
2517 ShuffleVectorInst::getShuffleMask(cast<Constant>(Mask), IntMask);
2518 return CreateShuffleVector(V1, V2, IntMask, Name);
2519 }
2520
2521 /// See class ShuffleVectorInst for a description of the mask representation.
2523 const Twine &Name = "") {
2524 if (Value *V = Folder.FoldShuffleVector(V1, V2, Mask))
2525 return V;
2526 return Insert(new ShuffleVectorInst(V1, V2, Mask), Name);
2527 }
2528
2529 /// Create a unary shuffle. The second vector operand of the IR instruction
2530 /// is poison.
2532 const Twine &Name = "") {
2533 return CreateShuffleVector(V, PoisonValue::get(V->getType()), Mask, Name);
2534 }
2535
2537 const Twine &Name = "") {
2538 if (auto *V = Folder.FoldExtractValue(Agg, Idxs))
2539 return V;
2540 return Insert(ExtractValueInst::Create(Agg, Idxs), Name);
2541 }
2542
2544 const Twine &Name = "") {
2545 if (auto *V = Folder.FoldInsertValue(Agg, Val, Idxs))
2546 return V;
2547 return Insert(InsertValueInst::Create(Agg, Val, Idxs), Name);
2548 }
2549
2550 LandingPadInst *CreateLandingPad(Type *Ty, unsigned NumClauses,
2551 const Twine &Name = "") {
2552 return Insert(LandingPadInst::Create(Ty, NumClauses), Name);
2553 }
2554
2555 Value *CreateFreeze(Value *V, const Twine &Name = "") {
2556 return Insert(new FreezeInst(V), Name);
2557 }
2558
2559 //===--------------------------------------------------------------------===//
2560 // Utility creation methods
2561 //===--------------------------------------------------------------------===//
2562
2563 /// Return a boolean value testing if \p Arg == 0.
2564 Value *CreateIsNull(Value *Arg, const Twine &Name = "") {
2565 return CreateICmpEQ(Arg, Constant::getNullValue(Arg->getType()), Name);
2566 }
2567
2568 /// Return a boolean value testing if \p Arg != 0.
2569 Value *CreateIsNotNull(Value *Arg, const Twine &Name = "") {
2570 return CreateICmpNE(Arg, Constant::getNullValue(Arg->getType()), Name);
2571 }
2572
2573 /// Return a boolean value testing if \p Arg < 0.
2574 Value *CreateIsNeg(Value *Arg, const Twine &Name = "") {
2576 }
2577
2578 /// Return a boolean value testing if \p Arg > -1.
2579 Value *CreateIsNotNeg(Value *Arg, const Twine &Name = "") {
2581 Name);
2582 }
2583
2584 /// Return the i64 difference between two pointer values, dividing out
2585 /// the size of the pointed-to objects.
2586 ///
2587 /// This is intended to implement C-style pointer subtraction. As such, the
2588 /// pointers must be appropriately aligned for their element types and
2589 /// pointing into the same object.
2590 Value *CreatePtrDiff(Type *ElemTy, Value *LHS, Value *RHS,
2591 const Twine &Name = "");
2592
2593 /// Create a launder.invariant.group intrinsic call. If Ptr type is
2594 /// different from pointer to i8, it's casted to pointer to i8 in the same
2595 /// address space before call and casted back to Ptr type after call.
2597
2598 /// \brief Create a strip.invariant.group intrinsic call. If Ptr type is
2599 /// different from pointer to i8, it's casted to pointer to i8 in the same
2600 /// address space before call and casted back to Ptr type after call.
2602
2603 /// Return a vector value that contains the vector V reversed
2604 Value *CreateVectorReverse(Value *V, const Twine &Name = "");
2605
2606 /// Return a vector splice intrinsic if using scalable vectors, otherwise
2607 /// return a shufflevector. If the immediate is positive, a vector is
2608 /// extracted from concat(V1, V2), starting at Imm. If the immediate
2609 /// is negative, we extract -Imm elements from V1 and the remaining
2610 /// elements from V2. Imm is a signed integer in the range
2611 /// -VL <= Imm < VL (where VL is the runtime vector length of the
2612 /// source/result vector)
2613 Value *CreateVectorSplice(Value *V1, Value *V2, int64_t Imm,
2614 const Twine &Name = "");
2615
2616 /// Return a vector value that contains \arg V broadcasted to \p
2617 /// NumElts elements.
2618 Value *CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name = "");
2619
2620 /// Return a vector value that contains \arg V broadcasted to \p
2621 /// EC elements.
2622 Value *CreateVectorSplat(ElementCount EC, Value *V, const Twine &Name = "");
2623
2625 unsigned Dimension, unsigned LastIndex,
2626 MDNode *DbgInfo);
2627
2628 Value *CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex,
2629 MDNode *DbgInfo);
2630
2632 unsigned Index, unsigned FieldIndex,
2633 MDNode *DbgInfo);
2634
2635 Value *createIsFPClass(Value *FPNum, unsigned Test);
2636
2637private:
2638 /// Helper function that creates an assume intrinsic call that
2639 /// represents an alignment assumption on the provided pointer \p PtrValue
2640 /// with offset \p OffsetValue and alignment value \p AlignValue.
2641 CallInst *CreateAlignmentAssumptionHelper(const DataLayout &DL,
2642 Value *PtrValue, Value *AlignValue,
2643 Value *OffsetValue);
2644
2645public:
2646 /// Create an assume intrinsic call that represents an alignment
2647 /// assumption on the provided pointer.
2648 ///
2649 /// An optional offset can be provided, and if it is provided, the offset
2650 /// must be subtracted from the provided pointer to get the pointer with the
2651 /// specified alignment.
2653 unsigned Alignment,
2654 Value *OffsetValue = nullptr);
2655
2656 /// Create an assume intrinsic call that represents an alignment
2657 /// assumption on the provided pointer.
2658 ///
2659 /// An optional offset can be provided, and if it is provided, the offset
2660 /// must be subtracted from the provided pointer to get the pointer with the
2661 /// specified alignment.
2662 ///
2663 /// This overload handles the condition where the Alignment is dependent
2664 /// on an existing value rather than a static value.
2666 Value *Alignment,
2667 Value *OffsetValue = nullptr);
2668};
2669
2670/// This provides a uniform API for creating instructions and inserting
2671/// them into a basic block: either at the end of a BasicBlock, or at a specific
2672/// iterator location in a block.
2673///
2674/// Note that the builder does not expose the full generality of LLVM
2675/// instructions. For access to extra instruction properties, use the mutators
2676/// (e.g. setVolatile) on the instructions after they have been
2677/// created. Convenience state exists to specify fast-math flags and fp-math
2678/// tags.
2679///
2680/// The first template argument specifies a class to use for creating constants.
2681/// This defaults to creating minimally folded constants. The second template
2682/// argument allows clients to specify custom insertion hooks that are called on
2683/// every newly created insertion.
2684template <typename FolderTy = ConstantFolder,
2685 typename InserterTy = IRBuilderDefaultInserter>
2686class IRBuilder : public IRBuilderBase {
2687private:
2688 FolderTy Folder;
2689 InserterTy Inserter;
2690
2691public:
2692 IRBuilder(LLVMContext &C, FolderTy Folder, InserterTy Inserter = InserterTy(),
2693 MDNode *FPMathTag = nullptr,
2694 ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2695 : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles),
2696 Folder(Folder), Inserter(Inserter) {}
2697
2698 explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
2699 ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2700 : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles) {}
2701
2702 explicit IRBuilder(BasicBlock *TheBB, FolderTy Folder,
2703 MDNode *FPMathTag = nullptr,
2704 ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2705 : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
2706 FPMathTag, OpBundles),
2707 Folder(Folder) {
2708 SetInsertPoint(TheBB);
2709 }
2710
2711 explicit IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag = nullptr,
2712 ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2713 : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
2714 FPMathTag, OpBundles) {
2715 SetInsertPoint(TheBB);
2716 }
2717
2718 explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr,
2719 ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2720 : IRBuilderBase(IP->getContext(), this->Folder, this->Inserter, FPMathTag,
2721 OpBundles) {
2722 SetInsertPoint(IP);
2723 }
2724
2725 IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, FolderTy Folder,
2726 MDNode *FPMathTag = nullptr,
2727 ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2728 : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
2729 FPMathTag, OpBundles),
2730 Folder(Folder) {
2731 SetInsertPoint(TheBB, IP);
2732 }
2733
2735 MDNode *FPMathTag = nullptr,
2736 ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2737 : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
2738 FPMathTag, OpBundles) {
2739 SetInsertPoint(TheBB, IP);
2740 }
2741
2742 /// Avoid copying the full IRBuilder. Prefer using InsertPointGuard
2743 /// or FastMathFlagGuard instead.
2744 IRBuilder(const IRBuilder &) = delete;
2745
2746 InserterTy &getInserter() { return Inserter; }
2747 const InserterTy &getInserter() const { return Inserter; }
2748};
2749
2750template <typename FolderTy, typename InserterTy>
2751IRBuilder(LLVMContext &, FolderTy, InserterTy, MDNode *,
2754template <typename FolderTy>
2759template <typename FolderTy>
2764
2765
2766// Create wrappers for C Binding types (see CBindingWrapping.h).
2768
2769} // end namespace llvm
2770
2771#endif // LLVM_IR_IRBUILDER_H
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Atomic ordering constants.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
#define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
return RetTy
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
uint64_t Addr
std::string Name
uint64_t Size
static bool isSigned(unsigned int Opcode)
This file contains the declarations of entities that describe floating point environment and related ...
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
uint64_t IntrinsicInst * II
#define P(N)
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file contains some templates that are useful if you are working with the STL at all.
Value * RHS
Value * LHS
Class for arbitrary precision integers.
Definition: APInt.h:78
an instruction to allocate memory on the stack
Definition: Instructions.h:61
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
Value handle that asserts if the Value is deleted.
Definition: ValueHandle.h:264
An instruction that atomically checks whether a specified value is in a memory location,...
Definition: Instructions.h:495
an instruction that atomically reads a memory location, combines it with another value,...
Definition: Instructions.h:696
BinOp
This enumeration lists the possible modifications atomicrmw can make.
Definition: Instructions.h:708
LLVM Basic Block Representation.
Definition: BasicBlock.h:61
iterator end()
Definition: BasicBlock.h:461
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:219
const DataLayout & getDataLayout() const
Get the data layout of the module this basic block belongs to.
Definition: BasicBlock.cpp:296
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:177
const_iterator getFirstNonPHIOrDbgOrAlloca() const
Returns an iterator to the first instruction in this block that is not a PHINode, a debug intrinsic,...
Definition: BasicBlock.cpp:430
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), InsertPosition InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
Conditional or Unconditional Branch instruction.
static BranchInst * Create(BasicBlock *IfTrue, InsertPosition InsertBefore=nullptr)
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1236
CallBr instruction, tracking function calls that may not return control but instead transfer it to a ...
static CallBrInst * Create(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)
This class represents a function call, abstracting a target machine's calling convention.
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static CastInst * CreatePointerBitCastOrAddrSpaceCast(Value *S, Type *Ty, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Create a BitCast or an AddrSpaceCast cast instruction.
static CastInst * CreatePointerCast(Value *S, Type *Ty, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Create a BitCast, AddrSpaceCast or a PtrToInt cast instruction.
static CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", InsertPosition InsertBefore=nullptr)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
static CatchPadInst * Create(Value *CatchSwitch, ArrayRef< Value * > Args, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static CatchReturnInst * Create(Value *CatchPad, BasicBlock *BB, InsertPosition InsertBefore=nullptr)
static CatchSwitchInst * Create(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumHandlers, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static CleanupPadInst * Create(Value *ParentPad, ArrayRef< Value * > Args=std::nullopt, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static CleanupReturnInst * Create(Value *CleanupPad, BasicBlock *UnwindBB=nullptr, InsertPosition InsertBefore=nullptr)
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:757
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:760
@ FCMP_TRUE
1 1 1 1 Always true (always folded)
Definition: InstrTypes.h:774
@ ICMP_SLT
signed less than
Definition: InstrTypes.h:786
@ ICMP_SLE
signed less or equal
Definition: InstrTypes.h:787
@ FCMP_OLT
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:763
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:772
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:761
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:762
@ ICMP_UGE
unsigned greater or equal
Definition: InstrTypes.h:781
@ ICMP_UGT
unsigned greater than
Definition: InstrTypes.h:780
@ ICMP_SGT
signed greater than
Definition: InstrTypes.h:784
@ FCMP_ULT
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:771
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:765
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:768
@ ICMP_ULT
unsigned less than
Definition: InstrTypes.h:782
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:769
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:764
@ FCMP_ORD
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:766
@ ICMP_EQ
equal
Definition: InstrTypes.h:778
@ ICMP_NE
not equal
Definition: InstrTypes.h:779
@ ICMP_SGE
signed greater or equal
Definition: InstrTypes.h:785
@ FCMP_UNE
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:773
@ ICMP_ULE
unsigned less or equal
Definition: InstrTypes.h:783
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:770
@ FCMP_FALSE
0 0 0 0 Always false (always folded)
Definition: InstrTypes.h:759
@ FCMP_UNO
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:767
bool isFPPredicate() const
Definition: InstrTypes.h:864
static StringRef getPredicateName(Predicate P)
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList)
Create an "inbounds" getelementptr.
Definition: Constants.h:1280
This is the shared class of boolean and integer constants.
Definition: Constants.h:81
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:850
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:857
This is an important base class in LLVM.
Definition: Constant.h:42
static Constant * getAllOnesValue(Type *Ty)
Definition: Constants.cpp:417
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:370
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:63
A debug info location.
Definition: DebugLoc.h:33
static ExtractElementInst * Create(Value *Vec, Value *Idx, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static ExtractValueInst * Create(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Convenience struct for specifying and reasoning about fast-math flags.
Definition: FMF.h:20
void clear()
Definition: FMF.h:61
An instruction for ordering other memory operations.
Definition: Instructions.h:420
This class represents a freeze function that returns random concrete value if an operand is either a ...
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Definition: DerivedTypes.h:168
Class to represent function types.
Definition: DerivedTypes.h:103
Represents flags for the getelementptr instruction/expression.
static GEPNoWrapFlags inBounds()
static GEPNoWrapFlags noUnsignedWrap()
static GEPNoWrapFlags none()
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Definition: Instructions.h:938
static GetElementPtrInst * CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Create an "inbounds" getelementptr.
Definition: Instructions.h:961
Type * getValueType() const
Definition: GlobalValue.h:296
This instruction compares its operands according to the predicate given to the constructor.
FastMathFlagGuard(const FastMathFlagGuard &)=delete
FastMathFlagGuard & operator=(const FastMathFlagGuard &)=delete
InsertPointGuard & operator=(const InsertPointGuard &)=delete
InsertPointGuard(const InsertPointGuard &)=delete
InsertPoint - A saved insertion point.
Definition: IRBuilder.h:254
InsertPoint(BasicBlock *InsertBlock, BasicBlock::iterator InsertPoint)
Creates a new insertion point at the given location.
Definition: IRBuilder.h:263
BasicBlock * getBlock() const
Definition: IRBuilder.h:269
InsertPoint()=default
Creates a new insertion point which doesn't point to anything.
bool isSet() const
Returns true if this insert point is set.
Definition: IRBuilder.h:267
BasicBlock::iterator getPoint() const
Definition: IRBuilder.h:270
OperandBundlesGuard(const OperandBundlesGuard &)=delete
OperandBundlesGuard & operator=(const OperandBundlesGuard &)=delete
Common base class shared among various IRBuilders.
Definition: IRBuilder.h:91
Value * CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1417
Value * CreateZExtOrBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2157
CallInst * CreateElementUnorderedAtomicMemCpy(Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size, uint32_t ElementSize, MDNode *TBAATag=nullptr, MDNode *TBAAStructTag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Create and insert an element unordered-atomic memcpy between the specified pointers.
Definition: IRBuilder.cpp:257
Value * CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2326
Value * CreateFAddFMF(Value *L, Value *R, Instruction *FMFSource, const Twine &Name="")
Copy fast-math-flags from an instruction rather than using the builder's default FMF.
Definition: IRBuilder.h:1564
ConstantInt * getInt1(bool V)
Get a constant value representing either true or false.
Definition: IRBuilder.h:458
Value * CreateFCmpS(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2396
CallInst * CreateMaskedCompressStore(Value *Val, Value *Ptr, Value *Mask=nullptr)
Create a call to Masked Compress Store intrinsic.
Definition: IRBuilder.cpp:705
InvokeInst * CreateInvoke(FunctionType *Ty, Value *Callee, BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="")
Definition: IRBuilder.h:1186
BasicBlock * BB
Definition: IRBuilder.h:116
Value * CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1391
CallInst * CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with 1 operand which is mangled on its type.
Definition: IRBuilder.cpp:914
Value * CreatePtrDiff(Type *ElemTy, Value *LHS, Value *RHS, const Twine &Name="")
Return the i64 difference between two pointer values, dividing out the size of the pointed-to objects...
Definition: IRBuilder.cpp:1107
CallInst * CreateMulReduce(Value *Src)
Create a vector int mul reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:438
CallInst * CreateFAddReduce(Value *Acc, Value *Src)
Create a sequential vector fadd reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:418
CallInst * CreateMaskedExpandLoad(Type *Ty, Value *Ptr, Value *Mask=nullptr, Value *PassThru=nullptr, const Twine &Name="")
Create a call to Masked Expand Load intrinsic.
Definition: IRBuilder.cpp:687
Value * CreateMaxNum(Value *LHS, Value *RHS, const Twine &Name="")
Create call to the maxnum intrinsic.
Definition: IRBuilder.h:999
Value * CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2277
Value * CreateConstGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0, const Twine &Name="")
Definition: IRBuilder.h:1943
CallBrInst * CreateCallBr(FunctionType *Ty, Value *Callee, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="")
Create a callbr instruction.
Definition: IRBuilder.h:1214
InvokeInst * CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="")
Definition: IRBuilder.h:1205
Value * CreateVScale(Constant *Scaling, const Twine &Name="")
Create a call to llvm.vscale, multiplied by Scaling.
Definition: IRBuilder.cpp:89
RoundingMode DefaultConstrainedRounding
Definition: IRBuilder.h:127
Value * CreateLaunderInvariantGroup(Value *Ptr)
Create a launder.invariant.group intrinsic call.
Definition: IRBuilder.cpp:1118
CallInst * CreateExtractVector(Type *DstType, Value *SrcVec, Value *Idx, const Twine &Name="")
Create a call to the vector.extract intrinsic.
Definition: IRBuilder.h:1054
Value * CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2351
Value * CreateInsertElement(Type *VecTy, Value *NewElt, uint64_t Idx, const Twine &Name="")
Definition: IRBuilder.h:2497
Value * CreateFPCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2237
Value * CreateSRem(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1427
LoadInst * CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, const Twine &Name="")
Definition: IRBuilder.h:1829
Value * CreateFSub(Value *L, Value *R, const Twine &Name="", MDNode *FPMD=nullptr)
Definition: IRBuilder.h:1577
Value * CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with 2 operands which is mangled on the first type.
Definition: IRBuilder.cpp:922
Value * CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2381
CatchPadInst * CreateCatchPad(Value *ParentPad, ArrayRef< Value * > Args, const Twine &Name="")
Definition: IRBuilder.h:1265
Value * CreateInsertElement(Type *VecTy, Value *NewElt, Value *Idx, const Twine &Name="")
Definition: IRBuilder.h:2492
void SetNoSanitizeMetadata()
Set nosanitize metadata.
Definition: IRBuilder.h:222
Value * CreateLShr(Value *LHS, uint64_t RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1468
AtomicCmpXchgInst * CreateAtomicCmpXchg(Value *Ptr, Value *Cmp, Value *New, MaybeAlign Align, AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering, SyncScope::ID SSID=SyncScope::System)
Definition: IRBuilder.h:1858
CallInst * CreateThreadLocalAddress(Value *Ptr)
Create a call to llvm.threadlocal.address intrinsic.
Definition: IRBuilder.cpp:539
Value * CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0, const Twine &Name="")
Definition: IRBuilder.h:1896
AllocaInst * CreateAlloca(Type *Ty, unsigned AddrSpace, Value *ArraySize=nullptr, const Twine &Name="")
Definition: IRBuilder.h:1790
void setDefaultOperandBundles(ArrayRef< OperandBundleDef > OpBundles)
Definition: IRBuilder.h:362
CallInst * CreateStackSave(const Twine &Name="")
Create a call to llvm.stacksave.
Definition: IRBuilder.h:1070
InvokeInst * CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > OpBundles, const Twine &Name="")
Definition: IRBuilder.h:1197
IntegerType * getInt1Ty()
Fetch the type representing a single bit.
Definition: IRBuilder.h:508
CallInst * CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, Value *Size, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *TBAAStructTag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Definition: IRBuilder.h:673
Value * CreateInsertValue(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &Name="")
Definition: IRBuilder.h:2543
Value * CreateAnd(ArrayRef< Value * > Ops)
Definition: IRBuilder.h:1506
IndirectBrInst * CreateIndirectBr(Value *Addr, unsigned NumDests=10)
Create an indirect branch instruction with the specified address operand, with an optional hint for t...
Definition: IRBuilder.h:1170
BranchInst * CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, Instruction *MDSrc)
Create a conditional 'br Cond, TrueDest, FalseDest' instruction.
Definition: IRBuilder.h:1146
Value * CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name="")
Definition: IRBuilder.h:1498
void setDefaultFPMathTag(MDNode *FPMathTag)
Set the floating point math metadata to be used.
Definition: IRBuilder.h:305
Type * getCurrentFunctionReturnType() const
Get the return type of the current function that we're emitting into.
Definition: IRBuilder.cpp:59
CallInst * CreateCall(FunctionCallee Callee, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > OpBundles, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2461
Value * CreateFMulFMF(Value *L, Value *R, Instruction *FMFSource, const Twine &Name="")
Copy fast-math-flags from an instruction rather than using the builder's default FMF.
Definition: IRBuilder.h:1618
CallInst * CreateGCGetPointerBase(Value *DerivedPtr, const Twine &Name="")
Create a call to the experimental.gc.pointer.base intrinsic to get the base pointer for the specified...
Definition: IRBuilder.cpp:896
Value * CreateFDiv(Value *L, Value *R, const Twine &Name="", MDNode *FPMD=nullptr)
Definition: IRBuilder.h:1631
CallInst * CreateInsertVector(Type *DstType, Value *SrcVec, Value *SubVec, Value *Idx, const Twine &Name="")
Create a call to the vector.insert intrinsic.
Definition: IRBuilder.h:1062
Value * CreateLShr(Value *LHS, const APInt &RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1463
void clearFastMathFlags()
Clear the fast-math flags.
Definition: IRBuilder.h:302
Value * CreateFSubFMF(Value *L, Value *R, Instruction *FMFSource, const Twine &Name="")
Copy fast-math-flags from an instruction rather than using the builder's default FMF.
Definition: IRBuilder.h:1591
Value * CreateFDivFMF(Value *L, Value *R, Instruction *FMFSource, const Twine &Name="")
Copy fast-math-flags from an instruction rather than using the builder's default FMF.
Definition: IRBuilder.h:1645
Value * CreateSIToFP(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2114
CallInst * CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes, FunctionCallee ActualCallee, ArrayRef< Value * > CallArgs, std::optional< ArrayRef< Value * > > DeoptArgs, ArrayRef< Value * > GCArgs, const Twine &Name="")
Create a call to the experimental.gc.statepoint intrinsic to start a new statepoint sequence.
Definition: IRBuilder.cpp:784
LoadInst * CreateLoad(Type *Ty, Value *Ptr, bool isVolatile, const Twine &Name="")
Definition: IRBuilder.h:1815
Value * CreateLogicalOr(ArrayRef< Value * > Ops)
Definition: IRBuilder.h:1719
Value * CreateExtractElement(Value *Vec, Value *Idx, const Twine &Name="")
Definition: IRBuilder.h:2480
Value * CreateLogicalOp(Instruction::BinaryOps Opc, Value *Cond1, Value *Cond2, const Twine &Name="")
Definition: IRBuilder.h:1705
IntegerType * getIntNTy(unsigned N)
Fetch the type representing an N-bit integer.
Definition: IRBuilder.h:536
void setDefaultConstrainedExcept(fp::ExceptionBehavior NewExcept)
Set the exception handling to be used with constrained floating point.
Definition: IRBuilder.h:320
Value * CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2285
Value * CreateFPTrunc(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2121
LoadInst * CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, const char *Name)
Definition: IRBuilder.h:1824
Value * CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2331
Type * getDoubleTy()
Fetch the type representing a 64-bit floating point value.
Definition: IRBuilder.h:556
Value * CreateZExtOrTrunc(Value *V, Type *DestTy, const Twine &Name="")
Create a ZExt or Trunc from the integer value V to DestTy.
Definition: IRBuilder.h:2059
Value * CreateFRemFMF(Value *L, Value *R, Instruction *FMFSource, const Twine &Name="")
Copy fast-math-flags from an instruction rather than using the builder's default FMF.
Definition: IRBuilder.h:1671
Value * CreateFAdd(Value *L, Value *R, const Twine &Name="", MDNode *FPMD=nullptr)
Definition: IRBuilder.h:1550
UnreachableInst * CreateUnreachable()
Definition: IRBuilder.h:1280
CallInst * CreateLifetimeStart(Value *Ptr, ConstantInt *Size=nullptr)
Create a lifetime.start intrinsic.
Definition: IRBuilder.cpp:482
CallInst * CreateConstrainedFPCmp(Intrinsic::ID ID, CmpInst::Predicate P, Value *L, Value *R, const Twine &Name="", std::optional< fp::ExceptionBehavior > Except=std::nullopt)
Definition: IRBuilder.cpp:1062
CallInst * CreateFree(Value *Source, ArrayRef< OperandBundleDef > Bundles=std::nullopt)
Generate the IR for a call to the builtin free function.
Definition: IRBuilder.cpp:354
CallInst * CreateAndReduce(Value *Src)
Create a vector int AND reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:442
Value * CreateVectorSplice(Value *V1, Value *V2, int64_t Imm, const Twine &Name="")
Return a vector splice intrinsic if using scalable vectors, otherwise return a shufflevector.
Definition: IRBuilder.cpp:1166
Value * CreatePointerCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2190
void setDefaultConstrainedRounding(RoundingMode NewRounding)
Set the rounding mode handling to be used with constrained floating point.
Definition: IRBuilder.h:330
Value * CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name="")
Return a vector value that contains.
Definition: IRBuilder.cpp:1193
Value * CreateFRem(Value *L, Value *R, const Twine &Name="", MDNode *FPMD=nullptr)
Definition: IRBuilder.h:1658
Value * CreateExtractValue(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &Name="")
Definition: IRBuilder.h:2536
Value * CreateAnd(Value *LHS, uint64_t RHS, const Twine &Name="")
Definition: IRBuilder.h:1502
ConstantInt * getTrue()
Get the constant value for i1 true.
Definition: IRBuilder.h:463
Value * Insert(Value *V, const Twine &Name="") const
Definition: IRBuilder.h:153
LandingPadInst * CreateLandingPad(Type *Ty, unsigned NumClauses, const Twine &Name="")
Definition: IRBuilder.h:2550
CallInst * CreateIntrinsic(Intrinsic::ID ID, ArrayRef< Type * > Types, ArrayRef< Value * > Args, Instruction *FMFSource=nullptr, const Twine &Name="")
Create a call to intrinsic ID with Args, mangled using Types.
Definition: IRBuilder.cpp:933
Value * CreateFNegFMF(Value *V, Instruction *FMFSource, const Twine &Name="")
Copy fast-math-flags from an instruction rather than using the builder's default FMF.
Definition: IRBuilder.h:1757
Value * CreateMaximum(Value *LHS, Value *RHS, const Twine &Name="")
Create call to the maximum intrinsic.
Definition: IRBuilder.h:1014
Value * CreateMinNum(Value *LHS, Value *RHS, const Twine &Name="")
Create call to the minnum intrinsic.
Definition: IRBuilder.h:989
Value * CreatePreserveStructAccessIndex(Type *ElTy, Value *Base, unsigned Index, unsigned FieldIndex, MDNode *DbgInfo)
Definition: IRBuilder.cpp:1261
CallInst * CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue, unsigned Alignment, Value *OffsetValue=nullptr)
Create an assume intrinsic call that represents an alignment assumption on the provided pointer.
Definition: IRBuilder.cpp:1307
CallInst * CreateMaskedLoad(Type *Ty, Value *Ptr, Align Alignment, Value *Mask, Value *PassThru=nullptr, const Twine &Name="")
Create a call to Masked Load intrinsic.
Definition: IRBuilder.cpp:579
Value * CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2289
CallInst * CreateConstrainedFPCall(Function *Callee, ArrayRef< Value * > Args, const Twine &Name="", std::optional< RoundingMode > Rounding=std::nullopt, std::optional< fp::ExceptionBehavior > Except=std::nullopt)
Definition: IRBuilder.cpp:1074
CallInst * CreateMemSet(Value *Ptr, Value *Val, uint64_t Size, MaybeAlign Align, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Create and insert a memset to the specified pointer and the specified value.
Definition: IRBuilder.h:592
LLVMContext & Context
Definition: IRBuilder.h:118
Value * CreateSelect(Value *C, Value *True, Value *False, const Twine &Name="", Instruction *MDFrom=nullptr)
Definition: IRBuilder.cpp:1091
InvokeInst * CreateInvoke(FunctionType *Ty, Value *Callee, BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > OpBundles, const Twine &Name="")
Create an invoke instruction.
Definition: IRBuilder.h:1175
RoundingMode getDefaultConstrainedRounding()
Get the rounding mode handling used with constrained floating point.
Definition: IRBuilder.h:345
Value * CreateFPToUI(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2087
Value * CreateConstGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, uint64_t Idx1, const Twine &Name="")
Definition: IRBuilder.h:1963
Value * CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2366
BasicBlock::iterator GetInsertPoint() const
Definition: IRBuilder.h:172
Value * CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx, const Twine &Name="")
Definition: IRBuilder.h:1989
FenceInst * CreateFence(AtomicOrdering Ordering, SyncScope::ID SSID=SyncScope::System, const Twine &Name="")
Definition: IRBuilder.h:1851
IntegerType * getIndexTy(const DataLayout &DL, unsigned AddrSpace)
Fetch the type of an integer that should be used to index GEP operations within AddressSpace.
Definition: IRBuilder.h:578
CallBrInst * CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > OpBundles, const Twine &Name="")
Definition: IRBuilder.h:1240
CallInst * CreateGCGetPointerOffset(Value *DerivedPtr, const Twine &Name="")
Create a call to the experimental.gc.get.pointer.offset intrinsic to get the offset of the specified ...
Definition: IRBuilder.cpp:905
fp::ExceptionBehavior getDefaultConstrainedExcept()
Get the exception handling used with constrained floating point.
Definition: IRBuilder.h:340
Value * CreateSExt(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2053
Value * CreateSExtOrBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2165
Value * CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2346
Value * CreateIntToPtr(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2142
Value * CreateTypeSize(Type *DstType, TypeSize Size)
Create an expression which evaluates to the number of units in Size at runtime.
Definition: IRBuilder.cpp:105
CallInst * CreateAddReduce(Value *Src)
Create a vector int add reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:434
Value * CreateFreeze(Value *V, const Twine &Name="")
Definition: IRBuilder.h:2555
BasicBlock::iterator InsertPt
Definition: IRBuilder.h:117
Value * CreateLShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1454
IntegerType * getIntPtrTy(const DataLayout &DL, unsigned AddrSpace=0)
Fetch the type of an integer with size at least as big as that of a pointer in the given address spac...
Definition: IRBuilder.h:572
IntegerType * getInt32Ty()
Fetch the type representing a 32-bit integer.
Definition: IRBuilder.h:523
Value * CreateConstInBoundsGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0, const Twine &Name="")
Definition: IRBuilder.h:1906
ConstantInt * getInt8(uint8_t C)
Get a constant 8-bit value.
Definition: IRBuilder.h:473
Value * CreatePtrAdd(Value *Ptr, Value *Offset, const Twine &Name="", GEPNoWrapFlags NW=GEPNoWrapFlags::none())
Definition: IRBuilder.h:1996
Value * CreateIsNotNeg(Value *Arg, const Twine &Name="")
Return a boolean value testing if Arg > -1.
Definition: IRBuilder.h:2579
CatchReturnInst * CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB)
Definition: IRBuilder.h:1276
CallInst * CreateConstrainedFPUnroundedBinOp(Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource=nullptr, const Twine &Name="", MDNode *FPMathTag=nullptr, std::optional< fp::ExceptionBehavior > Except=std::nullopt)
Definition: IRBuilder.cpp:989
CleanupReturnInst * CreateCleanupRet(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB=nullptr)
Definition: IRBuilder.h:1253
Value * CreateUIToFP(Value *V, Type *DestTy, const Twine &Name="", bool IsNonNeg=false)
Definition: IRBuilder.h:2101
ReturnInst * CreateRet(Value *V)
Create a 'ret <val>' instruction.
Definition: IRBuilder.h:1112
Value * CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1353
bool getIsFPConstrained()
Query for the use of constrained floating point math.
Definition: IRBuilder.h:317
Value * CreateAShr(Value *LHS, uint64_t RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1487
BasicBlock * GetInsertBlock() const
Definition: IRBuilder.h:171
CallInst * CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, Value *Size, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Definition: IRBuilder.h:717
Type * getHalfTy()
Fetch the type representing a 16-bit floating point value.
Definition: IRBuilder.h:541
void setFastMathFlags(FastMathFlags NewFMF)
Set the fast-math flags to be used with generated fp-math operators.
Definition: IRBuilder.h:308
Value * CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2316
void SetCurrentDebugLocation(DebugLoc L)
Set location information used by debugging information.
Definition: IRBuilder.h:217
void SetInsertPointPastAllocas(Function *F)
This specifies that created instructions should inserted at the beginning end of the specified functi...
Definition: IRBuilder.h:211
IntegerType * getInt64Ty()
Fetch the type representing a 64-bit integer.
Definition: IRBuilder.h:528
Value * CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="")
Definition: IRBuilder.h:1891
CallInst * CreateMemTransferInst(Intrinsic::ID IntrID, Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, Value *Size, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *TBAAStructTag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Definition: IRBuilder.cpp:220
Value * CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1387
InsertPoint saveAndClearIP()
Returns the current insert point, clearing it in the process.
Definition: IRBuilder.h:279
Value * CreateOr(Value *LHS, const APInt &RHS, const Twine &Name="")
Definition: IRBuilder.h:1520
Value * CreatePointerBitCastOrAddrSpaceCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2202
Value * CreateVectorReverse(Value *V, const Twine &Name="")
Return a vector value that contains the vector V reversed.
Definition: IRBuilder.cpp:1151
Value * CreateShuffleVector(Value *V, ArrayRef< int > Mask, const Twine &Name="")
Create a unary shuffle.
Definition: IRBuilder.h:2531
CallInst * CreateXorReduce(Value *Src)
Create a vector int XOR reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:450
Value * CreateAShr(Value *LHS, const APInt &RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1482
Value * CreateUDiv(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1395
Value * CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2361
FastMathFlags FMF
Definition: IRBuilder.h:123
Value * CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2265
Value * CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1357
IntegerType * getInt16Ty()
Fetch the type representing a 16-bit integer.
Definition: IRBuilder.h:518
Value * CreateGEP(Type *Ty, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="", GEPNoWrapFlags NW=GEPNoWrapFlags::none())
Definition: IRBuilder.h:1883
ConstantInt * getInt64(uint64_t C)
Get a constant 64-bit value.
Definition: IRBuilder.h:488
CatchSwitchInst * CreateCatchSwitch(Value *ParentPad, BasicBlock *UnwindBB, unsigned NumHandlers, const Twine &Name="")
Definition: IRBuilder.h:1258
Value * getAllOnesMask(ElementCount NumElts)
Return an all true boolean vector (mask) with NumElts lanes.
Definition: IRBuilder.h:845
Value * CreateUnOp(Instruction::UnaryOps Opc, Value *V, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:1770
Value * CreateNeg(Value *V, const Twine &Name="", bool HasNSW=false)
Definition: IRBuilder.h:1738
LoadInst * CreateLoad(Type *Ty, Value *Ptr, const Twine &Name="")
Definition: IRBuilder.h:1811
CallInst * CreateOrReduce(Value *Src)
Create a vector int OR reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:446
Value * CreateLdexp(Value *Src, Value *Exp, Instruction *FMFSource=nullptr, const Twine &Name="")
Create call to the ldexp intrinsic.
Definition: IRBuilder.h:1039
CallInst * CreateMalloc(Type *IntPtrTy, Type *AllocTy, Value *AllocSize, Value *ArraySize, ArrayRef< OperandBundleDef > OpB, Function *MallocF=nullptr, const Twine &Name="")
Definition: IRBuilder.cpp:302
InsertPoint saveIP() const
Returns the current insert point.
Definition: IRBuilder.h:274
void CollectMetadataToCopy(Instruction *Src, ArrayRef< unsigned > MetadataKinds)
Collect metadata with IDs MetadataKinds from Src which should be added to all created instructions.
Definition: IRBuilder.h:230
CallInst * CreateFPMinReduce(Value *Src)
Create a vector float min reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:470
void SetInsertPoint(BasicBlock::iterator IP)
This specifies that created instructions should be inserted at the specified point,...
Definition: IRBuilder.h:202
CallInst * CreateFPMaximumReduce(Value *Src)
Create a vector float maximum reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:474
Value * CreateInsertElement(Value *Vec, Value *NewElt, uint64_t Idx, const Twine &Name="")
Definition: IRBuilder.h:2509
Value * CreateShl(Value *LHS, uint64_t RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:1448
Value * CreateShuffleVector(Value *V1, Value *V2, ArrayRef< int > Mask, const Twine &Name="")
See class ShuffleVectorInst for a description of the mask representation.
Definition: IRBuilder.h:2522
ReturnInst * CreateAggregateRet(Value *const *retVals, unsigned N)
Create a sequence of N insertvalue instructions, with one Value from the retVals array each,...
Definition: IRBuilder.h:1123
Value * createIsFPClass(Value *FPNum, unsigned Test)
Definition: IRBuilder.cpp:1288
Value * CreateFCmpOLE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2321
CallInst * CreateFPMaxReduce(Value *Src)
Create a vector float max reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:466
Constant * CreateGlobalStringPtr(StringRef Str, const Twine &Name="", unsigned AddressSpace=0, Module *M=nullptr, bool AddNull=true)
Same as CreateGlobalString, but return a pointer with "i8*" type instead of a pointer to array of i8.
Definition: IRBuilder.h:2012
ConstantInt * getInt32(uint32_t C)
Get a constant 32-bit value.
Definition: IRBuilder.h:483
CallInst * CreateCall(FunctionCallee Callee, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2454
Value * CreateBitOrPointerCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2225
Value * CreateCmp(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2386
const IRBuilderDefaultInserter & Inserter
Definition: IRBuilder.h:120
Value * CreateICmpSLE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2297
PHINode * CreatePHI(Type *Ty, unsigned NumReservedValues, const Twine &Name="")
Definition: IRBuilder.h:2417
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > OpBundles, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2443
Value * CreateNot(Value *V, const Twine &Name="")
Definition: IRBuilder.h:1766
SwitchInst * CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases=10, MDNode *BranchWeights=nullptr, MDNode *Unpredictable=nullptr)
Create a switch instruction with the specified value, default dest, and with a hint for the number of...
Definition: IRBuilder.h:1160
Value * CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2261
InstTy * Insert(InstTy *I, const Twine &Name="") const
Insert and return the specified instruction.
Definition: IRBuilder.h:142
CallInst * CreateConstrainedFPBinOp(Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource=nullptr, const Twine &Name="", MDNode *FPMathTag=nullptr, std::optional< RoundingMode > Rounding=std::nullopt, std::optional< fp::ExceptionBehavior > Except=std::nullopt)
Definition: IRBuilder.cpp:970
Value * CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2341
void setIsFPConstrained(bool IsCon)
Enable/Disable use of constrained floating point math.
Definition: IRBuilder.h:314
DebugLoc getCurrentDebugLocation() const
Get location information used by debugging information.
Definition: IRBuilder.cpp:64
Value * CreateMinimum(Value *LHS, Value *RHS, const Twine &Name="")
Create call to the minimum intrinsic.
Definition: IRBuilder.h:1009
IntegerType * getInt128Ty()
Fetch the type representing a 128-bit integer.
Definition: IRBuilder.h:533
Value * CreateIsNeg(Value *Arg, const Twine &Name="")
Return a boolean value testing if Arg < 0.
Definition: IRBuilder.h:2574
Constant * Insert(Constant *C, const Twine &="") const
No-op overload to handle constants.
Definition: IRBuilder.h:149
Value * CreateSub(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:1361
Value * CreateBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2147
ConstantInt * getIntN(unsigned N, uint64_t C)
Get a constant N-bit value, zero extended or truncated from a 64-bit value.
Definition: IRBuilder.h:494
BranchInst * CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, MDNode *BranchWeights=nullptr, MDNode *Unpredictable=nullptr)
Create a conditional 'br Cond, TrueDest, FalseDest' instruction.
Definition: IRBuilder.h:1137
IRBuilderBase(LLVMContext &context, const IRBuilderFolder &Folder, const IRBuilderDefaultInserter &Inserter, MDNode *FPMathTag, ArrayRef< OperandBundleDef > OpBundles)
Definition: IRBuilder.h:132
void AddMetadataToInst(Instruction *I) const
Add all entries in MetadataToCopy to I.
Definition: IRBuilder.h:244
Value * CreateICmpUGT(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2269
LoadInst * CreateLoad(Type *Ty, Value *Ptr, const char *Name)
Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of converting the string to 'bool...
Definition: IRBuilder.h:1807
Value * CreateShl(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:1433
FastMathFlags getFastMathFlags() const
Get the flags to be applied to created floating point ops.
Definition: IRBuilder.h:297
Value * CreateNAryOp(unsigned Opc, ArrayRef< Value * > Ops, const Twine &Name="", MDNode *FPMathTag=nullptr)
Create either a UnaryOperator or BinaryOperator depending on Opc.
Definition: IRBuilder.cpp:1006
Value * CreateZExt(Value *V, Type *DestTy, const Twine &Name="", bool IsNonNeg=false)
Definition: IRBuilder.h:2041
CallInst * CreateMemCpyInline(Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, Value *Size, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *TBAAStructTag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Definition: IRBuilder.h:685
CallInst * CreateAssumption(Value *Cond, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Create an assume intrinsic call that allows the optimizer to assume that the provided condition will ...
Definition: IRBuilder.cpp:552
Value * CreateShuffleVector(Value *V1, Value *V2, Value *Mask, const Twine &Name="")
Definition: IRBuilder.h:2514
LLVMContext & getContext() const
Definition: IRBuilder.h:173
Value * CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2301
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1492
FastMathFlags & getFastMathFlags()
Definition: IRBuilder.h:299
ReturnInst * CreateRetVoid()
Create a 'ret void' instruction.
Definition: IRBuilder.h:1107
Value * CreateMaximumNum(Value *LHS, Value *RHS, const Twine &Name="")
Create call to the maximum intrinsic.
Definition: IRBuilder.h:1025
Value * CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1370
Value * CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1, const Twine &Name="")
Definition: IRBuilder.h:1930
Value * CreateConstInBoundsGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, uint64_t Idx1, const Twine &Name="")
Definition: IRBuilder.h:1976
Value * CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex, MDNode *DbgInfo)
Definition: IRBuilder.cpp:1242
StoreInst * CreateStore(Value *Val, Value *Ptr, bool isVolatile=false)
Definition: IRBuilder.h:1820
CallInst * CreateIntMaxReduce(Value *Src, bool IsSigned=false)
Create a vector integer max reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:454
CallInst * CreateMaskedStore(Value *Val, Value *Ptr, Align Alignment, Value *Mask)
Create a call to Masked Store intrinsic.
Definition: IRBuilder.cpp:599
Value * CreateAdd(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:1344
Value * CreatePtrToInt(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2137
Value * CreateSDiv(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1408
ConstantInt * getFalse()
Get the constant value for i1 false.
Definition: IRBuilder.h:468
VAArgInst * CreateVAArg(Value *List, Type *Ty, const Twine &Name="")
Definition: IRBuilder.h:2476
Value * CreateExactUDiv(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1404
Type * getFloatTy()
Fetch the type representing a 32-bit floating point value.
Definition: IRBuilder.h:551
Value * CreateIsNotNull(Value *Arg, const Twine &Name="")
Return a boolean value testing if Arg != 0.
Definition: IRBuilder.h:2569
void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP)
This specifies that created instructions should be inserted at the specified point.
Definition: IRBuilder.h:193
Instruction * CreateNoAliasScopeDeclaration(MDNode *ScopeTag)
Definition: IRBuilder.h:861
Value * CreateShl(Value *LHS, const APInt &RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:1442
AtomicRMWInst * CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr, Value *Val, MaybeAlign Align, AtomicOrdering Ordering, SyncScope::ID SSID=SyncScope::System)
Definition: IRBuilder.h:1871
CallInst * CreateGCResult(Instruction *Statepoint, Type *ResultType, const Twine &Name="")
Create a call to the experimental.gc.result intrinsic to extract the result from a call wrapped in a ...
Definition: IRBuilder.cpp:873
CleanupPadInst * CreateCleanupPad(Value *ParentPad, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="")
Definition: IRBuilder.h:1270
Value * CreateTrunc(Value *V, Type *DestTy, const Twine &Name="", bool IsNUW=false, bool IsNSW=false)
Definition: IRBuilder.h:2027
CallInst * CreateLifetimeEnd(Value *Ptr, ConstantInt *Size=nullptr)
Create a lifetime.end intrinsic.
Definition: IRBuilder.cpp:497
Value * CreateOr(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1514
PointerType * getPtrTy(unsigned AddrSpace=0)
Fetch the type representing a pointer.
Definition: IRBuilder.h:566
Value * CreateBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:1683
BranchInst * CreateBr(BasicBlock *Dest)
Create an unconditional 'br label X' instruction.
Definition: IRBuilder.h:1131
Value * CreateLogicalAnd(Value *Cond1, Value *Cond2, const Twine &Name="")
Definition: IRBuilder.h:1693
Value * CreateElementCount(Type *DstType, ElementCount EC)
Create an expression which evaluates to the number of elements in EC at runtime.
Definition: IRBuilder.cpp:100
Value * CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx, const Twine &Name="")
Definition: IRBuilder.h:2502
Value * CreateConstInBoundsGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0, const Twine &Name="")
Definition: IRBuilder.h:1953
fp::ExceptionBehavior DefaultConstrainedExcept
Definition: IRBuilder.h:126
CallInst * CreateConstrainedFPCast(Intrinsic::ID ID, Value *V, Type *DestTy, Instruction *FMFSource=nullptr, const Twine &Name="", MDNode *FPMathTag=nullptr, std::optional< RoundingMode > Rounding=std::nullopt, std::optional< fp::ExceptionBehavior > Except=std::nullopt)
Definition: IRBuilder.cpp:1021
void ClearInsertionPoint()
Clear the insertion point: created instructions will not be inserted into a block.
Definition: IRBuilder.h:166
Value * CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2293
ConstantInt * getInt16(uint16_t C)
Get a constant 16-bit value.
Definition: IRBuilder.h:478
MDNode * DefaultFPMathTag
Definition: IRBuilder.h:122
CallInst * CreateElementUnorderedAtomicMemMove(Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size, uint32_t ElementSize, MDNode *TBAATag=nullptr, MDNode *TBAAStructTag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Create and insert an element unordered-atomic memmove between the specified pointers.
Definition: IRBuilder.cpp:373
ArrayRef< OperandBundleDef > DefaultOperandBundles
Definition: IRBuilder.h:129
Value * CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2181
CallBrInst * CreateCallBr(FunctionType *Ty, Value *Callee, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > OpBundles, const Twine &Name="")
Definition: IRBuilder.h:1222
Value * CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2273
MDNode * getDefaultFPMathTag() const
Get the floating point math metadata being used.
Definition: IRBuilder.h:294
Value * CreateIntCast(Value *V, Type *DestTy, bool isSigned, const Twine &Name="")
Definition: IRBuilder.h:2216
Value * CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2336
void restoreIP(InsertPoint IP)
Sets the current insert point to a previously-saved location.
Definition: IRBuilder.h:286
Value * CreateIsNull(Value *Arg, const Twine &Name="")
Return a boolean value testing if Arg == 0.
Definition: IRBuilder.h:2564
Value * CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2306
CallInst * CreateStackRestore(Value *Ptr, const Twine &Name="")
Create a call to llvm.stackrestore.
Definition: IRBuilder.h:1077
CallInst * CreateIntMinReduce(Value *Src, bool IsSigned=false)
Create a vector integer min reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:460
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
Definition: IRBuilder.h:177
Type * getVoidTy()
Fetch the type representing void.
Definition: IRBuilder.h:561
Value * CreateOr(ArrayRef< Value * > Ops)
Definition: IRBuilder.h:1528
AllocaInst * CreateAlloca(Type *Ty, Value *ArraySize=nullptr, const Twine &Name="")
Definition: IRBuilder.h:1797
Value * CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1, const Twine &Name="", GEPNoWrapFlags NWFlags=GEPNoWrapFlags::none())
Definition: IRBuilder.h:1916
Value * CreateExtractElement(Value *Vec, uint64_t Idx, const Twine &Name="")
Definition: IRBuilder.h:2487
StoreInst * CreateAlignedStore(Value *Val, Value *Ptr, MaybeAlign Align, bool isVolatile=false)
Definition: IRBuilder.h:1843
Value * CreateOr(Value *LHS, uint64_t RHS, const Twine &Name="")
Definition: IRBuilder.h:1524
void setConstrainedFPCallAttr(CallBase *I)
Definition: IRBuilder.h:358
Value * CreateMinimumNum(Value *LHS, Value *RHS, const Twine &Name="")
Create call to the minimumnum intrinsic.
Definition: IRBuilder.h:1019
InvokeInst * CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes, FunctionCallee ActualInvokee, BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef< Value * > InvokeArgs, std::optional< ArrayRef< Value * > > DeoptArgs, ArrayRef< Value * > GCArgs, const Twine &Name="")
Create an invoke to the experimental.gc.statepoint intrinsic to start a new statepoint sequence.
Definition: IRBuilder.cpp:840
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2432
CallBrInst * CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="")
Definition: IRBuilder.h:1233
const IRBuilderFolder & Folder
Definition: IRBuilder.h:119
Value * CreateInBoundsPtrAdd(Value *Ptr, Value *Offset, const Twine &Name="")
Definition: IRBuilder.h:2001
Value * CreateIntCast(Value *, Type *, const char *)=delete
CallInst * CreateMemSetInline(Value *Dst, MaybeAlign DstAlign, Value *Val, Value *Size, bool IsVolatile=false, MDNode *TBAATag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Definition: IRBuilder.cpp:165
Value * CreateAShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1473
CallInst * CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val, uint64_t Size, Align Alignment, uint32_t ElementSize, MDNode *TBAATag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Create and insert an element unordered-atomic memset of the region of memory starting at the given po...
Definition: IRBuilder.h:617
Value * CreateFPExt(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2130
Value * CreateXor(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1536
CallInst * CreateFMulReduce(Value *Acc, Value *Src)
Create a sequential vector fmul reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:426
Value * CreateTruncOrBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2173
Value * CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2281
Value * CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2371
Value * CreateLogicalOr(Value *Cond1, Value *Cond2, const Twine &Name="")
Definition: IRBuilder.h:1699
Value * CreateFMul(Value *L, Value *R, const Twine &Name="", MDNode *FPMD=nullptr)
Definition: IRBuilder.h:1604
LoadInst * CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, bool isVolatile, const Twine &Name="")
Definition: IRBuilder.h:1834
Value * CreateFNeg(Value *V, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:1747
void setConstrainedFPFunctionAttr()
Definition: IRBuilder.h:349
void SetInstDebugLocation(Instruction *I) const
If this builder has a current debug location, set it on the specified instruction.
Definition: IRBuilder.cpp:71
void SetInsertPoint(Instruction *I)
This specifies that created instructions should be inserted before the specified instruction.
Definition: IRBuilder.h:184
IntegerType * getInt8Ty()
Fetch the type representing an 8-bit integer.
Definition: IRBuilder.h:513
ConstantInt * getInt(const APInt &AI)
Get a constant integer value.
Definition: IRBuilder.h:499
CallInst * CreateGCRelocate(Instruction *Statepoint, int BaseOffset, int DerivedOffset, Type *ResultType, const Twine &Name="")
Create a call to the experimental.gc.relocate intrinsics to project the relocated value of one pointe...
Definition: IRBuilder.cpp:884
Value * CreateURem(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1421
Value * CreateStepVector(Type *DstType, const Twine &Name="")
Creates a vector of type DstType with the linear sequence <0, 1, ...>
Definition: IRBuilder.cpp:110
CallInst * CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, uint64_t Size, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *TBAAStructTag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Create and insert a memcpy between the specified pointers.
Definition: IRBuilder.h:656
CallInst * CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, uint64_t Size, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Definition: IRBuilder.h:708
Value * CreatePreserveArrayAccessIndex(Type *ElTy, Value *Base, unsigned Dimension, unsigned LastIndex, MDNode *DbgInfo)
Definition: IRBuilder.cpp:1213
Value * CreateSExtOrTrunc(Value *V, Type *DestTy, const Twine &Name="")
Create a SExt or Trunc from the integer value V to DestTy.
Definition: IRBuilder.h:2074
ResumeInst * CreateResume(Value *Exn)
Definition: IRBuilder.h:1249
Value * CreateAddrSpaceCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2152
Type * getBFloatTy()
Fetch the type representing a 16-bit brain floating point value.
Definition: IRBuilder.h:546
Value * CreateXor(Value *LHS, const APInt &RHS, const Twine &Name="")
Definition: IRBuilder.h:1542
CallInst * CreateInvariantStart(Value *Ptr, ConstantInt *Size=nullptr)
Create a call to invariant.start intrinsic.
Definition: IRBuilder.cpp:512
Value * CreateMul(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:1378
Instruction * CreateNoAliasScopeDeclaration(Value *Scope)
Create a llvm.experimental.noalias.scope.decl intrinsic call.
Definition: IRBuilder.cpp:563
CallInst * CreateMaskedScatter(Value *Val, Value *Ptrs, Align Alignment, Value *Mask=nullptr)
Create a call to Masked Scatter intrinsic.
Definition: IRBuilder.cpp:662
Value * CreateXor(Value *LHS, uint64_t RHS, const Twine &Name="")
Definition: IRBuilder.h:1546
GlobalVariable * CreateGlobalString(StringRef Str, const Twine &Name="", unsigned AddressSpace=0, Module *M=nullptr, bool AddNull=true)
Make a new global variable with initializer type i8*.
Definition: IRBuilder.cpp:44
Value * CreateNSWNeg(Value *V, const Twine &Name="")
Definition: IRBuilder.h:1743
CallInst * CreateFPMinimumReduce(Value *Src)
Create a vector float minimum reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:478
Value * CreateFCmpOGE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2311
Value * CreateStripInvariantGroup(Value *Ptr)
Create a strip.invariant.group intrinsic call.
Definition: IRBuilder.cpp:1134
CallInst * CreateMaskedGather(Type *Ty, Value *Ptrs, Align Alignment, Value *Mask=nullptr, Value *PassThru=nullptr, const Twine &Name="")
Create a call to Masked Gather intrinsic.
Definition: IRBuilder.cpp:631
Value * CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1374
Value * CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2356
CallInst * CreateArithmeticFence(Value *Val, Type *DstType, const Twine &Name="")
Create a call to the arithmetic_fence intrinsic.
Definition: IRBuilder.h:1047
Value * CreateFPToSI(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2094
Value * CreateCopySign(Value *LHS, Value *RHS, Instruction *FMFSource=nullptr, const Twine &Name="")
Create call to the copysign intrinsic.
Definition: IRBuilder.h:1031
Provides an 'InsertHelper' that calls a user-provided callback after performing the default insertion...
Definition: IRBuilder.h:74
IRBuilderCallbackInserter(std::function< void(Instruction *)> Callback)
Definition: IRBuilder.h:80
void InsertHelper(Instruction *I, const Twine &Name, BasicBlock::iterator InsertPt) const override
Definition: IRBuilder.h:83
This provides the default implementation of the IRBuilder 'InsertHelper' method that is called whenev...
Definition: IRBuilder.h:60
virtual void InsertHelper(Instruction *I, const Twine &Name, BasicBlock::iterator InsertPt) const
Definition: IRBuilder.h:64
IRBuilderFolder - Interface for constant folding in IRBuilder.
virtual Value * FoldCmp(CmpInst::Predicate P, Value *LHS, Value *RHS) const =0
virtual Value * FoldUnOpFMF(Instruction::UnaryOps Opc, Value *V, FastMathFlags FMF) const =0
virtual Value * FoldBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS) const =0
virtual Value * FoldBinOpFMF(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, FastMathFlags FMF) const =0
virtual Value * FoldShuffleVector(Value *V1, Value *V2, ArrayRef< int > Mask) const =0
virtual Value * CreatePointerBitCastOrAddrSpaceCast(Constant *C, Type *DestTy) const =0
virtual Value * FoldInsertElement(Value *Vec, Value *NewElt, Value *Idx) const =0
virtual Value * CreatePointerCast(Constant *C, Type *DestTy) const =0
virtual Value * FoldCast(Instruction::CastOps Op, Value *V, Type *DestTy) const =0
virtual Value * FoldExtractElement(Value *Vec, Value *Idx) const =0
virtual Value * FoldExactBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, bool IsExact) const =0
virtual Value * FoldGEP(Type *Ty, Value *Ptr, ArrayRef< Value * > IdxList, GEPNoWrapFlags NW) const =0
virtual Value * FoldInsertValue(Value *Agg, Value *Val, ArrayRef< unsigned > IdxList) const =0
virtual Value * FoldNoWrapBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, bool HasNUW, bool HasNSW) const =0
virtual Value * FoldExtractValue(Value *Agg, ArrayRef< unsigned > IdxList) const =0
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:2686
IRBuilder(const IRBuilder &)=delete
Avoid copying the full IRBuilder.
IRBuilder(LLVMContext &C, FolderTy Folder, InserterTy Inserter=InserterTy(), MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Definition: IRBuilder.h:2692
IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, FolderTy Folder, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Definition: IRBuilder.h:2725
IRBuilder(Instruction *IP, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Definition: IRBuilder.h:2718
IRBuilder(LLVMContext &C, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Definition: IRBuilder.h:2698
InserterTy & getInserter()
Definition: IRBuilder.h:2746
IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Definition: IRBuilder.h:2734
IRBuilder(BasicBlock *TheBB, FolderTy Folder, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Definition: IRBuilder.h:2702
IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Definition: IRBuilder.h:2711
const InserterTy & getInserter() const
Definition: IRBuilder.h:2747
Indirect Branch Instruction.
static IndirectBrInst * Create(Value *Address, unsigned NumDests, InsertPosition InsertBefore=nullptr)