//===- Record.h - Classes to represent Table Records ------------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
//===----------------------------------------------------------------------===//
//
// This file defines the main TableGen data structures, including the TableGen
#ifndef RECORD_H
#define RECORD_H
+#include "llvm/Support/DataTypes.h"
#include <string>
#include <vector>
#include <map>
-#include <iostream>
+#include <ostream>
#include <cassert>
namespace llvm {
class StringInit;
class CodeInit;
class ListInit;
+class BinOpInit;
class DefInit;
class DagInit;
class TypedInit;
struct RecTy {
virtual ~RecTy() {}
- virtual void print(std::ostream &OS) const = 0;
+ virtual std::string getAsString() const = 0;
+ void print(std::ostream &OS) const { OS << getAsString(); }
void dump() const;
/// typeIsConvertibleTo - Return true if all values of 'this' type can be
virtual Init *convertValue( IntInit *II) { return 0; }
virtual Init *convertValue(StringInit *SI) { return 0; }
virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( BinOpInit *UI) { return 0; }
virtual Init *convertValue( CodeInit *CI) { return 0; }
virtual Init *convertValue(VarBitInit *VB) { return 0; }
virtual Init *convertValue( DefInit *DI) { return 0; }
virtual Init *convertValue(VarBitInit *VB) { return (Init*)VB; }
virtual Init *convertValue( DefInit *DI) { return 0; }
virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( BinOpInit *UI) { return 0; }
virtual Init *convertValue( TypedInit *TI);
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
- void print(std::ostream &OS) const { OS << "bit"; }
+ std::string getAsString() const { return "bit"; }
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
class BitsRecTy : public RecTy {
unsigned Size;
public:
- BitsRecTy(unsigned Sz) : Size(Sz) {}
+ explicit BitsRecTy(unsigned Sz) : Size(Sz) {}
unsigned getNumBits() const { return Size; }
virtual Init *convertValue(VarBitInit *VB) { return 0; }
virtual Init *convertValue( DefInit *DI) { return 0; }
virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( BinOpInit *UI) { return 0; }
virtual Init *convertValue( TypedInit *TI);
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
-
- void print(std::ostream &OS) const { OS << "bits<" << Size << ">"; }
+ std::string getAsString() const;
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
virtual Init *convertValue(VarBitInit *VB) { return 0; }
virtual Init *convertValue( DefInit *DI) { return 0; }
virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( BinOpInit *UI) { return 0; }
virtual Init *convertValue( TypedInit *TI);
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
-
- void print(std::ostream &OS) const { OS << "int"; }
+ std::string getAsString() const { return "int"; }
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
virtual Init *convertValue( IntInit *II) { return 0; }
virtual Init *convertValue(StringInit *SI) { return (Init*)SI; }
virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( BinOpInit *BO);
virtual Init *convertValue( CodeInit *CI) { return 0; }
virtual Init *convertValue(VarBitInit *VB) { return 0; }
virtual Init *convertValue( DefInit *DI) { return 0; }
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
- void print(std::ostream &OS) const { OS << "string"; }
+ std::string getAsString() const { return "string"; }
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
class ListRecTy : public RecTy {
RecTy *Ty;
public:
- ListRecTy(RecTy *T) : Ty(T) {}
+ explicit ListRecTy(RecTy *T) : Ty(T) {}
RecTy *getElementType() const { return Ty; }
virtual Init *convertValue(VarBitInit *VB) { return 0; }
virtual Init *convertValue( DefInit *DI) { return 0; }
virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( BinOpInit *UI) { return 0; }
virtual Init *convertValue( TypedInit *TI);
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
-
- void print(std::ostream &OS) const;
+
+ std::string getAsString() const;
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
virtual bool baseClassOf(const IntRecTy *RHS) const { return false; }
virtual bool baseClassOf(const StringRecTy *RHS) const { return false; }
virtual bool baseClassOf(const ListRecTy *RHS) const {
- return RHS->getElementType()->typeIsConvertibleTo(Ty);
+ return RHS->getElementType()->typeIsConvertibleTo(Ty);
}
virtual bool baseClassOf(const CodeRecTy *RHS) const { return false; }
virtual bool baseClassOf(const DagRecTy *RHS) const { return false; }
virtual Init *convertValue(VarBitInit *VB) { return 0; }
virtual Init *convertValue( DefInit *DI) { return 0; }
virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( BinOpInit *UI) { return 0; }
virtual Init *convertValue( TypedInit *TI);
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
-
- void print(std::ostream &OS) const { OS << "code"; }
+ std::string getAsString() const { return "code"; }
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
virtual Init *convertValue( CodeInit *CI) { return 0; }
virtual Init *convertValue(VarBitInit *VB) { return 0; }
virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( BinOpInit *BO);
virtual Init *convertValue( DagInit *CI) { return (Init*)CI; }
virtual Init *convertValue( TypedInit *TI);
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
- void print(std::ostream &OS) const { OS << "dag"; }
+ std::string getAsString() const { return "dag"; }
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
class RecordRecTy : public RecTy {
Record *Rec;
public:
- RecordRecTy(Record *R) : Rec(R) {}
+ explicit RecordRecTy(Record *R) : Rec(R) {}
Record *getRecord() const { return Rec; }
virtual Init *convertValue( ListInit *LI) { return 0; }
virtual Init *convertValue( CodeInit *CI) { return 0; }
virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( BinOpInit *UI) { return 0; }
virtual Init *convertValue( DefInit *DI);
virtual Init *convertValue( DagInit *DI) { return 0; }
- virtual Init *convertValue( TypedInit *VI);
+ virtual Init *convertValue( TypedInit *VI);
virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
- void print(std::ostream &OS) const;
+ std::string getAsString() const;
bool typeIsConvertibleTo(const RecTy *RHS) const {
return RHS->baseClassOf(this);
virtual bool isComplete() const { return true; }
/// print - Print out this value.
- virtual void print(std::ostream &OS) const = 0;
+ void print(std::ostream &OS) const { OS << getAsString(); }
+
+ /// getAsString - Convert this value to a string form.
+ virtual std::string getAsString() const = 0;
/// dump - Debugging method that may be called through a debugger, just
/// invokes print on cerr.
virtual Init *getFieldInit(Record &R, const std::string &FieldName) const {
return 0;
}
-
- enum BinaryOp { SHL, SRA, SRL };
- virtual Init *getBinaryOp(BinaryOp Op, Init *RHS) {
- return 0;
- }
/// resolveReferences - This method is used by classes that refer to other
/// variables which may not be defined at the time they expression is formed.
}
virtual bool isComplete() const { return false; }
- virtual void print(std::ostream &OS) const { OS << "?"; }
+ virtual std::string getAsString() const { return "?"; }
};
class BitInit : public Init {
bool Value;
public:
- BitInit(bool V) : Value(V) {}
+ explicit BitInit(bool V) : Value(V) {}
bool getValue() const { return Value; }
return Ty->convertValue(this);
}
- virtual void print(std::ostream &OS) const { OS << (Value ? "1" : "0"); }
+ virtual std::string getAsString() const { return Value ? "1" : "0"; }
};
/// BitsInit - { a, b, c } - Represents an initializer for a BitsRecTy value.
class BitsInit : public Init {
std::vector<Init*> Bits;
public:
- BitsInit(unsigned Size) : Bits(Size) {}
+ explicit BitsInit(unsigned Size) : Bits(Size) {}
unsigned getNumBits() const { return Bits.size(); }
if (!getBit(i)->isComplete()) return false;
return true;
}
- virtual void print(std::ostream &OS) const;
+ virtual std::string getAsString() const;
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
/// IntInit - 7 - Represent an initalization by a literal integer value.
///
class IntInit : public Init {
- int Value;
+ int64_t Value;
public:
- IntInit(int V) : Value(V) {}
+ explicit IntInit(int64_t V) : Value(V) {}
- int getValue() const { return Value; }
+ int64_t getValue() const { return Value; }
virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
- virtual Init *getBinaryOp(BinaryOp Op, Init *RHS);
-
- virtual void print(std::ostream &OS) const { OS << Value; }
+ virtual std::string getAsString() const;
};
class StringInit : public Init {
std::string Value;
public:
- StringInit(const std::string &V) : Value(V) {}
+ explicit StringInit(const std::string &V) : Value(V) {}
const std::string &getValue() const { return Value; }
return Ty->convertValue(this);
}
- virtual void print(std::ostream &OS) const { OS << "\"" << Value << "\""; }
+ virtual std::string getAsString() const { return "\"" + Value + "\""; }
};
/// CodeInit - "[{...}]" - Represent a code fragment.
class CodeInit : public Init {
std::string Value;
public:
- CodeInit(const std::string &V) : Value(V) {}
+ explicit CodeInit(const std::string &V) : Value(V) {}
const std::string getValue() const { return Value; }
return Ty->convertValue(this);
}
- virtual void print(std::ostream &OS) const { OS << "[{" << Value << "}]"; }
+ virtual std::string getAsString() const { return "[{" + Value + "}]"; }
};
/// ListInit - [AL, AH, CL] - Represent a list of defs
class ListInit : public Init {
std::vector<Init*> Values;
public:
- ListInit(std::vector<Init*> &Vs) {
+ explicit ListInit(std::vector<Init*> &Vs) {
Values.swap(Vs);
}
return Values[i];
}
+ Record *getElementAsRecord(unsigned i) const;
+
Init *convertInitListSlice(const std::vector<unsigned> &Elements);
virtual Init *convertInitializerTo(RecTy *Ty) {
///
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
- virtual void print(std::ostream &OS) const;
+ virtual std::string getAsString() const;
+
+ typedef std::vector<Init*>::iterator iterator;
+ typedef std::vector<Init*>::const_iterator const_iterator;
+
+ inline iterator begin() { return Values.begin(); }
+ inline const_iterator begin() const { return Values.begin(); }
+ inline iterator end () { return Values.end(); }
+ inline const_iterator end () const { return Values.end(); }
+
+ inline size_t size () const { return Values.size(); }
+ inline bool empty() const { return Values.empty(); }
+};
+
+/// BinOpInit - !op (X, Y) - Combine two inits.
+///
+class BinOpInit : public Init {
+public:
+ enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT };
+private:
+ BinaryOp Opc;
+ Init *LHS, *RHS;
+public:
+ BinOpInit(BinaryOp opc, Init *lhs, Init *rhs) : Opc(opc), LHS(lhs), RHS(rhs) {
+ }
+
+ BinaryOp getOpcode() const { return Opc; }
+ Init *getLHS() const { return LHS; }
+ Init *getRHS() const { return RHS; }
+
+ // Fold - If possible, fold this to a simpler init. Return this if not
+ // possible to fold.
+ Init *Fold();
+
+ virtual Init *convertInitializerTo(RecTy *Ty) {
+ return Ty->convertValue(this);
+ }
+
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+
+ virtual std::string getAsString() const;
};
+
/// TypedInit - This is the common super-class of types that have a specific,
/// explicit, type.
///
class TypedInit : public Init {
RecTy *Ty;
-public:
- TypedInit(RecTy *T) : Ty(T) {}
+public:
+ explicit TypedInit(RecTy *T) : Ty(T) {}
RecTy *getType() const { return Ty; }
class VarInit : public TypedInit {
std::string VarName;
public:
- VarInit(const std::string &VN, RecTy *T) : TypedInit(T), VarName(VN) {}
-
+ explicit VarInit(const std::string &VN, RecTy *T)
+ : TypedInit(T), VarName(VN) {}
+
virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
/// users of the value to allow the value to propagate out.
///
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
-
- virtual void print(std::ostream &OS) const { OS << VarName; }
+
+ virtual std::string getAsString() const { return VarName; }
};
TypedInit *getVariable() const { return TI; }
unsigned getBitNum() const { return Bit; }
-
- virtual void print(std::ostream &OS) const {
- TI->print(OS); OS << "{" << Bit << "}";
- }
+
+ virtual std::string getAsString() const;
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
};
-/// VarListElementInit - List[4] - Represent access to one element of a var or
+/// VarListElementInit - List[4] - Represent access to one element of a var or
/// field.
class VarListElementInit : public TypedInit {
TypedInit *TI;
virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
unsigned Elt);
- virtual void print(std::ostream &OS) const {
- TI->print(OS); OS << "[" << Element << "]";
- }
+ virtual std::string getAsString() const;
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
};
class DefInit : public Init {
Record *Def;
public:
- DefInit(Record *D) : Def(D) {}
-
+ explicit DefInit(Record *D) : Def(D) {}
+
virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
virtual RecTy *getFieldType(const std::string &FieldName) const;
virtual Init *getFieldInit(Record &R, const std::string &FieldName) const;
-
- virtual void print(std::ostream &OS) const;
+
+ virtual std::string getAsString() const;
};
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
- virtual void print(std::ostream &OS) const {
- Rec->print(OS); OS << "." << FieldName;
+ virtual std::string getAsString() const {
+ return Rec->getAsString() + "." + FieldName;
}
};
-/// DagInit - (def a, b) - Represent a DAG tree value. DAG inits are required
-/// to have Records for their first value, after that, any legal Init is
-/// possible.
+/// DagInit - (v a, b) - Represent a DAG tree value. DAG inits are required
+/// to have at least one value then a (possibly empty) list of arguments. Each
+/// argument can have a name associated with it.
///
class DagInit : public Init {
- Record *NodeTypeDef;
+ Init *Val;
std::vector<Init*> Args;
std::vector<std::string> ArgNames;
public:
- DagInit(Record *D, const std::vector<std::pair<Init*, std::string> > &args)
- : NodeTypeDef(D) {
+ DagInit(Init *V, const std::vector<std::pair<Init*, std::string> > &args)
+ : Val(V) {
Args.reserve(args.size());
ArgNames.reserve(args.size());
for (unsigned i = 0, e = args.size(); i != e; ++i) {
ArgNames.push_back(args[i].second);
}
}
+ DagInit(Init *V, const std::vector<Init*> &args,
+ const std::vector<std::string> &argNames)
+ : Val(V), Args(args), ArgNames(argNames) {
+ }
virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
- Record *getNodeType() const { return NodeTypeDef; }
+ Init *getOperator() const { return Val; }
unsigned getNumArgs() const { return Args.size(); }
Init *getArg(unsigned Num) const {
assert(Num < Args.size() && "Arg number out of range!");
Args[Num] = I;
}
+
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+
+ virtual std::string getAsString() const;
+
+ typedef std::vector<Init*>::iterator arg_iterator;
+ typedef std::vector<Init*>::const_iterator const_arg_iterator;
+ typedef std::vector<std::string>::iterator name_iterator;
+ typedef std::vector<std::string>::const_iterator const_name_iterator;
+
+ inline arg_iterator arg_begin() { return Args.begin(); }
+ inline const_arg_iterator arg_begin() const { return Args.begin(); }
+ inline arg_iterator arg_end () { return Args.end(); }
+ inline const_arg_iterator arg_end () const { return Args.end(); }
+
+ inline size_t arg_size () const { return Args.size(); }
+ inline bool arg_empty() const { return Args.empty(); }
+
+ inline name_iterator name_begin() { return ArgNames.begin(); }
+ inline const_name_iterator name_begin() const { return ArgNames.begin(); }
+ inline name_iterator name_end () { return ArgNames.end(); }
+ inline const_name_iterator name_end () const { return ArgNames.end(); }
+
+ inline size_t name_size () const { return ArgNames.size(); }
+ inline bool name_empty() const { return ArgNames.empty(); }
- virtual void print(std::ostream &OS) const;
};
//===----------------------------------------------------------------------===//
}
class Record {
- const std::string Name;
+ std::string Name;
std::vector<std::string> TemplateArgs;
std::vector<RecordVal> Values;
std::vector<Record*> SuperClasses;
public:
- Record(const std::string &N) : Name(N) {}
+ explicit Record(const std::string &N) : Name(N) {}
~Record() {}
const std::string &getName() const { return Name; }
+ void setName(const std::string &Name); // Also updates RecordKeeper.
const std::vector<std::string> &getTemplateArgs() const {
return TemplateArgs;
}
bool isSubClassOf(Record *R) const {
for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i)
if (SuperClasses[i] == R)
- return true;
+ return true;
return false;
}
///
ListInit *getValueAsListInit(const std::string &FieldName) const;
+ /// getValueAsListOfDefs - This method looks up the specified field and
+ /// returns its value as a vector of records, throwing an exception if the
+ /// field does not exist or if the value is not the right type.
+ ///
+ std::vector<Record*> getValueAsListOfDefs(const std::string &FieldName) const;
+
+ /// getValueAsListOfInts - This method looks up the specified field and returns
+ /// its value as a vector of integers, throwing an exception if the field does
+ /// not exist or if the value is not the right type.
+ ///
+ std::vector<int64_t> getValueAsListOfInts(const std::string &FieldName) const;
+
/// getValueAsDef - This method looks up the specified field and returns its
/// value as a Record, throwing an exception if the field does not exist or if
/// the value is not the right type.
bool getValueAsBit(const std::string &FieldName) const;
/// getValueAsInt - This method looks up the specified field and returns its
- /// value as an int, throwing an exception if the field does not exist or if
- /// the value is not the right type.
+ /// value as an int64_t, throwing an exception if the field does not exist or
+ /// if the value is not the right type.
///
- int getValueAsInt(const std::string &FieldName) const;
+ int64_t getValueAsInt(const std::string &FieldName) const;
/// getValueAsDag - This method looks up the specified field and returns its
/// value as an Dag, throwing an exception if the field does not exist or if
/// the value is not the right type.
///
DagInit *getValueAsDag(const std::string &FieldName) const;
+
+ /// getValueAsCode - This method looks up the specified field and returns
+ /// its value as the string data in a CodeInit, throwing an exception if the
+ /// field does not exist or if the value is not a code object.
+ ///
+ std::string getValueAsCode(const std::string &FieldName) const;
};
std::ostream &operator<<(std::ostream &OS, const Record &R);
public:
~RecordKeeper() {
for (std::map<std::string, Record*>::iterator I = Classes.begin(),
- E = Classes.end(); I != E; ++I)
+ 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)
+ 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; }
Defs.insert(std::make_pair(R->getName(), R));
}
+ /// removeClass - Remove, but do not delete, the specified record.
+ ///
+ void removeClass(const std::string &Name) {
+ assert(Classes.count(Name) && "Class does not exist!");
+ Classes.erase(Name);
+ }
+ /// removeDef - Remove, but do not delete, the specified record.
+ ///
+ void removeDef(const std::string &Name) {
+ assert(Defs.count(Name) && "Def does not exist!");
+ Defs.erase(Name);
+ }
+
//===--------------------------------------------------------------------===//
// High-level helper methods, useful for tablegen backends...
void dump() const;
};
+/// LessRecord - Sorting predicate to sort record pointers by name.
+///
+struct LessRecord {
+ bool operator()(const Record *Rec1, const Record *Rec2) const {
+ return Rec1->getName() < Rec2->getName();
+ }
+};
+
+/// LessRecordFieldName - Sorting predicate to sort record pointers by their
+/// name field.
+///
+struct LessRecordFieldName {
+ bool operator()(const Record *Rec1, const Record *Rec2) const {
+ return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name");
+ }
+};
+
+
std::ostream &operator<<(std::ostream &OS, const RecordKeeper &RK);
extern RecordKeeper Records;