contrib/llvm/lib/Target/Hexagon/RDFRegisters.h

   1 //===--- RDFRegisters.h -----------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLVM_LIB_TARGET_HEXAGON_RDFREGISTERS_H
  11 #define LLVM_LIB_TARGET_HEXAGON_RDFREGISTERS_H
  12
  13 #include "llvm/ADT/BitVector.h"
  14 #include "llvm/Target/TargetRegisterInfo.h"
  15
  16 #include <set>
  17 #include <unordered_map>
  18 #include <vector>
  19
  20 namespace llvm {
  21 namespace rdf {
  22
  23   typedef uint32_t RegisterId;
  24
  25   // Template class for a map translating uint32_t into arbitrary types.
  26   // The map will act like an indexed set: upon insertion of a new object,
  27   // it will automatically assign a new index to it. Index of 0 is treated
  28   // as invalid and is never allocated.
  29   template <typename T, unsigned N = 32>
  30   struct IndexedSet {
  31     IndexedSet() : Map() { Map.reserve(N); }
  32
  33     T get(uint32_t Idx) const {
  34       // Index Idx corresponds to Map[Idx-1].
  35       assert(Idx != 0 && !Map.empty() && Idx-1 < Map.size());
  36       return Map[Idx-1];
  37     }
  38
  39     uint32_t insert(T Val) {
  40       // Linear search.
  41       auto F = llvm::find(Map, Val);
  42       if (F != Map.end())
  43         return F - Map.begin() + 1;
  44       Map.push_back(Val);
  45       return Map.size();  // Return actual_index + 1.
  46     }
  47
  48     uint32_t find(T Val) const {
  49       auto F = llvm::find(Map, Val);
  50       assert(F != Map.end());
  51       return F - Map.begin() + 1;
  52     }
  53
  54     uint32_t size() const { return Map.size(); }
  55
  56     typedef typename std::vector<T>::const_iterator const_iterator;
  57     const_iterator begin() const { return Map.begin(); }
  58     const_iterator end() const { return Map.end(); }
  59
  60   private:
  61     std::vector<T> Map;
  62   };
  63
  64   struct RegisterRef {
  65     RegisterId Reg = 0;
  66     LaneBitmask Mask = LaneBitmask::getNone();
  67
  68     RegisterRef() = default;
  69     explicit RegisterRef(RegisterId R, LaneBitmask M = LaneBitmask::getAll())
  70       : Reg(R), Mask(R != 0 ? M : LaneBitmask::getNone()) {}
  71
  72     operator bool() const {
  73       return Reg != 0 && Mask.any();
  74     }
  75     bool operator== (const RegisterRef &RR) const {
  76       return Reg == RR.Reg && Mask == RR.Mask;
  77     }
  78     bool operator!= (const RegisterRef &RR) const {
  79       return !operator==(RR);
  80     }
  81     bool operator< (const RegisterRef &RR) const {
  82       return Reg < RR.Reg || (Reg == RR.Reg && Mask < RR.Mask);
  83     }
  84   };
  85
  86
  87   struct PhysicalRegisterInfo {
  88     PhysicalRegisterInfo(const TargetRegisterInfo &tri,
  89                          const MachineFunction &mf);
  90
  91     static bool isRegMaskId(RegisterId R) {
  92       return TargetRegisterInfo::isStackSlot(R);
  93     }
  94     RegisterId getRegMaskId(const uint32_t *RM) const {
  95       return TargetRegisterInfo::index2StackSlot(RegMasks.find(RM));
  96     }
  97     const uint32_t *getRegMaskBits(RegisterId R) const {
  98       return RegMasks.get(TargetRegisterInfo::stackSlot2Index(R));
  99     }
 100     RegisterRef normalize(RegisterRef RR) const;
 101
 102     bool alias(RegisterRef RA, RegisterRef RB) const {
 103       if (!isRegMaskId(RA.Reg))
 104         return !isRegMaskId(RB.Reg) ? aliasRR(RA, RB) : aliasRM(RA, RB);
 105       return !isRegMaskId(RB.Reg) ? aliasRM(RB, RA) : aliasMM(RA, RB);
 106     }
 107     std::set<RegisterId> getAliasSet(RegisterId Reg) const;
 108
 109     RegisterRef getRefForUnit(uint32_t U) const {
 110       return RegisterRef(UnitInfos[U].Reg, UnitInfos[U].Mask);
 111     }
 112     const BitVector &getMaskUnits(RegisterId MaskId) const {
 113       return MaskInfos[TargetRegisterInfo::stackSlot2Index(MaskId)].Units;
 114     }
 115     RegisterRef mapTo(RegisterRef RR, unsigned R) const;
 116
 117     const TargetRegisterInfo &getTRI() const { return TRI; }
 118
 119   private:
 120     struct RegInfo {
 121       const TargetRegisterClass *RegClass = nullptr;
 122     };
 123     struct UnitInfo {
 124       RegisterId Reg = 0;
 125       LaneBitmask Mask;
 126     };
 127     struct MaskInfo {
 128       BitVector Units;
 129     };
 130
 131     const TargetRegisterInfo &TRI;
 132     IndexedSet<const uint32_t*> RegMasks;
 133     std::vector<RegInfo> RegInfos;
 134     std::vector<UnitInfo> UnitInfos;
 135     std::vector<MaskInfo> MaskInfos;
 136
 137     bool aliasRR(RegisterRef RA, RegisterRef RB) const;
 138     bool aliasRM(RegisterRef RR, RegisterRef RM) const;
 139     bool aliasMM(RegisterRef RM, RegisterRef RN) const;
 140   };
 141
 142
 143   struct RegisterAggr {
 144     RegisterAggr(const PhysicalRegisterInfo &pri)
 145         : Units(pri.getTRI().getNumRegUnits()), PRI(pri) {}
 146     RegisterAggr(const RegisterAggr &RG) = default;
 147
 148     bool empty() const { return Units.none(); }
 149     bool hasAliasOf(RegisterRef RR) const;
 150     bool hasCoverOf(RegisterRef RR) const;
 151     static bool isCoverOf(RegisterRef RA, RegisterRef RB,
 152                           const PhysicalRegisterInfo &PRI) {
 153       return RegisterAggr(PRI).insert(RA).hasCoverOf(RB);
 154     }
 155
 156     RegisterAggr &insert(RegisterRef RR);
 157     RegisterAggr &insert(const RegisterAggr &RG);
 158     RegisterAggr &intersect(RegisterRef RR);
 159     RegisterAggr &intersect(const RegisterAggr &RG);
 160     RegisterAggr &clear(RegisterRef RR);
 161     RegisterAggr &clear(const RegisterAggr &RG);
 162
 163     RegisterRef intersectWith(RegisterRef RR) const;
 164     RegisterRef clearIn(RegisterRef RR) const;
 165     RegisterRef makeRegRef() const;
 166
 167     void print(raw_ostream &OS) const;
 168
 169     struct rr_iterator {
 170       typedef std::map<RegisterId,LaneBitmask> MapType;
 171     private:
 172       MapType Masks;
 173       MapType::iterator Pos;
 174       unsigned Index;
 175       const RegisterAggr *Owner;
 176     public:
 177       rr_iterator(const RegisterAggr &RG, bool End);
 178       RegisterRef operator*() const {
 179         return RegisterRef(Pos->first, Pos->second);
 180       }
 181       rr_iterator &operator++() {
 182         ++Pos;
 183         ++Index;
 184         return *this;
 185       }
 186       bool operator==(const rr_iterator &I) const {
 187         assert(Owner == I.Owner);
 188         return Index == I.Index;
 189       }
 190       bool operator!=(const rr_iterator &I) const {
 191         return !(*this == I);
 192       }
 193     };
 194
 195     rr_iterator rr_begin() const {
 196       return rr_iterator(*this, false);
 197     }
 198     rr_iterator rr_end() const {
 199       return rr_iterator(*this, true);
 200     }
 201
 202   private:
 203     BitVector Units;
 204     const PhysicalRegisterInfo &PRI;
 205   };
 206
 207
 208   // Optionally print the lane mask, if it is not ~0.
 209   struct PrintLaneMaskOpt {
 210     PrintLaneMaskOpt(LaneBitmask M) : Mask(M) {}
 211     LaneBitmask Mask;
 212   };
 213   raw_ostream &operator<< (raw_ostream &OS, const PrintLaneMaskOpt &P);
 214
 215 } // namespace rdf
 216 } // namespace llvm
 217
 218 #endif
 219