#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 <map>
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;
//===----------------------------------------------------------------------===//
private:
RecTyKind Kind;
- ListRecTy *ListTy;
- virtual void anchor();
+ std::unique_ptr<ListRecTy> 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;
/// 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<this>.
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) {
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<n>' - Represent a fixed number of bits
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
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
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<Ty>' - Represent a list of values, all of which must be of
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
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:
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.
/// 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
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) {
}
RecTy *getType() const { return Ty; }
+ Init *convertInitializerTo(RecTy *Ty) const override;
+
Init *
convertInitializerBitRange(const std::vector<unsigned> &Bits) const override;
Init *
UnsetInit() : Init(IK_UnsetInit) {}
UnsetInit(const UnsetInit &) = delete;
UnsetInit &operator=(const UnsetInit &Other) = delete;
- void anchor() override;
public:
static bool classof(const Init *I) {
}
static UnsetInit *get();
- Init *convertInitializerTo(RecTy *Ty) const override {
- return Ty->convertValue(const_cast<UnsetInit *>(this));
- }
+ Init *convertInitializerTo(RecTy *Ty) const override;
Init *getBit(unsigned Bit) const override {
return const_cast<UnsetInit*>(this);
explicit BitInit(bool V) : Init(IK_BitInit), Value(V) {}
BitInit(const BitInit &Other) = delete;
BitInit &operator=(BitInit &Other) = delete;
- void anchor() override;
public:
static bool classof(const Init *I) {
bool getValue() const { return Value; }
- Init *convertInitializerTo(RecTy *Ty) const override {
- return Ty->convertValue(const_cast<BitInit *>(this));
- }
+ Init *convertInitializerTo(RecTy *Ty) const override;
Init *getBit(unsigned Bit) const override {
assert(Bit < 1 && "Bit index out of range!");
unsigned getNumBits() const { return Bits.size(); }
- Init *convertInitializerTo(RecTy *Ty) const override {
- return Ty->convertValue(const_cast<BitsInit *>(this));
- }
+ Init *convertInitializerTo(RecTy *Ty) const override;
Init *
convertInitializerBitRange(const std::vector<unsigned> &Bits) const override;
int64_t getValue() const { return Value; }
- Init *convertInitializerTo(RecTy *Ty) const override {
- return Ty->convertValue(const_cast<IntInit *>(this));
- }
+ Init *convertInitializerTo(RecTy *Ty) const override;
Init *
convertInitializerBitRange(const std::vector<unsigned> &Bits) const override;
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) = delete;
StringInit &operator=(const StringInit &Other) = delete;
- void anchor() override;
public:
static bool classof(const Init *I) {
const std::string &getValue() const { return Value; }
- Init *convertInitializerTo(RecTy *Ty) const override {
- return Ty->convertValue(const_cast<StringInit *>(this));
- }
+ Init *convertInitializerTo(RecTy *Ty) const override;
std::string getAsString() const override { return "\"" + Value + "\""; }
std::string getAsUnquotedString() const override { return Value; }
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];
Init *
convertInitListSlice(const std::vector<unsigned> &Elements) const override;
- Init *convertInitializerTo(RecTy *Ty) const override {
- return Ty->convertValue(const_cast<ListInit *>(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.
ArrayRef<Init*> 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
// Clone - Clone this operator, replacing arguments with the new list
virtual OpInit *clone(std::vector<Init *> &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<OpInit *>(this));
- }
-
Init *resolveListElementReference(Record &R, const RecordVal *RV,
unsigned Elt) const override;
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();
}
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();
}
}
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();
}
}
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) {}
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<VarInit *>(this));
- }
-
const std::string &getName() const;
Init *getNameInit() const { return VarName; }
std::string getNameInitAsString() const {
}
static VarBitInit *get(TypedInit *T, unsigned B);
- Init *convertInitializerTo(RecTy *Ty) const override {
- return Ty->convertValue(const_cast<VarBitInit *>(this));
- }
+ Init *convertInitializerTo(RecTy *Ty) const override;
Init *getBitVar() const override { return TI; }
unsigned getBitNum() const override { return Bit; }
}
static VarListElementInit *get(TypedInit *T, unsigned E);
- Init *convertInitializerTo(RecTy *Ty) const override {
- return Ty->convertValue(const_cast<VarListElementInit *>(this));
- }
-
TypedInit *getVariable() const { return TI; }
unsigned getElementNum() const { return Element; }
}
static DefInit *get(Record*);
- Init *convertInitializerTo(RecTy *Ty) const override {
- return Ty->convertValue(const_cast<DefInit *>(this));
- }
+ Init *convertInitializerTo(RecTy *Ty) const override;
Record *getDef() const { return Def; }
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<FieldInit *>(this));
- }
Init *getBit(unsigned Bit) const override;
void Profile(FoldingSetNodeID &ID) const;
- Init *convertInitializerTo(RecTy *Ty) const override {
- return Ty->convertValue(const_cast<DagInit *>(this));
- }
+ Init *convertInitializerTo(RecTy *Ty) const override;
Init *getOperator() const { return Val; }
//===----------------------------------------------------------------------===//
class RecordVal {
- Init *Name;
+ PointerIntPair<Init *, 1, bool> 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; }
// Tracks Record instances. Not owned by Record.
RecordKeeper &TrackedRecords;
- DefInit *TheInit;
+ std::unique_ptr<DefInit> TheInit;
bool IsAnonymous;
// Class-instance values can be used by other defs. For example, Struct<i>
// def Def : Class<Struct<i>>;
//
// These need to get fully resolved before instantiating any other
- // definitions that usie them (e.g. Def). However, inside a multiclass they
+ // 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;
public:
// Constructs a record.
- explicit Record(const std::string &N, ArrayRef<SMLoc> locs,
- RecordKeeper &records, bool Anonymous = false) :
- ID(LastID++), Name(StringInit::get(N)), Locs(locs.begin(), locs.end()),
- TrackedRecords(records), TheInit(nullptr), IsAnonymous(Anonymous),
- ResolveFirst(false) {
- init();
- }
explicit Record(Init *N, ArrayRef<SMLoc> locs, RecordKeeper &records,
bool Anonymous = false) :
ID(LastID++), Name(N), Locs(locs.begin(), locs.end()),
- TrackedRecords(records), TheInit(nullptr), IsAnonymous(Anonymous),
- ResolveFirst(false) {
+ TrackedRecords(records), IsAnonymous(Anonymous), ResolveFirst(false) {
init();
}
+ explicit Record(const std::string &N, ArrayRef<SMLoc> 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),
+ IsAnonymous(O.IsAnonymous),
ResolveFirst(O.ResolveFirst) { }
static unsigned getNewUID() { return LastID++; }
/// get the corresponding DefInit.
DefInit *getDefInit();
- const std::vector<Init *> &getTemplateArgs() const {
+ ArrayRef<Init *> getTemplateArgs() const {
return TemplateArgs;
}
- const std::vector<RecordVal> &getValues() const { return Values; }
- const std::vector<Record*> &getSuperClasses() const { return SuperClasses; }
+ ArrayRef<RecordVal> getValues() const { return Values; }
+ ArrayRef<Record *> getSuperClasses() const { return SuperClasses; }
ArrayRef<SMRange> 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 {
}
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) {
}
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;
}
/// Return true if the named field is unset.
bool isValueUnset(StringRef FieldName) const {
- return getValueInit(FieldName) == UnsetInit::get();
+ return isa<UnsetInit>(getValueInit(FieldName));
}
/// getValueAsString - This method looks up the specified field and returns
};
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 {
projects / oota-llvm.git / blobdiff