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