reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

lib/Target/Hexagon/BitTracker.cpp
   73 using BT = BitTracker;

References

lib/Target/Hexagon/BitTracker.cpp
   97   raw_ostream &operator<<(raw_ostream &OS, const BT::BitValue &BV) {
   99       case BT::BitValue::Top:
  102       case BT::BitValue::Zero:
  105       case BT::BitValue::One:
  108       case BT::BitValue::Ref:
  115   raw_ostream &operator<<(raw_ostream &OS, const BT::RegisterCell &RC) {
  127       const BT::BitValue &V = RC[i];
  128       const BT::BitValue &SV = RC[Start];
  129       bool IsRef = (V.Type == BT::BitValue::Ref);
  133       if (IsRef && SV.Type == BT::BitValue::Ref && V.RefI.Reg == SV.RefI.Reg) {
  152         if (SV.Type == BT::BitValue::Ref && SeqRef)
  168       const BT::BitValue &SV = RC[Start];
  169       if (SV.Type == BT::BitValue::Ref && SeqRef)
  214 BT::RegisterCell &BT::RegisterCell::insert(const BT::RegisterCell &RC,
  214 BT::RegisterCell &BT::RegisterCell::insert(const BT::RegisterCell &RC,
  235 BT::RegisterCell BT::RegisterCell::extract(const BitMask &M) const {
  253 BT::RegisterCell &BT::RegisterCell::rol(uint16_t Sh) {
  274 BT::RegisterCell &BT::RegisterCell::fill(uint16_t B, uint16_t E,
  282 BT::RegisterCell &BT::RegisterCell::cat(const RegisterCell &RC) {
  320 BT::RegisterCell &BT::RegisterCell::regify(unsigned R) {
  348 BT::RegisterCell BT::MachineEvaluator::getCell(const RegisterRef &RR,
  412 BT::RegisterCell BT::MachineEvaluator::eIMM(int64_t V, uint16_t W) const {
  422 BT::RegisterCell BT::MachineEvaluator::eIMM(const ConstantInt *CI) const {
  432 BT::RegisterCell BT::MachineEvaluator::eADD(const RegisterCell &A1,
  465 BT::RegisterCell BT::MachineEvaluator::eSUB(const RegisterCell &A1,
  498 BT::RegisterCell BT::MachineEvaluator::eMLS(const RegisterCell &A1,
  508 BT::RegisterCell BT::MachineEvaluator::eMLU(const RegisterCell &A1,
  518 BT::RegisterCell BT::MachineEvaluator::eASL(const RegisterCell &A1,
  527 BT::RegisterCell BT::MachineEvaluator::eLSR(const RegisterCell &A1,
  537 BT::RegisterCell BT::MachineEvaluator::eASR(const RegisterCell &A1,
  548 BT::RegisterCell BT::MachineEvaluator::eAND(const RegisterCell &A1,
  570 BT::RegisterCell BT::MachineEvaluator::eORL(const RegisterCell &A1,
  592 BT::RegisterCell BT::MachineEvaluator::eXOR(const RegisterCell &A1,
  612 BT::RegisterCell BT::MachineEvaluator::eNOT(const RegisterCell &A1) const {
  627 BT::RegisterCell BT::MachineEvaluator::eSET(const RegisterCell &A1,
  635 BT::RegisterCell BT::MachineEvaluator::eCLR(const RegisterCell &A1,
  643 BT::RegisterCell BT::MachineEvaluator::eCLB(const RegisterCell &A1, bool B,
  653 BT::RegisterCell BT::MachineEvaluator::eCTB(const RegisterCell &A1, bool B,
  663 BT::RegisterCell BT::MachineEvaluator::eSXT(const RegisterCell &A1,
  674 BT::RegisterCell BT::MachineEvaluator::eZXT(const RegisterCell &A1,
  683 BT::RegisterCell BT::MachineEvaluator::eXTR(const RegisterCell &A1,
  695 BT::RegisterCell BT::MachineEvaluator::eINS(const RegisterCell &A1,
  707 BT::BitMask BT::MachineEvaluator::mask(unsigned Reg, unsigned Sub) const {
  989 BT::RegisterCell BT::get(RegisterRef RR) const {
lib/Target/Hexagon/HexagonBitTracker.cpp
   89 BT::BitMask HexagonEvaluator::mask(unsigned Reg, unsigned Sub) const {
  163   std::vector<BT::RegisterRef> Vector;
  178   const BT::RegisterRef &operator[](unsigned n) const {
  327       return rr0(RegisterCell(W0).fill(0, W0, BT::BitValue::Zero), Outputs);
  329       return rr0(RegisterCell(W0).fill(0, W0, BT::BitValue::One), Outputs);
  336       RC.fill(0, L, BT::BitValue::Zero);
  352       RC.fill(PW, RW, BT::BitValue::Zero);
  359       RC.fill(PW, RW, BT::BitValue::Zero);
  441       RPC.fill(0, 2, BT::BitValue::Zero);
  682       RC[im(2)] = BT::BitValue::Zero;
  687       RC[im(2)] = BT::BitValue::One;
  693       RC[BX] = RC[BX].is(0) ? BT::BitValue::One
  694                             : RC[BX].is(1) ? BT::BitValue::Zero
  695                                            : BT::BitValue::self();
  703       const BT::BitValue Zero = BT::BitValue::Zero;
  703       const BT::BitValue Zero = BT::BitValue::Zero;
  797         const BT::BitValue &V = R1[i];
  798         BT::BitValue F = (V.is(0) || V.is(1)) ? V : BT::BitValue::self();
  798         BT::BitValue F = (V.is(0) || V.is(1)) ? V : BT::BitValue::self();
  810       BT::BitValue PC0 = rc(1)[0];
  863       BT::BitValue TV = R1[W1-1];
  892       RC.fill(0, W0, (All1 ? BT::BitValue::One : BT::BitValue::Zero));
  892       RC.fill(0, W0, (All1 ? BT::BitValue::One : BT::BitValue::Zero));
  909       RC.fill(0, W0, (Has1 ? BT::BitValue::One : BT::BitValue::Zero));
  909       RC.fill(0, W0, (Has1 ? BT::BitValue::One : BT::BitValue::Zero));
  950       BT::BitValue V = rc(1)[im(2)];
  954         BT::BitValue F = V.is(TV) ? BT::BitValue::One : BT::BitValue::Zero;
  954         BT::BitValue F = V.is(TV) ? BT::BitValue::One : BT::BitValue::Zero;
  954         BT::BitValue F = V.is(TV) ? BT::BitValue::One : BT::BitValue::Zero;
  965           BT::RegisterRef PD(DefR, 0);
  969           RC.fill(PW, RW, BT::BitValue::Zero);
 1022   const BT::BitValue &Test = PC[0];
 1198     Res[i] = BT::BitValue::self(BT::BitRef(RD.Reg, i));
 1201     const BT::BitValue &Sign = Res[BitNum-1];
 1203       Res[i] = BT::BitValue::ref(Sign);
 1206       Res[i] = BT::BitValue::Zero;