1//===-- llvm/Operator.h - Operator utility subclass -------------*- 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 classes for working with Instructions and
10// ConstantExprs.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_IR_OPERATOR_H
15#define LLVM_IR_OPERATOR_H
16
17#include "llvm/ADT/MapVector.h"
18#include "llvm/IR/Constants.h"
19#include "llvm/IR/FMF.h"
20#include "llvm/IR/GEPNoWrapFlags.h"
21#include "llvm/IR/Instruction.h"
22#include "llvm/IR/Type.h"
23#include "llvm/IR/Value.h"
24#include "llvm/Support/Casting.h"
25#include <cstddef>
26#include <optional>
27
28namespace llvm {
29
30/// This is a utility class that provides an abstraction for the common
31/// functionality between Instructions and ConstantExprs.
32class Operator : public User {
33public:
34 // The Operator class is intended to be used as a utility, and is never itself
35 // instantiated.
36 Operator() = delete;
37 ~Operator() = delete;
38
39 void *operator new(size_t s) = delete;
40
41 /// Return the opcode for this Instruction or ConstantExpr.
42 unsigned getOpcode() const {
43 if (const Instruction *I = dyn_cast<Instruction>(Val: this))
44 return I->getOpcode();
45 return cast<ConstantExpr>(Val: this)->getOpcode();
46 }
47
48 /// If V is an Instruction or ConstantExpr, return its opcode.
49 /// Otherwise return UserOp1.
50 static unsigned getOpcode(const Value *V) {
51 if (const Instruction *I = dyn_cast<Instruction>(Val: V))
52 return I->getOpcode();
53 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(Val: V))
54 return CE->getOpcode();
55 return Instruction::UserOp1;
56 }
57
58 static bool classof(const Instruction *) { return true; }
59 static bool classof(const ConstantExpr *) { return true; }
60 static bool classof(const Value *V) {
61 return isa<Instruction>(Val: V) || isa<ConstantExpr>(Val: V);
62 }
63
64 /// Return true if this operator has flags which may cause this operator
65 /// to evaluate to poison despite having non-poison inputs.
66 bool hasPoisonGeneratingFlags() const;
67
68 /// Return true if this operator has poison-generating flags,
69 /// return attributes or metadata. The latter two is only possible for
70 /// instructions.
71 bool hasPoisonGeneratingAnnotations() const;
72};
73
74/// Utility class for integer operators which may exhibit overflow - Add, Sub,
75/// Mul, and Shl. It does not include SDiv, despite that operator having the
76/// potential for overflow.
77class OverflowingBinaryOperator : public Operator {
78public:
79 enum {
80 AnyWrap = 0,
81 NoUnsignedWrap = (1 << 0),
82 NoSignedWrap = (1 << 1)
83 };
84
85private:
86 friend class Instruction;
87 friend class ConstantExpr;
88
89 void setHasNoUnsignedWrap(bool B) {
90 SubclassOptionalData =
91 (SubclassOptionalData & ~NoUnsignedWrap) | (B * NoUnsignedWrap);
92 }
93 void setHasNoSignedWrap(bool B) {
94 SubclassOptionalData =
95 (SubclassOptionalData & ~NoSignedWrap) | (B * NoSignedWrap);
96 }
97
98public:
99 /// Transparently provide more efficient getOperand methods.
100 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
101
102 /// Test whether this operation is known to never
103 /// undergo unsigned overflow, aka the nuw property.
104 bool hasNoUnsignedWrap() const {
105 return SubclassOptionalData & NoUnsignedWrap;
106 }
107
108 /// Test whether this operation is known to never
109 /// undergo signed overflow, aka the nsw property.
110 bool hasNoSignedWrap() const {
111 return (SubclassOptionalData & NoSignedWrap) != 0;
112 }
113
114 /// Returns the no-wrap kind of the operation.
115 unsigned getNoWrapKind() const {
116 unsigned NoWrapKind = 0;
117 if (hasNoUnsignedWrap())
118 NoWrapKind |= NoUnsignedWrap;
119
120 if (hasNoSignedWrap())
121 NoWrapKind |= NoSignedWrap;
122
123 return NoWrapKind;
124 }
125
126 static bool classof(const Instruction *I) {
127 return I->getOpcode() == Instruction::Add ||
128 I->getOpcode() == Instruction::Sub ||
129 I->getOpcode() == Instruction::Mul ||
130 I->getOpcode() == Instruction::Shl;
131 }
132 static bool classof(const ConstantExpr *CE) {
133 return CE->getOpcode() == Instruction::Add ||
134 CE->getOpcode() == Instruction::Sub ||
135 CE->getOpcode() == Instruction::Mul ||
136 CE->getOpcode() == Instruction::Shl;
137 }
138 static bool classof(const Value *V) {
139 return (isa<Instruction>(Val: V) && classof(I: cast<Instruction>(Val: V))) ||
140 (isa<ConstantExpr>(Val: V) && classof(CE: cast<ConstantExpr>(Val: V)));
141 }
142};
143
144template <>
145struct OperandTraits<OverflowingBinaryOperator>
146 : public FixedNumOperandTraits<OverflowingBinaryOperator, 2> {};
147
148DEFINE_TRANSPARENT_OPERAND_ACCESSORS(OverflowingBinaryOperator, Value)
149
150/// A udiv or sdiv instruction, which can be marked as "exact",
151/// indicating that no bits are destroyed.
152class PossiblyExactOperator : public Operator {
153public:
154 enum {
155 IsExact = (1 << 0)
156 };
157
158private:
159 friend class Instruction;
160 friend class ConstantExpr;
161
162 void setIsExact(bool B) {
163 SubclassOptionalData = (SubclassOptionalData & ~IsExact) | (B * IsExact);
164 }
165
166public:
167 /// Transparently provide more efficient getOperand methods.
168 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
169
170 /// Test whether this division is known to be exact, with zero remainder.
171 bool isExact() const {
172 return SubclassOptionalData & IsExact;
173 }
174
175 static bool isPossiblyExactOpcode(unsigned OpC) {
176 return OpC == Instruction::SDiv ||
177 OpC == Instruction::UDiv ||
178 OpC == Instruction::AShr ||
179 OpC == Instruction::LShr;
180 }
181
182 static bool classof(const ConstantExpr *CE) {
183 return isPossiblyExactOpcode(OpC: CE->getOpcode());
184 }
185 static bool classof(const Instruction *I) {
186 return isPossiblyExactOpcode(OpC: I->getOpcode());
187 }
188 static bool classof(const Value *V) {
189 return (isa<Instruction>(Val: V) && classof(I: cast<Instruction>(Val: V))) ||
190 (isa<ConstantExpr>(Val: V) && classof(CE: cast<ConstantExpr>(Val: V)));
191 }
192};
193
194template <>
195struct OperandTraits<PossiblyExactOperator>
196 : public FixedNumOperandTraits<PossiblyExactOperator, 2> {};
197
198DEFINE_TRANSPARENT_OPERAND_ACCESSORS(PossiblyExactOperator, Value)
199
200/// Utility class for floating point operations which can have
201/// information about relaxed accuracy requirements attached to them.
202class FPMathOperator : public Operator {
203private:
204 friend class Instruction;
205
206 /// 'Fast' means all bits are set.
207 void setFast(bool B) {
208 setHasAllowReassoc(B);
209 setHasNoNaNs(B);
210 setHasNoInfs(B);
211 setHasNoSignedZeros(B);
212 setHasAllowReciprocal(B);
213 setHasAllowContract(B);
214 setHasApproxFunc(B);
215 }
216
217 void setHasAllowReassoc(bool B) {
218 SubclassOptionalData =
219 (SubclassOptionalData & ~FastMathFlags::AllowReassoc) |
220 (B * FastMathFlags::AllowReassoc);
221 }
222
223 void setHasNoNaNs(bool B) {
224 SubclassOptionalData =
225 (SubclassOptionalData & ~FastMathFlags::NoNaNs) |
226 (B * FastMathFlags::NoNaNs);
227 }
228
229 void setHasNoInfs(bool B) {
230 SubclassOptionalData =
231 (SubclassOptionalData & ~FastMathFlags::NoInfs) |
232 (B * FastMathFlags::NoInfs);
233 }
234
235 void setHasNoSignedZeros(bool B) {
236 SubclassOptionalData =
237 (SubclassOptionalData & ~FastMathFlags::NoSignedZeros) |
238 (B * FastMathFlags::NoSignedZeros);
239 }
240
241 void setHasAllowReciprocal(bool B) {
242 SubclassOptionalData =
243 (SubclassOptionalData & ~FastMathFlags::AllowReciprocal) |
244 (B * FastMathFlags::AllowReciprocal);
245 }
246
247 void setHasAllowContract(bool B) {
248 SubclassOptionalData =
249 (SubclassOptionalData & ~FastMathFlags::AllowContract) |
250 (B * FastMathFlags::AllowContract);
251 }
252
253 void setHasApproxFunc(bool B) {
254 SubclassOptionalData =
255 (SubclassOptionalData & ~FastMathFlags::ApproxFunc) |
256 (B * FastMathFlags::ApproxFunc);
257 }
258
259 /// Convenience function for setting multiple fast-math flags.
260 /// FMF is a mask of the bits to set.
261 void setFastMathFlags(FastMathFlags FMF) {
262 SubclassOptionalData |= FMF.Flags;
263 }
264
265 /// Convenience function for copying all fast-math flags.
266 /// All values in FMF are transferred to this operator.
267 void copyFastMathFlags(FastMathFlags FMF) {
268 SubclassOptionalData = FMF.Flags;
269 }
270
271public:
272 /// Test if this operation allows all non-strict floating-point transforms.
273 bool isFast() const {
274 return ((SubclassOptionalData & FastMathFlags::AllowReassoc) != 0 &&
275 (SubclassOptionalData & FastMathFlags::NoNaNs) != 0 &&
276 (SubclassOptionalData & FastMathFlags::NoInfs) != 0 &&
277 (SubclassOptionalData & FastMathFlags::NoSignedZeros) != 0 &&
278 (SubclassOptionalData & FastMathFlags::AllowReciprocal) != 0 &&
279 (SubclassOptionalData & FastMathFlags::AllowContract) != 0 &&
280 (SubclassOptionalData & FastMathFlags::ApproxFunc) != 0);
281 }
282
283 /// Test if this operation may be simplified with reassociative transforms.
284 bool hasAllowReassoc() const {
285 return (SubclassOptionalData & FastMathFlags::AllowReassoc) != 0;
286 }
287
288 /// Test if this operation's arguments and results are assumed not-NaN.
289 bool hasNoNaNs() const {
290 return (SubclassOptionalData & FastMathFlags::NoNaNs) != 0;
291 }
292
293 /// Test if this operation's arguments and results are assumed not-infinite.
294 bool hasNoInfs() const {
295 return (SubclassOptionalData & FastMathFlags::NoInfs) != 0;
296 }
297
298 /// Test if this operation can ignore the sign of zero.
299 bool hasNoSignedZeros() const {
300 return (SubclassOptionalData & FastMathFlags::NoSignedZeros) != 0;
301 }
302
303 /// Test if this operation can use reciprocal multiply instead of division.
304 bool hasAllowReciprocal() const {
305 return (SubclassOptionalData & FastMathFlags::AllowReciprocal) != 0;
306 }
307
308 /// Test if this operation can be floating-point contracted (FMA).
309 bool hasAllowContract() const {
310 return (SubclassOptionalData & FastMathFlags::AllowContract) != 0;
311 }
312
313 /// Test if this operation allows approximations of math library functions or
314 /// intrinsics.
315 bool hasApproxFunc() const {
316 return (SubclassOptionalData & FastMathFlags::ApproxFunc) != 0;
317 }
318
319 /// Convenience function for getting all the fast-math flags
320 FastMathFlags getFastMathFlags() const {
321 return FastMathFlags(SubclassOptionalData);
322 }
323
324 /// Get the maximum error permitted by this operation in ULPs. An accuracy of
325 /// 0.0 means that the operation should be performed with the default
326 /// precision.
327 float getFPAccuracy() const;
328
329 static bool classof(const Value *V) {
330 unsigned Opcode;
331 if (auto *I = dyn_cast<Instruction>(Val: V))
332 Opcode = I->getOpcode();
333 else
334 return false;
335
336 switch (Opcode) {
337 case Instruction::FNeg:
338 case Instruction::FAdd:
339 case Instruction::FSub:
340 case Instruction::FMul:
341 case Instruction::FDiv:
342 case Instruction::FRem:
343 // FIXME: To clean up and correct the semantics of fast-math-flags, FCmp
344 // should not be treated as a math op, but the other opcodes should.
345 // This would make things consistent with Select/PHI (FP value type
346 // determines whether they are math ops and, therefore, capable of
347 // having fast-math-flags).
348 case Instruction::FCmp:
349 return true;
350 case Instruction::PHI:
351 case Instruction::Select:
352 case Instruction::Call: {
353 Type *Ty = V->getType();
354 while (ArrayType *ArrTy = dyn_cast<ArrayType>(Val: Ty))
355 Ty = ArrTy->getElementType();
356 return Ty->isFPOrFPVectorTy();
357 }
358 default:
359 return false;
360 }
361 }
362};
363
364/// A helper template for defining operators for individual opcodes.
365template<typename SuperClass, unsigned Opc>
366class ConcreteOperator : public SuperClass {
367public:
368 static bool classof(const Instruction *I) {
369 return I->getOpcode() == Opc;
370 }
371 static bool classof(const ConstantExpr *CE) {
372 return CE->getOpcode() == Opc;
373 }
374 static bool classof(const Value *V) {
375 return (isa<Instruction>(Val: V) && classof(cast<Instruction>(Val: V))) ||
376 (isa<ConstantExpr>(Val: V) && classof(cast<ConstantExpr>(Val: V)));
377 }
378};
379
380class AddOperator
381 : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Add> {
382};
383class SubOperator
384 : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Sub> {
385};
386class MulOperator
387 : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Mul> {
388};
389class ShlOperator
390 : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Shl> {
391};
392
393class AShrOperator
394 : public ConcreteOperator<PossiblyExactOperator, Instruction::AShr> {
395};
396class LShrOperator
397 : public ConcreteOperator<PossiblyExactOperator, Instruction::LShr> {
398};
399
400class GEPOperator
401 : public ConcreteOperator<Operator, Instruction::GetElementPtr> {
402public:
403 /// Transparently provide more efficient getOperand methods.
404 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
405
406 GEPNoWrapFlags getNoWrapFlags() const {
407 return GEPNoWrapFlags::fromRaw(Flags: SubclassOptionalData);
408 }
409
410 /// Test whether this is an inbounds GEP, as defined by LangRef.html.
411 bool isInBounds() const { return getNoWrapFlags().isInBounds(); }
412
413 bool hasNoUnsignedSignedWrap() const {
414 return getNoWrapFlags().hasNoUnsignedSignedWrap();
415 }
416
417 bool hasNoUnsignedWrap() const {
418 return getNoWrapFlags().hasNoUnsignedWrap();
419 }
420
421 /// Returns the offset of the index with an inrange attachment, or
422 /// std::nullopt if none.
423 std::optional<ConstantRange> getInRange() const;
424
425 inline op_iterator idx_begin() { return op_begin()+1; }
426 inline const_op_iterator idx_begin() const { return op_begin()+1; }
427 inline op_iterator idx_end() { return op_end(); }
428 inline const_op_iterator idx_end() const { return op_end(); }
429
430 inline iterator_range<op_iterator> indices() {
431 return make_range(x: idx_begin(), y: idx_end());
432 }
433
434 inline iterator_range<const_op_iterator> indices() const {
435 return make_range(x: idx_begin(), y: idx_end());
436 }
437
438 Value *getPointerOperand() {
439 return getOperand(0);
440 }
441 const Value *getPointerOperand() const {
442 return getOperand(0);
443 }
444 static unsigned getPointerOperandIndex() {
445 return 0U; // get index for modifying correct operand
446 }
447
448 /// Method to return the pointer operand as a PointerType.
449 Type *getPointerOperandType() const {
450 return getPointerOperand()->getType();
451 }
452
453 Type *getSourceElementType() const;
454 Type *getResultElementType() const;
455
456 /// Method to return the address space of the pointer operand.
457 unsigned getPointerAddressSpace() const {
458 return getPointerOperandType()->getPointerAddressSpace();
459 }
460
461 unsigned getNumIndices() const { // Note: always non-negative
462 return getNumOperands() - 1;
463 }
464
465 bool hasIndices() const {
466 return getNumOperands() > 1;
467 }
468
469 /// Return true if all of the indices of this GEP are zeros.
470 /// If so, the result pointer and the first operand have the same
471 /// value, just potentially different types.
472 bool hasAllZeroIndices() const {
473 for (const_op_iterator I = idx_begin(), E = idx_end(); I != E; ++I) {
474 if (ConstantInt *C = dyn_cast<ConstantInt>(Val: I))
475 if (C->isZero())
476 continue;
477 return false;
478 }
479 return true;
480 }
481
482 /// Return true if all of the indices of this GEP are constant integers.
483 /// If so, the result pointer and the first operand have
484 /// a constant offset between them.
485 bool hasAllConstantIndices() const {
486 for (const_op_iterator I = idx_begin(), E = idx_end(); I != E; ++I) {
487 if (!isa<ConstantInt>(Val: I))
488 return false;
489 }
490 return true;
491 }
492
493 unsigned countNonConstantIndices() const {
494 return count_if(Range: indices(), P: [](const Use& use) {
495 return !isa<ConstantInt>(Val: *use);
496 });
497 }
498
499 /// Compute the maximum alignment that this GEP is garranteed to preserve.
500 Align getMaxPreservedAlignment(const DataLayout &DL) const;
501
502 /// Accumulate the constant address offset of this GEP if possible.
503 ///
504 /// This routine accepts an APInt into which it will try to accumulate the
505 /// constant offset of this GEP.
506 ///
507 /// If \p ExternalAnalysis is provided it will be used to calculate a offset
508 /// when a operand of GEP is not constant.
509 /// For example, for a value \p ExternalAnalysis might try to calculate a
510 /// lower bound. If \p ExternalAnalysis is successful, it should return true.
511 ///
512 /// If the \p ExternalAnalysis returns false or the value returned by \p
513 /// ExternalAnalysis results in a overflow/underflow, this routine returns
514 /// false and the value of the offset APInt is undefined (it is *not*
515 /// preserved!).
516 ///
517 /// The APInt passed into this routine must be at exactly as wide as the
518 /// IntPtr type for the address space of the base GEP pointer.
519 bool accumulateConstantOffset(
520 const DataLayout &DL, APInt &Offset,
521 function_ref<bool(Value &, APInt &)> ExternalAnalysis = nullptr) const;
522
523 static bool accumulateConstantOffset(
524 Type *SourceType, ArrayRef<const Value *> Index, const DataLayout &DL,
525 APInt &Offset,
526 function_ref<bool(Value &, APInt &)> ExternalAnalysis = nullptr);
527
528 /// Collect the offset of this GEP as a map of Values to their associated
529 /// APInt multipliers, as well as a total Constant Offset.
530 bool collectOffset(const DataLayout &DL, unsigned BitWidth,
531 MapVector<Value *, APInt> &VariableOffsets,
532 APInt &ConstantOffset) const;
533};
534
535template <>
536struct OperandTraits<GEPOperator>
537 : public VariadicOperandTraits<GEPOperator, 1> {};
538
539DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GEPOperator, Value)
540
541class PtrToIntOperator
542 : public ConcreteOperator<Operator, Instruction::PtrToInt> {
543 friend class PtrToInt;
544 friend class ConstantExpr;
545
546public:
547 /// Transparently provide more efficient getOperand methods.
548 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
549
550 Value *getPointerOperand() {
551 return getOperand(0);
552 }
553 const Value *getPointerOperand() const {
554 return getOperand(0);
555 }
556
557 static unsigned getPointerOperandIndex() {
558 return 0U; // get index for modifying correct operand
559 }
560
561 /// Method to return the pointer operand as a PointerType.
562 Type *getPointerOperandType() const {
563 return getPointerOperand()->getType();
564 }
565
566 /// Method to return the address space of the pointer operand.
567 unsigned getPointerAddressSpace() const {
568 return cast<PointerType>(Val: getPointerOperandType())->getAddressSpace();
569 }
570};
571
572template <>
573struct OperandTraits<PtrToIntOperator>
574 : public FixedNumOperandTraits<PtrToIntOperator, 1> {};
575
576DEFINE_TRANSPARENT_OPERAND_ACCESSORS(PtrToIntOperator, Value)
577
578class BitCastOperator
579 : public ConcreteOperator<Operator, Instruction::BitCast> {
580 friend class BitCastInst;
581 friend class ConstantExpr;
582
583public:
584 /// Transparently provide more efficient getOperand methods.
585 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
586
587 Type *getSrcTy() const {
588 return getOperand(0)->getType();
589 }
590
591 Type *getDestTy() const {
592 return getType();
593 }
594};
595
596template <>
597struct OperandTraits<BitCastOperator>
598 : public FixedNumOperandTraits<BitCastOperator, 1> {};
599
600DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BitCastOperator, Value)
601
602class AddrSpaceCastOperator
603 : public ConcreteOperator<Operator, Instruction::AddrSpaceCast> {
604 friend class AddrSpaceCastInst;
605 friend class ConstantExpr;
606
607public:
608 /// Transparently provide more efficient getOperand methods.
609 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
610
611 Value *getPointerOperand() { return getOperand(0); }
612
613 const Value *getPointerOperand() const { return getOperand(0); }
614
615 unsigned getSrcAddressSpace() const {
616 return getPointerOperand()->getType()->getPointerAddressSpace();
617 }
618
619 unsigned getDestAddressSpace() const {
620 return getType()->getPointerAddressSpace();
621 }
622};
623
624template <>
625struct OperandTraits<AddrSpaceCastOperator>
626 : public FixedNumOperandTraits<AddrSpaceCastOperator, 1> {};
627
628DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AddrSpaceCastOperator, Value)
629
630} // end namespace llvm
631
632#endif // LLVM_IR_OPERATOR_H
633