Delete dead code in the SelectionDAG headers (NFC)

[vsk]

Summary

I tested this with "ninja check-llvm-codegen" on a Release build with
all architectures enabled.

Found with llvm-cov.

include/llvm/CodeGen/SelectionDAG.h

#endif
   /// 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 &CF, 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 char TargetFlags = 0);
if (Op.getOpcode() == ISD::UNDEF) {
              "greater than the vector element type!");
       return getNode(ISD::UNDEF, SDLoc(), VT);
     }
 
     SmallVector<SDValue, 16> Ops(VT.getVectorNumElements(), Op);
     return getNode(ISD::BUILD_VECTOR, DL, VT, Ops);
   }
 
-  /// Return a splat ISD::BUILD_VECTOR node, but with Op's SDLoc.
-  SDValue getSplatBuildVector(EVT VT, SDValue Op) {
-    return getSplatBuildVector(VT, SDLoc(Op), Op);
-  }
-
   /// \brief Returns an ISD::VECTOR_SHUFFLE node semantically equivalent to
   /// the shuffle node in input but with swapped operands.
   ///
   /// Example: shuffle A, B, <0,5,2,7> -> shuffle B, A, <4,1,6,3>
   SDValue getCommutedVectorShuffle(const ShuffleVectorSDNode &SV);
 
   /// Convert Op, which must be of integer type, to the
   /// integer type VT, by either any-extending or truncating it.

include/llvm/CodeGen/SelectionDAGNodes.h

unsigned getScalarValueSizeInBits() const {
     return getValueType().getScalarType().getSizeInBits();
   }
 
   // Forwarding methods - These forward to the corresponding methods in SDNode.
   inline unsigned getOpcode() const;
   inline unsigned getNumOperands() const;
   inline const SDValue &getOperand(unsigned i) const;
   inline uint64_t getConstantOperandVal(unsigned i) const;
-  inline bool isTargetMemoryOpcode() const;
-  inline bool isTargetOpcode() const;
   inline bool isMachineOpcode() const;
   inline bool isUndef() const;
   inline unsigned getMachineOpcode() const;
   inline const DebugLoc &getDebugLoc() const;
   inline void dump() const;
   inline void dumpr() const;
 
   /// Return true if this operand (which must be a chain) reaches the
public:
   bool hasExact() const { return Exact; }
   bool hasUnsafeAlgebra() const { return UnsafeAlgebra; }
   bool hasNoNaNs() const { return NoNaNs; }
   bool hasNoInfs() const { return NoInfs; }
   bool hasNoSignedZeros() const { return NoSignedZeros; }
   bool hasAllowReciprocal() const { return AllowReciprocal; }
   bool hasVectorReduction() const { return VectorReduction; }
 
-  /// Return a raw encoding of the flags.
-  /// This function should only be used to add data to the NodeID value.
-  unsigned getRawFlags() const {
-    return (NoUnsignedWrap << 0) | (NoSignedWrap << 1) | (Exact << 2) |
-    (UnsafeAlgebra << 3) | (NoNaNs << 4) | (NoInfs << 5) |
-    (NoSignedZeros << 6) | (AllowReciprocal << 7);
-  }
-
   /// Clear any flags in this flag set that aren't also set in Flags.
   void intersectWith(const SDNodeFlags *Flags) {
     NoUnsignedWrap &= Flags->NoUnsignedWrap;
     NoSignedWrap &= Flags->NoSignedWrap;
     Exact &= Flags->Exact;
     UnsafeAlgebra &= Flags->UnsafeAlgebra;
     NoNaNs &= Flags->NoNaNs;
     NoInfs &= Flags->NoInfs;
inline unsigned SDValue::getNumOperands() const {
   return Node->getNumOperands();
 }
 inline const SDValue &SDValue::getOperand(unsigned i) const {
   return Node->getOperand(i);
 }
 inline uint64_t SDValue::getConstantOperandVal(unsigned i) const {
   return Node->getConstantOperandVal(i);
 }
-inline bool SDValue::isTargetOpcode() const {
-  return Node->isTargetOpcode();
-}
-inline bool SDValue::isTargetMemoryOpcode() const {
-  return Node->isTargetMemoryOpcode();
-}
 inline bool SDValue::isMachineOpcode() const {
   return Node->isMachineOpcode();
 }
 inline unsigned SDValue::getMachineOpcode() const {
   return Node->getMachineOpcode();
 }
 inline bool SDValue::isUndef() const {
   return Node->isUndef();
inline bool isNormalStore(const SDNode *N) {
     return St && !St->isTruncatingStore() &&
       St->getAddressingMode() == ISD::UNINDEXED;
   }
 
   /// Returns true if the specified node is a non-truncating store.
   inline bool isNON_TRUNCStore(const SDNode *N) {
     return isa<StoreSDNode>(N) && !cast<StoreSDNode>(N)->isTruncatingStore();
   }
-
-  /// Returns true if the specified node is a truncating store.
-  inline bool isTRUNCStore(const SDNode *N) {
-    return isa<StoreSDNode>(N) && cast<StoreSDNode>(N)->isTruncatingStore();
-  }
-
-  /// Returns true if the specified node is an unindexed store.
-  inline bool isUNINDEXEDStore(const SDNode *N) {
-    return isa<StoreSDNode>(N) &&
-      cast<StoreSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
-  }
 }
 
 } // end llvm namespace
 
 #endif