parent
acd0a53c02
commit
f4d3113a5f
|
@ -93,9 +93,9 @@ public:
|
|||
|
||||
SmallVector<Value *, 16> OutVals;
|
||||
SmallVector<ISD::ArgFlagsTy, 16> OutFlags;
|
||||
SmallVector<unsigned, 16> OutRegs;
|
||||
SmallVector<Register, 16> OutRegs;
|
||||
SmallVector<ISD::InputArg, 4> Ins;
|
||||
SmallVector<unsigned, 4> InRegs;
|
||||
SmallVector<Register, 4> InRegs;
|
||||
|
||||
CallLoweringInfo()
|
||||
: RetSExt(false), RetZExt(false), IsVarArg(false), IsInReg(false),
|
||||
|
|
|
@ -1140,7 +1140,7 @@ public:
|
|||
/// is a read of a super-register.
|
||||
/// This does not count partial redefines of virtual registers as reads:
|
||||
/// %reg1024:6 = OP.
|
||||
bool readsRegister(unsigned Reg,
|
||||
bool readsRegister(Register Reg,
|
||||
const TargetRegisterInfo *TRI = nullptr) const {
|
||||
return findRegisterUseOperandIdx(Reg, false, TRI) != -1;
|
||||
}
|
||||
|
@ -1148,20 +1148,20 @@ public:
|
|||
/// Return true if the MachineInstr reads the specified virtual register.
|
||||
/// Take into account that a partial define is a
|
||||
/// read-modify-write operation.
|
||||
bool readsVirtualRegister(unsigned Reg) const {
|
||||
bool readsVirtualRegister(Register Reg) const {
|
||||
return readsWritesVirtualRegister(Reg).first;
|
||||
}
|
||||
|
||||
/// Return a pair of bools (reads, writes) indicating if this instruction
|
||||
/// reads or writes Reg. This also considers partial defines.
|
||||
/// If Ops is not null, all operand indices for Reg are added.
|
||||
std::pair<bool,bool> readsWritesVirtualRegister(unsigned Reg,
|
||||
std::pair<bool,bool> readsWritesVirtualRegister(Register Reg,
|
||||
SmallVectorImpl<unsigned> *Ops = nullptr) const;
|
||||
|
||||
/// Return true if the MachineInstr kills the specified register.
|
||||
/// If TargetRegisterInfo is passed, then it also checks if there is
|
||||
/// a kill of a super-register.
|
||||
bool killsRegister(unsigned Reg,
|
||||
bool killsRegister(Register Reg,
|
||||
const TargetRegisterInfo *TRI = nullptr) const {
|
||||
return findRegisterUseOperandIdx(Reg, true, TRI) != -1;
|
||||
}
|
||||
|
@ -1170,7 +1170,7 @@ public:
|
|||
/// If TargetRegisterInfo is passed, then it also checks
|
||||
/// if there is a def of a super-register.
|
||||
/// NOTE: It's ignoring subreg indices on virtual registers.
|
||||
bool definesRegister(unsigned Reg,
|
||||
bool definesRegister(Register Reg,
|
||||
const TargetRegisterInfo *TRI = nullptr) const {
|
||||
return findRegisterDefOperandIdx(Reg, false, false, TRI) != -1;
|
||||
}
|
||||
|
@ -1178,38 +1178,38 @@ public:
|
|||
/// Return true if the MachineInstr modifies (fully define or partially
|
||||
/// define) the specified register.
|
||||
/// NOTE: It's ignoring subreg indices on virtual registers.
|
||||
bool modifiesRegister(unsigned Reg, const TargetRegisterInfo *TRI) const {
|
||||
bool modifiesRegister(Register Reg, const TargetRegisterInfo *TRI) const {
|
||||
return findRegisterDefOperandIdx(Reg, false, true, TRI) != -1;
|
||||
}
|
||||
|
||||
/// Returns true if the register is dead in this machine instruction.
|
||||
/// If TargetRegisterInfo is passed, then it also checks
|
||||
/// if there is a dead def of a super-register.
|
||||
bool registerDefIsDead(unsigned Reg,
|
||||
bool registerDefIsDead(Register Reg,
|
||||
const TargetRegisterInfo *TRI = nullptr) const {
|
||||
return findRegisterDefOperandIdx(Reg, true, false, TRI) != -1;
|
||||
}
|
||||
|
||||
/// Returns true if the MachineInstr has an implicit-use operand of exactly
|
||||
/// the given register (not considering sub/super-registers).
|
||||
bool hasRegisterImplicitUseOperand(unsigned Reg) const;
|
||||
bool hasRegisterImplicitUseOperand(Register Reg) const;
|
||||
|
||||
/// Returns the operand index that is a use of the specific register or -1
|
||||
/// if it is not found. It further tightens the search criteria to a use
|
||||
/// that kills the register if isKill is true.
|
||||
int findRegisterUseOperandIdx(unsigned Reg, bool isKill = false,
|
||||
int findRegisterUseOperandIdx(Register Reg, bool isKill = false,
|
||||
const TargetRegisterInfo *TRI = nullptr) const;
|
||||
|
||||
/// Wrapper for findRegisterUseOperandIdx, it returns
|
||||
/// a pointer to the MachineOperand rather than an index.
|
||||
MachineOperand *findRegisterUseOperand(unsigned Reg, bool isKill = false,
|
||||
MachineOperand *findRegisterUseOperand(Register Reg, bool isKill = false,
|
||||
const TargetRegisterInfo *TRI = nullptr) {
|
||||
int Idx = findRegisterUseOperandIdx(Reg, isKill, TRI);
|
||||
return (Idx == -1) ? nullptr : &getOperand(Idx);
|
||||
}
|
||||
|
||||
const MachineOperand *findRegisterUseOperand(
|
||||
unsigned Reg, bool isKill = false,
|
||||
Register Reg, bool isKill = false,
|
||||
const TargetRegisterInfo *TRI = nullptr) const {
|
||||
return const_cast<MachineInstr *>(this)->
|
||||
findRegisterUseOperand(Reg, isKill, TRI);
|
||||
|
@ -1221,14 +1221,14 @@ public:
|
|||
/// overlap the specified register. If TargetRegisterInfo is non-null,
|
||||
/// then it also checks if there is a def of a super-register.
|
||||
/// This may also return a register mask operand when Overlap is true.
|
||||
int findRegisterDefOperandIdx(unsigned Reg,
|
||||
int findRegisterDefOperandIdx(Register Reg,
|
||||
bool isDead = false, bool Overlap = false,
|
||||
const TargetRegisterInfo *TRI = nullptr) const;
|
||||
|
||||
/// Wrapper for findRegisterDefOperandIdx, it returns
|
||||
/// a pointer to the MachineOperand rather than an index.
|
||||
MachineOperand *
|
||||
findRegisterDefOperand(unsigned Reg, bool isDead = false,
|
||||
findRegisterDefOperand(Register Reg, bool isDead = false,
|
||||
bool Overlap = false,
|
||||
const TargetRegisterInfo *TRI = nullptr) {
|
||||
int Idx = findRegisterDefOperandIdx(Reg, isDead, Overlap, TRI);
|
||||
|
@ -1236,7 +1236,7 @@ public:
|
|||
}
|
||||
|
||||
const MachineOperand *
|
||||
findRegisterDefOperand(unsigned Reg, bool isDead = false,
|
||||
findRegisterDefOperand(Register Reg, bool isDead = false,
|
||||
bool Overlap = false,
|
||||
const TargetRegisterInfo *TRI = nullptr) const {
|
||||
return const_cast<MachineInstr *>(this)->findRegisterDefOperand(
|
||||
|
@ -1283,7 +1283,7 @@ public:
|
|||
///
|
||||
/// \pre CurRC must not be NULL.
|
||||
const TargetRegisterClass *getRegClassConstraintEffectForVReg(
|
||||
unsigned Reg, const TargetRegisterClass *CurRC,
|
||||
Register Reg, const TargetRegisterClass *CurRC,
|
||||
const TargetInstrInfo *TII, const TargetRegisterInfo *TRI,
|
||||
bool ExploreBundle = false) const;
|
||||
|
||||
|
@ -1346,39 +1346,39 @@ public:
|
|||
|
||||
/// Replace all occurrences of FromReg with ToReg:SubIdx,
|
||||
/// properly composing subreg indices where necessary.
|
||||
void substituteRegister(unsigned FromReg, unsigned ToReg, unsigned SubIdx,
|
||||
void substituteRegister(Register FromReg, Register ToReg, unsigned SubIdx,
|
||||
const TargetRegisterInfo &RegInfo);
|
||||
|
||||
/// We have determined MI kills a register. Look for the
|
||||
/// operand that uses it and mark it as IsKill. If AddIfNotFound is true,
|
||||
/// add a implicit operand if it's not found. Returns true if the operand
|
||||
/// exists / is added.
|
||||
bool addRegisterKilled(unsigned IncomingReg,
|
||||
bool addRegisterKilled(Register IncomingReg,
|
||||
const TargetRegisterInfo *RegInfo,
|
||||
bool AddIfNotFound = false);
|
||||
|
||||
/// Clear all kill flags affecting Reg. If RegInfo is provided, this includes
|
||||
/// all aliasing registers.
|
||||
void clearRegisterKills(unsigned Reg, const TargetRegisterInfo *RegInfo);
|
||||
void clearRegisterKills(Register Reg, const TargetRegisterInfo *RegInfo);
|
||||
|
||||
/// We have determined MI defined a register without a use.
|
||||
/// Look for the operand that defines it and mark it as IsDead. If
|
||||
/// AddIfNotFound is true, add a implicit operand if it's not found. Returns
|
||||
/// true if the operand exists / is added.
|
||||
bool addRegisterDead(unsigned Reg, const TargetRegisterInfo *RegInfo,
|
||||
bool addRegisterDead(Register Reg, const TargetRegisterInfo *RegInfo,
|
||||
bool AddIfNotFound = false);
|
||||
|
||||
/// Clear all dead flags on operands defining register @p Reg.
|
||||
void clearRegisterDeads(unsigned Reg);
|
||||
void clearRegisterDeads(Register Reg);
|
||||
|
||||
/// Mark all subregister defs of register @p Reg with the undef flag.
|
||||
/// This function is used when we determined to have a subregister def in an
|
||||
/// otherwise undefined super register.
|
||||
void setRegisterDefReadUndef(unsigned Reg, bool IsUndef = true);
|
||||
void setRegisterDefReadUndef(Register Reg, bool IsUndef = true);
|
||||
|
||||
/// We have determined MI defines a register. Make sure there is an operand
|
||||
/// defining Reg.
|
||||
void addRegisterDefined(unsigned Reg,
|
||||
void addRegisterDefined(Register Reg,
|
||||
const TargetRegisterInfo *RegInfo = nullptr);
|
||||
|
||||
/// Mark every physreg used by this instruction as
|
||||
|
@ -1386,7 +1386,7 @@ public:
|
|||
///
|
||||
/// On instructions with register mask operands, also add implicit-def
|
||||
/// operands for all registers in UsedRegs.
|
||||
void setPhysRegsDeadExcept(ArrayRef<unsigned> UsedRegs,
|
||||
void setPhysRegsDeadExcept(ArrayRef<Register> UsedRegs,
|
||||
const TargetRegisterInfo &TRI);
|
||||
|
||||
/// Return true if it is safe to move this instruction. If
|
||||
|
@ -1605,7 +1605,7 @@ public:
|
|||
|
||||
/// Find all DBG_VALUEs immediately following this instruction that point
|
||||
/// to a register def in this instruction and point them to \p Reg instead.
|
||||
void changeDebugValuesDefReg(unsigned Reg);
|
||||
void changeDebugValuesDefReg(Register Reg);
|
||||
|
||||
/// Returns the Intrinsic::ID for this instruction.
|
||||
/// \pre Must have an intrinsic ID operand.
|
||||
|
@ -1636,7 +1636,7 @@ private:
|
|||
/// this MI and the given operand index \p OpIdx.
|
||||
/// If the related operand does not constrained Reg, this returns CurRC.
|
||||
const TargetRegisterClass *getRegClassConstraintEffectForVRegImpl(
|
||||
unsigned OpIdx, unsigned Reg, const TargetRegisterClass *CurRC,
|
||||
unsigned OpIdx, Register Reg, const TargetRegisterClass *CurRC,
|
||||
const TargetInstrInfo *TII, const TargetRegisterInfo *TRI) const;
|
||||
};
|
||||
|
||||
|
|
|
@ -85,7 +85,7 @@ public:
|
|||
Register getReg(unsigned Idx) const { return MI->getOperand(Idx).getReg(); }
|
||||
|
||||
/// Add a new virtual register operand.
|
||||
const MachineInstrBuilder &addReg(unsigned RegNo, unsigned flags = 0,
|
||||
const MachineInstrBuilder &addReg(Register RegNo, unsigned flags = 0,
|
||||
unsigned SubReg = 0) const {
|
||||
assert((flags & 0x1) == 0 &&
|
||||
"Passing in 'true' to addReg is forbidden! Use enums instead.");
|
||||
|
@ -104,14 +104,14 @@ public:
|
|||
}
|
||||
|
||||
/// Add a virtual register definition operand.
|
||||
const MachineInstrBuilder &addDef(unsigned RegNo, unsigned Flags = 0,
|
||||
const MachineInstrBuilder &addDef(Register RegNo, unsigned Flags = 0,
|
||||
unsigned SubReg = 0) const {
|
||||
return addReg(RegNo, Flags | RegState::Define, SubReg);
|
||||
}
|
||||
|
||||
/// Add a virtual register use operand. It is an error for Flags to contain
|
||||
/// `RegState::Define` when calling this function.
|
||||
const MachineInstrBuilder &addUse(unsigned RegNo, unsigned Flags = 0,
|
||||
const MachineInstrBuilder &addUse(Register RegNo, unsigned Flags = 0,
|
||||
unsigned SubReg = 0) const {
|
||||
assert(!(Flags & RegState::Define) &&
|
||||
"Misleading addUse defines register, use addReg instead.");
|
||||
|
@ -316,7 +316,7 @@ inline MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
|
|||
/// This version of the builder sets up the first operand as a
|
||||
/// destination virtual register.
|
||||
inline MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
|
||||
const MCInstrDesc &MCID, unsigned DestReg) {
|
||||
const MCInstrDesc &MCID, Register DestReg) {
|
||||
return MachineInstrBuilder(MF, MF.CreateMachineInstr(MCID, DL))
|
||||
.addReg(DestReg, RegState::Define);
|
||||
}
|
||||
|
@ -327,7 +327,7 @@ inline MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
|
|||
inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
|
||||
MachineBasicBlock::iterator I,
|
||||
const DebugLoc &DL, const MCInstrDesc &MCID,
|
||||
unsigned DestReg) {
|
||||
Register DestReg) {
|
||||
MachineFunction &MF = *BB.getParent();
|
||||
MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
|
||||
BB.insert(I, MI);
|
||||
|
@ -343,7 +343,7 @@ inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
|
|||
inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
|
||||
MachineBasicBlock::instr_iterator I,
|
||||
const DebugLoc &DL, const MCInstrDesc &MCID,
|
||||
unsigned DestReg) {
|
||||
Register DestReg) {
|
||||
MachineFunction &MF = *BB.getParent();
|
||||
MachineInstr *MI = MF.CreateMachineInstr(MCID, DL);
|
||||
BB.insert(I, MI);
|
||||
|
@ -352,7 +352,7 @@ inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
|
|||
|
||||
inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineInstr &I,
|
||||
const DebugLoc &DL, const MCInstrDesc &MCID,
|
||||
unsigned DestReg) {
|
||||
Register DestReg) {
|
||||
// Calling the overload for instr_iterator is always correct. However, the
|
||||
// definition is not available in headers, so inline the check.
|
||||
if (I.isInsideBundle())
|
||||
|
@ -362,7 +362,7 @@ inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineInstr &I,
|
|||
|
||||
inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineInstr *I,
|
||||
const DebugLoc &DL, const MCInstrDesc &MCID,
|
||||
unsigned DestReg) {
|
||||
Register DestReg) {
|
||||
return BuildMI(BB, *I, DL, MCID, DestReg);
|
||||
}
|
||||
|
||||
|
@ -416,7 +416,7 @@ inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, const DebugLoc &DL,
|
|||
/// end of the given MachineBasicBlock, and sets up the first operand as a
|
||||
/// destination virtual register.
|
||||
inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, const DebugLoc &DL,
|
||||
const MCInstrDesc &MCID, unsigned DestReg) {
|
||||
const MCInstrDesc &MCID, Register DestReg) {
|
||||
return BuildMI(*BB, BB->end(), DL, MCID, DestReg);
|
||||
}
|
||||
|
||||
|
@ -426,7 +426,7 @@ inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, const DebugLoc &DL,
|
|||
/// second operand is an immediate.
|
||||
MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
|
||||
const MCInstrDesc &MCID, bool IsIndirect,
|
||||
unsigned Reg, const MDNode *Variable,
|
||||
Register Reg, const MDNode *Variable,
|
||||
const MDNode *Expr);
|
||||
|
||||
/// This version of the builder builds a DBG_VALUE intrinsic
|
||||
|
@ -442,7 +442,7 @@ MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
|
|||
MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
|
||||
MachineBasicBlock::iterator I, const DebugLoc &DL,
|
||||
const MCInstrDesc &MCID, bool IsIndirect,
|
||||
unsigned Reg, const MDNode *Variable,
|
||||
Register Reg, const MDNode *Variable,
|
||||
const MDNode *Expr);
|
||||
|
||||
/// This version of the builder builds a DBG_VALUE intrinsic
|
||||
|
|
|
@ -455,7 +455,7 @@ public:
|
|||
|
||||
/// Change the register this operand corresponds to.
|
||||
///
|
||||
void setReg(unsigned Reg);
|
||||
void setReg(Register Reg);
|
||||
|
||||
void setSubReg(unsigned subReg) {
|
||||
assert(isReg() && "Wrong MachineOperand mutator");
|
||||
|
@ -468,13 +468,13 @@ public:
|
|||
/// using TargetRegisterInfo to compose the subreg indices if necessary.
|
||||
/// Reg must be a virtual register, SubIdx can be 0.
|
||||
///
|
||||
void substVirtReg(unsigned Reg, unsigned SubIdx, const TargetRegisterInfo&);
|
||||
void substVirtReg(Register Reg, unsigned SubIdx, const TargetRegisterInfo&);
|
||||
|
||||
/// substPhysReg - Substitute the current register with the physical register
|
||||
/// Reg, taking any existing SubReg into account. For instance,
|
||||
/// substPhysReg(%eax) will change %reg1024:sub_8bit to %al.
|
||||
///
|
||||
void substPhysReg(unsigned Reg, const TargetRegisterInfo&);
|
||||
void substPhysReg(MCRegister Reg, const TargetRegisterInfo&);
|
||||
|
||||
void setIsUse(bool Val = true) { setIsDef(!Val); }
|
||||
|
||||
|
@ -736,7 +736,7 @@ public:
|
|||
/// ChangeToRegister - Replace this operand with a new register operand of
|
||||
/// the specified value. If an operand is known to be an register already,
|
||||
/// the setReg method should be used.
|
||||
void ChangeToRegister(unsigned Reg, bool isDef, bool isImp = false,
|
||||
void ChangeToRegister(Register Reg, bool isDef, bool isImp = false,
|
||||
bool isKill = false, bool isDead = false,
|
||||
bool isUndef = false, bool isDebug = false);
|
||||
|
||||
|
@ -762,7 +762,7 @@ public:
|
|||
return Op;
|
||||
}
|
||||
|
||||
static MachineOperand CreateReg(unsigned Reg, bool isDef, bool isImp = false,
|
||||
static MachineOperand CreateReg(Register Reg, bool isDef, bool isImp = false,
|
||||
bool isKill = false, bool isDead = false,
|
||||
bool isUndef = false,
|
||||
bool isEarlyClobber = false,
|
||||
|
|
|
@ -692,8 +692,8 @@ void MachineInstr::eraseFromParentAndMarkDBGValuesForRemoval() {
|
|||
for (const MachineOperand &MO : MI->operands()) {
|
||||
if (!MO.isReg() || !MO.isDef())
|
||||
continue;
|
||||
unsigned Reg = MO.getReg();
|
||||
if (!Register::isVirtualRegister(Reg))
|
||||
Register Reg = MO.getReg();
|
||||
if (!Reg.isVirtual())
|
||||
continue;
|
||||
MRI.markUsesInDebugValueAsUndef(Reg);
|
||||
}
|
||||
|
@ -873,7 +873,7 @@ MachineInstr::getRegClassConstraint(unsigned OpIdx,
|
|||
}
|
||||
|
||||
const TargetRegisterClass *MachineInstr::getRegClassConstraintEffectForVReg(
|
||||
unsigned Reg, const TargetRegisterClass *CurRC, const TargetInstrInfo *TII,
|
||||
Register Reg, const TargetRegisterClass *CurRC, const TargetInstrInfo *TII,
|
||||
const TargetRegisterInfo *TRI, bool ExploreBundle) const {
|
||||
// Check every operands inside the bundle if we have
|
||||
// been asked to.
|
||||
|
@ -890,7 +890,7 @@ const TargetRegisterClass *MachineInstr::getRegClassConstraintEffectForVReg(
|
|||
}
|
||||
|
||||
const TargetRegisterClass *MachineInstr::getRegClassConstraintEffectForVRegImpl(
|
||||
unsigned OpIdx, unsigned Reg, const TargetRegisterClass *CurRC,
|
||||
unsigned OpIdx, Register Reg, const TargetRegisterClass *CurRC,
|
||||
const TargetInstrInfo *TII, const TargetRegisterInfo *TRI) const {
|
||||
assert(CurRC && "Invalid initial register class");
|
||||
// Check if Reg is constrained by some of its use/def from MI.
|
||||
|
@ -933,7 +933,7 @@ unsigned MachineInstr::getBundleSize() const {
|
|||
|
||||
/// Returns true if the MachineInstr has an implicit-use operand of exactly
|
||||
/// the given register (not considering sub/super-registers).
|
||||
bool MachineInstr::hasRegisterImplicitUseOperand(unsigned Reg) const {
|
||||
bool MachineInstr::hasRegisterImplicitUseOperand(Register Reg) const {
|
||||
for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
|
||||
const MachineOperand &MO = getOperand(i);
|
||||
if (MO.isReg() && MO.isUse() && MO.isImplicit() && MO.getReg() == Reg)
|
||||
|
@ -946,12 +946,12 @@ bool MachineInstr::hasRegisterImplicitUseOperand(unsigned Reg) const {
|
|||
/// the specific register or -1 if it is not found. It further tightens
|
||||
/// the search criteria to a use that kills the register if isKill is true.
|
||||
int MachineInstr::findRegisterUseOperandIdx(
|
||||
unsigned Reg, bool isKill, const TargetRegisterInfo *TRI) const {
|
||||
Register Reg, bool isKill, const TargetRegisterInfo *TRI) const {
|
||||
for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
|
||||
const MachineOperand &MO = getOperand(i);
|
||||
if (!MO.isReg() || !MO.isUse())
|
||||
continue;
|
||||
unsigned MOReg = MO.getReg();
|
||||
Register MOReg = MO.getReg();
|
||||
if (!MOReg)
|
||||
continue;
|
||||
if (MOReg == Reg || (TRI && Reg && MOReg && TRI->regsOverlap(MOReg, Reg)))
|
||||
|
@ -965,7 +965,7 @@ int MachineInstr::findRegisterUseOperandIdx(
|
|||
/// indicating if this instruction reads or writes Reg. This also considers
|
||||
/// partial defines.
|
||||
std::pair<bool,bool>
|
||||
MachineInstr::readsWritesVirtualRegister(unsigned Reg,
|
||||
MachineInstr::readsWritesVirtualRegister(Register Reg,
|
||||
SmallVectorImpl<unsigned> *Ops) const {
|
||||
bool PartDef = false; // Partial redefine.
|
||||
bool FullDef = false; // Full define.
|
||||
|
@ -994,7 +994,7 @@ MachineInstr::readsWritesVirtualRegister(unsigned Reg,
|
|||
/// that are not dead are skipped. If TargetRegisterInfo is non-null, then it
|
||||
/// also checks if there is a def of a super-register.
|
||||
int
|
||||
MachineInstr::findRegisterDefOperandIdx(unsigned Reg, bool isDead, bool Overlap,
|
||||
MachineInstr::findRegisterDefOperandIdx(Register Reg, bool isDead, bool Overlap,
|
||||
const TargetRegisterInfo *TRI) const {
|
||||
bool isPhys = Register::isPhysicalRegister(Reg);
|
||||
for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
|
||||
|
@ -1005,7 +1005,7 @@ MachineInstr::findRegisterDefOperandIdx(unsigned Reg, bool isDead, bool Overlap,
|
|||
return i;
|
||||
if (!MO.isReg() || !MO.isDef())
|
||||
continue;
|
||||
unsigned MOReg = MO.getReg();
|
||||
Register MOReg = MO.getReg();
|
||||
bool Found = (MOReg == Reg);
|
||||
if (!Found && TRI && isPhys && Register::isPhysicalRegister(MOReg)) {
|
||||
if (Overlap)
|
||||
|
@ -1141,7 +1141,7 @@ void MachineInstr::clearKillInfo() {
|
|||
}
|
||||
}
|
||||
|
||||
void MachineInstr::substituteRegister(unsigned FromReg, unsigned ToReg,
|
||||
void MachineInstr::substituteRegister(Register FromReg, Register ToReg,
|
||||
unsigned SubIdx,
|
||||
const TargetRegisterInfo &RegInfo) {
|
||||
if (Register::isPhysicalRegister(ToReg)) {
|
||||
|
@ -1363,7 +1363,7 @@ unsigned MachineInstr::isConstantValuePHI() const {
|
|||
assert(getNumOperands() >= 3 &&
|
||||
"It's illegal to have a PHI without source operands");
|
||||
|
||||
unsigned Reg = getOperand(1).getReg();
|
||||
Register Reg = getOperand(1).getReg();
|
||||
for (unsigned i = 3, e = getNumOperands(); i < e; i += 2)
|
||||
if (getOperand(i).getReg() != Reg)
|
||||
return 0;
|
||||
|
@ -1779,7 +1779,7 @@ void MachineInstr::print(raw_ostream &OS, ModuleSlotTracker &MST,
|
|||
OS << '\n';
|
||||
}
|
||||
|
||||
bool MachineInstr::addRegisterKilled(unsigned IncomingReg,
|
||||
bool MachineInstr::addRegisterKilled(Register IncomingReg,
|
||||
const TargetRegisterInfo *RegInfo,
|
||||
bool AddIfNotFound) {
|
||||
bool isPhysReg = Register::isPhysicalRegister(IncomingReg);
|
||||
|
@ -1798,7 +1798,7 @@ bool MachineInstr::addRegisterKilled(unsigned IncomingReg,
|
|||
if (MO.isDebug())
|
||||
continue;
|
||||
|
||||
unsigned Reg = MO.getReg();
|
||||
Register Reg = MO.getReg();
|
||||
if (!Reg)
|
||||
continue;
|
||||
|
||||
|
@ -1845,20 +1845,20 @@ bool MachineInstr::addRegisterKilled(unsigned IncomingReg,
|
|||
return Found;
|
||||
}
|
||||
|
||||
void MachineInstr::clearRegisterKills(unsigned Reg,
|
||||
void MachineInstr::clearRegisterKills(Register Reg,
|
||||
const TargetRegisterInfo *RegInfo) {
|
||||
if (!Register::isPhysicalRegister(Reg))
|
||||
RegInfo = nullptr;
|
||||
for (MachineOperand &MO : operands()) {
|
||||
if (!MO.isReg() || !MO.isUse() || !MO.isKill())
|
||||
continue;
|
||||
unsigned OpReg = MO.getReg();
|
||||
Register OpReg = MO.getReg();
|
||||
if ((RegInfo && RegInfo->regsOverlap(Reg, OpReg)) || Reg == OpReg)
|
||||
MO.setIsKill(false);
|
||||
}
|
||||
}
|
||||
|
||||
bool MachineInstr::addRegisterDead(unsigned Reg,
|
||||
bool MachineInstr::addRegisterDead(Register Reg,
|
||||
const TargetRegisterInfo *RegInfo,
|
||||
bool AddIfNotFound) {
|
||||
bool isPhysReg = Register::isPhysicalRegister(Reg);
|
||||
|
@ -1870,7 +1870,7 @@ bool MachineInstr::addRegisterDead(unsigned Reg,
|
|||
MachineOperand &MO = getOperand(i);
|
||||
if (!MO.isReg() || !MO.isDef())
|
||||
continue;
|
||||
unsigned MOReg = MO.getReg();
|
||||
Register MOReg = MO.getReg();
|
||||
if (!MOReg)
|
||||
continue;
|
||||
|
||||
|
@ -1911,7 +1911,7 @@ bool MachineInstr::addRegisterDead(unsigned Reg,
|
|||
return true;
|
||||
}
|
||||
|
||||
void MachineInstr::clearRegisterDeads(unsigned Reg) {
|
||||
void MachineInstr::clearRegisterDeads(Register Reg) {
|
||||
for (MachineOperand &MO : operands()) {
|
||||
if (!MO.isReg() || !MO.isDef() || MO.getReg() != Reg)
|
||||
continue;
|
||||
|
@ -1919,7 +1919,7 @@ void MachineInstr::clearRegisterDeads(unsigned Reg) {
|
|||
}
|
||||
}
|
||||
|
||||
void MachineInstr::setRegisterDefReadUndef(unsigned Reg, bool IsUndef) {
|
||||
void MachineInstr::setRegisterDefReadUndef(Register Reg, bool IsUndef) {
|
||||
for (MachineOperand &MO : operands()) {
|
||||
if (!MO.isReg() || !MO.isDef() || MO.getReg() != Reg || MO.getSubReg() == 0)
|
||||
continue;
|
||||
|
@ -1927,7 +1927,7 @@ void MachineInstr::setRegisterDefReadUndef(unsigned Reg, bool IsUndef) {
|
|||
}
|
||||
}
|
||||
|
||||
void MachineInstr::addRegisterDefined(unsigned Reg,
|
||||
void MachineInstr::addRegisterDefined(Register Reg,
|
||||
const TargetRegisterInfo *RegInfo) {
|
||||
if (Register::isPhysicalRegister(Reg)) {
|
||||
MachineOperand *MO = findRegisterDefOperand(Reg, false, false, RegInfo);
|
||||
|
@ -1945,7 +1945,7 @@ void MachineInstr::addRegisterDefined(unsigned Reg,
|
|||
true /*IsImp*/));
|
||||
}
|
||||
|
||||
void MachineInstr::setPhysRegsDeadExcept(ArrayRef<unsigned> UsedRegs,
|
||||
void MachineInstr::setPhysRegsDeadExcept(ArrayRef<Register> UsedRegs,
|
||||
const TargetRegisterInfo &TRI) {
|
||||
bool HasRegMask = false;
|
||||
for (MachineOperand &MO : operands()) {
|
||||
|
@ -1954,19 +1954,19 @@ void MachineInstr::setPhysRegsDeadExcept(ArrayRef<unsigned> UsedRegs,
|
|||
continue;
|
||||
}
|
||||
if (!MO.isReg() || !MO.isDef()) continue;
|
||||
unsigned Reg = MO.getReg();
|
||||
if (!Register::isPhysicalRegister(Reg))
|
||||
Register Reg = MO.getReg();
|
||||
if (!Reg.isPhysical())
|
||||
continue;
|
||||
// If there are no uses, including partial uses, the def is dead.
|
||||
if (llvm::none_of(UsedRegs,
|
||||
[&](unsigned Use) { return TRI.regsOverlap(Use, Reg); }))
|
||||
[&](MCRegister Use) { return TRI.regsOverlap(Use, Reg); }))
|
||||
MO.setIsDead();
|
||||
}
|
||||
|
||||
// This is a call with a register mask operand.
|
||||
// Mask clobbers are always dead, so add defs for the non-dead defines.
|
||||
if (HasRegMask)
|
||||
for (ArrayRef<unsigned>::iterator I = UsedRegs.begin(), E = UsedRegs.end();
|
||||
for (ArrayRef<Register>::iterator I = UsedRegs.begin(), E = UsedRegs.end();
|
||||
I != E; ++I)
|
||||
addRegisterDefined(*I, &TRI);
|
||||
}
|
||||
|
@ -2010,7 +2010,7 @@ void MachineInstr::emitError(StringRef Msg) const {
|
|||
|
||||
MachineInstrBuilder llvm::BuildMI(MachineFunction &MF, const DebugLoc &DL,
|
||||
const MCInstrDesc &MCID, bool IsIndirect,
|
||||
unsigned Reg, const MDNode *Variable,
|
||||
Register Reg, const MDNode *Variable,
|
||||
const MDNode *Expr) {
|
||||
assert(isa<DILocalVariable>(Variable) && "not a variable");
|
||||
assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
|
||||
|
@ -2046,7 +2046,7 @@ MachineInstrBuilder llvm::BuildMI(MachineFunction &MF, const DebugLoc &DL,
|
|||
MachineInstrBuilder llvm::BuildMI(MachineBasicBlock &BB,
|
||||
MachineBasicBlock::iterator I,
|
||||
const DebugLoc &DL, const MCInstrDesc &MCID,
|
||||
bool IsIndirect, unsigned Reg,
|
||||
bool IsIndirect, Register Reg,
|
||||
const MDNode *Variable, const MDNode *Expr) {
|
||||
MachineFunction &MF = *BB.getParent();
|
||||
MachineInstr *MI = BuildMI(MF, DL, MCID, IsIndirect, Reg, Variable, Expr);
|
||||
|
@ -2116,7 +2116,7 @@ void MachineInstr::collectDebugValues(
|
|||
}
|
||||
}
|
||||
|
||||
void MachineInstr::changeDebugValuesDefReg(unsigned Reg) {
|
||||
void MachineInstr::changeDebugValuesDefReg(Register Reg) {
|
||||
// Collect matching debug values.
|
||||
SmallVector<MachineInstr *, 2> DbgValues;
|
||||
collectDebugValues(DbgValues);
|
||||
|
|
|
@ -49,7 +49,7 @@ static MachineFunction *getMFIfAvailable(MachineOperand &MO) {
|
|||
getMFIfAvailable(const_cast<const MachineOperand &>(MO)));
|
||||
}
|
||||
|
||||
void MachineOperand::setReg(unsigned Reg) {
|
||||
void MachineOperand::setReg(Register Reg) {
|
||||
if (getReg() == Reg)
|
||||
return; // No change.
|
||||
|
||||
|
@ -71,9 +71,9 @@ void MachineOperand::setReg(unsigned Reg) {
|
|||
SmallContents.RegNo = Reg;
|
||||
}
|
||||
|
||||
void MachineOperand::substVirtReg(unsigned Reg, unsigned SubIdx,
|
||||
void MachineOperand::substVirtReg(Register Reg, unsigned SubIdx,
|
||||
const TargetRegisterInfo &TRI) {
|
||||
assert(Register::isVirtualRegister(Reg));
|
||||
assert(Reg.isVirtual());
|
||||
if (SubIdx && getSubReg())
|
||||
SubIdx = TRI.composeSubRegIndices(SubIdx, getSubReg());
|
||||
setReg(Reg);
|
||||
|
@ -81,8 +81,8 @@ void MachineOperand::substVirtReg(unsigned Reg, unsigned SubIdx,
|
|||
setSubReg(SubIdx);
|
||||
}
|
||||
|
||||
void MachineOperand::substPhysReg(unsigned Reg, const TargetRegisterInfo &TRI) {
|
||||
assert(Register::isPhysicalRegister(Reg));
|
||||
void MachineOperand::substPhysReg(MCRegister Reg, const TargetRegisterInfo &TRI) {
|
||||
assert(Reg.isPhysical());
|
||||
if (getSubReg()) {
|
||||
Reg = TRI.getSubReg(Reg, getSubReg());
|
||||
// Note that getSubReg() may return 0 if the sub-register doesn't exist.
|
||||
|
@ -230,7 +230,7 @@ void MachineOperand::ChangeToTargetIndex(unsigned Idx, int64_t Offset,
|
|||
/// ChangeToRegister - Replace this operand with a new register operand of
|
||||
/// the specified value. If an operand is known to be an register already,
|
||||
/// the setReg method should be used.
|
||||
void MachineOperand::ChangeToRegister(unsigned Reg, bool isDef, bool isImp,
|
||||
void MachineOperand::ChangeToRegister(Register Reg, bool isDef, bool isImp,
|
||||
bool isKill, bool isDead, bool isUndef,
|
||||
bool isDebug) {
|
||||
MachineRegisterInfo *RegInfo = nullptr;
|
||||
|
|
|
@ -927,12 +927,12 @@ EmitMachineNode(SDNode *Node, bool IsClone, bool IsCloned,
|
|||
//
|
||||
// Collect all the used physreg defs, and make sure that any unused physreg
|
||||
// defs are marked as dead.
|
||||
SmallVector<unsigned, 8> UsedRegs;
|
||||
SmallVector<Register, 8> UsedRegs;
|
||||
|
||||
// Additional results must be physical register defs.
|
||||
if (HasPhysRegOuts) {
|
||||
for (unsigned i = NumDefs; i < NumResults; ++i) {
|
||||
unsigned Reg = II.getImplicitDefs()[i - NumDefs];
|
||||
Register Reg = II.getImplicitDefs()[i - NumDefs];
|
||||
if (!Node->hasAnyUseOfValue(i))
|
||||
continue;
|
||||
// This implicitly defined physreg has a use.
|
||||
|
@ -959,8 +959,8 @@ EmitMachineNode(SDNode *Node, bool IsClone, bool IsCloned,
|
|||
// direct RegisterSDNode operands.
|
||||
for (unsigned i = 0, e = F->getNumOperands(); i != e; ++i)
|
||||
if (RegisterSDNode *R = dyn_cast<RegisterSDNode>(F->getOperand(i))) {
|
||||
unsigned Reg = R->getReg();
|
||||
if (Register::isPhysicalRegister(Reg))
|
||||
Register Reg = R->getReg();
|
||||
if (Reg.isPhysical())
|
||||
UsedRegs.push_back(Reg);
|
||||
}
|
||||
}
|
||||
|
@ -1136,7 +1136,7 @@ EmitSpecialNode(SDNode *Node, bool IsClone, bool IsCloned,
|
|||
// then remove the early-clobber flag.
|
||||
for (unsigned Reg : ECRegs) {
|
||||
if (MIB->readsRegister(Reg, TRI)) {
|
||||
MachineOperand *MO =
|
||||
MachineOperand *MO =
|
||||
MIB->findRegisterDefOperand(Reg, false, false, TRI);
|
||||
assert(MO && "No def operand for clobbered register?");
|
||||
MO->setIsEarlyClobber(false);
|
||||
|
|
|
@ -219,15 +219,15 @@ class ARMFastISel final : public FastISel {
|
|||
bool Return,
|
||||
bool isVarArg);
|
||||
bool ProcessCallArgs(SmallVectorImpl<Value*> &Args,
|
||||
SmallVectorImpl<unsigned> &ArgRegs,
|
||||
SmallVectorImpl<Register> &ArgRegs,
|
||||
SmallVectorImpl<MVT> &ArgVTs,
|
||||
SmallVectorImpl<ISD::ArgFlagsTy> &ArgFlags,
|
||||
SmallVectorImpl<unsigned> &RegArgs,
|
||||
SmallVectorImpl<Register> &RegArgs,
|
||||
CallingConv::ID CC,
|
||||
unsigned &NumBytes,
|
||||
bool isVarArg);
|
||||
unsigned getLibcallReg(const Twine &Name);
|
||||
bool FinishCall(MVT RetVT, SmallVectorImpl<unsigned> &UsedRegs,
|
||||
bool FinishCall(MVT RetVT, SmallVectorImpl<Register> &UsedRegs,
|
||||
const Instruction *I, CallingConv::ID CC,
|
||||
unsigned &NumBytes, bool isVarArg);
|
||||
bool ARMEmitLibcall(const Instruction *I, RTLIB::Libcall Call);
|
||||
|
@ -301,7 +301,7 @@ ARMFastISel::AddOptionalDefs(const MachineInstrBuilder &MIB) {
|
|||
unsigned ARMFastISel::fastEmitInst_r(unsigned MachineInstOpcode,
|
||||
const TargetRegisterClass *RC,
|
||||
unsigned Op0, bool Op0IsKill) {
|
||||
unsigned ResultReg = createResultReg(RC);
|
||||
Register ResultReg = createResultReg(RC);
|
||||
const MCInstrDesc &II = TII.get(MachineInstOpcode);
|
||||
|
||||
// Make sure the input operand is sufficiently constrained to be legal
|
||||
|
@ -1893,10 +1893,10 @@ CCAssignFn *ARMFastISel::CCAssignFnForCall(CallingConv::ID CC,
|
|||
}
|
||||
|
||||
bool ARMFastISel::ProcessCallArgs(SmallVectorImpl<Value*> &Args,
|
||||
SmallVectorImpl<unsigned> &ArgRegs,
|
||||
SmallVectorImpl<Register> &ArgRegs,
|
||||
SmallVectorImpl<MVT> &ArgVTs,
|
||||
SmallVectorImpl<ISD::ArgFlagsTy> &ArgFlags,
|
||||
SmallVectorImpl<unsigned> &RegArgs,
|
||||
SmallVectorImpl<Register> &RegArgs,
|
||||
CallingConv::ID CC,
|
||||
unsigned &NumBytes,
|
||||
bool isVarArg) {
|
||||
|
@ -1960,7 +1960,7 @@ bool ARMFastISel::ProcessCallArgs(SmallVectorImpl<Value*> &Args,
|
|||
for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
|
||||
CCValAssign &VA = ArgLocs[i];
|
||||
const Value *ArgVal = Args[VA.getValNo()];
|
||||
unsigned Arg = ArgRegs[VA.getValNo()];
|
||||
Register Arg = ArgRegs[VA.getValNo()];
|
||||
MVT ArgVT = ArgVTs[VA.getValNo()];
|
||||
|
||||
assert((!ArgVT.isVector() && ArgVT.getSizeInBits() <= 64) &&
|
||||
|
@ -2039,7 +2039,7 @@ bool ARMFastISel::ProcessCallArgs(SmallVectorImpl<Value*> &Args,
|
|||
return true;
|
||||
}
|
||||
|
||||
bool ARMFastISel::FinishCall(MVT RetVT, SmallVectorImpl<unsigned> &UsedRegs,
|
||||
bool ARMFastISel::FinishCall(MVT RetVT, SmallVectorImpl<Register> &UsedRegs,
|
||||
const Instruction *I, CallingConv::ID CC,
|
||||
unsigned &NumBytes, bool isVarArg) {
|
||||
// Issue CALLSEQ_END
|
||||
|
@ -2060,7 +2060,7 @@ bool ARMFastISel::FinishCall(MVT RetVT, SmallVectorImpl<unsigned> &UsedRegs,
|
|||
// double fp reg we want.
|
||||
MVT DestVT = RVLocs[0].getValVT();
|
||||
const TargetRegisterClass* DstRC = TLI.getRegClassFor(DestVT);
|
||||
unsigned ResultReg = createResultReg(DstRC);
|
||||
Register ResultReg = createResultReg(DstRC);
|
||||
AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
|
||||
TII.get(ARM::VMOVDRR), ResultReg)
|
||||
.addReg(RVLocs[0].getLocReg())
|
||||
|
@ -2081,7 +2081,7 @@ bool ARMFastISel::FinishCall(MVT RetVT, SmallVectorImpl<unsigned> &UsedRegs,
|
|||
|
||||
const TargetRegisterClass* DstRC = TLI.getRegClassFor(CopyVT);
|
||||
|
||||
unsigned ResultReg = createResultReg(DstRC);
|
||||
Register ResultReg = createResultReg(DstRC);
|
||||
BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
|
||||
TII.get(TargetOpcode::COPY),
|
||||
ResultReg).addReg(RVLocs[0].getLocReg());
|
||||
|
@ -2231,7 +2231,7 @@ bool ARMFastISel::ARMEmitLibcall(const Instruction *I, RTLIB::Libcall Call) {
|
|||
|
||||
// Set up the argument vectors.
|
||||
SmallVector<Value*, 8> Args;
|
||||
SmallVector<unsigned, 8> ArgRegs;
|
||||
SmallVector<Register, 8> ArgRegs;
|
||||
SmallVector<MVT, 8> ArgVTs;
|
||||
SmallVector<ISD::ArgFlagsTy, 8> ArgFlags;
|
||||
Args.reserve(I->getNumOperands());
|
||||
|
@ -2257,13 +2257,13 @@ bool ARMFastISel::ARMEmitLibcall(const Instruction *I, RTLIB::Libcall Call) {
|
|||
}
|
||||
|
||||
// Handle the arguments now that we've gotten them.
|
||||
SmallVector<unsigned, 4> RegArgs;
|
||||
SmallVector<Register, 4> RegArgs;
|
||||
unsigned NumBytes;
|
||||
if (!ProcessCallArgs(Args, ArgRegs, ArgVTs, ArgFlags,
|
||||
RegArgs, CC, NumBytes, false))
|
||||
return false;
|
||||
|
||||
unsigned CalleeReg = 0;
|
||||
Register CalleeReg;
|
||||
if (Subtarget->genLongCalls()) {
|
||||
CalleeReg = getLibcallReg(TLI.getLibcallName(Call));
|
||||
if (CalleeReg == 0) return false;
|
||||
|
@ -2282,7 +2282,7 @@ bool ARMFastISel::ARMEmitLibcall(const Instruction *I, RTLIB::Libcall Call) {
|
|||
MIB.addExternalSymbol(TLI.getLibcallName(Call));
|
||||
|
||||
// Add implicit physical register uses to the call.
|
||||
for (unsigned R : RegArgs)
|
||||
for (Register R : RegArgs)
|
||||
MIB.addReg(R, RegState::Implicit);
|
||||
|
||||
// Add a register mask with the call-preserved registers.
|
||||
|
@ -2290,7 +2290,7 @@ bool ARMFastISel::ARMEmitLibcall(const Instruction *I, RTLIB::Libcall Call) {
|
|||
MIB.addRegMask(TRI.getCallPreservedMask(*FuncInfo.MF, CC));
|
||||
|
||||
// Finish off the call including any return values.
|
||||
SmallVector<unsigned, 4> UsedRegs;
|
||||
SmallVector<Register, 4> UsedRegs;
|
||||
if (!FinishCall(RetVT, UsedRegs, I, CC, NumBytes, false)) return false;
|
||||
|
||||
// Set all unused physreg defs as dead.
|
||||
|
@ -2340,7 +2340,7 @@ bool ARMFastISel::SelectCall(const Instruction *I,
|
|||
|
||||
// Set up the argument vectors.
|
||||
SmallVector<Value*, 8> Args;
|
||||
SmallVector<unsigned, 8> ArgRegs;
|
||||
SmallVector<Register, 8> ArgRegs;
|
||||
SmallVector<MVT, 8> ArgVTs;
|
||||
SmallVector<ISD::ArgFlagsTy, 8> ArgFlags;
|
||||
unsigned arg_size = CS.arg_size();
|
||||
|
@ -2377,8 +2377,8 @@ bool ARMFastISel::SelectCall(const Instruction *I,
|
|||
ArgVT != MVT::i1)
|
||||
return false;
|
||||
|
||||
unsigned Arg = getRegForValue(*i);
|
||||
if (Arg == 0)
|
||||
Register Arg = getRegForValue(*i);
|
||||
if (!Arg.isValid())
|
||||
return false;
|
||||
|
||||
unsigned OriginalAlignment = DL.getABITypeAlignment(ArgTy);
|
||||
|
@ -2391,7 +2391,7 @@ bool ARMFastISel::SelectCall(const Instruction *I,
|
|||
}
|
||||
|
||||
// Handle the arguments now that we've gotten them.
|
||||
SmallVector<unsigned, 4> RegArgs;
|
||||
SmallVector<Register, 4> RegArgs;
|
||||
unsigned NumBytes;
|
||||
if (!ProcessCallArgs(Args, ArgRegs, ArgVTs, ArgFlags,
|
||||
RegArgs, CC, NumBytes, isVarArg))
|
||||
|
@ -2401,7 +2401,7 @@ bool ARMFastISel::SelectCall(const Instruction *I,
|
|||
const GlobalValue *GV = dyn_cast<GlobalValue>(Callee);
|
||||
if (!GV || Subtarget->genLongCalls()) UseReg = true;
|
||||
|
||||
unsigned CalleeReg = 0;
|
||||
Register CalleeReg;
|
||||
if (UseReg) {
|
||||
if (IntrMemName)
|
||||
CalleeReg = getLibcallReg(IntrMemName);
|
||||
|
@ -2427,7 +2427,7 @@ bool ARMFastISel::SelectCall(const Instruction *I,
|
|||
MIB.addExternalSymbol(IntrMemName, 0);
|
||||
|
||||
// Add implicit physical register uses to the call.
|
||||
for (unsigned R : RegArgs)
|
||||
for (Register R : RegArgs)
|
||||
MIB.addReg(R, RegState::Implicit);
|
||||
|
||||
// Add a register mask with the call-preserved registers.
|
||||
|
@ -2435,7 +2435,7 @@ bool ARMFastISel::SelectCall(const Instruction *I,
|
|||
MIB.addRegMask(TRI.getCallPreservedMask(*FuncInfo.MF, CC));
|
||||
|
||||
// Finish off the call including any return values.
|
||||
SmallVector<unsigned, 4> UsedRegs;
|
||||
SmallVector<Register, 4> UsedRegs;
|
||||
if (!FinishCall(RetVT, UsedRegs, I, CC, NumBytes, isVarArg))
|
||||
return false;
|
||||
|
||||
|
|
|
@ -1141,14 +1141,14 @@ bool WebAssemblyFastISel::selectBitCast(const Instruction *I) {
|
|||
return true;
|
||||
}
|
||||
|
||||
unsigned Reg = fastEmit_ISD_BITCAST_r(VT.getSimpleVT(), RetVT.getSimpleVT(),
|
||||
Register Reg = fastEmit_ISD_BITCAST_r(VT.getSimpleVT(), RetVT.getSimpleVT(),
|
||||
In, I->getOperand(0)->hasOneUse());
|
||||
if (!Reg)
|
||||
return false;
|
||||
MachineBasicBlock::iterator Iter = FuncInfo.InsertPt;
|
||||
--Iter;
|
||||
assert(Iter->isBitcast());
|
||||
Iter->setPhysRegsDeadExcept(ArrayRef<unsigned>(), TRI);
|
||||
Iter->setPhysRegsDeadExcept(ArrayRef<Register>(), TRI);
|
||||
updateValueMap(I, Reg);
|
||||
return true;
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue