LLVM  14.0.0git
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"
33 #include "llvm/CodeGen/Register.h"
35 #include "llvm/IR/Constants.h"
36 #include "llvm/IR/DebugLoc.h"
37 #include "llvm/IR/Instruction.h"
38 #include "llvm/IR/Instructions.h"
39 #include "llvm/IR/Metadata.h"
40 #include "llvm/IR/Operator.h"
41 #include "llvm/Support/AlignOf.h"
43 #include "llvm/Support/Casting.h"
46 #include "llvm/Support/TypeSize.h"
47 #include <algorithm>
48 #include <cassert>
49 #include <climits>
50 #include <cstddef>
51 #include <cstdint>
52 #include <cstring>
53 #include <iterator>
54 #include <string>
55 #include <tuple>
56 
57 namespace llvm {
58 
59 class APInt;
60 class Constant;
61 template <typename T> struct DenseMapInfo;
62 class GlobalValue;
63 class MachineBasicBlock;
64 class MachineConstantPoolValue;
65 class MCSymbol;
66 class raw_ostream;
67 class SDNode;
68 class SelectionDAG;
69 class Type;
70 class Value;
71 
72 void checkForCycles(const SDNode *N, const SelectionDAG *DAG = nullptr,
73  bool force = false);
74 
75 /// This represents a list of ValueType's that has been intern'd by
76 /// a SelectionDAG. Instances of this simple value class are returned by
77 /// SelectionDAG::getVTList(...).
78 ///
79 struct SDVTList {
80  const EVT *VTs;
81  unsigned int NumVTs;
82 };
83 
84 namespace ISD {
85 
86  /// Node predicates
87 
88 /// If N is a BUILD_VECTOR or SPLAT_VECTOR node whose elements are all the
89 /// same constant or undefined, return true and return the constant value in
90 /// \p SplatValue.
91 bool isConstantSplatVector(const SDNode *N, APInt &SplatValue);
92 
93 /// Return true if the specified node is a BUILD_VECTOR or SPLAT_VECTOR where
94 /// all of the elements are ~0 or undef. If \p BuildVectorOnly is set to
95 /// true, it only checks BUILD_VECTOR.
97  bool BuildVectorOnly = false);
98 
99 /// Return true if the specified node is a BUILD_VECTOR or SPLAT_VECTOR where
100 /// all of the elements are 0 or undef. If \p BuildVectorOnly is set to true, it
101 /// only checks BUILD_VECTOR.
103  bool BuildVectorOnly = false);
104 
105 /// Return true if the specified node is a BUILD_VECTOR where all of the
106 /// elements are ~0 or undef.
107 bool isBuildVectorAllOnes(const SDNode *N);
108 
109 /// Return true if the specified node is a BUILD_VECTOR where all of the
110 /// elements are 0 or undef.
111 bool isBuildVectorAllZeros(const SDNode *N);
112 
113 /// Return true if the specified node is a BUILD_VECTOR node of all
114 /// ConstantSDNode or undef.
116 
117 /// Return true if the specified node is a BUILD_VECTOR node of all
118 /// ConstantFPSDNode or undef.
120 
121 /// Return true if the node has at least one operand and all operands of the
122 /// specified node are ISD::UNDEF.
123 bool allOperandsUndef(const SDNode *N);
124 
125 } // end namespace ISD
126 
127 //===----------------------------------------------------------------------===//
128 /// Unlike LLVM values, Selection DAG nodes may return multiple
129 /// values as the result of a computation. Many nodes return multiple values,
130 /// from loads (which define a token and a return value) to ADDC (which returns
131 /// a result and a carry value), to calls (which may return an arbitrary number
132 /// of values).
133 ///
134 /// As such, each use of a SelectionDAG computation must indicate the node that
135 /// computes it as well as which return value to use from that node. This pair
136 /// of information is represented with the SDValue value type.
137 ///
138 class SDValue {
139  friend struct DenseMapInfo<SDValue>;
140 
141  SDNode *Node = nullptr; // The node defining the value we are using.
142  unsigned ResNo = 0; // Which return value of the node we are using.
143 
144 public:
145  SDValue() = default;
146  SDValue(SDNode *node, unsigned resno);
147 
148  /// get the index which selects a specific result in the SDNode
149  unsigned getResNo() const { return ResNo; }
150 
151  /// get the SDNode which holds the desired result
152  SDNode *getNode() const { return Node; }
153 
154  /// set the SDNode
155  void setNode(SDNode *N) { Node = N; }
156 
157  inline SDNode *operator->() const { return Node; }
158 
159  bool operator==(const SDValue &O) const {
160  return Node == O.Node && ResNo == O.ResNo;
161  }
162  bool operator!=(const SDValue &O) const {
163  return !operator==(O);
164  }
165  bool operator<(const SDValue &O) const {
166  return std::tie(Node, ResNo) < std::tie(O.Node, O.ResNo);
167  }
168  explicit operator bool() const {
169  return Node != nullptr;
170  }
171 
172  SDValue getValue(unsigned R) const {
173  return SDValue(Node, R);
174  }
175 
176  /// Return true if this node is an operand of N.
177  bool isOperandOf(const SDNode *N) const;
178 
179  /// Return the ValueType of the referenced return value.
180  inline EVT getValueType() const;
181 
182  /// Return the simple ValueType of the referenced return value.
184  return getValueType().getSimpleVT();
185  }
186 
187  /// Returns the size of the value in bits.
188  ///
189  /// If the value type is a scalable vector type, the scalable property will
190  /// be set and the runtime size will be a positive integer multiple of the
191  /// base size.
193  return getValueType().getSizeInBits();
194  }
195 
198  }
199 
200  // Forwarding methods - These forward to the corresponding methods in SDNode.
201  inline unsigned getOpcode() const;
202  inline unsigned getNumOperands() const;
203  inline const SDValue &getOperand(unsigned i) const;
204  inline uint64_t getConstantOperandVal(unsigned i) const;
205  inline const APInt &getConstantOperandAPInt(unsigned i) const;
206  inline bool isTargetMemoryOpcode() const;
207  inline bool isTargetOpcode() const;
208  inline bool isMachineOpcode() const;
209  inline bool isUndef() const;
210  inline unsigned getMachineOpcode() const;
211  inline const DebugLoc &getDebugLoc() const;
212  inline void dump() const;
213  inline void dump(const SelectionDAG *G) const;
214  inline void dumpr() const;
215  inline void dumpr(const SelectionDAG *G) const;
216 
217  /// Return true if this operand (which must be a chain) reaches the
218  /// specified operand without crossing any side-effecting instructions.
219  /// In practice, this looks through token factors and non-volatile loads.
220  /// In order to remain efficient, this only
221  /// looks a couple of nodes in, it does not do an exhaustive search.
223  unsigned Depth = 2) const;
224 
225  /// Return true if there are no nodes using value ResNo of Node.
226  inline bool use_empty() const;
227 
228  /// Return true if there is exactly one node using value ResNo of Node.
229  inline bool hasOneUse() const;
230 };
231 
232 template<> struct DenseMapInfo<SDValue> {
233  static inline SDValue getEmptyKey() {
234  SDValue V;
235  V.ResNo = -1U;
236  return V;
237  }
238 
239  static inline SDValue getTombstoneKey() {
240  SDValue V;
241  V.ResNo = -2U;
242  return V;
243  }
244 
245  static unsigned getHashValue(const SDValue &Val) {
246  return ((unsigned)((uintptr_t)Val.getNode() >> 4) ^
247  (unsigned)((uintptr_t)Val.getNode() >> 9)) + Val.getResNo();
248  }
249 
250  static bool isEqual(const SDValue &LHS, const SDValue &RHS) {
251  return LHS == RHS;
252  }
253 };
254 
255 /// Allow casting operators to work directly on
256 /// SDValues as if they were SDNode*'s.
257 template<> struct simplify_type<SDValue> {
258  using SimpleType = SDNode *;
259 
261  return Val.getNode();
262  }
263 };
264 template<> struct simplify_type<const SDValue> {
265  using SimpleType = /*const*/ SDNode *;
266 
267  static SimpleType getSimplifiedValue(const SDValue &Val) {
268  return Val.getNode();
269  }
270 };
271 
272 /// Represents a use of a SDNode. This class holds an SDValue,
273 /// which records the SDNode being used and the result number, a
274 /// pointer to the SDNode using the value, and Next and Prev pointers,
275 /// which link together all the uses of an SDNode.
276 ///
277 class SDUse {
278  /// Val - The value being used.
279  SDValue Val;
280  /// User - The user of this value.
281  SDNode *User = nullptr;
282  /// Prev, Next - Pointers to the uses list of the SDNode referred by
283  /// this operand.
284  SDUse **Prev = nullptr;
285  SDUse *Next = nullptr;
286 
287 public:
288  SDUse() = default;
289  SDUse(const SDUse &U) = delete;
290  SDUse &operator=(const SDUse &) = delete;
291 
292  /// Normally SDUse will just implicitly convert to an SDValue that it holds.
293  operator const SDValue&() const { return Val; }
294 
295  /// If implicit conversion to SDValue doesn't work, the get() method returns
296  /// the SDValue.
297  const SDValue &get() const { return Val; }
298 
299  /// This returns the SDNode that contains this Use.
300  SDNode *getUser() { return User; }
301 
302  /// Get the next SDUse in the use list.
303  SDUse *getNext() const { return Next; }
304 
305  /// Convenience function for get().getNode().
306  SDNode *getNode() const { return Val.getNode(); }
307  /// Convenience function for get().getResNo().
308  unsigned getResNo() const { return Val.getResNo(); }
309  /// Convenience function for get().getValueType().
310  EVT getValueType() const { return Val.getValueType(); }
311 
312  /// Convenience function for get().operator==
313  bool operator==(const SDValue &V) const {
314  return Val == V;
315  }
316 
317  /// Convenience function for get().operator!=
318  bool operator!=(const SDValue &V) const {
319  return Val != V;
320  }
321 
322  /// Convenience function for get().operator<
323  bool operator<(const SDValue &V) const {
324  return Val < V;
325  }
326 
327 private:
328  friend class SelectionDAG;
329  friend class SDNode;
330  // TODO: unfriend HandleSDNode once we fix its operand handling.
331  friend class HandleSDNode;
332 
333  void setUser(SDNode *p) { User = p; }
334 
335  /// Remove this use from its existing use list, assign it the
336  /// given value, and add it to the new value's node's use list.
337  inline void set(const SDValue &V);
338  /// Like set, but only supports initializing a newly-allocated
339  /// SDUse with a non-null value.
340  inline void setInitial(const SDValue &V);
341  /// Like set, but only sets the Node portion of the value,
342  /// leaving the ResNo portion unmodified.
343  inline void setNode(SDNode *N);
344 
345  void addToList(SDUse **List) {
346  Next = *List;
347  if (Next) Next->Prev = &Next;
348  Prev = List;
349  *List = this;
350  }
351 
352  void removeFromList() {
353  *Prev = Next;
354  if (Next) Next->Prev = Prev;
355  }
356 };
357 
358 /// simplify_type specializations - Allow casting operators to work directly on
359 /// SDValues as if they were SDNode*'s.
360 template<> struct simplify_type<SDUse> {
361  using SimpleType = SDNode *;
362 
364  return Val.getNode();
365  }
366 };
367 
368 /// These are IR-level optimization flags that may be propagated to SDNodes.
369 /// TODO: This data structure should be shared by the IR optimizer and the
370 /// the backend.
371 struct SDNodeFlags {
372 private:
373  bool NoUnsignedWrap : 1;
374  bool NoSignedWrap : 1;
375  bool Exact : 1;
376  bool NoNaNs : 1;
377  bool NoInfs : 1;
378  bool NoSignedZeros : 1;
379  bool AllowReciprocal : 1;
380  bool AllowContract : 1;
381  bool ApproximateFuncs : 1;
382  bool AllowReassociation : 1;
383 
384  // We assume instructions do not raise floating-point exceptions by default,
385  // and only those marked explicitly may do so. We could choose to represent
386  // this via a positive "FPExcept" flags like on the MI level, but having a
387  // negative "NoFPExcept" flag here (that defaults to true) makes the flag
388  // intersection logic more straightforward.
389  bool NoFPExcept : 1;
390 
391 public:
392  /// Default constructor turns off all optimization flags.
394  : NoUnsignedWrap(false), NoSignedWrap(false), Exact(false), NoNaNs(false),
395  NoInfs(false), NoSignedZeros(false), AllowReciprocal(false),
396  AllowContract(false), ApproximateFuncs(false),
397  AllowReassociation(false), NoFPExcept(false) {}
398 
399  /// Propagate the fast-math-flags from an IR FPMathOperator.
400  void copyFMF(const FPMathOperator &FPMO) {
401  setNoNaNs(FPMO.hasNoNaNs());
402  setNoInfs(FPMO.hasNoInfs());
408  }
409 
410  // These are mutators for each flag.
411  void setNoUnsignedWrap(bool b) { NoUnsignedWrap = b; }
412  void setNoSignedWrap(bool b) { NoSignedWrap = b; }
413  void setExact(bool b) { Exact = b; }
414  void setNoNaNs(bool b) { NoNaNs = b; }
415  void setNoInfs(bool b) { NoInfs = b; }
416  void setNoSignedZeros(bool b) { NoSignedZeros = b; }
417  void setAllowReciprocal(bool b) { AllowReciprocal = b; }
418  void setAllowContract(bool b) { AllowContract = b; }
419  void setApproximateFuncs(bool b) { ApproximateFuncs = b; }
420  void setAllowReassociation(bool b) { AllowReassociation = b; }
421  void setNoFPExcept(bool b) { NoFPExcept = b; }
422 
423  // These are accessors for each flag.
424  bool hasNoUnsignedWrap() const { return NoUnsignedWrap; }
425  bool hasNoSignedWrap() const { return NoSignedWrap; }
426  bool hasExact() const { return Exact; }
427  bool hasNoNaNs() const { return NoNaNs; }
428  bool hasNoInfs() const { return NoInfs; }
429  bool hasNoSignedZeros() const { return NoSignedZeros; }
430  bool hasAllowReciprocal() const { return AllowReciprocal; }
431  bool hasAllowContract() const { return AllowContract; }
432  bool hasApproximateFuncs() const { return ApproximateFuncs; }
433  bool hasAllowReassociation() const { return AllowReassociation; }
434  bool hasNoFPExcept() const { return NoFPExcept; }
435 
436  /// Clear any flags in this flag set that aren't also set in Flags. All
437  /// flags will be cleared if Flags are undefined.
438  void intersectWith(const SDNodeFlags Flags) {
439  NoUnsignedWrap &= Flags.NoUnsignedWrap;
440  NoSignedWrap &= Flags.NoSignedWrap;
441  Exact &= Flags.Exact;
442  NoNaNs &= Flags.NoNaNs;
443  NoInfs &= Flags.NoInfs;
444  NoSignedZeros &= Flags.NoSignedZeros;
445  AllowReciprocal &= Flags.AllowReciprocal;
446  AllowContract &= Flags.AllowContract;
447  ApproximateFuncs &= Flags.ApproximateFuncs;
448  AllowReassociation &= Flags.AllowReassociation;
449  NoFPExcept &= Flags.NoFPExcept;
450  }
451 };
452 
453 /// Represents one node in the SelectionDAG.
454 ///
455 class SDNode : public FoldingSetNode, public ilist_node<SDNode> {
456 private:
457  /// The operation that this node performs.
458  int16_t NodeType;
459 
460 protected:
461  // We define a set of mini-helper classes to help us interpret the bits in our
462  // SubclassData. These are designed to fit within a uint16_t so they pack
463  // with NodeType.
464 
465 #if defined(_AIX) && (!defined(__GNUC__) || defined(__clang__))
466 // Except for GCC; by default, AIX compilers store bit-fields in 4-byte words
467 // and give the `pack` pragma push semantics.
468 #define BEGIN_TWO_BYTE_PACK() _Pragma("pack(2)")
469 #define END_TWO_BYTE_PACK() _Pragma("pack(pop)")
470 #else
471 #define BEGIN_TWO_BYTE_PACK()
472 #define END_TWO_BYTE_PACK()
473 #endif
474 
477  friend class SDNode;
478  friend class MemIntrinsicSDNode;
479  friend class MemSDNode;
480  friend class SelectionDAG;
481 
482  uint16_t HasDebugValue : 1;
483  uint16_t IsMemIntrinsic : 1;
484  uint16_t IsDivergent : 1;
485  };
486  enum { NumSDNodeBits = 3 };
487 
489  friend class ConstantSDNode;
490 
492 
493  uint16_t IsOpaque : 1;
494  };
495 
497  friend class MemSDNode;
498  friend class MemIntrinsicSDNode;
499  friend class AtomicSDNode;
500 
502 
503  uint16_t IsVolatile : 1;
504  uint16_t IsNonTemporal : 1;
505  uint16_t IsDereferenceable : 1;
506  uint16_t IsInvariant : 1;
507  };
509 
511  friend class LSBaseSDNode;
512  friend class VPLoadStoreSDNode;
513  friend class MaskedLoadStoreSDNode;
515  friend class VPGatherScatterSDNode;
516 
518 
519  // This storage is shared between disparate class hierarchies to hold an
520  // enumeration specific to the class hierarchy in use.
521  // LSBaseSDNode => enum ISD::MemIndexedMode
522  // VPLoadStoreBaseSDNode => enum ISD::MemIndexedMode
523  // MaskedLoadStoreBaseSDNode => enum ISD::MemIndexedMode
524  // VPGatherScatterSDNode => enum ISD::MemIndexType
525  // MaskedGatherScatterSDNode => enum ISD::MemIndexType
527  };
529 
531  friend class LoadSDNode;
532  friend class VPLoadSDNode;
533  friend class MaskedLoadSDNode;
534  friend class MaskedGatherSDNode;
535  friend class VPGatherSDNode;
536 
538 
539  uint16_t ExtTy : 2; // enum ISD::LoadExtType
540  uint16_t IsExpanding : 1;
541  };
542 
544  friend class StoreSDNode;
545  friend class VPStoreSDNode;
546  friend class MaskedStoreSDNode;
547  friend class MaskedScatterSDNode;
548  friend class VPScatterSDNode;
549 
551 
552  uint16_t IsTruncating : 1;
553  uint16_t IsCompressing : 1;
554  };
555 
556  union {
557  char RawSDNodeBits[sizeof(uint16_t)];
564  };
566 #undef BEGIN_TWO_BYTE_PACK
567 #undef END_TWO_BYTE_PACK
568 
569  // RawSDNodeBits must cover the entirety of the union. This means that all of
570  // the union's members must have size <= RawSDNodeBits. We write the RHS as
571  // "2" instead of sizeof(RawSDNodeBits) because MSVC can't handle the latter.
572  static_assert(sizeof(SDNodeBitfields) <= 2, "field too wide");
573  static_assert(sizeof(ConstantSDNodeBitfields) <= 2, "field too wide");
574  static_assert(sizeof(MemSDNodeBitfields) <= 2, "field too wide");
575  static_assert(sizeof(LSBaseSDNodeBitfields) <= 2, "field too wide");
576  static_assert(sizeof(LoadSDNodeBitfields) <= 2, "field too wide");
577  static_assert(sizeof(StoreSDNodeBitfields) <= 2, "field too wide");
578 
579 private:
580  friend class SelectionDAG;
581  // TODO: unfriend HandleSDNode once we fix its operand handling.
582  friend class HandleSDNode;
583 
584  /// Unique id per SDNode in the DAG.
585  int NodeId = -1;
586 
587  /// The values that are used by this operation.
588  SDUse *OperandList = nullptr;
589 
590  /// The types of the values this node defines. SDNode's may
591  /// define multiple values simultaneously.
592  const EVT *ValueList;
593 
594  /// List of uses for this SDNode.
595  SDUse *UseList = nullptr;
596 
597  /// The number of entries in the Operand/Value list.
598  unsigned short NumOperands = 0;
599  unsigned short NumValues;
600 
601  // The ordering of the SDNodes. It roughly corresponds to the ordering of the
602  // original LLVM instructions.
603  // This is used for turning off scheduling, because we'll forgo
604  // the normal scheduling algorithms and output the instructions according to
605  // this ordering.
606  unsigned IROrder;
607 
608  /// Source line information.
609  DebugLoc debugLoc;
610 
611  /// Return a pointer to the specified value type.
612  static const EVT *getValueTypeList(EVT VT);
613 
614  SDNodeFlags Flags;
615 
616 public:
617  /// Unique and persistent id per SDNode in the DAG.
618  /// Used for debug printing.
620 
621  //===--------------------------------------------------------------------===//
622  // Accessors
623  //
624 
625  /// Return the SelectionDAG opcode value for this node. For
626  /// pre-isel nodes (those for which isMachineOpcode returns false), these
627  /// are the opcode values in the ISD and <target>ISD namespaces. For
628  /// post-isel opcodes, see getMachineOpcode.
629  unsigned getOpcode() const { return (unsigned short)NodeType; }
630 
631  /// Test if this node has a target-specific opcode (in the
632  /// <target>ISD namespace).
633  bool isTargetOpcode() const { return NodeType >= ISD::BUILTIN_OP_END; }
634 
635  /// Test if this node has a target-specific opcode that may raise
636  /// FP exceptions (in the <target>ISD namespace and greater than
637  /// FIRST_TARGET_STRICTFP_OPCODE). Note that all target memory
638  /// opcode are currently automatically considered to possibly raise
639  /// FP exceptions as well.
640  bool isTargetStrictFPOpcode() const {
642  }
643 
644  /// Test if this node has a target-specific
645  /// memory-referencing opcode (in the <target>ISD namespace and
646  /// greater than FIRST_TARGET_MEMORY_OPCODE).
647  bool isTargetMemoryOpcode() const {
649  }
650 
651  /// Return true if the type of the node type undefined.
652  bool isUndef() const { return NodeType == ISD::UNDEF; }
653 
654  /// Test if this node is a memory intrinsic (with valid pointer information).
655  /// INTRINSIC_W_CHAIN and INTRINSIC_VOID nodes are sometimes created for
656  /// non-memory intrinsics (with chains) that are not really instances of
657  /// MemSDNode. For such nodes, we need some extra state to determine the
658  /// proper classof relationship.
659  bool isMemIntrinsic() const {
660  return (NodeType == ISD::INTRINSIC_W_CHAIN ||
662  SDNodeBits.IsMemIntrinsic;
663  }
664 
665  /// Test if this node is a strict floating point pseudo-op.
667  switch (NodeType) {
668  default:
669  return false;
672 #define DAG_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN) \
673  case ISD::STRICT_##DAGN:
674 #include "llvm/IR/ConstrainedOps.def"
675  return true;
676  }
677  }
678 
679  /// Test if this node has a post-isel opcode, directly
680  /// corresponding to a MachineInstr opcode.
681  bool isMachineOpcode() const { return NodeType < 0; }
682 
683  /// This may only be called if isMachineOpcode returns
684  /// true. It returns the MachineInstr opcode value that the node's opcode
685  /// corresponds to.
686  unsigned getMachineOpcode() const {
687  assert(isMachineOpcode() && "Not a MachineInstr opcode!");
688  return ~NodeType;
689  }
690 
691  bool getHasDebugValue() const { return SDNodeBits.HasDebugValue; }
692  void setHasDebugValue(bool b) { SDNodeBits.HasDebugValue = b; }
693 
694  bool isDivergent() const { return SDNodeBits.IsDivergent; }
695 
696  /// Return true if there are no uses of this node.
697  bool use_empty() const { return UseList == nullptr; }
698 
699  /// Return true if there is exactly one use of this node.
700  bool hasOneUse() const { return hasSingleElement(uses()); }
701 
702  /// Return the number of uses of this node. This method takes
703  /// time proportional to the number of uses.
704  size_t use_size() const { return std::distance(use_begin(), use_end()); }
705 
706  /// Return the unique node id.
707  int getNodeId() const { return NodeId; }
708 
709  /// Set unique node id.
710  void setNodeId(int Id) { NodeId = Id; }
711 
712  /// Return the node ordering.
713  unsigned getIROrder() const { return IROrder; }
714 
715  /// Set the node ordering.
716  void setIROrder(unsigned Order) { IROrder = Order; }
717 
718  /// Return the source location info.
719  const DebugLoc &getDebugLoc() const { return debugLoc; }
720 
721  /// Set source location info. Try to avoid this, putting
722  /// it in the constructor is preferable.
723  void setDebugLoc(DebugLoc dl) { debugLoc = std::move(dl); }
724 
725  /// This class provides iterator support for SDUse
726  /// operands that use a specific SDNode.
727  class use_iterator {
728  friend class SDNode;
729 
730  SDUse *Op = nullptr;
731 
732  explicit use_iterator(SDUse *op) : Op(op) {}
733 
734  public:
735  using iterator_category = std::forward_iterator_tag;
736  using value_type = SDUse;
737  using difference_type = std::ptrdiff_t;
738  using pointer = value_type *;
740 
741  use_iterator() = default;
743 
744  bool operator==(const use_iterator &x) const {
745  return Op == x.Op;
746  }
747  bool operator!=(const use_iterator &x) const {
748  return !operator==(x);
749  }
750 
751  /// Return true if this iterator is at the end of uses list.
752  bool atEnd() const { return Op == nullptr; }
753 
754  // Iterator traversal: forward iteration only.
755  use_iterator &operator++() { // Preincrement
756  assert(Op && "Cannot increment end iterator!");
757  Op = Op->getNext();
758  return *this;
759  }
760 
761  use_iterator operator++(int) { // Postincrement
762  use_iterator tmp = *this; ++*this; return tmp;
763  }
764 
765  /// Retrieve a pointer to the current user node.
766  SDNode *operator*() const {
767  assert(Op && "Cannot dereference end iterator!");
768  return Op->getUser();
769  }
770 
771  SDNode *operator->() const { return operator*(); }
772 
773  SDUse &getUse() const { return *Op; }
774 
775  /// Retrieve the operand # of this use in its user.
776  unsigned getOperandNo() const {
777  assert(Op && "Cannot dereference end iterator!");
778  return (unsigned)(Op - Op->getUser()->OperandList);
779  }
780  };
781 
782  /// Provide iteration support to walk over all uses of an SDNode.
784  return use_iterator(UseList);
785  }
786 
787  static use_iterator use_end() { return use_iterator(nullptr); }
788 
790  return make_range(use_begin(), use_end());
791  }
793  return make_range(use_begin(), use_end());
794  }
795 
796  /// Return true if there are exactly NUSES uses of the indicated value.
797  /// This method ignores uses of other values defined by this operation.
798  bool hasNUsesOfValue(unsigned NUses, unsigned Value) const;
799 
800  /// Return true if there are any use of the indicated value.
801  /// This method ignores uses of other values defined by this operation.
802  bool hasAnyUseOfValue(unsigned Value) const;
803 
804  /// Return true if this node is the only use of N.
805  bool isOnlyUserOf(const SDNode *N) const;
806 
807  /// Return true if this node is an operand of N.
808  bool isOperandOf(const SDNode *N) const;
809 
810  /// Return true if this node is a predecessor of N.
811  /// NOTE: Implemented on top of hasPredecessor and every bit as
812  /// expensive. Use carefully.
813  bool isPredecessorOf(const SDNode *N) const {
814  return N->hasPredecessor(this);
815  }
816 
817  /// Return true if N is a predecessor of this node.
818  /// N is either an operand of this node, or can be reached by recursively
819  /// traversing up the operands.
820  /// NOTE: This is an expensive method. Use it carefully.
821  bool hasPredecessor(const SDNode *N) const;
822 
823  /// Returns true if N is a predecessor of any node in Worklist. This
824  /// helper keeps Visited and Worklist sets externally to allow unions
825  /// searches to be performed in parallel, caching of results across
826  /// queries and incremental addition to Worklist. Stops early if N is
827  /// found but will resume. Remember to clear Visited and Worklists
828  /// if DAG changes. MaxSteps gives a maximum number of nodes to visit before
829  /// giving up. The TopologicalPrune flag signals that positive NodeIds are
830  /// topologically ordered (Operands have strictly smaller node id) and search
831  /// can be pruned leveraging this.
832  static bool hasPredecessorHelper(const SDNode *N,
835  unsigned int MaxSteps = 0,
836  bool TopologicalPrune = false) {
837  SmallVector<const SDNode *, 8> DeferredNodes;
838  if (Visited.count(N))
839  return true;
840 
841  // Node Id's are assigned in three places: As a topological
842  // ordering (> 0), during legalization (results in values set to
843  // 0), new nodes (set to -1). If N has a topolgical id then we
844  // know that all nodes with ids smaller than it cannot be
845  // successors and we need not check them. Filter out all node
846  // that can't be matches. We add them to the worklist before exit
847  // in case of multiple calls. Note that during selection the topological id
848  // may be violated if a node's predecessor is selected before it. We mark
849  // this at selection negating the id of unselected successors and
850  // restricting topological pruning to positive ids.
851 
852  int NId = N->getNodeId();
853  // If we Invalidated the Id, reconstruct original NId.
854  if (NId < -1)
855  NId = -(NId + 1);
856 
857  bool Found = false;
858  while (!Worklist.empty()) {
859  const SDNode *M = Worklist.pop_back_val();
860  int MId = M->getNodeId();
861  if (TopologicalPrune && M->getOpcode() != ISD::TokenFactor && (NId > 0) &&
862  (MId > 0) && (MId < NId)) {
863  DeferredNodes.push_back(M);
864  continue;
865  }
866  for (const SDValue &OpV : M->op_values()) {
867  SDNode *Op = OpV.getNode();
868  if (Visited.insert(Op).second)
869  Worklist.push_back(Op);
870  if (Op == N)
871  Found = true;
872  }
873  if (Found)
874  break;
875  if (MaxSteps != 0 && Visited.size() >= MaxSteps)
876  break;
877  }
878  // Push deferred nodes back on worklist.
879  Worklist.append(DeferredNodes.begin(), DeferredNodes.end());
880  // If we bailed early, conservatively return found.
881  if (MaxSteps != 0 && Visited.size() >= MaxSteps)
882  return true;
883  return Found;
884  }
885 
886  /// Return true if all the users of N are contained in Nodes.
887  /// NOTE: Requires at least one match, but doesn't require them all.
888  static bool areOnlyUsersOf(ArrayRef<const SDNode *> Nodes, const SDNode *N);
889 
890  /// Return the number of values used by this operation.
891  unsigned getNumOperands() const { return NumOperands; }
892 
893  /// Return the maximum number of operands that a SDNode can hold.
894  static constexpr size_t getMaxNumOperands() {
895  return std::numeric_limits<decltype(SDNode::NumOperands)>::max();
896  }
897 
898  /// Helper method returns the integer value of a ConstantSDNode operand.
899  inline uint64_t getConstantOperandVal(unsigned Num) const;
900 
901  /// Helper method returns the APInt of a ConstantSDNode operand.
902  inline const APInt &getConstantOperandAPInt(unsigned Num) const;
903 
904  const SDValue &getOperand(unsigned Num) const {
905  assert(Num < NumOperands && "Invalid child # of SDNode!");
906  return OperandList[Num];
907  }
908 
909  using op_iterator = SDUse *;
910 
911  op_iterator op_begin() const { return OperandList; }
912  op_iterator op_end() const { return OperandList+NumOperands; }
913  ArrayRef<SDUse> ops() const { return makeArrayRef(op_begin(), op_end()); }
914 
915  /// Iterator for directly iterating over the operand SDValue's.
917  : iterator_adaptor_base<value_op_iterator, op_iterator,
918  std::random_access_iterator_tag, SDValue,
919  ptrdiff_t, value_op_iterator *,
920  value_op_iterator *> {
921  explicit value_op_iterator(SDUse *U = nullptr)
922  : iterator_adaptor_base(U) {}
923 
924  const SDValue &operator*() const { return I->get(); }
925  };
926 
930  }
931 
932  SDVTList getVTList() const {
933  SDVTList X = { ValueList, NumValues };
934  return X;
935  }
936 
937  /// If this node has a glue operand, return the node
938  /// to which the glue operand points. Otherwise return NULL.
939  SDNode *getGluedNode() const {
940  if (getNumOperands() != 0 &&
942  return getOperand(getNumOperands()-1).getNode();
943  return nullptr;
944  }
945 
946  /// If this node has a glue value with a user, return
947  /// the user (there is at most one). Otherwise return NULL.
948  SDNode *getGluedUser() const {
949  for (use_iterator UI = use_begin(), UE = use_end(); UI != UE; ++UI)
950  if (UI.getUse().get().getValueType() == MVT::Glue)
951  return *UI;
952  return nullptr;
953  }
954 
955  SDNodeFlags getFlags() const { return Flags; }
956  void setFlags(SDNodeFlags NewFlags) { Flags = NewFlags; }
957 
958  /// Clear any flags in this node that aren't also set in Flags.
959  /// If Flags is not in a defined state then this has no effect.
960  void intersectFlagsWith(const SDNodeFlags Flags);
961 
962  /// Return the number of values defined/returned by this operator.
963  unsigned getNumValues() const { return NumValues; }
964 
965  /// Return the type of a specified result.
966  EVT getValueType(unsigned ResNo) const {
967  assert(ResNo < NumValues && "Illegal result number!");
968  return ValueList[ResNo];
969  }
970 
971  /// Return the type of a specified result as a simple type.
972  MVT getSimpleValueType(unsigned ResNo) const {
973  return getValueType(ResNo).getSimpleVT();
974  }
975 
976  /// Returns MVT::getSizeInBits(getValueType(ResNo)).
977  ///
978  /// If the value type is a scalable vector type, the scalable property will
979  /// be set and the runtime size will be a positive integer multiple of the
980  /// base size.
981  TypeSize getValueSizeInBits(unsigned ResNo) const {
982  return getValueType(ResNo).getSizeInBits();
983  }
984 
985  using value_iterator = const EVT *;
986 
987  value_iterator value_begin() const { return ValueList; }
988  value_iterator value_end() const { return ValueList+NumValues; }
991  }
992 
993  /// Return the opcode of this operation for printing.
994  std::string getOperationName(const SelectionDAG *G = nullptr) const;
995  static const char* getIndexedModeName(ISD::MemIndexedMode AM);
996  void print_types(raw_ostream &OS, const SelectionDAG *G) const;
997  void print_details(raw_ostream &OS, const SelectionDAG *G) const;
998  void print(raw_ostream &OS, const SelectionDAG *G = nullptr) const;
999  void printr(raw_ostream &OS, const SelectionDAG *G = nullptr) const;
1000 
1001  /// Print a SelectionDAG node and all children down to
1002  /// the leaves. The given SelectionDAG allows target-specific nodes
1003  /// to be printed in human-readable form. Unlike printr, this will
1004  /// print the whole DAG, including children that appear multiple
1005  /// times.
1006  ///
1007  void printrFull(raw_ostream &O, const SelectionDAG *G = nullptr) const;
1008 
1009  /// Print a SelectionDAG node and children up to
1010  /// depth "depth." The given SelectionDAG allows target-specific
1011  /// nodes to be printed in human-readable form. Unlike printr, this
1012  /// will print children that appear multiple times wherever they are
1013  /// used.
1014  ///
1015  void printrWithDepth(raw_ostream &O, const SelectionDAG *G = nullptr,
1016  unsigned depth = 100) const;
1017 
1018  /// Dump this node, for debugging.
1019  void dump() const;
1020 
1021  /// Dump (recursively) this node and its use-def subgraph.
1022  void dumpr() const;
1023 
1024  /// Dump this node, for debugging.
1025  /// The given SelectionDAG allows target-specific nodes to be printed
1026  /// in human-readable form.
1027  void dump(const SelectionDAG *G) const;
1028 
1029  /// Dump (recursively) this node and its use-def subgraph.
1030  /// The given SelectionDAG allows target-specific nodes to be printed
1031  /// in human-readable form.
1032  void dumpr(const SelectionDAG *G) const;
1033 
1034  /// printrFull to dbgs(). The given SelectionDAG allows
1035  /// target-specific nodes to be printed in human-readable form.
1036  /// Unlike dumpr, this will print the whole DAG, including children
1037  /// that appear multiple times.
1038  void dumprFull(const SelectionDAG *G = nullptr) const;
1039 
1040  /// printrWithDepth to dbgs(). The given
1041  /// SelectionDAG allows target-specific nodes to be printed in
1042  /// human-readable form. Unlike dumpr, this will print children
1043  /// that appear multiple times wherever they are used.
1044  ///
1045  void dumprWithDepth(const SelectionDAG *G = nullptr,
1046  unsigned depth = 100) const;
1047 
1048  /// Gather unique data for the node.
1049  void Profile(FoldingSetNodeID &ID) const;
1050 
1051  /// This method should only be used by the SDUse class.
1052  void addUse(SDUse &U) { U.addToList(&UseList); }
1053 
1054 protected:
1055  static SDVTList getSDVTList(EVT VT) {
1056  SDVTList Ret = { getValueTypeList(VT), 1 };
1057  return Ret;
1058  }
1059 
1060  /// Create an SDNode.
1061  ///
1062  /// SDNodes are created without any operands, and never own the operand
1063  /// storage. To add operands, see SelectionDAG::createOperands.
1064  SDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs)
1065  : NodeType(Opc), ValueList(VTs.VTs), NumValues(VTs.NumVTs),
1066  IROrder(Order), debugLoc(std::move(dl)) {
1067  memset(&RawSDNodeBits, 0, sizeof(RawSDNodeBits));
1068  assert(debugLoc.hasTrivialDestructor() && "Expected trivial destructor");
1069  assert(NumValues == VTs.NumVTs &&
1070  "NumValues wasn't wide enough for its operands!");
1071  }
1072 
1073  /// Release the operands and set this node to have zero operands.
1074  void DropOperands();
1075 };
1076 
1077 /// Wrapper class for IR location info (IR ordering and DebugLoc) to be passed
1078 /// into SDNode creation functions.
1079 /// When an SDNode is created from the DAGBuilder, the DebugLoc is extracted
1080 /// from the original Instruction, and IROrder is the ordinal position of
1081 /// the instruction.
1082 /// When an SDNode is created after the DAG is being built, both DebugLoc and
1083 /// the IROrder are propagated from the original SDNode.
1084 /// So SDLoc class provides two constructors besides the default one, one to
1085 /// be used by the DAGBuilder, the other to be used by others.
1086 class SDLoc {
1087 private:
1088  DebugLoc DL;
1089  int IROrder = 0;
1090 
1091 public:
1092  SDLoc() = default;
1093  SDLoc(const SDNode *N) : DL(N->getDebugLoc()), IROrder(N->getIROrder()) {}
1094  SDLoc(const SDValue V) : SDLoc(V.getNode()) {}
1095  SDLoc(const Instruction *I, int Order) : IROrder(Order) {
1096  assert(Order >= 0 && "bad IROrder");
1097  if (I)
1098  DL = I->getDebugLoc();
1099  }
1100 
1101  unsigned getIROrder() const { return IROrder; }
1102  const DebugLoc &getDebugLoc() const { return DL; }
1103 };
1104 
1105 // Define inline functions from the SDValue class.
1106 
1107 inline SDValue::SDValue(SDNode *node, unsigned resno)
1108  : Node(node), ResNo(resno) {
1109  // Explicitly check for !ResNo to avoid use-after-free, because there are
1110  // callers that use SDValue(N, 0) with a deleted N to indicate successful
1111  // combines.
1112  assert((!Node || !ResNo || ResNo < Node->getNumValues()) &&
1113  "Invalid result number for the given node!");
1114  assert(ResNo < -2U && "Cannot use result numbers reserved for DenseMaps.");
1115 }
1116 
1117 inline unsigned SDValue::getOpcode() const {
1118  return Node->getOpcode();
1119 }
1120 
1121 inline EVT SDValue::getValueType() const {
1122  return Node->getValueType(ResNo);
1123 }
1124 
1125 inline unsigned SDValue::getNumOperands() const {
1126  return Node->getNumOperands();
1127 }
1128 
1129 inline const SDValue &SDValue::getOperand(unsigned i) const {
1130  return Node->getOperand(i);
1131 }
1132 
1134  return Node->getConstantOperandVal(i);
1135 }
1136 
1137 inline const APInt &SDValue::getConstantOperandAPInt(unsigned i) const {
1138  return Node->getConstantOperandAPInt(i);
1139 }
1140 
1141 inline bool SDValue::isTargetOpcode() const {
1142  return Node->isTargetOpcode();
1143 }
1144 
1145 inline bool SDValue::isTargetMemoryOpcode() const {
1146  return Node->isTargetMemoryOpcode();
1147 }
1148 
1149 inline bool SDValue::isMachineOpcode() const {
1150  return Node->isMachineOpcode();
1151 }
1152 
1153 inline unsigned SDValue::getMachineOpcode() const {
1154  return Node->getMachineOpcode();
1155 }
1156 
1157 inline bool SDValue::isUndef() const {
1158  return Node->isUndef();
1159 }
1160 
1161 inline bool SDValue::use_empty() const {
1162  return !Node->hasAnyUseOfValue(ResNo);
1163 }
1164 
1165 inline bool SDValue::hasOneUse() const {
1166  return Node->hasNUsesOfValue(1, ResNo);
1167 }
1168 
1169 inline const DebugLoc &SDValue::getDebugLoc() const {
1170  return Node->getDebugLoc();
1171 }
1172 
1173 inline void SDValue::dump() const {
1174  return Node->dump();
1175 }
1176 
1177 inline void SDValue::dump(const SelectionDAG *G) const {
1178  return Node->dump(G);
1179 }
1180 
1181 inline void SDValue::dumpr() const {
1182  return Node->dumpr();
1183 }
1184 
1185 inline void SDValue::dumpr(const SelectionDAG *G) const {
1186  return Node->dumpr(G);
1187 }
1188 
1189 // Define inline functions from the SDUse class.
1190 
1191 inline void SDUse::set(const SDValue &V) {
1192  if (Val.getNode()) removeFromList();
1193  Val = V;
1194  if (V.getNode()) V.getNode()->addUse(*this);
1195 }
1196 
1197 inline void SDUse::setInitial(const SDValue &V) {
1198  Val = V;
1199  V.getNode()->addUse(*this);
1200 }
1201 
1202 inline void SDUse::setNode(SDNode *N) {
1203  if (Val.getNode()) removeFromList();
1204  Val.setNode(N);
1205  if (N) N->addUse(*this);
1206 }
1207 
1208 /// This class is used to form a handle around another node that
1209 /// is persistent and is updated across invocations of replaceAllUsesWith on its
1210 /// operand. This node should be directly created by end-users and not added to
1211 /// the AllNodes list.
1212 class HandleSDNode : public SDNode {
1213  SDUse Op;
1214 
1215 public:
1217  : SDNode(ISD::HANDLENODE, 0, DebugLoc(), getSDVTList(MVT::Other)) {
1218  // HandleSDNodes are never inserted into the DAG, so they won't be
1219  // auto-numbered. Use ID 65535 as a sentinel.
1220  PersistentId = 0xffff;
1221 
1222  // Manually set up the operand list. This node type is special in that it's
1223  // always stack allocated and SelectionDAG does not manage its operands.
1224  // TODO: This should either (a) not be in the SDNode hierarchy, or (b) not
1225  // be so special.
1226  Op.setUser(this);
1227  Op.setInitial(X);
1228  NumOperands = 1;
1229  OperandList = &Op;
1230  }
1231  ~HandleSDNode();
1232 
1233  const SDValue &getValue() const { return Op; }
1234 };
1235 
1236 class AddrSpaceCastSDNode : public SDNode {
1237 private:
1238  unsigned SrcAddrSpace;
1239  unsigned DestAddrSpace;
1240 
1241 public:
1242  AddrSpaceCastSDNode(unsigned Order, const DebugLoc &dl, EVT VT,
1243  unsigned SrcAS, unsigned DestAS);
1244 
1245  unsigned getSrcAddressSpace() const { return SrcAddrSpace; }
1246  unsigned getDestAddressSpace() const { return DestAddrSpace; }
1247 
1248  static bool classof(const SDNode *N) {
1249  return N->getOpcode() == ISD::ADDRSPACECAST;
1250  }
1251 };
1252 
1253 /// This is an abstract virtual class for memory operations.
1254 class MemSDNode : public SDNode {
1255 private:
1256  // VT of in-memory value.
1257  EVT MemoryVT;
1258 
1259 protected:
1260  /// Memory reference information.
1262 
1263 public:
1264  MemSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTs,
1265  EVT memvt, MachineMemOperand *MMO);
1266 
1267  bool readMem() const { return MMO->isLoad(); }
1268  bool writeMem() const { return MMO->isStore(); }
1269 
1270  /// Returns alignment and volatility of the memory access
1271  Align getOriginalAlign() const { return MMO->getBaseAlign(); }
1272  Align getAlign() const { return MMO->getAlign(); }
1273  // FIXME: Remove once transition to getAlign is over.
1274  unsigned getAlignment() const { return MMO->getAlign().value(); }
1275 
1276  /// Return the SubclassData value, without HasDebugValue. This contains an
1277  /// encoding of the volatile flag, as well as bits used by subclasses. This
1278  /// function should only be used to compute a FoldingSetNodeID value.
1279  /// The HasDebugValue bit is masked out because CSE map needs to match
1280  /// nodes with debug info with nodes without debug info. Same is about
1281  /// isDivergent bit.
1282  unsigned getRawSubclassData() const {
1283  uint16_t Data;
1284  union {
1285  char RawSDNodeBits[sizeof(uint16_t)];
1287  };
1288  memcpy(&RawSDNodeBits, &this->RawSDNodeBits, sizeof(this->RawSDNodeBits));
1289  SDNodeBits.HasDebugValue = 0;
1290  SDNodeBits.IsDivergent = false;
1291  memcpy(&Data, &RawSDNodeBits, sizeof(RawSDNodeBits));
1292  return Data;
1293  }
1294 
1295  bool isVolatile() const { return MemSDNodeBits.IsVolatile; }
1296  bool isNonTemporal() const { return MemSDNodeBits.IsNonTemporal; }
1297  bool isDereferenceable() const { return MemSDNodeBits.IsDereferenceable; }
1298  bool isInvariant() const { return MemSDNodeBits.IsInvariant; }
1299 
1300  // Returns the offset from the location of the access.
1301  int64_t getSrcValueOffset() const { return MMO->getOffset(); }
1302 
1303  /// Returns the AA info that describes the dereference.
1304  AAMDNodes getAAInfo() const { return MMO->getAAInfo(); }
1305 
1306  /// Returns the Ranges that describes the dereference.
1307  const MDNode *getRanges() const { return MMO->getRanges(); }
1308 
1309  /// Returns the synchronization scope ID for this memory operation.
1311 
1312  /// Return the atomic ordering requirements for this memory operation. For
1313  /// cmpxchg atomic operations, return the atomic ordering requirements when
1314  /// store occurs.
1316  return MMO->getSuccessOrdering();
1317  }
1318 
1319  /// Return a single atomic ordering that is at least as strong as both the
1320  /// success and failure orderings for an atomic operation. (For operations
1321  /// other than cmpxchg, this is equivalent to getSuccessOrdering().)
1323 
1324  /// Return true if the memory operation ordering is Unordered or higher.
1325  bool isAtomic() const { return MMO->isAtomic(); }
1326 
1327  /// Returns true if the memory operation doesn't imply any ordering
1328  /// constraints on surrounding memory operations beyond the normal memory
1329  /// aliasing rules.
1330  bool isUnordered() const { return MMO->isUnordered(); }
1331 
1332  /// Returns true if the memory operation is neither atomic or volatile.
1333  bool isSimple() const { return !isAtomic() && !isVolatile(); }
1334 
1335  /// Return the type of the in-memory value.
1336  EVT getMemoryVT() const { return MemoryVT; }
1337 
1338  /// Return a MachineMemOperand object describing the memory
1339  /// reference performed by operation.
1340  MachineMemOperand *getMemOperand() const { return MMO; }
1341 
1343  return MMO->getPointerInfo();
1344  }
1345 
1346  /// Return the address space for the associated pointer
1347  unsigned getAddressSpace() const {
1348  return getPointerInfo().getAddrSpace();
1349  }
1350 
1351  /// Update this MemSDNode's MachineMemOperand information
1352  /// to reflect the alignment of NewMMO, if it has a greater alignment.
1353  /// This must only be used when the new alignment applies to all users of
1354  /// this MachineMemOperand.
1355  void refineAlignment(const MachineMemOperand *NewMMO) {
1356  MMO->refineAlignment(NewMMO);
1357  }
1358 
1359  const SDValue &getChain() const { return getOperand(0); }
1360 
1361  const SDValue &getBasePtr() const {
1362  switch (getOpcode()) {
1363  case ISD::STORE:
1364  case ISD::VP_STORE:
1365  case ISD::MSTORE:
1366  case ISD::VP_SCATTER:
1367  return getOperand(2);
1368  case ISD::MGATHER:
1369  case ISD::MSCATTER:
1370  return getOperand(3);
1371  default:
1372  return getOperand(1);
1373  }
1374  }
1375 
1376  // Methods to support isa and dyn_cast
1377  static bool classof(const SDNode *N) {
1378  // For some targets, we lower some target intrinsics to a MemIntrinsicNode
1379  // with either an intrinsic or a target opcode.
1380  switch (N->getOpcode()) {
1381  case ISD::LOAD:
1382  case ISD::STORE:
1383  case ISD::PREFETCH:
1384  case ISD::ATOMIC_CMP_SWAP:
1386  case ISD::ATOMIC_SWAP:
1387  case ISD::ATOMIC_LOAD_ADD:
1388  case ISD::ATOMIC_LOAD_SUB:
1389  case ISD::ATOMIC_LOAD_AND:
1390  case ISD::ATOMIC_LOAD_CLR:
1391  case ISD::ATOMIC_LOAD_OR:
1392  case ISD::ATOMIC_LOAD_XOR:
1393  case ISD::ATOMIC_LOAD_NAND:
1394  case ISD::ATOMIC_LOAD_MIN:
1395  case ISD::ATOMIC_LOAD_MAX:
1396  case ISD::ATOMIC_LOAD_UMIN:
1397  case ISD::ATOMIC_LOAD_UMAX:
1398  case ISD::ATOMIC_LOAD_FADD:
1399  case ISD::ATOMIC_LOAD_FSUB:
1400  case ISD::ATOMIC_LOAD:
1401  case ISD::ATOMIC_STORE:
1402  case ISD::MLOAD:
1403  case ISD::MSTORE:
1404  case ISD::MGATHER:
1405  case ISD::MSCATTER:
1406  case ISD::VP_LOAD:
1407  case ISD::VP_STORE:
1408  case ISD::VP_GATHER:
1409  case ISD::VP_SCATTER:
1410  return true;
1411  default:
1412  return N->isMemIntrinsic() || N->isTargetMemoryOpcode();
1413  }
1414  }
1415 };
1416 
1417 /// This is an SDNode representing atomic operations.
1418 class AtomicSDNode : public MemSDNode {
1419 public:
1420  AtomicSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTL,
1421  EVT MemVT, MachineMemOperand *MMO)
1422  : MemSDNode(Opc, Order, dl, VTL, MemVT, MMO) {
1423  assert(((Opc != ISD::ATOMIC_LOAD && Opc != ISD::ATOMIC_STORE) ||
1424  MMO->isAtomic()) && "then why are we using an AtomicSDNode?");
1425  }
1426 
1427  const SDValue &getBasePtr() const { return getOperand(1); }
1428  const SDValue &getVal() const { return getOperand(2); }
1429 
1430  /// Returns true if this SDNode represents cmpxchg atomic operation, false
1431  /// otherwise.
1432  bool isCompareAndSwap() const {
1433  unsigned Op = getOpcode();
1434  return Op == ISD::ATOMIC_CMP_SWAP ||
1436  }
1437 
1438  /// For cmpxchg atomic operations, return the atomic ordering requirements
1439  /// when store does not occur.
1441  assert(isCompareAndSwap() && "Must be cmpxchg operation");
1442  return MMO->getFailureOrdering();
1443  }
1444 
1445  // Methods to support isa and dyn_cast
1446  static bool classof(const SDNode *N) {
1447  return N->getOpcode() == ISD::ATOMIC_CMP_SWAP ||
1448  N->getOpcode() == ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS ||
1449  N->getOpcode() == ISD::ATOMIC_SWAP ||
1450  N->getOpcode() == ISD::ATOMIC_LOAD_ADD ||
1451  N->getOpcode() == ISD::ATOMIC_LOAD_SUB ||
1452  N->getOpcode() == ISD::ATOMIC_LOAD_AND ||
1453  N->getOpcode() == ISD::ATOMIC_LOAD_CLR ||
1454  N->getOpcode() == ISD::ATOMIC_LOAD_OR ||
1455  N->getOpcode() == ISD::ATOMIC_LOAD_XOR ||
1456  N->getOpcode() == ISD::ATOMIC_LOAD_NAND ||
1457  N->getOpcode() == ISD::ATOMIC_LOAD_MIN ||
1458  N->getOpcode() == ISD::ATOMIC_LOAD_MAX ||
1459  N->getOpcode() == ISD::ATOMIC_LOAD_UMIN ||
1460  N->getOpcode() == ISD::ATOMIC_LOAD_UMAX ||
1461  N->getOpcode() == ISD::ATOMIC_LOAD_FADD ||
1462  N->getOpcode() == ISD::ATOMIC_LOAD_FSUB ||
1463  N->getOpcode() == ISD::ATOMIC_LOAD ||
1464  N->getOpcode() == ISD::ATOMIC_STORE;
1465  }
1466 };
1467 
1468 /// This SDNode is used for target intrinsics that touch
1469 /// memory and need an associated MachineMemOperand. Its opcode may be
1470 /// INTRINSIC_VOID, INTRINSIC_W_CHAIN, PREFETCH, or a target-specific opcode
1471 /// with a value not less than FIRST_TARGET_MEMORY_OPCODE.
1473 public:
1474  MemIntrinsicSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl,
1475  SDVTList VTs, EVT MemoryVT, MachineMemOperand *MMO)
1476  : MemSDNode(Opc, Order, dl, VTs, MemoryVT, MMO) {
1477  SDNodeBits.IsMemIntrinsic = true;
1478  }
1479 
1480  // Methods to support isa and dyn_cast
1481  static bool classof(const SDNode *N) {
1482  // We lower some target intrinsics to their target opcode
1483  // early a node with a target opcode can be of this class
1484  return N->isMemIntrinsic() ||
1485  N->getOpcode() == ISD::PREFETCH ||
1486  N->isTargetMemoryOpcode();
1487  }
1488 };
1489 
1490 /// This SDNode is used to implement the code generator
1491 /// support for the llvm IR shufflevector instruction. It combines elements
1492 /// from two input vectors into a new input vector, with the selection and
1493 /// ordering of elements determined by an array of integers, referred to as
1494 /// the shuffle mask. For input vectors of width N, mask indices of 0..N-1
1495 /// refer to elements from the LHS input, and indices from N to 2N-1 the RHS.
1496 /// An index of -1 is treated as undef, such that the code generator may put
1497 /// any value in the corresponding element of the result.
1498 class ShuffleVectorSDNode : public SDNode {
1499  // The memory for Mask is owned by the SelectionDAG's OperandAllocator, and
1500  // is freed when the SelectionDAG object is destroyed.
1501  const int *Mask;
1502 
1503 protected:
1504  friend class SelectionDAG;
1505 
1506  ShuffleVectorSDNode(EVT VT, unsigned Order, const DebugLoc &dl, const int *M)
1507  : SDNode(ISD::VECTOR_SHUFFLE, Order, dl, getSDVTList(VT)), Mask(M) {}
1508 
1509 public:
1511  EVT VT = getValueType(0);
1512  return makeArrayRef(Mask, VT.getVectorNumElements());
1513  }
1514 
1515  int getMaskElt(unsigned Idx) const {
1516  assert(Idx < getValueType(0).getVectorNumElements() && "Idx out of range!");
1517  return Mask[Idx];
1518  }
1519 
1520  bool isSplat() const { return isSplatMask(Mask, getValueType(0)); }
1521 
1522  int getSplatIndex() const {
1523  assert(isSplat() && "Cannot get splat index for non-splat!");
1524  EVT VT = getValueType(0);
1525  for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; ++i)
1526  if (Mask[i] >= 0)
1527  return Mask[i];
1528 
1529  // We can choose any index value here and be correct because all elements
1530  // are undefined. Return 0 for better potential for callers to simplify.
1531  return 0;
1532  }
1533 
1534  static bool isSplatMask(const int *Mask, EVT VT);
1535 
1536  /// Change values in a shuffle permute mask assuming
1537  /// the two vector operands have swapped position.
1539  unsigned NumElems = Mask.size();
1540  for (unsigned i = 0; i != NumElems; ++i) {
1541  int idx = Mask[i];
1542  if (idx < 0)
1543  continue;
1544  else if (idx < (int)NumElems)
1545  Mask[i] = idx + NumElems;
1546  else
1547  Mask[i] = idx - NumElems;
1548  }
1549  }
1550 
1551  static bool classof(const SDNode *N) {
1552  return N->getOpcode() == ISD::VECTOR_SHUFFLE;
1553  }
1554 };
1555 
1556 class ConstantSDNode : public SDNode {
1557  friend class SelectionDAG;
1558 
1559  const ConstantInt *Value;
1560 
1561  ConstantSDNode(bool isTarget, bool isOpaque, const ConstantInt *val, EVT VT)
1562  : SDNode(isTarget ? ISD::TargetConstant : ISD::Constant, 0, DebugLoc(),
1563  getSDVTList(VT)),
1564  Value(val) {
1565  ConstantSDNodeBits.IsOpaque = isOpaque;
1566  }
1567 
1568 public:
1569  const ConstantInt *getConstantIntValue() const { return Value; }
1570  const APInt &getAPIntValue() const { return Value->getValue(); }
1571  uint64_t getZExtValue() const { return Value->getZExtValue(); }
1572  int64_t getSExtValue() const { return Value->getSExtValue(); }
1574  return Value->getLimitedValue(Limit);
1575  }
1576  MaybeAlign getMaybeAlignValue() const { return Value->getMaybeAlignValue(); }
1577  Align getAlignValue() const { return Value->getAlignValue(); }
1578 
1579  bool isOne() const { return Value->isOne(); }
1580  bool isZero() const { return Value->isZero(); }
1581  // NOTE: This is soft-deprecated. Please use `isZero()` instead.
1582  bool isNullValue() const { return isZero(); }
1583  bool isAllOnes() const { return Value->isMinusOne(); }
1584  // NOTE: This is soft-deprecated. Please use `isAllOnes()` instead.
1585  bool isAllOnesValue() const { return isAllOnes(); }
1586  bool isMaxSignedValue() const { return Value->isMaxValue(true); }
1587  bool isMinSignedValue() const { return Value->isMinValue(true); }
1588 
1589  bool isOpaque() const { return ConstantSDNodeBits.IsOpaque; }
1590 
1591  static bool classof(const SDNode *N) {
1592  return N->getOpcode() == ISD::Constant ||
1593  N->getOpcode() == ISD::TargetConstant;
1594  }
1595 };
1596 
1598  return cast<ConstantSDNode>(getOperand(Num))->getZExtValue();
1599 }
1600 
1601 const APInt &SDNode::getConstantOperandAPInt(unsigned Num) const {
1602  return cast<ConstantSDNode>(getOperand(Num))->getAPIntValue();
1603 }
1604 
1605 class ConstantFPSDNode : public SDNode {
1606  friend class SelectionDAG;
1607 
1608  const ConstantFP *Value;
1609 
1610  ConstantFPSDNode(bool isTarget, const ConstantFP *val, EVT VT)
1611  : SDNode(isTarget ? ISD::TargetConstantFP : ISD::ConstantFP, 0,
1612  DebugLoc(), getSDVTList(VT)),
1613  Value(val) {}
1614 
1615 public:
1616  const APFloat& getValueAPF() const { return Value->getValueAPF(); }
1617  const ConstantFP *getConstantFPValue() const { return Value; }
1618 
1619  /// Return true if the value is positive or negative zero.
1620  bool isZero() const { return Value->isZero(); }
1621 
1622  /// Return true if the value is a NaN.
1623  bool isNaN() const { return Value->isNaN(); }
1624 
1625  /// Return true if the value is an infinity
1626  bool isInfinity() const { return Value->isInfinity(); }
1627 
1628  /// Return true if the value is negative.
1629  bool isNegative() const { return Value->isNegative(); }
1630 
1631  /// We don't rely on operator== working on double values, as
1632  /// it returns true for things that are clearly not equal, like -0.0 and 0.0.
1633  /// As such, this method can be used to do an exact bit-for-bit comparison of
1634  /// two floating point values.
1635 
1636  /// We leave the version with the double argument here because it's just so
1637  /// convenient to write "2.0" and the like. Without this function we'd
1638  /// have to duplicate its logic everywhere it's called.
1639  bool isExactlyValue(double V) const {
1640  return Value->getValueAPF().isExactlyValue(V);
1641  }
1642  bool isExactlyValue(const APFloat& V) const;
1643 
1644  static bool isValueValidForType(EVT VT, const APFloat& Val);
1645 
1646  static bool classof(const SDNode *N) {
1647  return N->getOpcode() == ISD::ConstantFP ||
1648  N->getOpcode() == ISD::TargetConstantFP;
1649  }
1650 };
1651 
1652 /// Returns true if \p V is a constant integer zero.
1653 bool isNullConstant(SDValue V);
1654 
1655 /// Returns true if \p V is an FP constant with a value of positive zero.
1656 bool isNullFPConstant(SDValue V);
1657 
1658 /// Returns true if \p V is an integer constant with all bits set.
1659 bool isAllOnesConstant(SDValue V);
1660 
1661 /// Returns true if \p V is a constant integer one.
1662 bool isOneConstant(SDValue V);
1663 
1664 /// Return the non-bitcasted source operand of \p V if it exists.
1665 /// If \p V is not a bitcasted value, it is returned as-is.
1666 SDValue peekThroughBitcasts(SDValue V);
1667 
1668 /// Return the non-bitcasted and one-use source operand of \p V if it exists.
1669 /// If \p V is not a bitcasted one-use value, it is returned as-is.
1670 SDValue peekThroughOneUseBitcasts(SDValue V);
1671 
1672 /// Return the non-extracted vector source operand of \p V if it exists.
1673 /// If \p V is not an extracted subvector, it is returned as-is.
1674 SDValue peekThroughExtractSubvectors(SDValue V);
1675 
1676 /// Returns true if \p V is a bitwise not operation. Assumes that an all ones
1677 /// constant is canonicalized to be operand 1.
1678 bool isBitwiseNot(SDValue V, bool AllowUndefs = false);
1679 
1680 /// Returns the SDNode if it is a constant splat BuildVector or constant int.
1681 ConstantSDNode *isConstOrConstSplat(SDValue N, bool AllowUndefs = false,
1682  bool AllowTruncation = false);
1683 
1684 /// Returns the SDNode if it is a demanded constant splat BuildVector or
1685 /// constant int.
1686 ConstantSDNode *isConstOrConstSplat(SDValue N, const APInt &DemandedElts,
1687  bool AllowUndefs = false,
1688  bool AllowTruncation = false);
1689 
1690 /// Returns the SDNode if it is a constant splat BuildVector or constant float.
1691 ConstantFPSDNode *isConstOrConstSplatFP(SDValue N, bool AllowUndefs = false);
1692 
1693 /// Returns the SDNode if it is a demanded constant splat BuildVector or
1694 /// constant float.
1695 ConstantFPSDNode *isConstOrConstSplatFP(SDValue N, const APInt &DemandedElts,
1696  bool AllowUndefs = false);
1697 
1698 /// Return true if the value is a constant 0 integer or a splatted vector of
1699 /// a constant 0 integer (with no undefs by default).
1700 /// Build vector implicit truncation is not an issue for null values.
1701 bool isNullOrNullSplat(SDValue V, bool AllowUndefs = false);
1702 
1703 /// Return true if the value is a constant 1 integer or a splatted vector of a
1704 /// constant 1 integer (with no undefs).
1705 /// Does not permit build vector implicit truncation.
1706 bool isOneOrOneSplat(SDValue V, bool AllowUndefs = false);
1707 
1708 /// Return true if the value is a constant -1 integer or a splatted vector of a
1709 /// constant -1 integer (with no undefs).
1710 /// Does not permit build vector implicit truncation.
1711 bool isAllOnesOrAllOnesSplat(SDValue V, bool AllowUndefs = false);
1712 
1713 /// Return true if \p V is either a integer or FP constant.
1714 inline bool isIntOrFPConstant(SDValue V) {
1715  return isa<ConstantSDNode>(V) || isa<ConstantFPSDNode>(V);
1716 }
1717 
1718 class GlobalAddressSDNode : public SDNode {
1719  friend class SelectionDAG;
1720 
1721  const GlobalValue *TheGlobal;
1722  int64_t Offset;
1723  unsigned TargetFlags;
1724 
1725  GlobalAddressSDNode(unsigned Opc, unsigned Order, const DebugLoc &DL,
1726  const GlobalValue *GA, EVT VT, int64_t o,
1727  unsigned TF);
1728 
1729 public:
1730  const GlobalValue *getGlobal() const { return TheGlobal; }
1731  int64_t getOffset() const { return Offset; }
1732  unsigned getTargetFlags() const { return TargetFlags; }
1733  // Return the address space this GlobalAddress belongs to.
1734  unsigned getAddressSpace() const;
1735 
1736  static bool classof(const SDNode *N) {
1737  return N->getOpcode() == ISD::GlobalAddress ||
1738  N->getOpcode() == ISD::TargetGlobalAddress ||
1739  N->getOpcode() == ISD::GlobalTLSAddress ||
1740  N->getOpcode() == ISD::TargetGlobalTLSAddress;
1741  }
1742 };
1743 
1744 class FrameIndexSDNode : public SDNode {
1745  friend class SelectionDAG;
1746 
1747  int FI;
1748 
1749  FrameIndexSDNode(int fi, EVT VT, bool isTarg)
1750  : SDNode(isTarg ? ISD::TargetFrameIndex : ISD::FrameIndex,
1751  0, DebugLoc(), getSDVTList(VT)), FI(fi) {
1752  }
1753 
1754 public:
1755  int getIndex() const { return FI; }
1756 
1757  static bool classof(const SDNode *N) {
1758  return N->getOpcode() == ISD::FrameIndex ||
1759  N->getOpcode() == ISD::TargetFrameIndex;
1760  }
1761 };
1762 
1763 /// This SDNode is used for LIFETIME_START/LIFETIME_END values, which indicate
1764 /// the offet and size that are started/ended in the underlying FrameIndex.
1765 class LifetimeSDNode : public SDNode {
1766  friend class SelectionDAG;
1767  int64_t Size;
1768  int64_t Offset; // -1 if offset is unknown.
1769 
1770  LifetimeSDNode(unsigned Opcode, unsigned Order, const DebugLoc &dl,
1771  SDVTList VTs, int64_t Size, int64_t Offset)
1772  : SDNode(Opcode, Order, dl, VTs), Size(Size), Offset(Offset) {}
1773 public:
1774  int64_t getFrameIndex() const {
1775  return cast<FrameIndexSDNode>(getOperand(1))->getIndex();
1776  }
1777 
1778  bool hasOffset() const { return Offset >= 0; }
1779  int64_t getOffset() const {
1780  assert(hasOffset() && "offset is unknown");
1781  return Offset;
1782  }
1783  int64_t getSize() const {
1784  assert(hasOffset() && "offset is unknown");
1785  return Size;
1786  }
1787 
1788  // Methods to support isa and dyn_cast
1789  static bool classof(const SDNode *N) {
1790  return N->getOpcode() == ISD::LIFETIME_START ||
1791  N->getOpcode() == ISD::LIFETIME_END;
1792  }
1793 };
1794 
1795 /// This SDNode is used for PSEUDO_PROBE values, which are the function guid and
1796 /// the index of the basic block being probed. A pseudo probe serves as a place
1797 /// holder and will be removed at the end of compilation. It does not have any
1798 /// operand because we do not want the instruction selection to deal with any.
1799 class PseudoProbeSDNode : public SDNode {
1800  friend class SelectionDAG;
1801  uint64_t Guid;
1802  uint64_t Index;
1804 
1805  PseudoProbeSDNode(unsigned Opcode, unsigned Order, const DebugLoc &Dl,
1806  SDVTList VTs, uint64_t Guid, uint64_t Index, uint32_t Attr)
1807  : SDNode(Opcode, Order, Dl, VTs), Guid(Guid), Index(Index),
1808  Attributes(Attr) {}
1809 
1810 public:
1811  uint64_t getGuid() const { return Guid; }
1812  uint64_t getIndex() const { return Index; }
1813  uint32_t getAttributes() const { return Attributes; }
1814 
1815  // Methods to support isa and dyn_cast
1816  static bool classof(const SDNode *N) {
1817  return N->getOpcode() == ISD::PSEUDO_PROBE;
1818  }
1819 };
1820 
1821 class JumpTableSDNode : public SDNode {
1822  friend class SelectionDAG;
1823 
1824  int JTI;
1825  unsigned TargetFlags;
1826 
1827  JumpTableSDNode(int jti, EVT VT, bool isTarg, unsigned TF)
1828  : SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable,
1829  0, DebugLoc(), getSDVTList(VT)), JTI(jti), TargetFlags(TF) {
1830  }
1831 
1832 public:
1833  int getIndex() const { return JTI; }
1834  unsigned getTargetFlags() const { return TargetFlags; }
1835 
1836  static bool classof(const SDNode *N) {
1837  return N->getOpcode() == ISD::JumpTable ||
1838  N->getOpcode() == ISD::TargetJumpTable;
1839  }
1840 };
1841 
1842 class ConstantPoolSDNode : public SDNode {
1843  friend class SelectionDAG;
1844 
1845  union {
1848  } Val;
1849  int Offset; // It's a MachineConstantPoolValue if top bit is set.
1850  Align Alignment; // Minimum alignment requirement of CP.
1851  unsigned TargetFlags;
1852 
1853  ConstantPoolSDNode(bool isTarget, const Constant *c, EVT VT, int o,
1854  Align Alignment, unsigned TF)
1855  : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0,
1856  DebugLoc(), getSDVTList(VT)),
1857  Offset(o), Alignment(Alignment), TargetFlags(TF) {
1858  assert(Offset >= 0 && "Offset is too large");
1859  Val.ConstVal = c;
1860  }
1861 
1862  ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v, EVT VT, int o,
1863  Align Alignment, unsigned TF)
1864  : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0,
1865  DebugLoc(), getSDVTList(VT)),
1866  Offset(o), Alignment(Alignment), TargetFlags(TF) {
1867  assert(Offset >= 0 && "Offset is too large");
1868  Val.MachineCPVal = v;
1869  Offset |= 1 << (sizeof(unsigned)*CHAR_BIT-1);
1870  }
1871 
1872 public:
1874  return Offset < 0;
1875  }
1876 
1877  const Constant *getConstVal() const {
1878  assert(!isMachineConstantPoolEntry() && "Wrong constantpool type");
1879  return Val.ConstVal;
1880  }
1881 
1883  assert(isMachineConstantPoolEntry() && "Wrong constantpool type");
1884  return Val.MachineCPVal;
1885  }
1886 
1887  int getOffset() const {
1888  return Offset & ~(1 << (sizeof(unsigned)*CHAR_BIT-1));
1889  }
1890 
1891  // Return the alignment of this constant pool object, which is either 0 (for
1892  // default alignment) or the desired value.
1893  Align getAlign() const { return Alignment; }
1894  unsigned getTargetFlags() const { return TargetFlags; }
1895 
1896  Type *getType() const;
1897 
1898  static bool classof(const SDNode *N) {
1899  return N->getOpcode() == ISD::ConstantPool ||
1900  N->getOpcode() == ISD::TargetConstantPool;
1901  }
1902 };
1903 
1904 /// Completely target-dependent object reference.
1905 class TargetIndexSDNode : public SDNode {
1906  friend class SelectionDAG;
1907 
1908  unsigned TargetFlags;
1909  int Index;
1910  int64_t Offset;
1911 
1912 public:
1913  TargetIndexSDNode(int Idx, EVT VT, int64_t Ofs, unsigned TF)
1914  : SDNode(ISD::TargetIndex, 0, DebugLoc(), getSDVTList(VT)),
1915  TargetFlags(TF), Index(Idx), Offset(Ofs) {}
1916 
1917  unsigned getTargetFlags() const { return TargetFlags; }
1918  int getIndex() const { return Index; }
1919  int64_t getOffset() const { return Offset; }
1920 
1921  static bool classof(const SDNode *N) {
1922  return N->getOpcode() == ISD::TargetIndex;
1923  }
1924 };
1925 
1926 class BasicBlockSDNode : public SDNode {
1927  friend class SelectionDAG;
1928 
1930 
1931  /// Debug info is meaningful and potentially useful here, but we create
1932  /// blocks out of order when they're jumped to, which makes it a bit
1933  /// harder. Let's see if we need it first.
1934  explicit BasicBlockSDNode(MachineBasicBlock *mbb)
1935  : SDNode(ISD::BasicBlock, 0, DebugLoc(), getSDVTList(MVT::Other)), MBB(mbb)
1936  {}
1937 
1938 public:
1939  MachineBasicBlock *getBasicBlock() const { return MBB; }
1940 
1941  static bool classof(const SDNode *N) {
1942  return N->getOpcode() == ISD::BasicBlock;
1943  }
1944 };
1945 
1946 /// A "pseudo-class" with methods for operating on BUILD_VECTORs.
1947 class BuildVectorSDNode : public SDNode {
1948 public:
1949  // These are constructed as SDNodes and then cast to BuildVectorSDNodes.
1950  explicit BuildVectorSDNode() = delete;
1951 
1952  /// Check if this is a constant splat, and if so, find the
1953  /// smallest element size that splats the vector. If MinSplatBits is
1954  /// nonzero, the element size must be at least that large. Note that the
1955  /// splat element may be the entire vector (i.e., a one element vector).
1956  /// Returns the splat element value in SplatValue. Any undefined bits in
1957  /// that value are zero, and the corresponding bits in the SplatUndef mask
1958  /// are set. The SplatBitSize value is set to the splat element size in
1959  /// bits. HasAnyUndefs is set to true if any bits in the vector are
1960  /// undefined. isBigEndian describes the endianness of the target.
1961  bool isConstantSplat(APInt &SplatValue, APInt &SplatUndef,
1962  unsigned &SplatBitSize, bool &HasAnyUndefs,
1963  unsigned MinSplatBits = 0,
1964  bool isBigEndian = false) const;
1965 
1966  /// Returns the demanded splatted value or a null value if this is not a
1967  /// splat.
1968  ///
1969  /// The DemandedElts mask indicates the elements that must be in the splat.
1970  /// If passed a non-null UndefElements bitvector, it will resize it to match
1971  /// the vector width and set the bits where elements are undef.
1972  SDValue getSplatValue(const APInt &DemandedElts,
1973  BitVector *UndefElements = nullptr) const;
1974 
1975  /// Returns the splatted value or a null value if this is not a splat.
1976  ///
1977  /// If passed a non-null UndefElements bitvector, it will resize it to match
1978  /// the vector width and set the bits where elements are undef.
1979  SDValue getSplatValue(BitVector *UndefElements = nullptr) const;
1980 
1981  /// Find the shortest repeating sequence of values in the build vector.
1982  ///
1983  /// e.g. { u, X, u, X, u, u, X, u } -> { X }
1984  /// { X, Y, u, Y, u, u, X, u } -> { X, Y }
1985  ///
1986  /// Currently this must be a power-of-2 build vector.
1987  /// The DemandedElts mask indicates the elements that must be present,
1988  /// undemanded elements in Sequence may be null (SDValue()). If passed a
1989  /// non-null UndefElements bitvector, it will resize it to match the original
1990  /// vector width and set the bits where elements are undef. If result is
1991  /// false, Sequence will be empty.
1992  bool getRepeatedSequence(const APInt &DemandedElts,
1994  BitVector *UndefElements = nullptr) const;
1995 
1996  /// Find the shortest repeating sequence of values in the build vector.
1997  ///
1998  /// e.g. { u, X, u, X, u, u, X, u } -> { X }
1999  /// { X, Y, u, Y, u, u, X, u } -> { X, Y }
2000  ///
2001  /// Currently this must be a power-of-2 build vector.
2002  /// If passed a non-null UndefElements bitvector, it will resize it to match
2003  /// the original vector width and set the bits where elements are undef.
2004  /// If result is false, Sequence will be empty.
2006  BitVector *UndefElements = nullptr) const;
2007 
2008  /// Returns the demanded splatted constant or null if this is not a constant
2009  /// splat.
2010  ///
2011  /// The DemandedElts mask indicates the elements that must be in the splat.
2012  /// If passed a non-null UndefElements bitvector, it will resize it to match
2013  /// the vector width and set the bits where elements are undef.
2014  ConstantSDNode *
2015  getConstantSplatNode(const APInt &DemandedElts,
2016  BitVector *UndefElements = nullptr) const;
2017 
2018  /// Returns the splatted constant or null if this is not a constant
2019  /// splat.
2020  ///
2021  /// If passed a non-null UndefElements bitvector, it will resize it to match
2022  /// the vector width and set the bits where elements are undef.
2023  ConstantSDNode *
2024  getConstantSplatNode(BitVector *UndefElements = nullptr) const;
2025 
2026  /// Returns the demanded splatted constant FP or null if this is not a
2027  /// constant FP splat.
2028  ///
2029  /// The DemandedElts mask indicates the elements that must be in the splat.
2030  /// If passed a non-null UndefElements bitvector, it will resize it to match
2031  /// the vector width and set the bits where elements are undef.
2033  getConstantFPSplatNode(const APInt &DemandedElts,
2034  BitVector *UndefElements = nullptr) const;
2035 
2036  /// Returns the splatted constant FP or null if this is not a constant
2037  /// FP splat.
2038  ///
2039  /// If passed a non-null UndefElements bitvector, it will resize it to match
2040  /// the vector width and set the bits where elements are undef.
2042  getConstantFPSplatNode(BitVector *UndefElements = nullptr) const;
2043 
2044  /// If this is a constant FP splat and the splatted constant FP is an
2045  /// exact power or 2, return the log base 2 integer value. Otherwise,
2046  /// return -1.
2047  ///
2048  /// The BitWidth specifies the necessary bit precision.
2049  int32_t getConstantFPSplatPow2ToLog2Int(BitVector *UndefElements,
2050  uint32_t BitWidth) const;
2051 
2052  bool isConstant() const;
2053 
2054  static bool classof(const SDNode *N) {
2055  return N->getOpcode() == ISD::BUILD_VECTOR;
2056  }
2057 };
2058 
2059 /// An SDNode that holds an arbitrary LLVM IR Value. This is
2060 /// used when the SelectionDAG needs to make a simple reference to something
2061 /// in the LLVM IR representation.
2062 ///
2063 class SrcValueSDNode : public SDNode {
2064  friend class SelectionDAG;
2065 
2066  const Value *V;
2067 
2068  /// Create a SrcValue for a general value.
2069  explicit SrcValueSDNode(const Value *v)
2070  : SDNode(ISD::SRCVALUE, 0, DebugLoc(), getSDVTList(MVT::Other)), V(v) {}
2071 
2072 public:
2073  /// Return the contained Value.
2074  const Value *getValue() const { return V; }
2075 
2076  static bool classof(const SDNode *N) {
2077  return N->getOpcode() == ISD::SRCVALUE;
2078  }
2079 };
2080 
2081 class MDNodeSDNode : public SDNode {
2082  friend class SelectionDAG;
2083 
2084  const MDNode *MD;
2085 
2086  explicit MDNodeSDNode(const MDNode *md)
2087  : SDNode(ISD::MDNODE_SDNODE, 0, DebugLoc(), getSDVTList(MVT::Other)), MD(md)
2088  {}
2089 
2090 public:
2091  const MDNode *getMD() const { return MD; }
2092 
2093  static bool classof(const SDNode *N) {
2094  return N->getOpcode() == ISD::MDNODE_SDNODE;
2095  }
2096 };
2097 
2098 class RegisterSDNode : public SDNode {
2099  friend class SelectionDAG;
2100 
2101  Register Reg;
2102 
2103  RegisterSDNode(Register reg, EVT VT)
2104  : SDNode(ISD::Register, 0, DebugLoc(), getSDVTList(VT)), Reg(reg) {}
2105 
2106 public:
2107  Register getReg() const { return Reg; }
2108 
2109  static bool classof(const SDNode *N) {
2110  return N->getOpcode() == ISD::Register;
2111  }
2112 };
2113 
2114 class RegisterMaskSDNode : public SDNode {
2115  friend class SelectionDAG;
2116 
2117  // The memory for RegMask is not owned by the node.
2118  const uint32_t *RegMask;
2119 
2120  RegisterMaskSDNode(const uint32_t *mask)
2122  RegMask(mask) {}
2123 
2124 public:
2125  const uint32_t *getRegMask() const { return RegMask; }
2126 
2127  static bool classof(const SDNode *N) {
2128  return N->getOpcode() == ISD::RegisterMask;
2129  }
2130 };
2131 
2132 class BlockAddressSDNode : public SDNode {
2133  friend class SelectionDAG;
2134 
2135  const BlockAddress *BA;
2136  int64_t Offset;
2137  unsigned TargetFlags;
2138 
2139  BlockAddressSDNode(unsigned NodeTy, EVT VT, const BlockAddress *ba,
2140  int64_t o, unsigned Flags)
2141  : SDNode(NodeTy, 0, DebugLoc(), getSDVTList(VT)),
2142  BA(ba), Offset(o), TargetFlags(Flags) {}
2143 
2144 public:
2145  const BlockAddress *getBlockAddress() const { return BA; }
2146  int64_t getOffset() const { return Offset; }
2147  unsigned getTargetFlags() const { return TargetFlags; }
2148 
2149  static bool classof(const SDNode *N) {
2150  return N->getOpcode() == ISD::BlockAddress ||
2151  N->getOpcode() == ISD::TargetBlockAddress;
2152  }
2153 };
2154 
2155 class LabelSDNode : public SDNode {
2156  friend class SelectionDAG;
2157 
2158  MCSymbol *Label;
2159 
2160  LabelSDNode(unsigned Opcode, unsigned Order, const DebugLoc &dl, MCSymbol *L)
2161  : SDNode(Opcode, Order, dl, getSDVTList(MVT::Other)), Label(L) {
2162  assert(LabelSDNode::classof(this) && "not a label opcode");
2163  }
2164 
2165 public:
2166  MCSymbol *getLabel() const { return Label; }
2167 
2168  static bool classof(const SDNode *N) {
2169  return N->getOpcode() == ISD::EH_LABEL ||
2170  N->getOpcode() == ISD::ANNOTATION_LABEL;
2171  }
2172 };
2173 
2175  friend class SelectionDAG;
2176 
2177  const char *Symbol;
2178  unsigned TargetFlags;
2179 
2180  ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned TF, EVT VT)
2181  : SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol, 0,
2182  DebugLoc(), getSDVTList(VT)),
2183  Symbol(Sym), TargetFlags(TF) {}
2184 
2185 public:
2186  const char *getSymbol() const { return Symbol; }
2187  unsigned getTargetFlags() const { return TargetFlags; }
2188 
2189  static bool classof(const SDNode *N) {
2190  return N->getOpcode() == ISD::ExternalSymbol ||
2191  N->getOpcode() == ISD::TargetExternalSymbol;
2192  }
2193 };
2194 
2195 class MCSymbolSDNode : public SDNode {
2196  friend class SelectionDAG;
2197 
2198  MCSymbol *Symbol;
2199 
2201  : SDNode(ISD::MCSymbol, 0, DebugLoc(), getSDVTList(VT)), Symbol(Symbol) {}
2202 
2203 public:
2204  MCSymbol *getMCSymbol() const { return Symbol; }
2205 
2206  static bool classof(const SDNode *N) {
2207  return N->getOpcode() == ISD::MCSymbol;
2208  }
2209 };
2210 
2211 class CondCodeSDNode : public SDNode {
2212  friend class SelectionDAG;
2213 
2214  ISD::CondCode Condition;
2215 
2217  : SDNode(ISD::CONDCODE, 0, DebugLoc(), getSDVTList(MVT::Other)),
2218  Condition(Cond) {}
2219 
2220 public:
2221  ISD::CondCode get() const { return Condition; }
2222 
2223  static bool classof(const SDNode *N) {
2224  return N->getOpcode() == ISD::CONDCODE;
2225  }
2226 };
2227 
2228 /// This class is used to represent EVT's, which are used
2229 /// to parameterize some operations.
2230 class VTSDNode : public SDNode {
2231  friend class SelectionDAG;
2232 
2233  EVT ValueType;
2234 
2235  explicit VTSDNode(EVT VT)
2236  : SDNode(ISD::VALUETYPE, 0, DebugLoc(), getSDVTList(MVT::Other)),
2237  ValueType(VT) {}
2238 
2239 public:
2240  EVT getVT() const { return ValueType; }
2241 
2242  static bool classof(const SDNode *N) {
2243  return N->getOpcode() == ISD::VALUETYPE;
2244  }
2245 };
2246 
2247 /// Base class for LoadSDNode and StoreSDNode
2248 class LSBaseSDNode : public MemSDNode {
2249 public:
2250  LSBaseSDNode(ISD::NodeType NodeTy, unsigned Order, const DebugLoc &dl,
2251  SDVTList VTs, ISD::MemIndexedMode AM, EVT MemVT,
2253  : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {
2254  LSBaseSDNodeBits.AddressingMode = AM;
2255  assert(getAddressingMode() == AM && "Value truncated");
2256  }
2257 
2258  const SDValue &getOffset() const {
2259  return getOperand(getOpcode() == ISD::LOAD ? 2 : 3);
2260  }
2261 
2262  /// Return the addressing mode for this load or store:
2263  /// unindexed, pre-inc, pre-dec, post-inc, or post-dec.
2265  return static_cast<ISD::MemIndexedMode>(LSBaseSDNodeBits.AddressingMode);
2266  }
2267 
2268  /// Return true if this is a pre/post inc/dec load/store.
2269  bool isIndexed() const { return getAddressingMode() != ISD::UNINDEXED; }
2270 
2271  /// Return true if this is NOT a pre/post inc/dec load/store.
2272  bool isUnindexed() const { return getAddressingMode() == ISD::UNINDEXED; }
2273 
2274  static bool classof(const SDNode *N) {
2275  return N->getOpcode() == ISD::LOAD ||
2276  N->getOpcode() == ISD::STORE;
2277  }
2278 };
2279 
2280 /// This class is used to represent ISD::LOAD nodes.
2281 class LoadSDNode : public LSBaseSDNode {
2282  friend class SelectionDAG;
2283 
2284  LoadSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2285  ISD::MemIndexedMode AM, ISD::LoadExtType ETy, EVT MemVT,
2287  : LSBaseSDNode(ISD::LOAD, Order, dl, VTs, AM, MemVT, MMO) {
2288  LoadSDNodeBits.ExtTy = ETy;
2289  assert(readMem() && "Load MachineMemOperand is not a load!");
2290  assert(!writeMem() && "Load MachineMemOperand is a store!");
2291  }
2292 
2293 public:
2294  /// Return whether this is a plain node,
2295  /// or one of the varieties of value-extending loads.
2297  return static_cast<ISD::LoadExtType>(LoadSDNodeBits.ExtTy);
2298  }
2299 
2300  const SDValue &getBasePtr() const { return getOperand(1); }
2301  const SDValue &getOffset() const { return getOperand(2); }
2302 
2303  static bool classof(const SDNode *N) {
2304  return N->getOpcode() == ISD::LOAD;
2305  }
2306 };
2307 
2308 /// This class is used to represent ISD::STORE nodes.
2309 class StoreSDNode : public LSBaseSDNode {
2310  friend class SelectionDAG;
2311 
2312  StoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2313  ISD::MemIndexedMode AM, bool isTrunc, EVT MemVT,
2315  : LSBaseSDNode(ISD::STORE, Order, dl, VTs, AM, MemVT, MMO) {
2316  StoreSDNodeBits.IsTruncating = isTrunc;
2317  assert(!readMem() && "Store MachineMemOperand is a load!");
2318  assert(writeMem() && "Store MachineMemOperand is not a store!");
2319  }
2320 
2321 public:
2322  /// Return true if the op does a truncation before store.
2323  /// For integers this is the same as doing a TRUNCATE and storing the result.
2324  /// For floats, it is the same as doing an FP_ROUND and storing the result.
2325  bool isTruncatingStore() const { return StoreSDNodeBits.IsTruncating; }
2326  void setTruncatingStore(bool Truncating) {
2327  StoreSDNodeBits.IsTruncating = Truncating;
2328  }
2329 
2330  const SDValue &getValue() const { return getOperand(1); }
2331  const SDValue &getBasePtr() const { return getOperand(2); }
2332  const SDValue &getOffset() const { return getOperand(3); }
2333 
2334  static bool classof(const SDNode *N) {
2335  return N->getOpcode() == ISD::STORE;
2336  }
2337 };
2338 
2339 /// This base class is used to represent VP_LOAD and VP_STORE nodes
2341 public:
2342  friend class SelectionDAG;
2343 
2344  VPLoadStoreSDNode(ISD::NodeType NodeTy, unsigned Order, const DebugLoc &dl,
2345  SDVTList VTs, ISD::MemIndexedMode AM, EVT MemVT,
2347  : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {
2348  LSBaseSDNodeBits.AddressingMode = AM;
2349  assert(getAddressingMode() == AM && "Value truncated");
2350  }
2351 
2352  // VPLoadSDNode (Chain, Ptr, Offset, Mask, EVL)
2353  // VPStoreSDNode (Chain, Data, Ptr, Offset, Mask, EVL)
2354  // Mask is a vector of i1 elements;
2355  // the type of EVL is TLI.getVPExplicitVectorLengthTy().
2356  const SDValue &getOffset() const {
2357  return getOperand(getOpcode() == ISD::VP_LOAD ? 2 : 3);
2358  }
2359  const SDValue &getBasePtr() const {
2360  return getOperand(getOpcode() == ISD::VP_LOAD ? 1 : 2);
2361  }
2362  const SDValue &getMask() const {
2363  return getOperand(getOpcode() == ISD::VP_LOAD ? 3 : 4);
2364  }
2365  const SDValue &getVectorLength() const {
2366  return getOperand(getOpcode() == ISD::VP_LOAD ? 4 : 5);
2367  }
2368 
2369  /// Return the addressing mode for this load or store:
2370  /// unindexed, pre-inc, pre-dec, post-inc, or post-dec.
2372  return static_cast<ISD::MemIndexedMode>(LSBaseSDNodeBits.AddressingMode);
2373  }
2374 
2375  /// Return true if this is a pre/post inc/dec load/store.
2376  bool isIndexed() const { return getAddressingMode() != ISD::UNINDEXED; }
2377 
2378  /// Return true if this is NOT a pre/post inc/dec load/store.
2379  bool isUnindexed() const { return getAddressingMode() == ISD::UNINDEXED; }
2380 
2381  static bool classof(const SDNode *N) {
2382  return N->getOpcode() == ISD::VP_LOAD || N->getOpcode() == ISD::VP_STORE;
2383  }
2384 };
2385 
2386 /// This class is used to represent a VP_LOAD node
2388 public:
2389  friend class SelectionDAG;
2390 
2391  VPLoadSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2392  ISD::MemIndexedMode AM, ISD::LoadExtType ETy, bool isExpanding,
2393  EVT MemVT, MachineMemOperand *MMO)
2394  : VPLoadStoreSDNode(ISD::VP_LOAD, Order, dl, VTs, AM, MemVT, MMO) {
2395  LoadSDNodeBits.ExtTy = ETy;
2396  LoadSDNodeBits.IsExpanding = isExpanding;
2397  }
2398 
2400  return static_cast<ISD::LoadExtType>(LoadSDNodeBits.ExtTy);
2401  }
2402 
2403  const SDValue &getBasePtr() const { return getOperand(1); }
2404  const SDValue &getOffset() const { return getOperand(2); }
2405  const SDValue &getMask() const { return getOperand(3); }
2406  const SDValue &getVectorLength() const { return getOperand(4); }
2407 
2408  static bool classof(const SDNode *N) {
2409  return N->getOpcode() == ISD::VP_LOAD;
2410  }
2411  bool isExpandingLoad() const { return LoadSDNodeBits.IsExpanding; }
2412 };
2413 
2414 /// This class is used to represent a VP_STORE node
2416 public:
2417  friend class SelectionDAG;
2418 
2419  VPStoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2420  ISD::MemIndexedMode AM, bool isTrunc, bool isCompressing,
2421  EVT MemVT, MachineMemOperand *MMO)
2422  : VPLoadStoreSDNode(ISD::VP_STORE, Order, dl, VTs, AM, MemVT, MMO) {
2423  StoreSDNodeBits.IsTruncating = isTrunc;
2424  StoreSDNodeBits.IsCompressing = isCompressing;
2425  }
2426 
2427  /// Return true if this is a truncating store.
2428  /// For integers this is the same as doing a TRUNCATE and storing the result.
2429  /// For floats, it is the same as doing an FP_ROUND and storing the result.
2430  bool isTruncatingStore() const { return StoreSDNodeBits.IsTruncating; }
2431 
2432  /// Returns true if the op does a compression to the vector before storing.
2433  /// The node contiguously stores the active elements (integers or floats)
2434  /// in src (those with their respective bit set in writemask k) to unaligned
2435  /// memory at base_addr.
2436  bool isCompressingStore() const { return StoreSDNodeBits.IsCompressing; }
2437 
2438  const SDValue &getValue() const { return getOperand(1); }
2439  const SDValue &getBasePtr() const { return getOperand(2); }
2440  const SDValue &getOffset() const { return getOperand(3); }
2441  const SDValue &getMask() const { return getOperand(4); }
2442  const SDValue &getVectorLength() const { return getOperand(5); }
2443 
2444  static bool classof(const SDNode *N) {
2445  return N->getOpcode() == ISD::VP_STORE;
2446  }
2447 };
2448 
2449 /// This base class is used to represent MLOAD and MSTORE nodes
2451 public:
2452  friend class SelectionDAG;
2453 
2454  MaskedLoadStoreSDNode(ISD::NodeType NodeTy, unsigned Order,
2455  const DebugLoc &dl, SDVTList VTs,
2456  ISD::MemIndexedMode AM, EVT MemVT,
2458  : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {
2459  LSBaseSDNodeBits.AddressingMode = AM;
2460  assert(getAddressingMode() == AM && "Value truncated");
2461  }
2462 
2463  // MaskedLoadSDNode (Chain, ptr, offset, mask, passthru)
2464  // MaskedStoreSDNode (Chain, data, ptr, offset, mask)
2465  // Mask is a vector of i1 elements
2466  const SDValue &getOffset() const {
2467  return getOperand(getOpcode() == ISD::MLOAD ? 2 : 3);
2468  }
2469  const SDValue &getMask() const {
2470  return getOperand(getOpcode() == ISD::MLOAD ? 3 : 4);
2471  }
2472 
2473  /// Return the addressing mode for this load or store:
2474  /// unindexed, pre-inc, pre-dec, post-inc, or post-dec.
2476  return static_cast<ISD::MemIndexedMode>(LSBaseSDNodeBits.AddressingMode);
2477  }
2478 
2479  /// Return true if this is a pre/post inc/dec load/store.
2480  bool isIndexed() const { return getAddressingMode() != ISD::UNINDEXED; }
2481 
2482  /// Return true if this is NOT a pre/post inc/dec load/store.
2483  bool isUnindexed() const { return getAddressingMode() == ISD::UNINDEXED; }
2484 
2485  static bool classof(const SDNode *N) {
2486  return N->getOpcode() == ISD::MLOAD ||
2487  N->getOpcode() == ISD::MSTORE;
2488  }
2489 };
2490 
2491 /// This class is used to represent an MLOAD node
2493 public:
2494  friend class SelectionDAG;
2495 
2496  MaskedLoadSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2498  bool IsExpanding, EVT MemVT, MachineMemOperand *MMO)
2499  : MaskedLoadStoreSDNode(ISD::MLOAD, Order, dl, VTs, AM, MemVT, MMO) {
2500  LoadSDNodeBits.ExtTy = ETy;
2501  LoadSDNodeBits.IsExpanding = IsExpanding;
2502  }
2503 
2505  return static_cast<ISD::LoadExtType>(LoadSDNodeBits.ExtTy);
2506  }
2507 
2508  const SDValue &getBasePtr() const { return getOperand(1); }
2509  const SDValue &getOffset() const { return getOperand(2); }
2510  const SDValue &getMask() const { return getOperand(3); }
2511  const SDValue &getPassThru() const { return getOperand(4); }
2512 
2513  static bool classof(const SDNode *N) {
2514  return N->getOpcode() == ISD::MLOAD;
2515  }
2516 
2517  bool isExpandingLoad() const { return LoadSDNodeBits.IsExpanding; }
2518 };
2519 
2520 /// This class is used to represent an MSTORE node
2522 public:
2523  friend class SelectionDAG;
2524 
2525  MaskedStoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2526  ISD::MemIndexedMode AM, bool isTrunc, bool isCompressing,
2527  EVT MemVT, MachineMemOperand *MMO)
2528  : MaskedLoadStoreSDNode(ISD::MSTORE, Order, dl, VTs, AM, MemVT, MMO) {
2529  StoreSDNodeBits.IsTruncating = isTrunc;
2530  StoreSDNodeBits.IsCompressing = isCompressing;
2531  }
2532 
2533  /// Return true if the op does a truncation before store.
2534  /// For integers this is the same as doing a TRUNCATE and storing the result.
2535  /// For floats, it is the same as doing an FP_ROUND and storing the result.
2536  bool isTruncatingStore() const { return StoreSDNodeBits.IsTruncating; }
2537 
2538  /// Returns true if the op does a compression to the vector before storing.
2539  /// The node contiguously stores the active elements (integers or floats)
2540  /// in src (those with their respective bit set in writemask k) to unaligned
2541  /// memory at base_addr.
2542  bool isCompressingStore() const { return StoreSDNodeBits.IsCompressing; }
2543 
2544  const SDValue &getValue() const { return getOperand(1); }
2545  const SDValue &getBasePtr() const { return getOperand(2); }
2546  const SDValue &getOffset() const { return getOperand(3); }
2547  const SDValue &getMask() const { return getOperand(4); }
2548 
2549  static bool classof(const SDNode *N) {
2550  return N->getOpcode() == ISD::MSTORE;
2551  }
2552 };
2553 
2554 /// This is a base class used to represent
2555 /// VP_GATHER and VP_SCATTER nodes
2556 ///
2558 public:
2559  friend class SelectionDAG;
2560 
2561  VPGatherScatterSDNode(ISD::NodeType NodeTy, unsigned Order,
2562  const DebugLoc &dl, SDVTList VTs, EVT MemVT,
2564  : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {
2565  LSBaseSDNodeBits.AddressingMode = IndexType;
2566  assert(getIndexType() == IndexType && "Value truncated");
2567  }
2568 
2569  /// How is Index applied to BasePtr when computing addresses.
2571  return static_cast<ISD::MemIndexType>(LSBaseSDNodeBits.AddressingMode);
2572  }
2573  bool isIndexScaled() const {
2574  return (getIndexType() == ISD::SIGNED_SCALED) ||
2576  }
2577  bool isIndexSigned() const {
2578  return (getIndexType() == ISD::SIGNED_SCALED) ||
2580  }
2581 
2582  // In the both nodes address is Op1, mask is Op2:
2583  // VPGatherSDNode (Chain, base, index, scale, mask, vlen)
2584  // VPScatterSDNode (Chain, value, base, index, scale, mask, vlen)
2585  // Mask is a vector of i1 elements
2586  const SDValue &getBasePtr() const {
2587  return getOperand((getOpcode() == ISD::VP_GATHER) ? 1 : 2);
2588  }
2589  const SDValue &getIndex() const {
2590  return getOperand((getOpcode() == ISD::VP_GATHER) ? 2 : 3);
2591  }
2592  const SDValue &getScale() const {
2593  return getOperand((getOpcode() == ISD::VP_GATHER) ? 3 : 4);
2594  }
2595  const SDValue &getMask() const {
2596  return getOperand((getOpcode() == ISD::VP_GATHER) ? 4 : 5);
2597  }
2598  const SDValue &getVectorLength() const {
2599  return getOperand((getOpcode() == ISD::VP_GATHER) ? 5 : 6);
2600  }
2601 
2602  static bool classof(const SDNode *N) {
2603  return N->getOpcode() == ISD::VP_GATHER ||
2604  N->getOpcode() == ISD::VP_SCATTER;
2605  }
2606 };
2607 
2608 /// This class is used to represent an VP_GATHER node
2609 ///
2611 public:
2612  friend class SelectionDAG;
2613 
2614  VPGatherSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemVT,
2616  : VPGatherScatterSDNode(ISD::VP_GATHER, Order, dl, VTs, MemVT, MMO,
2617  IndexType) {}
2618 
2619  static bool classof(const SDNode *N) {
2620  return N->getOpcode() == ISD::VP_GATHER;
2621  }
2622 };
2623 
2624 /// This class is used to represent an VP_SCATTER node
2625 ///
2627 public:
2628  friend class SelectionDAG;
2629 
2630  VPScatterSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemVT,
2632  : VPGatherScatterSDNode(ISD::VP_SCATTER, Order, dl, VTs, MemVT, MMO,
2633  IndexType) {}
2634 
2635  const SDValue &getValue() const { return getOperand(1); }
2636 
2637  static bool classof(const SDNode *N) {
2638  return N->getOpcode() == ISD::VP_SCATTER;
2639  }
2640 };
2641 
2642 /// This is a base class used to represent
2643 /// MGATHER and MSCATTER nodes
2644 ///
2646 public:
2647  friend class SelectionDAG;
2648 
2650  const DebugLoc &dl, SDVTList VTs, EVT MemVT,
2652  : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {
2653  LSBaseSDNodeBits.AddressingMode = IndexType;
2654  assert(getIndexType() == IndexType && "Value truncated");
2655  }
2656 
2657  /// How is Index applied to BasePtr when computing addresses.
2659  return static_cast<ISD::MemIndexType>(LSBaseSDNodeBits.AddressingMode);
2660  }
2662  LSBaseSDNodeBits.AddressingMode = IndexType;
2663  }
2664  bool isIndexScaled() const {
2665  return (getIndexType() == ISD::SIGNED_SCALED) ||
2667  }
2668  bool isIndexSigned() const {
2669  return (getIndexType() == ISD::SIGNED_SCALED) ||
2671  }
2672 
2673  // In the both nodes address is Op1, mask is Op2:
2674  // MaskedGatherSDNode (Chain, passthru, mask, base, index, scale)
2675  // MaskedScatterSDNode (Chain, value, mask, base, index, scale)
2676  // Mask is a vector of i1 elements
2677  const SDValue &getBasePtr() const { return getOperand(3); }
2678  const SDValue &getIndex() const { return getOperand(4); }
2679  const SDValue &getMask() const { return getOperand(2); }
2680  const SDValue &getScale() const { return getOperand(5); }
2681 
2682  static bool classof(const SDNode *N) {
2683  return N->getOpcode() == ISD::MGATHER ||
2684  N->getOpcode() == ISD::MSCATTER;
2685  }
2686 };
2687 
2688 /// This class is used to represent an MGATHER node
2689 ///
2691 public:
2692  friend class SelectionDAG;
2693 
2694  MaskedGatherSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2695  EVT MemVT, MachineMemOperand *MMO,
2696  ISD::MemIndexType IndexType, ISD::LoadExtType ETy)
2697  : MaskedGatherScatterSDNode(ISD::MGATHER, Order, dl, VTs, MemVT, MMO,
2698  IndexType) {
2699  LoadSDNodeBits.ExtTy = ETy;
2700  }
2701 
2702  const SDValue &getPassThru() const { return getOperand(1); }
2703 
2705  return ISD::LoadExtType(LoadSDNodeBits.ExtTy);
2706  }
2707 
2708  static bool classof(const SDNode *N) {
2709  return N->getOpcode() == ISD::MGATHER;
2710  }
2711 };
2712 
2713 /// This class is used to represent an MSCATTER node
2714 ///
2716 public:
2717  friend class SelectionDAG;
2718 
2719  MaskedScatterSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2720  EVT MemVT, MachineMemOperand *MMO,
2721  ISD::MemIndexType IndexType, bool IsTrunc)
2722  : MaskedGatherScatterSDNode(ISD::MSCATTER, Order, dl, VTs, MemVT, MMO,
2723  IndexType) {
2724  StoreSDNodeBits.IsTruncating = IsTrunc;
2725  }
2726 
2727  /// Return true if the op does a truncation before store.
2728  /// For integers this is the same as doing a TRUNCATE and storing the result.
2729  /// For floats, it is the same as doing an FP_ROUND and storing the result.
2730  bool isTruncatingStore() const { return StoreSDNodeBits.IsTruncating; }
2731 
2732  const SDValue &getValue() const { return getOperand(1); }
2733 
2734  static bool classof(const SDNode *N) {
2735  return N->getOpcode() == ISD::MSCATTER;
2736  }
2737 };
2738 
2739 /// An SDNode that represents everything that will be needed
2740 /// to construct a MachineInstr. These nodes are created during the
2741 /// instruction selection proper phase.
2742 ///
2743 /// Note that the only supported way to set the `memoperands` is by calling the
2744 /// `SelectionDAG::setNodeMemRefs` function as the memory management happens
2745 /// inside the DAG rather than in the node.
2746 class MachineSDNode : public SDNode {
2747 private:
2748  friend class SelectionDAG;
2749 
2750  MachineSDNode(unsigned Opc, unsigned Order, const DebugLoc &DL, SDVTList VTs)
2751  : SDNode(Opc, Order, DL, VTs) {}
2752 
2753  // We use a pointer union between a single `MachineMemOperand` pointer and
2754  // a pointer to an array of `MachineMemOperand` pointers. This is null when
2755  // the number of these is zero, the single pointer variant used when the
2756  // number is one, and the array is used for larger numbers.
2757  //
2758  // The array is allocated via the `SelectionDAG`'s allocator and so will
2759  // always live until the DAG is cleaned up and doesn't require ownership here.
2760  //
2761  // We can't use something simpler like `TinyPtrVector` here because `SDNode`
2762  // subclasses aren't managed in a conforming C++ manner. See the comments on
2763  // `SelectionDAG::MorphNodeTo` which details what all goes on, but the
2764  // constraint here is that these don't manage memory with their constructor or
2765  // destructor and can be initialized to a good state even if they start off
2766  // uninitialized.
2768 
2769  // Note that this could be folded into the above `MemRefs` member if doing so
2770  // is advantageous at some point. We don't need to store this in most cases.
2771  // However, at the moment this doesn't appear to make the allocation any
2772  // smaller and makes the code somewhat simpler to read.
2773  int NumMemRefs = 0;
2774 
2775 public:
2777 
2779  // Special case the common cases.
2780  if (NumMemRefs == 0)
2781  return {};
2782  if (NumMemRefs == 1)
2783  return makeArrayRef(MemRefs.getAddrOfPtr1(), 1);
2784 
2785  // Otherwise we have an actual array.
2786  return makeArrayRef(MemRefs.get<MachineMemOperand **>(), NumMemRefs);
2787  }
2788  mmo_iterator memoperands_begin() const { return memoperands().begin(); }
2789  mmo_iterator memoperands_end() const { return memoperands().end(); }
2790  bool memoperands_empty() const { return memoperands().empty(); }
2791 
2792  /// Clear out the memory reference descriptor list.
2793  void clearMemRefs() {
2794  MemRefs = nullptr;
2795  NumMemRefs = 0;
2796  }
2797 
2798  static bool classof(const SDNode *N) {
2799  return N->isMachineOpcode();
2800  }
2801 };
2802 
2803 /// An SDNode that records if a register contains a value that is guaranteed to
2804 /// be aligned accordingly.
2805 class AssertAlignSDNode : public SDNode {
2806  Align Alignment;
2807 
2808 public:
2809  AssertAlignSDNode(unsigned Order, const DebugLoc &DL, EVT VT, Align A)
2810  : SDNode(ISD::AssertAlign, Order, DL, getSDVTList(VT)), Alignment(A) {}
2811 
2812  Align getAlign() const { return Alignment; }
2813 
2814  static bool classof(const SDNode *N) {
2815  return N->getOpcode() == ISD::AssertAlign;
2816  }
2817 };
2818 
2820  const SDNode *Node;
2821  unsigned Operand;
2822 
2823  SDNodeIterator(const SDNode *N, unsigned Op) : Node(N), Operand(Op) {}
2824 
2825 public:
2826  using iterator_category = std::forward_iterator_tag;
2828  using difference_type = std::ptrdiff_t;
2829  using pointer = value_type *;
2831 
2832  bool operator==(const SDNodeIterator& x) const {
2833  return Operand == x.Operand;
2834  }
2835  bool operator!=(const SDNodeIterator& x) const { return !operator==(x); }
2836 
2837  pointer operator*() const {
2838  return Node->getOperand(Operand).getNode();
2839  }
2840  pointer operator->() const { return operator*(); }
2841 
2842  SDNodeIterator& operator++() { // Preincrement
2843  ++Operand;
2844  return *this;
2845  }
2846  SDNodeIterator operator++(int) { // Postincrement
2847  SDNodeIterator tmp = *this; ++*this; return tmp;
2848  }
2849  size_t operator-(SDNodeIterator Other) const {
2850  assert(Node == Other.Node &&
2851  "Cannot compare iterators of two different nodes!");
2852  return Operand - Other.Operand;
2853  }
2854 
2855  static SDNodeIterator begin(const SDNode *N) { return SDNodeIterator(N, 0); }
2856  static SDNodeIterator end (const SDNode *N) {
2857  return SDNodeIterator(N, N->getNumOperands());
2858  }
2859 
2860  unsigned getOperand() const { return Operand; }
2861  const SDNode *getNode() const { return Node; }
2862 };
2863 
2864 template <> struct GraphTraits<SDNode*> {
2865  using NodeRef = SDNode *;
2867 
2868  static NodeRef getEntryNode(SDNode *N) { return N; }
2869 
2871  return SDNodeIterator::begin(N);
2872  }
2873 
2875  return SDNodeIterator::end(N);
2876  }
2877 };
2878 
2879 /// A representation of the largest SDNode, for use in sizeof().
2880 ///
2881 /// This needs to be a union because the largest node differs on 32 bit systems
2882 /// with 4 and 8 byte pointer alignment, respectively.
2883 using LargestSDNode = AlignedCharArrayUnion<AtomicSDNode, TargetIndexSDNode,
2884  BlockAddressSDNode,
2885  GlobalAddressSDNode,
2887 
2888 /// The SDNode class with the greatest alignment requirement.
2890 
2891 namespace ISD {
2892 
2893  /// Returns true if the specified node is a non-extending and unindexed load.
2894  inline bool isNormalLoad(const SDNode *N) {
2895  const LoadSDNode *Ld = dyn_cast<LoadSDNode>(N);
2896  return Ld && Ld->getExtensionType() == ISD::NON_EXTLOAD &&
2898  }
2899 
2900  /// Returns true if the specified node is a non-extending load.
2901  inline bool isNON_EXTLoad(const SDNode *N) {
2902  return isa<LoadSDNode>(N) &&
2903  cast<LoadSDNode>(N)->getExtensionType() == ISD::NON_EXTLOAD;
2904  }
2905 
2906  /// Returns true if the specified node is a EXTLOAD.
2907  inline bool isEXTLoad(const SDNode *N) {
2908  return isa<LoadSDNode>(N) &&
2909  cast<LoadSDNode>(N)->getExtensionType() == ISD::EXTLOAD;
2910  }
2911 
2912  /// Returns true if the specified node is a SEXTLOAD.
2913  inline bool isSEXTLoad(const SDNode *N) {
2914  return isa<LoadSDNode>(N) &&
2915  cast<LoadSDNode>(N)->getExtensionType() == ISD::SEXTLOAD;
2916  }
2917 
2918  /// Returns true if the specified node is a ZEXTLOAD.
2919  inline bool isZEXTLoad(const SDNode *N) {
2920  return isa<LoadSDNode>(N) &&
2921  cast<LoadSDNode>(N)->getExtensionType() == ISD::ZEXTLOAD;
2922  }
2923 
2924  /// Returns true if the specified node is an unindexed load.
2925  inline bool isUNINDEXEDLoad(const SDNode *N) {
2926  return isa<LoadSDNode>(N) &&
2927  cast<LoadSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
2928  }
2929 
2930  /// Returns true if the specified node is a non-truncating
2931  /// and unindexed store.
2932  inline bool isNormalStore(const SDNode *N) {
2933  const StoreSDNode *St = dyn_cast<StoreSDNode>(N);
2934  return St && !St->isTruncatingStore() &&
2936  }
2937 
2938  /// Returns true if the specified node is an unindexed store.
2939  inline bool isUNINDEXEDStore(const SDNode *N) {
2940  return isa<StoreSDNode>(N) &&
2941  cast<StoreSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
2942  }
2943 
2944  /// Attempt to match a unary predicate against a scalar/splat constant or
2945  /// every element of a constant BUILD_VECTOR.
2946  /// If AllowUndef is true, then UNDEF elements will pass nullptr to Match.
2948  std::function<bool(ConstantSDNode *)> Match,
2949  bool AllowUndefs = false);
2950 
2951  /// Attempt to match a binary predicate against a pair of scalar/splat
2952  /// constants or every element of a pair of constant BUILD_VECTORs.
2953  /// If AllowUndef is true, then UNDEF elements will pass nullptr to Match.
2954  /// If AllowTypeMismatch is true then RetType + ArgTypes don't need to match.
2955  bool matchBinaryPredicate(
2956  SDValue LHS, SDValue RHS,
2957  std::function<bool(ConstantSDNode *, ConstantSDNode *)> Match,
2958  bool AllowUndefs = false, bool AllowTypeMismatch = false);
2959 
2960  /// Returns true if the specified value is the overflow result from one
2961  /// of the overflow intrinsic nodes.
2963  unsigned Opc = Op.getOpcode();
2964  return (Op.getResNo() == 1 &&
2965  (Opc == ISD::SADDO || Opc == ISD::UADDO || Opc == ISD::SSUBO ||
2966  Opc == ISD::USUBO || Opc == ISD::SMULO || Opc == ISD::UMULO));
2967  }
2968 
2969 } // end namespace ISD
2970 
2971 } // end namespace llvm
2972 
2973 #endif // LLVM_CODEGEN_SELECTIONDAGNODES_H
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::SDNode::getConstantOperandVal
uint64_t getConstantOperandVal(unsigned Num) const
Helper method returns the integer value of a ConstantSDNode operand.
Definition: SelectionDAGNodes.h:1597
llvm::AddrSpaceCastSDNode::AddrSpaceCastSDNode
AddrSpaceCastSDNode(unsigned Order, const DebugLoc &dl, EVT VT, unsigned SrcAS, unsigned DestAS)
Definition: SelectionDAG.cpp:10132
i
i
Definition: README.txt:29
llvm::ISD::ExternalSymbol
@ ExternalSymbol
Definition: ISDOpcodes.h:83
llvm::ISD::isUNINDEXEDStore
bool isUNINDEXEDStore(const SDNode *N)
Returns true if the specified node is an unindexed store.
Definition: SelectionDAGNodes.h:2939
llvm::SDNodeFlags::hasAllowReciprocal
bool hasAllowReciprocal() const
Definition: SelectionDAGNodes.h:430
llvm::MCSymbolSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2206
llvm::SDNode::use_iterator::use_iterator
use_iterator()=default
llvm::LoadSDNode::getOffset
const SDValue & getOffset() const
Definition: SelectionDAGNodes.h:2301
set
We currently generate a but we really shouldn eax ecx xorl edx divl ecx eax divl ecx movl eax ret A similar code sequence works for division We currently compile i32 v2 eax eax jo LBB1_2 atomic and others It is also currently not done for read modify write instructions It is also current not done if the OF or CF flags are needed The shift operators have the complication that when the shift count is EFLAGS is not set
Definition: README.txt:1277
ValueTypes.h
llvm::SDNode::StoreSDNodeBits
StoreSDNodeBitfields StoreSDNodeBits
Definition: SelectionDAGNodes.h:563
llvm::ShuffleVectorSDNode::getSplatIndex
int getSplatIndex() const
Definition: SelectionDAGNodes.h:1522
llvm::ConstantSDNode
Definition: SelectionDAGNodes.h:1556
llvm::RegisterSDNode
Definition: SelectionDAGNodes.h:2098
llvm::MaskedLoadSDNode::getExtensionType
ISD::LoadExtType getExtensionType() const
Definition: SelectionDAGNodes.h:2504
llvm::SDNode::Profile
void Profile(FoldingSetNodeID &ID) const
Gather unique data for the node.
Definition: SelectionDAG.cpp:10156
llvm::MachineMemOperand::isStore
bool isStore() const
Definition: MachineMemOperand.h:289
llvm::StoreSDNode::getBasePtr
const SDValue & getBasePtr() const
Definition: SelectionDAGNodes.h:2331
llvm::isConstOrConstSplat
ConstantSDNode * isConstOrConstSplat(SDValue N, bool AllowUndefs=false, bool AllowTruncation=false)
Returns the SDNode if it is a constant splat BuildVector or constant int.
Definition: SelectionDAG.cpp:10005
llvm::ISD::VECTOR_SHUFFLE
@ VECTOR_SHUFFLE
VECTOR_SHUFFLE(VEC1, VEC2) - Returns a vector, of the same type as VEC1/VEC2.
Definition: ISDOpcodes.h:563
llvm::SDValue::dump
void dump() const
Definition: SelectionDAGNodes.h:1173
llvm::ISD::INTRINSIC_VOID
@ INTRINSIC_VOID
OUTCHAIN = INTRINSIC_VOID(INCHAIN, INTRINSICID, arg1, arg2, ...) This node represents a target intrin...
Definition: ISDOpcodes.h:199
llvm::ISD::isOverflowIntrOpRes
bool isOverflowIntrOpRes(SDValue Op)
Returns true if the specified value is the overflow result from one of the overflow intrinsic nodes.
Definition: SelectionDAGNodes.h:2962
llvm::SDUse
Represents a use of a SDNode.
Definition: SelectionDAGNodes.h:277
llvm::ISD::MemIndexedMode
MemIndexedMode
MemIndexedMode enum - This enum defines the load / store indexed addressing modes.
Definition: ISDOpcodes.h:1310
llvm::AddrSpaceCastSDNode::getSrcAddressSpace
unsigned getSrcAddressSpace() const
Definition: SelectionDAGNodes.h:1245
llvm::isConstOrConstSplatFP
ConstantFPSDNode * isConstOrConstSplatFP(SDValue N, bool AllowUndefs=false)
Returns the SDNode if it is a constant splat BuildVector or constant float.
Definition: SelectionDAG.cpp:10064
llvm::MaskedLoadStoreSDNode::getMask
const SDValue & getMask() const
Definition: SelectionDAGNodes.h:2469
llvm::MaskedGatherSDNode
This class is used to represent an MGATHER node.
Definition: SelectionDAGNodes.h:2690
llvm::ISD::UMULO
@ UMULO
Definition: ISDOpcodes.h:319
llvm::VPLoadSDNode::getOffset
const SDValue & getOffset() const
Definition: SelectionDAGNodes.h:2404
llvm::MemSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1377
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
Reg
unsigned Reg
Definition: MachineSink.cpp:1566
llvm::ISD::JumpTable
@ JumpTable
Definition: ISDOpcodes.h:81
llvm::LifetimeSDNode::getSize
int64_t getSize() const
Definition: SelectionDAGNodes.h:1783
llvm::SDNode::getIROrder
unsigned getIROrder() const
Return the node ordering.
Definition: SelectionDAGNodes.h:713
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
llvm::objcarc::Sequence
Sequence
Definition: PtrState.h:41
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::SDNode::getValueType
EVT getValueType(unsigned ResNo) const
Return the type of a specified result.
Definition: SelectionDAGNodes.h:966
llvm::SDNodeFlags::setNoSignedZeros
void setNoSignedZeros(bool b)
Definition: SelectionDAGNodes.h:416
llvm::make_range
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Definition: iterator_range.h:53
llvm::SDNode::value_op_iterator::operator*
const SDValue & operator*() const
Definition: SelectionDAGNodes.h:924
llvm::VPStoreSDNode::getVectorLength
const SDValue & getVectorLength() const
Definition: SelectionDAGNodes.h:2442
llvm::SDLoc
Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation funct...
Definition: SelectionDAGNodes.h:1086
llvm::VPLoadSDNode::getVectorLength
const SDValue & getVectorLength() const
Definition: SelectionDAGNodes.h:2406
Metadata.h
llvm::ISD::LIFETIME_END
@ LIFETIME_END
Definition: ISDOpcodes.h:1178
llvm::VPStoreSDNode::getMask
const SDValue & getMask() const
Definition: SelectionDAGNodes.h:2441
llvm::simplify_type< SDValue >::getSimplifiedValue
static SimpleType getSimplifiedValue(SDValue &Val)
Definition: SelectionDAGNodes.h:260
llvm::SDNode::setIROrder
void setIROrder(unsigned Order)
Set the node ordering.
Definition: SelectionDAGNodes.h:716
llvm::MachineMemOperand::getAlign
Align getAlign() const
Return the minimum known alignment in bytes of the actual memory reference.
Definition: MachineOperand.cpp:1087
llvm::ConstantSDNode::getAPIntValue
const APInt & getAPIntValue() const
Definition: SelectionDAGNodes.h:1570
llvm::SDValue::use_empty
bool use_empty() const
Return true if there are no nodes using value ResNo of Node.
Definition: SelectionDAGNodes.h:1161
llvm::ConstantFPSDNode::isNegative
bool isNegative() const
Return true if the value is negative.
Definition: SelectionDAGNodes.h:1629
llvm::ISD::NON_EXTLOAD
@ NON_EXTLOAD
Definition: ISDOpcodes.h:1341
AtomicOrdering.h
llvm::VPGatherScatterSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2602
llvm::EVT::getFixedSizeInBits
uint64_t getFixedSizeInBits() const
Return the size of the specified fixed width value type in bits.
Definition: ValueTypes.h:349
llvm::AssertAlignSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2814
llvm::ISD::ATOMIC_LOAD_UMAX
@ ATOMIC_LOAD_UMAX
Definition: ISDOpcodes.h:1150
llvm::SDValue::getNode
SDNode * getNode() const
get the SDNode which holds the desired result
Definition: SelectionDAGNodes.h:152
llvm::isOneConstant
bool isOneConstant(SDValue V)
Returns true if V is a constant integer one.
Definition: SelectionDAG.cpp:9972
llvm::SDNode::use_size
size_t use_size() const
Return the number of uses of this node.
Definition: SelectionDAGNodes.h:704
llvm::ISD::ConstantFP
@ ConstantFP
Definition: ISDOpcodes.h:77
llvm::VPStoreSDNode::getOffset
const SDValue & getOffset() const
Definition: SelectionDAGNodes.h:2440
llvm::VPLoadStoreSDNode
This base class is used to represent VP_LOAD and VP_STORE nodes.
Definition: SelectionDAGNodes.h:2340
llvm::VPGatherScatterSDNode::isIndexScaled
bool isIndexScaled() const
Definition: SelectionDAGNodes.h:2573
llvm::ISD::LIFETIME_START
@ LIFETIME_START
This corresponds to the llvm.lifetime.
Definition: ISDOpcodes.h:1177
llvm::SDNode::getMaxNumOperands
static constexpr size_t getMaxNumOperands()
Return the maximum number of operands that a SDNode can hold.
Definition: SelectionDAGNodes.h:894
llvm::SDNodeFlags::setAllowContract
void setAllowContract(bool b)
Definition: SelectionDAGNodes.h:418
llvm::ISD::UADDO
@ UADDO
Definition: ISDOpcodes.h:311
llvm::SDNode::intersectFlagsWith
void intersectFlagsWith(const SDNodeFlags Flags)
Clear any flags in this node that aren't also set in Flags.
Definition: SelectionDAG.cpp:10313
llvm::ISD::ATOMIC_LOAD_CLR
@ ATOMIC_LOAD_CLR
Definition: ISDOpcodes.h:1143
llvm::SDNode::use_iterator::atEnd
bool atEnd() const
Return true if this iterator is at the end of uses list.
Definition: SelectionDAGNodes.h:752
llvm::SDNode::isUndef
bool isUndef() const
Return true if the type of the node type undefined.
Definition: SelectionDAGNodes.h:652
llvm::SDNode::isTargetStrictFPOpcode
bool isTargetStrictFPOpcode() const
Test if this node has a target-specific opcode that may raise FP exceptions (in the <target>ISD names...
Definition: SelectionDAGNodes.h:640
llvm::BuildVectorSDNode::getConstantFPSplatPow2ToLog2Int
int32_t getConstantFPSplatPow2ToLog2Int(BitVector *UndefElements, uint32_t BitWidth) const
If this is a constant FP splat and the splatted constant FP is an exact power or 2,...
Definition: SelectionDAG.cpp:10901
llvm::TargetIndexSDNode::getOffset
int64_t getOffset() const
Definition: SelectionDAGNodes.h:1919
llvm::DenseMapInfo< SDValue >::isEqual
static bool isEqual(const SDValue &LHS, const SDValue &RHS)
Definition: SelectionDAGNodes.h:250
llvm::SDNode::op_values
iterator_range< value_op_iterator > op_values() const
Definition: SelectionDAGNodes.h:927
llvm::AtomicSDNode::isCompareAndSwap
bool isCompareAndSwap() const
Returns true if this SDNode represents cmpxchg atomic operation, false otherwise.
Definition: SelectionDAGNodes.h:1432
TypeSize.h
llvm::ISD::MLOAD
@ MLOAD
Definition: ISDOpcodes.h:1160
llvm::MemSDNode::getSyncScopeID
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID for this memory operation.
Definition: SelectionDAGNodes.h:1310
op
#define op(i)
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
llvm::ISD::SIGNED_SCALED
@ SIGNED_SCALED
Definition: ISDOpcodes.h:1323
llvm::SDNodeFlags::hasNoNaNs
bool hasNoNaNs() const
Definition: SelectionDAGNodes.h:427
llvm::MemSDNode::getMergedOrdering
AtomicOrdering getMergedOrdering() const
Return a single atomic ordering that is at least as strong as both the success and failure orderings ...
Definition: SelectionDAGNodes.h:1322
llvm::MaskedStoreSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2549
llvm::MachineMemOperand::isLoad
bool isLoad() const
Definition: MachineMemOperand.h:288
llvm::MachineMemOperand::getOffset
int64_t getOffset() const
For normal values, this is a byte offset added to the base address.
Definition: MachineMemOperand.h:227
llvm::ISD::CONDCODE
@ CONDCODE
Definition: ISDOpcodes.h:73
llvm::iterator_adaptor_base< value_op_iterator, op_iterator, std::random_access_iterator_tag, SDValue, ptrdiff_t, value_op_iterator *, value_op_iterator * >::I
op_iterator I
Definition: iterator.h:235
llvm::ISD::TargetIndex
@ TargetIndex
TargetIndex - Like a constant pool entry, but with completely target-dependent semantics.
Definition: ISDOpcodes.h:177
llvm::SDVTList::NumVTs
unsigned int NumVTs
Definition: SelectionDAGNodes.h:81
llvm::MachineSDNode
An SDNode that represents everything that will be needed to construct a MachineInstr.
Definition: SelectionDAGNodes.h:2746
llvm::ConstantSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1591
llvm::SDNodeFlags::SDNodeFlags
SDNodeFlags()
Default constructor turns off all optimization flags.
Definition: SelectionDAGNodes.h:393
ErrorHandling.h
llvm::isBitwiseNot
bool isBitwiseNot(SDValue V, bool AllowUndefs=false)
Returns true if V is a bitwise not operation.
Definition: SelectionDAG.cpp:9995
llvm::SDValue::SDValue
SDValue()=default
llvm::ISD::MGATHER
@ MGATHER
Definition: ISDOpcodes.h:1172
llvm::VTSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2242
llvm::SDNodeIterator::operator->
pointer operator->() const
Definition: SelectionDAGNodes.h:2840
llvm::LifetimeSDNode::hasOffset
bool hasOffset() const
Definition: SelectionDAGNodes.h:1778
llvm::ShuffleVectorSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1551
llvm::ISD::EH_LABEL
@ EH_LABEL
EH_LABEL - Represents a label in mid basic block used to track locations needed for debug and excepti...
Definition: ISDOpcodes.h:988
llvm::MachineSDNode::memoperands_begin
mmo_iterator memoperands_begin() const
Definition: SelectionDAGNodes.h:2788
llvm::HandleSDNode
This class is used to form a handle around another node that is persistent and is updated across invo...
Definition: SelectionDAGNodes.h:1212
llvm::ISD::MemIndexType
MemIndexType
MemIndexType enum - This enum defines how to interpret MGATHER/SCATTER's index parameter when calcula...
Definition: ISDOpcodes.h:1322
llvm::MemSDNode::getMemoryVT
EVT getMemoryVT() const
Return the type of the in-memory value.
Definition: SelectionDAGNodes.h:1336
llvm::MemSDNode::getChain
const SDValue & getChain() const
Definition: SelectionDAGNodes.h:1359
llvm::LifetimeSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1789
llvm::SDNode
Represents one node in the SelectionDAG.
Definition: SelectionDAGNodes.h:455
llvm::GlobalAddressSDNode::getTargetFlags
unsigned getTargetFlags() const
Definition: SelectionDAGNodes.h:1732
llvm::ConstantPool
Definition: ConstantPools.h:43
llvm::ConstantSDNode::isAllOnes
bool isAllOnes() const
Definition: SelectionDAGNodes.h:1583
llvm::SDNodeIterator::operator-
size_t operator-(SDNodeIterator Other) const
Definition: SelectionDAGNodes.h:2849
llvm::VPLoadStoreSDNode::isIndexed
bool isIndexed() const
Return true if this is a pre/post inc/dec load/store.
Definition: SelectionDAGNodes.h:2376
llvm::LoadSDNode
This class is used to represent ISD::LOAD nodes.
Definition: SelectionDAGNodes.h:2281
llvm::MVT::Glue
@ Glue
Definition: MachineValueType.h:262
llvm::RegisterMaskSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2127
llvm::SDNode::use_iterator
This class provides iterator support for SDUse operands that use a specific SDNode.
Definition: SelectionDAGNodes.h:727
llvm::VPLoadSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2408
llvm::MaskedGatherScatterSDNode::getMask
const SDValue & getMask() const
Definition: SelectionDAGNodes.h:2679
llvm::MachineSDNode::memoperands_empty
bool memoperands_empty() const
Definition: SelectionDAGNodes.h:2790
llvm::MachineConstantPoolValue
Abstract base class for all machine specific constantpool value subclasses.
Definition: MachineConstantPool.h:35
llvm::Depth
@ Depth
Definition: SIMachineScheduler.h:36
llvm::MemIntrinsicSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1481
llvm::AAMDNodes
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:651
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::VPLoadStoreSDNode::isUnindexed
bool isUnindexed() const
Return true if this is NOT a pre/post inc/dec load/store.
Definition: SelectionDAGNodes.h:2379
llvm::MemSDNode::getBasePtr
const SDValue & getBasePtr() const
Definition: SelectionDAGNodes.h:1361
llvm::MachineMemOperand
A description of a memory reference used in the backend.
Definition: MachineMemOperand.h:128
llvm::iterator_adaptor_base
CRTP base class for adapting an iterator to a different type.
Definition: iterator.h:229
llvm::VPGatherScatterSDNode::getBasePtr
const SDValue & getBasePtr() const
Definition: SelectionDAGNodes.h:2586
llvm::MaskedLoadSDNode::MaskedLoadSDNode
MaskedLoadSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, ISD::MemIndexedMode AM, ISD::LoadExtType ETy, bool IsExpanding, EVT MemVT, MachineMemOperand *MMO)
Definition: SelectionDAGNodes.h:2496
llvm::SDNode::StoreSDNodeBitfields
Definition: SelectionDAGNodes.h:543
llvm::LargestSDNode
AlignedCharArrayUnion< AtomicSDNode, TargetIndexSDNode, BlockAddressSDNode, GlobalAddressSDNode, PseudoProbeSDNode > LargestSDNode
A representation of the largest SDNode, for use in sizeof().
Definition: SelectionDAGNodes.h:2886
llvm::MaskedStoreSDNode
This class is used to represent an MSTORE node.
Definition: SelectionDAGNodes.h:2521
llvm::SDValue::isTargetOpcode
bool isTargetOpcode() const
Definition: SelectionDAGNodes.h:1141
isBigEndian
static Optional< bool > isBigEndian(const SmallDenseMap< int64_t, int64_t, 8 > &MemOffset2Idx, int64_t LowestIdx)
Given a map from byte offsets in memory to indices in a load/store, determine if that map corresponds...
Definition: CombinerHelper.cpp:109
llvm::LabelSDNode::getLabel
MCSymbol * getLabel() const
Definition: SelectionDAGNodes.h:2166
llvm::VPGatherSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2619
llvm::SDNode::isPredecessorOf
bool isPredecessorOf(const SDNode *N) const
Return true if this node is a predecessor of N.
Definition: SelectionDAGNodes.h:813
llvm::SDNode::MemSDNodeBits
MemSDNodeBitfields MemSDNodeBits
Definition: SelectionDAGNodes.h:560
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::MemSDNode
This is an abstract virtual class for memory operations.
Definition: SelectionDAGNodes.h:1254
llvm::VPLoadSDNode::VPLoadSDNode
VPLoadSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, ISD::MemIndexedMode AM, ISD::LoadExtType ETy, bool isExpanding, EVT MemVT, MachineMemOperand *MMO)
Definition: SelectionDAGNodes.h:2391
llvm::SDNodeFlags::setAllowReassociation
void setAllowReassociation(bool b)
Definition: SelectionDAGNodes.h:420
llvm::SDNode::printrFull
void printrFull(raw_ostream &O, const SelectionDAG *G=nullptr) const
Print a SelectionDAG node and all children down to the leaves.
Definition: SelectionDAGDumper.cpp:1031
llvm::SDNodeIterator::getOperand
unsigned getOperand() const
Definition: SelectionDAGNodes.h:2860
llvm::ISD::isConstantSplatVectorAllZeros
bool isConstantSplatVectorAllZeros(const SDNode *N, bool BuildVectorOnly=false)
Return true if the specified node is a BUILD_VECTOR or SPLAT_VECTOR where all of the elements are 0 o...
Definition: SelectionDAG.cpp:220
llvm::SDNode::NumMemSDNodeBits
@ NumMemSDNodeBits
Definition: SelectionDAGNodes.h:508
Operator.h
llvm::VPLoadSDNode::isExpandingLoad
bool isExpandingLoad() const
Definition: SelectionDAGNodes.h:2411
llvm::ConstantSDNode::isZero
bool isZero() const
Definition: SelectionDAGNodes.h:1580
llvm::AddrSpaceCastSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1248
llvm::simplify_type< const SDValue >::getSimplifiedValue
static SimpleType getSimplifiedValue(const SDValue &Val)
Definition: SelectionDAGNodes.h:267
llvm::AtomicSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1446
AlignOf.h
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:116
llvm::SDNode::printr
void printr(raw_ostream &OS, const SelectionDAG *G=nullptr) const
Definition: SelectionDAGDumper.cpp:939
llvm::ISD::EXTLOAD
@ EXTLOAD
Definition: ISDOpcodes.h:1341
llvm::SmallVectorImpl::pop_back_val
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:635
llvm::LSBaseSDNode::isIndexed
bool isIndexed() const
Return true if this is a pre/post inc/dec load/store.
Definition: SelectionDAGNodes.h:2269
llvm::FPMathOperator::hasNoNaNs
bool hasNoNaNs() const
Test if this operation's arguments and results are assumed not-NaN.
Definition: Operator.h:337
llvm::SDNodeIterator::iterator_category
std::forward_iterator_tag iterator_category
Definition: SelectionDAGNodes.h:2826
llvm::HandleSDNode::HandleSDNode
HandleSDNode(SDValue X)
Definition: SelectionDAGNodes.h:1216
llvm::AssertAlignSDNode::getAlign
Align getAlign() const
Definition: SelectionDAGNodes.h:2812
llvm::SDNode::SDNodeBitfields
Definition: SelectionDAGNodes.h:476
llvm::MaskedGatherScatterSDNode
This is a base class used to represent MGATHER and MSCATTER nodes.
Definition: SelectionDAGNodes.h:2645
llvm::VPLoadStoreSDNode::getMask
const SDValue & getMask() const
Definition: SelectionDAGNodes.h:2362
tmp
alloca< 16 x float >, align 16 %tmp2=alloca< 16 x float >, align 16 store< 16 x float > %A,< 16 x float > *%tmp %s=bitcast< 16 x float > *%tmp to i8 *%s2=bitcast< 16 x float > *%tmp2 to i8 *call void @llvm.memcpy.i64(i8 *%s, i8 *%s2, i64 64, i32 16) %R=load< 16 x float > *%tmp2 ret< 16 x float > %R } declare void @llvm.memcpy.i64(i8 *nocapture, i8 *nocapture, i64, i32) nounwind which compiles to:_foo:subl $140, %esp movaps %xmm3, 112(%esp) movaps %xmm2, 96(%esp) movaps %xmm1, 80(%esp) movaps %xmm0, 64(%esp) movl 60(%esp), %eax movl %eax, 124(%esp) movl 56(%esp), %eax movl %eax, 120(%esp) movl 52(%esp), %eax< many many more 32-bit copies > movaps(%esp), %xmm0 movaps 16(%esp), %xmm1 movaps 32(%esp), %xmm2 movaps 48(%esp), %xmm3 addl $140, %esp ret On Nehalem, it may even be cheaper to just use movups when unaligned than to fall back to lower-granularity chunks. Implement processor-specific optimizations for parity with GCC on these processors. GCC does two optimizations:1. ix86_pad_returns inserts a noop before ret instructions if immediately preceded by a conditional branch or is the target of a jump. 2. ix86_avoid_jump_misspredicts inserts noops in cases where a 16-byte block of code contains more than 3 branches. The first one is done for all AMDs, Core2, and "Generic" The second one is done for:Atom, Pentium Pro, all AMDs, Pentium 4, Nocona, Core 2, and "Generic" Testcase:int x(int a) { return(a &0xf0)> >4 tmp
Definition: README.txt:1347
llvm::VPStoreSDNode::getValue
const SDValue & getValue() const
Definition: SelectionDAGNodes.h:2438
llvm::SDNodeIterator::difference_type
std::ptrdiff_t difference_type
Definition: SelectionDAGNodes.h:2828
llvm::SDNode::isDivergent
bool isDivergent() const
Definition: SelectionDAGNodes.h:694
llvm::SDNode::use_iterator::operator*
SDNode * operator*() const
Retrieve a pointer to the current user node.
Definition: SelectionDAGNodes.h:766
llvm::BlockAddressSDNode
Definition: SelectionDAGNodes.h:2132
llvm::ConstantPoolSDNode::getAlign
Align getAlign() const
Definition: SelectionDAGNodes.h:1893
llvm::SDNode::use_iterator::iterator_category
std::forward_iterator_tag iterator_category
Definition: SelectionDAGNodes.h:735
llvm::MachineMemOperand::getAAInfo
AAMDNodes getAAInfo() const
Return the AA tags for the memory reference.
Definition: MachineMemOperand.h:258
llvm::MachineMemOperand::isUnordered
bool isUnordered() const
Returns true if this memory operation doesn't have any ordering constraints other than normal aliasin...
Definition: MachineMemOperand.h:304
llvm::ArrayRef::const_iterator
const_pointer const_iterator
Definition: ArrayRef.h:51
llvm::BitmaskEnumDetail::Mask
std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:80
llvm::GraphTraits< SDNode * >::child_end
static ChildIteratorType child_end(NodeRef N)
Definition: SelectionDAGNodes.h:2874
llvm::SDNode::RawSDNodeBits
char RawSDNodeBits[sizeof(uint16_t)]
Definition: SelectionDAGNodes.h:557
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::PointerUnion::get
T get() const
Returns the value of the specified pointer type.
Definition: PointerUnion.h:158
llvm::SDUse::SDUse
SDUse()=default
p
the resulting code requires compare and branches when and if * p
Definition: README.txt:396
llvm::SDUse::get
const SDValue & get() const
If implicit conversion to SDValue doesn't work, the get() method returns the SDValue.
Definition: SelectionDAGNodes.h:297
llvm::MaskedScatterSDNode::isTruncatingStore
bool isTruncatingStore() const
Return true if the op does a truncation before store.
Definition: SelectionDAGNodes.h:2730
llvm::VPScatterSDNode::getValue
const SDValue & getValue() const
Definition: SelectionDAGNodes.h:2635
llvm::ConstantSDNode::getConstantIntValue
const ConstantInt * getConstantIntValue() const
Definition: SelectionDAGNodes.h:1569
llvm::ISD::ATOMIC_LOAD_OR
@ ATOMIC_LOAD_OR
Definition: ISDOpcodes.h:1144
llvm::SDUse::getResNo
unsigned getResNo() const
Convenience function for get().getResNo().
Definition: SelectionDAGNodes.h:308
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:198
llvm::SDNode::getVTList
SDVTList getVTList() const
Definition: SelectionDAGNodes.h:932
llvm::ConstantSDNode::getLimitedValue
uint64_t getLimitedValue(uint64_t Limit=UINT64_MAX)
Definition: SelectionDAGNodes.h:1573
llvm::MDNodeSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2093
llvm::MemSDNode::isUnordered
bool isUnordered() const
Returns true if the memory operation doesn't imply any ordering constraints on surrounding memory ope...
Definition: SelectionDAGNodes.h:1330
llvm::ShuffleVectorSDNode
This SDNode is used to implement the code generator support for the llvm IR shufflevector instruction...
Definition: SelectionDAGNodes.h:1498
llvm::FPMathOperator::hasNoInfs
bool hasNoInfs() const
Test if this operation's arguments and results are assumed not-infinite.
Definition: Operator.h:342
llvm::MaskedLoadStoreSDNode::isIndexed
bool isIndexed() const
Return true if this is a pre/post inc/dec load/store.
Definition: SelectionDAGNodes.h:2480
llvm::ConstantFPSDNode::isNaN
bool isNaN() const
Return true if the value is a NaN.
Definition: SelectionDAGNodes.h:1623
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::ISD::PSEUDO_PROBE
@ PSEUDO_PROBE
Pseudo probe for AutoFDO, as a place holder in a basic block to improve the sample counts quality.
Definition: ISDOpcodes.h:1197
llvm::SDNodeIterator::begin
static SDNodeIterator begin(const SDNode *N)
Definition: SelectionDAGNodes.h:2855
MachineValueType.h
llvm::SDNode::value_begin
value_iterator value_begin() const
Definition: SelectionDAGNodes.h:987
llvm::SDNodeFlags::setApproximateFuncs
void setApproximateFuncs(bool b)
Definition: SelectionDAGNodes.h:419
llvm::MaskedLoadSDNode::getPassThru
const SDValue & getPassThru() const
Definition: SelectionDAGNodes.h:2511
llvm::MaskedGatherSDNode::getPassThru
const SDValue & getPassThru() const
Definition: SelectionDAGNodes.h:2702
GraphTraits.h
llvm::ConstantFPSDNode::isValueValidForType
static bool isValueValidForType(EVT VT, const APFloat &Val)
Definition: SelectionDAG.cpp:124
llvm::SDNode::op_end
op_iterator op_end() const
Definition: SelectionDAGNodes.h:912
llvm::SDNodeFlags::copyFMF
void copyFMF(const FPMathOperator &FPMO)
Propagate the fast-math-flags from an IR FPMathOperator.
Definition: SelectionDAGNodes.h:400
llvm::MaskedLoadStoreSDNode
This base class is used to represent MLOAD and MSTORE nodes.
Definition: SelectionDAGNodes.h:2450
llvm::SDNode::SDNode
SDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs)
Create an SDNode.
Definition: SelectionDAGNodes.h:1064
llvm::MachineMemOperand::getPointerInfo
const MachinePointerInfo & getPointerInfo() const
Definition: MachineMemOperand.h:202
llvm::MemSDNode::isInvariant
bool isInvariant() const
Definition: SelectionDAGNodes.h:1298
Instruction.h
llvm::ISD::LoadExtType
LoadExtType
LoadExtType enum - This enum defines the three variants of LOADEXT (load with extension).
Definition: ISDOpcodes.h:1341
llvm::BlockAddressSDNode::getOffset
int64_t getOffset() const
Definition: SelectionDAGNodes.h:2146
llvm::HandleSDNode::getValue
const SDValue & getValue() const
Definition: SelectionDAGNodes.h:1233
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
llvm::DenseMapInfo
Definition: APInt.h:34
llvm::SDNode::getOpcode
unsigned getOpcode() const
Return the SelectionDAG opcode value for this node.
Definition: SelectionDAGNodes.h:629
llvm::AMDGPU::TargetIndex
TargetIndex
Definition: AMDGPU.h:338
llvm::SDNode::LoadSDNodeBits
LoadSDNodeBitfields LoadSDNodeBits
Definition: SelectionDAGNodes.h:562
llvm::StoreSDNode::setTruncatingStore
void setTruncatingStore(bool Truncating)
Definition: SelectionDAGNodes.h:2326
llvm::JumpTableSDNode::getTargetFlags
unsigned getTargetFlags() const
Definition: SelectionDAGNodes.h:1834
llvm::SDNode::SDNodeBits
SDNodeBitfields SDNodeBits
Definition: SelectionDAGNodes.h:558
llvm::ISD::GlobalAddress
@ GlobalAddress
Definition: ISDOpcodes.h:78
llvm::ExternalSymbolSDNode
Definition: SelectionDAGNodes.h:2174
llvm::SDNode::NumLSBaseSDNodeBits
@ NumLSBaseSDNodeBits
Definition: SelectionDAGNodes.h:528
llvm::SDValue::getValueType
EVT getValueType() const
Return the ValueType of the referenced return value.
Definition: SelectionDAGNodes.h:1121
llvm::SDValue::operator!=
bool operator!=(const SDValue &O) const
Definition: SelectionDAGNodes.h:162
llvm::MemIntrinsicSDNode
This SDNode is used for target intrinsics that touch memory and need an associated MachineMemOperand.
Definition: SelectionDAGNodes.h:1472
llvm::MutableArrayRef
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:307
llvm::SelectionDAG
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:216
Constants.h
llvm::MachineMemOperand::getBaseAlign
Align getBaseAlign() const
Return the minimum known alignment in bytes of the base address, without the offset.
Definition: MachineMemOperand.h:255
llvm::LoadSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2303
llvm::SDNode::hasOneUse
bool hasOneUse() const
Return true if there is exactly one use of this node.
Definition: SelectionDAGNodes.h:700
llvm::SDNode::areOnlyUsersOf
static bool areOnlyUsersOf(ArrayRef< const SDNode * > Nodes, const SDNode *N)
Return true if all the users of N are contained in Nodes.
Definition: SelectionDAG.cpp:10235
llvm::ISD::Constant
@ Constant
Definition: ISDOpcodes.h:76
llvm::ISD::isBuildVectorOfConstantFPSDNodes
bool isBuildVectorOfConstantFPSDNodes(const SDNode *N)
Return true if the specified node is a BUILD_VECTOR node of all ConstantFPSDNode or undef.
Definition: SelectionDAG.cpp:283
llvm::SmallVectorImpl::append
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:648
llvm::SDValue::reachesChainWithoutSideEffects
bool reachesChainWithoutSideEffects(SDValue Dest, unsigned Depth=2) const
Return true if this operand (which must be a chain) reaches the specified operand without crossing an...
Definition: SelectionDAG.cpp:10268
llvm::BuildVectorSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2054
llvm::User
Definition: User.h:44
llvm::SDNode::setFlags
void setFlags(SDNodeFlags NewFlags)
Definition: SelectionDAGNodes.h:956
llvm::EVT
Extended Value Type.
Definition: ValueTypes.h:35
llvm::MemSDNode::isDereferenceable
bool isDereferenceable() const
Definition: SelectionDAGNodes.h:1297
llvm::SDValue::operator==
bool operator==(const SDValue &O) const
Definition: SelectionDAGNodes.h:159
llvm::SDNodeIterator::operator++
SDNodeIterator operator++(int)
Definition: SelectionDAGNodes.h:2846
llvm::SDNode::isStrictFPOpcode
bool isStrictFPOpcode()
Test if this node is a strict floating point pseudo-op.
Definition: SelectionDAGNodes.h:666
llvm::JumpTableSDNode
Definition: SelectionDAGNodes.h:1821
llvm::EVT::getVectorNumElements
unsigned getVectorNumElements() const
Given a vector type, return the number of elements it contains.
Definition: ValueTypes.h:309
llvm::AtomicSDNode::getFailureOrdering
AtomicOrdering getFailureOrdering() const
For cmpxchg atomic operations, return the atomic ordering requirements when store does not occur.
Definition: SelectionDAGNodes.h:1440
llvm::VPScatterSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2637
llvm::ISD::STRICT_FP16_TO_FP
@ STRICT_FP16_TO_FP
Definition: ISDOpcodes.h:860
llvm::MaskedLoadStoreSDNode::MaskedLoadStoreSDNode
MaskedLoadStoreSDNode(ISD::NodeType NodeTy, unsigned Order, const DebugLoc &dl, SDVTList VTs, ISD::MemIndexedMode AM, EVT MemVT, MachineMemOperand *MMO)
Definition: SelectionDAGNodes.h:2454
llvm::MemIntrinsicSDNode::MemIntrinsicSDNode
MemIntrinsicSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemoryVT, MachineMemOperand *MMO)
Definition: SelectionDAGNodes.h:1474
llvm::BasicBlockSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1941
llvm::SDLoc::getIROrder
unsigned getIROrder() const
Definition: SelectionDAGNodes.h:1101
b
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int b
Definition: README.txt:418
llvm::MemSDNode::getRawSubclassData
unsigned getRawSubclassData() const
Return the SubclassData value, without HasDebugValue.
Definition: SelectionDAGNodes.h:1282
llvm::SDNode::dumprWithDepth
void dumprWithDepth(const SelectionDAG *G=nullptr, unsigned depth=100) const
printrWithDepth to dbgs().
Definition: SelectionDAGDumper.cpp:1038
llvm::TargetIndexSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1921
llvm::MaskedGatherScatterSDNode::setIndexType
void setIndexType(ISD::MemIndexType IndexType)
Definition: SelectionDAGNodes.h:2661
llvm::MaskedGatherScatterSDNode::MaskedGatherScatterSDNode
MaskedGatherScatterSDNode(ISD::NodeType NodeTy, unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemVT, MachineMemOperand *MMO, ISD::MemIndexType IndexType)
Definition: SelectionDAGNodes.h:2649
llvm::isIntOrFPConstant
bool isIntOrFPConstant(SDValue V)
Return true if V is either a integer or FP constant.
Definition: SelectionDAGNodes.h:1714
llvm::VPScatterSDNode
This class is used to represent an VP_SCATTER node.
Definition: SelectionDAGNodes.h:2626
UINT64_MAX
#define UINT64_MAX
Definition: DataTypes.h:77
llvm::FrameIndexSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1757
llvm::simplify_type
Definition: ilist_iterator.h:178
false
Definition: StackSlotColoring.cpp:142
llvm::SrcValueSDNode::getValue
const Value * getValue() const
Return the contained Value.
Definition: SelectionDAGNodes.h:2074
llvm::MaybeAlign
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:109
llvm::SDNode::ConstantSDNodeBitfields
Definition: SelectionDAGNodes.h:488
llvm::ShuffleVectorSDNode::isSplat
bool isSplat() const
Definition: SelectionDAGNodes.h:1520
llvm::ISD::NodeType
NodeType
ISD::NodeType enum - This enum defines the target-independent operators for a SelectionDAG.
Definition: ISDOpcodes.h:40
llvm::ISD::isUNINDEXEDLoad
bool isUNINDEXEDLoad(const SDNode *N)
Returns true if the specified node is an unindexed load.
Definition: SelectionDAGNodes.h:2925
llvm::SDNodeFlags::setExact
void setExact(bool b)
Definition: SelectionDAGNodes.h:413
llvm::ISD::ADDRSPACECAST
@ ADDRSPACECAST
ADDRSPACECAST - This operator converts between pointers of different address spaces.
Definition: ISDOpcodes.h:852
llvm::SDNode::uses
iterator_range< use_iterator > uses()
Definition: SelectionDAGNodes.h:789
llvm::ISD::ATOMIC_LOAD_AND
@ ATOMIC_LOAD_AND
Definition: ISDOpcodes.h:1142
llvm::SDNode::use_iterator::operator++
use_iterator & operator++()
Definition: SelectionDAGNodes.h:755
llvm::StoreSDNode::getOffset
const SDValue & getOffset() const
Definition: SelectionDAGNodes.h:2332
llvm::RegisterSDNode::getReg
Register getReg() const
Definition: SelectionDAGNodes.h:2107
llvm::MaskedLoadSDNode::getBasePtr
const SDValue & getBasePtr() const
Definition: SelectionDAGNodes.h:2508
llvm::MaskedStoreSDNode::getMask
const SDValue & getMask() const
Definition: SelectionDAGNodes.h:2547
llvm::Instruction
Definition: Instruction.h:45
llvm::rdf::NodeId
uint32_t NodeId
Definition: RDFGraph.h:260
llvm::ISD::MDNODE_SDNODE
@ MDNODE_SDNODE
MDNODE_SDNODE - This is a node that holdes an MDNode*, which is used to reference metadata in the IR.
Definition: ISDOpcodes.h:1057
llvm::ISD::ATOMIC_LOAD_UMIN
@ ATOMIC_LOAD_UMIN
Definition: ISDOpcodes.h:1149
llvm::LabelSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2168
llvm::ShuffleVectorSDNode::getMask
ArrayRef< int > getMask() const
Definition: SelectionDAGNodes.h:1510
llvm::peekThroughOneUseBitcasts
SDValue peekThroughOneUseBitcasts(SDValue V)
Return the non-bitcasted and one-use source operand of V if it exists.
Definition: SelectionDAG.cpp:9983
llvm::SDNodeIterator::operator==
bool operator==(const SDNodeIterator &x) const
Definition: SelectionDAGNodes.h:2832
llvm::BuildVectorSDNode::getSplatValue
SDValue getSplatValue(const APInt &DemandedElts, BitVector *UndefElements=nullptr) const
Returns the demanded splatted value or a null value if this is not a splat.
Definition: SelectionDAG.cpp:10784
llvm::SDNode::use_empty
bool use_empty() const
Return true if there are no uses of this node.
Definition: SelectionDAGNodes.h:697
llvm::DenseMapInfo< SDValue >::getHashValue
static unsigned getHashValue(const SDValue &Val)
Definition: SelectionDAGNodes.h:245
llvm::SDNode::isTargetOpcode
bool isTargetOpcode() const
Test if this node has a target-specific opcode (in the <target>ISD namespace).
Definition: SelectionDAGNodes.h:633
llvm::ISD::isBuildVectorOfConstantSDNodes
bool isBuildVectorOfConstantSDNodes(const SDNode *N)
Return true if the specified node is a BUILD_VECTOR node of all ConstantSDNode or undef.
Definition: SelectionDAG.cpp:270
llvm::VPStoreSDNode::getBasePtr
const SDValue & getBasePtr() const
Definition: SelectionDAGNodes.h:2439
llvm::isOneOrOneSplat
bool isOneOrOneSplat(SDValue V, bool AllowUndefs=false)
Return true if the value is a constant 1 integer or a splatted vector of a constant 1 integer (with n...
Definition: SelectionDAG.cpp:10106
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::ConstantFP
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:257
llvm::MaskedStoreSDNode::getValue
const SDValue & getValue() const
Definition: SelectionDAGNodes.h:2544
APFloat.h
This file declares a class to represent arbitrary precision floating point values and provide a varie...
llvm::ISD::ATOMIC_STORE
@ ATOMIC_STORE
OUTCHAIN = ATOMIC_STORE(INCHAIN, ptr, val) This corresponds to "store atomic" instruction.
Definition: ISDOpcodes.h:1118
llvm::LSBaseSDNode::isUnindexed
bool isUnindexed() const
Return true if this is NOT a pre/post inc/dec load/store.
Definition: SelectionDAGNodes.h:2272
llvm::FrameIndexSDNode
Definition: SelectionDAGNodes.h:1744
BitVector.h
llvm::ConstantSDNode::isMinSignedValue
bool isMinSignedValue() const
Definition: SelectionDAGNodes.h:1587
llvm::MaskedGatherSDNode::MaskedGatherSDNode
MaskedGatherSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemVT, MachineMemOperand *MMO, ISD::MemIndexType IndexType, ISD::LoadExtType ETy)
Definition: SelectionDAGNodes.h:2694
llvm::ISD::AssertAlign
@ AssertAlign
AssertAlign - These nodes record if a register contains a value that has a known alignment and the tr...
Definition: ISDOpcodes.h:68
DebugLoc.h
SmallPtrSet.h
llvm::SDNode::value_op_iterator::value_op_iterator
value_op_iterator(SDUse *U=nullptr)
Definition: SelectionDAGNodes.h:921
llvm::LabelSDNode
Definition: SelectionDAGNodes.h:2155
llvm::BitVector
Definition: BitVector.h:74
llvm::CondCodeSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2223
llvm::ISD::SMULO
@ SMULO
Same for multiplication.
Definition: ISDOpcodes.h:318
llvm::ISD::UNSIGNED_SCALED
@ UNSIGNED_SCALED
Definition: ISDOpcodes.h:1325
llvm::MemSDNode::isNonTemporal
bool isNonTemporal() const
Definition: SelectionDAGNodes.h:1296
llvm::ISD::TargetGlobalAddress
@ TargetGlobalAddress
TargetGlobalAddress - Like GlobalAddress, but the DAG does no folding or anything else with this node...
Definition: ISDOpcodes.h:164
Align
uint64_t Align
Definition: ELFObjHandler.cpp:83
llvm::MaskedScatterSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2734
llvm::GlobalAddressSDNode::getGlobal
const GlobalValue * getGlobal() const
Definition: SelectionDAGNodes.h:1730
llvm::MaskedLoadStoreSDNode::isUnindexed
bool isUnindexed() const
Return true if this is NOT a pre/post inc/dec load/store.
Definition: SelectionDAGNodes.h:2483
llvm::FPMathOperator::hasNoSignedZeros
bool hasNoSignedZeros() const
Test if this operation can ignore the sign of zero.
Definition: Operator.h:347
llvm::ConstantSDNode::isOne
bool isOne() const
Definition: SelectionDAGNodes.h:1579
llvm::ISD::UNINDEXED
@ UNINDEXED
Definition: ISDOpcodes.h:1310
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::DenseMapInfo< SDValue >::getEmptyKey
static SDValue getEmptyKey()
Definition: SelectionDAGNodes.h:233
llvm::SDValue::getConstantOperandVal
uint64_t getConstantOperandVal(unsigned i) const
Definition: SelectionDAGNodes.h:1133
force
therefore end up llgh r3 lr r0 br r14 but truncating the load would lh r3 br r14 Functions ret i64 and ought to be implemented ngr r0 br r14 but two address optimizations reverse the order of the AND and force
Definition: README.txt:112
c
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int int c
Definition: README.txt:418
llvm::SDValue::getValueSizeInBits
TypeSize getValueSizeInBits() const
Returns the size of the value in bits.
Definition: SelectionDAGNodes.h:192
llvm::LSBaseSDNode::getOffset
const SDValue & getOffset() const
Definition: SelectionDAGNodes.h:2258
llvm::ISD::USUBO
@ USUBO
Definition: ISDOpcodes.h:315
llvm::MemSDNode::isVolatile
bool isVolatile() const
Definition: SelectionDAGNodes.h:1295
llvm::MachineMemOperand::getSyncScopeID
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID for this memory operation.
Definition: MachineMemOperand.h:264
llvm::StoreSDNode::isTruncatingStore
bool isTruncatingStore() const
Return true if the op does a truncation before store.
Definition: SelectionDAGNodes.h:2325
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
llvm::RegisterMaskSDNode
Definition: SelectionDAGNodes.h:2114
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::ISD::VALUETYPE
@ VALUETYPE
Definition: ISDOpcodes.h:72
llvm::TargetIndexSDNode::getTargetFlags
unsigned getTargetFlags() const
Definition: SelectionDAGNodes.h:1917
llvm::SDNode::setDebugLoc
void setDebugLoc(DebugLoc dl)
Set source location info.
Definition: SelectionDAGNodes.h:723
llvm::MachineSDNode::memoperands
ArrayRef< MachineMemOperand * > memoperands() const
Definition: SelectionDAGNodes.h:2778
llvm::ISD::ATOMIC_LOAD_FADD
@ ATOMIC_LOAD_FADD
Definition: ISDOpcodes.h:1151
llvm::SDNode::value_op_iterator
Iterator for directly iterating over the operand SDValue's.
Definition: SelectionDAGNodes.h:916
llvm::ISD::TargetConstantFP
@ TargetConstantFP
Definition: ISDOpcodes.h:159
llvm::SDLoc::SDLoc
SDLoc(const SDValue V)
Definition: SelectionDAGNodes.h:1094
llvm::BlockAddressSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2149
llvm::VTSDNode::getVT
EVT getVT() const
Definition: SelectionDAGNodes.h:2240
llvm::SDNode::getGluedUser
SDNode * getGluedUser() const
If this node has a glue value with a user, return the user (there is at most one).
Definition: SelectionDAGNodes.h:948
llvm::MaskedScatterSDNode::MaskedScatterSDNode
MaskedScatterSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemVT, MachineMemOperand *MMO, ISD::MemIndexType IndexType, bool IsTrunc)
Definition: SelectionDAGNodes.h:2719
Node::dump
DEMANGLE_DUMP_METHOD void dump() const
llvm::MaskedLoadStoreSDNode::getOffset
const SDValue & getOffset() const
Definition: SelectionDAGNodes.h:2466
llvm::SDNodeIterator::operator++
SDNodeIterator & operator++()
Definition: SelectionDAGNodes.h:2842
llvm::ISD::BlockAddress
@ BlockAddress
Definition: ISDOpcodes.h:84
llvm::checkForCycles
void checkForCycles(const SelectionDAG *DAG, bool force=false)
Definition: SelectionDAG.cpp:11094
llvm::SDNode::MemSDNodeBitfields
Definition: SelectionDAGNodes.h:496
llvm::AssertAlignSDNode
An SDNode that records if a register contains a value that is guaranteed to be aligned accordingly.
Definition: SelectionDAGNodes.h:2805
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
llvm::AtomicOrdering
AtomicOrdering
Atomic ordering for LLVM's memory model.
Definition: AtomicOrdering.h:56
llvm::VPLoadStoreSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2381
llvm::ISD::matchUnaryPredicate
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...
Definition: SelectionDAG.cpp:305
llvm::MaskedScatterSDNode::getValue
const SDValue & getValue() const
Definition: SelectionDAGNodes.h:2732
val
The initial backend is deliberately restricted to z10 We should add support for later architectures at some point If an asm ties an i32 r result to an i64 the input will be treated as an leaving the upper bits uninitialised For i64 store i32 val
Definition: README.txt:15
llvm::APFloat
Definition: APFloat.h:701
llvm::SDNode::use_begin
use_iterator use_begin() const
Provide iteration support to walk over all uses of an SDNode.
Definition: SelectionDAGNodes.h:783
llvm::ISD::Register
@ Register
Definition: ISDOpcodes.h:74
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:197
llvm::SDValue::getNumOperands
unsigned getNumOperands() const
Definition: SelectionDAGNodes.h:1125
llvm::isNullFPConstant
bool isNullFPConstant(SDValue V)
Returns true if V is an FP constant with a value of positive zero.
Definition: SelectionDAG.cpp:9962
llvm::ISD::SADDO
@ SADDO
RESULT, BOOL = [SU]ADDO(LHS, RHS) - Overflow-aware nodes for addition.
Definition: ISDOpcodes.h:310
llvm::SDUse::getNext
SDUse * getNext() const
Get the next SDUse in the use list.
Definition: SelectionDAGNodes.h:303
llvm::VPGatherScatterSDNode::getIndexType
ISD::MemIndexType getIndexType() const
How is Index applied to BasePtr when computing addresses.
Definition: SelectionDAGNodes.h:2570
llvm::peekThroughBitcasts
SDValue peekThroughBitcasts(SDValue V)
Return the non-bitcasted source operand of V if it exists.
Definition: SelectionDAG.cpp:9977
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::BuildVectorSDNode::getConstantFPSplatNode
ConstantFPSDNode * getConstantFPSplatNode(const APInt &DemandedElts, BitVector *UndefElements=nullptr) const
Returns the demanded splatted constant FP or null if this is not a constant FP splat.
Definition: SelectionDAG.cpp:10889
llvm::StoreSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2334
llvm::VPGatherScatterSDNode::getScale
const SDValue & getScale() const
Definition: SelectionDAGNodes.h:2592
llvm::SDNode::NumSDNodeBits
@ NumSDNodeBits
Definition: SelectionDAGNodes.h:486
llvm::isNullOrNullSplat
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...
Definition: SelectionDAG.cpp:10099
llvm::EVT::getSizeInBits
TypeSize getSizeInBits() const
Return the size of the specified value type in bits.
Definition: ValueTypes.h:341
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
uint64_t
llvm::ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS
@ ATOMIC_CMP_SWAP_WITH_SUCCESS
Val, Success, OUTCHAIN = ATOMIC_CMP_SWAP_WITH_SUCCESS(INCHAIN, ptr, cmp, swap) N.b.
Definition: ISDOpcodes.h:1131
llvm::ISD::ATOMIC_LOAD_MIN
@ ATOMIC_LOAD_MIN
Definition: ISDOpcodes.h:1147
llvm::MemSDNode::refineAlignment
void refineAlignment(const MachineMemOperand *NewMMO)
Update this MemSDNode's MachineMemOperand information to reflect the alignment of NewMMO,...
Definition: SelectionDAGNodes.h:1355
llvm::RegisterSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2109
llvm::LifetimeSDNode
This SDNode is used for LIFETIME_START/LIFETIME_END values, which indicate the offet and size that ar...
Definition: SelectionDAGNodes.h:1765
llvm::ConstantFPSDNode
Definition: SelectionDAGNodes.h:1605
llvm::MemSDNode::getMemOperand
MachineMemOperand * getMemOperand() const
Return a MachineMemOperand object describing the memory reference performed by operation.
Definition: SelectionDAGNodes.h:1340
llvm::ISD::FIRST_TARGET_STRICTFP_OPCODE
static const int FIRST_TARGET_STRICTFP_OPCODE
FIRST_TARGET_STRICTFP_OPCODE - Target-specific pre-isel operations which cannot raise FP exceptions s...
Definition: ISDOpcodes.h:1255
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::ISD::LOAD
@ LOAD
LOAD and STORE have token chains as their first operand, then the same operands as an LLVM load/store...
Definition: ISDOpcodes.h:921
llvm::SDUse::getValueType
EVT getValueType() const
Convenience function for get().getValueType().
Definition: SelectionDAGNodes.h:310
llvm::ConstantPoolSDNode::getType
Type * getType() const
Definition: SelectionDAG.cpp:10712
llvm::SDNode::print_details
void print_details(raw_ostream &OS, const SelectionDAG *G) const
Definition: SelectionDAGDumper.cpp:557
llvm::SDNode::hasPredecessor
bool hasPredecessor(const SDNode *N) const
Return true if N is a predecessor of this node.
Definition: SelectionDAG.cpp:10306
llvm::SDValue::isTargetMemoryOpcode
bool isTargetMemoryOpcode() const
Definition: SelectionDAGNodes.h:1145
llvm::ISD::SRCVALUE
@ SRCVALUE
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:1053
llvm::VPLoadSDNode
This class is used to represent a VP_LOAD node.
Definition: SelectionDAGNodes.h:2387
llvm::MaskedStoreSDNode::isTruncatingStore
bool isTruncatingStore() const
Return true if the op does a truncation before store.
Definition: SelectionDAGNodes.h:2536
llvm::ConstantSDNode::getMaybeAlignValue
MaybeAlign getMaybeAlignValue() const
Definition: SelectionDAGNodes.h:1576
llvm::FPMathOperator::hasAllowReciprocal
bool hasAllowReciprocal() const
Test if this operation can use reciprocal multiply instead of division.
Definition: Operator.h:352
llvm::MachinePointerInfo
This class contains a discriminated union of information about pointers in memory operands,...
Definition: MachineMemOperand.h:38
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::BuildVectorSDNode::BuildVectorSDNode
BuildVectorSDNode()=delete
llvm::ISD::isConstantSplatVector
bool isConstantSplatVector(const SDNode *N, APInt &SplatValue)
Node predicates.
Definition: SelectionDAG.cpp:141
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::SDNode::setNodeId
void setNodeId(int Id)
Set unique node id.
Definition: SelectionDAGNodes.h:710
llvm::VPGatherScatterSDNode::getMask
const SDValue & getMask() const
Definition: SelectionDAGNodes.h:2595
llvm::SDLoc::getDebugLoc
const DebugLoc & getDebugLoc() const
Definition: SelectionDAGNodes.h:1102
llvm::SyncScope::ID
uint8_t ID
Definition: LLVMContext.h:47
llvm::SDNode::LSBaseSDNodeBitfields
Definition: SelectionDAGNodes.h:510
llvm::MaskedGatherScatterSDNode::isIndexScaled
bool isIndexScaled() const
Definition: SelectionDAGNodes.h:2664
llvm::ISD::ATOMIC_LOAD_NAND
@ ATOMIC_LOAD_NAND
Definition: ISDOpcodes.h:1146
llvm::SDNode::getOperand
const SDValue & getOperand(unsigned Num) const
Definition: SelectionDAGNodes.h:904
llvm::MaskedStoreSDNode::MaskedStoreSDNode
MaskedStoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, ISD::MemIndexedMode AM, bool isTrunc, bool isCompressing, EVT MemVT, MachineMemOperand *MMO)
Definition: SelectionDAGNodes.h:2525
iterator.h
llvm::MaskedLoadSDNode::isExpandingLoad
bool isExpandingLoad() const
Definition: SelectionDAGNodes.h:2517
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::FrameIndexSDNode::getIndex
int getIndex() const
Definition: SelectionDAGNodes.h:1755
llvm::VPLoadStoreSDNode::VPLoadStoreSDNode
VPLoadStoreSDNode(ISD::NodeType NodeTy, unsigned Order, const DebugLoc &dl, SDVTList VTs, ISD::MemIndexedMode AM, EVT MemVT, MachineMemOperand *MMO)
Definition: SelectionDAGNodes.h:2344
llvm::SDNode::use_iterator::getUse
SDUse & getUse() const
Definition: SelectionDAGNodes.h:773
llvm::SDNodeIterator::operator*
pointer operator*() const
Definition: SelectionDAGNodes.h:2837
llvm::SDNodeFlags::setAllowReciprocal
void setAllowReciprocal(bool b)
Definition: SelectionDAGNodes.h:417
Attributes
AMDGPU Kernel Attributes
Definition: AMDGPULowerKernelAttributes.cpp:254
llvm::CondCodeSDNode
Definition: SelectionDAGNodes.h:2211
llvm::ISD::ATOMIC_CMP_SWAP
@ ATOMIC_CMP_SWAP
Val, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmp, swap) For double-word atomic operations: ValLo,...
Definition: ISDOpcodes.h:1125
node
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper node
Definition: README-SSE.txt:406
llvm::ISD::ATOMIC_LOAD_ADD
@ ATOMIC_LOAD_ADD
Definition: ISDOpcodes.h:1140
llvm::SDNode::use_iterator::difference_type
std::ptrdiff_t difference_type
Definition: SelectionDAGNodes.h:737
llvm::LoadSDNode::getExtensionType
ISD::LoadExtType getExtensionType() const
Return whether this is a plain node, or one of the varieties of value-extending loads.
Definition: SelectionDAGNodes.h:2296
llvm::SDNode::dump
void dump() const
Dump this node, for debugging.
Definition: SelectionDAGDumper.cpp:539
llvm::BasicBlockSDNode
Definition: SelectionDAGNodes.h:1926
llvm::MemSDNode::getOriginalAlign
Align getOriginalAlign() const
Returns alignment and volatility of the memory access.
Definition: SelectionDAGNodes.h:1271
ArrayRef.h
llvm::MachineSDNode::mmo_iterator
ArrayRef< MachineMemOperand * >::const_iterator mmo_iterator
Definition: SelectionDAGNodes.h:2776
llvm::SDValue::getScalarValueSizeInBits
uint64_t getScalarValueSizeInBits() const
Definition: SelectionDAGNodes.h:196
TemplateParamKind::Type
@ Type
llvm::SDNode::ConstantSDNodeBits
ConstantSDNodeBitfields ConstantSDNodeBits
Definition: SelectionDAGNodes.h:559
END_TWO_BYTE_PACK
#define END_TWO_BYTE_PACK()
Definition: SelectionDAGNodes.h:472
llvm::GlobalAddressSDNode::getOffset
int64_t getOffset() const
Definition: SelectionDAGNodes.h:1731
llvm::BlockAddressSDNode::getTargetFlags
unsigned getTargetFlags() const
Definition: SelectionDAGNodes.h:2147
llvm::ISD::MSTORE
@ MSTORE
Definition: ISDOpcodes.h:1161
llvm::JumpTableSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1836
llvm::StoreSDNode
This class is used to represent ISD::STORE nodes.
Definition: SelectionDAGNodes.h:2309
llvm::ISD::ZEXTLOAD
@ ZEXTLOAD
Definition: ISDOpcodes.h:1341
llvm::SDValue::getValue
SDValue getValue(unsigned R) const
Definition: SelectionDAGNodes.h:172
llvm::AMDGPU::HSAMD::ValueType
ValueType
Value types.
Definition: AMDGPUMetadata.h:95
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::SDNodeFlags::hasNoUnsignedWrap
bool hasNoUnsignedWrap() const
Definition: SelectionDAGNodes.h:424
llvm::FPMathOperator::hasAllowReassoc
bool hasAllowReassoc() const
Test if this operation may be simplified with reassociative transforms.
Definition: Operator.h:332
llvm::FPMathOperator
Utility class for floating point operations which can have information about relaxed accuracy require...
Definition: Operator.h:250
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1609
llvm::LifetimeSDNode::getOffset
int64_t getOffset() const
Definition: SelectionDAGNodes.h:1779
llvm::SDNode::getNodeId
int getNodeId() const
Return the unique node id.
Definition: SelectionDAGNodes.h:707
llvm::SDLoc::SDLoc
SDLoc(const Instruction *I, int Order)
Definition: SelectionDAGNodes.h:1095
memcpy
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint cast struct s *agg result to sbyte *< sbyte * > sbyte uint cast struct s *memtmp to sbyte *< sbyte * > sbyte uint ret void llc ends up issuing two memcpy or custom lower memcpy(of small size) to be ldmia/stmia. I think option 2 is better but the current register allocator cannot allocate a chunk of registers at a time. A feasible temporary solution is to use specific physical registers at the lowering time for small(<
llvm::ConstantSDNode::getZExtValue
uint64_t getZExtValue() const
Definition: SelectionDAGNodes.h:1571
llvm::SDValue::getResNo
unsigned getResNo() const
get the index which selects a specific result in the SDNode
Definition: SelectionDAGNodes.h:149
llvm::SDNode::print
void print(raw_ostream &OS, const SelectionDAG *G=nullptr) const
Definition: SelectionDAGDumper.cpp:1048
llvm::MaskedLoadSDNode
This class is used to represent an MLOAD node.
Definition: SelectionDAGNodes.h:2492
llvm::MachineMemOperand::getSuccessOrdering
AtomicOrdering getSuccessOrdering() const
Return the atomic ordering requirements for this memory operation.
Definition: MachineMemOperand.h:271
llvm::MCSymbolSDNode
Definition: SelectionDAGNodes.h:2195
llvm::ISD::CondCode
CondCode
ISD::CondCode enum - These are ordered carefully to make the bitfields below work out,...
Definition: ISDOpcodes.h:1361
llvm::MaskedStoreSDNode::getOffset
const SDValue & getOffset() const
Definition: SelectionDAGNodes.h:2546
iterator_range.h
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:83
llvm::MemSDNode::MemSDNode
MemSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT memvt, MachineMemOperand *MMO)
Definition: SelectionDAG.cpp:10138
llvm::ExternalSymbolSDNode::getTargetFlags
unsigned getTargetFlags() const
Definition: SelectionDAGNodes.h:2187
llvm::ISD::ATOMIC_LOAD_FSUB
@ ATOMIC_LOAD_FSUB
Definition: ISDOpcodes.h:1152
llvm::ISD::TargetGlobalTLSAddress
@ TargetGlobalTLSAddress
Definition: ISDOpcodes.h:165
llvm::DenseMapInfo< SDValue >::getTombstoneKey
static SDValue getTombstoneKey()
Definition: SelectionDAGNodes.h:239
llvm::MVT
Machine Value Type.
Definition: MachineValueType.h:31
llvm::ISD::isNON_EXTLoad
bool isNON_EXTLoad(const SDNode *N)
Returns true if the specified node is a non-extending load.
Definition: SelectionDAGNodes.h:2901
llvm::SDNode::use_iterator::operator==
bool operator==(const use_iterator &x) const
Definition: SelectionDAGNodes.h:744
llvm::SDNode::dumpr
void dumpr() const
Dump (recursively) this node and its use-def subgraph.
Definition: SelectionDAGDumper.cpp:996
llvm::SDLoc::SDLoc
SDLoc(const SDNode *N)
Definition: SelectionDAGNodes.h:1093
llvm::SDVTList::VTs
const EVT * VTs
Definition: SelectionDAGNodes.h:80
llvm::MDNode
Metadata node.
Definition: Metadata.h:906
llvm::ShuffleVectorSDNode::ShuffleVectorSDNode
ShuffleVectorSDNode(EVT VT, unsigned Order, const DebugLoc &dl, const int *M)
Definition: SelectionDAGNodes.h:1506
llvm::SDNode::getSimpleValueType
MVT getSimpleValueType(unsigned ResNo) const
Return the type of a specified result as a simple type.
Definition: SelectionDAGNodes.h:972
llvm::StoreSDNode::getValue
const SDValue & getValue() const
Definition: SelectionDAGNodes.h:2330
llvm::SDNode::getValueSizeInBits
TypeSize getValueSizeInBits(unsigned ResNo) const
Returns MVT::getSizeInBits(getValueType(ResNo)).
Definition: SelectionDAGNodes.h:981
llvm::SDNodeFlags::setNoInfs
void setNoInfs(bool b)
Definition: SelectionDAGNodes.h:415
llvm::AssertAlignSDNode::AssertAlignSDNode
AssertAlignSDNode(unsigned Order, const DebugLoc &DL, EVT VT, Align A)
Definition: SelectionDAGNodes.h:2809
llvm::DebugLoc::hasTrivialDestructor
bool hasTrivialDestructor() const
Check whether this has a trivial destructor.
Definition: DebugLoc.h:69
llvm::SmallPtrSetImpl::count
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:382
llvm::FPMathOperator::hasApproxFunc
bool hasApproxFunc() const
Test if this operation allows approximations of math library functions or intrinsics.
Definition: Operator.h:363
llvm::SDNode::isMachineOpcode
bool isMachineOpcode() const
Test if this node has a post-isel opcode, directly corresponding to a MachineInstr opcode.
Definition: SelectionDAGNodes.h:681
llvm::ISD::TargetBlockAddress
@ TargetBlockAddress
Definition: ISDOpcodes.h:170
llvm::SDNode::values
iterator_range< value_iterator > values() const
Definition: SelectionDAGNodes.h:989
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
llvm::PseudoProbeSDNode::getGuid
uint64_t getGuid() const
Definition: SelectionDAGNodes.h:1811
llvm::ISD::ANNOTATION_LABEL
@ ANNOTATION_LABEL
ANNOTATION_LABEL - Represents a mid basic block label used by annotations.
Definition: ISDOpcodes.h:994
llvm::MDNodeSDNode
Definition: SelectionDAGNodes.h:2081
llvm::ISD::HANDLENODE
@ HANDLENODE
HANDLENODE node - Used as a handle for various purposes.
Definition: ISDOpcodes.h:1071
llvm::ISD::ConstantPool
@ ConstantPool
Definition: ISDOpcodes.h:82
llvm::SDLoc::SDLoc
SDLoc()=default
llvm::hasSingleElement
bool hasSingleElement(ContainerTy &&C)
Returns true if the given container only contains a single element.
Definition: STLExtras.h:259
llvm::LSBaseSDNode::LSBaseSDNode
LSBaseSDNode(ISD::NodeType NodeTy, unsigned Order, const DebugLoc &dl, SDVTList VTs, ISD::MemIndexedMode AM, EVT MemVT, MachineMemOperand *MMO)
Definition: SelectionDAGNodes.h:2250
ConstantPool
MIPS Relocation Principles In there are several elements of the llvm::ISD::NodeType enum that deal with addresses and or relocations These are defined in include llvm Target TargetSelectionDAG td ConstantPool
Definition: Relocation.txt:6
llvm::SDUse::getUser
SDNode * getUser()
This returns the SDNode that contains this Use.
Definition: SelectionDAGNodes.h:300
llvm::ISD::GlobalTLSAddress
@ GlobalTLSAddress
Definition: ISDOpcodes.h:79
llvm::MemSDNode::getAAInfo
AAMDNodes getAAInfo() const
Returns the AA info that describes the dereference.
Definition: SelectionDAGNodes.h:1304
llvm::BlockAddress
The address of a basic block.
Definition: Constants.h:848
llvm::ISD::TargetConstantPool
@ TargetConstantPool
Definition: ISDOpcodes.h:168
llvm::BuildVectorSDNode::isConstant
bool isConstant() const
Definition: SelectionDAG.cpp:10918
llvm::SDNode::use_iterator::operator->
SDNode * operator->() const
Definition: SelectionDAGNodes.h:771
llvm::MemSDNode::isAtomic
bool isAtomic() const
Return true if the memory operation ordering is Unordered or higher.
Definition: SelectionDAGNodes.h:1325
llvm::LifetimeSDNode::getFrameIndex
int64_t getFrameIndex() const
Definition: SelectionDAGNodes.h:1774
llvm::SDNode::print_types
void print_types(raw_ostream &OS, const SelectionDAG *G) const
Definition: SelectionDAGDumper.cpp:547
llvm::ISD::isSEXTLoad
bool isSEXTLoad(const SDNode *N)
Returns true if the specified node is a SEXTLOAD.
Definition: SelectionDAGNodes.h:2913
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::ISD::isNormalLoad
bool isNormalLoad(const SDNode *N)
Returns true if the specified node is a non-extending and unindexed load.
Definition: SelectionDAGNodes.h:2894
llvm::ConstantPoolSDNode
Definition: SelectionDAGNodes.h:1842
llvm::BlockAddressSDNode::getBlockAddress
const BlockAddress * getBlockAddress() const
Definition: SelectionDAGNodes.h:2145
llvm::SrcValueSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2076
llvm::BuildVectorSDNode::isConstantSplat
bool isConstantSplat(APInt &SplatValue, APInt &SplatUndef, unsigned &SplatBitSize, bool &HasAnyUndefs, unsigned MinSplatBits=0, bool isBigEndian=false) const
Check if this is a constant splat, and if so, find the smallest element size that splats the vector.
Definition: SelectionDAG.cpp:10718
llvm::SDNode::use_end
static use_iterator use_end()
Definition: SelectionDAGNodes.h:787
Cond
SmallVector< MachineOperand, 4 > Cond
Definition: BasicBlockSections.cpp:179
llvm::SDNodeFlags::intersectWith
void intersectWith(const SDNodeFlags Flags)
Clear any flags in this flag set that aren't also set in Flags.
Definition: SelectionDAGNodes.h:438
llvm::HandleSDNode::~HandleSDNode
~HandleSDNode()
Definition: SelectionDAG.cpp:10120
llvm::BuildVectorSDNode
A "pseudo-class" with methods for operating on BUILD_VECTORs.
Definition: SelectionDAGNodes.h:1947
llvm::FoldingSetBase::Node
Node - This class is used to maintain the singly linked bucket list in a folding set.
Definition: FoldingSet.h:133
llvm::SDNodeFlags::setNoFPExcept
void setNoFPExcept(bool b)
Definition: SelectionDAGNodes.h:421
llvm::SDNodeFlags::hasApproximateFuncs
bool hasApproximateFuncs() const
Definition: SelectionDAGNodes.h:432
llvm::ShuffleVectorSDNode::getMaskElt
int getMaskElt(unsigned Idx) const
Definition: SelectionDAGNodes.h:1515
llvm::SDNode::uses
iterator_range< use_iterator > uses() const
Definition: SelectionDAGNodes.h:792
llvm::ConstantPoolSDNode::getConstVal
const Constant * getConstVal() const
Definition: SelectionDAGNodes.h:1877
llvm::ConstantPoolSDNode::getOffset
int getOffset() const
Definition: SelectionDAGNodes.h:1887
llvm::SDValue::getMachineOpcode
unsigned getMachineOpcode() const
Definition: SelectionDAGNodes.h:1153
llvm::VPGatherSDNode
This class is used to represent an VP_GATHER node.
Definition: SelectionDAGNodes.h:2610
llvm::VPGatherScatterSDNode::isIndexSigned
bool isIndexSigned() const
Definition: SelectionDAGNodes.h:2577
llvm::BasicBlockSDNode::getBasicBlock
MachineBasicBlock * getBasicBlock() const
Definition: SelectionDAGNodes.h:1939
llvm::ISD::ATOMIC_LOAD_SUB
@ ATOMIC_LOAD_SUB
Definition: ISDOpcodes.h:1141
llvm::PseudoProbeSDNode::getIndex
uint64_t getIndex() const
Definition: SelectionDAGNodes.h:1812
llvm::SDNode::use_iterator::use_iterator
use_iterator(const use_iterator &I)
Definition: SelectionDAGNodes.h:742
uint32_t
llvm::SDNode::use_iterator::operator++
use_iterator operator++(int)
Definition: SelectionDAGNodes.h:761
llvm::SDNode::isOperandOf
bool isOperandOf(const SDNode *N) const
Return true if this node is an operand of N.
Definition: SelectionDAG.cpp:10253
llvm::MaskedGatherScatterSDNode::getBasePtr
const SDValue & getBasePtr() const
Definition: SelectionDAGNodes.h:2677
llvm::RegisterMaskSDNode::getRegMask
const uint32_t * getRegMask() const
Definition: SelectionDAGNodes.h:2125
llvm::SDValue::getOperand
const SDValue & getOperand(unsigned i) const
Definition: SelectionDAGNodes.h:1129
llvm::SDNode::LSBaseSDNodeBits
LSBaseSDNodeBitfields LSBaseSDNodeBits
Definition: SelectionDAGNodes.h:561
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
BEGIN_TWO_BYTE_PACK
#define BEGIN_TWO_BYTE_PACK()
Definition: SelectionDAGNodes.h:471
llvm::VTSDNode
This class is used to represent EVT's, which are used to parameterize some operations.
Definition: SelectionDAGNodes.h:2230
llvm::isAllOnesOrAllOnesSplat
bool isAllOnesOrAllOnesSplat(SDValue V, bool AllowUndefs=false)
Return true if the value is a constant -1 integer or a splatted vector of a constant -1 integer (with...
Definition: SelectionDAG.cpp:10113
llvm::MaskedStoreSDNode::isCompressingStore
bool isCompressingStore() const
Returns true if the op does a compression to the vector before storing.
Definition: SelectionDAGNodes.h:2542
llvm::SDNode::getIndexedModeName
static const char * getIndexedModeName(ISD::MemIndexedMode AM)
Definition: SelectionDAGDumper.cpp:492
llvm::FoldingSetNodeID
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:313
llvm::ConstantSDNode::getSExtValue
int64_t getSExtValue() const
Definition: SelectionDAGNodes.h:1572
llvm::SDNodeFlags::hasNoInfs
bool hasNoInfs() const
Definition: SelectionDAGNodes.h:428
llvm::ISD::UNDEF
@ UNDEF
UNDEF - An undefined node.
Definition: ISDOpcodes.h:211
llvm::SDValue::hasOneUse
bool hasOneUse() const
Return true if there is exactly one node using value ResNo of Node.
Definition: SelectionDAGNodes.h:1165
llvm::ISD::BUILTIN_OP_END
@ BUILTIN_OP_END
BUILTIN_OP_END - This must be the last enum value in this list.
Definition: ISDOpcodes.h:1249
llvm::VPLoadSDNode::getBasePtr
const SDValue & getBasePtr() const
Definition: SelectionDAGNodes.h:2403
llvm::SDValue::getSimpleValueType
MVT getSimpleValueType() const
Return the simple ValueType of the referenced return value.
Definition: SelectionDAGNodes.h:183
llvm::SDNode::ops
ArrayRef< SDUse > ops() const
Definition: SelectionDAGNodes.h:913
Node
Definition: ItaniumDemangle.h:235
llvm::AMDGPU::HSAMD::Kernel::Arg::Key::IsVolatile
constexpr char IsVolatile[]
Key for Kernel::Arg::Metadata::mIsVolatile.
Definition: AMDGPUMetadata.h:194
llvm::NVPTX::PTXLdStInstCode::Untyped
@ Untyped
Definition: NVPTX.h:119
llvm::peekThroughExtractSubvectors
SDValue peekThroughExtractSubvectors(SDValue V)
Return the non-extracted vector source operand of V if it exists.
Definition: SelectionDAG.cpp:9989
llvm::JumpTableSDNode::getIndex
int getIndex() const
Definition: SelectionDAGNodes.h:1833
llvm::SDVTList
This represents a list of ValueType's that has been intern'd by a SelectionDAG.
Definition: SelectionDAGNodes.h:79
llvm::ISD::ATOMIC_SWAP
@ ATOMIC_SWAP
Val, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amt) Val, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN,...
Definition: ISDOpcodes.h:1139
llvm::MaskedGatherScatterSDNode::getIndexType
ISD::MemIndexType getIndexType() const
How is Index applied to BasePtr when computing addresses.
Definition: SelectionDAGNodes.h:2658
llvm::ISD::SEXTLOAD
@ SEXTLOAD
Definition: ISDOpcodes.h:1341
llvm::VPLoadSDNode::getMask
const SDValue & getMask() const
Definition: SelectionDAGNodes.h:2405
llvm::FPMathOperator::hasAllowContract
bool hasAllowContract() const
Test if this operation can be floating-point contracted (FMA).
Definition: Operator.h:357
llvm::VPGatherScatterSDNode::getIndex
const SDValue & getIndex() const
Definition: SelectionDAGNodes.h:2589
llvm::MachinePointerInfo::getAddrSpace
unsigned getAddrSpace() const
Return the LLVM IR address space number that this pointer points into.
Definition: MachineOperand.cpp:983
llvm::PointerUnion< const Value *, const PseudoSourceValue * >
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::ilist_node
Definition: ilist_node.h:148
llvm::SmallPtrSetImplBase::size
size_type size() const
Definition: SmallPtrSet.h:92
FoldingSet.h
llvm::LoadSDNode::getBasePtr
const SDValue & getBasePtr() const
Definition: SelectionDAGNodes.h:2300
llvm::AddrSpaceCastSDNode::getDestAddressSpace
unsigned getDestAddressSpace() const
Definition: SelectionDAGNodes.h:1246
llvm::SDNode::getOperationName
std::string getOperationName(const SelectionDAG *G=nullptr) const
Return the opcode of this operation for printing.
Definition: SelectionDAGDumper.cpp:59
llvm::SDUse::operator<
bool operator<(const SDValue &V) const
Convenience function for get().operator<.
Definition: SelectionDAGNodes.h:323
llvm::SDNode::isMemIntrinsic
bool isMemIntrinsic() const
Test if this node is a memory intrinsic (with valid pointer information).
Definition: SelectionDAGNodes.h:659
llvm::AtomicSDNode
This is an SDNode representing atomic operations.
Definition: SelectionDAGNodes.h:1418
llvm::ISD::FrameIndex
@ FrameIndex
Definition: ISDOpcodes.h:80
llvm::MemSDNode::writeMem
bool writeMem() const
Definition: SelectionDAGNodes.h:1268
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::SDNode::dumprFull
void dumprFull(const SelectionDAG *G=nullptr) const
printrFull to dbgs().
Definition: SelectionDAGDumper.cpp:1042
llvm::SDNode::isOnlyUserOf
bool isOnlyUserOf(const SDNode *N) const
Return true if this node is the only use of N.
Definition: SelectionDAG.cpp:10221
ExternalSymbol
MIPS Relocation Principles In there are several elements of the llvm::ISD::NodeType enum that deal with addresses and or relocations These are defined in include llvm Target TargetSelectionDAG td ExternalSymbol
Definition: Relocation.txt:7
llvm::ConstantFPSDNode::isExactlyValue
bool isExactlyValue(double V) const
We don't rely on operator== working on double values, as it returns true for things that are clearly ...
Definition: SelectionDAGNodes.h:1639
llvm::MaskedGatherScatterSDNode::getScale
const SDValue & getScale() const
Definition: SelectionDAGNodes.h:2680
llvm::isAllOnesConstant
bool isAllOnesConstant(SDValue V)
Returns true if V is an integer constant with all bits set.
Definition: SelectionDAG.cpp:9967
llvm::MachineSDNode::clearMemRefs
void clearMemRefs()
Clear out the memory reference descriptor list.
Definition: SelectionDAGNodes.h:2793
llvm::ConstantFPSDNode::getConstantFPValue
const ConstantFP * getConstantFPValue() const
Definition: SelectionDAGNodes.h:1617
llvm::SDValue::operator<
bool operator<(const SDValue &O) const
Definition: SelectionDAGNodes.h:165
llvm::MaskedStoreSDNode::getBasePtr
const SDValue & getBasePtr() const
Definition: SelectionDAGNodes.h:2545
llvm::VPGatherSDNode::VPGatherSDNode
VPGatherSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemVT, MachineMemOperand *MMO, ISD::MemIndexType IndexType)
Definition: SelectionDAGNodes.h:2614
llvm::SDNodeIterator::operator!=
bool operator!=(const SDNodeIterator &x) const
Definition: SelectionDAGNodes.h:2835
std
Definition: BitVector.h:838
llvm::GlobalAddressSDNode
Definition: SelectionDAGNodes.h:1718
llvm::SDNode::LoadSDNodeBitfields
Definition: SelectionDAGNodes.h:530
llvm::VPScatterSDNode::VPScatterSDNode
VPScatterSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, EVT MemVT, MachineMemOperand *MMO, ISD::MemIndexType IndexType)
Definition: SelectionDAGNodes.h:2630
llvm::SDNode::getNumOperands
unsigned getNumOperands() const
Return the number of values used by this operation.
Definition: SelectionDAGNodes.h:891
llvm::GraphTraits< SDNode * >::getEntryNode
static NodeRef getEntryNode(SDNode *N)
Definition: SelectionDAGNodes.h:2868
llvm::SDNodeFlags::hasNoSignedWrap
bool hasNoSignedWrap() const
Definition: SelectionDAGNodes.h:425
llvm::ISD::isEXTLoad
bool isEXTLoad(const SDNode *N)
Returns true if the specified node is a EXTLOAD.
Definition: SelectionDAGNodes.h:2907
llvm::ConstantSDNode::isMaxSignedValue
bool isMaxSignedValue() const
Definition: SelectionDAGNodes.h:1586
uint16_t
llvm::SDNodeIterator
Definition: SelectionDAGNodes.h:2819
llvm::ConstantPoolSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1898
llvm::MaskedLoadStoreSDNode::getAddressingMode
ISD::MemIndexedMode getAddressingMode() const
Return the addressing mode for this load or store: unindexed, pre-inc, pre-dec, post-inc,...
Definition: SelectionDAGNodes.h:2475
llvm::isNullConstant
bool isNullConstant(SDValue V)
Returns true if V is a constant integer zero.
Definition: SelectionDAG.cpp:9957
llvm::EVT::getScalarType
EVT getScalarType() const
If this is a vector type, return the element type, otherwise return this.
Definition: ValueTypes.h:296
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:324
llvm::ISD::STRICT_FP_TO_FP16
@ STRICT_FP_TO_FP16
Definition: ISDOpcodes.h:861
llvm::ISD::TargetExternalSymbol
@ TargetExternalSymbol
Definition: ISDOpcodes.h:169
llvm::MemSDNode::getAddressSpace
unsigned getAddressSpace() const
Return the address space for the associated pointer.
Definition: SelectionDAGNodes.h:1347
llvm::BuildVectorSDNode::getConstantSplatNode
ConstantSDNode * getConstantSplatNode(const APInt &DemandedElts, BitVector *UndefElements=nullptr) const
Returns the demanded splatted constant or null if this is not a constant splat.
Definition: SelectionDAG.cpp:10877
llvm::Align::value
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:85
llvm::MCSymbolSDNode::getMCSymbol
MCSymbol * getMCSymbol() const
Definition: SelectionDAGNodes.h:2204
llvm::MDNodeSDNode::getMD
const MDNode * getMD() const
Definition: SelectionDAGNodes.h:2091
llvm::MemSDNode::getAlignment
unsigned getAlignment() const
Definition: SelectionDAGNodes.h:1274
llvm::SDNode::printrWithDepth
void printrWithDepth(raw_ostream &O, const SelectionDAG *G=nullptr, unsigned depth=100) const
Print a SelectionDAG node and children up to depth "depth." The given SelectionDAG allows target-spec...
Definition: SelectionDAGDumper.cpp:1026
JumpTable
MIPS Relocation Principles In there are several elements of the llvm::ISD::NodeType enum that deal with addresses and or relocations These are defined in include llvm Target TargetSelectionDAG td JumpTable
Definition: Relocation.txt:6
llvm::ConstantFPSDNode::isInfinity
bool isInfinity() const
Return true if the value is an infinity.
Definition: SelectionDAGNodes.h:1626
ISDOpcodes.h
llvm::TypeSize
Definition: TypeSize.h:417
llvm::TargetIndexSDNode
Completely target-dependent object reference.
Definition: SelectionDAGNodes.h:1905
llvm::MaskedLoadStoreSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2485
llvm::ISD::BUILD_VECTOR
@ BUILD_VECTOR
BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a fixed-width vector with the specified,...
Definition: ISDOpcodes.h:491
Casting.h
llvm::MemSDNode::MMO
MachineMemOperand * MMO
Memory reference information.
Definition: SelectionDAGNodes.h:1261
llvm::PointerUnion::getAddrOfPtr1
const First * getAddrOfPtr1() const
If the union is set to the first pointer type get an address pointing to it.
Definition: PointerUnion.h:173
llvm::BitWidth
constexpr unsigned BitWidth
Definition: BitmaskEnum.h:147
llvm::SDNode::use_iterator::operator!=
bool operator!=(const use_iterator &x) const
Definition: SelectionDAGNodes.h:747
llvm::ConstantPoolSDNode::ConstVal
const Constant * ConstVal
Definition: SelectionDAGNodes.h:1846
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::MachineSDNode::memoperands_end
mmo_iterator memoperands_end() const
Definition: SelectionDAGNodes.h:2789
x
TODO unsigned x
Definition: README.txt:10
llvm::SDValue
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation.
Definition: SelectionDAGNodes.h:138
llvm::SDValue::operator->
SDNode * operator->() const
Definition: SelectionDAGNodes.h:157
llvm::AddrSpaceCastSDNode
Definition: SelectionDAGNodes.h:1236
llvm::LSBaseSDNode::getAddressingMode
ISD::MemIndexedMode getAddressingMode() const
Return the addressing mode for this load or store: unindexed, pre-inc, pre-dec, post-inc,...
Definition: SelectionDAGNodes.h:2264
llvm::SDNode::addUse
void addUse(SDUse &U)
This method should only be used by the SDUse class.
Definition: SelectionDAGNodes.h:1052
llvm::ISD::TargetConstant
@ TargetConstant
TargetConstant* - Like Constant*, but the DAG does not do any folding, simplification,...
Definition: ISDOpcodes.h:158
llvm::SDUse::operator!=
bool operator!=(const SDValue &V) const
Convenience function for get().operator!=.
Definition: SelectionDAGNodes.h:318
llvm::MaskedGatherSDNode::getExtensionType
ISD::LoadExtType getExtensionType() const
Definition: SelectionDAGNodes.h:2704
llvm::SDNode::getNumValues
unsigned getNumValues() const
Return the number of values defined/returned by this operator.
Definition: SelectionDAGNodes.h:963
llvm::SrcValueSDNode
An SDNode that holds an arbitrary LLVM IR Value.
Definition: SelectionDAGNodes.h:2063
llvm::MachineSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2798
llvm::MachineMemOperand::isAtomic
bool isAtomic() const
Returns true if this operation has an atomic ordering requirement of unordered or higher,...
Definition: MachineMemOperand.h:297
llvm::TargetIndexSDNode::getIndex
int getIndex() const
Definition: SelectionDAGNodes.h:1918
llvm::PseudoProbeSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1816
llvm::SDNodeFlags
These are IR-level optimization flags that may be propagated to SDNodes.
Definition: SelectionDAGNodes.h:371
llvm::SDNodeFlags::hasExact
bool hasExact() const
Definition: SelectionDAGNodes.h:426
llvm::SDNode::getDebugLoc
const DebugLoc & getDebugLoc() const
Return the source location info.
Definition: SelectionDAGNodes.h:719
llvm::MachineMemOperand::getMergedOrdering
AtomicOrdering getMergedOrdering() const
Return a single atomic ordering that is at least as strong as both the success and failure orderings ...
Definition: MachineMemOperand.h:284
llvm::MachineMemOperand::refineAlignment
void refineAlignment(const MachineMemOperand *MMO)
Update this MachineMemOperand to reflect the alignment of MMO, if it has a greater alignment.
Definition: MachineOperand.cpp:1070
llvm::VPGatherScatterSDNode
This is a base class used to represent VP_GATHER and VP_SCATTER nodes.
Definition: SelectionDAGNodes.h:2557
llvm::ISD::STORE
@ STORE
Definition: ISDOpcodes.h:922
llvm::SDNodeFlags::hasAllowReassociation
bool hasAllowReassociation() const
Definition: SelectionDAGNodes.h:433
llvm::ISD::SSUBO
@ SSUBO
Same for subtraction.
Definition: ISDOpcodes.h:314
llvm::SDValue::isUndef
bool isUndef() const
Definition: SelectionDAGNodes.h:1157
llvm::MemSDNode::isSimple
bool isSimple() const
Returns true if the memory operation is neither atomic or volatile.
Definition: SelectionDAGNodes.h:1333
llvm::AtomicSDNode::getVal
const SDValue & getVal() const
Definition: SelectionDAGNodes.h:1428
llvm::ExternalSymbolSDNode::getSymbol
const char * getSymbol() const
Definition: SelectionDAGNodes.h:2186
llvm::SDNode::getMachineOpcode
unsigned getMachineOpcode() const
This may only be called if isMachineOpcode returns true.
Definition: SelectionDAGNodes.h:686
llvm::SDNode::PersistentId
uint16_t PersistentId
Unique and persistent id per SDNode in the DAG.
Definition: SelectionDAGNodes.h:619
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:476
llvm::ARMBuildAttrs::Symbol
@ Symbol
Definition: ARMBuildAttributes.h:79
llvm::MaskedLoadSDNode::getMask
const SDValue & getMask() const
Definition: SelectionDAGNodes.h:2510
llvm::VPLoadSDNode::getExtensionType
ISD::LoadExtType getExtensionType() const
Definition: SelectionDAGNodes.h:2399
llvm::VPLoadStoreSDNode::getVectorLength
const SDValue & getVectorLength() const
Definition: SelectionDAGNodes.h:2365
llvm::SDUse::operator==
bool operator==(const SDValue &V) const
Convenience function for get().operator==.
Definition: SelectionDAGNodes.h:313
llvm::SDNode::hasNUsesOfValue
bool hasNUsesOfValue(unsigned NUses, unsigned Value) const
Return true if there are exactly NUSES uses of the indicated value.
Definition: SelectionDAG.cpp:10192
llvm::MemSDNode::getAlign
Align getAlign() const
Definition: SelectionDAGNodes.h:1272
llvm::GlobalAddressSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1736
llvm::ConstantFPSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:1646
llvm::SDNode::op_begin
op_iterator op_begin() const
Definition: SelectionDAGNodes.h:911
llvm::SDValue::isOperandOf
bool isOperandOf(const SDNode *N) const
Return true if this node is an operand of N.
Definition: SelectionDAG.cpp:10249
llvm::LSBaseSDNode
Base class for LoadSDNode and StoreSDNode.
Definition: SelectionDAGNodes.h:2248
llvm::AtomicSDNode::getBasePtr
const SDValue & getBasePtr() const
Definition: SelectionDAGNodes.h:1427
llvm::VPStoreSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2444
llvm::MemSDNode::getSrcValueOffset
int64_t getSrcValueOffset() const
Definition: SelectionDAGNodes.h:1301
Instructions.h
llvm::ISD::RegisterMask
@ RegisterMask
Definition: ISDOpcodes.h:75
llvm::ISD::PREFETCH
@ PREFETCH
PREFETCH - This corresponds to a prefetch intrinsic.
Definition: ISDOpcodes.h:1101
llvm::ConstantSDNode::isOpaque
bool isOpaque() const
Definition: SelectionDAGNodes.h:1589
llvm::ConstantPoolSDNode::getMachineCPVal
MachineConstantPoolValue * getMachineCPVal() const
Definition: SelectionDAGNodes.h:1882
SmallVector.h
llvm::ConstantSDNode::isAllOnesValue
bool isAllOnesValue() const
Definition: SelectionDAGNodes.h:1585
llvm::SDValue::getConstantOperandAPInt
const APInt & getConstantOperandAPInt(unsigned i) const
Definition: SelectionDAGNodes.h:1137
llvm::ISD::FIRST_TARGET_MEMORY_OPCODE
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:1261
List
const NodeList & List
Definition: RDFGraph.cpp:201
llvm::SDNode::hasPredecessorHelper
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.
Definition: SelectionDAGNodes.h:832
llvm::SDNodeFlags::setNoUnsignedWrap
void setNoUnsignedWrap(bool b)
Definition: SelectionDAGNodes.h:411
N
#define N
llvm::VPStoreSDNode::VPStoreSDNode
VPStoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs, ISD::MemIndexedMode AM, bool isTrunc, bool isCompressing, EVT MemVT, MachineMemOperand *MMO)
Definition: SelectionDAGNodes.h:2419
llvm::SDNode::getHasDebugValue
bool getHasDebugValue() const
Definition: SelectionDAGNodes.h:691
llvm::SDNode::DropOperands
void DropOperands()
Release the operands and set this node to have zero operands.
Definition: SelectionDAG.cpp:8777
llvm::MemSDNode::getSuccessOrdering
AtomicOrdering getSuccessOrdering() const
Return the atomic ordering requirements for this memory operation.
Definition: SelectionDAGNodes.h:1315
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
llvm::GlobalAddressSDNode::getAddressSpace
unsigned getAddressSpace() const
Definition: SelectionDAG.cpp:10708
llvm::SDValue::dumpr
void dumpr() const
Definition: SelectionDAGNodes.h:1181
llvm::ISD::TargetJumpTable
@ TargetJumpTable
Definition: ISDOpcodes.h:167
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
AddressingMode
Definition: SystemZISelLowering.cpp:871
llvm::ISD::SIGNED_UNSCALED
@ SIGNED_UNSCALED
Definition: ISDOpcodes.h:1324
llvm::SDNodeFlags::setNoNaNs
void setNoNaNs(bool b)
Definition: SelectionDAGNodes.h:414
llvm::ConstantSDNode::getAlignValue
Align getAlignValue() const
Definition: SelectionDAGNodes.h:1577
llvm::SDNode::getConstantOperandAPInt
const APInt & getConstantOperandAPInt(unsigned Num) const
Helper method returns the APInt of a ConstantSDNode operand.
Definition: SelectionDAGNodes.h:1601
ilist_node.h
llvm::ISD::isZEXTLoad
bool isZEXTLoad(const SDNode *N)
Returns true if the specified node is a ZEXTLOAD.
Definition: SelectionDAGNodes.h:2919
MachineMemOperand.h
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
llvm::ConstantSDNode::isNullValue
bool isNullValue() const
Definition: SelectionDAGNodes.h:1582
llvm::MachineMemOperand::getFailureOrdering
AtomicOrdering getFailureOrdering() const
For cmpxchg atomic operations, return the atomic ordering requirements when store does not occur.
Definition: MachineMemOperand.h:277
llvm::MaskedScatterSDNode
This class is used to represent an MSCATTER node.
Definition: SelectionDAGNodes.h:2715
llvm::SDValue::getOpcode
unsigned getOpcode() const
Definition: SelectionDAGNodes.h:1117
llvm::ShuffleVectorSDNode::isSplatMask
static bool isSplatMask(const int *Mask, EVT VT)
Definition: SelectionDAG.cpp:10927
llvm::GraphTraits< SDNode * >::child_begin
static ChildIteratorType child_begin(NodeRef N)
Definition: SelectionDAGNodes.h:2870
llvm::SmallPtrSetImpl
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:343
llvm::ConstantPoolSDNode::MachineCPVal
MachineConstantPoolValue * MachineCPVal
Definition: SelectionDAGNodes.h:1847
llvm::SDUse::operator=
SDUse & operator=(const SDUse &)=delete
llvm::SDNode::isTargetMemoryOpcode
bool isTargetMemoryOpcode() const
Test if this node has a target-specific memory-referencing opcode (in the <target>ISD namespace and g...
Definition: SelectionDAGNodes.h:647
llvm::SDNode::value_end
value_iterator value_end() const
Definition: SelectionDAGNodes.h:988
llvm::ISD::INTRINSIC_W_CHAIN
@ INTRINSIC_W_CHAIN
RESULT,OUTCHAIN = INTRINSIC_W_CHAIN(INCHAIN, INTRINSICID, arg1, ...) This node represents a target in...
Definition: ISDOpcodes.h:192
llvm::MemSDNode::readMem
bool readMem() const
Definition: SelectionDAGNodes.h:1267
llvm::PseudoProbeSDNode
This SDNode is used for PSEUDO_PROBE values, which are the function guid and the index of the basic b...
Definition: SelectionDAGNodes.h:1799
llvm::ConstantFPSDNode::isZero
bool isZero() const
Return true if the value is positive or negative zero.
Definition: SelectionDAGNodes.h:1620
llvm::SDValue::getDebugLoc
const DebugLoc & getDebugLoc() const
Definition: SelectionDAGNodes.h:1169
Register.h
llvm::SDNodeFlags::hasNoFPExcept
bool hasNoFPExcept() const
Definition: SelectionDAGNodes.h:434
llvm::VPStoreSDNode
This class is used to represent a VP_STORE node.
Definition: SelectionDAGNodes.h:2415
llvm::GraphTraits
Definition: GraphTraits.h:35
llvm::SDNode::setHasDebugValue
void setHasDebugValue(bool b)
Definition: SelectionDAGNodes.h:692
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
llvm::VPGatherScatterSDNode::getVectorLength
const SDValue & getVectorLength() const
Definition: SelectionDAGNodes.h:2598
llvm::ISD::isNormalStore
bool isNormalStore(const SDNode *N)
Returns true if the specified node is a non-truncating and unindexed store.
Definition: SelectionDAGNodes.h:2932
llvm::BuildVectorSDNode::getRepeatedSequence
bool getRepeatedSequence(const APInt &DemandedElts, SmallVectorImpl< SDValue > &Sequence, BitVector *UndefElements=nullptr) const
Find the shortest repeating sequence of values in the build vector.
Definition: SelectionDAG.cpp:10824
llvm::ISD::ATOMIC_LOAD_XOR
@ ATOMIC_LOAD_XOR
Definition: ISDOpcodes.h:1145
llvm::SDUse::getNode
SDNode * getNode() const
Convenience function for get().getNode().
Definition: SelectionDAGNodes.h:306
llvm::SDValue::setNode
void setNode(SDNode *N)
set the SDNode
Definition: SelectionDAGNodes.h:155
llvm::ISD::TargetFrameIndex
@ TargetFrameIndex
Definition: ISDOpcodes.h:166
llvm::SDNodeIterator::getNode
const SDNode * getNode() const
Definition: SelectionDAGNodes.h:2861
llvm::VPLoadStoreSDNode::getAddressingMode
ISD::MemIndexedMode getAddressingMode() const
Return the addressing mode for this load or store: unindexed, pre-inc, pre-dec, post-inc,...
Definition: SelectionDAGNodes.h:2371
llvm::simplify_type< SDUse >::getSimplifiedValue
static SimpleType getSimplifiedValue(SDUse &Val)
Definition: SelectionDAGNodes.h:363
llvm::MaskedLoadSDNode::getOffset
const SDValue & getOffset() const
Definition: SelectionDAGNodes.h:2509
llvm::AMDGPU::VGPRIndexMode::Id
Id
Definition: SIDefines.h:231
llvm::MachineMemOperand::getRanges
const MDNode * getRanges() const
Return the range tag for the memory reference.
Definition: MachineMemOperand.h:261
llvm::MaskedGatherScatterSDNode::getIndex
const SDValue & getIndex() const
Definition: SelectionDAGNodes.h:2678
llvm::ConstantPoolSDNode::getTargetFlags
unsigned getTargetFlags() const
Definition: SelectionDAGNodes.h:1894
llvm::SDNodeFlags::hasNoSignedZeros
bool hasNoSignedZeros() const
Definition: SelectionDAGNodes.h:429
llvm::SDNode::getSDVTList
static SDVTList getSDVTList(EVT VT)
Definition: SelectionDAGNodes.h:1055
llvm::SDValue::isMachineOpcode
bool isMachineOpcode() const
Definition: SelectionDAGNodes.h:1149
llvm::ISD::allOperandsUndef
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...
Definition: SelectionDAG.cpp:296
llvm::MemSDNode::getRanges
const MDNode * getRanges() const
Returns the Ranges that describes the dereference.
Definition: SelectionDAGNodes.h:1307
llvm::PseudoProbeSDNode::getAttributes
uint32_t getAttributes() const
Definition: SelectionDAGNodes.h:1813
llvm::AtomicSDNode::AtomicSDNode
AtomicSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTL, EVT MemVT, MachineMemOperand *MMO)
Definition: SelectionDAGNodes.h:1420
llvm::ConstantFPSDNode::getValueAPF
const APFloat & getValueAPF() const
Definition: SelectionDAGNodes.h:1616
llvm::SDNode::getFlags
SDNodeFlags getFlags() const
Definition: SelectionDAGNodes.h:955
llvm::CondCodeSDNode::get
ISD::CondCode get() const
Definition: SelectionDAGNodes.h:2221
llvm::VPLoadStoreSDNode::getOffset
const SDValue & getOffset() const
Definition: SelectionDAGNodes.h:2356
llvm::ExternalSymbolSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2189
llvm::ConstantPoolSDNode::isMachineConstantPoolEntry
bool isMachineConstantPoolEntry() const
Definition: SelectionDAGNodes.h:1873
llvm::ShuffleVectorSDNode::commuteMask
static void commuteMask(MutableArrayRef< int > Mask)
Change values in a shuffle permute mask assuming the two vector operands have swapped position.
Definition: SelectionDAGNodes.h:1538
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::MaskedGatherScatterSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2682
llvm::ISD::matchBinaryPredicate
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...
Definition: SelectionDAG.cpp:332
llvm::MaskedLoadSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2513
llvm::MaskedGatherSDNode::classof
static bool classof(const SDNode *N)
Definition: SelectionDAGNodes.h:2708
llvm::ISD::isConstantSplatVectorAllOnes
bool isConstantSplatVectorAllOnes(const SDNode *N, bool BuildVectorOnly=false)
Return true if the specified node is a BUILD_VECTOR or SPLAT_VECTOR where all of the elements are ~0 ...
Definition: SelectionDAG.cpp:171
l