From 14c5784ee4c03c5a7aa6f483486985d2c24a2407 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Fri, 31 Jan 2025 17:37:17 +0100 Subject: [PATCH 1/2] [TableGen] Reduce size of MatchTableRecord (NFC) (#125221) MatchTableRecord stores a 64-bit RawValue. However, this field is only needed by a small part of the code (jump table generation). Create a separate RecordAndValue structure that is used in just the necessary places. Based on massif, this reduces memory usage on RISCVGenGlobalISel.inc by about 100MB (to 2.15GB). (cherry picked from commit e2301d674976b84ba505065a9702f3376e05bc43) --- .../GlobalISel/GlobalISelMatchTable.cpp | 46 +++++++------------ .../Common/GlobalISel/GlobalISelMatchTable.h | 42 ++++++++--------- 2 files changed, 38 insertions(+), 50 deletions(-) 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; From 4d04a406a5a5e13af679018b116fc9975eb85579 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Fri, 31 Jan 2025 21:27:09 +0100 Subject: [PATCH 2/2] [TableGen] Don't use inline storage for ReferenceLocs (NFC) (#125231) The ReferenceLocs are not enabled by default (they are used by the tablegen lsp server), and as such always empty, but still allocate inline storage for the SmallVector. Disabling it saves about 200MB on RISCVGenGlobalISel.inc. (The equivalent field in Record already disables inline storage.) (cherry picked from commit c640f97ccf723e64ff24af225cb995c905538406) --- llvm/include/llvm/TableGen/Record.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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);