--- /dev/null
+/*===-- FileLexer.l - Scanner for TableGen Files ----------------*- C++ -*-===//
+//
+//
+//===------------------------------------------------------------------------=*/
+
+%option prefix="File"
+%option yylineno
+%option nostdinit
+%option never-interactive
+%option batch
+%option noyywrap
+%option nodefault
+%option 8bit
+%option outfile="Lexer.cpp"
+%option ecs
+%option noreject
+%option noyymore
+
+
+%{
+#include "Record.h"
+typedef std::pair<Record*, std::vector<Init*>*> SubClassRefTy;
+#include "FileParser.h"
+
+// ParseInt - This has to handle the special case of binary numbers 0b0101
+static int ParseInt(const char *Str) {
+ if (Str[0] == '0' && Str[1] == 'b')
+ return strtol(Str+2, 0, 2);
+ return strtol(Str, 0, 0);
+}
+
+%}
+
+Comment \/\/.*
+
+Identifier [a-zA-Z_][0-9a-zA-Z_]*
+Integer [-+]?[0-9]+|0x[0-9a-fA-F]+|0b[01]+
+StringVal \"[^"]*\"
+
+%%
+
+{Comment} { /* Ignore comments */ }
+
+int { return INT; }
+bit { return BIT; }
+bits { return BITS; }
+string { return STRING; }
+list { return LIST; }
+
+class { return CLASS; }
+def { return DEF; }
+field { return FIELD; }
+set { return SET; }
+in { return IN; }
+
+{Identifier} { Filelval.StrVal = new std::string(yytext, yytext+yyleng);
+ return ID; }
+
+{StringVal} { Filelval.StrVal = new std::string(yytext+1, yytext+yyleng-1);
+ return STRVAL; }
+
+{Integer} { Filelval.IntVal = ParseInt(Filetext); return INTVAL; }
+
+[ \t\n]+ { /* Ignore whitespace */ }
+. { return Filetext[0]; }
+%%
--- /dev/null
+//===-- FileParser.y - Parser for TableGen files ----------------*- C++ -*-===//
+//
+// This file implements the bison parser for Table Generator files...
+//
+//===------------------------------------------------------------------------=//
+
+%{
+#include "Record.h"
+#include <iostream>
+#include <algorithm>
+#include <string>
+#include <stdio.h>
+#define YYERROR_VERBOSE 1
+
+int yyerror(const char *ErrorMsg);
+int yylex();
+extern FILE *Filein;
+extern int Filelineno;
+int Fileparse();
+static Record *CurRec = 0;
+
+typedef std::pair<Record*, std::vector<Init*>*> SubClassRefTy;
+
+static std::vector<std::pair<std::pair<std::string, std::vector<unsigned>*>,
+ Init*> > SetStack;
+
+void ParseFile() {
+ FILE *F = stdin;
+
+ Filein = F;
+ Filelineno = 1;
+ Fileparse();
+ Filein = stdin;
+}
+
+static std::ostream &err() {
+ return std::cerr << "Parsing Line #" << Filelineno << ": ";
+}
+
+static void addValue(const RecordVal &RV) {
+ if (CurRec->getValue(RV.getName())) {
+ err() << "Value '" << RV.getName() << "' multiply defined!\n";
+ abort();
+ }
+
+ CurRec->addValue(RV);
+}
+
+static void addSuperClass(Record *SC) {
+ if (CurRec->isSubClassOf(SC)) {
+ err() << "Already subclass of '" << SC->getName() << "'!\n";
+ abort();
+ }
+ CurRec->addSuperClass(SC);
+}
+
+static void setValue(const std::string &ValName,
+ std::vector<unsigned> *BitList, Init *V) {
+ if (!V) return ;
+
+ RecordVal *RV = CurRec->getValue(ValName);
+ if (RV == 0) {
+ err() << "Value '" << ValName << "' unknown!\n";
+ abort();
+ }
+
+ // If we are assigning to a subset of the bits in the value... then we must be
+ // assigning to a field of BitsRecTy, which must have a BitsInit
+ // initializer...
+ //
+ if (BitList) {
+ BitsInit *CurVal = dynamic_cast<BitsInit*>(RV->getValue());
+ if (CurVal == 0) {
+ err() << "Value '" << ValName << "' is not a bits type!\n";
+ abort();
+ }
+
+ // Convert the incoming value to a bits type of the appropriate size...
+ Init *BI = V->convertInitializerTo(new BitsRecTy(BitList->size()));
+ if (BI == 0) {
+ V->convertInitializerTo(new BitsRecTy(BitList->size()));
+ err() << "Initializer '" << *V << "' not compatible with bit range!\n";
+ abort();
+ }
+
+ // We should have a BitsInit type now...
+ assert(dynamic_cast<BitsInit*>(BI) != 0 || &(std::cerr << *BI) == 0);
+ BitsInit *BInit = (BitsInit*)BI;
+
+ BitsInit *NewVal = new BitsInit(CurVal->getNumBits());
+
+ for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
+ NewVal->setBit(i, CurVal->getBit(i));
+
+ // Loop over bits, assigning values as appopriate...
+ for (unsigned i = 0, e = BitList->size(); i != e; ++i) {
+ unsigned Bit = (*BitList)[i];
+ NewVal->setBit(Bit, BInit->getBit(i));
+ }
+ V = NewVal;
+ }
+
+ if (RV->setValue(V)) {
+ err() << "Value '" << ValName << "' of type '" << *RV->getType()
+ << "' is incompatible with initializer '" << *V << "'!\n";
+ abort();
+ }
+}
+
+static void addSubClass(Record *SC, const std::vector<Init*> &TemplateArgs) {
+ // Add all of the values in the subclass into the current class...
+ const std::vector<RecordVal> &Vals = SC->getValues();
+ for (unsigned i = 0, e = Vals.size(); i != e; ++i)
+ addValue(Vals[i]);
+
+ const std::vector<std::string> &TArgs = SC->getTemplateArgs();
+
+ // Ensure that an appropriate number of template arguments are specified...
+ if (TArgs.size() < TemplateArgs.size()) {
+ err() << "ERROR: More template args specified thang expected!\n";
+ abort();
+ } else { // This class expects template arguments...
+ // Loop over all of the template arguments, setting them to the specified
+ // value or leaving them as the default as neccesary.
+ for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
+ if (i < TemplateArgs.size()) { // A value is specified for this temp-arg?
+ // Set it now.
+ setValue(TArgs[i], 0, TemplateArgs[i]);
+ } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) {
+ err() << "ERROR: Value not specified for template argument #"
+ << i << " (" << TArgs[i] << ") of subclass '" << SC->getName()
+ << "'!\n";
+ abort();
+ }
+ }
+ }
+
+
+ // Since everything went well, we can now set the "superclass" list for the
+ // current record.
+ const std::vector<Record*> &SCs = SC->getSuperClasses();
+ for (unsigned i = 0, e = SCs.size(); i != e; ++i)
+ addSuperClass(SCs[i]);
+ addSuperClass(SC);
+}
+
+
+%}
+
+%union {
+ std::string *StrVal;
+ int IntVal;
+ RecTy *Ty;
+ Init *Initializer;
+ std::vector<Init*> *FieldList;
+ std::vector<Record*> *RecPtr;
+ std::vector<unsigned>*BitList;
+ Record *Rec;
+ SubClassRefTy *SubClassRef;
+ std::vector<SubClassRefTy> *SubClassList;
+};
+
+%token INT BIT STRING BITS LIST CLASS DEF FIELD SET IN
+%token <IntVal> INTVAL
+%token <StrVal> ID STRVAL
+
+%type <Ty> Type
+%type <RecPtr> DefList DefListNE
+%type <Rec> ClassInst DefInst Object ObjectBody ClassID DefID
+
+%type <SubClassRef> SubClassRef
+%type <SubClassList> ClassList ClassListNE
+%type <IntVal> OptPrefix
+%type <Initializer> Value OptValue
+%type <FieldList> ValueList ValueListNE
+%type <BitList> BitList OptBitList RBitList
+%type <StrVal> Declaration
+
+%start File
+%%
+
+ClassID : ID {
+ $$ = Records.getClass(*$1);
+ if ($$ == 0) {
+ err() << "Couldn't find class '" << *$1 << "'!\n";
+ abort();
+ }
+ delete $1;
+ };
+
+DefID : ID {
+ $$ = Records.getDef(*$1);
+ if ($$ == 0) {
+ err() << "Couldn't find def '" << *$1 << "'!\n";
+ abort();
+ }
+ delete $1;
+ };
+
+
+// TableGen types...
+Type : STRING { // string type
+ $$ = new StringRecTy();
+ } | BIT { // bit type
+ $$ = new BitRecTy();
+ } | BITS '<' INTVAL '>' { // bits<x> type
+ $$ = new BitsRecTy($3);
+ } | INT { // int type
+ $$ = new IntRecTy();
+ } | LIST '<' ClassID '>' { // list<x> type
+ $$ = new ListRecTy($3);
+ } | ClassID { // Record Type
+ $$ = new RecordRecTy($1);
+ };
+
+OptPrefix : /*empty*/ { $$ = 0; } | FIELD { $$ = 1; };
+
+OptValue : /*empty*/ { $$ = 0; } | '=' Value { $$ = $2; };
+
+Value : INTVAL {
+ $$ = new IntInit($1);
+ } | STRVAL {
+ $$ = new StringInit(*$1);
+ delete $1;
+ } | '?' {
+ $$ = new UnsetInit();
+ } | '{' ValueList '}' {
+ BitsInit *Init = new BitsInit($2->size());
+ for (unsigned i = 0, e = $2->size(); i != e; ++i) {
+ struct Init *Bit = (*$2)[i]->convertInitializerTo(new BitRecTy());
+ if (Bit == 0) {
+ err() << "Element #" << i << " (" << *(*$2)[i]
+ << ") is not convertable to a bit!\n";
+ abort();
+ }
+ Init->setBit($2->size()-i-1, Bit);
+ }
+ $$ = Init;
+ delete $2;
+ } | ID {
+ if (const RecordVal *RV = CurRec->getValue(*$1)) {
+ $$ = new VarInit(*$1, RV->getType());
+ } else if (Record *D = Records.getDef(*$1)) {
+ $$ = new DefInit(D);
+ } else {
+ err() << "Variable not defined: '" << *$1 << "'!\n";
+ abort();
+ }
+
+ delete $1;
+ } | Value '{' BitList '}' {
+ $$ = $1->convertInitializerBitRange(*$3);
+ if ($$ == 0) {
+ err() << "Invalid bit range for value '" << *$1 << "'!\n";
+ abort();
+ }
+ delete $3;
+ } | '[' DefList ']' {
+ $$ = new ListInit(*$2);
+ delete $2;
+ };
+
+DefList : /*empty */ {
+ $$ = new std::vector<Record*>();
+ } | DefListNE {
+ $$ = $1;
+ };
+DefListNE : DefID {
+ $$ = new std::vector<Record*>();
+ $$->push_back($1);
+ } | DefListNE ',' DefID {
+ ($$=$1)->push_back($3);
+ };
+
+
+RBitList : INTVAL {
+ $$ = new std::vector<unsigned>();
+ $$->push_back($1);
+ } | INTVAL '-' INTVAL {
+ if ($1 < $3 || $1 < 0 || $3 < 0) {
+ err() << "Invalid bit range: " << $1 << "-" << $3 << "!\n";
+ abort();
+ }
+ $$ = new std::vector<unsigned>();
+ for (int i = $1; i >= $3; --i)
+ $$->push_back(i);
+ } | INTVAL INTVAL {
+ $2 = -$2;
+ if ($1 < $2 || $1 < 0 || $2 < 0) {
+ err() << "Invalid bit range: " << $1 << "-" << $2 << "!\n";
+ abort();
+ }
+ $$ = new std::vector<unsigned>();
+ for (int i = $1; i >= $2; --i)
+ $$->push_back(i);
+ } | RBitList ',' INTVAL {
+ ($$=$1)->push_back($3);
+ } | RBitList ',' INTVAL '-' INTVAL {
+ if ($3 < $5 || $3 < 0 || $5 < 0) {
+ err() << "Invalid bit range: " << $3 << "-" << $5 << "!\n";
+ abort();
+ }
+ $$ = $1;
+ for (int i = $3; i >= $5; --i)
+ $$->push_back(i);
+ } | RBitList ',' INTVAL INTVAL {
+ $4 = -$4;
+ if ($3 < $4 || $3 < 0 || $4 < 0) {
+ err() << "Invalid bit range: " << $3 << "-" << $4 << "!\n";
+ abort();
+ }
+ $$ = $1;
+ for (int i = $3; i >= $4; --i)
+ $$->push_back(i);
+ };
+
+BitList : RBitList { $$ = $1; std::reverse($1->begin(), $1->end()); };
+
+OptBitList : /*empty*/ { $$ = 0; } | '{' BitList '}' { $$ = $2; };
+
+
+
+ValueList : /*empty*/ {
+ $$ = new std::vector<Init*>();
+ } | ValueListNE {
+ $$ = $1;
+ };
+
+ValueListNE : Value {
+ $$ = new std::vector<Init*>();
+ $$->push_back($1);
+ } | ValueListNE ',' Value {
+ ($$ = $1)->push_back($3);
+ };
+
+Declaration : OptPrefix Type ID OptValue {
+ addValue(RecordVal(*$3, $2, $1));
+ setValue(*$3, 0, $4);
+ $$ = $3;
+};
+
+BodyItem : Declaration ';' {
+ delete $1;
+} | SET ID OptBitList '=' Value ';' {
+ setValue(*$2, $3, $5);
+ delete $2;
+ delete $3;
+};
+
+BodyList : /*empty*/ | BodyList BodyItem;
+Body : ';' | '{' BodyList '}';
+
+SubClassRef : ClassID {
+ $$ = new SubClassRefTy($1, new std::vector<Init*>());
+ } | ClassID '<' ValueListNE '>' {
+ $$ = new SubClassRefTy($1, $3);
+ };
+
+ClassListNE : SubClassRef {
+ $$ = new std::vector<SubClassRefTy>();
+ $$->push_back(*$1);
+ delete $1;
+ }
+ | ClassListNE ',' SubClassRef {
+ ($$=$1)->push_back(*$3);
+ delete $3;
+ };
+
+ClassList : /*empty */ {
+ $$ = new std::vector<SubClassRefTy>();
+ }
+ | ':' ClassListNE {
+ $$ = $2;
+ };
+
+DeclListNE : Declaration {
+ CurRec->addTemplateArg(*$1);
+ delete $1;
+} | DeclListNE ',' Declaration {
+ CurRec->addTemplateArg(*$3);
+ delete $3;
+};
+
+TemplateArgList : '<' DeclListNE '>' {};
+OptTemplateArgList : /*empty*/ | TemplateArgList;
+
+ObjectBody : ID {
+ CurRec = new Record(*$1);
+ delete $1;
+ } OptTemplateArgList ClassList {
+ for (unsigned i = 0, e = $4->size(); i != e; ++i) {
+ addSubClass((*$4)[i].first, *(*$4)[i].second);
+ delete (*$4)[i].second; // Delete the template list
+ }
+ delete $4;
+
+ // Process any variables on the set stack...
+ for (unsigned i = 0, e = SetStack.size(); i != e; ++i)
+ setValue(SetStack[i].first.first, SetStack[i].first.second,
+ SetStack[i].second);
+ } Body {
+ CurRec->resolveReferences();
+ $$ = CurRec;
+ CurRec = 0;
+};
+
+ClassInst : CLASS ObjectBody {
+ if (Records.getClass($2->getName())) {
+ err() << "Class '" << $2->getName() << "' already defined!\n";
+ abort();
+ }
+ Records.addClass($$ = $2);
+};
+
+DefInst : DEF ObjectBody {
+ // TODO: If ObjectBody has template arguments, it's an error.
+ if (Records.getDef($2->getName())) {
+ err() << "Def '" << $2->getName() << "' already defined!\n";
+ abort();
+ }
+ Records.addDef($$ = $2);
+};
+
+
+Object : ClassInst | DefInst;
+
+// Support Set commands wrapping objects...
+Object : SET ID OptBitList '=' Value IN {
+ SetStack.push_back(std::make_pair(std::make_pair(*$2, $3), $5));
+ delete $2;
+ } '{' ObjectList '}' {
+ delete SetStack.back().first.second; // Delete OptBitList
+ SetStack.pop_back();
+ };
+
+ObjectList : Object {} | ObjectList Object {};
+
+File : ObjectList {};
+
+%%
+
+int yyerror(const char *ErrorMsg) {
+ err() << "Error parsing: " << ErrorMsg << "\n";
+ abort();
+}
--- /dev/null
+LEVEL = ../..
+TOOLNAME = tblgen
+USEDLIBS = support.a
+
+include $(LEVEL)/Makefile.common
+
+clean::
+ -rm -f FileParser.cpp FileParser.h FileLexer.cpp CommandLine.cpp
+ -rm -f FileParser.output
+
+test::
+ $(TOOLEXENAME_G) < X86.td
+ # -parse
+
+ @echo "enum {"
+ @$(TOOLEXENAME_G) < X86.td -class=Register
+ @echo
+ @echo "};"
+
+ @echo "enum {"
+ @$(TOOLEXENAME_G) < X86.td -class=Instruction
+ @echo
+ @echo "};"
--- /dev/null
+//===- Record.cpp - Record implementation ---------------------------------===//
+//
+//
+//===----------------------------------------------------------------------===//
+
+#include "Record.h"
+
+//===----------------------------------------------------------------------===//
+// Type implementations
+//===----------------------------------------------------------------------===//
+
+void RecTy::dump() const { print(std::cerr); }
+
+Init *BitRecTy::convertValue(BitsInit *BI) {
+ if (BI->getNumBits() != 1) return 0; // Only accept if just one bit!
+ return BI->getBit(0);
+}
+
+Init *BitRecTy::convertValue(IntInit *II) {
+ int Val = II->getValue();
+ if (Val != 0 && Val != 1) return 0; // Only accept 0 or 1 for a bit!
+ delete II;
+
+ return new BitInit(Val != 0);
+}
+
+Init *BitRecTy::convertValue(VarInit *VI) {
+ if (dynamic_cast<BitRecTy*>(VI->getType()))
+ return VI; // Accept variable if it is already of bit type!
+ return 0;
+}
+
+Init *BitsRecTy::convertValue(UnsetInit *UI) {
+ BitsInit *Ret = new BitsInit(Size);
+
+ for (unsigned i = 0; i != Size; ++i)
+ Ret->setBit(i, new UnsetInit());
+ return Ret;
+}
+
+Init *BitsRecTy::convertValue(BitInit *UI) {
+ if (Size != 1) return 0; // Can only convert single bit...
+ BitsInit *Ret = new BitsInit(1);
+ Ret->setBit(0, UI);
+ return Ret;
+}
+
+// convertValue from Int initializer to bits type: Split the integer up into the
+// appropriate bits...
+//
+Init *BitsRecTy::convertValue(IntInit *II) {
+ int Value = II->getValue();
+ delete II;
+
+ BitsInit *Ret = new BitsInit(Size);
+ for (unsigned i = 0; i != Size; ++i)
+ Ret->setBit(i, new BitInit(Value & (1 << i)));
+ return Ret;
+}
+
+Init *BitsRecTy::convertValue(BitsInit *BI) {
+ // If the number of bits is right, return it. Otherwise we need to expand or
+ // truncate...
+ if (BI->getNumBits() == Size) return BI;
+ return 0;
+}
+
+Init *BitsRecTy::convertValue(VarInit *VI) {
+ if (BitsRecTy *BRT = dynamic_cast<BitsRecTy*>(VI->getType()))
+ if (BRT->Size == Size) {
+ BitsInit *Ret = new BitsInit(Size);
+ for (unsigned i = 0; i != Size; ++i)
+ Ret->setBit(i, new VarBitInit(VI, i));
+ return Ret;
+ }
+ if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType())) {
+ BitsInit *Ret = new BitsInit(1);
+ Ret->setBit(0, VI);
+ return Ret;
+ }
+
+ return 0;
+}
+
+
+Init *IntRecTy::convertValue(BitsInit *BI) {
+ int Result = 0;
+ for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
+ if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) {
+ Result |= Bit->getValue() << i;
+ } else {
+ return 0;
+ }
+ return new IntInit(Result);
+}
+
+Init *IntRecTy::convertValue(VarInit *VI) {
+ if (dynamic_cast<IntRecTy*>(VI->getType()))
+ return VI; // Accept variable if already of the right type!
+ return 0;
+}
+
+Init *StringRecTy::convertValue(VarInit *VI) {
+ if (dynamic_cast<StringRecTy*>(VI->getType()))
+ return VI; // Accept variable if already of the right type!
+ return 0;
+}
+
+void ListRecTy::print(std::ostream &OS) const {
+ OS << "list<" << Class->getName() << ">";
+}
+
+Init *ListRecTy::convertValue(ListInit *LI) {
+ // Verify that all of the elements of the list are subclasses of the
+ // appopriate class!
+ for (unsigned i = 0, e = LI->getSize(); i != e; ++i)
+ if (!LI->getElement(i)->isSubClassOf(Class))
+ return 0;
+ return LI;
+}
+
+void RecordRecTy::print(std::ostream &OS) const {
+ OS << Rec->getName();
+}
+
+Init *RecordRecTy::convertValue(DefInit *DI) {
+ // Ensure that DI is a subclass of Rec.
+ if (!DI->getDef()->isSubClassOf(Rec))
+ return 0;
+ return DI;
+}
+
+//===----------------------------------------------------------------------===//
+// Initializer implementations
+//===----------------------------------------------------------------------===//
+
+void Init::dump() const { return print(std::cerr); }
+
+Init *BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+ BitsInit *BI = new BitsInit(Bits.size());
+ for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
+ if (Bits[i] >= getNumBits()) {
+ delete BI;
+ return 0;
+ }
+ BI->setBit(i, getBit(Bits[i]));
+ }
+ return BI;
+}
+
+void BitsInit::print(std::ostream &OS) const {
+ //if (!printInHex(OS)) return;
+ if (!printAsVariable(OS)) return;
+ if (!printAsUnset(OS)) return;
+
+ OS << "{ ";
+ for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
+ if (i) OS << ", ";
+ getBit(e-i-1)->print(OS);
+ }
+ OS << " }";
+}
+
+bool BitsInit::printInHex(std::ostream &OS) const {
+ // First, attempt to convert the value into an integer value...
+ int Result = 0;
+ for (unsigned i = 0, e = getNumBits(); i != e; ++i)
+ if (BitInit *Bit = dynamic_cast<BitInit*>(getBit(i))) {
+ Result |= Bit->getValue() << i;
+ } else {
+ return true;
+ }
+
+ OS << "0x" << std::hex << Result << std::dec;
+ return false;
+}
+
+bool BitsInit::printAsVariable(std::ostream &OS) const {
+ // Get the variable that we may be set equal to...
+ assert(getNumBits() != 0);
+ VarBitInit *FirstBit = dynamic_cast<VarBitInit*>(getBit(0));
+ if (FirstBit == 0) return true;
+ VarInit *Var = FirstBit->getVariable();
+
+ // Check to make sure the types are compatible.
+ BitsRecTy *Ty = dynamic_cast<BitsRecTy*>(Var->getType());
+ if (Ty == 0) return true;
+ if (Ty->getNumBits() != getNumBits()) return true; // Incompatible types!
+
+ // Check to make sure all bits are referring to the right bits in the variable
+ for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
+ VarBitInit *Bit = dynamic_cast<VarBitInit*>(getBit(i));
+ if (Bit == 0 || Bit->getVariable() != Var || Bit->getBitNum() != i)
+ return true;
+ }
+
+ OS << Var->getName();
+ return false;
+}
+
+bool BitsInit::printAsUnset(std::ostream &OS) const {
+ for (unsigned i = 0, e = getNumBits(); i != e; ++i)
+ if (!dynamic_cast<UnsetInit*>(getBit(i)))
+ return true;
+ OS << "?";
+ return false;
+}
+
+Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+ BitsInit *BI = new BitsInit(Bits.size());
+
+ for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
+ if (Bits[i] >= 32) {
+ delete BI;
+ return 0;
+ }
+ BI->setBit(i, new BitInit(Value & (1 << Bits[i])));
+ }
+ return BI;
+}
+
+void ListInit::print(std::ostream &OS) const {
+ OS << "[";
+ for (unsigned i = 0, e = Records.size(); i != e; ++i) {
+ if (i) OS << ", ";
+ OS << Records[i]->getName();
+ }
+ OS << "]";
+}
+
+Init *VarInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+ BitsRecTy *T = dynamic_cast<BitsRecTy*>(Ty);
+ if (T == 0) return 0; // Cannot subscript a non-bits variable...
+ unsigned NumBits = T->getNumBits();
+
+ BitsInit *BI = new BitsInit(Bits.size());
+ for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
+ if (Bits[i] >= NumBits) {
+ delete BI;
+ return 0;
+ }
+ BI->setBit(i, new VarBitInit(this, Bits[i]));
+ }
+ return BI;
+}
+
+Init *BitsInit::resolveReferences(Record &R) {
+ bool Changed = false;
+ BitsInit *New = new BitsInit(getNumBits());
+
+ for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
+ Init *B;
+ New->setBit(i, getBit(i));
+ do {
+ B = New->getBit(i);
+ New->setBit(i, B->resolveReferences(R));
+ Changed |= B != New->getBit(i);
+ } while (B != New->getBit(i));
+ }
+
+ if (Changed)
+ return New;
+ delete New;
+ return this;
+}
+
+
+
+Init *VarBitInit::resolveReferences(Record &R) {
+ if (R.isTemplateArg(getVariable()->getName()))
+ return this;
+
+ RecordVal *RV = R.getValue(getVariable()->getName());
+ assert(RV && "Reference to a non-existant variable?");
+ assert(dynamic_cast<BitsInit*>(RV->getValue()));
+ BitsInit *BI = (BitsInit*)RV->getValue();
+
+ assert(getBitNum() < BI->getNumBits() && "Bit reference out of range!");
+ Init *B = BI->getBit(getBitNum());
+
+ if (!dynamic_cast<UnsetInit*>(B)) // If the bit is not set...
+ return B; // Replace the VarBitInit with it.
+ return this;
+}
+
+void DefInit::print(std::ostream &OS) const {
+ OS << Def->getName();
+}
+
+//===----------------------------------------------------------------------===//
+// Other implementations
+//===----------------------------------------------------------------------===//
+
+RecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P)
+ : Name(N), Ty(T), Prefix(P) {
+ Value = Ty->convertValue(new UnsetInit());
+ assert(Value && "Cannot create unset value for current type!");
+}
+
+void RecordVal::dump() const { std::cerr << *this; }
+
+void RecordVal::print(std::ostream &OS, bool PrintSem) const {
+ if (getPrefix()) OS << "field ";
+ OS << *getType() << " " << getName();
+ if (getValue()) {
+ OS << " = " << *getValue();
+ }
+ if (PrintSem) OS << ";\n";
+}
+
+// resolveReferences - If there are any field references that refer to fields
+// that have been filled in, we can propagate the values now.
+//
+void Record::resolveReferences() {
+ for (unsigned i = 0, e = Values.size(); i != e; ++i)
+ Values[i].setValue(Values[i].getValue()->resolveReferences(*this));
+}
+
+void Record::dump() const { std::cerr << *this; }
+
+std::ostream &operator<<(std::ostream &OS, const Record &R) {
+ OS << R.getName();
+
+ const std::vector<std::string> &TArgs = R.getTemplateArgs();
+ if (!TArgs.empty()) {
+ OS << "<";
+ for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
+ if (i) OS << ", ";
+ const RecordVal *RV = R.getValue(TArgs[i]);
+ assert(RV && "Template argument record not found??");
+ RV->print(OS, false);
+ }
+ OS << ">";
+ }
+
+ OS << " {";
+ const std::vector<Record*> &SC = R.getSuperClasses();
+ if (!SC.empty()) {
+ OS << "\t//";
+ for (unsigned i = 0, e = SC.size(); i != e; ++i)
+ OS << " " << SC[i]->getName();
+ }
+ OS << "\n";
+
+ const std::vector<RecordVal> &Vals = R.getValues();
+ for (unsigned i = 0, e = Vals.size(); i != e; ++i)
+ if (Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName()))
+ OS << Vals[i];
+ for (unsigned i = 0, e = Vals.size(); i != e; ++i)
+ if (!Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName()))
+ OS << Vals[i];
+
+ return OS << "}\n";
+}
+
+void RecordKeeper::dump() const { std::cerr << *this; }
+
+std::ostream &operator<<(std::ostream &OS, const RecordKeeper &RK) {
+ OS << "------------- Classes -----------------\n";
+ const std::map<std::string, Record*> &Classes = RK.getClasses();
+ for (std::map<std::string, Record*>::const_iterator I = Classes.begin(),
+ E = Classes.end(); I != E; ++I)
+ OS << "class " << *I->second;
+
+ OS << "------------- Defs -----------------\n";
+ const std::map<std::string, Record*> &Defs = RK.getDefs();
+ for (std::map<std::string, Record*>::const_iterator I = Defs.begin(),
+ E = Defs.end(); I != E; ++I)
+ OS << "def " << *I->second;
+ return OS;
+}
--- /dev/null
+//===- Record.h - Classes to represent Table Records ------------*- C++ -*-===//
+//
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef RECORD_H
+#define RECORD_H
+
+#include <string>
+#include <vector>
+#include <map>
+#include <iostream>
+class Init;
+class UnsetInit;
+class BitInit;
+class BitsInit;
+class IntInit;
+class StringInit;
+class ListInit;
+class VarInit;
+class VarBitInit;
+class DefInit;
+class Record;
+
+//===----------------------------------------------------------------------===//
+// Type Classes
+//===----------------------------------------------------------------------===//
+
+struct RecTy {
+ virtual ~RecTy() {}
+
+ virtual Init *convertValue( UnsetInit *UI) { return 0; }
+ virtual Init *convertValue( BitInit *BI) { return 0; }
+ virtual Init *convertValue( BitsInit *BI) { return 0; }
+ virtual Init *convertValue( IntInit *II) { return 0; }
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( VarInit *VI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+
+ virtual void print(std::ostream &OS) const = 0;
+ void dump() const;
+};
+
+inline std::ostream &operator<<(std::ostream &OS, const RecTy &Ty) {
+ Ty.print(OS);
+ return OS;
+}
+
+struct BitRecTy : public RecTy {
+ Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
+ Init *convertValue(BitInit *BI) { return (Init*)BI; }
+ Init *convertValue(BitsInit *BI);
+ Init *convertValue(IntInit *II);
+ Init *convertValue(VarInit *VI);
+
+ void print(std::ostream &OS) const { OS << "bit"; }
+};
+
+class BitsRecTy : public RecTy {
+ unsigned Size;
+public:
+ BitsRecTy(unsigned Sz) : Size(Sz) {}
+
+ unsigned getNumBits() const { return Size; }
+
+ Init *convertValue(UnsetInit *UI);
+ Init *convertValue(BitInit *UI);
+ Init *convertValue(BitsInit *BI);
+ Init *convertValue(IntInit *II);
+ Init *convertValue(VarInit *VI);
+
+ void print(std::ostream &OS) const { OS << "bits<" << Size << ">"; }
+};
+
+struct IntRecTy : public RecTy {
+ Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
+ Init *convertValue(IntInit *II) { return (Init*)II; }
+ Init *convertValue(BitsInit *BI);
+ Init *convertValue(VarInit *VI);
+
+ void print(std::ostream &OS) const { OS << "int"; }
+};
+
+struct StringRecTy : public RecTy {
+ Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
+ Init *convertValue(StringInit *SI) { return (Init*)SI; }
+ Init *convertValue(VarInit *VI);
+ void print(std::ostream &OS) const { OS << "string"; }
+};
+
+class ListRecTy : public RecTy {
+ Record *Class;
+public:
+ ListRecTy(Record *C) : Class(C) {}
+ Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
+ Init *convertValue(ListInit *LI);
+
+ void print(std::ostream &OS) const;
+};
+
+class RecordRecTy : public RecTy {
+ Record *Rec;
+public:
+ RecordRecTy(Record *R) : Rec(R) {}
+
+ Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
+ Init *convertValue( DefInit *DI);
+
+ void print(std::ostream &OS) const;
+};
+
+//===----------------------------------------------------------------------===//
+// Initializer Classes
+//===----------------------------------------------------------------------===//
+
+struct Init {
+ virtual ~Init() {}
+
+ virtual bool isComplete() const = 0;
+ virtual void print(std::ostream &OS) const = 0;
+ void dump() const;
+
+ virtual Init *convertInitializerTo(RecTy *Ty) = 0;
+ virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+ return 0;
+ }
+
+ virtual Init *resolveReferences(Record &R) { return this; }
+};
+
+inline std::ostream &operator<<(std::ostream &OS, const Init &I) {
+ I.print(OS); return OS;
+}
+
+struct UnsetInit : public Init {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ virtual bool isComplete() const { return false; }
+ virtual void print(std::ostream &OS) const { OS << "?"; }
+};
+
+class BitInit : public Init {
+ bool Value;
+public:
+ BitInit(bool V) : Value(V) {}
+
+ bool getValue() const { return Value; }
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ virtual bool isComplete() const { return true; }
+ virtual void print(std::ostream &OS) const { OS << (Value ? "1" : "0"); }
+};
+
+class BitsInit : public Init {
+ std::vector<Init*> Bits;
+public:
+ BitsInit(unsigned Size) : Bits(Size) {}
+
+ unsigned getNumBits() const { return Bits.size(); }
+
+ Init *getBit(unsigned Bit) const {
+ assert(Bit < Bits.size() && "Bit index out of range!");
+ return Bits[Bit];
+ }
+ void setBit(unsigned Bit, Init *V) {
+ assert(Bit < Bits.size() && "Bit index out of range!");
+ Bits[Bit] = V;
+ }
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+ virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
+
+ virtual bool isComplete() const {
+ for (unsigned i = 0; i != getNumBits(); ++i)
+ if (!getBit(i)->isComplete()) return false;
+ return true;
+ }
+ virtual void print(std::ostream &OS) const;
+
+ virtual Init *resolveReferences(Record &R);
+
+ // printXX - Print this bitstream with the specified format, returning true if
+ // it is not possible.
+ bool printInHex(std::ostream &OS) const;
+ bool printAsVariable(std::ostream &OS) const;
+ bool printAsUnset(std::ostream &OS) const;
+};
+
+class IntInit : public Init {
+ int Value;
+public:
+ IntInit(int V) : Value(V) {}
+
+ int getValue() const { return Value; }
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+ virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
+
+ virtual bool isComplete() const { return true; }
+ virtual void print(std::ostream &OS) const { OS << Value; }
+};
+
+class StringInit : public Init {
+ std::string Value;
+public:
+ StringInit(const std::string &V) : Value(V) {}
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ virtual bool isComplete() const { return true; }
+ virtual void print(std::ostream &OS) const { OS << "\"" << Value << "\""; }
+};
+
+class ListInit : public Init {
+ std::vector<Record*> Records;
+public:
+ ListInit(std::vector<Record*> &Rs) {
+ Records.swap(Rs);
+ }
+
+ unsigned getSize() const { return Records.size(); }
+ Record *getElement(unsigned i) const {
+ assert(i < Records.size() && "List element index out of range!");
+ return Records[i];
+ }
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ virtual bool isComplete() const { return true; }
+ virtual void print(std::ostream &OS) const;
+};
+
+class VarInit : public Init {
+ std::string VarName;
+ RecTy *Ty;
+public:
+ VarInit(const std::string &VN, RecTy *T) : VarName(VN), Ty(T) {}
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ const std::string &getName() const { return VarName; }
+ RecTy *getType() const { return Ty; }
+
+ virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
+
+ virtual bool isComplete() const { return true; }
+ virtual void print(std::ostream &OS) const { OS << VarName; }
+};
+
+class VarBitInit : public Init {
+ VarInit *VI;
+ unsigned Bit;
+public:
+ VarBitInit(VarInit *V, unsigned B) : VI(V), Bit(B) {}
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ VarInit *getVariable() const { return VI; }
+ unsigned getBitNum() const { return Bit; }
+
+ virtual bool isComplete() const { return true; }
+ virtual void print(std::ostream &OS) const {
+ VI->print(OS); OS << "{" << Bit << "}";
+ }
+ virtual Init *resolveReferences(Record &R);
+};
+
+class DefInit : public Init {
+ Record *Def;
+public:
+ DefInit(Record *D) : Def(D) {}
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ Record *getDef() const { return Def; }
+
+ //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
+
+ virtual bool isComplete() const { return true; }
+ virtual void print(std::ostream &OS) const;
+};
+
+
+
+//===----------------------------------------------------------------------===//
+// High-Level Classes
+//===----------------------------------------------------------------------===//
+
+class RecordVal {
+ std::string Name;
+ RecTy *Ty;
+ unsigned Prefix;
+ Init *Value;
+public:
+ RecordVal(const std::string &N, RecTy *T, unsigned P);
+ ~RecordVal() { /*delete Ty; delete Value; Bad for copy ctor!*/ }
+
+ const std::string &getName() const { return Name; }
+
+ unsigned getPrefix() const { return Prefix; }
+ RecTy *getType() const { return Ty; }
+ Init *getValue() const { return Value; }
+
+ bool setValue(Init *V) {
+ if (V) {
+ Value = V->convertInitializerTo(Ty);
+ return Value == 0;
+ }
+ Value = 0;
+ return false;
+ }
+
+ void dump() const;
+ void print(std::ostream &OS, bool PrintSem = true) const;
+};
+
+inline std::ostream &operator<<(std::ostream &OS, const RecordVal &RV) {
+ RV.print(OS << " ");
+ return OS;
+}
+
+struct Record {
+ const std::string Name;
+ std::vector<std::string> TemplateArgs;
+ std::vector<RecordVal> Values;
+ std::vector<Record*> SuperClasses;
+public:
+
+ Record(const std::string &N) : Name(N) {}
+ ~Record() {}
+
+ const std::string &getName() const { return Name; }
+ const std::vector<std::string> &getTemplateArgs() const {
+ return TemplateArgs;
+ }
+ const std::vector<RecordVal> &getValues() const { return Values; }
+ const std::vector<Record*> &getSuperClasses() const { return SuperClasses; }
+
+ bool isTemplateArg(const std::string &Name) const {
+ for (unsigned i = 0, e = TemplateArgs.size(); i != e; ++i)
+ if (TemplateArgs[i] == Name) return true;
+ return false;
+ }
+
+ const RecordVal *getValue(const std::string &Name) const {
+ for (unsigned i = 0, e = Values.size(); i != e; ++i)
+ if (Values[i].getName() == Name) return &Values[i];
+ return 0;
+ }
+ RecordVal *getValue(const std::string &Name) {
+ for (unsigned i = 0, e = Values.size(); i != e; ++i)
+ if (Values[i].getName() == Name) return &Values[i];
+ return 0;
+ }
+
+ void addTemplateArg(const std::string &Name) {
+ assert(!isTemplateArg(Name) && "Template arg already defined!");
+ TemplateArgs.push_back(Name);
+ }
+
+ void addValue(const RecordVal &RV) {
+ assert(getValue(RV.getName()) == 0 && "Value already added!");
+ Values.push_back(RV);
+ }
+
+ bool isSubClassOf(Record *R) const {
+ for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
+ if (SuperClasses[i] == R)
+ return true;
+ return false;
+ }
+
+ void addSuperClass(Record *R) {
+ assert(!isSubClassOf(R) && "Already subclassing record!");
+ SuperClasses.push_back(R);
+ }
+
+ // resolveReferences - If there are any field references that refer to fields
+ // that have been filled in, we can propagate the values now.
+ //
+ void resolveReferences();
+
+ void dump() const;
+};
+
+std::ostream &operator<<(std::ostream &OS, const Record &R);
+
+class RecordKeeper {
+ std::map<std::string, Record*> Classes, Defs;
+public:
+ ~RecordKeeper() {
+ for (std::map<std::string, Record*>::iterator I = Classes.begin(),
+ E = Classes.end(); I != E; ++I)
+ delete I->second;
+ for (std::map<std::string, Record*>::iterator I = Defs.begin(),
+ E = Defs.end(); I != E; ++I)
+ delete I->second;
+ }
+
+ const std::map<std::string, Record*> &getClasses() const { return Classes; }
+ const std::map<std::string, Record*> &getDefs() const { return Defs; }
+
+ Record *getClass(const std::string &Name) const {
+ std::map<std::string, Record*>::const_iterator I = Classes.find(Name);
+ return I == Classes.end() ? 0 : I->second;
+ }
+ Record *getDef(const std::string &Name) const {
+ std::map<std::string, Record*>::const_iterator I = Defs.find(Name);
+ return I == Defs.end() ? 0 : I->second;
+ }
+ void addClass(Record *R) {
+ assert(getClass(R->getName()) == 0 && "Class already exists!");
+ Classes.insert(std::make_pair(R->getName(), R));
+ }
+ void addDef(Record *R) {
+ assert(getDef(R->getName()) == 0 && "Def already exists!");
+ Defs.insert(std::make_pair(R->getName(), R));
+ }
+
+ void dump() const;
+};
+
+std::ostream &operator<<(std::ostream &OS, const RecordKeeper &RK);
+
+extern RecordKeeper Records;
+
+#endif
--- /dev/null
+#include "Record.h"
+#include "Support/CommandLine.h"
+#include <algorithm>
+
+static cl::opt<std::string> Class("class", cl::desc("Print Enum list for this class"));
+static cl::opt<bool> Parse("parse");
+
+void ParseFile();
+
+RecordKeeper Records;
+
+static Init *getBit(Record *R, unsigned BitNo) {
+ const std::vector<RecordVal> &V = R->getValues();
+ for (unsigned i = 0, e = V.size(); i != e; ++i)
+ if (V[i].getPrefix()) {
+ assert(dynamic_cast<BitsInit*>(V[i].getValue()) &&
+ "Can only handle fields of bits<> type!");
+ BitsInit *I = (BitsInit*)V[i].getValue();
+ if (BitNo < I->getNumBits())
+ return I->getBit(BitNo);
+ BitNo -= I->getNumBits();
+ }
+
+ std::cerr << "Cannot find requested bit!\n";
+ abort();
+ return 0;
+}
+
+static unsigned getNumBits(Record *R) {
+ const std::vector<RecordVal> &V = R->getValues();
+ unsigned Num = 0;
+ for (unsigned i = 0, e = V.size(); i != e; ++i)
+ if (V[i].getPrefix()) {
+ assert(dynamic_cast<BitsInit*>(V[i].getValue()) &&
+ "Can only handle fields of bits<> type!");
+ Num += ((BitsInit*)V[i].getValue())->getNumBits();
+ }
+ return Num;
+}
+
+static bool BitsAreFixed(Record *I1, Record *I2, unsigned BitNo) {
+ return dynamic_cast<BitInit*>(getBit(I1, BitNo)) &&
+ dynamic_cast<BitInit*>(getBit(I2, BitNo));
+}
+
+static bool BitsAreEqual(Record *I1, Record *I2, unsigned BitNo) {
+ BitInit *Bit1 = dynamic_cast<BitInit*>(getBit(I1, BitNo));
+ BitInit *Bit2 = dynamic_cast<BitInit*>(getBit(I2, BitNo));
+
+ return Bit1 && Bit2 && Bit1->getValue() == Bit2->getValue();
+}
+
+static bool BitRangesEqual(Record *I1, Record *I2,
+ unsigned Start, unsigned End) {
+ for (unsigned i = Start; i != End; ++i)
+ if (!BitsAreEqual(I1, I2, i))
+ return false;
+ return true;
+}
+
+static unsigned getFirstFixedBit(Record *R, unsigned FirstFixedBit) {
+ // Look for the first bit of the pair that are required to be 0 or 1.
+ while (!dynamic_cast<BitInit*>(getBit(R, FirstFixedBit)))
+ ++FirstFixedBit;
+ return FirstFixedBit;
+}
+
+static void FindInstDifferences(Record *I1, Record *I2,
+ unsigned FirstFixedBit, unsigned MaxBits,
+ unsigned &FirstVaryingBitOverall,
+ unsigned &LastFixedBitOverall) {
+ // Compare the first instruction to the rest of the instructions, looking for
+ // fields that differ.
+ //
+ unsigned FirstVaryingBit = FirstFixedBit;
+ while (FirstVaryingBit < MaxBits && BitsAreEqual(I1, I2, FirstVaryingBit))
+ ++FirstVaryingBit;
+
+ unsigned LastFixedBit = FirstVaryingBit;
+ while (LastFixedBit < MaxBits && BitsAreFixed(I1, I2, LastFixedBit))
+ ++LastFixedBit;
+
+ if (FirstVaryingBit < FirstVaryingBitOverall)
+ FirstVaryingBitOverall = FirstVaryingBit;
+ if (LastFixedBit < LastFixedBitOverall)
+ LastFixedBitOverall = LastFixedBit;
+}
+
+static bool getBitValue(Record *R, unsigned BitNo) {
+ Init *I = getBit(R, BitNo);
+ assert(dynamic_cast<BitInit*>(I) && "Bit should be fixed!");
+ return ((BitInit*)I)->getValue();
+}
+
+struct BitComparator {
+ unsigned BitBegin, BitEnd;
+ BitComparator(unsigned B, unsigned E) : BitBegin(B), BitEnd(E) {}
+
+ bool operator()(Record *R1, Record *R2) { // Return true if R1 is less than R2
+ for (unsigned i = BitBegin; i != BitEnd; ++i) {
+ bool V1 = getBitValue(R1, i), V2 = getBitValue(R2, i);
+ if (V1 < V2)
+ return true;
+ else if (V2 < V1)
+ return false;
+ }
+ return false;
+ }
+};
+
+static void PrintRange(std::vector<Record*>::iterator I,
+ std::vector<Record*>::iterator E) {
+ while (I != E) std::cerr << **I++;
+}
+
+static bool getMemoryBit(unsigned char *M, unsigned i) {
+ return (M[i/8] & (1 << (i&7))) != 0;
+}
+
+static unsigned getFirstFixedBitInSequence(std::vector<Record*>::iterator IB,
+ std::vector<Record*>::iterator IE,
+ unsigned StartBit) {
+ unsigned FirstFixedBit = 0;
+ for (std::vector<Record*>::iterator I = IB; I != IE; ++I)
+ FirstFixedBit = std::max(FirstFixedBit, getFirstFixedBit(*I, StartBit));
+ return FirstFixedBit;
+}
+
+// ParseMachineCode - Try to split the vector of instructions (which is
+// intentially taken by-copy) in half, narrowing down the possible instructions
+// that we may have found. Eventually, this list will get pared down to zero or
+// one instruction, in which case we have a match or failure.
+//
+static Record *ParseMachineCode(std::vector<Record*>::iterator InstsB,
+ std::vector<Record*>::iterator InstsE,
+ unsigned char *M) {
+ assert(InstsB != InstsE && "Empty range?");
+ if (InstsB+1 == InstsE) {
+ // Only a single instruction, see if we match it...
+ Record *Inst = *InstsB;
+ for (unsigned i = 0, e = getNumBits(Inst); i != e; ++i)
+ if (BitInit *BI = dynamic_cast<BitInit*>(getBit(Inst, i)))
+ if (getMemoryBit(M, i) != BI->getValue())
+ return 0;
+ return Inst;
+ }
+
+ unsigned MaxBits = ~0;
+ for (std::vector<Record*>::iterator I = InstsB; I != InstsE; ++I)
+ MaxBits = std::min(MaxBits, getNumBits(*I));
+
+ unsigned FirstFixedBit = getFirstFixedBitInSequence(InstsB, InstsE, 0);
+ unsigned FirstVaryingBit, LastFixedBit;
+ do {
+ FirstVaryingBit = ~0;
+ LastFixedBit = ~0;
+ for (std::vector<Record*>::iterator I = InstsB+1; I != InstsE; ++I)
+ FindInstDifferences(*InstsB, *I, FirstFixedBit, MaxBits,
+ FirstVaryingBit, LastFixedBit);
+ if (FirstVaryingBit == MaxBits) {
+ std::cerr << "ERROR: Could not find bit to distinguish between "
+ << "the following entries!\n";
+ PrintRange(InstsB, InstsE);
+ }
+
+#if 0
+ std::cerr << "FVB: " << FirstVaryingBit << " - " << LastFixedBit
+ << ": " << InstsE-InstsB << "\n";
+#endif
+
+ FirstFixedBit = getFirstFixedBitInSequence(InstsB, InstsE, FirstVaryingBit);
+ } while (FirstVaryingBit != FirstFixedBit);
+
+ //std::cerr << "\n\nXXXXXXXXXXXXXXXXX\n\n";
+ //PrintRange(InstsB, InstsE);
+
+ // Sort the Insts list so that the entries have all of the bits in the range
+ // [FirstVaryingBit,LastFixedBit) sorted. These bits are all guaranteed to be
+ // set to either 0 or 1 (BitInit values), which simplifies things.
+ //
+ std::sort(InstsB, InstsE, BitComparator(FirstVaryingBit, LastFixedBit));
+
+ // Once the list is sorted by these bits, split the bit list into smaller
+ // lists, and recurse on each one.
+ //
+ std::vector<Record*>::iterator RangeBegin = InstsB;
+ Record *Match = 0;
+ while (RangeBegin != InstsE) {
+ std::vector<Record*>::iterator RangeEnd = RangeBegin+1;
+ while (RangeEnd != InstsE &&
+ BitRangesEqual(*RangeBegin, *RangeEnd, FirstVaryingBit, LastFixedBit))
+ ++RangeEnd;
+
+ // We just identified a range of equal instructions. If this range is the
+ // input range, we were not able to distinguish between the instructions in
+ // the set. Print an error and exit!
+ //
+ if (RangeBegin == InstsB && RangeEnd == InstsE) {
+ std::cerr << "Error: Could not distinguish among the following insts!:\n";
+ PrintRange(InstsB, InstsE);
+ abort();
+ }
+
+ if (Record *R = ParseMachineCode(RangeBegin, RangeEnd, M)) {
+ if (Match) {
+ std::cerr << "Error: Multiple matches found:\n";
+ PrintRange(InstsB, InstsE);
+ }
+
+ assert(Match == 0 && "Multiple matches??");
+ Match = R;
+ }
+ RangeBegin = RangeEnd;
+ }
+
+ return Match;
+}
+
+static void PrintValue(Record *I, unsigned char *Ptr, const RecordVal &Val) {
+ assert(dynamic_cast<BitsInit*>(Val.getValue()) &&
+ "Can only handle undefined bits<> types!");
+ BitsInit *BI = (BitsInit*)Val.getValue();
+ assert(BI->getNumBits() <= 32 && "Can only handle fields up to 32 bits!");
+
+ unsigned Value = 0;
+ const std::vector<RecordVal> &Vals = I->getValues();
+
+ // Start by filling in fixed values...
+ for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
+ if (BitInit *B = dynamic_cast<BitInit*>(BI->getBit(i)))
+ Value |= B->getValue() << i;
+
+ // Loop over all of the fields in the instruction adding in any
+ // contributions to this value (due to bit references).
+ //
+ unsigned Offset = 0;
+ for (unsigned f = 0, e = Vals.size(); f != e; ++f)
+ if (Vals[f].getPrefix()) {
+ BitsInit *FieldInit = (BitsInit*)Vals[f].getValue();
+ if (&Vals[f] == &Val) {
+ // Read the bits directly now...
+ for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
+ Value |= getMemoryBit(Ptr, Offset+i) << i;
+ break;
+ }
+
+ // Scan through the field looking for bit initializers of the current
+ // variable...
+ for (unsigned i = 0, e = FieldInit->getNumBits(); i != e; ++i)
+ if (VarBitInit *VBI =
+ dynamic_cast<VarBitInit*>(FieldInit->getBit(i))) {
+ if (VBI->getVariable()->getName() == Val.getName())
+ Value |= getMemoryBit(Ptr, Offset+i) << VBI->getBitNum();
+ }
+ Offset += FieldInit->getNumBits();
+ }
+
+ std::cout << "0x" << std::hex << Value << std::dec;
+}
+
+static void PrintInstruction(Record *I, unsigned char *Ptr) {
+ std::cout << "Inst " << getNumBits(I)/8 << " bytes: "
+ << "\t" << I->getName() << "\t" << *I->getValue("Name")->getValue()
+ << "\t";
+
+ const std::vector<RecordVal> &Vals = I->getValues();
+ for (unsigned i = 0, e = Vals.size(); i != e; ++i)
+ if (!Vals[i].getValue()->isComplete()) {
+ std::cout << Vals[i].getName() << "=";
+ PrintValue(I, Ptr, Vals[i]);
+ std::cout << "\t";
+ }
+
+ std::cout << "\n";// << *I;
+}
+
+static void ParseMachineCode() {
+ unsigned char Buffer[] = { 0x55, // push EBP
+ 0x89, 0xE5, // mov EBP, ESP
+ //0x83, 0xEC, 0x08, // sub ESP, 0x8
+ 0xE8, 1, 2, 3, 4, // call +0x04030201
+ 0x89, 0xEC, // mov ESP, EBP
+ 0x5D, // pop EBP
+ 0xC3, // ret
+ 0x90, // nop
+ 0xC9, // leave
+ 0x89, 0xF6, // mov ESI, ESI
+ 0xB8, 1, 2, 3, 4, // mov EAX, 0x04030201
+ 0x68, 1, 2, 3, 4, // push 0x04030201
+ 0x5e, // pop ESI
+ 0xFF, 0xD0, // call EAX
+ 0x85, 0xC0, // test EAX, EAX
+ 0xF4, // hlt
+ };
+
+ std::vector<Record*> Insts;
+
+ const std::map<std::string, Record*> &Defs = Records.getDefs();
+ Record *Inst = Records.getClass("Instruction");
+ assert(Inst && "Couldn't find Instruction class!");
+
+ for (std::map<std::string, Record*>::const_iterator I = Defs.begin(),
+ E = Defs.end(); I != E; ++I)
+ if (I->second->isSubClassOf(Inst))
+ Insts.push_back(I->second);
+
+ unsigned char *BuffPtr = Buffer;
+ while (1) {
+ Record *R = ParseMachineCode(Insts.begin(), Insts.end(), BuffPtr);
+ if (R == 0) {
+ std::cout << "Parse failed!\n";
+ return;
+ }
+ PrintInstruction(R, BuffPtr);
+
+ unsigned Bits = getNumBits(R);
+ assert((Bits & 7) == 0 && "Instruction is not an even number of bytes!");
+ BuffPtr += Bits/8;
+ }
+}
+
+
+int main(int argc, char **argv) {
+ cl::ParseCommandLineOptions(argc, argv);
+ ParseFile();
+
+ if (Parse) {
+ ParseMachineCode();
+ return 0;
+ }
+
+ if (Class == "") {
+ std::cout << Records; // No argument, dump all contents
+ } else {
+ Record *R = Records.getClass(Class);
+ if (R == 0) {
+ std::cerr << "Cannot find class '" << Class << "'!\n";
+ abort();
+ }
+
+ const std::map<std::string, Record*> &Defs = Records.getDefs();
+ for (std::map<std::string, Record*>::const_iterator I = Defs.begin(),
+ E = Defs.end(); I != E; ++I) {
+ if (I->second->isSubClassOf(R)) {
+ std::cout << I->first << ", ";
+ }
+ }
+ std::cout << "\n";
+ }
+ return 0;
+}
--- /dev/null
+/*===-- FileLexer.l - Scanner for TableGen Files ----------------*- C++ -*-===//
+//
+//
+//===------------------------------------------------------------------------=*/
+
+%option prefix="File"
+%option yylineno
+%option nostdinit
+%option never-interactive
+%option batch
+%option noyywrap
+%option nodefault
+%option 8bit
+%option outfile="Lexer.cpp"
+%option ecs
+%option noreject
+%option noyymore
+
+
+%{
+#include "Record.h"
+typedef std::pair<Record*, std::vector<Init*>*> SubClassRefTy;
+#include "FileParser.h"
+
+// ParseInt - This has to handle the special case of binary numbers 0b0101
+static int ParseInt(const char *Str) {
+ if (Str[0] == '0' && Str[1] == 'b')
+ return strtol(Str+2, 0, 2);
+ return strtol(Str, 0, 0);
+}
+
+%}
+
+Comment \/\/.*
+
+Identifier [a-zA-Z_][0-9a-zA-Z_]*
+Integer [-+]?[0-9]+|0x[0-9a-fA-F]+|0b[01]+
+StringVal \"[^"]*\"
+
+%%
+
+{Comment} { /* Ignore comments */ }
+
+int { return INT; }
+bit { return BIT; }
+bits { return BITS; }
+string { return STRING; }
+list { return LIST; }
+
+class { return CLASS; }
+def { return DEF; }
+field { return FIELD; }
+set { return SET; }
+in { return IN; }
+
+{Identifier} { Filelval.StrVal = new std::string(yytext, yytext+yyleng);
+ return ID; }
+
+{StringVal} { Filelval.StrVal = new std::string(yytext+1, yytext+yyleng-1);
+ return STRVAL; }
+
+{Integer} { Filelval.IntVal = ParseInt(Filetext); return INTVAL; }
+
+[ \t\n]+ { /* Ignore whitespace */ }
+. { return Filetext[0]; }
+%%
--- /dev/null
+//===-- FileParser.y - Parser for TableGen files ----------------*- C++ -*-===//
+//
+// This file implements the bison parser for Table Generator files...
+//
+//===------------------------------------------------------------------------=//
+
+%{
+#include "Record.h"
+#include <iostream>
+#include <algorithm>
+#include <string>
+#include <stdio.h>
+#define YYERROR_VERBOSE 1
+
+int yyerror(const char *ErrorMsg);
+int yylex();
+extern FILE *Filein;
+extern int Filelineno;
+int Fileparse();
+static Record *CurRec = 0;
+
+typedef std::pair<Record*, std::vector<Init*>*> SubClassRefTy;
+
+static std::vector<std::pair<std::pair<std::string, std::vector<unsigned>*>,
+ Init*> > SetStack;
+
+void ParseFile() {
+ FILE *F = stdin;
+
+ Filein = F;
+ Filelineno = 1;
+ Fileparse();
+ Filein = stdin;
+}
+
+static std::ostream &err() {
+ return std::cerr << "Parsing Line #" << Filelineno << ": ";
+}
+
+static void addValue(const RecordVal &RV) {
+ if (CurRec->getValue(RV.getName())) {
+ err() << "Value '" << RV.getName() << "' multiply defined!\n";
+ abort();
+ }
+
+ CurRec->addValue(RV);
+}
+
+static void addSuperClass(Record *SC) {
+ if (CurRec->isSubClassOf(SC)) {
+ err() << "Already subclass of '" << SC->getName() << "'!\n";
+ abort();
+ }
+ CurRec->addSuperClass(SC);
+}
+
+static void setValue(const std::string &ValName,
+ std::vector<unsigned> *BitList, Init *V) {
+ if (!V) return ;
+
+ RecordVal *RV = CurRec->getValue(ValName);
+ if (RV == 0) {
+ err() << "Value '" << ValName << "' unknown!\n";
+ abort();
+ }
+
+ // If we are assigning to a subset of the bits in the value... then we must be
+ // assigning to a field of BitsRecTy, which must have a BitsInit
+ // initializer...
+ //
+ if (BitList) {
+ BitsInit *CurVal = dynamic_cast<BitsInit*>(RV->getValue());
+ if (CurVal == 0) {
+ err() << "Value '" << ValName << "' is not a bits type!\n";
+ abort();
+ }
+
+ // Convert the incoming value to a bits type of the appropriate size...
+ Init *BI = V->convertInitializerTo(new BitsRecTy(BitList->size()));
+ if (BI == 0) {
+ V->convertInitializerTo(new BitsRecTy(BitList->size()));
+ err() << "Initializer '" << *V << "' not compatible with bit range!\n";
+ abort();
+ }
+
+ // We should have a BitsInit type now...
+ assert(dynamic_cast<BitsInit*>(BI) != 0 || &(std::cerr << *BI) == 0);
+ BitsInit *BInit = (BitsInit*)BI;
+
+ BitsInit *NewVal = new BitsInit(CurVal->getNumBits());
+
+ for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
+ NewVal->setBit(i, CurVal->getBit(i));
+
+ // Loop over bits, assigning values as appopriate...
+ for (unsigned i = 0, e = BitList->size(); i != e; ++i) {
+ unsigned Bit = (*BitList)[i];
+ NewVal->setBit(Bit, BInit->getBit(i));
+ }
+ V = NewVal;
+ }
+
+ if (RV->setValue(V)) {
+ err() << "Value '" << ValName << "' of type '" << *RV->getType()
+ << "' is incompatible with initializer '" << *V << "'!\n";
+ abort();
+ }
+}
+
+static void addSubClass(Record *SC, const std::vector<Init*> &TemplateArgs) {
+ // Add all of the values in the subclass into the current class...
+ const std::vector<RecordVal> &Vals = SC->getValues();
+ for (unsigned i = 0, e = Vals.size(); i != e; ++i)
+ addValue(Vals[i]);
+
+ const std::vector<std::string> &TArgs = SC->getTemplateArgs();
+
+ // Ensure that an appropriate number of template arguments are specified...
+ if (TArgs.size() < TemplateArgs.size()) {
+ err() << "ERROR: More template args specified thang expected!\n";
+ abort();
+ } else { // This class expects template arguments...
+ // Loop over all of the template arguments, setting them to the specified
+ // value or leaving them as the default as neccesary.
+ for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
+ if (i < TemplateArgs.size()) { // A value is specified for this temp-arg?
+ // Set it now.
+ setValue(TArgs[i], 0, TemplateArgs[i]);
+ } else if (!CurRec->getValue(TArgs[i])->getValue()->isComplete()) {
+ err() << "ERROR: Value not specified for template argument #"
+ << i << " (" << TArgs[i] << ") of subclass '" << SC->getName()
+ << "'!\n";
+ abort();
+ }
+ }
+ }
+
+
+ // Since everything went well, we can now set the "superclass" list for the
+ // current record.
+ const std::vector<Record*> &SCs = SC->getSuperClasses();
+ for (unsigned i = 0, e = SCs.size(); i != e; ++i)
+ addSuperClass(SCs[i]);
+ addSuperClass(SC);
+}
+
+
+%}
+
+%union {
+ std::string *StrVal;
+ int IntVal;
+ RecTy *Ty;
+ Init *Initializer;
+ std::vector<Init*> *FieldList;
+ std::vector<Record*> *RecPtr;
+ std::vector<unsigned>*BitList;
+ Record *Rec;
+ SubClassRefTy *SubClassRef;
+ std::vector<SubClassRefTy> *SubClassList;
+};
+
+%token INT BIT STRING BITS LIST CLASS DEF FIELD SET IN
+%token <IntVal> INTVAL
+%token <StrVal> ID STRVAL
+
+%type <Ty> Type
+%type <RecPtr> DefList DefListNE
+%type <Rec> ClassInst DefInst Object ObjectBody ClassID DefID
+
+%type <SubClassRef> SubClassRef
+%type <SubClassList> ClassList ClassListNE
+%type <IntVal> OptPrefix
+%type <Initializer> Value OptValue
+%type <FieldList> ValueList ValueListNE
+%type <BitList> BitList OptBitList RBitList
+%type <StrVal> Declaration
+
+%start File
+%%
+
+ClassID : ID {
+ $$ = Records.getClass(*$1);
+ if ($$ == 0) {
+ err() << "Couldn't find class '" << *$1 << "'!\n";
+ abort();
+ }
+ delete $1;
+ };
+
+DefID : ID {
+ $$ = Records.getDef(*$1);
+ if ($$ == 0) {
+ err() << "Couldn't find def '" << *$1 << "'!\n";
+ abort();
+ }
+ delete $1;
+ };
+
+
+// TableGen types...
+Type : STRING { // string type
+ $$ = new StringRecTy();
+ } | BIT { // bit type
+ $$ = new BitRecTy();
+ } | BITS '<' INTVAL '>' { // bits<x> type
+ $$ = new BitsRecTy($3);
+ } | INT { // int type
+ $$ = new IntRecTy();
+ } | LIST '<' ClassID '>' { // list<x> type
+ $$ = new ListRecTy($3);
+ } | ClassID { // Record Type
+ $$ = new RecordRecTy($1);
+ };
+
+OptPrefix : /*empty*/ { $$ = 0; } | FIELD { $$ = 1; };
+
+OptValue : /*empty*/ { $$ = 0; } | '=' Value { $$ = $2; };
+
+Value : INTVAL {
+ $$ = new IntInit($1);
+ } | STRVAL {
+ $$ = new StringInit(*$1);
+ delete $1;
+ } | '?' {
+ $$ = new UnsetInit();
+ } | '{' ValueList '}' {
+ BitsInit *Init = new BitsInit($2->size());
+ for (unsigned i = 0, e = $2->size(); i != e; ++i) {
+ struct Init *Bit = (*$2)[i]->convertInitializerTo(new BitRecTy());
+ if (Bit == 0) {
+ err() << "Element #" << i << " (" << *(*$2)[i]
+ << ") is not convertable to a bit!\n";
+ abort();
+ }
+ Init->setBit($2->size()-i-1, Bit);
+ }
+ $$ = Init;
+ delete $2;
+ } | ID {
+ if (const RecordVal *RV = CurRec->getValue(*$1)) {
+ $$ = new VarInit(*$1, RV->getType());
+ } else if (Record *D = Records.getDef(*$1)) {
+ $$ = new DefInit(D);
+ } else {
+ err() << "Variable not defined: '" << *$1 << "'!\n";
+ abort();
+ }
+
+ delete $1;
+ } | Value '{' BitList '}' {
+ $$ = $1->convertInitializerBitRange(*$3);
+ if ($$ == 0) {
+ err() << "Invalid bit range for value '" << *$1 << "'!\n";
+ abort();
+ }
+ delete $3;
+ } | '[' DefList ']' {
+ $$ = new ListInit(*$2);
+ delete $2;
+ };
+
+DefList : /*empty */ {
+ $$ = new std::vector<Record*>();
+ } | DefListNE {
+ $$ = $1;
+ };
+DefListNE : DefID {
+ $$ = new std::vector<Record*>();
+ $$->push_back($1);
+ } | DefListNE ',' DefID {
+ ($$=$1)->push_back($3);
+ };
+
+
+RBitList : INTVAL {
+ $$ = new std::vector<unsigned>();
+ $$->push_back($1);
+ } | INTVAL '-' INTVAL {
+ if ($1 < $3 || $1 < 0 || $3 < 0) {
+ err() << "Invalid bit range: " << $1 << "-" << $3 << "!\n";
+ abort();
+ }
+ $$ = new std::vector<unsigned>();
+ for (int i = $1; i >= $3; --i)
+ $$->push_back(i);
+ } | INTVAL INTVAL {
+ $2 = -$2;
+ if ($1 < $2 || $1 < 0 || $2 < 0) {
+ err() << "Invalid bit range: " << $1 << "-" << $2 << "!\n";
+ abort();
+ }
+ $$ = new std::vector<unsigned>();
+ for (int i = $1; i >= $2; --i)
+ $$->push_back(i);
+ } | RBitList ',' INTVAL {
+ ($$=$1)->push_back($3);
+ } | RBitList ',' INTVAL '-' INTVAL {
+ if ($3 < $5 || $3 < 0 || $5 < 0) {
+ err() << "Invalid bit range: " << $3 << "-" << $5 << "!\n";
+ abort();
+ }
+ $$ = $1;
+ for (int i = $3; i >= $5; --i)
+ $$->push_back(i);
+ } | RBitList ',' INTVAL INTVAL {
+ $4 = -$4;
+ if ($3 < $4 || $3 < 0 || $4 < 0) {
+ err() << "Invalid bit range: " << $3 << "-" << $4 << "!\n";
+ abort();
+ }
+ $$ = $1;
+ for (int i = $3; i >= $4; --i)
+ $$->push_back(i);
+ };
+
+BitList : RBitList { $$ = $1; std::reverse($1->begin(), $1->end()); };
+
+OptBitList : /*empty*/ { $$ = 0; } | '{' BitList '}' { $$ = $2; };
+
+
+
+ValueList : /*empty*/ {
+ $$ = new std::vector<Init*>();
+ } | ValueListNE {
+ $$ = $1;
+ };
+
+ValueListNE : Value {
+ $$ = new std::vector<Init*>();
+ $$->push_back($1);
+ } | ValueListNE ',' Value {
+ ($$ = $1)->push_back($3);
+ };
+
+Declaration : OptPrefix Type ID OptValue {
+ addValue(RecordVal(*$3, $2, $1));
+ setValue(*$3, 0, $4);
+ $$ = $3;
+};
+
+BodyItem : Declaration ';' {
+ delete $1;
+} | SET ID OptBitList '=' Value ';' {
+ setValue(*$2, $3, $5);
+ delete $2;
+ delete $3;
+};
+
+BodyList : /*empty*/ | BodyList BodyItem;
+Body : ';' | '{' BodyList '}';
+
+SubClassRef : ClassID {
+ $$ = new SubClassRefTy($1, new std::vector<Init*>());
+ } | ClassID '<' ValueListNE '>' {
+ $$ = new SubClassRefTy($1, $3);
+ };
+
+ClassListNE : SubClassRef {
+ $$ = new std::vector<SubClassRefTy>();
+ $$->push_back(*$1);
+ delete $1;
+ }
+ | ClassListNE ',' SubClassRef {
+ ($$=$1)->push_back(*$3);
+ delete $3;
+ };
+
+ClassList : /*empty */ {
+ $$ = new std::vector<SubClassRefTy>();
+ }
+ | ':' ClassListNE {
+ $$ = $2;
+ };
+
+DeclListNE : Declaration {
+ CurRec->addTemplateArg(*$1);
+ delete $1;
+} | DeclListNE ',' Declaration {
+ CurRec->addTemplateArg(*$3);
+ delete $3;
+};
+
+TemplateArgList : '<' DeclListNE '>' {};
+OptTemplateArgList : /*empty*/ | TemplateArgList;
+
+ObjectBody : ID {
+ CurRec = new Record(*$1);
+ delete $1;
+ } OptTemplateArgList ClassList {
+ for (unsigned i = 0, e = $4->size(); i != e; ++i) {
+ addSubClass((*$4)[i].first, *(*$4)[i].second);
+ delete (*$4)[i].second; // Delete the template list
+ }
+ delete $4;
+
+ // Process any variables on the set stack...
+ for (unsigned i = 0, e = SetStack.size(); i != e; ++i)
+ setValue(SetStack[i].first.first, SetStack[i].first.second,
+ SetStack[i].second);
+ } Body {
+ CurRec->resolveReferences();
+ $$ = CurRec;
+ CurRec = 0;
+};
+
+ClassInst : CLASS ObjectBody {
+ if (Records.getClass($2->getName())) {
+ err() << "Class '" << $2->getName() << "' already defined!\n";
+ abort();
+ }
+ Records.addClass($$ = $2);
+};
+
+DefInst : DEF ObjectBody {
+ // TODO: If ObjectBody has template arguments, it's an error.
+ if (Records.getDef($2->getName())) {
+ err() << "Def '" << $2->getName() << "' already defined!\n";
+ abort();
+ }
+ Records.addDef($$ = $2);
+};
+
+
+Object : ClassInst | DefInst;
+
+// Support Set commands wrapping objects...
+Object : SET ID OptBitList '=' Value IN {
+ SetStack.push_back(std::make_pair(std::make_pair(*$2, $3), $5));
+ delete $2;
+ } '{' ObjectList '}' {
+ delete SetStack.back().first.second; // Delete OptBitList
+ SetStack.pop_back();
+ };
+
+ObjectList : Object {} | ObjectList Object {};
+
+File : ObjectList {};
+
+%%
+
+int yyerror(const char *ErrorMsg) {
+ err() << "Error parsing: " << ErrorMsg << "\n";
+ abort();
+}
--- /dev/null
+LEVEL = ../..
+TOOLNAME = tblgen
+USEDLIBS = support.a
+
+include $(LEVEL)/Makefile.common
+
+clean::
+ -rm -f FileParser.cpp FileParser.h FileLexer.cpp CommandLine.cpp
+ -rm -f FileParser.output
+
+test::
+ $(TOOLEXENAME_G) < X86.td
+ # -parse
+
+ @echo "enum {"
+ @$(TOOLEXENAME_G) < X86.td -class=Register
+ @echo
+ @echo "};"
+
+ @echo "enum {"
+ @$(TOOLEXENAME_G) < X86.td -class=Instruction
+ @echo
+ @echo "};"
--- /dev/null
+//===- Record.cpp - Record implementation ---------------------------------===//
+//
+//
+//===----------------------------------------------------------------------===//
+
+#include "Record.h"
+
+//===----------------------------------------------------------------------===//
+// Type implementations
+//===----------------------------------------------------------------------===//
+
+void RecTy::dump() const { print(std::cerr); }
+
+Init *BitRecTy::convertValue(BitsInit *BI) {
+ if (BI->getNumBits() != 1) return 0; // Only accept if just one bit!
+ return BI->getBit(0);
+}
+
+Init *BitRecTy::convertValue(IntInit *II) {
+ int Val = II->getValue();
+ if (Val != 0 && Val != 1) return 0; // Only accept 0 or 1 for a bit!
+ delete II;
+
+ return new BitInit(Val != 0);
+}
+
+Init *BitRecTy::convertValue(VarInit *VI) {
+ if (dynamic_cast<BitRecTy*>(VI->getType()))
+ return VI; // Accept variable if it is already of bit type!
+ return 0;
+}
+
+Init *BitsRecTy::convertValue(UnsetInit *UI) {
+ BitsInit *Ret = new BitsInit(Size);
+
+ for (unsigned i = 0; i != Size; ++i)
+ Ret->setBit(i, new UnsetInit());
+ return Ret;
+}
+
+Init *BitsRecTy::convertValue(BitInit *UI) {
+ if (Size != 1) return 0; // Can only convert single bit...
+ BitsInit *Ret = new BitsInit(1);
+ Ret->setBit(0, UI);
+ return Ret;
+}
+
+// convertValue from Int initializer to bits type: Split the integer up into the
+// appropriate bits...
+//
+Init *BitsRecTy::convertValue(IntInit *II) {
+ int Value = II->getValue();
+ delete II;
+
+ BitsInit *Ret = new BitsInit(Size);
+ for (unsigned i = 0; i != Size; ++i)
+ Ret->setBit(i, new BitInit(Value & (1 << i)));
+ return Ret;
+}
+
+Init *BitsRecTy::convertValue(BitsInit *BI) {
+ // If the number of bits is right, return it. Otherwise we need to expand or
+ // truncate...
+ if (BI->getNumBits() == Size) return BI;
+ return 0;
+}
+
+Init *BitsRecTy::convertValue(VarInit *VI) {
+ if (BitsRecTy *BRT = dynamic_cast<BitsRecTy*>(VI->getType()))
+ if (BRT->Size == Size) {
+ BitsInit *Ret = new BitsInit(Size);
+ for (unsigned i = 0; i != Size; ++i)
+ Ret->setBit(i, new VarBitInit(VI, i));
+ return Ret;
+ }
+ if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType())) {
+ BitsInit *Ret = new BitsInit(1);
+ Ret->setBit(0, VI);
+ return Ret;
+ }
+
+ return 0;
+}
+
+
+Init *IntRecTy::convertValue(BitsInit *BI) {
+ int Result = 0;
+ for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
+ if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) {
+ Result |= Bit->getValue() << i;
+ } else {
+ return 0;
+ }
+ return new IntInit(Result);
+}
+
+Init *IntRecTy::convertValue(VarInit *VI) {
+ if (dynamic_cast<IntRecTy*>(VI->getType()))
+ return VI; // Accept variable if already of the right type!
+ return 0;
+}
+
+Init *StringRecTy::convertValue(VarInit *VI) {
+ if (dynamic_cast<StringRecTy*>(VI->getType()))
+ return VI; // Accept variable if already of the right type!
+ return 0;
+}
+
+void ListRecTy::print(std::ostream &OS) const {
+ OS << "list<" << Class->getName() << ">";
+}
+
+Init *ListRecTy::convertValue(ListInit *LI) {
+ // Verify that all of the elements of the list are subclasses of the
+ // appopriate class!
+ for (unsigned i = 0, e = LI->getSize(); i != e; ++i)
+ if (!LI->getElement(i)->isSubClassOf(Class))
+ return 0;
+ return LI;
+}
+
+void RecordRecTy::print(std::ostream &OS) const {
+ OS << Rec->getName();
+}
+
+Init *RecordRecTy::convertValue(DefInit *DI) {
+ // Ensure that DI is a subclass of Rec.
+ if (!DI->getDef()->isSubClassOf(Rec))
+ return 0;
+ return DI;
+}
+
+//===----------------------------------------------------------------------===//
+// Initializer implementations
+//===----------------------------------------------------------------------===//
+
+void Init::dump() const { return print(std::cerr); }
+
+Init *BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+ BitsInit *BI = new BitsInit(Bits.size());
+ for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
+ if (Bits[i] >= getNumBits()) {
+ delete BI;
+ return 0;
+ }
+ BI->setBit(i, getBit(Bits[i]));
+ }
+ return BI;
+}
+
+void BitsInit::print(std::ostream &OS) const {
+ //if (!printInHex(OS)) return;
+ if (!printAsVariable(OS)) return;
+ if (!printAsUnset(OS)) return;
+
+ OS << "{ ";
+ for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
+ if (i) OS << ", ";
+ getBit(e-i-1)->print(OS);
+ }
+ OS << " }";
+}
+
+bool BitsInit::printInHex(std::ostream &OS) const {
+ // First, attempt to convert the value into an integer value...
+ int Result = 0;
+ for (unsigned i = 0, e = getNumBits(); i != e; ++i)
+ if (BitInit *Bit = dynamic_cast<BitInit*>(getBit(i))) {
+ Result |= Bit->getValue() << i;
+ } else {
+ return true;
+ }
+
+ OS << "0x" << std::hex << Result << std::dec;
+ return false;
+}
+
+bool BitsInit::printAsVariable(std::ostream &OS) const {
+ // Get the variable that we may be set equal to...
+ assert(getNumBits() != 0);
+ VarBitInit *FirstBit = dynamic_cast<VarBitInit*>(getBit(0));
+ if (FirstBit == 0) return true;
+ VarInit *Var = FirstBit->getVariable();
+
+ // Check to make sure the types are compatible.
+ BitsRecTy *Ty = dynamic_cast<BitsRecTy*>(Var->getType());
+ if (Ty == 0) return true;
+ if (Ty->getNumBits() != getNumBits()) return true; // Incompatible types!
+
+ // Check to make sure all bits are referring to the right bits in the variable
+ for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
+ VarBitInit *Bit = dynamic_cast<VarBitInit*>(getBit(i));
+ if (Bit == 0 || Bit->getVariable() != Var || Bit->getBitNum() != i)
+ return true;
+ }
+
+ OS << Var->getName();
+ return false;
+}
+
+bool BitsInit::printAsUnset(std::ostream &OS) const {
+ for (unsigned i = 0, e = getNumBits(); i != e; ++i)
+ if (!dynamic_cast<UnsetInit*>(getBit(i)))
+ return true;
+ OS << "?";
+ return false;
+}
+
+Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+ BitsInit *BI = new BitsInit(Bits.size());
+
+ for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
+ if (Bits[i] >= 32) {
+ delete BI;
+ return 0;
+ }
+ BI->setBit(i, new BitInit(Value & (1 << Bits[i])));
+ }
+ return BI;
+}
+
+void ListInit::print(std::ostream &OS) const {
+ OS << "[";
+ for (unsigned i = 0, e = Records.size(); i != e; ++i) {
+ if (i) OS << ", ";
+ OS << Records[i]->getName();
+ }
+ OS << "]";
+}
+
+Init *VarInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+ BitsRecTy *T = dynamic_cast<BitsRecTy*>(Ty);
+ if (T == 0) return 0; // Cannot subscript a non-bits variable...
+ unsigned NumBits = T->getNumBits();
+
+ BitsInit *BI = new BitsInit(Bits.size());
+ for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
+ if (Bits[i] >= NumBits) {
+ delete BI;
+ return 0;
+ }
+ BI->setBit(i, new VarBitInit(this, Bits[i]));
+ }
+ return BI;
+}
+
+Init *BitsInit::resolveReferences(Record &R) {
+ bool Changed = false;
+ BitsInit *New = new BitsInit(getNumBits());
+
+ for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
+ Init *B;
+ New->setBit(i, getBit(i));
+ do {
+ B = New->getBit(i);
+ New->setBit(i, B->resolveReferences(R));
+ Changed |= B != New->getBit(i);
+ } while (B != New->getBit(i));
+ }
+
+ if (Changed)
+ return New;
+ delete New;
+ return this;
+}
+
+
+
+Init *VarBitInit::resolveReferences(Record &R) {
+ if (R.isTemplateArg(getVariable()->getName()))
+ return this;
+
+ RecordVal *RV = R.getValue(getVariable()->getName());
+ assert(RV && "Reference to a non-existant variable?");
+ assert(dynamic_cast<BitsInit*>(RV->getValue()));
+ BitsInit *BI = (BitsInit*)RV->getValue();
+
+ assert(getBitNum() < BI->getNumBits() && "Bit reference out of range!");
+ Init *B = BI->getBit(getBitNum());
+
+ if (!dynamic_cast<UnsetInit*>(B)) // If the bit is not set...
+ return B; // Replace the VarBitInit with it.
+ return this;
+}
+
+void DefInit::print(std::ostream &OS) const {
+ OS << Def->getName();
+}
+
+//===----------------------------------------------------------------------===//
+// Other implementations
+//===----------------------------------------------------------------------===//
+
+RecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P)
+ : Name(N), Ty(T), Prefix(P) {
+ Value = Ty->convertValue(new UnsetInit());
+ assert(Value && "Cannot create unset value for current type!");
+}
+
+void RecordVal::dump() const { std::cerr << *this; }
+
+void RecordVal::print(std::ostream &OS, bool PrintSem) const {
+ if (getPrefix()) OS << "field ";
+ OS << *getType() << " " << getName();
+ if (getValue()) {
+ OS << " = " << *getValue();
+ }
+ if (PrintSem) OS << ";\n";
+}
+
+// resolveReferences - If there are any field references that refer to fields
+// that have been filled in, we can propagate the values now.
+//
+void Record::resolveReferences() {
+ for (unsigned i = 0, e = Values.size(); i != e; ++i)
+ Values[i].setValue(Values[i].getValue()->resolveReferences(*this));
+}
+
+void Record::dump() const { std::cerr << *this; }
+
+std::ostream &operator<<(std::ostream &OS, const Record &R) {
+ OS << R.getName();
+
+ const std::vector<std::string> &TArgs = R.getTemplateArgs();
+ if (!TArgs.empty()) {
+ OS << "<";
+ for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
+ if (i) OS << ", ";
+ const RecordVal *RV = R.getValue(TArgs[i]);
+ assert(RV && "Template argument record not found??");
+ RV->print(OS, false);
+ }
+ OS << ">";
+ }
+
+ OS << " {";
+ const std::vector<Record*> &SC = R.getSuperClasses();
+ if (!SC.empty()) {
+ OS << "\t//";
+ for (unsigned i = 0, e = SC.size(); i != e; ++i)
+ OS << " " << SC[i]->getName();
+ }
+ OS << "\n";
+
+ const std::vector<RecordVal> &Vals = R.getValues();
+ for (unsigned i = 0, e = Vals.size(); i != e; ++i)
+ if (Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName()))
+ OS << Vals[i];
+ for (unsigned i = 0, e = Vals.size(); i != e; ++i)
+ if (!Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName()))
+ OS << Vals[i];
+
+ return OS << "}\n";
+}
+
+void RecordKeeper::dump() const { std::cerr << *this; }
+
+std::ostream &operator<<(std::ostream &OS, const RecordKeeper &RK) {
+ OS << "------------- Classes -----------------\n";
+ const std::map<std::string, Record*> &Classes = RK.getClasses();
+ for (std::map<std::string, Record*>::const_iterator I = Classes.begin(),
+ E = Classes.end(); I != E; ++I)
+ OS << "class " << *I->second;
+
+ OS << "------------- Defs -----------------\n";
+ const std::map<std::string, Record*> &Defs = RK.getDefs();
+ for (std::map<std::string, Record*>::const_iterator I = Defs.begin(),
+ E = Defs.end(); I != E; ++I)
+ OS << "def " << *I->second;
+ return OS;
+}
--- /dev/null
+//===- Record.h - Classes to represent Table Records ------------*- C++ -*-===//
+//
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef RECORD_H
+#define RECORD_H
+
+#include <string>
+#include <vector>
+#include <map>
+#include <iostream>
+class Init;
+class UnsetInit;
+class BitInit;
+class BitsInit;
+class IntInit;
+class StringInit;
+class ListInit;
+class VarInit;
+class VarBitInit;
+class DefInit;
+class Record;
+
+//===----------------------------------------------------------------------===//
+// Type Classes
+//===----------------------------------------------------------------------===//
+
+struct RecTy {
+ virtual ~RecTy() {}
+
+ virtual Init *convertValue( UnsetInit *UI) { return 0; }
+ virtual Init *convertValue( BitInit *BI) { return 0; }
+ virtual Init *convertValue( BitsInit *BI) { return 0; }
+ virtual Init *convertValue( IntInit *II) { return 0; }
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( VarInit *VI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+
+ virtual void print(std::ostream &OS) const = 0;
+ void dump() const;
+};
+
+inline std::ostream &operator<<(std::ostream &OS, const RecTy &Ty) {
+ Ty.print(OS);
+ return OS;
+}
+
+struct BitRecTy : public RecTy {
+ Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
+ Init *convertValue(BitInit *BI) { return (Init*)BI; }
+ Init *convertValue(BitsInit *BI);
+ Init *convertValue(IntInit *II);
+ Init *convertValue(VarInit *VI);
+
+ void print(std::ostream &OS) const { OS << "bit"; }
+};
+
+class BitsRecTy : public RecTy {
+ unsigned Size;
+public:
+ BitsRecTy(unsigned Sz) : Size(Sz) {}
+
+ unsigned getNumBits() const { return Size; }
+
+ Init *convertValue(UnsetInit *UI);
+ Init *convertValue(BitInit *UI);
+ Init *convertValue(BitsInit *BI);
+ Init *convertValue(IntInit *II);
+ Init *convertValue(VarInit *VI);
+
+ void print(std::ostream &OS) const { OS << "bits<" << Size << ">"; }
+};
+
+struct IntRecTy : public RecTy {
+ Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
+ Init *convertValue(IntInit *II) { return (Init*)II; }
+ Init *convertValue(BitsInit *BI);
+ Init *convertValue(VarInit *VI);
+
+ void print(std::ostream &OS) const { OS << "int"; }
+};
+
+struct StringRecTy : public RecTy {
+ Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
+ Init *convertValue(StringInit *SI) { return (Init*)SI; }
+ Init *convertValue(VarInit *VI);
+ void print(std::ostream &OS) const { OS << "string"; }
+};
+
+class ListRecTy : public RecTy {
+ Record *Class;
+public:
+ ListRecTy(Record *C) : Class(C) {}
+ Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
+ Init *convertValue(ListInit *LI);
+
+ void print(std::ostream &OS) const;
+};
+
+class RecordRecTy : public RecTy {
+ Record *Rec;
+public:
+ RecordRecTy(Record *R) : Rec(R) {}
+
+ Init *convertValue(UnsetInit *UI) { return (Init*)UI; }
+ Init *convertValue( DefInit *DI);
+
+ void print(std::ostream &OS) const;
+};
+
+//===----------------------------------------------------------------------===//
+// Initializer Classes
+//===----------------------------------------------------------------------===//
+
+struct Init {
+ virtual ~Init() {}
+
+ virtual bool isComplete() const = 0;
+ virtual void print(std::ostream &OS) const = 0;
+ void dump() const;
+
+ virtual Init *convertInitializerTo(RecTy *Ty) = 0;
+ virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+ return 0;
+ }
+
+ virtual Init *resolveReferences(Record &R) { return this; }
+};
+
+inline std::ostream &operator<<(std::ostream &OS, const Init &I) {
+ I.print(OS); return OS;
+}
+
+struct UnsetInit : public Init {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ virtual bool isComplete() const { return false; }
+ virtual void print(std::ostream &OS) const { OS << "?"; }
+};
+
+class BitInit : public Init {
+ bool Value;
+public:
+ BitInit(bool V) : Value(V) {}
+
+ bool getValue() const { return Value; }
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ virtual bool isComplete() const { return true; }
+ virtual void print(std::ostream &OS) const { OS << (Value ? "1" : "0"); }
+};
+
+class BitsInit : public Init {
+ std::vector<Init*> Bits;
+public:
+ BitsInit(unsigned Size) : Bits(Size) {}
+
+ unsigned getNumBits() const { return Bits.size(); }
+
+ Init *getBit(unsigned Bit) const {
+ assert(Bit < Bits.size() && "Bit index out of range!");
+ return Bits[Bit];
+ }
+ void setBit(unsigned Bit, Init *V) {
+ assert(Bit < Bits.size() && "Bit index out of range!");
+ Bits[Bit] = V;
+ }
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+ virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
+
+ virtual bool isComplete() const {
+ for (unsigned i = 0; i != getNumBits(); ++i)
+ if (!getBit(i)->isComplete()) return false;
+ return true;
+ }
+ virtual void print(std::ostream &OS) const;
+
+ virtual Init *resolveReferences(Record &R);
+
+ // printXX - Print this bitstream with the specified format, returning true if
+ // it is not possible.
+ bool printInHex(std::ostream &OS) const;
+ bool printAsVariable(std::ostream &OS) const;
+ bool printAsUnset(std::ostream &OS) const;
+};
+
+class IntInit : public Init {
+ int Value;
+public:
+ IntInit(int V) : Value(V) {}
+
+ int getValue() const { return Value; }
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+ virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
+
+ virtual bool isComplete() const { return true; }
+ virtual void print(std::ostream &OS) const { OS << Value; }
+};
+
+class StringInit : public Init {
+ std::string Value;
+public:
+ StringInit(const std::string &V) : Value(V) {}
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ virtual bool isComplete() const { return true; }
+ virtual void print(std::ostream &OS) const { OS << "\"" << Value << "\""; }
+};
+
+class ListInit : public Init {
+ std::vector<Record*> Records;
+public:
+ ListInit(std::vector<Record*> &Rs) {
+ Records.swap(Rs);
+ }
+
+ unsigned getSize() const { return Records.size(); }
+ Record *getElement(unsigned i) const {
+ assert(i < Records.size() && "List element index out of range!");
+ return Records[i];
+ }
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ virtual bool isComplete() const { return true; }
+ virtual void print(std::ostream &OS) const;
+};
+
+class VarInit : public Init {
+ std::string VarName;
+ RecTy *Ty;
+public:
+ VarInit(const std::string &VN, RecTy *T) : VarName(VN), Ty(T) {}
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ const std::string &getName() const { return VarName; }
+ RecTy *getType() const { return Ty; }
+
+ virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
+
+ virtual bool isComplete() const { return true; }
+ virtual void print(std::ostream &OS) const { OS << VarName; }
+};
+
+class VarBitInit : public Init {
+ VarInit *VI;
+ unsigned Bit;
+public:
+ VarBitInit(VarInit *V, unsigned B) : VI(V), Bit(B) {}
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ VarInit *getVariable() const { return VI; }
+ unsigned getBitNum() const { return Bit; }
+
+ virtual bool isComplete() const { return true; }
+ virtual void print(std::ostream &OS) const {
+ VI->print(OS); OS << "{" << Bit << "}";
+ }
+ virtual Init *resolveReferences(Record &R);
+};
+
+class DefInit : public Init {
+ Record *Def;
+public:
+ DefInit(Record *D) : Def(D) {}
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ Record *getDef() const { return Def; }
+
+ //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
+
+ virtual bool isComplete() const { return true; }
+ virtual void print(std::ostream &OS) const;
+};
+
+
+
+//===----------------------------------------------------------------------===//
+// High-Level Classes
+//===----------------------------------------------------------------------===//
+
+class RecordVal {
+ std::string Name;
+ RecTy *Ty;
+ unsigned Prefix;
+ Init *Value;
+public:
+ RecordVal(const std::string &N, RecTy *T, unsigned P);
+ ~RecordVal() { /*delete Ty; delete Value; Bad for copy ctor!*/ }
+
+ const std::string &getName() const { return Name; }
+
+ unsigned getPrefix() const { return Prefix; }
+ RecTy *getType() const { return Ty; }
+ Init *getValue() const { return Value; }
+
+ bool setValue(Init *V) {
+ if (V) {
+ Value = V->convertInitializerTo(Ty);
+ return Value == 0;
+ }
+ Value = 0;
+ return false;
+ }
+
+ void dump() const;
+ void print(std::ostream &OS, bool PrintSem = true) const;
+};
+
+inline std::ostream &operator<<(std::ostream &OS, const RecordVal &RV) {
+ RV.print(OS << " ");
+ return OS;
+}
+
+struct Record {
+ const std::string Name;
+ std::vector<std::string> TemplateArgs;
+ std::vector<RecordVal> Values;
+ std::vector<Record*> SuperClasses;
+public:
+
+ Record(const std::string &N) : Name(N) {}
+ ~Record() {}
+
+ const std::string &getName() const { return Name; }
+ const std::vector<std::string> &getTemplateArgs() const {
+ return TemplateArgs;
+ }
+ const std::vector<RecordVal> &getValues() const { return Values; }
+ const std::vector<Record*> &getSuperClasses() const { return SuperClasses; }
+
+ bool isTemplateArg(const std::string &Name) const {
+ for (unsigned i = 0, e = TemplateArgs.size(); i != e; ++i)
+ if (TemplateArgs[i] == Name) return true;
+ return false;
+ }
+
+ const RecordVal *getValue(const std::string &Name) const {
+ for (unsigned i = 0, e = Values.size(); i != e; ++i)
+ if (Values[i].getName() == Name) return &Values[i];
+ return 0;
+ }
+ RecordVal *getValue(const std::string &Name) {
+ for (unsigned i = 0, e = Values.size(); i != e; ++i)
+ if (Values[i].getName() == Name) return &Values[i];
+ return 0;
+ }
+
+ void addTemplateArg(const std::string &Name) {
+ assert(!isTemplateArg(Name) && "Template arg already defined!");
+ TemplateArgs.push_back(Name);
+ }
+
+ void addValue(const RecordVal &RV) {
+ assert(getValue(RV.getName()) == 0 && "Value already added!");
+ Values.push_back(RV);
+ }
+
+ bool isSubClassOf(Record *R) const {
+ for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
+ if (SuperClasses[i] == R)
+ return true;
+ return false;
+ }
+
+ void addSuperClass(Record *R) {
+ assert(!isSubClassOf(R) && "Already subclassing record!");
+ SuperClasses.push_back(R);
+ }
+
+ // resolveReferences - If there are any field references that refer to fields
+ // that have been filled in, we can propagate the values now.
+ //
+ void resolveReferences();
+
+ void dump() const;
+};
+
+std::ostream &operator<<(std::ostream &OS, const Record &R);
+
+class RecordKeeper {
+ std::map<std::string, Record*> Classes, Defs;
+public:
+ ~RecordKeeper() {
+ for (std::map<std::string, Record*>::iterator I = Classes.begin(),
+ E = Classes.end(); I != E; ++I)
+ delete I->second;
+ for (std::map<std::string, Record*>::iterator I = Defs.begin(),
+ E = Defs.end(); I != E; ++I)
+ delete I->second;
+ }
+
+ const std::map<std::string, Record*> &getClasses() const { return Classes; }
+ const std::map<std::string, Record*> &getDefs() const { return Defs; }
+
+ Record *getClass(const std::string &Name) const {
+ std::map<std::string, Record*>::const_iterator I = Classes.find(Name);
+ return I == Classes.end() ? 0 : I->second;
+ }
+ Record *getDef(const std::string &Name) const {
+ std::map<std::string, Record*>::const_iterator I = Defs.find(Name);
+ return I == Defs.end() ? 0 : I->second;
+ }
+ void addClass(Record *R) {
+ assert(getClass(R->getName()) == 0 && "Class already exists!");
+ Classes.insert(std::make_pair(R->getName(), R));
+ }
+ void addDef(Record *R) {
+ assert(getDef(R->getName()) == 0 && "Def already exists!");
+ Defs.insert(std::make_pair(R->getName(), R));
+ }
+
+ void dump() const;
+};
+
+std::ostream &operator<<(std::ostream &OS, const RecordKeeper &RK);
+
+extern RecordKeeper Records;
+
+#endif
--- /dev/null
+#include "Record.h"
+#include "Support/CommandLine.h"
+#include <algorithm>
+
+static cl::opt<std::string> Class("class", cl::desc("Print Enum list for this class"));
+static cl::opt<bool> Parse("parse");
+
+void ParseFile();
+
+RecordKeeper Records;
+
+static Init *getBit(Record *R, unsigned BitNo) {
+ const std::vector<RecordVal> &V = R->getValues();
+ for (unsigned i = 0, e = V.size(); i != e; ++i)
+ if (V[i].getPrefix()) {
+ assert(dynamic_cast<BitsInit*>(V[i].getValue()) &&
+ "Can only handle fields of bits<> type!");
+ BitsInit *I = (BitsInit*)V[i].getValue();
+ if (BitNo < I->getNumBits())
+ return I->getBit(BitNo);
+ BitNo -= I->getNumBits();
+ }
+
+ std::cerr << "Cannot find requested bit!\n";
+ abort();
+ return 0;
+}
+
+static unsigned getNumBits(Record *R) {
+ const std::vector<RecordVal> &V = R->getValues();
+ unsigned Num = 0;
+ for (unsigned i = 0, e = V.size(); i != e; ++i)
+ if (V[i].getPrefix()) {
+ assert(dynamic_cast<BitsInit*>(V[i].getValue()) &&
+ "Can only handle fields of bits<> type!");
+ Num += ((BitsInit*)V[i].getValue())->getNumBits();
+ }
+ return Num;
+}
+
+static bool BitsAreFixed(Record *I1, Record *I2, unsigned BitNo) {
+ return dynamic_cast<BitInit*>(getBit(I1, BitNo)) &&
+ dynamic_cast<BitInit*>(getBit(I2, BitNo));
+}
+
+static bool BitsAreEqual(Record *I1, Record *I2, unsigned BitNo) {
+ BitInit *Bit1 = dynamic_cast<BitInit*>(getBit(I1, BitNo));
+ BitInit *Bit2 = dynamic_cast<BitInit*>(getBit(I2, BitNo));
+
+ return Bit1 && Bit2 && Bit1->getValue() == Bit2->getValue();
+}
+
+static bool BitRangesEqual(Record *I1, Record *I2,
+ unsigned Start, unsigned End) {
+ for (unsigned i = Start; i != End; ++i)
+ if (!BitsAreEqual(I1, I2, i))
+ return false;
+ return true;
+}
+
+static unsigned getFirstFixedBit(Record *R, unsigned FirstFixedBit) {
+ // Look for the first bit of the pair that are required to be 0 or 1.
+ while (!dynamic_cast<BitInit*>(getBit(R, FirstFixedBit)))
+ ++FirstFixedBit;
+ return FirstFixedBit;
+}
+
+static void FindInstDifferences(Record *I1, Record *I2,
+ unsigned FirstFixedBit, unsigned MaxBits,
+ unsigned &FirstVaryingBitOverall,
+ unsigned &LastFixedBitOverall) {
+ // Compare the first instruction to the rest of the instructions, looking for
+ // fields that differ.
+ //
+ unsigned FirstVaryingBit = FirstFixedBit;
+ while (FirstVaryingBit < MaxBits && BitsAreEqual(I1, I2, FirstVaryingBit))
+ ++FirstVaryingBit;
+
+ unsigned LastFixedBit = FirstVaryingBit;
+ while (LastFixedBit < MaxBits && BitsAreFixed(I1, I2, LastFixedBit))
+ ++LastFixedBit;
+
+ if (FirstVaryingBit < FirstVaryingBitOverall)
+ FirstVaryingBitOverall = FirstVaryingBit;
+ if (LastFixedBit < LastFixedBitOverall)
+ LastFixedBitOverall = LastFixedBit;
+}
+
+static bool getBitValue(Record *R, unsigned BitNo) {
+ Init *I = getBit(R, BitNo);
+ assert(dynamic_cast<BitInit*>(I) && "Bit should be fixed!");
+ return ((BitInit*)I)->getValue();
+}
+
+struct BitComparator {
+ unsigned BitBegin, BitEnd;
+ BitComparator(unsigned B, unsigned E) : BitBegin(B), BitEnd(E) {}
+
+ bool operator()(Record *R1, Record *R2) { // Return true if R1 is less than R2
+ for (unsigned i = BitBegin; i != BitEnd; ++i) {
+ bool V1 = getBitValue(R1, i), V2 = getBitValue(R2, i);
+ if (V1 < V2)
+ return true;
+ else if (V2 < V1)
+ return false;
+ }
+ return false;
+ }
+};
+
+static void PrintRange(std::vector<Record*>::iterator I,
+ std::vector<Record*>::iterator E) {
+ while (I != E) std::cerr << **I++;
+}
+
+static bool getMemoryBit(unsigned char *M, unsigned i) {
+ return (M[i/8] & (1 << (i&7))) != 0;
+}
+
+static unsigned getFirstFixedBitInSequence(std::vector<Record*>::iterator IB,
+ std::vector<Record*>::iterator IE,
+ unsigned StartBit) {
+ unsigned FirstFixedBit = 0;
+ for (std::vector<Record*>::iterator I = IB; I != IE; ++I)
+ FirstFixedBit = std::max(FirstFixedBit, getFirstFixedBit(*I, StartBit));
+ return FirstFixedBit;
+}
+
+// ParseMachineCode - Try to split the vector of instructions (which is
+// intentially taken by-copy) in half, narrowing down the possible instructions
+// that we may have found. Eventually, this list will get pared down to zero or
+// one instruction, in which case we have a match or failure.
+//
+static Record *ParseMachineCode(std::vector<Record*>::iterator InstsB,
+ std::vector<Record*>::iterator InstsE,
+ unsigned char *M) {
+ assert(InstsB != InstsE && "Empty range?");
+ if (InstsB+1 == InstsE) {
+ // Only a single instruction, see if we match it...
+ Record *Inst = *InstsB;
+ for (unsigned i = 0, e = getNumBits(Inst); i != e; ++i)
+ if (BitInit *BI = dynamic_cast<BitInit*>(getBit(Inst, i)))
+ if (getMemoryBit(M, i) != BI->getValue())
+ return 0;
+ return Inst;
+ }
+
+ unsigned MaxBits = ~0;
+ for (std::vector<Record*>::iterator I = InstsB; I != InstsE; ++I)
+ MaxBits = std::min(MaxBits, getNumBits(*I));
+
+ unsigned FirstFixedBit = getFirstFixedBitInSequence(InstsB, InstsE, 0);
+ unsigned FirstVaryingBit, LastFixedBit;
+ do {
+ FirstVaryingBit = ~0;
+ LastFixedBit = ~0;
+ for (std::vector<Record*>::iterator I = InstsB+1; I != InstsE; ++I)
+ FindInstDifferences(*InstsB, *I, FirstFixedBit, MaxBits,
+ FirstVaryingBit, LastFixedBit);
+ if (FirstVaryingBit == MaxBits) {
+ std::cerr << "ERROR: Could not find bit to distinguish between "
+ << "the following entries!\n";
+ PrintRange(InstsB, InstsE);
+ }
+
+#if 0
+ std::cerr << "FVB: " << FirstVaryingBit << " - " << LastFixedBit
+ << ": " << InstsE-InstsB << "\n";
+#endif
+
+ FirstFixedBit = getFirstFixedBitInSequence(InstsB, InstsE, FirstVaryingBit);
+ } while (FirstVaryingBit != FirstFixedBit);
+
+ //std::cerr << "\n\nXXXXXXXXXXXXXXXXX\n\n";
+ //PrintRange(InstsB, InstsE);
+
+ // Sort the Insts list so that the entries have all of the bits in the range
+ // [FirstVaryingBit,LastFixedBit) sorted. These bits are all guaranteed to be
+ // set to either 0 or 1 (BitInit values), which simplifies things.
+ //
+ std::sort(InstsB, InstsE, BitComparator(FirstVaryingBit, LastFixedBit));
+
+ // Once the list is sorted by these bits, split the bit list into smaller
+ // lists, and recurse on each one.
+ //
+ std::vector<Record*>::iterator RangeBegin = InstsB;
+ Record *Match = 0;
+ while (RangeBegin != InstsE) {
+ std::vector<Record*>::iterator RangeEnd = RangeBegin+1;
+ while (RangeEnd != InstsE &&
+ BitRangesEqual(*RangeBegin, *RangeEnd, FirstVaryingBit, LastFixedBit))
+ ++RangeEnd;
+
+ // We just identified a range of equal instructions. If this range is the
+ // input range, we were not able to distinguish between the instructions in
+ // the set. Print an error and exit!
+ //
+ if (RangeBegin == InstsB && RangeEnd == InstsE) {
+ std::cerr << "Error: Could not distinguish among the following insts!:\n";
+ PrintRange(InstsB, InstsE);
+ abort();
+ }
+
+ if (Record *R = ParseMachineCode(RangeBegin, RangeEnd, M)) {
+ if (Match) {
+ std::cerr << "Error: Multiple matches found:\n";
+ PrintRange(InstsB, InstsE);
+ }
+
+ assert(Match == 0 && "Multiple matches??");
+ Match = R;
+ }
+ RangeBegin = RangeEnd;
+ }
+
+ return Match;
+}
+
+static void PrintValue(Record *I, unsigned char *Ptr, const RecordVal &Val) {
+ assert(dynamic_cast<BitsInit*>(Val.getValue()) &&
+ "Can only handle undefined bits<> types!");
+ BitsInit *BI = (BitsInit*)Val.getValue();
+ assert(BI->getNumBits() <= 32 && "Can only handle fields up to 32 bits!");
+
+ unsigned Value = 0;
+ const std::vector<RecordVal> &Vals = I->getValues();
+
+ // Start by filling in fixed values...
+ for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
+ if (BitInit *B = dynamic_cast<BitInit*>(BI->getBit(i)))
+ Value |= B->getValue() << i;
+
+ // Loop over all of the fields in the instruction adding in any
+ // contributions to this value (due to bit references).
+ //
+ unsigned Offset = 0;
+ for (unsigned f = 0, e = Vals.size(); f != e; ++f)
+ if (Vals[f].getPrefix()) {
+ BitsInit *FieldInit = (BitsInit*)Vals[f].getValue();
+ if (&Vals[f] == &Val) {
+ // Read the bits directly now...
+ for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
+ Value |= getMemoryBit(Ptr, Offset+i) << i;
+ break;
+ }
+
+ // Scan through the field looking for bit initializers of the current
+ // variable...
+ for (unsigned i = 0, e = FieldInit->getNumBits(); i != e; ++i)
+ if (VarBitInit *VBI =
+ dynamic_cast<VarBitInit*>(FieldInit->getBit(i))) {
+ if (VBI->getVariable()->getName() == Val.getName())
+ Value |= getMemoryBit(Ptr, Offset+i) << VBI->getBitNum();
+ }
+ Offset += FieldInit->getNumBits();
+ }
+
+ std::cout << "0x" << std::hex << Value << std::dec;
+}
+
+static void PrintInstruction(Record *I, unsigned char *Ptr) {
+ std::cout << "Inst " << getNumBits(I)/8 << " bytes: "
+ << "\t" << I->getName() << "\t" << *I->getValue("Name")->getValue()
+ << "\t";
+
+ const std::vector<RecordVal> &Vals = I->getValues();
+ for (unsigned i = 0, e = Vals.size(); i != e; ++i)
+ if (!Vals[i].getValue()->isComplete()) {
+ std::cout << Vals[i].getName() << "=";
+ PrintValue(I, Ptr, Vals[i]);
+ std::cout << "\t";
+ }
+
+ std::cout << "\n";// << *I;
+}
+
+static void ParseMachineCode() {
+ unsigned char Buffer[] = { 0x55, // push EBP
+ 0x89, 0xE5, // mov EBP, ESP
+ //0x83, 0xEC, 0x08, // sub ESP, 0x8
+ 0xE8, 1, 2, 3, 4, // call +0x04030201
+ 0x89, 0xEC, // mov ESP, EBP
+ 0x5D, // pop EBP
+ 0xC3, // ret
+ 0x90, // nop
+ 0xC9, // leave
+ 0x89, 0xF6, // mov ESI, ESI
+ 0xB8, 1, 2, 3, 4, // mov EAX, 0x04030201
+ 0x68, 1, 2, 3, 4, // push 0x04030201
+ 0x5e, // pop ESI
+ 0xFF, 0xD0, // call EAX
+ 0x85, 0xC0, // test EAX, EAX
+ 0xF4, // hlt
+ };
+
+ std::vector<Record*> Insts;
+
+ const std::map<std::string, Record*> &Defs = Records.getDefs();
+ Record *Inst = Records.getClass("Instruction");
+ assert(Inst && "Couldn't find Instruction class!");
+
+ for (std::map<std::string, Record*>::const_iterator I = Defs.begin(),
+ E = Defs.end(); I != E; ++I)
+ if (I->second->isSubClassOf(Inst))
+ Insts.push_back(I->second);
+
+ unsigned char *BuffPtr = Buffer;
+ while (1) {
+ Record *R = ParseMachineCode(Insts.begin(), Insts.end(), BuffPtr);
+ if (R == 0) {
+ std::cout << "Parse failed!\n";
+ return;
+ }
+ PrintInstruction(R, BuffPtr);
+
+ unsigned Bits = getNumBits(R);
+ assert((Bits & 7) == 0 && "Instruction is not an even number of bytes!");
+ BuffPtr += Bits/8;
+ }
+}
+
+
+int main(int argc, char **argv) {
+ cl::ParseCommandLineOptions(argc, argv);
+ ParseFile();
+
+ if (Parse) {
+ ParseMachineCode();
+ return 0;
+ }
+
+ if (Class == "") {
+ std::cout << Records; // No argument, dump all contents
+ } else {
+ Record *R = Records.getClass(Class);
+ if (R == 0) {
+ std::cerr << "Cannot find class '" << Class << "'!\n";
+ abort();
+ }
+
+ const std::map<std::string, Record*> &Defs = Records.getDefs();
+ for (std::map<std::string, Record*>::const_iterator I = Defs.begin(),
+ E = Defs.end(); I != E; ++I) {
+ if (I->second->isSubClassOf(R)) {
+ std::cout << I->first << ", ";
+ }
+ }
+ std::cout << "\n";
+ }
+ return 0;
+}
projects / oota-llvm.git / commitdiff