X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=include%2Fllvm%2FTableGen%2FRecord.h;h=2bbb1b9033971c2861b472640ba3d3498996e79a;hp=36464d75d5abbb602636d218d378a79efdb55763;hb=2515069180b0b99872f6358a16316a9d29ef5340;hpb=68b0d1d2b47f1be8eec2ce57c8119906c354ccd8 diff --git a/include/llvm/TableGen/Record.h b/include/llvm/TableGen/Record.h index 36464d75d5a..2bbb1b90339 100644 --- a/include/llvm/TableGen/Record.h +++ b/include/llvm/TableGen/Record.h @@ -17,49 +17,20 @@ #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/FoldingSet.h" -#include "llvm/Support/Allocator.h" +#include "llvm/ADT/PointerIntPair.h" #include "llvm/Support/Casting.h" #include "llvm/Support/DataTypes.h" #include "llvm/Support/ErrorHandling.h" -#include "llvm/Support/SourceMgr.h" +#include "llvm/Support/SMLoc.h" #include "llvm/Support/raw_ostream.h" #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(nullptr) {} + 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 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( BinOpInit *UI) { - return convertValue((TypedInit*)UI); - } - virtual Init *convertValue( TernOpInit *UI) { - return convertValue((TypedInit*)UI); - } - 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); - } - 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) { @@ -150,28 +90,9 @@ public: static BitRecTy *get() { return &Shared; } - Init *convertValue( UnsetInit *UI) override { return (Init*)UI; } - Init *convertValue( BitInit *BI) override { return (Init*)BI; } - Init *convertValue( BitsInit *BI) override; - Init *convertValue( IntInit *II) override; - 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 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( 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 { return "bit"; } - bool typeIsConvertibleTo(const RecTy *RHS) const override { - return RHS->baseClassOf(this); - } - bool baseClassOf(const RecTy*) const override; + bool typeIsConvertibleTo(const RecTy *RHS) const override; }; /// BitsRecTy - 'bits' - Represent a fixed number of bits @@ -189,28 +110,9 @@ public: unsigned getNumBits() const { return Size; } - Init *convertValue( UnsetInit *UI) override; - Init *convertValue( BitInit *UI) override; - Init *convertValue( BitsInit *BI) override; - Init *convertValue( IntInit *II) override; - 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( 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 { - return RHS->baseClassOf(this); - } - bool baseClassOf(const RecTy*) const override; + bool typeIsConvertibleTo(const RecTy *RHS) const override; }; /// IntRecTy - 'int' - Represent an integer value of no particular size @@ -226,29 +128,9 @@ public: static IntRecTy *get() { return &Shared; } - Init *convertValue( UnsetInit *UI) override { return (Init*)UI; } - Init *convertValue( BitInit *BI) override; - Init *convertValue( BitsInit *BI) override; - Init *convertValue( IntInit *II) override { return (Init*)II; } - 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( 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 { return "int"; } - bool typeIsConvertibleTo(const RecTy *RHS) const override { - return RHS->baseClassOf(this); - } - - bool baseClassOf(const RecTy*) const override; + bool typeIsConvertibleTo(const RecTy *RHS) const override; }; /// StringRecTy - 'string' - Represent an string value @@ -264,28 +146,7 @@ public: static StringRecTy *get() { return &Shared; } - Init *convertValue( UnsetInit *UI) override { return (Init*)UI; } - 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 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 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);} - - std::string getAsString() const override { return "string"; } - - bool typeIsConvertibleTo(const RecTy *RHS) const override { - return RHS->baseClassOf(this); - } + std::string getAsString() const override; }; /// ListRecTy - 'list' - Represent a list of values, all of which must be of @@ -304,29 +165,9 @@ public: static ListRecTy *get(RecTy *T) { return T->getListTy(); } RecTy *getElementType() const { return Ty; } - Init *convertValue( UnsetInit *UI) override { return (Init*)UI; } - 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 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( 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 { - return RHS->baseClassOf(this); - } - - bool baseClassOf(const RecTy*) const override; + bool typeIsConvertibleTo(const RecTy *RHS) const override; }; /// DagRecTy - 'dag' - Represent a dag fragment @@ -342,27 +183,7 @@ public: static DagRecTy *get() { return &Shared; } - Init *convertValue( UnsetInit *UI) override { return (Init*)UI; } - 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);} - Init *convertValue( DagInit *CI) override { return (Init*)CI; } - 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 { return "dag"; } - - bool typeIsConvertibleTo(const RecTy *RHS) const override { - return RHS->baseClassOf(this); - } + std::string getAsString() const override; }; /// RecordRecTy - '[classname]' - Represent an instance of a class, such as: @@ -382,28 +203,9 @@ public: Record *getRecord() const { return Rec; } - Init *convertValue( UnsetInit *UI) override { return (Init*)UI; } - 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 nullptr; } - Init *convertValue( TypedInit *VI) 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 { - return RHS->baseClassOf(this); - } - bool baseClassOf(const RecTy*) 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 @@ -561,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) { @@ -574,6 +379,8 @@ public: } RecTy *getType() const { return Ty; } + Init *convertInitializerTo(RecTy *Ty) const override; + Init * convertInitializerBitRange(const std::vector &Bits) const override; Init * @@ -596,9 +403,8 @@ public: /// class UnsetInit : public Init { UnsetInit() : Init(IK_UnsetInit) {} - UnsetInit(const UnsetInit &) LLVM_DELETED_FUNCTION; - UnsetInit &operator=(const UnsetInit &Other) LLVM_DELETED_FUNCTION; - void anchor() override; + UnsetInit(const UnsetInit &) = delete; + UnsetInit &operator=(const UnsetInit &Other) = delete; public: static bool classof(const Init *I) { @@ -606,9 +412,7 @@ public: } static UnsetInit *get(); - Init *convertInitializerTo(RecTy *Ty) const override { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; Init *getBit(unsigned Bit) const override { return const_cast(this); @@ -624,9 +428,8 @@ 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; - void anchor() override; + BitInit(const BitInit &Other) = delete; + BitInit &operator=(BitInit &Other) = delete; public: static bool classof(const Init *I) { @@ -636,9 +439,7 @@ public: bool getValue() const { return Value; } - Init *convertInitializerTo(RecTy *Ty) const override { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; Init *getBit(unsigned Bit) const override { assert(Bit < 1 && "Bit index out of range!"); @@ -651,14 +452,15 @@ public: /// 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,9 +472,7 @@ public: unsigned getNumBits() const { return Bits.size(); } - Init *convertInitializerTo(RecTy *Ty) const override { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; Init * convertInitializerBitRange(const std::vector &Bits) const override; @@ -688,6 +488,14 @@ public: } 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. + Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const override { + llvm_unreachable("Illegal element reference off bits"); + } + Init *resolveReferences(Record &R, const RecordVal *RV) const override; Init *getBit(unsigned Bit) const override { @@ -704,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) { @@ -715,9 +523,7 @@ public: int64_t getValue() const { return Value; } - Init *convertInitializerTo(RecTy *Ty) const override { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; Init * convertInitializerBitRange(const std::vector &Bits) const override; @@ -741,12 +547,11 @@ public: class StringInit : public TypedInit { std::string Value; - explicit StringInit(const std::string &V) + explicit StringInit(StringRef V) : TypedInit(IK_StringInit, StringRecTy::get()), Value(V) {} - StringInit(const StringInit &Other) LLVM_DELETED_FUNCTION; - StringInit &operator=(const StringInit &Other) LLVM_DELETED_FUNCTION; - void anchor() override; + StringInit(const StringInit &Other) = delete; + StringInit &operator=(const StringInit &Other) = delete; public: static bool classof(const Init *I) { @@ -756,9 +561,7 @@ public: const std::string &getValue() const { return Value; } - Init *convertInitializerTo(RecTy *Ty) const override { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; std::string getAsString() const override { return "\"" + Value + "\""; } std::string getAsUnquotedString() const override { return Value; } @@ -789,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) { @@ -800,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]; @@ -811,9 +613,7 @@ public: Init * convertInitListSlice(const std::vector &Elements) const override; - Init *convertInitializerTo(RecTy *Ty) const override { - 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. @@ -826,11 +626,11 @@ public: 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 @@ -846,8 +646,8 @@ public: /// 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) {} @@ -860,17 +660,13 @@ public: // Clone - Clone this operator, replacing arguments with the new list virtual OpInit *clone(std::vector &Operands) const = 0; - virtual int getNumOperands() const = 0; - virtual Init *getOperand(int i) const = 0; + virtual unsigned getNumOperands() const = 0; + virtual Init *getOperand(unsigned i) const = 0; // Fold - If possible, fold this to a simpler init. Return this if not // possible to fold. virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0; - Init *convertInitializerTo(RecTy *Ty) const override { - return Ty->convertValue(const_cast(this)); - } - Init *resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) const override; @@ -890,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) { @@ -906,8 +702,8 @@ public: return UnOpInit::get(getOpcode(), *Operands.begin(), getType()); } - int getNumOperands() const override { return 1; } - Init *getOperand(int i) const override { + unsigned getNumOperands() const override { return 1; } + Init *getOperand(unsigned i) const override { assert(i == 0 && "Invalid operand id for unary operator"); return getOperand(); } @@ -928,7 +724,7 @@ public: /// class BinOpInit : public OpInit { public: - enum BinaryOp { ADD, SHL, SRA, SRL, LISTCONCAT, STRCONCAT, CONCAT, EQ }; + enum BinaryOp { ADD, AND, SHL, SRA, SRL, LISTCONCAT, STRCONCAT, CONCAT, EQ }; private: BinaryOp Opc; @@ -937,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) { @@ -954,13 +750,12 @@ public: return BinOpInit::get(getOpcode(), Operands[0], Operands[1], getType()); } - 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(); - } else { - return getRHS(); + unsigned getNumOperands() const override { return 2; } + Init *getOperand(unsigned i) const override { + switch (i) { + default: llvm_unreachable("Invalid operand id for binary operator"); + case 0: return getLHS(); + case 1: return getRHS(); } } @@ -991,8 +786,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) { @@ -1010,16 +805,13 @@ public: getType()); } - 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) { - return getLHS(); - } else if (i == 1) { - return getMHS(); - } else { - return getRHS(); + unsigned getNumOperands() const override { return 3; } + Init *getOperand(unsigned i) const override { + switch (i) { + default: llvm_unreachable("Invalid operand id for ternary operator"); + case 0: return getLHS(); + case 1: return getMHS(); + case 2: return getRHS(); } } @@ -1044,13 +836,11 @@ public: class VarInit : public TypedInit { Init *VarName; - explicit VarInit(const std::string &VN, RecTy *T) - : TypedInit(IK_VarInit, T), VarName(StringInit::get(VN)) {} 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) { @@ -1059,10 +849,6 @@ public: static VarInit *get(const std::string &VN, RecTy *T); static VarInit *get(Init *VN, RecTy *T); - Init *convertInitializerTo(RecTy *Ty) const override { - return Ty->convertValue(const_cast(this)); - } - const std::string &getName() const; Init *getNameInit() const { return VarName; } std::string getNameInitAsString() const { @@ -1102,8 +888,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) { @@ -1111,9 +897,7 @@ public: } static VarBitInit *get(TypedInit *T, unsigned B); - Init *convertInitializerTo(RecTy *Ty) const override { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; Init *getBitVar() const override { return TI; } unsigned getBitNum() const override { return Bit; } @@ -1141,8 +925,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) { @@ -1150,10 +934,6 @@ public: } static VarListElementInit *get(TypedInit *T, unsigned E); - Init *convertInitializerTo(RecTy *Ty) const override { - return Ty->convertValue(const_cast(this)); - } - TypedInit *getVariable() const { return TI; } unsigned getElementNum() const { return Element; } @@ -1177,8 +957,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) { @@ -1186,9 +966,7 @@ public: } static DefInit *get(Record*); - Init *convertInitializerTo(RecTy *Ty) const override { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; Record *getDef() const { return Def; } @@ -1224,19 +1002,14 @@ 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) { return I->getKind() == IK_FieldInit; } static FieldInit *get(Init *R, const std::string &FN); - static FieldInit *get(Init *R, const Init *FN); - - Init *convertInitializerTo(RecTy *Ty) const override { - return Ty->convertValue(const_cast(this)); - } Init *getBit(unsigned Bit) const override; @@ -1267,8 +1040,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) { @@ -1283,9 +1056,7 @@ public: void Profile(FoldingSetNodeID &ID) const; - Init *convertInitializerTo(RecTy *Ty) const override { - return Ty->convertValue(const_cast(this)); - } + Init *convertInitializerTo(RecTy *Ty) const override; Init *getOperator() const { return Val; } @@ -1335,22 +1106,21 @@ public: //===----------------------------------------------------------------------===// class RecordVal { - Init *Name; + PointerIntPair NameAndPrefix; RecTy *Ty; - unsigned Prefix; Init *Value; public: - RecordVal(Init *N, RecTy *T, unsigned P); - RecordVal(const std::string &N, RecTy *T, unsigned P); + RecordVal(Init *N, RecTy *T, bool P); + RecordVal(const std::string &N, RecTy *T, bool P); const std::string &getName() const; - const Init *getNameInit() const { return Name; } + const Init *getNameInit() const { return NameAndPrefix.getPointer(); } std::string getNameInitAsString() const { return getNameInit()->getAsUnquotedString(); } - unsigned getPrefix() const { return Prefix; } + bool getPrefix() const { return NameAndPrefix.getInt(); } RecTy *getType() const { return Ty; } Init *getValue() const { return Value; } @@ -1389,36 +1159,46 @@ class Record { // Tracks Record instances. Not owned by Record. RecordKeeper &TrackedRecords; - DefInit *TheInit; + std::unique_ptr 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 use 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(nullptr), IsAnonymous(Anonymous) { - init(); - } explicit Record(Init *N, ArrayRef locs, RecordKeeper &records, bool Anonymous = false) : ID(LastID++), Name(N), Locs(locs.begin(), locs.end()), - TrackedRecords(records), TheInit(nullptr), IsAnonymous(Anonymous) { + TrackedRecords(records), IsAnonymous(Anonymous), ResolveFirst(false) { init(); } + explicit Record(const std::string &N, ArrayRef locs, + RecordKeeper &records, bool Anonymous = false) + : Record(StringInit::get(N), locs, records, Anonymous) {} + // When copy-constructing a Record, we must still guarantee a globally unique - // ID number. All other fields can be copied normally. + // ID number. Don't copy TheInit either since it's owned by the original + // record. All other fields can be copied normally. Record(const Record &O) : 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() {} + IsAnonymous(O.IsAnonymous), + ResolveFirst(O.ResolveFirst) { } static unsigned getNewUID() { return LastID++; } @@ -1440,33 +1220,33 @@ public: /// get the corresponding DefInit. DefInit *getDefInit(); - const std::vector &getTemplateArgs() const { + ArrayRef getTemplateArgs() const { return TemplateArgs; } - const std::vector &getValues() const { return Values; } - const std::vector &getSuperClasses() const { return SuperClasses; } + ArrayRef getValues() const { return Values; } + ArrayRef getSuperClasses() const { return SuperClasses; } ArrayRef getSuperClassRanges() const { return SuperClassRanges; } bool isTemplateArg(Init *Name) const { - for (unsigned i = 0, e = TemplateArgs.size(); i != e; ++i) - if (TemplateArgs[i] == Name) return true; + for (Init *TA : TemplateArgs) + if (TA == Name) return true; 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]; + for (const RecordVal &Val : Values) + if (Val.getNameInit() == Name) return &Val; 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]; + for (RecordVal &Val : Values) + if (Val.getNameInit() == Name) return &Val; return nullptr; } RecordVal *getValue(StringRef Name) { @@ -1478,7 +1258,7 @@ public: TemplateArgs.push_back(Name); } void addTemplateArg(StringRef Name) { - addTemplateArg(StringInit::get(Name.str())); + addTemplateArg(StringInit::get(Name)); } void addValue(const RecordVal &RV) { @@ -1503,19 +1283,19 @@ public: } void removeValue(StringRef Name) { - removeValue(StringInit::get(Name.str())); + removeValue(StringInit::get(Name)); } bool isSubClassOf(const Record *R) const { - for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i) - if (SuperClasses[i] == R) + for (const Record *SC : SuperClasses) + if (SC == R) return true; return false; } bool isSubClassOf(StringRef Name) const { - for (unsigned i = 0, e = SuperClasses.size(); i != e; ++i) - if (SuperClasses[i]->getNameInitAsString() == Name) + for (const Record *SC : SuperClasses) + if (SC->getNameInitAsString() == Name) return true; return false; } @@ -1544,6 +1324,14 @@ public: return IsAnonymous; } + bool isResolveFirst() const { + return ResolveFirst; + } + + void setResolveFirst(bool b) { + ResolveFirst = b; + } + void dump() const; //===--------------------------------------------------------------------===// @@ -1557,7 +1345,7 @@ public: /// Return true if the named field is unset. bool isValueUnset(StringRef FieldName) const { - return getValueInit(FieldName) == UnsetInit::get(); + return isa(getValueInit(FieldName)); } /// getValueAsString - This method looks up the specified field and returns @@ -1631,7 +1419,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; @@ -1641,53 +1429,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() ? nullptr : 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() ? nullptr : 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... @@ -1728,7 +1497,6 @@ 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 {