replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[globalisel][tablegen] Generate TypeObject table. NFC 

Summary:
Generate the type table from the types used by a target rather than hard-coding
the union of types used by all targets.

Depends on D36084

Reviewers: ab, t.p.northover, qcolombet, rovka, aditya_nandakumar

Reviewed By: rovka

Subscribers: kristof.beyls, igorb, llvm-commits

Differential Revision: https://reviews.llvm.org/D36085

llvm-svn: 310735
This commit is contained in:
Daniel Sanders 2017-08-11 17:30:37 +00:00
parent 73b7e78350
commit 6ac981151e
2 changed files with 36 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
llvm/test/TableGen/GlobalISelEmitter.td
View File

@ -83,6 +83,13 @@ def HasC : Predicate<"Subtarget->hasC()"> { let RecomputePerFunction = 1; }
// CHECK-NEXT: return Features;
// CHECK-NEXT: }
// CHECK-LABEL: enum {
// CHECK-NEXT: GILLT_s32,
// CHECK-NEXT: }
// CHECK-NEXT: const static LLT TypeObjects[] = {
// CHECK-NEXT: LLT::scalar(32),
// CHECK-NEXT: };
// CHECK: bool MyTargetInstructionSelector::selectImpl(MachineInstr &I) const {
// CHECK-NEXT: MachineFunction &MF = *I.getParent()->getParent();
// CHECK-NEXT: MachineRegisterInfo &MRI = MF.getRegInfo();

60
llvm/utils/TableGen/GlobalISelEmitter.cpp
View File

@ -110,30 +110,28 @@ public:
const LLT &get() const { return Ty; }
/// This ordering is used for std::unique() and std::sort(). There's no
/// particular logic behind the order.
/// particular logic behind the order but either A < B or B < A must be
/// true if A != B.
bool operator<(const LLTCodeGen &Other) const {
if (Ty.isValid() != Other.Ty.isValid())
return Ty.isValid() < Other.Ty.isValid();
if (!Ty.isValid())
return Other.Ty.isValid();
if (Ty.isScalar()) {
if (!Other.Ty.isValid())
return false;
if (Other.Ty.isScalar())
if (Ty.isVector() != Other.Ty.isVector())
return Ty.isVector() < Other.Ty.isVector();
if (Ty.isScalar() != Other.Ty.isScalar())
return Ty.isScalar() < Other.Ty.isScalar();
if (Ty.isPointer() != Other.Ty.isPointer())
return Ty.isPointer() < Other.Ty.isPointer();
if (Ty.isPointer() && Ty.getAddressSpace() != Other.Ty.getAddressSpace())
return Ty.getAddressSpace() < Other.Ty.getAddressSpace();
if (Ty.isVector() && Ty.getNumElements() != Other.Ty.getNumElements())
return Ty.getNumElements() < Other.Ty.getNumElements();
return Ty.getSizeInBits() < Other.Ty.getSizeInBits();
return false;
}
if (Ty.isVector()) {
if (!Other.Ty.isValid() || Other.Ty.isScalar())
return false;
if (Other.Ty.isVector()) {
if (Ty.getNumElements() < Other.Ty.getNumElements())
return true;
if (Ty.getNumElements() > Other.Ty.getNumElements())
return false;
return Ty.getSizeInBits() < Other.Ty.getSizeInBits();
}
return false;
}
llvm_unreachable("Unhandled LLT");
}
};
@ -626,8 +624,12 @@ protected:
LLTCodeGen Ty;
public:
static std::set<LLTCodeGen> KnownTypes;
LLTOperandMatcher(const LLTCodeGen &Ty)
: OperandPredicateMatcher(OPM_LLT), Ty(Ty) {}
: OperandPredicateMatcher(OPM_LLT), Ty(Ty) {
KnownTypes.insert(Ty);
}
static bool classof(const OperandPredicateMatcher *P) {
return P->getKind() == OPM_LLT;
@ -643,6 +645,8 @@ public:
}
};
std::set<LLTCodeGen> LLTOperandMatcher::KnownTypes;
/// Generates code to check that an operand is a particular target constant.
class ComplexPatternOperandMatcher : public OperandPredicateMatcher {
protected:
@ -2553,17 +2557,9 @@ void GlobalISelEmitter::run(raw_ostream &OS) {
// Emit a table containing the LLT objects needed by the matcher and an enum
// for the matcher to reference them with.
std::vector<LLTCodeGen> TypeObjects = {
LLT::scalar(8), LLT::scalar(16), LLT::scalar(32),
LLT::scalar(64), LLT::scalar(80), LLT::scalar(128),
LLT::vector(8, 1), LLT::vector(16, 1), LLT::vector(32, 1),
LLT::vector(64, 1), LLT::vector(8, 8), LLT::vector(16, 8),
LLT::vector(32, 8), LLT::vector(64, 8), LLT::vector(4, 16),
LLT::vector(8, 16), LLT::vector(16, 16), LLT::vector(32, 16),
LLT::vector(2, 32), LLT::vector(4, 32), LLT::vector(8, 32),
LLT::vector(16, 32), LLT::vector(2, 64), LLT::vector(4, 64),
LLT::vector(8, 64),
};
std::vector<LLTCodeGen> TypeObjects;
for (const auto &Ty : LLTOperandMatcher::KnownTypes)
TypeObjects.push_back(Ty);
std::sort(TypeObjects.begin(), TypeObjects.end());
OS << "enum {\n";
for (const auto &TypeObject : TypeObjects) {