LLVM  10.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  // We assume instructions do not raise floating-point exceptions by default,
372  // and only those marked explicitly may do so. We could choose to represent
373  // this via a positive "FPExcept" flags like on the MI level, but having a
374  // negative "NoFPExcept" flag here (that defaults to true) makes the flag
375  // intersection logic more straightforward.
376  bool NoFPExcept : 1;
377 
378 public:
379  /// Default constructor turns off all optimization flags.
381  : AnyDefined(false), NoUnsignedWrap(false), NoSignedWrap(false),
382  Exact(false), NoNaNs(false), NoInfs(false),
383  NoSignedZeros(false), AllowReciprocal(false), VectorReduction(false),
384  AllowContract(false), ApproximateFuncs(false),
385  AllowReassociation(false), NoFPExcept(true) {}
386 
387  /// Propagate the fast-math-flags from an IR FPMathOperator.
388  void copyFMF(const FPMathOperator &FPMO) {
389  setNoNaNs(FPMO.hasNoNaNs());
390  setNoInfs(FPMO.hasNoInfs());
391  setNoSignedZeros(FPMO.hasNoSignedZeros());
392  setAllowReciprocal(FPMO.hasAllowReciprocal());
393  setAllowContract(FPMO.hasAllowContract());
394  setApproximateFuncs(FPMO.hasApproxFunc());
395  setAllowReassociation(FPMO.hasAllowReassoc());
396  }
397 
398  /// Sets the state of the flags to the defined state.
399  void setDefined() { AnyDefined = true; }
400  /// Returns true if the flags are in a defined state.
401  bool isDefined() const { return AnyDefined; }
402 
403  // These are mutators for each flag.
404  void setNoUnsignedWrap(bool b) {
405  setDefined();
406  NoUnsignedWrap = b;
407  }
408  void setNoSignedWrap(bool b) {
409  setDefined();
410  NoSignedWrap = b;
411  }
412  void setExact(bool b) {
413  setDefined();
414  Exact = b;
415  }
416  void setNoNaNs(bool b) {
417  setDefined();
418  NoNaNs = b;
419  }
420  void setNoInfs(bool b) {
421  setDefined();
422  NoInfs = b;
423  }
424  void setNoSignedZeros(bool b) {
425  setDefined();
426  NoSignedZeros = b;
427  }
428  void setAllowReciprocal(bool b) {
429  setDefined();
430  AllowReciprocal = b;
431  }
432  void setVectorReduction(bool b) {
433  setDefined();
434  VectorReduction = b;
435  }
436  void setAllowContract(bool b) {
437  setDefined();
438  AllowContract = b;
439  }
440  void setApproximateFuncs(bool b) {
441  setDefined();
442  ApproximateFuncs = b;
443  }
444  void setAllowReassociation(bool b) {
445  setDefined();
446  AllowReassociation = b;
447  }
448  void setFPExcept(bool b) {
449  setDefined();
450  NoFPExcept = !b;
451  }
452 
453  // These are accessors for each flag.
454  bool hasNoUnsignedWrap() const { return NoUnsignedWrap; }
455  bool hasNoSignedWrap() const { return NoSignedWrap; }
456  bool hasExact() const { return Exact; }
457  bool hasNoNaNs() const { return NoNaNs; }
458  bool hasNoInfs() const { return NoInfs; }
459  bool hasNoSignedZeros() const { return NoSignedZeros; }
460  bool hasAllowReciprocal() const { return AllowReciprocal; }
461  bool hasVectorReduction() const { return VectorReduction; }
462  bool hasAllowContract() const { return AllowContract; }
463  bool hasApproximateFuncs() const { return ApproximateFuncs; }
464  bool hasAllowReassociation() const { return AllowReassociation; }
465  bool hasFPExcept() const { return !NoFPExcept; }
466 
467  bool isFast() const {
468  return NoSignedZeros && AllowReciprocal && NoNaNs && NoInfs && NoFPExcept &&
469  AllowContract && ApproximateFuncs && AllowReassociation;
470  }
471 
472  /// Clear any flags in this flag set that aren't also set in Flags.
473  /// If the given Flags are undefined then don't do anything.
474  void intersectWith(const SDNodeFlags Flags) {
475  if (!Flags.isDefined())
476  return;
477  NoUnsignedWrap &= Flags.NoUnsignedWrap;
478  NoSignedWrap &= Flags.NoSignedWrap;
479  Exact &= Flags.Exact;
480  NoNaNs &= Flags.NoNaNs;
481  NoInfs &= Flags.NoInfs;
482  NoSignedZeros &= Flags.NoSignedZeros;
483  AllowReciprocal &= Flags.AllowReciprocal;
484  VectorReduction &= Flags.VectorReduction;
485  AllowContract &= Flags.AllowContract;
486  ApproximateFuncs &= Flags.ApproximateFuncs;
487  AllowReassociation &= Flags.AllowReassociation;
488  NoFPExcept &= Flags.NoFPExcept;
489  }
490 };
491 
492 /// Represents one node in the SelectionDAG.
493 ///
494 class SDNode : public FoldingSetNode, public ilist_node<SDNode> {
495 private:
496  /// The operation that this node performs.
497  int16_t NodeType;
498 
499 protected:
500  // We define a set of mini-helper classes to help us interpret the bits in our
501  // SubclassData. These are designed to fit within a uint16_t so they pack
502  // with NodeType.
503 
504 #if defined(_AIX) && (!defined(__GNUC__) || defined(__ibmxl__))
505 // Except for GCC; by default, AIX compilers store bit-fields in 4-byte words
506 // and give the `pack` pragma push semantics.
507 #define BEGIN_TWO_BYTE_PACK() _Pragma("pack(2)")
508 #define END_TWO_BYTE_PACK() _Pragma("pack(pop)")
509 #else
510 #define BEGIN_TWO_BYTE_PACK()
511 #define END_TWO_BYTE_PACK()
512 #endif
513 
516  friend class SDNode;
517  friend class MemIntrinsicSDNode;
518  friend class MemSDNode;
519  friend class SelectionDAG;
520 
521  uint16_t HasDebugValue : 1;
522  uint16_t IsMemIntrinsic : 1;
523  uint16_t IsDivergent : 1;
524  };
525  enum { NumSDNodeBits = 3 };
526 
528  friend class ConstantSDNode;
529 
530  uint16_t : NumSDNodeBits;
531 
532  uint16_t IsOpaque : 1;
533  };
534 
536  friend class MemSDNode;
537  friend class MemIntrinsicSDNode;
538  friend class AtomicSDNode;
539 
540  uint16_t : NumSDNodeBits;
541 
542  uint16_t IsVolatile : 1;
543  uint16_t IsNonTemporal : 1;
544  uint16_t IsDereferenceable : 1;
545  uint16_t IsInvariant : 1;
546  };
547  enum { NumMemSDNodeBits = NumSDNodeBits + 4 };
548 
550  friend class LSBaseSDNode;
552 
553  uint16_t : NumMemSDNodeBits;
554 
555  // This storage is shared between disparate class hierarchies to hold an
556  // enumeration specific to the class hierarchy in use.
557  // LSBaseSDNode => enum ISD::MemIndexedMode
558  // MaskedGatherScatterSDNode => enum ISD::MemIndexType
559  uint16_t AddressingMode : 3;
560  };
561  enum { NumLSBaseSDNodeBits = NumMemSDNodeBits + 3 };
562 
564  friend class LoadSDNode;
565  friend class MaskedLoadSDNode;
566 
567  uint16_t : NumLSBaseSDNodeBits;
568 
569  uint16_t ExtTy : 2; // enum ISD::LoadExtType
570  uint16_t IsExpanding : 1;
571  };
572 
574  friend class StoreSDNode;
575  friend class MaskedStoreSDNode;
576 
577  uint16_t : NumLSBaseSDNodeBits;
578 
579  uint16_t IsTruncating : 1;
580  uint16_t IsCompressing : 1;
581  };
582 
583  union {
584  char RawSDNodeBits[sizeof(uint16_t)];
591  };
593 #undef BEGIN_TWO_BYTE_PACK
594 #undef END_TWO_BYTE_PACK
595 
596  // RawSDNodeBits must cover the entirety of the union. This means that all of
597  // the union's members must have size <= RawSDNodeBits. We write the RHS as
598  // "2" instead of sizeof(RawSDNodeBits) because MSVC can't handle the latter.
599  static_assert(sizeof(SDNodeBitfields) <= 2, "field too wide");
600  static_assert(sizeof(ConstantSDNodeBitfields) <= 2, "field too wide");
601  static_assert(sizeof(MemSDNodeBitfields) <= 2, "field too wide");
602  static_assert(sizeof(LSBaseSDNodeBitfields) <= 2, "field too wide");
603  static_assert(sizeof(LoadSDNodeBitfields) <= 2, "field too wide");
604  static_assert(sizeof(StoreSDNodeBitfields) <= 2, "field too wide");
605 
606 private:
607  friend class SelectionDAG;
608  // TODO: unfriend HandleSDNode once we fix its operand handling.
609  friend class HandleSDNode;
610 
611  /// Unique id per SDNode in the DAG.
612  int NodeId = -1;
613 
614  /// The values that are used by this operation.
615  SDUse *OperandList = nullptr;
616 
617  /// The types of the values this node defines. SDNode's may
618  /// define multiple values simultaneously.
619  const EVT *ValueList;
620 
621  /// List of uses for this SDNode.
622  SDUse *UseList = nullptr;
623 
624  /// The number of entries in the Operand/Value list.
625  unsigned short NumOperands = 0;
626  unsigned short NumValues;
627 
628  // The ordering of the SDNodes. It roughly corresponds to the ordering of the
629  // original LLVM instructions.
630  // This is used for turning off scheduling, because we'll forgo
631  // the normal scheduling algorithms and output the instructions according to
632  // this ordering.
633  unsigned IROrder;
634 
635  /// Source line information.
636  DebugLoc debugLoc;
637 
638  /// Return a pointer to the specified value type.
639  static const EVT *getValueTypeList(EVT VT);
640 
641  SDNodeFlags Flags;
642 
643 public:
644  /// Unique and persistent id per SDNode in the DAG.
645  /// Used for debug printing.
646  uint16_t PersistentId;
647 
648  //===--------------------------------------------------------------------===//
649  // Accessors
650  //
651 
652  /// Return the SelectionDAG opcode value for this node. For
653  /// pre-isel nodes (those for which isMachineOpcode returns false), these
654  /// are the opcode values in the ISD and <target>ISD namespaces. For
655  /// post-isel opcodes, see getMachineOpcode.
656  unsigned getOpcode() const { return (unsigned short)NodeType; }
657 
658  /// Test if this node has a target-specific opcode (in the
659  /// <target>ISD namespace).
660  bool isTargetOpcode() const { return NodeType >= ISD::BUILTIN_OP_END; }
661 
662  /// Test if this node has a target-specific
663  /// memory-referencing opcode (in the <target>ISD namespace and
664  /// greater than FIRST_TARGET_MEMORY_OPCODE).
665  bool isTargetMemoryOpcode() const {
666  return NodeType >= ISD::FIRST_TARGET_MEMORY_OPCODE;
667  }
668 
669  /// Return true if the type of the node type undefined.
670  bool isUndef() const { return NodeType == ISD::UNDEF; }
671 
672  /// Test if this node is a memory intrinsic (with valid pointer information).
673  /// INTRINSIC_W_CHAIN and INTRINSIC_VOID nodes are sometimes created for
674  /// non-memory intrinsics (with chains) that are not really instances of
675  /// MemSDNode. For such nodes, we need some extra state to determine the
676  /// proper classof relationship.
677  bool isMemIntrinsic() const {
678  return (NodeType == ISD::INTRINSIC_W_CHAIN ||
679  NodeType == ISD::INTRINSIC_VOID) &&
680  SDNodeBits.IsMemIntrinsic;
681  }
682 
683  /// Test if this node is a strict floating point pseudo-op.
685  switch (NodeType) {
686  default:
687  return false;
688  case ISD::STRICT_FADD:
689  case ISD::STRICT_FSUB:
690  case ISD::STRICT_FMUL:
691  case ISD::STRICT_FDIV:
692  case ISD::STRICT_FREM:
693  case ISD::STRICT_FMA:
694  case ISD::STRICT_FSQRT:
695  case ISD::STRICT_FPOW:
696  case ISD::STRICT_FPOWI:
697  case ISD::STRICT_FSIN:
698  case ISD::STRICT_FCOS:
699  case ISD::STRICT_FEXP:
700  case ISD::STRICT_FEXP2:
701  case ISD::STRICT_FLOG:
702  case ISD::STRICT_FLOG10:
703  case ISD::STRICT_FLOG2:
704  case ISD::STRICT_LRINT:
705  case ISD::STRICT_LLRINT:
706  case ISD::STRICT_FRINT:
708  case ISD::STRICT_FMAXNUM:
709  case ISD::STRICT_FMINNUM:
710  case ISD::STRICT_FCEIL:
711  case ISD::STRICT_FFLOOR:
712  case ISD::STRICT_LROUND:
713  case ISD::STRICT_LLROUND:
714  case ISD::STRICT_FROUND:
715  case ISD::STRICT_FTRUNC:
720  return true;
721  }
722  }
723 
724  /// Test if this node has a post-isel opcode, directly
725  /// corresponding to a MachineInstr opcode.
726  bool isMachineOpcode() const { return NodeType < 0; }
727 
728  /// This may only be called if isMachineOpcode returns
729  /// true. It returns the MachineInstr opcode value that the node's opcode
730  /// corresponds to.
731  unsigned getMachineOpcode() const {
732  assert(isMachineOpcode() && "Not a MachineInstr opcode!");
733  return ~NodeType;
734  }
735 
736  bool getHasDebugValue() const { return SDNodeBits.HasDebugValue; }
737  void setHasDebugValue(bool b) { SDNodeBits.HasDebugValue = b; }
738 
739  bool isDivergent() const { return SDNodeBits.IsDivergent; }
740 
741  /// Return true if there are no uses of this node.
742  bool use_empty() const { return UseList == nullptr; }
743 
744  /// Return true if there is exactly one use of this node.
745  bool hasOneUse() const {
746  return !use_empty() && std::next(use_begin()) == use_end();
747  }
748 
749  /// Return the number of uses of this node. This method takes
750  /// time proportional to the number of uses.
751  size_t use_size() const { return std::distance(use_begin(), use_end()); }
752 
753  /// Return the unique node id.
754  int getNodeId() const { return NodeId; }
755 
756  /// Set unique node id.
757  void setNodeId(int Id) { NodeId = Id; }
758 
759  /// Return the node ordering.
760  unsigned getIROrder() const { return IROrder; }
761 
762  /// Set the node ordering.
763  void setIROrder(unsigned Order) { IROrder = Order; }
764 
765  /// Return the source location info.
766  const DebugLoc &getDebugLoc() const { return debugLoc; }
767 
768  /// Set source location info. Try to avoid this, putting
769  /// it in the constructor is preferable.
770  void setDebugLoc(DebugLoc dl) { debugLoc = std::move(dl); }
771 
772  /// This class provides iterator support for SDUse
773  /// operands that use a specific SDNode.
775  : public std::iterator<std::forward_iterator_tag, SDUse, ptrdiff_t> {
776  friend class SDNode;
777 
778  SDUse *Op = nullptr;
779 
780  explicit use_iterator(SDUse *op) : Op(op) {}
781 
782  public:
783  using reference = std::iterator<std::forward_iterator_tag,
785  using pointer = std::iterator<std::forward_iterator_tag,
787 
788  use_iterator() = default;
789  use_iterator(const use_iterator &I) : Op(I.Op) {}
790 
791  bool operator==(const use_iterator &x) const {
792  return Op == x.Op;
793  }
794  bool operator!=(const use_iterator &x) const {
795  return !operator==(x);
796  }
797 
798  /// Return true if this iterator is at the end of uses list.
799  bool atEnd() const { return Op == nullptr; }
800 
801  // Iterator traversal: forward iteration only.
802  use_iterator &operator++() { // Preincrement
803  assert(Op && "Cannot increment end iterator!");
804  Op = Op->getNext();
805  return *this;
806  }
807 
808  use_iterator operator++(int) { // Postincrement
809  use_iterator tmp = *this; ++*this; return tmp;
810  }
811 
812  /// Retrieve a pointer to the current user node.
813  SDNode *operator*() const {
814  assert(Op && "Cannot dereference end iterator!");
815  return Op->getUser();
816  }
817 
818  SDNode *operator->() const { return operator*(); }
819 
820  SDUse &getUse() const { return *Op; }
821 
822  /// Retrieve the operand # of this use in its user.
823  unsigned getOperandNo() const {
824  assert(Op && "Cannot dereference end iterator!");
825  return (unsigned)(Op - Op->getUser()->OperandList);
826  }
827  };
828 
829  /// Provide iteration support to walk over all uses of an SDNode.
831  return use_iterator(UseList);
832  }
833 
834  static use_iterator use_end() { return use_iterator(nullptr); }
835 
837  return make_range(use_begin(), use_end());
838  }
840  return make_range(use_begin(), use_end());
841  }
842 
843  /// Return true if there are exactly NUSES uses of the indicated value.
844  /// This method ignores uses of other values defined by this operation.
845  bool hasNUsesOfValue(unsigned NUses, unsigned Value) const;
846 
847  /// Return true if there are any use of the indicated value.
848  /// This method ignores uses of other values defined by this operation.
849  bool hasAnyUseOfValue(unsigned Value) const;
850 
851  /// Return true if this node is the only use of N.
852  bool isOnlyUserOf(const SDNode *N) const;
853 
854  /// Return true if this node is an operand of N.
855  bool isOperandOf(const SDNode *N) const;
856 
857  /// Return true if this node is a predecessor of N.
858  /// NOTE: Implemented on top of hasPredecessor and every bit as
859  /// expensive. Use carefully.
860  bool isPredecessorOf(const SDNode *N) const {
861  return N->hasPredecessor(this);
862  }
863 
864  /// Return true if N is a predecessor of this node.
865  /// N is either an operand of this node, or can be reached by recursively
866  /// traversing up the operands.
867  /// NOTE: This is an expensive method. Use it carefully.
868  bool hasPredecessor(const SDNode *N) const;
869 
870  /// Returns true if N is a predecessor of any node in Worklist. This
871  /// helper keeps Visited and Worklist sets externally to allow unions
872  /// searches to be performed in parallel, caching of results across
873  /// queries and incremental addition to Worklist. Stops early if N is
874  /// found but will resume. Remember to clear Visited and Worklists
875  /// if DAG changes. MaxSteps gives a maximum number of nodes to visit before
876  /// giving up. The TopologicalPrune flag signals that positive NodeIds are
877  /// topologically ordered (Operands have strictly smaller node id) and search
878  /// can be pruned leveraging this.
879  static bool hasPredecessorHelper(const SDNode *N,
882  unsigned int MaxSteps = 0,
883  bool TopologicalPrune = false) {
884  SmallVector<const SDNode *, 8> DeferredNodes;
885  if (Visited.count(N))
886  return true;
887 
888  // Node Id's are assigned in three places: As a topological
889  // ordering (> 0), during legalization (results in values set to
890  // 0), new nodes (set to -1). If N has a topolgical id then we
891  // know that all nodes with ids smaller than it cannot be
892  // successors and we need not check them. Filter out all node
893  // that can't be matches. We add them to the worklist before exit
894  // in case of multiple calls. Note that during selection the topological id
895  // may be violated if a node's predecessor is selected before it. We mark
896  // this at selection negating the id of unselected successors and
897  // restricting topological pruning to positive ids.
898 
899  int NId = N->getNodeId();
900  // If we Invalidated the Id, reconstruct original NId.
901  if (NId < -1)
902  NId = -(NId + 1);
903 
904  bool Found = false;
905  while (!Worklist.empty()) {
906  const SDNode *M = Worklist.pop_back_val();
907  int MId = M->getNodeId();
908  if (TopologicalPrune && M->getOpcode() != ISD::TokenFactor && (NId > 0) &&
909  (MId > 0) && (MId < NId)) {
910  DeferredNodes.push_back(M);
911  continue;
912  }
913  for (const SDValue &OpV : M->op_values()) {
914  SDNode *Op = OpV.getNode();
915  if (Visited.insert(Op).second)
916  Worklist.push_back(Op);
917  if (Op == N)
918  Found = true;
919  }
920  if (Found)
921  break;
922  if (MaxSteps != 0 && Visited.size() >= MaxSteps)
923  break;
924  }
925  // Push deferred nodes back on worklist.
926  Worklist.append(DeferredNodes.begin(), DeferredNodes.end());
927  // If we bailed early, conservatively return found.
928  if (MaxSteps != 0 && Visited.size() >= MaxSteps)
929  return true;
930  return Found;
931  }
932 
933  /// Return true if all the users of N are contained in Nodes.
934  /// NOTE: Requires at least one match, but doesn't require them all.
935  static bool areOnlyUsersOf(ArrayRef<const SDNode *> Nodes, const SDNode *N);
936 
937  /// Return the number of values used by this operation.
938  unsigned getNumOperands() const { return NumOperands; }
939 
940  /// Return the maximum number of operands that a SDNode can hold.
941  static constexpr size_t getMaxNumOperands() {
943  }
944 
945  /// Helper method returns the integer value of a ConstantSDNode operand.
946  inline uint64_t getConstantOperandVal(unsigned Num) const;
947 
948  /// Helper method returns the APInt of a ConstantSDNode operand.
949  inline const APInt &getConstantOperandAPInt(unsigned Num) const;
950 
951  const SDValue &getOperand(unsigned Num) const {
952  assert(Num < NumOperands && "Invalid child # of SDNode!");
953  return OperandList[Num];
954  }
955 
956  using op_iterator = SDUse *;
957 
958  op_iterator op_begin() const { return OperandList; }
959  op_iterator op_end() const { return OperandList+NumOperands; }
960  ArrayRef<SDUse> ops() const { return makeArrayRef(op_begin(), op_end()); }
961 
962  /// Iterator for directly iterating over the operand SDValue's.
964  : iterator_adaptor_base<value_op_iterator, op_iterator,
965  std::random_access_iterator_tag, SDValue,
966  ptrdiff_t, value_op_iterator *,
967  value_op_iterator *> {
968  explicit value_op_iterator(SDUse *U = nullptr)
969  : iterator_adaptor_base(U) {}
970 
971  const SDValue &operator*() const { return I->get(); }
972  };
973 
975  return make_range(value_op_iterator(op_begin()),
976  value_op_iterator(op_end()));
977  }
978 
979  SDVTList getVTList() const {
980  SDVTList X = { ValueList, NumValues };
981  return X;
982  }
983 
984  /// If this node has a glue operand, return the node
985  /// to which the glue operand points. Otherwise return NULL.
986  SDNode *getGluedNode() const {
987  if (getNumOperands() != 0 &&
988  getOperand(getNumOperands()-1).getValueType() == MVT::Glue)
989  return getOperand(getNumOperands()-1).getNode();
990  return nullptr;
991  }
992 
993  /// If this node has a glue value with a user, return
994  /// the user (there is at most one). Otherwise return NULL.
995  SDNode *getGluedUser() const {
996  for (use_iterator UI = use_begin(), UE = use_end(); UI != UE; ++UI)
997  if (UI.getUse().get().getValueType() == MVT::Glue)
998  return *UI;
999  return nullptr;
1000  }
1001 
1002  const SDNodeFlags getFlags() const { return Flags; }
1003  void setFlags(SDNodeFlags NewFlags) { Flags = NewFlags; }
1004  bool isFast() { return Flags.isFast(); }
1005 
1006  /// Clear any flags in this node that aren't also set in Flags.
1007  /// If Flags is not in a defined state then this has no effect.
1008  void intersectFlagsWith(const SDNodeFlags Flags);
1009 
1010  /// Return the number of values defined/returned by this operator.
1011  unsigned getNumValues() const { return NumValues; }
1012 
1013  /// Return the type of a specified result.
1014  EVT getValueType(unsigned ResNo) const {
1015  assert(ResNo < NumValues && "Illegal result number!");
1016  return ValueList[ResNo];
1017  }
1018 
1019  /// Return the type of a specified result as a simple type.
1020  MVT getSimpleValueType(unsigned ResNo) const {
1021  return getValueType(ResNo).getSimpleVT();
1022  }
1023 
1024  /// Returns MVT::getSizeInBits(getValueType(ResNo)).
1025  unsigned getValueSizeInBits(unsigned ResNo) const {
1026  return getValueType(ResNo).getSizeInBits();
1027  }
1028 
1029  using value_iterator = const EVT *;
1030 
1031  value_iterator value_begin() const { return ValueList; }
1032  value_iterator value_end() const { return ValueList+NumValues; }
1033 
1034  /// Return the opcode of this operation for printing.
1035  std::string getOperationName(const SelectionDAG *G = nullptr) const;
1036  static const char* getIndexedModeName(ISD::MemIndexedMode AM);
1037  void print_types(raw_ostream &OS, const SelectionDAG *G) const;
1038  void print_details(raw_ostream &OS, const SelectionDAG *G) const;
1039  void print(raw_ostream &OS, const SelectionDAG *G = nullptr) const;
1040  void printr(raw_ostream &OS, const SelectionDAG *G = nullptr) const;
1041 
1042  /// Print a SelectionDAG node and all children down to
1043  /// the leaves. The given SelectionDAG allows target-specific nodes
1044  /// to be printed in human-readable form. Unlike printr, this will
1045  /// print the whole DAG, including children that appear multiple
1046  /// times.
1047  ///
1048  void printrFull(raw_ostream &O, const SelectionDAG *G = nullptr) const;
1049 
1050  /// Print a SelectionDAG node and children up to
1051  /// depth "depth." The given SelectionDAG allows target-specific
1052  /// nodes to be printed in human-readable form. Unlike printr, this
1053  /// will print children that appear multiple times wherever they are
1054  /// used.
1055  ///
1056  void printrWithDepth(raw_ostream &O, const SelectionDAG *G = nullptr,
1057  unsigned depth = 100) const;
1058 
1059  /// Dump this node, for debugging.
1060  void dump() const;
1061 
1062  /// Dump (recursively) this node and its use-def subgraph.
1063  void dumpr() const;
1064 
1065  /// Dump this node, for debugging.
1066  /// The given SelectionDAG allows target-specific nodes to be printed
1067  /// in human-readable form.
1068  void dump(const SelectionDAG *G) const;
1069 
1070  /// Dump (recursively) this node and its use-def subgraph.
1071  /// The given SelectionDAG allows target-specific nodes to be printed
1072  /// in human-readable form.
1073  void dumpr(const SelectionDAG *G) const;
1074 
1075  /// printrFull to dbgs(). The given SelectionDAG allows
1076  /// target-specific nodes to be printed in human-readable form.
1077  /// Unlike dumpr, this will print the whole DAG, including children
1078  /// that appear multiple times.
1079  void dumprFull(const SelectionDAG *G = nullptr) const;
1080 
1081  /// printrWithDepth to dbgs(). The given
1082  /// SelectionDAG allows target-specific nodes to be printed in
1083  /// human-readable form. Unlike dumpr, this will print children
1084  /// that appear multiple times wherever they are used.
1085  ///
1086  void dumprWithDepth(const SelectionDAG *G = nullptr,
1087  unsigned depth = 100) const;
1088 
1089  /// Gather unique data for the node.
1090  void Profile(FoldingSetNodeID &ID) const;
1091 
1092  /// This method should only be used by the SDUse class.
1093  void addUse(SDUse &U) { U.addToList(&UseList); }
1094 
1095 protected:
1096  static SDVTList getSDVTList(EVT VT) {
1097  SDVTList Ret = { getValueTypeList(VT), 1 };
1098  return Ret;
1099  }
1100 
1101  /// Create an SDNode.
1102  ///
1103  /// SDNodes are created without any operands, and never own the operand
1104  /// storage. To add operands, see SelectionDAG::createOperands.
1105  SDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs)
1106  : NodeType(Opc), ValueList(VTs.VTs), NumValues(VTs.NumVTs),
1107  IROrder(Order), debugLoc(std::move(dl)) {
1108  memset(&RawSDNodeBits, 0, sizeof(RawSDNodeBits));
1109  assert(debugLoc.hasTrivialDestructor() && "Expected trivial destructor");
1110  assert(NumValues == VTs.NumVTs &&
1111  "NumValues wasn't wide enough for its operands!");
1112  }
1113 
1114  /// Release the operands and set this node to have zero operands.
1115  void DropOperands();
1116 };
1117 
1118 /// Wrapper class for IR location info (IR ordering and DebugLoc) to be passed
1119 /// into SDNode creation functions.
1120 /// When an SDNode is created from the DAGBuilder, the DebugLoc is extracted
1121 /// from the original Instruction, and IROrder is the ordinal position of
1122 /// the instruction.
1123 /// When an SDNode is created after the DAG is being built, both DebugLoc and
1124 /// the IROrder are propagated from the original SDNode.
1125 /// So SDLoc class provides two constructors besides the default one, one to
1126 /// be used by the DAGBuilder, the other to be used by others.
1127 class SDLoc {
1128 private:
1129  DebugLoc DL;
1130  int IROrder = 0;
1131 
1132 public:
1133  SDLoc() = default;
1134  SDLoc(const SDNode *N) : DL(N->getDebugLoc()), IROrder(N->getIROrder()) {}
1135  SDLoc(const SDValue V) : SDLoc(V.getNode()) {}
1136  SDLoc(const Instruction *I, int Order) : IROrder(Order) {
1137  assert(Order >= 0 && "bad IROrder");
1138  if (I)
1139  DL = I->getDebugLoc();
1140  }
1141 
1142  unsigned getIROrder() const { return IROrder; }
1143  const DebugLoc &getDebugLoc() const { return DL; }
1144 };
1145 
1146 // Define inline functions from the SDValue class.
1147 
1148 inline SDValue::SDValue(SDNode *node, unsigned resno)
1149  : Node(node), ResNo(resno) {
1150  // Explicitly check for !ResNo to avoid use-after-free, because there are
1151  // callers that use SDValue(N, 0) with a deleted N to indicate successful
1152  // combines.
1153  assert((!Node || !ResNo || ResNo < Node->getNumValues()) &&
1154  "Invalid result number for the given node!");
1155  assert(ResNo < -2U && "Cannot use result numbers reserved for DenseMaps.");
1156 }
1157 
1158 inline unsigned SDValue::getOpcode() const {
1159  return Node->getOpcode();
1160 }
1161 
1162 inline EVT SDValue::getValueType() const {
1163  return Node->getValueType(ResNo);
1164 }
1165 
1166 inline unsigned SDValue::getNumOperands() const {
1167  return Node->getNumOperands();
1168 }
1169 
1170 inline const SDValue &SDValue::getOperand(unsigned i) const {
1171  return Node->getOperand(i);
1172 }
1173 
1174 inline uint64_t SDValue::getConstantOperandVal(unsigned i) const {
1175  return Node->getConstantOperandVal(i);
1176 }
1177 
1178 inline const APInt &SDValue::getConstantOperandAPInt(unsigned i) const {
1179  return Node->getConstantOperandAPInt(i);
1180 }
1181 
1182 inline bool SDValue::isTargetOpcode() const {
1183  return Node->isTargetOpcode();
1184 }
1185 
1186 inline bool SDValue::isTargetMemoryOpcode() const {
1187  return Node->isTargetMemoryOpcode();
1188 }
1189 
1190 inline bool SDValue::isMachineOpcode() const {
1191  return Node->isMachineOpcode();
1192 }
1193 
1194 inline unsigned SDValue::getMachineOpcode() const {
1195  return Node->getMachineOpcode();
1196 }
1197 
1198 inline bool SDValue::isUndef() const {
1199  return Node->isUndef();
1200 }
1201 
1202 inline bool SDValue::use_empty() const {
1203  return !Node->hasAnyUseOfValue(ResNo);
1204 }
1205 
1206 inline bool SDValue::hasOneUse() const {
1207  return Node->hasNUsesOfValue(1, ResNo);
1208 }
1209 
1210 inline const DebugLoc &SDValue::getDebugLoc() const {
1211  return Node->getDebugLoc();
1212 }
1213 
1214 inline void SDValue::dump() const {
1215  return Node->dump();
1216 }
1217 
1218 inline void SDValue::dump(const SelectionDAG *G) const {
1219  return Node->dump(G);
1220 }
1221 
1222 inline void SDValue::dumpr() const {
1223  return Node->dumpr();
1224 }
1225 
1226 inline void SDValue::dumpr(const SelectionDAG *G) const {
1227  return Node->dumpr(G);
1228 }
1229 
1230 // Define inline functions from the SDUse class.
1231 
1232 inline void SDUse::set(const SDValue &V) {
1233  if (Val.getNode()) removeFromList();
1234  Val = V;
1235  if (V.getNode()) V.getNode()->addUse(*this);
1236 }
1237 
1238 inline void SDUse::setInitial(const SDValue &V) {
1239  Val = V;
1240  V.getNode()->addUse(*this);
1241 }
1242 
1243 inline void SDUse::setNode(SDNode *N) {
1244  if (Val.getNode()) removeFromList();
1245  Val.setNode(N);
1246  if (N) N->addUse(*this);
1247 }
1248 
1249 /// This class is used to form a handle around another node that
1250 /// is persistent and is updated across invocations of replaceAllUsesWith on its
1251 /// operand. This node should be directly created by end-users and not added to
1252 /// the AllNodes list.
1253 class HandleSDNode : public SDNode {
1254  SDUse Op;
1255 
1256 public:
1258  : SDNode(ISD::HANDLENODE, 0, DebugLoc(), getSDVTList(MVT::Other)) {
1259  // HandleSDNodes are never inserted into the DAG, so they won't be
1260  // auto-numbered. Use ID 65535 as a sentinel.
1261  PersistentId = 0xffff;
1262 
1263  // Manually set up the operand list. This node type is special in that it's
1264  // always stack allocated and SelectionDAG does not manage its operands.
1265  // TODO: This should either (a) not be in the SDNode hierarchy, or (b) not
1266  // be so special.
1267  Op.setUser(this);
1268  Op.setInitial(X);
1269  NumOperands = 1;
1270  OperandList = &Op;
1271  }
1272  ~HandleSDNode();
1273 
1274  const SDValue &getValue() const { return Op; }
1275 };
1276 
1277 class AddrSpaceCastSDNode : public SDNode {
1278 private:
1279  unsigned SrcAddrSpace;
1280  unsigned DestAddrSpace;
1281 
1282 public:
1283  AddrSpaceCastSDNode(unsigned Order, const DebugLoc &dl, EVT VT,
1284  unsigned SrcAS, unsigned DestAS);
1285 
1286  unsigned getSrcAddressSpace() const { return SrcAddrSpace; }
1287  unsigned getDestAddressSpace() const { return DestAddrSpace; }
1288 
1289  static bool classof(const SDNode *N) {
1290  return N->getOpcode() == ISD::ADDRSPACECAST;
1291  }
1292 };
1293 
1294 /// This is an abstract virtual class for memory operations.
1295 class MemSDNode : public SDNode {
1296 private:
1297  // VT of in-memory value.
1298  EVT MemoryVT;
1299 
1300 protected:
1301  /// Memory reference information.
1303 
1304 public:
1305  MemSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTs,
1306  EVT memvt, MachineMemOperand *MMO);
1307 
1308  bool readMem() const { return MMO->isLoad(); }
1309  bool writeMem() const { return MMO->isStore(); }
1310 
1311  /// Returns alignment and volatility of the memory access
1312  unsigned getOriginalAlignment() const {
1313  return MMO->getBaseAlignment();
1314  }
1315  unsigned getAlignment() const {
1316  return MMO->getAlignment();
1317  }
1318 
1319  /// Return the SubclassData value, without HasDebugValue. This contains an
1320  /// encoding of the volatile flag, as well as bits used by subclasses. This
1321  /// function should only be used to compute a FoldingSetNodeID value.
1322  /// The HasDebugValue bit is masked out because CSE map needs to match
1323  /// nodes with debug info with nodes without debug info. Same is about
1324  /// isDivergent bit.
1325  unsigned getRawSubclassData() const {
1326  uint16_t Data;
1327  union {
1328  char RawSDNodeBits[sizeof(uint16_t)];
1329  SDNodeBitfields SDNodeBits;
1330  };
1331  memcpy(&RawSDNodeBits, &this->RawSDNodeBits, sizeof(this->RawSDNodeBits));
1332  SDNodeBits.HasDebugValue = 0;
1333  SDNodeBits.IsDivergent = false;
1334  memcpy(&Data, &RawSDNodeBits, sizeof(RawSDNodeBits));
1335  return Data;
1336  }
1337 
1338  bool isVolatile() const { return MemSDNodeBits.IsVolatile; }
1339  bool isNonTemporal() const { return MemSDNodeBits.IsNonTemporal; }
1340  bool isDereferenceable() const { return MemSDNodeBits.IsDereferenceable; }
1341  bool isInvariant() const { return MemSDNodeBits.IsInvariant; }
1342 
1343  // Returns the offset from the location of the access.
1344  int64_t getSrcValueOffset() const { return MMO->getOffset(); }
1345 
1346  /// Returns the AA info that describes the dereference.
1347  AAMDNodes getAAInfo() const { return MMO->getAAInfo(); }
1348 
1349  /// Returns the Ranges that describes the dereference.
1350  const MDNode *getRanges() const { return MMO->getRanges(); }
1351 
1352  /// Returns the synchronization scope ID for this memory operation.
1353  SyncScope::ID getSyncScopeID() const { return MMO->getSyncScopeID(); }
1354 
1355  /// Return the atomic ordering requirements for this memory operation. For
1356  /// cmpxchg atomic operations, return the atomic ordering requirements when
1357  /// store occurs.
1358  AtomicOrdering getOrdering() const { return MMO->getOrdering(); }
1359 
1360  /// Return true if the memory operation ordering is Unordered or higher.
1361  bool isAtomic() const { return MMO->isAtomic(); }
1362 
1363  /// Returns true if the memory operation doesn't imply any ordering
1364  /// constraints on surrounding memory operations beyond the normal memory
1365  /// aliasing rules.
1366  bool isUnordered() const { return MMO->isUnordered(); }
1367 
1368  /// Returns true if the memory operation is neither atomic or volatile.
1369  bool isSimple() const { return !isAtomic() && !isVolatile(); }
1370 
1371  /// Return the type of the in-memory value.
1372  EVT getMemoryVT() const { return MemoryVT; }
1373 
1374  /// Return a MachineMemOperand object describing the memory
1375  /// reference performed by operation.
1376  MachineMemOperand *getMemOperand() const { return MMO; }
1377 
1379  return MMO->getPointerInfo();
1380  }
1381 
1382  /// Return the address space for the associated pointer
1383  unsigned getAddressSpace() const {
1384  return getPointerInfo().getAddrSpace();
1385  }
1386 
1387  /// Update this MemSDNode's MachineMemOperand information
1388  /// to reflect the alignment of NewMMO, if it has a greater alignment.
1389  /// This must only be used when the new alignment applies to all users of
1390  /// this MachineMemOperand.
1391  void refineAlignment(const MachineMemOperand *NewMMO) {
1392  MMO->refineAlignment(NewMMO);
1393  }
1394 
1395  const SDValue &getChain() const { return getOperand(0); }
1396  const SDValue &getBasePtr() const {
1397  return getOperand(getOpcode() == ISD::STORE ? 2 : 1);
1398  }
1399 
1400  // Methods to support isa and dyn_cast
1401  static bool classof(const SDNode *N) {
1402  // For some targets, we lower some target intrinsics to a MemIntrinsicNode
1403  // with either an intrinsic or a target opcode.
1404  return N->getOpcode() == ISD::LOAD ||
1405  N->getOpcode() == ISD::STORE ||
1406  N->getOpcode() == ISD::PREFETCH ||
1407  N->getOpcode() == ISD::ATOMIC_CMP_SWAP ||
1409  N->getOpcode() == ISD::ATOMIC_SWAP ||
1410  N->getOpcode() == ISD::ATOMIC_LOAD_ADD ||
1411  N->getOpcode() == ISD::ATOMIC_LOAD_SUB ||
1412  N->getOpcode() == ISD::ATOMIC_LOAD_AND ||
1413  N->getOpcode() == ISD::ATOMIC_LOAD_CLR ||
1414  N->getOpcode() == ISD::ATOMIC_LOAD_OR ||
1415  N->getOpcode() == ISD::ATOMIC_LOAD_XOR ||
1416  N->getOpcode() == ISD::ATOMIC_LOAD_NAND ||
1417  N->getOpcode() == ISD::ATOMIC_LOAD_MIN ||
1418  N->getOpcode() == ISD::ATOMIC_LOAD_MAX ||
1419  N->getOpcode() == ISD::ATOMIC_LOAD_UMIN ||
1420  N->getOpcode() == ISD::ATOMIC_LOAD_UMAX ||
1421  N->getOpcode() == ISD::ATOMIC_LOAD_FADD ||
1422  N->getOpcode() == ISD::ATOMIC_LOAD_FSUB ||
1423  N->getOpcode() == ISD::ATOMIC_LOAD ||
1424  N->getOpcode() == ISD::ATOMIC_STORE ||
1425  N->getOpcode() == ISD::MLOAD ||
1426  N->getOpcode() == ISD::MSTORE ||
1427  N->getOpcode() == ISD::MGATHER ||
1428  N->getOpcode() == ISD::MSCATTER ||
1429  N->isMemIntrinsic() ||
1430  N->isTargetMemoryOpcode();
1431  }
1432 };
1433 
1434 /// This is an SDNode representing atomic operations.
1435 class AtomicSDNode : public MemSDNode {
1436 public:
1437  AtomicSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTL,
1438  EVT MemVT, MachineMemOperand *MMO)
1439  : MemSDNode(Opc, Order, dl, VTL, MemVT, MMO) {
1440  assert(((Opc != ISD::ATOMIC_LOAD && Opc != ISD::ATOMIC_STORE) ||
1441  MMO->isAtomic()) && "then why are we using an AtomicSDNode?");
1442  }
1443 
1444  const SDValue &getBasePtr() const { return getOperand(1); }
1445  const SDValue &getVal() const { return getOperand(2); }
1446 
1447  /// Returns true if this SDNode represents cmpxchg atomic operation, false
1448  /// otherwise.
1449  bool isCompareAndSwap() const {
1450  unsigned Op = getOpcode();
1451  return Op == ISD::ATOMIC_CMP_SWAP ||
1453  }
1454 
1455  /// For cmpxchg atomic operations, return the atomic ordering requirements
1456  /// when store does not occur.
1458  assert(isCompareAndSwap() && "Must be cmpxchg operation");
1459  return MMO->getFailureOrdering();
1460  }
1461 
1462  // Methods to support isa and dyn_cast
1463  static bool classof(const SDNode *N) {
1464  return N->getOpcode() == ISD::ATOMIC_CMP_SWAP ||
1466  N->getOpcode() == ISD::ATOMIC_SWAP ||
1467  N->getOpcode() == ISD::ATOMIC_LOAD_ADD ||
1468  N->getOpcode() == ISD::ATOMIC_LOAD_SUB ||
1469  N->getOpcode() == ISD::ATOMIC_LOAD_AND ||
1470  N->getOpcode() == ISD::ATOMIC_LOAD_CLR ||
1471  N->getOpcode() == ISD::ATOMIC_LOAD_OR ||
1472  N->getOpcode() == ISD::ATOMIC_LOAD_XOR ||
1473  N->getOpcode() == ISD::ATOMIC_LOAD_NAND ||
1474  N->getOpcode() == ISD::ATOMIC_LOAD_MIN ||
1475  N->getOpcode() == ISD::ATOMIC_LOAD_MAX ||
1476  N->getOpcode() == ISD::ATOMIC_LOAD_UMIN ||
1477  N->getOpcode() == ISD::ATOMIC_LOAD_UMAX ||
1478  N->getOpcode() == ISD::ATOMIC_LOAD_FADD ||
1479  N->getOpcode() == ISD::ATOMIC_LOAD_FSUB ||
1480  N->getOpcode() == ISD::ATOMIC_LOAD ||
1481  N->getOpcode() == ISD::ATOMIC_STORE;
1482  }
1483 };
1484 
1485 /// This SDNode is used for target intrinsics that touch
1486 /// memory and need an associated MachineMemOperand. Its opcode may be
1487 /// INTRINSIC_VOID, INTRINSIC_W_CHAIN, PREFETCH, or a target-specific opcode
1488 /// with a value not less than FIRST_TARGET_MEMORY_OPCODE.
1490 public:
1491  MemIntrinsicSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl,
1492  SDVTList VTs, EVT MemoryVT, MachineMemOperand *MMO)
1493  : MemSDNode(Opc, Order, dl, VTs, MemoryVT, MMO) {
1494  SDNodeBits.IsMemIntrinsic = true;
1495  }
1496 
1497  // Methods to support isa and dyn_cast
1498  static bool classof(const SDNode *N) {
1499  // We lower some target intrinsics to their target opcode
1500  // early a node with a target opcode can be of this class
1501  return N->isMemIntrinsic() ||
1502  N->getOpcode() == ISD::PREFETCH ||
1503  N->isTargetMemoryOpcode();
1504  }
1505 };
1506 
1507 /// This SDNode is used to implement the code generator
1508 /// support for the llvm IR shufflevector instruction. It combines elements
1509 /// from two input vectors into a new input vector, with the selection and
1510 /// ordering of elements determined by an array of integers, referred to as
1511 /// the shuffle mask. For input vectors of width N, mask indices of 0..N-1
1512 /// refer to elements from the LHS input, and indices from N to 2N-1 the RHS.
1513 /// An index of -1 is treated as undef, such that the code generator may put
1514 /// any value in the corresponding element of the result.
1515 class ShuffleVectorSDNode : public SDNode {
1516  // The memory for Mask is owned by the SelectionDAG's OperandAllocator, and
1517  // is freed when the SelectionDAG object is destroyed.
1518  const int *Mask;
1519 
1520 protected:
1521  friend class SelectionDAG;
1522 
1523  ShuffleVectorSDNode(EVT VT, unsigned Order, const DebugLoc &dl, const int *M)
1524  : SDNode(ISD::VECTOR_SHUFFLE, Order, dl, getSDVTList(VT)), Mask(M) {}
1525 
1526 public:
1528  EVT VT = getValueType(0);
1529  return makeArrayRef(Mask, VT.getVectorNumElements());
1530  }
1531 
1532  int getMaskElt(unsigned Idx) const {
1533  assert(Idx < getValueType(0).getVectorNumElements() && "Idx out of range!");
1534  return Mask[Idx];
1535  }
1536 
1537  bool isSplat() const { return isSplatMask(Mask, getValueType(0)); }
1538 
1539  int getSplatIndex() const {
1540  assert(isSplat() && "Cannot get splat index for non-splat!");
1541  EVT VT = getValueType(0);
1542  for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; ++i)
1543  if (Mask[i] >= 0)
1544  return Mask[i];
1545 
1546  // We can choose any index value here and be correct because all elements
1547  // are undefined. Return 0 for better potential for callers to simplify.
1548  return 0;
1549  }
1550 
1551  static bool isSplatMask(const int *Mask, EVT VT);
1552 
1553  /// Change values in a shuffle permute mask assuming
1554  /// the two vector operands have swapped position.
1555  static void commuteMask(MutableArrayRef<int> Mask) {
1556  unsigned NumElems = Mask.size();
1557  for (unsigned i = 0; i != NumElems; ++i) {
1558  int idx = Mask[i];
1559  if (idx < 0)
1560  continue;
1561  else if (idx < (int)NumElems)
1562  Mask[i] = idx + NumElems;
1563  else
1564  Mask[i] = idx - NumElems;
1565  }
1566  }
1567 
1568  static bool classof(const SDNode *N) {
1569  return N->getOpcode() == ISD::VECTOR_SHUFFLE;
1570  }
1571 };
1572 
1573 class ConstantSDNode : public SDNode {
1574  friend class SelectionDAG;
1575 
1576  const ConstantInt *Value;
1577 
1578  ConstantSDNode(bool isTarget, bool isOpaque, const ConstantInt *val, EVT VT)
1579  : SDNode(isTarget ? ISD::TargetConstant : ISD::Constant, 0, DebugLoc(),
1580  getSDVTList(VT)),
1581  Value(val) {
1582  ConstantSDNodeBits.IsOpaque = isOpaque;
1583  }
1584 
1585 public:
1586  const ConstantInt *getConstantIntValue() const { return Value; }
1587  const APInt &getAPIntValue() const { return Value->getValue(); }
1588  uint64_t getZExtValue() const { return Value->getZExtValue(); }
1589  int64_t getSExtValue() const { return Value->getSExtValue(); }
1590  uint64_t getLimitedValue(uint64_t Limit = UINT64_MAX) {
1591  return Value->getLimitedValue(Limit);
1592  }
1593 
1594  bool isOne() const { return Value->isOne(); }
1595  bool isNullValue() const { return Value->isZero(); }
1596  bool isAllOnesValue() const { return Value->isMinusOne(); }
1597 
1598  bool isOpaque() const { return ConstantSDNodeBits.IsOpaque; }
1599 
1600  static bool classof(const SDNode *N) {
1601  return N->getOpcode() == ISD::Constant ||
1603  }
1604 };
1605 
1606 uint64_t SDNode::getConstantOperandVal(unsigned Num) const {
1607  return cast<ConstantSDNode>(getOperand(Num))->getZExtValue();
1608 }
1609 
1610 const APInt &SDNode::getConstantOperandAPInt(unsigned Num) const {
1611  return cast<ConstantSDNode>(getOperand(Num))->getAPIntValue();
1612 }
1613 
1614 class ConstantFPSDNode : public SDNode {
1615  friend class SelectionDAG;
1616 
1617  const ConstantFP *Value;
1618 
1619  ConstantFPSDNode(bool isTarget, const ConstantFP *val, EVT VT)
1620  : SDNode(isTarget ? ISD::TargetConstantFP : ISD::ConstantFP, 0,
1621  DebugLoc(), getSDVTList(VT)),
1622  Value(val) {}
1623 
1624 public:
1625  const APFloat& getValueAPF() const { return Value->getValueAPF(); }
1626  const ConstantFP *getConstantFPValue() const { return Value; }
1627 
1628  /// Return true if the value is positive or negative zero.
1629  bool isZero() const { return Value->isZero(); }
1630 
1631  /// Return true if the value is a NaN.
1632  bool isNaN() const { return Value->isNaN(); }
1633 
1634  /// Return true if the value is an infinity
1635  bool isInfinity() const { return Value->isInfinity(); }
1636 
1637  /// Return true if the value is negative.
1638  bool isNegative() const { return Value->isNegative(); }
1639 
1640  /// We don't rely on operator== working on double values, as
1641  /// it returns true for things that are clearly not equal, like -0.0 and 0.0.
1642  /// As such, this method can be used to do an exact bit-for-bit comparison of
1643  /// two floating point values.
1644 
1645  /// We leave the version with the double argument here because it's just so
1646  /// convenient to write "2.0" and the like. Without this function we'd
1647  /// have to duplicate its logic everywhere it's called.
1648  bool isExactlyValue(double V) const {
1649  return Value->getValueAPF().isExactlyValue(V);
1650  }
1651  bool isExactlyValue(const APFloat& V) const;
1652 
1653  static bool isValueValidForType(EVT VT, const APFloat& Val);
1654 
1655  static bool classof(const SDNode *N) {
1656  return N->getOpcode() == ISD::ConstantFP ||
1658  }
1659 };
1660 
1661 /// Returns true if \p V is a constant integer zero.
1662 bool isNullConstant(SDValue V);
1663 
1664 /// Returns true if \p V is an FP constant with a value of positive zero.
1665 bool isNullFPConstant(SDValue V);
1666 
1667 /// Returns true if \p V is an integer constant with all bits set.
1668 bool isAllOnesConstant(SDValue V);
1669 
1670 /// Returns true if \p V is a constant integer one.
1671 bool isOneConstant(SDValue V);
1672 
1673 /// Return the non-bitcasted source operand of \p V if it exists.
1674 /// If \p V is not a bitcasted value, it is returned as-is.
1676 
1677 /// Return the non-bitcasted and one-use source operand of \p V if it exists.
1678 /// If \p V is not a bitcasted one-use value, it is returned as-is.
1680 
1681 /// Return the non-extracted vector source operand of \p V if it exists.
1682 /// If \p V is not an extracted subvector, it is returned as-is.
1684 
1685 /// Returns true if \p V is a bitwise not operation. Assumes that an all ones
1686 /// constant is canonicalized to be operand 1.
1687 bool isBitwiseNot(SDValue V, bool AllowUndefs = false);
1688 
1689 /// Returns the SDNode if it is a constant splat BuildVector or constant int.
1690 ConstantSDNode *isConstOrConstSplat(SDValue N, bool AllowUndefs = false,
1691  bool AllowTruncation = false);
1692 
1693 /// Returns the SDNode if it is a demanded constant splat BuildVector or
1694 /// constant int.
1695 ConstantSDNode *isConstOrConstSplat(SDValue N, const APInt &DemandedElts,
1696  bool AllowUndefs = false,
1697  bool AllowTruncation = false);
1698 
1699 /// Returns the SDNode if it is a constant splat BuildVector or constant float.
1700 ConstantFPSDNode *isConstOrConstSplatFP(SDValue N, bool AllowUndefs = false);
1701 
1702 /// Returns the SDNode if it is a demanded constant splat BuildVector or
1703 /// constant float.
1704 ConstantFPSDNode *isConstOrConstSplatFP(SDValue N, const APInt &DemandedElts,
1705  bool AllowUndefs = false);
1706 
1707 /// Return true if the value is a constant 0 integer or a splatted vector of
1708 /// a constant 0 integer (with no undefs by default).
1709 /// Build vector implicit truncation is not an issue for null values.
1710 bool isNullOrNullSplat(SDValue V, bool AllowUndefs = false);
1711 
1712 /// Return true if the value is a constant 1 integer or a splatted vector of a
1713 /// constant 1 integer (with no undefs).
1714 /// Does not permit build vector implicit truncation.
1715 bool isOneOrOneSplat(SDValue V);
1716 
1717 /// Return true if the value is a constant -1 integer or a splatted vector of a
1718 /// constant -1 integer (with no undefs).
1719 /// Does not permit build vector implicit truncation.
1721 
1722 class GlobalAddressSDNode : public SDNode {
1723  friend class SelectionDAG;
1724 
1725  const GlobalValue *TheGlobal;
1726  int64_t Offset;
1727  unsigned TargetFlags;
1728 
1729  GlobalAddressSDNode(unsigned Opc, unsigned Order, const DebugLoc &DL,
1730  const GlobalValue *GA, EVT VT, int64_t o,
1731  unsigned TF);
1732 
1733 public:
1734  const GlobalValue *getGlobal() const { return TheGlobal; }
1735  int64_t getOffset() const { return Offset; }
1736  unsigned getTargetFlags() const { return TargetFlags; }
1737  // Return the address space this GlobalAddress belongs to.
1738  unsigned getAddressSpace() const;
1739 
1740  static bool classof(const SDNode *N) {
1741  return N->getOpcode() == ISD::GlobalAddress ||
1743  N->getOpcode() == ISD::GlobalTLSAddress ||
1745  }
1746 };
1747 
1748 class FrameIndexSDNode : public SDNode {
1749  friend class SelectionDAG;
1750 
1751  int FI;
1752 
1753  FrameIndexSDNode(int fi, EVT VT, bool isTarg)
1754  : SDNode(isTarg ? ISD::TargetFrameIndex : ISD::FrameIndex,
1755  0, DebugLoc(), getSDVTList(VT)), FI(fi) {
1756  }
1757 
1758 public:
1759  int getIndex() const { return FI; }
1760 
1761  static bool classof(const SDNode *N) {
1762  return N->getOpcode() == ISD::FrameIndex ||
1764  }
1765 };
1766 
1767 /// This SDNode is used for LIFETIME_START/LIFETIME_END values, which indicate
1768 /// the offet and size that are started/ended in the underlying FrameIndex.
1769 class LifetimeSDNode : public SDNode {
1770  friend class SelectionDAG;
1771  int64_t Size;
1772  int64_t Offset; // -1 if offset is unknown.
1773 
1774  LifetimeSDNode(unsigned Opcode, unsigned Order, const DebugLoc &dl,
1775  SDVTList VTs, int64_t Size, int64_t Offset)
1776  : SDNode(Opcode, Order, dl, VTs), Size(Size), Offset(Offset) {}
1777 public:
1778  int64_t getFrameIndex() const {
1779  return cast<FrameIndexSDNode>(getOperand(1))->getIndex();
1780  }
1781 
1782  bool hasOffset() const { return Offset >= 0; }
1783  int64_t getOffset() const {
1784  assert(hasOffset() && "offset is unknown");
1785  return Offset;
1786  }
1787  int64_t getSize() const {
1788  assert(hasOffset() && "offset is unknown");
1789  return Size;
1790  }
1791 
1792  // Methods to support isa and dyn_cast
1793  static bool classof(const SDNode *N) {
1794  return N->getOpcode() == ISD::LIFETIME_START ||
1795  N->getOpcode() == ISD::LIFETIME_END;
1796  }
1797 };
1798 
1799 class JumpTableSDNode : public SDNode {
1800  friend class SelectionDAG;
1801 
1802  int JTI;
1803  unsigned TargetFlags;
1804 
1805  JumpTableSDNode(int jti, EVT VT, bool isTarg, unsigned TF)
1806  : SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable,
1807  0, DebugLoc(), getSDVTList(VT)), JTI(jti), TargetFlags(TF) {
1808  }
1809 
1810 public:
1811  int getIndex() const { return JTI; }
1812  unsigned getTargetFlags() const { return TargetFlags; }
1813 
1814  static bool classof(const SDNode *N) {
1815  return N->getOpcode() == ISD::JumpTable ||
1817  }
1818 };
1819 
1820 class ConstantPoolSDNode : public SDNode {
1821  friend class SelectionDAG;
1822 
1823  union {
1826  } Val;
1827  int Offset; // It's a MachineConstantPoolValue if top bit is set.
1828  unsigned Alignment; // Minimum alignment requirement of CP (not log2 value).
1829  unsigned TargetFlags;
1830 
1831  ConstantPoolSDNode(bool isTarget, const Constant *c, EVT VT, int o,
1832  unsigned Align, unsigned TF)
1833  : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0,
1834  DebugLoc(), getSDVTList(VT)), Offset(o), Alignment(Align),
1835  TargetFlags(TF) {
1836  assert(Offset >= 0 && "Offset is too large");
1837  Val.ConstVal = c;
1838  }
1839 
1840  ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v,
1841  EVT VT, int o, unsigned Align, unsigned TF)
1843  DebugLoc(), getSDVTList(VT)), Offset(o), Alignment(Align),
1844  TargetFlags(TF) {
1845  assert(Offset >= 0 && "Offset is too large");
1846  Val.MachineCPVal = v;
1847  Offset |= 1 << (sizeof(unsigned)*CHAR_BIT-1);
1848  }
1849 
1850 public:
1852  return Offset < 0;
1853  }
1854 
1855  const Constant *getConstVal() const {
1856  assert(!isMachineConstantPoolEntry() && "Wrong constantpool type");
1857  return Val.ConstVal;
1858  }
1859 
1861  assert(isMachineConstantPoolEntry() && "Wrong constantpool type");
1862  return Val.MachineCPVal;
1863  }
1864 
1865  int getOffset() const {
1866  return Offset & ~(1 << (sizeof(unsigned)*CHAR_BIT-1));
1867  }
1868 
1869  // Return the alignment of this constant pool object, which is either 0 (for
1870  // default alignment) or the desired value.
1871  unsigned getAlignment() const { return Alignment; }
1872  unsigned getTargetFlags() const { return TargetFlags; }
1873 
1874  Type *getType() const;
1875 
1876  static bool classof(const SDNode *N) {
1877  return N->getOpcode() == ISD::ConstantPool ||
1879  }
1880 };
1881 
1882 /// Completely target-dependent object reference.
1883 class TargetIndexSDNode : public SDNode {
1884  friend class SelectionDAG;
1885 
1886  unsigned TargetFlags;
1887  int Index;
1888  int64_t Offset;
1889 
1890 public:
1891  TargetIndexSDNode(int Idx, EVT VT, int64_t Ofs, unsigned TF)
1892  : SDNode(ISD::TargetIndex, 0, DebugLoc(), getSDVTList(VT)),
1893  TargetFlags(TF), Index(Idx), Offset(Ofs) {}
1894 
1895  unsigned getTargetFlags() const { return TargetFlags; }
1896  int getIndex() const { return Index; }
1897  int64_t getOffset() const { return Offset; }
1898 
1899  static bool classof(const SDNode *N) {
1900  return N->getOpcode() == ISD::TargetIndex;
1901  }
1902 };
1903 
1904 class BasicBlockSDNode : public SDNode {
1905  friend class SelectionDAG;
1906 
1907  MachineBasicBlock *MBB;
1908 
1909  /// Debug info is meaningful and potentially useful here, but we create
1910  /// blocks out of order when they're jumped to, which makes it a bit
1911  /// harder. Let's see if we need it first.
1912  explicit BasicBlockSDNode(MachineBasicBlock *mbb)
1913  : SDNode(ISD::BasicBlock, 0, DebugLoc(), getSDVTList(MVT::Other)), MBB(mbb)
1914  {}
1915 
1916 public:
1917  MachineBasicBlock *getBasicBlock() const { return MBB; }
1918 
1919  static bool classof(const SDNode *N) {
1920  return N->getOpcode() == ISD::BasicBlock;
1921  }
1922 };
1923 
1924 /// A "pseudo-class" with methods for operating on BUILD_VECTORs.
1925 class BuildVectorSDNode : public SDNode {
1926 public:
1927  // These are constructed as SDNodes and then cast to BuildVectorSDNodes.
1928  explicit BuildVectorSDNode() = delete;
1929 
1930  /// Check if this is a constant splat, and if so, find the
1931  /// smallest element size that splats the vector. If MinSplatBits is
1932  /// nonzero, the element size must be at least that large. Note that the
1933  /// splat element may be the entire vector (i.e., a one element vector).
1934  /// Returns the splat element value in SplatValue. Any undefined bits in
1935  /// that value are zero, and the corresponding bits in the SplatUndef mask
1936  /// are set. The SplatBitSize value is set to the splat element size in
1937  /// bits. HasAnyUndefs is set to true if any bits in the vector are
1938  /// undefined. isBigEndian describes the endianness of the target.
1939  bool isConstantSplat(APInt &SplatValue, APInt &SplatUndef,
1940  unsigned &SplatBitSize, bool &HasAnyUndefs,
1941  unsigned MinSplatBits = 0,
1942  bool isBigEndian = false) const;
1943 
1944  /// Returns the demanded splatted value or a null value if this is not a
1945  /// splat.
1946  ///
1947  /// The DemandedElts mask indicates the elements that must be in the splat.
1948  /// If passed a non-null UndefElements bitvector, it will resize it to match
1949  /// the vector width and set the bits where elements are undef.
1950  SDValue getSplatValue(const APInt &DemandedElts,
1951  BitVector *UndefElements = nullptr) const;
1952 
1953  /// Returns the splatted value or a null value if this is not a splat.
1954  ///
1955  /// If passed a non-null UndefElements bitvector, it will resize it to match
1956  /// the vector width and set the bits where elements are undef.
1957  SDValue getSplatValue(BitVector *UndefElements = nullptr) const;
1958 
1959  /// Returns the demanded splatted constant or null if this is not a constant
1960  /// splat.
1961  ///
1962  /// The DemandedElts mask indicates the elements that must be in the splat.
1963  /// If passed a non-null UndefElements bitvector, it will resize it to match
1964  /// the vector width and set the bits where elements are undef.
1965  ConstantSDNode *
1966  getConstantSplatNode(const APInt &DemandedElts,
1967  BitVector *UndefElements = nullptr) const;
1968 
1969  /// Returns the splatted constant or null if this is not a constant
1970  /// splat.
1971  ///
1972  /// If passed a non-null UndefElements bitvector, it will resize it to match
1973  /// the vector width and set the bits where elements are undef.
1974  ConstantSDNode *
1975  getConstantSplatNode(BitVector *UndefElements = nullptr) const;
1976 
1977  /// Returns the demanded splatted constant FP or null if this is not a
1978  /// constant FP splat.
1979  ///
1980  /// The DemandedElts mask indicates the elements that must be in the splat.
1981  /// If passed a non-null UndefElements bitvector, it will resize it to match
1982  /// the vector width and set the bits where elements are undef.
1984  getConstantFPSplatNode(const APInt &DemandedElts,
1985  BitVector *UndefElements = nullptr) const;
1986 
1987  /// Returns the splatted constant FP or null if this is not a constant
1988  /// FP splat.
1989  ///
1990  /// If passed a non-null UndefElements bitvector, it will resize it to match
1991  /// the vector width and set the bits where elements are undef.
1993  getConstantFPSplatNode(BitVector *UndefElements = nullptr) const;
1994 
1995  /// If this is a constant FP splat and the splatted constant FP is an
1996  /// exact power or 2, return the log base 2 integer value. Otherwise,
1997  /// return -1.
1998  ///
1999  /// The BitWidth specifies the necessary bit precision.
2000  int32_t getConstantFPSplatPow2ToLog2Int(BitVector *UndefElements,
2001  uint32_t BitWidth) const;
2002 
2003  bool isConstant() const;
2004 
2005  static bool classof(const SDNode *N) {
2006  return N->getOpcode() == ISD::BUILD_VECTOR;
2007  }
2008 };
2009 
2010 /// An SDNode that holds an arbitrary LLVM IR Value. This is
2011 /// used when the SelectionDAG needs to make a simple reference to something
2012 /// in the LLVM IR representation.
2013 ///
2014 class SrcValueSDNode : public SDNode {
2015  friend class SelectionDAG;
2016 
2017  const Value *V;
2018 
2019  /// Create a SrcValue for a general value.
2020  explicit SrcValueSDNode(const Value *v)
2021  : SDNode(ISD::SRCVALUE, 0, DebugLoc(), getSDVTList(MVT::Other)), V(v) {}
2022 
2023 public:
2024  /// Return the contained Value.
2025  const Value *getValue() const { return V; }
2026 
2027  static bool classof(const SDNode *N) {
2028  return N->getOpcode() == ISD::SRCVALUE;
2029  }
2030 };
2031 
2032 class MDNodeSDNode : public SDNode {
2033  friend class SelectionDAG;
2034 
2035  const MDNode *MD;
2036 
2037  explicit MDNodeSDNode(const MDNode *md)
2038  : SDNode(ISD::MDNODE_SDNODE, 0, DebugLoc(), getSDVTList(MVT::Other)), MD(md)
2039  {}
2040 
2041 public:
2042  const MDNode *getMD() const { return MD; }
2043 
2044  static bool classof(const SDNode *N) {
2045  return N->getOpcode() == ISD::MDNODE_SDNODE;
2046  }
2047 };
2048 
2049 class RegisterSDNode : public SDNode {
2050  friend class SelectionDAG;
2051 
2052  unsigned Reg;
2053 
2054  RegisterSDNode(unsigned reg, EVT VT)
2055  : SDNode(ISD::Register, 0, DebugLoc(), getSDVTList(VT)), Reg(reg) {}
2056 
2057 public:
2058  unsigned getReg() const { return Reg; }
2059 
2060  static bool classof(const SDNode *N) {
2061  return N->getOpcode() == ISD::Register;
2062  }
2063 };
2064 
2065 class RegisterMaskSDNode : public SDNode {
2066  friend class SelectionDAG;
2067 
2068  // The memory for RegMask is not owned by the node.
2069  const uint32_t *RegMask;
2070 
2071  RegisterMaskSDNode(const uint32_t *mask)
2072  : SDNode(ISD::RegisterMask, 0, DebugLoc(), getSDVTList(MVT::Untyped)),
2073  RegMask(mask) {}
2074 
2075 public:
2076  const uint32_t *getRegMask() const { return RegMask; }
2077 
2078  static bool classof(const SDNode *N) {
2079  return N->getOpcode() == ISD::RegisterMask;
2080  }
2081 };
2082 
2083 class BlockAddressSDNode : public SDNode {
2084  friend class SelectionDAG;
2085 
2086  const BlockAddress *BA;
2087  int64_t Offset;
2088  unsigned TargetFlags;
2089 
2090  BlockAddressSDNode(unsigned NodeTy, EVT VT, const BlockAddress *ba,
2091  int64_t o, unsigned Flags)
2092  : SDNode(NodeTy, 0, DebugLoc(), getSDVTList(VT)),
2093  BA(ba), Offset(o), TargetFlags(Flags) {}
2094 
2095 public:
2096  const BlockAddress *getBlockAddress() const { return BA; }
2097  int64_t getOffset() const { return Offset; }
2098  unsigned getTargetFlags() const { return TargetFlags; }
2099 
2100  static bool classof(const SDNode *N) {
2101  return N->getOpcode() == ISD::BlockAddress ||
2103  }
2104 };
2105 
2106 class LabelSDNode : public SDNode {
2107  friend class SelectionDAG;
2108 
2109  MCSymbol *Label;
2110 
2111  LabelSDNode(unsigned Opcode, unsigned Order, const DebugLoc &dl, MCSymbol *L)
2112  : SDNode(Opcode, Order, dl, getSDVTList(MVT::Other)), Label(L) {
2113  assert(LabelSDNode::classof(this) && "not a label opcode");
2114  }
2115 
2116 public:
2117  MCSymbol *getLabel() const { return Label; }
2118 
2119  static bool classof(const SDNode *N) {
2120  return N->getOpcode() == ISD::EH_LABEL ||
2122  }
2123 };
2124 
2126  friend class SelectionDAG;
2127 
2128  const char *Symbol;
2129  unsigned TargetFlags;
2130 
2131  ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned TF, EVT VT)
2132  : SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol, 0,
2133  DebugLoc(), getSDVTList(VT)),
2134  Symbol(Sym), TargetFlags(TF) {}
2135 
2136 public:
2137  const char *getSymbol() const { return Symbol; }
2138  unsigned getTargetFlags() const { return TargetFlags; }
2139 
2140  static bool classof(const SDNode *N) {
2141  return N->getOpcode() == ISD::ExternalSymbol ||
2143  }
2144 };
2145 
2146 class MCSymbolSDNode : public SDNode {
2147  friend class SelectionDAG;
2148 
2149  MCSymbol *Symbol;
2150 
2151  MCSymbolSDNode(MCSymbol *Symbol, EVT VT)
2152  : SDNode(ISD::MCSymbol, 0, DebugLoc(), getSDVTList(VT)), Symbol(Symbol) {}
2153 
2154 public:
2155  MCSymbol *getMCSymbol() const { return Symbol; }
2156 
2157  static bool classof(const SDNode *N) {
2158  return N->getOpcode() == ISD::MCSymbol;
2159  }
2160 };
2161 
2162 class CondCodeSDNode : public SDNode {
2163  friend class SelectionDAG;
2164 
2165  ISD::CondCode Condition;
2166 
2167  explicit CondCodeSDNode(ISD::CondCode Cond)
2168  : SDNode(ISD::CONDCODE, 0, DebugLoc(), getSDVTList(MVT::Other)),
2169  Condition(Cond) {}
2170 
2171 public:
2172  ISD::CondCode get() const { return Condition; }
2173 
2174  static bool classof(const SDNode *N) {
2175  return N->getOpcode() == ISD::CONDCODE;
2176  }
2177 };
2178 
2179 /// This class is used to represent EVT's, which are used
2180 /// to parameterize some operations.
2181 class VTSDNode : public SDNode {
2182  friend class SelectionDAG;
2183 
2184  EVT ValueType;
2185 
2186  explicit VTSDNode(EVT VT)
2187  : SDNode(ISD::VALUETYPE, 0, DebugLoc(), getSDVTList(MVT::Other)),
2188  ValueType(VT) {}
2189 
2190 public:
2191  EVT getVT() const { return ValueType; }
2192 
2193  static bool classof(const SDNode *N) {
2194  return N->getOpcode() == ISD::VALUETYPE;
2195  }
2196 };
2197 
2198 /// Base class for LoadSDNode and StoreSDNode
2199 class LSBaseSDNode : public MemSDNode {
2200 public:
2201  LSBaseSDNode(ISD::NodeType NodeTy, unsigned Order, const DebugLoc &dl,
2202  SDVTList VTs, ISD::MemIndexedMode AM, EVT MemVT,
2203  MachineMemOperand *MMO)
2204  : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {
2205  LSBaseSDNodeBits.AddressingMode = AM;
2206  assert(getAddressingMode() == AM && "Value truncated");
2207  }
2208 
2209  const SDValue &getOffset() const {
2210  return getOperand(getOpcode() == ISD::LOAD ? 2 : 3);
2211  }
2212 
2213  /// Return the addressing mode for this load or store:
2214  /// unindexed, pre-inc, pre-dec, post-inc, or post-dec.
2216  return static_cast<ISD::MemIndexedMode>(LSBaseSDNodeBits.AddressingMode);
2217  }
2218 
2219  /// Return true if this is a pre/post inc/dec load/store.
2220  bool isIndexed() const { return getAddressingMode() != ISD::UNINDEXED; }
2221 
2222  /// Return true if this is NOT a pre/post inc/dec load/store.
2223  bool isUnindexed() const { return getAddressingMode() == ISD::UNINDEXED; }
2224 
2225  static bool classof(const SDNode *N) {
2226  return N->getOpcode() == ISD::LOAD ||
2227  N->getOpcode() == ISD::STORE;
2228  }
2229 };
2230 
2231 /// This class is used to represent ISD::LOAD nodes.
2232 class LoadSDNode : public LSBaseSDNode {
2233  friend class SelectionDAG;
2234 
2235  LoadSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2236  ISD::MemIndexedMode AM, ISD::LoadExtType ETy, EVT MemVT,
2237  MachineMemOperand *MMO)
2238  : LSBaseSDNode(ISD::LOAD, Order, dl, VTs, AM, MemVT, MMO) {
2239  LoadSDNodeBits.ExtTy = ETy;
2240  assert(readMem() && "Load MachineMemOperand is not a load!");
2241  assert(!writeMem() && "Load MachineMemOperand is a store!");
2242  }
2243 
2244 public:
2245  /// Return whether this is a plain node,
2246  /// or one of the varieties of value-extending loads.
2248  return static_cast<ISD::LoadExtType>(LoadSDNodeBits.ExtTy);
2249  }
2250 
2251  const SDValue &getBasePtr() const { return getOperand(1); }
2252  const SDValue &getOffset() const { return getOperand(2); }
2253 
2254  static bool classof(const SDNode *N) {
2255  return N->getOpcode() == ISD::LOAD;
2256  }
2257 };
2258 
2259 /// This class is used to represent ISD::STORE nodes.
2260 class StoreSDNode : public LSBaseSDNode {
2261  friend class SelectionDAG;
2262 
2263  StoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2264  ISD::MemIndexedMode AM, bool isTrunc, EVT MemVT,
2265  MachineMemOperand *MMO)
2266  : LSBaseSDNode(ISD::STORE, Order, dl, VTs, AM, MemVT, MMO) {
2267  StoreSDNodeBits.IsTruncating = isTrunc;
2268  assert(!readMem() && "Store MachineMemOperand is a load!");
2269  assert(writeMem() && "Store MachineMemOperand is not a store!");
2270  }
2271 
2272 public:
2273  /// Return true if the op does a truncation before store.
2274  /// For integers this is the same as doing a TRUNCATE and storing the result.
2275  /// For floats, it is the same as doing an FP_ROUND and storing the result.
2276  bool isTruncatingStore() const { return StoreSDNodeBits.IsTruncating; }
2277  void setTruncatingStore(bool Truncating) {
2278  StoreSDNodeBits.IsTruncating = Truncating;
2279  }
2280 
2281  const SDValue &getValue() const { return getOperand(1); }
2282  const SDValue &getBasePtr() const { return getOperand(2); }
2283  const SDValue &getOffset() const { return getOperand(3); }
2284 
2285  static bool classof(const SDNode *N) {
2286  return N->getOpcode() == ISD::STORE;
2287  }
2288 };
2289 
2290 /// This base class is used to represent MLOAD and MSTORE nodes
2292 public:
2293  friend class SelectionDAG;
2294 
2295  MaskedLoadStoreSDNode(ISD::NodeType NodeTy, unsigned Order,
2296  const DebugLoc &dl, SDVTList VTs, EVT MemVT,
2297  MachineMemOperand *MMO)
2298  : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {}
2299 
2300  // MaskedLoadSDNode (Chain, ptr, mask, passthru)
2301  // MaskedStoreSDNode (Chain, data, ptr, mask)
2302  // Mask is a vector of i1 elements
2303  const SDValue &getBasePtr() const {
2304  return getOperand(getOpcode() == ISD::MLOAD ? 1 : 2);
2305  }
2306  const SDValue &getMask() const {
2307  return getOperand(getOpcode() == ISD::MLOAD ? 2 : 3);
2308  }
2309 
2310  static bool classof(const SDNode *N) {
2311  return N->getOpcode() == ISD::MLOAD ||
2312  N->getOpcode() == ISD::MSTORE;
2313  }
2314 };
2315 
2316 /// This class is used to represent an MLOAD node
2318 public:
2319  friend class SelectionDAG;
2320 
2321  MaskedLoadSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2322  ISD::LoadExtType ETy, bool IsExpanding, EVT MemVT,
2323  MachineMemOperand *MMO)
2324  : MaskedLoadStoreSDNode(ISD::MLOAD, Order, dl, VTs, MemVT, MMO) {
2325  LoadSDNodeBits.ExtTy = ETy;
2326  LoadSDNodeBits.IsExpanding = IsExpanding;
2327  }
2328 
2330  return static_cast<ISD::LoadExtType>(LoadSDNodeBits.ExtTy);
2331  }
2332 
2333  const SDValue &getBasePtr() const { return getOperand(1); }
2334  const SDValue &getMask() const { return getOperand(2); }
2335  const SDValue &getPassThru() const { return getOperand(3); }
2336 
2337  static bool classof(const SDNode *N) {
2338  return N->getOpcode() == ISD::MLOAD;
2339  }
2340 
2341  bool isExpandingLoad() const { return LoadSDNodeBits.IsExpanding; }
2342 };
2343 
2344 /// This class is used to represent an MSTORE node
2346 public:
2347  friend class SelectionDAG;
2348 
2349  MaskedStoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2350  bool isTrunc, bool isCompressing, EVT MemVT,
2351  MachineMemOperand *MMO)
2352  : MaskedLoadStoreSDNode(ISD::MSTORE, Order, dl, VTs, MemVT, MMO) {
2353  StoreSDNodeBits.IsTruncating = isTrunc;
2354  StoreSDNodeBits.IsCompressing = isCompressing;
2355  }
2356 
2357  /// Return true if the op does a truncation before store.
2358  /// For integers this is the same as doing a TRUNCATE and storing the result.
2359  /// For floats, it is the same as doing an FP_ROUND and storing the result.
2360  bool isTruncatingStore() const { return StoreSDNodeBits.IsTruncating; }
2361 
2362  /// Returns true if the op does a compression to the vector before storing.
2363  /// The node contiguously stores the active elements (integers or floats)
2364  /// in src (those with their respective bit set in writemask k) to unaligned
2365  /// memory at base_addr.
2366  bool isCompressingStore() const { return StoreSDNodeBits.IsCompressing; }
2367 
2368  const SDValue &getValue() const { return getOperand(1); }
2369  const SDValue &getBasePtr() const { return getOperand(2); }
2370  const SDValue &getMask() const { return getOperand(3); }
2371 
2372  static bool classof(const SDNode *N) {
2373  return N->getOpcode() == ISD::MSTORE;
2374  }
2375 };
2376 
2377 /// This is a base class used to represent
2378 /// MGATHER and MSCATTER nodes
2379 ///
2381 public:
2382  friend class SelectionDAG;
2383 
2385  const DebugLoc &dl, SDVTList VTs, EVT MemVT,
2386  MachineMemOperand *MMO, ISD::MemIndexType IndexType)
2387  : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {
2388  LSBaseSDNodeBits.AddressingMode = IndexType;
2389  assert(getIndexType() == IndexType && "Value truncated");
2390  }
2391 
2392  /// How is Index applied to BasePtr when computing addresses.
2394  return static_cast<ISD::MemIndexType>(LSBaseSDNodeBits.AddressingMode);
2395  }
2396  bool isIndexScaled() const {
2397  return (getIndexType() == ISD::SIGNED_SCALED) ||
2398  (getIndexType() == ISD::UNSIGNED_SCALED);
2399  }
2400  bool isIndexSigned() const {
2401  return (getIndexType() == ISD::SIGNED_SCALED) ||
2402  (getIndexType() == ISD::SIGNED_UNSCALED);
2403  }
2404 
2405  // In the both nodes address is Op1, mask is Op2:
2406  // MaskedGatherSDNode (Chain, passthru, mask, base, index, scale)
2407  // MaskedScatterSDNode (Chain, value, mask, base, index, scale)
2408  // Mask is a vector of i1 elements
2409  const SDValue &getBasePtr() const { return getOperand(3); }
2410  const SDValue &getIndex() const { return getOperand(4); }
2411  const SDValue &getMask() const { return getOperand(2); }
2412  const SDValue &getScale() const { return getOperand(5); }
2413 
2414  static bool classof(const SDNode *N) {
2415  return N->getOpcode() == ISD::MGATHER ||
2416  N->getOpcode() == ISD::MSCATTER;
2417  }
2418 };
2419 
2420 /// This class is used to represent an MGATHER node
2421 ///
2423 public:
2424  friend class SelectionDAG;
2425 
2426  MaskedGatherSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2427  EVT MemVT, MachineMemOperand *MMO,
2428  ISD::MemIndexType IndexType)
2429  : MaskedGatherScatterSDNode(ISD::MGATHER, Order, dl, VTs, MemVT, MMO,
2430  IndexType) {}
2431 
2432  const SDValue &getPassThru() const { return getOperand(1); }
2433 
2434  static bool classof(const SDNode *N) {
2435  return N->getOpcode() == ISD::MGATHER;
2436  }
2437 };
2438 
2439 /// This class is used to represent an MSCATTER node
2440 ///
2442 public:
2443  friend class SelectionDAG;
2444 
2445  MaskedScatterSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2446  EVT MemVT, MachineMemOperand *MMO,
2447  ISD::MemIndexType IndexType)
2448  : MaskedGatherScatterSDNode(ISD::MSCATTER, Order, dl, VTs, MemVT, MMO,
2449  IndexType) {}
2450 
2451  const SDValue &getValue() const { return getOperand(1); }
2452 
2453  static bool classof(const SDNode *N) {
2454  return N->getOpcode() == ISD::MSCATTER;
2455  }
2456 };
2457 
2458 /// An SDNode that represents everything that will be needed
2459 /// to construct a MachineInstr. These nodes are created during the
2460 /// instruction selection proper phase.
2461 ///
2462 /// Note that the only supported way to set the `memoperands` is by calling the
2463 /// `SelectionDAG::setNodeMemRefs` function as the memory management happens
2464 /// inside the DAG rather than in the node.
2465 class MachineSDNode : public SDNode {
2466 private:
2467  friend class SelectionDAG;
2468 
2469  MachineSDNode(unsigned Opc, unsigned Order, const DebugLoc &DL, SDVTList VTs)
2470  : SDNode(Opc, Order, DL, VTs) {}
2471 
2472  // We use a pointer union between a single `MachineMemOperand` pointer and
2473  // a pointer to an array of `MachineMemOperand` pointers. This is null when
2474  // the number of these is zero, the single pointer variant used when the
2475  // number is one, and the array is used for larger numbers.
2476  //
2477  // The array is allocated via the `SelectionDAG`'s allocator and so will
2478  // always live until the DAG is cleaned up and doesn't require ownership here.
2479  //
2480  // We can't use something simpler like `TinyPtrVector` here because `SDNode`
2481  // subclasses aren't managed in a conforming C++ manner. See the comments on
2482  // `SelectionDAG::MorphNodeTo` which details what all goes on, but the
2483  // constraint here is that these don't manage memory with their constructor or
2484  // destructor and can be initialized to a good state even if they start off
2485  // uninitialized.
2487 
2488  // Note that this could be folded into the above `MemRefs` member if doing so
2489  // is advantageous at some point. We don't need to store this in most cases.
2490  // However, at the moment this doesn't appear to make the allocation any
2491  // smaller and makes the code somewhat simpler to read.
2492  int NumMemRefs = 0;
2493 
2494 public:
2496 
2498  // Special case the common cases.
2499  if (NumMemRefs == 0)
2500  return {};
2501  if (NumMemRefs == 1)
2502  return makeArrayRef(MemRefs.getAddrOfPtr1(), 1);
2503 
2504  // Otherwise we have an actual array.
2505  return makeArrayRef(MemRefs.get<MachineMemOperand **>(), NumMemRefs);
2506  }
2507  mmo_iterator memoperands_begin() const { return memoperands().begin(); }
2508  mmo_iterator memoperands_end() const { return memoperands().end(); }
2509  bool memoperands_empty() const { return memoperands().empty(); }
2510 
2511  /// Clear out the memory reference descriptor list.
2512  void clearMemRefs() {
2513  MemRefs = nullptr;
2514  NumMemRefs = 0;
2515  }
2516 
2517  static bool classof(const SDNode *N) {
2518  return N->isMachineOpcode();
2519  }
2520 };
2521 
2522 class SDNodeIterator : public std::iterator<std::forward_iterator_tag,
2523  SDNode, ptrdiff_t> {
2524  const SDNode *Node;
2525  unsigned Operand;
2526 
2527  SDNodeIterator(const SDNode *N, unsigned Op) : Node(N), Operand(Op) {}
2528 
2529 public:
2530  bool operator==(const SDNodeIterator& x) const {
2531  return Operand == x.Operand;
2532  }
2533  bool operator!=(const SDNodeIterator& x) const { return !operator==(x); }
2534 
2535  pointer operator*() const {
2536  return Node->getOperand(Operand).getNode();
2537  }
2538  pointer operator->() const { return operator*(); }
2539 
2540  SDNodeIterator& operator++() { // Preincrement
2541  ++Operand;
2542  return *this;
2543  }
2544  SDNodeIterator operator++(int) { // Postincrement
2545  SDNodeIterator tmp = *this; ++*this; return tmp;
2546  }
2547  size_t operator-(SDNodeIterator Other) const {
2548  assert(Node == Other.Node &&
2549  "Cannot compare iterators of two different nodes!");
2550  return Operand - Other.Operand;
2551  }
2552 
2553  static SDNodeIterator begin(const SDNode *N) { return SDNodeIterator(N, 0); }
2554  static SDNodeIterator end (const SDNode *N) {
2555  return SDNodeIterator(N, N->getNumOperands());
2556  }
2557 
2558  unsigned getOperand() const { return Operand; }
2559  const SDNode *getNode() const { return Node; }
2560 };
2561 
2562 template <> struct GraphTraits<SDNode*> {
2563  using NodeRef = SDNode *;
2565 
2566  static NodeRef getEntryNode(SDNode *N) { return N; }
2567 
2569  return SDNodeIterator::begin(N);
2570  }
2571 
2573  return SDNodeIterator::end(N);
2574  }
2575 };
2576 
2577 /// A representation of the largest SDNode, for use in sizeof().
2578 ///
2579 /// This needs to be a union because the largest node differs on 32 bit systems
2580 /// with 4 and 8 byte pointer alignment, respectively.
2584 
2585 /// The SDNode class with the greatest alignment requirement.
2587 
2588 namespace ISD {
2589 
2590  /// Returns true if the specified node is a non-extending and unindexed load.
2591  inline bool isNormalLoad(const SDNode *N) {
2592  const LoadSDNode *Ld = dyn_cast<LoadSDNode>(N);
2593  return Ld && Ld->getExtensionType() == ISD::NON_EXTLOAD &&
2595  }
2596 
2597  /// Returns true if the specified node is a non-extending load.
2598  inline bool isNON_EXTLoad(const SDNode *N) {
2599  return isa<LoadSDNode>(N) &&
2600  cast<LoadSDNode>(N)->getExtensionType() == ISD::NON_EXTLOAD;
2601  }
2602 
2603  /// Returns true if the specified node is a EXTLOAD.
2604  inline bool isEXTLoad(const SDNode *N) {
2605  return isa<LoadSDNode>(N) &&
2606  cast<LoadSDNode>(N)->getExtensionType() == ISD::EXTLOAD;
2607  }
2608 
2609  /// Returns true if the specified node is a SEXTLOAD.
2610  inline bool isSEXTLoad(const SDNode *N) {
2611  return isa<LoadSDNode>(N) &&
2612  cast<LoadSDNode>(N)->getExtensionType() == ISD::SEXTLOAD;
2613  }
2614 
2615  /// Returns true if the specified node is a ZEXTLOAD.
2616  inline bool isZEXTLoad(const SDNode *N) {
2617  return isa<LoadSDNode>(N) &&
2618  cast<LoadSDNode>(N)->getExtensionType() == ISD::ZEXTLOAD;
2619  }
2620 
2621  /// Returns true if the specified node is an unindexed load.
2622  inline bool isUNINDEXEDLoad(const SDNode *N) {
2623  return isa<LoadSDNode>(N) &&
2624  cast<LoadSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
2625  }
2626 
2627  /// Returns true if the specified node is a non-truncating
2628  /// and unindexed store.
2629  inline bool isNormalStore(const SDNode *N) {
2630  const StoreSDNode *St = dyn_cast<StoreSDNode>(N);
2631  return St && !St->isTruncatingStore() &&
2633  }
2634 
2635  /// Returns true if the specified node is a non-truncating store.
2636  inline bool isNON_TRUNCStore(const SDNode *N) {
2637  return isa<StoreSDNode>(N) && !cast<StoreSDNode>(N)->isTruncatingStore();
2638  }
2639 
2640  /// Returns true if the specified node is a truncating store.
2641  inline bool isTRUNCStore(const SDNode *N) {
2642  return isa<StoreSDNode>(N) && cast<StoreSDNode>(N)->isTruncatingStore();
2643  }
2644 
2645  /// Returns true if the specified node is an unindexed store.
2646  inline bool isUNINDEXEDStore(const SDNode *N) {
2647  return isa<StoreSDNode>(N) &&
2648  cast<StoreSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
2649  }
2650 
2651  /// Attempt to match a unary predicate against a scalar/splat constant or
2652  /// every element of a constant BUILD_VECTOR.
2653  /// If AllowUndef is true, then UNDEF elements will pass nullptr to Match.
2656  bool AllowUndefs = false);
2657 
2658  /// Attempt to match a binary predicate against a pair of scalar/splat
2659  /// constants or every element of a pair of constant BUILD_VECTORs.
2660  /// If AllowUndef is true, then UNDEF elements will pass nullptr to Match.
2661  /// If AllowTypeMismatch is true then RetType + ArgTypes don't need to match.
2662  bool matchBinaryPredicate(
2663  SDValue LHS, SDValue RHS,
2665  bool AllowUndefs = false, bool AllowTypeMismatch = false);
2666 } // end namespace ISD
2667 
2668 } // end namespace llvm
2669 
2670 #endif // LLVM_CODEGEN_SELECTIONDAGNODES_H
ANNOTATION_LABEL - Represents a mid basic block label used by annotations.
Definition: ISDOpcodes.h:710
bool isMachineConstantPoolEntry() const
Iterator for directly iterating over the operand SDValue&#39;s.
void setAllowReciprocal(bool b)
void setAllowReassociation(bool b)
bool isInvariant() const
bool isUnordered() const
Returns true if this memory operation doesn&#39;t have any ordering constraints other than normal aliasin...
BUILTIN_OP_END - This must be the last enum value in this list.
Definition: ISDOpcodes.h:914
EVT getValueType() const
Return the ValueType of the referenced return value.
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
First const * getAddrOfPtr1() const
If the union is set to the first pointer type get an address pointing to it.
Definition: PointerUnion.h:209
Constrained versions of libm-equivalent floating point intrinsics.
Definition: ISDOpcodes.h:300
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
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...
bool isConstantSplat(SDValue Op, APInt &SplatVal)
If Op is a constant whose elements are all the same constant or undefined, return true and return the...
static bool classof(const SDNode *N)
bool isIndexed() const
Return true if this is a pre/post inc/dec load/store.
Atomic ordering constants.
MDNODE_SDNODE - This is a node that holdes an MDNode*, which is used to reference metadata in the IR...
Definition: ISDOpcodes.h:768
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:399
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
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:953
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)).
Val, Success, OUTCHAIN = ATOMIC_CMP_SWAP_WITH_SUCCESS(INCHAIN, ptr, cmp, swap) N.b.
Definition: ISDOpcodes.h:834
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:293
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.
block Block Frequency true
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.
T get() const
Returns the value of the specified pointer type.
Definition: PointerUnion.h:194
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
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)
unsigned getTargetFlags() const
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)
ConstantSDNode * isConstOrConstSplat(SDValue N, bool AllowUndefs=false, bool AllowTruncation=false)
Returns the SDNode if it is a constant splat BuildVector or constant int.
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:450
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
MaskedScatterSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemVT, MachineMemOperand *MMO, ISD::MemIndexType IndexType)
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.
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:842
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)
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:2099
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.
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
MemIndexType
MemIndexType enum - This enum defines how to interpret MGATHER/SCATTER&#39;s index parameter when calcula...
Definition: ISDOpcodes.h:969
unsigned getTargetFlags() const
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:1013
op_iterator op_begin() const
X = STRICT_FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type.
Definition: ISDOpcodes.h:331
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:359
bool isOneConstant(SDValue V)
Returns true if V is a constant integer one.
This corresponds to the llvm.lifetime.
Definition: ISDOpcodes.h:878
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 isSimple() const
Returns true if the memory operation is neither atomic or volatile.
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
MaskedGatherSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemVT, MachineMemOperand *MMO, ISD::MemIndexType IndexType)
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
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
static Optional< bool > isBigEndian(const SmallVector< int64_t, 4 > &ByteOffsets, int64_t FirstOffset)
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:988
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)
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
This is a base class used to represent MGATHER and MSCATTER nodes.
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:1145
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)
constexpr double e
Definition: MathExtras.h:57
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)
unsigned getTargetFlags() const
Val, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmp, swap) For double-word atomic operations: ValLo...
Definition: ISDOpcodes.h:828
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 isAtomic(Instruction *I)
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:782
uint64_t getAlignment() const
Return the minimum known alignment in bytes of the actual memory reference.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:40
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:704
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...
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:336
use_iterator(const use_iterator &I)
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.
bool isAtomic() const
Return true if the memory operation ordering is Unordered or higher.
ADDRSPACECAST - This operator converts between pointers of different address spaces.
Definition: ISDOpcodes.h:600
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:837
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
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
bool hasFPExcept() 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:921
unsigned getTargetFlags() const
void setNoNaNs(bool b)
Represents one node in the SelectionDAG.
bool isBitwiseNot(SDValue V, bool AllowUndefs=false)
Returns true if V is a bitwise not operation.
bool readMem() const
bool operator==(const SDNodeIterator &x) 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
A suitably aligned and sized character array member which can hold elements of any type...
Definition: AlignOf.h:48
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
bool matchBinaryPredicate(SDValue LHS, SDValue RHS, std::function< bool(ConstantSDNode *, ConstantSDNode *)> Match, bool AllowUndefs=false, bool AllowTypeMismatch=false)
Attempt to match a binary predicate against a pair of scalar/splat constants or every element of a pa...
void setTruncatingStore(bool Truncating)
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.
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:331
ISD::MemIndexType getIndexType() const
How is Index applied to BasePtr when computing addresses.
const SDValue & getValue() const
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:643
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
uint32_t Size
Definition: Profile.cpp:46
X = STRICT_FP_ROUND(Y, TRUNC) - Rounding &#39;Y&#39; from a larger floating point type down to the precision ...
Definition: ISDOpcodes.h:326
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.
SDValue peekThroughExtractSubvectors(SDValue V)
Return the non-extracted vector source operand of V if it exists.
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
MachineConstantPoolValue * getMachineCPVal() const
bool isUnordered() const
Returns true if the memory operation doesn&#39;t imply any ordering constraints on surrounding memory ope...
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.
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:73
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:808
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:1975
unsigned getNumOperands() const
bool isStrictFPOpcode()
Test if this node is a strict floating point pseudo-op.
static bool isVolatile(Instruction *Inst)
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:821
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)
TargetIndexSDNode(int Idx, EVT VT, int64_t Ofs, unsigned TF)
Val, OUTCHAIN = ATOMIC_LOAD(INCHAIN, ptr) This corresponds to "load atomic" instruction.
Definition: ISDOpcodes.h:817
const SDValue & getBasePtr() const
STRICT_FP_TO_[US]INT - Convert a floating point value to a signed or unsigned integer.
Definition: ISDOpcodes.h:310
const SDValue & getMask() const
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
unsigned getIROrder() const
MaskedGatherScatterSDNode(ISD::NodeType NodeTy, unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemVT, MachineMemOperand *MMO, ISD::MemIndexType IndexType)
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition: PointerUnion.h:156
void setFPExcept(bool b)
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:951
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:764
This class is used to represent ISD::LOAD nodes.