Skip to content

[NFC][Cloning] Remove now unused FindDebugInfoToIdentityMap #129151

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

Merged
merged 1 commit into from
Mar 15, 2025
Merged

[NFC][Cloning] Remove now unused FindDebugInfoToIdentityMap #129151

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
19 changes: 0 additions & 19 deletions llvm/include/llvm/Transforms/Utils/Cloning.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -244,25 +244,6 @@ DISubprogram *CollectDebugInfoForCloning(const Function &F,
CloneFunctionChangeType Changes,
DebugInfoFinder &DIFinder);

/// Based on \p Changes and \p DIFinder return debug info that needs to be
/// identity mapped during Metadata cloning.
///
/// NOTE: Such \a MetadataSetTy can be used by \a CloneFunction* to directly
/// specify metadata that should be identity mapped (and hence not cloned). The
/// metadata will be identity mapped in \a ValueToValueMapTy on first use. There
/// are several reasons for doing it this way rather than eagerly identity
/// mapping metadata nodes in a \a ValueMap:
/// 1. Mapping metadata is not cheap, particularly because of tracking.
/// 2. When cloning a Function we identity map lots of global module-level
/// metadata to avoid cloning it, while only a fraction of it is actually
/// used by the function. Mapping on first use is a lot faster for modules
/// with meaningful amount of debug info.
/// 3. Eagerly identity mapping metadata makes it harder to cache module-level
/// data (e.g. a set of metadata nodes in a \a DICompileUnit).
MetadataSetTy FindDebugInfoToIdentityMap(CloneFunctionChangeType Changes,
DebugInfoFinder &DIFinder,
DISubprogram *SPClonedWithinModule);

/// This class captures the data input to the InlineFunction call, and records
/// the auxiliary results produced by it.
class InlineFunctionInfo {
Expand Down
34 changes: 0 additions & 34 deletions llvm/lib/Transforms/Utils/CloneFunction.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -189,40 +189,6 @@ DISubprogram *llvm::CollectDebugInfoForCloning(const Function &F,
return SPClonedWithinModule;
}

MetadataSetTy
llvm::FindDebugInfoToIdentityMap(CloneFunctionChangeType Changes,
DebugInfoFinder &DIFinder,
DISubprogram *SPClonedWithinModule) {
if (Changes >= CloneFunctionChangeType::DifferentModule)
return {};

if (DIFinder.subprogram_count() == 0)
assert(!SPClonedWithinModule &&
"Subprogram should be in DIFinder->subprogram_count()...");

MetadataSetTy MD;

// Avoid cloning types, compile units, and (other) subprograms.
for (DISubprogram *ISP : DIFinder.subprograms())
if (ISP != SPClonedWithinModule)
MD.insert(ISP);

// If a subprogram isn't going to be cloned skip its lexical blocks as well.
for (DIScope *S : DIFinder.scopes()) {
auto *LScope = dyn_cast<DILocalScope>(S);
if (LScope && LScope->getSubprogram() != SPClonedWithinModule)
MD.insert(S);
}

for (DICompileUnit *CU : DIFinder.compile_units())
MD.insert(CU);

for (DIType *Type : DIFinder.types())
MD.insert(Type);

return MD;
}

void llvm::CloneFunctionMetadataInto(Function &NewFunc, const Function &OldFunc,
ValueToValueMapTy &VMap,
RemapFlags RemapFlag,
Expand Down