Branch data Line data Source code
1 : : //===- llvm/InstrTypes.h - Important Instruction subclasses -----*- 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 various meta classes of instructions that exist in the VM
10 : : // representation. Specific concrete subclasses of these may be found in the
11 : : // i*.h files...
12 : : //
13 : : //===----------------------------------------------------------------------===//
14 : :
15 : : #ifndef LLVM_IR_INSTRTYPES_H
16 : : #define LLVM_IR_INSTRTYPES_H
17 : :
18 : : #include "llvm/ADT/ArrayRef.h"
19 : : #include "llvm/ADT/STLExtras.h"
20 : : #include "llvm/ADT/Sequence.h"
21 : : #include "llvm/ADT/StringMap.h"
22 : : #include "llvm/ADT/Twine.h"
23 : : #include "llvm/ADT/iterator_range.h"
24 : : #include "llvm/IR/Attributes.h"
25 : : #include "llvm/IR/CallingConv.h"
26 : : #include "llvm/IR/DerivedTypes.h"
27 : : #include "llvm/IR/FMF.h"
28 : : #include "llvm/IR/Function.h"
29 : : #include "llvm/IR/Instruction.h"
30 : : #include "llvm/IR/LLVMContext.h"
31 : : #include "llvm/IR/OperandTraits.h"
32 : : #include "llvm/IR/User.h"
33 : : #include <algorithm>
34 : : #include <cassert>
35 : : #include <cstddef>
36 : : #include <cstdint>
37 : : #include <iterator>
38 : : #include <optional>
39 : : #include <string>
40 : : #include <vector>
41 : :
42 : : namespace llvm {
43 : :
44 : : class StringRef;
45 : : class Type;
46 : : class Value;
47 : : class ConstantRange;
48 : :
49 : : namespace Intrinsic {
50 : : typedef unsigned ID;
51 : : }
52 : :
53 : : //===----------------------------------------------------------------------===//
54 : : // UnaryInstruction Class
55 : : //===----------------------------------------------------------------------===//
56 : :
57 : : class UnaryInstruction : public Instruction {
58 : : protected:
59 : : UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock::iterator IB)
60 : : : Instruction(Ty, iType, &Op<0>(), 1, IB) {
61 : : Op<0>() = V;
62 : : }
63 : : UnaryInstruction(Type *Ty, unsigned iType, Value *V,
64 : : Instruction *IB = nullptr)
65 : : : Instruction(Ty, iType, &Op<0>(), 1, IB) {
66 : : Op<0>() = V;
67 : : }
68 : : UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock *IAE)
69 : : : Instruction(Ty, iType, &Op<0>(), 1, IAE) {
70 : : Op<0>() = V;
71 : : }
72 : :
73 : : public:
74 : : // allocate space for exactly one operand
75 : : void *operator new(size_t S) { return User::operator new(S, 1); }
76 : : void operator delete(void *Ptr) { User::operator delete(Ptr); }
77 : :
78 : : /// Transparently provide more efficient getOperand methods.
79 : : DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
80 : :
81 : : // Methods for support type inquiry through isa, cast, and dyn_cast:
82 : : static bool classof(const Instruction *I) {
83 : : return I->isUnaryOp() ||
84 : : I->getOpcode() == Instruction::Alloca ||
85 : : I->getOpcode() == Instruction::Load ||
86 : : I->getOpcode() == Instruction::VAArg ||
87 : : I->getOpcode() == Instruction::ExtractValue ||
88 : : (I->getOpcode() >= CastOpsBegin && I->getOpcode() < CastOpsEnd);
89 : : }
90 : : static bool classof(const Value *V) {
91 : : return isa<Instruction>(V) && classof(cast<Instruction>(V));
92 : : }
93 : : };
94 : :
95 : : template <>
96 : : struct OperandTraits<UnaryInstruction> :
97 : : public FixedNumOperandTraits<UnaryInstruction, 1> {
98 : : };
99 : :
100 : : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(UnaryInstruction, Value)
101 : :
102 : : //===----------------------------------------------------------------------===//
103 : : // UnaryOperator Class
104 : : //===----------------------------------------------------------------------===//
105 : :
106 : : class UnaryOperator : public UnaryInstruction {
107 : : void AssertOK();
108 : :
109 : : protected:
110 : : UnaryOperator(UnaryOps iType, Value *S, Type *Ty, const Twine &Name,
111 : : InsertPosition InsertBefore);
112 : :
113 : : // Note: Instruction needs to be a friend here to call cloneImpl.
114 : : friend class Instruction;
115 : :
116 : : UnaryOperator *cloneImpl() const;
117 : :
118 : : public:
119 : : /// Construct a unary instruction, given the opcode and an operand.
120 : : /// Optionally (if InstBefore is specified) insert the instruction
121 : : /// into a BasicBlock right before the specified instruction. The specified
122 : : /// Instruction is allowed to be a dereferenced end iterator.
123 : : ///
124 : : static UnaryOperator *Create(UnaryOps Op, Value *S,
125 : : const Twine &Name = Twine(),
126 : : InsertPosition InsertBefore = nullptr);
127 : :
128 : : /// These methods just forward to Create, and are useful when you
129 : : /// statically know what type of instruction you're going to create. These
130 : : /// helpers just save some typing.
131 : : #define HANDLE_UNARY_INST(N, OPC, CLASS) \
132 : : static UnaryOperator *Create##OPC(Value *V, const Twine &Name = "") {\
133 : : return Create(Instruction::OPC, V, Name);\
134 : : }
135 : : #include "llvm/IR/Instruction.def"
136 : : #define HANDLE_UNARY_INST(N, OPC, CLASS) \
137 : : static UnaryOperator *Create##OPC(Value *V, const Twine &Name, \
138 : : BasicBlock *BB) {\
139 : : return Create(Instruction::OPC, V, Name, BB);\
140 : : }
141 : : #include "llvm/IR/Instruction.def"
142 : : #define HANDLE_UNARY_INST(N, OPC, CLASS) \
143 : : static UnaryOperator *Create##OPC(Value *V, const Twine &Name, \
144 : : Instruction *I) {\
145 : : return Create(Instruction::OPC, V, Name, I);\
146 : : }
147 : : #include "llvm/IR/Instruction.def"
148 : : #define HANDLE_UNARY_INST(N, OPC, CLASS) \
149 : : static UnaryOperator *Create##OPC(Value *V, const Twine &Name, \
150 : : BasicBlock::iterator It) {\
151 : : return Create(Instruction::OPC, V, Name, It);\
152 : : }
153 : : #include "llvm/IR/Instruction.def"
154 : :
155 : : static UnaryOperator *
156 : : CreateWithCopiedFlags(UnaryOps Opc, Value *V, Instruction *CopyO,
157 : : const Twine &Name = "",
158 : : InsertPosition InsertBefore = nullptr) {
159 : : UnaryOperator *UO = Create(Opc, V, Name, InsertBefore);
160 : : UO->copyIRFlags(CopyO);
161 : : return UO;
162 : : }
163 : :
164 : : static UnaryOperator *CreateFNegFMF(Value *Op, Instruction *FMFSource,
165 : : const Twine &Name = "",
166 : : InsertPosition InsertBefore = nullptr) {
167 : : return CreateWithCopiedFlags(Instruction::FNeg, Op, FMFSource, Name,
168 : : InsertBefore);
169 : : }
170 : :
171 : : UnaryOps getOpcode() const {
172 : : return static_cast<UnaryOps>(Instruction::getOpcode());
173 : : }
174 : :
175 : : // Methods for support type inquiry through isa, cast, and dyn_cast:
176 : : static bool classof(const Instruction *I) {
177 : : return I->isUnaryOp();
178 : : }
179 : : static bool classof(const Value *V) {
180 : : return isa<Instruction>(V) && classof(cast<Instruction>(V));
181 : : }
182 : : };
183 : :
184 : : //===----------------------------------------------------------------------===//
185 : : // BinaryOperator Class
186 : : //===----------------------------------------------------------------------===//
187 : :
188 : : class BinaryOperator : public Instruction {
189 : : void AssertOK();
190 : :
191 : : protected:
192 : : BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
193 : : const Twine &Name, InsertPosition InsertBefore);
194 : :
195 : : // Note: Instruction needs to be a friend here to call cloneImpl.
196 : : friend class Instruction;
197 : :
198 : : BinaryOperator *cloneImpl() const;
199 : :
200 : : public:
201 : : // allocate space for exactly two operands
202 : : void *operator new(size_t S) { return User::operator new(S, 2); }
203 : : void operator delete(void *Ptr) { User::operator delete(Ptr); }
204 : :
205 : : /// Transparently provide more efficient getOperand methods.
206 : : DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
207 : :
208 : : /// Construct a binary instruction, given the opcode and the two
209 : : /// operands. Optionally (if InstBefore is specified) insert the instruction
210 : : /// into a BasicBlock right before the specified instruction. The specified
211 : : /// Instruction is allowed to be a dereferenced end iterator.
212 : : ///
213 : : static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2,
214 : : const Twine &Name = Twine(),
215 : : InsertPosition InsertBefore = nullptr);
216 : :
217 : : /// These methods just forward to Create, and are useful when you
218 : : /// statically know what type of instruction you're going to create. These
219 : : /// helpers just save some typing.
220 : : #define HANDLE_BINARY_INST(N, OPC, CLASS) \
221 : : static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
222 : : const Twine &Name = "") {\
223 : : return Create(Instruction::OPC, V1, V2, Name);\
224 : : }
225 : : #include "llvm/IR/Instruction.def"
226 : : #define HANDLE_BINARY_INST(N, OPC, CLASS) \
227 : : static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
228 : : const Twine &Name, BasicBlock *BB) {\
229 : : return Create(Instruction::OPC, V1, V2, Name, BB);\
230 : : }
231 : : #include "llvm/IR/Instruction.def"
232 : : #define HANDLE_BINARY_INST(N, OPC, CLASS) \
233 : : static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
234 : : const Twine &Name, Instruction *I) {\
235 : : return Create(Instruction::OPC, V1, V2, Name, I);\
236 : : }
237 : : #include "llvm/IR/Instruction.def"
238 : : #define HANDLE_BINARY_INST(N, OPC, CLASS) \
239 : : static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
240 : : const Twine &Name, BasicBlock::iterator It) {\
241 : : return Create(Instruction::OPC, V1, V2, Name, It);\
242 : : }
243 : : #include "llvm/IR/Instruction.def"
244 : :
245 : : static BinaryOperator *
246 : : CreateWithCopiedFlags(BinaryOps Opc, Value *V1, Value *V2, Value *CopyO,
247 : : const Twine &Name = "",
248 : : InsertPosition InsertBefore = nullptr) {
249 : : BinaryOperator *BO = Create(Opc, V1, V2, Name, InsertBefore);
250 : : BO->copyIRFlags(CopyO);
251 : : return BO;
252 : : }
253 : :
254 : : static BinaryOperator *CreateWithFMF(BinaryOps Opc, Value *V1, Value *V2,
255 : : FastMathFlags FMF,
256 : : const Twine &Name = "",
257 : : InsertPosition InsertBefore = nullptr) {
258 : : BinaryOperator *BO = Create(Opc, V1, V2, Name, InsertBefore);
259 : : BO->setFastMathFlags(FMF);
260 : : return BO;
261 : : }
262 : :
263 : : static BinaryOperator *CreateFAddFMF(Value *V1, Value *V2, FastMathFlags FMF,
264 : : const Twine &Name = "") {
265 : : return CreateWithFMF(Instruction::FAdd, V1, V2, FMF, Name);
266 : : }
267 : : static BinaryOperator *CreateFSubFMF(Value *V1, Value *V2, FastMathFlags FMF,
268 : : const Twine &Name = "") {
269 : : return CreateWithFMF(Instruction::FSub, V1, V2, FMF, Name);
270 : : }
271 : : static BinaryOperator *CreateFMulFMF(Value *V1, Value *V2, FastMathFlags FMF,
272 : : const Twine &Name = "") {
273 : : return CreateWithFMF(Instruction::FMul, V1, V2, FMF, Name);
274 : : }
275 : : static BinaryOperator *CreateFDivFMF(Value *V1, Value *V2, FastMathFlags FMF,
276 : : const Twine &Name = "") {
277 : : return CreateWithFMF(Instruction::FDiv, V1, V2, FMF, Name);
278 : : }
279 : :
280 : : static BinaryOperator *CreateFAddFMF(Value *V1, Value *V2,
281 : : Instruction *FMFSource,
282 : : const Twine &Name = "") {
283 : : return CreateWithCopiedFlags(Instruction::FAdd, V1, V2, FMFSource, Name);
284 : : }
285 : : static BinaryOperator *CreateFSubFMF(Value *V1, Value *V2,
286 : : Instruction *FMFSource,
287 : : const Twine &Name = "") {
288 : : return CreateWithCopiedFlags(Instruction::FSub, V1, V2, FMFSource, Name);
289 : : }
290 : : static BinaryOperator *CreateFMulFMF(Value *V1, Value *V2,
291 : : Instruction *FMFSource,
292 : : const Twine &Name = "") {
293 : : return CreateWithCopiedFlags(Instruction::FMul, V1, V2, FMFSource, Name);
294 : : }
295 : : static BinaryOperator *CreateFDivFMF(Value *V1, Value *V2,
296 : : Instruction *FMFSource,
297 : : const Twine &Name = "") {
298 : : return CreateWithCopiedFlags(Instruction::FDiv, V1, V2, FMFSource, Name);
299 : : }
300 : : static BinaryOperator *CreateFRemFMF(Value *V1, Value *V2,
301 : : Instruction *FMFSource,
302 : : const Twine &Name = "") {
303 : : return CreateWithCopiedFlags(Instruction::FRem, V1, V2, FMFSource, Name);
304 : : }
305 : :
306 : : static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2,
307 : : const Twine &Name = "") {
308 : : BinaryOperator *BO = Create(Opc, V1, V2, Name);
309 : : BO->setHasNoSignedWrap(true);
310 : : return BO;
311 : : }
312 : : static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2,
313 : : const Twine &Name, BasicBlock *BB) {
314 : : BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
315 : : BO->setHasNoSignedWrap(true);
316 : : return BO;
317 : : }
318 : : static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2,
319 : : const Twine &Name, Instruction *I) {
320 : : BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
321 : : BO->setHasNoSignedWrap(true);
322 : : return BO;
323 : : }
324 : : static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2,
325 : : const Twine &Name, BasicBlock::iterator It) {
326 : : BinaryOperator *BO = Create(Opc, V1, V2, Name, It);
327 : : BO->setHasNoSignedWrap(true);
328 : : return BO;
329 : : }
330 : :
331 : : static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2,
332 : : const Twine &Name = "") {
333 : : BinaryOperator *BO = Create(Opc, V1, V2, Name);
334 : : BO->setHasNoUnsignedWrap(true);
335 : : return BO;
336 : : }
337 : : static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2,
338 : : const Twine &Name, BasicBlock *BB) {
339 : : BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
340 : : BO->setHasNoUnsignedWrap(true);
341 : : return BO;
342 : : }
343 : : static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2,
344 : : const Twine &Name, Instruction *I) {
345 : : BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
346 : : BO->setHasNoUnsignedWrap(true);
347 : : return BO;
348 : : }
349 : : static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2,
350 : : const Twine &Name, BasicBlock::iterator It) {
351 : : BinaryOperator *BO = Create(Opc, V1, V2, Name, It);
352 : : BO->setHasNoUnsignedWrap(true);
353 : : return BO;
354 : : }
355 : :
356 : : static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2,
357 : : const Twine &Name = "") {
358 : : BinaryOperator *BO = Create(Opc, V1, V2, Name);
359 : : BO->setIsExact(true);
360 : : return BO;
361 : : }
362 : : static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2,
363 : : const Twine &Name, BasicBlock *BB) {
364 : : BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
365 : : BO->setIsExact(true);
366 : : return BO;
367 : : }
368 : : static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2,
369 : : const Twine &Name, Instruction *I) {
370 : : BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
371 : : BO->setIsExact(true);
372 : : return BO;
373 : : }
374 : : static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2,
375 : : const Twine &Name,
376 : : BasicBlock::iterator It) {
377 : : BinaryOperator *BO = Create(Opc, V1, V2, Name, It);
378 : : BO->setIsExact(true);
379 : : return BO;
380 : : }
381 : :
382 : : static inline BinaryOperator *
383 : : CreateDisjoint(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name = "");
384 : : static inline BinaryOperator *CreateDisjoint(BinaryOps Opc, Value *V1,
385 : : Value *V2, const Twine &Name,
386 : : BasicBlock *BB);
387 : : static inline BinaryOperator *CreateDisjoint(BinaryOps Opc, Value *V1,
388 : : Value *V2, const Twine &Name,
389 : : Instruction *I);
390 : : static inline BinaryOperator *CreateDisjoint(BinaryOps Opc, Value *V1,
391 : : Value *V2, const Twine &Name,
392 : : BasicBlock::iterator It);
393 : :
394 : : #define DEFINE_HELPERS(OPC, NUWNSWEXACT) \
395 : : static BinaryOperator *Create##NUWNSWEXACT##OPC(Value *V1, Value *V2, \
396 : : const Twine &Name = "") { \
397 : : return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name); \
398 : : } \
399 : : static BinaryOperator *Create##NUWNSWEXACT##OPC( \
400 : : Value *V1, Value *V2, const Twine &Name, BasicBlock *BB) { \
401 : : return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, BB); \
402 : : } \
403 : : static BinaryOperator *Create##NUWNSWEXACT##OPC( \
404 : : Value *V1, Value *V2, const Twine &Name, Instruction *I) { \
405 : : return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, I); \
406 : : } \
407 : : static BinaryOperator *Create##NUWNSWEXACT##OPC( \
408 : : Value *V1, Value *V2, const Twine &Name, BasicBlock::iterator It) { \
409 : : return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, It); \
410 : : }
411 : :
412 : : DEFINE_HELPERS(Add, NSW) // CreateNSWAdd
413 : : DEFINE_HELPERS(Add, NUW) // CreateNUWAdd
414 : : DEFINE_HELPERS(Sub, NSW) // CreateNSWSub
415 : : DEFINE_HELPERS(Sub, NUW) // CreateNUWSub
416 : : DEFINE_HELPERS(Mul, NSW) // CreateNSWMul
417 : : DEFINE_HELPERS(Mul, NUW) // CreateNUWMul
418 : : DEFINE_HELPERS(Shl, NSW) // CreateNSWShl
419 : : DEFINE_HELPERS(Shl, NUW) // CreateNUWShl
420 : :
421 : : DEFINE_HELPERS(SDiv, Exact) // CreateExactSDiv
422 : : DEFINE_HELPERS(UDiv, Exact) // CreateExactUDiv
423 : : DEFINE_HELPERS(AShr, Exact) // CreateExactAShr
424 : : DEFINE_HELPERS(LShr, Exact) // CreateExactLShr
425 : :
426 : : DEFINE_HELPERS(Or, Disjoint) // CreateDisjointOr
427 : :
428 : : #undef DEFINE_HELPERS
429 : :
430 : : /// Helper functions to construct and inspect unary operations (NEG and NOT)
431 : : /// via binary operators SUB and XOR:
432 : : ///
433 : : /// Create the NEG and NOT instructions out of SUB and XOR instructions.
434 : : ///
435 : : static BinaryOperator *CreateNeg(Value *Op, const Twine &Name = "",
436 : : InsertPosition InsertBefore = nullptr);
437 : : static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name = "",
438 : : InsertPosition InsertBefore = nullptr);
439 : : static BinaryOperator *CreateNot(Value *Op, const Twine &Name = "",
440 : : InsertPosition InsertBefore = nullptr);
441 : :
442 : : BinaryOps getOpcode() const {
443 : : return static_cast<BinaryOps>(Instruction::getOpcode());
444 : : }
445 : :
446 : : /// Exchange the two operands to this instruction.
447 : : /// This instruction is safe to use on any binary instruction and
448 : : /// does not modify the semantics of the instruction. If the instruction
449 : : /// cannot be reversed (ie, it's a Div), then return true.
450 : : ///
451 : : bool swapOperands();
452 : :
453 : : // Methods for support type inquiry through isa, cast, and dyn_cast:
454 : : static bool classof(const Instruction *I) {
455 : : return I->isBinaryOp();
456 : : }
457 : : static bool classof(const Value *V) {
458 : : return isa<Instruction>(V) && classof(cast<Instruction>(V));
459 : : }
460 : : };
461 : :
462 : : template <>
463 : : struct OperandTraits<BinaryOperator> :
464 : : public FixedNumOperandTraits<BinaryOperator, 2> {
465 : : };
466 : :
467 : : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BinaryOperator, Value)
468 : :
469 : : /// An or instruction, which can be marked as "disjoint", indicating that the
470 : : /// inputs don't have a 1 in the same bit position. Meaning this instruction
471 : : /// can also be treated as an add.
472 : : class PossiblyDisjointInst : public BinaryOperator {
473 : : public:
474 : : enum { IsDisjoint = (1 << 0) };
475 : :
476 : : void setIsDisjoint(bool B) {
477 : : SubclassOptionalData =
478 : : (SubclassOptionalData & ~IsDisjoint) | (B * IsDisjoint);
479 : : }
480 : :
481 : : bool isDisjoint() const { return SubclassOptionalData & IsDisjoint; }
482 : :
483 : : static bool classof(const Instruction *I) {
484 : : return I->getOpcode() == Instruction::Or;
485 : : }
486 : :
487 : : static bool classof(const Value *V) {
488 : : return isa<Instruction>(V) && classof(cast<Instruction>(V));
489 : : }
490 : : };
491 : :
492 : : BinaryOperator *BinaryOperator::CreateDisjoint(BinaryOps Opc, Value *V1,
493 : : Value *V2, const Twine &Name) {
494 : : BinaryOperator *BO = Create(Opc, V1, V2, Name);
495 : : cast<PossiblyDisjointInst>(BO)->setIsDisjoint(true);
496 : : return BO;
497 : : }
498 : : BinaryOperator *BinaryOperator::CreateDisjoint(BinaryOps Opc, Value *V1,
499 : : Value *V2, const Twine &Name,
500 : : BasicBlock *BB) {
501 : : BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
502 : : cast<PossiblyDisjointInst>(BO)->setIsDisjoint(true);
503 : : return BO;
504 : : }
505 : : BinaryOperator *BinaryOperator::CreateDisjoint(BinaryOps Opc, Value *V1,
506 : : Value *V2, const Twine &Name,
507 : : Instruction *I) {
508 : : BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
509 : : cast<PossiblyDisjointInst>(BO)->setIsDisjoint(true);
510 : : return BO;
511 : : }
512 : : BinaryOperator *BinaryOperator::CreateDisjoint(BinaryOps Opc, Value *V1,
513 : : Value *V2, const Twine &Name,
514 : : BasicBlock::iterator It) {
515 : : BinaryOperator *BO = Create(Opc, V1, V2, Name, It);
516 : : cast<PossiblyDisjointInst>(BO)->setIsDisjoint(true);
517 : : return BO;
518 : : }
519 : :
520 : : //===----------------------------------------------------------------------===//
521 : : // CastInst Class
522 : : //===----------------------------------------------------------------------===//
523 : :
524 : : /// This is the base class for all instructions that perform data
525 : : /// casts. It is simply provided so that instruction category testing
526 : : /// can be performed with code like:
527 : : ///
528 : : /// if (isa<CastInst>(Instr)) { ... }
529 : : /// Base class of casting instructions.
530 : : class CastInst : public UnaryInstruction {
531 : : protected:
532 : : /// Constructor with insert-before-instruction semantics for subclasses
533 : : CastInst(Type *Ty, unsigned iType, Value *S, const Twine &NameStr = "",
534 : : InsertPosition InsertBefore = nullptr)
535 : : : UnaryInstruction(Ty, iType, S, InsertBefore) {
536 : : setName(NameStr);
537 : : }
538 : :
539 : : public:
540 : : /// Provides a way to construct any of the CastInst subclasses using an
541 : : /// opcode instead of the subclass's constructor. The opcode must be in the
542 : : /// CastOps category (Instruction::isCast(opcode) returns true). This
543 : : /// constructor has insert-before-instruction semantics to automatically
544 : : /// insert the new CastInst before InsertBefore (if it is non-null).
545 : : /// Construct any of the CastInst subclasses
546 : : static CastInst *Create(
547 : : Instruction::CastOps, ///< The opcode of the cast instruction
548 : : Value *S, ///< The value to be casted (operand 0)
549 : : Type *Ty, ///< The type to which cast should be made
550 : : const Twine &Name = "", ///< Name for the instruction
551 : : InsertPosition InsertBefore = nullptr ///< Place to insert the instruction
552 : : );
553 : :
554 : : /// Create a ZExt or BitCast cast instruction
555 : : static CastInst *CreateZExtOrBitCast(
556 : : Value *S, ///< The value to be casted (operand 0)
557 : : Type *Ty, ///< The type to which cast should be made
558 : : const Twine &Name = "", ///< Name for the instruction
559 : : InsertPosition InsertBefore = nullptr ///< Place to insert the instruction
560 : : );
561 : :
562 : : /// Create a SExt or BitCast cast instruction
563 : : static CastInst *CreateSExtOrBitCast(
564 : : Value *S, ///< The value to be casted (operand 0)
565 : : Type *Ty, ///< The type to which cast should be made
566 : : const Twine &Name = "", ///< Name for the instruction
567 : : InsertPosition InsertBefore = nullptr ///< Place to insert the instruction
568 : : );
569 : :
570 : : /// Create a BitCast, AddrSpaceCast or a PtrToInt cast instruction.
571 : : static CastInst *CreatePointerCast(
572 : : Value *S, ///< The pointer value to be casted (operand 0)
573 : : Type *Ty, ///< The type to which cast should be made
574 : : const Twine &Name = "", ///< Name for the instruction
575 : : InsertPosition InsertBefore = nullptr ///< Place to insert the instruction
576 : : );
577 : :
578 : : /// Create a BitCast or an AddrSpaceCast cast instruction.
579 : : static CastInst *CreatePointerBitCastOrAddrSpaceCast(
580 : : Value *S, ///< The pointer value to be casted (operand 0)
581 : : Type *Ty, ///< The type to which cast should be made
582 : : const Twine &Name = "", ///< Name for the instruction
583 : : InsertPosition InsertBefore = nullptr ///< Place to insert the instruction
584 : : );
585 : :
586 : : /// Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
587 : : ///
588 : : /// If the value is a pointer type and the destination an integer type,
589 : : /// creates a PtrToInt cast. If the value is an integer type and the
590 : : /// destination a pointer type, creates an IntToPtr cast. Otherwise, creates
591 : : /// a bitcast.
592 : : static CastInst *CreateBitOrPointerCast(
593 : : Value *S, ///< The pointer value to be casted (operand 0)
594 : : Type *Ty, ///< The type to which cast should be made
595 : : const Twine &Name = "", ///< Name for the instruction
596 : : InsertPosition InsertBefore = nullptr ///< Place to insert the instruction
597 : : );
598 : :
599 : : /// Create a ZExt, BitCast, or Trunc for int -> int casts.
600 : : static CastInst *CreateIntegerCast(
601 : : Value *S, ///< The pointer value to be casted (operand 0)
602 : : Type *Ty, ///< The type to which cast should be made
603 : : bool isSigned, ///< Whether to regard S as signed or not
604 : : const Twine &Name = "", ///< Name for the instruction
605 : : InsertPosition InsertBefore = nullptr ///< Place to insert the instruction
606 : : );
607 : :
608 : : /// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
609 : : static CastInst *CreateFPCast(
610 : : Value *S, ///< The floating point value to be casted
611 : : Type *Ty, ///< The floating point type to cast to
612 : : const Twine &Name = "", ///< Name for the instruction
613 : : InsertPosition InsertBefore = nullptr ///< Place to insert the instruction
614 : : );
615 : :
616 : : /// Create a Trunc or BitCast cast instruction
617 : : static CastInst *CreateTruncOrBitCast(
618 : : Value *S, ///< The value to be casted (operand 0)
619 : : Type *Ty, ///< The type to which cast should be made
620 : : const Twine &Name = "", ///< Name for the instruction
621 : : InsertPosition InsertBefore = nullptr ///< Place to insert the instruction
622 : : );
623 : :
624 : : /// Check whether a bitcast between these types is valid
625 : : static bool isBitCastable(
626 : : Type *SrcTy, ///< The Type from which the value should be cast.
627 : : Type *DestTy ///< The Type to which the value should be cast.
628 : : );
629 : :
630 : : /// Check whether a bitcast, inttoptr, or ptrtoint cast between these
631 : : /// types is valid and a no-op.
632 : : ///
633 : : /// This ensures that any pointer<->integer cast has enough bits in the
634 : : /// integer and any other cast is a bitcast.
635 : : static bool isBitOrNoopPointerCastable(
636 : : Type *SrcTy, ///< The Type from which the value should be cast.
637 : : Type *DestTy, ///< The Type to which the value should be cast.
638 : : const DataLayout &DL);
639 : :
640 : : /// Returns the opcode necessary to cast Val into Ty using usual casting
641 : : /// rules.
642 : : /// Infer the opcode for cast operand and type
643 : : static Instruction::CastOps getCastOpcode(
644 : : const Value *Val, ///< The value to cast
645 : : bool SrcIsSigned, ///< Whether to treat the source as signed
646 : : Type *Ty, ///< The Type to which the value should be casted
647 : : bool DstIsSigned ///< Whether to treate the dest. as signed
648 : : );
649 : :
650 : : /// There are several places where we need to know if a cast instruction
651 : : /// only deals with integer source and destination types. To simplify that
652 : : /// logic, this method is provided.
653 : : /// @returns true iff the cast has only integral typed operand and dest type.
654 : : /// Determine if this is an integer-only cast.
655 : : bool isIntegerCast() const;
656 : :
657 : : /// A no-op cast is one that can be effected without changing any bits.
658 : : /// It implies that the source and destination types are the same size. The
659 : : /// DataLayout argument is to determine the pointer size when examining casts
660 : : /// involving Integer and Pointer types. They are no-op casts if the integer
661 : : /// is the same size as the pointer. However, pointer size varies with
662 : : /// platform. Note that a precondition of this method is that the cast is
663 : : /// legal - i.e. the instruction formed with these operands would verify.
664 : : static bool isNoopCast(
665 : : Instruction::CastOps Opcode, ///< Opcode of cast
666 : : Type *SrcTy, ///< SrcTy of cast
667 : : Type *DstTy, ///< DstTy of cast
668 : : const DataLayout &DL ///< DataLayout to get the Int Ptr type from.
669 : : );
670 : :
671 : : /// Determine if this cast is a no-op cast.
672 : : ///
673 : : /// \param DL is the DataLayout to determine pointer size.
674 : : bool isNoopCast(const DataLayout &DL) const;
675 : :
676 : : /// Determine how a pair of casts can be eliminated, if they can be at all.
677 : : /// This is a helper function for both CastInst and ConstantExpr.
678 : : /// @returns 0 if the CastInst pair can't be eliminated, otherwise
679 : : /// returns Instruction::CastOps value for a cast that can replace
680 : : /// the pair, casting SrcTy to DstTy.
681 : : /// Determine if a cast pair is eliminable
682 : : static unsigned isEliminableCastPair(
683 : : Instruction::CastOps firstOpcode, ///< Opcode of first cast
684 : : Instruction::CastOps secondOpcode, ///< Opcode of second cast
685 : : Type *SrcTy, ///< SrcTy of 1st cast
686 : : Type *MidTy, ///< DstTy of 1st cast & SrcTy of 2nd cast
687 : : Type *DstTy, ///< DstTy of 2nd cast
688 : : Type *SrcIntPtrTy, ///< Integer type corresponding to Ptr SrcTy, or null
689 : : Type *MidIntPtrTy, ///< Integer type corresponding to Ptr MidTy, or null
690 : : Type *DstIntPtrTy ///< Integer type corresponding to Ptr DstTy, or null
691 : : );
692 : :
693 : : /// Return the opcode of this CastInst
694 : : Instruction::CastOps getOpcode() const {
695 : : return Instruction::CastOps(Instruction::getOpcode());
696 : : }
697 : :
698 : : /// Return the source type, as a convenience
699 : : Type* getSrcTy() const { return getOperand(0)->getType(); }
700 : : /// Return the destination type, as a convenience
701 : : Type* getDestTy() const { return getType(); }
702 : :
703 : : /// This method can be used to determine if a cast from SrcTy to DstTy using
704 : : /// Opcode op is valid or not.
705 : : /// @returns true iff the proposed cast is valid.
706 : : /// Determine if a cast is valid without creating one.
707 : : static bool castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy);
708 : : static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy) {
709 : : return castIsValid(op, S->getType(), DstTy);
710 : : }
711 : :
712 : : /// Methods for support type inquiry through isa, cast, and dyn_cast:
713 : : static bool classof(const Instruction *I) {
714 : : return I->isCast();
715 : : }
716 : : static bool classof(const Value *V) {
717 : : return isa<Instruction>(V) && classof(cast<Instruction>(V));
718 : : }
719 : : };
720 : :
721 : : /// Instruction that can have a nneg flag (zext/uitofp).
722 : : class PossiblyNonNegInst : public CastInst {
723 : : public:
724 : : enum { NonNeg = (1 << 0) };
725 : :
726 : : static bool classof(const Instruction *I) {
727 : : switch (I->getOpcode()) {
728 : : case Instruction::ZExt:
729 : : case Instruction::UIToFP:
730 : : return true;
731 : : default:
732 : : return false;
733 : : }
734 : : }
735 : :
736 : : static bool classof(const Value *V) {
737 : : return isa<Instruction>(V) && classof(cast<Instruction>(V));
738 : : }
739 : : };
740 : :
741 : : //===----------------------------------------------------------------------===//
742 : : // CmpInst Class
743 : : //===----------------------------------------------------------------------===//
744 : :
745 : : /// This class is the base class for the comparison instructions.
746 : : /// Abstract base class of comparison instructions.
747 : : class CmpInst : public Instruction {
748 : : public:
749 : : /// This enumeration lists the possible predicates for CmpInst subclasses.
750 : : /// Values in the range 0-31 are reserved for FCmpInst, while values in the
751 : : /// range 32-64 are reserved for ICmpInst. This is necessary to ensure the
752 : : /// predicate values are not overlapping between the classes.
753 : : ///
754 : : /// Some passes (e.g. InstCombine) depend on the bit-wise characteristics of
755 : : /// FCMP_* values. Changing the bit patterns requires a potential change to
756 : : /// those passes.
757 : : enum Predicate : unsigned {
758 : : // Opcode U L G E Intuitive operation
759 : : FCMP_FALSE = 0, ///< 0 0 0 0 Always false (always folded)
760 : : FCMP_OEQ = 1, ///< 0 0 0 1 True if ordered and equal
761 : : FCMP_OGT = 2, ///< 0 0 1 0 True if ordered and greater than
762 : : FCMP_OGE = 3, ///< 0 0 1 1 True if ordered and greater than or equal
763 : : FCMP_OLT = 4, ///< 0 1 0 0 True if ordered and less than
764 : : FCMP_OLE = 5, ///< 0 1 0 1 True if ordered and less than or equal
765 : : FCMP_ONE = 6, ///< 0 1 1 0 True if ordered and operands are unequal
766 : : FCMP_ORD = 7, ///< 0 1 1 1 True if ordered (no nans)
767 : : FCMP_UNO = 8, ///< 1 0 0 0 True if unordered: isnan(X) | isnan(Y)
768 : : FCMP_UEQ = 9, ///< 1 0 0 1 True if unordered or equal
769 : : FCMP_UGT = 10, ///< 1 0 1 0 True if unordered or greater than
770 : : FCMP_UGE = 11, ///< 1 0 1 1 True if unordered, greater than, or equal
771 : : FCMP_ULT = 12, ///< 1 1 0 0 True if unordered or less than
772 : : FCMP_ULE = 13, ///< 1 1 0 1 True if unordered, less than, or equal
773 : : FCMP_UNE = 14, ///< 1 1 1 0 True if unordered or not equal
774 : : FCMP_TRUE = 15, ///< 1 1 1 1 Always true (always folded)
775 : : FIRST_FCMP_PREDICATE = FCMP_FALSE,
776 : : LAST_FCMP_PREDICATE = FCMP_TRUE,
777 : : BAD_FCMP_PREDICATE = FCMP_TRUE + 1,
778 : : ICMP_EQ = 32, ///< equal
779 : : ICMP_NE = 33, ///< not equal
780 : : ICMP_UGT = 34, ///< unsigned greater than
781 : : ICMP_UGE = 35, ///< unsigned greater or equal
782 : : ICMP_ULT = 36, ///< unsigned less than
783 : : ICMP_ULE = 37, ///< unsigned less or equal
784 : : ICMP_SGT = 38, ///< signed greater than
785 : : ICMP_SGE = 39, ///< signed greater or equal
786 : : ICMP_SLT = 40, ///< signed less than
787 : : ICMP_SLE = 41, ///< signed less or equal
788 : : FIRST_ICMP_PREDICATE = ICMP_EQ,
789 : : LAST_ICMP_PREDICATE = ICMP_SLE,
790 : : BAD_ICMP_PREDICATE = ICMP_SLE + 1
791 : : };
792 : : using PredicateField =
793 : : Bitfield::Element<Predicate, 0, 6, LAST_ICMP_PREDICATE>;
794 : :
795 : : /// Returns the sequence of all FCmp predicates.
796 : : static auto FCmpPredicates() {
797 : : return enum_seq_inclusive(Predicate::FIRST_FCMP_PREDICATE,
798 : : Predicate::LAST_FCMP_PREDICATE,
799 : : force_iteration_on_noniterable_enum);
800 : : }
801 : :
802 : : /// Returns the sequence of all ICmp predicates.
803 : : static auto ICmpPredicates() {
804 : : return enum_seq_inclusive(Predicate::FIRST_ICMP_PREDICATE,
805 : : Predicate::LAST_ICMP_PREDICATE,
806 : : force_iteration_on_noniterable_enum);
807 : : }
808 : :
809 : : protected:
810 : : CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred, Value *LHS,
811 : : Value *RHS, const Twine &Name = "",
812 : : InsertPosition InsertBefore = nullptr,
813 : : Instruction *FlagsSource = nullptr);
814 : :
815 : : public:
816 : : // allocate space for exactly two operands
817 : : void *operator new(size_t S) { return User::operator new(S, 2); }
818 : : void operator delete(void *Ptr) { User::operator delete(Ptr); }
819 : :
820 : : /// Construct a compare instruction, given the opcode, the predicate and
821 : : /// the two operands. Optionally (if InstBefore is specified) insert the
822 : : /// instruction into a BasicBlock right before the specified instruction.
823 : : /// The specified Instruction is allowed to be a dereferenced end iterator.
824 : : /// Create a CmpInst
825 : : static CmpInst *Create(OtherOps Op, Predicate Pred, Value *S1, Value *S2,
826 : : const Twine &Name = "",
827 : : InsertPosition InsertBefore = nullptr);
828 : :
829 : : /// Construct a compare instruction, given the opcode, the predicate,
830 : : /// the two operands and the instruction to copy the flags from. Optionally
831 : : /// (if InstBefore is specified) insert the instruction into a BasicBlock
832 : : /// right before the specified instruction. The specified Instruction is
833 : : /// allowed to be a dereferenced end iterator.
834 : : /// Create a CmpInst
835 : : static CmpInst *CreateWithCopiedFlags(OtherOps Op, Predicate Pred, Value *S1,
836 : : Value *S2,
837 : : const Instruction *FlagsSource,
838 : : const Twine &Name = "",
839 : : InsertPosition InsertBefore = nullptr);
840 : :
841 : : /// Get the opcode casted to the right type
842 : : OtherOps getOpcode() const {
843 : : return static_cast<OtherOps>(Instruction::getOpcode());
844 : : }
845 : :
846 : : /// Return the predicate for this instruction.
847 : : Predicate getPredicate() const { return getSubclassData<PredicateField>(); }
848 : :
849 : : /// Set the predicate for this instruction to the specified value.
850 : : void setPredicate(Predicate P) { setSubclassData<PredicateField>(P); }
851 : :
852 : : static bool isFPPredicate(Predicate P) {
853 : : static_assert(FIRST_FCMP_PREDICATE == 0,
854 : : "FIRST_FCMP_PREDICATE is required to be 0");
855 : : return P <= LAST_FCMP_PREDICATE;
856 : : }
857 : :
858 : : static bool isIntPredicate(Predicate P) {
859 : : return P >= FIRST_ICMP_PREDICATE && P <= LAST_ICMP_PREDICATE;
860 : : }
861 : :
862 : : static StringRef getPredicateName(Predicate P);
863 : :
864 : : bool isFPPredicate() const { return isFPPredicate(getPredicate()); }
865 : : bool isIntPredicate() const { return isIntPredicate(getPredicate()); }
866 : :
867 : : /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
868 : : /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
869 : : /// @returns the inverse predicate for the instruction's current predicate.
870 : : /// Return the inverse of the instruction's predicate.
871 : : Predicate getInversePredicate() const {
872 : : return getInversePredicate(getPredicate());
873 : : }
874 : :
875 : : /// Returns the ordered variant of a floating point compare.
876 : : ///
877 : : /// For example, UEQ -> OEQ, ULT -> OLT, OEQ -> OEQ
878 : : static Predicate getOrderedPredicate(Predicate Pred) {
879 : : return static_cast<Predicate>(Pred & FCMP_ORD);
880 : : }
881 : :
882 : : Predicate getOrderedPredicate() const {
883 : : return getOrderedPredicate(getPredicate());
884 : : }
885 : :
886 : : /// Returns the unordered variant of a floating point compare.
887 : : ///
888 : : /// For example, OEQ -> UEQ, OLT -> ULT, OEQ -> UEQ
889 : : static Predicate getUnorderedPredicate(Predicate Pred) {
890 : : return static_cast<Predicate>(Pred | FCMP_UNO);
891 : : }
892 : :
893 : : Predicate getUnorderedPredicate() const {
894 : : return getUnorderedPredicate(getPredicate());
895 : : }
896 : :
897 : : /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
898 : : /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
899 : : /// @returns the inverse predicate for predicate provided in \p pred.
900 : : /// Return the inverse of a given predicate
901 : : static Predicate getInversePredicate(Predicate pred);
902 : :
903 : : /// For example, EQ->EQ, SLE->SGE, ULT->UGT,
904 : : /// OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
905 : : /// @returns the predicate that would be the result of exchanging the two
906 : : /// operands of the CmpInst instruction without changing the result
907 : : /// produced.
908 : : /// Return the predicate as if the operands were swapped
909 : : Predicate getSwappedPredicate() const {
910 : : return getSwappedPredicate(getPredicate());
911 : : }
912 : :
913 : : /// This is a static version that you can use without an instruction
914 : : /// available.
915 : : /// Return the predicate as if the operands were swapped.
916 : : static Predicate getSwappedPredicate(Predicate pred);
917 : :
918 : : /// This is a static version that you can use without an instruction
919 : : /// available.
920 : : /// @returns true if the comparison predicate is strict, false otherwise.
921 : : static bool isStrictPredicate(Predicate predicate);
922 : :
923 : : /// @returns true if the comparison predicate is strict, false otherwise.
924 : : /// Determine if this instruction is using an strict comparison predicate.
925 : : bool isStrictPredicate() const { return isStrictPredicate(getPredicate()); }
926 : :
927 : : /// This is a static version that you can use without an instruction
928 : : /// available.
929 : : /// @returns true if the comparison predicate is non-strict, false otherwise.
930 : : static bool isNonStrictPredicate(Predicate predicate);
931 : :
932 : : /// @returns true if the comparison predicate is non-strict, false otherwise.
933 : : /// Determine if this instruction is using an non-strict comparison predicate.
934 : : bool isNonStrictPredicate() const {
935 : : return isNonStrictPredicate(getPredicate());
936 : : }
937 : :
938 : : /// For example, SGE -> SGT, SLE -> SLT, ULE -> ULT, UGE -> UGT.
939 : : /// Returns the strict version of non-strict comparisons.
940 : : Predicate getStrictPredicate() const {
941 : : return getStrictPredicate(getPredicate());
942 : : }
943 : :
944 : : /// This is a static version that you can use without an instruction
945 : : /// available.
946 : : /// @returns the strict version of comparison provided in \p pred.
947 : : /// If \p pred is not a strict comparison predicate, returns \p pred.
948 : : /// Returns the strict version of non-strict comparisons.
949 : : static Predicate getStrictPredicate(Predicate pred);
950 : :
951 : : /// For example, SGT -> SGE, SLT -> SLE, ULT -> ULE, UGT -> UGE.
952 : : /// Returns the non-strict version of strict comparisons.
953 : : Predicate getNonStrictPredicate() const {
954 : : return getNonStrictPredicate(getPredicate());
955 : : }
956 : :
957 : : /// This is a static version that you can use without an instruction
958 : : /// available.
959 : : /// @returns the non-strict version of comparison provided in \p pred.
960 : : /// If \p pred is not a strict comparison predicate, returns \p pred.
961 : : /// Returns the non-strict version of strict comparisons.
962 : : static Predicate getNonStrictPredicate(Predicate pred);
963 : :
964 : : /// This is a static version that you can use without an instruction
965 : : /// available.
966 : : /// Return the flipped strictness of predicate
967 : : static Predicate getFlippedStrictnessPredicate(Predicate pred);
968 : :
969 : : /// For predicate of kind "is X or equal to 0" returns the predicate "is X".
970 : : /// For predicate of kind "is X" returns the predicate "is X or equal to 0".
971 : : /// does not support other kind of predicates.
972 : : /// @returns the predicate that does not contains is equal to zero if
973 : : /// it had and vice versa.
974 : : /// Return the flipped strictness of predicate
975 : : Predicate getFlippedStrictnessPredicate() const {
976 : : return getFlippedStrictnessPredicate(getPredicate());
977 : : }
978 : :
979 : : /// Provide more efficient getOperand methods.
980 : : DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
981 : :
982 : : /// This is just a convenience that dispatches to the subclasses.
983 : : /// Swap the operands and adjust predicate accordingly to retain
984 : : /// the same comparison.
985 : : void swapOperands();
986 : :
987 : : /// This is just a convenience that dispatches to the subclasses.
988 : : /// Determine if this CmpInst is commutative.
989 : : bool isCommutative() const;
990 : :
991 : : /// Determine if this is an equals/not equals predicate.
992 : : /// This is a static version that you can use without an instruction
993 : : /// available.
994 : : static bool isEquality(Predicate pred);
995 : :
996 : : /// Determine if this is an equals/not equals predicate.
997 : : bool isEquality() const { return isEquality(getPredicate()); }
998 : :
999 : : /// Return true if the predicate is relational (not EQ or NE).
1000 : : static bool isRelational(Predicate P) { return !isEquality(P); }
1001 : :
1002 : : /// Return true if the predicate is relational (not EQ or NE).
1003 : : bool isRelational() const { return !isEquality(); }
1004 : :
1005 : : /// @returns true if the comparison is signed, false otherwise.
1006 : : /// Determine if this instruction is using a signed comparison.
1007 : : bool isSigned() const {
1008 : : return isSigned(getPredicate());
1009 : : }
1010 : :
1011 : : /// @returns true if the comparison is unsigned, false otherwise.
1012 : : /// Determine if this instruction is using an unsigned comparison.
1013 : : bool isUnsigned() const {
1014 : : return isUnsigned(getPredicate());
1015 : : }
1016 : :
1017 : : /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
1018 : : /// @returns the signed version of the unsigned predicate pred.
1019 : : /// return the signed version of a predicate
1020 : : static Predicate getSignedPredicate(Predicate pred);
1021 : :
1022 : : /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
1023 : : /// @returns the signed version of the predicate for this instruction (which
1024 : : /// has to be an unsigned predicate).
1025 : : /// return the signed version of a predicate
1026 : : Predicate getSignedPredicate() {
1027 : : return getSignedPredicate(getPredicate());
1028 : : }
1029 : :
1030 : : /// For example, SLT->ULT, SLE->ULE, SGT->UGT, SGE->UGE, ULT->Failed assert
1031 : : /// @returns the unsigned version of the signed predicate pred.
1032 : : static Predicate getUnsignedPredicate(Predicate pred);
1033 : :
1034 : : /// For example, SLT->ULT, SLE->ULE, SGT->UGT, SGE->UGE, ULT->Failed assert
1035 : : /// @returns the unsigned version of the predicate for this instruction (which
1036 : : /// has to be an signed predicate).
1037 : : /// return the unsigned version of a predicate
1038 : : Predicate getUnsignedPredicate() {
1039 : : return getUnsignedPredicate(getPredicate());
1040 : : }
1041 : :
1042 : : /// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert
1043 : : /// @returns the unsigned version of the signed predicate pred or
1044 : : /// the signed version of the signed predicate pred.
1045 : : static Predicate getFlippedSignednessPredicate(Predicate pred);
1046 : :
1047 : : /// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert
1048 : : /// @returns the unsigned version of the signed predicate pred or
1049 : : /// the signed version of the signed predicate pred.
1050 : : Predicate getFlippedSignednessPredicate() {
1051 : : return getFlippedSignednessPredicate(getPredicate());
1052 : : }
1053 : :
1054 : : /// This is just a convenience.
1055 : : /// Determine if this is true when both operands are the same.
1056 : : bool isTrueWhenEqual() const {
1057 : : return isTrueWhenEqual(getPredicate());
1058 : : }
1059 : :
1060 : : /// This is just a convenience.
1061 : : /// Determine if this is false when both operands are the same.
1062 : : bool isFalseWhenEqual() const {
1063 : : return isFalseWhenEqual(getPredicate());
1064 : : }
1065 : :
1066 : : /// @returns true if the predicate is unsigned, false otherwise.
1067 : : /// Determine if the predicate is an unsigned operation.
1068 : : static bool isUnsigned(Predicate predicate);
1069 : :
1070 : : /// @returns true if the predicate is signed, false otherwise.
1071 : : /// Determine if the predicate is an signed operation.
1072 : : static bool isSigned(Predicate predicate);
1073 : :
1074 : : /// Determine if the predicate is an ordered operation.
1075 : : static bool isOrdered(Predicate predicate);
1076 : :
1077 : : /// Determine if the predicate is an unordered operation.
1078 : : static bool isUnordered(Predicate predicate);
1079 : :
1080 : : /// Determine if the predicate is true when comparing a value with itself.
1081 : : static bool isTrueWhenEqual(Predicate predicate);
1082 : :
1083 : : /// Determine if the predicate is false when comparing a value with itself.
1084 : : static bool isFalseWhenEqual(Predicate predicate);
1085 : :
1086 : : /// Determine if Pred1 implies Pred2 is true when two compares have matching
1087 : : /// operands.
1088 : : static bool isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2);
1089 : :
1090 : : /// Determine if Pred1 implies Pred2 is false when two compares have matching
1091 : : /// operands.
1092 : : static bool isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2);
1093 : :
1094 : : /// Methods for support type inquiry through isa, cast, and dyn_cast:
1095 : : static bool classof(const Instruction *I) {
1096 : : return I->getOpcode() == Instruction::ICmp ||
1097 : : I->getOpcode() == Instruction::FCmp;
1098 : : }
1099 : : static bool classof(const Value *V) {
1100 : : return isa<Instruction>(V) && classof(cast<Instruction>(V));
1101 : : }
1102 : :
1103 : : /// Create a result type for fcmp/icmp
1104 : : static Type* makeCmpResultType(Type* opnd_type) {
1105 : : if (VectorType* vt = dyn_cast<VectorType>(opnd_type)) {
1106 : : return VectorType::get(Type::getInt1Ty(opnd_type->getContext()),
1107 : : vt->getElementCount());
1108 : : }
1109 : : return Type::getInt1Ty(opnd_type->getContext());
1110 : : }
1111 : :
1112 : : private:
1113 : : // Shadow Value::setValueSubclassData with a private forwarding method so that
1114 : : // subclasses cannot accidentally use it.
1115 : : void setValueSubclassData(unsigned short D) {
1116 : : Value::setValueSubclassData(D);
1117 : : }
1118 : : };
1119 : :
1120 : : // FIXME: these are redundant if CmpInst < BinaryOperator
1121 : : template <>
1122 : : struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> {
1123 : : };
1124 : :
1125 : : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CmpInst, Value)
1126 : :
1127 : : raw_ostream &operator<<(raw_ostream &OS, CmpInst::Predicate Pred);
1128 : :
1129 : : /// A lightweight accessor for an operand bundle meant to be passed
1130 : : /// around by value.
1131 : : struct OperandBundleUse {
1132 : : ArrayRef<Use> Inputs;
1133 : :
1134 : : OperandBundleUse() = default;
1135 : : explicit OperandBundleUse(StringMapEntry<uint32_t> *Tag, ArrayRef<Use> Inputs)
1136 : : : Inputs(Inputs), Tag(Tag) {}
1137 : :
1138 : : /// Return true if the operand at index \p Idx in this operand bundle
1139 : : /// has the attribute A.
1140 : : bool operandHasAttr(unsigned Idx, Attribute::AttrKind A) const {
1141 : : if (isDeoptOperandBundle())
1142 : : if (A == Attribute::ReadOnly || A == Attribute::NoCapture)
1143 : : return Inputs[Idx]->getType()->isPointerTy();
1144 : :
1145 : : // Conservative answer: no operands have any attributes.
1146 : : return false;
1147 : : }
1148 : :
1149 : : /// Return the tag of this operand bundle as a string.
1150 : : StringRef getTagName() const {
1151 : : return Tag->getKey();
1152 : : }
1153 : :
1154 : : /// Return the tag of this operand bundle as an integer.
1155 : : ///
1156 : : /// Operand bundle tags are interned by LLVMContextImpl::getOrInsertBundleTag,
1157 : : /// and this function returns the unique integer getOrInsertBundleTag
1158 : : /// associated the tag of this operand bundle to.
1159 : : uint32_t getTagID() const {
1160 : : return Tag->getValue();
1161 : : }
1162 : :
1163 : : /// Return true if this is a "deopt" operand bundle.
1164 : : bool isDeoptOperandBundle() const {
1165 : : return getTagID() == LLVMContext::OB_deopt;
1166 : : }
1167 : :
1168 : : /// Return true if this is a "funclet" operand bundle.
1169 : : bool isFuncletOperandBundle() const {
1170 : : return getTagID() == LLVMContext::OB_funclet;
1171 : : }
1172 : :
1173 : : /// Return true if this is a "cfguardtarget" operand bundle.
1174 : : bool isCFGuardTargetOperandBundle() const {
1175 : : return getTagID() == LLVMContext::OB_cfguardtarget;
1176 : : }
1177 : :
1178 : : private:
1179 : : /// Pointer to an entry in LLVMContextImpl::getOrInsertBundleTag.
1180 : : StringMapEntry<uint32_t> *Tag;
1181 : : };
1182 : :
1183 : : /// A container for an operand bundle being viewed as a set of values
1184 : : /// rather than a set of uses.
1185 : : ///
1186 : : /// Unlike OperandBundleUse, OperandBundleDefT owns the memory it carries, and
1187 : : /// so it is possible to create and pass around "self-contained" instances of
1188 : : /// OperandBundleDef and ConstOperandBundleDef.
1189 : : template <typename InputTy> class OperandBundleDefT {
1190 : : std::string Tag;
1191 : : std::vector<InputTy> Inputs;
1192 : :
1193 : : public:
1194 : : explicit OperandBundleDefT(std::string Tag, std::vector<InputTy> Inputs)
1195 : : : Tag(std::move(Tag)), Inputs(std::move(Inputs)) {}
1196 : : explicit OperandBundleDefT(std::string Tag, ArrayRef<InputTy> Inputs)
1197 : : : Tag(std::move(Tag)), Inputs(Inputs) {}
1198 : :
1199 : : explicit OperandBundleDefT(const OperandBundleUse &OBU) {
1200 : : Tag = std::string(OBU.getTagName());
1201 : : llvm::append_range(Inputs, OBU.Inputs);
1202 : : }
1203 : :
1204 : : ArrayRef<InputTy> inputs() const { return Inputs; }
1205 : :
1206 : : using input_iterator = typename std::vector<InputTy>::const_iterator;
1207 : :
1208 : 0 : size_t input_size() const { return Inputs.size(); }
1209 : : input_iterator input_begin() const { return Inputs.begin(); }
1210 : : input_iterator input_end() const { return Inputs.end(); }
1211 : :
1212 : : StringRef getTag() const { return Tag; }
1213 : : };
1214 : :
1215 : : using OperandBundleDef = OperandBundleDefT<Value *>;
1216 : : using ConstOperandBundleDef = OperandBundleDefT<const Value *>;
1217 : :
1218 : : //===----------------------------------------------------------------------===//
1219 : : // CallBase Class
1220 : : //===----------------------------------------------------------------------===//
1221 : :
1222 : : /// Base class for all callable instructions (InvokeInst and CallInst)
1223 : : /// Holds everything related to calling a function.
1224 : : ///
1225 : : /// All call-like instructions are required to use a common operand layout:
1226 : : /// - Zero or more arguments to the call,
1227 : : /// - Zero or more operand bundles with zero or more operand inputs each
1228 : : /// bundle,
1229 : : /// - Zero or more subclass controlled operands
1230 : : /// - The called function.
1231 : : ///
1232 : : /// This allows this base class to easily access the called function and the
1233 : : /// start of the arguments without knowing how many other operands a particular
1234 : : /// subclass requires. Note that accessing the end of the argument list isn't
1235 : : /// as cheap as most other operations on the base class.
1236 : : class CallBase : public Instruction {
1237 : : protected:
1238 : : // The first two bits are reserved by CallInst for fast retrieval,
1239 : : using CallInstReservedField = Bitfield::Element<unsigned, 0, 2>;
1240 : : using CallingConvField =
1241 : : Bitfield::Element<CallingConv::ID, CallInstReservedField::NextBit, 10,
1242 : : CallingConv::MaxID>;
1243 : : static_assert(
1244 : : Bitfield::areContiguous<CallInstReservedField, CallingConvField>(),
1245 : : "Bitfields must be contiguous");
1246 : :
1247 : : /// The last operand is the called operand.
1248 : : static constexpr int CalledOperandOpEndIdx = -1;
1249 : :
1250 : : AttributeList Attrs; ///< parameter attributes for callable
1251 : : FunctionType *FTy;
1252 : :
1253 : : template <class... ArgsTy>
1254 : : CallBase(AttributeList const &A, FunctionType *FT, ArgsTy &&... Args)
1255 : : : Instruction(std::forward<ArgsTy>(Args)...), Attrs(A), FTy(FT) {}
1256 : :
1257 : : using Instruction::Instruction;
1258 : :
1259 : : bool hasDescriptor() const { return Value::HasDescriptor; }
1260 : :
1261 : : unsigned getNumSubclassExtraOperands() const {
1262 : : switch (getOpcode()) {
1263 : : case Instruction::Call:
1264 : : return 0;
1265 : : case Instruction::Invoke:
1266 : : return 2;
1267 : : case Instruction::CallBr:
1268 : : return getNumSubclassExtraOperandsDynamic();
1269 : : }
1270 : : llvm_unreachable("Invalid opcode!");
1271 : : }
1272 : :
1273 : : /// Get the number of extra operands for instructions that don't have a fixed
1274 : : /// number of extra operands.
1275 : : unsigned getNumSubclassExtraOperandsDynamic() const;
1276 : :
1277 : : public:
1278 : : using Instruction::getContext;
1279 : :
1280 : : /// Create a clone of \p CB with a different set of operand bundles and
1281 : : /// insert it before \p InsertPt.
1282 : : ///
1283 : : /// The returned call instruction is identical \p CB in every way except that
1284 : : /// the operand bundles for the new instruction are set to the operand bundles
1285 : : /// in \p Bundles.
1286 : : static CallBase *Create(CallBase *CB, ArrayRef<OperandBundleDef> Bundles,
1287 : : InsertPosition InsertPt = nullptr);
1288 : :
1289 : : /// Create a clone of \p CB with the operand bundle with the tag matching
1290 : : /// \p Bundle's tag replaced with Bundle, and insert it before \p InsertPt.
1291 : : ///
1292 : : /// The returned call instruction is identical \p CI in every way except that
1293 : : /// the specified operand bundle has been replaced.
1294 : : static CallBase *Create(CallBase *CB, OperandBundleDef Bundle,
1295 : : InsertPosition InsertPt = nullptr);
1296 : :
1297 : : /// Create a clone of \p CB with operand bundle \p OB added.
1298 : : static CallBase *addOperandBundle(CallBase *CB, uint32_t ID,
1299 : : OperandBundleDef OB,
1300 : : InsertPosition InsertPt = nullptr);
1301 : :
1302 : : /// Create a clone of \p CB with operand bundle \p ID removed.
1303 : : static CallBase *removeOperandBundle(CallBase *CB, uint32_t ID,
1304 : : InsertPosition InsertPt = nullptr);
1305 : :
1306 : : /// Return the convergence control token for this call, if it exists.
1307 : : Value *getConvergenceControlToken() const {
1308 : : if (auto Bundle = getOperandBundle(llvm::LLVMContext::OB_convergencectrl)) {
1309 : : return Bundle->Inputs[0].get();
1310 : : }
1311 : : return nullptr;
1312 : : }
1313 : :
1314 : : static bool classof(const Instruction *I) {
1315 : : return I->getOpcode() == Instruction::Call ||
1316 : : I->getOpcode() == Instruction::Invoke ||
1317 : : I->getOpcode() == Instruction::CallBr;
1318 : : }
1319 : : static bool classof(const Value *V) {
1320 : : return isa<Instruction>(V) && classof(cast<Instruction>(V));
1321 : : }
1322 : :
1323 : 0 : FunctionType *getFunctionType() const { return FTy; }
1324 : :
1325 : : void mutateFunctionType(FunctionType *FTy) {
1326 : : Value::mutateType(FTy->getReturnType());
1327 : : this->FTy = FTy;
1328 : : }
1329 : :
1330 : : DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
1331 : :
1332 : : /// data_operands_begin/data_operands_end - Return iterators iterating over
1333 : : /// the call / invoke argument list and bundle operands. For invokes, this is
1334 : : /// the set of instruction operands except the invoke target and the two
1335 : : /// successor blocks; and for calls this is the set of instruction operands
1336 : : /// except the call target.
1337 : : User::op_iterator data_operands_begin() { return op_begin(); }
1338 : : User::const_op_iterator data_operands_begin() const {
1339 : : return const_cast<CallBase *>(this)->data_operands_begin();
1340 : : }
1341 : : User::op_iterator data_operands_end() {
1342 : : // Walk from the end of the operands over the called operand and any
1343 : : // subclass operands.
1344 : : return op_end() - getNumSubclassExtraOperands() - 1;
1345 : : }
1346 : : User::const_op_iterator data_operands_end() const {
1347 : : return const_cast<CallBase *>(this)->data_operands_end();
1348 : : }
1349 : : iterator_range<User::op_iterator> data_ops() {
1350 : : return make_range(data_operands_begin(), data_operands_end());
1351 : : }
1352 : : iterator_range<User::const_op_iterator> data_ops() const {
1353 : : return make_range(data_operands_begin(), data_operands_end());
1354 : : }
1355 : : bool data_operands_empty() const {
1356 : : return data_operands_end() == data_operands_begin();
1357 : : }
1358 : : unsigned data_operands_size() const {
1359 : : return std::distance(data_operands_begin(), data_operands_end());
1360 : : }
1361 : :
1362 : : bool isDataOperand(const Use *U) const {
1363 : : assert(this == U->getUser() &&
1364 : : "Only valid to query with a use of this instruction!");
1365 : : return data_operands_begin() <= U && U < data_operands_end();
1366 : : }
1367 : : bool isDataOperand(Value::const_user_iterator UI) const {
1368 : : return isDataOperand(&UI.getUse());
1369 : : }
1370 : :
1371 : : /// Given a value use iterator, return the data operand corresponding to it.
1372 : : /// Iterator must actually correspond to a data operand.
1373 : : unsigned getDataOperandNo(Value::const_user_iterator UI) const {
1374 : : return getDataOperandNo(&UI.getUse());
1375 : : }
1376 : :
1377 : : /// Given a use for a data operand, get the data operand number that
1378 : : /// corresponds to it.
1379 : : unsigned getDataOperandNo(const Use *U) const {
1380 : : assert(isDataOperand(U) && "Data operand # out of range!");
1381 : : return U - data_operands_begin();
1382 : : }
1383 : :
1384 : : /// Return the iterator pointing to the beginning of the argument list.
1385 : : User::op_iterator arg_begin() { return op_begin(); }
1386 : : User::const_op_iterator arg_begin() const {
1387 : : return const_cast<CallBase *>(this)->arg_begin();
1388 : : }
1389 : :
1390 : : /// Return the iterator pointing to the end of the argument list.
1391 : : User::op_iterator arg_end() {
1392 : : // From the end of the data operands, walk backwards past the bundle
1393 : : // operands.
1394 : : return data_operands_end() - getNumTotalBundleOperands();
1395 : : }
1396 : : User::const_op_iterator arg_end() const {
1397 : : return const_cast<CallBase *>(this)->arg_end();
1398 : : }
1399 : :
1400 : : /// Iteration adapter for range-for loops.
1401 : : iterator_range<User::op_iterator> args() {
1402 : : return make_range(arg_begin(), arg_end());
1403 : : }
1404 : : iterator_range<User::const_op_iterator> args() const {
1405 : : return make_range(arg_begin(), arg_end());
1406 : : }
1407 : : bool arg_empty() const { return arg_end() == arg_begin(); }
1408 : : unsigned arg_size() const { return arg_end() - arg_begin(); }
1409 : :
1410 : : Value *getArgOperand(unsigned i) const {
1411 : : assert(i < arg_size() && "Out of bounds!");
1412 : : return getOperand(i);
1413 : : }
1414 : :
1415 : : void setArgOperand(unsigned i, Value *v) {
1416 : : assert(i < arg_size() && "Out of bounds!");
1417 : : setOperand(i, v);
1418 : : }
1419 : :
1420 : : /// Wrappers for getting the \c Use of a call argument.
1421 : : const Use &getArgOperandUse(unsigned i) const {
1422 : : assert(i < arg_size() && "Out of bounds!");
1423 : : return User::getOperandUse(i);
1424 : : }
1425 : : Use &getArgOperandUse(unsigned i) {
1426 : : assert(i < arg_size() && "Out of bounds!");
1427 : : return User::getOperandUse(i);
1428 : : }
1429 : :
1430 : : bool isArgOperand(const Use *U) const {
1431 : : assert(this == U->getUser() &&
1432 : : "Only valid to query with a use of this instruction!");
1433 : : return arg_begin() <= U && U < arg_end();
1434 : : }
1435 : : bool isArgOperand(Value::const_user_iterator UI) const {
1436 : : return isArgOperand(&UI.getUse());
1437 : : }
1438 : :
1439 : : /// Given a use for a arg operand, get the arg operand number that
1440 : : /// corresponds to it.
1441 : : unsigned getArgOperandNo(const Use *U) const {
1442 : : assert(isArgOperand(U) && "Arg operand # out of range!");
1443 : : return U - arg_begin();
1444 : : }
1445 : :
1446 : : /// Given a value use iterator, return the arg operand number corresponding to
1447 : : /// it. Iterator must actually correspond to a data operand.
1448 : : unsigned getArgOperandNo(Value::const_user_iterator UI) const {
1449 : : return getArgOperandNo(&UI.getUse());
1450 : : }
1451 : :
1452 : : /// Returns true if this CallSite passes the given Value* as an argument to
1453 : : /// the called function.
1454 : : bool hasArgument(const Value *V) const {
1455 : : return llvm::is_contained(args(), V);
1456 : : }
1457 : :
1458 : 0 : Value *getCalledOperand() const { return Op<CalledOperandOpEndIdx>(); }
1459 : :
1460 : : const Use &getCalledOperandUse() const { return Op<CalledOperandOpEndIdx>(); }
1461 : : Use &getCalledOperandUse() { return Op<CalledOperandOpEndIdx>(); }
1462 : :
1463 : : /// Returns the function called, or null if this is an indirect function
1464 : : /// invocation or the function signature does not match the call signature.
1465 : 0 : Function *getCalledFunction() const {
1466 [ # # ]: 0 : if (auto *F = dyn_cast_or_null<Function>(getCalledOperand()))
1467 [ # # ]: 0 : if (F->getValueType() == getFunctionType())
1468 : 0 : return F;
1469 : 0 : return nullptr;
1470 : : }
1471 : :
1472 : : /// Return true if the callsite is an indirect call.
1473 : : bool isIndirectCall() const;
1474 : :
1475 : : /// Determine whether the passed iterator points to the callee operand's Use.
1476 : : bool isCallee(Value::const_user_iterator UI) const {
1477 : : return isCallee(&UI.getUse());
1478 : : }
1479 : :
1480 : : /// Determine whether this Use is the callee operand's Use.
1481 : : bool isCallee(const Use *U) const { return &getCalledOperandUse() == U; }
1482 : :
1483 : : /// Helper to get the caller (the parent function).
1484 : : Function *getCaller();
1485 : : const Function *getCaller() const {
1486 : : return const_cast<CallBase *>(this)->getCaller();
1487 : : }
1488 : :
1489 : : /// Tests if this call site must be tail call optimized. Only a CallInst can
1490 : : /// be tail call optimized.
1491 : : bool isMustTailCall() const;
1492 : :
1493 : : /// Tests if this call site is marked as a tail call.
1494 : : bool isTailCall() const;
1495 : :
1496 : : /// Returns the intrinsic ID of the intrinsic called or
1497 : : /// Intrinsic::not_intrinsic if the called function is not an intrinsic, or if
1498 : : /// this is an indirect call.
1499 : : Intrinsic::ID getIntrinsicID() const;
1500 : :
1501 : : void setCalledOperand(Value *V) { Op<CalledOperandOpEndIdx>() = V; }
1502 : :
1503 : : /// Sets the function called, including updating the function type.
1504 : : void setCalledFunction(Function *Fn) {
1505 : : setCalledFunction(Fn->getFunctionType(), Fn);
1506 : : }
1507 : :
1508 : : /// Sets the function called, including updating the function type.
1509 : : void setCalledFunction(FunctionCallee Fn) {
1510 : : setCalledFunction(Fn.getFunctionType(), Fn.getCallee());
1511 : : }
1512 : :
1513 : : /// Sets the function called, including updating to the specified function
1514 : : /// type.
1515 : : void setCalledFunction(FunctionType *FTy, Value *Fn) {
1516 : : this->FTy = FTy;
1517 : : // This function doesn't mutate the return type, only the function
1518 : : // type. Seems broken, but I'm just gonna stick an assert in for now.
1519 : : assert(getType() == FTy->getReturnType());
1520 : : setCalledOperand(Fn);
1521 : : }
1522 : :
1523 : : CallingConv::ID getCallingConv() const {
1524 : : return getSubclassData<CallingConvField>();
1525 : : }
1526 : :
1527 : : void setCallingConv(CallingConv::ID CC) {
1528 : : setSubclassData<CallingConvField>(CC);
1529 : : }
1530 : :
1531 : : /// Check if this call is an inline asm statement.
1532 : : bool isInlineAsm() const { return isa<InlineAsm>(getCalledOperand()); }
1533 : :
1534 : : /// \name Attribute API
1535 : : ///
1536 : : /// These methods access and modify attributes on this call (including
1537 : : /// looking through to the attributes on the called function when necessary).
1538 : : ///@{
1539 : :
1540 : : /// Return the parameter attributes for this call.
1541 : : ///
1542 : : AttributeList getAttributes() const { return Attrs; }
1543 : :
1544 : : /// Set the parameter attributes for this call.
1545 : : ///
1546 : : void setAttributes(AttributeList A) { Attrs = A; }
1547 : :
1548 : : /// Determine whether this call has the given attribute. If it does not
1549 : : /// then determine if the called function has the attribute, but only if
1550 : : /// the attribute is allowed for the call.
1551 : : bool hasFnAttr(Attribute::AttrKind Kind) const {
1552 : : assert(Kind != Attribute::NoBuiltin &&
1553 : : "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin");
1554 : : return hasFnAttrImpl(Kind);
1555 : : }
1556 : :
1557 : : /// Determine whether this call has the given attribute. If it does not
1558 : : /// then determine if the called function has the attribute, but only if
1559 : : /// the attribute is allowed for the call.
1560 : : bool hasFnAttr(StringRef Kind) const { return hasFnAttrImpl(Kind); }
1561 : :
1562 : : // TODO: remove non-AtIndex versions of these methods.
1563 : : /// adds the attribute to the list of attributes.
1564 : : void addAttributeAtIndex(unsigned i, Attribute::AttrKind Kind) {
1565 : : Attrs = Attrs.addAttributeAtIndex(getContext(), i, Kind);
1566 : : }
1567 : :
1568 : : /// adds the attribute to the list of attributes.
1569 : : void addAttributeAtIndex(unsigned i, Attribute Attr) {
1570 : : Attrs = Attrs.addAttributeAtIndex(getContext(), i, Attr);
1571 : : }
1572 : :
1573 : : /// Adds the attribute to the function.
1574 : 0 : void addFnAttr(Attribute::AttrKind Kind) {
1575 : 0 : Attrs = Attrs.addFnAttribute(getContext(), Kind);
1576 : 0 : }
1577 : :
1578 : : /// Adds the attribute to the function.
1579 : : void addFnAttr(Attribute Attr) {
1580 : : Attrs = Attrs.addFnAttribute(getContext(), Attr);
1581 : : }
1582 : :
1583 : : /// Adds the attribute to the return value.
1584 : : void addRetAttr(Attribute::AttrKind Kind) {
1585 : : Attrs = Attrs.addRetAttribute(getContext(), Kind);
1586 : : }
1587 : :
1588 : : /// Adds the attribute to the return value.
1589 : : void addRetAttr(Attribute Attr) {
1590 : : Attrs = Attrs.addRetAttribute(getContext(), Attr);
1591 : : }
1592 : :
1593 : : /// Adds the attribute to the indicated argument
1594 : : void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
1595 : : assert(ArgNo < arg_size() && "Out of bounds");
1596 : : Attrs = Attrs.addParamAttribute(getContext(), ArgNo, Kind);
1597 : : }
1598 : :
1599 : : /// Adds the attribute to the indicated argument
1600 : : void addParamAttr(unsigned ArgNo, Attribute Attr) {
1601 : : assert(ArgNo < arg_size() && "Out of bounds");
1602 : : Attrs = Attrs.addParamAttribute(getContext(), ArgNo, Attr);
1603 : : }
1604 : :
1605 : : /// removes the attribute from the list of attributes.
1606 : : void removeAttributeAtIndex(unsigned i, Attribute::AttrKind Kind) {
1607 : : Attrs = Attrs.removeAttributeAtIndex(getContext(), i, Kind);
1608 : : }
1609 : :
1610 : : /// removes the attribute from the list of attributes.
1611 : : void removeAttributeAtIndex(unsigned i, StringRef Kind) {
1612 : : Attrs = Attrs.removeAttributeAtIndex(getContext(), i, Kind);
1613 : : }
1614 : :
1615 : : /// Removes the attributes from the function
1616 : : void removeFnAttrs(const AttributeMask &AttrsToRemove) {
1617 : : Attrs = Attrs.removeFnAttributes(getContext(), AttrsToRemove);
1618 : : }
1619 : :
1620 : : /// Removes the attribute from the function
1621 : : void removeFnAttr(Attribute::AttrKind Kind) {
1622 : : Attrs = Attrs.removeFnAttribute(getContext(), Kind);
1623 : : }
1624 : :
1625 : : /// Removes the attribute from the function
1626 : : void removeFnAttr(StringRef Kind) {
1627 : : Attrs = Attrs.removeFnAttribute(getContext(), Kind);
1628 : : }
1629 : :
1630 : : /// Removes the attribute from the return value
1631 : : void removeRetAttr(Attribute::AttrKind Kind) {
1632 : : Attrs = Attrs.removeRetAttribute(getContext(), Kind);
1633 : : }
1634 : :
1635 : : /// Removes the attributes from the return value
1636 : : void removeRetAttrs(const AttributeMask &AttrsToRemove) {
1637 : : Attrs = Attrs.removeRetAttributes(getContext(), AttrsToRemove);
1638 : : }
1639 : :
1640 : : /// Removes the attribute from the given argument
1641 : : void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
1642 : : assert(ArgNo < arg_size() && "Out of bounds");
1643 : : Attrs = Attrs.removeParamAttribute(getContext(), ArgNo, Kind);
1644 : : }
1645 : :
1646 : : /// Removes the attribute from the given argument
1647 : : void removeParamAttr(unsigned ArgNo, StringRef Kind) {
1648 : : assert(ArgNo < arg_size() && "Out of bounds");
1649 : : Attrs = Attrs.removeParamAttribute(getContext(), ArgNo, Kind);
1650 : : }
1651 : :
1652 : : /// Removes the attributes from the given argument
1653 : : void removeParamAttrs(unsigned ArgNo, const AttributeMask &AttrsToRemove) {
1654 : : Attrs = Attrs.removeParamAttributes(getContext(), ArgNo, AttrsToRemove);
1655 : : }
1656 : :
1657 : : /// adds the dereferenceable attribute to the list of attributes.
1658 : : void addDereferenceableParamAttr(unsigned i, uint64_t Bytes) {
1659 : : Attrs = Attrs.addDereferenceableParamAttr(getContext(), i, Bytes);
1660 : : }
1661 : :
1662 : : /// adds the dereferenceable attribute to the list of attributes.
1663 : : void addDereferenceableRetAttr(uint64_t Bytes) {
1664 : : Attrs = Attrs.addDereferenceableRetAttr(getContext(), Bytes);
1665 : : }
1666 : :
1667 : : /// adds the range attribute to the list of attributes.
1668 : : void addRangeRetAttr(const ConstantRange &CR) {
1669 : : Attrs = Attrs.addRangeRetAttr(getContext(), CR);
1670 : : }
1671 : :
1672 : : /// Determine whether the return value has the given attribute.
1673 : : bool hasRetAttr(Attribute::AttrKind Kind) const {
1674 : : return hasRetAttrImpl(Kind);
1675 : : }
1676 : : /// Determine whether the return value has the given attribute.
1677 : : bool hasRetAttr(StringRef Kind) const { return hasRetAttrImpl(Kind); }
1678 : :
1679 : : /// Return the attribute for the given attribute kind for the return value.
1680 : : Attribute getRetAttr(Attribute::AttrKind Kind) const {
1681 : : Attribute RetAttr = Attrs.getRetAttr(Kind);
1682 : : if (RetAttr.isValid())
1683 : : return RetAttr;
1684 : :
1685 : : // Look at the callee, if available.
1686 : : if (const Function *F = getCalledFunction())
1687 : : return F->getRetAttribute(Kind);
1688 : : return Attribute();
1689 : : }
1690 : :
1691 : : /// Determine whether the argument or parameter has the given attribute.
1692 : : bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const;
1693 : :
1694 : : /// Get the attribute of a given kind at a position.
1695 : : Attribute getAttributeAtIndex(unsigned i, Attribute::AttrKind Kind) const {
1696 : : return getAttributes().getAttributeAtIndex(i, Kind);
1697 : : }
1698 : :
1699 : : /// Get the attribute of a given kind at a position.
1700 : : Attribute getAttributeAtIndex(unsigned i, StringRef Kind) const {
1701 : : return getAttributes().getAttributeAtIndex(i, Kind);
1702 : : }
1703 : :
1704 : : /// Get the attribute of a given kind for the function.
1705 : : Attribute getFnAttr(StringRef Kind) const {
1706 : : Attribute Attr = getAttributes().getFnAttr(Kind);
1707 : : if (Attr.isValid())
1708 : : return Attr;
1709 : : return getFnAttrOnCalledFunction(Kind);
1710 : : }
1711 : :
1712 : : /// Get the attribute of a given kind for the function.
1713 : : Attribute getFnAttr(Attribute::AttrKind Kind) const {
1714 : : Attribute A = getAttributes().getFnAttr(Kind);
1715 : : if (A.isValid())
1716 : : return A;
1717 : : return getFnAttrOnCalledFunction(Kind);
1718 : : }
1719 : :
1720 : : /// Get the attribute of a given kind from a given arg
1721 : : Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
1722 : : assert(ArgNo < arg_size() && "Out of bounds");
1723 : : Attribute A = getAttributes().getParamAttr(ArgNo, Kind);
1724 : : if (A.isValid())
1725 : : return A;
1726 : : return getParamAttrOnCalledFunction(ArgNo, Kind);
1727 : : }
1728 : :
1729 : : /// Get the attribute of a given kind from a given arg
1730 : : Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const {
1731 : : assert(ArgNo < arg_size() && "Out of bounds");
1732 : : Attribute A = getAttributes().getParamAttr(ArgNo, Kind);
1733 : : if (A.isValid())
1734 : : return A;
1735 : : return getParamAttrOnCalledFunction(ArgNo, Kind);
1736 : : }
1737 : :
1738 : : /// Return true if the data operand at index \p i has the attribute \p
1739 : : /// A.
1740 : : ///
1741 : : /// Data operands include call arguments and values used in operand bundles,
1742 : : /// but does not include the callee operand.
1743 : : ///
1744 : : /// The index \p i is interpreted as
1745 : : ///
1746 : : /// \p i in [0, arg_size) -> argument number (\p i)
1747 : : /// \p i in [arg_size, data_operand_size) -> bundle operand at index
1748 : : /// (\p i) in the operand list.
1749 : : bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const {
1750 : : // Note that we have to add one because `i` isn't zero-indexed.
1751 : : assert(i < arg_size() + getNumTotalBundleOperands() &&
1752 : : "Data operand index out of bounds!");
1753 : :
1754 : : // The attribute A can either be directly specified, if the operand in
1755 : : // question is a call argument; or be indirectly implied by the kind of its
1756 : : // containing operand bundle, if the operand is a bundle operand.
1757 : :
1758 : : if (i < arg_size())
1759 : : return paramHasAttr(i, Kind);
1760 : :
1761 : : assert(hasOperandBundles() && i >= getBundleOperandsStartIndex() &&
1762 : : "Must be either a call argument or an operand bundle!");
1763 : : return bundleOperandHasAttr(i, Kind);
1764 : : }
1765 : :
1766 : : /// Determine whether this data operand is not captured.
1767 : : // FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
1768 : : // better indicate that this may return a conservative answer.
1769 : : bool doesNotCapture(unsigned OpNo) const {
1770 : : return dataOperandHasImpliedAttr(OpNo, Attribute::NoCapture);
1771 : : }
1772 : :
1773 : : /// Determine whether this argument is passed by value.
1774 : : bool isByValArgument(unsigned ArgNo) const {
1775 : : return paramHasAttr(ArgNo, Attribute::ByVal);
1776 : : }
1777 : :
1778 : : /// Determine whether this argument is passed in an alloca.
1779 : : bool isInAllocaArgument(unsigned ArgNo) const {
1780 : : return paramHasAttr(ArgNo, Attribute::InAlloca);
1781 : : }
1782 : :
1783 : : /// Determine whether this argument is passed by value, in an alloca, or is
1784 : : /// preallocated.
1785 : : bool isPassPointeeByValueArgument(unsigned ArgNo) const {
1786 : : return paramHasAttr(ArgNo, Attribute::ByVal) ||
1787 : : paramHasAttr(ArgNo, Attribute::InAlloca) ||
1788 : : paramHasAttr(ArgNo, Attribute::Preallocated);
1789 : : }
1790 : :
1791 : : /// Determine whether passing undef to this argument is undefined behavior.
1792 : : /// If passing undef to this argument is UB, passing poison is UB as well
1793 : : /// because poison is more undefined than undef.
1794 : : bool isPassingUndefUB(unsigned ArgNo) const {
1795 : : return paramHasAttr(ArgNo, Attribute::NoUndef) ||
1796 : : // dereferenceable implies noundef.
1797 : : paramHasAttr(ArgNo, Attribute::Dereferenceable) ||
1798 : : // dereferenceable implies noundef, and null is a well-defined value.
1799 : : paramHasAttr(ArgNo, Attribute::DereferenceableOrNull);
1800 : : }
1801 : :
1802 : : /// Determine if there are is an inalloca argument. Only the last argument can
1803 : : /// have the inalloca attribute.
1804 : : bool hasInAllocaArgument() const {
1805 : : return !arg_empty() && paramHasAttr(arg_size() - 1, Attribute::InAlloca);
1806 : : }
1807 : :
1808 : : // FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
1809 : : // better indicate that this may return a conservative answer.
1810 : : bool doesNotAccessMemory(unsigned OpNo) const {
1811 : : return dataOperandHasImpliedAttr(OpNo, Attribute::ReadNone);
1812 : : }
1813 : :
1814 : : // FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
1815 : : // better indicate that this may return a conservative answer.
1816 : : bool onlyReadsMemory(unsigned OpNo) const {
1817 : : return dataOperandHasImpliedAttr(OpNo, Attribute::ReadOnly) ||
1818 : : dataOperandHasImpliedAttr(OpNo, Attribute::ReadNone);
1819 : : }
1820 : :
1821 : : // FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
1822 : : // better indicate that this may return a conservative answer.
1823 : : bool onlyWritesMemory(unsigned OpNo) const {
1824 : : return dataOperandHasImpliedAttr(OpNo, Attribute::WriteOnly) ||
1825 : : dataOperandHasImpliedAttr(OpNo, Attribute::ReadNone);
1826 : : }
1827 : :
1828 : : /// Extract the alignment of the return value.
1829 : : MaybeAlign getRetAlign() const {
1830 : : if (auto Align = Attrs.getRetAlignment())
1831 : : return Align;
1832 : : if (const Function *F = getCalledFunction())
1833 : : return F->getAttributes().getRetAlignment();
1834 : : return std::nullopt;
1835 : : }
1836 : :
1837 : : /// Extract the alignment for a call or parameter (0=unknown).
1838 : : MaybeAlign getParamAlign(unsigned ArgNo) const {
1839 : : return Attrs.getParamAlignment(ArgNo);
1840 : : }
1841 : :
1842 : : MaybeAlign getParamStackAlign(unsigned ArgNo) const {
1843 : : return Attrs.getParamStackAlignment(ArgNo);
1844 : : }
1845 : :
1846 : : /// Extract the byref type for a call or parameter.
1847 : : Type *getParamByRefType(unsigned ArgNo) const {
1848 : : if (auto *Ty = Attrs.getParamByRefType(ArgNo))
1849 : : return Ty;
1850 : : if (const Function *F = getCalledFunction())
1851 : : return F->getAttributes().getParamByRefType(ArgNo);
1852 : : return nullptr;
1853 : : }
1854 : :
1855 : : /// Extract the byval type for a call or parameter.
1856 : : Type *getParamByValType(unsigned ArgNo) const {
1857 : : if (auto *Ty = Attrs.getParamByValType(ArgNo))
1858 : : return Ty;
1859 : : if (const Function *F = getCalledFunction())
1860 : : return F->getAttributes().getParamByValType(ArgNo);
1861 : : return nullptr;
1862 : : }
1863 : :
1864 : : /// Extract the preallocated type for a call or parameter.
1865 : : Type *getParamPreallocatedType(unsigned ArgNo) const {
1866 : : if (auto *Ty = Attrs.getParamPreallocatedType(ArgNo))
1867 : : return Ty;
1868 : : if (const Function *F = getCalledFunction())
1869 : : return F->getAttributes().getParamPreallocatedType(ArgNo);
1870 : : return nullptr;
1871 : : }
1872 : :
1873 : : /// Extract the inalloca type for a call or parameter.
1874 : : Type *getParamInAllocaType(unsigned ArgNo) const {
1875 : : if (auto *Ty = Attrs.getParamInAllocaType(ArgNo))
1876 : : return Ty;
1877 : : if (const Function *F = getCalledFunction())
1878 : : return F->getAttributes().getParamInAllocaType(ArgNo);
1879 : : return nullptr;
1880 : : }
1881 : :
1882 : : /// Extract the sret type for a call or parameter.
1883 : : Type *getParamStructRetType(unsigned ArgNo) const {
1884 : : if (auto *Ty = Attrs.getParamStructRetType(ArgNo))
1885 : : return Ty;
1886 : : if (const Function *F = getCalledFunction())
1887 : : return F->getAttributes().getParamStructRetType(ArgNo);
1888 : : return nullptr;
1889 : : }
1890 : :
1891 : : /// Extract the elementtype type for a parameter.
1892 : : /// Note that elementtype() can only be applied to call arguments, not
1893 : : /// function declaration parameters.
1894 : : Type *getParamElementType(unsigned ArgNo) const {
1895 : : return Attrs.getParamElementType(ArgNo);
1896 : : }
1897 : :
1898 : : /// Extract the number of dereferenceable bytes for a call or
1899 : : /// parameter (0=unknown).
1900 : : uint64_t getRetDereferenceableBytes() const {
1901 : : uint64_t Bytes = Attrs.getRetDereferenceableBytes();
1902 : : if (const Function *F = getCalledFunction())
1903 : : Bytes = std::max(Bytes, F->getAttributes().getRetDereferenceableBytes());
1904 : : return Bytes;
1905 : : }
1906 : :
1907 : : /// Extract the number of dereferenceable bytes for a call or
1908 : : /// parameter (0=unknown).
1909 : : uint64_t getParamDereferenceableBytes(unsigned i) const {
1910 : : return Attrs.getParamDereferenceableBytes(i);
1911 : : }
1912 : :
1913 : : /// Extract the number of dereferenceable_or_null bytes for a call
1914 : : /// (0=unknown).
1915 : : uint64_t getRetDereferenceableOrNullBytes() const {
1916 : : uint64_t Bytes = Attrs.getRetDereferenceableOrNullBytes();
1917 : : if (const Function *F = getCalledFunction()) {
1918 : : Bytes = std::max(Bytes,
1919 : : F->getAttributes().getRetDereferenceableOrNullBytes());
1920 : : }
1921 : :
1922 : : return Bytes;
1923 : : }
1924 : :
1925 : : /// Extract the number of dereferenceable_or_null bytes for a
1926 : : /// parameter (0=unknown).
1927 : : uint64_t getParamDereferenceableOrNullBytes(unsigned i) const {
1928 : : return Attrs.getParamDereferenceableOrNullBytes(i);
1929 : : }
1930 : :
1931 : : /// Extract a test mask for disallowed floating-point value classes for the
1932 : : /// return value.
1933 : : FPClassTest getRetNoFPClass() const;
1934 : :
1935 : : /// Extract a test mask for disallowed floating-point value classes for the
1936 : : /// parameter.
1937 : : FPClassTest getParamNoFPClass(unsigned i) const;
1938 : :
1939 : : /// If this return value has a range attribute, return the value range of the
1940 : : /// argument. Otherwise, std::nullopt is returned.
1941 : : std::optional<ConstantRange> getRange() const;
1942 : :
1943 : : /// Return true if the return value is known to be not null.
1944 : : /// This may be because it has the nonnull attribute, or because at least
1945 : : /// one byte is dereferenceable and the pointer is in addrspace(0).
1946 : : bool isReturnNonNull() const;
1947 : :
1948 : : /// Determine if the return value is marked with NoAlias attribute.
1949 : : bool returnDoesNotAlias() const {
1950 : : return Attrs.hasRetAttr(Attribute::NoAlias);
1951 : : }
1952 : :
1953 : : /// If one of the arguments has the 'returned' attribute, returns its
1954 : : /// operand value. Otherwise, return nullptr.
1955 : : Value *getReturnedArgOperand() const {
1956 : : return getArgOperandWithAttribute(Attribute::Returned);
1957 : : }
1958 : :
1959 : : /// If one of the arguments has the specified attribute, returns its
1960 : : /// operand value. Otherwise, return nullptr.
1961 : : Value *getArgOperandWithAttribute(Attribute::AttrKind Kind) const;
1962 : :
1963 : : /// Return true if the call should not be treated as a call to a
1964 : : /// builtin.
1965 : : bool isNoBuiltin() const {
1966 : : return hasFnAttrImpl(Attribute::NoBuiltin) &&
1967 : : !hasFnAttrImpl(Attribute::Builtin);
1968 : : }
1969 : :
1970 : : /// Determine if the call requires strict floating point semantics.
1971 : : bool isStrictFP() const { return hasFnAttr(Attribute::StrictFP); }
1972 : :
1973 : : /// Return true if the call should not be inlined.
1974 : : bool isNoInline() const { return hasFnAttr(Attribute::NoInline); }
1975 : : void setIsNoInline() { addFnAttr(Attribute::NoInline); }
1976 : :
1977 : : MemoryEffects getMemoryEffects() const;
1978 : : void setMemoryEffects(MemoryEffects ME);
1979 : :
1980 : : /// Determine if the call does not access memory.
1981 : : bool doesNotAccessMemory() const;
1982 : : void setDoesNotAccessMemory();
1983 : :
1984 : : /// Determine if the call does not access or only reads memory.
1985 : : bool onlyReadsMemory() const;
1986 : : void setOnlyReadsMemory();
1987 : :
1988 : : /// Determine if the call does not access or only writes memory.
1989 : : bool onlyWritesMemory() const;
1990 : : void setOnlyWritesMemory();
1991 : :
1992 : : /// Determine if the call can access memmory only using pointers based
1993 : : /// on its arguments.
1994 : : bool onlyAccessesArgMemory() const;
1995 : : void setOnlyAccessesArgMemory();
1996 : :
1997 : : /// Determine if the function may only access memory that is
1998 : : /// inaccessible from the IR.
1999 : : bool onlyAccessesInaccessibleMemory() const;
2000 : : void setOnlyAccessesInaccessibleMemory();
2001 : :
2002 : : /// Determine if the function may only access memory that is
2003 : : /// either inaccessible from the IR or pointed to by its arguments.
2004 : : bool onlyAccessesInaccessibleMemOrArgMem() const;
2005 : : void setOnlyAccessesInaccessibleMemOrArgMem();
2006 : :
2007 : : /// Determine if the call cannot return.
2008 : : bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); }
2009 : : void setDoesNotReturn() { addFnAttr(Attribute::NoReturn); }
2010 : :
2011 : : /// Determine if the call should not perform indirect branch tracking.
2012 : : bool doesNoCfCheck() const { return hasFnAttr(Attribute::NoCfCheck); }
2013 : :
2014 : : /// Determine if the call cannot unwind.
2015 : : bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); }
2016 : : void setDoesNotThrow() { addFnAttr(Attribute::NoUnwind); }
2017 : :
2018 : : /// Determine if the invoke cannot be duplicated.
2019 : : bool cannotDuplicate() const { return hasFnAttr(Attribute::NoDuplicate); }
2020 : : void setCannotDuplicate() { addFnAttr(Attribute::NoDuplicate); }
2021 : :
2022 : : /// Determine if the call cannot be tail merged.
2023 : : bool cannotMerge() const { return hasFnAttr(Attribute::NoMerge); }
2024 : : void setCannotMerge() { addFnAttr(Attribute::NoMerge); }
2025 : :
2026 : : /// Determine if the invoke is convergent
2027 : : bool isConvergent() const { return hasFnAttr(Attribute::Convergent); }
2028 : : void setConvergent() { addFnAttr(Attribute::Convergent); }
2029 : : void setNotConvergent() { removeFnAttr(Attribute::Convergent); }
2030 : :
2031 : : /// Determine if the call returns a structure through first
2032 : : /// pointer argument.
2033 : : bool hasStructRetAttr() const {
2034 : : if (arg_empty())
2035 : : return false;
2036 : :
2037 : : // Be friendly and also check the callee.
2038 : : return paramHasAttr(0, Attribute::StructRet);
2039 : : }
2040 : :
2041 : : /// Determine if any call argument is an aggregate passed by value.
2042 : : bool hasByValArgument() const {
2043 : : return Attrs.hasAttrSomewhere(Attribute::ByVal);
2044 : : }
2045 : :
2046 : : ///@}
2047 : : // End of attribute API.
2048 : :
2049 : : /// \name Operand Bundle API
2050 : : ///
2051 : : /// This group of methods provides the API to access and manipulate operand
2052 : : /// bundles on this call.
2053 : : /// @{
2054 : :
2055 : : /// Return the number of operand bundles associated with this User.
2056 : : unsigned getNumOperandBundles() const {
2057 : : return std::distance(bundle_op_info_begin(), bundle_op_info_end());
2058 : : }
2059 : :
2060 : : /// Return true if this User has any operand bundles.
2061 : : bool hasOperandBundles() const { return getNumOperandBundles() != 0; }
2062 : :
2063 : : /// Return the index of the first bundle operand in the Use array.
2064 : : unsigned getBundleOperandsStartIndex() const {
2065 : : assert(hasOperandBundles() && "Don't call otherwise!");
2066 : : return bundle_op_info_begin()->Begin;
2067 : : }
2068 : :
2069 : : /// Return the index of the last bundle operand in the Use array.
2070 : : unsigned getBundleOperandsEndIndex() const {
2071 : : assert(hasOperandBundles() && "Don't call otherwise!");
2072 : : return bundle_op_info_end()[-1].End;
2073 : : }
2074 : :
2075 : : /// Return true if the operand at index \p Idx is a bundle operand.
2076 : : bool isBundleOperand(unsigned Idx) const {
2077 : : return hasOperandBundles() && Idx >= getBundleOperandsStartIndex() &&
2078 : : Idx < getBundleOperandsEndIndex();
2079 : : }
2080 : :
2081 : : /// Return true if the operand at index \p Idx is a bundle operand that has
2082 : : /// tag ID \p ID.
2083 : : bool isOperandBundleOfType(uint32_t ID, unsigned Idx) const {
2084 : : return isBundleOperand(Idx) &&
2085 : : getOperandBundleForOperand(Idx).getTagID() == ID;
2086 : : }
2087 : :
2088 : : /// Returns true if the use is a bundle operand.
2089 : : bool isBundleOperand(const Use *U) const {
2090 : : assert(this == U->getUser() &&
2091 : : "Only valid to query with a use of this instruction!");
2092 : : return hasOperandBundles() && isBundleOperand(U - op_begin());
2093 : : }
2094 : : bool isBundleOperand(Value::const_user_iterator UI) const {
2095 : : return isBundleOperand(&UI.getUse());
2096 : : }
2097 : :
2098 : : /// Return the total number operands (not operand bundles) used by
2099 : : /// every operand bundle in this OperandBundleUser.
2100 : : unsigned getNumTotalBundleOperands() const {
2101 : : if (!hasOperandBundles())
2102 : : return 0;
2103 : :
2104 : : unsigned Begin = getBundleOperandsStartIndex();
2105 : : unsigned End = getBundleOperandsEndIndex();
2106 : :
2107 : : assert(Begin <= End && "Should be!");
2108 : : return End - Begin;
2109 : : }
2110 : :
2111 : : /// Return the operand bundle at a specific index.
2112 : : OperandBundleUse getOperandBundleAt(unsigned Index) const {
2113 : : assert(Index < getNumOperandBundles() && "Index out of bounds!");
2114 : : return operandBundleFromBundleOpInfo(*(bundle_op_info_begin() + Index));
2115 : : }
2116 : :
2117 : : /// Return the number of operand bundles with the tag Name attached to
2118 : : /// this instruction.
2119 : : unsigned countOperandBundlesOfType(StringRef Name) const {
2120 : : unsigned Count = 0;
2121 : : for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i)
2122 : : if (getOperandBundleAt(i).getTagName() == Name)
2123 : : Count++;
2124 : :
2125 : : return Count;
2126 : : }
2127 : :
2128 : : /// Return the number of operand bundles with the tag ID attached to
2129 : : /// this instruction.
2130 : : unsigned countOperandBundlesOfType(uint32_t ID) const {
2131 : : unsigned Count = 0;
2132 : : for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i)
2133 : : if (getOperandBundleAt(i).getTagID() == ID)
2134 : : Count++;
2135 : :
2136 : : return Count;
2137 : : }
2138 : :
2139 : : /// Return an operand bundle by name, if present.
2140 : : ///
2141 : : /// It is an error to call this for operand bundle types that may have
2142 : : /// multiple instances of them on the same instruction.
2143 : : std::optional<OperandBundleUse> getOperandBundle(StringRef Name) const {
2144 : : assert(countOperandBundlesOfType(Name) < 2 && "Precondition violated!");
2145 : :
2146 : : for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
2147 : : OperandBundleUse U = getOperandBundleAt(i);
2148 : : if (U.getTagName() == Name)
2149 : : return U;
2150 : : }
2151 : :
2152 : : return std::nullopt;
2153 : : }
2154 : :
2155 : : /// Return an operand bundle by tag ID, if present.
2156 : : ///
2157 : : /// It is an error to call this for operand bundle types that may have
2158 : : /// multiple instances of them on the same instruction.
2159 : : std::optional<OperandBundleUse> getOperandBundle(uint32_t ID) const {
2160 : : assert(countOperandBundlesOfType(ID) < 2 && "Precondition violated!");
2161 : :
2162 : : for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
2163 : : OperandBundleUse U = getOperandBundleAt(i);
2164 : : if (U.getTagID() == ID)
2165 : : return U;
2166 : : }
2167 : :
2168 : : return std::nullopt;
2169 : : }
2170 : :
2171 : : /// Return the list of operand bundles attached to this instruction as
2172 : : /// a vector of OperandBundleDefs.
2173 : : ///
2174 : : /// This function copies the OperandBundeUse instances associated with this
2175 : : /// OperandBundleUser to a vector of OperandBundleDefs. Note:
2176 : : /// OperandBundeUses and OperandBundleDefs are non-trivially *different*
2177 : : /// representations of operand bundles (see documentation above).
2178 : : void getOperandBundlesAsDefs(SmallVectorImpl<OperandBundleDef> &Defs) const;
2179 : :
2180 : : /// Return the operand bundle for the operand at index OpIdx.
2181 : : ///
2182 : : /// It is an error to call this with an OpIdx that does not correspond to an
2183 : : /// bundle operand.
2184 : : OperandBundleUse getOperandBundleForOperand(unsigned OpIdx) const {
2185 : : return operandBundleFromBundleOpInfo(getBundleOpInfoForOperand(OpIdx));
2186 : : }
2187 : :
2188 : : /// Return true if this operand bundle user has operand bundles that
2189 : : /// may read from the heap.
2190 : : bool hasReadingOperandBundles() const;
2191 : :
2192 : : /// Return true if this operand bundle user has operand bundles that
2193 : : /// may write to the heap.
2194 : : bool hasClobberingOperandBundles() const;
2195 : :
2196 : : /// Return true if the bundle operand at index \p OpIdx has the
2197 : : /// attribute \p A.
2198 : : bool bundleOperandHasAttr(unsigned OpIdx, Attribute::AttrKind A) const {
2199 : : auto &BOI = getBundleOpInfoForOperand(OpIdx);
2200 : : auto OBU = operandBundleFromBundleOpInfo(BOI);
2201 : : return OBU.operandHasAttr(OpIdx - BOI.Begin, A);
2202 : : }
2203 : :
2204 : : /// Return true if \p Other has the same sequence of operand bundle
2205 : : /// tags with the same number of operands on each one of them as this
2206 : : /// OperandBundleUser.
2207 : : bool hasIdenticalOperandBundleSchema(const CallBase &Other) const {
2208 : : if (getNumOperandBundles() != Other.getNumOperandBundles())
2209 : : return false;
2210 : :
2211 : : return std::equal(bundle_op_info_begin(), bundle_op_info_end(),
2212 : : Other.bundle_op_info_begin());
2213 : : }
2214 : :
2215 : : /// Return true if this operand bundle user contains operand bundles
2216 : : /// with tags other than those specified in \p IDs.
2217 : : bool hasOperandBundlesOtherThan(ArrayRef<uint32_t> IDs) const {
2218 : : for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
2219 : : uint32_t ID = getOperandBundleAt(i).getTagID();
2220 : : if (!is_contained(IDs, ID))
2221 : : return true;
2222 : : }
2223 : : return false;
2224 : : }
2225 : :
2226 : : /// Used to keep track of an operand bundle. See the main comment on
2227 : : /// OperandBundleUser above.
2228 : : struct BundleOpInfo {
2229 : : /// The operand bundle tag, interned by
2230 : : /// LLVMContextImpl::getOrInsertBundleTag.
2231 : : StringMapEntry<uint32_t> *Tag;
2232 : :
2233 : : /// The index in the Use& vector where operands for this operand
2234 : : /// bundle starts.
2235 : : uint32_t Begin;
2236 : :
2237 : : /// The index in the Use& vector where operands for this operand
2238 : : /// bundle ends.
2239 : : uint32_t End;
2240 : :
2241 : : bool operator==(const BundleOpInfo &Other) const {
2242 : : return Tag == Other.Tag && Begin == Other.Begin && End == Other.End;
2243 : : }
2244 : : };
2245 : :
2246 : : /// Simple helper function to map a BundleOpInfo to an
2247 : : /// OperandBundleUse.
2248 : : OperandBundleUse
2249 : : operandBundleFromBundleOpInfo(const BundleOpInfo &BOI) const {
2250 : : const auto *begin = op_begin();
2251 : : ArrayRef<Use> Inputs(begin + BOI.Begin, begin + BOI.End);
2252 : : return OperandBundleUse(BOI.Tag, Inputs);
2253 : : }
2254 : :
2255 : : using bundle_op_iterator = BundleOpInfo *;
2256 : : using const_bundle_op_iterator = const BundleOpInfo *;
2257 : :
2258 : : /// Return the start of the list of BundleOpInfo instances associated
2259 : : /// with this OperandBundleUser.
2260 : : ///
2261 : : /// OperandBundleUser uses the descriptor area co-allocated with the host User
2262 : : /// to store some meta information about which operands are "normal" operands,
2263 : : /// and which ones belong to some operand bundle.
2264 : : ///
2265 : : /// The layout of an operand bundle user is
2266 : : ///
2267 : : /// +-----------uint32_t End-------------------------------------+
2268 : : /// | |
2269 : : /// | +--------uint32_t Begin--------------------+ |
2270 : : /// | | | |
2271 : : /// ^ ^ v v
2272 : : /// |------|------|----|----|----|----|----|---------|----|---------|----|-----
2273 : : /// | BOI0 | BOI1 | .. | DU | U0 | U1 | .. | BOI0_U0 | .. | BOI1_U0 | .. | Un
2274 : : /// |------|------|----|----|----|----|----|---------|----|---------|----|-----
2275 : : /// v v ^ ^
2276 : : /// | | | |
2277 : : /// | +--------uint32_t Begin------------+ |
2278 : : /// | |
2279 : : /// +-----------uint32_t End-----------------------------+
2280 : : ///
2281 : : ///
2282 : : /// BOI0, BOI1 ... are descriptions of operand bundles in this User's use
2283 : : /// list. These descriptions are installed and managed by this class, and
2284 : : /// they're all instances of OperandBundleUser<T>::BundleOpInfo.
2285 : : ///
2286 : : /// DU is an additional descriptor installed by User's 'operator new' to keep
2287 : : /// track of the 'BOI0 ... BOIN' co-allocation. OperandBundleUser does not
2288 : : /// access or modify DU in any way, it's an implementation detail private to
2289 : : /// User.
2290 : : ///
2291 : : /// The regular Use& vector for the User starts at U0. The operand bundle
2292 : : /// uses are part of the Use& vector, just like normal uses. In the diagram
2293 : : /// above, the operand bundle uses start at BOI0_U0. Each instance of
2294 : : /// BundleOpInfo has information about a contiguous set of uses constituting
2295 : : /// an operand bundle, and the total set of operand bundle uses themselves
2296 : : /// form a contiguous set of uses (i.e. there are no gaps between uses
2297 : : /// corresponding to individual operand bundles).
2298 : : ///
2299 : : /// This class does not know the location of the set of operand bundle uses
2300 : : /// within the use list -- that is decided by the User using this class via
2301 : : /// the BeginIdx argument in populateBundleOperandInfos.
2302 : : ///
2303 : : /// Currently operand bundle users with hung-off operands are not supported.
2304 : : bundle_op_iterator bundle_op_info_begin() {
2305 : : if (!hasDescriptor())
2306 : : return nullptr;
2307 : :
2308 : : uint8_t *BytesBegin = getDescriptor().begin();
2309 : : return reinterpret_cast<bundle_op_iterator>(BytesBegin);
2310 : : }
2311 : :
2312 : : /// Return the start of the list of BundleOpInfo instances associated
2313 : : /// with this OperandBundleUser.
2314 : : const_bundle_op_iterator bundle_op_info_begin() const {
2315 : : auto *NonConstThis = const_cast<CallBase *>(this);
2316 : : return NonConstThis->bundle_op_info_begin();
2317 : : }
2318 : :
2319 : : /// Return the end of the list of BundleOpInfo instances associated
2320 : : /// with this OperandBundleUser.
2321 : : bundle_op_iterator bundle_op_info_end() {
2322 : : if (!hasDescriptor())
2323 : : return nullptr;
2324 : :
2325 : : uint8_t *BytesEnd = getDescriptor().end();
2326 : : return reinterpret_cast<bundle_op_iterator>(BytesEnd);
2327 : : }
2328 : :
2329 : : /// Return the end of the list of BundleOpInfo instances associated
2330 : : /// with this OperandBundleUser.
2331 : : const_bundle_op_iterator bundle_op_info_end() const {
2332 : : auto *NonConstThis = const_cast<CallBase *>(this);
2333 : : return NonConstThis->bundle_op_info_end();
2334 : : }
2335 : :
2336 : : /// Return the range [\p bundle_op_info_begin, \p bundle_op_info_end).
2337 : : iterator_range<bundle_op_iterator> bundle_op_infos() {
2338 : : return make_range(bundle_op_info_begin(), bundle_op_info_end());
2339 : : }
2340 : :
2341 : : /// Return the range [\p bundle_op_info_begin, \p bundle_op_info_end).
2342 : : iterator_range<const_bundle_op_iterator> bundle_op_infos() const {
2343 : : return make_range(bundle_op_info_begin(), bundle_op_info_end());
2344 : : }
2345 : :
2346 : : /// Populate the BundleOpInfo instances and the Use& vector from \p
2347 : : /// Bundles. Return the op_iterator pointing to the Use& one past the last
2348 : : /// last bundle operand use.
2349 : : ///
2350 : : /// Each \p OperandBundleDef instance is tracked by a OperandBundleInfo
2351 : : /// instance allocated in this User's descriptor.
2352 : : op_iterator populateBundleOperandInfos(ArrayRef<OperandBundleDef> Bundles,
2353 : : const unsigned BeginIndex);
2354 : :
2355 : : /// Return true if the call has deopt state bundle.
2356 : : bool hasDeoptState() const {
2357 : : return getOperandBundle(LLVMContext::OB_deopt).has_value();
2358 : : }
2359 : :
2360 : : public:
2361 : : /// Return the BundleOpInfo for the operand at index OpIdx.
2362 : : ///
2363 : : /// It is an error to call this with an OpIdx that does not correspond to an
2364 : : /// bundle operand.
2365 : : BundleOpInfo &getBundleOpInfoForOperand(unsigned OpIdx);
2366 : : const BundleOpInfo &getBundleOpInfoForOperand(unsigned OpIdx) const {
2367 : : return const_cast<CallBase *>(this)->getBundleOpInfoForOperand(OpIdx);
2368 : : }
2369 : :
2370 : : protected:
2371 : : /// Return the total number of values used in \p Bundles.
2372 : 0 : static unsigned CountBundleInputs(ArrayRef<OperandBundleDef> Bundles) {
2373 : 0 : unsigned Total = 0;
2374 [ # # ]: 0 : for (const auto &B : Bundles)
2375 : 0 : Total += B.input_size();
2376 : 0 : return Total;
2377 : : }
2378 : :
2379 : : /// @}
2380 : : // End of operand bundle API.
2381 : :
2382 : : private:
2383 : : bool hasFnAttrOnCalledFunction(Attribute::AttrKind Kind) const;
2384 : : bool hasFnAttrOnCalledFunction(StringRef Kind) const;
2385 : :
2386 : : template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const {
2387 : : if (Attrs.hasFnAttr(Kind))
2388 : : return true;
2389 : :
2390 : : return hasFnAttrOnCalledFunction(Kind);
2391 : : }
2392 : : template <typename AK> Attribute getFnAttrOnCalledFunction(AK Kind) const;
2393 : : template <typename AK>
2394 : : Attribute getParamAttrOnCalledFunction(unsigned ArgNo, AK Kind) const;
2395 : :
2396 : : /// Determine whether the return value has the given attribute. Supports
2397 : : /// Attribute::AttrKind and StringRef as \p AttrKind types.
2398 : : template <typename AttrKind> bool hasRetAttrImpl(AttrKind Kind) const {
2399 : : if (Attrs.hasRetAttr(Kind))
2400 : : return true;
2401 : :
2402 : : // Look at the callee, if available.
2403 : : if (const Function *F = getCalledFunction())
2404 : : return F->getAttributes().hasRetAttr(Kind);
2405 : : return false;
2406 : : }
2407 : : };
2408 : :
2409 : : template <>
2410 : : struct OperandTraits<CallBase> : public VariadicOperandTraits<CallBase, 1> {};
2411 : :
2412 : 0 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CallBase, Value)
2413 : :
2414 : : //===----------------------------------------------------------------------===//
2415 : : // FuncletPadInst Class
2416 : : //===----------------------------------------------------------------------===//
2417 : : class FuncletPadInst : public Instruction {
2418 : : private:
2419 : : FuncletPadInst(const FuncletPadInst &CPI);
2420 : :
2421 : : explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
2422 : : ArrayRef<Value *> Args, unsigned Values,
2423 : : const Twine &NameStr, InsertPosition InsertBefore);
2424 : :
2425 : : void init(Value *ParentPad, ArrayRef<Value *> Args, const Twine &NameStr);
2426 : :
2427 : : protected:
2428 : : // Note: Instruction needs to be a friend here to call cloneImpl.
2429 : : friend class Instruction;
2430 : : friend class CatchPadInst;
2431 : : friend class CleanupPadInst;
2432 : :
2433 : : FuncletPadInst *cloneImpl() const;
2434 : :
2435 : : public:
2436 : : /// Provide fast operand accessors
2437 : : DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
2438 : :
2439 : : /// arg_size - Return the number of funcletpad arguments.
2440 : : ///
2441 : : unsigned arg_size() const { return getNumOperands() - 1; }
2442 : :
2443 : : /// Convenience accessors
2444 : :
2445 : : /// Return the outer EH-pad this funclet is nested within.
2446 : : ///
2447 : : /// Note: This returns the associated CatchSwitchInst if this FuncletPadInst
2448 : : /// is a CatchPadInst.
2449 : : Value *getParentPad() const { return Op<-1>(); }
2450 : : void setParentPad(Value *ParentPad) {
2451 : : assert(ParentPad);
2452 : : Op<-1>() = ParentPad;
2453 : : }
2454 : :
2455 : : /// getArgOperand/setArgOperand - Return/set the i-th funcletpad argument.
2456 : : ///
2457 : : Value *getArgOperand(unsigned i) const { return getOperand(i); }
2458 : : void setArgOperand(unsigned i, Value *v) { setOperand(i, v); }
2459 : :
2460 : : /// arg_operands - iteration adapter for range-for loops.
2461 : : op_range arg_operands() { return op_range(op_begin(), op_end() - 1); }
2462 : :
2463 : : /// arg_operands - iteration adapter for range-for loops.
2464 : : const_op_range arg_operands() const {
2465 : : return const_op_range(op_begin(), op_end() - 1);
2466 : : }
2467 : :
2468 : : // Methods for support type inquiry through isa, cast, and dyn_cast:
2469 : : static bool classof(const Instruction *I) { return I->isFuncletPad(); }
2470 : : static bool classof(const Value *V) {
2471 : : return isa<Instruction>(V) && classof(cast<Instruction>(V));
2472 : : }
2473 : : };
2474 : :
2475 : : template <>
2476 : : struct OperandTraits<FuncletPadInst>
2477 : : : public VariadicOperandTraits<FuncletPadInst, /*MINARITY=*/1> {};
2478 : :
2479 : : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(FuncletPadInst, Value)
2480 : :
2481 : : } // end namespace llvm
2482 : :
2483 : : #endif // LLVM_IR_INSTRTYPES_H
|
