X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTableGen%2FRecord.h;h=d775ddc3cba0dc3a0b1267525eff00cb1236c32b;hb=61f49542d7ca5a3fb6f752c88ba7eaf3fbffbaeb;hp=f3e014222235cdf047201d8dc606ce71e141c19d;hpb=b50df4a3df6db2ace3c011267934d3d10bdcc8db;p=oota-llvm.git diff --git a/include/llvm/TableGen/Record.h b/include/llvm/TableGen/Record.h index f3e01422223..d775ddc3cba 100644 --- a/include/llvm/TableGen/Record.h +++ b/include/llvm/TableGen/Record.h @@ -26,40 +26,11 @@ #include namespace llvm { -class raw_ostream; -// RecTy subclasses. -class BitRecTy; -class BitsRecTy; -class IntRecTy; -class StringRecTy; class ListRecTy; -class DagRecTy; -class RecordRecTy; - -// Init subclasses. -class Init; -class UnsetInit; -class BitInit; -class BitsInit; -class IntInit; -class StringInit; -class ListInit; -class UnOpInit; -class BinOpInit; -class TernOpInit; -class DefInit; -class DagInit; -class TypedInit; -class VarInit; -class FieldInit; -class VarBitInit; -class VarListElementInit; - -// Other classes. +struct MultiClass; class Record; class RecordVal; -struct MultiClass; class RecordKeeper; //===----------------------------------------------------------------------===// @@ -81,13 +52,12 @@ public: private: RecTyKind Kind; - ListRecTy *ListTy; - virtual void anchor(); + std::unique_ptr ListTy; public: RecTyKind getRecTyKind() const { return Kind; } - RecTy(RecTyKind K) : Kind(K), ListTy(0) {} + RecTy(RecTyKind K) : Kind(K) {} virtual ~RecTy() {} virtual std::string getAsString() const = 0; @@ -96,40 +66,10 @@ public: /// typeIsConvertibleTo - Return true if all values of 'this' type can be /// converted to the specified type. - virtual bool typeIsConvertibleTo(const RecTy *RHS) const = 0; + virtual bool typeIsConvertibleTo(const RecTy *RHS) const; /// getListTy - Returns the type representing list. 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( UnOpInit *UI) { - return convertValue((TypedInit*)UI); - } - virtual Init *convertValue( BinOpInit *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( VarInit *VI) { - return convertValue((TypedInit*)VI); - } - virtual Init *convertValue( FieldInit *FI) { - return convertValue((TypedInit*)FI); - } - -public: - virtual bool baseClassOf(const RecTy*) const; }; inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) { @@ -137,12 +77,12 @@ inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) { 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; @@ -150,37 +90,17 @@ public: static BitRecTy *get() { return &Shared; } - virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } - virtual Init *convertValue( BitInit *BI) { return (Init*)BI; } - virtual Init *convertValue( BitsInit *BI); - virtual Init *convertValue( IntInit *II); - virtual Init *convertValue(StringInit *SI) { return 0; } - virtual Init *convertValue( ListInit *LI) { 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( UnOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( TypedInit *TI); - virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} - virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} - - virtual std::string getAsString() const { return "bit"; } - - virtual bool typeIsConvertibleTo(const RecTy *RHS) const { - return RHS->baseClassOf(this); - } - virtual bool baseClassOf(const RecTy*) const; -}; + std::string getAsString() const override { return "bit"; } + bool typeIsConvertibleTo(const RecTy *RHS) const override; +}; -// BitsRecTy - 'bits' - Represent a fixed number of bits -/// BitsRecTy - 'bits<n>' - Represent a fixed number of bits +/// BitsRecTy - 'bits' - 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; @@ -190,36 +110,17 @@ public: unsigned getNumBits() const { return Size; } - virtual Init *convertValue( UnsetInit *UI); - virtual Init *convertValue( BitInit *UI); - virtual Init *convertValue( BitsInit *BI); - virtual Init *convertValue( IntInit *II); - virtual Init *convertValue(StringInit *SI) { return 0; } - virtual Init *convertValue( ListInit *LI) { return 0; } - virtual Init *convertValue(VarBitInit *VB) { return 0; } - virtual Init *convertValue( DefInit *DI) { return 0; } - virtual Init *convertValue( DagInit *DI) { return 0; } - virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( TypedInit *TI); - virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} - virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} - - virtual std::string getAsString() const; - - virtual bool typeIsConvertibleTo(const RecTy *RHS) const { - return RHS->baseClassOf(this); - } - virtual bool baseClassOf(const RecTy*) const; -}; + std::string getAsString() const override; + bool typeIsConvertibleTo(const RecTy *RHS) 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; @@ -227,29 +128,9 @@ public: static IntRecTy *get() { return &Shared; } - virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } - virtual Init *convertValue( BitInit *BI); - virtual Init *convertValue( BitsInit *BI); - virtual Init *convertValue( IntInit *II) { return (Init*)II; } - virtual Init *convertValue(StringInit *SI) { return 0; } - virtual Init *convertValue( ListInit *LI) { return 0; } - virtual Init *convertValue(VarBitInit *VB) { return 0; } - virtual Init *convertValue( DefInit *DI) { return 0; } - virtual Init *convertValue( DagInit *DI) { return 0; } - virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( TypedInit *TI); - virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} - virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} - - virtual std::string getAsString() const { return "int"; } - - virtual bool typeIsConvertibleTo(const RecTy *RHS) const { - return RHS->baseClassOf(this); - } - - virtual bool baseClassOf(const RecTy*) const; + std::string getAsString() const override { return "int"; } + + bool typeIsConvertibleTo(const RecTy *RHS) const override; }; /// StringRecTy - 'string' - Represent an string value @@ -257,6 +138,7 @@ public: class StringRecTy : public RecTy { static StringRecTy Shared; StringRecTy() : RecTy(StringRecTyKind) {} + public: static bool classof(const RecTy *RT) { return RT->getRecTyKind() == StringRecTyKind; @@ -264,39 +146,17 @@ public: static StringRecTy *get() { return &Shared; } - virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } - 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 (Init*)SI; } - virtual Init *convertValue( ListInit *LI) { return 0; } - virtual Init *convertValue( UnOpInit *BO); - virtual Init *convertValue( BinOpInit *BO); - virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);} - - 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); - virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} - virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} - - virtual std::string getAsString() const { return "string"; } - - virtual bool typeIsConvertibleTo(const RecTy *RHS) const { - return RHS->baseClassOf(this); - } + std::string getAsString() const override; }; -// ListRecTy - 'list' - Represent a list of values, all of which must be of -// the specified type. -/// ListRecTy - 'list<Ty>' - Represent a list of values, all of which must -/// be of the specified type. +/// ListRecTy - 'list' - Represent a list of values, all of which must be of +/// the specified type. /// class ListRecTy : public RecTy { 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; @@ -305,29 +165,9 @@ public: static ListRecTy *get(RecTy *T) { return T->getListTy(); } RecTy *getElementType() const { return Ty; } - virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } - 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); - virtual Init *convertValue(VarBitInit *VB) { return 0; } - virtual Init *convertValue( DefInit *DI) { return 0; } - virtual Init *convertValue( DagInit *DI) { return 0; } - virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( TypedInit *TI); - virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} - virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} - - virtual std::string getAsString() const; - - virtual bool typeIsConvertibleTo(const RecTy *RHS) const { - return RHS->baseClassOf(this); - } - - virtual bool baseClassOf(const RecTy*) const; + std::string getAsString() const override; + + bool typeIsConvertibleTo(const RecTy *RHS) const override; }; /// DagRecTy - 'dag' - Represent a dag fragment @@ -335,6 +175,7 @@ public: class DagRecTy : public RecTy { static DagRecTy Shared; DagRecTy() : RecTy(DagRecTyKind) {} + public: static bool classof(const RecTy *RT) { return RT->getRecTyKind() == DagRecTyKind; @@ -342,30 +183,9 @@ public: static DagRecTy *get() { return &Shared; } - virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } - 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(VarBitInit *VB) { return 0; } - virtual Init *convertValue( DefInit *DI) { return 0; } - virtual Init *convertValue( UnOpInit *BO); - virtual Init *convertValue( BinOpInit *BO); - virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(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);} - - virtual std::string getAsString() const { return "dag"; } - - virtual bool typeIsConvertibleTo(const RecTy *RHS) const { - return RHS->baseClassOf(this); - } + std::string getAsString() const override; }; - /// RecordRecTy - '[classname]' - Represent an instance of a class, such as: /// (R32 X = EAX). /// @@ -373,6 +193,7 @@ class RecordRecTy : public RecTy { Record *Rec; explicit RecordRecTy(Record *R) : RecTy(RecordRecTyKind), Rec(R) {} friend class Record; + public: static bool classof(const RecTy *RT) { return RT->getRecTyKind() == RecordRecTyKind; @@ -382,28 +203,9 @@ public: Record *getRecord() const { return Rec; } - virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; } - 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(VarBitInit *VB) { return 0; } - virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);} - virtual Init *convertValue( DefInit *DI); - virtual Init *convertValue( DagInit *DI) { return 0; } - virtual Init *convertValue( TypedInit *VI); - virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);} - virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);} - - virtual std::string getAsString() const; - - virtual bool typeIsConvertibleTo(const RecTy *RHS) const { - return RHS->baseClassOf(this); - } - virtual bool baseClassOf(const RecTy*) const; + std::string getAsString() const override; + + bool typeIsConvertibleTo(const RecTy *RHS) const override; }; /// resolveTypes - Find a common type that T1 and T2 convert to. @@ -432,8 +234,8 @@ protected: /// readability for really no benefit. enum InitKind { IK_BitInit, - IK_BitsInit, IK_FirstTypedInit, + IK_BitsInit, IK_DagInit, IK_DefInit, IK_FieldInit, @@ -454,8 +256,8 @@ protected: private: const InitKind Kind; - Init(const Init &) LLVM_DELETED_FUNCTION; - Init &operator=(const Init &) LLVM_DELETED_FUNCTION; + Init(const Init &) = delete; + Init &operator=(const Init &) = delete; virtual void anchor(); public: @@ -486,10 +288,8 @@ public: /// invokes print on stderr. void dump() const; - /// convertInitializerTo - This virtual function is a simple call-back - /// function that should be overridden to call the appropriate - /// RecTy::convertValue method. - /// + /// convertInitializerTo - This virtual function converts to the appropriate + /// Init based on the passed in type. virtual Init *convertInitializerTo(RecTy *Ty) const = 0; /// convertInitializerBitRange - This method is used to implement the bitrange @@ -499,7 +299,7 @@ public: /// virtual Init * convertInitializerBitRange(const std::vector &Bits) const { - return 0; + return nullptr; } /// convertInitListSlice - This method is used to implement the list slice @@ -509,14 +309,16 @@ public: /// virtual Init * convertInitListSlice(const std::vector &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 @@ -524,7 +326,7 @@ public: /// 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 @@ -559,11 +361,16 @@ inline raw_ostream &operator<<(raw_ostream &OS, const Init &I) { class TypedInit : public Init { RecTy *Ty; - TypedInit(const TypedInit &Other) LLVM_DELETED_FUNCTION; - TypedInit &operator=(const TypedInit &Other) LLVM_DELETED_FUNCTION; + TypedInit(const TypedInit &Other) = delete; + TypedInit &operator=(const TypedInit &Other) = delete; protected: explicit TypedInit(InitKind K, RecTy *T) : Init(K), Ty(T) {} + ~TypedInit() { + // If this is a DefInit we need to delete the RecordRecTy. + if (getKind() == IK_DefInit) + delete Ty; + } public: static bool classof(const Init *I) { @@ -572,16 +379,18 @@ public: } RecTy *getType() const { return Ty; } - virtual Init * - convertInitializerBitRange(const std::vector &Bits) const; - virtual Init * - convertInitListSlice(const std::vector &Elements) const; + Init *convertInitializerTo(RecTy *Ty) const override; + + Init * + convertInitializerBitRange(const std::vector &Bits) const override; + Init * + convertInitListSlice(const std::vector &Elements) const override; /// 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; + RecTy *getFieldType(const std::string &FieldName) const override; /// resolveListElementReference - This method is used to implement /// VarListElementInit::resolveReferences. If the list element is resolvable @@ -590,14 +399,12 @@ public: unsigned Elt) const = 0; }; - /// UnsetInit - ? - Represents an uninitialized value /// class UnsetInit : public Init { UnsetInit() : Init(IK_UnsetInit) {} - UnsetInit(const UnsetInit &) LLVM_DELETED_FUNCTION; - UnsetInit &operator=(const UnsetInit &Other) LLVM_DELETED_FUNCTION; - virtual void anchor(); + UnsetInit(const UnsetInit &) = delete; + UnsetInit &operator=(const UnsetInit &Other) = delete; public: static bool classof(const Init *I) { @@ -605,28 +412,24 @@ public: } static UnsetInit *get(); - virtual Init *convertInitializerTo(RecTy *Ty) const { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; - virtual Init *getBit(unsigned Bit) const { + Init *getBit(unsigned Bit) const override { return const_cast(this); } - virtual bool isComplete() const { return false; } - virtual std::string getAsString() const { return "?"; } + bool isComplete() const override { return false; } + std::string getAsString() const override { return "?"; } }; - /// BitInit - true/false - Represent a concrete initializer for a bit. /// class BitInit : public Init { bool Value; explicit BitInit(bool V) : Init(IK_BitInit), Value(V) {} - BitInit(const BitInit &Other) LLVM_DELETED_FUNCTION; - BitInit &operator=(BitInit &Other) LLVM_DELETED_FUNCTION; - virtual void anchor(); + BitInit(const BitInit &Other) = delete; + BitInit &operator=(BitInit &Other) = delete; public: static bool classof(const Init *I) { @@ -636,29 +439,28 @@ public: bool getValue() const { return Value; } - virtual Init *convertInitializerTo(RecTy *Ty) const { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; - virtual Init *getBit(unsigned Bit) const { + Init *getBit(unsigned Bit) const override { assert(Bit < 1 && "Bit index out of range!"); return const_cast(this); } - virtual std::string getAsString() const { return Value ? "1" : "0"; } + std::string getAsString() const override { return Value ? "1" : "0"; } }; /// BitsInit - { a, b, c } - Represents an initializer for a BitsRecTy value. /// It contains a vector of bits, whose size is determined by the type. /// -class BitsInit : public Init, public FoldingSetNode { +class BitsInit : public TypedInit, public FoldingSetNode { std::vector Bits; BitsInit(ArrayRef Range) - : Init(IK_BitsInit), Bits(Range.begin(), Range.end()) {} + : TypedInit(IK_BitsInit, BitsRecTy::get(Range.size())), + Bits(Range.begin(), Range.end()) {} - BitsInit(const BitsInit &Other) LLVM_DELETED_FUNCTION; - BitsInit &operator=(const BitsInit &Other) LLVM_DELETED_FUNCTION; + BitsInit(const BitsInit &Other) = delete; + BitsInit &operator=(const BitsInit &Other) = delete; public: static bool classof(const Init *I) { @@ -670,13 +472,11 @@ public: unsigned getNumBits() const { return Bits.size(); } - virtual Init *convertInitializerTo(RecTy *Ty) const { - return Ty->convertValue(const_cast(this)); - } - virtual Init * - convertInitializerBitRange(const std::vector &Bits) const; + Init *convertInitializerTo(RecTy *Ty) const override; + Init * + convertInitializerBitRange(const std::vector &Bits) const override; - virtual bool isComplete() const { + bool isComplete() const override { for (unsigned i = 0; i != getNumBits(); ++i) if (!getBit(i)->isComplete()) return false; return true; @@ -686,18 +486,25 @@ public: if (getBit(i)->isComplete()) return false; return true; } - virtual std::string getAsString() const; + std::string getAsString() const override; - virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; + /// resolveListElementReference - This method is used to implement + /// VarListElementInit::resolveReferences. If the list element is resolvable + /// now, we return the resolved value, otherwise we return null. + Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const override { + llvm_unreachable("Illegal element reference off bits"); + } - virtual Init *getBit(unsigned Bit) const { + Init *resolveReferences(Record &R, const RecordVal *RV) const override; + + Init *getBit(unsigned Bit) const override { assert(Bit < Bits.size() && "Bit index out of range!"); return Bits[Bit]; } }; - -/// IntInit - 7 - Represent an initalization by a literal integer value. +/// IntInit - 7 - Represent an initialization by a literal integer value. /// class IntInit : public TypedInit { int64_t Value; @@ -705,8 +512,8 @@ class IntInit : public TypedInit { explicit IntInit(int64_t V) : TypedInit(IK_IntInit, IntRecTy::get()), Value(V) {} - IntInit(const IntInit &Other) LLVM_DELETED_FUNCTION; - IntInit &operator=(const IntInit &Other) LLVM_DELETED_FUNCTION; + IntInit(const IntInit &Other) = delete; + IntInit &operator=(const IntInit &Other) = delete; public: static bool classof(const Init *I) { @@ -716,28 +523,25 @@ public: int64_t getValue() const { return Value; } - virtual Init *convertInitializerTo(RecTy *Ty) const { - return Ty->convertValue(const_cast(this)); - } - virtual Init * - convertInitializerBitRange(const std::vector &Bits) const; + Init *convertInitializerTo(RecTy *Ty) const override; + Init * + convertInitializerBitRange(const std::vector &Bits) const override; - virtual std::string getAsString() const; + std::string getAsString() const override; /// resolveListElementReference - This method is used to implement /// VarListElementInit::resolveReferences. If the list element is resolvable /// now, we return the resolved value, otherwise we return null. - virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt) const { + Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const override { llvm_unreachable("Illegal element reference off int"); } - virtual Init *getBit(unsigned Bit) const { + Init *getBit(unsigned Bit) const override { return BitInit::get((Value & (1ULL << Bit)) != 0); } }; - /// StringInit - "foo" - Represent an initialization by a string value. /// class StringInit : public TypedInit { @@ -746,9 +550,8 @@ class StringInit : public TypedInit { explicit StringInit(const std::string &V) : TypedInit(IK_StringInit, StringRecTy::get()), Value(V) {} - StringInit(const StringInit &Other) LLVM_DELETED_FUNCTION; - StringInit &operator=(const StringInit &Other) LLVM_DELETED_FUNCTION; - virtual void anchor(); + StringInit(const StringInit &Other) = delete; + StringInit &operator=(const StringInit &Other) = delete; public: static bool classof(const Init *I) { @@ -758,22 +561,20 @@ public: const std::string &getValue() const { return Value; } - virtual Init *convertInitializerTo(RecTy *Ty) const { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; - virtual std::string getAsString() const { return "\"" + Value + "\""; } - virtual std::string getAsUnquotedString() const { return Value; } + std::string getAsString() const override { return "\"" + Value + "\""; } + std::string getAsUnquotedString() const override { return Value; } /// resolveListElementReference - This method is used to implement /// VarListElementInit::resolveReferences. If the list element is resolvable /// now, we return the resolved value, otherwise we return null. - virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt) const { + Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const override { llvm_unreachable("Illegal element reference off string"); } - virtual Init *getBit(unsigned Bit) const { + Init *getBit(unsigned Bit) const override { llvm_unreachable("Illegal bit reference off string"); } }; @@ -782,6 +583,7 @@ public: /// class ListInit : public TypedInit, public FoldingSetNode { std::vector Values; + public: typedef std::vector::const_iterator const_iterator; @@ -790,8 +592,8 @@ private: : TypedInit(IK_ListInit, ListRecTy::get(EltTy)), Values(Range.begin(), Range.end()) {} - ListInit(const ListInit &Other) LLVM_DELETED_FUNCTION; - ListInit &operator=(const ListInit &Other) LLVM_DELETED_FUNCTION; + ListInit(const ListInit &Other) = delete; + ListInit &operator=(const ListInit &Other) = delete; public: static bool classof(const Init *I) { @@ -801,7 +603,6 @@ public: void Profile(FoldingSetNodeID &ID) const; - unsigned getSize() const { return Values.size(); } Init *getElement(unsigned i) const { assert(i < Values.size() && "List element index out of range!"); return Values[i]; @@ -809,47 +610,44 @@ public: Record *getElementAsRecord(unsigned i) const; - virtual Init * - convertInitListSlice(const std::vector &Elements) const; + Init * + convertInitListSlice(const std::vector &Elements) const override; - virtual Init *convertInitializerTo(RecTy *Ty) const { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; /// resolveReferences - This method is used by classes that refer to other /// variables which may not be defined at the time they expression is formed. /// If a value is set for the variable later, this method will be called on /// users of the value to allow the value to propagate out. /// - virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; + Init *resolveReferences(Record &R, const RecordVal *RV) const override; - virtual std::string getAsString() const; + std::string getAsString() const override; ArrayRef getValues() const { return Values; } - inline const_iterator begin() const { return Values.begin(); } - inline const_iterator end () const { return Values.end(); } + const_iterator begin() const { return Values.begin(); } + const_iterator end () const { return Values.end(); } - inline size_t size () const { return Values.size(); } - inline bool empty() const { return Values.empty(); } + size_t size () const { return Values.size(); } + bool empty() const { return Values.empty(); } /// resolveListElementReference - This method is used to implement /// VarListElementInit::resolveReferences. If the list element is resolvable /// now, we return the resolved value, otherwise we return null. - virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt) const; + Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const override; - virtual Init *getBit(unsigned Bit) const { + Init *getBit(unsigned Bit) const override { llvm_unreachable("Illegal bit reference off list"); } }; - /// OpInit - Base class for operators /// class OpInit : public TypedInit { - OpInit(const OpInit &Other) LLVM_DELETED_FUNCTION; - OpInit &operator=(OpInit &Other) LLVM_DELETED_FUNCTION; + OpInit(const OpInit &Other) = delete; + OpInit &operator=(OpInit &Other) = delete; protected: explicit OpInit(InitKind K, RecTy *Type) : TypedInit(K, Type) {} @@ -869,22 +667,18 @@ public: // possible to fold. virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0; - virtual Init *convertInitializerTo(RecTy *Ty) const { - return Ty->convertValue(const_cast(this)); - } - - virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt) const; + Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const override; - virtual Init *getBit(unsigned Bit) const; + 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; @@ -892,8 +686,8 @@ private: UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type) : OpInit(IK_UnOpInit, Type), Opc(opc), LHS(lhs) {} - UnOpInit(const UnOpInit &Other) LLVM_DELETED_FUNCTION; - UnOpInit &operator=(const UnOpInit &Other) LLVM_DELETED_FUNCTION; + UnOpInit(const UnOpInit &Other) = delete; + UnOpInit &operator=(const UnOpInit &Other) = delete; public: static bool classof(const Init *I) { @@ -902,14 +696,14 @@ public: static UnOpInit *get(UnaryOp opc, Init *lhs, RecTy *Type); // Clone - Clone this operator, replacing arguments with the new list - virtual OpInit *clone(std::vector &Operands) const { + OpInit *clone(std::vector &Operands) const override { assert(Operands.size() == 1 && "Wrong number of operands for unary operation"); return UnOpInit::get(getOpcode(), *Operands.begin(), getType()); } - virtual int getNumOperands() const { return 1; } - virtual Init *getOperand(int i) const { + int getNumOperands() const override { return 1; } + Init *getOperand(int i) const override { assert(i == 0 && "Invalid operand id for unary operator"); return getOperand(); } @@ -919,18 +713,19 @@ public: // Fold - If possible, fold this to a simpler init. Return this if not // possible to fold. - virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const; + Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const override; - virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; + Init *resolveReferences(Record &R, const RecordVal *RV) const override; - virtual std::string getAsString() const; + std::string getAsString() const override; }; /// BinOpInit - !op (X, Y) - Combine two inits. /// class BinOpInit : public OpInit { public: - enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, EQ }; + enum BinaryOp { ADD, AND, SHL, SRA, SRL, LISTCONCAT, STRCONCAT, CONCAT, EQ }; + private: BinaryOp Opc; Init *LHS, *RHS; @@ -938,8 +733,8 @@ private: BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) : OpInit(IK_BinOpInit, Type), Opc(opc), LHS(lhs), RHS(rhs) {} - BinOpInit(const BinOpInit &Other) LLVM_DELETED_FUNCTION; - BinOpInit &operator=(const BinOpInit &Other) LLVM_DELETED_FUNCTION; + BinOpInit(const BinOpInit &Other) = delete; + BinOpInit &operator=(const BinOpInit &Other) = delete; public: static bool classof(const Init *I) { @@ -949,14 +744,14 @@ public: RecTy *Type); // Clone - Clone this operator, replacing arguments with the new list - virtual OpInit *clone(std::vector &Operands) const { + OpInit *clone(std::vector &Operands) const override { assert(Operands.size() == 2 && "Wrong number of operands for binary operation"); return BinOpInit::get(getOpcode(), Operands[0], Operands[1], getType()); } - virtual int getNumOperands() const { return 2; } - virtual Init *getOperand(int i) const { + int getNumOperands() const override { return 2; } + Init *getOperand(int i) const override { assert((i == 0 || i == 1) && "Invalid operand id for binary operator"); if (i == 0) { return getLHS(); @@ -971,11 +766,11 @@ public: // Fold - If possible, fold this to a simpler init. Return this if not // possible to fold. - virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const; + Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const override; - virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; + Init *resolveReferences(Record &R, const RecordVal *RV) const override; - virtual std::string getAsString() const; + std::string getAsString() const override; }; /// TernOpInit - !op (X, Y, Z) - Combine two inits. @@ -983,6 +778,7 @@ public: class TernOpInit : public OpInit { public: enum TernaryOp { SUBST, FOREACH, IF }; + private: TernaryOp Opc; Init *LHS, *MHS, *RHS; @@ -991,8 +787,8 @@ private: RecTy *Type) : OpInit(IK_TernOpInit, Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) {} - TernOpInit(const TernOpInit &Other) LLVM_DELETED_FUNCTION; - TernOpInit &operator=(const TernOpInit &Other) LLVM_DELETED_FUNCTION; + TernOpInit(const TernOpInit &Other) = delete; + TernOpInit &operator=(const TernOpInit &Other) = delete; public: static bool classof(const Init *I) { @@ -1003,15 +799,15 @@ public: RecTy *Type); // Clone - Clone this operator, replacing arguments with the new list - virtual OpInit *clone(std::vector &Operands) const { + OpInit *clone(std::vector &Operands) const override { assert(Operands.size() == 3 && "Wrong number of operands for ternary operation"); return TernOpInit::get(getOpcode(), Operands[0], Operands[1], Operands[2], getType()); } - virtual int getNumOperands() const { return 3; } - virtual Init *getOperand(int i) const { + int getNumOperands() const override { return 3; } + Init *getOperand(int i) const override { assert((i == 0 || i == 1 || i == 2) && "Invalid operand id for ternary operator"); if (i == 0) { @@ -1030,16 +826,15 @@ public: // Fold - If possible, fold this to a simpler init. Return this if not // possible to fold. - virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const; + Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const override; - virtual bool isComplete() const { return false; } + bool isComplete() const override { return false; } - virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; + Init *resolveReferences(Record &R, const RecordVal *RV) const override; - virtual std::string getAsString() const; + std::string getAsString() const override; }; - /// VarInit - 'Opcode' - Represent a reference to an entire variable object. /// class VarInit : public TypedInit { @@ -1050,8 +845,8 @@ class VarInit : public TypedInit { explicit VarInit(Init *VN, RecTy *T) : TypedInit(IK_VarInit, T), VarName(VN) {} - VarInit(const VarInit &Other) LLVM_DELETED_FUNCTION; - VarInit &operator=(const VarInit &Other) LLVM_DELETED_FUNCTION; + VarInit(const VarInit &Other) = delete; + VarInit &operator=(const VarInit &Other) = delete; public: static bool classof(const Init *I) { @@ -1060,36 +855,31 @@ public: static VarInit *get(const std::string &VN, RecTy *T); static VarInit *get(Init *VN, RecTy *T); - virtual Init *convertInitializerTo(RecTy *Ty) const { - return Ty->convertValue(const_cast(this)); - } - const std::string &getName() const; Init *getNameInit() const { return VarName; } std::string getNameInitAsString() const { return getNameInit()->getAsUnquotedString(); } - virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt) const; + Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const override; - virtual RecTy *getFieldType(const std::string &FieldName) const; - virtual Init *getFieldInit(Record &R, const RecordVal *RV, - const std::string &FieldName) const; + RecTy *getFieldType(const std::string &FieldName) const override; + Init *getFieldInit(Record &R, const RecordVal *RV, + const std::string &FieldName) const override; /// resolveReferences - This method is used by classes that refer to other /// variables which may not be defined at the time they expression is formed. /// If a value is set for the variable later, this method will be called on /// users of the value to allow the value to propagate out. /// - virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; + Init *resolveReferences(Record &R, const RecordVal *RV) const override; - virtual Init *getBit(unsigned Bit) const; + Init *getBit(unsigned Bit) const override; - virtual std::string getAsString() const { return getName(); } + std::string getAsString() const override { return getName(); } }; - /// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field. /// class VarBitInit : public Init { @@ -1104,8 +894,8 @@ class VarBitInit : public Init { "Illegal VarBitInit expression!"); } - VarBitInit(const VarBitInit &Other) LLVM_DELETED_FUNCTION; - VarBitInit &operator=(const VarBitInit &Other) LLVM_DELETED_FUNCTION; + VarBitInit(const VarBitInit &Other) = delete; + VarBitInit &operator=(const VarBitInit &Other) = delete; public: static bool classof(const Init *I) { @@ -1113,17 +903,15 @@ public: } static VarBitInit *get(TypedInit *T, unsigned B); - virtual Init *convertInitializerTo(RecTy *Ty) const { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; - virtual Init *getBitVar() const { return TI; } - virtual unsigned getBitNum() const { return Bit; } + Init *getBitVar() const override { return TI; } + unsigned getBitNum() const override { return Bit; } - virtual std::string getAsString() const; - virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; + std::string getAsString() const override; + Init *resolveReferences(Record &R, const RecordVal *RV) const override; - virtual Init *getBit(unsigned B) const { + Init *getBit(unsigned B) const override { assert(B < 1 && "Bit index out of range!"); return const_cast(this); } @@ -1143,8 +931,8 @@ class VarListElementInit : public TypedInit { "Illegal VarBitInit expression!"); } - VarListElementInit(const VarListElementInit &Other) LLVM_DELETED_FUNCTION; - void operator=(const VarListElementInit &Other) LLVM_DELETED_FUNCTION; + VarListElementInit(const VarListElementInit &Other) = delete; + void operator=(const VarListElementInit &Other) = delete; public: static bool classof(const Init *I) { @@ -1152,24 +940,19 @@ public: } static VarListElementInit *get(TypedInit *T, unsigned E); - virtual Init *convertInitializerTo(RecTy *Ty) const { - return Ty->convertValue(const_cast(this)); - } - TypedInit *getVariable() const { return TI; } unsigned getElementNum() const { return Element; } /// resolveListElementReference - This method is used to implement /// VarListElementInit::resolveReferences. If the list element is resolvable /// now, we return the resolved value, otherwise we return null. - virtual Init *resolveListElementReference(Record &R, - const RecordVal *RV, - unsigned Elt) const; + Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const override; - virtual std::string getAsString() const; - virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; + std::string getAsString() const override; + Init *resolveReferences(Record &R, const RecordVal *RV) const override; - virtual Init *getBit(unsigned Bit) const; + Init *getBit(unsigned Bit) const override; }; /// DefInit - AL - Represent a reference to a 'def' in the description @@ -1180,8 +963,8 @@ class DefInit : public TypedInit { DefInit(Record *D, RecordRecTy *T) : TypedInit(IK_DefInit, T), Def(D) {} friend class Record; - DefInit(const DefInit &Other) LLVM_DELETED_FUNCTION; - DefInit &operator=(const DefInit &Other) LLVM_DELETED_FUNCTION; + DefInit(const DefInit &Other) = delete; + DefInit &operator=(const DefInit &Other) = delete; public: static bool classof(const Init *I) { @@ -1189,34 +972,31 @@ public: } static DefInit *get(Record*); - virtual Init *convertInitializerTo(RecTy *Ty) const { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; Record *getDef() const { return Def; } //virtual Init *convertInitializerBitRange(const std::vector &Bits); - virtual RecTy *getFieldType(const std::string &FieldName) const; - virtual Init *getFieldInit(Record &R, const RecordVal *RV, - const std::string &FieldName) const; + RecTy *getFieldType(const std::string &FieldName) const override; + Init *getFieldInit(Record &R, const RecordVal *RV, + const std::string &FieldName) const override; - virtual std::string getAsString() const; + std::string getAsString() const override; - virtual Init *getBit(unsigned Bit) const { + Init *getBit(unsigned Bit) const override { llvm_unreachable("Illegal bit reference off def"); } /// resolveListElementReference - This method is used to implement /// VarListElementInit::resolveReferences. If the list element is resolvable /// now, we return the resolved value, otherwise we return null. - virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt) const { + Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const override { llvm_unreachable("Illegal element reference off def"); } }; - /// FieldInit - X.Y - Represent a reference to a subfield of a variable /// class FieldInit : public TypedInit { @@ -1228,8 +1008,8 @@ class FieldInit : public TypedInit { assert(getType() && "FieldInit with non-record type!"); } - FieldInit(const FieldInit &Other) LLVM_DELETED_FUNCTION; - FieldInit &operator=(const FieldInit &Other) LLVM_DELETED_FUNCTION; + FieldInit(const FieldInit &Other) = delete; + FieldInit &operator=(const FieldInit &Other) = delete; public: static bool classof(const Init *I) { @@ -1238,19 +1018,14 @@ public: static FieldInit *get(Init *R, const std::string &FN); static FieldInit *get(Init *R, const Init *FN); - virtual Init *convertInitializerTo(RecTy *Ty) const { - return Ty->convertValue(const_cast(this)); - } - - virtual Init *getBit(unsigned Bit) const; + Init *getBit(unsigned Bit) const override; - virtual Init *resolveListElementReference(Record &R, - const RecordVal *RV, - unsigned Elt) const; + Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const override; - virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; + Init *resolveReferences(Record &R, const RecordVal *RV) const override; - virtual std::string getAsString() const { + std::string getAsString() const override { return Rec->getAsString() + "." + FieldName; } }; @@ -1272,8 +1047,8 @@ class DagInit : public TypedInit, public FoldingSetNode { Args(ArgRange.begin(), ArgRange.end()), ArgNames(NameRange.begin(), NameRange.end()) {} - DagInit(const DagInit &Other) LLVM_DELETED_FUNCTION; - DagInit &operator=(const DagInit &Other) LLVM_DELETED_FUNCTION; + DagInit(const DagInit &Other) = delete; + DagInit &operator=(const DagInit &Other) = delete; public: static bool classof(const Init *I) { @@ -1288,9 +1063,7 @@ public: void Profile(FoldingSetNodeID &ID) const; - virtual Init *convertInitializerTo(RecTy *Ty) const { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; Init *getOperator() const { return Val; } @@ -1306,9 +1079,9 @@ public: return ArgNames[Num]; } - virtual Init *resolveReferences(Record &R, const RecordVal *RV) const; + Init *resolveReferences(Record &R, const RecordVal *RV) const override; - virtual std::string getAsString() const; + std::string getAsString() const override; typedef std::vector::const_iterator const_arg_iterator; typedef std::vector::const_iterator const_name_iterator; @@ -1325,12 +1098,12 @@ public: inline size_t name_size () const { return ArgNames.size(); } inline bool name_empty() const { return ArgNames.empty(); } - virtual Init *getBit(unsigned Bit) const { + Init *getBit(unsigned Bit) const override { llvm_unreachable("Illegal bit reference off dag"); } - virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt) const { + Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const override { llvm_unreachable("Illegal element reference off dag"); } }; @@ -1344,6 +1117,7 @@ class RecordVal { RecTy *Ty; unsigned Prefix; Init *Value; + public: RecordVal(Init *N, RecTy *T, unsigned P); RecordVal(const std::string &N, RecTy *T, unsigned P); @@ -1361,9 +1135,9 @@ public: bool setValue(Init *V) { if (V) { Value = V->convertInitializerTo(Ty); - return Value == 0; + return Value == nullptr; } - Value = 0; + Value = nullptr; return false; } @@ -1396,22 +1170,35 @@ class Record { DefInit *TheInit; bool IsAnonymous; + // Class-instance values can be used by other defs. For example, Struct + // is used here as a template argument to another class: + // + // multiclass MultiClass { + // def Def : Class>; + // + // These need to get fully resolved before instantiating any other + // definitions that usie them (e.g. Def). However, inside a multiclass they + // can't be immediately resolved so we mark them ResolveFirst to fully + // resolve them later as soon as the multiclass is instantiated. + bool ResolveFirst; + void init(); void checkName(); public: - // Constructs a record. explicit Record(const std::string &N, ArrayRef 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), + ResolveFirst(false) { init(); } explicit Record(Init *N, ArrayRef 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), + ResolveFirst(false) { init(); } @@ -1421,14 +1208,11 @@ public: ID(LastID++), Name(O.Name), Locs(O.Locs), TemplateArgs(O.TemplateArgs), Values(O.Values), SuperClasses(O.SuperClasses), SuperClassRanges(O.SuperClassRanges), TrackedRecords(O.TrackedRecords), - TheInit(O.TheInit), IsAnonymous(O.IsAnonymous) { } - - ~Record() {} - + TheInit(O.TheInit), IsAnonymous(O.IsAnonymous), + ResolveFirst(O.ResolveFirst) { } static unsigned getNewUID() { return LastID++; } - unsigned getID() const { return ID; } const std::string &getName() const; @@ -1460,13 +1244,13 @@ public: return false; } bool isTemplateArg(StringRef Name) const { - return isTemplateArg(StringInit::get(Name.str())); + return isTemplateArg(StringInit::get(Name)); } 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)); @@ -1474,7 +1258,7 @@ public: 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)); @@ -1485,11 +1269,11 @@ public: TemplateArgs.push_back(Name); } void addTemplateArg(StringRef Name) { - addTemplateArg(StringInit::get(Name.str())); + addTemplateArg(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 @@ -1510,7 +1294,7 @@ public: } void removeValue(StringRef Name) { - removeValue(StringInit::get(Name.str())); + removeValue(StringInit::get(Name)); } bool isSubClassOf(const Record *R) const { @@ -1536,7 +1320,7 @@ public: /// 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 @@ -1551,6 +1335,14 @@ public: return IsAnonymous; } + bool isResolveFirst() const { + return ResolveFirst; + } + + void setResolveFirst(bool b) { + ResolveFirst = b; + } + void dump() const; //===--------------------------------------------------------------------===// @@ -1562,6 +1354,11 @@ public: /// Init *getValueInit(StringRef FieldName) const; + /// Return true if the named field is unset. + bool isValueUnset(StringRef FieldName) const { + return getValueInit(FieldName) == UnsetInit::get(); + } + /// getValueAsString - This method looks up the specified field and returns /// its value as a string, throwing an exception if the field does not exist /// or if the value is not a string. @@ -1612,7 +1409,7 @@ public: /// getValueAsBitOrUnset - This method looks up the specified field and /// returns its value as a bit. If the field is unset, sets Unset to true and - /// retunrs false. + /// returns false. /// bool getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const; @@ -1633,7 +1430,7 @@ raw_ostream &operator<<(raw_ostream &OS, const Record &R); struct MultiClass { Record Rec; // Placeholder for template args and Name. - typedef std::vector RecordVector; + typedef std::vector> RecordVector; RecordVector DefPrototypes; void dump() const; @@ -1643,53 +1440,34 @@ struct MultiClass { }; class RecordKeeper { - std::map Classes, Defs; + typedef std::map> RecordMap; + RecordMap Classes, Defs; public: - ~RecordKeeper() { - for (std::map::iterator I = Classes.begin(), - E = Classes.end(); I != E; ++I) - delete I->second; - for (std::map::iterator I = Defs.begin(), - E = Defs.end(); I != E; ++I) - delete I->second; - } - - const std::map &getClasses() const { return Classes; } - const std::map &getDefs() const { return Defs; } + const RecordMap &getClasses() const { return Classes; } + const RecordMap &getDefs() const { return Defs; } Record *getClass(const std::string &Name) const { - std::map::const_iterator I = Classes.find(Name); - return I == Classes.end() ? 0 : I->second; + auto I = Classes.find(Name); + return I == Classes.end() ? nullptr : I->second.get(); } Record *getDef(const std::string &Name) const { - std::map::const_iterator I = Defs.find(Name); - return I == Defs.end() ? 0 : I->second; + auto I = Defs.find(Name); + return I == Defs.end() ? nullptr : I->second.get(); } - void addClass(Record *R) { - bool Ins = Classes.insert(std::make_pair(R->getName(), R)).second; + void addClass(std::unique_ptr R) { + bool Ins = Classes.insert(std::make_pair(R->getName(), + std::move(R))).second; (void)Ins; assert(Ins && "Class already exists"); } - void addDef(Record *R) { - bool Ins = Defs.insert(std::make_pair(R->getName(), R)).second; + void addDef(std::unique_ptr R) { + bool Ins = Defs.insert(std::make_pair(R->getName(), + std::move(R))).second; (void)Ins; assert(Ins && "Record already exists"); } - /// 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... @@ -1729,6 +1507,86 @@ struct LessRecordFieldName { } }; +struct LessRecordRegister { + static size_t min(size_t a, size_t b) { return a < b ? a : b; } + static bool ascii_isdigit(char x) { return x >= '0' && x <= '9'; } + + struct RecordParts { + SmallVector, 4> Parts; + + RecordParts(StringRef Rec) { + if (Rec.empty()) + return; + + size_t Len = 0; + const char *Start = Rec.data(); + const char *Curr = Start; + bool isDigitPart = ascii_isdigit(Curr[0]); + for (size_t I = 0, E = Rec.size(); I != E; ++I, ++Len) { + bool isDigit = ascii_isdigit(Curr[I]); + if (isDigit != isDigitPart) { + Parts.push_back(std::make_pair(isDigitPart, StringRef(Start, Len))); + Len = 0; + Start = &Curr[I]; + isDigitPart = ascii_isdigit(Curr[I]); + } + } + // Push the last part. + Parts.push_back(std::make_pair(isDigitPart, StringRef(Start, Len))); + } + + size_t size() { return Parts.size(); } + + std::pair getPart(size_t i) { + assert (i < Parts.size() && "Invalid idx!"); + return Parts[i]; + } + }; + + bool operator()(const Record *Rec1, const Record *Rec2) const { + RecordParts LHSParts(StringRef(Rec1->getName())); + RecordParts RHSParts(StringRef(Rec2->getName())); + + size_t LHSNumParts = LHSParts.size(); + size_t RHSNumParts = RHSParts.size(); + assert (LHSNumParts && RHSNumParts && "Expected at least one part!"); + + if (LHSNumParts != RHSNumParts) + return LHSNumParts < RHSNumParts; + + // We expect the registers to be of the form [_a-zA-z]+([0-9]*[_a-zA-Z]*)*. + for (size_t I = 0, E = LHSNumParts; I < E; I+=2) { + std::pair LHSPart = LHSParts.getPart(I); + std::pair RHSPart = RHSParts.getPart(I); + // Expect even part to always be alpha. + assert (LHSPart.first == false && RHSPart.first == false && + "Expected both parts to be alpha."); + if (int Res = LHSPart.second.compare(RHSPart.second)) + return Res < 0; + } + for (size_t I = 1, E = LHSNumParts; I < E; I+=2) { + std::pair LHSPart = LHSParts.getPart(I); + std::pair RHSPart = RHSParts.getPart(I); + // Expect odd part to always be numeric. + assert (LHSPart.first == true && RHSPart.first == true && + "Expected both parts to be numeric."); + if (LHSPart.second.size() != RHSPart.second.size()) + return LHSPart.second.size() < RHSPart.second.size(); + + unsigned LHSVal, RHSVal; + + bool LHSFailed = LHSPart.second.getAsInteger(10, LHSVal); (void)LHSFailed; + assert(!LHSFailed && "Unable to convert LHS to integer."); + bool RHSFailed = RHSPart.second.getAsInteger(10, RHSVal); (void)RHSFailed; + assert(!RHSFailed && "Unable to convert RHS to integer."); + + if (LHSVal != RHSVal) + return LHSVal < RHSVal; + } + return LHSNumParts < RHSNumParts; + } +}; + raw_ostream &operator<<(raw_ostream &OS, const RecordKeeper &RK); /// QualifyName - Return an Init with a qualifier prefix referring