llvm/llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

//===-------- LegalizeFloatTypes.cpp - Legalization of float types --------===//
//
// 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 implements float type expansion and softening for LegalizeTypes.
// Softening is the act of turning a computation in an illegal floating point
// type into a computation in an integer type of the same size; also known as
// "soft float".  For example, turning f32 arithmetic into operations using i32.
// The resulting integer value is the same as what you would get by performing
// the floating point operation and bitcasting the result to the integer type.
// Expansion is the act of changing a computation in an illegal type to be a
// computation in two identical registers of a smaller type.  For example,
// implementing ppcf128 arithmetic in two f64 registers.
//
//===----------------------------------------------------------------------===//

#include "LegalizeTypes.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
usingnamespacellvm;

#define DEBUG_TYPE …

/// GetFPLibCall - Return the right libcall for the given floating point type.
/// FIXME: This is a local version of RTLIB::getFPLibCall that should be
///        refactored away (see RTLIB::getPOWI for an example).
static RTLIB::Libcall GetFPLibCall(EVT VT,
                                   RTLIB::Libcall Call_F32,
                                   RTLIB::Libcall Call_F64,
                                   RTLIB::Libcall Call_F80,
                                   RTLIB::Libcall Call_F128,
                                   RTLIB::Libcall Call_PPCF128) { … }

//===----------------------------------------------------------------------===//
//  Convert Float Results to Integer
//===----------------------------------------------------------------------===//

void DAGTypeLegalizer::SoftenFloatResult(SDNode *N, unsigned ResNo) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_Unary(SDNode *N, RTLIB::Libcall LC) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_Binary(SDNode *N, RTLIB::Libcall LC) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_BITCAST(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FREEZE(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_ARITH_FENCE(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_MERGE_VALUES(SDNode *N,
                                                      unsigned ResNo) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_BUILD_PAIR(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_ConstantFP(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_EXTRACT_ELEMENT(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_EXTRACT_VECTOR_ELT(SDNode *N, unsigned ResNo) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FABS(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FMINNUM(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FMAXNUM(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FMINIMUMNUM(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FMAXIMUMNUM(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FADD(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FACOS(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FASIN(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FATAN(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FCBRT(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FCEIL(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FCOPYSIGN(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FCOS(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FCOSH(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FDIV(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP2(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP10(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FFLOOR(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG2(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG10(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FMA(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FMUL(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FNEARBYINT(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FNEG(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FP_EXTEND(SDNode *N) { … }

// FIXME: Should we just use 'normal' FP_EXTEND / FP_TRUNC instead of special
// nodes?
SDValue DAGTypeLegalizer::SoftenFloatRes_FP16_TO_FP(SDNode *N) { … }

// FIXME: Should we just use 'normal' FP_EXTEND / FP_TRUNC instead of special
// nodes?
SDValue DAGTypeLegalizer::SoftenFloatRes_BF16_TO_FP(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FP_ROUND(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FPOW(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_ExpOp(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FFREXP(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FREM(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FRINT(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FROUND(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FROUNDEVEN(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FSIN(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FSINH(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FSQRT(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FSUB(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FTAN(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FTANH(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_FTRUNC(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_LOAD(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_ATOMIC_LOAD(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_SELECT(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_SELECT_CC(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_UNDEF(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_VAARG(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_XINT_TO_FP(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_VECREDUCE(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatRes_VECREDUCE_SEQ(SDNode *N) { … }

//===----------------------------------------------------------------------===//
//  Convert Float Operand to Integer
//===----------------------------------------------------------------------===//

bool DAGTypeLegalizer::SoftenFloatOperand(SDNode *N, unsigned OpNo) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_BITCAST(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_FP_ROUND(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_BR_CC(SDNode *N) { … }

// Even if the result type is legal, no libcall may exactly match. (e.g. We
// don't have FP-i8 conversions) This helper method looks for an appropriate
// promoted libcall.
static RTLIB::Libcall findFPToIntLibcall(EVT SrcVT, EVT RetVT, EVT &Promoted,
                                         bool Signed) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_XINT(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_XINT_SAT(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_SELECT_CC(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_SETCC(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_STORE(SDNode *N, unsigned OpNo) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_ATOMIC_STORE(SDNode *N, unsigned OpNo) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_FCOPYSIGN(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_Unary(SDNode *N, RTLIB::Libcall LC) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_LROUND(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_LLROUND(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_LRINT(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftenFloatOp_LLRINT(SDNode *N) { … }

//===----------------------------------------------------------------------===//
//  Float Result Expansion
//===----------------------------------------------------------------------===//

/// ExpandFloatResult - This method is called when the specified result of the
/// specified node is found to need expansion.  At this point, the node may also
/// have invalid operands or may have other results that need promotion, we just
/// know that (at least) one result needs expansion.
void DAGTypeLegalizer::ExpandFloatResult(SDNode *N, unsigned ResNo) { … }

void DAGTypeLegalizer::ExpandFloatRes_ConstantFP(SDNode *N, SDValue &Lo,
                                                 SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_Unary(SDNode *N, RTLIB::Libcall LC,
                                            SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_Binary(SDNode *N, RTLIB::Libcall LC,
                                             SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FABS(SDNode *N, SDValue &Lo,
                                           SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FMINNUM(SDNode *N, SDValue &Lo,
                                              SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FMAXNUM(SDNode *N, SDValue &Lo,
                                              SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FMINIMUMNUM(SDNode *N, SDValue &Lo,
                                                  SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FMAXIMUMNUM(SDNode *N, SDValue &Lo,
                                                  SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FADD(SDNode *N, SDValue &Lo,
                                           SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FACOS(SDNode *N, SDValue &Lo,
                                            SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FASIN(SDNode *N, SDValue &Lo,
                                            SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FATAN(SDNode *N, SDValue &Lo,
                                            SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FCBRT(SDNode *N, SDValue &Lo,
                                            SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FCEIL(SDNode *N,
                                            SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FCOPYSIGN(SDNode *N,
                                                SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FCOS(SDNode *N,
                                           SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FCOSH(SDNode *N, SDValue &Lo,
                                            SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FDIV(SDNode *N, SDValue &Lo,
                                           SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FEXP(SDNode *N,
                                           SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FEXP2(SDNode *N,
                                            SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FEXP10(SDNode *N, SDValue &Lo,
                                             SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FFLOOR(SDNode *N,
                                             SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FLOG(SDNode *N,
                                           SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FLOG2(SDNode *N,
                                            SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FLOG10(SDNode *N,
                                             SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FMA(SDNode *N, SDValue &Lo,
                                          SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FMUL(SDNode *N, SDValue &Lo,
                                           SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FNEARBYINT(SDNode *N,
                                                 SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FNEG(SDNode *N, SDValue &Lo,
                                           SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FP_EXTEND(SDNode *N, SDValue &Lo,
                                                SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FPOW(SDNode *N,
                                           SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FPOWI(SDNode *N,
                                            SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FLDEXP(SDNode *N, SDValue &Lo,
                                             SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FREEZE(SDNode *N,
                                             SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FREM(SDNode *N,
                                           SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FRINT(SDNode *N,
                                            SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FROUND(SDNode *N,
                                             SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FROUNDEVEN(SDNode *N,
                                             SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FSIN(SDNode *N,
                                           SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FSINH(SDNode *N, SDValue &Lo,
                                            SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FSQRT(SDNode *N,
                                            SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FSUB(SDNode *N, SDValue &Lo,
                                           SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FTAN(SDNode *N, SDValue &Lo,
                                           SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FTANH(SDNode *N, SDValue &Lo,
                                            SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_FTRUNC(SDNode *N,
                                             SDValue &Lo, SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_LOAD(SDNode *N, SDValue &Lo,
                                           SDValue &Hi) { … }

void DAGTypeLegalizer::ExpandFloatRes_XINT_TO_FP(SDNode *N, SDValue &Lo,
                                                 SDValue &Hi) { … }


//===----------------------------------------------------------------------===//
//  Float Operand Expansion
//===----------------------------------------------------------------------===//

/// ExpandFloatOperand - This method is called when the specified operand of the
/// specified node is found to need expansion.  At this point, all of the result
/// types of the node are known to be legal, but other operands of the node may
/// need promotion or expansion as well as the specified one.
bool DAGTypeLegalizer::ExpandFloatOperand(SDNode *N, unsigned OpNo) { … }

/// FloatExpandSetCCOperands - Expand the operands of a comparison.  This code
/// is shared among BR_CC, SELECT_CC, and SETCC handlers.
void DAGTypeLegalizer::FloatExpandSetCCOperands(SDValue &NewLHS,
                                                SDValue &NewRHS,
                                                ISD::CondCode &CCCode,
                                                const SDLoc &dl, SDValue &Chain,
                                                bool IsSignaling) { … }

SDValue DAGTypeLegalizer::ExpandFloatOp_BR_CC(SDNode *N) { … }

SDValue DAGTypeLegalizer::ExpandFloatOp_FCOPYSIGN(SDNode *N) { … }

SDValue DAGTypeLegalizer::ExpandFloatOp_FP_ROUND(SDNode *N) { … }

SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_XINT(SDNode *N) { … }

SDValue DAGTypeLegalizer::ExpandFloatOp_SELECT_CC(SDNode *N) { … }

SDValue DAGTypeLegalizer::ExpandFloatOp_SETCC(SDNode *N) { … }

SDValue DAGTypeLegalizer::ExpandFloatOp_STORE(SDNode *N, unsigned OpNo) { … }

SDValue DAGTypeLegalizer::ExpandFloatOp_LROUND(SDNode *N) { … }

SDValue DAGTypeLegalizer::ExpandFloatOp_LLROUND(SDNode *N) { … }

SDValue DAGTypeLegalizer::ExpandFloatOp_LRINT(SDNode *N) { … }

SDValue DAGTypeLegalizer::ExpandFloatOp_LLRINT(SDNode *N) { … }

//===----------------------------------------------------------------------===//
//  Float Operand Promotion
//===----------------------------------------------------------------------===//
//

static ISD::NodeType GetPromotionOpcode(EVT OpVT, EVT RetVT) { … }

static ISD::NodeType GetPromotionOpcodeStrict(EVT OpVT, EVT RetVT) { … }

bool DAGTypeLegalizer::PromoteFloatOperand(SDNode *N, unsigned OpNo) { … }

SDValue DAGTypeLegalizer::PromoteFloatOp_BITCAST(SDNode *N, unsigned OpNo) { … }

SDValue DAGTypeLegalizer::PromoteFloatOp_FAKE_USE(SDNode *N, unsigned OpNo) { … }

// Promote Operand 1 of FCOPYSIGN.  Operand 0 ought to be handled by
// PromoteFloatRes_FCOPYSIGN.
SDValue DAGTypeLegalizer::PromoteFloatOp_FCOPYSIGN(SDNode *N, unsigned OpNo) { … }

// Convert the promoted float value to the desired integer type
SDValue DAGTypeLegalizer::PromoteFloatOp_UnaryOp(SDNode *N, unsigned OpNo) { … }

SDValue DAGTypeLegalizer::PromoteFloatOp_FP_TO_XINT_SAT(SDNode *N,
                                                        unsigned OpNo) { … }

SDValue DAGTypeLegalizer::PromoteFloatOp_FP_EXTEND(SDNode *N, unsigned OpNo) { … }

SDValue DAGTypeLegalizer::PromoteFloatOp_STRICT_FP_EXTEND(SDNode *N,
                                                          unsigned OpNo) { … }

// Promote the float operands used for comparison.  The true- and false-
// operands have the same type as the result and are promoted, if needed, by
// PromoteFloatRes_SELECT_CC
SDValue DAGTypeLegalizer::PromoteFloatOp_SELECT_CC(SDNode *N, unsigned OpNo) { … }

// Construct a SETCC that compares the promoted values and sets the conditional
// code.
SDValue DAGTypeLegalizer::PromoteFloatOp_SETCC(SDNode *N, unsigned OpNo) { … }

// Lower the promoted Float down to the integer value of same size and construct
// a STORE of the integer value.
SDValue DAGTypeLegalizer::PromoteFloatOp_STORE(SDNode *N, unsigned OpNo) { … }

SDValue DAGTypeLegalizer::PromoteFloatOp_ATOMIC_STORE(SDNode *N,
                                                      unsigned OpNo) { … }

//===----------------------------------------------------------------------===//
//  Float Result Promotion
//===----------------------------------------------------------------------===//

void DAGTypeLegalizer::PromoteFloatResult(SDNode *N, unsigned ResNo) { … }

// Bitcast from i16 to f16:  convert the i16 to a f32 value instead.
// At this point, it is not possible to determine if the bitcast value is
// eventually stored to memory or promoted to f32 or promoted to a floating
// point at a higher precision.  Some of these cases are handled by FP_EXTEND,
// STORE promotion handlers.
SDValue DAGTypeLegalizer::PromoteFloatRes_BITCAST(SDNode *N) { … }

SDValue DAGTypeLegalizer::PromoteFloatRes_ConstantFP(SDNode *N) { … }

// If the Index operand is a constant, try to redirect the extract operation to
// the correct legalized vector.  If not, bit-convert the input vector to
// equivalent integer vector.  Extract the element as an (bit-cast) integer
// value and convert it to the promoted type.
SDValue DAGTypeLegalizer::PromoteFloatRes_EXTRACT_VECTOR_ELT(SDNode *N) { … }

// FCOPYSIGN(X, Y) returns the value of X with the sign of Y.  If the result
// needs promotion, so does the argument X.  Note that Y, if needed, will be
// handled during operand promotion.
SDValue DAGTypeLegalizer::PromoteFloatRes_FCOPYSIGN(SDNode *N) { … }

// Unary operation where the result and the operand have PromoteFloat type
// action.  Construct a new SDNode with the promoted float value of the old
// operand.
SDValue DAGTypeLegalizer::PromoteFloatRes_UnaryOp(SDNode *N) { … }

// Binary operations where the result and both operands have PromoteFloat type
// action.  Construct a new SDNode with the promoted float values of the old
// operands.
SDValue DAGTypeLegalizer::PromoteFloatRes_BinOp(SDNode *N) { … }

SDValue DAGTypeLegalizer::PromoteFloatRes_FMAD(SDNode *N) { … }

// Promote the Float (first) operand and retain the Integer (second) operand
SDValue DAGTypeLegalizer::PromoteFloatRes_ExpOp(SDNode *N) { … }

SDValue DAGTypeLegalizer::PromoteFloatRes_FFREXP(SDNode *N) { … }

// Explicit operation to reduce precision.  Reduce the value to half precision
// and promote it back to the legal type.
SDValue DAGTypeLegalizer::PromoteFloatRes_FP_ROUND(SDNode *N) { … }

// Explicit operation to reduce precision.  Reduce the value to half precision
// and promote it back to the legal type.
SDValue DAGTypeLegalizer::PromoteFloatRes_STRICT_FP_ROUND(SDNode *N) { … }

SDValue DAGTypeLegalizer::PromoteFloatRes_LOAD(SDNode *N) { … }

SDValue DAGTypeLegalizer::PromoteFloatRes_ATOMIC_LOAD(SDNode *N) { … }

// Construct a new SELECT node with the promoted true- and false- values.
SDValue DAGTypeLegalizer::PromoteFloatRes_SELECT(SDNode *N) { … }

// Construct a new SELECT_CC node with the promoted true- and false- values.
// The operands used for comparison are promoted by PromoteFloatOp_SELECT_CC.
SDValue DAGTypeLegalizer::PromoteFloatRes_SELECT_CC(SDNode *N) { … }

// Construct a SDNode that transforms the SINT or UINT operand to the promoted
// float type.
SDValue DAGTypeLegalizer::PromoteFloatRes_XINT_TO_FP(SDNode *N) { … }

SDValue DAGTypeLegalizer::PromoteFloatRes_UNDEF(SDNode *N) { … }

SDValue DAGTypeLegalizer::PromoteFloatRes_VECREDUCE(SDNode *N) { … }

SDValue DAGTypeLegalizer::PromoteFloatRes_VECREDUCE_SEQ(SDNode *N) { … }

SDValue DAGTypeLegalizer::BitcastToInt_ATOMIC_SWAP(SDNode *N) { … }

//===----------------------------------------------------------------------===//
//  Half Result Soft Promotion
//===----------------------------------------------------------------------===//

void DAGTypeLegalizer::SoftPromoteHalfResult(SDNode *N, unsigned ResNo) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_ARITH_FENCE(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_BITCAST(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_ConstantFP(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_EXTRACT_VECTOR_ELT(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_FCOPYSIGN(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_FMAD(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_ExpOp(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_FFREXP(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_FP_ROUND(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_LOAD(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_ATOMIC_LOAD(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_SELECT(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_SELECT_CC(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_XINT_TO_FP(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_UNDEF(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_UnaryOp(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_BinOp(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_VECREDUCE(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfRes_VECREDUCE_SEQ(SDNode *N) { … }

//===----------------------------------------------------------------------===//
//  Half Operand Soft Promotion
//===----------------------------------------------------------------------===//

bool DAGTypeLegalizer::SoftPromoteHalfOperand(SDNode *N, unsigned OpNo) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfOp_BITCAST(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfOp_FAKE_USE(SDNode *N, unsigned OpNo) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfOp_FCOPYSIGN(SDNode *N,
                                                      unsigned OpNo) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfOp_FP_EXTEND(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfOp_FP_TO_XINT(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfOp_FP_TO_XINT_SAT(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfOp_SELECT_CC(SDNode *N,
                                                      unsigned OpNo) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfOp_SETCC(SDNode *N) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfOp_STORE(SDNode *N, unsigned OpNo) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfOp_ATOMIC_STORE(SDNode *N,
                                                         unsigned OpNo) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfOp_STACKMAP(SDNode *N, unsigned OpNo) { … }

SDValue DAGTypeLegalizer::SoftPromoteHalfOp_PATCHPOINT(SDNode *N,
                                                       unsigned OpNo) { … }