contrib/llvm/utils/TableGen/InfoByHwMode.cpp

   1 //===--- InfoByHwMode.cpp -------------------------------------------------===//
   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 // Classes that implement data parameterized by HW modes for instruction
  10 // selection. Currently it is ValueTypeByHwMode (parameterized ValueType),
  11 // and RegSizeInfoByHwMode (parameterized register/spill size and alignment
  12 // data).
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "CodeGenTarget.h"
  16 #include "InfoByHwMode.h"
  17 #include "llvm/ADT/STLExtras.h"
  18 #include "llvm/ADT/Twine.h"
  19 #include "llvm/Support/Debug.h"
  20 #include "llvm/Support/raw_ostream.h"
  21
  22 #include <set>
  23 #include <string>
  24
  25 using namespace llvm;
  26
  27 std::string llvm::getModeName(unsigned Mode) {
  28   if (Mode == DefaultMode)
  29     return "*";
  30   return (Twine('m') + Twine(Mode)).str();
  31 }
  32
  33 ValueTypeByHwMode::ValueTypeByHwMode(Record *R, const CodeGenHwModes &CGH) {
  34   const HwModeSelect &MS = CGH.getHwModeSelect(R);
  35   for (const HwModeSelect::PairType &P : MS.Items) {
  36     auto I = Map.insert({P.first, MVT(llvm::getValueType(P.second))});
  37     assert(I.second && "Duplicate entry?");
  38     (void)I;
  39   }
  40 }
  41
  42 bool ValueTypeByHwMode::operator== (const ValueTypeByHwMode &T) const {
  43   assert(isValid() && T.isValid() && "Invalid type in assignment");
  44   bool Simple = isSimple();
  45   if (Simple != T.isSimple())
  46     return false;
  47   if (Simple)
  48     return getSimple() == T.getSimple();
  49
  50   return Map == T.Map;
  51 }
  52
  53 bool ValueTypeByHwMode::operator< (const ValueTypeByHwMode &T) const {
  54   assert(isValid() && T.isValid() && "Invalid type in comparison");
  55   // Default order for maps.
  56   return Map < T.Map;
  57 }
  58
  59 MVT &ValueTypeByHwMode::getOrCreateTypeForMode(unsigned Mode, MVT Type) {
  60   auto F = Map.find(Mode);
  61   if (F != Map.end())
  62     return F->second;
  63   // If Mode is not in the map, look up the default mode. If it exists,
  64   // make a copy of it for Mode and return it.
  65   auto D = Map.find(DefaultMode);
  66   if (D != Map.end())
  67     return Map.insert(std::make_pair(Mode, D->second)).first->second;
  68   // If default mode is not present either, use provided Type.
  69   return Map.insert(std::make_pair(Mode, Type)).first->second;
  70 }
  71
  72 StringRef ValueTypeByHwMode::getMVTName(MVT T) {
  73   StringRef N = llvm::getEnumName(T.SimpleTy);
  74   N.consume_front("MVT::");
  75   return N;
  76 }
  77
  78 void ValueTypeByHwMode::writeToStream(raw_ostream &OS) const {
  79   if (isSimple()) {
  80     OS << getMVTName(getSimple());
  81     return;
  82   }
  83
  84   std::vector<const PairType*> Pairs;
  85   for (const auto &P : Map)
  86     Pairs.push_back(&P);
  87   llvm::sort(Pairs, deref<std::less<PairType>>());
  88
  89   OS << '{';
  90   for (unsigned i = 0, e = Pairs.size(); i != e; ++i) {
  91     const PairType *P = Pairs[i];
  92     OS << '(' << getModeName(P->first)
  93        << ':' << getMVTName(P->second).str() << ')';
  94     if (i != e-1)
  95       OS << ',';
  96   }
  97   OS << '}';
  98 }
  99
 100 LLVM_DUMP_METHOD
 101 void ValueTypeByHwMode::dump() const {
 102   dbgs() << *this << '\n';
 103 }
 104
 105 ValueTypeByHwMode llvm::getValueTypeByHwMode(Record *Rec,
 106                                              const CodeGenHwModes &CGH) {
 107 #ifndef NDEBUG
 108   if (!Rec->isSubClassOf("ValueType"))
 109     Rec->dump();
 110 #endif
 111   assert(Rec->isSubClassOf("ValueType") &&
 112          "Record must be derived from ValueType");
 113   if (Rec->isSubClassOf("HwModeSelect"))
 114     return ValueTypeByHwMode(Rec, CGH);
 115   return ValueTypeByHwMode(llvm::getValueType(Rec));
 116 }
 117
 118 RegSizeInfo::RegSizeInfo(Record *R, const CodeGenHwModes &CGH) {
 119   RegSize = R->getValueAsInt("RegSize");
 120   SpillSize = R->getValueAsInt("SpillSize");
 121   SpillAlignment = R->getValueAsInt("SpillAlignment");
 122 }
 123
 124 bool RegSizeInfo::operator< (const RegSizeInfo &I) const {
 125   return std::tie(RegSize, SpillSize, SpillAlignment) <
 126          std::tie(I.RegSize, I.SpillSize, I.SpillAlignment);
 127 }
 128
 129 bool RegSizeInfo::isSubClassOf(const RegSizeInfo &I) const {
 130   return RegSize <= I.RegSize &&
 131          SpillAlignment && I.SpillAlignment % SpillAlignment == 0 &&
 132          SpillSize <= I.SpillSize;
 133 }
 134
 135 void RegSizeInfo::writeToStream(raw_ostream &OS) const {
 136   OS << "[R=" << RegSize << ",S=" << SpillSize
 137      << ",A=" << SpillAlignment << ']';
 138 }
 139
 140 RegSizeInfoByHwMode::RegSizeInfoByHwMode(Record *R,
 141       const CodeGenHwModes &CGH) {
 142   const HwModeSelect &MS = CGH.getHwModeSelect(R);
 143   for (const HwModeSelect::PairType &P : MS.Items) {
 144     auto I = Map.insert({P.first, RegSizeInfo(P.second, CGH)});
 145     assert(I.second && "Duplicate entry?");
 146     (void)I;
 147   }
 148 }
 149
 150 bool RegSizeInfoByHwMode::operator< (const RegSizeInfoByHwMode &I) const {
 151   unsigned M0 = Map.begin()->first;
 152   return get(M0) < I.get(M0);
 153 }
 154
 155 bool RegSizeInfoByHwMode::operator== (const RegSizeInfoByHwMode &I) const {
 156   unsigned M0 = Map.begin()->first;
 157   return get(M0) == I.get(M0);
 158 }
 159
 160 bool RegSizeInfoByHwMode::isSubClassOf(const RegSizeInfoByHwMode &I) const {
 161   unsigned M0 = Map.begin()->first;
 162   return get(M0).isSubClassOf(I.get(M0));
 163 }
 164
 165 bool RegSizeInfoByHwMode::hasStricterSpillThan(const RegSizeInfoByHwMode &I)
 166       const {
 167   unsigned M0 = Map.begin()->first;
 168   const RegSizeInfo &A0 = get(M0);
 169   const RegSizeInfo &B0 = I.get(M0);
 170   return std::tie(A0.SpillSize, A0.SpillAlignment) >
 171          std::tie(B0.SpillSize, B0.SpillAlignment);
 172 }
 173
 174 void RegSizeInfoByHwMode::writeToStream(raw_ostream &OS) const {
 175   typedef typename decltype(Map)::value_type PairType;
 176   std::vector<const PairType*> Pairs;
 177   for (const auto &P : Map)
 178     Pairs.push_back(&P);
 179   llvm::sort(Pairs, deref<std::less<PairType>>());
 180
 181   OS << '{';
 182   for (unsigned i = 0, e = Pairs.size(); i != e; ++i) {
 183     const PairType *P = Pairs[i];
 184     OS << '(' << getModeName(P->first) << ':' << P->second << ')';
 185     if (i != e-1)
 186       OS << ',';
 187   }
 188   OS << '}';
 189 }
 190
 191 namespace llvm {
 192   raw_ostream &operator<<(raw_ostream &OS, const ValueTypeByHwMode &T) {
 193     T.writeToStream(OS);
 194     return OS;
 195   }
 196
 197   raw_ostream &operator<<(raw_ostream &OS, const RegSizeInfo &T) {
 198     T.writeToStream(OS);
 199     return OS;
 200   }
 201
 202   raw_ostream &operator<<(raw_ostream &OS, const RegSizeInfoByHwMode &T) {
 203     T.writeToStream(OS);
 204     return OS;
 205   }
 206 }