LLVM  9.0.0svn
SelectionDAGNodes.h
Go to the documentation of this file.
1 //===- llvm/CodeGen/SelectionDAGNodes.h - SelectionDAG Nodes ----*- 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 declares the SDNode class and derived classes, which are used to
10 // represent the nodes and operations present in a SelectionDAG. These nodes
11 // and operations are machine code level operations, with some similarities to
12 // the GCC RTL representation.
13 //
14 // Clients should include the SelectionDAG.h file instead of this file directly.
15 //
16 //===----------------------------------------------------------------------===//
17 
18 #ifndef LLVM_CODEGEN_SELECTIONDAGNODES_H
19 #define LLVM_CODEGEN_SELECTIONDAGNODES_H
20 
21 #include "llvm/ADT/APFloat.h"
22 #include "llvm/ADT/ArrayRef.h"
23 #include "llvm/ADT/BitVector.h"
24 #include "llvm/ADT/FoldingSet.h"
25 #include "llvm/ADT/GraphTraits.h"
26 #include "llvm/ADT/SmallPtrSet.h"
27 #include "llvm/ADT/SmallVector.h"
28 #include "llvm/ADT/ilist_node.h"
29 #include "llvm/ADT/iterator.h"
34 #include "llvm/IR/Constants.h"
35 #include "llvm/IR/DebugLoc.h"
36 #include "llvm/IR/Instruction.h"
37 #include "llvm/IR/Instructions.h"
38 #include "llvm/IR/Metadata.h"
39 #include "llvm/IR/Operator.h"
40 #include "llvm/Support/AlignOf.h"
42 #include "llvm/Support/Casting.h"
45 #include <algorithm>
46 #include <cassert>
47 #include <climits>
48 #include <cstddef>
49 #include <cstdint>
50 #include <cstring>
51 #include <iterator>
52 #include <string>
53 #include <tuple>
54 
55 namespace llvm {
56 
57 class APInt;
58 class Constant;
59 template <typename T> struct DenseMapInfo;
60 class GlobalValue;
61 class MachineBasicBlock;
62 class MachineConstantPoolValue;
63 class MCSymbol;
64 class raw_ostream;
65 class SDNode;
66 class SelectionDAG;
67 class Type;
68 class Value;
69 
70 void checkForCycles(const SDNode *N, const SelectionDAG *DAG = nullptr,
71  bool force = false);
72 
73 /// This represents a list of ValueType's that has been intern'd by
74 /// a SelectionDAG. Instances of this simple value class are returned by
75 /// SelectionDAG::getVTList(...).
76 ///
77 struct SDVTList {
78  const EVT *VTs;
79  unsigned int NumVTs;
80 };
81 
82 namespace ISD {
83 
84  /// Node predicates
85 
86  /// If N is a BUILD_VECTOR node whose elements are all the same constant or
87  /// undefined, return true and return the constant value in \p SplatValue.
88  bool isConstantSplatVector(const SDNode *N, APInt &SplatValue);
89 
90  /// Return true if the specified node is a BUILD_VECTOR where all of the
91  /// elements are ~0 or undef.
92  bool isBuildVectorAllOnes(const SDNode *N);
93 
94  /// Return true if the specified node is a BUILD_VECTOR where all of the
95  /// elements are 0 or undef.
96  bool isBuildVectorAllZeros(const SDNode *N);
97 
98  /// Return true if the specified node is a BUILD_VECTOR node of all
99  /// ConstantSDNode or undef.
100  bool isBuildVectorOfConstantSDNodes(const SDNode *N);
101 
102  /// Return true if the specified node is a BUILD_VECTOR node of all
103  /// ConstantFPSDNode or undef.
105 
106  /// Return true if the node has at least one operand and all operands of the
107  /// specified node are ISD::UNDEF.
108  bool allOperandsUndef(const SDNode *N);
109 
110 } // end namespace ISD
111 
112 //===----------------------------------------------------------------------===//
113 /// Unlike LLVM values, Selection DAG nodes may return multiple
114 /// values as the result of a computation. Many nodes return multiple values,
115 /// from loads (which define a token and a return value) to ADDC (which returns
116 /// a result and a carry value), to calls (which may return an arbitrary number
117 /// of values).
118 ///
119 /// As such, each use of a SelectionDAG computation must indicate the node that
120 /// computes it as well as which return value to use from that node. This pair
121 /// of information is represented with the SDValue value type.
122 ///
123 class SDValue {
124  friend struct DenseMapInfo<SDValue>;
125 
126  SDNode *Node = nullptr; // The node defining the value we are using.
127  unsigned ResNo = 0; // Which return value of the node we are using.
128 
129 public:
130  SDValue() = default;
131  SDValue(SDNode *node, unsigned resno);
132 
133  /// get the index which selects a specific result in the SDNode
134  unsigned getResNo() const { return ResNo; }
135 
136  /// get the SDNode which holds the desired result
137  SDNode *getNode() const { return Node; }
138 
139  /// set the SDNode
140  void setNode(SDNode *N) { Node = N; }
141 
142  inline SDNode *operator->() const { return Node; }
143 
144  bool operator==(const SDValue &O) const {
145  return Node == O.Node && ResNo == O.ResNo;
146  }
147  bool operator!=(const SDValue &O) const {
148  return !operator==(O);
149  }
150  bool operator<(const SDValue &O) const {
151  return std::tie(Node, ResNo) < std::tie(O.Node, O.ResNo);
152  }
153  explicit operator bool() const {
154  return Node != nullptr;
155  }
156 
157  SDValue getValue(unsigned R) const {
158  return SDValue(Node, R);
159  }
160 
161  /// Return true if this node is an operand of N.
162  bool isOperandOf(const SDNode *N) const;
163 
164  /// Return the ValueType of the referenced return value.
165  inline EVT getValueType() const;
166 
167  /// Return the simple ValueType of the referenced return value.
169  return getValueType().getSimpleVT();
170  }
171 
172  /// Returns the size of the value in bits.
173  unsigned getValueSizeInBits() const {
174  return getValueType().getSizeInBits();
175  }
176 
177  unsigned getScalarValueSizeInBits() const {
178  return getValueType().getScalarType().getSizeInBits();
179  }
180 
181  // Forwarding methods - These forward to the corresponding methods in SDNode.
182  inline unsigned getOpcode() const;
183  inline unsigned getNumOperands() const;
184  inline const SDValue &getOperand(unsigned i) const;
185  inline uint64_t getConstantOperandVal(unsigned i) const;
186  inline const APInt &getConstantOperandAPInt(unsigned i) const;
187  inline bool isTargetMemoryOpcode() const;
188  inline bool isTargetOpcode() const;
189  inline bool isMachineOpcode() const;
190  inline bool isUndef() const;
191  inline unsigned getMachineOpcode() const;
192  inline const DebugLoc &getDebugLoc() const;
193  inline void dump() const;
194  inline void dump(const SelectionDAG *G) const;
195  inline void dumpr() const;
196  inline void dumpr(const SelectionDAG *G) const;
197 
198  /// Return true if this operand (which must be a chain) reaches the
199  /// specified operand without crossing any side-effecting instructions.
200  /// In practice, this looks through token factors and non-volatile loads.
201  /// In order to remain efficient, this only
202  /// looks a couple of nodes in, it does not do an exhaustive search.
203  bool reachesChainWithoutSideEffects(SDValue Dest,
204  unsigned Depth = 2) const;
205 
206  /// Return true if there are no nodes using value ResNo of Node.
207  inline bool use_empty() const;
208 
209  /// Return true if there is exactly one node using value ResNo of Node.
210  inline bool hasOneUse() const;
211 };
212 
213 template<> struct DenseMapInfo<SDValue> {
214  static inline SDValue getEmptyKey() {
215  SDValue V;
216  V.ResNo = -1U;
217  return V;
218  }
219 
220  static inline SDValue getTombstoneKey() {
221  SDValue V;
222  V.ResNo = -2U;
223  return V;
224  }
225 
226  static unsigned getHashValue(const SDValue &Val) {
227  return ((unsigned)((uintptr_t)Val.getNode() >> 4) ^
228  (unsigned)((uintptr_t)Val.getNode() >> 9)) + Val.getResNo();
229  }
230 
231  static bool isEqual(const SDValue &LHS, const SDValue &RHS) {
232  return LHS == RHS;
233  }
234 };
235 
236 /// Allow casting operators to work directly on
237 /// SDValues as if they were SDNode*'s.
238 template<> struct simplify_type<SDValue> {
239  using SimpleType = SDNode *;
240 
242  return Val.getNode();
243  }
244 };
245 template<> struct simplify_type<const SDValue> {
246  using SimpleType = /*const*/ SDNode *;
247 
248  static SimpleType getSimplifiedValue(const SDValue &Val) {
249  return Val.getNode();
250  }
251 };
252 
253 /// Represents a use of a SDNode. This class holds an SDValue,
254 /// which records the SDNode being used and the result number, a
255 /// pointer to the SDNode using the value, and Next and Prev pointers,
256 /// which link together all the uses of an SDNode.
257 ///
258 class SDUse {
259  /// Val - The value being used.
260  SDValue Val;
261  /// User - The user of this value.
262  SDNode *User = nullptr;
263  /// Prev, Next - Pointers to the uses list of the SDNode referred by
264  /// this operand.
265  SDUse **Prev = nullptr;
266  SDUse *Next = nullptr;
267 
268 public:
269  SDUse() = default;
270  SDUse(const SDUse &U) = delete;
271  SDUse &operator=(const SDUse &) = delete;
272 
273  /// Normally SDUse will just implicitly convert to an SDValue that it holds.
274  operator const SDValue&() const { return Val; }
275 
276  /// If implicit conversion to SDValue doesn't work, the get() method returns
277  /// the SDValue.
278  const SDValue &get() const { return Val; }
279 
280  /// This returns the SDNode that contains this Use.
281  SDNode *getUser() { return User; }
282 
283  /// Get the next SDUse in the use list.
284  SDUse *getNext() const { return Next; }
285 
286  /// Convenience function for get().getNode().
287  SDNode *getNode() const { return Val.getNode(); }
288  /// Convenience function for get().getResNo().
289  unsigned getResNo() const { return Val.getResNo(); }
290  /// Convenience function for get().getValueType().
291  EVT getValueType() const { return Val.getValueType(); }
292 
293  /// Convenience function for get().operator==
294  bool operator==(const SDValue &V) const {
295  return Val == V;
296  }
297 
298  /// Convenience function for get().operator!=
299  bool operator!=(const SDValue &V) const {
300  return Val != V;
301  }
302 
303  /// Convenience function for get().operator<
304  bool operator<(const SDValue &V) const {
305  return Val < V;
306  }
307 
308 private:
309  friend class SelectionDAG;
310  friend class SDNode;
311  // TODO: unfriend HandleSDNode once we fix its operand handling.
312  friend class HandleSDNode;
313 
314  void setUser(SDNode *p) { User = p; }
315 
316  /// Remove this use from its existing use list, assign it the
317  /// given value, and add it to the new value's node's use list.
318  inline void set(const SDValue &V);
319  /// Like set, but only supports initializing a newly-allocated
320  /// SDUse with a non-null value.
321  inline void setInitial(const SDValue &V);
322  /// Like set, but only sets the Node portion of the value,
323  /// leaving the ResNo portion unmodified.
324  inline void setNode(SDNode *N);
325 
326  void addToList(SDUse **List) {
327  Next = *List;
328  if (Next) Next->Prev = &Next;
329  Prev = List;
330  *List = this;
331  }
332 
333  void removeFromList() {
334  *Prev = Next;
335  if (Next) Next->Prev = Prev;
336  }
337 };
338 
339 /// simplify_type specializations - Allow casting operators to work directly on
340 /// SDValues as if they were SDNode*'s.
341 template<> struct simplify_type<SDUse> {
342  using SimpleType = SDNode *;
343 
345  return Val.getNode();
346  }
347 };
348 
349 /// These are IR-level optimization flags that may be propagated to SDNodes.
350 /// TODO: This data structure should be shared by the IR optimizer and the
351 /// the backend.
352 struct SDNodeFlags {
353 private:
354  // This bit is used to determine if the flags are in a defined state.
355  // Flag bits can only be masked out during intersection if the masking flags
356  // are defined.
357  bool AnyDefined : 1;
358 
359  bool NoUnsignedWrap : 1;
360  bool NoSignedWrap : 1;
361  bool Exact : 1;
362  bool NoNaNs : 1;
363  bool NoInfs : 1;
364  bool NoSignedZeros : 1;
365  bool AllowReciprocal : 1;
366  bool VectorReduction : 1;
367  bool AllowContract : 1;
368  bool ApproximateFuncs : 1;
369  bool AllowReassociation : 1;
370 
371 public:
372  /// Default constructor turns off all optimization flags.
374  : AnyDefined(false), NoUnsignedWrap(false), NoSignedWrap(false),
375  Exact(false), NoNaNs(false), NoInfs(false),
376  NoSignedZeros(false), AllowReciprocal(false), VectorReduction(false),
377  AllowContract(false), ApproximateFuncs(false),
378  AllowReassociation(false) {}
379 
380  /// Propagate the fast-math-flags from an IR FPMathOperator.
381  void copyFMF(const FPMathOperator &FPMO) {
382  setNoNaNs(FPMO.hasNoNaNs());
383  setNoInfs(FPMO.hasNoInfs());
384  setNoSignedZeros(FPMO.hasNoSignedZeros());
385  setAllowReciprocal(FPMO.hasAllowReciprocal());
386  setAllowContract(FPMO.hasAllowContract());
387  setApproximateFuncs(FPMO.hasApproxFunc());
388  setAllowReassociation(FPMO.hasAllowReassoc());
389  }
390 
391  /// Sets the state of the flags to the defined state.
392  void setDefined() { AnyDefined = true; }
393  /// Returns true if the flags are in a defined state.
394  bool isDefined() const { return AnyDefined; }
395 
396  // These are mutators for each flag.
397  void setNoUnsignedWrap(bool b) {
398  setDefined();
399  NoUnsignedWrap = b;
400  }
401  void setNoSignedWrap(bool b) {
402  setDefined();
403  NoSignedWrap = b;
404  }
405  void setExact(bool b) {
406  setDefined();
407  Exact = b;
408  }
409  void setNoNaNs(bool b) {
410  setDefined();
411  NoNaNs = b;
412  }
413  void setNoInfs(bool b) {
414  setDefined();
415  NoInfs = b;
416  }
417  void setNoSignedZeros(bool b) {
418  setDefined();
419  NoSignedZeros = b;
420  }
421  void setAllowReciprocal(bool b) {
422  setDefined();
423  AllowReciprocal = b;
424  }
425  void setVectorReduction(bool b) {
426  setDefined();
427  VectorReduction = b;
428  }
429  void setAllowContract(bool b) {
430  setDefined();
431  AllowContract = b;
432  }
433  void setApproximateFuncs(bool b) {
434  setDefined();
435  ApproximateFuncs = b;
436  }
437  void setAllowReassociation(bool b) {
438  setDefined();
439  AllowReassociation = b;
440  }
441 
442  // These are accessors for each flag.
443  bool hasNoUnsignedWrap() const { return NoUnsignedWrap; }
444  bool hasNoSignedWrap() const { return NoSignedWrap; }
445  bool hasExact() const { return Exact; }
446  bool hasNoNaNs() const { return NoNaNs; }
447  bool hasNoInfs() const { return NoInfs; }
448  bool hasNoSignedZeros() const { return NoSignedZeros; }
449  bool hasAllowReciprocal() const { return AllowReciprocal; }
450  bool hasVectorReduction() const { return VectorReduction; }
451  bool hasAllowContract() const { return AllowContract; }
452  bool hasApproximateFuncs() const { return ApproximateFuncs; }
453  bool hasAllowReassociation() const { return AllowReassociation; }
454 
455  bool isFast() const {
456  return NoSignedZeros && AllowReciprocal && NoNaNs && NoInfs &&
457  AllowContract && ApproximateFuncs && AllowReassociation;
458  }
459 
460  /// Clear any flags in this flag set that aren't also set in Flags.
461  /// If the given Flags are undefined then don't do anything.
462  void intersectWith(const SDNodeFlags Flags) {
463  if (!Flags.isDefined())
464  return;
465  NoUnsignedWrap &= Flags.NoUnsignedWrap;
466  NoSignedWrap &= Flags.NoSignedWrap;
467  Exact &= Flags.Exact;
468  NoNaNs &= Flags.NoNaNs;
469  NoInfs &= Flags.NoInfs;
470  NoSignedZeros &= Flags.NoSignedZeros;
471  AllowReciprocal &= Flags.AllowReciprocal;
472  VectorReduction &= Flags.VectorReduction;
473  AllowContract &= Flags.AllowContract;
474  ApproximateFuncs &= Flags.ApproximateFuncs;
475  AllowReassociation &= Flags.AllowReassociation;
476  }
477 };
478 
479 /// Represents one node in the SelectionDAG.
480 ///
481 class SDNode : public FoldingSetNode, public ilist_node<SDNode> {
482 private:
483  /// The operation that this node performs.
484  int16_t NodeType;
485 
486 protected:
487  // We define a set of mini-helper classes to help us interpret the bits in our
488  // SubclassData. These are designed to fit within a uint16_t so they pack
489  // with NodeType.
490 
491 #if defined(_AIX) && (!defined(__GNUC__) || defined(__ibmxl__))
492 // Except for GCC; by default, AIX compilers store bit-fields in 4-byte words
493 // and give the `pack` pragma push semantics.
494 #define BEGIN_TWO_BYTE_PACK() _Pragma("pack(2)")
495 #define END_TWO_BYTE_PACK() _Pragma("pack(pop)")
496 #else
497 #define BEGIN_TWO_BYTE_PACK()
498 #define END_TWO_BYTE_PACK()
499 #endif
500 
503  friend class SDNode;
504  friend class MemIntrinsicSDNode;
505  friend class MemSDNode;
506  friend class SelectionDAG;
507 
508  uint16_t HasDebugValue : 1;
509  uint16_t IsMemIntrinsic : 1;
510  uint16_t IsDivergent : 1;
511  };
512  enum { NumSDNodeBits = 3 };
513 
515  friend class ConstantSDNode;
516 
517  uint16_t : NumSDNodeBits;
518 
519  uint16_t IsOpaque : 1;
520  };
521 
523  friend class MemSDNode;
524  friend class MemIntrinsicSDNode;
525  friend class AtomicSDNode;
526 
527  uint16_t : NumSDNodeBits;
528 
529  uint16_t IsVolatile : 1;
530  uint16_t IsNonTemporal : 1;
531  uint16_t IsDereferenceable : 1;
532  uint16_t IsInvariant : 1;
533  };
534  enum { NumMemSDNodeBits = NumSDNodeBits + 4 };
535 
537  friend class LSBaseSDNode;
538 
539  uint16_t : NumMemSDNodeBits;
540 
541  uint16_t AddressingMode : 3; // enum ISD::MemIndexedMode
542  };
543  enum { NumLSBaseSDNodeBits = NumMemSDNodeBits + 3 };
544 
546  friend class LoadSDNode;
547  friend class MaskedLoadSDNode;
548 
549  uint16_t : NumLSBaseSDNodeBits;
550 
551  uint16_t ExtTy : 2; // enum ISD::LoadExtType
552  uint16_t IsExpanding : 1;
553  };
554 
556  friend class StoreSDNode;
557  friend class MaskedStoreSDNode;
558 
559  uint16_t : NumLSBaseSDNodeBits;
560 
561  uint16_t IsTruncating : 1;
562  uint16_t IsCompressing : 1;
563  };
564 
565  union {
566  char RawSDNodeBits[sizeof(uint16_t)];
573  };
575 #undef BEGIN_TWO_BYTE_PACK
576 #undef END_TWO_BYTE_PACK
577 
578  // RawSDNodeBits must cover the entirety of the union. This means that all of
579  // the union's members must have size <= RawSDNodeBits. We write the RHS as
580  // "2" instead of sizeof(RawSDNodeBits) because MSVC can't handle the latter.
581  static_assert(sizeof(SDNodeBitfields) <= 2, "field too wide");
582  static_assert(sizeof(ConstantSDNodeBitfields) <= 2, "field too wide");
583  static_assert(sizeof(MemSDNodeBitfields) <= 2, "field too wide");
584  static_assert(sizeof(LSBaseSDNodeBitfields) <= 2, "field too wide");
585  static_assert(sizeof(LoadSDNodeBitfields) <= 2, "field too wide");
586  static_assert(sizeof(StoreSDNodeBitfields) <= 2, "field too wide");
587 
588 private:
589  friend class SelectionDAG;
590  // TODO: unfriend HandleSDNode once we fix its operand handling.
591  friend class HandleSDNode;
592 
593  /// Unique id per SDNode in the DAG.
594  int NodeId = -1;
595 
596  /// The values that are used by this operation.
597  SDUse *OperandList = nullptr;
598 
599  /// The types of the values this node defines. SDNode's may
600  /// define multiple values simultaneously.
601  const EVT *ValueList;
602 
603  /// List of uses for this SDNode.
604  SDUse *UseList = nullptr;
605 
606  /// The number of entries in the Operand/Value list.
607  unsigned short NumOperands = 0;
608  unsigned short NumValues;
609 
610  // The ordering of the SDNodes. It roughly corresponds to the ordering of the
611  // original LLVM instructions.
612  // This is used for turning off scheduling, because we'll forgo
613  // the normal scheduling algorithms and output the instructions according to
614  // this ordering.
615  unsigned IROrder;
616 
617  /// Source line information.
618  DebugLoc debugLoc;
619 
620  /// Return a pointer to the specified value type.
621  static const EVT *getValueTypeList(EVT VT);
622 
623  SDNodeFlags Flags;
624 
625 public:
626  /// Unique and persistent id per SDNode in the DAG.
627  /// Used for debug printing.
628  uint16_t PersistentId;
629 
630  //===--------------------------------------------------------------------===//
631  // Accessors
632  //
633 
634  /// Return the SelectionDAG opcode value for this node. For
635  /// pre-isel nodes (those for which isMachineOpcode returns false), these
636  /// are the opcode values in the ISD and <target>ISD namespaces. For
637  /// post-isel opcodes, see getMachineOpcode.
638  unsigned getOpcode() const { return (unsigned short)NodeType; }
639 
640  /// Test if this node has a target-specific opcode (in the
641  /// <target>ISD namespace).
642  bool isTargetOpcode() const { return NodeType >= ISD::BUILTIN_OP_END; }
643 
644  /// Test if this node has a target-specific
645  /// memory-referencing opcode (in the <target>ISD namespace and
646  /// greater than FIRST_TARGET_MEMORY_OPCODE).
647  bool isTargetMemoryOpcode() const {
648  return NodeType >= ISD::FIRST_TARGET_MEMORY_OPCODE;
649  }
650 
651  /// Return true if the type of the node type undefined.
652  bool isUndef() const { return NodeType == ISD::UNDEF; }
653 
654  /// Test if this node is a memory intrinsic (with valid pointer information).
655  /// INTRINSIC_W_CHAIN and INTRINSIC_VOID nodes are sometimes created for
656  /// non-memory intrinsics (with chains) that are not really instances of
657  /// MemSDNode. For such nodes, we need some extra state to determine the
658  /// proper classof relationship.
659  bool isMemIntrinsic() const {
660  return (NodeType == ISD::INTRINSIC_W_CHAIN ||
661  NodeType == ISD::INTRINSIC_VOID) &&
662  SDNodeBits.IsMemIntrinsic;
663  }
664 
665  /// Test if this node is a strict floating point pseudo-op.
667  switch (NodeType) {
668  default:
669  return false;
670  case ISD::STRICT_FADD:
671  case ISD::STRICT_FSUB:
672  case ISD::STRICT_FMUL:
673  case ISD::STRICT_FDIV:
674  case ISD::STRICT_FREM:
675  case ISD::STRICT_FMA:
676  case ISD::STRICT_FSQRT:
677  case ISD::STRICT_FPOW:
678  case ISD::STRICT_FPOWI:
679  case ISD::STRICT_FSIN:
680  case ISD::STRICT_FCOS:
681  case ISD::STRICT_FEXP:
682  case ISD::STRICT_FEXP2:
683  case ISD::STRICT_FLOG:
684  case ISD::STRICT_FLOG10:
685  case ISD::STRICT_FLOG2:
686  case ISD::STRICT_FRINT:
688  case ISD::STRICT_FMAXNUM:
689  case ISD::STRICT_FMINNUM:
690  case ISD::STRICT_FCEIL:
691  case ISD::STRICT_FFLOOR:
692  case ISD::STRICT_FROUND:
693  case ISD::STRICT_FTRUNC:
694  return true;
695  }
696  }
697 
698  /// Test if this node has a post-isel opcode, directly
699  /// corresponding to a MachineInstr opcode.
700  bool isMachineOpcode() const { return NodeType < 0; }
701 
702  /// This may only be called if isMachineOpcode returns
703  /// true. It returns the MachineInstr opcode value that the node's opcode
704  /// corresponds to.
705  unsigned getMachineOpcode() const {
706  assert(isMachineOpcode() && "Not a MachineInstr opcode!");
707  return ~NodeType;
708  }
709 
710  bool getHasDebugValue() const { return SDNodeBits.HasDebugValue; }
711  void setHasDebugValue(bool b) { SDNodeBits.HasDebugValue = b; }
712 
713  bool isDivergent() const { return SDNodeBits.IsDivergent; }
714 
715  /// Return true if there are no uses of this node.
716  bool use_empty() const { return UseList == nullptr; }
717 
718  /// Return true if there is exactly one use of this node.
719  bool hasOneUse() const {
720  return !use_empty() && std::next(use_begin()) == use_end();
721  }
722 
723  /// Return the number of uses of this node. This method takes
724  /// time proportional to the number of uses.
725  size_t use_size() const { return std::distance(use_begin(), use_end()); }
726 
727  /// Return the unique node id.
728  int getNodeId() const { return NodeId; }
729 
730  /// Set unique node id.
731  void setNodeId(int Id) { NodeId = Id; }
732 
733  /// Return the node ordering.
734  unsigned getIROrder() const { return IROrder; }
735 
736  /// Set the node ordering.
737  void setIROrder(unsigned Order) { IROrder = Order; }
738 
739  /// Return the source location info.
740  const DebugLoc &getDebugLoc() const { return debugLoc; }
741 
742  /// Set source location info. Try to avoid this, putting
743  /// it in the constructor is preferable.
744  void setDebugLoc(DebugLoc dl) { debugLoc = std::move(dl); }
745 
746  /// This class provides iterator support for SDUse
747  /// operands that use a specific SDNode.
749  : public std::iterator<std::forward_iterator_tag, SDUse, ptrdiff_t> {
750  friend class SDNode;
751 
752  SDUse *Op = nullptr;
753 
754  explicit use_iterator(SDUse *op) : Op(op) {}
755 
756  public:
757  using reference = std::iterator<std::forward_iterator_tag,
759  using pointer = std::iterator<std::forward_iterator_tag,
761 
762  use_iterator() = default;
763  use_iterator(const use_iterator &I) : Op(I.Op) {}
764 
765  bool operator==(const use_iterator &x) const {
766  return Op == x.Op;
767  }
768  bool operator!=(const use_iterator &x) const {
769  return !operator==(x);
770  }
771 
772  /// Return true if this iterator is at the end of uses list.
773  bool atEnd() const { return Op == nullptr; }
774 
775  // Iterator traversal: forward iteration only.
776  use_iterator &operator++() { // Preincrement
777  assert(Op && "Cannot increment end iterator!");
778  Op = Op->getNext();
779  return *this;
780  }
781 
782  use_iterator operator++(int) { // Postincrement
783  use_iterator tmp = *this; ++*this; return tmp;
784  }
785 
786  /// Retrieve a pointer to the current user node.
787  SDNode *operator*() const {
788  assert(Op && "Cannot dereference end iterator!");
789  return Op->getUser();
790  }
791 
792  SDNode *operator->() const { return operator*(); }
793 
794  SDUse &getUse() const { return *Op; }
795 
796  /// Retrieve the operand # of this use in its user.
797  unsigned getOperandNo() const {
798  assert(Op && "Cannot dereference end iterator!");
799  return (unsigned)(Op - Op->getUser()->OperandList);
800  }
801  };
802 
803  /// Provide iteration support to walk over all uses of an SDNode.
805  return use_iterator(UseList);
806  }
807 
808  static use_iterator use_end() { return use_iterator(nullptr); }
809 
811  return make_range(use_begin(), use_end());
812  }
814  return make_range(use_begin(), use_end());
815  }
816 
817  /// Return true if there are exactly NUSES uses of the indicated value.
818  /// This method ignores uses of other values defined by this operation.
819  bool hasNUsesOfValue(unsigned NUses, unsigned Value) const;
820 
821  /// Return true if there are any use of the indicated value.
822  /// This method ignores uses of other values defined by this operation.
823  bool hasAnyUseOfValue(unsigned Value) const;
824 
825  /// Return true if this node is the only use of N.
826  bool isOnlyUserOf(const SDNode *N) const;
827 
828  /// Return true if this node is an operand of N.
829  bool isOperandOf(const SDNode *N) const;
830 
831  /// Return true if this node is a predecessor of N.
832  /// NOTE: Implemented on top of hasPredecessor and every bit as
833  /// expensive. Use carefully.
834  bool isPredecessorOf(const SDNode *N) const {
835  return N->hasPredecessor(this);
836  }
837 
838  /// Return true if N is a predecessor of this node.
839  /// N is either an operand of this node, or can be reached by recursively
840  /// traversing up the operands.
841  /// NOTE: This is an expensive method. Use it carefully.
842  bool hasPredecessor(const SDNode *N) const;
843 
844  /// Returns true if N is a predecessor of any node in Worklist. This
845  /// helper keeps Visited and Worklist sets externally to allow unions
846  /// searches to be performed in parallel, caching of results across
847  /// queries and incremental addition to Worklist. Stops early if N is
848  /// found but will resume. Remember to clear Visited and Worklists
849  /// if DAG changes. MaxSteps gives a maximum number of nodes to visit before
850  /// giving up. The TopologicalPrune flag signals that positive NodeIds are
851  /// topologically ordered (Operands have strictly smaller node id) and search
852  /// can be pruned leveraging this.
853  static bool hasPredecessorHelper(const SDNode *N,
856  unsigned int MaxSteps = 0,
857  bool TopologicalPrune = false) {
858  SmallVector<const SDNode *, 8> DeferredNodes;
859  if (Visited.count(N))
860  return true;
861 
862  // Node Id's are assigned in three places: As a topological
863  // ordering (> 0), during legalization (results in values set to
864  // 0), new nodes (set to -1). If N has a topolgical id then we
865  // know that all nodes with ids smaller than it cannot be
866  // successors and we need not check them. Filter out all node
867  // that can't be matches. We add them to the worklist before exit
868  // in case of multiple calls. Note that during selection the topological id
869  // may be violated if a node's predecessor is selected before it. We mark
870  // this at selection negating the id of unselected successors and
871  // restricting topological pruning to positive ids.
872 
873  int NId = N->getNodeId();
874  // If we Invalidated the Id, reconstruct original NId.
875  if (NId < -1)
876  NId = -(NId + 1);
877 
878  bool Found = false;
879  while (!Worklist.empty()) {
880  const SDNode *M = Worklist.pop_back_val();
881  int MId = M->getNodeId();
882  if (TopologicalPrune && M->getOpcode() != ISD::TokenFactor && (NId > 0) &&
883  (MId > 0) && (MId < NId)) {
884  DeferredNodes.push_back(M);
885  continue;
886  }
887  for (const SDValue &OpV : M->op_values()) {
888  SDNode *Op = OpV.getNode();
889  if (Visited.insert(Op).second)
890  Worklist.push_back(Op);
891  if (Op == N)
892  Found = true;
893  }
894  if (Found)
895  break;
896  if (MaxSteps != 0 && Visited.size() >= MaxSteps)
897  break;
898  }
899  // Push deferred nodes back on worklist.
900  Worklist.append(DeferredNodes.begin(), DeferredNodes.end());
901  // If we bailed early, conservatively return found.
902  if (MaxSteps != 0 && Visited.size() >= MaxSteps)
903  return true;
904  return Found;
905  }
906 
907  /// Return true if all the users of N are contained in Nodes.
908  /// NOTE: Requires at least one match, but doesn't require them all.
909  static bool areOnlyUsersOf(ArrayRef<const SDNode *> Nodes, const SDNode *N);
910 
911  /// Return the number of values used by this operation.
912  unsigned getNumOperands() const { return NumOperands; }
913 
914  /// Return the maximum number of operands that a SDNode can hold.
915  static constexpr size_t getMaxNumOperands() {
917  }
918 
919  /// Helper method returns the integer value of a ConstantSDNode operand.
920  inline uint64_t getConstantOperandVal(unsigned Num) const;
921 
922  /// Helper method returns the APInt of a ConstantSDNode operand.
923  inline const APInt &getConstantOperandAPInt(unsigned Num) const;
924 
925  const SDValue &getOperand(unsigned Num) const {
926  assert(Num < NumOperands && "Invalid child # of SDNode!");
927  return OperandList[Num];
928  }
929 
930  using op_iterator = SDUse *;
931 
932  op_iterator op_begin() const { return OperandList; }
933  op_iterator op_end() const { return OperandList+NumOperands; }
934  ArrayRef<SDUse> ops() const { return makeArrayRef(op_begin(), op_end()); }
935 
936  /// Iterator for directly iterating over the operand SDValue's.
938  : iterator_adaptor_base<value_op_iterator, op_iterator,
939  std::random_access_iterator_tag, SDValue,
940  ptrdiff_t, value_op_iterator *,
941  value_op_iterator *> {
942  explicit value_op_iterator(SDUse *U = nullptr)
943  : iterator_adaptor_base(U) {}
944 
945  const SDValue &operator*() const { return I->get(); }
946  };
947 
949  return make_range(value_op_iterator(op_begin()),
950  value_op_iterator(op_end()));
951  }
952 
953  SDVTList getVTList() const {
954  SDVTList X = { ValueList, NumValues };
955  return X;
956  }
957 
958  /// If this node has a glue operand, return the node
959  /// to which the glue operand points. Otherwise return NULL.
960  SDNode *getGluedNode() const {
961  if (getNumOperands() != 0 &&
962  getOperand(getNumOperands()-1).getValueType() == MVT::Glue)
963  return getOperand(getNumOperands()-1).getNode();
964  return nullptr;
965  }
966 
967  /// If this node has a glue value with a user, return
968  /// the user (there is at most one). Otherwise return NULL.
969  SDNode *getGluedUser() const {
970  for (use_iterator UI = use_begin(), UE = use_end(); UI != UE; ++UI)
971  if (UI.getUse().get().getValueType() == MVT::Glue)
972  return *UI;
973  return nullptr;
974  }
975 
976  const SDNodeFlags getFlags() const { return Flags; }
977  void setFlags(SDNodeFlags NewFlags) { Flags = NewFlags; }
978  bool isFast() { return Flags.isFast(); }
979 
980  /// Clear any flags in this node that aren't also set in Flags.
981  /// If Flags is not in a defined state then this has no effect.
982  void intersectFlagsWith(const SDNodeFlags Flags);
983 
984  /// Return the number of values defined/returned by this operator.
985  unsigned getNumValues() const { return NumValues; }
986 
987  /// Return the type of a specified result.
988  EVT getValueType(unsigned ResNo) const {
989  assert(ResNo < NumValues && "Illegal result number!");
990  return ValueList[ResNo];
991  }
992 
993  /// Return the type of a specified result as a simple type.
994  MVT getSimpleValueType(unsigned ResNo) const {
995  return getValueType(ResNo).getSimpleVT();
996  }
997 
998  /// Returns MVT::getSizeInBits(getValueType(ResNo)).
999  unsigned getValueSizeInBits(unsigned ResNo) const {
1000  return getValueType(ResNo).getSizeInBits();
1001  }
1002 
1003  using value_iterator = const EVT *;
1004 
1005  value_iterator value_begin() const { return ValueList; }
1006  value_iterator value_end() const { return ValueList+NumValues; }
1007 
1008  /// Return the opcode of this operation for printing.
1009  std::string getOperationName(const SelectionDAG *G = nullptr) const;
1010  static const char* getIndexedModeName(ISD::MemIndexedMode AM);
1011  void print_types(raw_ostream &OS, const SelectionDAG *G) const;
1012  void print_details(raw_ostream &OS, const SelectionDAG *G) const;
1013  void print(raw_ostream &OS, const SelectionDAG *G = nullptr) const;
1014  void printr(raw_ostream &OS, const SelectionDAG *G = nullptr) const;
1015 
1016  /// Print a SelectionDAG node and all children down to
1017  /// the leaves. The given SelectionDAG allows target-specific nodes
1018  /// to be printed in human-readable form. Unlike printr, this will
1019  /// print the whole DAG, including children that appear multiple
1020  /// times.
1021  ///
1022  void printrFull(raw_ostream &O, const SelectionDAG *G = nullptr) const;
1023 
1024  /// Print a SelectionDAG node and children up to
1025  /// depth "depth." The given SelectionDAG allows target-specific
1026  /// nodes to be printed in human-readable form. Unlike printr, this
1027  /// will print children that appear multiple times wherever they are
1028  /// used.
1029  ///
1030  void printrWithDepth(raw_ostream &O, const SelectionDAG *G = nullptr,
1031  unsigned depth = 100) const;
1032 
1033  /// Dump this node, for debugging.
1034  void dump() const;
1035 
1036  /// Dump (recursively) this node and its use-def subgraph.
1037  void dumpr() const;
1038 
1039  /// Dump this node, for debugging.
1040  /// The given SelectionDAG allows target-specific nodes to be printed
1041  /// in human-readable form.
1042  void dump(const SelectionDAG *G) const;
1043 
1044  /// Dump (recursively) this node and its use-def subgraph.
1045  /// The given SelectionDAG allows target-specific nodes to be printed
1046  /// in human-readable form.
1047  void dumpr(const SelectionDAG *G) const;
1048 
1049  /// printrFull to dbgs(). The given SelectionDAG allows
1050  /// target-specific nodes to be printed in human-readable form.
1051  /// Unlike dumpr, this will print the whole DAG, including children
1052  /// that appear multiple times.
1053  void dumprFull(const SelectionDAG *G = nullptr) const;
1054 
1055  /// printrWithDepth to dbgs(). The given
1056  /// SelectionDAG allows target-specific nodes to be printed in
1057  /// human-readable form. Unlike dumpr, this will print children
1058  /// that appear multiple times wherever they are used.
1059  ///
1060  void dumprWithDepth(const SelectionDAG *G = nullptr,
1061  unsigned depth = 100) const;
1062 
1063  /// Gather unique data for the node.
1064  void Profile(FoldingSetNodeID &ID) const;
1065 
1066  /// This method should only be used by the SDUse class.
1067  void addUse(SDUse &U) { U.addToList(&UseList); }
1068 
1069 protected:
1070  static SDVTList getSDVTList(EVT VT) {
1071  SDVTList Ret = { getValueTypeList(VT), 1 };
1072  return Ret;
1073  }
1074 
1075  /// Create an SDNode.
1076  ///
1077  /// SDNodes are created without any operands, and never own the operand
1078  /// storage. To add operands, see SelectionDAG::createOperands.
1079  SDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs)
1080  : NodeType(Opc), ValueList(VTs.VTs), NumValues(VTs.NumVTs),
1081  IROrder(Order), debugLoc(std::move(dl)) {
1082  memset(&RawSDNodeBits, 0, sizeof(RawSDNodeBits));
1083  assert(debugLoc.hasTrivialDestructor() && "Expected trivial destructor");
1084  assert(NumValues == VTs.NumVTs &&
1085  "NumValues wasn't wide enough for its operands!");
1086  }
1087 
1088  /// Release the operands and set this node to have zero operands.
1089  void DropOperands();
1090 };
1091 
1092 /// Wrapper class for IR location info (IR ordering and DebugLoc) to be passed
1093 /// into SDNode creation functions.
1094 /// When an SDNode is created from the DAGBuilder, the DebugLoc is extracted
1095 /// from the original Instruction, and IROrder is the ordinal position of
1096 /// the instruction.
1097 /// When an SDNode is created after the DAG is being built, both DebugLoc and
1098 /// the IROrder are propagated from the original SDNode.
1099 /// So SDLoc class provides two constructors besides the default one, one to
1100 /// be used by the DAGBuilder, the other to be used by others.
1101 class SDLoc {
1102 private:
1103  DebugLoc DL;
1104  int IROrder = 0;
1105 
1106 public:
1107  SDLoc() = default;
1108  SDLoc(const SDNode *N) : DL(N->getDebugLoc()), IROrder(N->getIROrder()) {}
1109  SDLoc(const SDValue V) : SDLoc(V.getNode()) {}
1110  SDLoc(const Instruction *I, int Order) : IROrder(Order) {
1111  assert(Order >= 0 && "bad IROrder");
1112  if (I)
1113  DL = I->getDebugLoc();
1114  }
1115 
1116  unsigned getIROrder() const { return IROrder; }
1117  const DebugLoc &getDebugLoc() const { return DL; }
1118 };
1119 
1120 // Define inline functions from the SDValue class.
1121 
1122 inline SDValue::SDValue(SDNode *node, unsigned resno)
1123  : Node(node), ResNo(resno) {
1124  // Explicitly check for !ResNo to avoid use-after-free, because there are
1125  // callers that use SDValue(N, 0) with a deleted N to indicate successful
1126  // combines.
1127  assert((!Node || !ResNo || ResNo < Node->getNumValues()) &&
1128  "Invalid result number for the given node!");
1129  assert(ResNo < -2U && "Cannot use result numbers reserved for DenseMaps.");
1130 }
1131 
1132 inline unsigned SDValue::getOpcode() const {
1133  return Node->getOpcode();
1134 }
1135 
1136 inline EVT SDValue::getValueType() const {
1137  return Node->getValueType(ResNo);
1138 }
1139 
1140 inline unsigned SDValue::getNumOperands() const {
1141  return Node->getNumOperands();
1142 }
1143 
1144 inline const SDValue &SDValue::getOperand(unsigned i) const {
1145  return Node->getOperand(i);
1146 }
1147 
1148 inline uint64_t SDValue::getConstantOperandVal(unsigned i) const {
1149  return Node->getConstantOperandVal(i);
1150 }
1151 
1152 inline const APInt &SDValue::getConstantOperandAPInt(unsigned i) const {
1153  return Node->getConstantOperandAPInt(i);
1154 }
1155 
1156 inline bool SDValue::isTargetOpcode() const {
1157  return Node->isTargetOpcode();
1158 }
1159 
1160 inline bool SDValue::isTargetMemoryOpcode() const {
1161  return Node->isTargetMemoryOpcode();
1162 }
1163 
1164 inline bool SDValue::isMachineOpcode() const {
1165  return Node->isMachineOpcode();
1166 }
1167 
1168 inline unsigned SDValue::getMachineOpcode() const {
1169  return Node->getMachineOpcode();
1170 }
1171 
1172 inline bool SDValue::isUndef() const {
1173  return Node->isUndef();
1174 }
1175 
1176 inline bool SDValue::use_empty() const {
1177  return !Node->hasAnyUseOfValue(ResNo);
1178 }
1179 
1180 inline bool SDValue::hasOneUse() const {
1181  return Node->hasNUsesOfValue(1, ResNo);
1182 }
1183 
1184 inline const DebugLoc &SDValue::getDebugLoc() const {
1185  return Node->getDebugLoc();
1186 }
1187 
1188 inline void SDValue::dump() const {
1189  return Node->dump();
1190 }
1191 
1192 inline void SDValue::dump(const SelectionDAG *G) const {
1193  return Node->dump(G);
1194 }
1195 
1196 inline void SDValue::dumpr() const {
1197  return Node->dumpr();
1198 }
1199 
1200 inline void SDValue::dumpr(const SelectionDAG *G) const {
1201  return Node->dumpr(G);
1202 }
1203 
1204 // Define inline functions from the SDUse class.
1205 
1206 inline void SDUse::set(const SDValue &V) {
1207  if (Val.getNode()) removeFromList();
1208  Val = V;
1209  if (V.getNode()) V.getNode()->addUse(*this);
1210 }
1211 
1212 inline void SDUse::setInitial(const SDValue &V) {
1213  Val = V;
1214  V.getNode()->addUse(*this);
1215 }
1216 
1217 inline void SDUse::setNode(SDNode *N) {
1218  if (Val.getNode()) removeFromList();
1219  Val.setNode(N);
1220  if (N) N->addUse(*this);
1221 }
1222 
1223 /// This class is used to form a handle around another node that
1224 /// is persistent and is updated across invocations of replaceAllUsesWith on its
1225 /// operand. This node should be directly created by end-users and not added to
1226 /// the AllNodes list.
1227 class HandleSDNode : public SDNode {
1228  SDUse Op;
1229 
1230 public:
1232  : SDNode(ISD::HANDLENODE, 0, DebugLoc(), getSDVTList(MVT::Other)) {
1233  // HandleSDNodes are never inserted into the DAG, so they won't be
1234  // auto-numbered. Use ID 65535 as a sentinel.
1235  PersistentId = 0xffff;
1236 
1237  // Manually set up the operand list. This node type is special in that it's
1238  // always stack allocated and SelectionDAG does not manage its operands.
1239  // TODO: This should either (a) not be in the SDNode hierarchy, or (b) not
1240  // be so special.
1241  Op.setUser(this);
1242  Op.setInitial(X);
1243  NumOperands = 1;
1244  OperandList = &Op;
1245  }
1246  ~HandleSDNode();
1247 
1248  const SDValue &getValue() const { return Op; }
1249 };
1250 
1251 class AddrSpaceCastSDNode : public SDNode {
1252 private:
1253  unsigned SrcAddrSpace;
1254  unsigned DestAddrSpace;
1255 
1256 public:
1257  AddrSpaceCastSDNode(unsigned Order, const DebugLoc &dl, EVT VT,
1258  unsigned SrcAS, unsigned DestAS);
1259 
1260  unsigned getSrcAddressSpace() const { return SrcAddrSpace; }
1261  unsigned getDestAddressSpace() const { return DestAddrSpace; }
1262 
1263  static bool classof(const SDNode *N) {
1264  return N->getOpcode() == ISD::ADDRSPACECAST;
1265  }
1266 };
1267 
1268 /// This is an abstract virtual class for memory operations.
1269 class MemSDNode : public SDNode {
1270 private:
1271  // VT of in-memory value.
1272  EVT MemoryVT;
1273 
1274 protected:
1275  /// Memory reference information.
1277 
1278 public:
1279  MemSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTs,
1280  EVT memvt, MachineMemOperand *MMO);
1281 
1282  bool readMem() const { return MMO->isLoad(); }
1283  bool writeMem() const { return MMO->isStore(); }
1284 
1285  /// Returns alignment and volatility of the memory access
1286  unsigned getOriginalAlignment() const {
1287  return MMO->getBaseAlignment();
1288  }
1289  unsigned getAlignment() const {
1290  return MMO->getAlignment();
1291  }
1292 
1293  /// Return the SubclassData value, without HasDebugValue. This contains an
1294  /// encoding of the volatile flag, as well as bits used by subclasses. This
1295  /// function should only be used to compute a FoldingSetNodeID value.
1296  /// The HasDebugValue bit is masked out because CSE map needs to match
1297  /// nodes with debug info with nodes without debug info. Same is about
1298  /// isDivergent bit.
1299  unsigned getRawSubclassData() const {
1300  uint16_t Data;
1301  union {
1302  char RawSDNodeBits[sizeof(uint16_t)];
1303  SDNodeBitfields SDNodeBits;
1304  };
1305  memcpy(&RawSDNodeBits, &this->RawSDNodeBits, sizeof(this->RawSDNodeBits));
1306  SDNodeBits.HasDebugValue = 0;
1307  SDNodeBits.IsDivergent = false;
1308  memcpy(&Data, &RawSDNodeBits, sizeof(RawSDNodeBits));
1309  return Data;
1310  }
1311 
1312  bool isVolatile() const { return MemSDNodeBits.IsVolatile; }
1313  bool isNonTemporal() const { return MemSDNodeBits.IsNonTemporal; }
1314  bool isDereferenceable() const { return MemSDNodeBits.IsDereferenceable; }
1315  bool isInvariant() const { return MemSDNodeBits.IsInvariant; }
1316 
1317  // Returns the offset from the location of the access.
1318  int64_t getSrcValueOffset() const { return MMO->getOffset(); }
1319 
1320  /// Returns the AA info that describes the dereference.
1321  AAMDNodes getAAInfo() const { return MMO->getAAInfo(); }
1322 
1323  /// Returns the Ranges that describes the dereference.
1324  const MDNode *getRanges() const { return MMO->getRanges(); }
1325 
1326  /// Returns the synchronization scope ID for this memory operation.
1327  SyncScope::ID getSyncScopeID() const { return MMO->getSyncScopeID(); }
1328 
1329  /// Return the atomic ordering requirements for this memory operation. For
1330  /// cmpxchg atomic operations, return the atomic ordering requirements when
1331  /// store occurs.
1332  AtomicOrdering getOrdering() const { return MMO->getOrdering(); }
1333 
1334  /// Return the type of the in-memory value.
1335  EVT getMemoryVT() const { return MemoryVT; }
1336 
1337  /// Return a MachineMemOperand object describing the memory
1338  /// reference performed by operation.
1339  MachineMemOperand *getMemOperand() const { return MMO; }
1340 
1342  return MMO->getPointerInfo();
1343  }
1344 
1345  /// Return the address space for the associated pointer
1346  unsigned getAddressSpace() const {
1347  return getPointerInfo().getAddrSpace();
1348  }
1349 
1350  /// Update this MemSDNode's MachineMemOperand information
1351  /// to reflect the alignment of NewMMO, if it has a greater alignment.
1352  /// This must only be used when the new alignment applies to all users of
1353  /// this MachineMemOperand.
1354  void refineAlignment(const MachineMemOperand *NewMMO) {
1355  MMO->refineAlignment(NewMMO);
1356  }
1357 
1358  const SDValue &getChain() const { return getOperand(0); }
1359  const SDValue &getBasePtr() const {
1360  return getOperand(getOpcode() == ISD::STORE ? 2 : 1);
1361  }
1362 
1363  // Methods to support isa and dyn_cast
1364  static bool classof(const SDNode *N) {
1365  // For some targets, we lower some target intrinsics to a MemIntrinsicNode
1366  // with either an intrinsic or a target opcode.
1367  return N->getOpcode() == ISD::LOAD ||
1368  N->getOpcode() == ISD::STORE ||
1369  N->getOpcode() == ISD::PREFETCH ||
1370  N->getOpcode() == ISD::ATOMIC_CMP_SWAP ||
1372  N->getOpcode() == ISD::ATOMIC_SWAP ||
1373  N->getOpcode() == ISD::ATOMIC_LOAD_ADD ||
1374  N->getOpcode() == ISD::ATOMIC_LOAD_SUB ||
1375  N->getOpcode() == ISD::ATOMIC_LOAD_AND ||
1376  N->getOpcode() == ISD::ATOMIC_LOAD_CLR ||
1377  N->getOpcode() == ISD::ATOMIC_LOAD_OR ||
1378  N->getOpcode() == ISD::ATOMIC_LOAD_XOR ||
1379  N->getOpcode() == ISD::ATOMIC_LOAD_NAND ||
1380  N->getOpcode() == ISD::ATOMIC_LOAD_MIN ||
1381  N->getOpcode() == ISD::ATOMIC_LOAD_MAX ||
1382  N->getOpcode() == ISD::ATOMIC_LOAD_UMIN ||
1383  N->getOpcode() == ISD::ATOMIC_LOAD_UMAX ||
1384  N->getOpcode() == ISD::ATOMIC_LOAD_FADD ||
1385  N->getOpcode() == ISD::ATOMIC_LOAD_FSUB ||
1386  N->getOpcode() == ISD::ATOMIC_LOAD ||
1387  N->getOpcode() == ISD::ATOMIC_STORE ||
1388  N->getOpcode() == ISD::MLOAD ||
1389  N->getOpcode() == ISD::MSTORE ||
1390  N->getOpcode() == ISD::MGATHER ||
1391  N->getOpcode() == ISD::MSCATTER ||
1392  N->isMemIntrinsic() ||
1393  N->isTargetMemoryOpcode();
1394  }
1395 };
1396 
1397 /// This is an SDNode representing atomic operations.
1398 class AtomicSDNode : public MemSDNode {
1399 public:
1400  AtomicSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTL,
1401  EVT MemVT, MachineMemOperand *MMO)
1402  : MemSDNode(Opc, Order, dl, VTL, MemVT, MMO) {
1403  assert(((Opc != ISD::ATOMIC_LOAD && Opc != ISD::ATOMIC_STORE) ||
1404  MMO->isAtomic()) && "then why are we using an AtomicSDNode?");
1405  }
1406 
1407  const SDValue &getBasePtr() const { return getOperand(1); }
1408  const SDValue &getVal() const { return getOperand(2); }
1409 
1410  /// Returns true if this SDNode represents cmpxchg atomic operation, false
1411  /// otherwise.
1412  bool isCompareAndSwap() const {
1413  unsigned Op = getOpcode();
1414  return Op == ISD::ATOMIC_CMP_SWAP ||
1416  }
1417 
1418  /// For cmpxchg atomic operations, return the atomic ordering requirements
1419  /// when store does not occur.
1421  assert(isCompareAndSwap() && "Must be cmpxchg operation");
1422  return MMO->getFailureOrdering();
1423  }
1424 
1425  // Methods to support isa and dyn_cast
1426  static bool classof(const SDNode *N) {
1427  return N->getOpcode() == ISD::ATOMIC_CMP_SWAP ||
1429  N->getOpcode() == ISD::ATOMIC_SWAP ||
1430  N->getOpcode() == ISD::ATOMIC_LOAD_ADD ||
1431  N->getOpcode() == ISD::ATOMIC_LOAD_SUB ||
1432  N->getOpcode() == ISD::ATOMIC_LOAD_AND ||
1433  N->getOpcode() == ISD::ATOMIC_LOAD_CLR ||
1434  N->getOpcode() == ISD::ATOMIC_LOAD_OR ||
1435  N->getOpcode() == ISD::ATOMIC_LOAD_XOR ||
1436  N->getOpcode() == ISD::ATOMIC_LOAD_NAND ||
1437  N->getOpcode() == ISD::ATOMIC_LOAD_MIN ||
1438  N->getOpcode() == ISD::ATOMIC_LOAD_MAX ||
1439  N->getOpcode() == ISD::ATOMIC_LOAD_UMIN ||
1440  N->getOpcode() == ISD::ATOMIC_LOAD_UMAX ||
1441  N->getOpcode() == ISD::ATOMIC_LOAD_FADD ||
1442  N->getOpcode() == ISD::ATOMIC_LOAD_FSUB ||
1443  N->getOpcode() == ISD::ATOMIC_LOAD ||
1444  N->getOpcode() == ISD::ATOMIC_STORE;
1445  }
1446 };
1447 
1448 /// This SDNode is used for target intrinsics that touch
1449 /// memory and need an associated MachineMemOperand. Its opcode may be
1450 /// INTRINSIC_VOID, INTRINSIC_W_CHAIN, PREFETCH, or a target-specific opcode
1451 /// with a value not less than FIRST_TARGET_MEMORY_OPCODE.
1453 public:
1454  MemIntrinsicSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl,
1455  SDVTList VTs, EVT MemoryVT, MachineMemOperand *MMO)
1456  : MemSDNode(Opc, Order, dl, VTs, MemoryVT, MMO) {
1457  SDNodeBits.IsMemIntrinsic = true;
1458  }
1459 
1460  // Methods to support isa and dyn_cast
1461  static bool classof(const SDNode *N) {
1462  // We lower some target intrinsics to their target opcode
1463  // early a node with a target opcode can be of this class
1464  return N->isMemIntrinsic() ||
1465  N->getOpcode() == ISD::PREFETCH ||
1466  N->isTargetMemoryOpcode();
1467  }
1468 };
1469 
1470 /// This SDNode is used to implement the code generator
1471 /// support for the llvm IR shufflevector instruction. It combines elements
1472 /// from two input vectors into a new input vector, with the selection and
1473 /// ordering of elements determined by an array of integers, referred to as
1474 /// the shuffle mask. For input vectors of width N, mask indices of 0..N-1
1475 /// refer to elements from the LHS input, and indices from N to 2N-1 the RHS.
1476 /// An index of -1 is treated as undef, such that the code generator may put
1477 /// any value in the corresponding element of the result.
1478 class ShuffleVectorSDNode : public SDNode {
1479  // The memory for Mask is owned by the SelectionDAG's OperandAllocator, and
1480  // is freed when the SelectionDAG object is destroyed.
1481  const int *Mask;
1482 
1483 protected:
1484  friend class SelectionDAG;
1485 
1486  ShuffleVectorSDNode(EVT VT, unsigned Order, const DebugLoc &dl, const int *M)
1487  : SDNode(ISD::VECTOR_SHUFFLE, Order, dl, getSDVTList(VT)), Mask(M) {}
1488 
1489 public:
1491  EVT VT = getValueType(0);
1492  return makeArrayRef(Mask, VT.getVectorNumElements());
1493  }
1494 
1495  int getMaskElt(unsigned Idx) const {
1496  assert(Idx < getValueType(0).getVectorNumElements() && "Idx out of range!");
1497  return Mask[Idx];
1498  }
1499 
1500  bool isSplat() const { return isSplatMask(Mask, getValueType(0)); }
1501 
1502  int getSplatIndex() const {
1503  assert(isSplat() && "Cannot get splat index for non-splat!");
1504  EVT VT = getValueType(0);
1505  for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; ++i)
1506  if (Mask[i] >= 0)
1507  return Mask[i];
1508 
1509  // We can choose any index value here and be correct because all elements
1510  // are undefined. Return 0 for better potential for callers to simplify.
1511  return 0;
1512  }
1513 
1514  static bool isSplatMask(const int *Mask, EVT VT);
1515 
1516  /// Change values in a shuffle permute mask assuming
1517  /// the two vector operands have swapped position.
1518  static void commuteMask(MutableArrayRef<int> Mask) {
1519  unsigned NumElems = Mask.size();
1520  for (unsigned i = 0; i != NumElems; ++i) {
1521  int idx = Mask[i];
1522  if (idx < 0)
1523  continue;
1524  else if (idx < (int)NumElems)
1525  Mask[i] = idx + NumElems;
1526  else
1527  Mask[i] = idx - NumElems;
1528  }
1529  }
1530 
1531  static bool classof(const SDNode *N) {
1532  return N->getOpcode() == ISD::VECTOR_SHUFFLE;
1533  }
1534 };
1535 
1536 class ConstantSDNode : public SDNode {
1537  friend class SelectionDAG;
1538 
1539  const ConstantInt *Value;
1540 
1541  ConstantSDNode(bool isTarget, bool isOpaque, const ConstantInt *val, EVT VT)
1542  : SDNode(isTarget ? ISD::TargetConstant : ISD::Constant, 0, DebugLoc(),
1543  getSDVTList(VT)),
1544  Value(val) {
1545  ConstantSDNodeBits.IsOpaque = isOpaque;
1546  }
1547 
1548 public:
1549  const ConstantInt *getConstantIntValue() const { return Value; }
1550  const APInt &getAPIntValue() const { return Value->getValue(); }
1551  uint64_t getZExtValue() const { return Value->getZExtValue(); }
1552  int64_t getSExtValue() const { return Value->getSExtValue(); }
1553  uint64_t getLimitedValue(uint64_t Limit = UINT64_MAX) {
1554  return Value->getLimitedValue(Limit);
1555  }
1556 
1557  bool isOne() const { return Value->isOne(); }
1558  bool isNullValue() const { return Value->isZero(); }
1559  bool isAllOnesValue() const { return Value->isMinusOne(); }
1560 
1561  bool isOpaque() const { return ConstantSDNodeBits.IsOpaque; }
1562 
1563  static bool classof(const SDNode *N) {
1564  return N->getOpcode() == ISD::Constant ||
1566  }
1567 };
1568 
1569 uint64_t SDNode::getConstantOperandVal(unsigned Num) const {
1570  return cast<ConstantSDNode>(getOperand(Num))->getZExtValue();
1571 }
1572 
1573 const APInt &SDNode::getConstantOperandAPInt(unsigned Num) const {
1574  return cast<ConstantSDNode>(getOperand(Num))->getAPIntValue();
1575 }
1576 
1577 class ConstantFPSDNode : public SDNode {
1578  friend class SelectionDAG;
1579 
1580  const ConstantFP *Value;
1581 
1582  ConstantFPSDNode(bool isTarget, const ConstantFP *val, EVT VT)
1583  : SDNode(isTarget ? ISD::TargetConstantFP : ISD::ConstantFP, 0,
1584  DebugLoc(), getSDVTList(VT)),
1585  Value(val) {}
1586 
1587 public:
1588  const APFloat& getValueAPF() const { return Value->getValueAPF(); }
1589  const ConstantFP *getConstantFPValue() const { return Value; }
1590 
1591  /// Return true if the value is positive or negative zero.
1592  bool isZero() const { return Value->isZero(); }
1593 
1594  /// Return true if the value is a NaN.
1595  bool isNaN() const { return Value->isNaN(); }
1596 
1597  /// Return true if the value is an infinity
1598  bool isInfinity() const { return Value->isInfinity(); }
1599 
1600  /// Return true if the value is negative.
1601  bool isNegative() const { return Value->isNegative(); }
1602 
1603  /// We don't rely on operator== working on double values, as
1604  /// it returns true for things that are clearly not equal, like -0.0 and 0.0.
1605  /// As such, this method can be used to do an exact bit-for-bit comparison of
1606  /// two floating point values.
1607 
1608  /// We leave the version with the double argument here because it's just so
1609  /// convenient to write "2.0" and the like. Without this function we'd
1610  /// have to duplicate its logic everywhere it's called.
1611  bool isExactlyValue(double V) const {
1612  return Value->getValueAPF().isExactlyValue(V);
1613  }
1614  bool isExactlyValue(const APFloat& V) const;
1615 
1616  static bool isValueValidForType(EVT VT, const APFloat& Val);
1617 
1618  static bool classof(const SDNode *N) {
1619  return N->getOpcode() == ISD::ConstantFP ||
1621  }
1622 };
1623 
1624 /// Returns true if \p V is a constant integer zero.
1625 bool isNullConstant(SDValue V);
1626 
1627 /// Returns true if \p V is an FP constant with a value of positive zero.
1628 bool isNullFPConstant(SDValue V);
1629 
1630 /// Returns true if \p V is an integer constant with all bits set.
1631 bool isAllOnesConstant(SDValue V);
1632 
1633 /// Returns true if \p V is a constant integer one.
1634 bool isOneConstant(SDValue V);
1635 
1636 /// Return the non-bitcasted source operand of \p V if it exists.
1637 /// If \p V is not a bitcasted value, it is returned as-is.
1639 
1640 /// Return the non-bitcasted and one-use source operand of \p V if it exists.
1641 /// If \p V is not a bitcasted one-use value, it is returned as-is.
1643 
1644 /// Returns true if \p V is a bitwise not operation. Assumes that an all ones
1645 /// constant is canonicalized to be operand 1.
1646 bool isBitwiseNot(SDValue V);
1647 
1648 /// Returns the SDNode if it is a constant splat BuildVector or constant int.
1649 ConstantSDNode *isConstOrConstSplat(SDValue N, bool AllowUndefs = false);
1650 
1651 /// Returns the SDNode if it is a demanded constant splat BuildVector or
1652 /// constant int.
1653 ConstantSDNode *isConstOrConstSplat(SDValue N, const APInt &DemandedElts,
1654  bool AllowUndefs = false);
1655 
1656 /// Returns the SDNode if it is a constant splat BuildVector or constant float.
1657 ConstantFPSDNode *isConstOrConstSplatFP(SDValue N, bool AllowUndefs = false);
1658 
1659 /// Returns the SDNode if it is a demanded constant splat BuildVector or
1660 /// constant float.
1661 ConstantFPSDNode *isConstOrConstSplatFP(SDValue N, const APInt &DemandedElts,
1662  bool AllowUndefs = false);
1663 
1664 /// Return true if the value is a constant 0 integer or a splatted vector of
1665 /// a constant 0 integer (with no undefs by default).
1666 /// Build vector implicit truncation is not an issue for null values.
1667 bool isNullOrNullSplat(SDValue V, bool AllowUndefs = false);
1668 
1669 /// Return true if the value is a constant 1 integer or a splatted vector of a
1670 /// constant 1 integer (with no undefs).
1671 /// Does not permit build vector implicit truncation.
1672 bool isOneOrOneSplat(SDValue V);
1673 
1674 /// Return true if the value is a constant -1 integer or a splatted vector of a
1675 /// constant -1 integer (with no undefs).
1676 /// Does not permit build vector implicit truncation.
1678 
1679 class GlobalAddressSDNode : public SDNode {
1680  friend class SelectionDAG;
1681 
1682  const GlobalValue *TheGlobal;
1683  int64_t Offset;
1684  unsigned char TargetFlags;
1685 
1686  GlobalAddressSDNode(unsigned Opc, unsigned Order, const DebugLoc &DL,
1687  const GlobalValue *GA, EVT VT, int64_t o,
1688  unsigned char TF);
1689 
1690 public:
1691  const GlobalValue *getGlobal() const { return TheGlobal; }
1692  int64_t getOffset() const { return Offset; }
1693  unsigned char getTargetFlags() const { return TargetFlags; }
1694  // Return the address space this GlobalAddress belongs to.
1695  unsigned getAddressSpace() const;
1696 
1697  static bool classof(const SDNode *N) {
1698  return N->getOpcode() == ISD::GlobalAddress ||
1700  N->getOpcode() == ISD::GlobalTLSAddress ||
1702  }
1703 };
1704 
1705 class FrameIndexSDNode : public SDNode {
1706  friend class SelectionDAG;
1707 
1708  int FI;
1709 
1710  FrameIndexSDNode(int fi, EVT VT, bool isTarg)
1711  : SDNode(isTarg ? ISD::TargetFrameIndex : ISD::FrameIndex,
1712  0, DebugLoc(), getSDVTList(VT)), FI(fi) {
1713  }
1714 
1715 public:
1716  int getIndex() const { return FI; }
1717 
1718  static bool classof(const SDNode *N) {
1719  return N->getOpcode() == ISD::FrameIndex ||
1721  }
1722 };
1723 
1724 /// This SDNode is used for LIFETIME_START/LIFETIME_END values, which indicate
1725 /// the offet and size that are started/ended in the underlying FrameIndex.
1726 class LifetimeSDNode : public SDNode {
1727  friend class SelectionDAG;
1728  int64_t Size;
1729  int64_t Offset; // -1 if offset is unknown.
1730 
1731  LifetimeSDNode(unsigned Opcode, unsigned Order, const DebugLoc &dl,
1732  SDVTList VTs, int64_t Size, int64_t Offset)
1733  : SDNode(Opcode, Order, dl, VTs), Size(Size), Offset(Offset) {}
1734 public:
1735  int64_t getFrameIndex() const {
1736  return cast<FrameIndexSDNode>(getOperand(1))->getIndex();
1737  }
1738 
1739  bool hasOffset() const { return Offset >= 0; }
1740  int64_t getOffset() const {
1741  assert(hasOffset() && "offset is unknown");
1742  return Offset;
1743  }
1744  int64_t getSize() const {
1745  assert(hasOffset() && "offset is unknown");
1746  return Size;
1747  }
1748 
1749  // Methods to support isa and dyn_cast
1750  static bool classof(const SDNode *N) {
1751  return N->getOpcode() == ISD::LIFETIME_START ||
1752  N->getOpcode() == ISD::LIFETIME_END;
1753  }
1754 };
1755 
1756 class JumpTableSDNode : public SDNode {
1757  friend class SelectionDAG;
1758 
1759  int JTI;
1760  unsigned char TargetFlags;
1761 
1762  JumpTableSDNode(int jti, EVT VT, bool isTarg, unsigned char TF)
1763  : SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable,
1764  0, DebugLoc(), getSDVTList(VT)), JTI(jti), TargetFlags(TF) {
1765  }
1766 
1767 public:
1768  int getIndex() const { return JTI; }
1769  unsigned char getTargetFlags() const { return TargetFlags; }
1770 
1771  static bool classof(const SDNode *N) {
1772  return N->getOpcode() == ISD::JumpTable ||
1774  }
1775 };
1776 
1777 class ConstantPoolSDNode : public SDNode {
1778  friend class SelectionDAG;
1779 
1780  union {
1783  } Val;
1784  int Offset; // It's a MachineConstantPoolValue if top bit is set.
1785  unsigned Alignment; // Minimum alignment requirement of CP (not log2 value).
1786  unsigned char TargetFlags;
1787 
1788  ConstantPoolSDNode(bool isTarget, const Constant *c, EVT VT, int o,
1789  unsigned Align, unsigned char TF)
1790  : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0,
1791  DebugLoc(), getSDVTList(VT)), Offset(o), Alignment(Align),
1792  TargetFlags(TF) {
1793  assert(Offset >= 0 && "Offset is too large");
1794  Val.ConstVal = c;
1795  }
1796 
1797  ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v,
1798  EVT VT, int o, unsigned Align, unsigned char TF)
1800  DebugLoc(), getSDVTList(VT)), Offset(o), Alignment(Align),
1801  TargetFlags(TF) {
1802  assert(Offset >= 0 && "Offset is too large");
1803  Val.MachineCPVal = v;
1804  Offset |= 1 << (sizeof(unsigned)*CHAR_BIT-1);
1805  }
1806 
1807 public:
1809  return Offset < 0;
1810  }
1811 
1812  const Constant *getConstVal() const {
1813  assert(!isMachineConstantPoolEntry() && "Wrong constantpool type");
1814  return Val.ConstVal;
1815  }
1816 
1818  assert(isMachineConstantPoolEntry() && "Wrong constantpool type");
1819  return Val.MachineCPVal;
1820  }
1821 
1822  int getOffset() const {
1823  return Offset & ~(1 << (sizeof(unsigned)*CHAR_BIT-1));
1824  }
1825 
1826  // Return the alignment of this constant pool object, which is either 0 (for
1827  // default alignment) or the desired value.
1828  unsigned getAlignment() const { return Alignment; }
1829  unsigned char getTargetFlags() const { return TargetFlags; }
1830 
1831  Type *getType() const;
1832 
1833  static bool classof(const SDNode *N) {
1834  return N->getOpcode() == ISD::ConstantPool ||
1836  }
1837 };
1838 
1839 /// Completely target-dependent object reference.
1840 class TargetIndexSDNode : public SDNode {
1841  friend class SelectionDAG;
1842 
1843  unsigned char TargetFlags;
1844  int Index;
1845  int64_t Offset;
1846 
1847 public:
1848  TargetIndexSDNode(int Idx, EVT VT, int64_t Ofs, unsigned char TF)
1849  : SDNode(ISD::TargetIndex, 0, DebugLoc(), getSDVTList(VT)),
1850  TargetFlags(TF), Index(Idx), Offset(Ofs) {}
1851 
1852  unsigned char getTargetFlags() const { return TargetFlags; }
1853  int getIndex() const { return Index; }
1854  int64_t getOffset() const { return Offset; }
1855 
1856  static bool classof(const SDNode *N) {
1857  return N->getOpcode() == ISD::TargetIndex;
1858  }
1859 };
1860 
1861 class BasicBlockSDNode : public SDNode {
1862  friend class SelectionDAG;
1863 
1864  MachineBasicBlock *MBB;
1865 
1866  /// Debug info is meaningful and potentially useful here, but we create
1867  /// blocks out of order when they're jumped to, which makes it a bit
1868  /// harder. Let's see if we need it first.
1869  explicit BasicBlockSDNode(MachineBasicBlock *mbb)
1870  : SDNode(ISD::BasicBlock, 0, DebugLoc(), getSDVTList(MVT::Other)), MBB(mbb)
1871  {}
1872 
1873 public:
1874  MachineBasicBlock *getBasicBlock() const { return MBB; }
1875 
1876  static bool classof(const SDNode *N) {
1877  return N->getOpcode() == ISD::BasicBlock;
1878  }
1879 };
1880 
1881 /// A "pseudo-class" with methods for operating on BUILD_VECTORs.
1882 class BuildVectorSDNode : public SDNode {
1883 public:
1884  // These are constructed as SDNodes and then cast to BuildVectorSDNodes.
1885  explicit BuildVectorSDNode() = delete;
1886 
1887  /// Check if this is a constant splat, and if so, find the
1888  /// smallest element size that splats the vector. If MinSplatBits is
1889  /// nonzero, the element size must be at least that large. Note that the
1890  /// splat element may be the entire vector (i.e., a one element vector).
1891  /// Returns the splat element value in SplatValue. Any undefined bits in
1892  /// that value are zero, and the corresponding bits in the SplatUndef mask
1893  /// are set. The SplatBitSize value is set to the splat element size in
1894  /// bits. HasAnyUndefs is set to true if any bits in the vector are
1895  /// undefined. isBigEndian describes the endianness of the target.
1896  bool isConstantSplat(APInt &SplatValue, APInt &SplatUndef,
1897  unsigned &SplatBitSize, bool &HasAnyUndefs,
1898  unsigned MinSplatBits = 0,
1899  bool isBigEndian = false) const;
1900 
1901  /// Returns the demanded splatted value or a null value if this is not a
1902  /// splat.
1903  ///
1904  /// The DemandedElts mask indicates the elements that must be in the splat.
1905  /// If passed a non-null UndefElements bitvector, it will resize it to match
1906  /// the vector width and set the bits where elements are undef.
1907  SDValue getSplatValue(const APInt &DemandedElts,
1908  BitVector *UndefElements = nullptr) const;
1909 
1910  /// Returns the splatted value or a null value if this is not a splat.
1911  ///
1912  /// If passed a non-null UndefElements bitvector, it will resize it to match
1913  /// the vector width and set the bits where elements are undef.
1914  SDValue getSplatValue(BitVector *UndefElements = nullptr) const;
1915 
1916  /// Returns the demanded splatted constant or null if this is not a constant
1917  /// splat.
1918  ///
1919  /// The DemandedElts mask indicates the elements that must be in the splat.
1920  /// If passed a non-null UndefElements bitvector, it will resize it to match
1921  /// the vector width and set the bits where elements are undef.
1922  ConstantSDNode *
1923  getConstantSplatNode(const APInt &DemandedElts,
1924  BitVector *UndefElements = nullptr) const;
1925 
1926  /// Returns the splatted constant or null if this is not a constant
1927  /// splat.
1928  ///
1929  /// If passed a non-null UndefElements bitvector, it will resize it to match
1930  /// the vector width and set the bits where elements are undef.
1931  ConstantSDNode *
1932  getConstantSplatNode(BitVector *UndefElements = nullptr) const;
1933 
1934  /// Returns the demanded splatted constant FP or null if this is not a
1935  /// constant FP splat.
1936  ///
1937  /// The DemandedElts mask indicates the elements that must be in the splat.
1938  /// If passed a non-null UndefElements bitvector, it will resize it to match
1939  /// the vector width and set the bits where elements are undef.
1941  getConstantFPSplatNode(const APInt &DemandedElts,
1942  BitVector *UndefElements = nullptr) const;
1943 
1944  /// Returns the splatted constant FP or null if this is not a constant
1945  /// FP splat.
1946  ///
1947  /// If passed a non-null UndefElements bitvector, it will resize it to match
1948  /// the vector width and set the bits where elements are undef.
1950  getConstantFPSplatNode(BitVector *UndefElements = nullptr) const;
1951 
1952  /// If this is a constant FP splat and the splatted constant FP is an
1953  /// exact power or 2, return the log base 2 integer value. Otherwise,
1954  /// return -1.
1955  ///
1956  /// The BitWidth specifies the necessary bit precision.
1957  int32_t getConstantFPSplatPow2ToLog2Int(BitVector *UndefElements,
1958  uint32_t BitWidth) const;
1959 
1960  bool isConstant() const;
1961 
1962  static bool classof(const SDNode *N) {
1963  return N->getOpcode() == ISD::BUILD_VECTOR;
1964  }
1965 };
1966 
1967 /// An SDNode that holds an arbitrary LLVM IR Value. This is
1968 /// used when the SelectionDAG needs to make a simple reference to something
1969 /// in the LLVM IR representation.
1970 ///
1971 class SrcValueSDNode : public SDNode {
1972  friend class SelectionDAG;
1973 
1974  const Value *V;
1975 
1976  /// Create a SrcValue for a general value.
1977  explicit SrcValueSDNode(const Value *v)
1978  : SDNode(ISD::SRCVALUE, 0, DebugLoc(), getSDVTList(MVT::Other)), V(v) {}
1979 
1980 public:
1981  /// Return the contained Value.
1982  const Value *getValue() const { return V; }
1983 
1984  static bool classof(const SDNode *N) {
1985  return N->getOpcode() == ISD::SRCVALUE;
1986  }
1987 };
1988 
1989 class MDNodeSDNode : public SDNode {
1990  friend class SelectionDAG;
1991 
1992  const MDNode *MD;
1993 
1994  explicit MDNodeSDNode(const MDNode *md)
1995  : SDNode(ISD::MDNODE_SDNODE, 0, DebugLoc(), getSDVTList(MVT::Other)), MD(md)
1996  {}
1997 
1998 public:
1999  const MDNode *getMD() const { return MD; }
2000 
2001  static bool classof(const SDNode *N) {
2002  return N->getOpcode() == ISD::MDNODE_SDNODE;
2003  }
2004 };
2005 
2006 class RegisterSDNode : public SDNode {
2007  friend class SelectionDAG;
2008 
2009  unsigned Reg;
2010 
2011  RegisterSDNode(unsigned reg, EVT VT)
2012  : SDNode(ISD::Register, 0, DebugLoc(), getSDVTList(VT)), Reg(reg) {}
2013 
2014 public:
2015  unsigned getReg() const { return Reg; }
2016 
2017  static bool classof(const SDNode *N) {
2018  return N->getOpcode() == ISD::Register;
2019  }
2020 };
2021 
2022 class RegisterMaskSDNode : public SDNode {
2023  friend class SelectionDAG;
2024 
2025  // The memory for RegMask is not owned by the node.
2026  const uint32_t *RegMask;
2027 
2028  RegisterMaskSDNode(const uint32_t *mask)
2029  : SDNode(ISD::RegisterMask, 0, DebugLoc(), getSDVTList(MVT::Untyped)),
2030  RegMask(mask) {}
2031 
2032 public:
2033  const uint32_t *getRegMask() const { return RegMask; }
2034 
2035  static bool classof(const SDNode *N) {
2036  return N->getOpcode() == ISD::RegisterMask;
2037  }
2038 };
2039 
2040 class BlockAddressSDNode : public SDNode {
2041  friend class SelectionDAG;
2042 
2043  const BlockAddress *BA;
2044  int64_t Offset;
2045  unsigned char TargetFlags;
2046 
2047  BlockAddressSDNode(unsigned NodeTy, EVT VT, const BlockAddress *ba,
2048  int64_t o, unsigned char Flags)
2049  : SDNode(NodeTy, 0, DebugLoc(), getSDVTList(VT)),
2050  BA(ba), Offset(o), TargetFlags(Flags) {}
2051 
2052 public:
2053  const BlockAddress *getBlockAddress() const { return BA; }
2054  int64_t getOffset() const { return Offset; }
2055  unsigned char getTargetFlags() const { return TargetFlags; }
2056 
2057  static bool classof(const SDNode *N) {
2058  return N->getOpcode() == ISD::BlockAddress ||
2060  }
2061 };
2062 
2063 class LabelSDNode : public SDNode {
2064  friend class SelectionDAG;
2065 
2066  MCSymbol *Label;
2067 
2068  LabelSDNode(unsigned Order, const DebugLoc &dl, MCSymbol *L)
2069  : SDNode(ISD::EH_LABEL, Order, dl, getSDVTList(MVT::Other)), Label(L) {}
2070 
2071 public:
2072  MCSymbol *getLabel() const { return Label; }
2073 
2074  static bool classof(const SDNode *N) {
2075  return N->getOpcode() == ISD::EH_LABEL ||
2077  }
2078 };
2079 
2081  friend class SelectionDAG;
2082 
2083  const char *Symbol;
2084  unsigned char TargetFlags;
2085 
2086  ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned char TF, EVT VT)
2087  : SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol,
2088  0, DebugLoc(), getSDVTList(VT)), Symbol(Sym), TargetFlags(TF) {}
2089 
2090 public:
2091  const char *getSymbol() const { return Symbol; }
2092  unsigned char getTargetFlags() const { return TargetFlags; }
2093 
2094  static bool classof(const SDNode *N) {
2095  return N->getOpcode() == ISD::ExternalSymbol ||
2097  }
2098 };
2099 
2100 class MCSymbolSDNode : public SDNode {
2101  friend class SelectionDAG;
2102 
2103  MCSymbol *Symbol;
2104 
2105  MCSymbolSDNode(MCSymbol *Symbol, EVT VT)
2106  : SDNode(ISD::MCSymbol, 0, DebugLoc(), getSDVTList(VT)), Symbol(Symbol) {}
2107 
2108 public:
2109  MCSymbol *getMCSymbol() const { return Symbol; }
2110 
2111  static bool classof(const SDNode *N) {
2112  return N->getOpcode() == ISD::MCSymbol;
2113  }
2114 };
2115 
2116 class CondCodeSDNode : public SDNode {
2117  friend class SelectionDAG;
2118 
2119  ISD::CondCode Condition;
2120 
2121  explicit CondCodeSDNode(ISD::CondCode Cond)
2122  : SDNode(ISD::CONDCODE, 0, DebugLoc(), getSDVTList(MVT::Other)),
2123  Condition(Cond) {}
2124 
2125 public:
2126  ISD::CondCode get() const { return Condition; }
2127 
2128  static bool classof(const SDNode *N) {
2129  return N->getOpcode() == ISD::CONDCODE;
2130  }
2131 };
2132 
2133 /// This class is used to represent EVT's, which are used
2134 /// to parameterize some operations.
2135 class VTSDNode : public SDNode {
2136  friend class SelectionDAG;
2137 
2138  EVT ValueType;
2139 
2140  explicit VTSDNode(EVT VT)
2141  : SDNode(ISD::VALUETYPE, 0, DebugLoc(), getSDVTList(MVT::Other)),
2142  ValueType(VT) {}
2143 
2144 public:
2145  EVT getVT() const { return ValueType; }
2146 
2147  static bool classof(const SDNode *N) {
2148  return N->getOpcode() == ISD::VALUETYPE;
2149  }
2150 };
2151 
2152 /// Base class for LoadSDNode and StoreSDNode
2153 class LSBaseSDNode : public MemSDNode {
2154 public:
2155  LSBaseSDNode(ISD::NodeType NodeTy, unsigned Order, const DebugLoc &dl,
2156  SDVTList VTs, ISD::MemIndexedMode AM, EVT MemVT,
2157  MachineMemOperand *MMO)
2158  : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {
2159  LSBaseSDNodeBits.AddressingMode = AM;
2160  assert(getAddressingMode() == AM && "Value truncated");
2161  assert((!MMO->isAtomic() || MMO->isVolatile()) &&
2162  "use an AtomicSDNode instead for non-volatile atomics");
2163  }
2164 
2165  const SDValue &getOffset() const {
2166  return getOperand(getOpcode() == ISD::LOAD ? 2 : 3);
2167  }
2168 
2169  /// Return the addressing mode for this load or store:
2170  /// unindexed, pre-inc, pre-dec, post-inc, or post-dec.
2172  return static_cast<ISD::MemIndexedMode>(LSBaseSDNodeBits.AddressingMode);
2173  }
2174 
2175  /// Return true if this is a pre/post inc/dec load/store.
2176  bool isIndexed() const { return getAddressingMode() != ISD::UNINDEXED; }
2177 
2178  /// Return true if this is NOT a pre/post inc/dec load/store.
2179  bool isUnindexed() const { return getAddressingMode() == ISD::UNINDEXED; }
2180 
2181  static bool classof(const SDNode *N) {
2182  return N->getOpcode() == ISD::LOAD ||
2183  N->getOpcode() == ISD::STORE;
2184  }
2185 };
2186 
2187 /// This class is used to represent ISD::LOAD nodes.
2188 class LoadSDNode : public LSBaseSDNode {
2189  friend class SelectionDAG;
2190 
2191  LoadSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2192  ISD::MemIndexedMode AM, ISD::LoadExtType ETy, EVT MemVT,
2193  MachineMemOperand *MMO)
2194  : LSBaseSDNode(ISD::LOAD, Order, dl, VTs, AM, MemVT, MMO) {
2195  LoadSDNodeBits.ExtTy = ETy;
2196  assert(readMem() && "Load MachineMemOperand is not a load!");
2197  assert(!writeMem() && "Load MachineMemOperand is a store!");
2198  }
2199 
2200 public:
2201  /// Return whether this is a plain node,
2202  /// or one of the varieties of value-extending loads.
2204  return static_cast<ISD::LoadExtType>(LoadSDNodeBits.ExtTy);
2205  }
2206 
2207  const SDValue &getBasePtr() const { return getOperand(1); }
2208  const SDValue &getOffset() const { return getOperand(2); }
2209 
2210  static bool classof(const SDNode *N) {
2211  return N->getOpcode() == ISD::LOAD;
2212  }
2213 };
2214 
2215 /// This class is used to represent ISD::STORE nodes.
2216 class StoreSDNode : public LSBaseSDNode {
2217  friend class SelectionDAG;
2218 
2219  StoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2220  ISD::MemIndexedMode AM, bool isTrunc, EVT MemVT,
2221  MachineMemOperand *MMO)
2222  : LSBaseSDNode(ISD::STORE, Order, dl, VTs, AM, MemVT, MMO) {
2223  StoreSDNodeBits.IsTruncating = isTrunc;
2224  assert(!readMem() && "Store MachineMemOperand is a load!");
2225  assert(writeMem() && "Store MachineMemOperand is not a store!");
2226  }
2227 
2228 public:
2229  /// Return true if the op does a truncation before store.
2230  /// For integers this is the same as doing a TRUNCATE and storing the result.
2231  /// For floats, it is the same as doing an FP_ROUND and storing the result.
2232  bool isTruncatingStore() const { return StoreSDNodeBits.IsTruncating; }
2233  void setTruncatingStore(bool Truncating) {
2234  StoreSDNodeBits.IsTruncating = Truncating;
2235  }
2236 
2237  const SDValue &getValue() const { return getOperand(1); }
2238  const SDValue &getBasePtr() const { return getOperand(2); }
2239  const SDValue &getOffset() const { return getOperand(3); }
2240 
2241  static bool classof(const SDNode *N) {
2242  return N->getOpcode() == ISD::STORE;
2243  }
2244 };
2245 
2246 /// This base class is used to represent MLOAD and MSTORE nodes
2248 public:
2249  friend class SelectionDAG;
2250 
2251  MaskedLoadStoreSDNode(ISD::NodeType NodeTy, unsigned Order,
2252  const DebugLoc &dl, SDVTList VTs, EVT MemVT,
2253  MachineMemOperand *MMO)
2254  : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {}
2255 
2256  // MaskedLoadSDNode (Chain, ptr, mask, passthru)
2257  // MaskedStoreSDNode (Chain, data, ptr, mask)
2258  // Mask is a vector of i1 elements
2259  const SDValue &getBasePtr() const {
2260  return getOperand(getOpcode() == ISD::MLOAD ? 1 : 2);
2261  }
2262  const SDValue &getMask() const {
2263  return getOperand(getOpcode() == ISD::MLOAD ? 2 : 3);
2264  }
2265 
2266  static bool classof(const SDNode *N) {
2267  return N->getOpcode() == ISD::MLOAD ||
2268  N->getOpcode() == ISD::MSTORE;
2269  }
2270 };
2271 
2272 /// This class is used to represent an MLOAD node
2274 public:
2275  friend class SelectionDAG;
2276 
2277  MaskedLoadSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2278  ISD::LoadExtType ETy, bool IsExpanding, EVT MemVT,
2279  MachineMemOperand *MMO)
2280  : MaskedLoadStoreSDNode(ISD::MLOAD, Order, dl, VTs, MemVT, MMO) {
2281  LoadSDNodeBits.ExtTy = ETy;
2282  LoadSDNodeBits.IsExpanding = IsExpanding;
2283  }
2284 
2286  return static_cast<ISD::LoadExtType>(LoadSDNodeBits.ExtTy);
2287  }
2288 
2289  const SDValue &getBasePtr() const { return getOperand(1); }
2290  const SDValue &getMask() const { return getOperand(2); }
2291  const SDValue &getPassThru() const { return getOperand(3); }
2292 
2293  static bool classof(const SDNode *N) {
2294  return N->getOpcode() == ISD::MLOAD;
2295  }
2296 
2297  bool isExpandingLoad() const { return LoadSDNodeBits.IsExpanding; }
2298 };
2299 
2300 /// This class is used to represent an MSTORE node
2302 public:
2303  friend class SelectionDAG;
2304 
2305  MaskedStoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2306  bool isTrunc, bool isCompressing, EVT MemVT,
2307  MachineMemOperand *MMO)
2308  : MaskedLoadStoreSDNode(ISD::MSTORE, Order, dl, VTs, MemVT, MMO) {
2309  StoreSDNodeBits.IsTruncating = isTrunc;
2310  StoreSDNodeBits.IsCompressing = isCompressing;
2311  }
2312 
2313  /// Return true if the op does a truncation before store.
2314  /// For integers this is the same as doing a TRUNCATE and storing the result.
2315  /// For floats, it is the same as doing an FP_ROUND and storing the result.
2316  bool isTruncatingStore() const { return StoreSDNodeBits.IsTruncating; }
2317 
2318  /// Returns true if the op does a compression to the vector before storing.
2319  /// The node contiguously stores the active elements (integers or floats)
2320  /// in src (those with their respective bit set in writemask k) to unaligned
2321  /// memory at base_addr.
2322  bool isCompressingStore() const { return StoreSDNodeBits.IsCompressing; }
2323 
2324  const SDValue &getValue() const { return getOperand(1); }
2325  const SDValue &getBasePtr() const { return getOperand(2); }
2326  const SDValue &getMask() const { return getOperand(3); }
2327 
2328  static bool classof(const SDNode *N) {
2329  return N->getOpcode() == ISD::MSTORE;
2330  }
2331 };
2332 
2333 /// This is a base class used to represent
2334 /// MGATHER and MSCATTER nodes
2335 ///
2337 public:
2338  friend class SelectionDAG;
2339 
2341  const DebugLoc &dl, SDVTList VTs, EVT MemVT,
2342  MachineMemOperand *MMO)
2343  : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {}
2344 
2345  // In the both nodes address is Op1, mask is Op2:
2346  // MaskedGatherSDNode (Chain, passthru, mask, base, index, scale)
2347  // MaskedScatterSDNode (Chain, value, mask, base, index, scale)
2348  // Mask is a vector of i1 elements
2349  const SDValue &getBasePtr() const { return getOperand(3); }
2350  const SDValue &getIndex() const { return getOperand(4); }
2351  const SDValue &getMask() const { return getOperand(2); }
2352  const SDValue &getScale() const { return getOperand(5); }
2353 
2354  static bool classof(const SDNode *N) {
2355  return N->getOpcode() == ISD::MGATHER ||
2356  N->getOpcode() == ISD::MSCATTER;
2357  }
2358 };
2359 
2360 /// This class is used to represent an MGATHER node
2361 ///
2363 public:
2364  friend class SelectionDAG;
2365 
2366  MaskedGatherSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2367  EVT MemVT, MachineMemOperand *MMO)
2368  : MaskedGatherScatterSDNode(ISD::MGATHER, Order, dl, VTs, MemVT, MMO) {}
2369 
2370  const SDValue &getPassThru() const { return getOperand(1); }
2371 
2372  static bool classof(const SDNode *N) {
2373  return N->getOpcode() == ISD::MGATHER;
2374  }
2375 };
2376 
2377 /// This class is used to represent an MSCATTER node
2378 ///
2380 public:
2381  friend class SelectionDAG;
2382 
2383  MaskedScatterSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2384  EVT MemVT, MachineMemOperand *MMO)
2385  : MaskedGatherScatterSDNode(ISD::MSCATTER, Order, dl, VTs, MemVT, MMO) {}
2386 
2387  const SDValue &getValue() const { return getOperand(1); }
2388 
2389  static bool classof(const SDNode *N) {
2390  return N->getOpcode() == ISD::MSCATTER;
2391  }
2392 };
2393 
2394 /// An SDNode that represents everything that will be needed
2395 /// to construct a MachineInstr. These nodes are created during the
2396 /// instruction selection proper phase.
2397 ///
2398 /// Note that the only supported way to set the `memoperands` is by calling the
2399 /// `SelectionDAG::setNodeMemRefs` function as the memory management happens
2400 /// inside the DAG rather than in the node.
2401 class MachineSDNode : public SDNode {
2402 private:
2403  friend class SelectionDAG;
2404 
2405  MachineSDNode(unsigned Opc, unsigned Order, const DebugLoc &DL, SDVTList VTs)
2406  : SDNode(Opc, Order, DL, VTs) {}
2407 
2408  // We use a pointer union between a single `MachineMemOperand` pointer and
2409  // a pointer to an array of `MachineMemOperand` pointers. This is null when
2410  // the number of these is zero, the single pointer variant used when the
2411  // number is one, and the array is used for larger numbers.
2412  //
2413  // The array is allocated via the `SelectionDAG`'s allocator and so will
2414  // always live until the DAG is cleaned up and doesn't require ownership here.
2415  //
2416  // We can't use something simpler like `TinyPtrVector` here because `SDNode`
2417  // subclasses aren't managed in a conforming C++ manner. See the comments on
2418  // `SelectionDAG::MorphNodeTo` which details what all goes on, but the
2419  // constraint here is that these don't manage memory with their constructor or
2420  // destructor and can be initialized to a good state even if they start off
2421  // uninitialized.
2423 
2424  // Note that this could be folded into the above `MemRefs` member if doing so
2425  // is advantageous at some point. We don't need to store this in most cases.
2426  // However, at the moment this doesn't appear to make the allocation any
2427  // smaller and makes the code somewhat simpler to read.
2428  int NumMemRefs = 0;
2429 
2430 public:
2432 
2434  // Special case the common cases.
2435  if (NumMemRefs == 0)
2436  return {};
2437  if (NumMemRefs == 1)
2438  return makeArrayRef(MemRefs.getAddrOfPtr1(), 1);
2439 
2440  // Otherwise we have an actual array.
2441  return makeArrayRef(MemRefs.get<MachineMemOperand **>(), NumMemRefs);
2442  }
2443  mmo_iterator memoperands_begin() const { return memoperands().begin(); }
2444  mmo_iterator memoperands_end() const { return memoperands().end(); }
2445  bool memoperands_empty() const { return memoperands().empty(); }
2446 
2447  /// Clear out the memory reference descriptor list.
2448  void clearMemRefs() {
2449  MemRefs = nullptr;
2450  NumMemRefs = 0;
2451  }
2452 
2453  static bool classof(const SDNode *N) {
2454  return N->isMachineOpcode();
2455  }
2456 };
2457 
2458 class SDNodeIterator : public std::iterator<std::forward_iterator_tag,
2459  SDNode, ptrdiff_t> {
2460  const SDNode *Node;
2461  unsigned Operand;
2462 
2463  SDNodeIterator(const SDNode *N, unsigned Op) : Node(N), Operand(Op) {}
2464 
2465 public:
2466  bool operator==(const SDNodeIterator& x) const {
2467  return Operand == x.Operand;
2468  }
2469  bool operator!=(const SDNodeIterator& x) const { return !operator==(x); }
2470 
2471  pointer operator*() const {
2472  return Node->getOperand(Operand).getNode();
2473  }
2474  pointer operator->() const { return operator*(); }
2475 
2476  SDNodeIterator& operator++() { // Preincrement
2477  ++Operand;
2478  return *this;
2479  }
2480  SDNodeIterator operator++(int) { // Postincrement
2481  SDNodeIterator tmp = *this; ++*this; return tmp;
2482  }
2483  size_t operator-(SDNodeIterator Other) const {
2484  assert(Node == Other.Node &&
2485  "Cannot compare iterators of two different nodes!");
2486  return Operand - Other.Operand;
2487  }
2488 
2489  static SDNodeIterator begin(const SDNode *N) { return SDNodeIterator(N, 0); }
2490  static SDNodeIterator end (const SDNode *N) {
2491  return SDNodeIterator(N, N->getNumOperands());
2492  }
2493 
2494  unsigned getOperand() const { return Operand; }
2495  const SDNode *getNode() const { return Node; }
2496 };
2497 
2498 template <> struct GraphTraits<SDNode*> {
2499  using NodeRef = SDNode *;
2501 
2502  static NodeRef getEntryNode(SDNode *N) { return N; }
2503 
2505  return SDNodeIterator::begin(N);
2506  }
2507 
2509  return SDNodeIterator::end(N);
2510  }
2511 };
2512 
2513 /// A representation of the largest SDNode, for use in sizeof().
2514 ///
2515 /// This needs to be a union because the largest node differs on 32 bit systems
2516 /// with 4 and 8 byte pointer alignment, respectively.
2520 
2521 /// The SDNode class with the greatest alignment requirement.
2523 
2524 namespace ISD {
2525 
2526  /// Returns true if the specified node is a non-extending and unindexed load.
2527  inline bool isNormalLoad(const SDNode *N) {
2528  const LoadSDNode *Ld = dyn_cast<LoadSDNode>(N);
2529  return Ld && Ld->getExtensionType() == ISD::NON_EXTLOAD &&
2531  }
2532 
2533  /// Returns true if the specified node is a non-extending load.
2534  inline bool isNON_EXTLoad(const SDNode *N) {
2535  return isa<LoadSDNode>(N) &&
2536  cast<LoadSDNode>(N)->getExtensionType() == ISD::NON_EXTLOAD;
2537  }
2538 
2539  /// Returns true if the specified node is a EXTLOAD.
2540  inline bool isEXTLoad(const SDNode *N) {
2541  return isa<LoadSDNode>(N) &&
2542  cast<LoadSDNode>(N)->getExtensionType() == ISD::EXTLOAD;
2543  }
2544 
2545  /// Returns true if the specified node is a SEXTLOAD.
2546  inline bool isSEXTLoad(const SDNode *N) {
2547  return isa<LoadSDNode>(N) &&
2548  cast<LoadSDNode>(N)->getExtensionType() == ISD::SEXTLOAD;
2549  }
2550 
2551  /// Returns true if the specified node is a ZEXTLOAD.
2552  inline bool isZEXTLoad(const SDNode *N) {
2553  return isa<LoadSDNode>(N) &&
2554  cast<LoadSDNode>(N)->getExtensionType() == ISD::ZEXTLOAD;
2555  }
2556 
2557  /// Returns true if the specified node is an unindexed load.
2558  inline bool isUNINDEXEDLoad(const SDNode *N) {
2559  return isa<LoadSDNode>(N) &&
2560  cast<LoadSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
2561  }
2562 
2563  /// Returns true if the specified node is a non-truncating
2564  /// and unindexed store.
2565  inline bool isNormalStore(const SDNode *N) {
2566  const StoreSDNode *St = dyn_cast<StoreSDNode>(N);
2567  return St && !St->isTruncatingStore() &&
2569  }
2570 
2571  /// Returns true if the specified node is a non-truncating store.
2572  inline bool isNON_TRUNCStore(const SDNode *N) {
2573  return isa<StoreSDNode>(N) && !cast<StoreSDNode>(N)->isTruncatingStore();
2574  }
2575 
2576  /// Returns true if the specified node is a truncating store.
2577  inline bool isTRUNCStore(const SDNode *N) {
2578  return isa<StoreSDNode>(N) && cast<StoreSDNode>(N)->isTruncatingStore();
2579  }
2580 
2581  /// Returns true if the specified node is an unindexed store.
2582  inline bool isUNINDEXEDStore(const SDNode *N) {
2583  return isa<StoreSDNode>(N) &&
2584  cast<StoreSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
2585  }
2586 
2587  /// Return true if the node is a math/logic binary operator. This corresponds
2588  /// to the IR function of the same name.
2589  inline bool isBinaryOp(const SDNode *N) {
2590  auto Op = N->getOpcode();
2591  return (Op == ISD::ADD || Op == ISD::SUB || Op == ISD::MUL ||
2592  Op == ISD::AND || Op == ISD::OR || Op == ISD::XOR ||
2593  Op == ISD::SHL || Op == ISD::SRL || Op == ISD::SRA ||
2594  Op == ISD::SDIV || Op == ISD::UDIV || Op == ISD::SREM ||
2595  Op == ISD::UREM || Op == ISD::FADD || Op == ISD::FSUB ||
2596  Op == ISD::FMUL || Op == ISD::FDIV || Op == ISD::FREM);
2597  }
2598 
2599  /// Attempt to match a unary predicate against a scalar/splat constant or
2600  /// every element of a constant BUILD_VECTOR.
2601  /// If AllowUndef is true, then UNDEF elements will pass nullptr to Match.
2604  bool AllowUndefs = false);
2605 
2606  /// Attempt to match a binary predicate against a pair of scalar/splat
2607  /// constants or every element of a pair of constant BUILD_VECTORs.
2608  /// If AllowUndef is true, then UNDEF elements will pass nullptr to Match.
2609  bool matchBinaryPredicate(
2610  SDValue LHS, SDValue RHS,
2612  bool AllowUndefs = false);
2613 } // end namespace ISD
2614 
2615 } // end namespace llvm
2616 
2617 #endif // LLVM_CODEGEN_SELECTIONDAGNODES_H
ANNOTATION_LABEL - Represents a mid basic block label used by annotations.
Definition: ISDOpcodes.h:682
bool isMachineConstantPoolEntry() const
Iterator for directly iterating over the operand SDValue&#39;s.
void setAllowReciprocal(bool b)
void setAllowReassociation(bool b)
bool isInvariant() const
BUILTIN_OP_END - This must be the last enum value in this list.
Definition: ISDOpcodes.h:886
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
EVT getValueType() const
Return the ValueType of the referenced return value.
Type
MessagePack types as defined in the standard, with the exception of Integer being divided into a sign...
Definition: MsgPackReader.h:48
static void commuteMask(MutableArrayRef< int > Mask)
Change values in a shuffle permute mask assuming the two vector operands have swapped position...
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
const SDValue & getOffset() const
void setFlags(SDNodeFlags NewFlags)
static bool isConstant(const MachineInstr &MI)
bool isUndef() const
bool hasNoSignedZeros() const
Constrained versions of libm-equivalent floating point intrinsics.
Definition: ISDOpcodes.h:295
This SDNode is used for target intrinsics that touch memory and need an associated MachineMemOperand...
bool hasNoNaNs() const
Test if this operation&#39;s arguments and results are assumed not-NaN.
Definition: Operator.h:332
const GlobalValue * getGlobal() const
PointerUnion< const Value *, const PseudoSourceValue * > ValueType
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
unsigned getOpcode() const
Return the SelectionDAG opcode value for this node.
MCSymbol * getLabel() const
bool hasNoInfs() const
Test if this operation&#39;s arguments and results are assumed not-infinite.
Definition: Operator.h:337
bool isBuildVectorOfConstantSDNodes(const SDNode *N)
Return true if the specified node is a BUILD_VECTOR node of all ConstantSDNode or undef...
static bool classof(const SDNode *N)
bool isIndexed() const
Return true if this is a pre/post inc/dec load/store.
Atomic ordering constants.
unsigned char getTargetFlags() const
MDNODE_SDNODE - This is a node that holdes an MDNode*, which is used to reference metadata in the IR...
Definition: ISDOpcodes.h:740
int64_t getOffset() const
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool isNON_TRUNCStore(const SDNode *N)
Returns true if the specified node is a non-truncating store.
value_iterator value_end() const
Various leaf nodes.
Definition: ISDOpcodes.h:59
bool isCompareAndSwap() const
Returns true if this SDNode represents cmpxchg atomic operation, false otherwise. ...
void intersectWith(const SDNodeFlags Flags)
Clear any flags in this flag set that aren&#39;t also set in Flags.
VECTOR_SHUFFLE(VEC1, VEC2) - Returns a vector, of the same type as VEC1/VEC2.
Definition: ISDOpcodes.h:366
EVT getScalarType() const
If this is a vector type, return the element type, otherwise return this.
Definition: ValueTypes.h:259
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
const SDValue & getVal() const
#define BEGIN_TWO_BYTE_PACK()
constexpr char IsVolatile[]
Key for Kernel::Arg::Metadata::mIsVolatile.
const Value * getSplatValue(const Value *V)
Get splat value if the input is a splat vector or return nullptr.
unsigned getIROrder() const
Return the node ordering.
const SDValue & getBasePtr() const
bool isNegative() const
Return true if the value is negative.
bool isTargetMemoryOpcode() const
Test if this node has a target-specific memory-referencing opcode (in the <target>ISD namespace and g...
const SDNode * getNode() const
EVT getValueType(unsigned ResNo) const
Return the type of a specified result.
bool operator<(const SDValue &O) const
MachineBasicBlock * getBasicBlock() const
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
StoreSDNodeBitfields StoreSDNodeBits
bool isMemIntrinsic() const
Test if this node is a memory intrinsic (with valid pointer information).
const SDValue & getValue() const
SDVTList getVTList() const
unsigned Reg
DEMANGLE_DUMP_METHOD void dump() const
This file contains the declarations for metadata subclasses.
bool isCompressingStore() const
Returns true if the op does a compression to the vector before storing.
MCSymbol * getMCSymbol() const
bool isTargetOpcode() const
bool atEnd() const
Return true if this iterator is at the end of uses list.
MVT getSimpleVT() const
Return the SimpleValueType held in the specified simple EVT.
Definition: ValueTypes.h:252
const SDValue & getBasePtr() const
uint32_t NodeId
Definition: RDFGraph.h:260
AAMDNodes getAAInfo() const
Returns the AA info that describes the dereference.
Completely target-dependent object reference.
const SDValue & getBasePtr() const
void copyFMF(const FPMathOperator &FPMO)
Propagate the fast-math-flags from an IR FPMathOperator.
const SDValue & getChain() const
static bool classof(const SDNode *N)
unsigned getResNo() const
Convenience function for get().getResNo().
ISD::MemIndexedMode getAddressingMode() const
Return the addressing mode for this load or store: unindexed, pre-inc, pre-dec, post-inc, or post-dec.
TargetGlobalAddress - Like GlobalAddress, but the DAG does no folding or anything else with this node...
Definition: ISDOpcodes.h:130
unsigned getAlignment() const
bool operator==(const use_iterator &x) const
unsigned getValueSizeInBits(unsigned ResNo) const
Returns MVT::getSizeInBits(getValueType(ResNo)).
bool isBitwiseNot(SDValue V)
Returns true if V is a bitwise not operation.
Val, Success, OUTCHAIN = ATOMIC_CMP_SWAP_WITH_SUCCESS(INCHAIN, ptr, cmp, swap) N.b.
Definition: ISDOpcodes.h:806
bool isAllOnesOrAllOnesSplat(SDValue V)
Return true if the value is a constant -1 integer or a splatted vector of a constant -1 integer (with...
Constrained versions of the binary floating point operators.
Definition: ISDOpcodes.h:288
SDLoc(const SDNode *N)
A debug info location.
Definition: DebugLoc.h:33
Metadata node.
Definition: Metadata.h:863
MVT getSimpleValueType(unsigned ResNo) const
Return the type of a specified result as a simple type.
bool hasAllowContract() const
Test if this operation can be floating-point contracted (FMA).
Definition: Operator.h:352
void setApproximateFuncs(bool b)
const SDNodeFlags getFlags() const
void setNodeId(int Id)
Set unique node id.
bool isTargetOpcode() const
Test if this node has a target-specific opcode (in the <target>ISD namespace).
SDNode * getNode() const
get the SDNode which holds the desired result
static bool classof(const SDNode *N)
#define op(i)
MachineMemOperand * getMemOperand() const
Return a MachineMemOperand object describing the memory reference performed by operation.
void setNoSignedZeros(bool b)
uint64_t getBaseAlignment() const
Return the minimum known alignment in bytes of the base address, without the offset.
static ChildIteratorType child_end(NodeRef N)
static SimpleType getSimplifiedValue(SDUse &Val)
uint16_t PersistentId
Unique and persistent id per SDNode in the DAG.
unsigned int NumVTs
const DebugLoc & getDebugLoc() const
Return the source location info.
SDUse * getNext() const
Get the next SDUse in the use list.
unsigned getValueSizeInBits() const
Returns the size of the value in bits.
bool hasOneUse() const
Return true if there is exactly one node using value ResNo of Node.
NodeType
ISD::NodeType enum - This enum defines the target-independent operators for a SelectionDAG.
Definition: ISDOpcodes.h:38
const ConstantFP * getConstantFPValue() const
const DebugLoc & getDebugLoc() const
This SDNode is used to implement the code generator support for the llvm IR shufflevector instruction...
static bool classof(const SDNode *N)
bool hasApproximateFuncs() const
RESULT,OUTCHAIN = INTRINSIC_W_CHAIN(INCHAIN, INTRINSICID, arg1, ...) This node represents a target in...
Definition: ISDOpcodes.h:158
bool isTruncatingStore() const
Return true if the op does a truncation before store.
static bool hasPredecessorHelper(const SDNode *N, SmallPtrSetImpl< const SDNode *> &Visited, SmallVectorImpl< const SDNode *> &Worklist, unsigned int MaxSteps=0, bool TopologicalPrune=false)
Returns true if N is a predecessor of any node in Worklist.
unsigned getAddressSpace() const
Return the address space for the associated pointer.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:343
unsigned char getTargetFlags() const
static bool classof(const SDNode *N)
bool isAtomic() const
Returns true if this operation has an atomic ordering requirement of unordered or higher...
static SDVTList getSDVTList(EVT VT)
void setNoSignedWrap(bool b)
The address of a basic block.
Definition: Constants.h:839
AAMDNodes getAAInfo() const
Return the AA tags for the memory reference.
static bool classof(const SDNode *N)
bool isSEXTLoad(const SDNode *N)
Returns true if the specified node is a SEXTLOAD.
bool hasOneUse() const
Return true if there is exactly one use of this node.
A description of a memory reference used in the backend.
Definition: BitVector.h:937
std::iterator< std::forward_iterator_tag, SDUse, ptrdiff_t >::reference reference
static bool classof(const SDNode *N)
void setVectorReduction(bool b)
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:450
Shift and rotation operations.
Definition: ISDOpcodes.h:409
bool matchUnaryPredicate(SDValue Op, std::function< bool(ConstantSDNode *)> Match, bool AllowUndefs=false)
Attempt to match a unary predicate against a scalar/splat constant or every element of a constant BUI...
bool isNormalStore(const SDNode *N)
Returns true if the specified node is a non-truncating and unindexed store.
const MDNode * getRanges() const
Return the range tag for the memory reference.
Base class for LoadSDNode and StoreSDNode.
bool isBuildVectorAllZeros(const SDNode *N)
Return true if the specified node is a BUILD_VECTOR where all of the elements are 0 or undef...
static Optional< unsigned > getOpcode(ArrayRef< VPValue *> Values)
Returns the opcode of Values or ~0 if they do not all agree.
Definition: VPlanSLP.cpp:196
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:41
const SDValue & getPassThru() const
const MDNode * getMD() const
ArrayRef< MachineMemOperand * > memoperands() const
op_iterator op_end() const
unsigned getScalarValueSizeInBits() const
uint64_t getConstantOperandVal(unsigned i) const
ISD::LoadExtType getExtensionType() const
Return whether this is a plain node, or one of the varieties of value-extending loads.
bool isZEXTLoad(const SDNode *N)
Returns true if the specified node is a ZEXTLOAD.
PT1 const * getAddrOfPtr1() const
If the union is set to the first pointer type get an address pointing to it.
Definition: PointerUnion.h:149
Val, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amt) Val, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amt) For double-word atomic operations: ValLo, ValHi, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amtLo, amtHi) ValLo, ValHi, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amtLo, amtHi) These correspond to the atomicrmw instruction.
Definition: ISDOpcodes.h:814
const SDValue & getValue() const
bool hasAllowReciprocal() const
Test if this operation can use reciprocal multiply instead of division.
Definition: Operator.h:347
bool isTRUNCStore(const SDNode *N)
Returns true if the specified node is a truncating store.
This class is used to represent EVT&#39;s, which are used to parameterize some operations.
const BlockAddress * getBlockAddress() const
This is an SDNode representing atomic operations.
ShuffleVectorSDNode(EVT VT, unsigned Order, const DebugLoc &dl, const int *M)
ELFYAML::ELF_STO Other
Definition: ELFYAML.cpp:849
AtomicOrdering getOrdering() const
Return the atomic ordering requirements for this memory operation.
static unsigned getHashValue(const SDValue &Val)
APInt operator*(APInt a, uint64_t RHS)
Definition: APInt.h:2090
This represents a list of ValueType&#39;s that has been intern&#39;d by a SelectionDAG.
bool isConstantSplatVector(const SDNode *N, APInt &SplatValue)
Node predicates.
This class is used to represent an MSTORE node.
AtomicOrdering
Atomic ordering for LLVM&#39;s memory model.
LoadSDNodeBitfields LoadSDNodeBits
bool isOne() const
This is just a convenience method to make client code smaller for a common case.
Definition: Constants.h:200
int64_t getSExtValue() const
bool operator==(const SDValue &V) const
Convenience function for get().operator==.
unsigned getSizeInBits() const
Return the size of the specified value type in bits.
Definition: ValueTypes.h:291
#define UINT64_MAX
Definition: DataTypes.h:83
static bool classof(const SDNode *N)
SDValue()=default
AtomicOrdering getOrdering() const
Return the atomic ordering requirements for this memory operation.
static bool classof(const SDNode *N)
void checkForCycles(const SelectionDAG *DAG, bool force=false)
bool writeMem() const
bool isOneOrOneSplat(SDValue V)
Return true if the value is a constant 1 integer or a splatted vector of a constant 1 integer (with n...
void clearMemRefs()
Clear out the memory reference descriptor list.
static SDNodeIterator begin(const SDNode *N)
bool isUNINDEXEDStore(const SDNode *N)
Returns true if the specified node is an unindexed store.
static bool classof(const SDNode *N)
static bool classof(const SDNode *N)
#define END_TWO_BYTE_PACK()
const SDValue & getScale() const
bool isNegative() const
Return true if the sign bit is set.
Definition: Constants.h:308
SDValue peekThroughBitcasts(SDValue V)
Return the non-bitcasted source operand of V if it exists.
Simple integer binary arithmetic operators.
Definition: ISDOpcodes.h:200
static SimpleType getSimplifiedValue(const SDValue &Val)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
static bool classof(const SDNode *N)
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:137
static bool classof(const SDNode *N)
bool isMinusOne() const
This function will return true iff every bit in this constant is set to true.
Definition: Constants.h:208
CondCode
ISD::CondCode enum - These are ordered carefully to make the bitfields below work out...
Definition: ISDOpcodes.h:968
op_iterator op_begin() const
TargetConstant* - Like Constant*, but the DAG does not do any folding, simplification, or lowering of the constant.
Definition: ISDOpcodes.h:124
MachineConstantPoolValue * MachineCPVal
ArrayRef< SDUse > ops() const
void setIROrder(unsigned Order)
Set the node ordering.
const SDValue & getMask() const
int64_t getSrcValueOffset() const
bool getHasDebugValue() const
mmo_iterator memoperands_end() const
unsigned getSrcAddressSpace() const
SDNodeBitfields SDNodeBits
const char * getSymbol() const
static bool classof(const SDNode *N)
bool use_empty() const
Return true if there are no nodes using value ResNo of Node.
UNDEF - An undefined node.
Definition: ISDOpcodes.h:177
This class is used to represent ISD::STORE nodes.
MaskedStoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, bool isTrunc, bool isCompressing, EVT MemVT, MachineMemOperand *MMO)
bool hasAllowReciprocal() const
BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a vector with the specified, possibly variable...
Definition: ISDOpcodes.h:326
bool isOneConstant(SDValue V)
Returns true if V is a constant integer one.
This corresponds to the llvm.lifetime.
Definition: ISDOpcodes.h:850
MVT getSimpleValueType() const
Return the simple ValueType of the referenced return value.
SDNode * operator->() const
bool isZero() const
Return true if the value is positive or negative zero.
bool hasAllowContract() const
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:305
unsigned getNumValues() const
Return the number of values defined/returned by this operator.
const SDValue & getBasePtr() const
static bool classof(const SDNode *N)
bool isNormalLoad(const SDNode *N)
Returns true if the specified node is a non-extending and unindexed load.
OUTCHAIN = INTRINSIC_VOID(INCHAIN, INTRINSICID, arg1, arg2, ...) This node represents a target intrin...
Definition: ISDOpcodes.h:165
const SDValue & operator*() const
bool isNaN() const
Return true if the value is a NaN.
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:148
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:290
use_iterator use_begin() const
Provide iteration support to walk over all uses of an SDNode.
Machine Value Type.
static bool classof(const SDNode *N)
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
Simple binary floating point operators.
Definition: ISDOpcodes.h:282
bool isMachineOpcode() const
CRTP base class for adapting an iterator to a different type.
Definition: iterator.h:205
unsigned getVectorNumElements() const
Given a vector type, return the number of elements it contains.
Definition: ValueTypes.h:272
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:148
This is an important base class in LLVM.
Definition: Constant.h:41
iterator_range< value_op_iterator > op_values() const
SDNode * getGluedUser() const
If this node has a glue value with a user, return the user (there is at most one).
static bool classof(const SDNode *N)
const SDValue & getOperand(unsigned Num) const
bool operator==(const SDValue &O) const
bool operator!=(const SDValue &V) const
Convenience function for get().operator!=.
LoadExtType
LoadExtType enum - This enum defines the three variants of LOADEXT (load with extension).
Definition: ISDOpcodes.h:943
This SDNode is used for LIFETIME_START/LIFETIME_END values, which indicate the offet and size that ar...
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static bool isOperandOf(const SUnit *SU, SDNode *N)
bool matchBinaryPredicate(SDValue LHS, SDValue RHS, std::function< bool(ConstantSDNode *, ConstantSDNode *)> Match, bool AllowUndefs=false)
Attempt to match a binary predicate against a pair of scalar/splat constants or every element of a pa...
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:263
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:370
unsigned char getTargetFlags() const
This is a base class used to represent MGATHER and MSCATTER nodes.
unsigned char getTargetFlags() const
const SDValue & getOffset() const
unsigned getDestAddressSpace() const
bool isTargetMemoryOpcode() const
bool isExactlyValue(double V) const
We don&#39;t rely on operator== working on double values, as it returns true for things that are clearly ...
Definition: APFloat.h:1129
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This class provides iterator support for SDUse operands that use a specific SDNode.
bool isExactlyValue(double V) const
We don&#39;t rely on operator== working on double values, as it returns true for things that are clearly ...
static bool classof(const SDNode *N)
unsigned getMachineOpcode() const
bool hasNoNaNs() const
void setNoInfs(bool b)
SDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs)
Create an SDNode.
const APInt & getAPIntValue() const
TargetIndex - Like a constant pool entry, but with completely target-dependent semantics.
Definition: ISDOpcodes.h:143
static bool classof(const SDNode *N)
SDNodeIterator & operator++()
SDNodeIterator operator++(int)
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
bool isDefined() const
Returns true if the flags are in a defined state.
SDNode * getGluedNode() const
If this node has a glue operand, return the node to which the glue operand points.
static bool classof(const SDNode *N)
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:381
unsigned getOriginalAlignment() const
Returns alignment and volatility of the memory access.
void setAllowContract(bool b)
const SDValue & getValue() const
static bool classof(const SDNode *N)
Val, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmp, swap) For double-word atomic operations: ValLo...
Definition: ISDOpcodes.h:800
unsigned char getTargetFlags() const
void addUse(SDUse &U)
This method should only be used by the SDUse class.
static bool classof(const SDNode *N)
const SDValue & getIndex() const
Extended Value Type.
Definition: ValueTypes.h:33
static bool classof(const SDNode *N)
const SDValue & getBasePtr() const
Abstract base class for all machine specific constantpool value subclasses.
static bool classof(const SDNode *N)
static wasm::ValType getType(const TargetRegisterClass *RC)
static bool classof(const SDNode *N)
bool isVolatile() const
This class contains a discriminated union of information about pointers in memory operands...
bool hasApproxFunc() const
Test if this operation allows approximations of math library functions or intrinsics.
Definition: Operator.h:358
bool isMachineOpcode() const
Test if this node has a post-isel opcode, directly corresponding to a MachineInstr opcode...
unsigned getNumOperands() const
Return the number of values used by this operation.
HANDLENODE node - Used as a handle for various purposes.
Definition: ISDOpcodes.h:754
uint64_t getAlignment() const
Return the minimum known alignment in bytes of the actual memory reference.
const SDValue & getMask() const
EH_LABEL - Represents a label in mid basic block used to track locations needed for debug and excepti...
Definition: ISDOpcodes.h:676
bool isUnindexed() const
Return true if this is NOT a pre/post inc/dec load/store.
void refineAlignment(const MachineMemOperand *MMO)
Update this MachineMemOperand to reflect the alignment of MMO, if it has a greater alignment...
bool isEXTLoad(const SDNode *N)
Returns true if the specified node is a EXTLOAD.
ConstantFPSDNode * isConstOrConstSplatFP(SDValue N, bool AllowUndefs=false)
Returns the SDNode if it is a constant splat BuildVector or constant float.
MachineMemOperand * MMO
Memory reference information.
static bool classof(const SDNode *N)
bool isUNINDEXEDLoad(const SDNode *N)
Returns true if the specified node is an unindexed load.
const APFloat & getValueAPF() const
Definition: Constants.h:302
bool hasAllowReassoc() const
Test if this operation may be simplified with reassociative transforms.
Definition: Operator.h:327
const APInt & getConstantOperandAPInt(unsigned i) const
bool use_empty() const
Return true if there are no uses of this node.
size_type size() const
Definition: SmallPtrSet.h:92
SDNode * getNode() const
Convenience function for get().getNode().
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
static bool isUndef(ArrayRef< int > Mask)
TokenFactor - This node takes multiple tokens as input and produces a single token result...
Definition: ISDOpcodes.h:49
bool isBuildVectorAllOnes(const SDNode *N)
Return true if the specified node is a BUILD_VECTOR where all of the elements are ~0 or undef...
ConstantSDNodeBitfields ConstantSDNodeBits
static bool classof(const SDNode *N)
bool memoperands_empty() const
bool hasNoSignedZeros() const
Test if this operation can ignore the sign of zero.
Definition: Operator.h:342
void setNoUnsignedWrap(bool b)
uint64_t getLimitedValue(uint64_t Limit=~0ULL) const
getLimitedValue - If the value is smaller than the specified limit, return it, otherwise return the l...
Definition: Constants.h:250
This is the shared class of boolean and integer constants.
Definition: Constants.h:83
void setNode(SDNode *N)
set the SDNode
bool isNullOrNullSplat(SDValue V, bool AllowUndefs=false)
Return true if the value is a constant 0 integer or a splatted vector of a constant 0 integer (with n...
use_iterator(const use_iterator &I)
TargetIndexSDNode(int Idx, EVT VT, int64_t Ofs, unsigned char TF)
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:221
const SDValue & getMask() const
void setDefined()
Sets the state of the flags to the defined state.
ADDRSPACECAST - This operator converts between pointers of different address spaces.
Definition: ISDOpcodes.h:574
value_iterator value_begin() const
static bool classof(const SDNode *N)
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:841
Utility class for floating point operations which can have information about relaxed accuracy require...
Definition: Operator.h:245
const DebugLoc & getDebugLoc() const
void dump() const
bool allOperandsUndef(const SDNode *N)
Return true if the node has at least one operand and all operands of the specified node are ISD::UNDE...
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
An SDNode that represents everything that will be needed to construct a MachineInstr.
const SDValue & getOffset() const
Promote Memory to Register
Definition: Mem2Reg.cpp:109
const SDValue & getPassThru() const
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:643
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:374
This is an abstract virtual class for memory operations.
const Constant * getConstVal() const
Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation funct...
bool isDivergent() const
static const int FIRST_TARGET_MEMORY_OPCODE
FIRST_TARGET_MEMORY_OPCODE - Target-specific pre-isel operations which do not reference a specific me...
Definition: ISDOpcodes.h:893
void setNoNaNs(bool b)
Represents one node in the SelectionDAG.
bool readMem() const
bool operator==(const SDNodeIterator &x) const
unsigned char getTargetFlags() const
static bool classof(const SDNode *N)
bool isDereferenceable() const
size_t use_size() const
Return the number of uses of this node.
A range adaptor for a pair of iterators.
EVT getMemoryVT() const
Return the type of the in-memory value.
Class for arbitrary precision integers.
Definition: APInt.h:69
bool isBuildVectorOfConstantFPSDNodes(const SDNode *N)
Return true if the specified node is a BUILD_VECTOR node of all ConstantFPSDNode or undef...
iterator_range< use_iterator > uses()
A "pseudo-class" with methods for operating on BUILD_VECTORs.
SDValue peekThroughOneUseBitcasts(SDValue V)
Return the non-bitcasted and one-use source operand of V if it exists.
static use_iterator use_end()
bool isNullFPConstant(SDValue V)
Returns true if V is an FP constant with a value of positive zero.
pointer operator->() const
This union template exposes a suitably aligned and sized character array member which can hold elemen...
Definition: AlignOf.h:137
unsigned getOperandNo() const
Retrieve the operand # of this use in its user.
iterator_range< use_iterator > uses() const
const SDValue & getBasePtr() const
const uint32_t * getRegMask() const
int getMaskElt(unsigned Idx) const
size_t operator-(SDNodeIterator Other) const
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:387
LSBaseSDNodeBitfields LSBaseSDNodeBits
bool hasVectorReduction() const
static bool classof(const SDNode *N)
static bool classof(const SDNode *N)
int getNodeId() const
Return the unique node id.
static bool classof(const SDNode *N)
bool hasNoSignedWrap() const
pointer operator*() const
void setTruncatingStore(bool Truncating)
static bool isConstantSplat(SDValue Op, APInt &SplatVal)
mmo_iterator memoperands_begin() const
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID for this memory operation.
These are IR-level optimization flags that may be propagated to SDNodes.
Represents a use of a SDNode.
void dumpr() const
SDNode * operator*() const
Retrieve a pointer to the current user node.
ConstantSDNode * isConstOrConstSplat(SDValue N, bool AllowUndefs=false)
Returns the SDNode if it is a constant splat BuildVector or constant int.
const MachinePointerInfo & getPointerInfo() const
static bool classof(const SDNode *N)
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:324
const SDValue & getValue() const
Bitwise operators - logical and, logical or, logical xor.
Definition: ISDOpcodes.h:386
bool operator!=(const use_iterator &x) const
Node - This class is used to maintain the singly linked bucket list in a folding set.
Definition: FoldingSet.h:135
bool operator!=(const SDValue &O) const
static DebugLoc getDebugLoc(MachineBasicBlock::instr_iterator FirstMI, MachineBasicBlock::instr_iterator LastMI)
Return the first found DebugLoc that has a DILocation, given a range of instructions.
This base class is used to represent MLOAD and MSTORE nodes.
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:55
bool isZero() const
Return true if the value is positive or negative zero.
Definition: Constants.h:305
static bool hasOneUse(unsigned Reg, MachineInstr *Def, MachineRegisterInfo &MRI, MachineDominatorTree &MDT, LiveIntervals &LIS)
static bool classof(const SDNode *N)
LOAD and STORE have token chains as their first operand, then the same operands as an LLVM load/store...
Definition: ISDOpcodes.h:615
bool isNaN() const
Return true if the value is a NaN.
Definition: Constants.h:314
static NodeRef getEntryNode(SDNode *N)
const NodeList & List
Definition: RDFGraph.cpp:201
static SimpleType getSimplifiedValue(SDValue &Val)
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
const ConstantInt * getConstantIntValue() const
const Value * getValue() const
Return the contained Value.
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
Definition: Constants.h:192
bool isInfinity() const
Return true if the value is infinity.
Definition: Constants.h:311
An SDNode that holds an arbitrary LLVM IR Value.
EVT getValueType() const
Convenience function for get().getValueType().
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:332
bool isBinaryOp(const SDNode *N)
Return true if the node is a math/logic binary operator.
uint32_t Size
Definition: Profile.cpp:46
const SDValue & getBasePtr() const
bool operator<(const SDValue &V) const
Convenience function for get().operator<.
bool isNON_EXTLoad(const SDNode *N)
Returns true if the specified node is a non-extending load.
unsigned getOpcode() const
SDValue getValue(unsigned R) const
bool isInfinity() const
Return true if the value is an infinity.
This class is used to represent an MSCATTER node.
static ChildIteratorType child_begin(NodeRef N)
SDLoc(const SDValue V)
const MachinePointerInfo & getPointerInfo() const
T get() const
Returns the value of the specified pointer type.
Definition: PointerUnion.h:134
MachineConstantPoolValue * getMachineCPVal() const
MaskedGatherScatterSDNode(ISD::NodeType NodeTy, unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemVT, MachineMemOperand *MMO)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This class is used to form a handle around another node that is persistent and is updated across invo...
unsigned getReg() const
std::iterator< std::forward_iterator_tag, SDUse, ptrdiff_t >::pointer pointer
bool isAllOnesConstant(SDValue V)
Returns true if V is an integer constant with all bits set.
This class is used to represent an MLOAD node.
MaskedScatterSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemVT, MachineMemOperand *MMO)
bool isPredecessorOf(const SDNode *N) const
Return true if this node is a predecessor of N.
unsigned getRawSubclassData() const
Return the SubclassData value, without HasDebugValue.
aarch64 promote const
ArrayRef< int > getMask() const
int64_t getOffset() const
For normal values, this is a byte offset added to the base address.
unsigned getOperand() const
LLVM Value Representation.
Definition: Value.h:72
uint64_t getConstantOperandVal(unsigned Num) const
Helper method returns the integer value of a ConstantSDNode operand.
unsigned getResNo() const
get the index which selects a specific result in the SDNode
static bool isEqual(const SDValue &LHS, const SDValue &RHS)
static SDNodeIterator end(const SDNode *N)
const MDNode * getRanges() const
Returns the Ranges that describes the dereference.
unsigned getMachineOpcode() const
This may only be called if isMachineOpcode returns true.
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID for this memory operation.
AtomicOrdering getFailureOrdering() const
For cmpxchg atomic operations, return the atomic ordering requirements when store does not occur...
MemSDNodeBitfields MemSDNodeBits
bool isTruncatingStore() const
Return true if the op does a truncation before store.
bool isNullConstant(SDValue V)
Returns true if V is a constant integer zero.
void setDebugLoc(DebugLoc dl)
Set source location info.
This class is used to represent an MGATHER node.
bool hasNoUnsignedWrap() const
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E&#39;s largest value.
Definition: BitmaskEnum.h:80
PREFETCH - This corresponds to a prefetch intrinsic.
Definition: ISDOpcodes.h:780
void setHasDebugValue(bool b)
bool isNonTemporal() const
LSBaseSDNode(ISD::NodeType NodeTy, unsigned Order, const DebugLoc &dl, SDVTList VTs, ISD::MemIndexedMode AM, EVT MemVT, MachineMemOperand *MMO)
bool isUndef() const
Return true if the type of the node type undefined.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
SDNodeFlags()
Default constructor turns off all optimization flags.
uint64_t getLimitedValue(uint64_t Limit=UINT64_MAX)
bool hasAllowReassociation() const
print Print MemDeps of function
SDLoc(const Instruction *I, int Order)
const APFloat & getValueAPF() const
static bool classof(const SDNode *N)
bool hasNoInfs() const
ISD::LoadExtType getExtensionType() const
static bool isSplat(ArrayRef< Value *> VL)
bool operator!=(const SDNodeIterator &x) const
static constexpr size_t getMaxNumOperands()
Return the maximum number of operands that a SDNode can hold.
bool operator==(uint64_t V1, const APInt &V2)
Definition: APInt.h:1966
unsigned getNumOperands() const
bool isStrictFPOpcode()
Test if this node is a strict floating point pseudo-op.
const SDValue & getOperand(unsigned i) const
int64_t getSExtValue() const
Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the ...
Definition: Constants.h:156
OUTCHAIN = ATOMIC_STORE(INCHAIN, ptr, val) This corresponds to "store atomic" instruction.
Definition: ISDOpcodes.h:793
SDNode * getUser()
This returns the SDNode that contains this Use.
MaskedLoadSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, ISD::LoadExtType ETy, bool IsExpanding, EVT MemVT, MachineMemOperand *MMO)
uint64_t getZExtValue() const
bool hasPredecessor(const SDNode *N) const
Return true if N is a predecessor of this node.
const APInt & getConstantOperandAPInt(unsigned Num) const
Helper method returns the APInt of a ConstantSDNode operand.
AtomicSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTL, EVT MemVT, MachineMemOperand *MMO)
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation...
int64_t getFrameIndex() const
MemIntrinsicSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemoryVT, MachineMemOperand *MMO)
Val, OUTCHAIN = ATOMIC_LOAD(INCHAIN, ptr) This corresponds to "load atomic" instruction.
Definition: ISDOpcodes.h:789
const SDValue & getBasePtr() const
const SDValue & getMask() const
unsigned getIROrder() const
MaskedGatherSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemVT, MachineMemOperand *MMO)
A discriminated union of two pointer types, with the discriminator in the low bit of the pointer...
Definition: PointerUnion.h:86
void refineAlignment(const MachineMemOperand *NewMMO)
Update this MemSDNode&#39;s MachineMemOperand information to reflect the alignment of NewMMO...
bool hasTrivialDestructor() const
Check whether this has a trivial destructor.
Definition: DebugLoc.h:69
MaskedLoadStoreSDNode(ISD::NodeType NodeTy, unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemVT, MachineMemOperand *MMO)
MemIndexedMode
MemIndexedMode enum - This enum defines the load / store indexed addressing modes.
Definition: ISDOpcodes.h:923
SRCVALUE - This is a node type that holds a Value* that is used to make reference to a value in the L...
Definition: ISDOpcodes.h:736
This class is used to represent ISD::LOAD nodes.