LLVM  10.0.0svn
SelectionDAG.h
Go to the documentation of this file.
1 //===- llvm/CodeGen/SelectionDAG.h - InstSelection DAG ----------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file declares the SelectionDAG class, and transitively defines the
10 // SDNode class and subclasses.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CODEGEN_SELECTIONDAG_H
15 #define LLVM_CODEGEN_SELECTIONDAG_H
16 
17 #include "llvm/ADT/APFloat.h"
18 #include "llvm/ADT/APInt.h"
19 #include "llvm/ADT/ArrayRef.h"
20 #include "llvm/ADT/DenseMap.h"
21 #include "llvm/ADT/DenseSet.h"
22 #include "llvm/ADT/FoldingSet.h"
23 #include "llvm/ADT/SetVector.h"
24 #include "llvm/ADT/SmallVector.h"
25 #include "llvm/ADT/StringMap.h"
26 #include "llvm/ADT/ilist.h"
27 #include "llvm/ADT/iterator.h"
38 #include "llvm/IR/DebugLoc.h"
39 #include "llvm/IR/Instructions.h"
40 #include "llvm/IR/Metadata.h"
41 #include "llvm/Support/Allocator.h"
44 #include "llvm/Support/Casting.h"
45 #include "llvm/Support/CodeGen.h"
49 #include <algorithm>
50 #include <cassert>
51 #include <cstdint>
52 #include <functional>
53 #include <map>
54 #include <string>
55 #include <tuple>
56 #include <utility>
57 #include <vector>
58 
59 namespace llvm {
60 
61 class BlockAddress;
62 class Constant;
63 class ConstantFP;
64 class ConstantInt;
65 class DataLayout;
66 struct fltSemantics;
67 class GlobalValue;
68 struct KnownBits;
69 class LLVMContext;
70 class MachineBasicBlock;
71 class MachineConstantPoolValue;
72 class MCSymbol;
73 class OptimizationRemarkEmitter;
74 class SDDbgValue;
75 class SDDbgLabel;
76 class SelectionDAG;
77 class SelectionDAGTargetInfo;
78 class TargetLibraryInfo;
79 class TargetLowering;
80 class TargetMachine;
81 class TargetSubtargetInfo;
82 class Value;
83 
84 class SDVTListNode : public FoldingSetNode {
85  friend struct FoldingSetTrait<SDVTListNode>;
86 
87  /// A reference to an Interned FoldingSetNodeID for this node.
88  /// The Allocator in SelectionDAG holds the data.
89  /// SDVTList contains all types which are frequently accessed in SelectionDAG.
90  /// The size of this list is not expected to be big so it won't introduce
91  /// a memory penalty.
92  FoldingSetNodeIDRef FastID;
93  const EVT *VTs;
94  unsigned int NumVTs;
95  /// The hash value for SDVTList is fixed, so cache it to avoid
96  /// hash calculation.
97  unsigned HashValue;
98 
99 public:
100  SDVTListNode(const FoldingSetNodeIDRef ID, const EVT *VT, unsigned int Num) :
101  FastID(ID), VTs(VT), NumVTs(Num) {
102  HashValue = ID.ComputeHash();
103  }
104 
106  SDVTList result = {VTs, NumVTs};
107  return result;
108  }
109 };
110 
111 /// Specialize FoldingSetTrait for SDVTListNode
112 /// to avoid computing temp FoldingSetNodeID and hash value.
113 template<> struct FoldingSetTrait<SDVTListNode> : DefaultFoldingSetTrait<SDVTListNode> {
114  static void Profile(const SDVTListNode &X, FoldingSetNodeID& ID) {
115  ID = X.FastID;
116  }
117 
118  static bool Equals(const SDVTListNode &X, const FoldingSetNodeID &ID,
119  unsigned IDHash, FoldingSetNodeID &TempID) {
120  if (X.HashValue != IDHash)
121  return false;
122  return ID == X.FastID;
123  }
124 
125  static unsigned ComputeHash(const SDVTListNode &X, FoldingSetNodeID &TempID) {
126  return X.HashValue;
127  }
128 };
129 
130 template <> struct ilist_alloc_traits<SDNode> {
131  static void deleteNode(SDNode *) {
132  llvm_unreachable("ilist_traits<SDNode> shouldn't see a deleteNode call!");
133  }
134 };
135 
136 /// Keeps track of dbg_value information through SDISel. We do
137 /// not build SDNodes for these so as not to perturb the generated code;
138 /// instead the info is kept off to the side in this structure. Each SDNode may
139 /// have one or more associated dbg_value entries. This information is kept in
140 /// DbgValMap.
141 /// Byval parameters are handled separately because they don't use alloca's,
142 /// which busts the normal mechanism. There is good reason for handling all
143 /// parameters separately: they may not have code generated for them, they
144 /// should always go at the beginning of the function regardless of other code
145 /// motion, and debug info for them is potentially useful even if the parameter
146 /// is unused. Right now only byval parameters are handled separately.
147 class SDDbgInfo {
148  BumpPtrAllocator Alloc;
150  SmallVector<SDDbgValue*, 32> ByvalParmDbgValues;
151  SmallVector<SDDbgLabel*, 4> DbgLabels;
153  DbgValMapType DbgValMap;
154 
155 public:
156  SDDbgInfo() = default;
157  SDDbgInfo(const SDDbgInfo &) = delete;
158  SDDbgInfo &operator=(const SDDbgInfo &) = delete;
159 
160  void add(SDDbgValue *V, const SDNode *Node, bool isParameter) {
161  if (isParameter) {
162  ByvalParmDbgValues.push_back(V);
163  } else DbgValues.push_back(V);
164  if (Node)
165  DbgValMap[Node].push_back(V);
166  }
167 
168  void add(SDDbgLabel *L) {
169  DbgLabels.push_back(L);
170  }
171 
172  /// Invalidate all DbgValues attached to the node and remove
173  /// it from the Node-to-DbgValues map.
174  void erase(const SDNode *Node);
175 
176  void clear() {
177  DbgValMap.clear();
178  DbgValues.clear();
179  ByvalParmDbgValues.clear();
180  DbgLabels.clear();
181  Alloc.Reset();
182  }
183 
184  BumpPtrAllocator &getAlloc() { return Alloc; }
185 
186  bool empty() const {
187  return DbgValues.empty() && ByvalParmDbgValues.empty() && DbgLabels.empty();
188  }
189 
191  auto I = DbgValMap.find(Node);
192  if (I != DbgValMap.end())
193  return I->second;
194  return ArrayRef<SDDbgValue*>();
195  }
196 
199 
200  DbgIterator DbgBegin() { return DbgValues.begin(); }
201  DbgIterator DbgEnd() { return DbgValues.end(); }
202  DbgIterator ByvalParmDbgBegin() { return ByvalParmDbgValues.begin(); }
203  DbgIterator ByvalParmDbgEnd() { return ByvalParmDbgValues.end(); }
204  DbgLabelIterator DbgLabelBegin() { return DbgLabels.begin(); }
205  DbgLabelIterator DbgLabelEnd() { return DbgLabels.end(); }
206 };
207 
208 void checkForCycles(const SelectionDAG *DAG, bool force = false);
209 
210 /// This is used to represent a portion of an LLVM function in a low-level
211 /// Data Dependence DAG representation suitable for instruction selection.
212 /// This DAG is constructed as the first step of instruction selection in order
213 /// to allow implementation of machine specific optimizations
214 /// and code simplifications.
215 ///
216 /// The representation used by the SelectionDAG is a target-independent
217 /// representation, which has some similarities to the GCC RTL representation,
218 /// but is significantly more simple, powerful, and is a graph form instead of a
219 /// linear form.
220 ///
222  const TargetMachine &TM;
223  const SelectionDAGTargetInfo *TSI = nullptr;
224  const TargetLowering *TLI = nullptr;
225  const TargetLibraryInfo *LibInfo = nullptr;
226  MachineFunction *MF;
227  Pass *SDAGISelPass = nullptr;
229  CodeGenOpt::Level OptLevel;
230 
231  LegacyDivergenceAnalysis * DA = nullptr;
232  FunctionLoweringInfo * FLI = nullptr;
233 
234  /// The function-level optimization remark emitter. Used to emit remarks
235  /// whenever manipulating the DAG.
237 
238  /// The starting token.
239  SDNode EntryNode;
240 
241  /// The root of the entire DAG.
242  SDValue Root;
243 
244  /// A linked list of nodes in the current DAG.
245  ilist<SDNode> AllNodes;
246 
247  /// The AllocatorType for allocating SDNodes. We use
248  /// pool allocation with recycling.
250  sizeof(LargestSDNode),
251  alignof(MostAlignedSDNode)>;
252 
253  /// Pool allocation for nodes.
254  NodeAllocatorType NodeAllocator;
255 
256  /// This structure is used to memoize nodes, automatically performing
257  /// CSE with existing nodes when a duplicate is requested.
258  FoldingSet<SDNode> CSEMap;
259 
260  /// Pool allocation for machine-opcode SDNode operands.
261  BumpPtrAllocator OperandAllocator;
262  ArrayRecycler<SDUse> OperandRecycler;
263 
264  /// Pool allocation for misc. objects that are created once per SelectionDAG.
265  BumpPtrAllocator Allocator;
266 
267  /// Tracks dbg_value and dbg_label information through SDISel.
268  SDDbgInfo *DbgInfo;
269 
273 
274  uint16_t NextPersistentId = 0;
275 
276 public:
277  /// Clients of various APIs that cause global effects on
278  /// the DAG can optionally implement this interface. This allows the clients
279  /// to handle the various sorts of updates that happen.
280  ///
281  /// A DAGUpdateListener automatically registers itself with DAG when it is
282  /// constructed, and removes itself when destroyed in RAII fashion.
286 
288  : Next(D.UpdateListeners), DAG(D) {
289  DAG.UpdateListeners = this;
290  }
291 
292  virtual ~DAGUpdateListener() {
293  assert(DAG.UpdateListeners == this &&
294  "DAGUpdateListeners must be destroyed in LIFO order");
295  DAG.UpdateListeners = Next;
296  }
297 
298  /// The node N that was deleted and, if E is not null, an
299  /// equivalent node E that replaced it.
300  virtual void NodeDeleted(SDNode *N, SDNode *E);
301 
302  /// The node N that was updated.
303  virtual void NodeUpdated(SDNode *N);
304 
305  /// The node N that was inserted.
306  virtual void NodeInserted(SDNode *N);
307  };
308 
310  std::function<void(SDNode *, SDNode *)> Callback;
311 
313  std::function<void(SDNode *, SDNode *)> Callback)
314  : DAGUpdateListener(DAG), Callback(std::move(Callback)) {}
315 
316  void NodeDeleted(SDNode *N, SDNode *E) override { Callback(N, E); }
317 
318  private:
319  virtual void anchor();
320  };
321 
322  /// When true, additional steps are taken to
323  /// ensure that getConstant() and similar functions return DAG nodes that
324  /// have legal types. This is important after type legalization since
325  /// any illegally typed nodes generated after this point will not experience
326  /// type legalization.
327  bool NewNodesMustHaveLegalTypes = false;
328 
329 private:
330  /// DAGUpdateListener is a friend so it can manipulate the listener stack.
331  friend struct DAGUpdateListener;
332 
333  /// Linked list of registered DAGUpdateListener instances.
334  /// This stack is maintained by DAGUpdateListener RAII.
335  DAGUpdateListener *UpdateListeners = nullptr;
336 
337  /// Implementation of setSubgraphColor.
338  /// Return whether we had to truncate the search.
339  bool setSubgraphColorHelper(SDNode *N, const char *Color,
340  DenseSet<SDNode *> &visited,
341  int level, bool &printed);
342 
343  template <typename SDNodeT, typename... ArgTypes>
344  SDNodeT *newSDNode(ArgTypes &&... Args) {
345  return new (NodeAllocator.template Allocate<SDNodeT>())
346  SDNodeT(std::forward<ArgTypes>(Args)...);
347  }
348 
349  /// Build a synthetic SDNodeT with the given args and extract its subclass
350  /// data as an integer (e.g. for use in a folding set).
351  ///
352  /// The args to this function are the same as the args to SDNodeT's
353  /// constructor, except the second arg (assumed to be a const DebugLoc&) is
354  /// omitted.
355  template <typename SDNodeT, typename... ArgTypes>
356  static uint16_t getSyntheticNodeSubclassData(unsigned IROrder,
357  ArgTypes &&... Args) {
358  // The compiler can reduce this expression to a constant iff we pass an
359  // empty DebugLoc. Thankfully, the debug location doesn't have any bearing
360  // on the subclass data.
361  return SDNodeT(IROrder, DebugLoc(), std::forward<ArgTypes>(Args)...)
362  .getRawSubclassData();
363  }
364 
365  template <typename SDNodeTy>
366  static uint16_t getSyntheticNodeSubclassData(unsigned Opc, unsigned Order,
367  SDVTList VTs, EVT MemoryVT,
368  MachineMemOperand *MMO) {
369  return SDNodeTy(Opc, Order, DebugLoc(), VTs, MemoryVT, MMO)
370  .getRawSubclassData();
371  }
372 
373  void createOperands(SDNode *Node, ArrayRef<SDValue> Vals);
374 
375  void removeOperands(SDNode *Node) {
376  if (!Node->OperandList)
377  return;
378  OperandRecycler.deallocate(
379  ArrayRecycler<SDUse>::Capacity::get(Node->NumOperands),
380  Node->OperandList);
381  Node->NumOperands = 0;
382  Node->OperandList = nullptr;
383  }
384  void CreateTopologicalOrder(std::vector<SDNode*>& Order);
385 public:
386  explicit SelectionDAG(const TargetMachine &TM, CodeGenOpt::Level);
387  SelectionDAG(const SelectionDAG &) = delete;
388  SelectionDAG &operator=(const SelectionDAG &) = delete;
389  ~SelectionDAG();
390 
391  /// Prepare this SelectionDAG to process code in the given MachineFunction.
392  void init(MachineFunction &NewMF, OptimizationRemarkEmitter &NewORE,
393  Pass *PassPtr, const TargetLibraryInfo *LibraryInfo,
394  LegacyDivergenceAnalysis * Divergence);
395 
397  FLI = FuncInfo;
398  }
399 
400  /// Clear state and free memory necessary to make this
401  /// SelectionDAG ready to process a new block.
402  void clear();
403 
404  MachineFunction &getMachineFunction() const { return *MF; }
405  const Pass *getPass() const { return SDAGISelPass; }
406 
407  const DataLayout &getDataLayout() const { return MF->getDataLayout(); }
408  const TargetMachine &getTarget() const { return TM; }
409  const TargetSubtargetInfo &getSubtarget() const { return MF->getSubtarget(); }
410  const TargetLowering &getTargetLoweringInfo() const { return *TLI; }
411  const TargetLibraryInfo &getLibInfo() const { return *LibInfo; }
412  const SelectionDAGTargetInfo &getSelectionDAGInfo() const { return *TSI; }
413  const LegacyDivergenceAnalysis *getDivergenceAnalysis() const { return DA; }
414  LLVMContext *getContext() const {return Context; }
415  OptimizationRemarkEmitter &getORE() const { return *ORE; }
416 
417  /// Pop up a GraphViz/gv window with the DAG rendered using 'dot'.
418  void viewGraph(const std::string &Title);
419  void viewGraph();
420 
421 #ifndef NDEBUG
422  std::map<const SDNode *, std::string> NodeGraphAttrs;
423 #endif
424 
425  /// Clear all previously defined node graph attributes.
426  /// Intended to be used from a debugging tool (eg. gdb).
427  void clearGraphAttrs();
428 
429  /// Set graph attributes for a node. (eg. "color=red".)
430  void setGraphAttrs(const SDNode *N, const char *Attrs);
431 
432  /// Get graph attributes for a node. (eg. "color=red".)
433  /// Used from getNodeAttributes.
434  const std::string getGraphAttrs(const SDNode *N) const;
435 
436  /// Convenience for setting node color attribute.
437  void setGraphColor(const SDNode *N, const char *Color);
438 
439  /// Convenience for setting subgraph color attribute.
440  void setSubgraphColor(SDNode *N, const char *Color);
441 
443 
444  allnodes_const_iterator allnodes_begin() const { return AllNodes.begin(); }
445  allnodes_const_iterator allnodes_end() const { return AllNodes.end(); }
446 
448 
449  allnodes_iterator allnodes_begin() { return AllNodes.begin(); }
450  allnodes_iterator allnodes_end() { return AllNodes.end(); }
451 
453  return AllNodes.size();
454  }
455 
457  return make_range(allnodes_begin(), allnodes_end());
458  }
460  return make_range(allnodes_begin(), allnodes_end());
461  }
462 
463  /// Return the root tag of the SelectionDAG.
464  const SDValue &getRoot() const { return Root; }
465 
466  /// Return the token chain corresponding to the entry of the function.
468  return SDValue(const_cast<SDNode *>(&EntryNode), 0);
469  }
470 
471  /// Set the current root tag of the SelectionDAG.
472  ///
474  assert((!N.getNode() || N.getValueType() == MVT::Other) &&
475  "DAG root value is not a chain!");
476  if (N.getNode())
477  checkForCycles(N.getNode(), this);
478  Root = N;
479  if (N.getNode())
480  checkForCycles(this);
481  return Root;
482  }
483 
484 #ifndef NDEBUG
485  void VerifyDAGDiverence();
486 #endif
487 
488  /// This iterates over the nodes in the SelectionDAG, folding
489  /// certain types of nodes together, or eliminating superfluous nodes. The
490  /// Level argument controls whether Combine is allowed to produce nodes and
491  /// types that are illegal on the target.
492  void Combine(CombineLevel Level, AliasAnalysis *AA,
493  CodeGenOpt::Level OptLevel);
494 
495  /// This transforms the SelectionDAG into a SelectionDAG that
496  /// only uses types natively supported by the target.
497  /// Returns "true" if it made any changes.
498  ///
499  /// Note that this is an involved process that may invalidate pointers into
500  /// the graph.
501  bool LegalizeTypes();
502 
503  /// This transforms the SelectionDAG into a SelectionDAG that is
504  /// compatible with the target instruction selector, as indicated by the
505  /// TargetLowering object.
506  ///
507  /// Note that this is an involved process that may invalidate pointers into
508  /// the graph.
509  void Legalize();
510 
511  /// Transforms a SelectionDAG node and any operands to it into a node
512  /// that is compatible with the target instruction selector, as indicated by
513  /// the TargetLowering object.
514  ///
515  /// \returns true if \c N is a valid, legal node after calling this.
516  ///
517  /// This essentially runs a single recursive walk of the \c Legalize process
518  /// over the given node (and its operands). This can be used to incrementally
519  /// legalize the DAG. All of the nodes which are directly replaced,
520  /// potentially including N, are added to the output parameter \c
521  /// UpdatedNodes so that the delta to the DAG can be understood by the
522  /// caller.
523  ///
524  /// When this returns false, N has been legalized in a way that make the
525  /// pointer passed in no longer valid. It may have even been deleted from the
526  /// DAG, and so it shouldn't be used further. When this returns true, the
527  /// N passed in is a legal node, and can be immediately processed as such.
528  /// This may still have done some work on the DAG, and will still populate
529  /// UpdatedNodes with any new nodes replacing those originally in the DAG.
530  bool LegalizeOp(SDNode *N, SmallSetVector<SDNode *, 16> &UpdatedNodes);
531 
532  /// This transforms the SelectionDAG into a SelectionDAG
533  /// that only uses vector math operations supported by the target. This is
534  /// necessary as a separate step from Legalize because unrolling a vector
535  /// operation can introduce illegal types, which requires running
536  /// LegalizeTypes again.
537  ///
538  /// This returns true if it made any changes; in that case, LegalizeTypes
539  /// is called again before Legalize.
540  ///
541  /// Note that this is an involved process that may invalidate pointers into
542  /// the graph.
543  bool LegalizeVectors();
544 
545  /// This method deletes all unreachable nodes in the SelectionDAG.
546  void RemoveDeadNodes();
547 
548  /// Remove the specified node from the system. This node must
549  /// have no referrers.
550  void DeleteNode(SDNode *N);
551 
552  /// Return an SDVTList that represents the list of values specified.
553  SDVTList getVTList(EVT VT);
554  SDVTList getVTList(EVT VT1, EVT VT2);
555  SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3);
556  SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4);
557  SDVTList getVTList(ArrayRef<EVT> VTs);
558 
559  //===--------------------------------------------------------------------===//
560  // Node creation methods.
561 
562  /// Create a ConstantSDNode wrapping a constant value.
563  /// If VT is a vector type, the constant is splatted into a BUILD_VECTOR.
564  ///
565  /// If only legal types can be produced, this does the necessary
566  /// transformations (e.g., if the vector element type is illegal).
567  /// @{
568  SDValue getConstant(uint64_t Val, const SDLoc &DL, EVT VT,
569  bool isTarget = false, bool isOpaque = false);
570  SDValue getConstant(const APInt &Val, const SDLoc &DL, EVT VT,
571  bool isTarget = false, bool isOpaque = false);
572 
573  SDValue getAllOnesConstant(const SDLoc &DL, EVT VT, bool IsTarget = false,
574  bool IsOpaque = false) {
576  VT, IsTarget, IsOpaque);
577  }
578 
579  SDValue getConstant(const ConstantInt &Val, const SDLoc &DL, EVT VT,
580  bool isTarget = false, bool isOpaque = false);
581  SDValue getIntPtrConstant(uint64_t Val, const SDLoc &DL,
582  bool isTarget = false);
583  SDValue getShiftAmountConstant(uint64_t Val, EVT VT, const SDLoc &DL,
584  bool LegalTypes = true);
585 
586  SDValue getTargetConstant(uint64_t Val, const SDLoc &DL, EVT VT,
587  bool isOpaque = false) {
588  return getConstant(Val, DL, VT, true, isOpaque);
589  }
590  SDValue getTargetConstant(const APInt &Val, const SDLoc &DL, EVT VT,
591  bool isOpaque = false) {
592  return getConstant(Val, DL, VT, true, isOpaque);
593  }
594  SDValue getTargetConstant(const ConstantInt &Val, const SDLoc &DL, EVT VT,
595  bool isOpaque = false) {
596  return getConstant(Val, DL, VT, true, isOpaque);
597  }
598 
599  /// Create a true or false constant of type \p VT using the target's
600  /// BooleanContent for type \p OpVT.
601  SDValue getBoolConstant(bool V, const SDLoc &DL, EVT VT, EVT OpVT);
602  /// @}
603 
604  /// Create a ConstantFPSDNode wrapping a constant value.
605  /// If VT is a vector type, the constant is splatted into a BUILD_VECTOR.
606  ///
607  /// If only legal types can be produced, this does the necessary
608  /// transformations (e.g., if the vector element type is illegal).
609  /// The forms that take a double should only be used for simple constants
610  /// that can be exactly represented in VT. No checks are made.
611  /// @{
612  SDValue getConstantFP(double Val, const SDLoc &DL, EVT VT,
613  bool isTarget = false);
614  SDValue getConstantFP(const APFloat &Val, const SDLoc &DL, EVT VT,
615  bool isTarget = false);
616  SDValue getConstantFP(const ConstantFP &V, const SDLoc &DL, EVT VT,
617  bool isTarget = false);
618  SDValue getTargetConstantFP(double Val, const SDLoc &DL, EVT VT) {
619  return getConstantFP(Val, DL, VT, true);
620  }
621  SDValue getTargetConstantFP(const APFloat &Val, const SDLoc &DL, EVT VT) {
622  return getConstantFP(Val, DL, VT, true);
623  }
624  SDValue getTargetConstantFP(const ConstantFP &Val, const SDLoc &DL, EVT VT) {
625  return getConstantFP(Val, DL, VT, true);
626  }
627  /// @}
628 
629  SDValue getGlobalAddress(const GlobalValue *GV, const SDLoc &DL, EVT VT,
630  int64_t offset = 0, bool isTargetGA = false,
631  unsigned char TargetFlags = 0);
633  int64_t offset = 0,
634  unsigned char TargetFlags = 0) {
635  return getGlobalAddress(GV, DL, VT, offset, true, TargetFlags);
636  }
637  SDValue getFrameIndex(int FI, EVT VT, bool isTarget = false);
639  return getFrameIndex(FI, VT, true);
640  }
641  SDValue getJumpTable(int JTI, EVT VT, bool isTarget = false,
642  unsigned char TargetFlags = 0);
643  SDValue getTargetJumpTable(int JTI, EVT VT, unsigned char TargetFlags = 0) {
644  return getJumpTable(JTI, VT, true, TargetFlags);
645  }
646  SDValue getConstantPool(const Constant *C, EVT VT,
647  unsigned Align = 0, int Offs = 0, bool isT=false,
648  unsigned char TargetFlags = 0);
650  unsigned Align = 0, int Offset = 0,
651  unsigned char TargetFlags = 0) {
652  return getConstantPool(C, VT, Align, Offset, true, TargetFlags);
653  }
654  SDValue getConstantPool(MachineConstantPoolValue *C, EVT VT,
655  unsigned Align = 0, int Offs = 0, bool isT=false,
656  unsigned char TargetFlags = 0);
658  EVT VT, unsigned Align = 0,
659  int Offset = 0, unsigned char TargetFlags=0) {
660  return getConstantPool(C, VT, Align, Offset, true, TargetFlags);
661  }
662  SDValue getTargetIndex(int Index, EVT VT, int64_t Offset = 0,
663  unsigned char TargetFlags = 0);
664  // When generating a branch to a BB, we don't in general know enough
665  // to provide debug info for the BB at that time, so keep this one around.
666  SDValue getBasicBlock(MachineBasicBlock *MBB);
667  SDValue getBasicBlock(MachineBasicBlock *MBB, SDLoc dl);
668  SDValue getExternalSymbol(const char *Sym, EVT VT);
669  SDValue getExternalSymbol(const char *Sym, const SDLoc &dl, EVT VT);
670  SDValue getTargetExternalSymbol(const char *Sym, EVT VT,
671  unsigned char TargetFlags = 0);
672  SDValue getMCSymbol(MCSymbol *Sym, EVT VT);
673 
674  SDValue getValueType(EVT);
675  SDValue getRegister(unsigned Reg, EVT VT);
676  SDValue getRegisterMask(const uint32_t *RegMask);
677  SDValue getEHLabel(const SDLoc &dl, SDValue Root, MCSymbol *Label);
678  SDValue getLabelNode(unsigned Opcode, const SDLoc &dl, SDValue Root,
679  MCSymbol *Label);
680  SDValue getBlockAddress(const BlockAddress *BA, EVT VT,
681  int64_t Offset = 0, bool isTarget = false,
682  unsigned char TargetFlags = 0);
684  int64_t Offset = 0,
685  unsigned char TargetFlags = 0) {
686  return getBlockAddress(BA, VT, Offset, true, TargetFlags);
687  }
688 
689  SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, unsigned Reg,
690  SDValue N) {
691  return getNode(ISD::CopyToReg, dl, MVT::Other, Chain,
692  getRegister(Reg, N.getValueType()), N);
693  }
694 
695  // This version of the getCopyToReg method takes an extra operand, which
696  // indicates that there is potentially an incoming glue value (if Glue is not
697  // null) and that there should be a glue result.
698  SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, unsigned Reg, SDValue N,
699  SDValue Glue) {
700  SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
701  SDValue Ops[] = { Chain, getRegister(Reg, N.getValueType()), N, Glue };
702  return getNode(ISD::CopyToReg, dl, VTs,
703  makeArrayRef(Ops, Glue.getNode() ? 4 : 3));
704  }
705 
706  // Similar to last getCopyToReg() except parameter Reg is a SDValue
707  SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, SDValue Reg, SDValue N,
708  SDValue Glue) {
709  SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
710  SDValue Ops[] = { Chain, Reg, N, Glue };
711  return getNode(ISD::CopyToReg, dl, VTs,
712  makeArrayRef(Ops, Glue.getNode() ? 4 : 3));
713  }
714 
715  SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT) {
716  SDVTList VTs = getVTList(VT, MVT::Other);
717  SDValue Ops[] = { Chain, getRegister(Reg, VT) };
718  return getNode(ISD::CopyFromReg, dl, VTs, Ops);
719  }
720 
721  // This version of the getCopyFromReg method takes an extra operand, which
722  // indicates that there is potentially an incoming glue value (if Glue is not
723  // null) and that there should be a glue result.
724  SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT,
725  SDValue Glue) {
726  SDVTList VTs = getVTList(VT, MVT::Other, MVT::Glue);
727  SDValue Ops[] = { Chain, getRegister(Reg, VT), Glue };
728  return getNode(ISD::CopyFromReg, dl, VTs,
729  makeArrayRef(Ops, Glue.getNode() ? 3 : 2));
730  }
731 
733 
734  /// Return an ISD::VECTOR_SHUFFLE node. The number of elements in VT,
735  /// which must be a vector type, must match the number of mask elements
736  /// NumElts. An integer mask element equal to -1 is treated as undefined.
737  SDValue getVectorShuffle(EVT VT, const SDLoc &dl, SDValue N1, SDValue N2,
739 
740  /// Return an ISD::BUILD_VECTOR node. The number of elements in VT,
741  /// which must be a vector type, must match the number of operands in Ops.
742  /// The operands must have the same type as (or, for integers, a type wider
743  /// than) VT's element type.
745  // VerifySDNode (via InsertNode) checks BUILD_VECTOR later.
746  return getNode(ISD::BUILD_VECTOR, DL, VT, Ops);
747  }
748 
749  /// Return an ISD::BUILD_VECTOR node. The number of elements in VT,
750  /// which must be a vector type, must match the number of operands in Ops.
751  /// The operands must have the same type as (or, for integers, a type wider
752  /// than) VT's element type.
754  // VerifySDNode (via InsertNode) checks BUILD_VECTOR later.
755  return getNode(ISD::BUILD_VECTOR, DL, VT, Ops);
756  }
757 
758  /// Return a splat ISD::BUILD_VECTOR node, consisting of Op splatted to all
759  /// elements. VT must be a vector type. Op's type must be the same as (or,
760  /// for integers, a type wider than) VT's element type.
762  // VerifySDNode (via InsertNode) checks BUILD_VECTOR later.
763  if (Op.getOpcode() == ISD::UNDEF) {
764  assert((VT.getVectorElementType() == Op.getValueType() ||
765  (VT.isInteger() &&
767  "A splatted value must have a width equal or (for integers) "
768  "greater than the vector element type!");
769  return getNode(ISD::UNDEF, SDLoc(), VT);
770  }
771 
773  return getNode(ISD::BUILD_VECTOR, DL, VT, Ops);
774  }
775 
776  /// Returns an ISD::VECTOR_SHUFFLE node semantically equivalent to
777  /// the shuffle node in input but with swapped operands.
778  ///
779  /// Example: shuffle A, B, <0,5,2,7> -> shuffle B, A, <4,1,6,3>
780  SDValue getCommutedVectorShuffle(const ShuffleVectorSDNode &SV);
781 
782  /// Convert Op, which must be of float type, to the
783  /// float type VT, by either extending or rounding (by truncation).
784  SDValue getFPExtendOrRound(SDValue Op, const SDLoc &DL, EVT VT);
785 
786  /// Convert Op, which must be of integer type, to the
787  /// integer type VT, by either any-extending or truncating it.
788  SDValue getAnyExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT);
789 
790  /// Convert Op, which must be of integer type, to the
791  /// integer type VT, by either sign-extending or truncating it.
792  SDValue getSExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT);
793 
794  /// Convert Op, which must be of integer type, to the
795  /// integer type VT, by either zero-extending or truncating it.
796  SDValue getZExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT);
797 
798  /// Return the expression required to zero extend the Op
799  /// value assuming it was the smaller SrcTy value.
800  SDValue getZeroExtendInReg(SDValue Op, const SDLoc &DL, EVT VT);
801 
802  /// Convert Op, which must be of integer type, to the integer type VT, by
803  /// either truncating it or performing either zero or sign extension as
804  /// appropriate extension for the pointer's semantics.
805  SDValue getPtrExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT);
806 
807  /// Return the expression required to extend the Op as a pointer value
808  /// assuming it was the smaller SrcTy value. This may be either a zero extend
809  /// or a sign extend.
810  SDValue getPtrExtendInReg(SDValue Op, const SDLoc &DL, EVT VT);
811 
812  /// Convert Op, which must be of integer type, to the integer type VT,
813  /// by using an extension appropriate for the target's
814  /// BooleanContent for type OpVT or truncating it.
815  SDValue getBoolExtOrTrunc(SDValue Op, const SDLoc &SL, EVT VT, EVT OpVT);
816 
817  /// Create a bitwise NOT operation as (XOR Val, -1).
818  SDValue getNOT(const SDLoc &DL, SDValue Val, EVT VT);
819 
820  /// Create a logical NOT operation as (XOR Val, BooleanOne).
821  SDValue getLogicalNOT(const SDLoc &DL, SDValue Val, EVT VT);
822 
823  /// Create an add instruction with appropriate flags when used for
824  /// addressing some offset of an object. i.e. if a load is split into multiple
825  /// components, create an add nuw from the base pointer to the offset.
826  SDValue getObjectPtrOffset(const SDLoc &SL, SDValue Op, int64_t Offset) {
827  EVT VT = Op.getValueType();
828  return getObjectPtrOffset(SL, Op, getConstant(Offset, SL, VT));
829  }
830 
832  EVT VT = Op.getValueType();
833 
834  // The object itself can't wrap around the address space, so it shouldn't be
835  // possible for the adds of the offsets to the split parts to overflow.
836  SDNodeFlags Flags;
837  Flags.setNoUnsignedWrap(true);
838  return getNode(ISD::ADD, SL, VT, Op, Offset, Flags);
839  }
840 
841  /// Return a new CALLSEQ_START node, that starts new call frame, in which
842  /// InSize bytes are set up inside CALLSEQ_START..CALLSEQ_END sequence and
843  /// OutSize specifies part of the frame set up prior to the sequence.
844  SDValue getCALLSEQ_START(SDValue Chain, uint64_t InSize, uint64_t OutSize,
845  const SDLoc &DL) {
846  SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
847  SDValue Ops[] = { Chain,
848  getIntPtrConstant(InSize, DL, true),
849  getIntPtrConstant(OutSize, DL, true) };
850  return getNode(ISD::CALLSEQ_START, DL, VTs, Ops);
851  }
852 
853  /// Return a new CALLSEQ_END node, which always must have a
854  /// glue result (to ensure it's not CSE'd).
855  /// CALLSEQ_END does not have a useful SDLoc.
857  SDValue InGlue, const SDLoc &DL) {
858  SDVTList NodeTys = getVTList(MVT::Other, MVT::Glue);
860  Ops.push_back(Chain);
861  Ops.push_back(Op1);
862  Ops.push_back(Op2);
863  if (InGlue.getNode())
864  Ops.push_back(InGlue);
865  return getNode(ISD::CALLSEQ_END, DL, NodeTys, Ops);
866  }
867 
868  /// Return true if the result of this operation is always undefined.
869  bool isUndef(unsigned Opcode, ArrayRef<SDValue> Ops);
870 
871  /// Return an UNDEF node. UNDEF does not have a useful SDLoc.
873  return getNode(ISD::UNDEF, SDLoc(), VT);
874  }
875 
876  /// Return a GLOBAL_OFFSET_TABLE node. This does not have a useful SDLoc.
878  return getNode(ISD::GLOBAL_OFFSET_TABLE, SDLoc(), VT);
879  }
880 
881  /// Gets or creates the specified node.
882  ///
883  SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
884  ArrayRef<SDUse> Ops);
885  SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
886  ArrayRef<SDValue> Ops, const SDNodeFlags Flags = SDNodeFlags());
887  SDValue getNode(unsigned Opcode, const SDLoc &DL, ArrayRef<EVT> ResultTys,
888  ArrayRef<SDValue> Ops);
889  SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList,
890  ArrayRef<SDValue> Ops);
891 
892  // Specialize based on number of operands.
893  SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT);
894  SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue Operand,
895  const SDNodeFlags Flags = SDNodeFlags());
896  SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
897  SDValue N2, const SDNodeFlags Flags = SDNodeFlags());
898  SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
899  SDValue N2, SDValue N3,
900  const SDNodeFlags Flags = SDNodeFlags());
901  SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
902  SDValue N2, SDValue N3, SDValue N4);
903  SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
904  SDValue N2, SDValue N3, SDValue N4, SDValue N5);
905 
906  // Specialize again based on number of operands for nodes with a VTList
907  // rather than a single VT.
908  SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList);
909  SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N);
910  SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N1,
911  SDValue N2);
912  SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N1,
913  SDValue N2, SDValue N3);
914  SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N1,
915  SDValue N2, SDValue N3, SDValue N4);
916  SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N1,
917  SDValue N2, SDValue N3, SDValue N4, SDValue N5);
918 
919  /// Compute a TokenFactor to force all the incoming stack arguments to be
920  /// loaded from the stack. This is used in tail call lowering to protect
921  /// stack arguments from being clobbered.
922  SDValue getStackArgumentTokenFactor(SDValue Chain);
923 
924  SDValue getMemcpy(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src,
925  SDValue Size, unsigned Align, bool isVol, bool AlwaysInline,
926  bool isTailCall, MachinePointerInfo DstPtrInfo,
927  MachinePointerInfo SrcPtrInfo);
928 
929  SDValue getMemmove(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src,
930  SDValue Size, unsigned Align, bool isVol, bool isTailCall,
931  MachinePointerInfo DstPtrInfo,
932  MachinePointerInfo SrcPtrInfo);
933 
934  SDValue getMemset(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src,
935  SDValue Size, unsigned Align, bool isVol, bool isTailCall,
936  MachinePointerInfo DstPtrInfo);
937 
938  SDValue getAtomicMemcpy(SDValue Chain, const SDLoc &dl, SDValue Dst,
939  unsigned DstAlign, SDValue Src, unsigned SrcAlign,
940  SDValue Size, Type *SizeTy, unsigned ElemSz,
941  bool isTailCall, MachinePointerInfo DstPtrInfo,
942  MachinePointerInfo SrcPtrInfo);
943 
944  SDValue getAtomicMemmove(SDValue Chain, const SDLoc &dl, SDValue Dst,
945  unsigned DstAlign, SDValue Src, unsigned SrcAlign,
946  SDValue Size, Type *SizeTy, unsigned ElemSz,
947  bool isTailCall, MachinePointerInfo DstPtrInfo,
948  MachinePointerInfo SrcPtrInfo);
949 
950  SDValue getAtomicMemset(SDValue Chain, const SDLoc &dl, SDValue Dst,
951  unsigned DstAlign, SDValue Value, SDValue Size,
952  Type *SizeTy, unsigned ElemSz, bool isTailCall,
953  MachinePointerInfo DstPtrInfo);
954 
955  /// Helper function to make it easier to build SetCC's if you just have an
956  /// ISD::CondCode instead of an SDValue.
957  SDValue getSetCC(const SDLoc &DL, EVT VT, SDValue LHS, SDValue RHS,
958  ISD::CondCode Cond) {
959  assert(LHS.getValueType().isVector() == RHS.getValueType().isVector() &&
960  "Cannot compare scalars to vectors");
961  assert(LHS.getValueType().isVector() == VT.isVector() &&
962  "Cannot compare scalars to vectors");
963  assert(Cond != ISD::SETCC_INVALID &&
964  "Cannot create a setCC of an invalid node.");
965  return getNode(ISD::SETCC, DL, VT, LHS, RHS, getCondCode(Cond));
966  }
967 
968  /// Helper function to make it easier to build Select's if you just have
969  /// operands and don't want to check for vector.
970  SDValue getSelect(const SDLoc &DL, EVT VT, SDValue Cond, SDValue LHS,
971  SDValue RHS) {
972  assert(LHS.getValueType() == RHS.getValueType() &&
973  "Cannot use select on differing types");
974  assert(VT.isVector() == LHS.getValueType().isVector() &&
975  "Cannot mix vectors and scalars");
976  auto Opcode = Cond.getValueType().isVector() ? ISD::VSELECT : ISD::SELECT;
977  return getNode(Opcode, DL, VT, Cond, LHS, RHS);
978  }
979 
980  /// Helper function to make it easier to build SelectCC's if you just have an
981  /// ISD::CondCode instead of an SDValue.
982  SDValue getSelectCC(const SDLoc &DL, SDValue LHS, SDValue RHS, SDValue True,
983  SDValue False, ISD::CondCode Cond) {
984  return getNode(ISD::SELECT_CC, DL, True.getValueType(), LHS, RHS, True,
985  False, getCondCode(Cond));
986  }
987 
988  /// Try to simplify a select/vselect into 1 of its operands or a constant.
989  SDValue simplifySelect(SDValue Cond, SDValue TVal, SDValue FVal);
990 
991  /// Try to simplify a shift into 1 of its operands or a constant.
992  SDValue simplifyShift(SDValue X, SDValue Y);
993 
994  /// Try to simplify a floating-point binary operation into 1 of its operands
995  /// or a constant.
996  SDValue simplifyFPBinop(unsigned Opcode, SDValue X, SDValue Y);
997 
998  /// VAArg produces a result and token chain, and takes a pointer
999  /// and a source value as input.
1000  SDValue getVAArg(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
1001  SDValue SV, unsigned Align);
1002 
1003  /// Gets a node for an atomic cmpxchg op. There are two
1004  /// valid Opcodes. ISD::ATOMIC_CMO_SWAP produces the value loaded and a
1005  /// chain result. ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS produces the value loaded,
1006  /// a success flag (initially i1), and a chain.
1007  SDValue getAtomicCmpSwap(unsigned Opcode, const SDLoc &dl, EVT MemVT,
1008  SDVTList VTs, SDValue Chain, SDValue Ptr,
1009  SDValue Cmp, SDValue Swp, MachineMemOperand *MMO);
1010 
1011  /// Gets a node for an atomic op, produces result (if relevant)
1012  /// and chain and takes 2 operands.
1013  SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT, SDValue Chain,
1014  SDValue Ptr, SDValue Val, MachineMemOperand *MMO);
1015 
1016  /// Gets a node for an atomic op, produces result and chain and
1017  /// takes 1 operand.
1018  SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT, EVT VT,
1019  SDValue Chain, SDValue Ptr, MachineMemOperand *MMO);
1020 
1021  /// Gets a node for an atomic op, produces result and chain and takes N
1022  /// operands.
1023  SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT,
1024  SDVTList VTList, ArrayRef<SDValue> Ops,
1025  MachineMemOperand *MMO);
1026 
1027  /// Creates a MemIntrinsicNode that may produce a
1028  /// result and takes a list of operands. Opcode may be INTRINSIC_VOID,
1029  /// INTRINSIC_W_CHAIN, or a target-specific opcode with a value not
1030  /// less than FIRST_TARGET_MEMORY_OPCODE.
1031  SDValue getMemIntrinsicNode(
1032  unsigned Opcode, const SDLoc &dl, SDVTList VTList,
1033  ArrayRef<SDValue> Ops, EVT MemVT,
1034  MachinePointerInfo PtrInfo,
1035  unsigned Align = 0,
1038  unsigned Size = 0,
1039  const AAMDNodes &AAInfo = AAMDNodes());
1040 
1041  SDValue getMemIntrinsicNode(unsigned Opcode, const SDLoc &dl, SDVTList VTList,
1042  ArrayRef<SDValue> Ops, EVT MemVT,
1043  MachineMemOperand *MMO);
1044 
1045  /// Creates a LifetimeSDNode that starts (`IsStart==true`) or ends
1046  /// (`IsStart==false`) the lifetime of the portion of `FrameIndex` between
1047  /// offsets `Offset` and `Offset + Size`.
1048  SDValue getLifetimeNode(bool IsStart, const SDLoc &dl, SDValue Chain,
1049  int FrameIndex, int64_t Size, int64_t Offset = -1);
1050 
1051  /// Create a MERGE_VALUES node from the given operands.
1052  SDValue getMergeValues(ArrayRef<SDValue> Ops, const SDLoc &dl);
1053 
1054  /// Loads are not normal binary operators: their result type is not
1055  /// determined by their operands, and they produce a value AND a token chain.
1056  ///
1057  /// This function will set the MOLoad flag on MMOFlags, but you can set it if
1058  /// you want. The MOStore flag must not be set.
1059  SDValue getLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
1060  MachinePointerInfo PtrInfo, unsigned Alignment = 0,
1062  const AAMDNodes &AAInfo = AAMDNodes(),
1063  const MDNode *Ranges = nullptr);
1064  SDValue getLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
1065  MachineMemOperand *MMO);
1066  SDValue
1067  getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT, SDValue Chain,
1068  SDValue Ptr, MachinePointerInfo PtrInfo, EVT MemVT,
1069  unsigned Alignment = 0,
1071  const AAMDNodes &AAInfo = AAMDNodes());
1072  SDValue getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT,
1073  SDValue Chain, SDValue Ptr, EVT MemVT,
1074  MachineMemOperand *MMO);
1075  SDValue getIndexedLoad(SDValue OrigLoad, const SDLoc &dl, SDValue Base,
1077  SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT,
1078  const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
1079  MachinePointerInfo PtrInfo, EVT MemVT, unsigned Alignment = 0,
1081  const AAMDNodes &AAInfo = AAMDNodes(),
1082  const MDNode *Ranges = nullptr);
1083  SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT,
1084  const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
1085  EVT MemVT, MachineMemOperand *MMO);
1086 
1087  /// Helper function to build ISD::STORE nodes.
1088  ///
1089  /// This function will set the MOStore flag on MMOFlags, but you can set it if
1090  /// you want. The MOLoad and MOInvariant flags must not be set.
1091  SDValue
1092  getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
1093  MachinePointerInfo PtrInfo, unsigned Alignment = 0,
1095  const AAMDNodes &AAInfo = AAMDNodes());
1096  SDValue getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
1097  MachineMemOperand *MMO);
1098  SDValue
1099  getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
1100  MachinePointerInfo PtrInfo, EVT SVT, unsigned Alignment = 0,
1102  const AAMDNodes &AAInfo = AAMDNodes());
1103  SDValue getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val,
1104  SDValue Ptr, EVT SVT, MachineMemOperand *MMO);
1105  SDValue getIndexedStore(SDValue OrigStore, const SDLoc &dl, SDValue Base,
1106  SDValue Offset, ISD::MemIndexedMode AM);
1107 
1108  /// Returns sum of the base pointer and offset.
1109  SDValue getMemBasePlusOffset(SDValue Base, unsigned Offset, const SDLoc &DL);
1110 
1111  SDValue getMaskedLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
1112  SDValue Mask, SDValue Src0, EVT MemVT,
1114  bool IsExpanding = false);
1115  SDValue getMaskedStore(SDValue Chain, const SDLoc &dl, SDValue Val,
1116  SDValue Ptr, SDValue Mask, EVT MemVT,
1117  MachineMemOperand *MMO, bool IsTruncating = false,
1118  bool IsCompressing = false);
1119  SDValue getMaskedGather(SDVTList VTs, EVT VT, const SDLoc &dl,
1121  SDValue getMaskedScatter(SDVTList VTs, EVT VT, const SDLoc &dl,
1123 
1124  /// Return (create a new or find existing) a target-specific node.
1125  /// TargetMemSDNode should be derived class from MemSDNode.
1126  template <class TargetMemSDNode>
1127  SDValue getTargetMemSDNode(SDVTList VTs, ArrayRef<SDValue> Ops,
1128  const SDLoc &dl, EVT MemVT,
1129  MachineMemOperand *MMO);
1130 
1131  /// Construct a node to track a Value* through the backend.
1132  SDValue getSrcValue(const Value *v);
1133 
1134  /// Return an MDNodeSDNode which holds an MDNode.
1135  SDValue getMDNode(const MDNode *MD);
1136 
1137  /// Return a bitcast using the SDLoc of the value operand, and casting to the
1138  /// provided type. Use getNode to set a custom SDLoc.
1139  SDValue getBitcast(EVT VT, SDValue V);
1140 
1141  /// Return an AddrSpaceCastSDNode.
1142  SDValue getAddrSpaceCast(const SDLoc &dl, EVT VT, SDValue Ptr, unsigned SrcAS,
1143  unsigned DestAS);
1144 
1145  /// Return the specified value casted to
1146  /// the target's desired shift amount type.
1147  SDValue getShiftAmountOperand(EVT LHSTy, SDValue Op);
1148 
1149  /// Expand the specified \c ISD::VAARG node as the Legalize pass would.
1150  SDValue expandVAArg(SDNode *Node);
1151 
1152  /// Expand the specified \c ISD::VACOPY node as the Legalize pass would.
1153  SDValue expandVACopy(SDNode *Node);
1154 
1155  /// Returs an GlobalAddress of the function from the current module with
1156  /// name matching the given ExternalSymbol. Additionally can provide the
1157  /// matched function.
1158  /// Panics the function doesn't exists.
1159  SDValue getSymbolFunctionGlobalAddress(SDValue Op,
1160  Function **TargetFunction = nullptr);
1161 
1162  /// *Mutate* the specified node in-place to have the
1163  /// specified operands. If the resultant node already exists in the DAG,
1164  /// this does not modify the specified node, instead it returns the node that
1165  /// already exists. If the resultant node does not exist in the DAG, the
1166  /// input node is returned. As a degenerate case, if you specify the same
1167  /// input operands as the node already has, the input node is returned.
1168  SDNode *UpdateNodeOperands(SDNode *N, SDValue Op);
1169  SDNode *UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2);
1170  SDNode *UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2,
1171  SDValue Op3);
1172  SDNode *UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2,
1173  SDValue Op3, SDValue Op4);
1174  SDNode *UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2,
1175  SDValue Op3, SDValue Op4, SDValue Op5);
1176  SDNode *UpdateNodeOperands(SDNode *N, ArrayRef<SDValue> Ops);
1177 
1178  /// Creates a new TokenFactor containing \p Vals. If \p Vals contains 64k
1179  /// values or more, move values into new TokenFactors in 64k-1 blocks, until
1180  /// the final TokenFactor has less than 64k operands.
1181  SDValue getTokenFactor(const SDLoc &DL, SmallVectorImpl<SDValue> &Vals);
1182 
1183  /// *Mutate* the specified machine node's memory references to the provided
1184  /// list.
1185  void setNodeMemRefs(MachineSDNode *N,
1186  ArrayRef<MachineMemOperand *> NewMemRefs);
1187 
1188  // Propagates the change in divergence to users
1189  void updateDivergence(SDNode * N);
1190 
1191  /// These are used for target selectors to *mutate* the
1192  /// specified node to have the specified return type, Target opcode, and
1193  /// operands. Note that target opcodes are stored as
1194  /// ~TargetOpcode in the node opcode field. The resultant node is returned.
1195  SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT);
1196  SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT, SDValue Op1);
1197  SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT,
1198  SDValue Op1, SDValue Op2);
1199  SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT,
1200  SDValue Op1, SDValue Op2, SDValue Op3);
1201  SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT,
1202  ArrayRef<SDValue> Ops);
1203  SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1, EVT VT2);
1204  SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1,
1205  EVT VT2, ArrayRef<SDValue> Ops);
1206  SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1,
1207  EVT VT2, EVT VT3, ArrayRef<SDValue> Ops);
1208  SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1,
1209  EVT VT2, SDValue Op1);
1210  SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1,
1211  EVT VT2, SDValue Op1, SDValue Op2);
1212  SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, SDVTList VTs,
1213  ArrayRef<SDValue> Ops);
1214 
1215  /// This *mutates* the specified node to have the specified
1216  /// return type, opcode, and operands.
1217  SDNode *MorphNodeTo(SDNode *N, unsigned Opc, SDVTList VTs,
1218  ArrayRef<SDValue> Ops);
1219 
1220  /// Mutate the specified strict FP node to its non-strict equivalent,
1221  /// unlinking the node from its chain and dropping the metadata arguments.
1222  /// The node must be a strict FP node.
1223  SDNode *mutateStrictFPToFP(SDNode *Node);
1224 
1225  /// These are used for target selectors to create a new node
1226  /// with specified return type(s), MachineInstr opcode, and operands.
1227  ///
1228  /// Note that getMachineNode returns the resultant node. If there is already
1229  /// a node of the specified opcode and operands, it returns that node instead
1230  /// of the current one.
1231  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT);
1232  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
1233  SDValue Op1);
1234  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
1235  SDValue Op1, SDValue Op2);
1236  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
1237  SDValue Op1, SDValue Op2, SDValue Op3);
1238  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
1239  ArrayRef<SDValue> Ops);
1240  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1241  EVT VT2, SDValue Op1, SDValue Op2);
1242  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1243  EVT VT2, SDValue Op1, SDValue Op2, SDValue Op3);
1244  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1245  EVT VT2, ArrayRef<SDValue> Ops);
1246  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1247  EVT VT2, EVT VT3, SDValue Op1, SDValue Op2);
1248  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1249  EVT VT2, EVT VT3, SDValue Op1, SDValue Op2,
1250  SDValue Op3);
1251  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1252  EVT VT2, EVT VT3, ArrayRef<SDValue> Ops);
1253  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl,
1254  ArrayRef<EVT> ResultTys, ArrayRef<SDValue> Ops);
1255  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, SDVTList VTs,
1256  ArrayRef<SDValue> Ops);
1257 
1258  /// A convenience function for creating TargetInstrInfo::EXTRACT_SUBREG nodes.
1259  SDValue getTargetExtractSubreg(int SRIdx, const SDLoc &DL, EVT VT,
1260  SDValue Operand);
1261 
1262  /// A convenience function for creating TargetInstrInfo::INSERT_SUBREG nodes.
1263  SDValue getTargetInsertSubreg(int SRIdx, const SDLoc &DL, EVT VT,
1264  SDValue Operand, SDValue Subreg);
1265 
1266  /// Get the specified node if it's already available, or else return NULL.
1267  SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTList, ArrayRef<SDValue> Ops,
1268  const SDNodeFlags Flags = SDNodeFlags());
1269 
1270  /// Creates a SDDbgValue node.
1271  SDDbgValue *getDbgValue(DIVariable *Var, DIExpression *Expr, SDNode *N,
1272  unsigned R, bool IsIndirect, const DebugLoc &DL,
1273  unsigned O);
1274 
1275  /// Creates a constant SDDbgValue node.
1276  SDDbgValue *getConstantDbgValue(DIVariable *Var, DIExpression *Expr,
1277  const Value *C, const DebugLoc &DL,
1278  unsigned O);
1279 
1280  /// Creates a FrameIndex SDDbgValue node.
1281  SDDbgValue *getFrameIndexDbgValue(DIVariable *Var, DIExpression *Expr,
1282  unsigned FI, bool IsIndirect,
1283  const DebugLoc &DL, unsigned O);
1284 
1285  /// Creates a VReg SDDbgValue node.
1286  SDDbgValue *getVRegDbgValue(DIVariable *Var, DIExpression *Expr,
1287  unsigned VReg, bool IsIndirect,
1288  const DebugLoc &DL, unsigned O);
1289 
1290  /// Creates a SDDbgLabel node.
1291  SDDbgLabel *getDbgLabel(DILabel *Label, const DebugLoc &DL, unsigned O);
1292 
1293  /// Transfer debug values from one node to another, while optionally
1294  /// generating fragment expressions for split-up values. If \p InvalidateDbg
1295  /// is set, debug values are invalidated after they are transferred.
1296  void transferDbgValues(SDValue From, SDValue To, unsigned OffsetInBits = 0,
1297  unsigned SizeInBits = 0, bool InvalidateDbg = true);
1298 
1299  /// Remove the specified node from the system. If any of its
1300  /// operands then becomes dead, remove them as well. Inform UpdateListener
1301  /// for each node deleted.
1302  void RemoveDeadNode(SDNode *N);
1303 
1304  /// This method deletes the unreachable nodes in the
1305  /// given list, and any nodes that become unreachable as a result.
1306  void RemoveDeadNodes(SmallVectorImpl<SDNode *> &DeadNodes);
1307 
1308  /// Modify anything using 'From' to use 'To' instead.
1309  /// This can cause recursive merging of nodes in the DAG. Use the first
1310  /// version if 'From' is known to have a single result, use the second
1311  /// if you have two nodes with identical results (or if 'To' has a superset
1312  /// of the results of 'From'), use the third otherwise.
1313  ///
1314  /// These methods all take an optional UpdateListener, which (if not null) is
1315  /// informed about nodes that are deleted and modified due to recursive
1316  /// changes in the dag.
1317  ///
1318  /// These functions only replace all existing uses. It's possible that as
1319  /// these replacements are being performed, CSE may cause the From node
1320  /// to be given new uses. These new uses of From are left in place, and
1321  /// not automatically transferred to To.
1322  ///
1323  void ReplaceAllUsesWith(SDValue From, SDValue To);
1324  void ReplaceAllUsesWith(SDNode *From, SDNode *To);
1325  void ReplaceAllUsesWith(SDNode *From, const SDValue *To);
1326 
1327  /// Replace any uses of From with To, leaving
1328  /// uses of other values produced by From.getNode() alone.
1329  void ReplaceAllUsesOfValueWith(SDValue From, SDValue To);
1330 
1331  /// Like ReplaceAllUsesOfValueWith, but for multiple values at once.
1332  /// This correctly handles the case where
1333  /// there is an overlap between the From values and the To values.
1334  void ReplaceAllUsesOfValuesWith(const SDValue *From, const SDValue *To,
1335  unsigned Num);
1336 
1337  /// If an existing load has uses of its chain, create a token factor node with
1338  /// that chain and the new memory node's chain and update users of the old
1339  /// chain to the token factor. This ensures that the new memory node will have
1340  /// the same relative memory dependency position as the old load. Returns the
1341  /// new merged load chain.
1342  SDValue makeEquivalentMemoryOrdering(LoadSDNode *Old, SDValue New);
1343 
1344  /// Topological-sort the AllNodes list and a
1345  /// assign a unique node id for each node in the DAG based on their
1346  /// topological order. Returns the number of nodes.
1347  unsigned AssignTopologicalOrder();
1348 
1349  /// Move node N in the AllNodes list to be immediately
1350  /// before the given iterator Position. This may be used to update the
1351  /// topological ordering when the list of nodes is modified.
1353  AllNodes.insert(Position, AllNodes.remove(N));
1354  }
1355 
1356  /// Returns an APFloat semantics tag appropriate for the given type. If VT is
1357  /// a vector type, the element semantics are returned.
1359  switch (VT.getScalarType().getSimpleVT().SimpleTy) {
1360  default: llvm_unreachable("Unknown FP format");
1361  case MVT::f16: return APFloat::IEEEhalf();
1362  case MVT::f32: return APFloat::IEEEsingle();
1363  case MVT::f64: return APFloat::IEEEdouble();
1364  case MVT::f80: return APFloat::x87DoubleExtended();
1365  case MVT::f128: return APFloat::IEEEquad();
1366  case MVT::ppcf128: return APFloat::PPCDoubleDouble();
1367  }
1368  }
1369 
1370  /// Add a dbg_value SDNode. If SD is non-null that means the
1371  /// value is produced by SD.
1372  void AddDbgValue(SDDbgValue *DB, SDNode *SD, bool isParameter);
1373 
1374  /// Add a dbg_label SDNode.
1375  void AddDbgLabel(SDDbgLabel *DB);
1376 
1377  /// Get the debug values which reference the given SDNode.
1378  ArrayRef<SDDbgValue*> GetDbgValues(const SDNode* SD) const {
1379  return DbgInfo->getSDDbgValues(SD);
1380  }
1381 
1382 public:
1383  /// Return true if there are any SDDbgValue nodes associated
1384  /// with this SelectionDAG.
1385  bool hasDebugValues() const { return !DbgInfo->empty(); }
1386 
1387  SDDbgInfo::DbgIterator DbgBegin() const { return DbgInfo->DbgBegin(); }
1388  SDDbgInfo::DbgIterator DbgEnd() const { return DbgInfo->DbgEnd(); }
1389 
1391  return DbgInfo->ByvalParmDbgBegin();
1392  }
1394  return DbgInfo->ByvalParmDbgEnd();
1395  }
1396 
1398  return DbgInfo->DbgLabelBegin();
1399  }
1401  return DbgInfo->DbgLabelEnd();
1402  }
1403 
1404  /// To be invoked on an SDNode that is slated to be erased. This
1405  /// function mirrors \c llvm::salvageDebugInfo.
1406  void salvageDebugInfo(SDNode &N);
1407 
1408  void dump() const;
1409 
1410  /// Create a stack temporary, suitable for holding the specified value type.
1411  /// If minAlign is specified, the slot size will have at least that alignment.
1412  SDValue CreateStackTemporary(EVT VT, unsigned minAlign = 1);
1413 
1414  /// Create a stack temporary suitable for holding either of the specified
1415  /// value types.
1416  SDValue CreateStackTemporary(EVT VT1, EVT VT2);
1417 
1418  SDValue FoldSymbolOffset(unsigned Opcode, EVT VT,
1419  const GlobalAddressSDNode *GA,
1420  const SDNode *N2);
1421 
1422  SDValue FoldConstantArithmetic(unsigned Opcode, const SDLoc &DL, EVT VT,
1423  SDNode *N1, SDNode *N2);
1424 
1425  SDValue FoldConstantArithmetic(unsigned Opcode, const SDLoc &DL, EVT VT,
1426  const ConstantSDNode *C1,
1427  const ConstantSDNode *C2);
1428 
1429  SDValue FoldConstantVectorArithmetic(unsigned Opcode, const SDLoc &DL, EVT VT,
1430  ArrayRef<SDValue> Ops,
1431  const SDNodeFlags Flags = SDNodeFlags());
1432 
1433  /// Fold floating-point operations with 2 operands when both operands are
1434  /// constants and/or undefined.
1435  SDValue foldConstantFPMath(unsigned Opcode, const SDLoc &DL, EVT VT,
1436  SDValue N1, SDValue N2);
1437 
1438  /// Constant fold a setcc to true or false.
1439  SDValue FoldSetCC(EVT VT, SDValue N1, SDValue N2, ISD::CondCode Cond,
1440  const SDLoc &dl);
1441 
1442  /// See if the specified operand can be simplified with the knowledge that
1443  /// only the bits specified by DemandedBits are used. If so, return the
1444  /// simpler operand, otherwise return a null SDValue.
1445  ///
1446  /// (This exists alongside SimplifyDemandedBits because GetDemandedBits can
1447  /// simplify nodes with multiple uses more aggressively.)
1448  SDValue GetDemandedBits(SDValue V, const APInt &DemandedBits);
1449 
1450  /// See if the specified operand can be simplified with the knowledge that
1451  /// only the bits specified by DemandedBits are used in the elements specified
1452  /// by DemandedElts. If so, return the simpler operand, otherwise return a
1453  /// null SDValue.
1454  ///
1455  /// (This exists alongside SimplifyDemandedBits because GetDemandedBits can
1456  /// simplify nodes with multiple uses more aggressively.)
1457  SDValue GetDemandedBits(SDValue V, const APInt &DemandedBits,
1458  const APInt &DemandedElts);
1459 
1460  /// Return true if the sign bit of Op is known to be zero.
1461  /// We use this predicate to simplify operations downstream.
1462  bool SignBitIsZero(SDValue Op, unsigned Depth = 0) const;
1463 
1464  /// Return true if 'Op & Mask' is known to be zero. We
1465  /// use this predicate to simplify operations downstream. Op and Mask are
1466  /// known to be the same type.
1467  bool MaskedValueIsZero(SDValue Op, const APInt &Mask,
1468  unsigned Depth = 0) const;
1469 
1470  /// Return true if 'Op & Mask' is known to be zero in DemandedElts. We
1471  /// use this predicate to simplify operations downstream. Op and Mask are
1472  /// known to be the same type.
1473  bool MaskedValueIsZero(SDValue Op, const APInt &Mask,
1474  const APInt &DemandedElts, unsigned Depth = 0) const;
1475 
1476  /// Return true if '(Op & Mask) == Mask'.
1477  /// Op and Mask are known to be the same type.
1478  bool MaskedValueIsAllOnes(SDValue Op, const APInt &Mask,
1479  unsigned Depth = 0) const;
1480 
1481  /// Determine which bits of Op are known to be either zero or one and return
1482  /// them in Known. For vectors, the known bits are those that are shared by
1483  /// every vector element.
1484  /// Targets can implement the computeKnownBitsForTargetNode method in the
1485  /// TargetLowering class to allow target nodes to be understood.
1486  KnownBits computeKnownBits(SDValue Op, unsigned Depth = 0) const;
1487 
1488  /// Determine which bits of Op are known to be either zero or one and return
1489  /// them in Known. The DemandedElts argument allows us to only collect the
1490  /// known bits that are shared by the requested vector elements.
1491  /// Targets can implement the computeKnownBitsForTargetNode method in the
1492  /// TargetLowering class to allow target nodes to be understood.
1493  KnownBits computeKnownBits(SDValue Op, const APInt &DemandedElts,
1494  unsigned Depth = 0) const;
1495 
1496  /// Used to represent the possible overflow behavior of an operation.
1497  /// Never: the operation cannot overflow.
1498  /// Always: the operation will always overflow.
1499  /// Sometime: the operation may or may not overflow.
1504  };
1505 
1506  /// Determine if the result of the addition of 2 node can overflow.
1507  OverflowKind computeOverflowKind(SDValue N0, SDValue N1) const;
1508 
1509  /// Test if the given value is known to have exactly one bit set. This differs
1510  /// from computeKnownBits in that it doesn't necessarily determine which bit
1511  /// is set.
1512  bool isKnownToBeAPowerOfTwo(SDValue Val) const;
1513 
1514  /// Return the number of times the sign bit of the register is replicated into
1515  /// the other bits. We know that at least 1 bit is always equal to the sign
1516  /// bit (itself), but other cases can give us information. For example,
1517  /// immediately after an "SRA X, 2", we know that the top 3 bits are all equal
1518  /// to each other, so we return 3. Targets can implement the
1519  /// ComputeNumSignBitsForTarget method in the TargetLowering class to allow
1520  /// target nodes to be understood.
1521  unsigned ComputeNumSignBits(SDValue Op, unsigned Depth = 0) const;
1522 
1523  /// Return the number of times the sign bit of the register is replicated into
1524  /// the other bits. We know that at least 1 bit is always equal to the sign
1525  /// bit (itself), but other cases can give us information. For example,
1526  /// immediately after an "SRA X, 2", we know that the top 3 bits are all equal
1527  /// to each other, so we return 3. The DemandedElts argument allows
1528  /// us to only collect the minimum sign bits of the requested vector elements.
1529  /// Targets can implement the ComputeNumSignBitsForTarget method in the
1530  /// TargetLowering class to allow target nodes to be understood.
1531  unsigned ComputeNumSignBits(SDValue Op, const APInt &DemandedElts,
1532  unsigned Depth = 0) const;
1533 
1534  /// Return true if the specified operand is an ISD::ADD with a ConstantSDNode
1535  /// on the right-hand side, or if it is an ISD::OR with a ConstantSDNode that
1536  /// is guaranteed to have the same semantics as an ADD. This handles the
1537  /// equivalence:
1538  /// X|Cst == X+Cst iff X&Cst = 0.
1539  bool isBaseWithConstantOffset(SDValue Op) const;
1540 
1541  /// Test whether the given SDValue is known to never be NaN. If \p SNaN is
1542  /// true, returns if \p Op is known to never be a signaling NaN (it may still
1543  /// be a qNaN).
1544  bool isKnownNeverNaN(SDValue Op, bool SNaN = false, unsigned Depth = 0) const;
1545 
1546  /// \returns true if \p Op is known to never be a signaling NaN.
1547  bool isKnownNeverSNaN(SDValue Op, unsigned Depth = 0) const {
1548  return isKnownNeverNaN(Op, true, Depth);
1549  }
1550 
1551  /// Test whether the given floating point SDValue is known to never be
1552  /// positive or negative zero.
1553  bool isKnownNeverZeroFloat(SDValue Op) const;
1554 
1555  /// Test whether the given SDValue is known to contain non-zero value(s).
1556  bool isKnownNeverZero(SDValue Op) const;
1557 
1558  /// Test whether two SDValues are known to compare equal. This
1559  /// is true if they are the same value, or if one is negative zero and the
1560  /// other positive zero.
1561  bool isEqualTo(SDValue A, SDValue B) const;
1562 
1563  /// Return true if A and B have no common bits set. As an example, this can
1564  /// allow an 'add' to be transformed into an 'or'.
1565  bool haveNoCommonBitsSet(SDValue A, SDValue B) const;
1566 
1567  /// Test whether \p V has a splatted value for all the demanded elements.
1568  ///
1569  /// On success \p UndefElts will indicate the elements that have UNDEF
1570  /// values instead of the splat value, this is only guaranteed to be correct
1571  /// for \p DemandedElts.
1572  ///
1573  /// NOTE: The function will return true for a demanded splat of UNDEF values.
1574  bool isSplatValue(SDValue V, const APInt &DemandedElts, APInt &UndefElts);
1575 
1576  /// Test whether \p V has a splatted value.
1577  bool isSplatValue(SDValue V, bool AllowUndefs = false);
1578 
1579  /// If V is a splatted value, return the source vector and its splat index.
1580  SDValue getSplatSourceVector(SDValue V, int &SplatIndex);
1581 
1582  /// If V is a splat vector, return its scalar source operand by extracting
1583  /// that element from the source vector.
1585 
1586  /// Match a binop + shuffle pyramid that represents a horizontal reduction
1587  /// over the elements of a vector starting from the EXTRACT_VECTOR_ELT node /p
1588  /// Extract. The reduction must use one of the opcodes listed in /p
1589  /// CandidateBinOps and on success /p BinOp will contain the matching opcode.
1590  /// Returns the vector that is being reduced on, or SDValue() if a reduction
1591  /// was not matched.
1592  SDValue matchBinOpReduction(SDNode *Extract, ISD::NodeType &BinOp,
1593  ArrayRef<ISD::NodeType> CandidateBinOps);
1594 
1595  /// Utility function used by legalize and lowering to
1596  /// "unroll" a vector operation by splitting out the scalars and operating
1597  /// on each element individually. If the ResNE is 0, fully unroll the vector
1598  /// op. If ResNE is less than the width of the vector op, unroll up to ResNE.
1599  /// If the ResNE is greater than the width of the vector op, unroll the
1600  /// vector op and fill the end of the resulting vector with UNDEFS.
1601  SDValue UnrollVectorOp(SDNode *N, unsigned ResNE = 0);
1602 
1603  /// Like UnrollVectorOp(), but for the [US](ADD|SUB|MUL)O family of opcodes.
1604  /// This is a separate function because those opcodes have two results.
1605  std::pair<SDValue, SDValue> UnrollVectorOverflowOp(SDNode *N,
1606  unsigned ResNE = 0);
1607 
1608  /// Return true if loads are next to each other and can be
1609  /// merged. Check that both are nonvolatile and if LD is loading
1610  /// 'Bytes' bytes from a location that is 'Dist' units away from the
1611  /// location that the 'Base' load is loading from.
1612  bool areNonVolatileConsecutiveLoads(LoadSDNode *LD, LoadSDNode *Base,
1613  unsigned Bytes, int Dist) const;
1614 
1615  /// Infer alignment of a load / store address. Return 0 if
1616  /// it cannot be inferred.
1617  unsigned InferPtrAlignment(SDValue Ptr) const;
1618 
1619  /// Compute the VTs needed for the low/hi parts of a type
1620  /// which is split (or expanded) into two not necessarily identical pieces.
1621  std::pair<EVT, EVT> GetSplitDestVTs(const EVT &VT) const;
1622 
1623  /// Split the vector with EXTRACT_SUBVECTOR using the provides
1624  /// VTs and return the low/high part.
1625  std::pair<SDValue, SDValue> SplitVector(const SDValue &N, const SDLoc &DL,
1626  const EVT &LoVT, const EVT &HiVT);
1627 
1628  /// Split the vector with EXTRACT_SUBVECTOR and return the low/high part.
1629  std::pair<SDValue, SDValue> SplitVector(const SDValue &N, const SDLoc &DL) {
1630  EVT LoVT, HiVT;
1631  std::tie(LoVT, HiVT) = GetSplitDestVTs(N.getValueType());
1632  return SplitVector(N, DL, LoVT, HiVT);
1633  }
1634 
1635  /// Split the node's operand with EXTRACT_SUBVECTOR and
1636  /// return the low/high part.
1637  std::pair<SDValue, SDValue> SplitVectorOperand(const SDNode *N, unsigned OpNo)
1638  {
1639  return SplitVector(N->getOperand(OpNo), SDLoc(N));
1640  }
1641 
1642  /// Widen the vector up to the next power of two using INSERT_SUBVECTOR.
1643  SDValue WidenVector(const SDValue &N, const SDLoc &DL);
1644 
1645  /// Append the extracted elements from Start to Count out of the vector Op
1646  /// in Args. If Count is 0, all of the elements will be extracted.
1647  void ExtractVectorElements(SDValue Op, SmallVectorImpl<SDValue> &Args,
1648  unsigned Start = 0, unsigned Count = 0);
1649 
1650  /// Compute the default alignment value for the given type.
1651  unsigned getEVTAlignment(EVT MemoryVT) const;
1652 
1653  /// Test whether the given value is a constant int or similar node.
1654  SDNode *isConstantIntBuildVectorOrConstantInt(SDValue N);
1655 
1656  /// Test whether the given value is a constant FP or similar node.
1658 
1659  /// \returns true if \p N is any kind of constant or build_vector of
1660  /// constants, int or float. If a vector, it may not necessarily be a splat.
1662  return isConstantIntBuildVectorOrConstantInt(N) ||
1664  }
1665 
1666  void addCallSiteInfo(const SDNode *CallNode, CallSiteInfoImpl &&CallInfo) {
1667  SDCallSiteInfo[CallNode] = std::move(CallInfo);
1668  }
1669 
1670  CallSiteInfo getSDCallSiteInfo(const SDNode *CallNode) {
1671  auto I = SDCallSiteInfo.find(CallNode);
1672  if (I != SDCallSiteInfo.end())
1673  return std::move(I->second);
1674  return CallSiteInfo();
1675  }
1676 
1677 private:
1678  void InsertNode(SDNode *N);
1679  bool RemoveNodeFromCSEMaps(SDNode *N);
1680  void AddModifiedNodeToCSEMaps(SDNode *N);
1681  SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op, void *&InsertPos);
1682  SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op1, SDValue Op2,
1683  void *&InsertPos);
1684  SDNode *FindModifiedNodeSlot(SDNode *N, ArrayRef<SDValue> Ops,
1685  void *&InsertPos);
1686  SDNode *UpdateSDLocOnMergeSDNode(SDNode *N, const SDLoc &loc);
1687 
1688  void DeleteNodeNotInCSEMaps(SDNode *N);
1689  void DeallocateNode(SDNode *N);
1690 
1691  void allnodes_clear();
1692 
1693  /// Look up the node specified by ID in CSEMap. If it exists, return it. If
1694  /// not, return the insertion token that will make insertion faster. This
1695  /// overload is for nodes other than Constant or ConstantFP, use the other one
1696  /// for those.
1697  SDNode *FindNodeOrInsertPos(const FoldingSetNodeID &ID, void *&InsertPos);
1698 
1699  /// Look up the node specified by ID in CSEMap. If it exists, return it. If
1700  /// not, return the insertion token that will make insertion faster. Performs
1701  /// additional processing for constant nodes.
1702  SDNode *FindNodeOrInsertPos(const FoldingSetNodeID &ID, const SDLoc &DL,
1703  void *&InsertPos);
1704 
1705  /// List of non-single value types.
1706  FoldingSet<SDVTListNode> VTListMap;
1707 
1708  /// Maps to auto-CSE operations.
1709  std::vector<CondCodeSDNode*> CondCodeNodes;
1710 
1711  std::vector<SDNode*> ValueTypeNodes;
1712  std::map<EVT, SDNode*, EVT::compareRawBits> ExtendedValueTypeNodes;
1713  StringMap<SDNode*> ExternalSymbols;
1714 
1715  std::map<std::pair<std::string, unsigned char>,SDNode*> TargetExternalSymbols;
1717 };
1718 
1719 template <> struct GraphTraits<SelectionDAG*> : public GraphTraits<SDNode*> {
1721 
1723  return nodes_iterator(G->allnodes_begin());
1724  }
1725 
1727  return nodes_iterator(G->allnodes_end());
1728  }
1729 };
1730 
1731 template <class TargetMemSDNode>
1733  ArrayRef<SDValue> Ops,
1734  const SDLoc &dl, EVT MemVT,
1735  MachineMemOperand *MMO) {
1736  /// Compose node ID and try to find an existing node.
1738  unsigned Opcode =
1739  TargetMemSDNode(dl.getIROrder(), DebugLoc(), VTs, MemVT, MMO).getOpcode();
1740  ID.AddInteger(Opcode);
1741  ID.AddPointer(VTs.VTs);
1742  for (auto& Op : Ops) {
1743  ID.AddPointer(Op.getNode());
1744  ID.AddInteger(Op.getResNo());
1745  }
1746  ID.AddInteger(MemVT.getRawBits());
1747  ID.AddInteger(MMO->getPointerInfo().getAddrSpace());
1748  ID.AddInteger(getSyntheticNodeSubclassData<TargetMemSDNode>(
1749  dl.getIROrder(), VTs, MemVT, MMO));
1750 
1751  void *IP = nullptr;
1752  if (SDNode *E = FindNodeOrInsertPos(ID, dl, IP)) {
1753  cast<TargetMemSDNode>(E)->refineAlignment(MMO);
1754  return SDValue(E, 0);
1755  }
1756 
1757  /// Existing node was not found. Create a new one.
1758  auto *N = newSDNode<TargetMemSDNode>(dl.getIROrder(), dl.getDebugLoc(), VTs,
1759  MemVT, MMO);
1760  createOperands(N, Ops);
1761  CSEMap.InsertNode(N, IP);
1762  InsertNode(N);
1763  return SDValue(N, 0);
1764 }
1765 
1766 } // end namespace llvm
1767 
1768 #endif // LLVM_CODEGEN_SELECTIONDAG_H
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:80
uint64_t CallInst * C
static const fltSemantics & IEEEquad() LLVM_READNONE
Definition: APFloat.cpp:161
void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, OptimizationRemarkEmitter *ORE=nullptr, bool UseInstrInfo=true)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
void AddPointer(const void *Ptr)
Add* - Add various data types to Bit data.
Definition: FoldingSet.cpp:51
void add(SDDbgLabel *L)
Definition: SelectionDAG.h:168
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:110
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
EVT getValueType() const
Return the ValueType of the referenced return value.
OverflowKind
Used to represent the possible overflow behavior of an operation.
static MSP430CC::CondCodes getCondCode(unsigned Cond)
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT, SDValue Glue)
Definition: SelectionDAG.h:724
static APInt getAllOnesValue(unsigned numBits)
Get the all-ones value.
Definition: APInt.h:561
const TargetLibraryInfo & getLibInfo() const
Definition: SelectionDAG.h:411
LLVMContext & Context
Keeps track of dbg_value information through SDISel.
Definition: SelectionDAG.h:147
SDValue getSetCC(const SDLoc &DL, EVT VT, SDValue LHS, SDValue RHS, ISD::CondCode Cond)
Helper function to make it easier to build SetCC&#39;s if you just have an ISD::CondCode instead of an SD...
Definition: SelectionDAG.h:957
SDValue getCALLSEQ_END(SDValue Chain, SDValue Op1, SDValue Op2, SDValue InGlue, const SDLoc &DL)
Return a new CALLSEQ_END node, which always must have a glue result (to ensure it&#39;s not CSE&#39;d)...
Definition: SelectionDAG.h:856
Atomic ordering constants.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
static void removeOperands(MachineInstr &MI, unsigned i)
EVT getScalarType() const
If this is a vector type, return the element type, otherwise return this.
Definition: ValueTypes.h:259
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
DbgIterator ByvalParmDbgEnd()
Definition: SelectionDAG.h:203
const Value * getSplatValue(const Value *V)
Get splat value if the input is a splat vector or return nullptr.
Implements a dense probed hash-table based set.
Definition: DenseSet.h:249
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
Clients of various APIs that cause global effects on the DAG can optionally implement this interface...
Definition: SelectionDAG.h:283
unsigned Reg
This file contains the declarations for metadata subclasses.
MVT getSimpleVT() const
Return the SimpleValueType held in the specified simple EVT.
Definition: ValueTypes.h:252
ArrayRef< SDDbgValue * > getSDDbgValues(const SDNode *Node) const
Definition: SelectionDAG.h:190
static bool Equals(const SDVTListNode &X, const FoldingSetNodeID &ID, unsigned IDHash, FoldingSetNodeID &TempID)
Definition: SelectionDAG.h:118
bool salvageDebugInfo(Instruction &I)
Assuming the instruction I is going to be deleted, attempt to salvage debug users of I by writing the...
Definition: Local.cpp:1630
static const fltSemantics & EVTToAPFloatSemantics(EVT VT)
Returns an APFloat semantics tag appropriate for the given type.
Recycle small arrays allocated from a BumpPtrAllocator.
Definition: ArrayRecycler.h:28
SDValue getTargetConstantFP(const ConstantFP &Val, const SDLoc &DL, EVT VT)
Definition: SelectionDAG.h:624
A debug info location.
Definition: DebugLoc.h:33
Metadata node.
Definition: Metadata.h:863
bool isInteger() const
Return true if this is an integer or a vector integer type.
Definition: ValueTypes.h:140
SDValue getSelect(const SDLoc &DL, EVT VT, SDValue Cond, SDValue LHS, SDValue RHS)
Helper function to make it easier to build Select&#39;s if you just have operands and don&#39;t want to check...
Definition: SelectionDAG.h:970
DbgIterator DbgBegin()
Definition: SelectionDAG.h:200
SDDbgInfo::DbgLabelIterator DbgLabelBegin() const
SDNode * getNode() const
get the SDNode which holds the desired result
const SDValue & setRoot(SDValue N)
Set the current root tag of the SelectionDAG.
Definition: SelectionDAG.h:473
SmallVectorImpl< SDDbgLabel * >::iterator DbgLabelIterator
Definition: SelectionDAG.h:198
The address of the GOT.
Definition: ISDOpcodes.h:65
Select with condition operator - This selects between a true value and a false value (ops #2 and #3) ...
Definition: ISDOpcodes.h:459
NodeType
ISD::NodeType enum - This enum defines the target-independent operators for a SelectionDAG.
Definition: ISDOpcodes.h:38
This file defines the MallocAllocator and BumpPtrAllocator interfaces.
This SDNode is used to implement the code generator support for the llvm IR shufflevector instruction...
unsigned getAddrSpace() const
Return the LLVM IR address space number that this pointer points into.
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
The address of a basic block.
Definition: Constants.h:839
A description of a memory reference used in the backend.
Definition: BitVector.h:937
bool isKnownToBeAPowerOfTwo(const Value *V, const DataLayout &DL, bool OrZero=false, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if the given value is known to have exactly one bit set when defined. ...
SDDbgInfo::DbgIterator DbgEnd() const
SDValue getTargetConstantFP(const APFloat &Val, const SDLoc &DL, EVT VT)
Definition: SelectionDAG.h:621
void Reset()
Deallocate all but the current slab and reset the current pointer to the beginning of it...
Definition: Allocator.h:194
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:450
CallSiteInfo getSDCallSiteInfo(const SDNode *CallNode)
static Optional< unsigned > getOpcode(ArrayRef< VPValue *> Values)
Returns the opcode of Values or ~0 if they do not all agree.
Definition: VPlanSLP.cpp:196
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:41
CopyToReg - This node has three operands: a chain, a register number to set to this value...
Definition: ISDOpcodes.h:169
SimpleValueType SimpleTy
bool MaskedValueIsZero(const Value *V, const APInt &Mask, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if &#39;V & Mask&#39; is known to be zero.
CALLSEQ_START/CALLSEQ_END - These operators mark the beginning and end of a call sequence, and carry arbitrary information that target might want to know.
Definition: ISDOpcodes.h:744
void AddInteger(signed I)
Definition: FoldingSet.cpp:60
SmallVectorImpl< SDDbgValue * >::iterator DbgIterator
Definition: SelectionDAG.h:197
SDValue getEntryNode() const
Return the token chain corresponding to the entry of the function.
Definition: SelectionDAG.h:467
const DataLayout & getDataLayout() const
Definition: SelectionDAG.h:407
SmallVectorImpl< ArgRegPair > CallSiteInfoImpl
void setFunctionLoweringInfo(FunctionLoweringInfo *FuncInfo)
Definition: SelectionDAG.h:396
SDValue getTargetConstant(const ConstantInt &Val, const SDLoc &DL, EVT VT, bool isOpaque=false)
Definition: SelectionDAG.h:594
Position
Position to insert a new instruction relative to an existing instruction.
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
This file implements a class to represent arbitrary precision integral constant values and operations...
This represents a list of ValueType&#39;s that has been intern&#39;d by a SelectionDAG.
iterator_range< allnodes_iterator > allnodes()
Definition: SelectionDAG.h:456
static int64_t getConstant(const MachineInstr *MI)
void InsertNode(T *N, void *InsertPos)
InsertNode - Insert the specified node into the folding set, knowing that it is not already in the fo...
Definition: FoldingSet.h:451
unsigned getScalarSizeInBits() const
Definition: ValueTypes.h:297
void checkForCycles(const SelectionDAG *DAG, bool force=false)
MachineFunction & getMachineFunction() const
Definition: SelectionDAG.h:404
DAGUpdateListener *const Next
Definition: SelectionDAG.h:284
SDValue getTargetFrameIndex(int FI, EVT VT)
Definition: SelectionDAG.h:638
const TargetMachine & getTarget() const
Definition: SelectionDAG.h:408
Select with a vector condition (op #0) and two vector operands (ops #1 and #2), returning a vector re...
Definition: ISDOpcodes.h:453
Simple integer binary arithmetic operators.
Definition: ISDOpcodes.h:200
bool isSplatValue(const Value *V, unsigned Depth=0)
Return true if the input value is known to be a vector with all identical elements (potentially inclu...
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
SDValue getUNDEF(EVT VT)
Return an UNDEF node. UNDEF does not have a useful SDLoc.
Definition: SelectionDAG.h:872
CondCode
ISD::CondCode enum - These are ordered carefully to make the bitfields below work out...
Definition: ISDOpcodes.h:995
static const fltSemantics & IEEEdouble() LLVM_READNONE
Definition: APFloat.cpp:158
SDValue getTargetConstant(uint64_t Val, const SDLoc &DL, EVT VT, bool isOpaque=false)
Definition: SelectionDAG.h:586
allnodes_iterator allnodes_end()
Definition: SelectionDAG.h:450
SDValue getSplatBuildVector(EVT VT, const SDLoc &DL, SDValue Op)
Return a splat ISD::BUILD_VECTOR node, consisting of Op splatted to all elements. ...
Definition: SelectionDAG.h:761
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
SDDbgInfo::DbgIterator DbgBegin() const
allnodes_iterator allnodes_begin()
Definition: SelectionDAG.h:449
SDValue getTargetConstantFP(double Val, const SDLoc &DL, EVT VT)
Definition: SelectionDAG.h:618
static SDValue WidenVector(SDValue V64Reg, SelectionDAG &DAG)
WidenVector - Given a value in the V64 register class, produce the equivalent value in the V128 regis...
const DataLayout & getDataLayout() const
Return the DataLayout attached to the Module associated to this MF.
SDValue getBuildVector(EVT VT, const SDLoc &DL, ArrayRef< SDUse > Ops)
Return an ISD::BUILD_VECTOR node.
Definition: SelectionDAG.h:753
UNDEF - An undefined node.
Definition: ISDOpcodes.h:177
BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a vector with the specified, possibly variable...
Definition: ISDOpcodes.h:351
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:176
unsigned ComputeHash() const
ComputeHash - Compute a strong hash value for this FoldingSetNodeIDRef, used to lookup the node in th...
Definition: FoldingSet.cpp:29
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:305
BumpPtrAllocatorImpl BumpPtrAllocator
The standard BumpPtrAllocator which just uses the default template parameters.
Definition: Allocator.h:434
Use delete by default for iplist and ilist.
Definition: ilist.h:40
unsigned ComputeNumSignBits(const Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return the number of times the sign bit of the register is replicated into the other bits...
DAGNodeDeletedListener(SelectionDAG &DAG, std::function< void(SDNode *, SDNode *)> Callback)
Definition: SelectionDAG.h:312
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:432
FoldingSetTrait - This trait class is used to define behavior of how to "profile" (in the FoldingSet ...
Definition: FoldingSet.h:249
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
static nodes_iterator nodes_begin(SelectionDAG *G)
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
const SelectionDAGTargetInfo & getSelectionDAGInfo() const
Definition: SelectionDAG.h:412
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:140
unsigned getVectorNumElements() const
Given a vector type, return the number of elements it contains.
Definition: ValueTypes.h:272
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:41
bool hasDebugValues() const
Return true if there are any SDDbgValue nodes associated with this SelectionDAG.
const SDValue & getOperand(unsigned Num) const
LoadExtType
LoadExtType enum - This enum defines the three variants of LOADEXT (load with extension).
Definition: ISDOpcodes.h:970
bool bitsLE(EVT VT) const
Return true if this has no more bits than VT.
Definition: ValueTypes.h:246
DbgLabelIterator DbgLabelEnd()
Definition: SelectionDAG.h:205
bool empty() const
Definition: SelectionDAG.h:186
bool isKnownNeverSNaN(SDValue Op, unsigned Depth=0) const
const LegacyDivergenceAnalysis * getDivergenceAnalysis() const
Definition: SelectionDAG.h:413
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:263
SDValue getCALLSEQ_START(SDValue Chain, uint64_t InSize, uint64_t OutSize, const SDLoc &DL)
Return a new CALLSEQ_START node, that starts new call frame, in which InSize bytes are set up inside ...
Definition: SelectionDAG.h:844
std::pair< SDValue, SDValue > SplitVectorOperand(const SDNode *N, unsigned OpNo)
Split the node&#39;s operand with EXTRACT_SUBVECTOR and return the low/high part.
CombineLevel
Definition: DAGCombine.h:15
This file declares a class to represent arbitrary precision floating point values and provide a varie...
BumpPtrAllocator & getAlloc()
Definition: SelectionDAG.h:184
void RepositionNode(allnodes_iterator Position, SDNode *N)
Move node N in the AllNodes list to be immediately before the given iterator Position.
SDDbgInfo::DbgIterator ByvalParmDbgEnd() const
Base class for variables.
static const fltSemantics & x87DoubleExtended() LLVM_READNONE
Definition: APFloat.cpp:164
std::pair< SDValue, SDValue > SplitVector(const SDValue &N, const SDLoc &DL)
Split the vector with EXTRACT_SUBVECTOR and return the low/high part.
Targets can subclass this to parameterize the SelectionDAG lowering and instruction selection process...
const Pass * getPass() const
Definition: SelectionDAG.h:405
Extended Value Type.
Definition: ValueTypes.h:33
Abstract base class for all machine specific constantpool value subclasses.
SDValue getTargetConstantPool(MachineConstantPoolValue *C, EVT VT, unsigned Align=0, int Offset=0, unsigned char TargetFlags=0)
Definition: SelectionDAG.h:657
SDValue getAllOnesConstant(const SDLoc &DL, EVT VT, bool IsTarget=false, bool IsOpaque=false)
Definition: SelectionDAG.h:573
static Constant * simplifyFPBinop(Value *Op0, Value *Op1)
iterator_range< allnodes_const_iterator > allnodes() const
Definition: SelectionDAG.h:459
SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, unsigned Reg, SDValue N, SDValue Glue)
Definition: SelectionDAG.h:698
An intrusive list with ownership and callbacks specified/controlled by ilist_traits, only with API safe for polymorphic types.
Definition: ilist.h:388
This class contains a discriminated union of information about pointers in memory operands...
FoldingSet - This template class is used to instantiate a specialized implementation of the folding s...
Definition: FoldingSet.h:473
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
SmallVector< ArgRegPair, 1 > CallSiteInfo
Vector of call argument and its forwarding register.
The memory access writes data.
SDValue getObjectPtrOffset(const SDLoc &SL, SDValue Op, SDValue Offset)
Definition: SelectionDAG.h:831
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
SDValue getTargetConstantPool(const Constant *C, EVT VT, unsigned Align=0, int Offset=0, unsigned char TargetFlags=0)
Definition: SelectionDAG.h:649
SDValue getTargetJumpTable(int JTI, EVT VT, unsigned char TargetFlags=0)
Definition: SelectionDAG.h:643
static bool isUndef(ArrayRef< int > Mask)
static const fltSemantics & IEEEsingle() LLVM_READNONE
Definition: APFloat.cpp:155
Basic Register Allocator
const TargetLowering & getTargetLoweringInfo() const
Definition: SelectionDAG.h:410
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:297
Iterator for intrusive lists based on ilist_node.
void setNoUnsignedWrap(bool b)
This is the shared class of boolean and integer constants.
Definition: Constants.h:83
Color
A "color", which is either even or odd.
BlockVerifier::State From
static const fltSemantics & IEEEhalf() LLVM_READNONE
Definition: APFloat.cpp:152
ilist< SDNode >::size_type allnodes_size() const
Definition: SelectionDAG.h:452
EVT getVectorElementType() const
Given a vector type, return the type of each element.
Definition: ValueTypes.h:264
static nodes_iterator nodes_end(SelectionDAG *G)
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:221
SDValue getTargetMemSDNode(SDVTList VTs, ArrayRef< SDValue > Ops, const SDLoc &dl, EVT MemVT, MachineMemOperand *MMO)
Return (create a new or find existing) a target-specific node.
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
SDValue getBuildVector(EVT VT, const SDLoc &DL, ArrayRef< SDValue > Ops)
Return an ISD::BUILD_VECTOR node.
Definition: SelectionDAG.h:744
Provides information about what library functions are available for the current target.
void addCallSiteInfo(const SDNode *CallNode, CallSiteInfoImpl &&CallInfo)
const DebugLoc & getDebugLoc() const
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
An SDNode that represents everything that will be needed to construct a MachineInstr.
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:643
Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation funct...
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
Represents one node in the SelectionDAG.
DbgIterator DbgEnd()
Definition: SelectionDAG.h:201
allnodes_const_iterator allnodes_begin() const
Definition: SelectionDAG.h:444
SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, unsigned Reg, SDValue N)
Definition: SelectionDAG.h:689
DWARF expression.
A range adaptor for a pair of iterators.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:219
Class for arbitrary precision integers.
Definition: APInt.h:69
std::function< void(SDNode *, SDNode *)> Callback
Definition: SelectionDAG.h:310
Select(COND, TRUEVAL, FALSEVAL).
Definition: ISDOpcodes.h:444
typename SuperClass::iterator iterator
Definition: SmallVector.h:319
SDDbgInfo::DbgLabelIterator DbgLabelEnd() const
static void clear(coro::Shape &Shape)
Definition: Coroutines.cpp:211
Flags
Flags values. These may be or&#39;d together.
AlignedCharArrayUnion< AtomicSDNode, TargetIndexSDNode, BlockAddressSDNode, GlobalAddressSDNode > LargestSDNode
A representation of the largest SDNode, for use in sizeof().
The memory access reads data.
TargetSubtargetInfo - Generic base class for all target subtargets.
bool isConstantValueOfAnyType(SDValue N)
SDValue getTargetConstant(const APInt &Val, const SDLoc &DL, EVT VT, bool isOpaque=false)
Definition: SelectionDAG.h:590
std::map< const SDNode *, std::string > NodeGraphAttrs
Definition: SelectionDAG.h:422
static const fltSemantics & PPCDoubleDouble() LLVM_READNONE
Definition: APFloat.cpp:170
These are IR-level optimization flags that may be propagated to SDNodes.
allnodes_const_iterator allnodes_end() const
Definition: SelectionDAG.h:445
SDValue getTargetBlockAddress(const BlockAddress *BA, EVT VT, int64_t Offset=0, unsigned char TargetFlags=0)
Definition: SelectionDAG.h:683
SDVTListNode(const FoldingSetNodeIDRef ID, const EVT *VT, unsigned int Num)
Definition: SelectionDAG.h:100
const MachinePointerInfo & getPointerInfo() const
bool isVector() const
Return true if this is a vector value type.
Definition: ValueTypes.h:150
FoldingSetNodeIDRef - This class describes a reference to an interned FoldingSetNodeID, which can be a useful to store node id data rather than using plain FoldingSetNodeIDs, since the 32-element SmallVector is often much larger than necessary, and the possibility of heap allocation means it requires a non-trivial destructor call.
Definition: FoldingSet.h:277
Holds the information from a dbg_label node through SDISel.
SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT)
Definition: SelectionDAG.h:715
Node - This class is used to maintain the singly linked bucket list in a folding set.
Definition: FoldingSet.h:135
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:55
static unsigned ComputeHash(const SDVTListNode &X, FoldingSetNodeID &TempID)
Definition: SelectionDAG.h:125
#define I(x, y, z)
Definition: MD5.cpp:58
bool haveNoCommonBitsSet(const Value *LHS, const Value *RHS, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Return true if LHS and RHS have no common bits set.
#define N
const TargetSubtargetInfo & getSubtarget() const
Definition: SelectionDAG.h:409
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
FunctionLoweringInfo - This contains information that is global to a function that is used when lower...
iterator end()
Definition: DenseMap.h:108
SDDbgInfo::DbgIterator ByvalParmDbgBegin() const
uint32_t Size
Definition: Profile.cpp:46
unsigned getOpcode() const
bool isKnownNeverNaN(const Value *V, const TargetLibraryInfo *TLI, unsigned Depth=0)
Return true if the floating-point scalar value is not a NaN or if the floating-point vector value has...
SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, SDValue Reg, SDValue N, SDValue Glue)
Definition: SelectionDAG.h:707
CopyFromReg - This node indicates that the input value is a virtual or physical register that is defi...
Definition: ISDOpcodes.h:174
const SDValue & getRoot() const
Return the root tag of the SelectionDAG.
Definition: SelectionDAG.h:464
SDValue getGLOBAL_OFFSET_TABLE(EVT VT)
Return a GLOBAL_OFFSET_TABLE node. This does not have a useful SDLoc.
Definition: SelectionDAG.h:877
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:72
SDValue getSelectCC(const SDLoc &DL, SDValue LHS, SDValue RHS, SDValue True, SDValue False, ISD::CondCode Cond)
Helper function to make it easier to build SelectCC&#39;s if you just have an ISD::CondCode instead of an...
Definition: SelectionDAG.h:982
SDVTList getSDVTList()
Definition: SelectionDAG.h:105
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E&#39;s largest value.
Definition: BitmaskEnum.h:80
DefaultFoldingSetTrait - This class provides default implementations for FoldingSetTrait implementati...
Definition: FoldingSet.h:220
OptimizationRemarkEmitter & getORE() const
Definition: SelectionDAG.h:415
static void deleteNode(SDNode *)
Definition: SelectionDAG.h:131
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:65
void add(SDDbgValue *V, const SDNode *Node, bool isParameter)
Definition: SelectionDAG.h:160
void deallocate(Capacity Cap, T *Ptr)
Deallocate an array with the specified Capacity.
print Print MemDeps of function
ArrayRef< SDDbgValue * > GetDbgValues(const SDNode *SD) const
Get the debug values which reference the given SDNode.
SetCC operator - This evaluates to a true value iff the condition is true.
Definition: ISDOpcodes.h:467
static SDNode * isConstantFPBuildVectorOrConstantFP(SDValue N)
DbgIterator ByvalParmDbgBegin()
Definition: SelectionDAG.h:202
SDValue getObjectPtrOffset(const SDLoc &SL, SDValue Op, int64_t Offset)
Create an add instruction with appropriate flags when used for addressing some offset of an object...
Definition: SelectionDAG.h:826
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation...
Holds the information from a dbg_value node through SDISel.
static void Profile(const SDVTListNode &X, FoldingSetNodeID &ID)
Definition: SelectionDAG.h:114
DbgLabelIterator DbgLabelBegin()
Definition: SelectionDAG.h:204
The optimization diagnostic interface.
void NodeDeleted(SDNode *N, SDNode *E) override
The node N that was deleted and, if E is not null, an equivalent node E that replaced it...
Definition: SelectionDAG.h:316
LLVMContext * getContext() const
Definition: SelectionDAG.h:414
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
unsigned getIROrder() const
SDValue getTargetGlobalAddress(const GlobalValue *GV, const SDLoc &DL, EVT VT, int64_t offset=0, unsigned char TargetFlags=0)
Definition: SelectionDAG.h:632
MemIndexedMode
MemIndexedMode enum - This enum defines the load / store indexed addressing modes.
Definition: ISDOpcodes.h:950
This class is used to represent ISD::LOAD nodes.