Coverage Report

Created: 2018-07-18 22:01

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/CodeGen/SelectionDAGNodes.h
Line
Count
Source (jump to first uncovered line)
1
//===- llvm/CodeGen/SelectionDAGNodes.h - SelectionDAG Nodes ----*- C++ -*-===//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
// This file declares the SDNode class and derived classes, which are used to
11
// represent the nodes and operations present in a SelectionDAG.  These nodes
12
// and operations are machine code level operations, with some similarities to
13
// the GCC RTL representation.
14
//
15
// Clients should include the SelectionDAG.h file instead of this file directly.
16
//
17
//===----------------------------------------------------------------------===//
18
19
#ifndef LLVM_CODEGEN_SELECTIONDAGNODES_H
20
#define LLVM_CODEGEN_SELECTIONDAGNODES_H
21
22
#include "llvm/ADT/APFloat.h"
23
#include "llvm/ADT/ArrayRef.h"
24
#include "llvm/ADT/BitVector.h"
25
#include "llvm/ADT/FoldingSet.h"
26
#include "llvm/ADT/GraphTraits.h"
27
#include "llvm/ADT/SmallPtrSet.h"
28
#include "llvm/ADT/SmallVector.h"
29
#include "llvm/ADT/ilist_node.h"
30
#include "llvm/ADT/iterator.h"
31
#include "llvm/ADT/iterator_range.h"
32
#include "llvm/CodeGen/ISDOpcodes.h"
33
#include "llvm/CodeGen/MachineMemOperand.h"
34
#include "llvm/CodeGen/ValueTypes.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"
42
#include "llvm/Support/AtomicOrdering.h"
43
#include "llvm/Support/Casting.h"
44
#include "llvm/Support/ErrorHandling.h"
45
#include "llvm/Support/MachineValueType.h"
46
#include <algorithm>
47
#include <cassert>
48
#include <climits>
49
#include <cstddef>
50
#include <cstdint>
51
#include <cstring>
52
#include <iterator>
53
#include <string>
54
#include <tuple>
55
56
namespace llvm {
57
58
class APInt;
59
class Constant;
60
template <typename T> struct DenseMapInfo;
61
class GlobalValue;
62
class MachineBasicBlock;
63
class MachineConstantPoolValue;
64
class MCSymbol;
65
class raw_ostream;
66
class SDNode;
67
class SelectionDAG;
68
class Type;
69
class Value;
70
71
void checkForCycles(const SDNode *N, const SelectionDAG *DAG = nullptr,
72
                    bool force = false);
73
74
/// This represents a list of ValueType's that has been intern'd by
75
/// a SelectionDAG.  Instances of this simple value class are returned by
76
/// SelectionDAG::getVTList(...).
77
///
78
struct SDVTList {
79
  const EVT *VTs;
80
  unsigned int NumVTs;
81
};
82
83
namespace ISD {
84
85
  /// Node predicates
86
87
  /// If N is a BUILD_VECTOR node whose elements are all the same constant or
88
  /// undefined, return true and return the constant value in \p SplatValue.
89
  bool isConstantSplatVector(const SDNode *N, APInt &SplatValue);
90
91
  /// Return true if the specified node is a BUILD_VECTOR where all of the
92
  /// elements are ~0 or undef.
93
  bool isBuildVectorAllOnes(const SDNode *N);
94
95
  /// Return true if the specified node is a BUILD_VECTOR where all of the
96
  /// elements are 0 or undef.
97
  bool isBuildVectorAllZeros(const SDNode *N);
98
99
  /// Return true if the specified node is a BUILD_VECTOR node of all
100
  /// ConstantSDNode or undef.
101
  bool isBuildVectorOfConstantSDNodes(const SDNode *N);
102
103
  /// Return true if the specified node is a BUILD_VECTOR node of all
104
  /// ConstantFPSDNode or undef.
105
  bool isBuildVectorOfConstantFPSDNodes(const SDNode *N);
106
107
  /// Return true if the node has at least one operand and all operands of the
108
  /// specified node are ISD::UNDEF.
109
  bool allOperandsUndef(const SDNode *N);
110
111
} // end namespace ISD
112
113
//===----------------------------------------------------------------------===//
114
/// Unlike LLVM values, Selection DAG nodes may return multiple
115
/// values as the result of a computation.  Many nodes return multiple values,
116
/// from loads (which define a token and a return value) to ADDC (which returns
117
/// a result and a carry value), to calls (which may return an arbitrary number
118
/// of values).
119
///
120
/// As such, each use of a SelectionDAG computation must indicate the node that
121
/// computes it as well as which return value to use from that node.  This pair
122
/// of information is represented with the SDValue value type.
123
///
124
0
class SDValue {
125
  friend struct DenseMapInfo<SDValue>;
126
127
  SDNode *Node = nullptr; // The node defining the value we are using.
128
  unsigned ResNo = 0;     // Which return value of the node we are using.
129
130
public:
131
776M
  SDValue() = default;
132
  SDValue(SDNode *node, unsigned resno);
133
134
  /// get the index which selects a specific result in the SDNode
135
392M
  unsigned getResNo() const { return ResNo; }
136
137
  /// get the SDNode which holds the desired result
138
3.60G
  SDNode *getNode() const { return Node; }
139
140
  /// set the SDNode
141
16.8M
  void setNode(SDNode *N) { Node = N; }
142
143
461M
  inline SDNode *operator->() const { return Node; }
144
145
709M
  bool operator==(const SDValue &O) const {
146
709M
    return Node == O.Node && 
ResNo == O.ResNo453M
;
147
709M
  }
148
40.1M
  bool operator!=(const SDValue &O) const {
149
40.1M
    return !operator==(O);
150
40.1M
  }
151
321k
  bool operator<(const SDValue &O) const {
152
321k
    return std::tie(Node, ResNo) < std::tie(O.Node, O.ResNo);
153
321k
  }
154
110M
  explicit operator bool() const {
155
110M
    return Node != nullptr;
156
110M
  }
157
158
28.6M
  SDValue getValue(unsigned R) const {
159
28.6M
    return SDValue(Node, R);
160
28.6M
  }
161
162
  /// Return true if this node is an operand of N.
163
  bool isOperandOf(const SDNode *N) const;
164
165
  /// Return the ValueType of the referenced return value.
166
  inline EVT getValueType() const;
167
168
  /// Return the simple ValueType of the referenced return value.
169
17.7M
  MVT getSimpleValueType() const {
170
17.7M
    return getValueType().getSimpleVT();
171
17.7M
  }
172
173
  /// Returns the size of the value in bits.
174
5.46M
  unsigned getValueSizeInBits() const {
175
5.46M
    return getValueType().getSizeInBits();
176
5.46M
  }
177
178
83.9M
  unsigned getScalarValueSizeInBits() const {
179
83.9M
    return getValueType().getScalarType().getSizeInBits();
180
83.9M
  }
181
182
  // Forwarding methods - These forward to the corresponding methods in SDNode.
183
  inline unsigned getOpcode() const;
184
  inline unsigned getNumOperands() const;
185
  inline const SDValue &getOperand(unsigned i) const;
186
  inline uint64_t getConstantOperandVal(unsigned i) const;
187
  inline bool isTargetMemoryOpcode() const;
188
  inline bool isTargetOpcode() const;
189
  inline bool isMachineOpcode() const;
190
  inline bool isUndef() const;
191
  inline unsigned getMachineOpcode() const;
192
  inline const DebugLoc &getDebugLoc() const;
193
  inline void dump() const;
194
  inline void dump(const SelectionDAG *G) const;
195
  inline void dumpr() const;
196
  inline void dumpr(const SelectionDAG *G) const;
197
198
  /// Return true if this operand (which must be a chain) reaches the
199
  /// specified operand without crossing any side-effecting instructions.
200
  /// In practice, this looks through token factors and non-volatile loads.
201
  /// In order to remain efficient, this only
202
  /// looks a couple of nodes in, it does not do an exhaustive search.
203
  bool reachesChainWithoutSideEffects(SDValue Dest,
204
                                      unsigned Depth = 2) const;
205
206
  /// Return true if there are no nodes using value ResNo of Node.
207
  inline bool use_empty() const;
208
209
  /// Return true if there is exactly one node using value ResNo of Node.
210
  inline bool hasOneUse() const;
211
};
212
213
template<> struct DenseMapInfo<SDValue> {
214
103M
  static inline SDValue getEmptyKey() {
215
103M
    SDValue V;
216
103M
    V.ResNo = -1U;
217
103M
    return V;
218
103M
  }
219
220
75.9M
  static inline SDValue getTombstoneKey() {
221
75.9M
    SDValue V;
222
75.9M
    V.ResNo = -2U;
223
75.9M
    return V;
224
75.9M
  }
225
226
69.7M
  static unsigned getHashValue(const SDValue &Val) {
227
69.7M
    return ((unsigned)((uintptr_t)Val.getNode() >> 4) ^
228
69.7M
            (unsigned)((uintptr_t)Val.getNode() >> 9)) + Val.getResNo();
229
69.7M
  }
230
231
522M
  static bool isEqual(const SDValue &LHS, const SDValue &RHS) {
232
522M
    return LHS == RHS;
233
522M
  }
234
};
235
template <> struct isPodLike<SDValue> { static const bool value = true; };
236
237
/// Allow casting operators to work directly on
238
/// SDValues as if they were SDNode*'s.
239
template<> struct simplify_type<SDValue> {
240
  using SimpleType = SDNode *;
241
242
124M
  static SimpleType getSimplifiedValue(SDValue &Val) {
243
124M
    return Val.getNode();
244
124M
  }
245
};
246
template<> struct simplify_type<const SDValue> {
247
  using SimpleType = /*const*/ SDNode *;
248
249
783M
  static SimpleType getSimplifiedValue(const SDValue &Val) {
250
783M
    return Val.getNode();
251
783M
  }
252
};
253
254
/// Represents a use of a SDNode. This class holds an SDValue,
255
/// which records the SDNode being used and the result number, a
256
/// pointer to the SDNode using the value, and Next and Prev pointers,
257
/// which link together all the uses of an SDNode.
258
///
259
class SDUse {
260
  /// Val - The value being used.
261
  SDValue Val;
262
  /// User - The user of this value.
263
  SDNode *User = nullptr;
264
  /// Prev, Next - Pointers to the uses list of the SDNode referred by
265
  /// this operand.
266
  SDUse **Prev = nullptr;
267
  SDUse *Next = nullptr;
268
269
public:
270
16.8M
  SDUse() = default;
271
  SDUse(const SDUse &U) = delete;
272
  SDUse &operator=(const SDUse &) = delete;
273
274
  /// Normally SDUse will just implicitly convert to an SDValue that it holds.
275
1.30G
  operator const SDValue&() const { return Val; }
276
277
  /// If implicit conversion to SDValue doesn't work, the get() method returns
278
  /// the SDValue.
279
347M
  const SDValue &get() const { return Val; }
280
281
  /// This returns the SDNode that contains this Use.
282
300M
  SDNode *getUser() { return User; }
283
284
  /// Get the next SDUse in the use list.
285
361M
  SDUse *getNext() const { return Next; }
286
287
  /// Convenience function for get().getNode().
288
239M
  SDNode *getNode() const { return Val.getNode(); }
289
  /// Convenience function for get().getResNo().
290
176M
  unsigned getResNo() const { return Val.getResNo(); }
291
  /// Convenience function for get().getValueType().
292
  EVT getValueType() const { return Val.getValueType(); }
293
294
  /// Convenience function for get().operator==
295
1.15k
  bool operator==(const SDValue &V) const {
296
1.15k
    return Val == V;
297
1.15k
  }
298
299
  /// Convenience function for get().operator!=
300
1.92M
  bool operator!=(const SDValue &V) const {
301
1.92M
    return Val != V;
302
1.92M
  }
303
304
  /// Convenience function for get().operator<
305
  bool operator<(const SDValue &V) const {
306
    return Val < V;
307
  }
308
309
private:
310
  friend class SelectionDAG;
311
  friend class SDNode;
312
  // TODO: unfriend HandleSDNode once we fix its operand handling.
313
  friend class HandleSDNode;
314
315
150M
  void setUser(SDNode *p) { User = p; }
316
317
  /// Remove this use from its existing use list, assign it the
318
  /// given value, and add it to the new value's node's use list.
319
  inline void set(const SDValue &V);
320
  /// Like set, but only supports initializing a newly-allocated
321
  /// SDUse with a non-null value.
322
  inline void setInitial(const SDValue &V);
323
  /// Like set, but only sets the Node portion of the value,
324
  /// leaving the ResNo portion unmodified.
325
  inline void setNode(SDNode *N);
326
327
165M
  void addToList(SDUse **List) {
328
165M
    Next = *List;
329
165M
    if (Next) 
Next->Prev = &Next83.9M
;
330
165M
    Prev = List;
331
165M
    *List = this;
332
165M
  }
333
334
104M
  void removeFromList() {
335
104M
    *Prev = Next;
336
104M
    if (Next) 
Next->Prev = Prev29.8M
;
337
104M
  }
338
};
339
340
/// simplify_type specializations - Allow casting operators to work directly on
341
/// SDValues as if they were SDNode*'s.
342
template<> struct simplify_type<SDUse> {
343
  using SimpleType = SDNode *;
344
345
  static SimpleType getSimplifiedValue(SDUse &Val) {
346
    return Val.getNode();
347
  }
348
};
349
350
/// These are IR-level optimization flags that may be propagated to SDNodes.
351
/// TODO: This data structure should be shared by the IR optimizer and the
352
/// the backend.
353
0
struct SDNodeFlags {
354
private:
355
  // This bit is used to determine if the flags are in a defined state.
356
  // Flag bits can only be masked out during intersection if the masking flags
357
  // are defined.
358
  bool AnyDefined : 1;
359
360
  bool NoUnsignedWrap : 1;
361
  bool NoSignedWrap : 1;
362
  bool Exact : 1;
363
  bool NoNaNs : 1;
364
  bool NoInfs : 1;
365
  bool NoSignedZeros : 1;
366
  bool AllowReciprocal : 1;
367
  bool VectorReduction : 1;
368
  bool AllowContract : 1;
369
  bool ApproximateFuncs : 1;
370
  bool AllowReassociation : 1;
371
372
public:
373
  /// Default constructor turns off all optimization flags.
374
  SDNodeFlags()
375
      : AnyDefined(false), NoUnsignedWrap(false), NoSignedWrap(false),
376
        Exact(false), NoNaNs(false), NoInfs(false),
377
        NoSignedZeros(false), AllowReciprocal(false), VectorReduction(false),
378
        AllowContract(false), ApproximateFuncs(false),
379
121M
        AllowReassociation(false) {}
380
381
  /// Propagate the fast-math-flags from an IR FPMathOperator.
382
455k
  void copyFMF(const FPMathOperator &FPMO) {
383
455k
    setNoNaNs(FPMO.hasNoNaNs());
384
455k
    setNoInfs(FPMO.hasNoInfs());
385
455k
    setNoSignedZeros(FPMO.hasNoSignedZeros());
386
455k
    setAllowReciprocal(FPMO.hasAllowReciprocal());
387
455k
    setAllowContract(FPMO.hasAllowContract());
388
455k
    setApproximateFuncs(FPMO.hasApproxFunc());
389
455k
    setAllowReassociation(FPMO.hasAllowReassoc());
390
455k
  }
391
392
  /// Sets the state of the flags to the defined state.
393
7.60M
  void setDefined() { AnyDefined = true; }
394
  /// Returns true if the flags are in a defined state.
395
1.69M
  bool isDefined() const { return AnyDefined; }
396
397
  // These are mutators for each flag.
398
3.59M
  void setNoUnsignedWrap(bool b) {
399
3.59M
    setDefined();
400
3.59M
    NoUnsignedWrap = b;
401
3.59M
  }
402
653k
  void setNoSignedWrap(bool b) {
403
653k
    setDefined();
404
653k
    NoSignedWrap = b;
405
653k
  }
406
171k
  void setExact(bool b) {
407
171k
    setDefined();
408
171k
    Exact = b;
409
171k
  }
410
455k
  void setNoNaNs(bool b) {
411
455k
    setDefined();
412
455k
    NoNaNs = b;
413
455k
  }
414
455k
  void setNoInfs(bool b) {
415
455k
    setDefined();
416
455k
    NoInfs = b;
417
455k
  }
418
455k
  void setNoSignedZeros(bool b) {
419
455k
    setDefined();
420
455k
    NoSignedZeros = b;
421
455k
  }
422
455k
  void setAllowReciprocal(bool b) {
423
455k
    setDefined();
424
455k
    AllowReciprocal = b;
425
455k
  }
426
1.06k
  void setVectorReduction(bool b) {
427
1.06k
    setDefined();
428
1.06k
    VectorReduction = b;
429
1.06k
  }
430
455k
  void setAllowContract(bool b) {
431
455k
    setDefined();
432
455k
    AllowContract = b;
433
455k
  }
434
455k
  void setApproximateFuncs(bool b) {
435
455k
    setDefined();
436
455k
    ApproximateFuncs = b;
437
455k
  }
438
455k
  void setAllowReassociation(bool b) {
439
455k
    setDefined();
440
455k
    AllowReassociation = b;
441
455k
  }
442
443
  // These are accessors for each flag.
444
45.3k
  bool hasNoUnsignedWrap() const { return NoUnsignedWrap; }
445
26.9k
  bool hasNoSignedWrap() const { return NoSignedWrap; }
446
602k
  bool hasExact() const { return Exact; }
447
7.41M
  bool hasNoNaNs() const { return NoNaNs; }
448
7.01M
  bool hasNoInfs() const { return NoInfs; }
449
7.10M
  bool hasNoSignedZeros() const { return NoSignedZeros; }
450
7.21M
  bool hasAllowReciprocal() const { return AllowReciprocal; }
451
989k
  bool hasVectorReduction() const { return VectorReduction; }
452
7.30M
  bool hasAllowContract() const { return AllowContract; }
453
7.01M
  bool hasApproximateFuncs() const { return ApproximateFuncs; }
454
7.57M
  bool hasAllowReassociation() const { return AllowReassociation; }
455
456
  bool isFast() const {
457
    return NoSignedZeros && AllowReciprocal && NoNaNs && NoInfs &&
458
           AllowContract && ApproximateFuncs && AllowReassociation;
459
  }
460
461
  /// Clear any flags in this flag set that aren't also set in Flags.
462
  /// If the given Flags are undefined then don't do anything.
463
1.23M
  void intersectWith(const SDNodeFlags Flags) {
464
1.23M
    if (!Flags.isDefined())
465
1.01M
      return;
466
218k
    NoUnsignedWrap &= Flags.NoUnsignedWrap;
467
218k
    NoSignedWrap &= Flags.NoSignedWrap;
468
218k
    Exact &= Flags.Exact;
469
218k
    NoNaNs &= Flags.NoNaNs;
470
218k
    NoInfs &= Flags.NoInfs;
471
218k
    NoSignedZeros &= Flags.NoSignedZeros;
472
218k
    AllowReciprocal &= Flags.AllowReciprocal;
473
218k
    VectorReduction &= Flags.VectorReduction;
474
218k
    AllowContract &= Flags.AllowContract;
475
218k
    ApproximateFuncs &= Flags.ApproximateFuncs;
476
218k
    AllowReassociation &= Flags.AllowReassociation;
477
218k
  }
478
};
479
480
/// Represents one node in the SelectionDAG.
481
///
482
class SDNode : public FoldingSetNode, public ilist_node<SDNode> {
483
private:
484
  /// The operation that this node performs.
485
  int16_t NodeType;
486
487
protected:
488
  // We define a set of mini-helper classes to help us interpret the bits in our
489
  // SubclassData.  These are designed to fit within a uint16_t so they pack
490
  // with NodeType.
491
492
  class SDNodeBitfields {
493
    friend class SDNode;
494
    friend class MemIntrinsicSDNode;
495
    friend class MemSDNode;
496
    friend class SelectionDAG;
497
498
    uint16_t HasDebugValue : 1;
499
    uint16_t IsMemIntrinsic : 1;
500
    uint16_t IsDivergent : 1;
501
  };
502
  enum { NumSDNodeBits = 3 };
503
504
  class ConstantSDNodeBitfields {
505
    friend class ConstantSDNode;
506
507
    uint16_t : NumSDNodeBits;
508
509
    uint16_t IsOpaque : 1;
510
  };
511
512
  class MemSDNodeBitfields {
513
    friend class MemSDNode;
514
    friend class MemIntrinsicSDNode;
515
    friend class AtomicSDNode;
516
517
    uint16_t : NumSDNodeBits;
518
519
    uint16_t IsVolatile : 1;
520
    uint16_t IsNonTemporal : 1;
521
    uint16_t IsDereferenceable : 1;
522
    uint16_t IsInvariant : 1;
523
  };
524
  enum { NumMemSDNodeBits = NumSDNodeBits + 4 };
525
526
  class LSBaseSDNodeBitfields {
527
    friend class LSBaseSDNode;
528
529
    uint16_t : NumMemSDNodeBits;
530
531
    uint16_t AddressingMode : 3; // enum ISD::MemIndexedMode
532
  };
533
  enum { NumLSBaseSDNodeBits = NumMemSDNodeBits + 3 };
534
535
  class LoadSDNodeBitfields {
536
    friend class LoadSDNode;
537
    friend class MaskedLoadSDNode;
538
539
    uint16_t : NumLSBaseSDNodeBits;
540
541
    uint16_t ExtTy : 2; // enum ISD::LoadExtType
542
    uint16_t IsExpanding : 1;
543
  };
544
545
  class StoreSDNodeBitfields {
546
    friend class StoreSDNode;
547
    friend class MaskedStoreSDNode;
548
549
    uint16_t : NumLSBaseSDNodeBits;
550
551
    uint16_t IsTruncating : 1;
552
    uint16_t IsCompressing : 1;
553
  };
554
555
  union {
556
    char RawSDNodeBits[sizeof(uint16_t)];
557
    SDNodeBitfields SDNodeBits;
558
    ConstantSDNodeBitfields ConstantSDNodeBits;
559
    MemSDNodeBitfields MemSDNodeBits;
560
    LSBaseSDNodeBitfields LSBaseSDNodeBits;
561
    LoadSDNodeBitfields LoadSDNodeBits;
562
    StoreSDNodeBitfields StoreSDNodeBits;
563
  };
564
565
  // RawSDNodeBits must cover the entirety of the union.  This means that all of
566
  // the union's members must have size <= RawSDNodeBits.  We write the RHS as
567
  // "2" instead of sizeof(RawSDNodeBits) because MSVC can't handle the latter.
568
  static_assert(sizeof(SDNodeBitfields) <= 2, "field too wide");
569
  static_assert(sizeof(ConstantSDNodeBitfields) <= 2, "field too wide");
570
  static_assert(sizeof(MemSDNodeBitfields) <= 2, "field too wide");
571
  static_assert(sizeof(LSBaseSDNodeBitfields) <= 2, "field too wide");
572
  static_assert(sizeof(LoadSDNodeBitfields) <= 2, "field too wide");
573
  static_assert(sizeof(StoreSDNodeBitfields) <= 2, "field too wide");
574
575
private:
576
  friend class SelectionDAG;
577
  // TODO: unfriend HandleSDNode once we fix its operand handling.
578
  friend class HandleSDNode;
579
580
  /// Unique id per SDNode in the DAG.
581
  int NodeId = -1;
582
583
  /// The values that are used by this operation.
584
  SDUse *OperandList = nullptr;
585
586
  /// The types of the values this node defines.  SDNode's may
587
  /// define multiple values simultaneously.
588
  const EVT *ValueList;
589
590
  /// List of uses for this SDNode.
591
  SDUse *UseList = nullptr;
592
593
  /// The number of entries in the Operand/Value list.
594
  unsigned short NumOperands = 0;
595
  unsigned short NumValues;
596
597
  // The ordering of the SDNodes. It roughly corresponds to the ordering of the
598
  // original LLVM instructions.
599
  // This is used for turning off scheduling, because we'll forgo
600
  // the normal scheduling algorithms and output the instructions according to
601
  // this ordering.
602
  unsigned IROrder;
603
604
  /// Source line information.
605
  DebugLoc debugLoc;
606
607
  /// Return a pointer to the specified value type.
608
  static const EVT *getValueTypeList(EVT VT);
609
610
  SDNodeFlags Flags;
611
612
public:
613
  /// Unique and persistent id per SDNode in the DAG.
614
  /// Used for debug printing.
615
  uint16_t PersistentId;
616
617
  //===--------------------------------------------------------------------===//
618
  //  Accessors
619
  //
620
621
  /// Return the SelectionDAG opcode value for this node. For
622
  /// pre-isel nodes (those for which isMachineOpcode returns false), these
623
  /// are the opcode values in the ISD and <target>ISD namespaces. For
624
  /// post-isel opcodes, see getMachineOpcode.
625
6.03G
  unsigned getOpcode()  const { return (unsigned short)NodeType; }
626
627
  /// Test if this node has a target-specific opcode (in the
628
  /// \<target\>ISD namespace).
629
591k
  bool isTargetOpcode() const { return NodeType >= ISD::BUILTIN_OP_END; }
630
631
  /// Test if this node has a target-specific
632
  /// memory-referencing opcode (in the \<target\>ISD namespace and
633
  /// greater than FIRST_TARGET_MEMORY_OPCODE).
634
75.0M
  bool isTargetMemoryOpcode() const {
635
75.0M
    return NodeType >= ISD::FIRST_TARGET_MEMORY_OPCODE;
636
75.0M
  }
637
638
  /// Return true if the type of the node type undefined.
639
67.1M
  bool isUndef() const { return NodeType == ISD::UNDEF; }
640
641
  /// Test if this node is a memory intrinsic (with valid pointer information).
642
  /// INTRINSIC_W_CHAIN and INTRINSIC_VOID nodes are sometimes created for
643
  /// non-memory intrinsics (with chains) that are not really instances of
644
  /// MemSDNode. For such nodes, we need some extra state to determine the
645
  /// proper classof relationship.
646
1.63M
  bool isMemIntrinsic() const {
647
1.63M
    return (NodeType == ISD::INTRINSIC_W_CHAIN ||
648
1.63M
            
NodeType == ISD::INTRINSIC_VOID1.59M
) &&
649
1.63M
           
SDNodeBits.IsMemIntrinsic82.2k
;
650
1.63M
  }
651
652
  /// Test if this node is a strict floating point pseudo-op.
653
31.3M
  bool isStrictFPOpcode() {
654
31.3M
    switch (NodeType) {
655
31.3M
      default:
656
31.3M
        return false;
657
31.3M
      case ISD::STRICT_FADD:
658
100
      case ISD::STRICT_FSUB:
659
100
      case ISD::STRICT_FMUL:
660
100
      case ISD::STRICT_FDIV:
661
100
      case ISD::STRICT_FREM:
662
100
      case ISD::STRICT_FMA:
663
100
      case ISD::STRICT_FSQRT:
664
100
      case ISD::STRICT_FPOW:
665
100
      case ISD::STRICT_FPOWI:
666
100
      case ISD::STRICT_FSIN:
667
100
      case ISD::STRICT_FCOS:
668
100
      case ISD::STRICT_FEXP:
669
100
      case ISD::STRICT_FEXP2:
670
100
      case ISD::STRICT_FLOG:
671
100
      case ISD::STRICT_FLOG10:
672
100
      case ISD::STRICT_FLOG2:
673
100
      case ISD::STRICT_FRINT:
674
100
      case ISD::STRICT_FNEARBYINT:
675
100
        return true;
676
31.3M
    }
677
31.3M
  }
678
679
  /// Test if this node has a post-isel opcode, directly
680
  /// corresponding to a MachineInstr opcode.
681
261M
  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
124M
  unsigned getMachineOpcode() const {
687
124M
    assert(isMachineOpcode() && "Not a MachineInstr opcode!");
688
124M
    return ~NodeType;
689
124M
  }
690
691
17.3M
  bool getHasDebugValue() const { return SDNodeBits.HasDebugValue; }
692
530
  void setHasDebugValue(bool b) { SDNodeBits.HasDebugValue = b; }
693
694
121M
  bool isDivergent() const { return SDNodeBits.IsDivergent; }
695
696
  /// Return true if there are no uses of this node.
697
586M
  bool use_empty() const { return UseList == nullptr; }
698
699
  /// Return true if there is exactly one use of this node.
700
41.1M
  bool hasOneUse() const {
701
41.1M
    return !use_empty() && 
std::next(use_begin()) == use_end()41.1M
;
702
41.1M
  }
703
704
  /// Return the number of uses of this node. This method takes
705
  /// time proportional to the number of uses.
706
1.53k
  size_t use_size() const { return std::distance(use_begin(), use_end()); }
707
708
  /// Return the unique node id.
709
306M
  int getNodeId() const { return NodeId; }
710
711
  /// Set unique node id.
712
430M
  void setNodeId(int Id) { NodeId = Id; }
713
714
  /// Return the node ordering.
715
192M
  unsigned getIROrder() const { return IROrder; }
716
717
  /// Set the node ordering.
718
152k
  void setIROrder(unsigned Order) { IROrder = Order; }
719
720
  /// Return the source location info.
721
141M
  const DebugLoc &getDebugLoc() const { return debugLoc; }
722
723
  /// Set source location info.  Try to avoid this, putting
724
  /// it in the constructor is preferable.
725
957k
  void setDebugLoc(DebugLoc dl) { debugLoc = std::move(dl); }
726
727
  /// This class provides iterator support for SDUse
728
  /// operands that use a specific SDNode.
729
  class use_iterator
730
    : public std::iterator<std::forward_iterator_tag, SDUse, ptrdiff_t> {
731
    friend class SDNode;
732
733
    SDUse *Op = nullptr;
734
735
538M
    explicit use_iterator(SDUse *op) : Op(op) {}
736
737
  public:
738
    using reference = std::iterator<std::forward_iterator_tag,
739
                                    SDUse, ptrdiff_t>::reference;
740
    using pointer = std::iterator<std::forward_iterator_tag,
741
                                  SDUse, ptrdiff_t>::pointer;
742
743
    use_iterator() = default;
744
244M
    use_iterator(const use_iterator &I) : Op(I.Op) {}
745
746
604M
    bool operator==(const use_iterator &x) const {
747
604M
      return Op == x.Op;
748
604M
    }
749
563M
    bool operator!=(const use_iterator &x) const {
750
563M
      return !operator==(x);
751
563M
    }
752
753
    /// Return true if this iterator is at the end of uses list.
754
    bool atEnd() const { return Op == nullptr; }
755
756
    // Iterator traversal: forward iteration only.
757
361M
    use_iterator &operator++() {          // Preincrement
758
361M
      assert(Op && "Cannot increment end iterator!");
759
361M
      Op = Op->getNext();
760
361M
      return *this;
761
361M
    }
762
763
160
    use_iterator operator++(int) {        // Postincrement
764
160
      use_iterator tmp = *this; ++*this; return tmp;
765
160
    }
766
767
    /// Retrieve a pointer to the current user node.
768
286M
    SDNode *operator*() const {
769
286M
      assert(Op && "Cannot dereference end iterator!");
770
286M
      return Op->getUser();
771
286M
    }
772
773
1.28M
    SDNode *operator->() const { return operator*(); }
774
775
90.7M
    SDUse &getUse() const { return *Op; }
776
777
    /// Retrieve the operand # of this use in its user.
778
13.7M
    unsigned getOperandNo() const {
779
13.7M
      assert(Op && "Cannot dereference end iterator!");
780
13.7M
      return (unsigned)(Op - Op->getUser()->OperandList);
781
13.7M
    }
782
  };
783
784
  /// Provide iteration support to walk over all uses of an SDNode.
785
269M
  use_iterator use_begin() const {
786
269M
    return use_iterator(UseList);
787
269M
  }
788
789
268M
  static use_iterator use_end() { return use_iterator(nullptr); }
790
791
32.7M
  inline iterator_range<use_iterator> uses() {
792
32.7M
    return make_range(use_begin(), use_end());
793
32.7M
  }
794
1.08M
  inline iterator_range<use_iterator> uses() const {
795
1.08M
    return make_range(use_begin(), use_end());
796
1.08M
  }
797
798
  /// Return true if there are exactly NUSES uses of the indicated value.
799
  /// This method ignores uses of other values defined by this operation.
800
  bool hasNUsesOfValue(unsigned NUses, unsigned Value) const;
801
802
  /// Return true if there are any use of the indicated value.
803
  /// This method ignores uses of other values defined by this operation.
804
  bool hasAnyUseOfValue(unsigned Value) const;
805
806
  /// Return true if this node is the only use of N.
807
  bool isOnlyUserOf(const SDNode *N) const;
808
809
  /// Return true if this node is an operand of N.
810
  bool isOperandOf(const SDNode *N) const;
811
812
  /// Return true if this node is a predecessor of N.
813
  /// NOTE: Implemented on top of hasPredecessor and every bit as
814
  /// expensive. Use carefully.
815
93.4k
  bool isPredecessorOf(const SDNode *N) const {
816
93.4k
    return N->hasPredecessor(this);
817
93.4k
  }
818
819
  /// Return true if N is a predecessor of this node.
820
  /// N is either an operand of this node, or can be reached by recursively
821
  /// traversing up the operands.
822
  /// NOTE: This is an expensive method. Use it carefully.
823
  bool hasPredecessor(const SDNode *N) const;
824
825
  /// Returns true if N is a predecessor of any node in Worklist. This
826
  /// helper keeps Visited and Worklist sets externally to allow unions
827
  /// searches to be performed in parallel, caching of results across
828
  /// queries and incremental addition to Worklist. Stops early if N is
829
  /// found but will resume. Remember to clear Visited and Worklists
830
  /// if DAG changes. MaxSteps gives a maximum number of nodes to visit before
831
  /// giving up. The TopologicalPrune flag signals that positive NodeIds are
832
  /// topologically ordered (Operands have strictly smaller node id) and search
833
  /// can be pruned leveraging this.
834
  static bool hasPredecessorHelper(const SDNode *N,
835
                                   SmallPtrSetImpl<const SDNode *> &Visited,
836
                                   SmallVectorImpl<const SDNode *> &Worklist,
837
                                   unsigned int MaxSteps = 0,
838
490k
                                   bool TopologicalPrune = false) {
839
490k
    SmallVector<const SDNode *, 8> DeferredNodes;
840
490k
    if (Visited.count(N))
841
55.5k
      return true;
842
434k
843
434k
    // Node Id's are assigned in three places: As a topological
844
434k
    // ordering (> 0), during legalization (results in values set to
845
434k
    // 0), new nodes (set to -1). If N has a topolgical id then we
846
434k
    // know that all nodes with ids smaller than it cannot be
847
434k
    // successors and we need not check them. Filter out all node
848
434k
    // that can't be matches. We add them to the worklist before exit
849
434k
    // in case of multiple calls. Note that during selection the topological id
850
434k
    // may be violated if a node's predecessor is selected before it. We mark
851
434k
    // this at selection negating the id of unselected successors and
852
434k
    // restricting topological pruning to positive ids.
853
434k
854
434k
    int NId = N->getNodeId();
855
434k
    // If we Invalidated the Id, reconstruct original NId.
856
434k
    if (NId < -1)
857
20.0k
      NId = -(NId + 1);
858
434k
859
434k
    bool Found = false;
860
5.03M
    while (!Worklist.empty()) {
861
4.65M
      const SDNode *M = Worklist.pop_back_val();
862
4.65M
      int MId = M->getNodeId();
863
4.65M
      if (TopologicalPrune && 
M->getOpcode() != ISD::TokenFactor169k
&&
(NId > 0)165k
&&
864
4.65M
          
(MId > 0)165k
&&
(MId < NId)159k
) {
865
117k
        DeferredNodes.push_back(M);
866
117k
        continue;
867
117k
      }
868
8.76M
      
for (const SDValue &OpV : M->op_values())4.53M
{
869
8.76M
        SDNode *Op = OpV.getNode();
870
8.76M
        if (Visited.insert(Op).second)
871
4.43M
          Worklist.push_back(Op);
872
8.76M
        if (Op == N)
873
52.5k
          Found = true;
874
8.76M
      }
875
4.53M
      if (Found)
876
51.9k
        break;
877
4.48M
      if (MaxSteps != 0 && 
Visited.size() >= MaxSteps115k
)
878
0
        break;
879
4.48M
    }
880
434k
    // Push deferred nodes back on worklist.
881
434k
    Worklist.append(DeferredNodes.begin(), DeferredNodes.end());
882
434k
    // If we bailed early, conservatively return found.
883
434k
    if (MaxSteps != 0 && 
Visited.size() >= MaxSteps142k
)
884
0
      return true;
885
434k
    return Found;
886
434k
  }
887
888
  /// Return true if all the users of N are contained in Nodes.
889
  /// NOTE: Requires at least one match, but doesn't require them all.
890
  static bool areOnlyUsersOf(ArrayRef<const SDNode *> Nodes, const SDNode *N);
891
892
  /// Return the number of values used by this operation.
893
568M
  unsigned getNumOperands() const { return NumOperands; }
894
895
  /// Helper method returns the integer value of a ConstantSDNode operand.
896
  inline uint64_t getConstantOperandVal(unsigned Num) const;
897
898
1.26G
  const SDValue &getOperand(unsigned Num) const {
899
1.26G
    assert(Num < NumOperands && "Invalid child # of SDNode!");
900
1.26G
    return OperandList[Num];
901
1.26G
  }
902
903
  using op_iterator = SDUse *;
904
905
323M
  op_iterator op_begin() const { return OperandList; }
906
317M
  op_iterator op_end() const { return OperandList+NumOperands; }
907
78.3M
  ArrayRef<SDUse> ops() const { return makeArrayRef(op_begin(), op_end()); }
908
909
  /// Iterator for directly iterating over the operand SDValue's.
910
  struct value_op_iterator
911
      : iterator_adaptor_base<value_op_iterator, op_iterator,
912
                              std::random_access_iterator_tag, SDValue,
913
                              ptrdiff_t, value_op_iterator *,
914
                              value_op_iterator *> {
915
    explicit value_op_iterator(SDUse *U = nullptr)
916
368M
      : iterator_adaptor_base(U) {}
917
918
340M
    const SDValue &operator*() const { return I->get(); }
919
  };
920
921
184M
  iterator_range<value_op_iterator> op_values() const {
922
184M
    return make_range(value_op_iterator(op_begin()),
923
184M
                      value_op_iterator(op_end()));
924
184M
  }
925
926
75.2M
  SDVTList getVTList() const {
927
75.2M
    SDVTList X = { ValueList, NumValues };
928
75.2M
    return X;
929
75.2M
  }
930
931
  /// If this node has a glue operand, return the node
932
  /// to which the glue operand points. Otherwise return NULL.
933
83.0M
  SDNode *getGluedNode() const {
934
83.0M
    if (getNumOperands() != 0 &&
935
83.0M
        
getOperand(getNumOperands()-1).getValueType() == MVT::Glue82.5M
)
936
15.4M
      return getOperand(getNumOperands()-1).getNode();
937
67.5M
    return nullptr;
938
67.5M
  }
939
940
  /// If this node has a glue value with a user, return
941
  /// the user (there is at most one). Otherwise return NULL.
942
3.84M
  SDNode *getGluedUser() const {
943
8.75M
    for (use_iterator UI = use_begin(), UE = use_end(); UI != UE; 
++UI4.91M
)
944
6.56M
      if (UI.getUse().get().getValueType() == MVT::Glue)
945
1.64M
        return *UI;
946
3.84M
    
return nullptr2.19M
;
947
3.84M
  }
948
949
13.3M
  const SDNodeFlags getFlags() const { return Flags; }
950
18.4M
  void setFlags(SDNodeFlags NewFlags) { Flags = NewFlags; }
951
  bool isFast() { return Flags.isFast(); }
952
953
  /// Clear any flags in this node that aren't also set in Flags.
954
  /// If Flags is not in a defined state then this has no effect.
955
  void intersectFlagsWith(const SDNodeFlags Flags);
956
957
  /// Return the number of values defined/returned by this operator.
958
170M
  unsigned getNumValues() const { return NumValues; }
959
960
  /// Return the type of a specified result.
961
1.03G
  EVT getValueType(unsigned ResNo) const {
962
1.03G
    assert(ResNo < NumValues && "Illegal result number!");
963
1.03G
    return ValueList[ResNo];
964
1.03G
  }
965
966
  /// Return the type of a specified result as a simple type.
967
34.4M
  MVT getSimpleValueType(unsigned ResNo) const {
968
34.4M
    return getValueType(ResNo).getSimpleVT();
969
34.4M
  }
970
971
  /// Returns MVT::getSizeInBits(getValueType(ResNo)).
972
928k
  unsigned getValueSizeInBits(unsigned ResNo) const {
973
928k
    return getValueType(ResNo).getSizeInBits();
974
928k
  }
975
976
  using value_iterator = const EVT *;
977
978
37.8M
  value_iterator value_begin() const { return ValueList; }
979
37.8M
  value_iterator value_end() const { return ValueList+NumValues; }
980
981
  /// Return the opcode of this operation for printing.
982
  std::string getOperationName(const SelectionDAG *G = nullptr) const;
983
  static const char* getIndexedModeName(ISD::MemIndexedMode AM);
984
  void print_types(raw_ostream &OS, const SelectionDAG *G) const;
985
  void print_details(raw_ostream &OS, const SelectionDAG *G) const;
986
  void print(raw_ostream &OS, const SelectionDAG *G = nullptr) const;
987
  void printr(raw_ostream &OS, const SelectionDAG *G = nullptr) const;
988
989
  /// Print a SelectionDAG node and all children down to
990
  /// the leaves.  The given SelectionDAG allows target-specific nodes
991
  /// to be printed in human-readable form.  Unlike printr, this will
992
  /// print the whole DAG, including children that appear multiple
993
  /// times.
994
  ///
995
  void printrFull(raw_ostream &O, const SelectionDAG *G = nullptr) const;
996
997
  /// Print a SelectionDAG node and children up to
998
  /// depth "depth."  The given SelectionDAG allows target-specific
999
  /// nodes to be printed in human-readable form.  Unlike printr, this
1000
  /// will print children that appear multiple times wherever they are
1001
  /// used.
1002
  ///
1003
  void printrWithDepth(raw_ostream &O, const SelectionDAG *G = nullptr,
1004
                       unsigned depth = 100) const;
1005
1006
  /// Dump this node, for debugging.
1007
  void dump() const;
1008
1009
  /// Dump (recursively) this node and its use-def subgraph.
1010
  void dumpr() const;
1011
1012
  /// Dump this node, for debugging.
1013
  /// The given SelectionDAG allows target-specific nodes to be printed
1014
  /// in human-readable form.
1015
  void dump(const SelectionDAG *G) const;
1016
1017
  /// Dump (recursively) this node and its use-def subgraph.
1018
  /// The given SelectionDAG allows target-specific nodes to be printed
1019
  /// in human-readable form.
1020
  void dumpr(const SelectionDAG *G) const;
1021
1022
  /// printrFull to dbgs().  The given SelectionDAG allows
1023
  /// target-specific nodes to be printed in human-readable form.
1024
  /// Unlike dumpr, this will print the whole DAG, including children
1025
  /// that appear multiple times.
1026
  void dumprFull(const SelectionDAG *G = nullptr) const;
1027
1028
  /// printrWithDepth to dbgs().  The given
1029
  /// SelectionDAG allows target-specific nodes to be printed in
1030
  /// human-readable form.  Unlike dumpr, this will print children
1031
  /// that appear multiple times wherever they are used.
1032
  ///
1033
  void dumprWithDepth(const SelectionDAG *G = nullptr,
1034
                      unsigned depth = 100) const;
1035
1036
  /// Gather unique data for the node.
1037
  void Profile(FoldingSetNodeID &ID) const;
1038
1039
  /// This method should only be used by the SDUse class.
1040
165M
  void addUse(SDUse &U) { U.addToList(&UseList); }
1041
1042
protected:
1043
45.5M
  static SDVTList getSDVTList(EVT VT) {
1044
45.5M
    SDVTList Ret = { getValueTypeList(VT), 1 };
1045
45.5M
    return Ret;
1046
45.5M
  }
1047
1048
  /// Create an SDNode.
1049
  ///
1050
  /// SDNodes are created without any operands, and never own the operand
1051
  /// storage. To add operands, see SelectionDAG::createOperands.
1052
  SDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs)
1053
      : NodeType(Opc), ValueList(VTs.VTs), NumValues(VTs.NumVTs),
1054
85.2M
        IROrder(Order), debugLoc(std::move(dl)) {
1055
85.2M
    memset(&RawSDNodeBits, 0, sizeof(RawSDNodeBits));
1056
85.2M
    assert(debugLoc.hasTrivialDestructor() && "Expected trivial destructor");
1057
85.2M
    assert(NumValues == VTs.NumVTs &&
1058
85.2M
           "NumValues wasn't wide enough for its operands!");
1059
85.2M
  }
1060
1061
  /// Release the operands and set this node to have zero operands.
1062
  void DropOperands();
1063
};
1064
1065
/// Wrapper class for IR location info (IR ordering and DebugLoc) to be passed
1066
/// into SDNode creation functions.
1067
/// When an SDNode is created from the DAGBuilder, the DebugLoc is extracted
1068
/// from the original Instruction, and IROrder is the ordinal position of
1069
/// the instruction.
1070
/// When an SDNode is created after the DAG is being built, both DebugLoc and
1071
/// the IROrder are propagated from the original SDNode.
1072
/// So SDLoc class provides two constructors besides the default one, one to
1073
/// be used by the DAGBuilder, the other to be used by others.
1074
0
class SDLoc {
1075
private:
1076
  DebugLoc DL;
1077
  int IROrder = 0;
1078
1079
public:
1080
7.13M
  SDLoc() = default;
1081
121M
  SDLoc(const SDNode *N) : DL(N->getDebugLoc()), IROrder(N->getIROrder()) {}
1082
45.4M
  SDLoc(const SDValue V) : SDLoc(V.getNode()) {}
1083
20.3M
  SDLoc(const Instruction *I, int Order) : IROrder(Order) {
1084
20.3M
    assert(Order >= 0 && "bad IROrder");
1085
20.3M
    if (I)
1086
18.7M
      DL = I->getDebugLoc();
1087
20.3M
  }
1088
1089
64.6M
  unsigned getIROrder() const { return IROrder; }
1090
43.1M
  const DebugLoc &getDebugLoc() const { return DL; }
1091
};
1092
1093
// Define inline functions from the SDValue class.
1094
1095
inline SDValue::SDValue(SDNode *node, unsigned resno)
1096
263M
    : Node(node), ResNo(resno) {
1097
263M
  // Explicitly check for !ResNo to avoid use-after-free, because there are
1098
263M
  // callers that use SDValue(N, 0) with a deleted N to indicate successful
1099
263M
  // combines.
1100
263M
  assert((!Node || !ResNo || ResNo < Node->getNumValues()) &&
1101
263M
         "Invalid result number for the given node!");
1102
263M
  assert(ResNo < -2U && "Cannot use result numbers reserved for DenseMaps.");
1103
263M
}
1104
1105
572M
inline unsigned SDValue::getOpcode() const {
1106
572M
  return Node->getOpcode();
1107
572M
}
1108
1109
729M
inline EVT SDValue::getValueType() const {
1110
729M
  return Node->getValueType(ResNo);
1111
729M
}
1112
1113
82.9M
inline unsigned SDValue::getNumOperands() const {
1114
82.9M
  return Node->getNumOperands();
1115
82.9M
}
1116
1117
193M
inline const SDValue &SDValue::getOperand(unsigned i) const {
1118
193M
  return Node->getOperand(i);
1119
193M
}
1120
1121
1.47M
inline uint64_t SDValue::getConstantOperandVal(unsigned i) const {
1122
1.47M
  return Node->getConstantOperandVal(i);
1123
1.47M
}
1124
1125
inline bool SDValue::isTargetOpcode() const {
1126
  return Node->isTargetOpcode();
1127
}
1128
1129
inline bool SDValue::isTargetMemoryOpcode() const {
1130
  return Node->isTargetMemoryOpcode();
1131
}
1132
1133
40.2M
inline bool SDValue::isMachineOpcode() const {
1134
40.2M
  return Node->isMachineOpcode();
1135
40.2M
}
1136
1137
7.77M
inline unsigned SDValue::getMachineOpcode() const {
1138
7.77M
  return Node->getMachineOpcode();
1139
7.77M
}
1140
1141
66.7M
inline bool SDValue::isUndef() const {
1142
66.7M
  return Node->isUndef();
1143
66.7M
}
1144
1145
1.03M
inline bool SDValue::use_empty() const {
1146
1.03M
  return !Node->hasAnyUseOfValue(ResNo);
1147
1.03M
}
1148
1149
22.4M
inline bool SDValue::hasOneUse() const {
1150
22.4M
  return Node->hasNUsesOfValue(1, ResNo);
1151
22.4M
}
1152
1153
122k
inline const DebugLoc &SDValue::getDebugLoc() const {
1154
122k
  return Node->getDebugLoc();
1155
122k
}
1156
1157
inline void SDValue::dump() const {
1158
  return Node->dump();
1159
}
1160
1161
inline void SDValue::dump(const SelectionDAG *G) const {
1162
  return Node->dump(G);
1163
}
1164
1165
inline void SDValue::dumpr() const {
1166
  return Node->dumpr();
1167
}
1168
1169
inline void SDValue::dumpr(const SelectionDAG *G) const {
1170
  return Node->dumpr(G);
1171
}
1172
1173
// Define inline functions from the SDUse class.
1174
1175
101M
inline void SDUse::set(const SDValue &V) {
1176
101M
  if (
Val.getNode()101M
) removeFromList();
1177
101M
  Val = V;
1178
101M
  if (V.getNode()) 
V.getNode()->addUse(*this)11.2M
;
1179
101M
}
1180
1181
150M
inline void SDUse::setInitial(const SDValue &V) {
1182
150M
  Val = V;
1183
150M
  V.getNode()->addUse(*this);
1184
150M
}
1185
1186
3.66M
inline void SDUse::setNode(SDNode *N) {
1187
3.66M
  if (Val.getNode()) removeFromList();
1188
3.66M
  Val.setNode(N);
1189
3.66M
  if (N) N->addUse(*this);
1190
3.66M
}
1191
1192
/// This class is used to form a handle around another node that
1193
/// is persistent and is updated across invocations of replaceAllUsesWith on its
1194
/// operand.  This node should be directly created by end-users and not added to
1195
/// the AllNodes list.
1196
class HandleSDNode : public SDNode {
1197
  SDUse Op;
1198
1199
public:
1200
  explicit HandleSDNode(SDValue X)
1201
16.8M
    : SDNode(ISD::HANDLENODE, 0, DebugLoc(), getSDVTList(MVT::Other)) {
1202
16.8M
    // HandleSDNodes are never inserted into the DAG, so they won't be
1203
16.8M
    // auto-numbered. Use ID 65535 as a sentinel.
1204
16.8M
    PersistentId = 0xffff;
1205
16.8M
1206
16.8M
    // Manually set up the operand list. This node type is special in that it's
1207
16.8M
    // always stack allocated and SelectionDAG does not manage its operands.
1208
16.8M
    // TODO: This should either (a) not be in the SDNode hierarchy, or (b) not
1209
16.8M
    // be so special.
1210
16.8M
    Op.setUser(this);
1211
16.8M
    Op.setInitial(X);
1212
16.8M
    NumOperands = 1;
1213
16.8M
    OperandList = &Op;
1214
16.8M
  }
1215
  ~HandleSDNode();
1216
1217
15.5M
  const SDValue &getValue() const { return Op; }
1218
};
1219
1220
class AddrSpaceCastSDNode : public SDNode {
1221
private:
1222
  unsigned SrcAddrSpace;
1223
  unsigned DestAddrSpace;
1224
1225
public:
1226
  AddrSpaceCastSDNode(unsigned Order, const DebugLoc &dl, EVT VT,
1227
                      unsigned SrcAS, unsigned DestAS);
1228
1229
454
  unsigned getSrcAddressSpace() const { return SrcAddrSpace; }
1230
378
  unsigned getDestAddressSpace() const { return DestAddrSpace; }
1231
1232
1.23k
  static bool classof(const SDNode *N) {
1233
1.23k
    return N->getOpcode() == ISD::ADDRSPACECAST;
1234
1.23k
  }
1235
};
1236
1237
/// This is an abstract virtual class for memory operations.
1238
class MemSDNode : public SDNode {
1239
private:
1240
  // VT of in-memory value.
1241
  EVT MemoryVT;
1242
1243
protected:
1244
  /// Memory reference information.
1245
  MachineMemOperand *MMO;
1246
1247
public:
1248
  MemSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTs,
1249
            EVT memvt, MachineMemOperand *MMO);
1250
1251
3.47k
  bool readMem() const { return MMO->isLoad(); }
1252
16.5k
  bool writeMem() const { return MMO->isStore(); }
1253
1254
  /// Returns alignment and volatility of the memory access
1255
6.65M
  unsigned getOriginalAlignment() const {
1256
6.65M
    return MMO->getBaseAlignment();
1257
6.65M
  }
1258
16.6M
  unsigned getAlignment() const {
1259
16.6M
    return MMO->getAlignment();
1260
16.6M
  }
1261
1262
  /// Return the SubclassData value, without HasDebugValue. This contains an
1263
  /// encoding of the volatile flag, as well as bits used by subclasses. This
1264
  /// function should only be used to compute a FoldingSetNodeID value.
1265
  /// The HasDebugValue bit is masked out because CSE map needs to match
1266
  /// nodes with debug info with nodes without debug info. Same is about
1267
  /// isDivergent bit.
1268
10.3M
  unsigned getRawSubclassData() const {
1269
10.3M
    uint16_t Data;
1270
10.3M
    union {
1271
10.3M
      char RawSDNodeBits[sizeof(uint16_t)];
1272
10.3M
      SDNodeBitfields SDNodeBits;
1273
10.3M
    };
1274
10.3M
    memcpy(&RawSDNodeBits, &this->RawSDNodeBits, sizeof(this->RawSDNodeBits));
1275
10.3M
    SDNodeBits.HasDebugValue = 0;
1276
10.3M
    SDNodeBits.IsDivergent = false;
1277
10.3M
    memcpy(&Data, &RawSDNodeBits, sizeof(RawSDNodeBits));
1278
10.3M
    return Data;
1279
10.3M
  }
1280
1281
63.6M
  bool isVolatile() const { return MemSDNodeBits.IsVolatile; }
1282
760k
  bool isNonTemporal() const { return MemSDNodeBits.IsNonTemporal; }
1283
31.6k
  bool isDereferenceable() const { return MemSDNodeBits.IsDereferenceable; }
1284
36.0M
  bool isInvariant() const { return MemSDNodeBits.IsInvariant; }
1285
1286
  // Returns the offset from the location of the access.
1287
6.69M
  int64_t getSrcValueOffset() const { return MMO->getOffset(); }
1288
1289
  /// Returns the AA info that describes the dereference.
1290
5.57M
  AAMDNodes getAAInfo() const { return MMO->getAAInfo(); }
1291
1292
  /// Returns the Ranges that describes the dereference.
1293
4.68M
  const MDNode *getRanges() const { return MMO->getRanges(); }
1294
1295
  /// Returns the synchronization scope ID for this memory operation.
1296
0
  SyncScope::ID getSyncScopeID() const { return MMO->getSyncScopeID(); }
1297
1298
  /// Return the atomic ordering requirements for this memory operation. For
1299
  /// cmpxchg atomic operations, return the atomic ordering requirements when
1300
  /// store occurs.
1301
128k
  AtomicOrdering getOrdering() const { return MMO->getOrdering(); }
1302
1303
  /// Return the type of the in-memory value.
1304
80.9M
  EVT getMemoryVT() const { return MemoryVT; }
1305
1306
  /// Return a MachineMemOperand object describing the memory
1307
  /// reference performed by operation.
1308
10.0M
  MachineMemOperand *getMemOperand() const { return MMO; }
1309
1310
15.6M
  const MachinePointerInfo &getPointerInfo() const {
1311
15.6M
    return MMO->getPointerInfo();
1312
15.6M
  }
1313
1314
  /// Return the address space for the associated pointer
1315
8.52M
  unsigned getAddressSpace() const {
1316
8.52M
    return getPointerInfo().getAddrSpace();
1317
8.52M
  }
1318
1319
  /// Update this MemSDNode's MachineMemOperand information
1320
  /// to reflect the alignment of NewMMO, if it has a greater alignment.
1321
  /// This must only be used when the new alignment applies to all users of
1322
  /// this MachineMemOperand.
1323
63.1k
  void refineAlignment(const MachineMemOperand *NewMMO) {
1324
63.1k
    MMO->refineAlignment(NewMMO);
1325
63.1k
  }
1326
1327
64.0M
  const SDValue &getChain() const { return getOperand(0); }
1328
93.1M
  const SDValue &getBasePtr() const {
1329
93.1M
    return getOperand(getOpcode() == ISD::STORE ? 
283.9M
:
19.12M
);
1330
93.1M
  }
1331
1332
  // Methods to support isa and dyn_cast
1333
17.4M
  static bool classof(const SDNode *N) {
1334
17.4M
    // For some targets, we lower some target intrinsics to a MemIntrinsicNode
1335
17.4M
    // with either an intrinsic or a target opcode.
1336
17.4M
    return N->getOpcode() == ISD::LOAD                ||
1337
17.4M
           
N->getOpcode() == ISD::STORE12.8M
||
1338
17.4M
           
N->getOpcode() == ISD::PREFETCH1.66M
||
1339
17.4M
           
N->getOpcode() == ISD::ATOMIC_CMP_SWAP1.66M
||
1340
17.4M
           
N->getOpcode() == ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS1.66M
||
1341
17.4M
           
N->getOpcode() == ISD::ATOMIC_SWAP1.66M
||
1342
17.4M
           
N->getOpcode() == ISD::ATOMIC_LOAD_ADD1.65M
||
1343
17.4M
           
N->getOpcode() == ISD::ATOMIC_LOAD_SUB1.65M
||
1344
17.4M
           
N->getOpcode() == ISD::ATOMIC_LOAD_AND1.65M
||
1345
17.4M
           
N->getOpcode() == ISD::ATOMIC_LOAD_CLR1.65M
||
1346
17.4M
           
N->getOpcode() == ISD::ATOMIC_LOAD_OR1.65M
||
1347
17.4M
           
N->getOpcode() == ISD::ATOMIC_LOAD_XOR1.65M
||
1348
17.4M
           
N->getOpcode() == ISD::ATOMIC_LOAD_NAND1.65M
||
1349
17.4M
           
N->getOpcode() == ISD::ATOMIC_LOAD_MIN1.65M
||
1350
17.4M
           
N->getOpcode() == ISD::ATOMIC_LOAD_MAX1.65M
||
1351
17.4M
           
N->getOpcode() == ISD::ATOMIC_LOAD_UMIN1.65M
||
1352
17.4M
           
N->getOpcode() == ISD::ATOMIC_LOAD_UMAX1.64M
||
1353
17.4M
           
N->getOpcode() == ISD::ATOMIC_LOAD1.64M
||
1354
17.4M
           
N->getOpcode() == ISD::ATOMIC_STORE1.64M
||
1355
17.4M
           
N->getOpcode() == ISD::MLOAD1.64M
||
1356
17.4M
           
N->getOpcode() == ISD::MSTORE1.63M
||
1357
17.4M
           
N->getOpcode() == ISD::MGATHER1.63M
||
1358
17.4M
           
N->getOpcode() == ISD::MSCATTER1.63M
||
1359
17.4M
           
N->isMemIntrinsic()1.63M
||
1360
17.4M
           
N->isTargetMemoryOpcode()1.55M
;
1361
17.4M
  }
1362
};
1363
1364
/// This is an SDNode representing atomic operations.
1365
class AtomicSDNode : public MemSDNode {
1366
public:
1367
  AtomicSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTL,
1368
               EVT MemVT, MachineMemOperand *MMO)
1369
21.3k
      : MemSDNode(Opc, Order, dl, VTL, MemVT, MMO) {}
1370
1371
3.57k
  const SDValue &getBasePtr() const { return getOperand(1); }
1372
338
  const SDValue &getVal() const { return getOperand(2); }
1373
1374
  /// Returns true if this SDNode represents cmpxchg atomic operation, false
1375
  /// otherwise.
1376
  bool isCompareAndSwap() const {
1377
    unsigned Op = getOpcode();
1378
    return Op == ISD::ATOMIC_CMP_SWAP ||
1379
           Op == ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS;
1380
  }
1381
1382
  /// For cmpxchg atomic operations, return the atomic ordering requirements
1383
  /// when store does not occur.
1384
  AtomicOrdering getFailureOrdering() const {
1385
    assert(isCompareAndSwap() && "Must be cmpxchg operation");
1386
    return MMO->getFailureOrdering();
1387
  }
1388
1389
  // Methods to support isa and dyn_cast
1390
517k
  static bool classof(const SDNode *N) {
1391
517k
    return N->getOpcode() == ISD::ATOMIC_CMP_SWAP     ||
1392
517k
           
N->getOpcode() == ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS517k
||
1393
517k
           
N->getOpcode() == ISD::ATOMIC_SWAP517k
||
1394
517k
           
N->getOpcode() == ISD::ATOMIC_LOAD_ADD517k
||
1395
517k
           
N->getOpcode() == ISD::ATOMIC_LOAD_SUB517k
||
1396
517k
           
N->getOpcode() == ISD::ATOMIC_LOAD_AND516k
||
1397
517k
           
N->getOpcode() == ISD::ATOMIC_LOAD_CLR516k
||
1398
517k
           
N->getOpcode() == ISD::ATOMIC_LOAD_OR516k
||
1399
517k
           
N->getOpcode() == ISD::ATOMIC_LOAD_XOR516k
||
1400
517k
           
N->getOpcode() == ISD::ATOMIC_LOAD_NAND516k
||
1401
517k
           
N->getOpcode() == ISD::ATOMIC_LOAD_MIN516k
||
1402
517k
           
N->getOpcode() == ISD::ATOMIC_LOAD_MAX516k
||
1403
517k
           
N->getOpcode() == ISD::ATOMIC_LOAD_UMIN516k
||
1404
517k
           
N->getOpcode() == ISD::ATOMIC_LOAD_UMAX516k
||
1405
517k
           
N->getOpcode() == ISD::ATOMIC_LOAD516k
||
1406
517k
           
N->getOpcode() == ISD::ATOMIC_STORE516k
;
1407
517k
  }
1408
};
1409
1410
/// This SDNode is used for target intrinsics that touch
1411
/// memory and need an associated MachineMemOperand. Its opcode may be
1412
/// INTRINSIC_VOID, INTRINSIC_W_CHAIN, PREFETCH, or a target-specific opcode
1413
/// with a value not less than FIRST_TARGET_MEMORY_OPCODE.
1414
class MemIntrinsicSDNode : public MemSDNode {
1415
public:
1416
  MemIntrinsicSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl,
1417
                     SDVTList VTs, EVT MemoryVT, MachineMemOperand *MMO)
1418
157k
      : MemSDNode(Opc, Order, dl, VTs, MemoryVT, MMO) {
1419
157k
    SDNodeBits.IsMemIntrinsic = true;
1420
157k
  }
1421
1422
  // Methods to support isa and dyn_cast
1423
186
  static bool classof(const SDNode *N) {
1424
186
    // We lower some target intrinsics to their target opcode
1425
186
    // early a node with a target opcode can be of this class
1426
186
    return N->isMemIntrinsic()             ||
1427
186
           
N->getOpcode() == ISD::PREFETCH0
||
1428
186
           
N->isTargetMemoryOpcode()0
;
1429
186
  }
1430
};
1431
1432
/// This SDNode is used to implement the code generator
1433
/// support for the llvm IR shufflevector instruction.  It combines elements
1434
/// from two input vectors into a new input vector, with the selection and
1435
/// ordering of elements determined by an array of integers, referred to as
1436
/// the shuffle mask.  For input vectors of width N, mask indices of 0..N-1
1437
/// refer to elements from the LHS input, and indices from N to 2N-1 the RHS.
1438
/// An index of -1 is treated as undef, such that the code generator may put
1439
/// any value in the corresponding element of the result.
1440
class ShuffleVectorSDNode : public SDNode {
1441
  // The memory for Mask is owned by the SelectionDAG's OperandAllocator, and
1442
  // is freed when the SelectionDAG object is destroyed.
1443
  const int *Mask;
1444
1445
protected:
1446
  friend class SelectionDAG;
1447
1448
  ShuffleVectorSDNode(EVT VT, unsigned Order, const DebugLoc &dl, const int *M)
1449
112k
      : SDNode(ISD::VECTOR_SHUFFLE, Order, dl, getSDVTList(VT)), Mask(M) {}
1450
1451
public:
1452
384k
  ArrayRef<int> getMask() const {
1453
384k
    EVT VT = getValueType(0);
1454
384k
    return makeArrayRef(Mask, VT.getVectorNumElements());
1455
384k
  }
1456
1457
2.80M
  int getMaskElt(unsigned Idx) const {
1458
2.80M
    assert(Idx < getValueType(0).getVectorNumElements() && "Idx out of range!");
1459
2.80M
    return Mask[Idx];
1460
2.80M
  }
1461
1462
98.0k
  bool isSplat() const { return isSplatMask(Mask, getValueType(0)); }
1463
1464
39.7k
  int  getSplatIndex() const {
1465
39.7k
    assert(isSplat() && "Cannot get splat index for non-splat!");
1466
39.7k
    EVT VT = getValueType(0);
1467
40.6k
    for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; 
++i843
) {
1468
40.6k
      if (Mask[i] >= 0)
1469
39.7k
        return Mask[i];
1470
40.6k
    }
1471
39.7k
    
llvm_unreachable0
("Splat with all undef indices?");
1472
39.7k
  }
1473
1474
  static bool isSplatMask(const int *Mask, EVT VT);
1475
1476
  /// Change values in a shuffle permute mask assuming
1477
  /// the two vector operands have swapped position.
1478
185k
  static void commuteMask(MutableArrayRef<int> Mask) {
1479
185k
    unsigned NumElems = Mask.size();
1480
2.44M
    for (unsigned i = 0; i != NumElems; 
++i2.25M
) {
1481
2.25M
      int idx = Mask[i];
1482
2.25M
      if (idx < 0)
1483
341k
        continue;
1484
1.91M
      else if (idx < (int)NumElems)
1485
1.22M
        Mask[i] = idx + NumElems;
1486
687k
      else
1487
687k
        Mask[i] = idx - NumElems;
1488
2.25M
    }
1489
185k
  }
1490
1491
936k
  static bool classof(const SDNode *N) {
1492
936k
    return N->getOpcode() == ISD::VECTOR_SHUFFLE;
1493
936k
  }
1494
};
1495
1496
class ConstantSDNode : public SDNode {
1497
  friend class SelectionDAG;
1498
1499
  const ConstantInt *Value;
1500
1501
  ConstantSDNode(bool isTarget, bool isOpaque, const ConstantInt *val, EVT VT)
1502
      : SDNode(isTarget ? ISD::TargetConstant : ISD::Constant, 0, DebugLoc(),
1503
               getSDVTList(VT)),
1504
12.7M
        Value(val) {
1505
12.7M
    ConstantSDNodeBits.IsOpaque = isOpaque;
1506
12.7M
  }
1507
1508
public:
1509
20.5M
  const ConstantInt *getConstantIntValue() const { return Value; }
1510
50.2M
  const APInt &getAPIntValue() const { return Value->getValue(); }
1511
16.8M
  uint64_t getZExtValue() const { return Value->getZExtValue(); }
1512
102M
  int64_t getSExtValue() const { return Value->getSExtValue(); }
1513
341
  uint64_t getLimitedValue(uint64_t Limit = UINT64_MAX) {
1514
341
    return Value->getLimitedValue(Limit);
1515
341
  }
1516
1517
6.80M
  bool isOne() const { return Value->isOne(); }
1518
17.9M
  bool isNullValue() const { return Value->isZero(); }
1519
6.34M
  bool isAllOnesValue() const { return Value->isMinusOne(); }
1520
1521
26.9M
  bool isOpaque() const { return ConstantSDNodeBits.IsOpaque; }
1522
1523
463M
  static bool classof(const SDNode *N) {
1524
463M
    return N->getOpcode() == ISD::Constant ||
1525
463M
           
N->getOpcode() == ISD::TargetConstant275M
;
1526
463M
  }
1527
};
1528
1529
1.85M
uint64_t SDNode::getConstantOperandVal(unsigned Num) const {
1530
1.85M
  return cast<ConstantSDNode>(getOperand(Num))->getZExtValue();
1531
1.85M
}
1532
1533
class ConstantFPSDNode : public SDNode {
1534
  friend class SelectionDAG;
1535
1536
  const ConstantFP *Value;
1537
1538
  ConstantFPSDNode(bool isTarget, const ConstantFP *val, EVT VT)
1539
      : SDNode(isTarget ? ISD::TargetConstantFP : ISD::ConstantFP, 0,
1540
               DebugLoc(), getSDVTList(VT)),
1541
112k
        Value(val) {}
1542
1543
public:
1544
348k
  const APFloat& getValueAPF() const { return Value->getValueAPF(); }
1545
178k
  const ConstantFP *getConstantFPValue() const { return Value; }
1546
1547
  /// Return true if the value is positive or negative zero.
1548
139k
  bool isZero() const { return Value->isZero(); }
1549
1550
  /// Return true if the value is a NaN.
1551
7.24k
  bool isNaN() const { return Value->isNaN(); }
1552
1553
  /// Return true if the value is an infinity
1554
2
  bool isInfinity() const { return Value->isInfinity(); }
1555
1556
  /// Return true if the value is negative.
1557
37.2k
  bool isNegative() const { return Value->isNegative(); }
1558
1559
  /// We don't rely on operator== working on double values, as
1560
  /// it returns true for things that are clearly not equal, like -0.0 and 0.0.
1561
  /// As such, this method can be used to do an exact bit-for-bit comparison of
1562
  /// two floating point values.
1563
1564
  /// We leave the version with the double argument here because it's just so
1565
  /// convenient to write "2.0" and the like.  Without this function we'd
1566
  /// have to duplicate its logic everywhere it's called.
1567
77.0k
  bool isExactlyValue(double V) const {
1568
77.0k
    return Value->getValueAPF().isExactlyValue(V);
1569
77.0k
  }
1570
  bool isExactlyValue(const APFloat& V) const;
1571
1572
  static bool isValueValidForType(EVT VT, const APFloat& Val);
1573
1574
212M
  static bool classof(const SDNode *N) {
1575
212M
    return N->getOpcode() == ISD::ConstantFP ||
1576
212M
           
N->getOpcode() == ISD::TargetConstantFP211M
;
1577
212M
  }
1578
};
1579
1580
/// Returns true if \p V is a constant integer zero.
1581
bool isNullConstant(SDValue V);
1582
1583
/// Returns true if \p V is an FP constant with a value of positive zero.
1584
bool isNullFPConstant(SDValue V);
1585
1586
/// Returns true if \p V is an integer constant with all bits set.
1587
bool isAllOnesConstant(SDValue V);
1588
1589
/// Returns true if \p V is a constant integer one.
1590
bool isOneConstant(SDValue V);
1591
1592
/// Returns true if \p V is a bitwise not operation. Assumes that an all ones
1593
/// constant is canonicalized to be operand 1.
1594
bool isBitwiseNot(SDValue V);
1595
1596
/// Returns the SDNode if it is a constant splat BuildVector or constant int.
1597
ConstantSDNode *isConstOrConstSplat(SDValue N);
1598
1599
/// Returns the SDNode if it is a constant splat BuildVector or constant float.
1600
ConstantFPSDNode *isConstOrConstSplatFP(SDValue N);
1601
1602
class GlobalAddressSDNode : public SDNode {
1603
  friend class SelectionDAG;
1604
1605
  const GlobalValue *TheGlobal;
1606
  int64_t Offset;
1607
  unsigned char TargetFlags;
1608
1609
  GlobalAddressSDNode(unsigned Opc, unsigned Order, const DebugLoc &DL,
1610
                      const GlobalValue *GA, EVT VT, int64_t o,
1611
                      unsigned char TF);
1612
1613
public:
1614
7.61M
  const GlobalValue *getGlobal() const { return TheGlobal; }
1615
4.65M
  int64_t getOffset() const { return Offset; }
1616
3.03M
  unsigned char getTargetFlags() const { return TargetFlags; }
1617
  // Return the address space this GlobalAddress belongs to.
1618
  unsigned getAddressSpace() const;
1619
1620
144M
  static bool classof(const SDNode *N) {
1621
144M
    return N->getOpcode() == ISD::GlobalAddress ||
1622
144M
           
N->getOpcode() == ISD::TargetGlobalAddress140M
||
1623
144M
           
N->getOpcode() == ISD::GlobalTLSAddress135M
||
1624
144M
           
N->getOpcode() == ISD::TargetGlobalTLSAddress135M
;
1625
144M
  }
1626
};
1627
1628
class FrameIndexSDNode : public SDNode {
1629
  friend class SelectionDAG;
1630
1631
  int FI;
1632
1633
  FrameIndexSDNode(int fi, EVT VT, bool isTarg)
1634
    : SDNode(isTarg ? ISD::TargetFrameIndex : ISD::FrameIndex,
1635
823k
      0, DebugLoc(), getSDVTList(VT)), FI(fi) {
1636
823k
  }
1637
1638
public:
1639
7.83M
  int getIndex() const { return FI; }
1640
1641
97.4M
  static bool classof(const SDNode *N) {
1642
97.4M
    return N->getOpcode() == ISD::FrameIndex ||
1643
97.4M
           
N->getOpcode() == ISD::TargetFrameIndex88.9M
;
1644
97.4M
  }
1645
};
1646
1647
class JumpTableSDNode : public SDNode {
1648
  friend class SelectionDAG;
1649
1650
  int JTI;
1651
  unsigned char TargetFlags;
1652
1653
  JumpTableSDNode(int jti, EVT VT, bool isTarg, unsigned char TF)
1654
    : SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable,
1655
7.27k
      0, DebugLoc(), getSDVTList(VT)), JTI(jti), TargetFlags(TF) {
1656
7.27k
  }
1657
1658
public:
1659
11.5k
  int getIndex() const { return JTI; }
1660
6.96k
  unsigned char getTargetFlags() const { return TargetFlags; }
1661
1662
58.2M
  static bool classof(const SDNode *N) {
1663
58.2M
    return N->getOpcode() == ISD::JumpTable ||
1664
58.2M
           N->getOpcode() == ISD::TargetJumpTable;
1665
58.2M
  }
1666
};
1667
1668
class ConstantPoolSDNode : public SDNode {
1669
  friend class SelectionDAG;
1670
1671
  union {
1672
    const Constant *ConstVal;
1673
    MachineConstantPoolValue *MachineCPVal;
1674
  } Val;
1675
  int Offset;  // It's a MachineConstantPoolValue if top bit is set.
1676
  unsigned Alignment;  // Minimum alignment requirement of CP (not log2 value).
1677
  unsigned char TargetFlags;
1678
1679
  ConstantPoolSDNode(bool isTarget, const Constant *c, EVT VT, int o,
1680
                     unsigned Align, unsigned char TF)
1681
    : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0,
1682
             DebugLoc(), getSDVTList(VT)), Offset(o), Alignment(Align),
1683
238k
             TargetFlags(TF) {
1684
238k
    assert(Offset >= 0 && "Offset is too large");
1685
238k
    Val.ConstVal = c;
1686
238k
  }
1687
1688
  ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v,
1689
                     EVT VT, int o, unsigned Align, unsigned char TF)
1690
    : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0,
1691
             DebugLoc(), getSDVTList(VT)), Offset(o), Alignment(Align),
1692
273
             TargetFlags(TF) {
1693
273
    assert(Offset >= 0 && "Offset is too large");
1694
273
    Val.MachineCPVal = v;
1695
273
    Offset |= 1 << (sizeof(unsigned)*CHAR_BIT-1);
1696
273
  }
1697
1698
public:
1699
479k
  bool isMachineConstantPoolEntry() const {
1700
479k
    return Offset < 0;
1701
479k
  }
1702
1703
498k
  const Constant *getConstVal() const {
1704
498k
    assert(!isMachineConstantPoolEntry() && "Wrong constantpool type");
1705
498k
    return Val.ConstVal;
1706
498k
  }
1707
1708
359
  MachineConstantPoolValue *getMachineCPVal() const {
1709
359
    assert(isMachineConstantPoolEntry() && "Wrong constantpool type");
1710
359
    return Val.MachineCPVal;
1711
359
  }
1712
1713
390k
  int getOffset() const {
1714
390k
    return Offset & ~(1 << (sizeof(unsigned)*CHAR_BIT-1));
1715
390k
  }
1716
1717
  // Return the alignment of this constant pool object, which is either 0 (for
1718
  // default alignment) or the desired value.
1719
475k
  unsigned getAlignment() const { return Alignment; }
1720
255k
  unsigned char getTargetFlags() const { return TargetFlags; }
1721
1722
  Type *getType() const;
1723
1724
69.8M
  static bool classof(const SDNode *N) {
1725
69.8M
    return N->getOpcode() == ISD::ConstantPool ||
1726
69.8M
           
N->getOpcode() == ISD::TargetConstantPool69.8M
;
1727
69.8M
  }
1728
};
1729
1730
/// Completely target-dependent object reference.
1731
class TargetIndexSDNode : public SDNode {
1732
  friend class SelectionDAG;
1733
1734
  unsigned char TargetFlags;
1735
  int Index;
1736
  int64_t Offset;
1737
1738
public:
1739
  TargetIndexSDNode(int Idx, EVT VT, int64_t Ofs, unsigned char TF)
1740
    : SDNode(ISD::TargetIndex, 0, DebugLoc(), getSDVTList(VT)),
1741
0
      TargetFlags(TF), Index(Idx), Offset(Ofs) {}
1742
1743
0
  unsigned char getTargetFlags() const { return TargetFlags; }
1744
0
  int getIndex() const { return Index; }
1745
0
  int64_t getOffset() const { return Offset; }
1746
1747
58.0M
  static bool classof(const SDNode *N) {
1748
58.0M
    return N->getOpcode() == ISD::TargetIndex;
1749
58.0M
  }
1750
};
1751
1752
class BasicBlockSDNode : public SDNode {
1753
  friend class SelectionDAG;
1754
1755
  MachineBasicBlock *MBB;
1756
1757
  /// Debug info is meaningful and potentially useful here, but we create
1758
  /// blocks out of order when they're jumped to, which makes it a bit
1759
  /// harder.  Let's see if we need it first.
1760
  explicit BasicBlockSDNode(MachineBasicBlock *mbb)
1761
    : SDNode(ISD::BasicBlock, 0, DebugLoc(), getSDVTList(MVT::Other)), MBB(mbb)
1762
1.88M
  {}
1763
1764
public:
1765
2.65M
  MachineBasicBlock *getBasicBlock() const { return MBB; }
1766
1767
65.9M
  static bool classof(const SDNode *N) {
1768
65.9M
    return N->getOpcode() == ISD::BasicBlock;
1769
65.9M
  }
1770
};
1771
1772
/// A "pseudo-class" with methods for operating on BUILD_VECTORs.
1773
class BuildVectorSDNode : public SDNode {
1774
public:
1775
  // These are constructed as SDNodes and then cast to BuildVectorSDNodes.
1776
  explicit BuildVectorSDNode() = delete;
1777
1778
  /// Check if this is a constant splat, and if so, find the
1779
  /// smallest element size that splats the vector.  If MinSplatBits is
1780
  /// nonzero, the element size must be at least that large.  Note that the
1781
  /// splat element may be the entire vector (i.e., a one element vector).
1782
  /// Returns the splat element value in SplatValue.  Any undefined bits in
1783
  /// that value are zero, and the corresponding bits in the SplatUndef mask
1784
  /// are set.  The SplatBitSize value is set to the splat element size in
1785
  /// bits.  HasAnyUndefs is set to true if any bits in the vector are
1786
  /// undefined.  isBigEndian describes the endianness of the target.
1787
  bool isConstantSplat(APInt &SplatValue, APInt &SplatUndef,
1788
                       unsigned &SplatBitSize, bool &HasAnyUndefs,
1789
                       unsigned MinSplatBits = 0,
1790
                       bool isBigEndian = false) const;
1791
1792
  /// Returns the splatted value or a null value if this is not a splat.
1793
  ///
1794
  /// If passed a non-null UndefElements bitvector, it will resize it to match
1795
  /// the vector width and set the bits where elements are undef.
1796
  SDValue getSplatValue(BitVector *UndefElements = nullptr) const;
1797
1798
  /// Returns the splatted constant or null if this is not a constant
1799
  /// splat.
1800
  ///
1801
  /// If passed a non-null UndefElements bitvector, it will resize it to match
1802
  /// the vector width and set the bits where elements are undef.
1803
  ConstantSDNode *
1804
  getConstantSplatNode(BitVector *UndefElements = nullptr) const;
1805
1806
  /// Returns the splatted constant FP or null if this is not a constant
1807
  /// FP splat.
1808
  ///
1809
  /// If passed a non-null UndefElements bitvector, it will resize it to match
1810
  /// the vector width and set the bits where elements are undef.
1811
  ConstantFPSDNode *
1812
  getConstantFPSplatNode(BitVector *UndefElements = nullptr) const;
1813
1814
  /// If this is a constant FP splat and the splatted constant FP is an
1815
  /// exact power or 2, return the log base 2 integer value.  Otherwise,
1816
  /// return -1.
1817
  ///
1818
  /// The BitWidth specifies the necessary bit precision.
1819
  int32_t getConstantFPSplatPow2ToLog2Int(BitVector *UndefElements,
1820
                                          uint32_t BitWidth) const;
1821
1822
  bool isConstant() const;
1823
1824
38.9M
  static bool classof(const SDNode *N) {
1825
38.9M
    return N->getOpcode() == ISD::BUILD_VECTOR;
1826
38.9M
  }
1827
};
1828
1829
/// An SDNode that holds an arbitrary LLVM IR Value. This is
1830
/// used when the SelectionDAG needs to make a simple reference to something
1831
/// in the LLVM IR representation.
1832
///
1833
class SrcValueSDNode : public SDNode {
1834
  friend class SelectionDAG;
1835
1836
  const Value *V;
1837
1838
  /// Create a SrcValue for a general value.
1839
  explicit SrcValueSDNode(const Value *v)
1840
1.57k
    : SDNode(ISD::SRCVALUE, 0, DebugLoc(), getSDVTList(MVT::Other)), V(v) {}
1841
1842
public:
1843
  /// Return the contained Value.
1844
2.72k
  const Value *getValue() const { return V; }
1845
1846
15
  static bool classof(const SDNode *N) {
1847
15
    return N->getOpcode() == ISD::SRCVALUE;
1848
15
  }
1849
};
1850
1851
class MDNodeSDNode : public SDNode {
1852
  friend class SelectionDAG;
1853
1854
  const MDNode *MD;
1855
1856
  explicit MDNodeSDNode(const MDNode *md)
1857
  : SDNode(ISD::MDNODE_SDNODE, 0, DebugLoc(), getSDVTList(MVT::Other)), MD(md)
1858
23.1k
  {}
1859
1860
public:
1861
23.0k
  const MDNode *getMD() const { return MD; }
1862
1863
46.5M
  static bool classof(const SDNode *N) {
1864
46.5M
    return N->getOpcode() == ISD::MDNODE_SDNODE;
1865
46.5M
  }
1866
};
1867
1868
class RegisterSDNode : public SDNode {
1869
  friend class SelectionDAG;
1870
1871
  unsigned Reg;
1872
1873
  RegisterSDNode(unsigned reg, EVT VT)
1874
7.68M
    : SDNode(ISD::Register, 0, DebugLoc(), getSDVTList(VT)), Reg(reg) {}
1875
1876
public:
1877
35.8M
  unsigned getReg() const { return Reg; }
1878
1879
106M
  static bool classof(const SDNode *N) {
1880
106M
    return N->getOpcode() == ISD::Register;
1881
106M
  }
1882
};
1883
1884
class RegisterMaskSDNode : public SDNode {
1885
  friend class SelectionDAG;
1886
1887
  // The memory for RegMask is not owned by the node.
1888
  const uint32_t *RegMask;
1889
1890
  RegisterMaskSDNode(const uint32_t *mask)
1891
    : SDNode(ISD::RegisterMask, 0, DebugLoc(), getSDVTList(MVT::Untyped)),
1892
536k
      RegMask(mask) {}
1893
1894
public:
1895
1.25M
  const uint32_t *getRegMask() const { return RegMask; }
1896
1897
81.8M
  static bool classof(const SDNode *N) {
1898
81.8M
    return N->getOpcode() == ISD::RegisterMask;
1899
81.8M
  }
1900
};
1901
1902
class BlockAddressSDNode : public SDNode {
1903
  friend class SelectionDAG;
1904
1905
  const BlockAddress *BA;
1906
  int64_t Offset;
1907
  unsigned char TargetFlags;
1908
1909
  BlockAddressSDNode(unsigned NodeTy, EVT VT, const BlockAddress *ba,
1910
                     int64_t o, unsigned char Flags)
1911
    : SDNode(NodeTy, 0, DebugLoc(), getSDVTList(VT)),
1912
274
             BA(ba), Offset(o), TargetFlags(Flags) {}
1913
1914
public:
1915
384
  const BlockAddress *getBlockAddress() const { return BA; }
1916
249
  int64_t getOffset() const { return Offset; }
1917
217
  unsigned char getTargetFlags() const { return TargetFlags; }
1918
1919
58.0M
  static bool classof(const SDNode *N) {
1920
58.0M
    return N->getOpcode() == ISD::BlockAddress ||
1921
58.0M
           
N->getOpcode() == ISD::TargetBlockAddress58.0M
;
1922
58.0M
  }
1923
};
1924
1925
class LabelSDNode : public SDNode {
1926
  friend class SelectionDAG;
1927
1928
  MCSymbol *Label;
1929
1930
  LabelSDNode(unsigned Order, const DebugLoc &dl, MCSymbol *L)
1931
39.3k
      : SDNode(ISD::EH_LABEL, Order, dl, getSDVTList(MVT::Other)), Label(L) {}
1932
1933
public:
1934
39.2k
  MCSymbol *getLabel() const { return Label; }
1935
1936
  static bool classof(const SDNode *N) {
1937
    return N->getOpcode() == ISD::EH_LABEL ||
1938
           N->getOpcode() == ISD::ANNOTATION_LABEL;
1939
  }
1940
};
1941
1942
class ExternalSymbolSDNode : public SDNode {
1943
  friend class SelectionDAG;
1944
1945
  const char *Symbol;
1946
  unsigned char TargetFlags;
1947
1948
  ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned char TF, EVT VT)
1949
    : SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol,
1950
48.7k
             0, DebugLoc(), getSDVTList(VT)), Symbol(Sym), TargetFlags(TF) {}
1951
1952
public:
1953
86.6k
  const char *getSymbol() const { return Symbol; }
1954
22.7k
  unsigned char getTargetFlags() const { return TargetFlags; }
1955
1956
58.1M
  static bool classof(const SDNode *N) {
1957
58.1M
    return N->getOpcode() == ISD::ExternalSymbol ||
1958
58.1M
           
N->getOpcode() == ISD::TargetExternalSymbol58.1M
;
1959
58.1M
  }
1960
};
1961
1962
class MCSymbolSDNode : public SDNode {
1963
  friend class SelectionDAG;
1964
1965
  MCSymbol *Symbol;
1966
1967
  MCSymbolSDNode(MCSymbol *Symbol, EVT VT)
1968
53
      : SDNode(ISD::MCSymbol, 0, DebugLoc(), getSDVTList(VT)), Symbol(Symbol) {}
1969
1970
public:
1971
74
  MCSymbol *getMCSymbol() const { return Symbol; }
1972
1973
58.0M
  static bool classof(const SDNode *N) {
1974
58.0M
    return N->getOpcode() == ISD::MCSymbol;
1975
58.0M
  }
1976
};
1977
1978
class CondCodeSDNode : public SDNode {
1979
  friend class SelectionDAG;
1980
1981
  ISD::CondCode Condition;
1982
1983
  explicit CondCodeSDNode(ISD::CondCode Cond)
1984
    : SDNode(ISD::CONDCODE, 0, DebugLoc(), getSDVTList(MVT::Other)),
1985
1.40M
      Condition(Cond) {}
1986
1987
public:
1988
9.94M
  ISD::CondCode get() const { return Condition; }
1989
1990
  static bool classof(const SDNode *N) {
1991
    return N->getOpcode() == ISD::CONDCODE;
1992
  }
1993
};
1994
1995
/// This class is used to represent EVT's, which are used
1996
/// to parameterize some operations.
1997
class VTSDNode : public SDNode {
1998
  friend class SelectionDAG;
1999
2000
  EVT ValueType;
2001
2002
  explicit VTSDNode(EVT VT)
2003
    : SDNode(ISD::VALUETYPE, 0, DebugLoc(), getSDVTList(MVT::Other)),
2004
316k
      ValueType(VT) {}
2005
2006
public:
2007
3.34M
  EVT getVT() const { return ValueType; }
2008
2009
21
  static bool classof(const SDNode *N) {
2010
21
    return N->getOpcode() == ISD::VALUETYPE;
2011
21
  }
2012
};
2013
2014
/// Base class for LoadSDNode and StoreSDNode
2015
class LSBaseSDNode : public MemSDNode {
2016
public:
2017
  LSBaseSDNode(ISD::NodeType NodeTy, unsigned Order, const DebugLoc &dl,
2018
               SDVTList VTs, ISD::MemIndexedMode AM, EVT MemVT,
2019
               MachineMemOperand *MMO)
2020
8.29M
      : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {
2021
8.29M
    LSBaseSDNodeBits.AddressingMode = AM;
2022
8.29M
    assert(getAddressingMode() == AM && "Value truncated");
2023
8.29M
  }
2024
2025
17.5k
  const SDValue &getOffset() const {
2026
17.5k
    return getOperand(getOpcode() == ISD::LOAD ? 
28.69k
:
38.86k
);
2027
17.5k
  }
2028
2029
  /// Return the addressing mode for this load or store:
2030
  /// unindexed, pre-inc, pre-dec, post-inc, or post-dec.
2031
179M
  ISD::MemIndexedMode getAddressingMode() const {
2032
179M
    return static_cast<ISD::MemIndexedMode>(LSBaseSDNodeBits.AddressingMode);
2033
179M
  }
2034
2035
  /// Return true if this is a pre/post inc/dec load/store.
2036
31.1M
  bool isIndexed() const { return getAddressingMode() != ISD::UNINDEXED; }
2037
2038
  /// Return true if this is NOT a pre/post inc/dec load/store.
2039
20.2M
  bool isUnindexed() const { return getAddressingMode() == ISD::UNINDEXED; }
2040
2041
11.3k
  static bool classof(const SDNode *N) {
2042
11.3k
    return N->getOpcode() == ISD::LOAD ||
2043
11.3k
           
N->getOpcode() == ISD::STORE5.65k
;
2044
11.3k
  }
2045
};
2046
2047
/// This class is used to represent ISD::LOAD nodes.
2048
class LoadSDNode : public LSBaseSDNode {
2049
  friend class SelectionDAG;
2050
2051
  LoadSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2052
             ISD::MemIndexedMode AM, ISD::LoadExtType ETy, EVT MemVT,
2053
             MachineMemOperand *MMO)
2054
3.80M
      : LSBaseSDNode(ISD::LOAD, Order, dl, VTs, AM, MemVT, MMO) {
2055
3.80M
    LoadSDNodeBits.ExtTy = ETy;
2056
3.80M
    assert(readMem() && "Load MachineMemOperand is not a load!");
2057
3.80M
    assert(!writeMem() && "Load MachineMemOperand is a store!");
2058
3.80M
  }
2059
2060
public:
2061
  /// Return whether this is a plain node,
2062
  /// or one of the varieties of value-extending loads.
2063
29.4M
  ISD::LoadExtType getExtensionType() const {
2064
29.4M
    return static_cast<ISD::LoadExtType>(LoadSDNodeBits.ExtTy);
2065
29.4M
  }
2066
2067
9.27M
  const SDValue &getBasePtr() const { return getOperand(1); }
2068
117k
  const SDValue &getOffset() const { return getOperand(2); }
2069
2070
80.4M
  static bool classof(const SDNode *N) {
2071
80.4M
    return N->getOpcode() == ISD::LOAD;
2072
80.4M
  }
2073
};
2074
2075
/// This class is used to represent ISD::STORE nodes.
2076
class StoreSDNode : public LSBaseSDNode {
2077
  friend class SelectionDAG;
2078
2079
  StoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2080
              ISD::MemIndexedMode AM, bool isTrunc, EVT MemVT,
2081
              MachineMemOperand *MMO)
2082
4.48M
      : LSBaseSDNode(ISD::STORE, Order, dl, VTs, AM, MemVT, MMO) {
2083
4.48M
    StoreSDNodeBits.IsTruncating = isTrunc;
2084
4.48M
    assert(!readMem() && "Store MachineMemOperand is a load!");
2085
4.48M
    assert(writeMem() && "Store MachineMemOperand is not a store!");
2086
4.48M
  }
2087
2088
public:
2089
  /// Return true if the op does a truncation before store.
2090
  /// For integers this is the same as doing a TRUNCATE and storing the result.
2091
  /// For floats, it is the same as doing an FP_ROUND and storing the result.
2092
25.7M
  bool isTruncatingStore() const { return StoreSDNodeBits.IsTruncating; }
2093
213
  void setTruncatingStore(bool Truncating) {
2094
213
    StoreSDNodeBits.IsTruncating = Truncating;
2095
213
  }
2096
2097
58.6M
  const SDValue &getValue() const { return getOperand(1); }
2098
19.6M
  const SDValue &getBasePtr() const { return getOperand(2); }
2099
1.84k
  const SDValue &getOffset() const { return getOperand(3); }
2100
2101
38.7M
  static bool classof(const SDNode *N) {
2102
38.7M
    return N->getOpcode() == ISD::STORE;
2103
38.7M
  }
2104
};
2105
2106
/// This base class is used to represent MLOAD and MSTORE nodes
2107
class MaskedLoadStoreSDNode : public MemSDNode {
2108
public:
2109
  friend class SelectionDAG;
2110
2111
  MaskedLoadStoreSDNode(ISD::NodeType NodeTy, unsigned Order,
2112
                        const DebugLoc &dl, SDVTList VTs, EVT MemVT,
2113
                        MachineMemOperand *MMO)
2114
2.02k
      : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {}
2115
2116
  // In the both nodes address is Op1, mask is Op2:
2117
  // MaskedLoadSDNode (Chain, ptr, mask, src0), src0 is a passthru value
2118
  // MaskedStoreSDNode (Chain, ptr, mask, data)
2119
  // Mask is a vector of i1 elements
2120
194
  const SDValue &getBasePtr() const { return getOperand(1); }
2121
3.12k
  const SDValue &getMask() const    { return getOperand(2); }
2122
2123
  static bool classof(const SDNode *N) {
2124
    return N->getOpcode() == ISD::MLOAD ||
2125
           N->getOpcode() == ISD::MSTORE;
2126
  }
2127
};
2128
2129
/// This class is used to represent an MLOAD node
2130
class MaskedLoadSDNode : public MaskedLoadStoreSDNode {
2131
public:
2132
  friend class SelectionDAG;
2133
2134
  MaskedLoadSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2135
                   ISD::LoadExtType ETy, bool IsExpanding, EVT MemVT,
2136
                   MachineMemOperand *MMO)
2137
1.22k
      : MaskedLoadStoreSDNode(ISD::MLOAD, Order, dl, VTs, MemVT, MMO) {
2138
1.22k
    LoadSDNodeBits.ExtTy = ETy;
2139
1.22k
    LoadSDNodeBits.IsExpanding = IsExpanding;
2140
1.22k
  }
2141
2142
2.27k
  ISD::LoadExtType getExtensionType() const {
2143
2.27k
    return static_cast<ISD::LoadExtType>(LoadSDNodeBits.ExtTy);
2144
2.27k
  }
2145
2146
171
  const SDValue &getSrc0() const { return getOperand(3); }
2147
569
  static bool classof(const SDNode *N) {
2148
569
    return N->getOpcode() == ISD::MLOAD;
2149
569
  }
2150
2151
2.91k
  bool isExpandingLoad() const { return LoadSDNodeBits.IsExpanding; }
2152
};
2153
2154
/// This class is used to represent an MSTORE node
2155
class MaskedStoreSDNode : public MaskedLoadStoreSDNode {
2156
public:
2157
  friend class SelectionDAG;
2158
2159
  MaskedStoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2160
                    bool isTrunc, bool isCompressing, EVT MemVT,
2161
                    MachineMemOperand *MMO)
2162
796
      : MaskedLoadStoreSDNode(ISD::MSTORE, Order, dl, VTs, MemVT, MMO) {
2163
796
    StoreSDNodeBits.IsTruncating = isTrunc;
2164
796
    StoreSDNodeBits.IsCompressing = isCompressing;
2165
796
  }
2166
2167
  /// Return true if the op does a truncation before store.
2168
  /// For integers this is the same as doing a TRUNCATE and storing the result.
2169
  /// For floats, it is the same as doing an FP_ROUND and storing the result.
2170
1.16k
  bool isTruncatingStore() const { return StoreSDNodeBits.IsTruncating; }
2171
2172
  /// Returns true if the op does a compression to the vector before storing.
2173
  /// The node contiguously stores the active elements (integers or floats)
2174
  /// in src (those with their respective bit set in writemask k) to unaligned
2175
  /// memory at base_addr.
2176
1.50k
  bool isCompressingStore() const { return StoreSDNodeBits.IsCompressing; }
2177
2178
844
  const SDValue &getValue() const { return getOperand(3); }
2179
2180
341
  static bool classof(const SDNode *N) {
2181
341
    return N->getOpcode() == ISD::MSTORE;
2182
341
  }
2183
};
2184
2185
/// This is a base class used to represent
2186
/// MGATHER and MSCATTER nodes
2187
///
2188
class MaskedGatherScatterSDNode : public MemSDNode {
2189
public:
2190
  friend class SelectionDAG;
2191
2192
  MaskedGatherScatterSDNode(ISD::NodeType NodeTy, unsigned Order,
2193
                            const DebugLoc &dl, SDVTList VTs, EVT MemVT,
2194
                            MachineMemOperand *MMO)
2195
1.15k
      : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {}
2196
2197
  // In the both nodes address is Op1, mask is Op2:
2198
  // MaskedGatherSDNode  (Chain, passthru, mask, base, index, scale)
2199
  // MaskedScatterSDNode (Chain, value, mask, base, index, scale)
2200
  // Mask is a vector of i1 elements
2201
574
  const SDValue &getBasePtr() const { return getOperand(3); }
2202
601
  const SDValue &getIndex()   const { return getOperand(4); }
2203
1.15k
  const SDValue &getMask()    const { return getOperand(2); }
2204
798
  const SDValue &getValue()   const { return getOperand(1); }
2205
574
  const SDValue &getScale()   const { return getOperand(5); }
2206
2207
  static bool classof(const SDNode *N) {
2208
    return N->getOpcode() == ISD::MGATHER ||
2209
           N->getOpcode() == ISD::MSCATTER;
2210
  }
2211
};
2212
2213
/// This class is used to represent an MGATHER node
2214
///
2215
class MaskedGatherSDNode : public MaskedGatherScatterSDNode {
2216
public:
2217
  friend class SelectionDAG;
2218
2219
  MaskedGatherSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2220
                     EVT MemVT, MachineMemOperand *MMO)
2221
860
      : MaskedGatherScatterSDNode(ISD::MGATHER, Order, dl, VTs, MemVT, MMO) {}
2222
2223
  static bool classof(const SDNode *N) {
2224
    return N->getOpcode() == ISD::MGATHER;
2225
  }
2226
};
2227
2228
/// This class is used to represent an MSCATTER node
2229
///
2230
class MaskedScatterSDNode : public MaskedGatherScatterSDNode {
2231
public:
2232
  friend class SelectionDAG;
2233
2234
  MaskedScatterSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
2235
                      EVT MemVT, MachineMemOperand *MMO)
2236
296
      : MaskedGatherScatterSDNode(ISD::MSCATTER, Order, dl, VTs, MemVT, MMO) {}
2237
2238
  static bool classof(const SDNode *N) {
2239
    return N->getOpcode() == ISD::MSCATTER;
2240
  }
2241
};
2242
2243
/// An SDNode that represents everything that will be needed
2244
/// to construct a MachineInstr. These nodes are created during the
2245
/// instruction selection proper phase.
2246
class MachineSDNode : public SDNode {
2247
public:
2248
  using mmo_iterator = MachineMemOperand **;
2249
2250
private:
2251
  friend class SelectionDAG;
2252
2253
  MachineSDNode(unsigned Opc, unsigned Order, const DebugLoc &DL, SDVTList VTs)
2254
757k
      : SDNode(Opc, Order, DL, VTs) {}
2255
2256
  /// Memory reference descriptions for this instruction.
2257
  mmo_iterator MemRefs = nullptr;
2258
  mmo_iterator MemRefsEnd = nullptr;
2259
2260
public:
2261
10.6M
  mmo_iterator memoperands_begin() const { return MemRefs; }
2262
10.5M
  mmo_iterator memoperands_end() const { return MemRefsEnd; }
2263
298k
  bool memoperands_empty() const { return MemRefsEnd == MemRefs; }
2264
2265
  /// Assign this MachineSDNodes's memory reference descriptor
2266
  /// list. This does not transfer ownership.
2267
13.1M
  void setMemRefs(mmo_iterator NewMemRefs, mmo_iterator NewMemRefsEnd) {
2268
15.4M
    for (mmo_iterator MMI = NewMemRefs, MME = NewMemRefsEnd; MMI != MME; 
++MMI2.34M
)
2269
13.1M
      assert(*MMI && "Null mem ref detected!");
2270
13.1M
    MemRefs = NewMemRefs;
2271
13.1M
    MemRefsEnd = NewMemRefsEnd;
2272
13.1M
  }
2273
2274
12.3M
  static bool classof(const SDNode *N) {
2275
12.3M
    return N->isMachineOpcode();
2276
12.3M
  }
2277
};
2278
2279
class SDNodeIterator : public std::iterator<std::forward_iterator_tag,
2280
                                            SDNode, ptrdiff_t> {
2281
  const SDNode *Node;
2282
  unsigned Operand;
2283
2284
17.3k
  SDNodeIterator(const SDNode *N, unsigned Op) : Node(N), Operand(Op) {}
2285
2286
public:
2287
24.3k
  bool operator==(const SDNodeIterator& x) const {
2288
24.3k
    return Operand == x.Operand;
2289
24.3k
  }
2290
24.3k
  bool operator!=(const SDNodeIterator& x) const { return !operator==(x); }
2291
2292
15.6k
  pointer operator*() const {
2293
15.6k
    return Node->getOperand(Operand).getNode();
2294
15.6k
  }
2295
  pointer operator->() const { return operator*(); }
2296
2297
15.6k
  SDNodeIterator& operator++() {                // Preincrement
2298
15.6k
    ++Operand;
2299
15.6k
    return *this;
2300
15.6k
  }
2301
0
  SDNodeIterator operator++(int) { // Postincrement
2302
0
    SDNodeIterator tmp = *this; ++*this; return tmp;
2303
0
  }
2304
  size_t operator-(SDNodeIterator Other) const {
2305
    assert(Node == Other.Node &&
2306
           "Cannot compare iterators of two different nodes!");
2307
    return Operand - Other.Operand;
2308
  }
2309
2310
8.65k
  static SDNodeIterator begin(const SDNode *N) { return SDNodeIterator(N, 0); }
2311
8.65k
  static SDNodeIterator end  (const SDNode *N) {
2312
8.65k
    return SDNodeIterator(N, N->getNumOperands());
2313
8.65k
  }
2314
2315
  unsigned getOperand() const { return Operand; }
2316
  const SDNode *getNode() const { return Node; }
2317
};
2318
2319
template <> struct GraphTraits<SDNode*> {
2320
  using NodeRef = SDNode *;
2321
  using ChildIteratorType = SDNodeIterator;
2322
2323
  static NodeRef getEntryNode(SDNode *N) { return N; }
2324
2325
  static ChildIteratorType child_begin(NodeRef N) {
2326
    return SDNodeIterator::begin(N);
2327
  }
2328
2329
  static ChildIteratorType child_end(NodeRef N) {
2330
    return SDNodeIterator::end(N);
2331
  }
2332
};
2333
2334
/// A representation of the largest SDNode, for use in sizeof().
2335
///
2336
/// This needs to be a union because the largest node differs on 32 bit systems
2337
/// with 4 and 8 byte pointer alignment, respectively.
2338
using LargestSDNode = AlignedCharArrayUnion<AtomicSDNode, TargetIndexSDNode,
2339
                                            BlockAddressSDNode,
2340
                                            GlobalAddressSDNode>;
2341
2342
/// The SDNode class with the greatest alignment requirement.
2343
using MostAlignedSDNode = GlobalAddressSDNode;
2344
2345
namespace ISD {
2346
2347
  /// Returns true if the specified node is a non-extending and unindexed load.
2348
11.1M
  inline bool isNormalLoad(const SDNode *N) {
2349
11.1M
    const LoadSDNode *Ld = dyn_cast<LoadSDNode>(N);
2350
11.1M
    return Ld && 
Ld->getExtensionType() == ISD::NON_EXTLOAD5.79M
&&
2351
11.1M
      
Ld->getAddressingMode() == ISD::UNINDEXED4.72M
;
2352
11.1M
  }
2353
2354
  /// Returns true if the specified node is a non-extending load.
2355
677k
  inline bool isNON_EXTLoad(const SDNode *N) {
2356
677k
    return isa<LoadSDNode>(N) &&
2357
677k
      
cast<LoadSDNode>(N)->getExtensionType() == ISD::NON_EXTLOAD277k
;
2358
677k
  }
2359
2360
  /// Returns true if the specified node is a EXTLOAD.
2361
824k
  inline bool isEXTLoad(const SDNode *N) {
2362
824k
    return isa<LoadSDNode>(N) &&
2363
824k
      
cast<LoadSDNode>(N)->getExtensionType() == ISD::EXTLOAD88.1k
;
2364
824k
  }
2365
2366
  /// Returns true if the specified node is a SEXTLOAD.
2367
577k
  inline bool isSEXTLoad(const SDNode *N) {
2368
577k
    return isa<LoadSDNode>(N) &&
2369
577k
      
cast<LoadSDNode>(N)->getExtensionType() == ISD::SEXTLOAD70.8k
;
2370
577k
  }
2371
2372
  /// Returns true if the specified node is a ZEXTLOAD.
2373
5.43M
  inline bool isZEXTLoad(const SDNode *N) {
2374
5.43M
    return isa<LoadSDNode>(N) &&
2375
5.43M
      
cast<LoadSDNode>(N)->getExtensionType() == ISD::ZEXTLOAD5.20M
;
2376
5.43M
  }
2377
2378
  /// Returns true if the specified node is an unindexed load.
2379
1.76M
  inline bool isUNINDEXEDLoad(const SDNode *N) {
2380
1.76M
    return isa<LoadSDNode>(N) &&
2381
1.76M
      
cast<LoadSDNode>(N)->getAddressingMode() == ISD::UNINDEXED1.44M
;
2382
1.76M
  }
2383
2384
  /// Returns true if the specified node is a non-truncating
2385
  /// and unindexed store.
2386
6.34M
  inline bool isNormalStore(const SDNode *N) {
2387
6.34M
    const StoreSDNode *St = dyn_cast<StoreSDNode>(N);
2388
6.34M
    return St && 
!St->isTruncatingStore()6.34M
&&
2389
6.34M
      
St->getAddressingMode() == ISD::UNINDEXED5.87M
;
2390
6.34M
  }
2391
2392
  /// Returns true if the specified node is a non-truncating store.
2393
2.71M
  inline bool isNON_TRUNCStore(const SDNode *N) {
2394
2.71M
    return isa<StoreSDNode>(N) && 
!cast<StoreSDNode>(N)->isTruncatingStore()268k
;
2395
2.71M
  }
2396
2397
  /// Returns true if the specified node is a truncating store.
2398
  inline bool isTRUNCStore(const SDNode *N) {
2399
    return isa<StoreSDNode>(N) && cast<StoreSDNode>(N)->isTruncatingStore();
2400
  }
2401
2402
  /// Returns true if the specified node is an unindexed store.
2403
  inline bool isUNINDEXEDStore(const SDNode *N) {
2404
    return isa<StoreSDNode>(N) &&
2405
      cast<StoreSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
2406
  }
2407
2408
  /// Attempt to match a unary predicate against a scalar/splat constant or
2409
  /// every element of a constant BUILD_VECTOR.
2410
  bool matchUnaryPredicate(SDValue Op,
2411
                           std::function<bool(ConstantSDNode *)> Match);
2412
2413
  /// Attempt to match a binary predicate against a pair of scalar/splat
2414
  /// constants or every element of a pair of constant BUILD_VECTORs.
2415
  bool matchBinaryPredicate(
2416
      SDValue LHS, SDValue RHS,
2417
      std::function<bool(ConstantSDNode *, ConstantSDNode *)> Match);
2418
2419
} // end namespace ISD
2420
2421
} // end namespace llvm
2422
2423
#endif // LLVM_CODEGEN_SELECTIONDAGNODES_H