RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 11:13:28 +01:00
Code Issues 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.

llvm-svn: 238648
This commit is contained in:
Craig Topper 2015-05-30 07:36:01 +00:00
parent 0ffd711178
commit baa40e9044
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:
RecTyKind Kind;
std::unique_ptr<ListRecTy> ListTy;
virtual void anchor();
public:
RecTyKind getRecTyKind() const { return Kind; }
@ -95,12 +94,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<this>.
ListRecTy *getListTy();
virtual bool baseClassOf(const RecTy*) const;
};
inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) {
@ -123,10 +120,7 @@ public:
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
@ -146,10 +140,7 @@ public:
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
@ -167,11 +158,7 @@ public:
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
@ -180,7 +167,7 @@ class StringRecTy : public RecTy {
static StringRecTy Shared;
StringRecTy() : RecTy(StringRecTyKind) {}
void anchor() override;
virtual void anchor();
public:
static bool classof(const RecTy *RT) {
return RT->getRecTyKind() == StringRecTyKind;
@ -189,10 +176,6 @@ public:
static StringRecTy *get() { return &Shared; }
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
@ -213,11 +196,7 @@ public:
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
@ -226,7 +205,7 @@ class DagRecTy : public RecTy {
static DagRecTy Shared;
DagRecTy() : RecTy(DagRecTyKind) {}
void anchor() override;
virtual void anchor();
public:
static bool classof(const RecTy *RT) {
return RT->getRecTyKind() == DagRecTyKind;
@ -235,10 +214,6 @@ public:
static DagRecTy *get() { return &Shared; }
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:
@ -260,10 +235,7 @@ public:
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.

30
lib/TableGen/Record.cpp
View File

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