LLVM 19.0.0git
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"
24#include "llvm/ADT/StringMap.h"
25#include "llvm/ADT/ilist.h"
26#include "llvm/ADT/iterator.h"
35#include "llvm/IR/DebugLoc.h"
36#include "llvm/IR/Metadata.h"
42#include <cassert>
43#include <cstdint>
44#include <functional>
45#include <map>
46#include <string>
47#include <tuple>
48#include <utility>
49#include <vector>
50
51namespace llvm {
52
53class DIExpression;
54class DILabel;
55class DIVariable;
56class Function;
57class Pass;
58class Type;
59template <class GraphType> struct GraphTraits;
60template <typename T, unsigned int N> class SmallSetVector;
61template <typename T, typename Enable> struct FoldingSetTrait;
62class AAResults;
63class BlockAddress;
64class BlockFrequencyInfo;
65class Constant;
66class ConstantFP;
67class ConstantInt;
68class DataLayout;
69struct fltSemantics;
70class FunctionLoweringInfo;
71class FunctionVarLocs;
72class GlobalValue;
73struct KnownBits;
74class LLVMContext;
75class MachineBasicBlock;
76class MachineConstantPoolValue;
77class MCSymbol;
78class OptimizationRemarkEmitter;
79class ProfileSummaryInfo;
80class SDDbgValue;
81class SDDbgOperand;
82class SDDbgLabel;
83class SelectionDAG;
84class SelectionDAGTargetInfo;
85class TargetLibraryInfo;
86class TargetLowering;
87class TargetMachine;
88class TargetSubtargetInfo;
89class Value;
90
91template <typename T> class GenericSSAContext;
92using SSAContext = GenericSSAContext<Function>;
93template <typename T> class GenericUniformityInfo;
94using UniformityInfo = GenericUniformityInfo<SSAContext>;
95
97 friend struct FoldingSetTrait<SDVTListNode>;
98
99 /// A reference to an Interned FoldingSetNodeID for this node.
100 /// The Allocator in SelectionDAG holds the data.
101 /// SDVTList contains all types which are frequently accessed in SelectionDAG.
102 /// The size of this list is not expected to be big so it won't introduce
103 /// a memory penalty.
104 FoldingSetNodeIDRef FastID;
105 const EVT *VTs;
106 unsigned int NumVTs;
107 /// The hash value for SDVTList is fixed, so cache it to avoid
108 /// hash calculation.
109 unsigned HashValue;
110
111public:
112 SDVTListNode(const FoldingSetNodeIDRef ID, const EVT *VT, unsigned int Num) :
113 FastID(ID), VTs(VT), NumVTs(Num) {
114 HashValue = ID.ComputeHash();
115 }
116
118 SDVTList result = {VTs, NumVTs};
119 return result;
120 }
121};
122
123/// Specialize FoldingSetTrait for SDVTListNode
124/// to avoid computing temp FoldingSetNodeID and hash value.
125template<> struct FoldingSetTrait<SDVTListNode> : DefaultFoldingSetTrait<SDVTListNode> {
126 static void Profile(const SDVTListNode &X, FoldingSetNodeID& ID) {
127 ID = X.FastID;
128 }
129
130 static bool Equals(const SDVTListNode &X, const FoldingSetNodeID &ID,
131 unsigned IDHash, FoldingSetNodeID &TempID) {
132 if (X.HashValue != IDHash)
133 return false;
134 return ID == X.FastID;
135 }
136
137 static unsigned ComputeHash(const SDVTListNode &X, FoldingSetNodeID &TempID) {
138 return X.HashValue;
139 }
140};
141
142template <> struct ilist_alloc_traits<SDNode> {
143 static void deleteNode(SDNode *) {
144 llvm_unreachable("ilist_traits<SDNode> shouldn't see a deleteNode call!");
145 }
146};
147
148/// Keeps track of dbg_value information through SDISel. We do
149/// not build SDNodes for these so as not to perturb the generated code;
150/// instead the info is kept off to the side in this structure. Each SDNode may
151/// have one or more associated dbg_value entries. This information is kept in
152/// DbgValMap.
153/// Byval parameters are handled separately because they don't use alloca's,
154/// which busts the normal mechanism. There is good reason for handling all
155/// parameters separately: they may not have code generated for them, they
156/// should always go at the beginning of the function regardless of other code
157/// motion, and debug info for them is potentially useful even if the parameter
158/// is unused. Right now only byval parameters are handled separately.
160 BumpPtrAllocator Alloc;
162 SmallVector<SDDbgValue*, 32> ByvalParmDbgValues;
165 DbgValMapType DbgValMap;
166
167public:
168 SDDbgInfo() = default;
169 SDDbgInfo(const SDDbgInfo &) = delete;
170 SDDbgInfo &operator=(const SDDbgInfo &) = delete;
171
172 void add(SDDbgValue *V, bool isParameter);
173
174 void add(SDDbgLabel *L) { DbgLabels.push_back(L); }
175
176 /// Invalidate all DbgValues attached to the node and remove
177 /// it from the Node-to-DbgValues map.
178 void erase(const SDNode *Node);
179
180 void clear() {
181 DbgValMap.clear();
182 DbgValues.clear();
183 ByvalParmDbgValues.clear();
184 DbgLabels.clear();
185 Alloc.Reset();
186 }
187
188 BumpPtrAllocator &getAlloc() { return Alloc; }
189
190 bool empty() const {
191 return DbgValues.empty() && ByvalParmDbgValues.empty() && DbgLabels.empty();
192 }
193
195 auto I = DbgValMap.find(Node);
196 if (I != DbgValMap.end())
197 return I->second;
198 return ArrayRef<SDDbgValue*>();
199 }
200
203
204 DbgIterator DbgBegin() { return DbgValues.begin(); }
205 DbgIterator DbgEnd() { return DbgValues.end(); }
206 DbgIterator ByvalParmDbgBegin() { return ByvalParmDbgValues.begin(); }
207 DbgIterator ByvalParmDbgEnd() { return ByvalParmDbgValues.end(); }
208 DbgLabelIterator DbgLabelBegin() { return DbgLabels.begin(); }
209 DbgLabelIterator DbgLabelEnd() { return DbgLabels.end(); }
210};
211
212void checkForCycles(const SelectionDAG *DAG, bool force = false);
213
214/// This is used to represent a portion of an LLVM function in a low-level
215/// Data Dependence DAG representation suitable for instruction selection.
216/// This DAG is constructed as the first step of instruction selection in order
217/// to allow implementation of machine specific optimizations
218/// and code simplifications.
219///
220/// The representation used by the SelectionDAG is a target-independent
221/// representation, which has some similarities to the GCC RTL representation,
222/// but is significantly more simple, powerful, and is a graph form instead of a
223/// linear form.
224///
226 const TargetMachine &TM;
227 const SelectionDAGTargetInfo *TSI = nullptr;
228 const TargetLowering *TLI = nullptr;
229 const TargetLibraryInfo *LibInfo = nullptr;
230 const FunctionVarLocs *FnVarLocs = nullptr;
231 MachineFunction *MF;
232 Pass *SDAGISelPass = nullptr;
233 LLVMContext *Context;
234 CodeGenOptLevel OptLevel;
235
236 UniformityInfo *UA = nullptr;
237 FunctionLoweringInfo * FLI = nullptr;
238
239 /// The function-level optimization remark emitter. Used to emit remarks
240 /// whenever manipulating the DAG.
242
243 ProfileSummaryInfo *PSI = nullptr;
244 BlockFrequencyInfo *BFI = nullptr;
245
246 /// List of non-single value types.
247 FoldingSet<SDVTListNode> VTListMap;
248
249 /// Pool allocation for misc. objects that are created once per SelectionDAG.
250 BumpPtrAllocator Allocator;
251
252 /// The starting token.
253 SDNode EntryNode;
254
255 /// The root of the entire DAG.
256 SDValue Root;
257
258 /// A linked list of nodes in the current DAG.
259 ilist<SDNode> AllNodes;
260
261 /// The AllocatorType for allocating SDNodes. We use
262 /// pool allocation with recycling.
264 sizeof(LargestSDNode),
265 alignof(MostAlignedSDNode)>;
266
267 /// Pool allocation for nodes.
268 NodeAllocatorType NodeAllocator;
269
270 /// This structure is used to memoize nodes, automatically performing
271 /// CSE with existing nodes when a duplicate is requested.
272 FoldingSet<SDNode> CSEMap;
273
274 /// Pool allocation for machine-opcode SDNode operands.
275 BumpPtrAllocator OperandAllocator;
276 ArrayRecycler<SDUse> OperandRecycler;
277
278 /// Tracks dbg_value and dbg_label information through SDISel.
279 SDDbgInfo *DbgInfo;
280
282
283 struct NodeExtraInfo {
284 CallSiteInfo CSInfo;
285 MDNode *HeapAllocSite = nullptr;
286 MDNode *PCSections = nullptr;
287 bool NoMerge = false;
288 };
289 /// Out-of-line extra information for SDNodes.
291
292 /// PersistentId counter to be used when inserting the next
293 /// SDNode to this SelectionDAG. We do not place that under
294 /// `#if LLVM_ENABLE_ABI_BREAKING_CHECKS` intentionally because
295 /// it adds unneeded complexity without noticeable
296 /// benefits (see discussion with @thakis in D120714).
297 uint16_t NextPersistentId = 0;
298
299public:
300 /// Clients of various APIs that cause global effects on
301 /// the DAG can optionally implement this interface. This allows the clients
302 /// to handle the various sorts of updates that happen.
303 ///
304 /// A DAGUpdateListener automatically registers itself with DAG when it is
305 /// constructed, and removes itself when destroyed in RAII fashion.
309
311 : Next(D.UpdateListeners), DAG(D) {
312 DAG.UpdateListeners = this;
313 }
314
316 assert(DAG.UpdateListeners == this &&
317 "DAGUpdateListeners must be destroyed in LIFO order");
318 DAG.UpdateListeners = Next;
319 }
320
321 /// The node N that was deleted and, if E is not null, an
322 /// equivalent node E that replaced it.
323 virtual void NodeDeleted(SDNode *N, SDNode *E);
324
325 /// The node N that was updated.
326 virtual void NodeUpdated(SDNode *N);
327
328 /// The node N that was inserted.
329 virtual void NodeInserted(SDNode *N);
330 };
331
333 std::function<void(SDNode *, SDNode *)> Callback;
334
336 std::function<void(SDNode *, SDNode *)> Callback)
338
339 void NodeDeleted(SDNode *N, SDNode *E) override { Callback(N, E); }
340
341 private:
342 virtual void anchor();
343 };
344
346 std::function<void(SDNode *)> Callback;
347
349 std::function<void(SDNode *)> Callback)
351
352 void NodeInserted(SDNode *N) override { Callback(N); }
353
354 private:
355 virtual void anchor();
356 };
357
358 /// Help to insert SDNodeFlags automatically in transforming. Use
359 /// RAII to save and resume flags in current scope.
361 SelectionDAG &DAG;
362 SDNodeFlags Flags;
363 FlagInserter *LastInserter;
364
365 public:
367 : DAG(SDAG), Flags(Flags),
368 LastInserter(SDAG.getFlagInserter()) {
369 SDAG.setFlagInserter(this);
370 }
372 : FlagInserter(SDAG, N->getFlags()) {}
373
374 FlagInserter(const FlagInserter &) = delete;
376 ~FlagInserter() { DAG.setFlagInserter(LastInserter); }
377
378 SDNodeFlags getFlags() const { return Flags; }
379 };
380
381 /// When true, additional steps are taken to
382 /// ensure that getConstant() and similar functions return DAG nodes that
383 /// have legal types. This is important after type legalization since
384 /// any illegally typed nodes generated after this point will not experience
385 /// type legalization.
387
388private:
389 /// DAGUpdateListener is a friend so it can manipulate the listener stack.
390 friend struct DAGUpdateListener;
391
392 /// Linked list of registered DAGUpdateListener instances.
393 /// This stack is maintained by DAGUpdateListener RAII.
394 DAGUpdateListener *UpdateListeners = nullptr;
395
396 /// Implementation of setSubgraphColor.
397 /// Return whether we had to truncate the search.
398 bool setSubgraphColorHelper(SDNode *N, const char *Color,
399 DenseSet<SDNode *> &visited,
400 int level, bool &printed);
401
402 template <typename SDNodeT, typename... ArgTypes>
403 SDNodeT *newSDNode(ArgTypes &&... Args) {
404 return new (NodeAllocator.template Allocate<SDNodeT>())
405 SDNodeT(std::forward<ArgTypes>(Args)...);
406 }
407
408 /// Build a synthetic SDNodeT with the given args and extract its subclass
409 /// data as an integer (e.g. for use in a folding set).
410 ///
411 /// The args to this function are the same as the args to SDNodeT's
412 /// constructor, except the second arg (assumed to be a const DebugLoc&) is
413 /// omitted.
414 template <typename SDNodeT, typename... ArgTypes>
415 static uint16_t getSyntheticNodeSubclassData(unsigned IROrder,
416 ArgTypes &&... Args) {
417 // The compiler can reduce this expression to a constant iff we pass an
418 // empty DebugLoc. Thankfully, the debug location doesn't have any bearing
419 // on the subclass data.
420 return SDNodeT(IROrder, DebugLoc(), std::forward<ArgTypes>(Args)...)
421 .getRawSubclassData();
422 }
423
424 template <typename SDNodeTy>
425 static uint16_t getSyntheticNodeSubclassData(unsigned Opc, unsigned Order,
426 SDVTList VTs, EVT MemoryVT,
427 MachineMemOperand *MMO) {
428 return SDNodeTy(Opc, Order, DebugLoc(), VTs, MemoryVT, MMO)
429 .getRawSubclassData();
430 }
431
432 void createOperands(SDNode *Node, ArrayRef<SDValue> Vals);
433
434 void removeOperands(SDNode *Node) {
435 if (!Node->OperandList)
436 return;
437 OperandRecycler.deallocate(
439 Node->OperandList);
440 Node->NumOperands = 0;
441 Node->OperandList = nullptr;
442 }
443 void CreateTopologicalOrder(std::vector<SDNode*>& Order);
444
445public:
446 // Maximum depth for recursive analysis such as computeKnownBits, etc.
447 static constexpr unsigned MaxRecursionDepth = 6;
448
450 SelectionDAG(const SelectionDAG &) = delete;
453
454 /// Prepare this SelectionDAG to process code in the given MachineFunction.
456 Pass *PassPtr, const TargetLibraryInfo *LibraryInfo,
458 BlockFrequencyInfo *BFIin, FunctionVarLocs const *FnVarLocs);
459
461 FLI = FuncInfo;
462 }
463
464 /// Clear state and free memory necessary to make this
465 /// SelectionDAG ready to process a new block.
466 void clear();
467
468 MachineFunction &getMachineFunction() const { return *MF; }
469 const Pass *getPass() const { return SDAGISelPass; }
470
471 const DataLayout &getDataLayout() const { return MF->getDataLayout(); }
472 const TargetMachine &getTarget() const { return TM; }
473 const TargetSubtargetInfo &getSubtarget() const { return MF->getSubtarget(); }
474 template <typename STC> const STC &getSubtarget() const {
475 return MF->getSubtarget<STC>();
476 }
477 const TargetLowering &getTargetLoweringInfo() const { return *TLI; }
478 const TargetLibraryInfo &getLibInfo() const { return *LibInfo; }
479 const SelectionDAGTargetInfo &getSelectionDAGInfo() const { return *TSI; }
480 const UniformityInfo *getUniformityInfo() const { return UA; }
481 /// Returns the result of the AssignmentTrackingAnalysis pass if it's
482 /// available, otherwise return nullptr.
483 const FunctionVarLocs *getFunctionVarLocs() const { return FnVarLocs; }
484 LLVMContext *getContext() const { return Context; }
485 OptimizationRemarkEmitter &getORE() const { return *ORE; }
486 ProfileSummaryInfo *getPSI() const { return PSI; }
487 BlockFrequencyInfo *getBFI() const { return BFI; }
488
489 FlagInserter *getFlagInserter() { return Inserter; }
490 void setFlagInserter(FlagInserter *FI) { Inserter = FI; }
491
492 /// Just dump dot graph to a user-provided path and title.
493 /// This doesn't open the dot viewer program and
494 /// helps visualization when outside debugging session.
495 /// FileName expects absolute path. If provided
496 /// without any path separators then the file
497 /// will be created in the current directory.
498 /// Error will be emitted if the path is insane.
499#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
500 LLVM_DUMP_METHOD void dumpDotGraph(const Twine &FileName, const Twine &Title);
501#endif
502
503 /// Pop up a GraphViz/gv window with the DAG rendered using 'dot'.
504 void viewGraph(const std::string &Title);
505 void viewGraph();
506
507#if LLVM_ENABLE_ABI_BREAKING_CHECKS
508 std::map<const SDNode *, std::string> NodeGraphAttrs;
509#endif
510
511 /// Clear all previously defined node graph attributes.
512 /// Intended to be used from a debugging tool (eg. gdb).
513 void clearGraphAttrs();
514
515 /// Set graph attributes for a node. (eg. "color=red".)
516 void setGraphAttrs(const SDNode *N, const char *Attrs);
517
518 /// Get graph attributes for a node. (eg. "color=red".)
519 /// Used from getNodeAttributes.
520 std::string getGraphAttrs(const SDNode *N) const;
521
522 /// Convenience for setting node color attribute.
523 void setGraphColor(const SDNode *N, const char *Color);
524
525 /// Convenience for setting subgraph color attribute.
526 void setSubgraphColor(SDNode *N, const char *Color);
527
529
530 allnodes_const_iterator allnodes_begin() const { return AllNodes.begin(); }
531 allnodes_const_iterator allnodes_end() const { return AllNodes.end(); }
532
534
535 allnodes_iterator allnodes_begin() { return AllNodes.begin(); }
536 allnodes_iterator allnodes_end() { return AllNodes.end(); }
537
539 return AllNodes.size();
540 }
541
544 }
547 }
548
549 /// Return the root tag of the SelectionDAG.
550 const SDValue &getRoot() const { return Root; }
551
552 /// Return the token chain corresponding to the entry of the function.
554 return SDValue(const_cast<SDNode *>(&EntryNode), 0);
555 }
556
557 /// Set the current root tag of the SelectionDAG.
558 ///
560 assert((!N.getNode() || N.getValueType() == MVT::Other) &&
561 "DAG root value is not a chain!");
562 if (N.getNode())
563 checkForCycles(N.getNode(), this);
564 Root = N;
565 if (N.getNode())
566 checkForCycles(this);
567 return Root;
568 }
569
570#ifndef NDEBUG
571 void VerifyDAGDivergence();
572#endif
573
574 /// This iterates over the nodes in the SelectionDAG, folding
575 /// certain types of nodes together, or eliminating superfluous nodes. The
576 /// Level argument controls whether Combine is allowed to produce nodes and
577 /// types that are illegal on the target.
578 void Combine(CombineLevel Level, AAResults *AA, CodeGenOptLevel OptLevel);
579
580 /// This transforms the SelectionDAG into a SelectionDAG that
581 /// only uses types natively supported by the target.
582 /// Returns "true" if it made any changes.
583 ///
584 /// Note that this is an involved process that may invalidate pointers into
585 /// the graph.
586 bool LegalizeTypes();
587
588 /// This transforms the SelectionDAG into a SelectionDAG that is
589 /// compatible with the target instruction selector, as indicated by the
590 /// TargetLowering object.
591 ///
592 /// Note that this is an involved process that may invalidate pointers into
593 /// the graph.
594 void Legalize();
595
596 /// Transforms a SelectionDAG node and any operands to it into a node
597 /// that is compatible with the target instruction selector, as indicated by
598 /// the TargetLowering object.
599 ///
600 /// \returns true if \c N is a valid, legal node after calling this.
601 ///
602 /// This essentially runs a single recursive walk of the \c Legalize process
603 /// over the given node (and its operands). This can be used to incrementally
604 /// legalize the DAG. All of the nodes which are directly replaced,
605 /// potentially including N, are added to the output parameter \c
606 /// UpdatedNodes so that the delta to the DAG can be understood by the
607 /// caller.
608 ///
609 /// When this returns false, N has been legalized in a way that make the
610 /// pointer passed in no longer valid. It may have even been deleted from the
611 /// DAG, and so it shouldn't be used further. When this returns true, the
612 /// N passed in is a legal node, and can be immediately processed as such.
613 /// This may still have done some work on the DAG, and will still populate
614 /// UpdatedNodes with any new nodes replacing those originally in the DAG.
615 bool LegalizeOp(SDNode *N, SmallSetVector<SDNode *, 16> &UpdatedNodes);
616
617 /// This transforms the SelectionDAG into a SelectionDAG
618 /// that only uses vector math operations supported by the target. This is
619 /// necessary as a separate step from Legalize because unrolling a vector
620 /// operation can introduce illegal types, which requires running
621 /// LegalizeTypes again.
622 ///
623 /// This returns true if it made any changes; in that case, LegalizeTypes
624 /// is called again before Legalize.
625 ///
626 /// Note that this is an involved process that may invalidate pointers into
627 /// the graph.
628 bool LegalizeVectors();
629
630 /// This method deletes all unreachable nodes in the SelectionDAG.
631 void RemoveDeadNodes();
632
633 /// Remove the specified node from the system. This node must
634 /// have no referrers.
635 void DeleteNode(SDNode *N);
636
637 /// Return an SDVTList that represents the list of values specified.
639 SDVTList getVTList(EVT VT1, EVT VT2);
640 SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3);
641 SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4);
643
644 //===--------------------------------------------------------------------===//
645 // Node creation methods.
646
647 /// Create a ConstantSDNode wrapping a constant value.
648 /// If VT is a vector type, the constant is splatted into a BUILD_VECTOR.
649 ///
650 /// If only legal types can be produced, this does the necessary
651 /// transformations (e.g., if the vector element type is illegal).
652 /// @{
653 SDValue getConstant(uint64_t Val, const SDLoc &DL, EVT VT,
654 bool isTarget = false, bool isOpaque = false);
655 SDValue getConstant(const APInt &Val, const SDLoc &DL, EVT VT,
656 bool isTarget = false, bool isOpaque = false);
657
658 SDValue getAllOnesConstant(const SDLoc &DL, EVT VT, bool IsTarget = false,
659 bool IsOpaque = false) {
661 IsTarget, IsOpaque);
662 }
663
664 SDValue getConstant(const ConstantInt &Val, const SDLoc &DL, EVT VT,
665 bool isTarget = false, bool isOpaque = false);
667 bool isTarget = false);
669 bool LegalTypes = true);
670 SDValue getShiftAmountConstant(const APInt &Val, EVT VT, const SDLoc &DL,
671 bool LegalTypes = true);
673 bool isTarget = false);
674
676 bool isOpaque = false) {
677 return getConstant(Val, DL, VT, true, isOpaque);
678 }
679 SDValue getTargetConstant(const APInt &Val, const SDLoc &DL, EVT VT,
680 bool isOpaque = false) {
681 return getConstant(Val, DL, VT, true, isOpaque);
682 }
684 bool isOpaque = false) {
685 return getConstant(Val, DL, VT, true, isOpaque);
686 }
687
688 /// Create a true or false constant of type \p VT using the target's
689 /// BooleanContent for type \p OpVT.
690 SDValue getBoolConstant(bool V, const SDLoc &DL, EVT VT, EVT OpVT);
691 /// @}
692
693 /// Create a ConstantFPSDNode wrapping a constant value.
694 /// If VT is a vector type, the constant is splatted into a BUILD_VECTOR.
695 ///
696 /// If only legal types can be produced, this does the necessary
697 /// transformations (e.g., if the vector element type is illegal).
698 /// The forms that take a double should only be used for simple constants
699 /// that can be exactly represented in VT. No checks are made.
700 /// @{
701 SDValue getConstantFP(double Val, const SDLoc &DL, EVT VT,
702 bool isTarget = false);
703 SDValue getConstantFP(const APFloat &Val, const SDLoc &DL, EVT VT,
704 bool isTarget = false);
705 SDValue getConstantFP(const ConstantFP &V, const SDLoc &DL, EVT VT,
706 bool isTarget = false);
707 SDValue getTargetConstantFP(double Val, const SDLoc &DL, EVT VT) {
708 return getConstantFP(Val, DL, VT, true);
709 }
710 SDValue getTargetConstantFP(const APFloat &Val, const SDLoc &DL, EVT VT) {
711 return getConstantFP(Val, DL, VT, true);
712 }
714 return getConstantFP(Val, DL, VT, true);
715 }
716 /// @}
717
718 SDValue getGlobalAddress(const GlobalValue *GV, const SDLoc &DL, EVT VT,
719 int64_t offset = 0, bool isTargetGA = false,
720 unsigned TargetFlags = 0);
722 int64_t offset = 0, unsigned TargetFlags = 0) {
723 return getGlobalAddress(GV, DL, VT, offset, true, TargetFlags);
724 }
725 SDValue getFrameIndex(int FI, EVT VT, bool isTarget = false);
727 return getFrameIndex(FI, VT, true);
728 }
729 SDValue getJumpTable(int JTI, EVT VT, bool isTarget = false,
730 unsigned TargetFlags = 0);
731 SDValue getTargetJumpTable(int JTI, EVT VT, unsigned TargetFlags = 0) {
732 return getJumpTable(JTI, VT, true, TargetFlags);
733 }
734 SDValue getJumpTableDebugInfo(int JTI, SDValue Chain, const SDLoc &DL);
736 MaybeAlign Align = std::nullopt, int Offs = 0,
737 bool isT = false, unsigned TargetFlags = 0);
739 MaybeAlign Align = std::nullopt, int Offset = 0,
740 unsigned TargetFlags = 0) {
741 return getConstantPool(C, VT, Align, Offset, true, TargetFlags);
742 }
744 MaybeAlign Align = std::nullopt, int Offs = 0,
745 bool isT = false, unsigned TargetFlags = 0);
747 MaybeAlign Align = std::nullopt, int Offset = 0,
748 unsigned TargetFlags = 0) {
749 return getConstantPool(C, VT, Align, Offset, true, TargetFlags);
750 }
751 // When generating a branch to a BB, we don't in general know enough
752 // to provide debug info for the BB at that time, so keep this one around.
754 SDValue getExternalSymbol(const char *Sym, EVT VT);
755 SDValue getTargetExternalSymbol(const char *Sym, EVT VT,
756 unsigned TargetFlags = 0);
758
760 SDValue getRegister(unsigned Reg, EVT VT);
761 SDValue getRegisterMask(const uint32_t *RegMask);
762 SDValue getEHLabel(const SDLoc &dl, SDValue Root, MCSymbol *Label);
763 SDValue getLabelNode(unsigned Opcode, const SDLoc &dl, SDValue Root,
764 MCSymbol *Label);
765 SDValue getBlockAddress(const BlockAddress *BA, EVT VT, int64_t Offset = 0,
766 bool isTarget = false, unsigned TargetFlags = 0);
768 int64_t Offset = 0, unsigned TargetFlags = 0) {
769 return getBlockAddress(BA, VT, Offset, true, TargetFlags);
770 }
771
772 SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, unsigned Reg,
773 SDValue N) {
774 return getNode(ISD::CopyToReg, dl, MVT::Other, Chain,
775 getRegister(Reg, N.getValueType()), N);
776 }
777
778 // This version of the getCopyToReg method takes an extra operand, which
779 // indicates that there is potentially an incoming glue value (if Glue is not
780 // null) and that there should be a glue result.
781 SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, unsigned Reg, SDValue N,
782 SDValue Glue) {
783 SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
784 SDValue Ops[] = { Chain, getRegister(Reg, N.getValueType()), N, Glue };
785 return getNode(ISD::CopyToReg, dl, VTs,
786 ArrayRef(Ops, Glue.getNode() ? 4 : 3));
787 }
788
789 // Similar to last getCopyToReg() except parameter Reg is a SDValue
791 SDValue Glue) {
792 SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
793 SDValue Ops[] = { Chain, Reg, N, Glue };
794 return getNode(ISD::CopyToReg, dl, VTs,
795 ArrayRef(Ops, Glue.getNode() ? 4 : 3));
796 }
797
798 SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT) {
799 SDVTList VTs = getVTList(VT, MVT::Other);
800 SDValue Ops[] = { Chain, getRegister(Reg, VT) };
801 return getNode(ISD::CopyFromReg, dl, VTs, Ops);
802 }
803
804 // This version of the getCopyFromReg method takes an extra operand, which
805 // indicates that there is potentially an incoming glue value (if Glue is not
806 // null) and that there should be a glue result.
807 SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT,
808 SDValue Glue) {
809 SDVTList VTs = getVTList(VT, MVT::Other, MVT::Glue);
810 SDValue Ops[] = { Chain, getRegister(Reg, VT), Glue };
811 return getNode(ISD::CopyFromReg, dl, VTs,
812 ArrayRef(Ops, Glue.getNode() ? 3 : 2));
813 }
814
816
817 /// Return an ISD::VECTOR_SHUFFLE node. The number of elements in VT,
818 /// which must be a vector type, must match the number of mask elements
819 /// NumElts. An integer mask element equal to -1 is treated as undefined.
820 SDValue getVectorShuffle(EVT VT, const SDLoc &dl, SDValue N1, SDValue N2,
821 ArrayRef<int> Mask);
822
823 /// Return an ISD::BUILD_VECTOR node. The number of elements in VT,
824 /// which must be a vector type, must match the number of operands in Ops.
825 /// The operands must have the same type as (or, for integers, a type wider
826 /// than) VT's element type.
828 // VerifySDNode (via InsertNode) checks BUILD_VECTOR later.
829 return getNode(ISD::BUILD_VECTOR, DL, VT, Ops);
830 }
831
832 /// Return an ISD::BUILD_VECTOR node. The number of elements in VT,
833 /// which must be a vector type, must match the number of operands in Ops.
834 /// The operands must have the same type as (or, for integers, a type wider
835 /// than) VT's element type.
837 // VerifySDNode (via InsertNode) checks BUILD_VECTOR later.
838 return getNode(ISD::BUILD_VECTOR, DL, VT, Ops);
839 }
840
841 /// Return a splat ISD::BUILD_VECTOR node, consisting of Op splatted to all
842 /// elements. VT must be a vector type. Op's type must be the same as (or,
843 /// for integers, a type wider than) VT's element type.
845 // VerifySDNode (via InsertNode) checks BUILD_VECTOR later.
846 if (Op.getOpcode() == ISD::UNDEF) {
847 assert((VT.getVectorElementType() == Op.getValueType() ||
848 (VT.isInteger() &&
849 VT.getVectorElementType().bitsLE(Op.getValueType()))) &&
850 "A splatted value must have a width equal or (for integers) "
851 "greater than the vector element type!");
852 return getNode(ISD::UNDEF, SDLoc(), VT);
853 }
854
856 return getNode(ISD::BUILD_VECTOR, DL, VT, Ops);
857 }
858
859 // Return a splat ISD::SPLAT_VECTOR node, consisting of Op splatted to all
860 // elements.
862 if (Op.getOpcode() == ISD::UNDEF) {
863 assert((VT.getVectorElementType() == Op.getValueType() ||
864 (VT.isInteger() &&
865 VT.getVectorElementType().bitsLE(Op.getValueType()))) &&
866 "A splatted value must have a width equal or (for integers) "
867 "greater than the vector element type!");
868 return getNode(ISD::UNDEF, SDLoc(), VT);
869 }
870 return getNode(ISD::SPLAT_VECTOR, DL, VT, Op);
871 }
872
873 /// Returns a node representing a splat of one value into all lanes
874 /// of the provided vector type. This is a utility which returns
875 /// either a BUILD_VECTOR or SPLAT_VECTOR depending on the
876 /// scalability of the desired vector type.
878 assert(VT.isVector() && "Can't splat to non-vector type");
879 return VT.isScalableVector() ?
881 }
882
883 /// Returns a vector of type ResVT whose elements contain the linear sequence
884 /// <0, Step, Step * 2, Step * 3, ...>
885 SDValue getStepVector(const SDLoc &DL, EVT ResVT, const APInt &StepVal);
886
887 /// Returns a vector of type ResVT whose elements contain the linear sequence
888 /// <0, 1, 2, 3, ...>
889 SDValue getStepVector(const SDLoc &DL, EVT ResVT);
890
891 /// Returns an ISD::VECTOR_SHUFFLE node semantically equivalent to
892 /// the shuffle node in input but with swapped operands.
893 ///
894 /// Example: shuffle A, B, <0,5,2,7> -> shuffle B, A, <4,1,6,3>
896
897 /// Convert Op, which must be of float type, to the
898 /// float type VT, by either extending or rounding (by truncation).
900
901 /// Convert Op, which must be a STRICT operation of float type, to the
902 /// float type VT, by either extending or rounding (by truncation).
903 std::pair<SDValue, SDValue>
905
906 /// Convert *_EXTEND_VECTOR_INREG to *_EXTEND opcode.
907 static unsigned getOpcode_EXTEND(unsigned Opcode) {
908 switch (Opcode) {
909 case ISD::ANY_EXTEND:
911 return ISD::ANY_EXTEND;
912 case ISD::ZERO_EXTEND:
914 return ISD::ZERO_EXTEND;
915 case ISD::SIGN_EXTEND:
917 return ISD::SIGN_EXTEND;
918 }
919 llvm_unreachable("Unknown opcode");
920 }
921
922 /// Convert *_EXTEND to *_EXTEND_VECTOR_INREG opcode.
923 static unsigned getOpcode_EXTEND_VECTOR_INREG(unsigned Opcode) {
924 switch (Opcode) {
925 case ISD::ANY_EXTEND:
928 case ISD::ZERO_EXTEND:
931 case ISD::SIGN_EXTEND:
934 }
935 llvm_unreachable("Unknown opcode");
936 }
937
938 /// Convert Op, which must be of integer type, to the
939 /// integer type VT, by either any-extending or truncating it.
941
942 /// Convert Op, which must be of integer type, to the
943 /// integer type VT, by either sign-extending or truncating it.
945
946 /// Convert Op, which must be of integer type, to the
947 /// integer type VT, by either zero-extending or truncating it.
949
950 /// Convert Op, which must be of integer type, to the
951 /// integer type VT, by either any/sign/zero-extending (depending on IsAny /
952 /// IsSigned) or truncating it.
954 EVT VT, unsigned Opcode) {
955 switch(Opcode) {
956 case ISD::ANY_EXTEND:
957 return getAnyExtOrTrunc(Op, DL, VT);
958 case ISD::ZERO_EXTEND:
959 return getZExtOrTrunc(Op, DL, VT);
960 case ISD::SIGN_EXTEND:
961 return getSExtOrTrunc(Op, DL, VT);
962 }
963 llvm_unreachable("Unsupported opcode");
964 }
965
966 /// Convert Op, which must be of integer type, to the
967 /// integer type VT, by either sign/zero-extending (depending on IsSigned) or
968 /// truncating it.
969 SDValue getExtOrTrunc(bool IsSigned, SDValue Op, const SDLoc &DL, EVT VT) {
970 return IsSigned ? getSExtOrTrunc(Op, DL, VT) : getZExtOrTrunc(Op, DL, VT);
971 }
972
973 /// Convert Op, which must be of integer type, to the
974 /// integer type VT, by first bitcasting (from potential vector) to
975 /// corresponding scalar type then either any-extending or truncating it.
977
978 /// Convert Op, which must be of integer type, to the
979 /// integer type VT, by first bitcasting (from potential vector) to
980 /// corresponding scalar type then either sign-extending or truncating it.
982
983 /// Convert Op, which must be of integer type, to the
984 /// integer type VT, by first bitcasting (from potential vector) to
985 /// corresponding scalar type then either zero-extending or truncating it.
987
988 /// Return the expression required to zero extend the Op
989 /// value assuming it was the smaller SrcTy value.
991
992 /// Convert Op, which must be of integer type, to the integer type VT, by
993 /// either truncating it or performing either zero or sign extension as
994 /// appropriate extension for the pointer's semantics.
996
997 /// Return the expression required to extend the Op as a pointer value
998 /// assuming it was the smaller SrcTy value. This may be either a zero extend
999 /// or a sign extend.
1001
1002 /// Convert Op, which must be of integer type, to the integer type VT,
1003 /// by using an extension appropriate for the target's
1004 /// BooleanContent for type OpVT or truncating it.
1005 SDValue getBoolExtOrTrunc(SDValue Op, const SDLoc &SL, EVT VT, EVT OpVT);
1006
1007 /// Create negative operation as (SUB 0, Val).
1008 SDValue getNegative(SDValue Val, const SDLoc &DL, EVT VT);
1009
1010 /// Create a bitwise NOT operation as (XOR Val, -1).
1011 SDValue getNOT(const SDLoc &DL, SDValue Val, EVT VT);
1012
1013 /// Create a logical NOT operation as (XOR Val, BooleanOne).
1014 SDValue getLogicalNOT(const SDLoc &DL, SDValue Val, EVT VT);
1015
1016 /// Create a vector-predicated logical NOT operation as (VP_XOR Val,
1017 /// BooleanOne, Mask, EVL).
1018 SDValue getVPLogicalNOT(const SDLoc &DL, SDValue Val, SDValue Mask,
1019 SDValue EVL, EVT VT);
1020
1021 /// Convert a vector-predicated Op, which must be an integer vector, to the
1022 /// vector-type VT, by performing either vector-predicated zext or truncating
1023 /// it. The Op will be returned as-is if Op and VT are vectors containing
1024 /// integer with same width.
1026 SDValue EVL);
1027
1028 /// Convert a vector-predicated Op, which must be of integer type, to the
1029 /// vector-type integer type VT, by either truncating it or performing either
1030 /// vector-predicated zero or sign extension as appropriate extension for the
1031 /// pointer's semantics. This function just redirects to getVPZExtOrTrunc
1032 /// right now.
1034 SDValue EVL);
1035
1036 /// Returns sum of the base pointer and offset.
1037 /// Unlike getObjectPtrOffset this does not set NoUnsignedWrap by default.
1039 const SDNodeFlags Flags = SDNodeFlags());
1041 const SDNodeFlags Flags = SDNodeFlags());
1042
1043 /// Create an add instruction with appropriate flags when used for
1044 /// addressing some offset of an object. i.e. if a load is split into multiple
1045 /// components, create an add nuw from the base pointer to the offset.
1047 SDNodeFlags Flags;
1048 Flags.setNoUnsignedWrap(true);
1049 return getMemBasePlusOffset(Ptr, Offset, SL, Flags);
1050 }
1051
1053 // The object itself can't wrap around the address space, so it shouldn't be
1054 // possible for the adds of the offsets to the split parts to overflow.
1055 SDNodeFlags Flags;
1056 Flags.setNoUnsignedWrap(true);
1057 return getMemBasePlusOffset(Ptr, Offset, SL, Flags);
1058 }
1059
1060 /// Return a new CALLSEQ_START node, that starts new call frame, in which
1061 /// InSize bytes are set up inside CALLSEQ_START..CALLSEQ_END sequence and
1062 /// OutSize specifies part of the frame set up prior to the sequence.
1064 const SDLoc &DL) {
1065 SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
1066 SDValue Ops[] = { Chain,
1067 getIntPtrConstant(InSize, DL, true),
1068 getIntPtrConstant(OutSize, DL, true) };
1069 return getNode(ISD::CALLSEQ_START, DL, VTs, Ops);
1070 }
1071
1072 /// Return a new CALLSEQ_END node, which always must have a
1073 /// glue result (to ensure it's not CSE'd).
1074 /// CALLSEQ_END does not have a useful SDLoc.
1076 SDValue InGlue, const SDLoc &DL) {
1077 SDVTList NodeTys = getVTList(MVT::Other, MVT::Glue);
1079 Ops.push_back(Chain);
1080 Ops.push_back(Op1);
1081 Ops.push_back(Op2);
1082 if (InGlue.getNode())
1083 Ops.push_back(InGlue);
1084 return getNode(ISD::CALLSEQ_END, DL, NodeTys, Ops);
1085 }
1086
1088 SDValue Glue, const SDLoc &DL) {
1089 return getCALLSEQ_END(
1090 Chain, getIntPtrConstant(Size1, DL, /*isTarget=*/true),
1091 getIntPtrConstant(Size2, DL, /*isTarget=*/true), Glue, DL);
1092 }
1093
1094 /// Return true if the result of this operation is always undefined.
1095 bool isUndef(unsigned Opcode, ArrayRef<SDValue> Ops);
1096
1097 /// Return an UNDEF node. UNDEF does not have a useful SDLoc.
1099 return getNode(ISD::UNDEF, SDLoc(), VT);
1100 }
1101
1102 /// Return a node that represents the runtime scaling 'MulImm * RuntimeVL'.
1103 SDValue getVScale(const SDLoc &DL, EVT VT, APInt MulImm,
1104 bool ConstantFold = true);
1105
1107 bool ConstantFold = true);
1108
1109 /// Return a GLOBAL_OFFSET_TABLE node. This does not have a useful SDLoc.
1111 return getNode(ISD::GLOBAL_OFFSET_TABLE, SDLoc(), VT);
1112 }
1113
1114 /// Gets or creates the specified node.
1115 ///
1116 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
1117 ArrayRef<SDUse> Ops);
1118 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
1119 ArrayRef<SDValue> Ops, const SDNodeFlags Flags);
1120 SDValue getNode(unsigned Opcode, const SDLoc &DL, ArrayRef<EVT> ResultTys,
1121 ArrayRef<SDValue> Ops);
1122 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList,
1123 ArrayRef<SDValue> Ops, const SDNodeFlags Flags);
1124
1125 // Use flags from current flag inserter.
1126 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
1127 ArrayRef<SDValue> Ops);
1128 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList,
1129 ArrayRef<SDValue> Ops);
1130 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue Operand);
1131 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
1132 SDValue N2);
1133 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
1134 SDValue N2, SDValue N3);
1135
1136 // Specialize based on number of operands.
1137 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT);
1138 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue Operand,
1139 const SDNodeFlags Flags);
1140 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
1141 SDValue N2, const SDNodeFlags Flags);
1142 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
1143 SDValue N2, SDValue N3, const SDNodeFlags Flags);
1144 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
1145 SDValue N2, SDValue N3, SDValue N4);
1146 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
1147 SDValue N2, SDValue N3, SDValue N4, SDValue N5);
1148
1149 // Specialize again based on number of operands for nodes with a VTList
1150 // rather than a single VT.
1151 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList);
1152 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N);
1153 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N1,
1154 SDValue N2);
1155 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N1,
1156 SDValue N2, SDValue N3);
1157 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N1,
1158 SDValue N2, SDValue N3, SDValue N4);
1159 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N1,
1160 SDValue N2, SDValue N3, SDValue N4, SDValue N5);
1161
1162 /// Compute a TokenFactor to force all the incoming stack arguments to be
1163 /// loaded from the stack. This is used in tail call lowering to protect
1164 /// stack arguments from being clobbered.
1166
1167 SDValue getMemcpy(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src,
1168 SDValue Size, Align Alignment, bool isVol,
1169 bool AlwaysInline, bool isTailCall,
1170 MachinePointerInfo DstPtrInfo,
1171 MachinePointerInfo SrcPtrInfo,
1172 const AAMDNodes &AAInfo = AAMDNodes(),
1173 AAResults *AA = nullptr);
1174
1175 SDValue getMemmove(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src,
1176 SDValue Size, Align Alignment, bool isVol, bool isTailCall,
1177 MachinePointerInfo DstPtrInfo,
1178 MachinePointerInfo SrcPtrInfo,
1179 const AAMDNodes &AAInfo = AAMDNodes(),
1180 AAResults *AA = nullptr);
1181
1182 SDValue getMemset(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src,
1183 SDValue Size, Align Alignment, bool isVol,
1184 bool AlwaysInline, bool isTailCall,
1185 MachinePointerInfo DstPtrInfo,
1186 const AAMDNodes &AAInfo = AAMDNodes());
1187
1188 SDValue getAtomicMemcpy(SDValue Chain, const SDLoc &dl, SDValue Dst,
1189 SDValue Src, SDValue Size, Type *SizeTy,
1190 unsigned ElemSz, bool isTailCall,
1191 MachinePointerInfo DstPtrInfo,
1192 MachinePointerInfo SrcPtrInfo);
1193
1194 SDValue getAtomicMemmove(SDValue Chain, const SDLoc &dl, SDValue Dst,
1195 SDValue Src, SDValue Size, Type *SizeTy,
1196 unsigned ElemSz, bool isTailCall,
1197 MachinePointerInfo DstPtrInfo,
1198 MachinePointerInfo SrcPtrInfo);
1199
1200 SDValue getAtomicMemset(SDValue Chain, const SDLoc &dl, SDValue Dst,
1201 SDValue Value, SDValue Size, Type *SizeTy,
1202 unsigned ElemSz, bool isTailCall,
1203 MachinePointerInfo DstPtrInfo);
1204
1205 /// Helper function to make it easier to build SetCC's if you just have an
1206 /// ISD::CondCode instead of an SDValue.
1208 ISD::CondCode Cond, SDValue Chain = SDValue(),
1209 bool IsSignaling = false) {
1210 assert(LHS.getValueType().isVector() == RHS.getValueType().isVector() &&
1211 "Vector/scalar operand type mismatch for setcc");
1212 assert(LHS.getValueType().isVector() == VT.isVector() &&
1213 "Vector/scalar result type mismatch for setcc");
1215 "Cannot create a setCC of an invalid node.");
1216 if (Chain)
1217 return getNode(IsSignaling ? ISD::STRICT_FSETCCS : ISD::STRICT_FSETCC, DL,
1218 {VT, MVT::Other}, {Chain, LHS, RHS, getCondCode(Cond)});
1219 return getNode(ISD::SETCC, DL, VT, LHS, RHS, getCondCode(Cond));
1220 }
1221
1222 /// Helper function to make it easier to build VP_SETCCs if you just have an
1223 /// ISD::CondCode instead of an SDValue.
1225 ISD::CondCode Cond, SDValue Mask, SDValue EVL) {
1226 assert(LHS.getValueType().isVector() && RHS.getValueType().isVector() &&
1227 "Cannot compare scalars");
1229 "Cannot create a setCC of an invalid node.");
1230 return getNode(ISD::VP_SETCC, DL, VT, LHS, RHS, getCondCode(Cond), Mask,
1231 EVL);
1232 }
1233
1234 /// Helper function to make it easier to build Select's if you just have
1235 /// operands and don't want to check for vector.
1237 SDValue RHS) {
1238 assert(LHS.getValueType() == VT && RHS.getValueType() == VT &&
1239 "Cannot use select on differing types");
1240 auto Opcode = Cond.getValueType().isVector() ? ISD::VSELECT : ISD::SELECT;
1241 return getNode(Opcode, DL, VT, Cond, LHS, RHS);
1242 }
1243
1244 /// Helper function to make it easier to build SelectCC's if you just have an
1245 /// ISD::CondCode instead of an SDValue.
1247 SDValue False, ISD::CondCode Cond) {
1248 return getNode(ISD::SELECT_CC, DL, True.getValueType(), LHS, RHS, True,
1249 False, getCondCode(Cond));
1250 }
1251
1252 /// Try to simplify a select/vselect into 1 of its operands or a constant.
1254
1255 /// Try to simplify a shift into 1 of its operands or a constant.
1257
1258 /// Try to simplify a floating-point binary operation into 1 of its operands
1259 /// or a constant.
1260 SDValue simplifyFPBinop(unsigned Opcode, SDValue X, SDValue Y,
1261 SDNodeFlags Flags);
1262
1263 /// VAArg produces a result and token chain, and takes a pointer
1264 /// and a source value as input.
1265 SDValue getVAArg(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
1266 SDValue SV, unsigned Align);
1267
1268 /// Gets a node for an atomic cmpxchg op. There are two
1269 /// valid Opcodes. ISD::ATOMIC_CMO_SWAP produces the value loaded and a
1270 /// chain result. ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS produces the value loaded,
1271 /// a success flag (initially i1), and a chain.
1272 SDValue getAtomicCmpSwap(unsigned Opcode, const SDLoc &dl, EVT MemVT,
1273 SDVTList VTs, SDValue Chain, SDValue Ptr,
1274 SDValue Cmp, SDValue Swp, MachineMemOperand *MMO);
1275
1276 /// Gets a node for an atomic op, produces result (if relevant)
1277 /// and chain and takes 2 operands.
1278 SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT, SDValue Chain,
1280
1281 /// Gets a node for an atomic op, produces result and chain and
1282 /// takes 1 operand.
1283 SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT, EVT VT,
1284 SDValue Chain, SDValue Ptr, MachineMemOperand *MMO);
1285
1286 /// Gets a node for an atomic op, produces result and chain and takes N
1287 /// operands.
1288 SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT,
1289 SDVTList VTList, ArrayRef<SDValue> Ops,
1290 MachineMemOperand *MMO);
1291
1292 /// Creates a MemIntrinsicNode that may produce a
1293 /// result and takes a list of operands. Opcode may be INTRINSIC_VOID,
1294 /// INTRINSIC_W_CHAIN, or a target-specific opcode with a value not
1295 /// less than FIRST_TARGET_MEMORY_OPCODE.
1297 unsigned Opcode, const SDLoc &dl, SDVTList VTList, ArrayRef<SDValue> Ops,
1298 EVT MemVT, MachinePointerInfo PtrInfo, Align Alignment,
1301 LocationSize Size = 0, const AAMDNodes &AAInfo = AAMDNodes());
1302
1304 unsigned Opcode, const SDLoc &dl, SDVTList VTList, ArrayRef<SDValue> Ops,
1305 EVT MemVT, MachinePointerInfo PtrInfo,
1306 MaybeAlign Alignment = std::nullopt,
1309 LocationSize Size = 0, const AAMDNodes &AAInfo = AAMDNodes()) {
1310 // Ensure that codegen never sees alignment 0
1311 return getMemIntrinsicNode(Opcode, dl, VTList, Ops, MemVT, PtrInfo,
1312 Alignment.value_or(getEVTAlign(MemVT)), Flags,
1313 Size, AAInfo);
1314 }
1315
1316 SDValue getMemIntrinsicNode(unsigned Opcode, const SDLoc &dl, SDVTList VTList,
1317 ArrayRef<SDValue> Ops, EVT MemVT,
1318 MachineMemOperand *MMO);
1319
1320 /// Creates a LifetimeSDNode that starts (`IsStart==true`) or ends
1321 /// (`IsStart==false`) the lifetime of the portion of `FrameIndex` between
1322 /// offsets `Offset` and `Offset + Size`.
1323 SDValue getLifetimeNode(bool IsStart, const SDLoc &dl, SDValue Chain,
1324 int FrameIndex, int64_t Size, int64_t Offset = -1);
1325
1326 /// Creates a PseudoProbeSDNode with function GUID `Guid` and
1327 /// the index of the block `Index` it is probing, as well as the attributes
1328 /// `attr` of the probe.
1329 SDValue getPseudoProbeNode(const SDLoc &Dl, SDValue Chain, uint64_t Guid,
1330 uint64_t Index, uint32_t Attr);
1331
1332 /// Create a MERGE_VALUES node from the given operands.
1334
1335 /// Loads are not normal binary operators: their result type is not
1336 /// determined by their operands, and they produce a value AND a token chain.
1337 ///
1338 /// This function will set the MOLoad flag on MMOFlags, but you can set it if
1339 /// you want. The MOStore flag must not be set.
1340 SDValue getLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
1341 MachinePointerInfo PtrInfo,
1342 MaybeAlign Alignment = MaybeAlign(),
1344 const AAMDNodes &AAInfo = AAMDNodes(),
1345 const MDNode *Ranges = nullptr);
1346 SDValue getLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
1347 MachineMemOperand *MMO);
1348 SDValue
1349 getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT, SDValue Chain,
1350 SDValue Ptr, MachinePointerInfo PtrInfo, EVT MemVT,
1351 MaybeAlign Alignment = MaybeAlign(),
1353 const AAMDNodes &AAInfo = AAMDNodes());
1354 SDValue getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT,
1355 SDValue Chain, SDValue Ptr, EVT MemVT,
1356 MachineMemOperand *MMO);
1357 SDValue getIndexedLoad(SDValue OrigLoad, const SDLoc &dl, SDValue Base,
1360 const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
1361 MachinePointerInfo PtrInfo, EVT MemVT, Align Alignment,
1363 const AAMDNodes &AAInfo = AAMDNodes(),
1364 const MDNode *Ranges = nullptr);
1366 ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT, const SDLoc &dl,
1368 EVT MemVT, MaybeAlign Alignment = MaybeAlign(),
1370 const AAMDNodes &AAInfo = AAMDNodes(), const MDNode *Ranges = nullptr) {
1371 // Ensures that codegen never sees a None Alignment.
1372 return getLoad(AM, ExtType, VT, dl, Chain, Ptr, Offset, PtrInfo, MemVT,
1373 Alignment.value_or(getEVTAlign(MemVT)), MMOFlags, AAInfo,
1374 Ranges);
1375 }
1377 const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
1378 EVT MemVT, MachineMemOperand *MMO);
1379
1380 /// Helper function to build ISD::STORE nodes.
1381 ///
1382 /// This function will set the MOStore flag on MMOFlags, but you can set it if
1383 /// you want. The MOLoad and MOInvariant flags must not be set.
1384
1385 SDValue
1386 getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
1387 MachinePointerInfo PtrInfo, Align Alignment,
1389 const AAMDNodes &AAInfo = AAMDNodes());
1390 inline SDValue
1391 getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
1392 MachinePointerInfo PtrInfo, MaybeAlign Alignment = MaybeAlign(),
1394 const AAMDNodes &AAInfo = AAMDNodes()) {
1395 return getStore(Chain, dl, Val, Ptr, PtrInfo,
1396 Alignment.value_or(getEVTAlign(Val.getValueType())),
1397 MMOFlags, AAInfo);
1398 }
1399 SDValue getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
1400 MachineMemOperand *MMO);
1401 SDValue
1402 getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
1403 MachinePointerInfo PtrInfo, EVT SVT, Align Alignment,
1405 const AAMDNodes &AAInfo = AAMDNodes());
1406 inline SDValue
1408 MachinePointerInfo PtrInfo, EVT SVT,
1409 MaybeAlign Alignment = MaybeAlign(),
1411 const AAMDNodes &AAInfo = AAMDNodes()) {
1412 return getTruncStore(Chain, dl, Val, Ptr, PtrInfo, SVT,
1413 Alignment.value_or(getEVTAlign(SVT)), MMOFlags,
1414 AAInfo);
1415 }
1416 SDValue getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val,
1417 SDValue Ptr, EVT SVT, MachineMemOperand *MMO);
1418 SDValue getIndexedStore(SDValue OrigStore, const SDLoc &dl, SDValue Base,
1420
1422 const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
1423 SDValue Mask, SDValue EVL, MachinePointerInfo PtrInfo,
1424 EVT MemVT, Align Alignment,
1425 MachineMemOperand::Flags MMOFlags, const AAMDNodes &AAInfo,
1426 const MDNode *Ranges = nullptr, bool IsExpanding = false);
1427 inline SDValue
1429 const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
1430 SDValue Mask, SDValue EVL, MachinePointerInfo PtrInfo, EVT MemVT,
1431 MaybeAlign Alignment = MaybeAlign(),
1433 const AAMDNodes &AAInfo = AAMDNodes(),
1434 const MDNode *Ranges = nullptr, bool IsExpanding = false) {
1435 // Ensures that codegen never sees a None Alignment.
1436 return getLoadVP(AM, ExtType, VT, dl, Chain, Ptr, Offset, Mask, EVL,
1437 PtrInfo, MemVT, Alignment.value_or(getEVTAlign(MemVT)),
1438 MMOFlags, AAInfo, Ranges, IsExpanding);
1439 }
1441 const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
1442 SDValue Mask, SDValue EVL, EVT MemVT,
1443 MachineMemOperand *MMO, bool IsExpanding = false);
1444 SDValue getLoadVP(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
1445 SDValue Mask, SDValue EVL, MachinePointerInfo PtrInfo,
1446 MaybeAlign Alignment, MachineMemOperand::Flags MMOFlags,
1447 const AAMDNodes &AAInfo, const MDNode *Ranges = nullptr,
1448 bool IsExpanding = false);
1449 SDValue getLoadVP(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
1450 SDValue Mask, SDValue EVL, MachineMemOperand *MMO,
1451 bool IsExpanding = false);
1452 SDValue getExtLoadVP(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT,
1453 SDValue Chain, SDValue Ptr, SDValue Mask, SDValue EVL,
1454 MachinePointerInfo PtrInfo, EVT MemVT,
1455 MaybeAlign Alignment, MachineMemOperand::Flags MMOFlags,
1456 const AAMDNodes &AAInfo, bool IsExpanding = false);
1457 SDValue getExtLoadVP(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT,
1458 SDValue Chain, SDValue Ptr, SDValue Mask, SDValue EVL,
1459 EVT MemVT, MachineMemOperand *MMO,
1460 bool IsExpanding = false);
1461 SDValue getIndexedLoadVP(SDValue OrigLoad, const SDLoc &dl, SDValue Base,
1463 SDValue getStoreVP(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
1464 SDValue Offset, SDValue Mask, SDValue EVL, EVT MemVT,
1466 bool IsTruncating = false, bool IsCompressing = false);
1467 SDValue getTruncStoreVP(SDValue Chain, const SDLoc &dl, SDValue Val,
1468 SDValue Ptr, SDValue Mask, SDValue EVL,
1469 MachinePointerInfo PtrInfo, EVT SVT, Align Alignment,
1470 MachineMemOperand::Flags MMOFlags,
1471 const AAMDNodes &AAInfo, bool IsCompressing = false);
1472 SDValue getTruncStoreVP(SDValue Chain, const SDLoc &dl, SDValue Val,
1473 SDValue Ptr, SDValue Mask, SDValue EVL, EVT SVT,
1474 MachineMemOperand *MMO, bool IsCompressing = false);
1475 SDValue getIndexedStoreVP(SDValue OrigStore, const SDLoc &dl, SDValue Base,
1477
1479 EVT VT, const SDLoc &DL, SDValue Chain, SDValue Ptr,
1480 SDValue Offset, SDValue Stride, SDValue Mask,
1481 SDValue EVL, EVT MemVT, MachineMemOperand *MMO,
1482 bool IsExpanding = false);
1484 SDValue Stride, SDValue Mask, SDValue EVL,
1485 MachineMemOperand *MMO, bool IsExpanding = false);
1487 SDValue Chain, SDValue Ptr, SDValue Stride,
1488 SDValue Mask, SDValue EVL, EVT MemVT,
1489 MachineMemOperand *MMO, bool IsExpanding = false);
1490 SDValue getStridedStoreVP(SDValue Chain, const SDLoc &DL, SDValue Val,
1491 SDValue Ptr, SDValue Offset, SDValue Stride,
1492 SDValue Mask, SDValue EVL, EVT MemVT,
1494 bool IsTruncating = false,
1495 bool IsCompressing = false);
1497 SDValue Ptr, SDValue Stride, SDValue Mask,
1498 SDValue EVL, EVT SVT, MachineMemOperand *MMO,
1499 bool IsCompressing = false);
1500
1501 SDValue getGatherVP(SDVTList VTs, EVT VT, const SDLoc &dl,
1503 ISD::MemIndexType IndexType);
1504 SDValue getScatterVP(SDVTList VTs, EVT VT, const SDLoc &dl,
1506 ISD::MemIndexType IndexType);
1507
1508 SDValue getMaskedLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Base,
1509 SDValue Offset, SDValue Mask, SDValue Src0, EVT MemVT,
1511 ISD::LoadExtType, bool IsExpanding = false);
1514 SDValue getMaskedStore(SDValue Chain, const SDLoc &dl, SDValue Val,
1515 SDValue Base, SDValue Offset, SDValue Mask, EVT MemVT,
1517 bool IsTruncating = false, bool IsCompressing = false);
1518 SDValue getIndexedMaskedStore(SDValue OrigStore, const SDLoc &dl,
1521 SDValue getMaskedGather(SDVTList VTs, EVT MemVT, const SDLoc &dl,
1523 ISD::MemIndexType IndexType, ISD::LoadExtType ExtTy);
1524 SDValue getMaskedScatter(SDVTList VTs, EVT MemVT, const SDLoc &dl,
1526 ISD::MemIndexType IndexType,
1527 bool IsTruncating = false);
1528
1529 SDValue getGetFPEnv(SDValue Chain, const SDLoc &dl, SDValue Ptr, EVT MemVT,
1530 MachineMemOperand *MMO);
1531 SDValue getSetFPEnv(SDValue Chain, const SDLoc &dl, SDValue Ptr, EVT MemVT,
1532 MachineMemOperand *MMO);
1533
1534 /// Construct a node to track a Value* through the backend.
1535 SDValue getSrcValue(const Value *v);
1536
1537 /// Return an MDNodeSDNode which holds an MDNode.
1538 SDValue getMDNode(const MDNode *MD);
1539
1540 /// Return a bitcast using the SDLoc of the value operand, and casting to the
1541 /// provided type. Use getNode to set a custom SDLoc.
1543
1544 /// Return an AddrSpaceCastSDNode.
1545 SDValue getAddrSpaceCast(const SDLoc &dl, EVT VT, SDValue Ptr, unsigned SrcAS,
1546 unsigned DestAS);
1547
1548 /// Return a freeze using the SDLoc of the value operand.
1550
1551 /// Return an AssertAlignSDNode.
1553
1554 /// Swap N1 and N2 if Opcode is a commutative binary opcode
1555 /// and the canonical form expects the opposite order.
1556 void canonicalizeCommutativeBinop(unsigned Opcode, SDValue &N1,
1557 SDValue &N2) const;
1558
1559 /// Return the specified value casted to
1560 /// the target's desired shift amount type.
1562
1563 /// Expand the specified \c ISD::VAARG node as the Legalize pass would.
1565
1566 /// Expand the specified \c ISD::VACOPY node as the Legalize pass would.
1568
1569 /// Return a GlobalAddress of the function from the current module with
1570 /// name matching the given ExternalSymbol. Additionally can provide the
1571 /// matched function.
1572 /// Panic if the function doesn't exist.
1574 Function **TargetFunction = nullptr);
1575
1576 /// *Mutate* the specified node in-place to have the
1577 /// specified operands. If the resultant node already exists in the DAG,
1578 /// this does not modify the specified node, instead it returns the node that
1579 /// already exists. If the resultant node does not exist in the DAG, the
1580 /// input node is returned. As a degenerate case, if you specify the same
1581 /// input operands as the node already has, the input node is returned.
1585 SDValue Op3);
1587 SDValue Op3, SDValue Op4);
1589 SDValue Op3, SDValue Op4, SDValue Op5);
1591
1592 /// Creates a new TokenFactor containing \p Vals. If \p Vals contains 64k
1593 /// values or more, move values into new TokenFactors in 64k-1 blocks, until
1594 /// the final TokenFactor has less than 64k operands.
1596
1597 /// *Mutate* the specified machine node's memory references to the provided
1598 /// list.
1601
1602 // Calculate divergence of node \p N based on its operands.
1604
1605 // Propagates the change in divergence to users
1606 void updateDivergence(SDNode * N);
1607
1608 /// These are used for target selectors to *mutate* the
1609 /// specified node to have the specified return type, Target opcode, and
1610 /// operands. Note that target opcodes are stored as
1611 /// ~TargetOpcode in the node opcode field. The resultant node is returned.
1612 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT);
1613 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT, SDValue Op1);
1614 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT,
1615 SDValue Op1, SDValue Op2);
1616 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT,
1617 SDValue Op1, SDValue Op2, SDValue Op3);
1618 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT,
1619 ArrayRef<SDValue> Ops);
1620 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1, EVT VT2);
1621 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1,
1622 EVT VT2, ArrayRef<SDValue> Ops);
1623 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1,
1624 EVT VT2, EVT VT3, ArrayRef<SDValue> Ops);
1625 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1,
1626 EVT VT2, SDValue Op1, SDValue Op2);
1627 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, SDVTList VTs,
1628 ArrayRef<SDValue> Ops);
1629
1630 /// This *mutates* the specified node to have the specified
1631 /// return type, opcode, and operands.
1632 SDNode *MorphNodeTo(SDNode *N, unsigned Opc, SDVTList VTs,
1633 ArrayRef<SDValue> Ops);
1634
1635 /// Mutate the specified strict FP node to its non-strict equivalent,
1636 /// unlinking the node from its chain and dropping the metadata arguments.
1637 /// The node must be a strict FP node.
1639
1640 /// These are used for target selectors to create a new node
1641 /// with specified return type(s), MachineInstr opcode, and operands.
1642 ///
1643 /// Note that getMachineNode returns the resultant node. If there is already
1644 /// a node of the specified opcode and operands, it returns that node instead
1645 /// of the current one.
1646 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT);
1647 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
1648 SDValue Op1);
1649 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
1650 SDValue Op1, SDValue Op2);
1651 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
1652 SDValue Op1, SDValue Op2, SDValue Op3);
1653 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
1654 ArrayRef<SDValue> Ops);
1655 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1656 EVT VT2, SDValue Op1, SDValue Op2);
1657 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1658 EVT VT2, SDValue Op1, SDValue Op2, SDValue Op3);
1659 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1660 EVT VT2, ArrayRef<SDValue> Ops);
1661 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1662 EVT VT2, EVT VT3, SDValue Op1, SDValue Op2);
1663 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1664 EVT VT2, EVT VT3, SDValue Op1, SDValue Op2,
1665 SDValue Op3);
1666 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1667 EVT VT2, EVT VT3, ArrayRef<SDValue> Ops);
1668 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl,
1669 ArrayRef<EVT> ResultTys, ArrayRef<SDValue> Ops);
1670 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, SDVTList VTs,
1671 ArrayRef<SDValue> Ops);
1672
1673 /// A convenience function for creating TargetInstrInfo::EXTRACT_SUBREG nodes.
1674 SDValue getTargetExtractSubreg(int SRIdx, const SDLoc &DL, EVT VT,
1675 SDValue Operand);
1676
1677 /// A convenience function for creating TargetInstrInfo::INSERT_SUBREG nodes.
1678 SDValue getTargetInsertSubreg(int SRIdx, const SDLoc &DL, EVT VT,
1679 SDValue Operand, SDValue Subreg);
1680
1681 /// Get the specified node if it's already available, or else return NULL.
1682 SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTList,
1683 ArrayRef<SDValue> Ops, const SDNodeFlags Flags);
1684 SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTList,
1685 ArrayRef<SDValue> Ops);
1686
1687 /// Check if a node exists without modifying its flags.
1688 bool doesNodeExist(unsigned Opcode, SDVTList VTList, ArrayRef<SDValue> Ops);
1689
1690 /// Creates a SDDbgValue node.
1692 unsigned R, bool IsIndirect, const DebugLoc &DL,
1693 unsigned O);
1694
1695 /// Creates a constant SDDbgValue node.
1697 const Value *C, const DebugLoc &DL,
1698 unsigned O);
1699
1700 /// Creates a FrameIndex SDDbgValue node.
1702 unsigned FI, bool IsIndirect,
1703 const DebugLoc &DL, unsigned O);
1704
1705 /// Creates a FrameIndex SDDbgValue node.
1707 unsigned FI,
1708 ArrayRef<SDNode *> Dependencies,
1709 bool IsIndirect, const DebugLoc &DL,
1710 unsigned O);
1711
1712 /// Creates a VReg SDDbgValue node.
1714 unsigned VReg, bool IsIndirect,
1715 const DebugLoc &DL, unsigned O);
1716
1717 /// Creates a SDDbgValue node from a list of locations.
1720 ArrayRef<SDNode *> Dependencies, bool IsIndirect,
1721 const DebugLoc &DL, unsigned O, bool IsVariadic);
1722
1723 /// Creates a SDDbgLabel node.
1724 SDDbgLabel *getDbgLabel(DILabel *Label, const DebugLoc &DL, unsigned O);
1725
1726 /// Transfer debug values from one node to another, while optionally
1727 /// generating fragment expressions for split-up values. If \p InvalidateDbg
1728 /// is set, debug values are invalidated after they are transferred.
1729 void transferDbgValues(SDValue From, SDValue To, unsigned OffsetInBits = 0,
1730 unsigned SizeInBits = 0, bool InvalidateDbg = true);
1731
1732 /// Remove the specified node from the system. If any of its
1733 /// operands then becomes dead, remove them as well. Inform UpdateListener
1734 /// for each node deleted.
1735 void RemoveDeadNode(SDNode *N);
1736
1737 /// This method deletes the unreachable nodes in the
1738 /// given list, and any nodes that become unreachable as a result.
1740
1741 /// Modify anything using 'From' to use 'To' instead.
1742 /// This can cause recursive merging of nodes in the DAG. Use the first
1743 /// version if 'From' is known to have a single result, use the second
1744 /// if you have two nodes with identical results (or if 'To' has a superset
1745 /// of the results of 'From'), use the third otherwise.
1746 ///
1747 /// These methods all take an optional UpdateListener, which (if not null) is
1748 /// informed about nodes that are deleted and modified due to recursive
1749 /// changes in the dag.
1750 ///
1751 /// These functions only replace all existing uses. It's possible that as
1752 /// these replacements are being performed, CSE may cause the From node
1753 /// to be given new uses. These new uses of From are left in place, and
1754 /// not automatically transferred to To.
1755 ///
1758 void ReplaceAllUsesWith(SDNode *From, const SDValue *To);
1759
1760 /// Replace any uses of From with To, leaving
1761 /// uses of other values produced by From.getNode() alone.
1763
1764 /// Like ReplaceAllUsesOfValueWith, but for multiple values at once.
1765 /// This correctly handles the case where
1766 /// there is an overlap between the From values and the To values.
1767 void ReplaceAllUsesOfValuesWith(const SDValue *From, const SDValue *To,
1768 unsigned Num);
1769
1770 /// If an existing load has uses of its chain, create a token factor node with
1771 /// that chain and the new memory node's chain and update users of the old
1772 /// chain to the token factor. This ensures that the new memory node will have
1773 /// the same relative memory dependency position as the old load. Returns the
1774 /// new merged load chain.
1775 SDValue makeEquivalentMemoryOrdering(SDValue OldChain, SDValue NewMemOpChain);
1776
1777 /// If an existing load has uses of its chain, create a token factor node with
1778 /// that chain and the new memory node's chain and update users of the old
1779 /// chain to the token factor. This ensures that the new memory node will have
1780 /// the same relative memory dependency position as the old load. Returns the
1781 /// new merged load chain.
1783
1784 /// Topological-sort the AllNodes list and a
1785 /// assign a unique node id for each node in the DAG based on their
1786 /// topological order. Returns the number of nodes.
1787 unsigned AssignTopologicalOrder();
1788
1789 /// Move node N in the AllNodes list to be immediately
1790 /// before the given iterator Position. This may be used to update the
1791 /// topological ordering when the list of nodes is modified.
1793 AllNodes.insert(Position, AllNodes.remove(N));
1794 }
1795
1796 /// Returns an APFloat semantics tag appropriate for the given type. If VT is
1797 /// a vector type, the element semantics are returned.
1799 switch (VT.getScalarType().getSimpleVT().SimpleTy) {
1800 default: llvm_unreachable("Unknown FP format");
1801 case MVT::f16: return APFloat::IEEEhalf();
1802 case MVT::bf16: return APFloat::BFloat();
1803 case MVT::f32: return APFloat::IEEEsingle();
1804 case MVT::f64: return APFloat::IEEEdouble();
1805 case MVT::f80: return APFloat::x87DoubleExtended();
1806 case MVT::f128: return APFloat::IEEEquad();
1807 case MVT::ppcf128: return APFloat::PPCDoubleDouble();
1808 }
1809 }
1810
1811 /// Add a dbg_value SDNode. If SD is non-null that means the
1812 /// value is produced by SD.
1813 void AddDbgValue(SDDbgValue *DB, bool isParameter);
1814
1815 /// Add a dbg_label SDNode.
1816 void AddDbgLabel(SDDbgLabel *DB);
1817
1818 /// Get the debug values which reference the given SDNode.
1820 return DbgInfo->getSDDbgValues(SD);
1821 }
1822
1823public:
1824 /// Return true if there are any SDDbgValue nodes associated
1825 /// with this SelectionDAG.
1826 bool hasDebugValues() const { return !DbgInfo->empty(); }
1827
1828 SDDbgInfo::DbgIterator DbgBegin() const { return DbgInfo->DbgBegin(); }
1829 SDDbgInfo::DbgIterator DbgEnd() const { return DbgInfo->DbgEnd(); }
1830
1832 return DbgInfo->ByvalParmDbgBegin();
1833 }
1835 return DbgInfo->ByvalParmDbgEnd();
1836 }
1837
1839 return DbgInfo->DbgLabelBegin();
1840 }
1842 return DbgInfo->DbgLabelEnd();
1843 }
1844
1845 /// To be invoked on an SDNode that is slated to be erased. This
1846 /// function mirrors \c llvm::salvageDebugInfo.
1847 void salvageDebugInfo(SDNode &N);
1848
1849 void dump() const;
1850
1851 /// In most cases this function returns the ABI alignment for a given type,
1852 /// except for illegal vector types where the alignment exceeds that of the
1853 /// stack. In such cases we attempt to break the vector down to a legal type
1854 /// and return the ABI alignment for that instead.
1855 Align getReducedAlign(EVT VT, bool UseABI);
1856
1857 /// Create a stack temporary based on the size in bytes and the alignment
1858 SDValue CreateStackTemporary(TypeSize Bytes, Align Alignment);
1859
1860 /// Create a stack temporary, suitable for holding the specified value type.
1861 /// If minAlign is specified, the slot size will have at least that alignment.
1862 SDValue CreateStackTemporary(EVT VT, unsigned minAlign = 1);
1863
1864 /// Create a stack temporary suitable for holding either of the specified
1865 /// value types.
1867
1868 SDValue FoldSymbolOffset(unsigned Opcode, EVT VT,
1869 const GlobalAddressSDNode *GA,
1870 const SDNode *N2);
1871
1872 SDValue FoldConstantArithmetic(unsigned Opcode, const SDLoc &DL, EVT VT,
1873 ArrayRef<SDValue> Ops);
1874
1875 /// Fold floating-point operations when all operands are constants and/or
1876 /// undefined.
1877 SDValue foldConstantFPMath(unsigned Opcode, const SDLoc &DL, EVT VT,
1878 ArrayRef<SDValue> Ops);
1879
1880 /// Constant fold a setcc to true or false.
1882 const SDLoc &dl);
1883
1884 /// Return true if the sign bit of Op is known to be zero.
1885 /// We use this predicate to simplify operations downstream.
1886 bool SignBitIsZero(SDValue Op, unsigned Depth = 0) const;
1887
1888 /// Return true if 'Op & Mask' is known to be zero. We
1889 /// use this predicate to simplify operations downstream. Op and Mask are
1890 /// known to be the same type.
1891 bool MaskedValueIsZero(SDValue Op, const APInt &Mask,
1892 unsigned Depth = 0) const;
1893
1894 /// Return true if 'Op & Mask' is known to be zero in DemandedElts. We
1895 /// use this predicate to simplify operations downstream. Op and Mask are
1896 /// known to be the same type.
1897 bool MaskedValueIsZero(SDValue Op, const APInt &Mask,
1898 const APInt &DemandedElts, unsigned Depth = 0) const;
1899
1900 /// Return true if 'Op' is known to be zero in DemandedElts. We
1901 /// use this predicate to simplify operations downstream.
1902 bool MaskedVectorIsZero(SDValue Op, const APInt &DemandedElts,
1903 unsigned Depth = 0) const;
1904
1905 /// Return true if '(Op & Mask) == Mask'.
1906 /// Op and Mask are known to be the same type.
1907 bool MaskedValueIsAllOnes(SDValue Op, const APInt &Mask,
1908 unsigned Depth = 0) const;
1909
1910 /// For each demanded element of a vector, see if it is known to be zero.
1912 unsigned Depth = 0) const;
1913
1914 /// Determine which bits of Op are known to be either zero or one and return
1915 /// them in Known. For vectors, the known bits are those that are shared by
1916 /// every vector element.
1917 /// Targets can implement the computeKnownBitsForTargetNode method in the
1918 /// TargetLowering class to allow target nodes to be understood.
1919 KnownBits computeKnownBits(SDValue Op, unsigned Depth = 0) const;
1920
1921 /// Determine which bits of Op are known to be either zero or one and return
1922 /// them in Known. The DemandedElts argument allows us to only collect the
1923 /// known bits that are shared by the requested vector elements.
1924 /// Targets can implement the computeKnownBitsForTargetNode method in the
1925 /// TargetLowering class to allow target nodes to be understood.
1926 KnownBits computeKnownBits(SDValue Op, const APInt &DemandedElts,
1927 unsigned Depth = 0) const;
1928
1929 /// Used to represent the possible overflow behavior of an operation.
1930 /// Never: the operation cannot overflow.
1931 /// Always: the operation will always overflow.
1932 /// Sometime: the operation may or may not overflow.
1937 };
1938
1939 /// Determine if the result of the signed addition of 2 nodes can overflow.
1941
1942 /// Determine if the result of the unsigned addition of 2 nodes can overflow.
1944
1945 /// Determine if the result of the addition of 2 nodes can overflow.
1947 SDValue N1) const {
1948 return IsSigned ? computeOverflowForSignedAdd(N0, N1)
1950 }
1951
1952 /// Determine if the result of the addition of 2 nodes can never overflow.
1953 bool willNotOverflowAdd(bool IsSigned, SDValue N0, SDValue N1) const {
1954 return computeOverflowForAdd(IsSigned, N0, N1) == OFK_Never;
1955 }
1956
1957 /// Determine if the result of the signed sub of 2 nodes can overflow.
1959
1960 /// Determine if the result of the unsigned sub of 2 nodes can overflow.
1962
1963 /// Determine if the result of the sub of 2 nodes can overflow.
1965 SDValue N1) const {
1966 return IsSigned ? computeOverflowForSignedSub(N0, N1)
1968 }
1969
1970 /// Determine if the result of the sub of 2 nodes can never overflow.
1971 bool willNotOverflowSub(bool IsSigned, SDValue N0, SDValue N1) const {
1972 return computeOverflowForSub(IsSigned, N0, N1) == OFK_Never;
1973 }
1974
1975 /// Determine if the result of the signed mul of 2 nodes can overflow.
1977
1978 /// Determine if the result of the unsigned mul of 2 nodes can overflow.
1980
1981 /// Determine if the result of the mul of 2 nodes can overflow.
1983 SDValue N1) const {
1984 return IsSigned ? computeOverflowForSignedMul(N0, N1)
1986 }
1987
1988 /// Determine if the result of the mul of 2 nodes can never overflow.
1989 bool willNotOverflowMul(bool IsSigned, SDValue N0, SDValue N1) const {
1990 return computeOverflowForMul(IsSigned, N0, N1) == OFK_Never;
1991 }
1992
1993 /// Test if the given value is known to have exactly one bit set. This differs
1994 /// from computeKnownBits in that it doesn't necessarily determine which bit
1995 /// is set.
1996 bool isKnownToBeAPowerOfTwo(SDValue Val, unsigned Depth = 0) const;
1997
1998 /// Return the number of times the sign bit of the register is replicated into
1999 /// the other bits. We know that at least 1 bit is always equal to the sign
2000 /// bit (itself), but other cases can give us information. For example,
2001 /// immediately after an "SRA X, 2", we know that the top 3 bits are all equal
2002 /// to each other, so we return 3. Targets can implement the
2003 /// ComputeNumSignBitsForTarget method in the TargetLowering class to allow
2004 /// target nodes to be understood.
2005 unsigned ComputeNumSignBits(SDValue Op, unsigned Depth = 0) const;
2006
2007 /// Return the number of times the sign bit of the register is replicated into
2008 /// the other bits. We know that at least 1 bit is always equal to the sign
2009 /// bit (itself), but other cases can give us information. For example,
2010 /// immediately after an "SRA X, 2", we know that the top 3 bits are all equal
2011 /// to each other, so we return 3. The DemandedElts argument allows
2012 /// us to only collect the minimum sign bits of the requested vector elements.
2013 /// Targets can implement the ComputeNumSignBitsForTarget method in the
2014 /// TargetLowering class to allow target nodes to be understood.
2015 unsigned ComputeNumSignBits(SDValue Op, const APInt &DemandedElts,
2016 unsigned Depth = 0) const;
2017
2018 /// Get the upper bound on bit size for this Value \p Op as a signed integer.
2019 /// i.e. x == sext(trunc(x to MaxSignedBits) to bitwidth(x)).
2020 /// Similar to the APInt::getSignificantBits function.
2021 /// Helper wrapper to ComputeNumSignBits.
2022 unsigned ComputeMaxSignificantBits(SDValue Op, unsigned Depth = 0) const;
2023
2024 /// Get the upper bound on bit size for this Value \p Op as a signed integer.
2025 /// i.e. x == sext(trunc(x to MaxSignedBits) to bitwidth(x)).
2026 /// Similar to the APInt::getSignificantBits function.
2027 /// Helper wrapper to ComputeNumSignBits.
2028 unsigned ComputeMaxSignificantBits(SDValue Op, const APInt &DemandedElts,
2029 unsigned Depth = 0) const;
2030
2031 /// Return true if this function can prove that \p Op is never poison
2032 /// and, if \p PoisonOnly is false, does not have undef bits.
2034 unsigned Depth = 0) const;
2035
2036 /// Return true if this function can prove that \p Op is never poison
2037 /// and, if \p PoisonOnly is false, does not have undef bits. The DemandedElts
2038 /// argument limits the check to the requested vector elements.
2039 bool isGuaranteedNotToBeUndefOrPoison(SDValue Op, const APInt &DemandedElts,
2040 bool PoisonOnly = false,
2041 unsigned Depth = 0) const;
2042
2043 /// Return true if this function can prove that \p Op is never poison.
2044 bool isGuaranteedNotToBePoison(SDValue Op, unsigned Depth = 0) const {
2045 return isGuaranteedNotToBeUndefOrPoison(Op, /*PoisonOnly*/ true, Depth);
2046 }
2047
2048 /// Return true if this function can prove that \p Op is never poison. The
2049 /// DemandedElts argument limits the check to the requested vector elements.
2050 bool isGuaranteedNotToBePoison(SDValue Op, const APInt &DemandedElts,
2051 unsigned Depth = 0) const {
2052 return isGuaranteedNotToBeUndefOrPoison(Op, DemandedElts,
2053 /*PoisonOnly*/ true, Depth);
2054 }
2055
2056 /// Return true if Op can create undef or poison from non-undef & non-poison
2057 /// operands. The DemandedElts argument limits the check to the requested
2058 /// vector elements.
2059 ///
2060 /// \p ConsiderFlags controls whether poison producing flags on the
2061 /// instruction are considered. This can be used to see if the instruction
2062 /// could still introduce undef or poison even without poison generating flags
2063 /// which might be on the instruction. (i.e. could the result of
2064 /// Op->dropPoisonGeneratingFlags() still create poison or undef)
2065 bool canCreateUndefOrPoison(SDValue Op, const APInt &DemandedElts,
2066 bool PoisonOnly = false,
2067 bool ConsiderFlags = true,
2068 unsigned Depth = 0) const;
2069
2070 /// Return true if Op can create undef or poison from non-undef & non-poison
2071 /// operands.
2072 ///
2073 /// \p ConsiderFlags controls whether poison producing flags on the
2074 /// instruction are considered. This can be used to see if the instruction
2075 /// could still introduce undef or poison even without poison generating flags
2076 /// which might be on the instruction. (i.e. could the result of
2077 /// Op->dropPoisonGeneratingFlags() still create poison or undef)
2078 bool canCreateUndefOrPoison(SDValue Op, bool PoisonOnly = false,
2079 bool ConsiderFlags = true,
2080 unsigned Depth = 0) const;
2081
2082 /// Return true if the specified operand is an ISD::OR or ISD::XOR node
2083 /// that can be treated as an ISD::ADD node.
2084 /// or(x,y) == add(x,y) iff haveNoCommonBitsSet(x,y)
2085 /// xor(x,y) == add(x,y) iff isMinSignedConstant(y)
2086 bool isADDLike(SDValue Op) const;
2087
2088 /// Return true if the specified operand is an ISD::ADD with a ConstantSDNode
2089 /// on the right-hand side, or if it is an ISD::OR with a ConstantSDNode that
2090 /// is guaranteed to have the same semantics as an ADD. This handles the
2091 /// equivalence:
2092 /// X|Cst == X+Cst iff X&Cst = 0.
2094
2095 /// Test whether the given SDValue (or all elements of it, if it is a
2096 /// vector) is known to never be NaN. If \p SNaN is true, returns if \p Op is
2097 /// known to never be a signaling NaN (it may still be a qNaN).
2098 bool isKnownNeverNaN(SDValue Op, bool SNaN = false, unsigned Depth = 0) const;
2099
2100 /// \returns true if \p Op is known to never be a signaling NaN.
2101 bool isKnownNeverSNaN(SDValue Op, unsigned Depth = 0) const {
2102 return isKnownNeverNaN(Op, true, Depth);
2103 }
2104
2105 /// Test whether the given floating point SDValue is known to never be
2106 /// positive or negative zero.
2107 bool isKnownNeverZeroFloat(SDValue Op) const;
2108
2109 /// Test whether the given SDValue is known to contain non-zero value(s).
2110 bool isKnownNeverZero(SDValue Op, unsigned Depth = 0) const;
2111
2112 /// Test whether two SDValues are known to compare equal. This
2113 /// is true if they are the same value, or if one is negative zero and the
2114 /// other positive zero.
2115 bool isEqualTo(SDValue A, SDValue B) const;
2116
2117 /// Return true if A and B have no common bits set. As an example, this can
2118 /// allow an 'add' to be transformed into an 'or'.
2119 bool haveNoCommonBitsSet(SDValue A, SDValue B) const;
2120
2121 /// Test whether \p V has a splatted value for all the demanded elements.
2122 ///
2123 /// On success \p UndefElts will indicate the elements that have UNDEF
2124 /// values instead of the splat value, this is only guaranteed to be correct
2125 /// for \p DemandedElts.
2126 ///
2127 /// NOTE: The function will return true for a demanded splat of UNDEF values.
2128 bool isSplatValue(SDValue V, const APInt &DemandedElts, APInt &UndefElts,
2129 unsigned Depth = 0) const;
2130
2131 /// Test whether \p V has a splatted value.
2132 bool isSplatValue(SDValue V, bool AllowUndefs = false) const;
2133
2134 /// If V is a splatted value, return the source vector and its splat index.
2135 SDValue getSplatSourceVector(SDValue V, int &SplatIndex);
2136
2137 /// If V is a splat vector, return its scalar source operand by extracting
2138 /// that element from the source vector. If LegalTypes is true, this method
2139 /// may only return a legally-typed splat value. If it cannot legalize the
2140 /// splatted value it will return SDValue().
2141 SDValue getSplatValue(SDValue V, bool LegalTypes = false);
2142
2143 /// If a SHL/SRA/SRL node \p V has a constant or splat constant shift amount
2144 /// that is less than the element bit-width of the shift node, return it.
2146 const APInt &DemandedElts) const;
2147
2148 /// If a SHL/SRA/SRL node \p V has constant shift amounts that are all less
2149 /// than the element bit-width of the shift node, return the minimum value.
2150 const APInt *
2152 const APInt &DemandedElts) const;
2153
2154 /// If a SHL/SRA/SRL node \p V has constant shift amounts that are all less
2155 /// than the element bit-width of the shift node, return the maximum value.
2156 const APInt *
2158 const APInt &DemandedElts) const;
2159
2160 /// Match a binop + shuffle pyramid that represents a horizontal reduction
2161 /// over the elements of a vector starting from the EXTRACT_VECTOR_ELT node /p
2162 /// Extract. The reduction must use one of the opcodes listed in /p
2163 /// CandidateBinOps and on success /p BinOp will contain the matching opcode.
2164 /// Returns the vector that is being reduced on, or SDValue() if a reduction
2165 /// was not matched. If \p AllowPartials is set then in the case of a
2166 /// reduction pattern that only matches the first few stages, the extracted
2167 /// subvector of the start of the reduction is returned.
2169 ArrayRef<ISD::NodeType> CandidateBinOps,
2170 bool AllowPartials = false);
2171
2172 /// Utility function used by legalize and lowering to
2173 /// "unroll" a vector operation by splitting out the scalars and operating
2174 /// on each element individually. If the ResNE is 0, fully unroll the vector
2175 /// op. If ResNE is less than the width of the vector op, unroll up to ResNE.
2176 /// If the ResNE is greater than the width of the vector op, unroll the
2177 /// vector op and fill the end of the resulting vector with UNDEFS.
2178 SDValue UnrollVectorOp(SDNode *N, unsigned ResNE = 0);
2179
2180 /// Like UnrollVectorOp(), but for the [US](ADD|SUB|MUL)O family of opcodes.
2181 /// This is a separate function because those opcodes have two results.
2182 std::pair<SDValue, SDValue> UnrollVectorOverflowOp(SDNode *N,
2183 unsigned ResNE = 0);
2184
2185 /// Return true if loads are next to each other and can be
2186 /// merged. Check that both are nonvolatile and if LD is loading
2187 /// 'Bytes' bytes from a location that is 'Dist' units away from the
2188 /// location that the 'Base' load is loading from.
2190 unsigned Bytes, int Dist) const;
2191
2192 /// Infer alignment of a load / store address. Return std::nullopt if it
2193 /// cannot be inferred.
2195
2196 /// Split the scalar node with EXTRACT_ELEMENT using the provided VTs and
2197 /// return the low/high part.
2198 std::pair<SDValue, SDValue> SplitScalar(const SDValue &N, const SDLoc &DL,
2199 const EVT &LoVT, const EVT &HiVT);
2200
2201 /// Compute the VTs needed for the low/hi parts of a type
2202 /// which is split (or expanded) into two not necessarily identical pieces.
2203 std::pair<EVT, EVT> GetSplitDestVTs(const EVT &VT) const;
2204
2205 /// Compute the VTs needed for the low/hi parts of a type, dependent on an
2206 /// enveloping VT that has been split into two identical pieces. Sets the
2207 /// HisIsEmpty flag when hi type has zero storage size.
2208 std::pair<EVT, EVT> GetDependentSplitDestVTs(const EVT &VT, const EVT &EnvVT,
2209 bool *HiIsEmpty) const;
2210
2211 /// Split the vector with EXTRACT_SUBVECTOR using the provided
2212 /// VTs and return the low/high part.
2213 std::pair<SDValue, SDValue> SplitVector(const SDValue &N, const SDLoc &DL,
2214 const EVT &LoVT, const EVT &HiVT);
2215
2216 /// Split the vector with EXTRACT_SUBVECTOR and return the low/high part.
2217 std::pair<SDValue, SDValue> SplitVector(const SDValue &N, const SDLoc &DL) {
2218 EVT LoVT, HiVT;
2219 std::tie(LoVT, HiVT) = GetSplitDestVTs(N.getValueType());
2220 return SplitVector(N, DL, LoVT, HiVT);
2221 }
2222
2223 /// Split the explicit vector length parameter of a VP operation.
2224 std::pair<SDValue, SDValue> SplitEVL(SDValue N, EVT VecVT, const SDLoc &DL);
2225
2226 /// Split the node's operand with EXTRACT_SUBVECTOR and
2227 /// return the low/high part.
2228 std::pair<SDValue, SDValue> SplitVectorOperand(const SDNode *N, unsigned OpNo)
2229 {
2230 return SplitVector(N->getOperand(OpNo), SDLoc(N));
2231 }
2232
2233 /// Widen the vector up to the next power of two using INSERT_SUBVECTOR.
2234 SDValue WidenVector(const SDValue &N, const SDLoc &DL);
2235
2236 /// Append the extracted elements from Start to Count out of the vector Op in
2237 /// Args. If Count is 0, all of the elements will be extracted. The extracted
2238 /// elements will have type EVT if it is provided, and otherwise their type
2239 /// will be Op's element type.
2241 unsigned Start = 0, unsigned Count = 0,
2242 EVT EltVT = EVT());
2243
2244 /// Compute the default alignment value for the given type.
2245 Align getEVTAlign(EVT MemoryVT) const;
2246
2247 /// Test whether the given value is a constant int or similar node.
2249
2250 /// Test whether the given value is a constant FP or similar node.
2252
2253 /// \returns true if \p N is any kind of constant or build_vector of
2254 /// constants, int or float. If a vector, it may not necessarily be a splat.
2258 }
2259
2260 /// Set CallSiteInfo to be associated with Node.
2262 SDEI[Node].CSInfo = std::move(CallInfo);
2263 }
2264 /// Return CallSiteInfo associated with Node, or a default if none exists.
2266 auto I = SDEI.find(Node);
2267 return I != SDEI.end() ? std::move(I->second).CSInfo : CallSiteInfo();
2268 }
2269 /// Set HeapAllocSite to be associated with Node.
2271 SDEI[Node].HeapAllocSite = MD;
2272 }
2273 /// Return HeapAllocSite associated with Node, or nullptr if none exists.
2275 auto I = SDEI.find(Node);
2276 return I != SDEI.end() ? I->second.HeapAllocSite : nullptr;
2277 }
2278 /// Set PCSections to be associated with Node.
2279 void addPCSections(const SDNode *Node, MDNode *MD) {
2280 SDEI[Node].PCSections = MD;
2281 }
2282 /// Return PCSections associated with Node, or nullptr if none exists.
2284 auto It = SDEI.find(Node);
2285 return It != SDEI.end() ? It->second.PCSections : nullptr;
2286 }
2287 /// Set NoMergeSiteInfo to be associated with Node if NoMerge is true.
2288 void addNoMergeSiteInfo(const SDNode *Node, bool NoMerge) {
2289 if (NoMerge)
2290 SDEI[Node].NoMerge = NoMerge;
2291 }
2292 /// Return NoMerge info associated with Node.
2293 bool getNoMergeSiteInfo(const SDNode *Node) const {
2294 auto I = SDEI.find(Node);
2295 return I != SDEI.end() ? I->second.NoMerge : false;
2296 }
2297
2298 /// Copy extra info associated with one node to another.
2299 void copyExtraInfo(SDNode *From, SDNode *To);
2300
2301 /// Return the current function's default denormal handling kind for the given
2302 /// floating point type.
2304 return MF->getDenormalMode(EVTToAPFloatSemantics(VT));
2305 }
2306
2307 bool shouldOptForSize() const;
2308
2309 /// Get the (commutative) neutral element for the given opcode, if it exists.
2310 SDValue getNeutralElement(unsigned Opcode, const SDLoc &DL, EVT VT,
2311 SDNodeFlags Flags);
2312
2313 /// Some opcodes may create immediate undefined behavior when used with some
2314 /// values (integer division-by-zero for example). Therefore, these operations
2315 /// are not generally safe to move around or change.
2316 bool isSafeToSpeculativelyExecute(unsigned Opcode) const {
2317 switch (Opcode) {
2318 case ISD::SDIV:
2319 case ISD::SREM:
2320 case ISD::SDIVREM:
2321 case ISD::UDIV:
2322 case ISD::UREM:
2323 case ISD::UDIVREM:
2324 return false;
2325 default:
2326 return true;
2327 }
2328 }
2329
2330 /// Check if the provided node is save to speculatively executed given its
2331 /// current arguments. So, while `udiv` the opcode is not safe to
2332 /// speculatively execute, a given `udiv` node may be if the denominator is
2333 /// known nonzero.
2335 switch (N->getOpcode()) {
2336 case ISD::UDIV:
2337 return isKnownNeverZero(N->getOperand(1));
2338 default:
2339 return isSafeToSpeculativelyExecute(N->getOpcode());
2340 }
2341 }
2342
2344 const SDLoc &DLoc);
2345
2346private:
2347 void InsertNode(SDNode *N);
2348 bool RemoveNodeFromCSEMaps(SDNode *N);
2349 void AddModifiedNodeToCSEMaps(SDNode *N);
2350 SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op, void *&InsertPos);
2351 SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op1, SDValue Op2,
2352 void *&InsertPos);
2353 SDNode *FindModifiedNodeSlot(SDNode *N, ArrayRef<SDValue> Ops,
2354 void *&InsertPos);
2355 SDNode *UpdateSDLocOnMergeSDNode(SDNode *N, const SDLoc &loc);
2356
2357 void DeleteNodeNotInCSEMaps(SDNode *N);
2358 void DeallocateNode(SDNode *N);
2359
2360 void allnodes_clear();
2361
2362 /// Look up the node specified by ID in CSEMap. If it exists, return it. If
2363 /// not, return the insertion token that will make insertion faster. This
2364 /// overload is for nodes other than Constant or ConstantFP, use the other one
2365 /// for those.
2366 SDNode *FindNodeOrInsertPos(const FoldingSetNodeID &ID, void *&InsertPos);
2367
2368 /// Look up the node specified by ID in CSEMap. If it exists, return it. If
2369 /// not, return the insertion token that will make insertion faster. Performs
2370 /// additional processing for constant nodes.
2371 SDNode *FindNodeOrInsertPos(const FoldingSetNodeID &ID, const SDLoc &DL,
2372 void *&InsertPos);
2373
2374 /// Maps to auto-CSE operations.
2375 std::vector<CondCodeSDNode*> CondCodeNodes;
2376
2377 std::vector<SDNode*> ValueTypeNodes;
2378 std::map<EVT, SDNode*, EVT::compareRawBits> ExtendedValueTypeNodes;
2379 StringMap<SDNode*> ExternalSymbols;
2380
2381 std::map<std::pair<std::string, unsigned>, SDNode *> TargetExternalSymbols;
2383
2384 FlagInserter *Inserter = nullptr;
2385};
2386
2387template <> struct GraphTraits<SelectionDAG*> : public GraphTraits<SDNode*> {
2389
2391 return nodes_iterator(G->allnodes_begin());
2392 }
2393
2395 return nodes_iterator(G->allnodes_end());
2396 }
2397};
2398
2399} // end namespace llvm
2400
2401#endif // LLVM_CODEGEN_SELECTIONDAG_H
aarch64 AArch64 CCMP Pass
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file defines the StringMap class.
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
This file defines the BumpPtrAllocator interface.
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
RelocType Type
Definition: COFFYAML.cpp:391
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition: Compiler.h:529
This file defines the DenseMap class.
This file defines the DenseSet and SmallDenseSet classes.
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
This file defines a hash set that can be used to remove duplication of nodes in a graph.
Hexagon Vector Combine
#define I(x, y, z)
Definition: MD5.cpp:58
#define G(x, y, z)
Definition: MD5.cpp:56
unsigned Reg
This file contains the declarations for metadata subclasses.
LLVMContext & Context
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
const char LLVMTargetMachineRef TM
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static Constant * ConstantFold(Instruction *I, const DataLayout &DL, const SmallDenseMap< Value *, Constant * > &ConstantPool)
Try to fold instruction I into a constant.
This file defines the SmallVector class.
static void removeOperands(MachineInstr &MI, unsigned i)
Value * RHS
Value * LHS
Class for arbitrary precision integers.
Definition: APInt.h:76
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
Definition: APInt.h:212
static Capacity get(size_t N)
Get the capacity of an array that can hold at least N elements.
Definition: ArrayRecycler.h:79
Recycle small arrays allocated from a BumpPtrAllocator.
Definition: ArrayRecycler.h:28
void deallocate(Capacity Cap, T *Ptr)
Deallocate an array with the specified Capacity.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
The address of a basic block.
Definition: Constants.h:889
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:268
This is the shared class of boolean and integer constants.
Definition: Constants.h:80
This is an important base class in LLVM.
Definition: Constant.h:41
DWARF expression.
Base class for variables.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
A debug info location.
Definition: DebugLoc.h:33
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:155
iterator end()
Definition: DenseMap.h:84
Implements a dense probed hash-table based set.
Definition: DenseSet.h:271
Node - This class is used to maintain the singly linked bucket list in a folding set.
Definition: FoldingSet.h:138
FoldingSetNodeIDRef - This class describes a reference to an interned FoldingSetNodeID,...
Definition: FoldingSet.h:290
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:320
FoldingSet - This template class is used to instantiate a specialized implementation of the folding s...
Definition: FoldingSet.h:528
FunctionLoweringInfo - This contains information that is global to a function that is used when lower...
Data structure describing the variable locations in a function.
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
This class is used to represent ISD::LOAD nodes.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
Metadata node.
Definition: Metadata.h:1067
SimpleValueType SimpleTy
Abstract base class for all machine specific constantpool value subclasses.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
const DataLayout & getDataLayout() const
Return the DataLayout attached to the Module associated to this MF.
A description of a memory reference used in the backend.
Flags
Flags values. These may be or'd together.
@ MOLoad
The memory access reads data.
@ MOStore
The memory access writes data.
An SDNode that represents everything that will be needed to construct a MachineInstr.
The optimization diagnostic interface.
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:94
Analysis providing profile information.
Keeps track of dbg_value information through SDISel.
Definition: SelectionDAG.h:159
BumpPtrAllocator & getAlloc()
Definition: SelectionDAG.h:188
DbgIterator ByvalParmDbgBegin()
Definition: SelectionDAG.h:206
DbgIterator DbgEnd()
Definition: SelectionDAG.h:205
SDDbgInfo & operator=(const SDDbgInfo &)=delete
SmallVectorImpl< SDDbgLabel * >::iterator DbgLabelIterator
Definition: SelectionDAG.h:202
SDDbgInfo()=default
void add(SDDbgValue *V, bool isParameter)
bool empty() const
Definition: SelectionDAG.h:190
DbgLabelIterator DbgLabelEnd()
Definition: SelectionDAG.h:209
DbgIterator ByvalParmDbgEnd()
Definition: SelectionDAG.h:207
SmallVectorImpl< SDDbgValue * >::iterator DbgIterator
Definition: SelectionDAG.h:201
SDDbgInfo(const SDDbgInfo &)=delete
DbgLabelIterator DbgLabelBegin()
Definition: SelectionDAG.h:208
void add(SDDbgLabel *L)
Definition: SelectionDAG.h:174
DbgIterator DbgBegin()
Definition: SelectionDAG.h:204
void erase(const SDNode *Node)
Invalidate all DbgValues attached to the node and remove it from the Node-to-DbgValues map.
ArrayRef< SDDbgValue * > getSDDbgValues(const SDNode *Node) const
Definition: SelectionDAG.h:194
Holds the information from a dbg_label node through SDISel.
Holds the information from a dbg_value node through SDISel.
Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation funct...
Represents one node in the SelectionDAG.
SDVTListNode(const FoldingSetNodeIDRef ID, const EVT *VT, unsigned int Num)
Definition: SelectionDAG.h:112
SDVTList getSDVTList()
Definition: SelectionDAG.h:117
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation.
SDNode * getNode() const
get the SDNode which holds the desired result
EVT getValueType() const
Return the ValueType of the referenced return value.
Targets can subclass this to parameterize the SelectionDAG lowering and instruction selection process...
Help to insert SDNodeFlags automatically in transforming.
Definition: SelectionDAG.h:360
SDNodeFlags getFlags() const
Definition: SelectionDAG.h:378
FlagInserter(SelectionDAG &SDAG, SDNodeFlags Flags)
Definition: SelectionDAG.h:366
FlagInserter(const FlagInserter &)=delete
FlagInserter(SelectionDAG &SDAG, SDNode *N)
Definition: SelectionDAG.h:371
FlagInserter & operator=(const FlagInserter &)=delete
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:225
bool willNotOverflowAdd(bool IsSigned, SDValue N0, SDValue N1) const
Determine if the result of the addition of 2 nodes can never overflow.
static unsigned getOpcode_EXTEND_VECTOR_INREG(unsigned Opcode)
Convert *_EXTEND to *_EXTEND_VECTOR_INREG opcode.
Definition: SelectionDAG.h:923
Align getReducedAlign(EVT VT, bool UseABI)
In most cases this function returns the ABI alignment for a given type, except for illegal vector typ...
SDValue getShiftAmountOperand(EVT LHSTy, SDValue Op)
Return the specified value casted to the target's desired shift amount type.
SDValue getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT, SDValue Chain, SDValue Ptr, MachinePointerInfo PtrInfo, EVT MemVT, MaybeAlign Alignment=MaybeAlign(), MachineMemOperand::Flags MMOFlags=MachineMemOperand::MONone, const AAMDNodes &AAInfo=AAMDNodes())
SDValue getExtLoadVP(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT, SDValue Chain, SDValue Ptr, SDValue Mask, SDValue EVL, MachinePointerInfo PtrInfo, EVT MemVT, MaybeAlign Alignment, MachineMemOperand::Flags MMOFlags, const AAMDNodes &AAInfo, bool IsExpanding=false)
SDValue getTargetGlobalAddress(const GlobalValue *GV, const SDLoc &DL, EVT VT, int64_t offset=0, unsigned TargetFlags=0)
Definition: SelectionDAG.h:721
SDValue getExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT, unsigned Opcode)
Convert Op, which must be of integer type, to the integer type VT, by either any/sign/zero-extending ...
Definition: SelectionDAG.h:953
SDValue getSplatSourceVector(SDValue V, int &SplatIndex)
If V is a splatted value, return the source vector and its splat index.
SDValue getLabelNode(unsigned Opcode, const SDLoc &dl, SDValue Root, MCSymbol *Label)
OverflowKind computeOverflowForUnsignedSub(SDValue N0, SDValue N1) const
Determine if the result of the unsigned sub of 2 nodes can overflow.
unsigned ComputeMaxSignificantBits(SDValue Op, unsigned Depth=0) const
Get the upper bound on bit size for this Value Op as a signed integer.
const SDValue & getRoot() const
Return the root tag of the SelectionDAG.
Definition: SelectionDAG.h:550
SDValue getMemmove(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src, SDValue Size, Align Alignment, bool isVol, bool isTailCall, MachinePointerInfo DstPtrInfo, MachinePointerInfo SrcPtrInfo, const AAMDNodes &AAInfo=AAMDNodes(), AAResults *AA=nullptr)
SDValue getMaskedGather(SDVTList VTs, EVT MemVT, const SDLoc &dl, ArrayRef< SDValue > Ops, MachineMemOperand *MMO, ISD::MemIndexType IndexType, ISD::LoadExtType ExtTy)
bool isKnownNeverSNaN(SDValue Op, unsigned Depth=0) const
SDValue getAddrSpaceCast(const SDLoc &dl, EVT VT, SDValue Ptr, unsigned SrcAS, unsigned DestAS)
Return an AddrSpaceCastSDNode.
SDValue getSelect(const SDLoc &DL, EVT VT, SDValue Cond, SDValue LHS, SDValue RHS)
Helper function to make it easier to build Select's if you just have operands and don't want to check...
SDValue getStackArgumentTokenFactor(SDValue Chain)
Compute a TokenFactor to force all the incoming stack arguments to be loaded from the stack.
const TargetSubtargetInfo & getSubtarget() const
Definition: SelectionDAG.h:473
const APInt * getValidMaximumShiftAmountConstant(SDValue V, const APInt &DemandedElts) const
If a SHL/SRA/SRL node V has constant shift amounts that are all less than the element bit-width of th...
const Pass * getPass() const
Definition: SelectionDAG.h:469
SDValue getMergeValues(ArrayRef< SDValue > Ops, const SDLoc &dl)
Create a MERGE_VALUES node from the given operands.
SDVTList getVTList(EVT VT)
Return an SDVTList that represents the list of values specified.
OptimizationRemarkEmitter & getORE() const
Definition: SelectionDAG.h:485
BlockFrequencyInfo * getBFI() const
Definition: SelectionDAG.h:487
void updateDivergence(SDNode *N)
SDValue getSplatValue(SDValue V, bool LegalTypes=false)
If V is a splat vector, return its scalar source operand by extracting that element from the source v...
SDValue FoldSetCC(EVT VT, SDValue N1, SDValue N2, ISD::CondCode Cond, const SDLoc &dl)
Constant fold a setcc to true or false.
MachineSDNode * getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT)
These are used for target selectors to create a new node with specified return type(s),...
void ExtractVectorElements(SDValue Op, SmallVectorImpl< SDValue > &Args, unsigned Start=0, unsigned Count=0, EVT EltVT=EVT())
Append the extracted elements from Start to Count out of the vector Op in Args.
SDValue getNeutralElement(unsigned Opcode, const SDLoc &DL, EVT VT, SDNodeFlags Flags)
Get the (commutative) neutral element for the given opcode, if it exists.
SDValue getAtomicMemset(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Value, SDValue Size, Type *SizeTy, unsigned ElemSz, bool isTailCall, MachinePointerInfo DstPtrInfo)
bool LegalizeVectors()
This transforms the SelectionDAG into a SelectionDAG that only uses vector math operations supported ...
SDValue getTargetConstantFP(const APFloat &Val, const SDLoc &DL, EVT VT)
Definition: SelectionDAG.h:710
SDValue getVScale(const SDLoc &DL, EVT VT, APInt MulImm, bool ConstantFold=true)
Return a node that represents the runtime scaling 'MulImm * RuntimeVL'.
SDValue getPseudoProbeNode(const SDLoc &Dl, SDValue Chain, uint64_t Guid, uint64_t Index, uint32_t Attr)
Creates a PseudoProbeSDNode with function GUID Guid and the index of the block Index it is probing,...
SDValue getFreeze(SDValue V)
Return a freeze using the SDLoc of the value operand.
SDNode * SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT)
These are used for target selectors to mutate the specified node to have the specified return type,...
SDValue getBitcastedSExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT)
Convert Op, which must be of integer type, to the integer type VT, by first bitcasting (from potentia...
SDValue getConstantPool(const Constant *C, EVT VT, MaybeAlign Align=std::nullopt, int Offs=0, bool isT=false, unsigned TargetFlags=0)
SDValue getStridedLoadVP(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT, const SDLoc &DL, SDValue Chain, SDValue Ptr, SDValue Offset, SDValue Stride, SDValue Mask, SDValue EVL, EVT MemVT, MachineMemOperand *MMO, bool IsExpanding=false)
SDNode * isConstantIntBuildVectorOrConstantInt(SDValue N) const
Test whether the given value is a constant int or similar node.
SDDbgInfo::DbgIterator ByvalParmDbgEnd() const
SDValue getAtomicCmpSwap(unsigned Opcode, const SDLoc &dl, EVT MemVT, SDVTList VTs, SDValue Chain, SDValue Ptr, SDValue Cmp, SDValue Swp, MachineMemOperand *MMO)
Gets a node for an atomic cmpxchg op.
SDValue makeEquivalentMemoryOrdering(SDValue OldChain, SDValue NewMemOpChain)
If an existing load has uses of its chain, create a token factor node with that chain and the new mem...
SDDbgValue * getVRegDbgValue(DIVariable *Var, DIExpression *Expr, unsigned VReg, bool IsIndirect, const DebugLoc &DL, unsigned O)
Creates a VReg SDDbgValue node.
void ReplaceAllUsesOfValuesWith(const SDValue *From, const SDValue *To, unsigned Num)
Like ReplaceAllUsesOfValueWith, but for multiple values at once.
SDValue getJumpTableDebugInfo(int JTI, SDValue Chain, const SDLoc &DL)
SDValue getSetCC(const SDLoc &DL, EVT VT, SDValue LHS, SDValue RHS, ISD::CondCode Cond, SDValue Chain=SDValue(), bool IsSignaling=false)
Helper function to make it easier to build SetCC's if you just have an ISD::CondCode instead of an SD...
SDValue getSymbolFunctionGlobalAddress(SDValue Op, Function **TargetFunction=nullptr)
Return a GlobalAddress of the function from the current module with name matching the given ExternalS...
bool isSafeToSpeculativelyExecute(unsigned Opcode) const
Some opcodes may create immediate undefined behavior when used with some values (integer division-by-...
OverflowKind computeOverflowForSub(bool IsSigned, SDValue N0, SDValue N1) const
Determine if the result of the sub of 2 nodes can overflow.
SDValue UnrollVectorOp(SDNode *N, unsigned ResNE=0)
Utility function used by legalize and lowering to "unroll" a vector operation by splitting out the sc...
SDDbgInfo::DbgIterator ByvalParmDbgBegin() const
void setFunctionLoweringInfo(FunctionLoweringInfo *FuncInfo)
Definition: SelectionDAG.h:460
SDValue getConstantFP(double Val, const SDLoc &DL, EVT VT, bool isTarget=false)
Create a ConstantFPSDNode wrapping a constant value.
OverflowKind
Used to represent the possible overflow behavior of an operation.
bool isADDLike(SDValue Op) const
Return true if the specified operand is an ISD::OR or ISD::XOR node that can be treated as an ISD::AD...
SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, unsigned Reg, SDValue N, SDValue Glue)
Definition: SelectionDAG.h:781
bool haveNoCommonBitsSet(SDValue A, SDValue B) const
Return true if A and B have no common bits set.
bool calculateDivergence(SDNode *N)
SDValue getElementCount(const SDLoc &DL, EVT VT, ElementCount EC, bool ConstantFold=true)
SDValue getGetFPEnv(SDValue Chain, const SDLoc &dl, SDValue Ptr, EVT MemVT, MachineMemOperand *MMO)
SDValue getAssertAlign(const SDLoc &DL, SDValue V, Align A)
Return an AssertAlignSDNode.
SDNode * mutateStrictFPToFP(SDNode *Node)
Mutate the specified strict FP node to its non-strict equivalent, unlinking the node from its chain a...
SDValue getLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr, MachinePointerInfo PtrInfo, MaybeAlign Alignment=MaybeAlign(), MachineMemOperand::Flags MMOFlags=MachineMemOperand::MONone, const AAMDNodes &AAInfo=AAMDNodes(), const MDNode *Ranges=nullptr)
Loads are not normal binary operators: their result type is not determined by their operands,...
SDValue getGLOBAL_OFFSET_TABLE(EVT VT)
Return a GLOBAL_OFFSET_TABLE node. This does not have a useful SDLoc.
SDValue getBitcastedZExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT)
Convert Op, which must be of integer type, to the integer type VT, by first bitcasting (from potentia...
SelectionDAG(const SelectionDAG &)=delete
SDValue getStepVector(const SDLoc &DL, EVT ResVT, const APInt &StepVal)
Returns a vector of type ResVT whose elements contain the linear sequence <0, Step,...
bool willNotOverflowSub(bool IsSigned, SDValue N0, SDValue N1) const
Determine if the result of the sub of 2 nodes can never overflow.
SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT, SDValue Chain, SDValue Ptr, SDValue Val, MachineMemOperand *MMO)
Gets a node for an atomic op, produces result (if relevant) and chain and takes 2 operands.
Align getEVTAlign(EVT MemoryVT) const
Compute the default alignment value for the given type.
void addNoMergeSiteInfo(const SDNode *Node, bool NoMerge)
Set NoMergeSiteInfo to be associated with Node if NoMerge is true.
bool shouldOptForSize() const
std::pair< SDValue, SDValue > SplitVectorOperand(const SDNode *N, unsigned OpNo)
Split the node's operand with EXTRACT_SUBVECTOR and return the low/high part.
SDValue getNOT(const SDLoc &DL, SDValue Val, EVT VT)
Create a bitwise NOT operation as (XOR Val, -1).
SDValue getVPZExtOrTrunc(const SDLoc &DL, EVT VT, SDValue Op, SDValue Mask, SDValue EVL)
Convert a vector-predicated Op, which must be an integer vector, to the vector-type VT,...
const STC & getSubtarget() const
Definition: SelectionDAG.h:474
SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset, MachinePointerInfo PtrInfo, EVT MemVT, MaybeAlign Alignment=MaybeAlign(), MachineMemOperand::Flags MMOFlags=MachineMemOperand::MONone, const AAMDNodes &AAInfo=AAMDNodes(), const MDNode *Ranges=nullptr)
const TargetLowering & getTargetLoweringInfo() const
Definition: SelectionDAG.h:477
bool isEqualTo(SDValue A, SDValue B) const
Test whether two SDValues are known to compare equal.
static constexpr unsigned MaxRecursionDepth
Definition: SelectionDAG.h:447
SDValue getStridedStoreVP(SDValue Chain, const SDLoc &DL, SDValue Val, SDValue Ptr, SDValue Offset, SDValue Stride, SDValue Mask, SDValue EVL, EVT MemVT, MachineMemOperand *MMO, ISD::MemIndexedMode AM, bool IsTruncating=false, bool IsCompressing=false)
bool isGuaranteedNotToBePoison(SDValue Op, unsigned Depth=0) const
Return true if this function can prove that Op is never poison.
SDValue expandVACopy(SDNode *Node)
Expand the specified ISD::VACOPY node as the Legalize pass would.
SDValue getIndexedMaskedLoad(SDValue OrigLoad, const SDLoc &dl, SDValue Base, SDValue Offset, ISD::MemIndexedMode AM)
SelectionDAG & operator=(const SelectionDAG &)=delete
SDValue getTargetConstant(const APInt &Val, const SDLoc &DL, EVT VT, bool isOpaque=false)
Definition: SelectionDAG.h:679
APInt computeVectorKnownZeroElements(SDValue Op, const APInt &DemandedElts, unsigned Depth=0) const
For each demanded element of a vector, see if it is known to be zero.
void AddDbgValue(SDDbgValue *DB, bool isParameter)
Add a dbg_value SDNode.
bool NewNodesMustHaveLegalTypes
When true, additional steps are taken to ensure that getConstant() and similar functions return DAG n...
Definition: SelectionDAG.h:386
std::pair< EVT, EVT > GetSplitDestVTs(const EVT &VT) const
Compute the VTs needed for the low/hi parts of a type which is split (or expanded) into two not neces...
MDNode * getHeapAllocSite(const SDNode *Node) const
Return HeapAllocSite associated with Node, or nullptr if none exists.
void salvageDebugInfo(SDNode &N)
To be invoked on an SDNode that is slated to be erased.
SDNode * MorphNodeTo(SDNode *N, unsigned Opc, SDVTList VTs, ArrayRef< SDValue > Ops)
This mutates the specified node to have the specified return type, opcode, and operands.
SDValue getTargetJumpTable(int JTI, EVT VT, unsigned TargetFlags=0)
Definition: SelectionDAG.h:731
SDValue getLoadVP(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset, SDValue Mask, SDValue EVL, MachinePointerInfo PtrInfo, EVT MemVT, MaybeAlign Alignment=MaybeAlign(), MachineMemOperand::Flags MMOFlags=MachineMemOperand::MONone, const AAMDNodes &AAInfo=AAMDNodes(), const MDNode *Ranges=nullptr, bool IsExpanding=false)
std::pair< SDValue, SDValue > UnrollVectorOverflowOp(SDNode *N, unsigned ResNE=0)
Like UnrollVectorOp(), but for the [US](ADD|SUB|MUL)O family of opcodes.
allnodes_const_iterator allnodes_begin() const
Definition: SelectionDAG.h:530
SDValue getUNDEF(EVT VT)
Return an UNDEF node. UNDEF does not have a useful SDLoc.
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's not CSE'd).
SDValue getGatherVP(SDVTList VTs, EVT VT, const SDLoc &dl, ArrayRef< SDValue > Ops, MachineMemOperand *MMO, ISD::MemIndexType IndexType)
SDValue getBuildVector(EVT VT, const SDLoc &DL, ArrayRef< SDValue > Ops)
Return an ISD::BUILD_VECTOR node.
Definition: SelectionDAG.h:827
SDValue getMemcpy(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src, SDValue Size, Align Alignment, bool isVol, bool AlwaysInline, bool isTailCall, MachinePointerInfo DstPtrInfo, MachinePointerInfo SrcPtrInfo, const AAMDNodes &AAInfo=AAMDNodes(), AAResults *AA=nullptr)
SDValue getBitcastedAnyExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT)
Convert Op, which must be of integer type, to the integer type VT, by first bitcasting (from potentia...
allnodes_const_iterator allnodes_end() const
Definition: SelectionDAG.h:531
bool isSplatValue(SDValue V, const APInt &DemandedElts, APInt &UndefElts, unsigned Depth=0) const
Test whether V has a splatted value for all the demanded elements.
void DeleteNode(SDNode *N)
Remove the specified node from the system.
SDValue getBitcast(EVT VT, SDValue V)
Return a bitcast using the SDLoc of the value operand, and casting to the provided type.
SDDbgValue * getDbgValueList(DIVariable *Var, DIExpression *Expr, ArrayRef< SDDbgOperand > Locs, ArrayRef< SDNode * > Dependencies, bool IsIndirect, const DebugLoc &DL, unsigned O, bool IsVariadic)
Creates a SDDbgValue node from a list of locations.
SDDbgInfo::DbgIterator DbgEnd() const
SDValue getNegative(SDValue Val, const SDLoc &DL, EVT VT)
Create negative operation as (SUB 0, Val).
void setNodeMemRefs(MachineSDNode *N, ArrayRef< MachineMemOperand * > NewMemRefs)
Mutate the specified machine node's memory references to the provided list.
SDValue simplifySelect(SDValue Cond, SDValue TVal, SDValue FVal)
Try to simplify a select/vselect into 1 of its operands or a constant.
CallSiteInfo getCallSiteInfo(const SDNode *Node)
Return CallSiteInfo associated with Node, or a default if none exists.
SDValue getZeroExtendInReg(SDValue Op, const SDLoc &DL, EVT VT)
Return the expression required to zero extend the Op value assuming it was the smaller SrcTy value.
const DataLayout & getDataLayout() const
Definition: SelectionDAG.h:471
SDNode * isConstantFPBuildVectorOrConstantFP(SDValue N) const
Test whether the given value is a constant FP or similar node.
allnodes_iterator allnodes_begin()
Definition: SelectionDAG.h:535
iterator_range< allnodes_const_iterator > allnodes() const
Definition: SelectionDAG.h:545
MDNode * getPCSections(const SDNode *Node) const
Return PCSections associated with Node, or nullptr if none exists.
ProfileSummaryInfo * getPSI() const
Definition: SelectionDAG.h:486
SDValue expandVAArg(SDNode *Node)
Expand the specified ISD::VAARG node as the Legalize pass would.
SDValue getTargetFrameIndex(int FI, EVT VT)
Definition: SelectionDAG.h:726
void Legalize()
This transforms the SelectionDAG into a SelectionDAG that is compatible with the target instruction s...
SDValue getTokenFactor(const SDLoc &DL, SmallVectorImpl< SDValue > &Vals)
Creates a new TokenFactor containing Vals.
void setGraphAttrs(const SDNode *N, const char *Attrs)
Set graph attributes for a node. (eg. "color=red".)
SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, SDValue Reg, SDValue N, SDValue Glue)
Definition: SelectionDAG.h:790
bool LegalizeOp(SDNode *N, SmallSetVector< SDNode *, 16 > &UpdatedNodes)
Transforms a SelectionDAG node and any operands to it into a node that is compatible with the target ...
bool doesNodeExist(unsigned Opcode, SDVTList VTList, ArrayRef< SDValue > Ops)
Check if a node exists without modifying its flags.
void addHeapAllocSite(const SDNode *Node, MDNode *MD)
Set HeapAllocSite to be associated with Node.
const SelectionDAGTargetInfo & getSelectionDAGInfo() const
Definition: SelectionDAG.h:479
bool areNonVolatileConsecutiveLoads(LoadSDNode *LD, LoadSDNode *Base, unsigned Bytes, int Dist) const
Return true if loads are next to each other and can be merged.
SDDbgLabel * getDbgLabel(DILabel *Label, const DebugLoc &DL, unsigned O)
Creates a SDDbgLabel node.
SDValue getTargetConstant(const ConstantInt &Val, const SDLoc &DL, EVT VT, bool isOpaque=false)
Definition: SelectionDAG.h:683
SDValue getStoreVP(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr, SDValue Offset, SDValue Mask, SDValue EVL, EVT MemVT, MachineMemOperand *MMO, ISD::MemIndexedMode AM, bool IsTruncating=false, bool IsCompressing=false)
std::pair< SDValue, SDValue > SplitVector(const SDValue &N, const SDLoc &DL)
Split the vector with EXTRACT_SUBVECTOR and return the low/high part.
OverflowKind computeOverflowForUnsignedMul(SDValue N0, SDValue N1) const
Determine if the result of the unsigned mul of 2 nodes can overflow.
void copyExtraInfo(SDNode *From, SDNode *To)
Copy extra info associated with one node to another.
SDValue getConstant(uint64_t Val, const SDLoc &DL, EVT VT, bool isTarget=false, bool isOpaque=false)
Create a ConstantSDNode wrapping a constant value.
void setGraphColor(const SDNode *N, const char *Color)
Convenience for setting node color attribute.
SDValue getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr, MachinePointerInfo PtrInfo, MaybeAlign Alignment=MaybeAlign(), MachineMemOperand::Flags MMOFlags=MachineMemOperand::MONone, const AAMDNodes &AAInfo=AAMDNodes())
SDValue getMemBasePlusOffset(SDValue Base, TypeSize Offset, const SDLoc &DL, const SDNodeFlags Flags=SDNodeFlags())
Returns sum of the base pointer and offset.
SDValue getGlobalAddress(const GlobalValue *GV, const SDLoc &DL, EVT VT, int64_t offset=0, bool isTargetGA=false, unsigned TargetFlags=0)
bool willNotOverflowMul(bool IsSigned, SDValue N0, SDValue N1) const
Determine if the result of the mul of 2 nodes can never overflow.
SDValue getMemset(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src, SDValue Size, Align Alignment, bool isVol, bool AlwaysInline, bool isTailCall, MachinePointerInfo DstPtrInfo, const AAMDNodes &AAInfo=AAMDNodes())
SDValue getVAArg(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue SV, unsigned Align)
VAArg produces a result and token chain, and takes a pointer and a source value as input.
OverflowKind computeOverflowForMul(bool IsSigned, SDValue N0, SDValue N1) const
Determine if the result of the mul of 2 nodes can overflow.
SDValue getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr, MachinePointerInfo PtrInfo, EVT SVT, Align Alignment, MachineMemOperand::Flags MMOFlags=MachineMemOperand::MONone, const AAMDNodes &AAInfo=AAMDNodes())
SDValue getAllOnesConstant(const SDLoc &DL, EVT VT, bool IsTarget=false, bool IsOpaque=false)
Definition: SelectionDAG.h:658
SDValue getMDNode(const MDNode *MD)
Return an MDNodeSDNode which holds an MDNode.
void clear()
Clear state and free memory necessary to make this SelectionDAG ready to process a new block.
SDValue getCALLSEQ_END(SDValue Chain, uint64_t Size1, uint64_t Size2, SDValue Glue, const SDLoc &DL)
void ReplaceAllUsesWith(SDValue From, SDValue To)
Modify anything using 'From' to use 'To' instead.
SDValue getCommutedVectorShuffle(const ShuffleVectorSDNode &SV)
Returns an ISD::VECTOR_SHUFFLE node semantically equivalent to the shuffle node in input but with swa...
std::pair< SDValue, SDValue > SplitVector(const SDValue &N, const SDLoc &DL, const EVT &LoVT, const EVT &HiVT)
Split the vector with EXTRACT_SUBVECTOR using the provided VTs and return the low/high part.
const APInt * getValidShiftAmountConstant(SDValue V, const APInt &DemandedElts) const
If a SHL/SRA/SRL node V has a constant or splat constant shift amount that is less than the element b...
SDValue makeStateFunctionCall(unsigned LibFunc, SDValue Ptr, SDValue InChain, const SDLoc &DLoc)
Helper used to make a call to a library function that has one argument of pointer type.
bool isGuaranteedNotToBeUndefOrPoison(SDValue Op, bool PoisonOnly=false, unsigned Depth=0) const
Return true if this function can prove that Op is never poison and, if PoisonOnly is false,...
SDValue getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr, MachinePointerInfo PtrInfo, Align Alignment, MachineMemOperand::Flags MMOFlags=MachineMemOperand::MONone, const AAMDNodes &AAInfo=AAMDNodes())
Helper function to build ISD::STORE nodes.
SDValue getIndexedLoadVP(SDValue OrigLoad, const SDLoc &dl, SDValue Base, SDValue Offset, ISD::MemIndexedMode AM)
SDValue getSrcValue(const Value *v)
Construct a node to track a Value* through the backend.
SDValue getSplatVector(EVT VT, const SDLoc &DL, SDValue Op)
Definition: SelectionDAG.h:861
SDValue getMemIntrinsicNode(unsigned Opcode, const SDLoc &dl, SDVTList VTList, ArrayRef< SDValue > Ops, EVT MemVT, MachinePointerInfo PtrInfo, MaybeAlign Alignment=std::nullopt, MachineMemOperand::Flags Flags=MachineMemOperand::MOLoad|MachineMemOperand::MOStore, LocationSize Size=0, const AAMDNodes &AAInfo=AAMDNodes())
SDValue getAtomicMemcpy(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src, SDValue Size, Type *SizeTy, unsigned ElemSz, bool isTailCall, MachinePointerInfo DstPtrInfo, MachinePointerInfo SrcPtrInfo)
OverflowKind computeOverflowForSignedMul(SDValue N0, SDValue N1) const
Determine if the result of the signed mul of 2 nodes can overflow.
MaybeAlign InferPtrAlign(SDValue Ptr) const
Infer alignment of a load / store address.
FlagInserter * getFlagInserter()
Definition: SelectionDAG.h:489
bool MaskedValueIsAllOnes(SDValue Op, const APInt &Mask, unsigned Depth=0) const
Return true if '(Op & Mask) == Mask'.
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 ...
bool hasDebugValues() const
Return true if there are any SDDbgValue nodes associated with this SelectionDAG.
bool SignBitIsZero(SDValue Op, unsigned Depth=0) const
Return true if the sign bit of Op is known to be zero.
SDValue getRegister(unsigned Reg, EVT VT)
void init(MachineFunction &NewMF, OptimizationRemarkEmitter &NewORE, Pass *PassPtr, const TargetLibraryInfo *LibraryInfo, UniformityInfo *UA, ProfileSummaryInfo *PSIin, BlockFrequencyInfo *BFIin, FunctionVarLocs const *FnVarLocs)
Prepare this SelectionDAG to process code in the given MachineFunction.
void RemoveDeadNodes()
This method deletes all unreachable nodes in the SelectionDAG.
void RemoveDeadNode(SDNode *N)
Remove the specified node from the system.
SDValue getBuildVector(EVT VT, const SDLoc &DL, ArrayRef< SDUse > Ops)
Return an ISD::BUILD_VECTOR node.
Definition: SelectionDAG.h:836
void AddDbgLabel(SDDbgLabel *DB)
Add a dbg_label SDNode.
bool isConstantValueOfAnyType(SDValue N) const
SDDbgInfo::DbgLabelIterator DbgLabelEnd() const
SDValue getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr, MachinePointerInfo PtrInfo, EVT SVT, MaybeAlign Alignment=MaybeAlign(), MachineMemOperand::Flags MMOFlags=MachineMemOperand::MONone, const AAMDNodes &AAInfo=AAMDNodes())
allnodes_iterator allnodes_end()
Definition: SelectionDAG.h:536
SDDbgInfo::DbgLabelIterator DbgLabelBegin() const
SDValue getTargetExtractSubreg(int SRIdx, const SDLoc &DL, EVT VT, SDValue Operand)
A convenience function for creating TargetInstrInfo::EXTRACT_SUBREG nodes.
SDValue getBasicBlock(MachineBasicBlock *MBB)
SDValue getSExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT)
Convert Op, which must be of integer type, to the integer type VT, by either sign-extending or trunca...
bool isKnownToBeAPowerOfTwo(SDValue Val, unsigned Depth=0) const
Test if the given value is known to have exactly one bit set.
SDValue getEHLabel(const SDLoc &dl, SDValue Root, MCSymbol *Label)
std::string getGraphAttrs(const SDNode *N) const
Get graph attributes for a node.
SDValue getIndexedStoreVP(SDValue OrigStore, const SDLoc &dl, SDValue Base, SDValue Offset, ISD::MemIndexedMode AM)
bool isKnownNeverZero(SDValue Op, unsigned Depth=0) const
Test whether the given SDValue is known to contain non-zero value(s).
SDValue getIndexedStore(SDValue OrigStore, const SDLoc &dl, SDValue Base, SDValue Offset, ISD::MemIndexedMode AM)
SDValue getSetFPEnv(SDValue Chain, const SDLoc &dl, SDValue Ptr, EVT MemVT, MachineMemOperand *MMO)
SDValue getBoolExtOrTrunc(SDValue Op, const SDLoc &SL, EVT VT, EVT OpVT)
Convert Op, which must be of integer type, to the integer type VT, by using an extension appropriate ...
SDValue getMaskedStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Base, SDValue Offset, SDValue Mask, EVT MemVT, MachineMemOperand *MMO, ISD::MemIndexedMode AM, bool IsTruncating=false, bool IsCompressing=false)
static const fltSemantics & EVTToAPFloatSemantics(EVT VT)
Returns an APFloat semantics tag appropriate for the given type.
SDValue getExternalSymbol(const char *Sym, EVT VT)
const TargetMachine & getTarget() const
Definition: SelectionDAG.h:472
bool getNoMergeSiteInfo(const SDNode *Node) const
Return NoMerge info associated with Node.
std::pair< SDValue, SDValue > getStrictFPExtendOrRound(SDValue Op, SDValue Chain, const SDLoc &DL, EVT VT)
Convert Op, which must be a STRICT operation of float type, to the float type VT, by either extending...
SDValue getObjectPtrOffset(const SDLoc &SL, SDValue Ptr, SDValue Offset)
std::pair< SDValue, SDValue > SplitEVL(SDValue N, EVT VecVT, const SDLoc &DL)
Split the explicit vector length parameter of a VP operation.
SDValue getPtrExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT)
Convert Op, which must be of integer type, to the integer type VT, by either truncating it or perform...
SDValue getVPLogicalNOT(const SDLoc &DL, SDValue Val, SDValue Mask, SDValue EVL, EVT VT)
Create a vector-predicated logical NOT operation as (VP_XOR Val, BooleanOne, Mask,...
SDDbgInfo::DbgIterator DbgBegin() const
SDValue getAnyExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT)
Convert Op, which must be of integer type, to the integer type VT, by either any-extending or truncat...
SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, unsigned Reg, SDValue N)
Definition: SelectionDAG.h:772
iterator_range< allnodes_iterator > allnodes()
Definition: SelectionDAG.h:542
OverflowKind computeOverflowForAdd(bool IsSigned, SDValue N0, SDValue N1) const
Determine if the result of the addition of 2 nodes can overflow.
SDValue getBlockAddress(const BlockAddress *BA, EVT VT, int64_t Offset=0, bool isTarget=false, unsigned TargetFlags=0)
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's if you just have an ISD::CondCode instead of an...
bool isKnownNeverZeroFloat(SDValue Op) const
Test whether the given floating point SDValue is known to never be positive or negative zero.
SDValue getLoadVP(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset, SDValue Mask, SDValue EVL, MachinePointerInfo PtrInfo, EVT MemVT, Align Alignment, MachineMemOperand::Flags MMOFlags, const AAMDNodes &AAInfo, const MDNode *Ranges=nullptr, bool IsExpanding=false)
SDValue getIntPtrConstant(uint64_t Val, const SDLoc &DL, bool isTarget=false)
SDDbgValue * getConstantDbgValue(DIVariable *Var, DIExpression *Expr, const Value *C, const DebugLoc &DL, unsigned O)
Creates a constant SDDbgValue node.
SDValue getScatterVP(SDVTList VTs, EVT VT, const SDLoc &dl, ArrayRef< SDValue > Ops, MachineMemOperand *MMO, ISD::MemIndexType IndexType)
SDValue getValueType(EVT)
SDValue getTargetConstantFP(double Val, const SDLoc &DL, EVT VT)
Definition: SelectionDAG.h:707
ArrayRef< SDDbgValue * > GetDbgValues(const SDNode *SD) const
Get the debug values which reference the given SDNode.
SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, ArrayRef< SDUse > Ops)
Gets or creates the specified node.
OverflowKind computeOverflowForSignedAdd(SDValue N0, SDValue N1) const
Determine if the result of the signed addition of 2 nodes can overflow.
SDValue getFPExtendOrRound(SDValue Op, const SDLoc &DL, EVT VT)
Convert Op, which must be of float type, to the float type VT, by either extending or rounding (by tr...
unsigned AssignTopologicalOrder()
Topological-sort the AllNodes list and a assign a unique node id for each node in the DAG based on th...
ilist< SDNode >::size_type allnodes_size() const
Definition: SelectionDAG.h:538
ilist< SDNode >::const_iterator allnodes_const_iterator
Definition: SelectionDAG.h:528
SDValue getAtomicMemmove(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src, SDValue Size, Type *SizeTy, unsigned ElemSz, bool isTailCall, MachinePointerInfo DstPtrInfo, MachinePointerInfo SrcPtrInfo)
bool isKnownNeverNaN(SDValue Op, bool SNaN=false, unsigned Depth=0) const
Test whether the given SDValue (or all elements of it, if it is a vector) is known to never be NaN.
SDValue getIndexedMaskedStore(SDValue OrigStore, const SDLoc &dl, SDValue Base, SDValue Offset, ISD::MemIndexedMode AM)
SDValue getTruncStoreVP(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr, SDValue Mask, SDValue EVL, MachinePointerInfo PtrInfo, EVT SVT, Align Alignment, MachineMemOperand::Flags MMOFlags, const AAMDNodes &AAInfo, bool IsCompressing=false)
SDValue getTargetConstant(uint64_t Val, const SDLoc &DL, EVT VT, bool isOpaque=false)
Definition: SelectionDAG.h:675
const TargetLibraryInfo & getLibInfo() const
Definition: SelectionDAG.h:478
unsigned ComputeNumSignBits(SDValue Op, unsigned Depth=0) const
Return the number of times the sign bit of the register is replicated into the other bits.
bool MaskedVectorIsZero(SDValue Op, const APInt &DemandedElts, unsigned Depth=0) const
Return true if 'Op' is known to be zero in DemandedElts.
SDValue getBoolConstant(bool V, const SDLoc &DL, EVT VT, EVT OpVT)
Create a true or false constant of type VT using the target's BooleanContent for type OpVT.
SDValue getTargetBlockAddress(const BlockAddress *BA, EVT VT, int64_t Offset=0, unsigned TargetFlags=0)
Definition: SelectionDAG.h:767
SDDbgValue * getFrameIndexDbgValue(DIVariable *Var, DIExpression *Expr, unsigned FI, bool IsIndirect, const DebugLoc &DL, unsigned O)
Creates a FrameIndex SDDbgValue node.
const UniformityInfo * getUniformityInfo() const
Definition: SelectionDAG.h:480
SDValue getExtStridedLoadVP(ISD::LoadExtType ExtType, const SDLoc &DL, EVT VT, SDValue Chain, SDValue Ptr, SDValue Stride, SDValue Mask, SDValue EVL, EVT MemVT, MachineMemOperand *MMO, bool IsExpanding=false)
SDValue getJumpTable(int JTI, EVT VT, bool isTarget=false, unsigned TargetFlags=0)
bool isBaseWithConstantOffset(SDValue Op) const
Return true if the specified operand is an ISD::ADD with a ConstantSDNode on the right-hand side,...
SDValue getVPPtrExtOrTrunc(const SDLoc &DL, EVT VT, SDValue Op, SDValue Mask, SDValue EVL)
Convert a vector-predicated Op, which must be of integer type, to the vector-type integer type VT,...
SDValue getVectorIdxConstant(uint64_t Val, const SDLoc &DL, bool isTarget=false)
void ReplaceAllUsesOfValueWith(SDValue From, SDValue To)
Replace any uses of From with To, leaving uses of other values produced by From.getNode() alone.
MachineFunction & getMachineFunction() const
Definition: SelectionDAG.h:468
SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT)
Definition: SelectionDAG.h:798
SDValue getPtrExtendInReg(SDValue Op, const SDLoc &DL, EVT VT)
Return the expression required to extend the Op as a pointer value assuming it was the smaller SrcTy ...
bool canCreateUndefOrPoison(SDValue Op, const APInt &DemandedElts, bool PoisonOnly=false, bool ConsiderFlags=true, unsigned Depth=0) const
Return true if Op can create undef or poison from non-undef & non-poison operands.
OverflowKind computeOverflowForUnsignedAdd(SDValue N0, SDValue N1) const
Determine if the result of the unsigned addition of 2 nodes can overflow.
void setFlagInserter(FlagInserter *FI)
Definition: SelectionDAG.h:490
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:844
SDValue FoldConstantArithmetic(unsigned Opcode, const SDLoc &DL, EVT VT, ArrayRef< SDValue > Ops)
bool isSafeToSpeculativelyExecuteNode(const SDNode *N) const
Check if the provided node is save to speculatively executed given its current arguments.
SDValue getFrameIndex(int FI, EVT VT, bool isTarget=false)
SDValue getTruncStridedStoreVP(SDValue Chain, const SDLoc &DL, SDValue Val, SDValue Ptr, SDValue Stride, SDValue Mask, SDValue EVL, EVT SVT, MachineMemOperand *MMO, bool IsCompressing=false)
const FunctionVarLocs * getFunctionVarLocs() const
Returns the result of the AssignmentTrackingAnalysis pass if it's available, otherwise return nullptr...
Definition: SelectionDAG.h:483
void canonicalizeCommutativeBinop(unsigned Opcode, SDValue &N1, SDValue &N2) const
Swap N1 and N2 if Opcode is a commutative binary opcode and the canonical form expects the opposite o...
KnownBits computeKnownBits(SDValue Op, unsigned Depth=0) const
Determine which bits of Op are known to be either zero or one and return them in Known.
SDValue getRegisterMask(const uint32_t *RegMask)
SDValue getZExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT)
Convert Op, which must be of integer type, to the integer type VT, by either zero-extending or trunca...
SDValue getCondCode(ISD::CondCode Cond)
SDValue getLifetimeNode(bool IsStart, const SDLoc &dl, SDValue Chain, int FrameIndex, int64_t Size, int64_t Offset=-1)
Creates a LifetimeSDNode that starts (IsStart==true) or ends (IsStart==false) the lifetime of the por...
void addCallSiteInfo(const SDNode *Node, CallSiteInfo &&CallInfo)
Set CallSiteInfo to be associated with Node.
SDValue getExtOrTrunc(bool IsSigned, SDValue Op, const SDLoc &DL, EVT VT)
Convert Op, which must be of integer type, to the integer type VT, by either sign/zero-extending (dep...
Definition: SelectionDAG.h:969
bool MaskedValueIsZero(SDValue Op, const APInt &Mask, unsigned Depth=0) const
Return true if 'Op & Mask' is known to be zero.
OverflowKind computeOverflowForSignedSub(SDValue N0, SDValue N1) const
Determine if the result of the signed sub of 2 nodes can overflow.
SDValue getObjectPtrOffset(const SDLoc &SL, SDValue Ptr, TypeSize Offset)
Create an add instruction with appropriate flags when used for addressing some offset of an object.
LLVMContext * getContext() const
Definition: SelectionDAG.h:484
SDValue simplifyFPBinop(unsigned Opcode, SDValue X, SDValue Y, SDNodeFlags Flags)
Try to simplify a floating-point binary operation into 1 of its operands or a constant.
const SDValue & setRoot(SDValue N)
Set the current root tag of the SelectionDAG.
Definition: SelectionDAG.h:559
const APInt * getValidMinimumShiftAmountConstant(SDValue V, const APInt &DemandedElts) const
If a SHL/SRA/SRL node V has constant shift amounts that are all less than the element bit-width of th...
void addPCSections(const SDNode *Node, MDNode *MD)
Set PCSections to be associated with Node.
SDValue getShiftAmountConstant(uint64_t Val, EVT VT, const SDLoc &DL, bool LegalTypes=true)
bool isGuaranteedNotToBePoison(SDValue Op, const APInt &DemandedElts, unsigned Depth=0) const
Return true if this function can prove that Op is never poison.
SDValue getTargetConstantPool(MachineConstantPoolValue *C, EVT VT, MaybeAlign Align=std::nullopt, int Offset=0, unsigned TargetFlags=0)
Definition: SelectionDAG.h:746
void clearGraphAttrs()
Clear all previously defined node graph attributes.
SDValue getMemIntrinsicNode(unsigned Opcode, const SDLoc &dl, SDVTList VTList, ArrayRef< SDValue > Ops, EVT MemVT, MachinePointerInfo PtrInfo, Align Alignment, MachineMemOperand::Flags Flags=MachineMemOperand::MOLoad|MachineMemOperand::MOStore, LocationSize Size=0, const AAMDNodes &AAInfo=AAMDNodes())
Creates a MemIntrinsicNode that may produce a result and takes a list of operands.
SDValue getTargetExternalSymbol(const char *Sym, EVT VT, unsigned TargetFlags=0)
SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT, SDValue Glue)
Definition: SelectionDAG.h:807
SDValue getMCSymbol(MCSymbol *Sym, EVT VT)
bool isUndef(unsigned Opcode, ArrayRef< SDValue > Ops)
Return true if the result of this operation is always undefined.
SDValue getSetCCVP(const SDLoc &DL, EVT VT, SDValue LHS, SDValue RHS, ISD::CondCode Cond, SDValue Mask, SDValue EVL)
Helper function to make it easier to build VP_SETCCs if you just have an ISD::CondCode instead of an ...
SDValue CreateStackTemporary(TypeSize Bytes, Align Alignment)
Create a stack temporary based on the size in bytes and the alignment.
SDNode * UpdateNodeOperands(SDNode *N, SDValue Op)
Mutate the specified node in-place to have the specified operands.
std::pair< EVT, EVT > GetDependentSplitDestVTs(const EVT &VT, const EVT &EnvVT, bool *HiIsEmpty) const
Compute the VTs needed for the low/hi parts of a type, dependent on an enveloping VT that has been sp...
SDValue foldConstantFPMath(unsigned Opcode, const SDLoc &DL, EVT VT, ArrayRef< SDValue > Ops)
Fold floating-point operations when all operands are constants and/or undefined.
SDNode * getNodeIfExists(unsigned Opcode, SDVTList VTList, ArrayRef< SDValue > Ops, const SDNodeFlags Flags)
Get the specified node if it's already available, or else return NULL.
SDValue getTargetConstantPool(const Constant *C, EVT VT, MaybeAlign Align=std::nullopt, int Offset=0, unsigned TargetFlags=0)
Definition: SelectionDAG.h:738
SDValue FoldSymbolOffset(unsigned Opcode, EVT VT, const GlobalAddressSDNode *GA, const SDNode *N2)
void RepositionNode(allnodes_iterator Position, SDNode *N)
Move node N in the AllNodes list to be immediately before the given iterator Position.
SDValue getIndexedLoad(SDValue OrigLoad, const SDLoc &dl, SDValue Base, SDValue Offset, ISD::MemIndexedMode AM)
SDValue getTargetInsertSubreg(int SRIdx, const SDLoc &DL, EVT VT, SDValue Operand, SDValue Subreg)
A convenience function for creating TargetInstrInfo::INSERT_SUBREG nodes.
SDValue getEntryNode() const
Return the token chain corresponding to the entry of the function.
Definition: SelectionDAG.h:553
SDDbgValue * getDbgValue(DIVariable *Var, DIExpression *Expr, SDNode *N, unsigned R, bool IsIndirect, const DebugLoc &DL, unsigned O)
Creates a SDDbgValue node.
void setSubgraphColor(SDNode *N, const char *Color)
Convenience for setting subgraph color attribute.
SDValue getMaskedLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Base, SDValue Offset, SDValue Mask, SDValue Src0, EVT MemVT, MachineMemOperand *MMO, ISD::MemIndexedMode AM, ISD::LoadExtType, bool IsExpanding=false)
SDValue getTargetConstantFP(const ConstantFP &Val, const SDLoc &DL, EVT VT)
Definition: SelectionDAG.h:713
DenormalMode getDenormalMode(EVT VT) const
Return the current function's default denormal handling kind for the given floating point type.
SDValue getSplat(EVT VT, const SDLoc &DL, SDValue Op)
Returns a node representing a splat of one value into all lanes of the provided vector type.
Definition: SelectionDAG.h:877
std::pair< SDValue, SDValue > SplitScalar(const SDValue &N, const SDLoc &DL, const EVT &LoVT, const EVT &HiVT)
Split the scalar node with EXTRACT_ELEMENT using the provided VTs and return the low/high part.
static unsigned getOpcode_EXTEND(unsigned Opcode)
Convert *_EXTEND_VECTOR_INREG to *_EXTEND opcode.
Definition: SelectionDAG.h:907
SDValue matchBinOpReduction(SDNode *Extract, ISD::NodeType &BinOp, ArrayRef< ISD::NodeType > CandidateBinOps, bool AllowPartials=false)
Match a binop + shuffle pyramid that represents a horizontal reduction over the elements of a vector ...
SDValue getVectorShuffle(EVT VT, const SDLoc &dl, SDValue N1, SDValue N2, ArrayRef< int > Mask)
Return an ISD::VECTOR_SHUFFLE node.
LLVM_DUMP_METHOD void dumpDotGraph(const Twine &FileName, const Twine &Title)
Just dump dot graph to a user-provided path and title.
SDValue simplifyShift(SDValue X, SDValue Y)
Try to simplify a shift into 1 of its operands or a constant.
void transferDbgValues(SDValue From, SDValue To, unsigned OffsetInBits=0, unsigned SizeInBits=0, bool InvalidateDbg=true)
Transfer debug values from one node to another, while optionally generating fragment expressions for ...
SDValue getLogicalNOT(const SDLoc &DL, SDValue Val, EVT VT)
Create a logical NOT operation as (XOR Val, BooleanOne).
SDValue getMaskedScatter(SDVTList VTs, EVT MemVT, const SDLoc &dl, ArrayRef< SDValue > Ops, MachineMemOperand *MMO, ISD::MemIndexType IndexType, bool IsTruncating=false)
ilist< SDNode >::iterator allnodes_iterator
Definition: SelectionDAG.h:533
bool LegalizeTypes()
This transforms the SelectionDAG into a SelectionDAG that only uses types natively supported by the t...
This SDNode is used to implement the code generator support for the llvm IR shufflevector instruction...
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:370
bool empty() const
Definition: SmallVector.h:94
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
typename SuperClass::iterator iterator
Definition: SmallVector.h:590
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:127
Provides information about what library functions are available for the current target.
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:76
TargetSubtargetInfo - Generic base class for all target subtargets.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
pointer remove(iterator &IT)
Definition: ilist.h:188
iterator insert(iterator where, pointer New)
Definition: ilist.h:165
An intrusive list with ownership and callbacks specified/controlled by ilist_traits,...
Definition: ilist.h:328
A range adaptor for a pair of iterators.
This file defines classes to implement an intrusive doubly linked list class (i.e.
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
NodeType
ISD::NodeType enum - This enum defines the target-independent operators for a SelectionDAG.
Definition: ISDOpcodes.h:40
@ SETCC
SetCC operator - This evaluates to a true value iff the condition is true.
Definition: ISDOpcodes.h:750
@ STRICT_FSETCC
STRICT_FSETCC/STRICT_FSETCCS - Constrained versions of SETCC, used for floating-point operands only.
Definition: ISDOpcodes.h:476
@ ConstantFP
Definition: ISDOpcodes.h:77
@ ANY_EXTEND
ANY_EXTEND - Used for integer types. The high bits are undefined.
Definition: ISDOpcodes.h:783
@ SIGN_EXTEND_VECTOR_INREG
SIGN_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register sign-extension of the low ...
Definition: ISDOpcodes.h:820
@ SDIVREM
SDIVREM/UDIVREM - Divide two integers and produce both a quotient and remainder result.
Definition: ISDOpcodes.h:255
@ STRICT_FSETCCS
Definition: ISDOpcodes.h:477
@ SIGN_EXTEND
Conversion operators.
Definition: ISDOpcodes.h:774
@ SELECT
Select(COND, TRUEVAL, FALSEVAL).
Definition: ISDOpcodes.h:727
@ UNDEF
UNDEF - An undefined node.
Definition: ISDOpcodes.h:211
@ SPLAT_VECTOR
SPLAT_VECTOR(VAL) - Returns a vector with the scalar value VAL duplicated in all lanes.
Definition: ISDOpcodes.h:627
@ CopyFromReg
CopyFromReg - This node indicates that the input value is a virtual or physical register that is defi...
Definition: ISDOpcodes.h:208
@ CopyToReg
CopyToReg - This node has three operands: a chain, a register number to set to this value,...
Definition: ISDOpcodes.h:203
@ ZERO_EXTEND
ZERO_EXTEND - Used for integer types, zeroing the new bits.
Definition: ISDOpcodes.h:780
@ SELECT_CC
Select with condition operator - This selects between a true value and a false value (ops #2 and #3) ...
Definition: ISDOpcodes.h:742
@ ANY_EXTEND_VECTOR_INREG
ANY_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register any-extension of the low la...
Definition: ISDOpcodes.h:809
@ GLOBAL_OFFSET_TABLE
The address of the GOT.
Definition: ISDOpcodes.h:87
@ VSELECT
Select with a vector condition (op #0) and two vector operands (ops #1 and #2), returning a vector re...
Definition: ISDOpcodes.h:736
@ ZERO_EXTEND_VECTOR_INREG
ZERO_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register zero-extension of the low ...
Definition: ISDOpcodes.h:831
@ BlockAddress
Definition: ISDOpcodes.h:84
@ CALLSEQ_START
CALLSEQ_START/CALLSEQ_END - These operators mark the beginning and end of a call sequence,...
Definition: ISDOpcodes.h:1140
@ BUILD_VECTOR
BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a fixed-width vector with the specified,...
Definition: ISDOpcodes.h:515
MemIndexType
MemIndexType enum - This enum defines how to interpret MGATHER/SCATTER's index parameter when calcula...
Definition: ISDOpcodes.h:1485
MemIndexedMode
MemIndexedMode enum - This enum defines the load / store indexed addressing modes.
Definition: ISDOpcodes.h:1472
CondCode
ISD::CondCode enum - These are ordered carefully to make the bitfields below work out,...
Definition: ISDOpcodes.h:1523
LoadExtType
LoadExtType enum - This enum defines the three variants of LOADEXT (load with extension).
Definition: ISDOpcodes.h:1503
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
AlignedCharArrayUnion< AtomicSDNode, TargetIndexSDNode, BlockAddressSDNode, GlobalAddressSDNode, PseudoProbeSDNode > LargestSDNode
A representation of the largest SDNode, for use in sizeof().
GenericSSAContext< Function > SSAContext
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
void checkForCycles(const SelectionDAG *DAG, bool force=false)
BumpPtrAllocatorImpl BumpPtrAllocator
The standard BumpPtrAllocator which just uses the default template parameters.
Definition: Allocator.h:375
CodeGenOptLevel
Code generation optimization level.
Definition: CodeGen.h:54
GenericUniformityInfo< SSAContext > UniformityInfo
CombineLevel
Definition: DAGCombine.h:15
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1849
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
#define N
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:760
static const fltSemantics & IEEEsingle() LLVM_READNONE
Definition: APFloat.cpp:249
static const fltSemantics & PPCDoubleDouble() LLVM_READNONE
Definition: APFloat.cpp:252
static const fltSemantics & x87DoubleExtended() LLVM_READNONE
Definition: APFloat.cpp:263
static const fltSemantics & IEEEquad() LLVM_READNONE
Definition: APFloat.cpp:251
static const fltSemantics & IEEEdouble() LLVM_READNONE
Definition: APFloat.cpp:250
static const fltSemantics & IEEEhalf() LLVM_READNONE
Definition: APFloat.cpp:247
static const fltSemantics & BFloat() LLVM_READNONE
Definition: APFloat.cpp:248
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
DefaultFoldingSetTrait - This class provides default implementations for FoldingSetTrait implementati...
Definition: FoldingSet.h:233
Represent subnormal handling kind for floating point instruction inputs and outputs.
Extended Value Type.
Definition: ValueTypes.h:34
uint64_t getScalarSizeInBits() const
Definition: ValueTypes.h:370
MVT getSimpleVT() const
Return the SimpleValueType held in the specified simple EVT.
Definition: ValueTypes.h:306
bool isVector() const
Return true if this is a vector value type.
Definition: ValueTypes.h:167
EVT getScalarType() const
If this is a vector type, return the element type, otherwise return this.
Definition: ValueTypes.h:313
bool isScalableVector() const
Return true if this is a vector type where the runtime length is machine dependent.
Definition: ValueTypes.h:173
EVT getVectorElementType() const
Given a vector type, return the type of each element.
Definition: ValueTypes.h:318
unsigned getVectorNumElements() const
Given a vector type, return the number of elements it contains.
Definition: ValueTypes.h:326
bool bitsLE(EVT VT) const
Return true if this has no more bits than VT.
Definition: ValueTypes.h:298
bool isInteger() const
Return true if this is an integer or a vector integer type.
Definition: ValueTypes.h:151
static bool Equals(const SDVTListNode &X, const FoldingSetNodeID &ID, unsigned IDHash, FoldingSetNodeID &TempID)
Definition: SelectionDAG.h:130
static unsigned ComputeHash(const SDVTListNode &X, FoldingSetNodeID &TempID)
Definition: SelectionDAG.h:137
static void Profile(const SDVTListNode &X, FoldingSetNodeID &ID)
Definition: SelectionDAG.h:126
FoldingSetTrait - This trait class is used to define behavior of how to "profile" (in the FoldingSet ...
Definition: FoldingSet.h:263
static nodes_iterator nodes_begin(SelectionDAG *G)
static nodes_iterator nodes_end(SelectionDAG *G)
This class contains a discriminated union of information about pointers in memory operands,...
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:117
These are IR-level optimization flags that may be propagated to SDNodes.
This represents a list of ValueType's that has been intern'd by a SelectionDAG.
DAGNodeDeletedListener(SelectionDAG &DAG, std::function< void(SDNode *, SDNode *)> Callback)
Definition: SelectionDAG.h:335
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:339
std::function< void(SDNode *, SDNode *)> Callback
Definition: SelectionDAG.h:333
std::function< void(SDNode *)> Callback
Definition: SelectionDAG.h:346
void NodeInserted(SDNode *N) override
The node N that was inserted.
Definition: SelectionDAG.h:352
DAGNodeInsertedListener(SelectionDAG &DAG, std::function< void(SDNode *)> Callback)
Definition: SelectionDAG.h:348
Clients of various APIs that cause global effects on the DAG can optionally implement this interface.
Definition: SelectionDAG.h:306
DAGUpdateListener *const Next
Definition: SelectionDAG.h:307
virtual void NodeDeleted(SDNode *N, SDNode *E)
The node N that was deleted and, if E is not null, an equivalent node E that replaced it.
virtual void NodeInserted(SDNode *N)
The node N that was inserted.
virtual void NodeUpdated(SDNode *N)
The node N that was updated.
static void deleteNode(SDNode *)
Definition: SelectionDAG.h:143
Use delete by default for iplist and ilist.
Definition: ilist.h:41