27#define GET_INSTRINFO_CTOR_DTOR
28#include "SparcGenInstrInfo.inc"
31void SparcInstrInfo::anchor() {}
35 RI(ST), Subtarget(ST) {}
39 return Subtarget.is64Bit() ? &SP::I64RegsRegClass : &SP::IntRegsRegClass;
47 switch (
MI.getOpcode()) {
65 switch (
MI.getOpcode()) {
84 if (
MI.getOperand(1).isFI() &&
MI.getOperand(2).isImm() &&
85 MI.getOperand(2).getImm() == 0) {
86 FrameIndex =
MI.getOperand(1).getIndex();
87 return MI.getOperand(0).getReg();
100 switch (
MI.getOpcode()) {
119 if (
MI.getOperand(0).isFI() &&
MI.getOperand(1).isImm() &&
120 MI.getOperand(1).getImm() == 0) {
121 FrameIndex =
MI.getOperand(0).getIndex();
122 return MI.getOperand(2).getReg();
207 return Opc == SP::BCOND ||
Opc == SP::BPICC ||
Opc == SP::BPICCA ||
208 Opc == SP::BPICCNT ||
Opc == SP::BPICCANT;
212 return Opc == SP::BPXCC ||
Opc == SP::BPXCCA ||
Opc == SP::BPXCCNT ||
217 return Opc == SP::BPR ||
Opc == SP::BPRA ||
Opc == SP::BPRNT ||
222 return Opc == SP::FBCOND ||
Opc == SP::FBCONDA ||
Opc == SP::FBCOND_V9 ||
223 Opc == SP::FBCONDA_V9;
232 return Opc == SP::BINDrr ||
Opc == SP::BINDri;
255 switch (
MI.getOpcode()) {
281 case SP::CALL_LONGJUMP:
282 return MI.getOperand(0).getMBB();
290 bool AllowModify)
const {
295 if (!isUnpredicatedTerminator(*
I))
300 unsigned LastOpc = LastInst->
getOpcode();
303 if (
I ==
MBB.begin() || !isUnpredicatedTerminator(*--
I)) {
318 unsigned SecondLastOpc = SecondLastInst->
getOpcode();
325 LastInst = SecondLastInst;
327 if (
I ==
MBB.begin() || !isUnpredicatedTerminator(*--
I)) {
332 SecondLastInst = &*
I;
333 SecondLastOpc = SecondLastInst->
getOpcode();
339 if (SecondLastInst &&
I !=
MBB.begin() && isUnpredicatedTerminator(*--
I))
361 I->eraseFromParent();
374 int *BytesAdded)
const {
375 assert(
TBB &&
"insertBranch must not be told to insert a fallthrough");
377 "Sparc branch conditions should have at most three components!");
380 assert(!FBB &&
"Unconditional branch with multiple successors!");
388 unsigned Opc =
Cond[0].getImm();
389 unsigned CC =
Cond[1].getImm();
413 assert(RS &&
"RegScavenger required for long branching");
415 "new block should be inserted for expanding unconditional branch");
416 assert(
MBB.pred_size() == 1 &&
"should only have a single predecessor");
418 "restore block should be inserted for restoring clobbered registers");
425 "Branch offsets outside of the signed 32-bit range not supported");
426 RS->enterBasicBlockEnd(
MBB);
435 bool IsO7Used = RS->isRegUsed(SP::O7);
436 Register ScratchReg = RS->FindUnusedReg(&SP::IntRegsRegClass);
443 RS->setRegUsed(ScratchReg);
449 Subtarget.is64Bit() ? SP::I64RegsRegClass : SP::IntRegsRegClass;
453 TRI.eliminateFrameIndex(std::prev(
I), 0, 0, RS);
458 .
addMBB(IsO7Used ? &RestoreBB : &NewDestBB);
467 Subtarget.is64Bit() ? SP::I64RegsRegClass : SP::IntRegsRegClass;
471 TRI.eliminateFrameIndex(std::prev(
I), 0, 1, RS);
477 int *BytesRemoved)
const {
481 while (
I !=
MBB.begin()) {
484 if (
I->isDebugInstr())
492 I->eraseFromParent();
498 *BytesRemoved = Removed;
512 assert((
Offset & 0b11) == 0 &&
"Malformed branch offset");
514 case SP::CALL_LONGJUMP:
538 return isIntN(Subtarget.getCLOpts().bpcc_offset_bits,
Offset >> 2);
544 return isIntN(Subtarget.getCLOpts().bpr_offset_bits,
Offset >> 2);
554 bool RenamableDest,
bool RenamableSrc)
const {
555 unsigned numSubRegs = 0;
557 const unsigned *subRegIdx =
nullptr;
558 bool ExtraG0 =
false;
560 const unsigned DW_SubRegsIdx[] = { SP::sub_even, SP::sub_odd };
561 const unsigned DFP_FP_SubRegsIdx[] = { SP::sub_even, SP::sub_odd };
562 const unsigned QFP_DFP_SubRegsIdx[] = { SP::sub_even64, SP::sub_odd64 };
563 const unsigned QFP_FP_SubRegsIdx[] = { SP::sub_even, SP::sub_odd,
564 SP::sub_odd64_then_sub_even,
565 SP::sub_odd64_then_sub_odd };
567 if (SP::IntRegsRegClass.
contains(DestReg, SrcReg))
570 else if (SP::IntPairRegClass.
contains(DestReg, SrcReg)) {
571 subRegIdx = DW_SubRegsIdx;
575 }
else if (SP::FPRegsRegClass.
contains(DestReg, SrcReg))
578 else if (SP::DFPRegsRegClass.
contains(DestReg, SrcReg)) {
579 if (Subtarget.isV9()) {
584 subRegIdx = DFP_FP_SubRegsIdx;
588 }
else if (SP::QFPRegsRegClass.
contains(DestReg, SrcReg)) {
589 if (Subtarget.isV9()) {
590 if (Subtarget.hasHardQuad()) {
595 subRegIdx = QFP_DFP_SubRegsIdx;
601 subRegIdx = QFP_FP_SubRegsIdx;
605 }
else if (SP::ASRRegsRegClass.
contains(DestReg) &&
606 SP::IntRegsRegClass.
contains(SrcReg)) {
610 }
else if (SP::IntRegsRegClass.
contains(DestReg) &&
611 SP::ASRRegsRegClass.
contains(SrcReg)) {
617 if (numSubRegs == 0 || subRegIdx ==
nullptr || movOpc == 0)
623 for (
unsigned i = 0; i != numSubRegs; ++i) {
624 Register Dst =
TRI->getSubReg(DestReg, subRegIdx[i]);
625 Register Src =
TRI->getSubReg(SrcReg, subRegIdx[i]);
626 assert(Dst && Src &&
"Bad sub-register");
642 Register SrcReg,
bool isKill,
int FI,
647 if (
I !=
MBB.end())
DL =
I->getDebugLoc();
656 if (RC == &SP::I64RegsRegClass)
659 else if (RC == &SP::IntRegsRegClass)
662 else if (RC == &SP::IntPairRegClass)
665 else if (RC == &SP::FPRegsRegClass)
668 else if (SP::DFPRegsRegClass.hasSubClassEq(RC))
671 else if (SP::QFPRegsRegClass.hasSubClassEq(RC))
687 if (
I !=
MBB.end())
DL =
I->getDebugLoc();
695 if (RC == &SP::I64RegsRegClass)
698 else if (RC == &SP::IntRegsRegClass)
701 else if (RC == &SP::IntPairRegClass)
704 else if (RC == &SP::FPRegsRegClass)
707 else if (SP::DFPRegsRegClass.hasSubClassEq(RC))
710 else if (SP::QFPRegsRegClass.hasSubClassEq(RC))
723 return GlobalBaseReg;
731 Subtarget.is64Bit() ? &SP::I64RegsRegClass : &SP::IntRegsRegClass;
732 GlobalBaseReg = RegInfo.createVirtualRegister(PtrRC);
739 return GlobalBaseReg;
743 unsigned &StructSize)
const {
747 unsigned StructSizeOpNum = 0;
748 switch (
MI.getOpcode()) {
760 case SP::TAIL_CALLri:
773 return StructSize != 0;
777 unsigned Opcode =
MI.getOpcode();
779 if (
MI.isInlineAsm()) {
781 const char *AsmStr =
MI.getOperand(0).getSymbolName();
785 if (Opcode == TargetOpcode::BUNDLE)
786 return getInstBundleSize(
MI);
788 if (
MI.getOpcode() == SP::GETPCX) {
807 if (
MI.hasDelaySlot()) {
808 unsigned StructSize = 0;
811 return get(Opcode).getSize();
815 Register &SrcReg2, int64_t &CmpMask,
816 int64_t &CmpValue)
const {
818 switch (
MI.getOpcode()) {
822 DstReg =
MI.getOperand(0).getReg();
823 SrcReg =
MI.getOperand(1).getReg();
826 CmpValue =
MI.getOperand(2).getImm();
827 return DstReg == SP::G0 && CmpValue == 0;
829 DstReg =
MI.getOperand(0).getReg();
830 SrcReg =
MI.getOperand(1).getReg();
831 SrcReg2 =
MI.getOperand(2).getReg();
834 return DstReg == SP::G0 && SrcReg2 == SP::G0;
854 switch (
MI->getOpcode()) {
856 NewOpcode = SP::ANDNCCrr;
859 NewOpcode = SP::ANDNCCri;
862 NewOpcode = SP::ANDCCrr;
865 NewOpcode = SP::ANDCCri;
868 NewOpcode = SP::ORCCrr;
871 NewOpcode = SP::ORCCri;
874 NewOpcode = SP::ORNCCrr;
877 NewOpcode = SP::ORNCCri;
880 NewOpcode = SP::XORCCrr;
883 NewOpcode = SP::XNORCCri;
886 NewOpcode = SP::XNORCCrr;
889 NewOpcode = SP::ADDCCrr;
892 NewOpcode = SP::ADDCCri;
895 NewOpcode = SP::SUBCCrr;
898 NewOpcode = SP::SUBCCri;
904 bool IsICCModified =
false;
912 if (
I->modifiesRegister(SP::ICC,
TRI) ||
I->readsRegister(SP::ICC,
TRI))
918 if (
I->readsRegister(SP::ICC,
TRI)) {
919 bool IsICCBranch =
I->getOpcode() == SP::BCOND ||
920 I->getOpcode() == SP::BPICC ||
921 I->getOpcode() == SP::BPXCC;
923 I->getOpcode() == SP::MOVICCrr ||
I->getOpcode() == SP::MOVICCri ||
924 I->getOpcode() == SP::MOVXCCrr ||
I->getOpcode() == SP::MOVXCCri;
925 bool IsICCConditional = IsICCBranch || IsICCMove;
926 if (!IsICCConditional ||
927 (
I->getOperand(IsICCBranch ? 1 : 3).getImm() !=
SPCC::ICC_E &&
928 I->getOperand(IsICCBranch ? 1 : 3).getImm() !=
SPCC::ICC_NE))
930 }
else if (
I->modifiesRegister(SP::ICC,
TRI)) {
931 IsICCModified =
true;
936 if (!IsICCModified) {
943 if (
MRI->hasOneNonDBGUse(SrcReg))
944 MI->getOperand(0).setReg(SP::G0);
946 MI->setDesc(
get(NewOpcode));
947 MI->addRegisterDefined(SP::ICC);
954 switch (
MI.getOpcode()) {
955 case TargetOpcode::LOAD_STACK_GUARD: {
956 assert(Subtarget.getTargetTriple().isOSLinux() &&
957 "Only Linux target is expected to contain LOAD_STACK_GUARD");
959 const int64_t
Offset = Subtarget.is64Bit() ? 0x28 : 0x14;
960 MI.setDesc(
get(Subtarget.is64Bit() ? SP::LDXri : SP::LDri));
967 assert(!Subtarget.isV9() &&
968 "V8BAR should not be emitted on V9 processors!");
static void parseCondBranch(MachineInstr *LastInst, MachineBasicBlock *&Target, SmallVectorImpl< MachineOperand > &Cond)
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
MachineBasicBlock MachineBasicBlock::iterator MBBI
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
Register const TargetRegisterInfo * TRI
Promote Memory to Register
SmallVector< MachineOperand, 4 > Cond
MachineRegisterInfo & MRI
const SmallVectorImpl< MachineOperand > MachineBasicBlock * TBB
This file declares the machine register scavenger class.
static bool contains(SmallPtrSetImpl< ConstantExpr * > &Cache, ConstantExpr *Expr, Constant *C)
This file defines the SmallVector class.
static bool isFCondBranchOpcode(int Opc)
static bool isRegCondBranchOpcode(int Opc)
static SPCC::CondCodes GetOppositeBranchCondition(SPCC::CondCodes CC)
static bool isI32CondBranchOpcode(int Opc)
static bool isI64CondBranchOpcode(int Opc)
Represent a constant reference to an array (0 or more elements consecutively in memory),...
MCRegisterClass - Base class of TargetRegisterClass.
Helper class for constructing bundles of MachineInstrs.
MachineInstrBundleIterator< MachineInstr > iterator
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
Align getObjectAlign(int ObjectIdx) const
Return the alignment of the specified stack object.
int64_t getObjectSize(int ObjectIdx) const
Return the size of the specified object.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
const MachineBasicBlock & front() const
MachineMemOperand * getMachineMemOperand(MachinePointerInfo PtrInfo, MachineMemOperand::Flags F, LLT MemTy, Align BaseAlignment, const MMOMetadata &Metadata=MMOMetadata(), SyncScope::ID SSID=SyncScope::System, AtomicOrdering Ordering=AtomicOrdering::NotAtomic, AtomicOrdering FailureOrdering=AtomicOrdering::NotAtomic)
getMachineMemOperand - Allocate a new MachineMemOperand.
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
const MachineInstrBuilder & setOperandDead(unsigned OpIdx) const
const MachineInstrBuilder & addReg(Register RegNo, RegState Flags={}, unsigned SubReg=0) const
Add a new virtual register operand.
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
const MachineInstrBuilder & add(const MachineOperand &MO) const
const MachineInstrBuilder & addFrameIndex(int Idx) const
const MachineInstrBuilder & addMBB(MachineBasicBlock *MBB, unsigned TargetFlags=0) const
const MachineInstrBuilder & addMemOperand(MachineMemOperand *MMO) const
MachineInstr * getInstr() const
If conversion operators fail, use this method to get the MachineInstr explicitly.
Representation of each machine instruction.
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
const MachineBasicBlock * getParent() const
LLVM_ABI bool addRegisterKilled(Register IncomingReg, const TargetRegisterInfo *RegInfo, bool AddIfNotFound=false)
We have determined MI kills a register.
LLVM_ABI void addRegisterDefined(Register Reg, const TargetRegisterInfo *RegInfo=nullptr)
We have determined MI defines a register.
const MachineOperand & getOperand(unsigned i) const
LLVM_ABI MachineInstrBundleIterator< MachineInstr > eraseFromParent()
Unlink 'this' from the containing basic block and delete it.
A description of a memory reference used in the backend.
@ MOLoad
The memory access reads data.
@ MOStore
The memory access writes data.
MachineOperand class - Representation of each machine instruction operand.
MachineBasicBlock * getMBB() const
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
static MachineOperand CreateImm(int64_t Val)
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Wrapper class representing virtual and physical registers.
constexpr bool isValid() const
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
bool needsUnimp(const MachineInstr &MI, unsigned &StructSize) const
Register isLoadFromStackSlot(const MachineInstr &MI, int &FrameIndex, TypeSize &MemBytes) const override
isLoadFromStackSlot - If the specified machine instruction is a direct load from a stack slot,...
void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I, const DebugLoc &DL, Register DestReg, Register SrcReg, bool KillSrc, bool RenamableDest=false, bool RenamableSrc=false) const override
bool isBranchOffsetInRange(unsigned BranchOpc, int64_t Offset) const override
Determine if the branch target is in range.
void storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, Register SrcReg, bool isKill, int FrameIndex, const TargetRegisterClass *RC, Register VReg, MachineInstr::MIFlag Flags=MachineInstr::NoFlags) const override
bool analyzeCompare(const MachineInstr &MI, Register &SrcReg, Register &SrcReg2, int64_t &CmpMask, int64_t &CmpValue) const override
bool optimizeCompareInstr(MachineInstr &CmpInstr, Register SrcReg, Register SrcReg2, int64_t CmpMask, int64_t CmpValue, const MachineRegisterInfo *MRI) const override
void insertIndirectBranch(MachineBasicBlock &MBB, MachineBasicBlock &NewDestBB, MachineBasicBlock &RestoreBB, const DebugLoc &DL, int64_t BrOffset, RegScavenger *RS) const override
bool reverseBranchCondition(SmallVectorImpl< MachineOperand > &Cond) const override
Register getGlobalBaseReg(MachineFunction *MF) const
bool isSchedulingBoundary(const MachineInstr &MI, const MachineBasicBlock *MBB, const MachineFunction &MF) const override
void loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, Register DestReg, int FrameIndex, const TargetRegisterClass *RC, Register VReg, unsigned SubReg=0, MachineInstr::MIFlag Flags=MachineInstr::NoFlags) const override
unsigned removeBranch(MachineBasicBlock &MBB, int *BytesRemoved=nullptr) const override
MachineBasicBlock * getBranchDestBlock(const MachineInstr &MI) const override
bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB, SmallVectorImpl< MachineOperand > &Cond, bool AllowModify=false) const override
Register isStoreToStackSlot(const MachineInstr &MI, int &FrameIndex, TypeSize &MemBytes) const override
isStoreToStackSlot - If the specified machine instruction is a direct store to a stack slot,...
SparcInstrInfo(const SparcSubtarget &ST)
const SparcRegisterInfo & getRegisterInfo() const
getRegisterInfo - TargetInstrInfo is a superset of MRegister info.
const TargetRegisterClass * getInlineAsmMemoryOperandRegClass(InlineAsm::ConstraintCode C) const override
unsigned getInstSizeInBytes(const MachineInstr &MI) const override
GetInstSize - Return the number of bytes of code the specified instruction may be.
unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB, ArrayRef< MachineOperand > Cond, const DebugLoc &DL, int *BytesAdded=nullptr) const override
bool expandPostRAPseudo(MachineInstr &MI) const override
Register getGlobalBaseReg() const
int getBranchRelaxationSpillFrameIndex()
void setGlobalBaseReg(Register Reg)
virtual bool isSchedulingBoundary(const MachineInstr &MI, const MachineBasicBlock *MBB, const MachineFunction &MF) const
Test if the given instruction should be considered a scheduling boundary.
Primary interface to the complete machine description for the target machine.
bool isPositionIndependent() const
const MCAsmInfo & getMCAsmInfo() const
Return target specific asm information.
CodeModel::Model getCodeModel() const
Returns the code model.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Target - Wrapper for Target specific information.
static constexpr TypeSize getFixed(ScalarTy ExactSize)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
static bool isCondBranchOpcode(int Opc)
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
constexpr bool isInt(int64_t x)
Checks if an integer fits into the given bit width.
@ Kill
The last use of a register.
constexpr RegState getKillRegState(bool B)
static bool isIndirectBranchOpcode(int Opc)
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Count
static bool isUncondBranchOpcode(int Opc)
constexpr bool isIntN(unsigned N, int64_t x)
Checks if an signed integer fits into the given (dynamic) bit width.
MCRegisterClass TargetRegisterClass
static LLVM_ABI MachinePointerInfo getFixedStack(MachineFunction &MF, int FI, int64_t Offset=0)
Return a MachinePointerInfo record that refers to the specified FrameIndex.