LLVM 19.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 copysign intrinsic.
1020 Instruction *FMFSource = nullptr,
1021 const Twine &Name = "") {
1022 return CreateBinaryIntrinsic(Intrinsic::copysign, LHS, RHS, FMFSource,
1023 Name);
1024 }
1025
1026 /// Create call to the ldexp intrinsic.
1027 Value *CreateLdexp(Value *Src, Value *Exp, Instruction *FMFSource = nullptr,
1028 const Twine &Name = "") {
1029 assert(!IsFPConstrained && "TODO: Support strictfp");
1030 return CreateIntrinsic(Intrinsic::ldexp, {Src->getType(), Exp->getType()},
1031 {Src, Exp}, FMFSource, Name);
1032 }
1033
1034 /// Create a call to the arithmetic_fence intrinsic.
1036 const Twine &Name = "") {
1037 return CreateIntrinsic(Intrinsic::arithmetic_fence, DstType, Val, nullptr,
1038 Name);
1039 }
1040
1041 /// Create a call to the vector.extract intrinsic.
1043 const Twine &Name = "") {
1044 return CreateIntrinsic(Intrinsic::vector_extract,
1045 {DstType, SrcVec->getType()}, {SrcVec, Idx}, nullptr,
1046 Name);
1047 }
1048
1049 /// Create a call to the vector.insert intrinsic.
1050 CallInst *CreateInsertVector(Type *DstType, Value *SrcVec, Value *SubVec,
1051 Value *Idx, const Twine &Name = "") {
1052 return CreateIntrinsic(Intrinsic::vector_insert,
1053 {DstType, SubVec->getType()}, {SrcVec, SubVec, Idx},
1054 nullptr, Name);
1055 }
1056
1057 /// Create a call to llvm.stacksave
1059 const DataLayout &DL = BB->getDataLayout();
1060 return CreateIntrinsic(Intrinsic::stacksave, {DL.getAllocaPtrType(Context)},
1061 {}, nullptr, Name);
1062 }
1063
1064 /// Create a call to llvm.stackrestore
1066 return CreateIntrinsic(Intrinsic::stackrestore, {Ptr->getType()}, {Ptr},
1067 nullptr, Name);
1068 }
1069
1070private:
1071 /// Create a call to a masked intrinsic with given Id.
1072 CallInst *CreateMaskedIntrinsic(Intrinsic::ID Id, ArrayRef<Value *> Ops,
1073 ArrayRef<Type *> OverloadedTypes,
1074 const Twine &Name = "");
1075
1076 //===--------------------------------------------------------------------===//
1077 // Instruction creation methods: Terminators
1078 //===--------------------------------------------------------------------===//
1079
1080private:
1081 /// Helper to add branch weight and unpredictable metadata onto an
1082 /// instruction.
1083 /// \returns The annotated instruction.
1084 template <typename InstTy>
1085 InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
1086 if (Weights)
1087 I->setMetadata(LLVMContext::MD_prof, Weights);
1088 if (Unpredictable)
1089 I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
1090 return I;
1091 }
1092
1093public:
1094 /// Create a 'ret void' instruction.
1097 }
1098
1099 /// Create a 'ret <val>' instruction.
1101 return Insert(ReturnInst::Create(Context, V));
1102 }
1103
1104 /// Create a sequence of N insertvalue instructions,
1105 /// with one Value from the retVals array each, that build a aggregate
1106 /// return value one value at a time, and a ret instruction to return
1107 /// the resulting aggregate value.
1108 ///
1109 /// This is a convenience function for code that uses aggregate return values
1110 /// as a vehicle for having multiple return values.
1111 ReturnInst *CreateAggregateRet(Value *const *retVals, unsigned N) {
1113 for (unsigned i = 0; i != N; ++i)
1114 V = CreateInsertValue(V, retVals[i], i, "mrv");
1115 return Insert(ReturnInst::Create(Context, V));
1116 }
1117
1118 /// Create an unconditional 'br label X' instruction.
1120 return Insert(BranchInst::Create(Dest));
1121 }
1122
1123 /// Create a conditional 'br Cond, TrueDest, FalseDest'
1124 /// instruction.
1126 MDNode *BranchWeights = nullptr,
1127 MDNode *Unpredictable = nullptr) {
1128 return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
1129 BranchWeights, Unpredictable));
1130 }
1131
1132 /// Create a conditional 'br Cond, TrueDest, FalseDest'
1133 /// instruction. Copy branch meta data if available.
1135 Instruction *MDSrc) {
1136 BranchInst *Br = BranchInst::Create(True, False, Cond);
1137 if (MDSrc) {
1138 unsigned WL[4] = {LLVMContext::MD_prof, LLVMContext::MD_unpredictable,
1139 LLVMContext::MD_make_implicit, LLVMContext::MD_dbg};
1140 Br->copyMetadata(*MDSrc, WL);
1141 }
1142 return Insert(Br);
1143 }
1144
1145 /// Create a switch instruction with the specified value, default dest,
1146 /// and with a hint for the number of cases that will be added (for efficient
1147 /// allocation).
1148 SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10,
1149 MDNode *BranchWeights = nullptr,
1150 MDNode *Unpredictable = nullptr) {
1151 return Insert(addBranchMetadata(SwitchInst::Create(V, Dest, NumCases),
1152 BranchWeights, Unpredictable));
1153 }
1154
1155 /// Create an indirect branch instruction with the specified address
1156 /// operand, with an optional hint for the number of destinations that will be
1157 /// added (for efficient allocation).
1158 IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) {
1159 return Insert(IndirectBrInst::Create(Addr, NumDests));
1160 }
1161
1162 /// Create an invoke instruction.
1164 BasicBlock *NormalDest, BasicBlock *UnwindDest,
1165 ArrayRef<Value *> Args,
1167 const Twine &Name = "") {
1168 InvokeInst *II =
1169 InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles);
1170 if (IsFPConstrained)
1172 return Insert(II, Name);
1173 }
1175 BasicBlock *NormalDest, BasicBlock *UnwindDest,
1176 ArrayRef<Value *> Args = std::nullopt,
1177 const Twine &Name = "") {
1178 InvokeInst *II =
1179 InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args);
1180 if (IsFPConstrained)
1182 return Insert(II, Name);
1183 }
1184
1186 BasicBlock *UnwindDest, ArrayRef<Value *> Args,
1188 const Twine &Name = "") {
1189 return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
1190 NormalDest, UnwindDest, Args, OpBundles, Name);
1191 }
1192
1194 BasicBlock *UnwindDest,
1195 ArrayRef<Value *> Args = std::nullopt,
1196 const Twine &Name = "") {
1197 return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
1198 NormalDest, UnwindDest, Args, Name);
1199 }
1200
1201 /// \brief Create a callbr instruction.
1203 BasicBlock *DefaultDest,
1204 ArrayRef<BasicBlock *> IndirectDests,
1205 ArrayRef<Value *> Args = std::nullopt,
1206 const Twine &Name = "") {
1207 return Insert(CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests,
1208 Args), Name);
1209 }
1211 BasicBlock *DefaultDest,
1212 ArrayRef<BasicBlock *> IndirectDests,
1213 ArrayRef<Value *> Args,
1215 const Twine &Name = "") {
1216 return Insert(
1217 CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests, Args,
1218 OpBundles), Name);
1219 }
1220
1222 ArrayRef<BasicBlock *> IndirectDests,
1223 ArrayRef<Value *> Args = std::nullopt,
1224 const Twine &Name = "") {
1225 return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
1226 DefaultDest, IndirectDests, Args, Name);
1227 }
1229 ArrayRef<BasicBlock *> IndirectDests,
1230 ArrayRef<Value *> Args,
1232 const Twine &Name = "") {
1233 return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
1234 DefaultDest, IndirectDests, Args, Name);
1235 }
1236
1238 return Insert(ResumeInst::Create(Exn));
1239 }
1240
1242 BasicBlock *UnwindBB = nullptr) {
1243 return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB));
1244 }
1245
1247 unsigned NumHandlers,
1248 const Twine &Name = "") {
1249 return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers),
1250 Name);
1251 }
1252
1254 const Twine &Name = "") {
1255 return Insert(CatchPadInst::Create(ParentPad, Args), Name);
1256 }
1257
1259 ArrayRef<Value *> Args = std::nullopt,
1260 const Twine &Name = "") {
1261 return Insert(CleanupPadInst::Create(ParentPad, Args), Name);
1262 }
1263
1265 return Insert(CatchReturnInst::Create(CatchPad, BB));
1266 }
1267
1269 return Insert(new UnreachableInst(Context));
1270 }
1271
1272 //===--------------------------------------------------------------------===//
1273 // Instruction creation methods: Binary Operators
1274 //===--------------------------------------------------------------------===//
1275private:
1276 BinaryOperator *CreateInsertNUWNSWBinOp(BinaryOperator::BinaryOps Opc,
1277 Value *LHS, Value *RHS,
1278 const Twine &Name,
1279 bool HasNUW, bool HasNSW) {
1281 if (HasNUW) BO->setHasNoUnsignedWrap();
1282 if (HasNSW) BO->setHasNoSignedWrap();
1283 return BO;
1284 }
1285
1286 Instruction *setFPAttrs(Instruction *I, MDNode *FPMD,
1287 FastMathFlags FMF) const {
1288 if (!FPMD)
1289 FPMD = DefaultFPMathTag;
1290 if (FPMD)
1291 I->setMetadata(LLVMContext::MD_fpmath, FPMD);
1292 I->setFastMathFlags(FMF);
1293 return I;
1294 }
1295
1296 Value *getConstrainedFPRounding(std::optional<RoundingMode> Rounding) {
1298
1299 if (Rounding)
1300 UseRounding = *Rounding;
1301
1302 std::optional<StringRef> RoundingStr =
1303 convertRoundingModeToStr(UseRounding);
1304 assert(RoundingStr && "Garbage strict rounding mode!");
1305 auto *RoundingMDS = MDString::get(Context, *RoundingStr);
1306
1307 return MetadataAsValue::get(Context, RoundingMDS);
1308 }
1309
1310 Value *getConstrainedFPExcept(std::optional<fp::ExceptionBehavior> Except) {
1311 std::optional<StringRef> ExceptStr = convertExceptionBehaviorToStr(
1312 Except.value_or(DefaultConstrainedExcept));
1313 assert(ExceptStr && "Garbage strict exception behavior!");
1314 auto *ExceptMDS = MDString::get(Context, *ExceptStr);
1315
1316 return MetadataAsValue::get(Context, ExceptMDS);
1317 }
1318
1319 Value *getConstrainedFPPredicate(CmpInst::Predicate Predicate) {
1320 assert(CmpInst::isFPPredicate(Predicate) &&
1321 Predicate != CmpInst::FCMP_FALSE &&
1322 Predicate != CmpInst::FCMP_TRUE &&
1323 "Invalid constrained FP comparison predicate!");
1324
1325 StringRef PredicateStr = CmpInst::getPredicateName(Predicate);
1326 auto *PredicateMDS = MDString::get(Context, PredicateStr);
1327
1328 return MetadataAsValue::get(Context, PredicateMDS);
1329 }
1330
1331public:
1333 bool HasNUW = false, bool HasNSW = false) {
1334 if (Value *V =
1335 Folder.FoldNoWrapBinOp(Instruction::Add, LHS, RHS, HasNUW, HasNSW))
1336 return V;
1337 return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name, HasNUW,
1338 HasNSW);
1339 }
1340
1342 return CreateAdd(LHS, RHS, Name, false, true);
1343 }
1344
1346 return CreateAdd(LHS, RHS, Name, true, false);
1347 }
1348
1350 bool HasNUW = false, bool HasNSW = false) {
1351 if (Value *V =
1352 Folder.FoldNoWrapBinOp(Instruction::Sub, LHS, RHS, HasNUW, HasNSW))
1353 return V;
1354 return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name, HasNUW,
1355 HasNSW);
1356 }
1357
1359 return CreateSub(LHS, RHS, Name, false, true);
1360 }
1361
1363 return CreateSub(LHS, RHS, Name, true, false);
1364 }
1365
1367 bool HasNUW = false, bool HasNSW = false) {
1368 if (Value *V =
1369 Folder.FoldNoWrapBinOp(Instruction::Mul, LHS, RHS, HasNUW, HasNSW))
1370 return V;
1371 return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name, HasNUW,
1372 HasNSW);
1373 }
1374
1376 return CreateMul(LHS, RHS, Name, false, true);
1377 }
1378
1380 return CreateMul(LHS, RHS, Name, true, false);
1381 }
1382
1384 bool isExact = false) {
1385 if (Value *V = Folder.FoldExactBinOp(Instruction::UDiv, LHS, RHS, isExact))
1386 return V;
1387 if (!isExact)
1388 return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
1389 return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name);
1390 }
1391
1393 return CreateUDiv(LHS, RHS, Name, true);
1394 }
1395
1397 bool isExact = false) {
1398 if (Value *V = Folder.FoldExactBinOp(Instruction::SDiv, LHS, RHS, isExact))
1399 return V;
1400 if (!isExact)
1401 return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
1402 return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
1403 }
1404
1406 return CreateSDiv(LHS, RHS, Name, true);
1407 }
1408
1410 if (Value *V = Folder.FoldBinOp(Instruction::URem, LHS, RHS))
1411 return V;
1412 return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
1413 }
1414
1416 if (Value *V = Folder.FoldBinOp(Instruction::SRem, LHS, RHS))
1417 return V;
1418 return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
1419 }
1420
1422 bool HasNUW = false, bool HasNSW = false) {
1423 if (Value *V =
1424 Folder.FoldNoWrapBinOp(Instruction::Shl, LHS, RHS, HasNUW, HasNSW))
1425 return V;
1426 return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name,
1427 HasNUW, HasNSW);
1428 }
1429
1430 Value *CreateShl(Value *LHS, const APInt &RHS, const Twine &Name = "",
1431 bool HasNUW = false, bool HasNSW = false) {
1432 return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1433 HasNUW, HasNSW);
1434 }
1435
1437 bool HasNUW = false, bool HasNSW = false) {
1438 return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1439 HasNUW, HasNSW);
1440 }
1441
1443 bool isExact = false) {
1444 if (Value *V = Folder.FoldExactBinOp(Instruction::LShr, LHS, RHS, isExact))
1445 return V;
1446 if (!isExact)
1447 return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
1448 return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
1449 }
1450
1451 Value *CreateLShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
1452 bool isExact = false) {
1453 return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1454 }
1455
1457 bool isExact = false) {
1458 return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1459 }
1460
1462 bool isExact = false) {
1463 if (Value *V = Folder.FoldExactBinOp(Instruction::AShr, LHS, RHS, isExact))
1464 return V;
1465 if (!isExact)
1466 return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
1467 return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name);
1468 }
1469
1470 Value *CreateAShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
1471 bool isExact = false) {
1472 return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1473 }
1474
1476 bool isExact = false) {
1477 return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1478 }
1479
1481 if (auto *V = Folder.FoldBinOp(Instruction::And, LHS, RHS))
1482 return V;
1483 return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
1484 }
1485
1486 Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1487 return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1488 }
1489
1491 return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1492 }
1493
1495 assert(!Ops.empty());
1496 Value *Accum = Ops[0];
1497 for (unsigned i = 1; i < Ops.size(); i++)
1498 Accum = CreateAnd(Accum, Ops[i]);
1499 return Accum;
1500 }
1501
1503 if (auto *V = Folder.FoldBinOp(Instruction::Or, LHS, RHS))
1504 return V;
1505 return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
1506 }
1507
1508 Value *CreateOr(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1509 return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1510 }
1511
1513 return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1514 }
1515
1517 assert(!Ops.empty());
1518 Value *Accum = Ops[0];
1519 for (unsigned i = 1; i < Ops.size(); i++)
1520 Accum = CreateOr(Accum, Ops[i]);
1521 return Accum;
1522 }
1523
1525 if (Value *V = Folder.FoldBinOp(Instruction::Xor, LHS, RHS))
1526 return V;
1527 return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
1528 }
1529
1530 Value *CreateXor(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1531 return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1532 }
1533
1535 return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1536 }
1537
1538 Value *CreateFAdd(Value *L, Value *R, const Twine &Name = "",
1539 MDNode *FPMD = nullptr) {
1540 if (IsFPConstrained)
1541 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1542 L, R, nullptr, Name, FPMD);
1543
1544 if (Value *V = Folder.FoldBinOpFMF(Instruction::FAdd, L, R, FMF))
1545 return V;
1546 Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
1547 return Insert(I, Name);
1548 }
1549
1550 /// Copy fast-math-flags from an instruction rather than using the builder's
1551 /// default FMF.
1553 const Twine &Name = "") {
1554 if (IsFPConstrained)
1555 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1556 L, R, FMFSource, Name);
1557
1558 FastMathFlags FMF = FMFSource->getFastMathFlags();
1559 if (Value *V = Folder.FoldBinOpFMF(Instruction::FAdd, L, R, FMF))
1560 return V;
1561 Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), nullptr, FMF);
1562 return Insert(I, Name);
1563 }
1564
1565 Value *CreateFSub(Value *L, Value *R, const Twine &Name = "",
1566 MDNode *FPMD = nullptr) {
1567 if (IsFPConstrained)
1568 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1569 L, R, nullptr, Name, FPMD);
1570
1571 if (Value *V = Folder.FoldBinOpFMF(Instruction::FSub, L, R, FMF))
1572 return V;
1573 Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF);
1574 return Insert(I, Name);
1575 }
1576
1577 /// Copy fast-math-flags from an instruction rather than using the builder's
1578 /// default FMF.
1580 const Twine &Name = "") {
1581 if (IsFPConstrained)
1582 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1583 L, R, FMFSource, Name);
1584
1585 FastMathFlags FMF = FMFSource->getFastMathFlags();
1586 if (Value *V = Folder.FoldBinOpFMF(Instruction::FSub, L, R, FMF))
1587 return V;
1588 Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), nullptr, FMF);
1589 return Insert(I, Name);
1590 }
1591
1592 Value *CreateFMul(Value *L, Value *R, const Twine &Name = "",
1593 MDNode *FPMD = nullptr) {
1594 if (IsFPConstrained)
1595 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1596 L, R, nullptr, Name, FPMD);
1597
1598 if (Value *V = Folder.FoldBinOpFMF(Instruction::FMul, L, R, FMF))
1599 return V;
1600 Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF);
1601 return Insert(I, Name);
1602 }
1603
1604 /// Copy fast-math-flags from an instruction rather than using the builder's
1605 /// default FMF.
1607 const Twine &Name = "") {
1608 if (IsFPConstrained)
1609 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1610 L, R, FMFSource, Name);
1611
1612 FastMathFlags FMF = FMFSource->getFastMathFlags();
1613 if (Value *V = Folder.FoldBinOpFMF(Instruction::FMul, L, R, FMF))
1614 return V;
1615 Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), nullptr, FMF);
1616 return Insert(I, Name);
1617 }
1618
1619 Value *CreateFDiv(Value *L, Value *R, const Twine &Name = "",
1620 MDNode *FPMD = nullptr) {
1621 if (IsFPConstrained)
1622 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
1623 L, R, nullptr, Name, FPMD);
1624
1625 if (Value *V = Folder.FoldBinOpFMF(Instruction::FDiv, L, R, FMF))
1626 return V;
1627 Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF);
1628 return Insert(I, Name);
1629 }
1630
1631 /// Copy fast-math-flags from an instruction rather than using the builder's
1632 /// default FMF.
1634 const Twine &Name = "") {
1635 if (IsFPConstrained)
1636 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
1637 L, R, FMFSource, Name);
1638
1639 FastMathFlags FMF = FMFSource->getFastMathFlags();
1640 if (Value *V = Folder.FoldBinOpFMF(Instruction::FDiv, L, R, FMF))
1641 return V;
1642 Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), nullptr, FMF);
1643 return Insert(I, Name);
1644 }
1645
1646 Value *CreateFRem(Value *L, Value *R, const Twine &Name = "",
1647 MDNode *FPMD = nullptr) {
1648 if (IsFPConstrained)
1649 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
1650 L, R, nullptr, Name, FPMD);
1651
1652 if (Value *V = Folder.FoldBinOpFMF(Instruction::FRem, L, R, FMF)) return V;
1653 Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMF);
1654 return Insert(I, Name);
1655 }
1656
1657 /// Copy fast-math-flags from an instruction rather than using the builder's
1658 /// default FMF.
1660 const Twine &Name = "") {
1661 if (IsFPConstrained)
1662 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
1663 L, R, FMFSource, Name);
1664
1665 FastMathFlags FMF = FMFSource->getFastMathFlags();
1666 if (Value *V = Folder.FoldBinOpFMF(Instruction::FRem, L, R, FMF)) return V;
1667 Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), nullptr, FMF);
1668 return Insert(I, Name);
1669 }
1670
1672 Value *LHS, Value *RHS, const Twine &Name = "",
1673 MDNode *FPMathTag = nullptr) {
1674 if (Value *V = Folder.FoldBinOp(Opc, LHS, RHS)) return V;
1675 Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
1676 if (isa<FPMathOperator>(BinOp))
1677 setFPAttrs(BinOp, FPMathTag, FMF);
1678 return Insert(BinOp, Name);
1679 }
1680
1681 Value *CreateLogicalAnd(Value *Cond1, Value *Cond2, const Twine &Name = "") {
1682 assert(Cond2->getType()->isIntOrIntVectorTy(1));
1683 return CreateSelect(Cond1, Cond2,
1685 }
1686
1687 Value *CreateLogicalOr(Value *Cond1, Value *Cond2, const Twine &Name = "") {
1688 assert(Cond2->getType()->isIntOrIntVectorTy(1));
1689 return CreateSelect(Cond1, ConstantInt::getAllOnesValue(Cond2->getType()),
1690 Cond2, Name);
1691 }
1692
1694 const Twine &Name = "") {
1695 switch (Opc) {
1696 case Instruction::And:
1697 return CreateLogicalAnd(Cond1, Cond2, Name);
1698 case Instruction::Or:
1699 return CreateLogicalOr(Cond1, Cond2, Name);
1700 default:
1701 break;
1702 }
1703 llvm_unreachable("Not a logical operation.");
1704 }
1705
1706 // NOTE: this is sequential, non-commutative, ordered reduction!
1708 assert(!Ops.empty());
1709 Value *Accum = Ops[0];
1710 for (unsigned i = 1; i < Ops.size(); i++)
1711 Accum = CreateLogicalOr(Accum, Ops[i]);
1712 return Accum;
1713 }
1714
1716 Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource = nullptr,
1717 const Twine &Name = "", MDNode *FPMathTag = nullptr,
1718 std::optional<RoundingMode> Rounding = std::nullopt,
1719 std::optional<fp::ExceptionBehavior> Except = std::nullopt);
1720
1722 Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource = nullptr,
1723 const Twine &Name = "", MDNode *FPMathTag = nullptr,
1724 std::optional<fp::ExceptionBehavior> Except = std::nullopt);
1725
1726 Value *CreateNeg(Value *V, const Twine &Name = "", bool HasNSW = false) {
1727 return CreateSub(Constant::getNullValue(V->getType()), V, Name,
1728 /*HasNUW=*/0, HasNSW);
1729 }
1730
1731 Value *CreateNSWNeg(Value *V, const Twine &Name = "") {
1732 return CreateNeg(V, Name, /*HasNSW=*/true);
1733 }
1734
1735 Value *CreateFNeg(Value *V, const Twine &Name = "",
1736 MDNode *FPMathTag = nullptr) {
1737 if (Value *Res = Folder.FoldUnOpFMF(Instruction::FNeg, V, FMF))
1738 return Res;
1739 return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), FPMathTag, FMF),
1740 Name);
1741 }
1742
1743 /// Copy fast-math-flags from an instruction rather than using the builder's
1744 /// default FMF.
1746 const Twine &Name = "") {
1747 FastMathFlags FMF = FMFSource->getFastMathFlags();
1748 if (Value *Res = Folder.FoldUnOpFMF(Instruction::FNeg, V, FMF))
1749 return Res;
1750 return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), nullptr, FMF),
1751 Name);
1752 }
1753
1754 Value *CreateNot(Value *V, const Twine &Name = "") {
1755 return CreateXor(V, Constant::getAllOnesValue(V->getType()), Name);
1756 }
1757
1759 Value *V, const Twine &Name = "",
1760 MDNode *FPMathTag = nullptr) {
1761 if (Value *Res = Folder.FoldUnOpFMF(Opc, V, FMF))
1762 return Res;
1763 Instruction *UnOp = UnaryOperator::Create(Opc, V);
1764 if (isa<FPMathOperator>(UnOp))
1765 setFPAttrs(UnOp, FPMathTag, FMF);
1766 return Insert(UnOp, Name);
1767 }
1768
1769 /// Create either a UnaryOperator or BinaryOperator depending on \p Opc.
1770 /// Correct number of operands must be passed accordingly.
1771 Value *CreateNAryOp(unsigned Opc, ArrayRef<Value *> Ops,
1772 const Twine &Name = "", MDNode *FPMathTag = nullptr);
1773
1774 //===--------------------------------------------------------------------===//
1775 // Instruction creation methods: Memory Instructions
1776 //===--------------------------------------------------------------------===//
1777
1778 AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace,
1779 Value *ArraySize = nullptr, const Twine &Name = "") {
1780 const DataLayout &DL = BB->getDataLayout();
1781 Align AllocaAlign = DL.getPrefTypeAlign(Ty);
1782 return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name);
1783 }
1784
1785 AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = nullptr,
1786 const Twine &Name = "") {
1787 const DataLayout &DL = BB->getDataLayout();
1788 Align AllocaAlign = DL.getPrefTypeAlign(Ty);
1789 unsigned AddrSpace = DL.getAllocaAddrSpace();
1790 return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name);
1791 }
1792
1793 /// Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of
1794 /// converting the string to 'bool' for the isVolatile parameter.
1795 LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
1796 return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name);
1797 }
1798
1799 LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1800 return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name);
1801 }
1802
1803 LoadInst *CreateLoad(Type *Ty, Value *Ptr, bool isVolatile,
1804 const Twine &Name = "") {
1805 return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), isVolatile, Name);
1806 }
1807
1808 StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
1809 return CreateAlignedStore(Val, Ptr, MaybeAlign(), isVolatile);
1810 }
1811
1813 const char *Name) {
1814 return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
1815 }
1816
1818 const Twine &Name = "") {
1819 return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
1820 }
1821
1823 bool isVolatile, const Twine &Name = "") {
1824 if (!Align) {
1825 const DataLayout &DL = BB->getDataLayout();
1826 Align = DL.getABITypeAlign(Ty);
1827 }
1828 return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile, *Align), Name);
1829 }
1830
1832 bool isVolatile = false) {
1833 if (!Align) {
1834 const DataLayout &DL = BB->getDataLayout();
1835 Align = DL.getABITypeAlign(Val->getType());
1836 }
1837 return Insert(new StoreInst(Val, Ptr, isVolatile, *Align));
1838 }
1841 const Twine &Name = "") {
1842 return Insert(new FenceInst(Context, Ordering, SSID), Name);
1843 }
1844
1847 AtomicOrdering SuccessOrdering,
1848 AtomicOrdering FailureOrdering,
1850 if (!Align) {
1851 const DataLayout &DL = BB->getDataLayout();
1852 Align = llvm::Align(DL.getTypeStoreSize(New->getType()));
1853 }
1854
1855 return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, *Align, SuccessOrdering,
1856 FailureOrdering, SSID));
1857 }
1858
1860 Value *Val, MaybeAlign Align,
1861 AtomicOrdering Ordering,
1863 if (!Align) {
1864 const DataLayout &DL = BB->getDataLayout();
1865 Align = llvm::Align(DL.getTypeStoreSize(Val->getType()));
1866 }
1867
1868 return Insert(new AtomicRMWInst(Op, Ptr, Val, *Align, Ordering, SSID));
1869 }
1870
1872 const Twine &Name = "",
1874 if (auto *V = Folder.FoldGEP(Ty, Ptr, IdxList, NW))
1875 return V;
1876 return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList, NW), Name);
1877 }
1878
1880 const Twine &Name = "") {
1881 return CreateGEP(Ty, Ptr, IdxList, Name, GEPNoWrapFlags::inBounds());
1882 }
1883
1884 Value *CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1885 const Twine &Name = "") {
1886 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1887
1888 if (auto *V = Folder.FoldGEP(Ty, Ptr, Idx, GEPNoWrapFlags::none()))
1889 return V;
1890
1892 }
1893
1895 const Twine &Name = "") {
1896 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1897
1898 if (auto *V = Folder.FoldGEP(Ty, Ptr, Idx, GEPNoWrapFlags::inBounds()))
1899 return V;
1900
1902 }
1903
1904 Value *CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1,
1905 const Twine &Name = "") {
1906 Value *Idxs[] = {
1907 ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1908 ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1909 };
1910
1911 if (auto *V = Folder.FoldGEP(Ty, Ptr, Idxs, GEPNoWrapFlags::none()))
1912 return V;
1913
1914 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1915 }
1916
1918 unsigned Idx1, 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, GEPNoWrapFlags::inBounds()))
1925 return V;
1926
1928 }
1929
1931 const Twine &Name = "") {
1932 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1933
1934 if (auto *V = Folder.FoldGEP(Ty, Ptr, Idx, GEPNoWrapFlags::none()))
1935 return V;
1936
1938 }
1939
1941 const Twine &Name = "") {
1942 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1943
1944 if (auto *V = Folder.FoldGEP(Ty, Ptr, Idx, GEPNoWrapFlags::inBounds()))
1945 return V;
1946
1948 }
1949
1951 const Twine &Name = "") {
1952 Value *Idxs[] = {
1953 ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1954 ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1955 };
1956
1957 if (auto *V = Folder.FoldGEP(Ty, Ptr, Idxs, GEPNoWrapFlags::none()))
1958 return V;
1959
1960 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1961 }
1962
1964 uint64_t Idx1, 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::inBounds()))
1971 return V;
1972
1974 }
1975
1977 const Twine &Name = "") {
1978 return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name);
1979 }
1980
1983 return CreateGEP(getInt8Ty(), Ptr, Offset, Name, NW);
1984 }
1985
1987 const Twine &Name = "") {
1988 return CreateGEP(getInt8Ty(), Ptr, Offset, Name,
1990 }
1991
1992 /// Same as CreateGlobalString, but return a pointer with "i8*" type
1993 /// instead of a pointer to array of i8.
1994 ///
1995 /// If no module is given via \p M, it is take from the insertion point basic
1996 /// block.
1998 unsigned AddressSpace = 0,
1999 Module *M = nullptr, bool AddNull = true) {
2000 GlobalVariable *GV =
2001 CreateGlobalString(Str, Name, AddressSpace, M, AddNull);
2002 Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
2003 Constant *Indices[] = {Zero, Zero};
2005 Indices);
2006 }
2007
2008 //===--------------------------------------------------------------------===//
2009 // Instruction creation methods: Cast/Conversion Operators
2010 //===--------------------------------------------------------------------===//
2011
2012 Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "",
2013 bool IsNUW = false, bool IsNSW = false) {
2014 if (V->getType() == DestTy)
2015 return V;
2016 if (Value *Folded = Folder.FoldCast(Instruction::Trunc, V, DestTy))
2017 return Folded;
2018 Instruction *I = CastInst::Create(Instruction::Trunc, V, DestTy);
2019 if (IsNUW)
2020 I->setHasNoUnsignedWrap();
2021 if (IsNSW)
2022 I->setHasNoSignedWrap();
2023 return Insert(I, Name);
2024 }
2025
2026 Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "",
2027 bool IsNonNeg = false) {
2028 if (V->getType() == DestTy)
2029 return V;
2030 if (Value *Folded = Folder.FoldCast(Instruction::ZExt, V, DestTy))
2031 return Folded;
2032 Instruction *I = Insert(new ZExtInst(V, DestTy), Name);
2033 if (IsNonNeg)
2034 I->setNonNeg();
2035 return I;
2036 }
2037
2038 Value *CreateSExt(Value *V, Type *DestTy, const Twine &Name = "") {
2039 return CreateCast(Instruction::SExt, V, DestTy, Name);
2040 }
2041
2042 /// Create a ZExt or Trunc from the integer value V to DestTy. Return
2043 /// the value untouched if the type of V is already DestTy.
2045 const Twine &Name = "") {
2046 assert(V->getType()->isIntOrIntVectorTy() &&
2047 DestTy->isIntOrIntVectorTy() &&
2048 "Can only zero extend/truncate integers!");
2049 Type *VTy = V->getType();
2050 if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
2051 return CreateZExt(V, DestTy, Name);
2052 if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
2053 return CreateTrunc(V, DestTy, Name);
2054 return V;
2055 }
2056
2057 /// Create a SExt 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 sign extend/truncate integers!");
2064 Type *VTy = V->getType();
2065 if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
2066 return CreateSExt(V, DestTy, Name);
2067 if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
2068 return CreateTrunc(V, DestTy, Name);
2069 return V;
2070 }
2071
2072 Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = "") {
2073 if (IsFPConstrained)
2074 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptoui,
2075 V, DestTy, nullptr, Name);
2076 return CreateCast(Instruction::FPToUI, V, DestTy, Name);
2077 }
2078
2079 Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = "") {
2080 if (IsFPConstrained)
2081 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptosi,
2082 V, DestTy, nullptr, Name);
2083 return CreateCast(Instruction::FPToSI, V, DestTy, Name);
2084 }
2085
2086 Value *CreateUIToFP(Value *V, Type *DestTy, const Twine &Name = "",
2087 bool IsNonNeg = false) {
2088 if (IsFPConstrained)
2089 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_uitofp,
2090 V, DestTy, nullptr, Name);
2091 if (Value *Folded = Folder.FoldCast(Instruction::UIToFP, V, DestTy))
2092 return Folded;
2093 Instruction *I = Insert(new UIToFPInst(V, DestTy), Name);
2094 if (IsNonNeg)
2095 I->setNonNeg();
2096 return I;
2097 }
2098
2099 Value *CreateSIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
2100 if (IsFPConstrained)
2101 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_sitofp,
2102 V, DestTy, nullptr, Name);
2103 return CreateCast(Instruction::SIToFP, V, DestTy, Name);
2104 }
2105
2107 const Twine &Name = "") {
2108 if (IsFPConstrained)
2110 Intrinsic::experimental_constrained_fptrunc, V, DestTy, nullptr,
2111 Name);
2112 return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
2113 }
2114
2115 Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "") {
2116 if (IsFPConstrained)
2117 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fpext,
2118 V, DestTy, nullptr, Name);
2119 return CreateCast(Instruction::FPExt, V, DestTy, Name);
2120 }
2121
2123 const Twine &Name = "") {
2124 return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
2125 }
2126
2128 const Twine &Name = "") {
2129 return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
2130 }
2131
2133 const Twine &Name = "") {
2134 return CreateCast(Instruction::BitCast, V, DestTy, Name);
2135 }
2136
2138 const Twine &Name = "") {
2139 return CreateCast(Instruction::AddrSpaceCast, V, DestTy, Name);
2140 }
2141
2142 Value *CreateZExtOrBitCast(Value *V, Type *DestTy, const Twine &Name = "") {
2143 Instruction::CastOps CastOp =
2144 V->getType()->getScalarSizeInBits() == DestTy->getScalarSizeInBits()
2145 ? Instruction::BitCast
2146 : Instruction::ZExt;
2147 return CreateCast(CastOp, V, DestTy, Name);
2148 }
2149
2150 Value *CreateSExtOrBitCast(Value *V, Type *DestTy, const Twine &Name = "") {
2151 Instruction::CastOps CastOp =
2152 V->getType()->getScalarSizeInBits() == DestTy->getScalarSizeInBits()
2153 ? Instruction::BitCast
2154 : Instruction::SExt;
2155 return CreateCast(CastOp, V, DestTy, Name);
2156 }
2157
2158 Value *CreateTruncOrBitCast(Value *V, Type *DestTy, const Twine &Name = "") {
2159 Instruction::CastOps CastOp =
2160 V->getType()->getScalarSizeInBits() == DestTy->getScalarSizeInBits()
2161 ? Instruction::BitCast
2162 : Instruction::Trunc;
2163 return CreateCast(CastOp, V, DestTy, Name);
2164 }
2165
2167 const Twine &Name = "") {
2168 if (V->getType() == DestTy)
2169 return V;
2170 if (Value *Folded = Folder.FoldCast(Op, V, DestTy))
2171 return Folded;
2172 return Insert(CastInst::Create(Op, V, DestTy), Name);
2173 }
2174
2176 const Twine &Name = "") {
2177 if (V->getType() == DestTy)
2178 return V;
2179 if (auto *VC = dyn_cast<Constant>(V))
2180 return Insert(Folder.CreatePointerCast(VC, DestTy), Name);
2181 return Insert(CastInst::CreatePointerCast(V, DestTy), Name);
2182 }
2183
2184 // With opaque pointers enabled, this can be substituted with
2185 // CreateAddrSpaceCast.
2186 // TODO: Replace uses of this method and remove the method itself.
2188 const Twine &Name = "") {
2189 if (V->getType() == DestTy)
2190 return V;
2191
2192 if (auto *VC = dyn_cast<Constant>(V)) {
2194 Name);
2195 }
2196
2198 Name);
2199 }
2200
2202 const Twine &Name = "") {
2203 Instruction::CastOps CastOp =
2204 V->getType()->getScalarSizeInBits() > DestTy->getScalarSizeInBits()
2205 ? Instruction::Trunc
2206 : (isSigned ? Instruction::SExt : Instruction::ZExt);
2207 return CreateCast(CastOp, V, DestTy, Name);
2208 }
2209
2211 const Twine &Name = "") {
2212 if (V->getType() == DestTy)
2213 return V;
2214 if (V->getType()->isPtrOrPtrVectorTy() && DestTy->isIntOrIntVectorTy())
2215 return CreatePtrToInt(V, DestTy, Name);
2216 if (V->getType()->isIntOrIntVectorTy() && DestTy->isPtrOrPtrVectorTy())
2217 return CreateIntToPtr(V, DestTy, Name);
2218
2219 return CreateBitCast(V, DestTy, Name);
2220 }
2221
2222 Value *CreateFPCast(Value *V, Type *DestTy, const Twine &Name = "") {
2223 Instruction::CastOps CastOp =
2224 V->getType()->getScalarSizeInBits() > DestTy->getScalarSizeInBits()
2225 ? Instruction::FPTrunc
2226 : Instruction::FPExt;
2227 return CreateCast(CastOp, V, DestTy, Name);
2228 }
2229
2231 Intrinsic::ID ID, Value *V, Type *DestTy,
2232 Instruction *FMFSource = nullptr, const Twine &Name = "",
2233 MDNode *FPMathTag = nullptr,
2234 std::optional<RoundingMode> Rounding = std::nullopt,
2235 std::optional<fp::ExceptionBehavior> Except = std::nullopt);
2236
2237 // Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a
2238 // compile time error, instead of converting the string to bool for the
2239 // isSigned parameter.
2240 Value *CreateIntCast(Value *, Type *, const char *) = delete;
2241
2242 //===--------------------------------------------------------------------===//
2243 // Instruction creation methods: Compare Instructions
2244 //===--------------------------------------------------------------------===//
2245
2248 }
2249
2252 }
2253
2256 }
2257
2260 }
2261
2264 }
2265
2268 }
2269
2272 }
2273
2276 }
2277
2280 }
2281
2284 }
2285
2287 MDNode *FPMathTag = nullptr) {
2288 return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name, FPMathTag);
2289 }
2290
2292 MDNode *FPMathTag = nullptr) {
2293 return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name, FPMathTag);
2294 }
2295
2297 MDNode *FPMathTag = nullptr) {
2298 return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name, FPMathTag);
2299 }
2300
2302 MDNode *FPMathTag = nullptr) {
2303 return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name, FPMathTag);
2304 }
2305
2307 MDNode *FPMathTag = nullptr) {
2308 return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name, FPMathTag);
2309 }
2310
2312 MDNode *FPMathTag = nullptr) {
2313 return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name, FPMathTag);
2314 }
2315
2317 MDNode *FPMathTag = nullptr) {
2318 return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name, FPMathTag);
2319 }
2320
2322 MDNode *FPMathTag = nullptr) {
2323 return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name, FPMathTag);
2324 }
2325
2327 MDNode *FPMathTag = nullptr) {
2328 return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name, FPMathTag);
2329 }
2330
2332 MDNode *FPMathTag = nullptr) {
2333 return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name, FPMathTag);
2334 }
2335
2337 MDNode *FPMathTag = nullptr) {
2338 return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name, FPMathTag);
2339 }
2340
2342 MDNode *FPMathTag = nullptr) {
2343 return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name, FPMathTag);
2344 }
2345
2347 MDNode *FPMathTag = nullptr) {
2348 return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name, FPMathTag);
2349 }
2350
2352 MDNode *FPMathTag = nullptr) {
2353 return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name, FPMathTag);
2354 }
2355
2357 const Twine &Name = "") {
2358 if (auto *V = Folder.FoldCmp(P, LHS, RHS))
2359 return V;
2360 return Insert(new ICmpInst(P, LHS, RHS), Name);
2361 }
2362
2363 // Create a quiet floating-point comparison (i.e. one that raises an FP
2364 // exception only in the case where an input is a signaling NaN).
2365 // Note that this differs from CreateFCmpS only if IsFPConstrained is true.
2367 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2368 return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, false);
2369 }
2370
2372 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2373 return CmpInst::isFPPredicate(Pred)
2374 ? CreateFCmp(Pred, LHS, RHS, Name, FPMathTag)
2375 : CreateICmp(Pred, LHS, RHS, Name);
2376 }
2377
2378 // Create a signaling floating-point comparison (i.e. one that raises an FP
2379 // exception whenever an input is any NaN, signaling or quiet).
2380 // Note that this differs from CreateFCmp only if IsFPConstrained is true.
2382 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2383 return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, true);
2384 }
2385
2386private:
2387 // Helper routine to create either a signaling or a quiet FP comparison.
2388 Value *CreateFCmpHelper(CmpInst::Predicate P, Value *LHS, Value *RHS,
2389 const Twine &Name, MDNode *FPMathTag,
2390 bool IsSignaling);
2391
2392public:
2395 const Twine &Name = "",
2396 std::optional<fp::ExceptionBehavior> Except = std::nullopt);
2397
2398 //===--------------------------------------------------------------------===//
2399 // Instruction creation methods: Other Instructions
2400 //===--------------------------------------------------------------------===//
2401
2402 PHINode *CreatePHI(Type *Ty, unsigned NumReservedValues,
2403 const Twine &Name = "") {
2404 PHINode *Phi = PHINode::Create(Ty, NumReservedValues);
2405 if (isa<FPMathOperator>(Phi))
2406 setFPAttrs(Phi, nullptr /* MDNode* */, FMF);
2407 return Insert(Phi, Name);
2408 }
2409
2410private:
2411 CallInst *createCallHelper(Function *Callee, ArrayRef<Value *> Ops,
2412 const Twine &Name = "",
2413 Instruction *FMFSource = nullptr,
2414 ArrayRef<OperandBundleDef> OpBundles = {});
2415
2416public:
2418 ArrayRef<Value *> Args = std::nullopt,
2419 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2420 CallInst *CI = CallInst::Create(FTy, Callee, Args, DefaultOperandBundles);
2421 if (IsFPConstrained)
2423 if (isa<FPMathOperator>(CI))
2424 setFPAttrs(CI, FPMathTag, FMF);
2425 return Insert(CI, Name);
2426 }
2427
2430 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2431 CallInst *CI = CallInst::Create(FTy, Callee, Args, OpBundles);
2432 if (IsFPConstrained)
2434 if (isa<FPMathOperator>(CI))
2435 setFPAttrs(CI, FPMathTag, FMF);
2436 return Insert(CI, Name);
2437 }
2438
2440 ArrayRef<Value *> Args = std::nullopt,
2441 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2442 return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args, Name,
2443 FPMathTag);
2444 }
2445
2448 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2449 return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args,
2450 OpBundles, Name, FPMathTag);
2451 }
2452
2454 Function *Callee, ArrayRef<Value *> Args, const Twine &Name = "",
2455 std::optional<RoundingMode> Rounding = std::nullopt,
2456 std::optional<fp::ExceptionBehavior> Except = std::nullopt);
2457
2458 Value *CreateSelect(Value *C, Value *True, Value *False,
2459 const Twine &Name = "", Instruction *MDFrom = nullptr);
2460
2462 return Insert(new VAArgInst(List, Ty), Name);
2463 }
2464
2466 const Twine &Name = "") {
2467 if (Value *V = Folder.FoldExtractElement(Vec, Idx))
2468 return V;
2470 }
2471
2473 const Twine &Name = "") {
2474 return CreateExtractElement(Vec, getInt64(Idx), Name);
2475 }
2476
2478 const Twine &Name = "") {
2479 return CreateInsertElement(PoisonValue::get(VecTy), NewElt, Idx, Name);
2480 }
2481
2483 const Twine &Name = "") {
2484 return CreateInsertElement(PoisonValue::get(VecTy), NewElt, Idx, Name);
2485 }
2486
2488 const Twine &Name = "") {
2489 if (Value *V = Folder.FoldInsertElement(Vec, NewElt, Idx))
2490 return V;
2491 return Insert(InsertElementInst::Create(Vec, NewElt, Idx), Name);
2492 }
2493
2495 const Twine &Name = "") {
2496 return CreateInsertElement(Vec, NewElt, getInt64(Idx), Name);
2497 }
2498
2500 const Twine &Name = "") {
2501 SmallVector<int, 16> IntMask;
2502 ShuffleVectorInst::getShuffleMask(cast<Constant>(Mask), IntMask);
2503 return CreateShuffleVector(V1, V2, IntMask, Name);
2504 }
2505
2506 /// See class ShuffleVectorInst for a description of the mask representation.
2508 const Twine &Name = "") {
2509 if (Value *V = Folder.FoldShuffleVector(V1, V2, Mask))
2510 return V;
2511 return Insert(new ShuffleVectorInst(V1, V2, Mask), Name);
2512 }
2513
2514 /// Create a unary shuffle. The second vector operand of the IR instruction
2515 /// is poison.
2517 const Twine &Name = "") {
2518 return CreateShuffleVector(V, PoisonValue::get(V->getType()), Mask, Name);
2519 }
2520
2522 const Twine &Name = "") {
2523 if (auto *V = Folder.FoldExtractValue(Agg, Idxs))
2524 return V;
2525 return Insert(ExtractValueInst::Create(Agg, Idxs), Name);
2526 }
2527
2529 const Twine &Name = "") {
2530 if (auto *V = Folder.FoldInsertValue(Agg, Val, Idxs))
2531 return V;
2532 return Insert(InsertValueInst::Create(Agg, Val, Idxs), Name);
2533 }
2534
2535 LandingPadInst *CreateLandingPad(Type *Ty, unsigned NumClauses,
2536 const Twine &Name = "") {
2537 return Insert(LandingPadInst::Create(Ty, NumClauses), Name);
2538 }
2539
2540 Value *CreateFreeze(Value *V, const Twine &Name = "") {
2541 return Insert(new FreezeInst(V), Name);
2542 }
2543
2544 //===--------------------------------------------------------------------===//
2545 // Utility creation methods
2546 //===--------------------------------------------------------------------===//
2547
2548 /// Return a boolean value testing if \p Arg == 0.
2549 Value *CreateIsNull(Value *Arg, const Twine &Name = "") {
2550 return CreateICmpEQ(Arg, Constant::getNullValue(Arg->getType()), Name);
2551 }
2552
2553 /// Return a boolean value testing if \p Arg != 0.
2554 Value *CreateIsNotNull(Value *Arg, const Twine &Name = "") {
2555 return CreateICmpNE(Arg, Constant::getNullValue(Arg->getType()), Name);
2556 }
2557
2558 /// Return a boolean value testing if \p Arg < 0.
2559 Value *CreateIsNeg(Value *Arg, const Twine &Name = "") {
2561 }
2562
2563 /// Return a boolean value testing if \p Arg > -1.
2564 Value *CreateIsNotNeg(Value *Arg, const Twine &Name = "") {
2566 Name);
2567 }
2568
2569 /// Return the i64 difference between two pointer values, dividing out
2570 /// the size of the pointed-to objects.
2571 ///
2572 /// This is intended to implement C-style pointer subtraction. As such, the
2573 /// pointers must be appropriately aligned for their element types and
2574 /// pointing into the same object.
2575 Value *CreatePtrDiff(Type *ElemTy, Value *LHS, Value *RHS,
2576 const Twine &Name = "");
2577
2578 /// Create a launder.invariant.group intrinsic call. If Ptr type is
2579 /// different from pointer to i8, it's casted to pointer to i8 in the same
2580 /// address space before call and casted back to Ptr type after call.
2582
2583 /// \brief Create a strip.invariant.group intrinsic call. If Ptr type is
2584 /// different from pointer to i8, it's casted to pointer to i8 in the same
2585 /// address space before call and casted back to Ptr type after call.
2587
2588 /// Return a vector value that contains the vector V reversed
2589 Value *CreateVectorReverse(Value *V, const Twine &Name = "");
2590
2591 /// Return a vector splice intrinsic if using scalable vectors, otherwise
2592 /// return a shufflevector. If the immediate is positive, a vector is
2593 /// extracted from concat(V1, V2), starting at Imm. If the immediate
2594 /// is negative, we extract -Imm elements from V1 and the remaining
2595 /// elements from V2. Imm is a signed integer in the range
2596 /// -VL <= Imm < VL (where VL is the runtime vector length of the
2597 /// source/result vector)
2598 Value *CreateVectorSplice(Value *V1, Value *V2, int64_t Imm,
2599 const Twine &Name = "");
2600
2601 /// Return a vector value that contains \arg V broadcasted to \p
2602 /// NumElts elements.
2603 Value *CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name = "");
2604
2605 /// Return a vector value that contains \arg V broadcasted to \p
2606 /// EC elements.
2607 Value *CreateVectorSplat(ElementCount EC, Value *V, const Twine &Name = "");
2608
2610 unsigned Dimension, unsigned LastIndex,
2611 MDNode *DbgInfo);
2612
2613 Value *CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex,
2614 MDNode *DbgInfo);
2615
2617 unsigned Index, unsigned FieldIndex,
2618 MDNode *DbgInfo);
2619
2620 Value *createIsFPClass(Value *FPNum, unsigned Test);
2621
2622private:
2623 /// Helper function that creates an assume intrinsic call that
2624 /// represents an alignment assumption on the provided pointer \p PtrValue
2625 /// with offset \p OffsetValue and alignment value \p AlignValue.
2626 CallInst *CreateAlignmentAssumptionHelper(const DataLayout &DL,
2627 Value *PtrValue, Value *AlignValue,
2628 Value *OffsetValue);
2629
2630public:
2631 /// Create an assume intrinsic call that represents an alignment
2632 /// assumption on the provided pointer.
2633 ///
2634 /// An optional offset can be provided, and if it is provided, the offset
2635 /// must be subtracted from the provided pointer to get the pointer with the
2636 /// specified alignment.
2638 unsigned Alignment,
2639 Value *OffsetValue = nullptr);
2640
2641 /// Create an assume intrinsic call that represents an alignment
2642 /// assumption on the provided pointer.
2643 ///
2644 /// An optional offset can be provided, and if it is provided, the offset
2645 /// must be subtracted from the provided pointer to get the pointer with the
2646 /// specified alignment.
2647 ///
2648 /// This overload handles the condition where the Alignment is dependent
2649 /// on an existing value rather than a static value.
2651 Value *Alignment,
2652 Value *OffsetValue = nullptr);
2653};
2654
2655/// This provides a uniform API for creating instructions and inserting
2656/// them into a basic block: either at the end of a BasicBlock, or at a specific
2657/// iterator location in a block.
2658///
2659/// Note that the builder does not expose the full generality of LLVM
2660/// instructions. For access to extra instruction properties, use the mutators
2661/// (e.g. setVolatile) on the instructions after they have been
2662/// created. Convenience state exists to specify fast-math flags and fp-math
2663/// tags.
2664///
2665/// The first template argument specifies a class to use for creating constants.
2666/// This defaults to creating minimally folded constants. The second template
2667/// argument allows clients to specify custom insertion hooks that are called on
2668/// every newly created insertion.
2669template <typename FolderTy = ConstantFolder,
2670 typename InserterTy = IRBuilderDefaultInserter>
2671class IRBuilder : public IRBuilderBase {
2672private:
2673 FolderTy Folder;
2674 InserterTy Inserter;
2675
2676public:
2677 IRBuilder(LLVMContext &C, FolderTy Folder, InserterTy Inserter = InserterTy(),
2678 MDNode *FPMathTag = nullptr,
2679 ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2680 : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles),
2681 Folder(Folder), Inserter(Inserter) {}
2682
2683 explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
2684 ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2685 : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles) {}
2686
2687 explicit IRBuilder(BasicBlock *TheBB, FolderTy Folder,
2688 MDNode *FPMathTag = nullptr,
2689 ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2690 : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
2691 FPMathTag, OpBundles),
2692 Folder(Folder) {
2693 SetInsertPoint(TheBB);
2694 }
2695
2696 explicit IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag = nullptr,
2697 ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2698 : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
2699 FPMathTag, OpBundles) {
2700 SetInsertPoint(TheBB);
2701 }
2702
2703 explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr,
2704 ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2705 : IRBuilderBase(IP->getContext(), this->Folder, this->Inserter, FPMathTag,
2706 OpBundles) {
2707 SetInsertPoint(IP);
2708 }
2709
2710 IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, FolderTy Folder,
2711 MDNode *FPMathTag = nullptr,
2712 ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2713 : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
2714 FPMathTag, OpBundles),
2715 Folder(Folder) {
2716 SetInsertPoint(TheBB, IP);
2717 }
2718
2720 MDNode *FPMathTag = nullptr,
2721 ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2722 : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
2723 FPMathTag, OpBundles) {
2724 SetInsertPoint(TheBB, IP);
2725 }
2726
2727 /// Avoid copying the full IRBuilder. Prefer using InsertPointGuard
2728 /// or FastMathFlagGuard instead.
2729 IRBuilder(const IRBuilder &) = delete;
2730
2731 InserterTy &getInserter() { return Inserter; }
2732 const InserterTy &getInserter() const { return Inserter; }
2733};
2734
2735template <typename FolderTy, typename InserterTy>
2736IRBuilder(LLVMContext &, FolderTy, InserterTy, MDNode *,
2739template <typename FolderTy>
2744template <typename FolderTy>
2749
2750
2751// Create wrappers for C Binding types (see CBindingWrapping.h).
2753
2754} // end namespace llvm
2755
2756#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:451
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:209
const DataLayout & getDataLayout() const
Get the data layout of the module this basic block belongs to.
Definition: BasicBlock.cpp:294
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:167
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:428
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:1267
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:110
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 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:1405
Value * CreateZExtOrBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2142
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:2311
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:1552
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:2381
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:1174
BasicBlock * BB
Definition: IRBuilder.h:116
Value * CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1379
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:2262
Value * CreateConstGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0, const Twine &Name="")
Definition: IRBuilder.h:1930
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:1202
InvokeInst * CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="")
Definition: IRBuilder.h:1193
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:1042
Value * CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2336
Value * CreateInsertElement(Type *VecTy, Value *NewElt, uint64_t Idx, const Twine &Name="")
Definition: IRBuilder.h:2482
Value * CreateFPCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2222
Value * CreateSRem(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1415
LoadInst * CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, const Twine &Name="")
Definition: IRBuilder.h:1817
Value * CreateFSub(Value *L, Value *R, const Twine &Name="", MDNode *FPMD=nullptr)
Definition: IRBuilder.h:1565
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:2366
CatchPadInst * CreateCatchPad(Value *ParentPad, ArrayRef< Value * > Args, const Twine &Name="")
Definition: IRBuilder.h:1253
Value * CreateInsertElement(Type *VecTy, Value *NewElt, Value *Idx, const Twine &Name="")
Definition: IRBuilder.h:2477
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:1456
AtomicCmpXchgInst * CreateAtomicCmpXchg(Value *Ptr, Value *Cmp, Value *New, MaybeAlign Align, AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering, SyncScope::ID SSID=SyncScope::System)
Definition: IRBuilder.h:1846
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:1884
AllocaInst * CreateAlloca(Type *Ty, unsigned AddrSpace, Value *ArraySize=nullptr, const Twine &Name="")
Definition: IRBuilder.h:1778
void setDefaultOperandBundles(ArrayRef< OperandBundleDef > OpBundles)
Definition: IRBuilder.h:362
CallInst * CreateStackSave(const Twine &Name="")
Create a call to llvm.stacksave.
Definition: IRBuilder.h:1058
InvokeInst * CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > OpBundles, const Twine &Name="")
Definition: IRBuilder.h:1185
IntegerType * getInt1Ty()
Fetch the type representing a single bit.
Definition: IRBuilder.h:508
Value * CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1, const Twine &Name="")
Definition: IRBuilder.h:1904
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:2528
Value * CreateAnd(ArrayRef< Value * > Ops)
Definition: IRBuilder.h:1494
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:1158
BranchInst * CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, Instruction *MDSrc)
Create a conditional 'br Cond, TrueDest, FalseDest' instruction.
Definition: IRBuilder.h:1134
Value * CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name="")
Definition: IRBuilder.h:1486
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:2446
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:1606
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:1619
CallInst * CreateInsertVector(Type *DstType, Value *SrcVec, Value *SubVec, Value *Idx, const Twine &Name="")
Create a call to the vector.insert intrinsic.
Definition: IRBuilder.h:1050
Value * CreateLShr(Value *LHS, const APInt &RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1451
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:1579
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:1633
Value * CreateSIToFP(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2099
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:1803
Value * CreateLogicalOr(ArrayRef< Value * > Ops)
Definition: IRBuilder.h:1707
Value * CreateExtractElement(Value *Vec, Value *Idx, const Twine &Name="")
Definition: IRBuilder.h:2465
Value * CreateLogicalOp(Instruction::BinaryOps Opc, Value *Cond1, Value *Cond2, const Twine &Name="")
Definition: IRBuilder.h:1693
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:2270
Value * CreateFPTrunc(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2106
LoadInst * CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, const char *Name)
Definition: IRBuilder.h:1812
Value * CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2316
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:2044
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:1659
Value * CreateFAdd(Value *L, Value *R, const Twine &Name="", MDNode *FPMD=nullptr)
Definition: IRBuilder.h:1538
UnreachableInst * CreateUnreachable()
Definition: IRBuilder.h:1268
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:2175
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:1646
Value * CreateExtractValue(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &Name="")
Definition: IRBuilder.h:2521
Value * CreateAnd(Value *LHS, uint64_t RHS, const Twine &Name="")
Definition: IRBuilder.h:1490
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:2535
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:1745
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:2274
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:1163
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:2072
Value * CreateConstGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, uint64_t Idx1, const Twine &Name="")
Definition: IRBuilder.h:1950
Value * CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2351
BasicBlock::iterator GetInsertPoint() const
Definition: IRBuilder.h:172
Value * CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx, const Twine &Name="")
Definition: IRBuilder.h:1976
FenceInst * CreateFence(AtomicOrdering Ordering, SyncScope::ID SSID=SyncScope::System, const Twine &Name="")
Definition: IRBuilder.h:1839
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:1228
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:2038
Value * CreateSExtOrBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2150
Value * CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2331
Value * CreateIntToPtr(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2127
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:2540
BasicBlock::iterator InsertPt
Definition: IRBuilder.h:117
Value * CreateLShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1442
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:1894
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:1981
Value * CreateIsNotNeg(Value *Arg, const Twine &Name="")
Return a boolean value testing if Arg > -1.
Definition: IRBuilder.h:2564
CatchReturnInst * CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB)
Definition: IRBuilder.h:1264
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:1241
Value * CreateUIToFP(Value *V, Type *DestTy, const Twine &Name="", bool IsNonNeg=false)
Definition: IRBuilder.h:2086
ReturnInst * CreateRet(Value *V)
Create a 'ret <val>' instruction.
Definition: IRBuilder.h:1100
Value * CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1341
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:1475
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:2301
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:1879
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:1375
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:1508
Value * CreatePointerBitCastOrAddrSpaceCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2187
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:2516
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:1470
Value * CreateUDiv(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1383
Value * CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2346
FastMathFlags FMF
Definition: IRBuilder.h:123
Value * CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2250
Value * CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1345
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:1871
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:1246
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:1758
Value * CreateNeg(Value *V, const Twine &Name="", bool HasNSW=false)
Definition: IRBuilder.h:1726
LoadInst * CreateLoad(Type *Ty, Value *Ptr, const Twine &Name="")
Definition: IRBuilder.h:1799
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:1027
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:2494
Value * CreateShl(Value *LHS, uint64_t RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:1436
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:2507
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:1111
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:2306
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:1997
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:2439
Value * CreateBitOrPointerCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2210
Value * CreateCmp(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2371
const IRBuilderDefaultInserter & Inserter
Definition: IRBuilder.h:120
Value * CreateICmpSLE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2282
PHINode * CreatePHI(Type *Ty, unsigned NumReservedValues, const Twine &Name="")
Definition: IRBuilder.h:2402
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > OpBundles, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2428
Value * CreateNot(Value *V, const Twine &Name="")
Definition: IRBuilder.h:1754
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:1148
Value * CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2246
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:2326
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:2559
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:1349
Value * CreateBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2132
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:1125
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:2254
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:1795
Value * CreateShl(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:1421
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:2026
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:2499
LLVMContext & getContext() const
Definition: IRBuilder.h:173
Value * CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2286
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1480
FastMathFlags & getFastMathFlags()
Definition: IRBuilder.h:299
ReturnInst * CreateRetVoid()
Create a 'ret void' instruction.
Definition: IRBuilder.h:1095
Value * CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1358
Value * CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1, const Twine &Name="")
Definition: IRBuilder.h:1917
Value * CreateConstInBoundsGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, uint64_t Idx1, const Twine &Name="")
Definition: IRBuilder.h:1963
Value * CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex, MDNode *DbgInfo)
Definition: IRBuilder.cpp:1242
StoreInst * CreateStore(Value *Val, Value *Ptr, bool isVolatile=false)
Definition: IRBuilder.h:1808
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:1332
Value * CreatePtrToInt(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2122
Value * CreateSDiv(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1396
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:2461
Value * CreateExactUDiv(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1392
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:2554
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:1430
AtomicRMWInst * CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr, Value *Val, MaybeAlign Align, AtomicOrdering Ordering, SyncScope::ID SSID=SyncScope::System)
Definition: IRBuilder.h:1859
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:1258
Value * CreateTrunc(Value *V, Type *DestTy, const Twine &Name="", bool IsNUW=false, bool IsNSW=false)
Definition: IRBuilder.h:2012
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:1502
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:1671
BranchInst * CreateBr(BasicBlock *Dest)
Create an unconditional 'br label X' instruction.
Definition: IRBuilder.h:1119
Value * CreateLogicalAnd(Value *Cond1, Value *Cond2, const Twine &Name="")
Definition: IRBuilder.h:1681
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:2487
Value * CreateConstInBoundsGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0, const Twine &Name="")
Definition: IRBuilder.h:1940
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:2278
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:2166
CallBrInst * CreateCallBr(FunctionType *Ty, Value *Callee, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > OpBundles, const Twine &Name="")
Definition: IRBuilder.h:1210
Value * CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2258
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:2201
Value * CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2321
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:2549
Value * CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2291
CallInst * CreateStackRestore(Value *Ptr, const Twine &Name="")
Create a call to llvm.stackrestore.
Definition: IRBuilder.h:1065
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:1516
AllocaInst * CreateAlloca(Type *Ty, Value *ArraySize=nullptr, const Twine &Name="")
Definition: IRBuilder.h:1785
Value * CreateExtractElement(Value *Vec, uint64_t Idx, const Twine &Name="")
Definition: IRBuilder.h:2472
StoreInst * CreateAlignedStore(Value *Val, Value *Ptr, MaybeAlign Align, bool isVolatile=false)
Definition: IRBuilder.h:1831
Value * CreateOr(Value *LHS, uint64_t RHS, const Twine &Name="")
Definition: IRBuilder.h:1512
void setConstrainedFPCallAttr(CallBase *I)
Definition: IRBuilder.h:358
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:2417
CallBrInst * CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="")
Definition: IRBuilder.h:1221
const IRBuilderFolder & Folder
Definition: IRBuilder.h:119
Value * CreateInBoundsPtrAdd(Value *Ptr, Value *Offset, const Twine &Name="")
Definition: IRBuilder.h:1986
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:1461
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:2115
Value * CreateXor(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1524
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:2158
Value * CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2266
Value * CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2356
Value * CreateLogicalOr(Value *Cond1, Value *Cond2, const Twine &Name="")
Definition: IRBuilder.h:1687
Value * CreateFMul(Value *L, Value *R, const Twine &Name="", MDNode *FPMD=nullptr)
Definition: IRBuilder.h:1592
LoadInst * CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, bool isVolatile, const Twine &Name="")
Definition: IRBuilder.h:1822
Value * CreateFNeg(Value *V, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:1735
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:1409
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:2059
ResumeInst * CreateResume(Value *Exn)
Definition: IRBuilder.h:1237
Value * CreateAddrSpaceCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2137
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:1530
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:1366
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:1534
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:1731
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:2296
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:1362
Value * CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2341
CallInst * CreateArithmeticFence(Value *Val, Type *DstType, const Twine &Name="")
Create a call to the arithmetic_fence intrinsic.
Definition: IRBuilder.h:1035
Value * CreateFPToSI(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2079
Value * CreateCopySign(Value *LHS, Value *RHS, Instruction *FMFSource=nullptr, const Twine &Name="")
Create call to the copysign intrinsic.
Definition: IRBuilder.h:1019
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:2671
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:2677
IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, FolderTy Folder, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Definition: IRBuilder.h:2710
IRBuilder(Instruction *IP, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Definition: IRBuilder.h:2703
IRBuilder(LLVMContext &C, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Definition: IRBuilder.h:2683
InserterTy & getInserter()
Definition: IRBuilder.h:2731
IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Definition: IRBuilder.h:2719
IRBuilder(BasicBlock *TheBB, FolderTy Folder, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Definition: IRBuilder.h:2687
IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=std::nullopt)
Definition: IRBuilder.h:2696
const InserterTy & getInserter() const
Definition: IRBuilder.h:2732
Indirect Branch Instruction.
static IndirectBrInst * Create(Value *Address, unsigned NumDests, InsertPosition InsertBefore=nullptr)
static InsertElementInst * Create(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
void setHasNoUnsignedWrap(bool b=true)
Set or clear the nuw flag on this instruction, which must be an operator which supports this flag.
void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag.
FastMathFlags getFastMathFlags() const LLVM_READONLY
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
Class to represent integer types.
Definition: DerivedTypes.h:40
Invoke instruction.
static InvokeInst * Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
The landingpad instruction holds all of the information necessary to generate correct exception handl...