utils/TableGen/CodeGenRegisters.cpp

   1 //===- CodeGenRegisters.cpp - Register and RegisterClass Info -------------===//
   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 // This file defines structures to encapsulate information gleaned from the
  11 // target register and register class definitions.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "CodeGenRegisters.h"
  16 #include "CodeGenTarget.h"
  17 #include "llvm/ADT/StringExtras.h"
  18
  19 using namespace llvm;
  20
  21 //===----------------------------------------------------------------------===//
  22 //                              CodeGenRegister
  23 //===----------------------------------------------------------------------===//
  24
  25 CodeGenRegister::CodeGenRegister(Record *R) : TheDef(R) {
  26   CostPerUse = R->getValueAsInt("CostPerUse");
  27 }
  28
  29 const std::string &CodeGenRegister::getName() const {
  30   return TheDef->getName();
  31 }
  32
  33 //===----------------------------------------------------------------------===//
  34 //                            CodeGenRegisterClass
  35 //===----------------------------------------------------------------------===//
  36
  37 CodeGenRegisterClass::CodeGenRegisterClass(Record *R) : TheDef(R) {
  38   // Rename anonymous register classes.
  39   if (R->getName().size() > 9 && R->getName()[9] == '.') {
  40     static unsigned AnonCounter = 0;
  41     R->setName("AnonRegClass_"+utostr(AnonCounter++));
  42   }
  43
  44   std::vector<Record*> TypeList = R->getValueAsListOfDefs("RegTypes");
  45   for (unsigned i = 0, e = TypeList.size(); i != e; ++i) {
  46     Record *Type = TypeList[i];
  47     if (!Type->isSubClassOf("ValueType"))
  48       throw "RegTypes list member '" + Type->getName() +
  49         "' does not derive from the ValueType class!";
  50     VTs.push_back(getValueType(Type));
  51   }
  52   assert(!VTs.empty() && "RegisterClass must contain at least one ValueType!");
  53
  54   std::vector<Record*> RegList = R->getValueAsListOfDefs("MemberList");
  55   for (unsigned i = 0, e = RegList.size(); i != e; ++i) {
  56     Record *Reg = RegList[i];
  57     if (!Reg->isSubClassOf("Register"))
  58       throw "Register Class member '" + Reg->getName() +
  59             "' does not derive from the Register class!";
  60     Elements.push_back(Reg);
  61   }
  62
  63   // SubRegClasses is a list<dag> containing (RC, subregindex, ...) dags.
  64   ListInit *SRC = R->getValueAsListInit("SubRegClasses");
  65   for (ListInit::const_iterator i = SRC->begin(), e = SRC->end(); i != e; ++i) {
  66     DagInit *DAG = dynamic_cast<DagInit*>(*i);
  67     if (!DAG) throw "SubRegClasses must contain DAGs";
  68     DefInit *DAGOp = dynamic_cast<DefInit*>(DAG->getOperator());
  69     Record *RCRec;
  70     if (!DAGOp || !(RCRec = DAGOp->getDef())->isSubClassOf("RegisterClass"))
  71       throw "Operator '" + DAG->getOperator()->getAsString() +
  72         "' in SubRegClasses is not a RegisterClass";
  73     // Iterate over args, all SubRegIndex instances.
  74     for (DagInit::const_arg_iterator ai = DAG->arg_begin(), ae = DAG->arg_end();
  75          ai != ae; ++ai) {
  76       DefInit *Idx = dynamic_cast<DefInit*>(*ai);
  77       Record *IdxRec;
  78       if (!Idx || !(IdxRec = Idx->getDef())->isSubClassOf("SubRegIndex"))
  79         throw "Argument '" + (*ai)->getAsString() +
  80           "' in SubRegClasses is not a SubRegIndex";
  81       if (!SubRegClasses.insert(std::make_pair(IdxRec, RCRec)).second)
  82         throw "SubRegIndex '" + IdxRec->getName() + "' mentioned twice";
  83     }
  84   }
  85
  86   // Allow targets to override the size in bits of the RegisterClass.
  87   unsigned Size = R->getValueAsInt("Size");
  88
  89   Namespace = R->getValueAsString("Namespace");
  90   SpillSize = Size ? Size : EVT(VTs[0]).getSizeInBits();
  91   SpillAlignment = R->getValueAsInt("Alignment");
  92   CopyCost = R->getValueAsInt("CopyCost");
  93   Allocatable = R->getValueAsBit("isAllocatable");
  94   MethodBodies = R->getValueAsCode("MethodBodies");
  95   MethodProtos = R->getValueAsCode("MethodProtos");
  96 }
  97
  98 const std::string &CodeGenRegisterClass::getName() const {
  99   return TheDef->getName();
 100 }
 101
 102 //===----------------------------------------------------------------------===//
 103 //                               CodeGenRegBank
 104 //===----------------------------------------------------------------------===//
 105
 106 CodeGenRegBank::CodeGenRegBank(RecordKeeper &Records) : Records(Records) {
 107   // Read in the user-defined (named) sub-register indices. More indices will
 108   // be synthesized.
 109   SubRegIndices = Records.getAllDerivedDefinitions("SubRegIndex");
 110   std::sort(SubRegIndices.begin(), SubRegIndices.end(), LessRecord());
 111   NumNamedIndices = SubRegIndices.size();
 112 }
 113
 114 Record *CodeGenRegBank::getCompositeSubRegIndex(Record *A, Record *B) {
 115   std::string Name = A->getName() + "_then_" + B->getName();
 116   Record *R = new Record(Name, SMLoc(), Records);
 117   Records.addDef(R);
 118   SubRegIndices.push_back(R);
 119   return R;
 120 }
 121
 122 unsigned CodeGenRegBank::getSubRegIndexNo(Record *idx) {
 123   std::vector<Record*>::const_iterator i =
 124     std::find(SubRegIndices.begin(), SubRegIndices.end(), idx);
 125   assert(i != SubRegIndices.end() && "Not a SubRegIndex");
 126   return (i - SubRegIndices.begin()) + 1;
 127 }
 128