llvm/llvm/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp

//===----- LegalizeIntegerTypes.cpp - Legalization of integer 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 integer type expansion and promotion for LegalizeTypes.
// Promotion is the act of changing a computation in an illegal type into a
// computation in a larger type.  For example, implementing i8 arithmetic in an
// i32 register (often needed on powerpc).
// Expansion is the act of changing a computation in an illegal type into a
// computation in two identical registers of a smaller type.  For example,
// implementing i64 arithmetic in two i32 registers (often needed on 32-bit
// targets).
//
//===----------------------------------------------------------------------===//

#include "LegalizeTypes.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/CodeGen/StackMaps.h"
#include "llvm/CodeGen/TargetLowering.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/KnownBits.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
usingnamespacellvm;

#define DEBUG_TYPE …

//===----------------------------------------------------------------------===//
//  Integer Result Promotion
//===----------------------------------------------------------------------===//

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

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

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

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

SDValue DAGTypeLegalizer::PromoteIntRes_Atomic0(AtomicSDNode *N) { … }

SDValue DAGTypeLegalizer::PromoteIntRes_Atomic1(AtomicSDNode *N) { … }

SDValue DAGTypeLegalizer::PromoteIntRes_AtomicCmpSwap(AtomicSDNode *N,
                                                      unsigned ResNo) { … }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SDValue DAGTypeLegalizer::PromoteIntRes_LOAD(LoadSDNode *N) { … }

SDValue DAGTypeLegalizer::PromoteIntRes_MLOAD(MaskedLoadSDNode *N) { … }

SDValue DAGTypeLegalizer::PromoteIntRes_MGATHER(MaskedGatherSDNode *N) { … }

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

/// Promote the overflow flag of an overflowing arithmetic node.
SDValue DAGTypeLegalizer::PromoteIntRes_Overflow(SDNode *N) { … }

template <class MatchContextClass>
SDValue DAGTypeLegalizer::PromoteIntRes_ADDSUBSHLSAT(SDNode *N) { … }

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

static SDValue SaturateWidenedDIVFIX(SDValue V, SDLoc &dl,
                                     unsigned SatW, bool Signed,
                                     const TargetLowering &TLI,
                                     SelectionDAG &DAG) { … }

static SDValue earlyExpandDIVFIX(SDNode *N, SDValue LHS, SDValue RHS,
                                 unsigned Scale, const TargetLowering &TLI,
                                 SelectionDAG &DAG, unsigned SatW = 0) { … }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// A vp version of PromoteIntRes_FunnelShift.
SDValue DAGTypeLegalizer::PromoteIntRes_VPFunnelShift(SDNode *N) { … }

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

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

// Handle promotion for the ADDE/SUBE/UADDO_CARRY/USUBO_CARRY nodes. Notice that
// the third operand of ADDE/SUBE nodes is carry flag, which differs from
// the UADDO_CARRY/USUBO_CARRY nodes in that the third operand is carry Boolean.
SDValue DAGTypeLegalizer::PromoteIntRes_UADDSUBO_CARRY(SDNode *N,
                                                       unsigned ResNo) { … }

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

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

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

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

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

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

//===----------------------------------------------------------------------===//
//  Integer Operand Promotion
//===----------------------------------------------------------------------===//

/// PromoteIntegerOperand - This method is called when the specified operand of
/// the specified node is found to need promotion.  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::PromoteIntegerOperand(SDNode *N, unsigned OpNo) { … }

// These operands can be either sign extended or zero extended as long as we
// treat them the same. If an extension is free, choose that. Otherwise, follow
// target preference.
void DAGTypeLegalizer::SExtOrZExtPromotedOperands(SDValue &LHS, SDValue &RHS) { … }

/// PromoteSetCCOperands - Promote the operands of a comparison.  This code is
/// shared among BR_CC, SELECT_CC, and SETCC handlers.
void DAGTypeLegalizer::PromoteSetCCOperands(SDValue &LHS, SDValue &RHS,
                                            ISD::CondCode CCCode) { … }

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

SDValue DAGTypeLegalizer::PromoteIntOp_ATOMIC_STORE(AtomicSDNode *N) { … }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SDValue DAGTypeLegalizer::PromoteIntOp_STORE(StoreSDNode *N, unsigned OpNo){ … }

SDValue DAGTypeLegalizer::PromoteIntOp_MSTORE(MaskedStoreSDNode *N,
                                              unsigned OpNo) { … }

SDValue DAGTypeLegalizer::PromoteIntOp_MLOAD(MaskedLoadSDNode *N,
                                             unsigned OpNo) { … }

SDValue DAGTypeLegalizer::PromoteIntOp_MGATHER(MaskedGatherSDNode *N,
                                               unsigned OpNo) { … }

SDValue DAGTypeLegalizer::PromoteIntOp_MSCATTER(MaskedScatterSDNode *N,
                                                unsigned OpNo) { … }

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

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

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

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

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

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

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

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

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

static unsigned getExtendForIntVecReduction(SDNode *N) { … }

SDValue DAGTypeLegalizer::PromoteIntOpVectorReduction(SDNode *N, SDValue V) { … }

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

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

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

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

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

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

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

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

//===----------------------------------------------------------------------===//
//  Integer Result Expansion
//===----------------------------------------------------------------------===//

/// ExpandIntegerResult - 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::ExpandIntegerResult(SDNode *N, unsigned ResNo) { … }

/// Lower an atomic node to the appropriate builtin call.
std::pair <SDValue, SDValue> DAGTypeLegalizer::ExpandAtomic(SDNode *Node) { … }

/// N is a shift by a value that needs to be expanded,
/// and the shift amount is a constant 'Amt'.  Expand the operation.
void DAGTypeLegalizer::ExpandShiftByConstant(SDNode *N, const APInt &Amt,
                                             SDValue &Lo, SDValue &Hi) { … }

/// ExpandShiftWithKnownAmountBit - Try to determine whether we can simplify
/// this shift based on knowledge of the high bit of the shift amount.  If we
/// can tell this, we know that it is >= 32 or < 32, without knowing the actual
/// shift amount.
bool DAGTypeLegalizer::
ExpandShiftWithKnownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) { … }

/// ExpandShiftWithUnknownAmountBit - Fully general expansion of integer shift
/// of any size.
bool DAGTypeLegalizer::
ExpandShiftWithUnknownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) { … }

static std::pair<ISD::CondCode, ISD::NodeType> getExpandedMinMaxOps(int Op) { … }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Helper for producing an FP_EXTEND/STRICT_FP_EXTEND of Op.
static SDValue fpExtendHelper(SDValue Op, SDValue &Chain, bool IsStrict, EVT VT,
                              SDLoc DL, SelectionDAG &DAG) { … }

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

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

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

void DAGTypeLegalizer::ExpandIntRes_LOAD(LoadSDNode *N,
                                         SDValue &Lo, SDValue &Hi) { … }

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

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

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

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

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

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

/// This performs an expansion of the integer result for a fixed point
/// multiplication. The default expansion performs rounding down towards
/// negative infinity, though targets that do care about rounding should specify
/// a target hook for rounding and provide their own expansion or lowering of
/// fixed point multiplication to be consistent with rounding.
void DAGTypeLegalizer::ExpandIntRes_MULFIX(SDNode *N, SDValue &Lo,
                                           SDValue &Hi) { … }

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

void DAGTypeLegalizer::ExpandIntRes_SADDSUBO(SDNode *Node,
                                             SDValue &Lo, SDValue &Hi) { … }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//===----------------------------------------------------------------------===//
//  Integer Operand Expansion
//===----------------------------------------------------------------------===//

/// ExpandIntegerOperand - 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::ExpandIntegerOperand(SDNode *N, unsigned OpNo) { … }

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

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

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

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

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

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

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

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

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

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

SDValue DAGTypeLegalizer::ExpandIntOp_STORE(StoreSDNode *N, unsigned OpNo) { … }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// FIXME: We wouldn't need this if clang could promote short integers
// that are arguments to FAKE_USE.
SDValue DAGTypeLegalizer::PromoteIntOp_FAKE_USE(SDNode *N) { … }

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

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

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

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