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