diff --git a/llvm/include/llvm/TableGen/Record.h b/llvm/include/llvm/TableGen/Record.h index d9930a48e8084..e04ed34823148 100644 --- a/llvm/include/llvm/TableGen/Record.h +++ b/llvm/include/llvm/TableGen/Record.h @@ -1523,7 +1523,7 @@ class RecordVal { bool IsUsed = false; /// Reference locations to this record value. - SmallVector ReferenceLocs; + SmallVector ReferenceLocs; public: RecordVal(const Init *N, const RecTy *T, FieldKind K); diff --git a/llvm/utils/TableGen/Common/GlobalISel/GlobalISelMatchTable.cpp b/llvm/utils/TableGen/Common/GlobalISel/GlobalISelMatchTable.cpp index f0cd98dd2dee0..8564bf8d2d91b 100644 --- a/llvm/utils/TableGen/Common/GlobalISel/GlobalISelMatchTable.cpp +++ b/llvm/utils/TableGen/Common/GlobalISel/GlobalISelMatchTable.cpp @@ -227,26 +227,12 @@ MatchTableRecord MatchTable::NamedValue(unsigned NumBytes, MatchTableRecord::MTRF_CommaFollows); } -MatchTableRecord MatchTable::NamedValue(unsigned NumBytes, StringRef NamedValue, - int64_t RawValue) { - return MatchTableRecord(std::nullopt, NamedValue, NumBytes, - MatchTableRecord::MTRF_CommaFollows, RawValue); -} - MatchTableRecord MatchTable::NamedValue(unsigned NumBytes, StringRef Namespace, StringRef NamedValue) { return MatchTableRecord(std::nullopt, (Namespace + "::" + NamedValue).str(), NumBytes, MatchTableRecord::MTRF_CommaFollows); } -MatchTableRecord MatchTable::NamedValue(unsigned NumBytes, StringRef Namespace, - StringRef NamedValue, - int64_t RawValue) { - return MatchTableRecord(std::nullopt, (Namespace + "::" + NamedValue).str(), - NumBytes, MatchTableRecord::MTRF_CommaFollows, - RawValue); -} - MatchTableRecord MatchTable::IntValue(unsigned NumBytes, int64_t IntValue) { assert(isUIntN(NumBytes * 8, IntValue) || isIntN(NumBytes * 8, IntValue)); auto Str = llvm::to_string(IntValue); @@ -651,8 +637,8 @@ void SwitchMatcher::emit(MatchTable &Table) { [&Table]() { return Table.allocateLabelID(); }); const unsigned Default = Table.allocateLabelID(); - const int64_t LowerBound = Values.begin()->getRawValue(); - const int64_t UpperBound = Values.rbegin()->getRawValue() + 1; + const int64_t LowerBound = Values.begin()->RawValue; + const int64_t UpperBound = Values.rbegin()->RawValue + 1; emitPredicateSpecificOpcodes(*Condition, Table); @@ -664,10 +650,11 @@ void SwitchMatcher::emit(MatchTable &Table) { auto VI = Values.begin(); for (unsigned I = 0, E = Values.size(); I < E; ++I) { auto V = *VI++; - while (J++ < V.getRawValue()) + while (J++ < V.RawValue) Table << MatchTable::IntValue(4, 0); - V.turnIntoComment(); - Table << MatchTable::LineBreak << V << MatchTable::JumpTarget(LabelIDs[I]); + V.Record.turnIntoComment(); + Table << MatchTable::LineBreak << V.Record + << MatchTable::JumpTarget(LabelIDs[I]); } Table << MatchTable::LineBreak; @@ -1145,11 +1132,11 @@ void SameOperandMatcher::emitPredicateOpcodes(MatchTable &Table, std::map LLTOperandMatcher::TypeIDValues; -MatchTableRecord LLTOperandMatcher::getValue() const { +RecordAndValue LLTOperandMatcher::getValue() const { const auto VI = TypeIDValues.find(Ty); if (VI == TypeIDValues.end()) return MatchTable::NamedValue(1, getTy().getCxxEnumValue()); - return MatchTable::NamedValue(1, getTy().getCxxEnumValue(), VI->second); + return {MatchTable::NamedValue(1, getTy().getCxxEnumValue()), VI->second}; } bool LLTOperandMatcher::hasValue() const { @@ -1167,7 +1154,8 @@ void LLTOperandMatcher::emitPredicateOpcodes(MatchTable &Table, << MatchTable::ULEB128Value(InsnVarID); } Table << MatchTable::Comment("Op") << MatchTable::ULEB128Value(OpIdx) - << MatchTable::Comment("Type") << getValue() << MatchTable::LineBreak; + << MatchTable::Comment("Type") << getValue().Record + << MatchTable::LineBreak; } //===- PointerToAnyOperandMatcher -----------------------------------------===// @@ -1411,12 +1399,12 @@ Error OperandMatcher::addTypeCheckPredicate(const TypeSetByHwMode &VTy, DenseMap InstructionOpcodeMatcher::OpcodeValues; -MatchTableRecord +RecordAndValue InstructionOpcodeMatcher::getInstValue(const CodeGenInstruction *I) const { const auto VI = OpcodeValues.find(I); if (VI != OpcodeValues.end()) - return MatchTable::NamedValue(2, I->Namespace, I->TheDef->getName(), - VI->second); + return {MatchTable::NamedValue(2, I->Namespace, I->TheDef->getName()), + VI->second}; return MatchTable::NamedValue(2, I->Namespace, I->TheDef->getName()); } @@ -1428,14 +1416,14 @@ void InstructionOpcodeMatcher::initOpcodeValuesMap( OpcodeValues[I] = Target.getInstrIntValue(I->TheDef); } -MatchTableRecord InstructionOpcodeMatcher::getValue() const { +RecordAndValue InstructionOpcodeMatcher::getValue() const { assert(Insts.size() == 1); const CodeGenInstruction *I = Insts[0]; const auto VI = OpcodeValues.find(I); if (VI != OpcodeValues.end()) - return MatchTable::NamedValue(2, I->Namespace, I->TheDef->getName(), - VI->second); + return {MatchTable::NamedValue(2, I->Namespace, I->TheDef->getName()), + VI->second}; return MatchTable::NamedValue(2, I->Namespace, I->TheDef->getName()); } @@ -1447,7 +1435,7 @@ void InstructionOpcodeMatcher::emitPredicateOpcodes(MatchTable &Table, << MatchTable::ULEB128Value(InsnVarID); for (const CodeGenInstruction *I : Insts) - Table << getInstValue(I); + Table << getInstValue(I).Record; Table << MatchTable::LineBreak; } diff --git a/llvm/utils/TableGen/Common/GlobalISel/GlobalISelMatchTable.h b/llvm/utils/TableGen/Common/GlobalISel/GlobalISelMatchTable.h index e7914a613973b..77c8bc290faaf 100644 --- a/llvm/utils/TableGen/Common/GlobalISel/GlobalISelMatchTable.h +++ b/llvm/utils/TableGen/Common/GlobalISel/GlobalISelMatchTable.h @@ -145,14 +145,10 @@ struct MatchTableRecord { /// A bitfield of RecordFlagsBits flags. unsigned Flags; - /// The actual run-time value, if known - int64_t RawValue; - MatchTableRecord(std::optional LabelID_, StringRef EmitStr, - unsigned NumElements, unsigned Flags, - int64_t RawValue = std::numeric_limits::min()) + unsigned NumElements, unsigned Flags) : LabelID(LabelID_.value_or(~0u)), EmitStr(EmitStr), - NumElements(NumElements), Flags(Flags), RawValue(RawValue) { + NumElements(NumElements), Flags(Flags) { assert((!LabelID_ || LabelID != ~0u) && "This value is reserved for non-labels"); } @@ -166,12 +162,6 @@ struct MatchTableRecord { NumElements = 0; } - /// For Jump Table generation purposes - bool operator<(const MatchTableRecord &Other) const { - return RawValue < Other.RawValue; - } - int64_t getRawValue() const { return RawValue; } - void emit(raw_ostream &OS, bool LineBreakNextAfterThis, const MatchTable &Table) const; unsigned size() const { return NumElements; } @@ -202,12 +192,8 @@ class MatchTable { static MatchTableRecord Comment(StringRef Comment); static MatchTableRecord Opcode(StringRef Opcode, int IndentAdjust = 0); static MatchTableRecord NamedValue(unsigned NumBytes, StringRef NamedValue); - static MatchTableRecord NamedValue(unsigned NumBytes, StringRef NamedValue, - int64_t RawValue); static MatchTableRecord NamedValue(unsigned NumBytes, StringRef Namespace, StringRef NamedValue); - static MatchTableRecord NamedValue(unsigned NumBytes, StringRef Namespace, - StringRef NamedValue, int64_t RawValue); static MatchTableRecord IntValue(unsigned NumBytes, int64_t IntValue); static MatchTableRecord ULEB128Value(uint64_t IntValue); static MatchTableRecord Label(unsigned LabelID); @@ -400,6 +386,20 @@ class GroupMatcher final : public Matcher { bool candidateConditionMatches(const PredicateMatcher &Predicate) const; }; +/// MatchTableRecord and associated value, for jump table generation. +struct RecordAndValue { + MatchTableRecord Record; + int64_t RawValue; + + RecordAndValue(MatchTableRecord Record, + int64_t RawValue = std::numeric_limits::min()) + : Record(std::move(Record)), RawValue(RawValue) {} + + bool operator<(const RecordAndValue &Other) const { + return RawValue < Other.RawValue; + } +}; + class SwitchMatcher : public Matcher { /// All the nested matchers, representing distinct switch-cases. The first /// conditions (as Matcher::getFirstCondition() reports) of all the nested @@ -414,7 +414,7 @@ class SwitchMatcher : public Matcher { /// Temporary set used to check that the case values don't repeat within the /// same switch. - std::set Values; + std::set Values; /// An owning collection for any auxiliary matchers created while optimizing /// nested matchers contained. @@ -874,7 +874,7 @@ class PredicateMatcher { return hasValue() && PredicateMatcher::isIdentical(B); } - virtual MatchTableRecord getValue() const { + virtual RecordAndValue getValue() const { assert(hasValue() && "Can not get a value of a value-less predicate!"); llvm_unreachable("Not implemented yet"); } @@ -968,7 +968,7 @@ class LLTOperandMatcher : public OperandPredicateMatcher { Ty == cast(&B)->Ty; } - MatchTableRecord getValue() const override; + RecordAndValue getValue() const override; bool hasValue() const override; LLTCodeGen getTy() const { return Ty; } @@ -1378,7 +1378,7 @@ class InstructionOpcodeMatcher : public InstructionPredicateMatcher { static DenseMap OpcodeValues; - MatchTableRecord getInstValue(const CodeGenInstruction *I) const; + RecordAndValue getInstValue(const CodeGenInstruction *I) const; public: static void initOpcodeValuesMap(const CodeGenTarget &Target); @@ -1405,7 +1405,7 @@ class InstructionOpcodeMatcher : public InstructionPredicateMatcher { // TODO: This is used for the SwitchMatcher optimization. We should be able to // return a list of the opcodes to match. - MatchTableRecord getValue() const override; + RecordAndValue getValue() const override; void emitPredicateOpcodes(MatchTable &Table, RuleMatcher &Rule) const override;