LLVM 18.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
283
284 struct NodeExtraInfo {
285 CallSiteInfo CSInfo;
286 MDNode *HeapAllocSite = nullptr;
287 MDNode *PCSections = nullptr;
288 bool NoMerge = false;
289 };
290 /// Out-of-line extra information for SDNodes.
292
293 /// PersistentId counter to be used when inserting the next
294 /// SDNode to this SelectionDAG. We do not place that under
295 /// `#if LLVM_ENABLE_ABI_BREAKING_CHECKS` intentionally because
296 /// it adds unneeded complexity without noticeable
297 /// benefits (see discussion with @thakis in D120714).
298 uint16_t NextPersistentId = 0;
299
300public:
301 /// Clients of various APIs that cause global effects on
302 /// the DAG can optionally implement this interface. This allows the clients
303 /// to handle the various sorts of updates that happen.
304 ///
305 /// A DAGUpdateListener automatically registers itself with DAG when it is
306 /// constructed, and removes itself when destroyed in RAII fashion.
310
312 : Next(D.UpdateListeners), DAG(D) {
313 DAG.UpdateListeners = this;
314 }
315
317 assert(DAG.UpdateListeners == this &&
318 "DAGUpdateListeners must be destroyed in LIFO order");
319 DAG.UpdateListeners = Next;
320 }
321
322 /// The node N that was deleted and, if E is not null, an
323 /// equivalent node E that replaced it.
324 virtual void NodeDeleted(SDNode *N, SDNode *E);
325
326 /// The node N that was updated.
327 virtual void NodeUpdated(SDNode *N);
328
329 /// The node N that was inserted.
330 virtual void NodeInserted(SDNode *N);
331 };
332
334 std::function<void(SDNode *, SDNode *)> Callback;
335
337 std::function<void(SDNode *, SDNode *)> Callback)
339
340 void NodeDeleted(SDNode *N, SDNode *E) override { Callback(N, E); }
341
342 private:
343 virtual void anchor();
344 };
345
347 std::function<void(SDNode *)> Callback;
348
350 std::function<void(SDNode *)> Callback)
352
353 void NodeInserted(SDNode *N) override { Callback(N); }
354
355 private:
356 virtual void anchor();
357 };
358
359 /// Help to insert SDNodeFlags automatically in transforming. Use
360 /// RAII to save and resume flags in current scope.
362 SelectionDAG &DAG;
363 SDNodeFlags Flags;
364 FlagInserter *LastInserter;
365
366 public:
368 : DAG(SDAG), Flags(Flags),
369 LastInserter(SDAG.getFlagInserter()) {
370 SDAG.setFlagInserter(this);
371 }
373 : FlagInserter(SDAG, N->getFlags()) {}
374
375 FlagInserter(const FlagInserter &) = delete;
377 ~FlagInserter() { DAG.setFlagInserter(LastInserter); }
378
379 SDNodeFlags getFlags() const { return Flags; }
380 };
381
382 /// When true, additional steps are taken to
383 /// ensure that getConstant() and similar functions return DAG nodes that
384 /// have legal types. This is important after type legalization since
385 /// any illegally typed nodes generated after this point will not experience
386 /// type legalization.
388
389private:
390 /// DAGUpdateListener is a friend so it can manipulate the listener stack.
391 friend struct DAGUpdateListener;
392
393 /// Linked list of registered DAGUpdateListener instances.
394 /// This stack is maintained by DAGUpdateListener RAII.
395 DAGUpdateListener *UpdateListeners = nullptr;
396
397 /// Implementation of setSubgraphColor.
398 /// Return whether we had to truncate the search.
399 bool setSubgraphColorHelper(SDNode *N, const char *Color,
400 DenseSet<SDNode *> &visited,
401 int level, bool &printed);
402
403 template <typename SDNodeT, typename... ArgTypes>
404 SDNodeT *newSDNode(ArgTypes &&... Args) {
405 return new (NodeAllocator.template Allocate<SDNodeT>())
406 SDNodeT(std::forward<ArgTypes>(Args)...);
407 }
408
409 /// Build a synthetic SDNodeT with the given args and extract its subclass
410 /// data as an integer (e.g. for use in a folding set).
411 ///
412 /// The args to this function are the same as the args to SDNodeT's
413 /// constructor, except the second arg (assumed to be a const DebugLoc&) is
414 /// omitted.
415 template <typename SDNodeT, typename... ArgTypes>
416 static uint16_t getSyntheticNodeSubclassData(unsigned IROrder,
417 ArgTypes &&... Args) {
418 // The compiler can reduce this expression to a constant iff we pass an
419 // empty DebugLoc. Thankfully, the debug location doesn't have any bearing
420 // on the subclass data.
421 return SDNodeT(IROrder, DebugLoc(), std::forward<ArgTypes>(Args)...)
422 .getRawSubclassData();
423 }
424
425 template <typename SDNodeTy>
426 static uint16_t getSyntheticNodeSubclassData(unsigned Opc, unsigned Order,
427 SDVTList VTs, EVT MemoryVT,
428 MachineMemOperand *MMO) {
429 return SDNodeTy(Opc, Order, DebugLoc(), VTs, MemoryVT, MMO)
430 .getRawSubclassData();
431 }
432
433 void createOperands(SDNode *Node, ArrayRef<SDValue> Vals);
434
435 void removeOperands(SDNode *Node) {
436 if (!Node->OperandList)
437 return;
438 OperandRecycler.deallocate(
440 Node->OperandList);
441 Node->NumOperands = 0;
442 Node->OperandList = nullptr;
443 }
444 void CreateTopologicalOrder(std::vector<SDNode*>& Order);
445
446public:
447 // Maximum depth for recursive analysis such as computeKnownBits, etc.
448 static constexpr unsigned MaxRecursionDepth = 6;
449
451 SelectionDAG(const SelectionDAG &) = delete;
454
455 /// Prepare this SelectionDAG to process code in the given MachineFunction.
457 Pass *PassPtr, const TargetLibraryInfo *LibraryInfo,
459 BlockFrequencyInfo *BFIin, FunctionVarLocs const *FnVarLocs);
460
462 FLI = FuncInfo;
463 }
464
465 /// Clear state and free memory necessary to make this
466 /// SelectionDAG ready to process a new block.
467 void clear();
468
469 MachineFunction &getMachineFunction() const { return *MF; }
470 const Pass *getPass() const { return SDAGISelPass; }
471
472 const DataLayout &getDataLayout() const { return MF->getDataLayout(); }
473 const TargetMachine &getTarget() const { return TM; }
474 const TargetSubtargetInfo &getSubtarget() const { return MF->getSubtarget(); }
475 template <typename STC> const STC &getSubtarget() const {
476 return MF->getSubtarget<STC>();
477 }
478 const TargetLowering &getTargetLoweringInfo() const { return *TLI; }
479 const TargetLibraryInfo &getLibInfo() const { return *LibInfo; }
480 const SelectionDAGTargetInfo &getSelectionDAGInfo() const { return *TSI; }
481 const UniformityInfo *getUniformityInfo() const { return UA; }
482 /// Returns the result of the AssignmentTrackingAnalysis pass if it's
483 /// available, otherwise return nullptr.
484 const FunctionVarLocs *getFunctionVarLocs() const { return FnVarLocs; }
485 LLVMContext *getContext() const { return Context; }
486 OptimizationRemarkEmitter &getORE() const { return *ORE; }
487 ProfileSummaryInfo *getPSI() const { return PSI; }
488 BlockFrequencyInfo *getBFI() const { return BFI; }
489
490 FlagInserter *getFlagInserter() { return Inserter; }
491 void setFlagInserter(FlagInserter *FI) { Inserter = FI; }
492
493 /// Just dump dot graph to a user-provided path and title.
494 /// This doesn't open the dot viewer program and
495 /// helps visualization when outside debugging session.
496 /// FileName expects absolute path. If provided
497 /// without any path separators then the file
498 /// will be created in the current directory.
499 /// Error will be emitted if the path is insane.
500#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
501 LLVM_DUMP_METHOD void dumpDotGraph(const Twine &FileName, const Twine &Title);
502#endif
503
504 /// Pop up a GraphViz/gv window with the DAG rendered using 'dot'.
505 void viewGraph(const std::string &Title);
506 void viewGraph();
507
508#if LLVM_ENABLE_ABI_BREAKING_CHECKS
509 std::map<const SDNode *, std::string> NodeGraphAttrs;
510#endif
511
512 /// Clear all previously defined node graph attributes.
513 /// Intended to be used from a debugging tool (eg. gdb).
514 void clearGraphAttrs();
515
516 /// Set graph attributes for a node. (eg. "color=red".)
517 void setGraphAttrs(const SDNode *N, const char *Attrs);
518
519 /// Get graph attributes for a node. (eg. "color=red".)
520 /// Used from getNodeAttributes.
521 std::string getGraphAttrs(const SDNode *N) const;
522
523 /// Convenience for setting node color attribute.
524 void setGraphColor(const SDNode *N, const char *Color);
525
526 /// Convenience for setting subgraph color attribute.
527 void setSubgraphColor(SDNode *N, const char *Color);
528
530
531 allnodes_const_iterator allnodes_begin() const { return AllNodes.begin(); }
532 allnodes_const_iterator allnodes_end() const { return AllNodes.end(); }
533
535
536 allnodes_iterator allnodes_begin() { return AllNodes.begin(); }
537 allnodes_iterator allnodes_end() { return AllNodes.end(); }
538
540 return AllNodes.size();
541 }
542
545 }
548 }
549
550 /// Return the root tag of the SelectionDAG.
551 const SDValue &getRoot() const { return Root; }
552
553 /// Return the token chain corresponding to the entry of the function.
555 return SDValue(const_cast<SDNode *>(&EntryNode), 0);
556 }
557
558 /// Set the current root tag of the SelectionDAG.
559 ///
561 assert((!N.getNode() || N.getValueType() == MVT::Other) &&
562 "DAG root value is not a chain!");
563 if (N.getNode())
564 checkForCycles(N.getNode(), this);
565 Root = N;
566 if (N.getNode())
567 checkForCycles(this);
568 return Root;
569 }
570
571#ifndef NDEBUG
572 void VerifyDAGDivergence();
573#endif
574
575 /// This iterates over the nodes in the SelectionDAG, folding
576 /// certain types of nodes together, or eliminating superfluous nodes. The
577 /// Level argument controls whether Combine is allowed to produce nodes and
578 /// types that are illegal on the target.
579 void Combine(CombineLevel Level, AAResults *AA, CodeGenOptLevel OptLevel);
580
581 /// This transforms the SelectionDAG into a SelectionDAG that
582 /// only uses types natively supported by the target.
583 /// Returns "true" if it made any changes.
584 ///
585 /// Note that this is an involved process that may invalidate pointers into
586 /// the graph.
587 bool LegalizeTypes();
588
589 /// This transforms the SelectionDAG into a SelectionDAG that is
590 /// compatible with the target instruction selector, as indicated by the
591 /// TargetLowering object.
592 ///
593 /// Note that this is an involved process that may invalidate pointers into
594 /// the graph.
595 void Legalize();
596
597 /// Transforms a SelectionDAG node and any operands to it into a node
598 /// that is compatible with the target instruction selector, as indicated by
599 /// the TargetLowering object.
600 ///
601 /// \returns true if \c N is a valid, legal node after calling this.
602 ///
603 /// This essentially runs a single recursive walk of the \c Legalize process
604 /// over the given node (and its operands). This can be used to incrementally
605 /// legalize the DAG. All of the nodes which are directly replaced,
606 /// potentially including N, are added to the output parameter \c
607 /// UpdatedNodes so that the delta to the DAG can be understood by the
608 /// caller.
609 ///
610 /// When this returns false, N has been legalized in a way that make the
611 /// pointer passed in no longer valid. It may have even been deleted from the
612 /// DAG, and so it shouldn't be used further. When this returns true, the
613 /// N passed in is a legal node, and can be immediately processed as such.
614 /// This may still have done some work on the DAG, and will still populate
615 /// UpdatedNodes with any new nodes replacing those originally in the DAG.
616 bool LegalizeOp(SDNode *N, SmallSetVector<SDNode *, 16> &UpdatedNodes);
617
618 /// This transforms the SelectionDAG into a SelectionDAG
619 /// that only uses vector math operations supported by the target. This is
620 /// necessary as a separate step from Legalize because unrolling a vector
621 /// operation can introduce illegal types, which requires running
622 /// LegalizeTypes again.
623 ///
624 /// This returns true if it made any changes; in that case, LegalizeTypes
625 /// is called again before Legalize.
626 ///
627 /// Note that this is an involved process that may invalidate pointers into
628 /// the graph.
629 bool LegalizeVectors();
630
631 /// This method deletes all unreachable nodes in the SelectionDAG.
632 void RemoveDeadNodes();
633
634 /// Remove the specified node from the system. This node must
635 /// have no referrers.
636 void DeleteNode(SDNode *N);
637
638 /// Return an SDVTList that represents the list of values specified.
640 SDVTList getVTList(EVT VT1, EVT VT2);
641 SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3);
642 SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4);
644
645 //===--------------------------------------------------------------------===//
646 // Node creation methods.
647
648 /// Create a ConstantSDNode wrapping a constant value.
649 /// If VT is a vector type, the constant is splatted into a BUILD_VECTOR.
650 ///
651 /// If only legal types can be produced, this does the necessary
652 /// transformations (e.g., if the vector element type is illegal).
653 /// @{
654 SDValue getConstant(uint64_t Val, const SDLoc &DL, EVT VT,
655 bool isTarget = false, bool isOpaque = false);
656 SDValue getConstant(const APInt &Val, const SDLoc &DL, EVT VT,
657 bool isTarget = false, bool isOpaque = false);
658
659 SDValue getAllOnesConstant(const SDLoc &DL, EVT VT, bool IsTarget = false,
660 bool IsOpaque = false) {
662 IsTarget, IsOpaque);
663 }
664
665 SDValue getConstant(const ConstantInt &Val, const SDLoc &DL, EVT VT,
666 bool isTarget = false, bool isOpaque = false);
668 bool isTarget = false);
670 bool LegalTypes = true);
672 bool isTarget = false);
673
675 bool isOpaque = false) {
676 return getConstant(Val, DL, VT, true, isOpaque);
677 }
678 SDValue getTargetConstant(const APInt &Val, const SDLoc &DL, EVT VT,
679 bool isOpaque = false) {
680 return getConstant(Val, DL, VT, true, isOpaque);
681 }
683 bool isOpaque = false) {
684 return getConstant(Val, DL, VT, true, isOpaque);
685 }
686
687 /// Create a true or false constant of type \p VT using the target's
688 /// BooleanContent for type \p OpVT.
689 SDValue getBoolConstant(bool V, const SDLoc &DL, EVT VT, EVT OpVT);
690 /// @}
691
692 /// Create a ConstantFPSDNode wrapping a constant value.
693 /// If VT is a vector type, the constant is splatted into a BUILD_VECTOR.
694 ///
695 /// If only legal types can be produced, this does the necessary
696 /// transformations (e.g., if the vector element type is illegal).
697 /// The forms that take a double should only be used for simple constants
698 /// that can be exactly represented in VT. No checks are made.
699 /// @{
700 SDValue getConstantFP(double Val, const SDLoc &DL, EVT VT,
701 bool isTarget = false);
702 SDValue getConstantFP(const APFloat &Val, const SDLoc &DL, EVT VT,
703 bool isTarget = false);
704 SDValue getConstantFP(const ConstantFP &V, const SDLoc &DL, EVT VT,
705 bool isTarget = false);
706 SDValue getTargetConstantFP(double Val, const SDLoc &DL, EVT VT) {
707 return getConstantFP(Val, DL, VT, true);
708 }
709 SDValue getTargetConstantFP(const APFloat &Val, const SDLoc &DL, EVT VT) {
710 return getConstantFP(Val, DL, VT, true);
711 }
713 return getConstantFP(Val, DL, VT, true);
714 }
715 /// @}
716
717 SDValue getGlobalAddress(const GlobalValue *GV, const SDLoc &DL, EVT VT,
718 int64_t offset = 0, bool isTargetGA = false,
719 unsigned TargetFlags = 0);
721 int64_t offset = 0, unsigned TargetFlags = 0) {
722 return getGlobalAddress(GV, DL, VT, offset, true, TargetFlags);
723 }
724 SDValue getFrameIndex(int FI, EVT VT, bool isTarget = false);
726 return getFrameIndex(FI, VT, true);
727 }
728 SDValue getJumpTable(int JTI, EVT VT, bool isTarget = false,
729 unsigned TargetFlags = 0);
730 SDValue getTargetJumpTable(int JTI, EVT VT, unsigned TargetFlags = 0) {
731 return getJumpTable(JTI, VT, true, TargetFlags);
732 }
733 SDValue getJumpTableDebugInfo(int JTI, SDValue Chain, const SDLoc &DL);
735 MaybeAlign Align = std::nullopt, int Offs = 0,
736 bool isT = false, unsigned TargetFlags = 0);
738 MaybeAlign Align = std::nullopt, int Offset = 0,
739 unsigned TargetFlags = 0) {
740 return getConstantPool(C, VT, Align, Offset, true, TargetFlags);
741 }
743 MaybeAlign Align = std::nullopt, int Offs = 0,
744 bool isT = false, unsigned TargetFlags = 0);
746 MaybeAlign Align = std::nullopt, int Offset = 0,
747 unsigned TargetFlags = 0) {
748 return getConstantPool(C, VT, Align, Offset, true, TargetFlags);
749 }
750 // When generating a branch to a BB, we don't in general know enough
751 // to provide debug info for the BB at that time, so keep this one around.
753 SDValue getExternalSymbol(const char *Sym, EVT VT);
754 SDValue getTargetExternalSymbol(const char *Sym, EVT VT,
755 unsigned TargetFlags = 0);
757
759 SDValue getRegister(unsigned Reg, EVT VT);
761 SDValue getEHLabel(const SDLoc &dl, SDValue Root, MCSymbol *Label);
762 SDValue getLabelNode(unsigned Opcode, const SDLoc &dl, SDValue Root,
763 MCSymbol *Label);
764 SDValue getBlockAddress(const BlockAddress *BA, EVT VT, int64_t Offset = 0,
765 bool isTarget = false, unsigned TargetFlags = 0);
767 int64_t Offset = 0, unsigned TargetFlags = 0) {
768 return getBlockAddress(BA, VT, Offset, true, TargetFlags);
769 }
770
771 SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, unsigned Reg,
772 SDValue N) {
773 return getNode(ISD::CopyToReg, dl, MVT::Other, Chain,
774 getRegister(Reg, N.getValueType()), N);
775 }
776
777 // This version of the getCopyToReg method takes an extra operand, which
778 // indicates that there is potentially an incoming glue value (if Glue is not
779 // null) and that there should be a glue result.
780 SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, unsigned Reg, SDValue N,
781 SDValue Glue) {
782 SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
783 SDValue Ops[] = { Chain, getRegister(Reg, N.getValueType()), N, Glue };
784 return getNode(ISD::CopyToReg, dl, VTs,
785 ArrayRef(Ops, Glue.getNode() ? 4 : 3));
786 }
787
788 // Similar to last getCopyToReg() except parameter Reg is a SDValue
790 SDValue Glue) {
791 SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
792 SDValue Ops[] = { Chain, Reg, N, Glue };
793 return getNode(ISD::CopyToReg, dl, VTs,
794 ArrayRef(Ops, Glue.getNode() ? 4 : 3));
795 }
796
797 SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT) {
798 SDVTList VTs = getVTList(VT, MVT::Other);
799 SDValue Ops[] = { Chain, getRegister(Reg, VT) };
800 return getNode(ISD::CopyFromReg, dl, VTs, Ops);
801 }
802
803 // This version of the getCopyFromReg method takes an extra operand, which
804 // indicates that there is potentially an incoming glue value (if Glue is not
805 // null) and that there should be a glue result.
806 SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT,
807 SDValue Glue) {
808 SDVTList VTs = getVTList(VT, MVT::Other, MVT::Glue);
809 SDValue Ops[] = { Chain, getRegister(Reg, VT), Glue };
810 return getNode(ISD::CopyFromReg, dl, VTs,
811 ArrayRef(Ops, Glue.getNode() ? 3 : 2));
812 }
813
815
816 /// Return an ISD::VECTOR_SHUFFLE node. The number of elements in VT,
817 /// which must be a vector type, must match the number of mask elements
818 /// NumElts. An integer mask element equal to -1 is treated as undefined.
819 SDValue getVectorShuffle(EVT VT, const SDLoc &dl, SDValue N1, SDValue N2,
820 ArrayRef<int> Mask);
821
822 /// Return an ISD::BUILD_VECTOR node. The number of elements in VT,
823 /// which must be a vector type, must match the number of operands in Ops.
824 /// The operands must have the same type as (or, for integers, a type wider
825 /// than) VT's element type.
827 // VerifySDNode (via InsertNode) checks BUILD_VECTOR later.
828 return getNode(ISD::BUILD_VECTOR, DL, VT, Ops);
829 }
830
831 /// Return an ISD::BUILD_VECTOR node. The number of elements in VT,
832 /// which must be a vector type, must match the number of operands in Ops.
833 /// The operands must have the same type as (or, for integers, a type wider
834 /// than) VT's element type.
836 // VerifySDNode (via InsertNode) checks BUILD_VECTOR later.
837 return getNode(ISD::BUILD_VECTOR, DL, VT, Ops);
838 }
839
840 /// Return a splat ISD::BUILD_VECTOR node, consisting of Op splatted to all
841 /// elements. VT must be a vector type. Op's type must be the same as (or,
842 /// for integers, a type wider than) VT's element type.
844 // VerifySDNode (via InsertNode) checks BUILD_VECTOR later.
845 if (Op.getOpcode() == ISD::UNDEF) {
846 assert((VT.getVectorElementType() == Op.getValueType() ||
847 (VT.isInteger() &&
848 VT.getVectorElementType().bitsLE(Op.getValueType()))) &&
849 "A splatted value must have a width equal or (for integers) "
850 "greater than the vector element type!");
851 return getNode(ISD::UNDEF, SDLoc(), VT);
852 }
853
855 return getNode(ISD::BUILD_VECTOR, DL, VT, Ops);
856 }
857
858 // Return a splat ISD::SPLAT_VECTOR node, consisting of Op splatted to all
859 // elements.
861 if (Op.getOpcode() == ISD::UNDEF) {
862 assert((VT.getVectorElementType() == Op.getValueType() ||
863 (VT.isInteger() &&
864 VT.getVectorElementType().bitsLE(Op.getValueType()))) &&
865 "A splatted value must have a width equal or (for integers) "
866 "greater than the vector element type!");
867 return getNode(ISD::UNDEF, SDLoc(), VT);
868 }
869 return getNode(ISD::SPLAT_VECTOR, DL, VT, Op);
870 }
871
872 /// Returns a node representing a splat of one value into all lanes
873 /// of the provided vector type. This is a utility which returns
874 /// either a BUILD_VECTOR or SPLAT_VECTOR depending on the
875 /// scalability of the desired vector type.
877 assert(VT.isVector() && "Can't splat to non-vector type");
878 return VT.isScalableVector() ?
880 }
881
882 /// Returns a vector of type ResVT whose elements contain the linear sequence
883 /// <0, Step, Step * 2, Step * 3, ...>
884 SDValue getStepVector(const SDLoc &DL, EVT ResVT, APInt StepVal);
885
886 /// Returns a vector of type ResVT whose elements contain the linear sequence
887 /// <0, 1, 2, 3, ...>
888 SDValue getStepVector(const SDLoc &DL, EVT ResVT);
889
890 /// Returns an ISD::VECTOR_SHUFFLE node semantically equivalent to
891 /// the shuffle node in input but with swapped operands.
892 ///
893 /// Example: shuffle A, B, <0,5,2,7> -> shuffle B, A, <4,1,6,3>
895
896 /// Convert Op, which must be of float type, to the
897 /// float type VT, by either extending or rounding (by truncation).
899
900 /// Convert Op, which must be a STRICT operation of float type, to the
901 /// float type VT, by either extending or rounding (by truncation).
902 std::pair<SDValue, SDValue>
904
905 /// Convert *_EXTEND_VECTOR_INREG to *_EXTEND opcode.
906 static unsigned getOpcode_EXTEND(unsigned Opcode) {
907 switch (Opcode) {
908 case ISD::ANY_EXTEND:
910 return ISD::ANY_EXTEND;
911 case ISD::ZERO_EXTEND:
913 return ISD::ZERO_EXTEND;
914 case ISD::SIGN_EXTEND:
916 return ISD::SIGN_EXTEND;
917 }
918 llvm_unreachable("Unknown opcode");
919 }
920
921 /// Convert *_EXTEND to *_EXTEND_VECTOR_INREG opcode.
922 static unsigned getOpcode_EXTEND_VECTOR_INREG(unsigned Opcode) {
923 switch (Opcode) {
924 case ISD::ANY_EXTEND:
927 case ISD::ZERO_EXTEND:
930 case ISD::SIGN_EXTEND:
933 }
934 llvm_unreachable("Unknown opcode");
935 }
936
937 /// Convert Op, which must be of integer type, to the
938 /// integer type VT, by either any-extending or truncating it.
940
941 /// Convert Op, which must be of integer type, to the
942 /// integer type VT, by either sign-extending or truncating it.
944
945 /// Convert Op, which must be of integer type, to the
946 /// integer type VT, by either zero-extending or truncating it.
948
949 /// Convert Op, which must be of integer type, to the
950 /// integer type VT, by either any/sign/zero-extending (depending on IsAny /
951 /// IsSigned) or truncating it.
953 EVT VT, unsigned Opcode) {
954 switch(Opcode) {
955 case ISD::ANY_EXTEND:
956 return getAnyExtOrTrunc(Op, DL, VT);
957 case ISD::ZERO_EXTEND:
958 return getZExtOrTrunc(Op, DL, VT);
959 case ISD::SIGN_EXTEND:
960 return getSExtOrTrunc(Op, DL, VT);
961 }
962 llvm_unreachable("Unsupported opcode");
963 }
964
965 /// Convert Op, which must be of integer type, to the
966 /// integer type VT, by either sign/zero-extending (depending on IsSigned) or
967 /// truncating it.
968 SDValue getExtOrTrunc(bool IsSigned, SDValue Op, const SDLoc &DL, EVT VT) {
969 return IsSigned ? getSExtOrTrunc(Op, DL, VT) : getZExtOrTrunc(Op, DL, VT);
970 }
971
972 /// Convert Op, which must be of integer type, to the
973 /// integer type VT, by first bitcasting (from potential vector) to
974 /// corresponding scalar type then either any-extending or truncating it.
976
977 /// Convert Op, which must be of integer type, to the
978 /// integer type VT, by first bitcasting (from potential vector) to
979 /// corresponding scalar type then either sign-extending or truncating it.
981
982 /// Convert Op, which must be of integer type, to the
983 /// integer type VT, by first bitcasting (from potential vector) to
984 /// corresponding scalar type then either zero-extending or truncating it.
986
987 /// Return the expression required to zero extend the Op
988 /// value assuming it was the smaller SrcTy value.
990
991 /// Convert Op, which must be of integer type, to the integer type VT, by
992 /// either truncating it or performing either zero or sign extension as
993 /// appropriate extension for the pointer's semantics.
995
996 /// Return the expression required to extend the Op as a pointer value
997 /// assuming it was the smaller SrcTy value. This may be either a zero extend
998 /// or a sign extend.
1000
1001 /// Convert Op, which must be of integer type, to the integer type VT,
1002 /// by using an extension appropriate for the target's
1003 /// BooleanContent for type OpVT or truncating it.
1004 SDValue getBoolExtOrTrunc(SDValue Op, const SDLoc &SL, EVT VT, EVT OpVT);
1005
1006 /// Create negative operation as (SUB 0, Val).
1007 SDValue getNegative(SDValue Val, const SDLoc &DL, EVT VT);
1008
1009 /// Create a bitwise NOT operation as (XOR Val, -1).
1010 SDValue getNOT(const SDLoc &DL, SDValue Val, EVT VT);
1011
1012 /// Create a logical NOT operation as (XOR Val, BooleanOne).
1013 SDValue getLogicalNOT(const SDLoc &DL, SDValue Val, EVT VT);
1014
1015 /// Create a vector-predicated logical NOT operation as (VP_XOR Val,
1016 /// BooleanOne, Mask, EVL).
1017 SDValue getVPLogicalNOT(const SDLoc &DL, SDValue Val, SDValue Mask,
1018 SDValue EVL, EVT VT);
1019
1020 /// Convert a vector-predicated Op, which must be an integer vector, to the
1021 /// vector-type VT, by performing either vector-predicated zext or truncating
1022 /// it. The Op will be returned as-is if Op and VT are vectors containing
1023 /// integer with same width.
1025 SDValue EVL);
1026
1027 /// Convert a vector-predicated Op, which must be of integer type, to the
1028 /// vector-type integer type VT, by either truncating it or performing either
1029 /// vector-predicated zero or sign extension as appropriate extension for the
1030 /// pointer's semantics. This function just redirects to getVPZExtOrTrunc
1031 /// right now.
1033 SDValue EVL);
1034
1035 /// Returns sum of the base pointer and offset.
1036 /// Unlike getObjectPtrOffset this does not set NoUnsignedWrap by default.
1038 const SDNodeFlags Flags = SDNodeFlags());
1040 const SDNodeFlags Flags = SDNodeFlags());
1041
1042 /// Create an add instruction with appropriate flags when used for
1043 /// addressing some offset of an object. i.e. if a load is split into multiple
1044 /// components, create an add nuw from the base pointer to the offset.
1046 SDNodeFlags Flags;
1047 Flags.setNoUnsignedWrap(true);
1048 return getMemBasePlusOffset(Ptr, Offset, SL, Flags);
1049 }
1050
1052 // The object itself can't wrap around the address space, so it shouldn't be
1053 // possible for the adds of the offsets to the split parts to overflow.
1054 SDNodeFlags Flags;
1055 Flags.setNoUnsignedWrap(true);
1056 return getMemBasePlusOffset(Ptr, Offset, SL, Flags);
1057 }
1058
1059 /// Return a new CALLSEQ_START node, that starts new call frame, in which
1060 /// InSize bytes are set up inside CALLSEQ_START..CALLSEQ_END sequence and
1061 /// OutSize specifies part of the frame set up prior to the sequence.
1063 const SDLoc &DL) {
1064 SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
1065 SDValue Ops[] = { Chain,
1066 getIntPtrConstant(InSize, DL, true),
1067 getIntPtrConstant(OutSize, DL, true) };
1068 return getNode(ISD::CALLSEQ_START, DL, VTs, Ops);
1069 }
1070
1071 /// Return a new CALLSEQ_END node, which always must have a
1072 /// glue result (to ensure it's not CSE'd).
1073 /// CALLSEQ_END does not have a useful SDLoc.
1075 SDValue InGlue, const SDLoc &DL) {
1076 SDVTList NodeTys = getVTList(MVT::Other, MVT::Glue);
1078 Ops.push_back(Chain);
1079 Ops.push_back(Op1);
1080 Ops.push_back(Op2);
1081 if (InGlue.getNode())
1082 Ops.push_back(InGlue);
1083 return getNode(ISD::CALLSEQ_END, DL, NodeTys, Ops);
1084 }
1085
1087 SDValue Glue, const SDLoc &DL) {
1088 return getCALLSEQ_END(
1089 Chain, getIntPtrConstant(Size1, DL, /*isTarget=*/true),
1090 getIntPtrConstant(Size2, DL, /*isTarget=*/true), Glue, DL);
1091 }
1092
1093 /// Return true if the result of this operation is always undefined.
1094 bool isUndef(unsigned Opcode, ArrayRef<SDValue> Ops);
1095
1096 /// Return an UNDEF node. UNDEF does not have a useful SDLoc.
1098 return getNode(ISD::UNDEF, SDLoc(), VT);
1099 }
1100
1101 /// Return a node that represents the runtime scaling 'MulImm * RuntimeVL'.
1102 SDValue getVScale(const SDLoc &DL, EVT VT, APInt MulImm,
1103 bool ConstantFold = true);
1104
1106 bool ConstantFold = true);
1107
1108 /// Return a GLOBAL_OFFSET_TABLE node. This does not have a useful SDLoc.
1110 return getNode(ISD::GLOBAL_OFFSET_TABLE, SDLoc(), VT);
1111 }
1112
1113 /// Gets or creates the specified node.
1114 ///
1115 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
1116 ArrayRef<SDUse> Ops);
1117 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
1118 ArrayRef<SDValue> Ops, const SDNodeFlags Flags);
1119 SDValue getNode(unsigned Opcode, const SDLoc &DL, ArrayRef<EVT> ResultTys,
1120 ArrayRef<SDValue> Ops);
1121 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList,
1122 ArrayRef<SDValue> Ops, const SDNodeFlags Flags);
1123
1124 // Use flags from current flag inserter.
1125 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
1126 ArrayRef<SDValue> Ops);
1127 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList,
1128 ArrayRef<SDValue> Ops);
1129 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue Operand);
1130 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
1131 SDValue N2);
1132 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
1133 SDValue N2, SDValue N3);
1134
1135 // Specialize based on number of operands.
1136 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT);
1137 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue Operand,
1138 const SDNodeFlags Flags);
1139 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
1140 SDValue N2, const SDNodeFlags Flags);
1141 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
1142 SDValue N2, SDValue N3, const SDNodeFlags Flags);
1143 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
1144 SDValue N2, SDValue N3, SDValue N4);
1145 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
1146 SDValue N2, SDValue N3, SDValue N4, SDValue N5);
1147
1148 // Specialize again based on number of operands for nodes with a VTList
1149 // rather than a single VT.
1150 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList);
1151 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N);
1152 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N1,
1153 SDValue N2);
1154 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N1,
1155 SDValue N2, SDValue N3);
1156 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N1,
1157 SDValue N2, SDValue N3, SDValue N4);
1158 SDValue getNode(unsigned Opcode, const SDLoc &DL, SDVTList VTList, SDValue N1,
1159 SDValue N2, SDValue N3, SDValue N4, SDValue N5);
1160
1161 /// Compute a TokenFactor to force all the incoming stack arguments to be
1162 /// loaded from the stack. This is used in tail call lowering to protect
1163 /// stack arguments from being clobbered.
1165
1166 SDValue getMemcpy(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src,
1167 SDValue Size, Align Alignment, bool isVol,
1168 bool AlwaysInline, bool isTailCall,
1169 MachinePointerInfo DstPtrInfo,
1170 MachinePointerInfo SrcPtrInfo,
1171 const AAMDNodes &AAInfo = AAMDNodes(),
1172 AAResults *AA = nullptr);
1173
1174 SDValue getMemmove(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src,
1175 SDValue Size, Align Alignment, bool isVol, bool isTailCall,
1176 MachinePointerInfo DstPtrInfo,
1177 MachinePointerInfo SrcPtrInfo,
1178 const AAMDNodes &AAInfo = AAMDNodes(),
1179 AAResults *AA = nullptr);
1180
1181 SDValue getMemset(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src,
1182 SDValue Size, Align Alignment, bool isVol,
1183 bool AlwaysInline, bool isTailCall,
1184 MachinePointerInfo DstPtrInfo,
1185 const AAMDNodes &AAInfo = AAMDNodes());
1186
1187 SDValue getAtomicMemcpy(SDValue Chain, const SDLoc &dl, SDValue Dst,
1188 SDValue Src, SDValue Size, Type *SizeTy,
1189 unsigned ElemSz, bool isTailCall,
1190 MachinePointerInfo DstPtrInfo,
1191 MachinePointerInfo SrcPtrInfo);
1192
1193 SDValue getAtomicMemmove(SDValue Chain, const SDLoc &dl, SDValue Dst,
1194 SDValue Src, SDValue Size, Type *SizeTy,
1195 unsigned ElemSz, bool isTailCall,
1196 MachinePointerInfo DstPtrInfo,
1197 MachinePointerInfo SrcPtrInfo);
1198
1199 SDValue getAtomicMemset(SDValue Chain, const SDLoc &dl, SDValue Dst,
1200 SDValue Value, SDValue Size, Type *SizeTy,
1201 unsigned ElemSz, bool isTailCall,
1202 MachinePointerInfo DstPtrInfo);
1203
1204 /// Helper function to make it easier to build SetCC's if you just have an
1205 /// ISD::CondCode instead of an SDValue.
1207 ISD::CondCode Cond, SDValue Chain = SDValue(),
1208 bool IsSignaling = false) {
1209 assert(LHS.getValueType().isVector() == RHS.getValueType().isVector() &&
1210 "Vector/scalar operand type mismatch for setcc");
1211 assert(LHS.getValueType().isVector() == VT.isVector() &&
1212 "Vector/scalar result type mismatch for setcc");
1214 "Cannot create a setCC of an invalid node.");
1215 if (Chain)
1216 return getNode(IsSignaling ? ISD::STRICT_FSETCCS : ISD::STRICT_FSETCC, DL,
1217 {VT, MVT::Other}, {Chain, LHS, RHS, getCondCode(Cond)});
1218 return getNode(ISD::SETCC, DL, VT, LHS, RHS, getCondCode(Cond));
1219 }
1220
1221 /// Helper function to make it easier to build VP_SETCCs if you just have an
1222 /// ISD::CondCode instead of an SDValue.
1224 ISD::CondCode Cond, SDValue Mask, SDValue EVL) {
1225 assert(LHS.getValueType().isVector() && RHS.getValueType().isVector() &&
1226 "Cannot compare scalars");
1228 "Cannot create a setCC of an invalid node.");
1229 return getNode(ISD::VP_SETCC, DL, VT, LHS, RHS, getCondCode(Cond), Mask,
1230 EVL);
1231 }
1232
1233 /// Helper function to make it easier to build Select's if you just have
1234 /// operands and don't want to check for vector.
1236 SDValue RHS) {
1237 assert(LHS.getValueType() == VT && RHS.getValueType() == VT &&
1238 "Cannot use select on differing types");
1239 auto Opcode = Cond.getValueType().isVector() ? ISD::VSELECT : ISD::SELECT;
1240 return getNode(Opcode, DL, VT, Cond, LHS, RHS);
1241 }
1242
1243 /// Helper function to make it easier to build SelectCC's if you just have an
1244 /// ISD::CondCode instead of an SDValue.
1246 SDValue False, ISD::CondCode Cond) {
1247 return getNode(ISD::SELECT_CC, DL, True.getValueType(), LHS, RHS, True,
1248 False, getCondCode(Cond));
1249 }
1250
1251 /// Try to simplify a select/vselect into 1 of its operands or a constant.
1253
1254 /// Try to simplify a shift into 1 of its operands or a constant.
1256
1257 /// Try to simplify a floating-point binary operation into 1 of its operands
1258 /// or a constant.
1260 SDNodeFlags Flags);
1261
1262 /// VAArg produces a result and token chain, and takes a pointer
1263 /// and a source value as input.
1264 SDValue getVAArg(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
1265 SDValue SV, unsigned Align);
1266
1267 /// Gets a node for an atomic cmpxchg op. There are two
1268 /// valid Opcodes. ISD::ATOMIC_CMO_SWAP produces the value loaded and a
1269 /// chain result. ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS produces the value loaded,
1270 /// a success flag (initially i1), and a chain.
1271 SDValue getAtomicCmpSwap(unsigned Opcode, const SDLoc &dl, EVT MemVT,
1272 SDVTList VTs, SDValue Chain, SDValue Ptr,
1273 SDValue Cmp, SDValue Swp, MachineMemOperand *MMO);
1274
1275 /// Gets a node for an atomic op, produces result (if relevant)
1276 /// and chain and takes 2 operands.
1277 SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT, SDValue Chain,
1279
1280 /// Gets a node for an atomic op, produces result and chain and
1281 /// takes 1 operand.
1282 SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT, EVT VT,
1283 SDValue Chain, SDValue Ptr, MachineMemOperand *MMO);
1284
1285 /// Gets a node for an atomic op, produces result and chain and takes N
1286 /// operands.
1287 SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT,
1288 SDVTList VTList, ArrayRef<SDValue> Ops,
1289 MachineMemOperand *MMO);
1290
1291 /// Creates a MemIntrinsicNode that may produce a
1292 /// result and takes a list of operands. Opcode may be INTRINSIC_VOID,
1293 /// INTRINSIC_W_CHAIN, or a target-specific opcode with a value not
1294 /// less than FIRST_TARGET_MEMORY_OPCODE.
1296 unsigned Opcode, const SDLoc &dl, SDVTList VTList, ArrayRef<SDValue> Ops,
1297 EVT MemVT, MachinePointerInfo PtrInfo, Align Alignment,
1300 uint64_t Size = 0, const AAMDNodes &AAInfo = AAMDNodes());
1301
1303 unsigned Opcode, const SDLoc &dl, SDVTList VTList, ArrayRef<SDValue> Ops,
1304 EVT MemVT, MachinePointerInfo PtrInfo,
1305 MaybeAlign Alignment = std::nullopt,
1308 uint64_t Size = 0, const AAMDNodes &AAInfo = AAMDNodes()) {
1309 // Ensure that codegen never sees alignment 0
1310 return getMemIntrinsicNode(Opcode, dl, VTList, Ops, MemVT, PtrInfo,
1311 Alignment.value_or(getEVTAlign(MemVT)), Flags,
1312 Size, AAInfo);
1313 }
1314
1315 SDValue getMemIntrinsicNode(unsigned Opcode, const SDLoc &dl, SDVTList VTList,
1316 ArrayRef<SDValue> Ops, EVT MemVT,
1317 MachineMemOperand *MMO);
1318
1319 /// Creates a LifetimeSDNode that starts (`IsStart==true`) or ends
1320 /// (`IsStart==false`) the lifetime of the portion of `FrameIndex` between
1321 /// offsets `Offset` and `Offset + Size`.
1322 SDValue getLifetimeNode(bool IsStart, const SDLoc &dl, SDValue Chain,
1323 int FrameIndex, int64_t Size, int64_t Offset = -1);
1324
1325 /// Creates a PseudoProbeSDNode with function GUID `Guid` and
1326 /// the index of the block `Index` it is probing, as well as the attributes
1327 /// `attr` of the probe.
1328 SDValue getPseudoProbeNode(const SDLoc &Dl, SDValue Chain, uint64_t Guid,
1329 uint64_t Index, uint32_t Attr);
1330
1331 /// Create a MERGE_VALUES node from the given operands.
1333
1334 /// Loads are not normal binary operators: their result type is not
1335 /// determined by their operands, and they produce a value AND a token chain.
1336 ///
1337 /// This function will set the MOLoad flag on MMOFlags, but you can set it if
1338 /// you want. The MOStore flag must not be set.
1339 SDValue getLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
1340 MachinePointerInfo PtrInfo,
1341 MaybeAlign Alignment = MaybeAlign(),
1343 const AAMDNodes &AAInfo = AAMDNodes(),
1344 const MDNode *Ranges = nullptr);
1345 SDValue getLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
1346 MachineMemOperand *MMO);
1347 SDValue
1348 getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT, SDValue Chain,
1349 SDValue Ptr, MachinePointerInfo PtrInfo, EVT MemVT,
1350 MaybeAlign Alignment = MaybeAlign(),
1352 const AAMDNodes &AAInfo = AAMDNodes());
1353 SDValue getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT,
1354 SDValue Chain, SDValue Ptr, EVT MemVT,
1355 MachineMemOperand *MMO);
1356 SDValue getIndexedLoad(SDValue OrigLoad, const SDLoc &dl, SDValue Base,
1359 const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
1360 MachinePointerInfo PtrInfo, EVT MemVT, Align Alignment,
1362 const AAMDNodes &AAInfo = AAMDNodes(),
1363 const MDNode *Ranges = nullptr);
1365 ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT, const SDLoc &dl,
1367 EVT MemVT, MaybeAlign Alignment = MaybeAlign(),
1369 const AAMDNodes &AAInfo = AAMDNodes(), const MDNode *Ranges = nullptr) {
1370 // Ensures that codegen never sees a None Alignment.
1371 return getLoad(AM, ExtType, VT, dl, Chain, Ptr, Offset, PtrInfo, MemVT,
1372 Alignment.value_or(getEVTAlign(MemVT)), MMOFlags, AAInfo,
1373 Ranges);
1374 }
1376 const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
1377 EVT MemVT, MachineMemOperand *MMO);
1378
1379 /// Helper function to build ISD::STORE nodes.
1380 ///
1381 /// This function will set the MOStore flag on MMOFlags, but you can set it if
1382 /// you want. The MOLoad and MOInvariant flags must not be set.
1383
1384 SDValue
1385 getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
1386 MachinePointerInfo PtrInfo, Align Alignment,
1388 const AAMDNodes &AAInfo = AAMDNodes());
1389 inline SDValue
1390 getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
1391 MachinePointerInfo PtrInfo, MaybeAlign Alignment = MaybeAlign(),
1393 const AAMDNodes &AAInfo = AAMDNodes()) {
1394 return getStore(Chain, dl, Val, Ptr, PtrInfo,
1395 Alignment.value_or(getEVTAlign(Val.getValueType())),
1396 MMOFlags, AAInfo);
1397 }
1398 SDValue getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
1399 MachineMemOperand *MMO);
1400 SDValue
1401 getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
1402 MachinePointerInfo PtrInfo, EVT SVT, Align Alignment,
1404 const AAMDNodes &AAInfo = AAMDNodes());
1405 inline SDValue
1407 MachinePointerInfo PtrInfo, EVT SVT,
1408 MaybeAlign Alignment = MaybeAlign(),
1410 const AAMDNodes &AAInfo = AAMDNodes()) {
1411 return getTruncStore(Chain, dl, Val, Ptr, PtrInfo, SVT,
1412 Alignment.value_or(getEVTAlign(SVT)), MMOFlags,
1413 AAInfo);
1414 }
1415 SDValue getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val,
1416 SDValue Ptr, EVT SVT, MachineMemOperand *MMO);
1417 SDValue getIndexedStore(SDValue OrigStore, const SDLoc &dl, SDValue Base,
1419
1421 const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
1422 SDValue Mask, SDValue EVL, MachinePointerInfo PtrInfo,
1423 EVT MemVT, Align Alignment,
1424 MachineMemOperand::Flags MMOFlags, const AAMDNodes &AAInfo,
1425 const MDNode *Ranges = nullptr, bool IsExpanding = false);
1426 inline SDValue
1428 const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
1429 SDValue Mask, SDValue EVL, MachinePointerInfo PtrInfo, EVT MemVT,
1430 MaybeAlign Alignment = MaybeAlign(),
1432 const AAMDNodes &AAInfo = AAMDNodes(),
1433 const MDNode *Ranges = nullptr, bool IsExpanding = false) {
1434 // Ensures that codegen never sees a None Alignment.
1435 return getLoadVP(AM, ExtType, VT, dl, Chain, Ptr, Offset, Mask, EVL,
1436 PtrInfo, MemVT, Alignment.value_or(getEVTAlign(MemVT)),
1437 MMOFlags, AAInfo, Ranges, IsExpanding);
1438 }
1440 const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
1441 SDValue Mask, SDValue EVL, EVT MemVT,
1442 MachineMemOperand *MMO, bool IsExpanding = false);
1443 SDValue getLoadVP(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
1444 SDValue Mask, SDValue EVL, MachinePointerInfo PtrInfo,
1445 MaybeAlign Alignment, MachineMemOperand::Flags MMOFlags,
1446 const AAMDNodes &AAInfo, const MDNode *Ranges = nullptr,
1447 bool IsExpanding = false);
1448 SDValue getLoadVP(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
1449 SDValue Mask, SDValue EVL, MachineMemOperand *MMO,
1450 bool IsExpanding = false);
1451 SDValue getExtLoadVP(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT,
1452 SDValue Chain, SDValue Ptr, SDValue Mask, SDValue EVL,
1453 MachinePointerInfo PtrInfo, EVT MemVT,
1454 MaybeAlign Alignment, MachineMemOperand::Flags MMOFlags,
1455 const AAMDNodes &AAInfo, bool IsExpanding = false);
1456 SDValue getExtLoadVP(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT,
1457 SDValue Chain, SDValue Ptr, SDValue Mask, SDValue EVL,
1458 EVT MemVT, MachineMemOperand *MMO,
1459 bool IsExpanding = false);
1460 SDValue getIndexedLoadVP(SDValue OrigLoad, const SDLoc &dl, SDValue Base,
1462 SDValue getStoreVP(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
1463 SDValue Offset, SDValue Mask, SDValue EVL, EVT MemVT,
1465 bool IsTruncating = false, bool IsCompressing = false);
1466 SDValue getTruncStoreVP(SDValue Chain, const SDLoc &dl, SDValue Val,
1467 SDValue Ptr, SDValue Mask, SDValue EVL,
1468 MachinePointerInfo PtrInfo, EVT SVT, Align Alignment,
1469 MachineMemOperand::Flags MMOFlags,
1470 const AAMDNodes &AAInfo, bool IsCompressing = false);
1471 SDValue getTruncStoreVP(SDValue Chain, const SDLoc &dl, SDValue Val,
1472 SDValue Ptr, SDValue Mask, SDValue EVL, EVT SVT,
1473 MachineMemOperand *MMO, bool IsCompressing = false);
1474 SDValue getIndexedStoreVP(SDValue OrigStore, const SDLoc &dl, SDValue Base,
1476
1478 EVT VT, const SDLoc &DL, SDValue Chain, SDValue Ptr,
1479 SDValue Offset, SDValue Stride, SDValue Mask,
1480 SDValue EVL, MachinePointerInfo PtrInfo, EVT MemVT,
1481 Align Alignment, MachineMemOperand::Flags MMOFlags,
1482 const AAMDNodes &AAInfo,
1483 const MDNode *Ranges = nullptr,
1484 bool IsExpanding = false);
1486 ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT, const SDLoc &DL,
1487 SDValue Chain, SDValue Ptr, SDValue Offset, SDValue Stride, SDValue Mask,
1488 SDValue EVL, MachinePointerInfo PtrInfo, EVT MemVT,
1489 MaybeAlign Alignment = MaybeAlign(),
1491 const AAMDNodes &AAInfo = AAMDNodes(), const MDNode *Ranges = nullptr,
1492 bool IsExpanding = false) {
1493 // Ensures that codegen never sees a None Alignment.
1494 return getStridedLoadVP(AM, ExtType, VT, DL, Chain, Ptr, Offset, Stride,
1495 Mask, EVL, PtrInfo, MemVT,
1496 Alignment.value_or(getEVTAlign(MemVT)), MMOFlags,
1497 AAInfo, Ranges, IsExpanding);
1498 }
1500 EVT VT, const SDLoc &DL, SDValue Chain, SDValue Ptr,
1501 SDValue Offset, SDValue Stride, SDValue Mask,
1502 SDValue EVL, EVT MemVT, MachineMemOperand *MMO,
1503 bool IsExpanding = false);
1505 SDValue Stride, SDValue Mask, SDValue EVL,
1506 MachinePointerInfo PtrInfo, MaybeAlign Alignment,
1507 MachineMemOperand::Flags MMOFlags,
1508 const AAMDNodes &AAInfo,
1509 const MDNode *Ranges = nullptr,
1510 bool IsExpanding = false);
1512 SDValue Stride, SDValue Mask, SDValue EVL,
1513 MachineMemOperand *MMO, bool IsExpanding = false);
1514 SDValue
1515 getExtStridedLoadVP(ISD::LoadExtType ExtType, const SDLoc &DL, EVT VT,
1516 SDValue Chain, SDValue Ptr, SDValue Stride, SDValue Mask,
1517 SDValue EVL, MachinePointerInfo PtrInfo, EVT MemVT,
1518 MaybeAlign Alignment, MachineMemOperand::Flags MMOFlags,
1519 const AAMDNodes &AAInfo, bool IsExpanding = false);
1521 SDValue Chain, SDValue Ptr, SDValue Stride,
1522 SDValue Mask, SDValue EVL, EVT MemVT,
1523 MachineMemOperand *MMO, bool IsExpanding = false);
1527 SDValue getStridedStoreVP(SDValue Chain, const SDLoc &DL, SDValue Val,
1528 SDValue Ptr, SDValue Offset, SDValue Stride,
1529 SDValue Mask, SDValue EVL, EVT MemVT,
1531 bool IsTruncating = false,
1532 bool IsCompressing = false);
1534 SDValue Ptr, SDValue Stride, SDValue Mask,
1535 SDValue EVL, MachinePointerInfo PtrInfo,
1536 EVT SVT, Align Alignment,
1537 MachineMemOperand::Flags MMOFlags,
1538 const AAMDNodes &AAInfo,
1539 bool IsCompressing = false);
1541 SDValue Ptr, SDValue Stride, SDValue Mask,
1542 SDValue EVL, EVT SVT, MachineMemOperand *MMO,
1543 bool IsCompressing = false);
1547
1548 SDValue getGatherVP(SDVTList VTs, EVT VT, const SDLoc &dl,
1550 ISD::MemIndexType IndexType);
1551 SDValue getScatterVP(SDVTList VTs, EVT VT, const SDLoc &dl,
1553 ISD::MemIndexType IndexType);
1554
1555 SDValue getMaskedLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Base,
1556 SDValue Offset, SDValue Mask, SDValue Src0, EVT MemVT,
1558 ISD::LoadExtType, bool IsExpanding = false);
1561 SDValue getMaskedStore(SDValue Chain, const SDLoc &dl, SDValue Val,
1562 SDValue Base, SDValue Offset, SDValue Mask, EVT MemVT,
1564 bool IsTruncating = false, bool IsCompressing = false);
1565 SDValue getIndexedMaskedStore(SDValue OrigStore, const SDLoc &dl,
1568 SDValue getMaskedGather(SDVTList VTs, EVT MemVT, const SDLoc &dl,
1570 ISD::MemIndexType IndexType, ISD::LoadExtType ExtTy);
1571 SDValue getMaskedScatter(SDVTList VTs, EVT MemVT, const SDLoc &dl,
1573 ISD::MemIndexType IndexType,
1574 bool IsTruncating = false);
1575
1576 SDValue getGetFPEnv(SDValue Chain, const SDLoc &dl, SDValue Ptr, EVT MemVT,
1577 MachineMemOperand *MMO);
1578 SDValue getSetFPEnv(SDValue Chain, const SDLoc &dl, SDValue Ptr, EVT MemVT,
1579 MachineMemOperand *MMO);
1580
1581 /// Construct a node to track a Value* through the backend.
1582 SDValue getSrcValue(const Value *v);
1583
1584 /// Return an MDNodeSDNode which holds an MDNode.
1585 SDValue getMDNode(const MDNode *MD);
1586
1587 /// Return a bitcast using the SDLoc of the value operand, and casting to the
1588 /// provided type. Use getNode to set a custom SDLoc.
1590
1591 /// Return an AddrSpaceCastSDNode.
1592 SDValue getAddrSpaceCast(const SDLoc &dl, EVT VT, SDValue Ptr, unsigned SrcAS,
1593 unsigned DestAS);
1594
1595 /// Return a freeze using the SDLoc of the value operand.
1597
1598 /// Return an AssertAlignSDNode.
1600
1601 /// Swap N1 and N2 if Opcode is a commutative binary opcode
1602 /// and the canonical form expects the opposite order.
1603 void canonicalizeCommutativeBinop(unsigned Opcode, SDValue &N1,
1604 SDValue &N2) const;
1605
1606 /// Return the specified value casted to
1607 /// the target's desired shift amount type.
1609
1610 /// Expand the specified \c ISD::VAARG node as the Legalize pass would.
1612
1613 /// Expand the specified \c ISD::VACOPY node as the Legalize pass would.
1615
1616 /// Returs an GlobalAddress of the function from the current module with
1617 /// name matching the given ExternalSymbol. Additionally can provide the
1618 /// matched function.
1619 /// Panics the function doesn't exists.
1621 Function **TargetFunction = nullptr);
1622
1623 /// *Mutate* the specified node in-place to have the
1624 /// specified operands. If the resultant node already exists in the DAG,
1625 /// this does not modify the specified node, instead it returns the node that
1626 /// already exists. If the resultant node does not exist in the DAG, the
1627 /// input node is returned. As a degenerate case, if you specify the same
1628 /// input operands as the node already has, the input node is returned.
1632 SDValue Op3);
1634 SDValue Op3, SDValue Op4);
1636 SDValue Op3, SDValue Op4, SDValue Op5);
1638
1639 /// Creates a new TokenFactor containing \p Vals. If \p Vals contains 64k
1640 /// values or more, move values into new TokenFactors in 64k-1 blocks, until
1641 /// the final TokenFactor has less than 64k operands.
1643
1644 /// *Mutate* the specified machine node's memory references to the provided
1645 /// list.
1648
1649 // Calculate divergence of node \p N based on its operands.
1651
1652 // Propagates the change in divergence to users
1653 void updateDivergence(SDNode * N);
1654
1655 /// These are used for target selectors to *mutate* the
1656 /// specified node to have the specified return type, Target opcode, and
1657 /// operands. Note that target opcodes are stored as
1658 /// ~TargetOpcode in the node opcode field. The resultant node is returned.
1659 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT);
1660 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT, SDValue Op1);
1661 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT,
1662 SDValue Op1, SDValue Op2);
1663 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT,
1664 SDValue Op1, SDValue Op2, SDValue Op3);
1665 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT,
1666 ArrayRef<SDValue> Ops);
1667 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1, EVT VT2);
1668 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1,
1669 EVT VT2, ArrayRef<SDValue> Ops);
1670 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1,
1671 EVT VT2, EVT VT3, ArrayRef<SDValue> Ops);
1672 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1,
1673 EVT VT2, SDValue Op1, SDValue Op2);
1674 SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, SDVTList VTs,
1675 ArrayRef<SDValue> Ops);
1676
1677 /// This *mutates* the specified node to have the specified
1678 /// return type, opcode, and operands.
1679 SDNode *MorphNodeTo(SDNode *N, unsigned Opc, SDVTList VTs,
1680 ArrayRef<SDValue> Ops);
1681
1682 /// Mutate the specified strict FP node to its non-strict equivalent,
1683 /// unlinking the node from its chain and dropping the metadata arguments.
1684 /// The node must be a strict FP node.
1686
1687 /// These are used for target selectors to create a new node
1688 /// with specified return type(s), MachineInstr opcode, and operands.
1689 ///
1690 /// Note that getMachineNode returns the resultant node. If there is already
1691 /// a node of the specified opcode and operands, it returns that node instead
1692 /// of the current one.
1693 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT);
1694 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
1695 SDValue Op1);
1696 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
1697 SDValue Op1, SDValue Op2);
1698 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
1699 SDValue Op1, SDValue Op2, SDValue Op3);
1700 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
1701 ArrayRef<SDValue> Ops);
1702 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1703 EVT VT2, SDValue Op1, SDValue Op2);
1704 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1705 EVT VT2, SDValue Op1, SDValue Op2, SDValue Op3);
1706 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1707 EVT VT2, ArrayRef<SDValue> Ops);
1708 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1709 EVT VT2, EVT VT3, SDValue Op1, SDValue Op2);
1710 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1711 EVT VT2, EVT VT3, SDValue Op1, SDValue Op2,
1712 SDValue Op3);
1713 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
1714 EVT VT2, EVT VT3, ArrayRef<SDValue> Ops);
1715 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl,
1716 ArrayRef<EVT> ResultTys, ArrayRef<SDValue> Ops);
1717 MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, SDVTList VTs,
1718 ArrayRef<SDValue> Ops);
1719
1720 /// A convenience function for creating TargetInstrInfo::EXTRACT_SUBREG nodes.
1721 SDValue getTargetExtractSubreg(int SRIdx, const SDLoc &DL, EVT VT,
1722 SDValue Operand);
1723
1724 /// A convenience function for creating TargetInstrInfo::INSERT_SUBREG nodes.
1725 SDValue getTargetInsertSubreg(int SRIdx, const SDLoc &DL, EVT VT,
1726 SDValue Operand, SDValue Subreg);
1727
1728 /// Get the specified node if it's already available, or else return NULL.
1729 SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTList,
1730 ArrayRef<SDValue> Ops, const SDNodeFlags Flags);
1731 SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTList,
1732 ArrayRef<SDValue> Ops);
1733
1734 /// Check if a node exists without modifying its flags.
1735 bool doesNodeExist(unsigned Opcode, SDVTList VTList, ArrayRef<SDValue> Ops);
1736
1737 /// Creates a SDDbgValue node.
1739 unsigned R, bool IsIndirect, const DebugLoc &DL,
1740 unsigned O);
1741
1742 /// Creates a constant SDDbgValue node.
1744 const Value *C, const DebugLoc &DL,
1745 unsigned O);
1746
1747 /// Creates a FrameIndex SDDbgValue node.
1749 unsigned FI, bool IsIndirect,
1750 const DebugLoc &DL, unsigned O);
1751
1752 /// Creates a FrameIndex SDDbgValue node.
1754 unsigned FI,
1755 ArrayRef<SDNode *> Dependencies,
1756 bool IsIndirect, const DebugLoc &DL,
1757 unsigned O);
1758
1759 /// Creates a VReg SDDbgValue node.
1761 unsigned VReg, bool IsIndirect,
1762 const DebugLoc &DL, unsigned O);
1763
1764 /// Creates a SDDbgValue node from a list of locations.
1767 ArrayRef<SDNode *> Dependencies, bool IsIndirect,
1768 const DebugLoc &DL, unsigned O, bool IsVariadic);
1769
1770 /// Creates a SDDbgLabel node.
1771 SDDbgLabel *getDbgLabel(DILabel *Label, const DebugLoc &DL, unsigned O);
1772
1773 /// Transfer debug values from one node to another, while optionally
1774 /// generating fragment expressions for split-up values. If \p InvalidateDbg
1775 /// is set, debug values are invalidated after they are transferred.
1776 void transferDbgValues(SDValue From, SDValue To, unsigned OffsetInBits = 0,
1777 unsigned SizeInBits = 0, bool InvalidateDbg = true);
1778
1779 /// Remove the specified node from the system. If any of its
1780 /// operands then becomes dead, remove them as well. Inform UpdateListener
1781 /// for each node deleted.
1782 void RemoveDeadNode(SDNode *N);
1783
1784 /// This method deletes the unreachable nodes in the
1785 /// given list, and any nodes that become unreachable as a result.
1787
1788 /// Modify anything using 'From' to use 'To' instead.
1789 /// This can cause recursive merging of nodes in the DAG. Use the first
1790 /// version if 'From' is known to have a single result, use the second
1791 /// if you have two nodes with identical results (or if 'To' has a superset
1792 /// of the results of 'From'), use the third otherwise.
1793 ///
1794 /// These methods all take an optional UpdateListener, which (if not null) is
1795 /// informed about nodes that are deleted and modified due to recursive
1796 /// changes in the dag.
1797 ///
1798 /// These functions only replace all existing uses. It's possible that as
1799 /// these replacements are being performed, CSE may cause the From node
1800 /// to be given new uses. These new uses of From are left in place, and
1801 /// not automatically transferred to To.
1802 ///
1805 void ReplaceAllUsesWith(SDNode *From, const SDValue *To);
1806
1807 /// Replace any uses of From with To, leaving
1808 /// uses of other values produced by From.getNode() alone.
1810
1811 /// Like ReplaceAllUsesOfValueWith, but for multiple values at once.
1812 /// This correctly handles the case where
1813 /// there is an overlap between the From values and the To values.
1814 void ReplaceAllUsesOfValuesWith(const SDValue *From, const SDValue *To,
1815 unsigned Num);
1816
1817 /// If an existing load has uses of its chain, create a token factor node with
1818 /// that chain and the new memory node's chain and update users of the old
1819 /// chain to the token factor. This ensures that the new memory node will have
1820 /// the same relative memory dependency position as the old load. Returns the
1821 /// new merged load chain.
1822 SDValue makeEquivalentMemoryOrdering(SDValue OldChain, SDValue NewMemOpChain);
1823
1824 /// If an existing load has uses of its chain, create a token factor node with
1825 /// that chain and the new memory node's chain and update users of the old
1826 /// chain to the token factor. This ensures that the new memory node will have
1827 /// the same relative memory dependency position as the old load. Returns the
1828 /// new merged load chain.
1830
1831 /// Topological-sort the AllNodes list and a
1832 /// assign a unique node id for each node in the DAG based on their
1833 /// topological order. Returns the number of nodes.
1834 unsigned AssignTopologicalOrder();
1835
1836 /// Move node N in the AllNodes list to be immediately
1837 /// before the given iterator Position. This may be used to update the
1838 /// topological ordering when the list of nodes is modified.
1840 AllNodes.insert(Position, AllNodes.remove(N));
1841 }
1842
1843 /// Returns an APFloat semantics tag appropriate for the given type. If VT is
1844 /// a vector type, the element semantics are returned.
1846 switch (VT.getScalarType().getSimpleVT().SimpleTy) {
1847 default: llvm_unreachable("Unknown FP format");
1848 case MVT::f16: return APFloat::IEEEhalf();
1849 case MVT::bf16: return APFloat::BFloat();
1850 case MVT::f32: return APFloat::IEEEsingle();
1851 case MVT::f64: return APFloat::IEEEdouble();
1852 case MVT::f80: return APFloat::x87DoubleExtended();
1853 case MVT::f128: return APFloat::IEEEquad();
1854 case MVT::ppcf128: return APFloat::PPCDoubleDouble();
1855 }
1856 }
1857
1858 /// Add a dbg_value SDNode. If SD is non-null that means the
1859 /// value is produced by SD.
1860 void AddDbgValue(SDDbgValue *DB, bool isParameter);
1861
1862 /// Add a dbg_label SDNode.
1863 void AddDbgLabel(SDDbgLabel *DB);
1864
1865 /// Get the debug values which reference the given SDNode.
1867 return DbgInfo->getSDDbgValues(SD);
1868 }
1869
1870public:
1871 /// Return true if there are any SDDbgValue nodes associated
1872 /// with this SelectionDAG.
1873 bool hasDebugValues() const { return !DbgInfo->empty(); }
1874
1875 SDDbgInfo::DbgIterator DbgBegin() const { return DbgInfo->DbgBegin(); }
1876 SDDbgInfo::DbgIterator DbgEnd() const { return DbgInfo->DbgEnd(); }
1877
1879 return DbgInfo->ByvalParmDbgBegin();
1880 }
1882 return DbgInfo->ByvalParmDbgEnd();
1883 }
1884
1886 return DbgInfo->DbgLabelBegin();
1887 }
1889 return DbgInfo->DbgLabelEnd();
1890 }
1891
1892 /// To be invoked on an SDNode that is slated to be erased. This
1893 /// function mirrors \c llvm::salvageDebugInfo.
1894 void salvageDebugInfo(SDNode &N);
1895
1896 void dump() const;
1897
1898 /// In most cases this function returns the ABI alignment for a given type,
1899 /// except for illegal vector types where the alignment exceeds that of the
1900 /// stack. In such cases we attempt to break the vector down to a legal type
1901 /// and return the ABI alignment for that instead.
1902 Align getReducedAlign(EVT VT, bool UseABI);
1903
1904 /// Create a stack temporary based on the size in bytes and the alignment
1905 SDValue CreateStackTemporary(TypeSize Bytes, Align Alignment);
1906
1907 /// Create a stack temporary, suitable for holding the specified value type.
1908 /// If minAlign is specified, the slot size will have at least that alignment.
1909 SDValue CreateStackTemporary(EVT VT, unsigned minAlign = 1);
1910
1911 /// Create a stack temporary suitable for holding either of the specified
1912 /// value types.
1914
1915 SDValue FoldSymbolOffset(unsigned Opcode, EVT VT,
1916 const GlobalAddressSDNode *GA,
1917 const SDNode *N2);
1918
1919 SDValue FoldConstantArithmetic(unsigned Opcode, const SDLoc &DL, EVT VT,
1920 ArrayRef<SDValue> Ops);
1921
1922 /// Fold floating-point operations when all operands are constants and/or
1923 /// undefined.
1924 SDValue foldConstantFPMath(unsigned Opcode, const SDLoc &DL, EVT VT,
1925 ArrayRef<SDValue> Ops);
1926
1927 /// Constant fold a setcc to true or false.
1929 const SDLoc &dl);
1930
1931 /// Return true if the sign bit of Op is known to be zero.
1932 /// We use this predicate to simplify operations downstream.
1933 bool SignBitIsZero(SDValue Op, unsigned Depth = 0) const;
1934
1935 /// Return true if 'Op & Mask' is known to be zero. We
1936 /// use this predicate to simplify operations downstream. Op and Mask are
1937 /// known to be the same type.
1938 bool MaskedValueIsZero(SDValue Op, const APInt &Mask,
1939 unsigned Depth = 0) const;
1940
1941 /// Return true if 'Op & Mask' is known to be zero in DemandedElts. We
1942 /// use this predicate to simplify operations downstream. Op and Mask are
1943 /// known to be the same type.
1944 bool MaskedValueIsZero(SDValue Op, const APInt &Mask,
1945 const APInt &DemandedElts, unsigned Depth = 0) const;
1946
1947 /// Return true if 'Op' is known to be zero in DemandedElts. We
1948 /// use this predicate to simplify operations downstream.
1949 bool MaskedVectorIsZero(SDValue Op, const APInt &DemandedElts,
1950 unsigned Depth = 0) const;
1951
1952 /// Return true if '(Op & Mask) == Mask'.
1953 /// Op and Mask are known to be the same type.
1954 bool MaskedValueIsAllOnes(SDValue Op, const APInt &Mask,
1955 unsigned Depth = 0) const;
1956
1957 /// For each demanded element of a vector, see if it is known to be zero.
1959 unsigned Depth = 0) const;
1960
1961 /// Determine which bits of Op are known to be either zero or one and return
1962 /// them in Known. For vectors, the known bits are those that are shared by
1963 /// every vector element.
1964 /// Targets can implement the computeKnownBitsForTargetNode method in the
1965 /// TargetLowering class to allow target nodes to be understood.
1966 KnownBits computeKnownBits(SDValue Op, unsigned Depth = 0) const;
1967
1968 /// Determine which bits of Op are known to be either zero or one and return
1969 /// them in Known. The DemandedElts argument allows us to only collect the
1970 /// known bits that are shared by the requested vector elements.
1971 /// Targets can implement the computeKnownBitsForTargetNode method in the
1972 /// TargetLowering class to allow target nodes to be understood.
1973 KnownBits computeKnownBits(SDValue Op, const APInt &DemandedElts,
1974 unsigned Depth = 0) const;
1975
1976 /// Used to represent the possible overflow behavior of an operation.
1977 /// Never: the operation cannot overflow.
1978 /// Always: the operation will always overflow.
1979 /// Sometime: the operation may or may not overflow.
1984 };
1985
1986 /// Determine if the result of the signed addition of 2 nodes can overflow.
1988
1989 /// Determine if the result of the unsigned addition of 2 nodes can overflow.
1991
1992 /// Determine if the result of the addition of 2 nodes can overflow.
1994 SDValue N1) const {
1995 return IsSigned ? computeOverflowForSignedAdd(N0, N1)
1997 }
1998
1999 /// Determine if the result of the addition of 2 nodes can never overflow.
2000 bool willNotOverflowAdd(bool IsSigned, SDValue N0, SDValue N1) const {
2001 return computeOverflowForAdd(IsSigned, N0, N1) == OFK_Never;
2002 }
2003
2004 /// Determine if the result of the signed sub of 2 nodes can overflow.
2006
2007 /// Determine if the result of the unsigned sub of 2 nodes can overflow.
2009
2010 /// Determine if the result of the sub of 2 nodes can overflow.
2012 SDValue N1) const {
2013 return IsSigned ? computeOverflowForSignedSub(N0, N1)
2015 }
2016
2017 /// Determine if the result of the sub of 2 nodes can never overflow.
2018 bool willNotOverflowSub(bool IsSigned, SDValue N0, SDValue N1) const {
2019 return computeOverflowForSub(IsSigned, N0, N1) == OFK_Never;
2020 }
2021
2022 /// Determine if the result of the signed mul of 2 nodes can overflow.
2024
2025 /// Determine if the result of the unsigned mul of 2 nodes can overflow.
2027
2028 /// Determine if the result of the mul of 2 nodes can overflow.
2030 SDValue N1) const {
2031 return IsSigned ? computeOverflowForSignedMul(N0, N1)
2033 }
2034
2035 /// Determine if the result of the mul of 2 nodes can never overflow.
2036 bool willNotOverflowMul(bool IsSigned, SDValue N0, SDValue N1) const {
2037 return computeOverflowForMul(IsSigned, N0, N1) == OFK_Never;
2038 }
2039
2040 /// Test if the given value is known to have exactly one bit set. This differs
2041 /// from computeKnownBits in that it doesn't necessarily determine which bit
2042 /// is set.
2043 bool isKnownToBeAPowerOfTwo(SDValue Val, unsigned Depth = 0) const;
2044
2045 /// Return the number of times the sign bit of the register is replicated into
2046 /// the other bits. We know that at least 1 bit is always equal to the sign
2047 /// bit (itself), but other cases can give us information. For example,
2048 /// immediately after an "SRA X, 2", we know that the top 3 bits are all equal
2049 /// to each other, so we return 3. Targets can implement the
2050 /// ComputeNumSignBitsForTarget method in the TargetLowering class to allow
2051 /// target nodes to be understood.
2052 unsigned ComputeNumSignBits(SDValue Op, unsigned Depth = 0) const;
2053
2054 /// Return the number of times the sign bit of the register is replicated into
2055 /// the other bits. We know that at least 1 bit is always equal to the sign
2056 /// bit (itself), but other cases can give us information. For example,
2057 /// immediately after an "SRA X, 2", we know that the top 3 bits are all equal
2058 /// to each other, so we return 3. The DemandedElts argument allows
2059 /// us to only collect the minimum sign bits of the requested vector elements.
2060 /// Targets can implement the ComputeNumSignBitsForTarget method in the
2061 /// TargetLowering class to allow target nodes to be understood.
2062 unsigned ComputeNumSignBits(SDValue Op, const APInt &DemandedElts,
2063 unsigned Depth = 0) const;
2064
2065 /// Get the upper bound on bit size for this Value \p Op as a signed integer.
2066 /// i.e. x == sext(trunc(x to MaxSignedBits) to bitwidth(x)).
2067 /// Similar to the APInt::getSignificantBits function.
2068 /// Helper wrapper to ComputeNumSignBits.
2069 unsigned ComputeMaxSignificantBits(SDValue Op, unsigned Depth = 0) const;
2070
2071 /// Get the upper bound on bit size for this Value \p Op as a signed integer.
2072 /// i.e. x == sext(trunc(x to MaxSignedBits) to bitwidth(x)).
2073 /// Similar to the APInt::getSignificantBits function.
2074 /// Helper wrapper to ComputeNumSignBits.
2075 unsigned ComputeMaxSignificantBits(SDValue Op, const APInt &DemandedElts,
2076 unsigned Depth = 0) const;
2077
2078 /// Return true if this function can prove that \p Op is never poison
2079 /// and, if \p PoisonOnly is false, does not have undef bits.
2080 bool isGuaranteedNotToBeUndefOrPoison(SDValue Op, bool PoisonOnly = false,
2081 unsigned Depth = 0) const;
2082
2083 /// Return true if this function can prove that \p Op is never poison
2084 /// and, if \p PoisonOnly is false, does not have undef bits. The DemandedElts
2085 /// argument limits the check to the requested vector elements.
2086 bool isGuaranteedNotToBeUndefOrPoison(SDValue Op, const APInt &DemandedElts,
2087 bool PoisonOnly = false,
2088 unsigned Depth = 0) const;
2089
2090 /// Return true if this function can prove that \p Op is never poison.
2091 bool isGuaranteedNotToBePoison(SDValue Op, unsigned Depth = 0) const {
2092 return isGuaranteedNotToBeUndefOrPoison(Op, /*PoisonOnly*/ true, Depth);
2093 }
2094
2095 /// Return true if this function can prove that \p Op is never poison. The
2096 /// DemandedElts argument limits the check to the requested vector elements.
2097 bool isGuaranteedNotToBePoison(SDValue Op, const APInt &DemandedElts,
2098 unsigned Depth = 0) const {
2099 return isGuaranteedNotToBeUndefOrPoison(Op, DemandedElts,
2100 /*PoisonOnly*/ true, Depth);
2101 }
2102
2103 /// Return true if Op can create undef or poison from non-undef & non-poison
2104 /// operands. The DemandedElts argument limits the check to the requested
2105 /// vector elements.
2106 ///
2107 /// \p ConsiderFlags controls whether poison producing flags on the
2108 /// instruction are considered. This can be used to see if the instruction
2109 /// could still introduce undef or poison even without poison generating flags
2110 /// which might be on the instruction. (i.e. could the result of
2111 /// Op->dropPoisonGeneratingFlags() still create poison or undef)
2112 bool canCreateUndefOrPoison(SDValue Op, const APInt &DemandedElts,
2113 bool PoisonOnly = false,
2114 bool ConsiderFlags = true,
2115 unsigned Depth = 0) const;
2116
2117 /// Return true if Op can create undef or poison from non-undef & non-poison
2118 /// operands.
2119 ///
2120 /// \p ConsiderFlags controls whether poison producing flags on the
2121 /// instruction are considered. This can be used to see if the instruction
2122 /// could still introduce undef or poison even without poison generating flags
2123 /// which might be on the instruction. (i.e. could the result of
2124 /// Op->dropPoisonGeneratingFlags() still create poison or undef)
2125 bool canCreateUndefOrPoison(SDValue Op, bool PoisonOnly = false,
2126 bool ConsiderFlags = true,
2127 unsigned Depth = 0) const;
2128
2129 /// Return true if the specified operand is an ISD::OR or ISD::XOR node
2130 /// that can be treated as an ISD::ADD node.
2131 /// or(x,y) == add(x,y) iff haveNoCommonBitsSet(x,y)
2132 /// xor(x,y) == add(x,y) iff isMinSignedConstant(y)
2133 bool isADDLike(SDValue Op) const;
2134
2135 /// Return true if the specified operand is an ISD::ADD with a ConstantSDNode
2136 /// on the right-hand side, or if it is an ISD::OR with a ConstantSDNode that
2137 /// is guaranteed to have the same semantics as an ADD. This handles the
2138 /// equivalence:
2139 /// X|Cst == X+Cst iff X&Cst = 0.
2141
2142 /// Test whether the given SDValue (or all elements of it, if it is a
2143 /// vector) is known to never be NaN. If \p SNaN is true, returns if \p Op is
2144 /// known to never be a signaling NaN (it may still be a qNaN).
2145 bool isKnownNeverNaN(SDValue Op, bool SNaN = false, unsigned Depth = 0) const;
2146
2147 /// \returns true if \p Op is known to never be a signaling NaN.
2148 bool isKnownNeverSNaN(SDValue Op, unsigned Depth = 0) const {
2149 return isKnownNeverNaN(Op, true, Depth);
2150 }
2151
2152 /// Test whether the given floating point SDValue is known to never be
2153 /// positive or negative zero.
2154 bool isKnownNeverZeroFloat(SDValue Op) const;
2155
2156 /// Test whether the given SDValue is known to contain non-zero value(s).
2157 bool isKnownNeverZero(SDValue Op, unsigned Depth = 0) const;
2158
2159 /// Test whether two SDValues are known to compare equal. This
2160 /// is true if they are the same value, or if one is negative zero and the
2161 /// other positive zero.
2162 bool isEqualTo(SDValue A, SDValue B) const;
2163
2164 /// Return true if A and B have no common bits set. As an example, this can
2165 /// allow an 'add' to be transformed into an 'or'.
2166 bool haveNoCommonBitsSet(SDValue A, SDValue B) const;
2167
2168 /// Test whether \p V has a splatted value for all the demanded elements.
2169 ///
2170 /// On success \p UndefElts will indicate the elements that have UNDEF
2171 /// values instead of the splat value, this is only guaranteed to be correct
2172 /// for \p DemandedElts.
2173 ///
2174 /// NOTE: The function will return true for a demanded splat of UNDEF values.
2175 bool isSplatValue(SDValue V, const APInt &DemandedElts, APInt &UndefElts,
2176 unsigned Depth = 0) const;
2177
2178 /// Test whether \p V has a splatted value.
2179 bool isSplatValue(SDValue V, bool AllowUndefs = false) const;
2180
2181 /// If V is a splatted value, return the source vector and its splat index.
2182 SDValue getSplatSourceVector(SDValue V, int &SplatIndex);
2183
2184 /// If V is a splat vector, return its scalar source operand by extracting
2185 /// that element from the source vector. If LegalTypes is true, this method
2186 /// may only return a legally-typed splat value. If it cannot legalize the
2187 /// splatted value it will return SDValue().
2188 SDValue getSplatValue(SDValue V, bool LegalTypes = false);
2189
2190 /// If a SHL/SRA/SRL node \p V has a constant or splat constant shift amount
2191 /// that is less than the element bit-width of the shift node, return it.
2193 const APInt &DemandedElts) const;
2194
2195 /// If a SHL/SRA/SRL node \p V has constant shift amounts that are all less
2196 /// than the element bit-width of the shift node, return the minimum value.
2197 const APInt *
2199 const APInt &DemandedElts) const;
2200
2201 /// If a SHL/SRA/SRL node \p V has constant shift amounts that are all less
2202 /// than the element bit-width of the shift node, return the maximum value.
2203 const APInt *
2205 const APInt &DemandedElts) const;
2206
2207 /// Match a binop + shuffle pyramid that represents a horizontal reduction
2208 /// over the elements of a vector starting from the EXTRACT_VECTOR_ELT node /p
2209 /// Extract. The reduction must use one of the opcodes listed in /p
2210 /// CandidateBinOps and on success /p BinOp will contain the matching opcode.
2211 /// Returns the vector that is being reduced on, or SDValue() if a reduction
2212 /// was not matched. If \p AllowPartials is set then in the case of a
2213 /// reduction pattern that only matches the first few stages, the extracted
2214 /// subvector of the start of the reduction is returned.
2216 ArrayRef<ISD::NodeType> CandidateBinOps,
2217 bool AllowPartials = false);
2218
2219 /// Utility function used by legalize and lowering to
2220 /// "unroll" a vector operation by splitting out the scalars and operating
2221 /// on each element individually. If the ResNE is 0, fully unroll the vector
2222 /// op. If ResNE is less than the width of the vector op, unroll up to ResNE.
2223 /// If the ResNE is greater than the width of the vector op, unroll the
2224 /// vector op and fill the end of the resulting vector with UNDEFS.
2225 SDValue UnrollVectorOp(SDNode *N, unsigned ResNE = 0);
2226
2227 /// Like UnrollVectorOp(), but for the [US](ADD|SUB|MUL)O family of opcodes.
2228 /// This is a separate function because those opcodes have two results.
2229 std::pair<SDValue, SDValue> UnrollVectorOverflowOp(SDNode *N,
2230 unsigned ResNE = 0);
2231
2232 /// Return true if loads are next to each other and can be
2233 /// merged. Check that both are nonvolatile and if LD is loading
2234 /// 'Bytes' bytes from a location that is 'Dist' units away from the
2235 /// location that the 'Base' load is loading from.
2237 unsigned Bytes, int Dist) const;
2238
2239 /// Infer alignment of a load / store address. Return std::nullopt if it
2240 /// cannot be inferred.
2242
2243 /// Split the scalar node with EXTRACT_ELEMENT using the provided VTs and
2244 /// return the low/high part.
2245 std::pair<SDValue, SDValue> SplitScalar(const SDValue &N, const SDLoc &DL,
2246 const EVT &LoVT, const EVT &HiVT);
2247
2248 /// Compute the VTs needed for the low/hi parts of a type
2249 /// which is split (or expanded) into two not necessarily identical pieces.
2250 std::pair<EVT, EVT> GetSplitDestVTs(const EVT &VT) const;
2251
2252 /// Compute the VTs needed for the low/hi parts of a type, dependent on an
2253 /// enveloping VT that has been split into two identical pieces. Sets the
2254 /// HisIsEmpty flag when hi type has zero storage size.
2255 std::pair<EVT, EVT> GetDependentSplitDestVTs(const EVT &VT, const EVT &EnvVT,
2256 bool *HiIsEmpty) const;
2257
2258 /// Split the vector with EXTRACT_SUBVECTOR using the provides
2259 /// VTs and return the low/high part.
2260 std::pair<SDValue, SDValue> SplitVector(const SDValue &N, const SDLoc &DL,
2261 const EVT &LoVT, const EVT &HiVT);
2262
2263 /// Split the vector with EXTRACT_SUBVECTOR and return the low/high part.
2264 std::pair<SDValue, SDValue> SplitVector(const SDValue &N, const SDLoc &DL) {
2265 EVT LoVT, HiVT;
2266 std::tie(LoVT, HiVT) = GetSplitDestVTs(N.getValueType());
2267 return SplitVector(N, DL, LoVT, HiVT);
2268 }
2269
2270 /// Split the explicit vector length parameter of a VP operation.
2271 std::pair<SDValue, SDValue> SplitEVL(SDValue N, EVT VecVT, const SDLoc &DL);
2272
2273 /// Split the node's operand with EXTRACT_SUBVECTOR and
2274 /// return the low/high part.
2275 std::pair<SDValue, SDValue> SplitVectorOperand(const SDNode *N, unsigned OpNo)
2276 {
2277 return SplitVector(N->getOperand(OpNo), SDLoc(N));
2278 }
2279
2280 /// Widen the vector up to the next power of two using INSERT_SUBVECTOR.
2281 SDValue WidenVector(const SDValue &N, const SDLoc &DL);
2282
2283 /// Append the extracted elements from Start to Count out of the vector Op in
2284 /// Args. If Count is 0, all of the elements will be extracted. The extracted
2285 /// elements will have type EVT if it is provided, and otherwise their type
2286 /// will be Op's element type.
2288 unsigned Start = 0, unsigned Count = 0,
2289 EVT EltVT = EVT());
2290
2291 /// Compute the default alignment value for the given type.
2292 Align getEVTAlign(EVT MemoryVT) const;
2293
2294 /// Test whether the given value is a constant int or similar node.
2296
2297 /// Test whether the given value is a constant FP or similar node.
2299
2300 /// \returns true if \p N is any kind of constant or build_vector of
2301 /// constants, int or float. If a vector, it may not necessarily be a splat.
2305 }
2306
2307 /// Set CallSiteInfo to be associated with Node.
2309 SDEI[Node].CSInfo = std::move(CallInfo);
2310 }
2311 /// Return CallSiteInfo associated with Node, or a default if none exists.
2313 auto I = SDEI.find(Node);
2314 return I != SDEI.end() ? std::move(I->second).CSInfo : CallSiteInfo();
2315 }
2316 /// Set HeapAllocSite to be associated with Node.
2318 SDEI[Node].HeapAllocSite = MD;
2319 }
2320 /// Return HeapAllocSite associated with Node, or nullptr if none exists.
2322 auto I = SDEI.find(Node);
2323 return I != SDEI.end() ? I->second.HeapAllocSite : nullptr;
2324 }
2325 /// Set PCSections to be associated with Node.
2326 void addPCSections(const SDNode *Node, MDNode *MD) {
2327 SDEI[Node].PCSections = MD;
2328 }
2329 /// Return PCSections associated with Node, or nullptr if none exists.
2331 auto It = SDEI.find(Node);
2332 return It != SDEI.end() ? It->second.PCSections : nullptr;
2333 }
2334 /// Set NoMergeSiteInfo to be associated with Node if NoMerge is true.
2335 void addNoMergeSiteInfo(const SDNode *Node, bool NoMerge) {
2336 if (NoMerge)
2337 SDEI[Node].NoMerge = NoMerge;
2338 }
2339 /// Return NoMerge info associated with Node.
2340 bool getNoMergeSiteInfo(const SDNode *Node) const {
2341 auto I = SDEI.find(Node);
2342 return I != SDEI.end() ? I->second.NoMerge : false;
2343 }
2344
2345 /// Copy extra info associated with one node to another.
2346 void copyExtraInfo(SDNode *From, SDNode *To);
2347
2348 /// Return the current function's default denormal handling kind for the given
2349 /// floating point type.
2351 return MF->getDenormalMode(EVTToAPFloatSemantics(VT));
2352 }
2353
2354 bool shouldOptForSize() const;
2355
2356 /// Get the (commutative) neutral element for the given opcode, if it exists.
2357 SDValue getNeutralElement(unsigned Opcode, const SDLoc &DL, EVT VT,
2358 SDNodeFlags Flags);
2359
2360 /// Some opcodes may create immediate undefined behavior when used with some
2361 /// values (integer division-by-zero for example). Therefore, these operations
2362 /// are not generally safe to move around or change.
2364 switch (Opcode) {
2365 case ISD::SDIV:
2366 case ISD::SREM:
2367 case ISD::SDIVREM:
2368 case ISD::UDIV:
2369 case ISD::UREM:
2370 case ISD::UDIVREM:
2371 return false;
2372 default:
2373 return true;
2374 }
2375 }
2376
2377 /// Check if the provided node is save to speculatively executed given its
2378 /// current arguments. So, while `udiv` the opcode is not safe to
2379 /// speculatively execute, a given `udiv` node may be if the denominator is
2380 /// known nonzero.
2382 switch (N->getOpcode()) {
2383 case ISD::UDIV:
2384 return isKnownNeverZero(N->getOperand(1));
2385 default:
2386 return isSafeToSpeculativelyExecute(N->getOpcode());
2387 }
2388 }
2389
2391 const SDLoc &DLoc);
2392
2393private:
2394 void InsertNode(SDNode *N);
2395 bool RemoveNodeFromCSEMaps(SDNode *N);
2396 void AddModifiedNodeToCSEMaps(SDNode *N);
2397 SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op, void *&InsertPos);
2398 SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op1, SDValue Op2,
2399 void *&InsertPos);
2400 SDNode *FindModifiedNodeSlot(SDNode *N, ArrayRef<SDValue> Ops,
2401 void *&InsertPos);
2402 SDNode *UpdateSDLocOnMergeSDNode(SDNode *N, const SDLoc &loc);
2403
2404 void DeleteNodeNotInCSEMaps(SDNode *N);
2405 void DeallocateNode(SDNode *N);
2406
2407 void allnodes_clear();
2408
2409 /// Look up the node specified by ID in CSEMap. If it exists, return it. If
2410 /// not, return the insertion token that will make insertion faster. This
2411 /// overload is for nodes other than Constant or ConstantFP, use the other one
2412 /// for those.
2413 SDNode *FindNodeOrInsertPos(const FoldingSetNodeID &ID, void *&InsertPos);
2414
2415 /// Look up the node specified by ID in CSEMap. If it exists, return it. If
2416 /// not, return the insertion token that will make insertion faster. Performs
2417 /// additional processing for constant nodes.
2418 SDNode *FindNodeOrInsertPos(const FoldingSetNodeID &ID, const SDLoc &DL,
2419 void *&InsertPos);
2420
2421 /// Maps to auto-CSE operations.
2422 std::vector<CondCodeSDNode*> CondCodeNodes;
2423
2424 std::vector<SDNode*> ValueTypeNodes;
2425 std::map<EVT, SDNode*, EVT::compareRawBits> ExtendedValueTypeNodes;
2426 StringMap<SDNode*> ExternalSymbols;
2427
2428 std::map<std::pair<std::string, unsigned>, SDNode *> TargetExternalSymbols;
2430
2431 FlagInserter *Inserter = nullptr;
2432};
2433
2434template <> struct GraphTraits<SelectionDAG*> : public GraphTraits<SDNode*> {
2436
2438 return nodes_iterator(G->allnodes_begin());
2439 }
2440
2442 return nodes_iterator(G->allnodes_end());
2443 }
2444};
2445
2446} // end namespace llvm
2447
2448#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:477
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
static constexpr uint32_t RegMask
Definition: aarch32.h:221
static constexpr uint32_t Opcode
Definition: aarch32.h:200
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:875
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:261
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
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:137
FoldingSetNodeIDRef - This class describes a reference to an interned FoldingSetNodeID,...
Definition: FoldingSet.h:289
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:319
FoldingSet - This template class is used to instantiate a specialized implementation of the folding s...
Definition: FoldingSet.h:521
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:1037
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.
SmallVectorImpl< ArgRegPair > CallSiteInfoImpl
SmallVector< ArgRegPair, 1 > CallSiteInfo
Vector of call argument and its forwarding register.
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:361
SDNodeFlags getFlags() const
Definition: SelectionDAG.h:379
FlagInserter(SelectionDAG &SDAG, SDNodeFlags Flags)
Definition: SelectionDAG.h:367
FlagInserter(const FlagInserter &)=delete
FlagInserter(SelectionDAG &SDAG, SDNode *N)
Definition: SelectionDAG.h:372
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:922
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:720
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:952
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:551
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:474
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...
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, uint64_t Size=0, const AAMDNodes &AAInfo=AAMDNodes())
const Pass * getPass() const
Definition: SelectionDAG.h:470
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:486
BlockFrequencyInfo * getBFI() const
Definition: SelectionDAG.h:488
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:709
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)
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)
Returs an GlobalAddress of the function from the current module with name matching the given External...
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:461
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:780
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 getExtStridedLoadVP(ISD::LoadExtType ExtType, const SDLoc &DL, EVT VT, SDValue Chain, SDValue Ptr, SDValue Stride, SDValue Mask, SDValue EVL, MachinePointerInfo PtrInfo, EVT MemVT, MaybeAlign Alignment, MachineMemOperand::Flags MMOFlags, const AAMDNodes &AAInfo, bool IsExpanding=false)
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
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:475
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:478
bool isEqualTo(SDValue A, SDValue B) const
Test whether two SDValues are known to compare equal.
static constexpr unsigned MaxRecursionDepth
Definition: SelectionDAG.h:448
SDValue getTruncStridedStoreVP(SDValue Chain, const SDLoc &DL, SDValue Val, SDValue Ptr, SDValue Stride, SDValue Mask, SDValue EVL, MachinePointerInfo PtrInfo, EVT SVT, Align Alignment, MachineMemOperand::Flags MMOFlags, const AAMDNodes &AAInfo, bool IsCompressing=false)
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:678
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:387
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:730
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:531
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:826
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:532
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:472
SDNode * isConstantFPBuildVectorOrConstantFP(SDValue N) const
Test whether the given value is a constant FP or similar node.
allnodes_iterator allnodes_begin()
Definition: SelectionDAG.h:536
iterator_range< allnodes_const_iterator > allnodes() const
Definition: SelectionDAG.h:546
MDNode * getPCSections(const SDNode *Node) const
Return PCSections associated with Node, or nullptr if none exists.
ProfileSummaryInfo * getPSI() const
Definition: SelectionDAG.h:487
SDValue expandVAArg(SDNode *Node)
Expand the specified ISD::VAARG node as the Legalize pass would.
SDValue getTargetFrameIndex(int FI, EVT VT)
Definition: SelectionDAG.h:725
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:789
void addCallSiteInfo(const SDNode *Node, CallSiteInfoImpl &&CallInfo)
Set CallSiteInfo to be associated with Node.
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:480
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:682
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:659
SDValue getMDNode(const MDNode *MD)
Return an MDNodeSDNode which holds an MDNode.
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, MachinePointerInfo PtrInfo, EVT MemVT, MaybeAlign Alignment=MaybeAlign(), MachineMemOperand::Flags MMOFlags=MachineMemOperand::MONone, const AAMDNodes &AAInfo=AAMDNodes(), const MDNode *Ranges=nullptr, bool IsExpanding=false)
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)
SDValue getIndexedStridedStoreVP(SDValue OrigStore, const SDLoc &DL, SDValue Base, SDValue Offset, ISD::MemIndexedMode AM)
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 provides 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:860
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:490
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:835
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:537
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:473
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 getStepVector(const SDLoc &DL, EVT ResVT, APInt StepVal)
Returns a vector of type ResVT whose elements contain the linear sequence <0, Step,...
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:771
iterator_range< allnodes_iterator > allnodes()
Definition: SelectionDAG.h:543
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 getMemIntrinsicNode(unsigned Opcode, const SDLoc &dl, SDVTList VTList, ArrayRef< SDValue > Ops, EVT MemVT, MachinePointerInfo PtrInfo, Align Alignment, MachineMemOperand::Flags Flags=MachineMemOperand::MOLoad|MachineMemOperand::MOStore, uint64_t Size=0, const AAMDNodes &AAInfo=AAMDNodes())
Creates a MemIntrinsicNode that may produce a result and takes a list of operands.
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:706
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:539
ilist< SDNode >::const_iterator allnodes_const_iterator
Definition: SelectionDAG.h:529
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:674
const TargetLibraryInfo & getLibInfo() const
Definition: SelectionDAG.h:479
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.
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, MachinePointerInfo PtrInfo, EVT MemVT, Align Alignment, MachineMemOperand::Flags MMOFlags, const AAMDNodes &AAInfo, const MDNode *Ranges=nullptr, bool IsExpanding=false)
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:766
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:481
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:469
SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT)
Definition: SelectionDAG.h:797
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:491
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:843
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)
const FunctionVarLocs * getFunctionVarLocs() const
Returns the result of the AssignmentTrackingAnalysis pass if it's available, otherwise return nullptr...
Definition: SelectionDAG.h:484
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...
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:968
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 getIndexedStridedLoadVP(SDValue OrigLoad, const SDLoc &DL, SDValue Base, SDValue Offset, ISD::MemIndexedMode AM)
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:485
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:560
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:745
void clearGraphAttrs()
Clear all previously defined node graph attributes.
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:806
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:737
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:554
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:712
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:876
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:906
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:534
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:577
typename SuperClass::iterator iterator
Definition: SmallVector.h:581
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:112
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:78
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:1138
@ 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:1468
MemIndexedMode
MemIndexedMode enum - This enum defines the load / store indexed addressing modes.
Definition: ISDOpcodes.h:1455
CondCode
ISD::CondCode enum - These are ordered carefully to make the bitfields below work out,...
Definition: ISDOpcodes.h:1506
LoadExtType
LoadExtType enum - This enum defines the three variants of LOADEXT (load with extension).
Definition: ISDOpcodes.h:1486
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:1853
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:738
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:232
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:363
MVT getSimpleVT() const
Return the SimpleValueType held in the specified simple EVT.
Definition: ValueTypes.h:299
bool isVector() const
Return true if this is a vector value type.
Definition: ValueTypes.h:160
EVT getScalarType() const
If this is a vector type, return the element type, otherwise return this.
Definition: ValueTypes.h:306
bool isScalableVector() const
Return true if this is a vector type where the runtime length is machine dependent.
Definition: ValueTypes.h:166
EVT getVectorElementType() const
Given a vector type, return the type of each element.
Definition: ValueTypes.h:311
unsigned getVectorNumElements() const
Given a vector type, return the number of elements it contains.
Definition: ValueTypes.h:319
bool bitsLE(EVT VT) const
Return true if this has no more bits than VT.
Definition: ValueTypes.h:291
bool isInteger() const
Return true if this is an integer or a vector integer type.
Definition: ValueTypes.h:144
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:262
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:336
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:340
std::function< void(SDNode *, SDNode *)> Callback
Definition: SelectionDAG.h:334
std::function< void(SDNode *)> Callback
Definition: SelectionDAG.h:347
void NodeInserted(SDNode *N) override
The node N that was inserted.
Definition: SelectionDAG.h:353
DAGNodeInsertedListener(SelectionDAG &DAG, std::function< void(SDNode *)> Callback)
Definition: SelectionDAG.h:349
Clients of various APIs that cause global effects on the DAG can optionally implement this interface.
Definition: SelectionDAG.h:307
DAGUpdateListener *const Next
Definition: SelectionDAG.h:308
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