public:
RecTyKind getRecTyKind() const { return Kind; }
- RecTy(RecTyKind K) : Kind(K), ListTy(0) {}
+ RecTy(RecTyKind K) : Kind(K), ListTy(nullptr) {}
virtual ~RecTy() {}
virtual std::string getAsString() const = 0;
ListRecTy *getListTy();
public: // These methods should only be called from subclasses of Init
- 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( UnsetInit *UI) { return nullptr; }
+ virtual Init *convertValue( BitInit *BI) { return nullptr; }
+ virtual Init *convertValue( BitsInit *BI) { return nullptr; }
+ virtual Init *convertValue( IntInit *II) { return nullptr; }
+ virtual Init *convertValue(StringInit *SI) { return nullptr; }
+ virtual Init *convertValue( ListInit *LI) { return nullptr; }
virtual Init *convertValue( UnOpInit *UI) {
return convertValue((TypedInit*)UI);
}
virtual Init *convertValue( TernOpInit *UI) {
return convertValue((TypedInit*)UI);
}
- virtual Init *convertValue(VarBitInit *VB) { return 0; }
- virtual Init *convertValue( DefInit *DI) { return 0; }
- virtual Init *convertValue( DagInit *DI) { return 0; }
- virtual Init *convertValue( TypedInit *TI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return nullptr; }
+ virtual Init *convertValue( DefInit *DI) { return nullptr; }
+ virtual Init *convertValue( DagInit *DI) { return nullptr; }
+ virtual Init *convertValue( TypedInit *TI) { return nullptr; }
virtual Init *convertValue( VarInit *VI) {
return convertValue((TypedInit*)VI);
}
return OS;
}
-
/// BitRecTy - 'bit' - Represent a single bit
///
class BitRecTy : public RecTy {
static BitRecTy Shared;
BitRecTy() : RecTy(BitRecTyKind) {}
+
public:
static bool classof(const RecTy *RT) {
return RT->getRecTyKind() == BitRecTyKind;
Init *convertValue( BitInit *BI) override { return (Init*)BI; }
Init *convertValue( BitsInit *BI) override;
Init *convertValue( IntInit *II) override;
- Init *convertValue(StringInit *SI) override { return 0; }
- Init *convertValue( ListInit *LI) override { return 0; }
+ Init *convertValue(StringInit *SI) override { return nullptr; }
+ Init *convertValue( ListInit *LI) override { return nullptr; }
Init *convertValue(VarBitInit *VB) override { return (Init*)VB; }
- Init *convertValue( DefInit *DI) override { return 0; }
- Init *convertValue( DagInit *DI) override { return 0; }
+ Init *convertValue( DefInit *DI) override { return nullptr; }
+ Init *convertValue( DagInit *DI) override { return nullptr; }
Init *convertValue( UnOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( BinOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( TernOpInit *UI) override {return RecTy::convertValue(UI);}
bool baseClassOf(const RecTy*) const override;
};
-
/// BitsRecTy - 'bits<n>' - Represent a fixed number of bits
///
class BitsRecTy : public RecTy {
unsigned Size;
explicit BitsRecTy(unsigned Sz) : RecTy(BitsRecTyKind), Size(Sz) {}
+
public:
static bool classof(const RecTy *RT) {
return RT->getRecTyKind() == BitsRecTyKind;
Init *convertValue( BitInit *UI) override;
Init *convertValue( BitsInit *BI) override;
Init *convertValue( IntInit *II) override;
- Init *convertValue(StringInit *SI) override { return 0; }
- Init *convertValue( ListInit *LI) override { return 0; }
- Init *convertValue(VarBitInit *VB) override { return 0; }
- Init *convertValue( DefInit *DI) override { return 0; }
- Init *convertValue( DagInit *DI) override { return 0; }
- Init *convertValue( UnOpInit *UI) override { return RecTy::convertValue(UI);}
+ Init *convertValue(StringInit *SI) override { return nullptr; }
+ Init *convertValue( ListInit *LI) override { return nullptr; }
+ Init *convertValue(VarBitInit *VB) override { return nullptr; }
+ Init *convertValue( DefInit *DI) override { return nullptr; }
+ Init *convertValue( DagInit *DI) override { return nullptr; }
+ Init *convertValue( UnOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( BinOpInit *UI) override { return RecTy::convertValue(UI);}
- Init *convertValue( TernOpInit *UI) override {return RecTy::convertValue(UI);}
+ Init *convertValue(TernOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( TypedInit *TI) override;
- Init *convertValue( VarInit *VI) override{ return RecTy::convertValue(VI);}
- Init *convertValue( FieldInit *FI) override{ return RecTy::convertValue(FI);}
+ Init *convertValue( VarInit *VI) override { return RecTy::convertValue(VI);}
+ Init *convertValue( FieldInit *FI) override { return RecTy::convertValue(FI);}
std::string getAsString() const override;
- bool typeIsConvertibleTo(const RecTy *RHS) const override{
+ bool typeIsConvertibleTo(const RecTy *RHS) const override {
return RHS->baseClassOf(this);
}
bool baseClassOf(const RecTy*) const override;
};
-
/// IntRecTy - 'int' - Represent an integer value of no particular size
///
class IntRecTy : public RecTy {
static IntRecTy Shared;
IntRecTy() : RecTy(IntRecTyKind) {}
+
public:
static bool classof(const RecTy *RT) {
return RT->getRecTyKind() == IntRecTyKind;
Init *convertValue( BitInit *BI) override;
Init *convertValue( BitsInit *BI) override;
Init *convertValue( IntInit *II) override { return (Init*)II; }
- Init *convertValue(StringInit *SI) override { return 0; }
- Init *convertValue( ListInit *LI) override { return 0; }
- Init *convertValue(VarBitInit *VB) override { return 0; }
- Init *convertValue( DefInit *DI) override { return 0; }
- Init *convertValue( DagInit *DI) override { return 0; }
+ Init *convertValue(StringInit *SI) override { return nullptr; }
+ Init *convertValue( ListInit *LI) override { return nullptr; }
+ Init *convertValue(VarBitInit *VB) override { return nullptr; }
+ Init *convertValue( DefInit *DI) override { return nullptr; }
+ Init *convertValue( DagInit *DI) override { return nullptr; }
Init *convertValue( UnOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( BinOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( TernOpInit *UI) override {return RecTy::convertValue(UI);}
class StringRecTy : public RecTy {
static StringRecTy Shared;
StringRecTy() : RecTy(StringRecTyKind) {}
+
public:
static bool classof(const RecTy *RT) {
return RT->getRecTyKind() == StringRecTyKind;
static StringRecTy *get() { return &Shared; }
Init *convertValue( UnsetInit *UI) override { return (Init*)UI; }
- Init *convertValue( BitInit *BI) override { return 0; }
- Init *convertValue( BitsInit *BI) override { return 0; }
- Init *convertValue( IntInit *II) override { return 0; }
+ Init *convertValue( BitInit *BI) override { return nullptr; }
+ Init *convertValue( BitsInit *BI) override { return nullptr; }
+ Init *convertValue( IntInit *II) override { return nullptr; }
Init *convertValue(StringInit *SI) override { return (Init*)SI; }
- Init *convertValue( ListInit *LI) override { return 0; }
+ Init *convertValue( ListInit *LI) override { return nullptr; }
Init *convertValue( UnOpInit *BO) override;
Init *convertValue( BinOpInit *BO) override;
Init *convertValue( TernOpInit *BO) override {return RecTy::convertValue(BO);}
- Init *convertValue(VarBitInit *VB) override { return 0; }
- Init *convertValue( DefInit *DI) override { return 0; }
- Init *convertValue( DagInit *DI) override { return 0; }
+ Init *convertValue(VarBitInit *VB) override { return nullptr; }
+ Init *convertValue( DefInit *DI) override { return nullptr; }
+ Init *convertValue( DagInit *DI) override { return nullptr; }
Init *convertValue( TypedInit *TI) override;
Init *convertValue( VarInit *VI) override { return RecTy::convertValue(VI);}
Init *convertValue( FieldInit *FI) override { return RecTy::convertValue(FI);}
RecTy *Ty;
explicit ListRecTy(RecTy *T) : RecTy(ListRecTyKind), Ty(T) {}
friend ListRecTy *RecTy::getListTy();
+
public:
static bool classof(const RecTy *RT) {
return RT->getRecTyKind() == ListRecTyKind;
RecTy *getElementType() const { return Ty; }
Init *convertValue( UnsetInit *UI) override { return (Init*)UI; }
- Init *convertValue( BitInit *BI) override { return 0; }
- Init *convertValue( BitsInit *BI) override { return 0; }
- Init *convertValue( IntInit *II) override { return 0; }
- Init *convertValue(StringInit *SI) override { return 0; }
+ Init *convertValue( BitInit *BI) override { return nullptr; }
+ Init *convertValue( BitsInit *BI) override { return nullptr; }
+ Init *convertValue( IntInit *II) override { return nullptr; }
+ Init *convertValue(StringInit *SI) override { return nullptr; }
Init *convertValue( ListInit *LI) override;
- Init *convertValue(VarBitInit *VB) override { return 0; }
- Init *convertValue( DefInit *DI) override { return 0; }
- Init *convertValue( DagInit *DI) override { return 0; }
- Init *convertValue( UnOpInit *UI) override { return RecTy::convertValue(UI);}
+ Init *convertValue(VarBitInit *VB) override { return nullptr; }
+ Init *convertValue( DefInit *DI) override { return nullptr; }
+ Init *convertValue( DagInit *DI) override { return nullptr; }
+ Init *convertValue( UnOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( BinOpInit *UI) override { return RecTy::convertValue(UI);}
- Init *convertValue( TernOpInit *UI) override{ return RecTy::convertValue(UI);}
+ Init *convertValue(TernOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( TypedInit *TI) override;
Init *convertValue( VarInit *VI) override { return RecTy::convertValue(VI);}
Init *convertValue( FieldInit *FI) override { return RecTy::convertValue(FI);}
std::string getAsString() const override;
- bool typeIsConvertibleTo(const RecTy *RHS) const override{
+ bool typeIsConvertibleTo(const RecTy *RHS) const override {
return RHS->baseClassOf(this);
}
class DagRecTy : public RecTy {
static DagRecTy Shared;
DagRecTy() : RecTy(DagRecTyKind) {}
+
public:
static bool classof(const RecTy *RT) {
return RT->getRecTyKind() == DagRecTyKind;
static DagRecTy *get() { return &Shared; }
Init *convertValue( UnsetInit *UI) override { return (Init*)UI; }
- Init *convertValue( BitInit *BI) override { return 0; }
- Init *convertValue( BitsInit *BI) override { return 0; }
- Init *convertValue( IntInit *II) override { return 0; }
- Init *convertValue(StringInit *SI) override { return 0; }
- Init *convertValue( ListInit *LI) override { return 0; }
- Init *convertValue(VarBitInit *VB) override { return 0; }
- Init *convertValue( DefInit *DI) override { return 0; }
+ Init *convertValue( BitInit *BI) override { return nullptr; }
+ Init *convertValue( BitsInit *BI) override { return nullptr; }
+ Init *convertValue( IntInit *II) override { return nullptr; }
+ Init *convertValue(StringInit *SI) override { return nullptr; }
+ Init *convertValue( ListInit *LI) override { return nullptr; }
+ Init *convertValue(VarBitInit *VB) override { return nullptr; }
+ Init *convertValue( DefInit *DI) override { return nullptr; }
Init *convertValue( UnOpInit *BO) override;
Init *convertValue( BinOpInit *BO) override;
Init *convertValue( TernOpInit *BO) override {return RecTy::convertValue(BO);}
std::string getAsString() const override { return "dag"; }
- bool typeIsConvertibleTo(const RecTy *RHS) const override{
+ bool typeIsConvertibleTo(const RecTy *RHS) const override {
return RHS->baseClassOf(this);
}
};
-
/// RecordRecTy - '[classname]' - Represent an instance of a class, such as:
/// (R32 X = EAX).
///
Record *Rec;
explicit RecordRecTy(Record *R) : RecTy(RecordRecTyKind), Rec(R) {}
friend class Record;
+
public:
static bool classof(const RecTy *RT) {
return RT->getRecTyKind() == RecordRecTyKind;
Record *getRecord() const { return Rec; }
Init *convertValue( UnsetInit *UI) override { return (Init*)UI; }
- Init *convertValue( BitInit *BI) override { return 0; }
- Init *convertValue( BitsInit *BI) override { return 0; }
- Init *convertValue( IntInit *II) override { return 0; }
- Init *convertValue(StringInit *SI) override { return 0; }
- Init *convertValue( ListInit *LI) override { return 0; }
- Init *convertValue(VarBitInit *VB) override { return 0; }
+ Init *convertValue( BitInit *BI) override { return nullptr; }
+ Init *convertValue( BitsInit *BI) override { return nullptr; }
+ Init *convertValue( IntInit *II) override { return nullptr; }
+ Init *convertValue(StringInit *SI) override { return nullptr; }
+ Init *convertValue( ListInit *LI) override { return nullptr; }
+ Init *convertValue(VarBitInit *VB) override { return nullptr; }
Init *convertValue( UnOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( BinOpInit *UI) override { return RecTy::convertValue(UI);}
Init *convertValue( TernOpInit *UI) override {return RecTy::convertValue(UI);}
Init *convertValue( DefInit *DI) override;
- Init *convertValue( DagInit *DI) override { return 0; }
+ Init *convertValue( DagInit *DI) override { return nullptr; }
Init *convertValue( TypedInit *VI) override;
Init *convertValue( VarInit *VI) override { return RecTy::convertValue(VI);}
Init *convertValue( FieldInit *FI) override { return RecTy::convertValue(FI);}
///
virtual Init *
convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
- return 0;
+ return nullptr;
}
/// convertInitListSlice - This method is used to implement the list slice
///
virtual Init *
convertInitListSlice(const std::vector<unsigned> &Elements) const {
- return 0;
+ return nullptr;
}
/// getFieldType - This method is used to implement the FieldInit class.
/// Implementors of this method should return the type of the named field if
/// they are of record type.
///
- virtual RecTy *getFieldType(const std::string &FieldName) const { return 0; }
+ virtual RecTy *getFieldType(const std::string &FieldName) const {
+ return nullptr;
+ }
/// getFieldInit - This method complements getFieldType to return the
/// initializer for the specified field. If getFieldType returns non-null
///
virtual Init *getFieldInit(Record &R, const RecordVal *RV,
const std::string &FieldName) const {
- return 0;
+ return nullptr;
}
/// resolveReferences - This method is used by classes that refer to other
unsigned Elt) const = 0;
};
-
/// UnsetInit - ? - Represents an uninitialized value
///
class UnsetInit : public Init {
std::string getAsString() const override { return "?"; }
};
-
/// BitInit - true/false - Represent a concrete initializer for a bit.
///
class BitInit : public Init {
}
};
-
/// IntInit - 7 - Represent an initialization by a literal integer value.
///
class IntInit : public TypedInit {
}
};
-
/// StringInit - "foo" - Represent an initialization by a string value.
///
class StringInit : public TypedInit {
///
class ListInit : public TypedInit, public FoldingSetNode {
std::vector<Init*> Values;
+
public:
typedef std::vector<Init*>::const_iterator const_iterator;
}
};
-
/// OpInit - Base class for operators
///
class OpInit : public TypedInit {
Init *getBit(unsigned Bit) const override;
};
-
/// UnOpInit - !op (X) - Transform an init.
///
class UnOpInit : public OpInit {
public:
enum UnaryOp { CAST, HEAD, TAIL, EMPTY };
+
private:
UnaryOp Opc;
Init *LHS;
///
class BinOpInit : public OpInit {
public:
- enum BinaryOp { ADD, SHL, SRA, SRL, STRCONCAT, CONCAT, EQ };
+ enum BinaryOp { ADD, SHL, SRA, SRL, LISTCONCAT, STRCONCAT, CONCAT, EQ };
+
private:
BinaryOp Opc;
Init *LHS, *RHS;
class TernOpInit : public OpInit {
public:
enum TernaryOp { SUBST, FOREACH, IF };
+
private:
TernaryOp Opc;
Init *LHS, *MHS, *RHS;
std::string getAsString() const override;
};
-
/// VarInit - 'Opcode' - Represent a reference to an entire variable object.
///
class VarInit : public TypedInit {
std::string getAsString() const override { return getName(); }
};
-
/// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field.
///
class VarBitInit : public Init {
}
};
-
/// FieldInit - X.Y - Represent a reference to a subfield of a variable
///
class FieldInit : public TypedInit {
RecTy *Ty;
unsigned Prefix;
Init *Value;
+
public:
RecordVal(Init *N, RecTy *T, unsigned P);
RecordVal(const std::string &N, RecTy *T, unsigned P);
bool setValue(Init *V) {
if (V) {
Value = V->convertInitializerTo(Ty);
- return Value == 0;
+ return Value == nullptr;
}
- Value = 0;
+ Value = nullptr;
return false;
}
void checkName();
public:
-
// Constructs a record.
explicit Record(const std::string &N, ArrayRef<SMLoc> locs,
RecordKeeper &records, bool Anonymous = false) :
ID(LastID++), Name(StringInit::get(N)), Locs(locs.begin(), locs.end()),
- TrackedRecords(records), TheInit(0), IsAnonymous(Anonymous) {
+ TrackedRecords(records), TheInit(nullptr), IsAnonymous(Anonymous) {
init();
}
explicit Record(Init *N, ArrayRef<SMLoc> locs, RecordKeeper &records,
bool Anonymous = false) :
ID(LastID++), Name(N), Locs(locs.begin(), locs.end()),
- TrackedRecords(records), TheInit(0), IsAnonymous(Anonymous) {
+ TrackedRecords(records), TheInit(nullptr), IsAnonymous(Anonymous) {
init();
}
~Record() {}
-
static unsigned getNewUID() { return LastID++; }
-
unsigned getID() const { return ID; }
const std::string &getName() const;
const RecordVal *getValue(const Init *Name) const {
for (unsigned i = 0, e = Values.size(); i != e; ++i)
if (Values[i].getNameInit() == Name) return &Values[i];
- return 0;
+ return nullptr;
}
const RecordVal *getValue(StringRef Name) const {
return getValue(StringInit::get(Name));
RecordVal *getValue(const Init *Name) {
for (unsigned i = 0, e = Values.size(); i != e; ++i)
if (Values[i].getNameInit() == Name) return &Values[i];
- return 0;
+ return nullptr;
}
RecordVal *getValue(StringRef Name) {
return getValue(StringInit::get(Name));
}
void addValue(const RecordVal &RV) {
- assert(getValue(RV.getNameInit()) == 0 && "Value already added!");
+ assert(getValue(RV.getNameInit()) == nullptr && "Value already added!");
Values.push_back(RV);
if (Values.size() > 1)
// Keep NAME at the end of the list. It makes record dumps a
/// resolveReferences - If there are any field references that refer to fields
/// that have been filled in, we can propagate the values now.
///
- void resolveReferences() { resolveReferencesTo(0); }
+ void resolveReferences() { resolveReferencesTo(nullptr); }
/// resolveReferencesTo - If anything in this record refers to RV, replace the
/// reference to RV with the RHS of RV. If RV is null, we resolve all
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;
+ return I == Classes.end() ? nullptr : 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;
+ return I == Defs.end() ? nullptr : I->second;
}
void addClass(Record *R) {
bool Ins = Classes.insert(std::make_pair(R->getName(), R)).second;