26using namespace LegalizeActions;
29 return ST.isTargetAEABI() || ST.isTargetGNUAEABI() || ST.isTargetMuslAEABI();
33 using namespace TargetOpcode;
44 if (ST.isThumb1Only()) {
46 LegacyInfo.computeTables();
47 verify(*ST.getInstrInfo());
52 .legalForCartesianProduct({s8, s16, s32}, {s1, s8, s16});
58 .clampScalar(0, s32, s32);
70 .legalFor({{s32, s32}})
74 bool HasHWDivide = (!ST.isThumb() && ST.hasDivideInARMMode()) ||
75 (ST.isThumb() && ST.hasDivideInThumbMode());
79 .clampScalar(0, s32, s32);
83 .clampScalar(0, s32, s32);
88 REMBuilder.lowerFor({s32});
90 REMBuilder.customFor({s32});
92 REMBuilder.libcallFor({s32});
103 .clampScalar(0, s32, s32);
116 .legalForTypesWithMemDesc({{s8, p0, s8, 8},
120 .unsupportedIfMemSizeNotPow2();
136 if (!ST.useSoftFloat() && ST.hasVFP2Base()) {
138 {G_FADD, G_FSUB, G_FMUL, G_FDIV, G_FCONSTANT, G_FNEG})
139 .legalFor({s32, s64});
156 .legalForCartesianProduct({s32}, {s32, s64});
158 .legalForCartesianProduct({s32, s64}, {s32});
164 .libcallFor({s32, s64});
176 setFCmpLibcallsAEABI();
178 setFCmpLibcallsGNU();
184 .libcallForCartesianProduct({s32}, {s32, s64});
186 .libcallForCartesianProduct({s32, s64}, {s32});
193 LoadStoreBuilder.lower();
195 if (!ST.useSoftFloat() && ST.hasVFP4Base())
202 if (ST.hasV5TOps()) {
205 .clampScalar(1, s32, s32)
209 .clampScalar(1, s32, s32)
214 .clampScalar(1, s32, s32)
218 .clampScalar(1, s32, s32)
222 LegacyInfo.computeTables();
223 verify(*ST.getInstrInfo());
226void ARMLegalizerInfo::setFCmpLibcallsAEABI() {
282void ARMLegalizerInfo::setFCmpLibcallsGNU() {
324 unsigned Size)
const {
335 using namespace TargetOpcode;
341 switch (
MI.getOpcode()) {
346 Register OriginalResult =
MI.getOperand(0).getReg();
347 auto Size =
MRI.getType(OriginalResult).getSizeInBits();
352 MI.getOpcode() == G_SREM ? RTLIB::SDIVREM_I32 : RTLIB::UDIVREM_I32;
362 {{
MI.getOperand(1).
getReg(), ArgTy, 0},
363 {
MI.getOperand(2).
getReg(), ArgTy, 0}},
371 MRI.getType(
MI.getOperand(3).getReg()) &&
372 "Mismatched operands for G_FCMP");
373 auto OpSize =
MRI.getType(
MI.getOperand(2).getReg()).getSizeInBits();
375 auto OriginalResult =
MI.getOperand(0).getReg();
378 auto Libcalls = getFCmpLibcalls(Predicate, OpSize);
380 if (Libcalls.empty()) {
383 "Predicate needs libcalls, but none specified");
386 MI.eraseFromParent();
390 assert((OpSize == 32 || OpSize == 64) &&
"Unsupported operand size");
395 for (
auto Libcall : Libcalls) {
396 auto LibcallResult =
MRI.createGenericVirtualRegister(
LLT::scalar(32));
398 {LibcallResult, RetTy, 0},
399 {{MI.getOperand(2).getReg(), ArgTy, 0},
400 {MI.getOperand(3).getReg(), ArgTy, 0}},
406 auto ProcessedResult =
409 :
MRI.createGenericVirtualRegister(
MRI.getType(OriginalResult));
418 MIRBuilder.
buildTrunc(ProcessedResult, LibcallResult);
423 MIRBuilder.
buildICmp(ResultPred, ProcessedResult, LibcallResult, Zero);
425 Results.push_back(ProcessedResult);
437 MI.getOperand(1).getFPImm()->getValueAPF().bitcastToAPInt();
439 *ConstantInt::get(Ctx, AsInteger));
444 MI.eraseFromParent();
unsigned const MachineRegisterInfo * MRI
This file describes how to lower LLVM calls to machine code calls.
static bool AEABI(const ARMSubtarget &ST)
This file declares the targeting of the Machinelegalizer class for ARM.
Function Alias Analysis Results
Implement a low-level type suitable for MachineInstr level instruction selection.
This file declares the MachineIRBuilder class.
static unsigned getReg(const MCDisassembler *D, unsigned RC, unsigned RegNo)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ARMLegalizerInfo(const ARMSubtarget &ST)
bool legalizeCustom(LegalizerHelper &Helper, MachineInstr &MI, LostDebugLocObserver &LocObserver) const override
Called for instructions with the Custom LegalizationAction.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
@ FCMP_TRUE
1 1 1 1 Always true (always folded)
@ ICMP_SLT
signed less than
@ ICMP_SLE
signed less or equal
@ FCMP_OLT
0 1 0 0 True if ordered and less than
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
@ ICMP_SGT
signed greater than
@ FCMP_ULT
1 1 0 0 True if unordered or less than
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
@ FCMP_ORD
0 1 1 1 True if ordered (no nans)
@ ICMP_SGE
signed greater or equal
@ FCMP_UNE
1 1 1 0 True if unordered or not equal
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
@ FCMP_FALSE
0 0 0 0 Always false (always folded)
@ FCMP_UNO
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
bool isFPPredicate() const
bool isIntPredicate() const
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
void resize(typename StorageT::size_type s)
static constexpr LLT scalar(unsigned SizeInBits)
Get a low-level scalar or aggregate "bag of bits".
static constexpr LLT pointer(unsigned AddressSpace, unsigned SizeInBits)
Get a low-level pointer in the given address space.
This is an important class for using LLVM in a threaded context.
LegalizeRuleSet & legalFor(std::initializer_list< LLT > Types)
The instruction is legal when type index 0 is any type in the given list.
LegalizeRuleSet & libcallFor(std::initializer_list< LLT > Types)
LegalizeRuleSet & maxScalar(unsigned TypeIdx, const LLT Ty)
Ensure the scalar is at most as wide as Ty.
LegalizeRuleSet & customForCartesianProduct(std::initializer_list< LLT > Types)
LegalizeRuleSet & lower()
The instruction is lowered.
LegalizeRuleSet & lowerFor(std::initializer_list< LLT > Types)
The instruction is lowered when type index 0 is any type in the given list.
LegalizeRuleSet & clampScalar(unsigned TypeIdx, const LLT MinTy, const LLT MaxTy)
Limit the range of scalar sizes to MinTy and MaxTy.
LegalizeRuleSet & alwaysLegal()
LegalizeRuleSet & legalForCartesianProduct(std::initializer_list< LLT > Types)
The instruction is legal when type indexes 0 and 1 are both in the given list.
LegalizeRuleSet & legalForTypesWithMemDesc(std::initializer_list< LegalityPredicates::TypePairAndMemDesc > TypesAndMemDesc)
The instruction is legal when type indexes 0 and 1 along with the memory size and minimum alignment i...
LegalizeRuleSet & customFor(std::initializer_list< LLT > Types)
@ Legalized
Instruction has been legalized and the MachineFunction changed.
MachineIRBuilder & MIRBuilder
Expose MIRBuilder so clients can set their own RecordInsertInstruction functions.
LegalizeRuleSet & getActionDefinitionsBuilder(unsigned Opcode)
Get the action definition builder for the given opcode.
const LegacyLegalizerInfo & getLegacyLegalizerInfo() const
Function & getFunction()
Return the LLVM function that this machine code represents.
Helper class to build MachineInstr.
MachineInstrBuilder buildICmp(CmpInst::Predicate Pred, const DstOp &Res, const SrcOp &Op0, const SrcOp &Op1)
Build and insert a Res = G_ICMP Pred, Op0, Op1.
MachineFunction & getMF()
Getter for the function we currently build.
MachineInstrBuilder buildTrunc(const DstOp &Res, const SrcOp &Op)
Build and insert Res = G_TRUNC Op.
MachineRegisterInfo * getMRI()
Getter for MRI.
MachineInstrBuilder buildOr(const DstOp &Dst, const SrcOp &Src0, const SrcOp &Src1, std::optional< unsigned > Flags=std::nullopt)
Build and insert Res = G_OR Op0, Op1.
virtual MachineInstrBuilder buildConstant(const DstOp &Res, const ConstantInt &Val)
Build and insert Res = G_CONSTANT Val.
Representation of each machine instruction.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Wrapper class representing virtual and physical registers.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Class to represent struct types.
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
The instances of the Type class are immutable: once they are created, they are never changed.
static Type * getDoubleTy(LLVMContext &C)
static IntegerType * getInt32Ty(LLVMContext &C)
static Type * getFloatTy(LLVMContext &C)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ Libcall
The operation should be implemented as a call to some kind of runtime support library.
Predicate
Predicate - These are "(BI << 5) | BO" for various predicates.
This is an optimization pass for GlobalISel generic memory operations.
LegalizerHelper::LegalizeResult createLibcall(MachineIRBuilder &MIRBuilder, const char *Name, const CallLowering::ArgInfo &Result, ArrayRef< CallLowering::ArgInfo > Args, CallingConv::ID CC, LostDebugLocObserver &LocObserver, MachineInstr *MI=nullptr)
Helper function that creates a libcall to the given Name using the given calling convention CC.