================
@@ -420,101 +412,79 @@ static ParamLocsVecTy computeParamInfo(
bool GlobalMergeFunc::merge(Module &M, const StableFunctionMap *FunctionMap) {
bool Changed = false;
- // Build a map from stable function name to function.
- StringMap<Function *> StableNameToFuncMap;
- for (auto &F : M)
- StableNameToFuncMap[get_stable_name(F.getName())] = &F;
- // Track merged functions
- DenseSet<Function *> MergedFunctions;
-
- auto ModId = M.getModuleIdentifier();
- for (auto &[Hash, SFS] : FunctionMap->getFunctionMap()) {
- // Parameter locations based on the unique hash sequences
- // across the candidates.
+ // Collect stable functions related to the current module.
+ DenseMap<stable_hash, SmallVector<Function *>> HashToFuncs;
+ DenseMap<Function *, FunctionHashInfo> FuncToFI;
+ auto &Maps = FunctionMap->getFunctionMap();
+ for (auto &F : M) {
+ if (!isEligibleFunction(&F))
+ continue;
+ auto FI = llvm::StructuralHashWithDifferences(F, ignoreOp);
+ if (Maps.contains(FI.FunctionHash)) {
+ HashToFuncs[FI.FunctionHash].push_back(&F);
+ FuncToFI.try_emplace(&F, std::move(FI));
+ }
+ }
+
+ for (auto &[Hash, Funcs] : HashToFuncs) {
std::optional<ParamLocsVecTy> ParamLocsVec;
- Function *MergedFunc = nullptr;
- std::string MergedModId;
SmallVector<FuncMergeInfo> FuncMergeInfos;
- for (auto &SF : SFS) {
- // Get the function from the stable name.
- auto I = StableNameToFuncMap.find(
- *FunctionMap->getNameForId(SF->FunctionNameId));
- if (I == StableNameToFuncMap.end())
- continue;
- Function *F = I->second;
- assert(F);
- // Skip if the function has been merged before.
- if (MergedFunctions.count(F))
- continue;
- // Consider the function if it is eligible for merging.
- if (!isEligibleFunction(F))
- continue;
- auto FI = llvm::StructuralHashWithDifferences(*F, ignoreOp);
- uint64_t FuncHash = FI.FunctionHash;
- if (Hash != FuncHash) {
- ++NumMismatchedFunctionHash;
- continue;
- }
+ // Iterate functions with the same hash.
+ for (auto &F : Funcs) {
+ auto &SFS = Maps.at(Hash);
+ auto &FI = FuncToFI.at(F);
- if (SF->InstCount != FI.IndexInstruction->size()) {
- ++NumMismatchedInstCount;
+ // Check if the function is compatible with any stable function
+ // in terms of the number of instructions and ignored operands.
+ assert(!SFS.empty());
+ auto &RFS = SFS[0];
----------------
kyulee-com wrote:
If the codegen data is not stale —meaning there has been no source change in
the first or second pass— the size regression is less of a concern. My main
worry was about the stability of optimization when the codegen data becomes
outdated.
https://github.com/llvm/llvm-project/pull/115750
_______________________________________________
llvm-branch-commits mailing list
llvm-branch-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
