Lines Matching refs:BitTracker
9 #include "BitTracker.h"
231 static bool isEqual(const BitTracker::RegisterCell &RC1, uint16_t B1,
232 const BitTracker::RegisterCell &RC2, uint16_t B2, uint16_t W);
233 static bool isZero(const BitTracker::RegisterCell &RC, uint16_t B,
235 static bool getConst(const BitTracker::RegisterCell &RC, uint16_t B,
239 static bool getSubregMask(const BitTracker::RegisterRef &RR,
246 BitTracker::RegisterRef &SL, BitTracker::RegisterRef &SH,
255 const BitTracker::RegisterRef &RR, MachineRegisterInfo &MRI);
256 static bool isTransparentCopy(const BitTracker::RegisterRef &RD,
257 const BitTracker::RegisterRef &RS, MachineRegisterInfo &MRI);
342 bool HexagonBitSimplify::isEqual(const BitTracker::RegisterCell &RC1,
343 uint16_t B1, const BitTracker::RegisterCell &RC2, uint16_t B2,
347 if (RC1[B1+i].Type == BitTracker::BitValue::Ref && RC1[B1+i].RefI.Reg == 0)
350 if (RC2[B2+i].Type == BitTracker::BitValue::Ref && RC2[B2+i].RefI.Reg == 0)
358 bool HexagonBitSimplify::isZero(const BitTracker::RegisterCell &RC,
367 bool HexagonBitSimplify::getConst(const BitTracker::RegisterCell &RC,
372 const BitTracker::BitValue &BV = RC[i-1];
435 bool HexagonBitSimplify::getSubregMask(const BitTracker::RegisterRef &RR,
463 BitTracker::RegisterRef &SL, BitTracker::RegisterRef &SH,
926 const BitTracker::RegisterRef &RR, MachineRegisterInfo &MRI) {
956 bool HexagonBitSimplify::isTransparentCopy(const BitTracker::RegisterRef &RD,
957 const BitTracker::RegisterRef &RS, MachineRegisterInfo &MRI) {
1081 RedundantInstrElimination(BitTracker &bt, const HexagonInstrInfo &hii,
1095 bool usedBitsEqual(BitTracker::RegisterRef RD, BitTracker::RegisterRef RS);
1100 BitTracker &BT;
1244 BitTracker::RegisterRef UR = *I;
1289 BitTracker::RegisterRef RR = MI.getOperand(OpN);
1306 bool RedundantInstrElimination::usedBitsEqual(BitTracker::RegisterRef RD,
1307 BitTracker::RegisterRef RS) {
1308 const BitTracker::RegisterCell &DC = BT.lookup(RD.Reg);
1309 const BitTracker::RegisterCell &SC = BT.lookup(RS.Reg);
1347 BitTracker::RegisterRef RD = MI->getOperand(0);
1350 const BitTracker::RegisterCell &DC = BT.lookup(RD.Reg);
1357 BitTracker::RegisterRef RS = Op;
1367 const BitTracker::RegisterCell &SC = BT.lookup(RS.Reg);
1403 ConstGeneration(BitTracker &bt, const HexagonInstrInfo &hii,
1417 BitTracker &BT;
1511 const BitTracker::RegisterCell &DRC = BT.lookup(DR);
1534 CopyGeneration(BitTracker &bt, const HexagonInstrInfo &hii,
1541 bool findMatch(const BitTracker::RegisterRef &Inp,
1542 BitTracker::RegisterRef &Out, const RegisterSet &AVs);
1547 BitTracker &BT;
1573 bool CopyGeneration::findMatch(const BitTracker::RegisterRef &Inp,
1574 BitTracker::RegisterRef &Out, const RegisterSet &AVs) {
1577 const BitTracker::RegisterCell &InpRC = BT.lookup(Inp.Reg);
1586 const BitTracker::RegisterCell &RC = BT.lookup(R);
1641 BitTracker::RegisterRef MR;
1648 BT.put(BitTracker::RegisterRef(NewR), BT.get(MR));
1659 BitTracker::RegisterRef TL = { R, SubLo };
1660 BitTracker::RegisterRef TH = { R, SubHi };
1661 BitTracker::RegisterRef ML, MH;
1670 BT.put(BitTracker::RegisterRef(NewR), BT.get(R));
1702 BitTracker::RegisterRef RD = MI.getOperand(0);
1709 BitTracker::RegisterRef RS = MI.getOperand(1);
1719 BitTracker::RegisterRef SL, SH;
1734 BitTracker::RegisterRef RH = MI.getOperand(1), RL = MI.getOperand(2);
1744 BitTracker::RegisterRef RS = MI.getOperand(SrcX);
1775 BitSimplification(BitTracker &bt, const MachineDominatorTree &mdt,
1784 struct RegHalf : public BitTracker::RegisterRef {
1788 bool matchHalf(unsigned SelfR, const BitTracker::RegisterCell &RC,
1790 bool validateReg(BitTracker::RegisterRef R, unsigned Opc, unsigned OpNum);
1792 bool matchPackhl(unsigned SelfR, const BitTracker::RegisterCell &RC,
1793 BitTracker::RegisterRef &Rs, BitTracker::RegisterRef &Rt);
1798 bool genPackhl(MachineInstr *MI, BitTracker::RegisterRef RD,
1799 const BitTracker::RegisterCell &RC);
1800 bool genExtractHalf(MachineInstr *MI, BitTracker::RegisterRef RD,
1801 const BitTracker::RegisterCell &RC);
1802 bool genCombineHalf(MachineInstr *MI, BitTracker::RegisterRef RD,
1803 const BitTracker::RegisterCell &RC);
1804 bool genExtractLow(MachineInstr *MI, BitTracker::RegisterRef RD,
1805 const BitTracker::RegisterCell &RC);
1806 bool genBitSplit(MachineInstr *MI, BitTracker::RegisterRef RD,
1807 const BitTracker::RegisterCell &RC, const RegisterSet &AVs);
1808 bool simplifyTstbit(MachineInstr *MI, BitTracker::RegisterRef RD,
1809 const BitTracker::RegisterCell &RC);
1810 bool simplifyExtractLow(MachineInstr *MI, BitTracker::RegisterRef RD,
1811 const BitTracker::RegisterCell &RC, const RegisterSet &AVs);
1812 bool simplifyRCmp0(MachineInstr *MI, BitTracker::RegisterRef RD);
1823 BitTracker &BT;
1832 const BitTracker::RegisterCell &RC, unsigned B, RegHalf &RH) {
1860 const BitTracker::RegisterCell &SC = BT.lookup(Reg);
1865 const BitTracker::BitValue &RV = RC[i+B];
1866 if (RV.Type == BitTracker::BitValue::Ref) {
1909 bool BitSimplification::validateReg(BitTracker::RegisterRef R, unsigned Opc,
1919 const BitTracker::RegisterCell &RC, BitTracker::RegisterRef &Rs,
1920 BitTracker::RegisterRef &Rt) {
1955 BitTracker::RegisterRef RS = ValOp;
1958 const BitTracker::RegisterCell &RC = BT.lookup(RS.Reg);
2001 BitTracker::RegisterRef RS = MI->getOperand(2);
2004 const BitTracker::RegisterCell &RC = BT.lookup(RS.Reg);
2050 BitTracker::RegisterRef RD, const BitTracker::RegisterCell &RC) {
2054 BitTracker::RegisterRef Rs, Rt;
2070 BT.put(BitTracker::RegisterRef(NewR), RC);
2077 BitTracker::RegisterRef RD, const BitTracker::RegisterCell &RC) {
2109 BT.put(BitTracker::RegisterRef(NewR), RC);
2116 BitTracker::RegisterRef RD, const BitTracker::RegisterCell &RC) {
2141 BT.put(BitTracker::RegisterRef(NewR), RC);
2148 BitTracker::RegisterRef RD, const BitTracker::RegisterCell &RC) {
2179 BitTracker::RegisterRef RS = Op;
2182 const BitTracker::RegisterCell &SC = BT.lookup(RS.Reg);
2201 BT.put(BitTracker::RegisterRef(NewR), RC);
2208 BitTracker::RegisterRef RD, const BitTracker::RegisterCell &RC,
2228 auto ctlz = [] (const BitTracker::RegisterCell &C) -> unsigned {
2242 const BitTracker::BitValue &B0 = RC[0];
2243 if (B0.Type != BitTracker::BitValue::Ref)
2252 const BitTracker::BitValue &V = RC[i];
2253 if (V.Type != BitTracker::BitValue::Ref)
2269 const BitTracker::RegisterCell &SC = BT.lookup(S);
2273 const BitTracker::BitValue &S0 = SC[0];
2274 if (S0.Type != BitTracker::BitValue::Ref || S0.RefI.Reg != SrcR)
2288 const BitTracker::BitValue &V = SC[I];
2289 if (V.Type != BitTracker::BitValue::Ref)
2361 BitTracker::RegisterRef RD, const BitTracker::RegisterCell &RC) {
2367 BitTracker::RegisterRef RS = MI->getOperand(1);
2376 const BitTracker::RegisterCell &SC = BT.lookup(RS.Reg);
2377 const BitTracker::BitValue &V = SC[F+BN];
2378 if (V.Type == BitTracker::BitValue::Ref && V.RefI.Reg != RS.Reg) {
2384 BitTracker::RegisterRef RR(V.RefI.Reg, 0);
2421 BitTracker::RegisterRef RD, const BitTracker::RegisterCell &RC,
2454 const BitTracker::BitValue &TopV = RC[W-1];
2461 const BitTracker::BitValue &V = RC[I];
2462 if (V.Type == BitTracker::BitValue::Ref && V.RefI.Reg == RD.Reg)
2480 assert(TopV.Type == BitTracker::BitValue::Ref);
2508 const BitTracker::RegisterCell &SC = BT.lookup(R);
2604 BT.put(BitTracker::RegisterRef(NewR), RC);
2613 BitTracker::RegisterRef RD) {
2633 BitTracker::RegisterRef SR = MI->getOperand(1);
2636 const BitTracker::RegisterCell &SC = BT.lookup(SR.Reg);
2642 const BitTracker::BitValue &V = SC[I];
2654 BitTracker::RegisterCell NewRC(W);
2656 NewRC[I] = BitTracker::BitValue(C & 1);
2659 BT.put(BitTracker::RegisterRef(NewR), NewRC);
2722 BitTracker::RegisterCell NewRC(W);
2723 NewRC[0] = BitTracker::BitValue::self();
2724 NewRC.fill(1, W, BitTracker::BitValue::Zero);
2725 BT.put(BitTracker::RegisterRef(NewR), NewRC);
2762 BitTracker::RegisterRef RD = Op0;
2766 const BitTracker::RegisterCell &RC = BT.lookup(RD.Reg);
2810 BitTracker BT(HE, MF);
2939 BitTracker *BTP = nullptr;
2949 BitTracker::RegisterRef Inp, Out;
2956 BitTracker::RegisterRef LR, PR; // Loop Register, Preheader Register
3006 const BitTracker::RegisterCell &RC = BTP->lookup(Reg);
3008 const BitTracker::BitValue &V = RC[i];
3060 const BitTracker::RegisterCell &OutC = BTP->lookup(OutR);
3062 const BitTracker::BitValue &V = OutC[i];
3063 if (V.Type != BitTracker::BitValue::Ref)
3075 const BitTracker::RegisterCell &OutC1 = BTP->lookup(OutR1);
3076 const BitTracker::RegisterCell &OutC2 = BTP->lookup(OutR2);
3082 const BitTracker::BitValue &V1 = OutC1[i], &V2 = OutC2[i];
3083 if (V1.Type != V2.Type || V1.Type == BitTracker::BitValue::One)
3085 if (V1.Type != BitTracker::BitValue::Ref)
3351 BitTracker BT(HE, MF);