/// Represents G_BUILD_VECTOR, G_CONCAT_VECTORS or G_MERGE_VALUES.
/// All these have the common property of generating a single value from
/// multiple sources.
-class GMergeLikeOp : public GenericMachineInstr {
+class GMergeLikeInstr : public GenericMachineInstr {
public:
/// Returns the number of source registers.
unsigned getNumSources() const { return getNumOperands() - 1; }
};
/// Represents a G_MERGE_VALUES.
-class GMerge : public GMergeLikeOp {
+class GMerge : public GMergeLikeInstr {
public:
static bool classof(const MachineInstr *MI) {
return MI->getOpcode() == TargetOpcode::G_MERGE_VALUES;
};
/// Represents a G_CONCAT_VECTORS.
-class GConcatVectors : public GMergeLikeOp {
+class GConcatVectors : public GMergeLikeInstr {
public:
static bool classof(const MachineInstr *MI) {
return MI->getOpcode() == TargetOpcode::G_CONCAT_VECTORS;
};
/// Represents a G_BUILD_VECTOR.
-class GBuildVector : public GMergeLikeOp {
+class GBuildVector : public GMergeLikeInstr {
public:
static bool classof(const MachineInstr *MI) {
return MI->getOpcode() == TargetOpcode::G_BUILD_VECTOR;
// Check if sequence of elements from merge-like instruction is defined by
// another sequence of elements defined by unmerge. Most often this is the
// same sequence. Search for elements using findValueFromDefImpl.
- bool isSequenceFromUnmerge(GMergeLikeOp &MI, unsigned MergeStartIdx,
+ bool isSequenceFromUnmerge(GMergeLikeInstr &MI, unsigned MergeStartIdx,
GUnmerge *Unmerge, unsigned UnmergeIdxStart,
unsigned NumElts, unsigned EltSize) {
assert(MergeStartIdx + NumElts <= MI.getNumSources());
return true;
}
- bool tryCombineMergeLike(GMergeLikeOp &MI,
+ bool tryCombineMergeLike(GMergeLikeInstr &MI,
SmallVectorImpl<MachineInstr *> &DeadInsts,
SmallVectorImpl<Register> &UpdatedDefs,
GISelChangeObserver &Observer) {
Register SrcReg = lookThroughCopyInstrs(MI.getOperand(1).getReg());
MachineInstr *MergeI = MRI.getVRegDef(SrcReg);
- if (!MergeI || !isa<GMergeLikeOp>(MergeI))
+ if (!MergeI || !isa<GMergeLikeInstr>(MergeI))
return false;
Register DstReg = MI.getOperand(0).getReg();
break;
}
}
- Changed = Finder.tryCombineMergeLike(cast<GMergeLikeOp>(MI), DeadInsts,
+ Changed = Finder.tryCombineMergeLike(cast<GMergeLikeInstr>(MI), DeadInsts,
UpdatedDefs, WrapperObserver);
break;
case TargetOpcode::G_EXTRACT:
/// Build and insert G_ASSERT_SEXT, G_ASSERT_ZEXT, or G_ASSERT_ALIGN
///
/// \return a MachineInstrBuilder for the newly created instruction.
- MachineInstrBuilder buildAssertOp(unsigned Opc, const DstOp &Res, const SrcOp &Op,
- unsigned Val) {
+ MachineInstrBuilder buildAssertInstr(unsigned Opc, const DstOp &Res,
+ const SrcOp &Op, unsigned Val) {
return buildInstr(Opc, Res, Op).addImm(Val);
}
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAssertZExt(const DstOp &Res, const SrcOp &Op,
unsigned Size) {
- return buildAssertOp(TargetOpcode::G_ASSERT_ZEXT, Res, Op, Size);
+ return buildAssertInstr(TargetOpcode::G_ASSERT_ZEXT, Res, Op, Size);
}
/// Build and insert \p Res = G_ASSERT_SEXT Op, Size
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAssertSExt(const DstOp &Res, const SrcOp &Op,
unsigned Size) {
- return buildAssertOp(TargetOpcode::G_ASSERT_SEXT, Res, Op, Size);
+ return buildAssertInstr(TargetOpcode::G_ASSERT_SEXT, Res, Op, Size);
}
/// Build and insert \p Res = G_ASSERT_ALIGN Op, AlignVal
/// \return a MachineInstrBuilder for the newly created instruction.
MachineInstrBuilder buildAssertAlign(const DstOp &Res, const SrcOp &Op,
Align AlignVal) {
- return buildAssertOp(TargetOpcode::G_ASSERT_ALIGN, Res, Op, AlignVal.value());
+ return buildAssertInstr(TargetOpcode::G_ASSERT_ALIGN, Res, Op,
+ AlignVal.value());
}
/// Build and insert `Res = G_LOAD Addr, MMO`.
auto &Unmerge = cast<GUnmerge>(MI);
Register SrcReg = peekThroughBitcast(Unmerge.getSourceReg(), MRI);
- auto *SrcInstr = getOpcodeDef<GMergeLikeOp>(SrcReg, MRI);
+ auto *SrcInstr = getOpcodeDef<GMergeLikeInstr>(SrcReg, MRI);
if (!SrcInstr)
return false;