RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2025-04-03 08:41:44 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[TableGen] Merge RecTy::typeIsConvertibleTo and RecTy::baseClassOf. NFC

Browse Source 
typeIsConvertibleTo was just calling baseClassOf(this) on the argument passed to it, but there weren't different signatures for baseClassOf so passing 'this' didn't really do anything interesting. typeIsConvertibleTo could have just been a non-virtual method in RecTy. But since that would be kind of a silly method, I instead re-distributed the logic from baseClassOf into typeIsConvertibleTo.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@238648 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Craig Topper 2015-05-30 07:36:01 +00:00
parent 15617cdf57
commit be43b88fae
2 changed files with 22 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
include/llvm/TableGen/Record.h
View File

@ -81,7 +81,6 @@ public:
private: private:
RecTyKind Kind; RecTyKind Kind;
std::unique_ptr<ListRecTy> ListTy; std::unique_ptr<ListRecTy> ListTy;
virtual void anchor();
public: public:
RecTyKind getRecTyKind() const { return Kind; } RecTyKind getRecTyKind() const { return Kind; }
@ -95,12 +94,10 @@ public:
/// typeIsConvertibleTo - Return true if all values of 'this' type can be /// typeIsConvertibleTo - Return true if all values of 'this' type can be
/// converted to the specified type. /// 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>. /// getListTy - Returns the type representing list<this>.
ListRecTy *getListTy(); ListRecTy *getListTy();
virtual bool baseClassOf(const RecTy*) const;
}; };
inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) { inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) {
@ -123,10 +120,7 @@ public:
std::string getAsString() const override { return "bit"; } std::string getAsString() const override { return "bit"; }
bool typeIsConvertibleTo(const RecTy *RHS) const override { bool typeIsConvertibleTo(const RecTy *RHS) const override;
return RHS->baseClassOf(this);
}
bool baseClassOf(const RecTy*) const override;
}; };
/// BitsRecTy - 'bits<n>' - Represent a fixed number of bits /// BitsRecTy - 'bits<n>' - Represent a fixed number of bits
@ -146,10 +140,7 @@ public:
std::string getAsString() const override; std::string getAsString() const override;
bool typeIsConvertibleTo(const RecTy *RHS) const override { bool typeIsConvertibleTo(const RecTy *RHS) const override;
return RHS->baseClassOf(this);
}
bool baseClassOf(const RecTy*) const override;
}; };
/// IntRecTy - 'int' - Represent an integer value of no particular size /// IntRecTy - 'int' - Represent an integer value of no particular size
@ -167,11 +158,7 @@ public:
std::string getAsString() const override { return "int"; } std::string getAsString() const override { return "int"; }
bool typeIsConvertibleTo(const RecTy *RHS) const override { bool typeIsConvertibleTo(const RecTy *RHS) const override;
return RHS->baseClassOf(this);
}
bool baseClassOf(const RecTy*) const override;
}; };
/// StringRecTy - 'string' - Represent an string value /// StringRecTy - 'string' - Represent an string value
@ -180,7 +167,7 @@ class StringRecTy : public RecTy {
static StringRecTy Shared; static StringRecTy Shared;
StringRecTy() : RecTy(StringRecTyKind) {} StringRecTy() : RecTy(StringRecTyKind) {}
void anchor() override; virtual void anchor();
public: public:
static bool classof(const RecTy *RT) { static bool classof(const RecTy *RT) {
return RT->getRecTyKind() == StringRecTyKind; return RT->getRecTyKind() == StringRecTyKind;
@ -189,10 +176,6 @@ public:
static StringRecTy *get() { return &Shared; } static StringRecTy *get() { return &Shared; }
std::string getAsString() const override { return "string"; } std::string getAsString() const override { return "string"; }
bool typeIsConvertibleTo(const RecTy *RHS) const override {
return RHS->baseClassOf(this);
}
}; };
/// ListRecTy - 'list<Ty>' - Represent a list of values, all of which must be of /// ListRecTy - 'list<Ty>' - Represent a list of values, all of which must be of
@ -213,11 +196,7 @@ public:
std::string getAsString() const override; std::string getAsString() const override;
bool typeIsConvertibleTo(const RecTy *RHS) const override { bool typeIsConvertibleTo(const RecTy *RHS) const override;
return RHS->baseClassOf(this);
}
bool baseClassOf(const RecTy*) const override;
}; };
/// DagRecTy - 'dag' - Represent a dag fragment /// DagRecTy - 'dag' - Represent a dag fragment
@ -226,7 +205,7 @@ class DagRecTy : public RecTy {
static DagRecTy Shared; static DagRecTy Shared;
DagRecTy() : RecTy(DagRecTyKind) {} DagRecTy() : RecTy(DagRecTyKind) {}
void anchor() override; virtual void anchor();
public: public:
static bool classof(const RecTy *RT) { static bool classof(const RecTy *RT) {
return RT->getRecTyKind() == DagRecTyKind; return RT->getRecTyKind() == DagRecTyKind;
@ -235,10 +214,6 @@ public:
static DagRecTy *get() { return &Shared; } static DagRecTy *get() { return &Shared; }
std::string getAsString() const override { return "dag"; } std::string getAsString() const override { return "dag"; }
bool typeIsConvertibleTo(const RecTy *RHS) const override {
return RHS->baseClassOf(this);
}
}; };
/// RecordRecTy - '[classname]' - Represent an instance of a class, such as: /// RecordRecTy - '[classname]' - Represent an instance of a class, such as:
@ -260,10 +235,7 @@ public:
std::string getAsString() const override; std::string getAsString() const override;
bool typeIsConvertibleTo(const RecTy *RHS) const override { bool typeIsConvertibleTo(const RecTy *RHS) const override;
return RHS->baseClassOf(this);
}
bool baseClassOf(const RecTy*) const override;
}; };
/// resolveTypes - Find a common type that T1 and T2 convert to. /// resolveTypes - Find a common type that T1 and T2 convert to.

30
lib/TableGen/Record.cpp
View File

@ -86,7 +86,6 @@ IntRecTy IntRecTy::Shared;
StringRecTy StringRecTy::Shared; StringRecTy StringRecTy::Shared;
DagRecTy DagRecTy::Shared; DagRecTy DagRecTy::Shared;
void RecTy::anchor() { }
void RecTy::dump() const { print(errs()); } void RecTy::dump() const { print(errs()); }
void StringRecTy::anchor() { } void StringRecTy::anchor() { }
@ -98,13 +97,13 @@ ListRecTy *RecTy::getListTy() {
return ListTy.get(); return ListTy.get();
} }
bool RecTy::baseClassOf(const RecTy *RHS) const { bool RecTy::typeIsConvertibleTo(const RecTy *RHS) const {
assert (RHS && "NULL pointer"); assert(RHS && "NULL pointer");
return Kind == RHS->getRecTyKind(); return Kind == RHS->getRecTyKind();
} }
bool BitRecTy::baseClassOf(const RecTy *RHS) const{ bool BitRecTy::typeIsConvertibleTo(const RecTy *RHS) const{
if(RecTy::baseClassOf(RHS) || RHS->getRecTyKind() == IntRecTyKind) if(RecTy::typeIsConvertibleTo(RHS) || RHS->getRecTyKind() == IntRecTyKind)
return true; return true;
if(const BitsRecTy *BitsTy = dyn_cast<BitsRecTy>(RHS)) if(const BitsRecTy *BitsTy = dyn_cast<BitsRecTy>(RHS))
return BitsTy->getNumBits() == 1; return BitsTy->getNumBits() == 1;
@ -125,14 +124,14 @@ std::string BitsRecTy::getAsString() const {
return "bits<" + utostr(Size) + ">"; return "bits<" + utostr(Size) + ">";
} }
bool BitsRecTy::baseClassOf(const RecTy *RHS) const{ bool BitsRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
if (RecTy::baseClassOf(RHS)) //argument and the receiver are the same type if (RecTy::typeIsConvertibleTo(RHS)) //argument and the sender are same type
return cast<BitsRecTy>(RHS)->Size == Size; return cast<BitsRecTy>(RHS)->Size == Size;
RecTyKind kind = RHS->getRecTyKind(); RecTyKind kind = RHS->getRecTyKind();
return (kind == BitRecTyKind && Size == 1) || (kind == IntRecTyKind); return (kind == BitRecTyKind && Size == 1) || (kind == IntRecTyKind);
} }
bool IntRecTy::baseClassOf(const RecTy *RHS) const{ bool IntRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
RecTyKind kind = RHS->getRecTyKind(); RecTyKind kind = RHS->getRecTyKind();
return kind==BitRecTyKind || kind==BitsRecTyKind || kind==IntRecTyKind; return kind==BitRecTyKind || kind==BitsRecTyKind || kind==IntRecTyKind;
} }
@ -142,9 +141,9 @@ std::string ListRecTy::getAsString() const {
return "list<" + Ty->getAsString() + ">"; return "list<" + Ty->getAsString() + ">";
} }
bool ListRecTy::baseClassOf(const RecTy *RHS) const{ bool ListRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
if(const ListRecTy* ListTy = dyn_cast<ListRecTy>(RHS)) if (const auto *ListTy = dyn_cast<ListRecTy>(RHS))
return ListTy->getElementType()->typeIsConvertibleTo(Ty); return Ty->typeIsConvertibleTo(ListTy->getElementType());
return false; return false;
} }
@ -156,17 +155,16 @@ std::string RecordRecTy::getAsString() const {
return Rec->getName(); return Rec->getName();
} }
bool RecordRecTy::baseClassOf(const RecTy *RHS) const{ bool RecordRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
const RecordRecTy *RTy = dyn_cast<RecordRecTy>(RHS); const RecordRecTy *RTy = dyn_cast<RecordRecTy>(RHS);
if (!RTy) if (!RTy)
return false; return false;
if (Rec == RTy->getRecord() || RTy->getRecord()->isSubClassOf(Rec)) if (RTy->getRecord() == Rec || Rec->isSubClassOf(RTy->getRecord()))
return true; return true;
const std::vector<Record*> &SC = Rec->getSuperClasses(); for (Record *SC : RTy->getRecord()->getSuperClasses())
for (unsigned i = 0, e = SC.size(); i != e; ++i) if (Rec->isSubClassOf(SC))
if (RTy->getRecord()->isSubClassOf(SC[i]))
return true; return true;
return false; return false;