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

source code of llvm/include/llvm/IR/Operator.h