Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- llvm/CodeGen/SelectionDAG.h - InstSelection DAG ----------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file declares the SelectionDAG class, and transitively defines the

// SDNode class and subclasses.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CODEGEN_SELECTIONDAG_H

#define LLVM_CODEGEN_SELECTIONDAG_H

#include "llvm/ADT/APFloat.h"

#include "llvm/ADT/APInt.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/DenseSet.h"

#include "llvm/ADT/FoldingSet.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringMap.h"

#include "llvm/ADT/ilist.h"

#include "llvm/ADT/iterator.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/CodeGen/DAGCombine.h"

#include "llvm/CodeGen/ISDOpcodes.h"

#include "llvm/CodeGen/MachineFunction.h"

#include "llvm/CodeGen/MachineMemOperand.h"

#include "llvm/CodeGen/SelectionDAGNodes.h"

#include "llvm/CodeGen/ValueTypes.h"

#include "llvm/IR/DebugLoc.h"

#include "llvm/IR/Metadata.h"

#include "llvm/Support/Allocator.h"

#include "llvm/Support/ArrayRecycler.h"

#include "llvm/Support/CodeGen.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/MachineValueType.h"

#include "llvm/Support/RecyclingAllocator.h"

#include <cassert>

#include <cstdint>

#include <functional>

#include <map>

#include <string>

#include <tuple>

#include <utility>

#include <vector>

namespace llvm {

class DIExpression;

class DILabel;

class DIVariable;

class Function;

class Pass;

class Type;

template <class GraphType> struct GraphTraits;

template <typename T, unsigned int N> class SmallSetVector;

template <typename T, typename Enable> struct FoldingSetTrait;

class AAResults;

class BlockAddress;

class BlockFrequencyInfo;

class Constant;

class ConstantFP;

class ConstantInt;

class DataLayout;

struct fltSemantics;

class FunctionLoweringInfo;

class FunctionVarLocs;

class GlobalValue;

struct KnownBits;

class LegacyDivergenceAnalysis;

class LLVMContext;

class MachineBasicBlock;

class MachineConstantPoolValue;

class MCSymbol;

class OptimizationRemarkEmitter;

class ProfileSummaryInfo;

class SDDbgValue;

class SDDbgOperand;

class SDDbgLabel;

class SelectionDAG;

class SelectionDAGTargetInfo;

class TargetLibraryInfo;

class TargetLowering;

class TargetMachine;

class TargetSubtargetInfo;

class Value;

class SDVTListNode : public FoldingSetNode {

  friend struct FoldingSetTrait<SDVTListNode>;

  /// A reference to an Interned FoldingSetNodeID for this node.

  /// The Allocator in SelectionDAG holds the data.

  /// SDVTList contains all types which are frequently accessed in SelectionDAG.

  /// The size of this list is not expected to be big so it won't introduce

  /// a memory penalty.

  FoldingSetNodeIDRef FastID;

  const EVT *VTs;

  unsigned int NumVTs;

  /// The hash value for SDVTList is fixed, so cache it to avoid

  /// hash calculation.

  unsigned HashValue;

public:

  SDVTListNode(const FoldingSetNodeIDRef ID, const EVT *VT, unsigned int Num) :

      FastID(ID), VTs(VT), NumVTs(Num) {

    HashValue = ID.ComputeHash();

  }

  SDVTList getSDVTList() {

    SDVTList result = {VTs, NumVTs};

    return result;

  }

};

/// Specialize FoldingSetTrait for SDVTListNode

/// to avoid computing temp FoldingSetNodeID and hash value.

template<> struct FoldingSetTrait<SDVTListNode> : DefaultFoldingSetTrait<SDVTListNode> {

  static void Profile(const SDVTListNode &X, FoldingSetNodeID& ID) {

    ID = X.FastID;

  }

  static bool Equals(const SDVTListNode &X, const FoldingSetNodeID &ID,

                     unsigned IDHash, FoldingSetNodeID &TempID) {

    if (X.HashValue != IDHash)

      return false;

    return ID == X.FastID;

  }

  static unsigned ComputeHash(const SDVTListNode &X, FoldingSetNodeID &TempID) {

    return X.HashValue;

  }

};

template <> struct ilist_alloc_traits<SDNode> {

  static void deleteNode(SDNode *) {

    llvm_unreachable("ilist_traits<SDNode> shouldn't see a deleteNode call!");

  }

};

/// Keeps track of dbg_value information through SDISel.  We do

/// not build SDNodes for these so as not to perturb the generated code;

/// instead the info is kept off to the side in this structure. Each SDNode may

/// have one or more associated dbg_value entries. This information is kept in

/// DbgValMap.

/// Byval parameters are handled separately because they don't use alloca's,

/// which busts the normal mechanism.  There is good reason for handling all

/// parameters separately:  they may not have code generated for them, they

/// should always go at the beginning of the function regardless of other code

/// motion, and debug info for them is potentially useful even if the parameter

/// is unused.  Right now only byval parameters are handled separately.

class SDDbgInfo {

  BumpPtrAllocator Alloc;

  SmallVector<SDDbgValue*, 32> DbgValues;

  SmallVector<SDDbgValue*, 32> ByvalParmDbgValues;

  SmallVector<SDDbgLabel*, 4> DbgLabels;

  using DbgValMapType = DenseMap<const SDNode *, SmallVector<SDDbgValue *, 2>>;

  DbgValMapType DbgValMap;

public:

  SDDbgInfo() = default;

  SDDbgInfo(const SDDbgInfo &) = delete;

  SDDbgInfo &operator=(const SDDbgInfo &) = delete;

  void add(SDDbgValue *V, bool isParameter);

  void add(SDDbgLabel *L) { DbgLabels.push_back(L); }

  /// Invalidate all DbgValues attached to the node and remove

  /// it from the Node-to-DbgValues map.

  void erase(const SDNode *Node);

  void clear() {

    DbgValMap.clear();

    DbgValues.clear();

    ByvalParmDbgValues.clear();

    DbgLabels.clear();

    Alloc.Reset();

  }

  BumpPtrAllocator &getAlloc() { return Alloc; }

  bool empty() const {

    return DbgValues.empty() && ByvalParmDbgValues.empty() && DbgLabels.empty();

  }

  ArrayRef<SDDbgValue*> getSDDbgValues(const SDNode *Node) const {

    auto I = DbgValMap.find(Node);

    if (I != DbgValMap.end())

      return I->second;

    return ArrayRef<SDDbgValue*>();

  }

  using DbgIterator = SmallVectorImpl<SDDbgValue*>::iterator;

  using DbgLabelIterator = SmallVectorImpl<SDDbgLabel*>::iterator;

  DbgIterator DbgBegin() { return DbgValues.begin(); }

  DbgIterator DbgEnd()   { return DbgValues.end(); }

  DbgIterator ByvalParmDbgBegin() { return ByvalParmDbgValues.begin(); }

  DbgIterator ByvalParmDbgEnd()   { return ByvalParmDbgValues.end(); }

  DbgLabelIterator DbgLabelBegin() { return DbgLabels.begin(); }

  DbgLabelIterator DbgLabelEnd()   { return DbgLabels.end(); }

};

void checkForCycles(const SelectionDAG *DAG, bool force = false);

/// This is used to represent a portion of an LLVM function in a low-level

/// Data Dependence DAG representation suitable for instruction selection.

/// This DAG is constructed as the first step of instruction selection in order

/// to allow implementation of machine specific optimizations

/// and code simplifications.

///

/// The representation used by the SelectionDAG is a target-independent

/// representation, which has some similarities to the GCC RTL representation,

/// but is significantly more simple, powerful, and is a graph form instead of a

/// linear form.

///

class SelectionDAG {

  const TargetMachine &TM;

  const SelectionDAGTargetInfo *TSI = nullptr;

  const TargetLowering *TLI = nullptr;

  const TargetLibraryInfo *LibInfo = nullptr;

  const FunctionVarLocs *FnVarLocs = nullptr;

  MachineFunction *MF;

  Pass *SDAGISelPass = nullptr;

  LLVMContext *Context;

  CodeGenOpt::Level OptLevel;

  LegacyDivergenceAnalysis * DA = nullptr;

  FunctionLoweringInfo * FLI = nullptr;

  /// The function-level optimization remark emitter.  Used to emit remarks

  /// whenever manipulating the DAG.

  OptimizationRemarkEmitter *ORE;

  ProfileSummaryInfo *PSI = nullptr;

  BlockFrequencyInfo *BFI = nullptr;

  /// List of non-single value types.

  FoldingSet<SDVTListNode> VTListMap;

  /// Pool allocation for misc. objects that are created once per SelectionDAG.

  BumpPtrAllocator Allocator;

  /// The starting token.

  SDNode EntryNode;

  /// The root of the entire DAG.

  SDValue Root;

  /// A linked list of nodes in the current DAG.

  ilist<SDNode> AllNodes;

  /// The AllocatorType for allocating SDNodes. We use

  /// pool allocation with recycling.

  using NodeAllocatorType = RecyclingAllocator<BumpPtrAllocator, SDNode,

                                               sizeof(LargestSDNode),

                                               alignof(MostAlignedSDNode)>;

  /// Pool allocation for nodes.

  NodeAllocatorType NodeAllocator;

  /// This structure is used to memoize nodes, automatically performing

  /// CSE with existing nodes when a duplicate is requested.

  FoldingSet<SDNode> CSEMap;

  /// Pool allocation for machine-opcode SDNode operands.

  BumpPtrAllocator OperandAllocator;

  ArrayRecycler<SDUse> OperandRecycler;

  /// Tracks dbg_value and dbg_label information through SDISel.

  SDDbgInfo *DbgInfo;

  using CallSiteInfo = MachineFunction::CallSiteInfo;

  using CallSiteInfoImpl = MachineFunction::CallSiteInfoImpl;

  struct NodeExtraInfo {

    CallSiteInfo CSInfo;

    MDNode *HeapAllocSite = nullptr;

    MDNode *PCSections = nullptr;

    bool NoMerge = false;

  };

  /// Out-of-line extra information for SDNodes.

  DenseMap<const SDNode *, NodeExtraInfo> SDEI;

  /// PersistentId counter to be used when inserting the next

  /// SDNode to this SelectionDAG. We do not place that under

  /// `#if LLVM_ENABLE_ABI_BREAKING_CHECKS` intentionally because

  /// it adds unneeded complexity without noticeable

  /// benefits (see discussion with @thakis in D120714).

  uint16_t NextPersistentId = 0;

public:

  /// Clients of various APIs that cause global effects on

  /// the DAG can optionally implement this interface.  This allows the clients

  /// to handle the various sorts of updates that happen.

  ///

  /// A DAGUpdateListener automatically registers itself with DAG when it is

  /// constructed, and removes itself when destroyed in RAII fashion.

  struct DAGUpdateListener {

    DAGUpdateListener *const Next;

    SelectionDAG &DAG;

    explicit DAGUpdateListener(SelectionDAG &D)

      : Next(D.UpdateListeners), DAG(D) {

      DAG.UpdateListeners = this;

    }

    virtual ~DAGUpdateListener() {

      assert(DAG.UpdateListeners == this &&

             "DAGUpdateListeners must be destroyed in LIFO order");

      DAG.UpdateListeners = Next;

    }

    /// The node N that was deleted and, if E is not null, an

    /// equivalent node E that replaced it.

    virtual void NodeDeleted(SDNode *N, SDNode *E);

    /// The node N that was updated.

    virtual void NodeUpdated(SDNode *N);

    /// The node N that was inserted.

    virtual void NodeInserted(SDNode *N);

  };

  struct DAGNodeDeletedListener : public DAGUpdateListener {

    std::function<void(SDNode *, SDNode *)> Callback;

    DAGNodeDeletedListener(SelectionDAG &DAG,

                           std::function<void(SDNode *, SDNode *)> Callback)

        : DAGUpdateListener(DAG), Callback(std::move(Callback)) {}

    void NodeDeleted(SDNode *N, SDNode *E) override { Callback(N, E); }

   private:

    virtual void anchor();

  };

  struct DAGNodeInsertedListener : public DAGUpdateListener {

    std::function<void(SDNode *)> Callback;

    DAGNodeInsertedListener(SelectionDAG &DAG,

                            std::function<void(SDNode *)> Callback)

        : DAGUpdateListener(DAG), Callback(std::move(Callback)) {}

    void NodeInserted(SDNode *N) override { Callback(N); }

  private:

    virtual void anchor();

  };

  /// Help to insert SDNodeFlags automatically in transforming. Use

  /// RAII to save and resume flags in current scope.

  class FlagInserter {

    SelectionDAG &DAG;

    SDNodeFlags Flags;

    FlagInserter *LastInserter;

  public:

    FlagInserter(SelectionDAG &SDAG, SDNodeFlags Flags)

        : DAG(SDAG), Flags(Flags),

          LastInserter(SDAG.getFlagInserter()) {

      SDAG.setFlagInserter(this);

    }

    FlagInserter(SelectionDAG &SDAG, SDNode *N)

        : FlagInserter(SDAG, N->getFlags()) {}

    FlagInserter(const FlagInserter &) = delete;

    FlagInserter &operator=(const FlagInserter &) = delete;

    ~FlagInserter() { DAG.setFlagInserter(LastInserter); }

    SDNodeFlags getFlags() const { return Flags; }

  };

  /// When true, additional steps are taken to

  /// ensure that getConstant() and similar functions return DAG nodes that

  /// have legal types. This is important after type legalization since

  /// any illegally typed nodes generated after this point will not experience

  /// type legalization.

  bool NewNodesMustHaveLegalTypes = false;

private:

  /// DAGUpdateListener is a friend so it can manipulate the listener stack.

  friend struct DAGUpdateListener;

  /// Linked list of registered DAGUpdateListener instances.

  /// This stack is maintained by DAGUpdateListener RAII.

  DAGUpdateListener *UpdateListeners = nullptr;

  /// Implementation of setSubgraphColor.

  /// Return whether we had to truncate the search.

  bool setSubgraphColorHelper(SDNode *N, const char *Color,

                              DenseSet<SDNode *> &visited,

                              int level, bool &printed);

  template <typename SDNodeT, typename... ArgTypes>

  SDNodeT *newSDNode(ArgTypes &&... Args) {

    return new (NodeAllocator.template Allocate<SDNodeT>())

        SDNodeT(std::forward<ArgTypes>(Args)...);

  }

  /// Build a synthetic SDNodeT with the given args and extract its subclass

  /// data as an integer (e.g. for use in a folding set).

  ///

  /// The args to this function are the same as the args to SDNodeT's

  /// constructor, except the second arg (assumed to be a const DebugLoc&) is

  /// omitted.

  template <typename SDNodeT, typename... ArgTypes>

  static uint16_t getSyntheticNodeSubclassData(unsigned IROrder,

                                               ArgTypes &&... Args) {

    // The compiler can reduce this expression to a constant iff we pass an

    // empty DebugLoc.  Thankfully, the debug location doesn't have any bearing

    // on the subclass data.

    return SDNodeT(IROrder, DebugLoc(), std::forward<ArgTypes>(Args)...)

        .getRawSubclassData();

  }

  template <typename SDNodeTy>

  static uint16_t getSyntheticNodeSubclassData(unsigned Opc, unsigned Order,

                                                SDVTList VTs, EVT MemoryVT,

                                                MachineMemOperand *MMO) {

    return SDNodeTy(Opc, Order, DebugLoc(), VTs, MemoryVT, MMO)

         .getRawSubclassData();

  }

  void createOperands(SDNode *Node, ArrayRef<SDValue> Vals);

  void removeOperands(SDNode *Node) {

    if (!Node->OperandList)

      return;

    OperandRecycler.deallocate(

        ArrayRecycler<SDUse>::Capacity::get(Node->NumOperands),

        Node->OperandList);

    Node->NumOperands = 0;

    Node->OperandList = nullptr;

  }

  void CreateTopologicalOrder(std::vector<SDNode*>& Order);

public:

  // Maximum depth for recursive analysis such as computeKnownBits, etc.

  static constexpr unsigned MaxRecursionDepth = 6;

  explicit SelectionDAG(const TargetMachine &TM, CodeGenOpt::Level);

  SelectionDAG(const SelectionDAG &) = delete;

  SelectionDAG &operator=(const SelectionDAG &) = delete;

  ~SelectionDAG();

  /// Prepare this SelectionDAG to process code in the given MachineFunction.

  void init(MachineFunction &NewMF, OptimizationRemarkEmitter &NewORE,

            Pass *PassPtr, const TargetLibraryInfo *LibraryInfo,

            LegacyDivergenceAnalysis *Divergence, ProfileSummaryInfo *PSIin,

            BlockFrequencyInfo *BFIin, FunctionVarLocs const *FnVarLocs);

  void setFunctionLoweringInfo(FunctionLoweringInfo * FuncInfo) {

    FLI = FuncInfo;

  }

  /// Clear state and free memory necessary to make this

  /// SelectionDAG ready to process a new block.

  void clear();

  MachineFunction &getMachineFunction() const { return *MF; }

  const Pass *getPass() const { return SDAGISelPass; }

  const DataLayout &getDataLayout() const { return MF->getDataLayout(); }

  const TargetMachine &getTarget() const { return TM; }

  const TargetSubtargetInfo &getSubtarget() const { return MF->getSubtarget(); }

  template <typename STC> const STC &getSubtarget() const {

    return MF->getSubtarget<STC>();

  }

  const TargetLowering &getTargetLoweringInfo() const { return *TLI; }

  const TargetLibraryInfo &getLibInfo() const { return *LibInfo; }

  const SelectionDAGTargetInfo &getSelectionDAGInfo() const { return *TSI; }

  const LegacyDivergenceAnalysis *getDivergenceAnalysis() const { return DA; }

  /// Returns the result of the AssignmentTrackingAnalysis pass if it's

  /// available, otherwise return nullptr.

  const FunctionVarLocs *getFunctionVarLocs() const { return FnVarLocs; }

  LLVMContext *getContext() const { return Context; }

  OptimizationRemarkEmitter &getORE() const { return *ORE; }

  ProfileSummaryInfo *getPSI() const { return PSI; }

  BlockFrequencyInfo *getBFI() const { return BFI; }

  FlagInserter *getFlagInserter() { return Inserter; }

  void setFlagInserter(FlagInserter *FI) { Inserter = FI; }

  /// Just dump dot graph to a user-provided path and title.

  /// This doesn't open the dot viewer program and

  /// helps visualization when outside debugging session.

  /// FileName expects absolute path. If provided

  /// without any path separators then the file

  /// will be created in the current directory.

  /// Error will be emitted if the path is insane.

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

  LLVM_DUMP_METHOD void dumpDotGraph(const Twine &FileName, const Twine &Title);

#endif

  /// Pop up a GraphViz/gv window with the DAG rendered using 'dot'.

  void viewGraph(const std::string &Title);

  void viewGraph();

#if LLVM_ENABLE_ABI_BREAKING_CHECKS

  std::map<const SDNode *, std::string> NodeGraphAttrs;

#endif

  /// Clear all previously defined node graph attributes.

  /// Intended to be used from a debugging tool (eg. gdb).

  void clearGraphAttrs();

  /// Set graph attributes for a node. (eg. "color=red".)

  void setGraphAttrs(const SDNode *N, const char *Attrs);

  /// Get graph attributes for a node. (eg. "color=red".)

  /// Used from getNodeAttributes.

  std::string getGraphAttrs(const SDNode *N) const;

  /// Convenience for setting node color attribute.

  void setGraphColor(const SDNode *N, const char *Color);

  /// Convenience for setting subgraph color attribute.

  void setSubgraphColor(SDNode *N, const char *Color);

  using allnodes_const_iterator = ilist<SDNode>::const_iterator;

  allnodes_const_iterator allnodes_begin() const { return AllNodes.begin(); }

  allnodes_const_iterator allnodes_end() const { return AllNodes.end(); }

  using allnodes_iterator = ilist<SDNode>::iterator;

  allnodes_iterator allnodes_begin() { return AllNodes.begin(); }

  allnodes_iterator allnodes_end() { return AllNodes.end(); }

  ilist<SDNode>::size_type allnodes_size() const {

    return AllNodes.size();

  }

  iterator_range<allnodes_iterator> allnodes() {

    return make_range(allnodes_begin(), allnodes_end());

  }

  iterator_range<allnodes_const_iterator> allnodes() const {

    return make_range(allnodes_begin(), allnodes_end());

  }

  /// Return the root tag of the SelectionDAG.

  const SDValue &getRoot() const { return Root; }

  /// Return the token chain corresponding to the entry of the function.

  SDValue getEntryNode() const {

    return SDValue(const_cast<SDNode *>(&EntryNode), 0);

  }

  /// Set the current root tag of the SelectionDAG.

  ///

  const SDValue &setRoot(SDValue N) {

    assert((!N.getNode() || N.getValueType() == MVT::Other) &&

           "DAG root value is not a chain!");

    if (N.getNode())

      checkForCycles(N.getNode(), this);

    Root = N;

    if (N.getNode())

      checkForCycles(this);

    return Root;

  }

#ifndef NDEBUG

  void VerifyDAGDivergence();

#endif

  /// This iterates over the nodes in the SelectionDAG, folding

  /// certain types of nodes together, or eliminating superfluous nodes.  The

  /// Level argument controls whether Combine is allowed to produce nodes and

  /// types that are illegal on the target.

  void Combine(CombineLevel Level, AAResults *AA,

               CodeGenOpt::Level OptLevel);

  /// This transforms the SelectionDAG into a SelectionDAG that

  /// only uses types natively supported by the target.

  /// Returns "true" if it made any changes.

  ///

  /// Note that this is an involved process that may invalidate pointers into

  /// the graph.

  bool LegalizeTypes();

  /// This transforms the SelectionDAG into a SelectionDAG that is

  /// compatible with the target instruction selector, as indicated by the

  /// TargetLowering object.

  ///

  /// Note that this is an involved process that may invalidate pointers into

  /// the graph.

  void Legalize();

  /// Transforms a SelectionDAG node and any operands to it into a node

  /// that is compatible with the target instruction selector, as indicated by

  /// the TargetLowering object.

  ///

  /// \returns true if \c N is a valid, legal node after calling this.

  ///

  /// This essentially runs a single recursive walk of the \c Legalize process

  /// over the given node (and its operands). This can be used to incrementally

  /// legalize the DAG. All of the nodes which are directly replaced,

  /// potentially including N, are added to the output parameter \c

  /// UpdatedNodes so that the delta to the DAG can be understood by the

  /// caller.

  ///

  /// When this returns false, N has been legalized in a way that make the

  /// pointer passed in no longer valid. It may have even been deleted from the

  /// DAG, and so it shouldn't be used further. When this returns true, the

  /// N passed in is a legal node, and can be immediately processed as such.

  /// This may still have done some work on the DAG, and will still populate

  /// UpdatedNodes with any new nodes replacing those originally in the DAG.

  bool LegalizeOp(SDNode *N, SmallSetVector<SDNode *, 16> &UpdatedNodes);

  /// This transforms the SelectionDAG into a SelectionDAG

  /// that only uses vector math operations supported by the target.  This is

  /// necessary as a separate step from Legalize because unrolling a vector

  /// operation can introduce illegal types, which requires running

  /// LegalizeTypes again.

  ///

  /// This returns true if it made any changes; in that case, LegalizeTypes

  /// is called again before Legalize.

  ///

  /// Note that this is an involved process that may invalidate pointers into

  /// the graph.

  bool LegalizeVectors();

  /// This method deletes all unreachable nodes in the SelectionDAG.

  void RemoveDeadNodes();

  /// Remove the specified node from the system.  This node must

  /// have no referrers.

  void DeleteNode(SDNode *N);

  /// Return an SDVTList that represents the list of values specified.

  SDVTList getVTList(EVT VT);

  SDVTList getVTList(EVT VT1, EVT VT2);

  SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3);

  SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4);

  SDVTList getVTList(ArrayRef<EVT> VTs);

  //===--------------------------------------------------------------------===//

  // Node creation methods.

  /// Create a ConstantSDNode wrapping a constant value.

  /// If VT is a vector type, the constant is splatted into a BUILD_VECTOR.

  ///

  /// If only legal types can be produced, this does the necessary

  /// transformations (e.g., if the vector element type is illegal).

  /// @{

  SDValue getConstant(uint64_t Val, const SDLoc &DL, EVT VT,

                      bool isTarget = false, bool isOpaque = false);

  SDValue getConstant(const APInt &Val, const SDLoc &DL, EVT VT,

                      bool isTarget = false, bool isOpaque = false);

  SDValue getAllOnesConstant(const SDLoc &DL, EVT VT, bool IsTarget = false,

                             bool IsOpaque = false) {

    return getConstant(APInt::getAllOnes(VT.getScalarSizeInBits()), DL, VT,

                       IsTarget, IsOpaque);

  }

  SDValue getConstant(const ConstantInt &Val, const SDLoc &DL, EVT VT,

                      bool isTarget = false, bool isOpaque = false);

  SDValue getIntPtrConstant(uint64_t Val, const SDLoc &DL,

                            bool isTarget = false);

  SDValue getShiftAmountConstant(uint64_t Val, EVT VT, const SDLoc &DL,

                                 bool LegalTypes = true);

  SDValue getVectorIdxConstant(uint64_t Val, const SDLoc &DL,

                               bool isTarget = false);

  SDValue getTargetConstant(uint64_t Val, const SDLoc &DL, EVT VT,

                            bool isOpaque = false) {

    return getConstant(Val, DL, VT, true, isOpaque);

  }

  SDValue getTargetConstant(const APInt &Val, const SDLoc &DL, EVT VT,

                            bool isOpaque = false) {

    return getConstant(Val, DL, VT, true, isOpaque);

  }

  SDValue getTargetConstant(const ConstantInt &Val, const SDLoc &DL, EVT VT,

                            bool isOpaque = false) {

    return getConstant(Val, DL, VT, true, isOpaque);

  }

  /// Create a true or false constant of type \p VT using the target's

  /// BooleanContent for type \p OpVT.

  SDValue getBoolConstant(bool V, const SDLoc &DL, EVT VT, EVT OpVT);

  /// @}

  /// Create a ConstantFPSDNode wrapping a constant value.

  /// If VT is a vector type, the constant is splatted into a BUILD_VECTOR.

  ///

  /// If only legal types can be produced, this does the necessary

  /// transformations (e.g., if the vector element type is illegal).

  /// The forms that take a double should only be used for simple constants

  /// that can be exactly represented in VT.  No checks are made.

  /// @{

  SDValue getConstantFP(double Val, const SDLoc &DL, EVT VT,

                        bool isTarget = false);

  SDValue getConstantFP(const APFloat &Val, const SDLoc &DL, EVT VT,

                        bool isTarget = false);

  SDValue getConstantFP(const ConstantFP &V, const SDLoc &DL, EVT VT,

                        bool isTarget = false);

  SDValue getTargetConstantFP(double Val, const SDLoc &DL, EVT VT) {

    return getConstantFP(Val, DL, VT, true);

  }

  SDValue getTargetConstantFP(const APFloat &Val, const SDLoc &DL, EVT VT) {

    return getConstantFP(Val, DL, VT, true);

  }

  SDValue getTargetConstantFP(const ConstantFP &Val, const SDLoc &DL, EVT VT) {

    return getConstantFP(Val, DL, VT, true);

  }

  /// @}

  SDValue getGlobalAddress(const GlobalValue *GV, const SDLoc &DL, EVT VT,

                           int64_t offset = 0, bool isTargetGA = false,

                           unsigned TargetFlags = 0);

  SDValue getTargetGlobalAddress(const GlobalValue *GV, const SDLoc &DL, EVT VT,

                                 int64_t offset = 0, unsigned TargetFlags = 0) {

    return getGlobalAddress(GV, DL, VT, offset, true, TargetFlags);

  }

  SDValue getFrameIndex(int FI, EVT VT, bool isTarget = false);

  SDValue getTargetFrameIndex(int FI, EVT VT) {

    return getFrameIndex(FI, VT, true);

  }

  SDValue getJumpTable(int JTI, EVT VT, bool isTarget = false,

                       unsigned TargetFlags = 0);

  SDValue getTargetJumpTable(int JTI, EVT VT, unsigned TargetFlags = 0) {

    return getJumpTable(JTI, VT, true, TargetFlags);

  }

  SDValue getConstantPool(const Constant *C, EVT VT,

                          MaybeAlign Align = std::nullopt, int Offs = 0,

                          bool isT = false, unsigned TargetFlags = 0);

  SDValue getTargetConstantPool(const Constant *C, EVT VT,

                                MaybeAlign Align = std::nullopt, int Offset = 0,

                                unsigned TargetFlags = 0) {

    return getConstantPool(C, VT, Align, Offset, true, TargetFlags);

  }

  SDValue getConstantPool(MachineConstantPoolValue *C, EVT VT,

                          MaybeAlign Align = std::nullopt, int Offs = 0,

                          bool isT = false, unsigned TargetFlags = 0);

  SDValue getTargetConstantPool(MachineConstantPoolValue *C, EVT VT,

                                MaybeAlign Align = std::nullopt, int Offset = 0,

                                unsigned TargetFlags = 0) {

    return getConstantPool(C, VT, Align, Offset, true, TargetFlags);

  }

  SDValue getTargetIndex(int Index, EVT VT, int64_t Offset = 0,

                         unsigned TargetFlags = 0);

  // When generating a branch to a BB, we don't in general know enough

  // to provide debug info for the BB at that time, so keep this one around.

  SDValue getBasicBlock(MachineBasicBlock *MBB);

  SDValue getExternalSymbol(const char *Sym, EVT VT);

  SDValue getTargetExternalSymbol(const char *Sym, EVT VT,

                                  unsigned TargetFlags = 0);

  SDValue getMCSymbol(MCSymbol *Sym, EVT VT);

  SDValue getValueType(EVT);

  SDValue getRegister(unsigned Reg, EVT VT);

  SDValue getRegisterMask(const uint32_t *RegMask);

  SDValue getEHLabel(const SDLoc &dl, SDValue Root, MCSymbol *Label);

  SDValue getLabelNode(unsigned Opcode, const SDLoc &dl, SDValue Root,

                       MCSymbol *Label);

  SDValue getBlockAddress(const BlockAddress *BA, EVT VT, int64_t Offset = 0,

                          bool isTarget = false, unsigned TargetFlags = 0);

  SDValue getTargetBlockAddress(const BlockAddress *BA, EVT VT,

                                int64_t Offset = 0, unsigned TargetFlags = 0) {

    return getBlockAddress(BA, VT, Offset, true, TargetFlags);

  }

  SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, unsigned Reg,

                       SDValue N) {

    return getNode(ISD::CopyToReg, dl, MVT::Other, Chain,

                   getRegister(Reg, N.getValueType()), N);

  }

  // This version of the getCopyToReg method takes an extra operand, which

  // indicates that there is potentially an incoming glue value (if Glue is not

  // null) and that there should be a glue result.

  SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, unsigned Reg, SDValue N,

                       SDValue Glue) {

    SDVTList VTs = getVTList(MVT::Other, MVT::Glue);

    SDValue Ops[] = { Chain, getRegister(Reg, N.getValueType()), N, Glue };

    return getNode(ISD::CopyToReg, dl, VTs,

                   ArrayRef(Ops, Glue.getNode() ? 4 : 3));

  }

  // Similar to last getCopyToReg() except parameter Reg is a SDValue

  SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, SDValue Reg, SDValue N,

                       SDValue Glue) {

    SDVTList VTs = getVTList(MVT::Other, MVT::Glue);

    SDValue Ops[] = { Chain, Reg, N, Glue };

    return getNode(ISD::CopyToReg, dl, VTs,

                   ArrayRef(Ops, Glue.getNode() ? 4 : 3));

  }

  SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT) {

    SDVTList VTs = getVTList(VT, MVT::Other);

    SDValue Ops[] = { Chain, getRegister(Reg, VT) };

    return getNode(ISD::CopyFromReg, dl, VTs, Ops);