Branch data Line data Source code
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"
24 : : #include "llvm/IR/ConstantFolder.h"
25 : : #include "llvm/IR/Constants.h"
26 : : #include "llvm/IR/DataLayout.h"
27 : : #include "llvm/IR/DebugLoc.h"
28 : : #include "llvm/IR/DerivedTypes.h"
29 : : #include "llvm/IR/FPEnv.h"
30 : : #include "llvm/IR/Function.h"
31 : : #include "llvm/IR/GlobalVariable.h"
32 : : #include "llvm/IR/InstrTypes.h"
33 : : #include "llvm/IR/Instruction.h"
34 : : #include "llvm/IR/Instructions.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"
41 : : #include "llvm/Support/AtomicOrdering.h"
42 : : #include "llvm/Support/CBindingWrapping.h"
43 : : #include "llvm/Support/Casting.h"
44 : : #include <cassert>
45 : : #include <cstdint>
46 : : #include <functional>
47 : : #include <optional>
48 : : #include <utility>
49 : :
50 : : namespace llvm {
51 : :
52 : : class APInt;
53 : : class 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.
60 : : class IRBuilderDefaultInserter {
61 : : public:
62 : : virtual ~IRBuilderDefaultInserter();
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.
74 : : class IRBuilderCallbackInserter : public IRBuilderDefaultInserter {
75 : : std::function<void(Instruction *)> Callback;
76 : :
77 : : public:
78 : : ~IRBuilderCallbackInserter() override;
79 : :
80 : : IRBuilderCallbackInserter(std::function<void(Instruction *)> Callback)
81 : : : Callback(std::move(Callback)) {}
82 : :
83 : : void InsertHelper(Instruction *I, const Twine &Name,
84 : : BasicBlock::iterator InsertPt) const override {
85 : : IRBuilderDefaultInserter::InsertHelper(I, Name, InsertPt);
86 : : Callback(I);
87 : : }
88 : : };
89 : :
90 : : /// Common base class shared among various IRBuilders.
91 : : class IRBuilderBase {
92 : : /// Pairs of (metadata kind, MDNode *) that should be added to all newly
93 : : /// created instructions, like !dbg metadata.
94 : : SmallVector<std::pair<unsigned, MDNode *>, 2> MetadataToCopy;
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 : :
115 : : protected:
116 : : BasicBlock *BB;
117 : : BasicBlock::iterator InsertPt;
118 : : LLVMContext &Context;
119 : : const IRBuilderFolder &Folder;
120 : : const IRBuilderDefaultInserter &Inserter;
121 : :
122 : : MDNode *DefaultFPMathTag;
123 : : FastMathFlags FMF;
124 : :
125 : : bool IsFPConstrained = false;
126 : : fp::ExceptionBehavior DefaultConstrainedExcept = fp::ebStrict;
127 : : RoundingMode DefaultConstrainedRounding = RoundingMode::Dynamic;
128 : :
129 : : ArrayRef<OperandBundleDef> DefaultOperandBundles;
130 : :
131 : : public:
132 : 0 : IRBuilderBase(LLVMContext &context, const IRBuilderFolder &Folder,
133 : : const IRBuilderDefaultInserter &Inserter, MDNode *FPMathTag,
134 : : ArrayRef<OperandBundleDef> OpBundles)
135 : 0 : : Context(context), Folder(Folder), Inserter(Inserter),
136 : 0 : DefaultFPMathTag(FPMathTag), DefaultOperandBundles(OpBundles) {
137 : 0 : ClearInsertionPoint();
138 : 0 : }
139 : :
140 : : /// Insert and return the specified instruction.
141 : : template<typename InstTy>
142 : 0 : InstTy *Insert(InstTy *I, const Twine &Name = "") const {
143 : 0 : Inserter.InsertHelper(I, Name, InsertPt);
144 : 0 : AddMetadataToInst(I);
145 : 0 : 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.
166 : 0 : void ClearInsertionPoint() {
167 : 0 : BB = nullptr;
168 : 0 : InsertPt = BasicBlock::iterator();
169 : 0 : }
170 : :
171 : : BasicBlock *GetInsertBlock() const { return BB; }
172 : : BasicBlock::iterator GetInsertPoint() const { return InsertPt; }
173 : : LLVMContext &getContext() const { return Context; }
174 : :
175 : : /// This specifies that created instructions should be appended to the
176 : : /// end of the specified block.
177 : 0 : void SetInsertPoint(BasicBlock *TheBB) {
178 : 0 : BB = TheBB;
179 [ # # ]: 0 : InsertPt = BB->end();
180 : 0 : }
181 : :
182 : : /// This specifies that created instructions should be inserted before
183 : : /// the specified instruction.
184 : : void SetInsertPoint(Instruction *I) {
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.
193 : : void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {
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.
202 : : void SetInsertPoint(BasicBlock::iterator IP) {
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.
211 : : void SetInsertPointPastAllocas(Function *F) {
212 : : BB = &F->getEntryBlock();
213 : : InsertPt = BB->getFirstNonPHIOrDbgOrAlloca();
214 : : }
215 : :
216 : : /// Set location information used by debugging information.
217 : : void SetCurrentDebugLocation(DebugLoc L) {
218 : : AddOrRemoveMetadataToCopy(LLVMContext::MD_dbg, L.getAsMDNode());
219 : : }
220 : :
221 : : /// Set nosanitize metadata.
222 : : void SetNoSanitizeMetadata() {
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.
230 : : void CollectMetadataToCopy(Instruction *Src,
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.
237 : : DebugLoc getCurrentDebugLocation() const;
238 : :
239 : : /// If this builder has a current debug location, set it on the
240 : : /// specified instruction.
241 : : void SetInstDebugLocation(Instruction *I) const;
242 : :
243 : : /// Add all entries in MetadataToCopy to \p I.
244 : 0 : void AddMetadataToInst(Instruction *I) const {
245 [ # # ]: 0 : for (const auto &KV : MetadataToCopy)
246 : 0 : I->setMetadata(KV.first, KV.second);
247 : 0 : }
248 : :
249 : : /// Get the return type of the current function that we're emitting
250 : : /// into.
251 : : Type *getCurrentFunctionReturnType() const;
252 : :
253 : : /// InsertPoint - A saved insertion point.
254 : : class InsertPoint {
255 : : BasicBlock *Block = nullptr;
256 : : BasicBlock::iterator Point;
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.
263 : : InsertPoint(BasicBlock *InsertBlock, BasicBlock::iterator InsertPoint)
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.
274 : : InsertPoint saveIP() const {
275 : : return InsertPoint(GetInsertBlock(), GetInsertPoint());
276 : : }
277 : :
278 : : /// Returns the current insert point, clearing it in the process.
279 : : InsertPoint saveAndClearIP() {
280 : : InsertPoint IP(GetInsertBlock(), GetInsertPoint());
281 : : ClearInsertionPoint();
282 : : return IP;
283 : : }
284 : :
285 : : /// Sets the current insert point to a previously-saved location.
286 : : void restoreIP(InsertPoint IP) {
287 : : if (IP.isSet())
288 : : SetInsertPoint(IP.getBlock(), IP.getPoint());
289 : : else
290 : : ClearInsertionPoint();
291 : : }
292 : :
293 : : /// Get the floating point math metadata being used.
294 : : MDNode *getDefaultFPMathTag() const { return DefaultFPMathTag; }
295 : :
296 : : /// Get the flags to be applied to created floating point ops
297 : : FastMathFlags getFastMathFlags() const { return FMF; }
298 : :
299 : : FastMathFlags &getFastMathFlags() { return FMF; }
300 : :
301 : : /// Clear the fast-math flags.
302 : : void clearFastMathFlags() { FMF.clear(); }
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
317 : : bool getIsFPConstrained() { return IsFPConstrained; }
318 : :
319 : : /// Set the exception handling to be used with constrained floating point
320 : : void setDefaultConstrainedExcept(fp::ExceptionBehavior NewExcept) {
321 : : #ifndef NDEBUG
322 : : std::optional<StringRef> ExceptStr =
323 : : convertExceptionBehaviorToStr(NewExcept);
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
330 : : void setDefaultConstrainedRounding(RoundingMode NewRounding) {
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
340 : : fp::ExceptionBehavior getDefaultConstrainedExcept() {
341 : : return DefaultConstrainedExcept;
342 : : }
343 : :
344 : : /// Get the rounding mode handling used with constrained floating point
345 : : RoundingMode getDefaultConstrainedRounding() {
346 : : return DefaultConstrainedRounding;
347 : : }
348 : :
349 : : void setConstrainedFPFunctionAttr() {
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 : :
358 : 0 : void setConstrainedFPCallAttr(CallBase *I) {
359 : 0 : I->addFnAttr(Attribute::StrictFP);
360 : 0 : }
361 : :
362 : : void setDefaultOperandBundles(ArrayRef<OperandBundleDef> OpBundles) {
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.
372 : : class InsertPointGuard {
373 : : IRBuilderBase &Builder;
374 : : AssertingVH<BasicBlock> Block;
375 : : BasicBlock::iterator Point;
376 : : DebugLoc DbgLoc;
377 : :
378 : : public:
379 : : InsertPointGuard(IRBuilderBase &B)
380 : : : Builder(B), Block(B.GetInsertBlock()), Point(B.GetInsertPoint()),
381 : : DbgLoc(B.getCurrentDebugLocation()) {}
382 : :
383 : : InsertPointGuard(const InsertPointGuard &) = delete;
384 : : InsertPointGuard &operator=(const InsertPointGuard &) = delete;
385 : :
386 : : ~InsertPointGuard() {
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.
394 : : class FastMathFlagGuard {
395 : : IRBuilderBase &Builder;
396 : : FastMathFlags FMF;
397 : : MDNode *FPMathTag;
398 : : bool IsFPConstrained;
399 : : fp::ExceptionBehavior DefaultConstrainedExcept;
400 : : RoundingMode DefaultConstrainedRounding;
401 : :
402 : : public:
403 : : FastMathFlagGuard(IRBuilderBase &B)
404 : : : Builder(B), FMF(B.FMF), FPMathTag(B.DefaultFPMathTag),
405 : : IsFPConstrained(B.IsFPConstrained),
406 : : DefaultConstrainedExcept(B.DefaultConstrainedExcept),
407 : : DefaultConstrainedRounding(B.DefaultConstrainedRounding) {}
408 : :
409 : : FastMathFlagGuard(const FastMathFlagGuard &) = delete;
410 : : FastMathFlagGuard &operator=(const FastMathFlagGuard &) = delete;
411 : :
412 : : ~FastMathFlagGuard() {
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.
423 : : class OperandBundlesGuard {
424 : : IRBuilderBase &Builder;
425 : : ArrayRef<OperandBundleDef> DefaultOperandBundles;
426 : :
427 : : public:
428 : : OperandBundlesGuard(IRBuilderBase &B)
429 : : : Builder(B), DefaultOperandBundles(B.DefaultOperandBundles) {}
430 : :
431 : : OperandBundlesGuard(const OperandBundlesGuard &) = delete;
432 : : OperandBundlesGuard &operator=(const OperandBundlesGuard &) = delete;
433 : :
434 : : ~OperandBundlesGuard() {
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.
453 : : GlobalVariable *CreateGlobalString(StringRef Str, const Twine &Name = "",
454 : : unsigned AddressSpace = 0,
455 : : Module *M = nullptr, bool AddNull = true);
456 : :
457 : : /// Get a constant value representing either true or false.
458 : : ConstantInt *getInt1(bool V) {
459 : : return ConstantInt::get(getInt1Ty(), V);
460 : : }
461 : :
462 : : /// Get the constant value for i1 true.
463 : : ConstantInt *getTrue() {
464 : : return ConstantInt::getTrue(Context);
465 : : }
466 : :
467 : : /// Get the constant value for i1 false.
468 : : ConstantInt *getFalse() {
469 : : return ConstantInt::getFalse(Context);
470 : : }
471 : :
472 : : /// Get a constant 8-bit value.
473 : : ConstantInt *getInt8(uint8_t C) {
474 : : return ConstantInt::get(getInt8Ty(), C);
475 : : }
476 : :
477 : : /// Get a constant 16-bit value.
478 : : ConstantInt *getInt16(uint16_t C) {
479 : : return ConstantInt::get(getInt16Ty(), C);
480 : : }
481 : :
482 : : /// Get a constant 32-bit value.
483 : : ConstantInt *getInt32(uint32_t C) {
484 : : return ConstantInt::get(getInt32Ty(), C);
485 : : }
486 : :
487 : : /// Get a constant 64-bit value.
488 : : ConstantInt *getInt64(uint64_t C) {
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.
494 : : ConstantInt *getIntN(unsigned N, uint64_t C) {
495 : : return ConstantInt::get(getIntNTy(N), C);
496 : : }
497 : :
498 : : /// Get a constant integer value.
499 : : ConstantInt *getInt(const APInt &AI) {
500 : : return ConstantInt::get(Context, AI);
501 : : }
502 : :
503 : : //===--------------------------------------------------------------------===//
504 : : // Type creation methods
505 : : //===--------------------------------------------------------------------===//
506 : :
507 : : /// Fetch the type representing a single bit
508 : : IntegerType *getInt1Ty() {
509 : : return Type::getInt1Ty(Context);
510 : : }
511 : :
512 : : /// Fetch the type representing an 8-bit integer.
513 : : IntegerType *getInt8Ty() {
514 : : return Type::getInt8Ty(Context);
515 : : }
516 : :
517 : : /// Fetch the type representing a 16-bit integer.
518 : : IntegerType *getInt16Ty() {
519 : : return Type::getInt16Ty(Context);
520 : : }
521 : :
522 : : /// Fetch the type representing a 32-bit integer.
523 : : IntegerType *getInt32Ty() {
524 : : return Type::getInt32Ty(Context);
525 : : }
526 : :
527 : : /// Fetch the type representing a 64-bit integer.
528 : : IntegerType *getInt64Ty() {
529 : : return Type::getInt64Ty(Context);
530 : : }
531 : :
532 : : /// Fetch the type representing a 128-bit integer.
533 : : IntegerType *getInt128Ty() { return Type::getInt128Ty(Context); }
534 : :
535 : : /// Fetch the type representing an N-bit integer.
536 : : IntegerType *getIntNTy(unsigned N) {
537 : : return Type::getIntNTy(Context, N);
538 : : }
539 : :
540 : : /// Fetch the type representing a 16-bit floating point value.
541 : : Type *getHalfTy() {
542 : : return Type::getHalfTy(Context);
543 : : }
544 : :
545 : : /// Fetch the type representing a 16-bit brain floating point value.
546 : : Type *getBFloatTy() {
547 : : return Type::getBFloatTy(Context);
548 : : }
549 : :
550 : : /// Fetch the type representing a 32-bit floating point value.
551 : : Type *getFloatTy() {
552 : : return Type::getFloatTy(Context);
553 : : }
554 : :
555 : : /// Fetch the type representing a 64-bit floating point value.
556 : : Type *getDoubleTy() {
557 : : return Type::getDoubleTy(Context);
558 : : }
559 : :
560 : : /// Fetch the type representing void.
561 : : Type *getVoidTy() {
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.
592 : : CallInst *CreateMemSet(Value *Ptr, Value *Val, uint64_t Size,
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 : :
600 : : CallInst *CreateMemSet(Value *Ptr, Value *Val, Value *Size, MaybeAlign Align,
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.
617 : : CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,
618 : : uint64_t Size, Align Alignment,
619 : : uint32_t ElementSize,
620 : : MDNode *TBAATag = nullptr,
621 : : MDNode *ScopeTag = nullptr,
622 : : MDNode *NoAliasTag = nullptr) {
623 : : return CreateElementUnorderedAtomicMemSet(Ptr, Val, getInt64(Size),
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 : :
644 : : CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,
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.
656 : : CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src,
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 : :
667 : : CallInst *CreateMemTransferInst(
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 : :
673 : : CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src,
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 *
685 : : CreateMemCpyInline(Value *Dst, MaybeAlign DstAlign, Value *Src,
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.
702 : : CallInst *CreateElementUnorderedAtomicMemCpy(
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 : :
708 : : CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,
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 : :
717 : : CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,
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.
737 : : CallInst *CreateElementUnorderedAtomicMemMove(
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 : :
743 : : private:
744 : : CallInst *getReductionIntrinsic(Intrinsic::ID ID, Value *Src);
745 : :
746 : : public:
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.
751 : : CallInst *CreateFAddReduce(Value *Acc, Value *Src);
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.
757 : : CallInst *CreateFMulReduce(Value *Acc, Value *Src);
758 : :
759 : : /// Create a vector int add reduction intrinsic of the source vector.
760 : : CallInst *CreateAddReduce(Value *Src);
761 : :
762 : : /// Create a vector int mul reduction intrinsic of the source vector.
763 : : CallInst *CreateMulReduce(Value *Src);
764 : :
765 : : /// Create a vector int AND reduction intrinsic of the source vector.
766 : : CallInst *CreateAndReduce(Value *Src);
767 : :
768 : : /// Create a vector int OR reduction intrinsic of the source vector.
769 : : CallInst *CreateOrReduce(Value *Src);
770 : :
771 : : /// Create a vector int XOR reduction intrinsic of the source vector.
772 : : CallInst *CreateXorReduce(Value *Src);
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.
784 : : CallInst *CreateFPMaxReduce(Value *Src);
785 : :
786 : : /// Create a vector float min reduction intrinsic of the source
787 : : /// vector.
788 : : CallInst *CreateFPMinReduce(Value *Src);
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.
793 : : CallInst *CreateFPMaximumReduce(Value *Src);
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.
798 : : CallInst *CreateFPMinimumReduce(Value *Src);
799 : :
800 : : /// Create a lifetime.start intrinsic.
801 : : ///
802 : : /// If the pointer isn't i8* it will be converted.
803 : : CallInst *CreateLifetimeStart(Value *Ptr, ConstantInt *Size = nullptr);
804 : :
805 : : /// Create a lifetime.end intrinsic.
806 : : ///
807 : : /// If the pointer isn't i8* it will be converted.
808 : : CallInst *CreateLifetimeEnd(Value *Ptr, ConstantInt *Size = nullptr);
809 : :
810 : : /// Create a call to invariant.start intrinsic.
811 : : ///
812 : : /// If the pointer isn't i8* it will be converted.
813 : : CallInst *CreateInvariantStart(Value *Ptr, ConstantInt *Size = nullptr);
814 : :
815 : : /// Create a call to llvm.threadlocal.address intrinsic.
816 : : CallInst *CreateThreadLocalAddress(Value *Ptr);
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
841 : : CallInst *CreateMaskedCompressStore(Value *Val, Value *Ptr,
842 : : Value *Mask = nullptr);
843 : :
844 : : /// Return an all true boolean vector (mask) with \p NumElts lanes.
845 : : Value *getAllOnesMask(ElementCount NumElts) {
846 : : VectorType *VTy = VectorType::get(Type::getInt1Ty(Context), NumElts);
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 *
856 : : CreateAssumption(Value *Cond,
857 : : ArrayRef<OperandBundleDef> OpBundles = std::nullopt);
858 : :
859 : : /// Create a llvm.experimental.noalias.scope.decl intrinsic call.
860 : : Instruction *CreateNoAliasScopeDeclaration(Value *Scope);
861 : : Instruction *CreateNoAliasScopeDeclaration(MDNode *ScopeTag) {
862 : : return CreateNoAliasScopeDeclaration(
863 : : MetadataAsValue::get(Context, ScopeTag));
864 : : }
865 : :
866 : : /// Create a call to the experimental.gc.statepoint intrinsic to
867 : : /// start a new statepoint sequence.
868 : : CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
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.
877 : : CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
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.
888 : : CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
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 *
898 : : CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
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.
906 : : InvokeInst *CreateGCStatepointInvoke(
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 *
917 : : CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
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.
925 : : CallInst *CreateGCResult(Instruction *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.
931 : : CallInst *CreateGCRelocate(Instruction *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.
951 : : Value *CreateElementCount(Type *DstType, ElementCount EC);
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.
955 : : Value *CreateTypeSize(Type *DstType, TypeSize Size);
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.
962 : : CallInst *CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V,
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.
968 : : Value *CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS,
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.
975 : : CallInst *CreateIntrinsic(Intrinsic::ID ID, ArrayRef<Type *> Types,
976 : : ArrayRef<Value *> Args,
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.
983 : : CallInst *CreateIntrinsic(Type *RetTy, Intrinsic::ID ID,
984 : : ArrayRef<Value *> Args,
985 : : Instruction *FMFSource = nullptr,
986 : : const Twine &Name = "");
987 : :
988 : : /// Create call to the minnum intrinsic.
989 : : Value *CreateMinNum(Value *LHS, Value *RHS, const Twine &Name = "") {
990 : : if (IsFPConstrained) {
991 : : return CreateConstrainedFPUnroundedBinOp(
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.
999 : : Value *CreateMaxNum(Value *LHS, Value *RHS, const Twine &Name = "") {
1000 : : if (IsFPConstrained) {
1001 : : return CreateConstrainedFPUnroundedBinOp(
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.
1009 : : Value *CreateMinimum(Value *LHS, Value *RHS, const Twine &Name = "") {
1010 : : return CreateBinaryIntrinsic(Intrinsic::minimum, LHS, RHS, nullptr, Name);
1011 : : }
1012 : :
1013 : : /// Create call to the maximum intrinsic.
1014 : : Value *CreateMaximum(Value *LHS, Value *RHS, const Twine &Name = "") {
1015 : : return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name);
1016 : : }
1017 : :
1018 : : /// Create call to the copysign intrinsic.
1019 : : Value *CreateCopySign(Value *LHS, Value *RHS,
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.
1035 : : CallInst *CreateArithmeticFence(Value *Val, Type *DstType,
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.
1042 : : CallInst *CreateExtractVector(Type *DstType, Value *SrcVec, Value *Idx,
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
1058 : : CallInst *CreateStackSave(const Twine &Name = "") {
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
1065 : : CallInst *CreateStackRestore(Value *Ptr, const Twine &Name = "") {
1066 : : return CreateIntrinsic(Intrinsic::stackrestore, {Ptr->getType()}, {Ptr},
1067 : : nullptr, Name);
1068 : : }
1069 : :
1070 : : private:
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 : :
1080 : : private:
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 : :
1093 : : public:
1094 : : /// Create a 'ret void' instruction.
1095 : : ReturnInst *CreateRetVoid() {
1096 : : return Insert(ReturnInst::Create(Context));
1097 : : }
1098 : :
1099 : : /// Create a 'ret <val>' instruction.
1100 : 0 : ReturnInst *CreateRet(Value *V) {
1101 [ # # # # : 0 : 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) {
1112 : : Value *V = PoisonValue::get(getCurrentFunctionReturnType());
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.
1119 : : BranchInst *CreateBr(BasicBlock *Dest) {
1120 : : return Insert(BranchInst::Create(Dest));
1121 : : }
1122 : :
1123 : : /// Create a conditional 'br Cond, TrueDest, FalseDest'
1124 : : /// instruction.
1125 : : BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
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.
1134 : : BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
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.
1163 : : InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
1164 : : BasicBlock *NormalDest, BasicBlock *UnwindDest,
1165 : : ArrayRef<Value *> Args,
1166 : : ArrayRef<OperandBundleDef> OpBundles,
1167 : : const Twine &Name = "") {
1168 : : InvokeInst *II =
1169 : : InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles);
1170 : : if (IsFPConstrained)
1171 : : setConstrainedFPCallAttr(II);
1172 : : return Insert(II, Name);
1173 : : }
1174 : : InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
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)
1181 : : setConstrainedFPCallAttr(II);
1182 : : return Insert(II, Name);
1183 : : }
1184 : :
1185 : : InvokeInst *CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest,
1186 : : BasicBlock *UnwindDest, ArrayRef<Value *> Args,
1187 : : ArrayRef<OperandBundleDef> OpBundles,
1188 : : const Twine &Name = "") {
1189 : : return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
1190 : : NormalDest, UnwindDest, Args, OpBundles, Name);
1191 : : }
1192 : :
1193 : : InvokeInst *CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest,
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.
1202 : : CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee,
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 : : }
1210 : : CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee,
1211 : : BasicBlock *DefaultDest,
1212 : : ArrayRef<BasicBlock *> IndirectDests,
1213 : : ArrayRef<Value *> Args,
1214 : : ArrayRef<OperandBundleDef> OpBundles,
1215 : : const Twine &Name = "") {
1216 : : return Insert(
1217 : : CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests, Args,
1218 : : OpBundles), Name);
1219 : : }
1220 : :
1221 : : CallBrInst *CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest,
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 : : }
1228 : : CallBrInst *CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest,
1229 : : ArrayRef<BasicBlock *> IndirectDests,
1230 : : ArrayRef<Value *> Args,
1231 : : ArrayRef<OperandBundleDef> OpBundles,
1232 : : const Twine &Name = "") {
1233 : : return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
1234 : : DefaultDest, IndirectDests, Args, Name);
1235 : : }
1236 : :
1237 : : ResumeInst *CreateResume(Value *Exn) {
1238 : : return Insert(ResumeInst::Create(Exn));
1239 : : }
1240 : :
1241 : : CleanupReturnInst *CreateCleanupRet(CleanupPadInst *CleanupPad,
1242 : : BasicBlock *UnwindBB = nullptr) {
1243 : : return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB));
1244 : : }
1245 : :
1246 : : CatchSwitchInst *CreateCatchSwitch(Value *ParentPad, BasicBlock *UnwindBB,
1247 : : unsigned NumHandlers,
1248 : : const Twine &Name = "") {
1249 : : return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers),
1250 : : Name);
1251 : : }
1252 : :
1253 : : CatchPadInst *CreateCatchPad(Value *ParentPad, ArrayRef<Value *> Args,
1254 : : const Twine &Name = "") {
1255 : : return Insert(CatchPadInst::Create(ParentPad, Args), Name);
1256 : : }
1257 : :
1258 : : CleanupPadInst *CreateCleanupPad(Value *ParentPad,
1259 : : ArrayRef<Value *> Args = std::nullopt,
1260 : : const Twine &Name = "") {
1261 : : return Insert(CleanupPadInst::Create(ParentPad, Args), Name);
1262 : : }
1263 : :
1264 : : CatchReturnInst *CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB) {
1265 : : return Insert(CatchReturnInst::Create(CatchPad, BB));
1266 : : }
1267 : :
1268 : : UnreachableInst *CreateUnreachable() {
1269 : : return Insert(new UnreachableInst(Context));
1270 : : }
1271 : :
1272 : : //===--------------------------------------------------------------------===//
1273 : : // Instruction creation methods: Binary Operators
1274 : : //===--------------------------------------------------------------------===//
1275 : : private:
1276 : : BinaryOperator *CreateInsertNUWNSWBinOp(BinaryOperator::BinaryOps Opc,
1277 : : Value *LHS, Value *RHS,
1278 : : const Twine &Name,
1279 : : bool HasNUW, bool HasNSW) {
1280 : : BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
1281 : : if (HasNUW) BO->setHasNoUnsignedWrap();
1282 : : if (HasNSW) BO->setHasNoSignedWrap();
1283 : : return BO;
1284 : : }
1285 : :
1286 : 0 : Instruction *setFPAttrs(Instruction *I, MDNode *FPMD,
1287 : : FastMathFlags FMF) const {
1288 [ # # ]: 0 : if (!FPMD)
1289 : 0 : FPMD = DefaultFPMathTag;
1290 [ # # ]: 0 : if (FPMD)
1291 : 0 : I->setMetadata(LLVMContext::MD_fpmath, FPMD);
1292 : 0 : I->setFastMathFlags(FMF);
1293 : 0 : return I;
1294 : : }
1295 : :
1296 : : Value *getConstrainedFPRounding(std::optional<RoundingMode> Rounding) {
1297 : : RoundingMode UseRounding = DefaultConstrainedRounding;
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 : :
1331 : : public:
1332 : : Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "",
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 : :
1341 : : Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1342 : : return CreateAdd(LHS, RHS, Name, false, true);
1343 : : }
1344 : :
1345 : : Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1346 : : return CreateAdd(LHS, RHS, Name, true, false);
1347 : : }
1348 : :
1349 : : Value *CreateSub(Value *LHS, Value *RHS, const Twine &Name = "",
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 : :
1358 : : Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
1359 : : return CreateSub(LHS, RHS, Name, false, true);
1360 : : }
1361 : :
1362 : : Value *CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
1363 : : return CreateSub(LHS, RHS, Name, true, false);
1364 : : }
1365 : :
1366 : : Value *CreateMul(Value *LHS, Value *RHS, const Twine &Name = "",
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 : :
1375 : : Value *CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
1376 : : return CreateMul(LHS, RHS, Name, false, true);
1377 : : }
1378 : :
1379 : : Value *CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
1380 : : return CreateMul(LHS, RHS, Name, true, false);
1381 : : }
1382 : :
1383 : : Value *CreateUDiv(Value *LHS, Value *RHS, const Twine &Name = "",
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 : :
1392 : : Value *CreateExactUDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
1393 : : return CreateUDiv(LHS, RHS, Name, true);
1394 : : }
1395 : :
1396 : : Value *CreateSDiv(Value *LHS, Value *RHS, const Twine &Name = "",
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 : :
1405 : : Value *CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
1406 : : return CreateSDiv(LHS, RHS, Name, true);
1407 : : }
1408 : :
1409 : : Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") {
1410 : : if (Value *V = Folder.FoldBinOp(Instruction::URem, LHS, RHS))
1411 : : return V;
1412 : : return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
1413 : : }
1414 : :
1415 : : Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") {
1416 : : if (Value *V = Folder.FoldBinOp(Instruction::SRem, LHS, RHS))
1417 : : return V;
1418 : : return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
1419 : : }
1420 : :
1421 : : Value *CreateShl(Value *LHS, Value *RHS, const Twine &Name = "",
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 : :
1436 : : Value *CreateShl(Value *LHS, uint64_t RHS, const Twine &Name = "",
1437 : : bool HasNUW = false, bool HasNSW = false) {
1438 : : return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1439 : : HasNUW, HasNSW);
1440 : : }
1441 : :
1442 : : Value *CreateLShr(Value *LHS, Value *RHS, const Twine &Name = "",
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 : :
1456 : : Value *CreateLShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
1457 : : bool isExact = false) {
1458 : : return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1459 : : }
1460 : :
1461 : : Value *CreateAShr(Value *LHS, Value *RHS, const Twine &Name = "",
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 : :
1475 : : Value *CreateAShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
1476 : : bool isExact = false) {
1477 : : return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1478 : : }
1479 : :
1480 : : Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
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 : :
1490 : : Value *CreateAnd(Value *LHS, uint64_t RHS, const Twine &Name = "") {
1491 : : return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1492 : : }
1493 : :
1494 : : Value *CreateAnd(ArrayRef<Value*> Ops) {
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 : :
1502 : : Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
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 : :
1512 : : Value *CreateOr(Value *LHS, uint64_t RHS, const Twine &Name = "") {
1513 : : return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1514 : : }
1515 : :
1516 : : Value *CreateOr(ArrayRef<Value*> Ops) {
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 : :
1524 : : Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") {
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 : :
1534 : : Value *CreateXor(Value *LHS, uint64_t RHS, const Twine &Name = "") {
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.
1552 : : Value *CreateFAddFMF(Value *L, Value *R, Instruction *FMFSource,
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.
1579 : : Value *CreateFSubFMF(Value *L, Value *R, Instruction *FMFSource,
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.
1606 : : Value *CreateFMulFMF(Value *L, Value *R, Instruction *FMFSource,
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.
1633 : : Value *CreateFDivFMF(Value *L, Value *R, Instruction *FMFSource,
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.
1659 : : Value *CreateFRemFMF(Value *L, Value *R, Instruction *FMFSource,
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 : :
1671 : : Value *CreateBinOp(Instruction::BinaryOps Opc,
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,
1684 : : ConstantInt::getNullValue(Cond2->getType()), Name);
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 : :
1693 : : Value *CreateLogicalOp(Instruction::BinaryOps Opc, Value *Cond1, Value *Cond2,
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!
1707 : : Value *CreateLogicalOr(ArrayRef<Value *> Ops) {
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 : :
1715 : : CallInst *CreateConstrainedFPBinOp(
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 : :
1721 : : CallInst *CreateConstrainedFPUnroundedBinOp(
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.
1745 : : Value *CreateFNegFMF(Value *V, Instruction *FMFSource,
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 : :
1758 : : Value *CreateUnOp(Instruction::UnaryOps Opc,
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 : :
1812 : : LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
1813 : : const char *Name) {
1814 : : return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
1815 : : }
1816 : :
1817 : : LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
1818 : : const Twine &Name = "") {
1819 : : return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
1820 : : }
1821 : :
1822 : : LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
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 : :
1831 : : StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, MaybeAlign Align,
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 : : }
1839 : : FenceInst *CreateFence(AtomicOrdering Ordering,
1840 : : SyncScope::ID SSID = SyncScope::System,
1841 : : const Twine &Name = "") {
1842 : : return Insert(new FenceInst(Context, Ordering, SSID), Name);
1843 : : }
1844 : :
1845 : : AtomicCmpXchgInst *
1846 : : CreateAtomicCmpXchg(Value *Ptr, Value *Cmp, Value *New, MaybeAlign Align,
1847 : : AtomicOrdering SuccessOrdering,
1848 : : AtomicOrdering FailureOrdering,
1849 : : SyncScope::ID SSID = SyncScope::System) {
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 : :
1859 : : AtomicRMWInst *CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr,
1860 : : Value *Val, MaybeAlign Align,
1861 : : AtomicOrdering Ordering,
1862 : : SyncScope::ID SSID = SyncScope::System) {
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 : :
1871 : : Value *CreateGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
1872 : : const Twine &Name = "",
1873 : : GEPNoWrapFlags NW = GEPNoWrapFlags::none()) {
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 : :
1879 : : Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
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 : :
1891 : : return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1892 : : }
1893 : :
1894 : : Value *CreateConstInBoundsGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
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 : :
1901 : : return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
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 : :
1917 : : Value *CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0,
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 : :
1927 : : return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1928 : : }
1929 : :
1930 : : Value *CreateConstGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
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 : :
1937 : : return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1938 : : }
1939 : :
1940 : : Value *CreateConstInBoundsGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
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 : :
1947 : : return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1948 : : }
1949 : :
1950 : : Value *CreateConstGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, uint64_t Idx1,
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 : :
1963 : : Value *CreateConstInBoundsGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0,
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 : :
1973 : : return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1974 : : }
1975 : :
1976 : : Value *CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx,
1977 : : const Twine &Name = "") {
1978 : : return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name);
1979 : : }
1980 : :
1981 : : Value *CreatePtrAdd(Value *Ptr, Value *Offset, const Twine &Name = "",
1982 : : GEPNoWrapFlags NW = GEPNoWrapFlags::none()) {
1983 : : return CreateGEP(getInt8Ty(), Ptr, Offset, Name, NW);
1984 : : }
1985 : :
1986 : : Value *CreateInBoundsPtrAdd(Value *Ptr, Value *Offset,
1987 : : const Twine &Name = "") {
1988 : : return CreateGEP(getInt8Ty(), Ptr, Offset, Name,
1989 : : GEPNoWrapFlags::inBounds());
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.
1997 : : Constant *CreateGlobalStringPtr(StringRef Str, const Twine &Name = "",
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};
2004 : : return ConstantExpr::getInBoundsGetElementPtr(GV->getValueType(), GV,
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.
2044 : : Value *CreateZExtOrTrunc(Value *V, Type *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.
2059 : : Value *CreateSExtOrTrunc(Value *V, Type *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 : :
2106 : : Value *CreateFPTrunc(Value *V, Type *DestTy,
2107 : : const Twine &Name = "") {
2108 : : if (IsFPConstrained)
2109 : : return CreateConstrainedFPCast(
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 : :
2122 : : Value *CreatePtrToInt(Value *V, Type *DestTy,
2123 : : const Twine &Name = "") {
2124 : : return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
2125 : : }
2126 : :
2127 : : Value *CreateIntToPtr(Value *V, Type *DestTy,
2128 : : const Twine &Name = "") {
2129 : : return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
2130 : : }
2131 : :
2132 : : Value *CreateBitCast(Value *V, Type *DestTy,
2133 : : const Twine &Name = "") {
2134 : : return CreateCast(Instruction::BitCast, V, DestTy, Name);
2135 : : }
2136 : :
2137 : : Value *CreateAddrSpaceCast(Value *V, Type *DestTy,
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 : :
2166 : : Value *CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy,
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 : :
2175 : : Value *CreatePointerCast(Value *V, Type *DestTy,
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.
2187 : : Value *CreatePointerBitCastOrAddrSpaceCast(Value *V, Type *DestTy,
2188 : : const Twine &Name = "") {
2189 : : if (V->getType() == DestTy)
2190 : : return V;
2191 : :
2192 : : if (auto *VC = dyn_cast<Constant>(V)) {
2193 : : return Insert(Folder.CreatePointerBitCastOrAddrSpaceCast(VC, DestTy),
2194 : : Name);
2195 : : }
2196 : :
2197 : : return Insert(CastInst::CreatePointerBitCastOrAddrSpaceCast(V, DestTy),
2198 : : Name);
2199 : : }
2200 : :
2201 : : Value *CreateIntCast(Value *V, Type *DestTy, bool isSigned,
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 : :
2210 : : Value *CreateBitOrPointerCast(Value *V, Type *DestTy,
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 : :
2230 : : CallInst *CreateConstrainedFPCast(
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 : :
2246 : : Value *CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name = "") {
2247 : : return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
2248 : : }
2249 : :
2250 : : Value *CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name = "") {
2251 : : return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name);
2252 : : }
2253 : :
2254 : : Value *CreateICmpUGT(Value *LHS, Value *RHS, const Twine &Name = "") {
2255 : : return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name);
2256 : : }
2257 : :
2258 : : Value *CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name = "") {
2259 : : return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name);
2260 : : }
2261 : :
2262 : : Value *CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name = "") {
2263 : : return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name);
2264 : : }
2265 : :
2266 : : Value *CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name = "") {
2267 : : return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name);
2268 : : }
2269 : :
2270 : : Value *CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name = "") {
2271 : : return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name);
2272 : : }
2273 : :
2274 : : Value *CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name = "") {
2275 : : return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name);
2276 : : }
2277 : :
2278 : : Value *CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name = "") {
2279 : : return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name);
2280 : : }
2281 : :
2282 : : Value *CreateICmpSLE(Value *LHS, Value *RHS, const Twine &Name = "") {
2283 : : return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
2284 : : }
2285 : :
2286 : : Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name = "",
2287 : : MDNode *FPMathTag = nullptr) {
2288 : : return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name, FPMathTag);
2289 : : }
2290 : :
2291 : : Value *CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name = "",
2292 : : MDNode *FPMathTag = nullptr) {
2293 : : return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name, FPMathTag);
2294 : : }
2295 : :
2296 : : Value *CreateFCmpOGE(Value *LHS, Value *RHS, const Twine &Name = "",
2297 : : MDNode *FPMathTag = nullptr) {
2298 : : return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name, FPMathTag);
2299 : : }
2300 : :
2301 : : Value *CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name = "",
2302 : : MDNode *FPMathTag = nullptr) {
2303 : : return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name, FPMathTag);
2304 : : }
2305 : :
2306 : : Value *CreateFCmpOLE(Value *LHS, Value *RHS, const Twine &Name = "",
2307 : : MDNode *FPMathTag = nullptr) {
2308 : : return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name, FPMathTag);
2309 : : }
2310 : :
2311 : : Value *CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name = "",
2312 : : MDNode *FPMathTag = nullptr) {
2313 : : return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name, FPMathTag);
2314 : : }
2315 : :
2316 : : Value *CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name = "",
2317 : : MDNode *FPMathTag = nullptr) {
2318 : : return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name, FPMathTag);
2319 : : }
2320 : :
2321 : : Value *CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name = "",
2322 : : MDNode *FPMathTag = nullptr) {
2323 : : return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name, FPMathTag);
2324 : : }
2325 : :
2326 : : Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name = "",
2327 : : MDNode *FPMathTag = nullptr) {
2328 : : return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name, FPMathTag);
2329 : : }
2330 : :
2331 : : Value *CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name = "",
2332 : : MDNode *FPMathTag = nullptr) {
2333 : : return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name, FPMathTag);
2334 : : }
2335 : :
2336 : : Value *CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name = "",
2337 : : MDNode *FPMathTag = nullptr) {
2338 : : return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name, FPMathTag);
2339 : : }
2340 : :
2341 : : Value *CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name = "",
2342 : : MDNode *FPMathTag = nullptr) {
2343 : : return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name, FPMathTag);
2344 : : }
2345 : :
2346 : : Value *CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name = "",
2347 : : MDNode *FPMathTag = nullptr) {
2348 : : return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name, FPMathTag);
2349 : : }
2350 : :
2351 : : Value *CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name = "",
2352 : : MDNode *FPMathTag = nullptr) {
2353 : : return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name, FPMathTag);
2354 : : }
2355 : :
2356 : : Value *CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
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.
2366 : : Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
2367 : : const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2368 : : return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, false);
2369 : : }
2370 : :
2371 : : Value *CreateCmp(CmpInst::Predicate Pred, Value *LHS, Value *RHS,
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.
2381 : : Value *CreateFCmpS(CmpInst::Predicate P, Value *LHS, Value *RHS,
2382 : : const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2383 : : return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, true);
2384 : : }
2385 : :
2386 : : private:
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 : :
2392 : : public:
2393 : : CallInst *CreateConstrainedFPCmp(
2394 : : Intrinsic::ID ID, CmpInst::Predicate P, Value *L, Value *R,
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 : :
2410 : : private:
2411 : : CallInst *createCallHelper(Function *Callee, ArrayRef<Value *> Ops,
2412 : : const Twine &Name = "",
2413 : : Instruction *FMFSource = nullptr,
2414 : : ArrayRef<OperandBundleDef> OpBundles = {});
2415 : :
2416 : : public:
2417 : 0 : CallInst *CreateCall(FunctionType *FTy, Value *Callee,
2418 : : ArrayRef<Value *> Args = std::nullopt,
2419 : : const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2420 [ # # # # ]: 0 : CallInst *CI = CallInst::Create(FTy, Callee, Args, DefaultOperandBundles);
2421 [ # # ]: 0 : if (IsFPConstrained)
2422 [ # # ]: 0 : setConstrainedFPCallAttr(CI);
2423 [ # # # # ]: 0 : if (isa<FPMathOperator>(CI))
2424 [ # # ]: 0 : setFPAttrs(CI, FPMathTag, FMF);
2425 [ # # ]: 0 : return Insert(CI, Name);
2426 : : }
2427 : :
2428 : : CallInst *CreateCall(FunctionType *FTy, Value *Callee, ArrayRef<Value *> Args,
2429 : : ArrayRef<OperandBundleDef> OpBundles,
2430 : : const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2431 : : CallInst *CI = CallInst::Create(FTy, Callee, Args, OpBundles);
2432 : : if (IsFPConstrained)
2433 : : setConstrainedFPCallAttr(CI);
2434 : : if (isa<FPMathOperator>(CI))
2435 : : setFPAttrs(CI, FPMathTag, FMF);
2436 : : return Insert(CI, Name);
2437 : : }
2438 : :
2439 : 0 : CallInst *CreateCall(FunctionCallee Callee,
2440 : : ArrayRef<Value *> Args = std::nullopt,
2441 : : const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2442 : 0 : return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args, Name,
2443 : 0 : FPMathTag);
2444 : : }
2445 : :
2446 : : CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args,
2447 : : ArrayRef<OperandBundleDef> OpBundles,
2448 : : const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2449 : : return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args,
2450 : : OpBundles, Name, FPMathTag);
2451 : : }
2452 : :
2453 : : CallInst *CreateConstrainedFPCall(
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 : :
2461 : : VAArgInst *CreateVAArg(Value *List, Type *Ty, const Twine &Name = "") {
2462 : : return Insert(new VAArgInst(List, Ty), Name);
2463 : : }
2464 : :
2465 : : Value *CreateExtractElement(Value *Vec, Value *Idx,
2466 : : const Twine &Name = "") {
2467 : : if (Value *V = Folder.FoldExtractElement(Vec, Idx))
2468 : : return V;
2469 : : return Insert(ExtractElementInst::Create(Vec, Idx), Name);
2470 : : }
2471 : :
2472 : : Value *CreateExtractElement(Value *Vec, uint64_t Idx,
2473 : : const Twine &Name = "") {
2474 : : return CreateExtractElement(Vec, getInt64(Idx), Name);
2475 : : }
2476 : :
2477 : : Value *CreateInsertElement(Type *VecTy, Value *NewElt, Value *Idx,
2478 : : const Twine &Name = "") {
2479 : : return CreateInsertElement(PoisonValue::get(VecTy), NewElt, Idx, Name);
2480 : : }
2481 : :
2482 : : Value *CreateInsertElement(Type *VecTy, Value *NewElt, uint64_t Idx,
2483 : : const Twine &Name = "") {
2484 : : return CreateInsertElement(PoisonValue::get(VecTy), NewElt, Idx, Name);
2485 : : }
2486 : :
2487 : : Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
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 : :
2494 : : Value *CreateInsertElement(Value *Vec, Value *NewElt, uint64_t Idx,
2495 : : const Twine &Name = "") {
2496 : : return CreateInsertElement(Vec, NewElt, getInt64(Idx), Name);
2497 : : }
2498 : :
2499 : : Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
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.
2507 : : Value *CreateShuffleVector(Value *V1, Value *V2, ArrayRef<int> Mask,
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.
2516 : : Value *CreateShuffleVector(Value *V, ArrayRef<int> Mask,
2517 : : const Twine &Name = "") {
2518 : : return CreateShuffleVector(V, PoisonValue::get(V->getType()), Mask, Name);
2519 : : }
2520 : :
2521 : : Value *CreateExtractValue(Value *Agg, ArrayRef<unsigned> Idxs,
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 : :
2528 : : Value *CreateInsertValue(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
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 = "") {
2560 : : return CreateICmpSLT(Arg, ConstantInt::getNullValue(Arg->getType()), Name);
2561 : : }
2562 : :
2563 : : /// Return a boolean value testing if \p Arg > -1.
2564 : : Value *CreateIsNotNeg(Value *Arg, const Twine &Name = "") {
2565 : : return CreateICmpSGT(Arg, ConstantInt::getAllOnesValue(Arg->getType()),
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.
2581 : : Value *CreateLaunderInvariantGroup(Value *Ptr);
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.
2586 : : Value *CreateStripInvariantGroup(Value *Ptr);
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 : :
2609 : : Value *CreatePreserveArrayAccessIndex(Type *ElTy, Value *Base,
2610 : : unsigned Dimension, unsigned LastIndex,
2611 : : MDNode *DbgInfo);
2612 : :
2613 : : Value *CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex,
2614 : : MDNode *DbgInfo);
2615 : :
2616 : : Value *CreatePreserveStructAccessIndex(Type *ElTy, Value *Base,
2617 : : unsigned Index, unsigned FieldIndex,
2618 : : MDNode *DbgInfo);
2619 : :
2620 : : Value *createIsFPClass(Value *FPNum, unsigned Test);
2621 : :
2622 : : private:
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 : :
2630 : : public:
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.
2637 : : CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
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.
2650 : : CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
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.
2669 : : template <typename FolderTy = ConstantFolder,
2670 : : typename InserterTy = IRBuilderDefaultInserter>
2671 : : class IRBuilder : public IRBuilderBase {
2672 : : private:
2673 : : FolderTy Folder;
2674 : : InserterTy Inserter;
2675 : :
2676 : : public:
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 : 0 : explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
2684 : 0 : ArrayRef<OperandBundleDef> OpBundles = std::nullopt)
2685 : 0 : : 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 : :
2719 : : IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP,
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 : :
2735 : : template <typename FolderTy, typename InserterTy>
2736 : : IRBuilder(LLVMContext &, FolderTy, InserterTy, MDNode *,
2737 : : ArrayRef<OperandBundleDef>) -> IRBuilder<FolderTy, InserterTy>;
2738 : : IRBuilder(LLVMContext &, MDNode *, ArrayRef<OperandBundleDef>) -> IRBuilder<>;
2739 : : template <typename FolderTy>
2740 : : IRBuilder(BasicBlock *, FolderTy, MDNode *, ArrayRef<OperandBundleDef>)
2741 : : -> IRBuilder<FolderTy>;
2742 : : IRBuilder(BasicBlock *, MDNode *, ArrayRef<OperandBundleDef>) -> IRBuilder<>;
2743 : : IRBuilder(Instruction *, MDNode *, ArrayRef<OperandBundleDef>) -> IRBuilder<>;
2744 : : template <typename FolderTy>
2745 : : IRBuilder(BasicBlock *, BasicBlock::iterator, FolderTy, MDNode *,
2746 : : ArrayRef<OperandBundleDef>) -> IRBuilder<FolderTy>;
2747 : : IRBuilder(BasicBlock *, BasicBlock::iterator, MDNode *,
2748 : : ArrayRef<OperandBundleDef>) -> IRBuilder<>;
2749 : :
2750 : :
2751 : : // Create wrappers for C Binding types (see CBindingWrapping.h).
2752 : : DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef)
2753 : :
2754 : : } // end namespace llvm
2755 : :
2756 : : #endif // LLVM_IR_IRBUILDER_H
|
