14#ifndef LLVM_CODEGEN_GLOBALISEL_LEGALIZATIONARTIFACTCOMBINER_H
15#define LLVM_CODEGEN_GLOBALISEL_LEGALIZATIONARTIFACTCOMBINER_H
32#define DEBUG_TYPE "legalizer"
41 static bool isArtifactCast(
unsigned Opc) {
43 case TargetOpcode::G_TRUNC:
44 case TargetOpcode::G_SEXT:
45 case TargetOpcode::G_ZEXT:
46 case TargetOpcode::G_ANYEXT:
57 : Builder(
B), MRI(MRI), LI(LI), VT(VT) {}
64 assert(
MI.getOpcode() == TargetOpcode::G_ANYEXT);
66 Builder.setInstrAndDebugLoc(
MI);
68 Register SrcReg = lookThroughCopyInstrs(
MI.getOperand(1).getReg());
74 if (MRI.getType(DstReg) == MRI.getType(TruncSrc))
78 Builder.buildAnyExtOrTrunc(DstReg, TruncSrc);
80 markInstAndDefDead(
MI, *MRI.getVRegDef(SrcReg), DeadInsts);
91 Builder.buildInstr(ExtMI->
getOpcode(), {DstReg}, {ExtSrc});
93 markInstAndDefDead(
MI, *ExtMI, DeadInsts);
100 const LLT DstTy = MRI.getType(DstReg);
101 if (isInstLegal({TargetOpcode::G_CONSTANT, {DstTy}})) {
106 Builder.setDebugLoc(MergedLocation);
107 Builder.buildConstant(DstReg,
110 markInstAndDefDead(
MI, *SrcCst, DeadInsts);
122 assert(
MI.getOpcode() == TargetOpcode::G_ZEXT);
124 Builder.setInstrAndDebugLoc(
MI);
126 Register SrcReg = lookThroughCopyInstrs(
MI.getOperand(1).getReg());
134 LLT DstTy = MRI.getType(DstReg);
135 if (isInstUnsupported({TargetOpcode::G_AND, {DstTy}}) ||
136 isConstantUnsupported(DstTy))
139 LLT SrcTy = MRI.getType(SrcReg);
141 if (SextSrc && (DstTy != MRI.getType(SextSrc)))
142 SextSrc = Builder.buildSExtOrTrunc(DstTy, SextSrc).getReg(0);
143 if (TruncSrc && (DstTy != MRI.getType(TruncSrc)))
144 TruncSrc = Builder.buildAnyExtOrTrunc(DstTy, TruncSrc).getReg(0);
146 Register AndSrc = SextSrc ? SextSrc : TruncSrc;
153 if (VT && (VT->getKnownZeroes(AndSrc) | ExtMaskVal).isAllOnes()) {
157 auto Mask = Builder.buildConstant(DstTy, ExtMaskVal);
158 Builder.buildAnd(DstReg, AndSrc, Mask);
160 markInstAndDefDead(
MI, *MRI.getVRegDef(SrcReg), DeadInsts);
169 MI.getOperand(1).setReg(ZextSrc);
172 markDefDead(
MI, *MRI.getVRegDef(SrcReg), DeadInsts);
179 const LLT DstTy = MRI.getType(DstReg);
180 if (isInstLegal({TargetOpcode::G_CONSTANT, {DstTy}})) {
181 Builder.buildConstant(DstReg,
184 markInstAndDefDead(
MI, *SrcCst, DeadInsts);
196 assert(
MI.getOpcode() == TargetOpcode::G_SEXT);
198 Builder.setInstrAndDebugLoc(
MI);
200 Register SrcReg = lookThroughCopyInstrs(
MI.getOperand(1).getReg());
205 LLT DstTy = MRI.getType(DstReg);
206 LLT SrcTy = MRI.getType(SrcReg);
207 uint64_t SizeInBits = SrcTy.getScalarSizeInBits();
208 if (isInstUnsupported({TargetOpcode::G_SEXT_INREG,
211 {
static_cast<int64_t
>(SizeInBits)}}))
214 if (DstTy != MRI.getType(TruncSrc))
215 TruncSrc = Builder.buildAnyExtOrTrunc(DstTy, TruncSrc).getReg(0);
218 if (VT && VT->computeNumSignBits(TruncSrc) >
223 Builder.buildSExtInReg(DstReg, TruncSrc, SizeInBits);
224 markInstAndDefDead(
MI, *MRI.getVRegDef(SrcReg), DeadInsts);
236 Builder.buildInstr(ExtMI->
getOpcode(), {DstReg}, {ExtSrc});
238 markInstAndDefDead(
MI, *MRI.getVRegDef(SrcReg), DeadInsts);
245 const LLT DstTy = MRI.getType(DstReg);
246 if (isInstLegal({TargetOpcode::G_CONSTANT, {DstTy}})) {
247 Builder.buildConstant(DstReg,
250 markInstAndDefDead(
MI, *SrcCst, DeadInsts);
263 assert(
MI.getOpcode() == TargetOpcode::G_TRUNC);
265 Builder.setInstrAndDebugLoc(
MI);
267 const LLT DstTy = MRI.getType(DstReg);
268 Register SrcReg = lookThroughCopyInstrs(
MI.getOperand(1).getReg());
273 if (isInstLegal({TargetOpcode::G_CONSTANT, {DstTy}})) {
274 Builder.buildConstant(DstReg,
277 markInstAndDefDead(
MI, *SrcCst, DeadInsts);
286 const Register MergeSrcReg = SrcMerge->getSourceReg(0);
287 const LLT MergeSrcTy = MRI.getType(MergeSrcReg);
302 if (MergeSrcTy != WorkTy)
303 return Builder.buildBitcast(WorkTy, R).getReg(0);
307 if (DstSize < MergeSrcSize) {
310 if (isInstUnsupported({TargetOpcode::G_TRUNC, {DstTy, WorkTy}}))
313 LLVM_DEBUG(
dbgs() <<
"Combining G_TRUNC(G_MERGE_VALUES) to G_TRUNC: "
316 Builder.buildTrunc(DstReg, AsInt(MergeSrcReg));
318 }
else if (DstSize == MergeSrcSize) {
321 dbgs() <<
"Replacing G_TRUNC(G_MERGE_VALUES) with merge input: "
324 UpdatedDefs, Observer);
325 }
else if (DstSize % MergeSrcSize == 0) {
328 if (isInstUnsupported({TargetOpcode::G_MERGE_VALUES, {DstTy, WorkTy}}))
332 dbgs() <<
"Combining G_TRUNC(G_MERGE_VALUES) to G_MERGE_VALUES: "
335 const unsigned NumSrcs = DstSize / MergeSrcSize;
336 assert(NumSrcs < SrcMI->getNumOperands() - 1 &&
337 "trunc(merge) should require less inputs than merge");
339 for (
unsigned i = 0; i < NumSrcs; ++i)
340 SrcRegs[i] = AsInt(SrcMerge->getSourceReg(i));
342 Builder.buildMergeValues(DstReg, SrcRegs);
349 markInstAndDefDead(
MI, *SrcMerge, DeadInsts);
361 Builder.buildTrunc(DstReg, TruncSrc);
363 markInstAndDefDead(
MI, *MRI.getVRegDef(TruncSrc), DeadInsts);
371 LLT FoundRegTy = MRI.getType(FoundReg);
372 if (DstTy == FoundRegTy) {
373 LLVM_DEBUG(
dbgs() <<
".. Combine G_TRUNC(G_[S,Z,ANY]EXT/G_TRUNC...): "
379 markInstAndDefDead(
MI, *MRI.getVRegDef(SrcReg), DeadInsts);
392 unsigned Opcode =
MI.getOpcode();
393 assert(Opcode == TargetOpcode::G_ANYEXT || Opcode == TargetOpcode::G_ZEXT ||
394 Opcode == TargetOpcode::G_SEXT);
397 MI.getOperand(1).getReg(), MRI)) {
398 Builder.setInstrAndDebugLoc(
MI);
400 LLT DstTy = MRI.getType(DstReg);
402 if (Opcode == TargetOpcode::G_ANYEXT) {
404 if (!isInstLegal({TargetOpcode::G_IMPLICIT_DEF, {DstTy}}))
407 auto Impl = Builder.buildUndef(DstTy);
414 if (isConstantUnsupported(DstTy))
417 auto Cnst = Builder.buildConstant(DstTy, 0);
423 markInstAndDefDead(
MI, *
DefMI, DeadInsts);
433 assert(
MI.getOpcode() == TargetOpcode::G_UNMERGE_VALUES);
435 const unsigned CastOpc = CastMI.
getOpcode();
437 if (!isArtifactCast(CastOpc))
440 const unsigned NumDefs =
MI.getNumOperands() - 1;
443 const LLT CastSrcTy = MRI.getType(CastSrcReg);
444 const LLT DestTy = MRI.getType(
MI.getOperand(0).getReg());
445 const LLT SrcTy = MRI.getType(
MI.getOperand(NumDefs).getReg());
450 if (CastOpc == TargetOpcode::G_TRUNC) {
451 if (SrcTy.isVector() && SrcTy.getScalarType() == DestTy.
getScalarType()) {
461 unsigned UnmergeNumElts =
468 if (isInstUnsupported(
469 {TargetOpcode::G_UNMERGE_VALUES, {UnmergeTy, CastSrcTy}}) ||
470 LI.getAction({TargetOpcode::G_TRUNC, {SrcWideTy, UnmergeTy}})
474 Builder.setInstrAndDebugLoc(
MI);
475 auto NewUnmerge = Builder.buildUnmerge(UnmergeTy, CastSrcReg);
477 for (
unsigned I = 0;
I != NumDefs; ++
I) {
480 Builder.buildTrunc(DefReg, NewUnmerge.getReg(
I));
483 markInstAndDefDead(
MI, CastMI, DeadInsts);
495 if (CastSrcSize % DestSize != 0)
499 if (isInstUnsupported(
500 {TargetOpcode::G_UNMERGE_VALUES, {DestTy, CastSrcTy}}))
505 const unsigned NewNumDefs = CastSrcSize / DestSize;
507 for (
unsigned Idx = 0; Idx < NewNumDefs; ++Idx) {
509 DstRegs[Idx] =
MI.getOperand(Idx).getReg();
511 DstRegs[Idx] = MRI.createGenericVirtualRegister(DestTy);
515 Builder.setInstrAndDebugLoc(
MI);
516 Builder.buildUnmerge(DstRegs, CastSrcReg);
518 markInstAndDefDead(
MI, CastMI, DeadInsts);
533 case TargetOpcode::G_BUILD_VECTOR:
534 case TargetOpcode::G_MERGE_VALUES:
560 DestTy ==
OpTy.getElementType();
561 case TargetOpcode::G_CONCAT_VECTORS: {
567 const unsigned OpEltSize =
OpTy.getElementType().getSizeInBits();
572 if (ConvertOp == TargetOpcode::G_TRUNC)
592 DefMO.
setReg(MRI.createGenericVirtualRegister(MRI.getType(DstReg)));
594 Builder.buildCopy(DstReg, SrcReg);
600 for (
auto &
UseMI : MRI.use_instructions(DstReg)) {
610 for (
auto *
UseMI : UseMIs)
618 if (Def.getReg() == SearchDef)
649 unsigned SrcSize = MRI.getType(Src1Reg).getSizeInBits();
652 unsigned StartSrcIdx = (StartBit / SrcSize) + 1;
654 unsigned InRegOffset = StartBit % SrcSize;
658 if (InRegOffset +
Size > SrcSize)
662 if (InRegOffset == 0 &&
Size == SrcSize) {
663 CurrentBest = SrcReg;
664 return findValueFromDefImpl(SrcReg, 0,
Size, MRI.getType(SrcReg));
667 return findValueFromDefImpl(SrcReg, InRegOffset,
Size,
668 MRI.getType(SrcReg));
682 unsigned SrcSize = MRI.getType(Src1Reg).getSizeInBits();
685 unsigned StartSrcIdx = (StartBit / SrcSize) + 1;
687 unsigned InRegOffset = StartBit % SrcSize;
689 if (InRegOffset != 0)
696 if (
Size > SrcSize) {
697 if (
Size % SrcSize > 0)
700 unsigned NumSrcsUsed =
Size / SrcSize;
705 LLT SrcTy = MRI.getType(Src1Reg);
710 LI.getAction({TargetOpcode::G_BUILD_VECTOR, {NewBVTy, SrcTy}});
715 for (
unsigned SrcIdx = StartSrcIdx; SrcIdx < StartSrcIdx + NumSrcsUsed;
718 MIB.setInstrAndDebugLoc(BV);
719 return MIB.buildBuildVector(NewBVTy, NewSrcs).getReg(0);
722 return BV.
getReg(StartSrcIdx);
732 assert(
MI.getOpcode() == TargetOpcode::G_INSERT);
735 Register ContainerSrcReg =
MI.getOperand(1).getReg();
736 Register InsertedReg =
MI.getOperand(2).getReg();
737 LLT InsertedRegTy = MRI.getType(InsertedReg);
738 unsigned InsertOffset =
MI.getOperand(3).getImm();
776 unsigned InsertedEndBit = InsertOffset + InsertedRegTy.
getSizeInBits();
777 unsigned EndBit = StartBit +
Size;
778 unsigned NewStartBit;
780 if (EndBit <= InsertOffset || InsertedEndBit <= StartBit) {
781 SrcRegToUse = ContainerSrcReg;
782 NewStartBit = StartBit;
783 return findValueFromDefImpl(SrcRegToUse, NewStartBit,
Size,
784 MRI.getType(SrcRegToUse));
786 if (InsertOffset <= StartBit && EndBit <= InsertedEndBit) {
787 SrcRegToUse = InsertedReg;
788 NewStartBit = StartBit - InsertOffset;
789 if (NewStartBit == 0 &&
790 Size == MRI.getType(SrcRegToUse).getSizeInBits())
791 CurrentBest = SrcRegToUse;
792 return findValueFromDefImpl(SrcRegToUse, NewStartBit,
Size,
793 MRI.getType(SrcRegToUse));
807 assert(
MI.getOpcode() == TargetOpcode::G_SEXT ||
808 MI.getOpcode() == TargetOpcode::G_ZEXT ||
809 MI.getOpcode() == TargetOpcode::G_ANYEXT);
813 LLT SrcType = MRI.getType(SrcReg);
817 if (!SrcType.isScalar())
820 if (StartBit +
Size > SrcSize)
823 if (StartBit == 0 && SrcType.getSizeInBits() ==
Size)
824 CurrentBest = SrcReg;
825 return findValueFromDefImpl(SrcReg, StartBit,
Size, SrcType);
835 assert(
MI.getOpcode() == TargetOpcode::G_TRUNC);
839 LLT SrcType = MRI.getType(SrcReg);
842 if (!SrcType.isScalar())
845 return findValueFromDefImpl(SrcReg, StartBit,
Size, SrcType);
853 std::optional<DefinitionAndSourceRegister> DefSrcReg =
856 DefReg = DefSrcReg->Reg;
860 switch (Def->getOpcode()) {
861 case TargetOpcode::G_CONCAT_VECTORS:
863 case TargetOpcode::G_UNMERGE_VALUES: {
864 unsigned DefStartBit = 0;
865 unsigned DefSize = MRI.getType(DefReg).getSizeInBits();
866 for (
const auto &MO : Def->defs()) {
867 if (MO.getReg() == DefReg)
869 DefStartBit += DefSize;
871 Register SrcReg = Def->getOperand(Def->getNumOperands() - 1).getReg();
873 findValueFromDefImpl(SrcReg, StartBit + DefStartBit,
Size, DstTy);
879 if (StartBit == 0 &&
Size == DefSize)
883 case TargetOpcode::G_BUILD_VECTOR:
886 case TargetOpcode::G_INSERT:
887 return findValueFromInsert(*Def, StartBit,
Size);
888 case TargetOpcode::G_TRUNC:
889 return findValueFromTrunc(*Def, StartBit,
Size);
890 case TargetOpcode::G_SEXT:
891 case TargetOpcode::G_ZEXT:
892 case TargetOpcode::G_ANYEXT:
893 return findValueFromExt(*Def, StartBit,
Size);
894 case TargetOpcode::G_IMPLICIT_DEF: {
895 if (MRI.getType(DefReg) == DstTy)
897 MIB.setInstrAndDebugLoc(*Def);
898 return MIB.buildUndef(DstTy).getReg(0);
908 : MRI(Mri), MIB(Builder), LI(Info) {}
917 Register FoundReg = findValueFromDefImpl(DefReg, StartBit,
Size, DstTy);
918 return FoundReg != DefReg ? FoundReg :
Register();
926 unsigned NumDefs =
MI.getNumDefs();
927 LLT DestTy = MRI.getType(
MI.getReg(0));
930 for (
unsigned DefIdx = 0; DefIdx < NumDefs; ++DefIdx) {
932 if (MRI.use_nodbg_empty(DefReg)) {
933 DeadDefs[DefIdx] =
true;
940 if (MRI.getType(FoundVal) != DestTy)
945 DeadDefs[DefIdx] =
true;
947 return DeadDefs.
all();
951 unsigned &DefOperandIdx) {
955 Unmerge->findRegisterDefOperandIdx(Def,
nullptr);
966 GUnmerge *Unmerge,
unsigned UnmergeIdxStart,
967 unsigned NumElts,
unsigned EltSize,
970 assert(MergeStartIdx + NumElts <=
MI.getNumSources());
971 for (
unsigned i = MergeStartIdx; i < MergeStartIdx + NumElts; ++i) {
972 unsigned EltUnmergeIdx;
974 MI.getSourceReg(i), EltSize, EltUnmergeIdx);
976 if (EltUnmerge == Unmerge) {
978 if (i - MergeStartIdx != EltUnmergeIdx - UnmergeIdxStart)
980 }
else if (!AllowUndef ||
992 LLT EltTy = MRI.getType(Elt0);
995 unsigned Elt0UnmergeIdx;
1001 unsigned NumMIElts =
MI.getNumSources();
1003 LLT DstTy = MRI.getType(Dst);
1004 Register UnmergeSrc = Unmerge->getSourceReg();
1005 LLT UnmergeSrcTy = MRI.getType(UnmergeSrc);
1016 if ((DstSize == UnmergeSrcSize) && (DstTy == UnmergeSrcTy) &&
1017 (Elt0UnmergeIdx == 0)) {
1038 if ((DstSize < UnmergeSrcSize) &&
1042 (Elt0UnmergeIdx % NumMIElts == 0) &&
1043 getCoverTy(UnmergeSrcTy, DstTy) == UnmergeSrcTy) {
1047 MIB.setInstrAndDebugLoc(
MI);
1048 auto NewUnmerge = MIB.buildUnmerge(DstTy, Unmerge->getSourceReg());
1049 unsigned DstIdx = (Elt0UnmergeIdx * EltSize) / DstTy.
getSizeInBits();
1051 UpdatedDefs, Observer);
1066 if ((DstSize > UnmergeSrcSize) &&
1070 unsigned NumElts = Unmerge->getNumDefs();
1071 for (
unsigned i = 0; i <
MI.getNumSources(); i += NumElts) {
1072 unsigned EltUnmergeIdx;
1074 EltSize, EltUnmergeIdx);
1076 if ((!UnmergeI) || (UnmergeI->getNumDefs() != NumElts) ||
1077 (EltUnmergeIdx != 0))
1082 ConcatSources.
push_back(UnmergeI->getSourceReg());
1085 MIB.setInstrAndDebugLoc(
MI);
1086 MIB.buildMergeLikeInstr(Dst, ConcatSources);
1099 unsigned NumDefs =
MI.getNumDefs();
1101 std::optional<DefinitionAndSourceRegister> DefSrcReg =
1107 LLT OpTy = MRI.getType(SrcReg);
1108 LLT DestTy = MRI.getType(
MI.getReg(0));
1109 unsigned SrcDefIdx =
getDefIndex(*SrcDef, DefSrcReg->Reg);
1111 Builder.setInstrAndDebugLoc(
MI);
1115 markInstAndDefDead(
MI, *SrcDef, DeadInsts, SrcDefIdx);
1125 Register SrcUnmergeSrc = SrcUnmerge->getSourceReg();
1126 LLT SrcUnmergeSrcTy = MRI.getType(SrcUnmergeSrc);
1132 {TargetOpcode::G_UNMERGE_VALUES, {
OpTy, SrcUnmergeSrcTy}});
1133 switch (ActionStep.
Action) {
1135 if (!
OpTy.isVector() || !LI.isLegal({TargetOpcode::G_UNMERGE_VALUES,
1136 {DestTy, SrcUnmergeSrcTy}}))
1151 auto NewUnmerge = Builder.buildUnmerge(DestTy, SrcUnmergeSrc);
1156 for (
unsigned I = 0;
I != NumDefs; ++
I) {
1159 MRI, Builder, UpdatedDefs, Observer);
1162 markInstAndDefDead(
MI, *SrcUnmerge, DeadInsts, SrcDefIdx);
1167 unsigned ConvertOp = 0;
1170 unsigned SrcOp = SrcDef->getOpcode();
1171 if (isArtifactCast(
SrcOp)) {
1177 ConvertOp,
OpTy, DestTy)) {
1185 if (NumMergeRegs < NumDefs) {
1186 if (NumDefs % NumMergeRegs != 0)
1189 Builder.setInstrAndDebugLoc(
MI);
1197 const unsigned NewNumDefs = NumDefs / NumMergeRegs;
1198 for (
unsigned Idx = 0;
Idx < NumMergeRegs; ++
Idx) {
1200 for (
unsigned j = 0, DefIdx = Idx * NewNumDefs;
j < NewNumDefs;
1205 LLT MergeDstTy = MRI.getType(SrcDef->getOperand(0).getReg());
1210 LLT MergeEltTy = MergeDstTy.
divide(NumMergeRegs);
1225 Register TmpReg = MRI.createGenericVirtualRegister(MergeEltTy);
1226 Builder.buildInstr(ConvertOp, {TmpReg},
1228 Builder.buildUnmerge(DstRegs, TmpReg);
1232 UpdatedDefs.append(DstRegs.
begin(), DstRegs.
end());
1235 }
else if (NumMergeRegs > NumDefs) {
1236 if (ConvertOp != 0 || NumMergeRegs % NumDefs != 0)
1239 Builder.setInstrAndDebugLoc(
MI);
1247 const unsigned NumRegs = NumMergeRegs / NumDefs;
1248 for (
unsigned DefIdx = 0; DefIdx < NumDefs; ++DefIdx) {
1250 for (
unsigned j = 0, Idx = NumRegs * DefIdx + 1;
j < NumRegs;
1255 Builder.buildMergeLikeInstr(DefReg, Regs);
1256 UpdatedDefs.push_back(DefReg);
1262 if (!ConvertOp && DestTy != MergeSrcTy) {
1263 if (DestTy.isPointer())
1264 ConvertOp = TargetOpcode::G_INTTOPTR;
1266 ConvertOp = TargetOpcode::G_PTRTOINT;
1268 ConvertOp = TargetOpcode::G_BITCAST;
1272 Builder.setInstrAndDebugLoc(
MI);
1274 for (
unsigned Idx = 0;
Idx < NumDefs; ++
Idx) {
1275 Register DefReg =
MI.getOperand(Idx).getReg();
1278 if (!MRI.use_empty(DefReg)) {
1279 Builder.buildInstr(ConvertOp, {DefReg}, {MergeSrc});
1280 UpdatedDefs.push_back(DefReg);
1284 markInstAndDefDead(
MI, *MergeI, DeadInsts);
1288 assert(DestTy == MergeSrcTy &&
1289 "Bitcast and the other kinds of conversions should "
1290 "have happened earlier");
1292 Builder.setInstrAndDebugLoc(
MI);
1293 for (
unsigned Idx = 0;
Idx < NumDefs; ++
Idx) {
1294 Register DstReg =
MI.getOperand(Idx).getReg();
1301 markInstAndDefDead(
MI, *MergeI, DeadInsts);
1308 assert(
MI.getOpcode() == TargetOpcode::G_EXTRACT);
1323 Register SrcReg = lookThroughCopyInstrs(
MI.getOperand(1).getReg());
1325 if (MergeI && MergeI->
getOpcode() == TargetOpcode::G_IMPLICIT_DEF) {
1326 Builder.setInstrAndDebugLoc(
MI);
1327 Builder.buildUndef(DstReg);
1329 markInstAndDefDead(
MI, *MergeI, DeadInsts);
1335 LLT DstTy = MRI.getType(DstReg);
1336 LLT SrcTy = MRI.getType(SrcReg);
1340 unsigned Offset =
MI.getOperand(2).getImm();
1342 unsigned MergeSrcSize = SrcTy.getSizeInBits() / NumMergeSrcs;
1343 unsigned MergeSrcIdx =
Offset / MergeSrcSize;
1346 unsigned EndMergeSrcIdx = (
Offset + ExtractDstSize - 1) / MergeSrcSize;
1349 if (MergeSrcIdx != EndMergeSrcIdx)
1353 Builder.setInstrAndDebugLoc(
MI);
1355 Offset - MergeSrcIdx * MergeSrcSize);
1357 markInstAndDefDead(
MI, *MergeI, DeadInsts);
1373 if (!DeadInsts.
empty())
1374 deleteMarkedDeadInsts(DeadInsts, WrapperObserver);
1382 switch (
MI.getOpcode()) {
1385 case TargetOpcode::G_ANYEXT:
1388 case TargetOpcode::G_ZEXT:
1391 case TargetOpcode::G_SEXT:
1394 case TargetOpcode::G_UNMERGE_VALUES:
1396 UpdatedDefs, WrapperObserver);
1398 case TargetOpcode::G_MERGE_VALUES:
1399 case TargetOpcode::G_BUILD_VECTOR:
1400 case TargetOpcode::G_CONCAT_VECTORS:
1403 for (
MachineInstr &U : MRI.use_instructions(
MI.getOperand(0).getReg())) {
1404 if (U.getOpcode() == TargetOpcode::G_UNMERGE_VALUES ||
1405 U.getOpcode() == TargetOpcode::G_TRUNC) {
1411 UpdatedDefs, WrapperObserver);
1413 case TargetOpcode::G_EXTRACT:
1416 case TargetOpcode::G_TRUNC:
1431 while (!UpdatedDefs.
empty()) {
1435 switch (
Use.getOpcode()) {
1437 case TargetOpcode::G_ANYEXT:
1438 case TargetOpcode::G_ZEXT:
1439 case TargetOpcode::G_SEXT:
1440 case TargetOpcode::G_UNMERGE_VALUES:
1441 case TargetOpcode::G_EXTRACT:
1442 case TargetOpcode::G_TRUNC:
1443 case TargetOpcode::G_BUILD_VECTOR:
1447 case TargetOpcode::G_ASSERT_SEXT:
1448 case TargetOpcode::G_ASSERT_ZEXT:
1449 case TargetOpcode::G_ASSERT_ALIGN:
1450 case TargetOpcode::COPY: {
1452 if (Copy.isVirtual())
1469 switch (
MI.getOpcode()) {
1470 case TargetOpcode::COPY:
1471 case TargetOpcode::G_TRUNC:
1472 case TargetOpcode::G_ZEXT:
1473 case TargetOpcode::G_ANYEXT:
1474 case TargetOpcode::G_SEXT:
1475 case TargetOpcode::G_EXTRACT:
1476 case TargetOpcode::G_ASSERT_SEXT:
1477 case TargetOpcode::G_ASSERT_ZEXT:
1478 case TargetOpcode::G_ASSERT_ALIGN:
1479 return MI.getOperand(1).getReg();
1480 case TargetOpcode::G_UNMERGE_VALUES:
1481 return MI.getOperand(
MI.getNumOperands() - 1).getReg();
1494 unsigned DefIdx = 0) {
1505 while (PrevMI != &
DefMI) {
1506 Register PrevRegSrc = getArtifactSrcReg(*PrevMI);
1510 if (TmpDef != &
DefMI) {
1514 "Expecting copy or artifact cast here");
1523 if (PrevMI == &
DefMI) {
1552 unsigned DefIdx = 0) {
1554 markDefDead(
MI,
DefMI, DeadInsts, DefIdx);
1565 for (
auto *DeadMI : DeadInsts) {
1568 DeadMI->eraseFromParent();
1585 bool isConstantUnsupported(
LLT Ty)
const {
1587 return isInstUnsupported({TargetOpcode::G_CONSTANT, {Ty}});
1590 return isInstUnsupported({TargetOpcode::G_CONSTANT, {EltTy}}) ||
1591 isInstUnsupported({TargetOpcode::G_BUILD_VECTOR, {Ty, EltTy}});
MachineInstrBuilder & UseMI
MachineInstrBuilder MachineInstrBuilder & DefMI
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This contains common code to allow clients to notify changes to machine instr.
Declares convenience wrapper classes for interpreting MachineInstr instances as specific generic oper...
Interface for Targets to specify which operations they can successfully select and how the others sho...
Contains matchers for matching SSA Machine Instructions.
This file declares the MachineIRBuilder class.
Promote Memory to Register
MachineRegisterInfo & MRI
This file implements the SmallBitVector class.
static constexpr int Concat[]
Class for arbitrary precision integers.
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
LLVM_ABI APInt zext(unsigned width) const
Zero extend to a new width.
LLVM_ABI APInt trunc(unsigned width) const
Truncate to new width.
LLVM_ABI APInt sext(unsigned width) const
Sign extend to a new width.
static LLVM_ABI DebugLoc getMergedLocation(DebugLoc LocA, DebugLoc LocB)
When two instructions are combined into a single instruction we also need to combine the original loc...
static constexpr ElementCount getFixed(ScalarTy MinVal)
Represents a G_BUILD_VECTOR.
Represents a G_CONCAT_VECTORS.
const APInt & getValue() const
Abstract class that contains various methods for clients to notify about changes.
virtual void changingInstr(MachineInstr &MI)=0
This instruction is about to be mutated in some way.
virtual void changedInstr(MachineInstr &MI)=0
This instruction was mutated in some way.
Simple wrapper observer that takes several observers, and calls each one for each event.
void changedInstr(MachineInstr &MI) override
This instruction was mutated in some way.
void changingInstr(MachineInstr &MI) override
This instruction is about to be mutated in some way.
void erasingInstr(MachineInstr &MI) override
An instruction is about to be erased.
Represents G_BUILD_VECTOR, G_CONCAT_VECTORS or G_MERGE_VALUES.
Register getSourceReg(unsigned I) const
Returns the I'th source register.
unsigned getNumSources() const
Returns the number of source registers.
Represents a G_UNMERGE_VALUES.
Register getReg(unsigned Idx) const
Access the Idx'th operand as a register and return it.
LLT changeElementCount(ElementCount EC) const
Return a vector or scalar with the same element type and the new element count.
constexpr unsigned getScalarSizeInBits() const
constexpr bool isScalar() const
LLT getScalarType() const
constexpr uint16_t getNumElements() const
Returns the number of elements in a vector LLT.
constexpr bool isFloat() const
constexpr bool isVector() const
constexpr TypeSize getSizeInBits() const
Returns the total size of the type. Must only be called on sized types.
constexpr bool isPointer() const
LLT divide(int Factor) const
Return a type that is Factor times smaller.
static constexpr LLT fixed_vector(unsigned NumElements, unsigned ScalarSizeInBits)
Get a low-level fixed-width vector of some number of elements and element width.
static LLT integer(unsigned SizeInBits)
LLT getElementType() const
Returns the vector's element type. Only valid for vector types.
This class provides utilities for finding source registers of specific bit ranges in an artifact.
Register findValueFromDef(Register DefReg, unsigned StartBit, unsigned Size, LLT DstTy)
Try to find a source of the value defined in the def DefReg, starting at position StartBit with size ...
bool tryCombineUnmergeDefs(GUnmerge &MI, GISelChangeObserver &Observer, SmallVectorImpl< Register > &UpdatedDefs)
Try to combine the defs of an unmerge MI by attempting to find values that provides the bits for each...
bool isSequenceFromUnmerge(GMergeLikeInstr &MI, unsigned MergeStartIdx, GUnmerge *Unmerge, unsigned UnmergeIdxStart, unsigned NumElts, unsigned EltSize, bool AllowUndef)
GUnmerge * findUnmergeThatDefinesReg(Register Reg, unsigned Size, unsigned &DefOperandIdx)
bool tryCombineMergeLike(GMergeLikeInstr &MI, SmallVectorImpl< MachineInstr * > &DeadInsts, SmallVectorImpl< Register > &UpdatedDefs, GISelChangeObserver &Observer)
ArtifactValueFinder(MachineRegisterInfo &Mri, MachineIRBuilder &Builder, const LegalizerInfo &Info)
bool tryFoldUnmergeCast(MachineInstr &MI, MachineInstr &CastMI, SmallVectorImpl< MachineInstr * > &DeadInsts, SmallVectorImpl< Register > &UpdatedDefs)
bool tryFoldImplicitDef(MachineInstr &MI, SmallVectorImpl< MachineInstr * > &DeadInsts, SmallVectorImpl< Register > &UpdatedDefs, GISelObserverWrapper &Observer)
Try to fold G_[ASZ]EXT (G_IMPLICIT_DEF).
bool tryCombineZExt(MachineInstr &MI, SmallVectorImpl< MachineInstr * > &DeadInsts, SmallVectorImpl< Register > &UpdatedDefs, GISelObserverWrapper &Observer)
bool tryCombineInstruction(MachineInstr &MI, SmallVectorImpl< MachineInstr * > &DeadInsts, GISelObserverWrapper &WrapperObserver)
Try to combine away MI.
bool tryCombineTrunc(MachineInstr &MI, SmallVectorImpl< MachineInstr * > &DeadInsts, SmallVectorImpl< Register > &UpdatedDefs, GISelObserverWrapper &Observer)
LegalizationArtifactCombiner(MachineIRBuilder &B, MachineRegisterInfo &MRI, const LegalizerInfo &LI, GISelValueTracking *VT=nullptr)
bool tryCombineSExt(MachineInstr &MI, SmallVectorImpl< MachineInstr * > &DeadInsts, SmallVectorImpl< Register > &UpdatedDefs, GISelObserverWrapper &Observer)
static bool canFoldMergeOpcode(unsigned MergeOp, unsigned ConvertOp, LLT OpTy, LLT DestTy)
static unsigned getDefIndex(const MachineInstr &MI, Register SearchDef)
Return the operand index in MI that defines Def.
static void replaceRegOrBuildCopy(Register DstReg, Register SrcReg, MachineRegisterInfo &MRI, MachineIRBuilder &Builder, SmallVectorImpl< Register > &UpdatedDefs, GISelChangeObserver &Observer)
Try to replace DstReg with SrcReg or build a COPY instruction depending on the register constraints.
bool tryCombineUnmergeValues(GUnmerge &MI, SmallVectorImpl< MachineInstr * > &DeadInsts, SmallVectorImpl< Register > &UpdatedDefs, GISelChangeObserver &Observer)
bool tryCombineExtract(MachineInstr &MI, SmallVectorImpl< MachineInstr * > &DeadInsts, SmallVectorImpl< Register > &UpdatedDefs)
bool tryCombineAnyExt(MachineInstr &MI, SmallVectorImpl< MachineInstr * > &DeadInsts, SmallVectorImpl< Register > &UpdatedDefs, GISelObserverWrapper &Observer)
LegalizeActionStep getAction(const LegalityQuery &Query) const
Determine what action should be taken to legalize the described instruction.
Helper class to build MachineInstr.
Register getReg(unsigned Idx) const
Get the register for the operand index.
Representation of each machine instruction.
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
unsigned getNumOperands() const
Retuns the total number of operands.
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
const MachineOperand & getOperand(unsigned i) const
MachineOperand class - Representation of each machine instruction operand.
LLVM_ABI void setReg(Register Reg)
Change the register this operand corresponds to.
MachineInstr * getParent()
getParent - Return the instruction that this operand belongs to.
Register getReg() const
getReg - Returns the register number.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
LLVM_ABI LLVM_READONLY MachineInstr * getVRegDef(Register Reg) const
getVRegDef - Return the machine instr that defines the specified virtual register or null if none is ...
bool hasOneUse(Register RegNo) const
hasOneUse - Return true if there is exactly one instruction using the specified register.
bool use_empty(Register RegNo) const
use_empty - Return true if there are no instructions using the specified register.
Wrapper class representing virtual and physical registers.
constexpr bool isValid() const
constexpr bool isVirtual() const
Return true if the specified register number is in the virtual register namespace.
This is a 'bitvector' (really, a variable-sized bit array), optimized for the case when the array is ...
bool all() const
Returns true if all bits are set.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
void push_back(const T &Elt)
LLVM_NO_SANITIZE_CFI_UNRELATED_CAST iterator begin()
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
A Use represents the edge between a Value definition and its users.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ FewerElements
The (vector) operation should be implemented by splitting it into sub-vectors where the operation is ...
@ Legal
The operation is expected to be selectable directly by the target, and no transformation is necessary...
@ Unsupported
This operation is completely unsupported on the target.
@ Lower
The operation itself must be expressed in terms of simpler actions on this target.
@ NarrowScalar
The operation should be synthesized from multiple instructions acting on a narrower scalar base-type.
@ MoreElements
The (vector) operation should be implemented by widening the input vector and ignoring the lanes adde...
operand_type_match m_Reg()
GInstrBind< GConstant > m_GConstant(GConstant *&Inst)
Match a literal G_CONSTANT instruction (no look-through of splats or copies).
UnaryOp_match< SrcTy, TargetOpcode::G_ZEXT > m_GZExt(const SrcTy &Src)
UnaryOp_match< SrcTy, TargetOpcode::G_SEXT > m_GSExt(const SrcTy &Src)
ImplicitDefMatch m_GImplicitDef()
bool mi_match(Reg R, const MachineRegisterInfo &MRI, Pattern &&P)
Or< Preds... > m_any_of(Preds &&... preds)
bind_ty< MachineInstr * > m_MInstr(MachineInstr *&MI)
And< Preds... > m_all_of(Preds &&... preds)
UnaryOp_match< SrcTy, TargetOpcode::G_ANYEXT > m_GAnyExt(const SrcTy &Src)
UnaryOp_match< SrcTy, TargetOpcode::G_TRUNC > m_GTrunc(const SrcTy &Src)
NodeAddr< DefNode * > Def
This is an optimization pass for GlobalISel generic memory operations.
LLVM_ABI MachineInstr * getOpcodeDef(unsigned Opcode, Register Reg, const MachineRegisterInfo &MRI)
See if Reg is defined by an single def instruction that is Opcode.
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
LLVM_ABI MachineInstr * getDefIgnoringCopies(Register Reg, const MachineRegisterInfo &MRI)
Find the def instruction for Reg, folding away any trivial copies.
bool isPreISelGenericOptimizationHint(unsigned Opcode)
LLVM_ABI bool canReplaceReg(Register DstReg, Register SrcReg, MachineRegisterInfo &MRI)
Check if DstReg can be replaced with SrcReg depending on the register constraints.
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
LLVM_ABI LLVM_READNONE LLT getCoverTy(LLT OrigTy, LLT TargetTy)
Return smallest type that covers both OrigTy and TargetTy and is multiple of TargetTy.
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI std::optional< DefinitionAndSourceRegister > getDefSrcRegIgnoringCopies(Register Reg, const MachineRegisterInfo &MRI)
Find the def instruction for Reg, and underlying value Register folding away any copies.
LLVM_ABI Register getSrcRegIgnoringCopies(Register Reg, const MachineRegisterInfo &MRI)
Find the source register for Reg, folding away any trivial copies.
The LegalityQuery object bundles together all the information that's needed to decide whether a given...
LegalizeAction Action
The action to take or the final answer.
unsigned TypeIdx
If describing an action, the type index to change. Otherwise zero.