Skip to content

Commit d001e0e

Browse files
committed
[globalisel] Add GISelChangeObserver::changingInstr()
Summary: In addition to knowing that an instruction is changed. It's also useful to know when it's about to change. For example, it might print the instruction so you can track the changes in a debug log, it might remove it from some queue while it's being worked on, or it might want to change several instructions as a single transaction and act on all the changes at once. Added changingInstr() to all existing uses of changedInstr() Reviewers: aditya_nandakumar Reviewed By: aditya_nandakumar Subscribers: rovka, kristof.beyls, llvm-commits Differential Revision: https://reviews.llvm.org/D55623 llvm-svn: 348992
1 parent 25b5602 commit d001e0e

File tree

5 files changed

+40
-6
lines changed

5 files changed

+40
-6
lines changed

llvm/include/llvm/CodeGen/GlobalISel/GISelChangeObserver.h

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -30,6 +30,8 @@ class GISelChangeObserver {
3030
virtual void erasingInstr(MachineInstr &MI) = 0;
3131
/// An instruction was created and inserted into the function.
3232
virtual void createdInstr(MachineInstr &MI) = 0;
33+
/// This instruction is about to be mutated in some way.
34+
virtual void changingInstr(MachineInstr &MI) = 0;
3335
/// This instruction was mutated in some way.
3436
virtual void changedInstr(MachineInstr &MI) = 0;
3537
};

llvm/lib/CodeGen/GlobalISel/Combiner.cpp

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -44,16 +44,20 @@ class WorkListMaintainer : public GISelChangeObserver {
4444
virtual ~WorkListMaintainer() {}
4545

4646
void erasingInstr(MachineInstr &MI) override {
47-
LLVM_DEBUG(dbgs() << "Erased: "; MI.print(dbgs()); dbgs() << "\n");
47+
LLVM_DEBUG(dbgs() << "Erased: " << MI << "\n");
4848
WorkList.remove(&MI);
4949
}
5050
void createdInstr(MachineInstr &MI) override {
51-
LLVM_DEBUG(dbgs() << "Created: "; MI.print(dbgs()); dbgs() << "\n");
51+
LLVM_DEBUG(dbgs() << "Created: " << MI << "\n");
5252
WorkList.insert(&MI);
5353
}
54+
void changingInstr(MachineInstr &MI) override {
55+
LLVM_DEBUG(dbgs() << "Changing: " << MI << "\n");
56+
WorkList.remove(&MI);
57+
}
5458
// Currently changed conservatively assumes erased.
5559
void changedInstr(MachineInstr &MI) override {
56-
LLVM_DEBUG(dbgs() << "Changed: "; MI.print(dbgs()); dbgs() << "\n");
60+
LLVM_DEBUG(dbgs() << "Changed: " << MI << "\n");
5761
WorkList.remove(&MI);
5862
}
5963
};

llvm/lib/CodeGen/GlobalISel/Legalizer.cpp

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -91,19 +91,23 @@ class LegalizerWorkListManager : public GISelChangeObserver {
9191
else
9292
InstList.insert(&MI);
9393
}
94-
LLVM_DEBUG(dbgs() << ".. .. New MI: " << MI;);
94+
LLVM_DEBUG(dbgs() << ".. .. New MI: " << MI);
9595
}
9696

9797
void erasingInstr(MachineInstr &MI) override {
98-
LLVM_DEBUG(dbgs() << ".. .. Erasing: " << MI;);
98+
LLVM_DEBUG(dbgs() << ".. .. Erasing: " << MI);
9999
InstList.remove(&MI);
100100
ArtifactList.remove(&MI);
101101
}
102102

103+
void changingInstr(MachineInstr &MI) override {
104+
LLVM_DEBUG(dbgs() << ".. .. Changing MI: " << MI);
105+
}
106+
103107
void changedInstr(MachineInstr &MI) override {
104108
// When insts change, we want to revisit them to legalize them again.
105109
// We'll consider them the same as created.
106-
LLVM_DEBUG(dbgs() << ".. .. Changed MI: " << MI;);
110+
LLVM_DEBUG(dbgs() << ".. .. Changed MI: " << MI);
107111
createdInstr(MI);
108112
}
109113
};

llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -711,6 +711,7 @@ LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
711711
}
712712
auto &TII = *MI.getMF()->getSubtarget().getInstrInfo();
713713
// Make the original instruction a trunc now, and update its source.
714+
Observer.changingInstr(MI);
714715
MI.setDesc(TII.get(TargetOpcode::G_TRUNC));
715716
MI.getOperand(1).setReg(MIBNewOp->getOperand(0).getReg());
716717
Observer.changedInstr(MI);
@@ -726,13 +727,15 @@ LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
726727
// Perform operation at larger width (any extension is fine here, high bits
727728
// don't affect the result) and then truncate the result back to the
728729
// original type.
730+
Observer.changingInstr(MI);
729731
widenScalarSrc(MI, WideTy, 1, TargetOpcode::G_ANYEXT);
730732
widenScalarSrc(MI, WideTy, 2, TargetOpcode::G_ANYEXT);
731733
widenScalarDst(MI, WideTy);
732734
Observer.changedInstr(MI);
733735
return Legalized;
734736

735737
case TargetOpcode::G_SHL:
738+
Observer.changingInstr(MI);
736739
widenScalarSrc(MI, WideTy, 1, TargetOpcode::G_ANYEXT);
737740
// The "number of bits to shift" operand must preserve its value as an
738741
// unsigned integer:
@@ -743,13 +746,15 @@ LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
743746

744747
case TargetOpcode::G_SDIV:
745748
case TargetOpcode::G_SREM:
749+
Observer.changingInstr(MI);
746750
widenScalarSrc(MI, WideTy, 1, TargetOpcode::G_SEXT);
747751
widenScalarSrc(MI, WideTy, 2, TargetOpcode::G_SEXT);
748752
widenScalarDst(MI, WideTy);
749753
Observer.changedInstr(MI);
750754
return Legalized;
751755

752756
case TargetOpcode::G_ASHR:
757+
Observer.changingInstr(MI);
753758
widenScalarSrc(MI, WideTy, 1, TargetOpcode::G_SEXT);
754759
// The "number of bits to shift" operand must preserve its value as an
755760
// unsigned integer:
@@ -761,6 +766,7 @@ LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
761766
case TargetOpcode::G_UDIV:
762767
case TargetOpcode::G_UREM:
763768
case TargetOpcode::G_LSHR:
769+
Observer.changingInstr(MI);
764770
widenScalarSrc(MI, WideTy, 1, TargetOpcode::G_ZEXT);
765771
widenScalarSrc(MI, WideTy, 2, TargetOpcode::G_ZEXT);
766772
widenScalarDst(MI, WideTy);
@@ -773,6 +779,7 @@ LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
773779
// Perform operation at larger width (any extension is fine here, high bits
774780
// don't affect the result) and then truncate the result back to the
775781
// original type.
782+
Observer.changingInstr(MI);
776783
widenScalarSrc(MI, WideTy, 2, TargetOpcode::G_ANYEXT);
777784
widenScalarSrc(MI, WideTy, 3, TargetOpcode::G_ANYEXT);
778785
widenScalarDst(MI, WideTy);
@@ -783,27 +790,31 @@ LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
783790
case TargetOpcode::G_FPTOUI:
784791
if (TypeIdx != 0)
785792
return UnableToLegalize;
793+
Observer.changingInstr(MI);
786794
widenScalarDst(MI, WideTy);
787795
Observer.changedInstr(MI);
788796
return Legalized;
789797

790798
case TargetOpcode::G_SITOFP:
791799
if (TypeIdx != 1)
792800
return UnableToLegalize;
801+
Observer.changingInstr(MI);
793802
widenScalarSrc(MI, WideTy, 1, TargetOpcode::G_SEXT);
794803
Observer.changedInstr(MI);
795804
return Legalized;
796805

797806
case TargetOpcode::G_UITOFP:
798807
if (TypeIdx != 1)
799808
return UnableToLegalize;
809+
Observer.changingInstr(MI);
800810
widenScalarSrc(MI, WideTy, 1, TargetOpcode::G_ZEXT);
801811
Observer.changedInstr(MI);
802812
return Legalized;
803813

804814
case TargetOpcode::G_INSERT:
805815
if (TypeIdx != 0)
806816
return UnableToLegalize;
817+
Observer.changingInstr(MI);
807818
widenScalarSrc(MI, WideTy, 1, TargetOpcode::G_ANYEXT);
808819
widenScalarDst(MI, WideTy);
809820
Observer.changedInstr(MI);
@@ -819,6 +830,7 @@ LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
819830
LLVM_FALLTHROUGH;
820831
case TargetOpcode::G_SEXTLOAD:
821832
case TargetOpcode::G_ZEXTLOAD:
833+
Observer.changingInstr(MI);
822834
widenScalarDst(MI, WideTy);
823835
Observer.changedInstr(MI);
824836
return Legalized;
@@ -828,6 +840,7 @@ LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
828840
WideTy != LLT::scalar(8))
829841
return UnableToLegalize;
830842

843+
Observer.changingInstr(MI);
831844
widenScalarSrc(MI, WideTy, 0, TargetOpcode::G_ZEXT);
832845
Observer.changedInstr(MI);
833846
return Legalized;
@@ -836,6 +849,7 @@ LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
836849
MachineOperand &SrcMO = MI.getOperand(1);
837850
LLVMContext &Ctx = MIRBuilder.getMF().getFunction().getContext();
838851
const APInt &Val = SrcMO.getCImm()->getValue().sext(WideTy.getSizeInBits());
852+
Observer.changingInstr(MI);
839853
SrcMO.setCImm(ConstantInt::get(Ctx, Val));
840854

841855
widenScalarDst(MI, WideTy);
@@ -857,18 +871,21 @@ LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
857871
default:
858872
llvm_unreachable("Unhandled fp widen type");
859873
}
874+
Observer.changingInstr(MI);
860875
SrcMO.setFPImm(ConstantFP::get(Ctx, Val));
861876

862877
widenScalarDst(MI, WideTy, 0, TargetOpcode::G_FPTRUNC);
863878
Observer.changedInstr(MI);
864879
return Legalized;
865880
}
866881
case TargetOpcode::G_BRCOND:
882+
Observer.changingInstr(MI);
867883
widenScalarSrc(MI, WideTy, 0, TargetOpcode::G_ANYEXT);
868884
Observer.changedInstr(MI);
869885
return Legalized;
870886

871887
case TargetOpcode::G_FCMP:
888+
Observer.changingInstr(MI);
872889
if (TypeIdx == 0)
873890
widenScalarDst(MI, WideTy);
874891
else {
@@ -879,6 +896,7 @@ LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
879896
return Legalized;
880897

881898
case TargetOpcode::G_ICMP:
899+
Observer.changingInstr(MI);
882900
if (TypeIdx == 0)
883901
widenScalarDst(MI, WideTy);
884902
else {
@@ -894,13 +912,15 @@ LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
894912

895913
case TargetOpcode::G_GEP:
896914
assert(TypeIdx == 1 && "unable to legalize pointer of GEP");
915+
Observer.changingInstr(MI);
897916
widenScalarSrc(MI, WideTy, 2, TargetOpcode::G_SEXT);
898917
Observer.changedInstr(MI);
899918
return Legalized;
900919

901920
case TargetOpcode::G_PHI: {
902921
assert(TypeIdx == 0 && "Expecting only Idx 0");
903922

923+
Observer.changingInstr(MI);
904924
for (unsigned I = 1; I < MI.getNumOperands(); I += 2) {
905925
MachineBasicBlock &OpMBB = *MI.getOperand(I + 1).getMBB();
906926
MIRBuilder.setInsertPt(OpMBB, OpMBB.getFirstTerminator());
@@ -916,6 +936,7 @@ LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
916936
case TargetOpcode::G_EXTRACT_VECTOR_ELT:
917937
if (TypeIdx != 2)
918938
return UnableToLegalize;
939+
Observer.changingInstr(MI);
919940
widenScalarSrc(MI, WideTy, 2, TargetOpcode::G_SEXT);
920941
Observer.changedInstr(MI);
921942
return Legalized;
@@ -1152,6 +1173,7 @@ LegalizerHelper::lowerBitCount(MachineInstr &MI, unsigned TypeIdx, LLT Ty) {
11521173
return UnableToLegalize;
11531174
case TargetOpcode::G_CTLZ_ZERO_UNDEF: {
11541175
// This trivially expands to CTLZ.
1176+
Observer.changingInstr(MI);
11551177
MI.setDesc(TII.get(TargetOpcode::G_CTLZ));
11561178
Observer.changedInstr(MI);
11571179
return Legalized;
@@ -1201,6 +1223,7 @@ LegalizerHelper::lowerBitCount(MachineInstr &MI, unsigned TypeIdx, LLT Ty) {
12011223
}
12021224
case TargetOpcode::G_CTTZ_ZERO_UNDEF: {
12031225
// This trivially expands to CTTZ.
1226+
Observer.changingInstr(MI);
12041227
MI.setDesc(TII.get(TargetOpcode::G_CTTZ));
12051228
Observer.changedInstr(MI);
12061229
return Legalized;

llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ namespace {
1313

1414
class DummyGISelObserver : public GISelChangeObserver {
1515
public:
16+
void changingInstr(MachineInstr &MI) override {}
1617
void changedInstr(MachineInstr &MI) override {}
1718
void createdInstr(MachineInstr &MI) override {}
1819
void erasingInstr(MachineInstr &MI) override {}

0 commit comments

Comments
 (0)