Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

[TableGen] Delete non-const overloads of getAllDerivedDefinitions #110990

Merged
merged 1 commit into from
Oct 3, 2024
Merged

[TableGen] Delete non-const overloads of getAllDerivedDefinitions #110990

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
26 changes: 1 addition & 25 deletions llvm/include/llvm/TableGen/Record.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2058,28 +2058,19 @@ class RecordKeeper {
//===--------------------------------------------------------------------===//
// High-level helper methods, useful for tablegen backends.

// Non-const methods return std::vector<Record *> by value or reference.
// Const methods return std::vector<const Record *> by value or
// ArrayRef<const Record *>.

/// Get all the concrete records that inherit from the one specified
/// class. The class must be defined.
ArrayRef<const Record *> getAllDerivedDefinitions(StringRef ClassName) const;
const std::vector<Record *> &getAllDerivedDefinitions(StringRef ClassName);

/// Get all the concrete records that inherit from all the specified
/// classes. The classes must be defined.
std::vector<const Record *>
getAllDerivedDefinitions(ArrayRef<StringRef> ClassNames) const;
std::vector<Record *>
getAllDerivedDefinitions(ArrayRef<StringRef> ClassNames);

/// Get all the concrete records that inherit from specified class, if the
/// class is defined. Returns an empty vector if the class is not defined.
ArrayRef<const Record *>
getAllDerivedDefinitionsIfDefined(StringRef ClassName) const;
const std::vector<Record *> &
getAllDerivedDefinitionsIfDefined(StringRef ClassName);

void dump() const;

Expand All @@ -2091,24 +2082,9 @@ class RecordKeeper {
RecordKeeper &operator=(RecordKeeper &&) = delete;
RecordKeeper &operator=(const RecordKeeper &) = delete;

// Helper template functions for backend accessors.
template <typename VecTy>
const VecTy &
getAllDerivedDefinitionsImpl(StringRef ClassName,
std::map<std::string, VecTy> &Cache) const;

template <typename VecTy>
VecTy getAllDerivedDefinitionsImpl(ArrayRef<StringRef> ClassNames) const;

template <typename VecTy>
const VecTy &getAllDerivedDefinitionsIfDefinedImpl(
StringRef ClassName, std::map<std::string, VecTy> &Cache) const;

std::string InputFilename;
RecordMap Classes, Defs;
mutable std::map<std::string, std::vector<const Record *>>
ClassRecordsMapConst;
mutable std::map<std::string, std::vector<Record *>> ClassRecordsMap;
mutable std::map<std::string, std::vector<const Record *>> Cache;
GlobalMap ExtraGlobals;

// TODO: Move timing related code out of RecordKeeper.
Expand Down
63 changes: 12 additions & 51 deletions llvm/lib/TableGen/Record.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3275,24 +3275,20 @@ void RecordKeeper::stopBackendTimer() {
}
}

template <typename VecTy>
const VecTy &RecordKeeper::getAllDerivedDefinitionsImpl(
StringRef ClassName, std::map<std::string, VecTy> &Cache) const {
ArrayRef<const Record *>
RecordKeeper::getAllDerivedDefinitions(StringRef ClassName) const {
// We cache the record vectors for single classes. Many backends request
// the same vectors multiple times.
auto Pair = Cache.try_emplace(ClassName.str());
if (Pair.second)
Pair.first->second =
getAllDerivedDefinitionsImpl<VecTy>(ArrayRef(ClassName));

return Pair.first->second;
auto [Iter, Inserted] = Cache.try_emplace(ClassName.str());
if (Inserted)
Iter->second = getAllDerivedDefinitions(ArrayRef(ClassName));
return Iter->second;
}

template <typename VecTy>
VecTy RecordKeeper::getAllDerivedDefinitionsImpl(
ArrayRef<StringRef> ClassNames) const {
std::vector<const Record *>
RecordKeeper::getAllDerivedDefinitions(ArrayRef<StringRef> ClassNames) const {
SmallVector<const Record *, 2> ClassRecs;
VecTy Defs;
std::vector<const Record *> Defs;

assert(ClassNames.size() > 0 && "At least one class must be passed.");
for (const auto &ClassName : ClassNames) {
Expand All @@ -3312,46 +3308,11 @@ VecTy RecordKeeper::getAllDerivedDefinitionsImpl(
return Defs;
}

template <typename VecTy>
const VecTy &RecordKeeper::getAllDerivedDefinitionsIfDefinedImpl(
StringRef ClassName, std::map<std::string, VecTy> &Cache) const {
return getClass(ClassName)
? getAllDerivedDefinitionsImpl<VecTy>(ClassName, Cache)
: Cache[""];
}

ArrayRef<const Record *>
RecordKeeper::getAllDerivedDefinitions(StringRef ClassName) const {
return getAllDerivedDefinitionsImpl<std::vector<const Record *>>(
ClassName, ClassRecordsMapConst);
}

const std::vector<Record *> &
RecordKeeper::getAllDerivedDefinitions(StringRef ClassName) {
return getAllDerivedDefinitionsImpl<std::vector<Record *>>(ClassName,
ClassRecordsMap);
}

std::vector<const Record *>
RecordKeeper::getAllDerivedDefinitions(ArrayRef<StringRef> ClassNames) const {
return getAllDerivedDefinitionsImpl<std::vector<const Record *>>(ClassNames);
}

std::vector<Record *>
RecordKeeper::getAllDerivedDefinitions(ArrayRef<StringRef> ClassNames) {
return getAllDerivedDefinitionsImpl<std::vector<Record *>>(ClassNames);
}

ArrayRef<const Record *>
RecordKeeper::getAllDerivedDefinitionsIfDefined(StringRef ClassName) const {
return getAllDerivedDefinitionsIfDefinedImpl<std::vector<const Record *>>(
ClassName, ClassRecordsMapConst);
}

const std::vector<Record *> &
RecordKeeper::getAllDerivedDefinitionsIfDefined(StringRef ClassName) {
return getAllDerivedDefinitionsIfDefinedImpl<std::vector<Record *>>(
ClassName, ClassRecordsMap);
if (getClass(ClassName))
return getAllDerivedDefinitions(ClassName);
return Cache[""];
}

void RecordKeeper::dumpAllocationStats(raw_ostream &OS) const {
Expand Down
Loading