From d01d42e76cb3a4db4785069e7b50a5a41163ded8 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Sun, 2 Nov 2008 05:52:50 +0000 Subject: [PATCH] Add a new MergeFunctions pass. It finds identical functions and merges them. This triggers only 60 times in llvm-test (look at .llvm.bc, not .linked.rbc) and so it probably wont be turned on by default. Also, may of those are likely to go away when PR2973 is fixed. llvm-svn: 58557 --- llvm/include/llvm/LinkAllPasses.h | 1 + llvm/include/llvm/Transforms/IPO.h | 12 +- llvm/lib/Transforms/IPO/MergeFunctions.cpp | 358 ++++++++++++++++++ llvm/test/Transforms/MergeFunc/dg.exp | 3 + .../Transforms/MergeFunc/phi-speculation1.ll | 29 ++ .../Transforms/MergeFunc/phi-speculation2.ll | 29 ++ 6 files changed, 429 insertions(+), 3 deletions(-) create mode 100644 llvm/lib/Transforms/IPO/MergeFunctions.cpp create mode 100644 llvm/test/Transforms/MergeFunc/dg.exp create mode 100644 llvm/test/Transforms/MergeFunc/phi-speculation1.ll create mode 100644 llvm/test/Transforms/MergeFunc/phi-speculation2.ll diff --git a/llvm/include/llvm/LinkAllPasses.h b/llvm/include/llvm/LinkAllPasses.h index e23108c67f47..4dbfa2619be9 100644 --- a/llvm/include/llvm/LinkAllPasses.h +++ b/llvm/include/llvm/LinkAllPasses.h @@ -121,6 +121,7 @@ namespace { (void) llvm::createInstructionNamerPass(); (void) llvm::createPartialSpecializationPass(); (void) llvm::createAddReadAttrsPass(); + (void) llvm::createMergeFunctionsPass(); (void) llvm::createPrintModulePass(0); (void) llvm::createPrintFunctionPass("", 0); diff --git a/llvm/include/llvm/Transforms/IPO.h b/llvm/include/llvm/Transforms/IPO.h index ac8da776a2fa..887614074c56 100644 --- a/llvm/include/llvm/Transforms/IPO.h +++ b/llvm/include/llvm/Transforms/IPO.h @@ -38,7 +38,7 @@ ModulePass *createStripSymbolsPass(bool OnlyDebugInfo = false); /// to invoke/unwind instructions. This should really be part of the C/C++ /// front-end, but it's so much easier to write transformations in LLVM proper. /// -ModulePass* createLowerSetJmpPass(); +ModulePass *createLowerSetJmpPass(); //===----------------------------------------------------------------------===// /// createConstantMergePass - This function returns a new pass that merges @@ -186,13 +186,19 @@ ModulePass *createStripDeadPrototypesPass(); /// createPartialSpecializationPass - This pass specializes functions for /// constant arguments. /// -ModulePass* createPartialSpecializationPass(); +ModulePass *createPartialSpecializationPass(); //===----------------------------------------------------------------------===// /// createAddReadAttrsPass - This pass discovers functions that do not access /// memory, or only read memory, and gives them the readnone/readonly attribute. /// -Pass* createAddReadAttrsPass(); +Pass *createAddReadAttrsPass(); + +//===----------------------------------------------------------------------===// +/// createMergeFunctionsPass - This pass discovers identical functions and +/// collapses them. +/// +ModulePass *createMergeFunctionsPass(); } // End llvm namespace diff --git a/llvm/lib/Transforms/IPO/MergeFunctions.cpp b/llvm/lib/Transforms/IPO/MergeFunctions.cpp new file mode 100644 index 000000000000..563ed7db76f4 --- /dev/null +++ b/llvm/lib/Transforms/IPO/MergeFunctions.cpp @@ -0,0 +1,358 @@ +//===- MergeFunctions.cpp - Merge identical functions ---------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This pass looks for equivalent functions that are mergable and folds them. +// +// A Function will not be analyzed if: +// * it is overridable at runtime (except for weak linkage), or +// * it is used by anything other than the callee parameter of a call/invoke +// +// A hash is computed from the function, based on its type and number of +// basic blocks. +// +// Once all hashes are computed, we perform an expensive equality comparison +// on each function pair. This takes n^2/2 comparisons per bucket, so it's +// important that the hash function be high quality. The equality comparison +// iterates through each instruction in each basic block. +// +// When a match is found, the functions are folded. We can only fold two +// functions when we know that the definition of one of them is not +// overridable. +// * fold a function marked internal by replacing all of its users. +// * fold extern or weak functions by replacing them with a global alias +// +//===----------------------------------------------------------------------===// +// +// Future work: +// +// * fold vector::push_back and vector::push_back. +// +// These two functions have different types, but in a way that doesn't matter +// to us. As long as we never see an S or T itself, using S* and S** is the +// same as using a T* and T**. +// +// * virtual functions. +// +// Many functions have their address taken by the virtual function table for +// the object they belong to. However, as long as it's only used for a lookup +// and call, this is irrelevant, and we'd like to fold such implementations. +// +//===----------------------------------------------------------------------===// + +#define DEBUG_TYPE "mergefunc" +#include "llvm/Transforms/IPO.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/Statistic.h" +#include "llvm/Constants.h" +#include "llvm/InlineAsm.h" +#include "llvm/Instructions.h" +#include "llvm/Module.h" +#include "llvm/Pass.h" +#include "llvm/Support/Compiler.h" +#include "llvm/Support/Debug.h" +#include +#include +using namespace llvm; + +STATISTIC(NumFunctionsMerged, "Number of functions merged"); +STATISTIC(NumMergeFails, "Number of identical function pairings not merged"); + +namespace { + struct VISIBILITY_HIDDEN MergeFunctions : public ModulePass { + static char ID; // Pass identification, replacement for typeid + MergeFunctions() : ModulePass((intptr_t)&ID) {} + + bool runOnModule(Module &M); + }; +} + +char MergeFunctions::ID = 0; +static RegisterPass +X("mergefunc", "Merge Functions"); + +ModulePass *llvm::createMergeFunctionsPass() { + return new MergeFunctions(); +} + +static unsigned hash(const Function *F) { + return F->size() ^ reinterpret_cast(F->getType()); + //return F->size() ^ F->arg_size() ^ F->getReturnType(); +} + +static bool compare(const Value *V, const Value *U) { + assert(!isa(V) && !isa(U) && + "Must not compare basic blocks."); + + assert(V->getType() == U->getType() && + "Two of the same operation have operands of different type."); + + // TODO: If the constant is an expression of F, we should accept that it's + // equal to the same expression in terms of G. + if (isa(V)) + return V == U; + + // The caller has ensured that ValueMap[V] != U. Since Arguments are + // pre-loaded into the ValueMap, and Instructions are added as we go, we know + // that this can only be a mis-match. + if (isa(V) || isa(V)) + return false; + + if (isa(V) && isa(U)) { + const InlineAsm *IAF = cast(V); + const InlineAsm *IAG = cast(U); + return IAF->getAsmString() == IAG->getAsmString() && + IAF->getConstraintString() == IAG->getConstraintString(); + } + + return false; +} + +static bool equals(const BasicBlock *BB1, const BasicBlock *BB2, + DenseMap &ValueMap, + DenseMap &SpeculationMap) { + // Specutively add it anyways. If it's false, we'll notice a difference later, and + // this won't matter. + ValueMap[BB1] = BB2; + + BasicBlock::const_iterator FI = BB1->begin(), FE = BB1->end(); + BasicBlock::const_iterator GI = BB2->begin(), GE = BB2->end(); + + do { + if (!FI->isSameOperationAs(const_cast(&*GI))) + return false; + + if (FI->getNumOperands() != GI->getNumOperands()) + return false; + + if (ValueMap[FI] == GI) { + ++FI, ++GI; + continue; + } + + if (ValueMap[FI] != NULL) + return false; + + for (unsigned i = 0, e = FI->getNumOperands(); i != e; ++i) { + Value *OpF = FI->getOperand(i); + Value *OpG = GI->getOperand(i); + + if (ValueMap[OpF] == OpG) + continue; + + if (ValueMap[OpF] != NULL) + return false; + + assert(OpF->getType() == OpG->getType() && + "Two of the same operation has operands of different type."); + + if (OpF->getValueID() != OpG->getValueID()) + return false; + + if (isa(FI)) { + if (SpeculationMap[OpF] == NULL) + SpeculationMap[OpF] = OpG; + else if (SpeculationMap[OpF] != OpG) + return false; + continue; + } else if (isa(OpF)) { + assert(isa(FI) && + "BasicBlock referenced by non-Terminator non-PHI"); + // This call changes the ValueMap, hence we can't use + // Value *& = ValueMap[...] + if (!equals(cast(OpF), cast(OpG), ValueMap, + SpeculationMap)) + return false; + } else { + if (!compare(OpF, OpG)) + return false; + } + + ValueMap[OpF] = OpG; + } + + ValueMap[FI] = GI; + ++FI, ++GI; + } while (FI != FE && GI != GE); + + return FI == FE && GI == GE; +} + +static bool equals(const Function *F, const Function *G) { + // We need to recheck everything, but check the things that weren't included + // in the hash first. + + if (F->getAttributes() != G->getAttributes()) + return false; + + if (F->hasGC() != G->hasGC()) + return false; + + if (F->hasGC() && F->getGC() != G->getGC()) + return false; + + if (F->hasSection() != G->hasSection()) + return false; + + if (F->hasSection() && F->getSection() != G->getSection()) + return false; + + // TODO: if it's internal and only used in direct calls, we could handle this + // case too. + if (F->getCallingConv() != G->getCallingConv()) + return false; + + // TODO: We want to permit cases where two functions take T* and S* but + // only load or store them into T** and S**. + if (F->getType() != G->getType()) + return false; + + DenseMap ValueMap; + DenseMap SpeculationMap; + ValueMap[F] = G; + + assert(F->arg_size() == G->arg_size() && + "Identical functions have a different number of args."); + + for (Function::const_arg_iterator fi = F->arg_begin(), gi = G->arg_begin(), + fe = F->arg_end(); fi != fe; ++fi, ++gi) + ValueMap[fi] = gi; + + if (!equals(&F->getEntryBlock(), &G->getEntryBlock(), ValueMap, + SpeculationMap)) + return false; + + for (DenseMap::iterator + I = SpeculationMap.begin(), E = SpeculationMap.end(); I != E; ++I) { + if (ValueMap[I->first] != I->second) + return false; + } + + return true; +} + +static bool fold(std::vector &FnVec, unsigned i, unsigned j) { + if (FnVec[i]->mayBeOverridden() && !FnVec[j]->mayBeOverridden()) + std::swap(FnVec[i], FnVec[j]); + + Function *F = FnVec[i]; + Function *G = FnVec[j]; + + if (!F->mayBeOverridden()) { + if (G->hasInternalLinkage()) { + F->setAlignment(std::max(F->getAlignment(), G->getAlignment())); + G->replaceAllUsesWith(F); + G->eraseFromParent(); + ++NumFunctionsMerged; + return true; + } + + if (G->hasExternalLinkage() || G->hasWeakLinkage()) { + GlobalAlias *GA = new GlobalAlias(G->getType(), G->getLinkage(), "", + F, G->getParent()); + F->setAlignment(std::max(F->getAlignment(), G->getAlignment())); + GA->takeName(G); + GA->setVisibility(G->getVisibility()); + G->replaceAllUsesWith(GA); + G->eraseFromParent(); + ++NumFunctionsMerged; + return true; + } + } + + DOUT << "Failed on " << F->getName() << " and " << G->getName() << "\n"; + + ++NumMergeFails; + return false; +} + +static bool hasAddressTaken(User *U) { + for (User::use_iterator I = U->use_begin(), E = U->use_end(); I != E; ++I) { + User *Use = *I; + + // 'call (bitcast @F to ...)' happens a lot. + while (isa(Use) && Use->hasOneUse()) { + Use = *Use->use_begin(); + } + + if (isa(Use)) { + if (hasAddressTaken(Use)) + return true; + } + + if (!isa(Use) && !isa(Use)) + return true; + + // Make sure we aren't passing U as a parameter to call instead of the + // callee. getOperand(0) is the callee for both CallInst and InvokeInst. + // Check the other operands to see if any of them is F. + for (User::op_iterator OI = I->op_begin() + 1, OE = I->op_end(); OI != OE; + ++OI) { + if (*OI == U) + return true; + } + } + + return false; +} + +bool MergeFunctions::runOnModule(Module &M) { + bool Changed = false; + + std::map > FnMap; + + for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) { + if (F->isDeclaration() || F->isIntrinsic()) + continue; + + if (F->hasLinkOnceLinkage() || F->hasCommonLinkage() || + F->hasDLLImportLinkage() || F->hasDLLExportLinkage()) + continue; + + if (hasAddressTaken(F)) + continue; + + FnMap[hash(F)].push_back(F); + } + + // TODO: instead of running in a loop, we could also fold functions in callgraph + // order. Constructing the CFG probably isn't cheaper than just running in a loop. + + bool LocalChanged; + do { + LocalChanged = false; + for (std::map >::iterator I = FnMap.begin(), + E = FnMap.end(); I != E; ++I) { + DOUT << "size: " << FnMap.size() << "\n"; + std::vector &FnVec = I->second; + DOUT << "hash (" << I->first << "): " << FnVec.size() << "\n"; + + for (int i = 0, e = FnVec.size(); i != e; ++i) { + for (int j = i + 1; j != e; ++j) { + bool isEqual = equals(FnVec[i], FnVec[j]); + + DOUT << " " << FnVec[i]->getName() + << (isEqual ? " == " : " != ") + << FnVec[j]->getName() << "\n"; + + if (isEqual) { + if (fold(FnVec, i, j)) { + LocalChanged = true; + FnVec.erase(FnVec.begin() + j); + --j, --e; + } + } + } + } + + } + Changed |= LocalChanged; + } while (LocalChanged); + + return Changed; +} diff --git a/llvm/test/Transforms/MergeFunc/dg.exp b/llvm/test/Transforms/MergeFunc/dg.exp new file mode 100644 index 000000000000..f2005891a59a --- /dev/null +++ b/llvm/test/Transforms/MergeFunc/dg.exp @@ -0,0 +1,3 @@ +load_lib llvm.exp + +RunLLVMTests [lsort [glob -nocomplain $srcdir/$subdir/*.{ll,c,cpp}]] diff --git a/llvm/test/Transforms/MergeFunc/phi-speculation1.ll b/llvm/test/Transforms/MergeFunc/phi-speculation1.ll new file mode 100644 index 000000000000..89f31e3adad0 --- /dev/null +++ b/llvm/test/Transforms/MergeFunc/phi-speculation1.ll @@ -0,0 +1,29 @@ +; RUN: llvm-as < %s | opt -mergefunc -stats | not grep {functions merged} + +define i32 @foo1(i32 %x) { +entry: + %A = add i32 %x, 1 + %B = call i32 @foo1(i32 %A) + br label %loop +loop: + %C = phi i32 [%B, %entry], [%D, %loop] + %D = add i32 %x, 2 + %E = icmp ugt i32 %D, 10000 + br i1 %E, label %loopexit, label %loop +loopexit: + ret i32 %D +} + +define i32 @foo2(i32 %x) { +entry: + %0 = add i32 %x, 1 + %1 = call i32 @foo2(i32 %0) + br label %loop +loop: + %2 = phi i32 [%1, %entry], [%3, %loop] + %3 = add i32 %2, 2 + %4 = icmp ugt i32 %3, 10000 + br i1 %4, label %loopexit, label %loop +loopexit: + ret i32 %3 +} diff --git a/llvm/test/Transforms/MergeFunc/phi-speculation2.ll b/llvm/test/Transforms/MergeFunc/phi-speculation2.ll new file mode 100644 index 000000000000..16491002001a --- /dev/null +++ b/llvm/test/Transforms/MergeFunc/phi-speculation2.ll @@ -0,0 +1,29 @@ +; RUN: llvm-as < %s | opt -mergefunc -stats |& grep {functions merged} + +define i32 @foo1(i32 %x) { +entry: + %A = add i32 %x, 1 + %B = call i32 @foo1(i32 %A) + br label %loop +loop: + %C = phi i32 [%B, %entry], [%D, %loop] + %D = add i32 %C, 2 + %E = icmp ugt i32 %D, 10000 + br i1 %E, label %loopexit, label %loop +loopexit: + ret i32 %D +} + +define i32 @foo2(i32 %x) { +entry: + %0 = add i32 %x, 1 + %1 = call i32 @foo2(i32 %0) + br label %loop +loop: + %2 = phi i32 [%1, %entry], [%3, %loop] + %3 = add i32 %2, 2 + %4 = icmp ugt i32 %3, 10000 + br i1 %4, label %loopexit, label %loop +loopexit: + ret i32 %3 +}