LLVM  12.0.0git
MergeFunctions.cpp
Go to the documentation of this file.
1 //===- MergeFunctions.cpp - Merge identical functions ---------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This pass looks for equivalent functions that are mergable and folds them.
10 //
11 // Order relation is defined on set of functions. It was made through
12 // special function comparison procedure that returns
13 // 0 when functions are equal,
14 // -1 when Left function is less than right function, and
15 // 1 for opposite case. We need total-ordering, so we need to maintain
16 // four properties on the functions set:
17 // a <= a (reflexivity)
18 // if a <= b and b <= a then a = b (antisymmetry)
19 // if a <= b and b <= c then a <= c (transitivity).
20 // for all a and b: a <= b or b <= a (totality).
21 //
22 // Comparison iterates through each instruction in each basic block.
23 // Functions are kept on binary tree. For each new function F we perform
24 // lookup in binary tree.
25 // In practice it works the following way:
26 // -- We define Function* container class with custom "operator<" (FunctionPtr).
27 // -- "FunctionPtr" instances are stored in std::set collection, so every
28 // std::set::insert operation will give you result in log(N) time.
29 //
30 // As an optimization, a hash of the function structure is calculated first, and
31 // two functions are only compared if they have the same hash. This hash is
32 // cheap to compute, and has the property that if function F == G according to
33 // the comparison function, then hash(F) == hash(G). This consistency property
34 // is critical to ensuring all possible merging opportunities are exploited.
35 // Collisions in the hash affect the speed of the pass but not the correctness
36 // or determinism of the resulting transformation.
37 //
38 // When a match is found the functions are folded. If both functions are
39 // overridable, we move the functionality into a new internal function and
40 // leave two overridable thunks to it.
41 //
42 //===----------------------------------------------------------------------===//
43 //
44 // Future work:
45 //
46 // * virtual functions.
47 //
48 // Many functions have their address taken by the virtual function table for
49 // the object they belong to. However, as long as it's only used for a lookup
50 // and call, this is irrelevant, and we'd like to fold such functions.
51 //
52 // * be smarter about bitcasts.
53 //
54 // In order to fold functions, we will sometimes add either bitcast instructions
55 // or bitcast constant expressions. Unfortunately, this can confound further
56 // analysis since the two functions differ where one has a bitcast and the
57 // other doesn't. We should learn to look through bitcasts.
58 //
59 // * Compare complex types with pointer types inside.
60 // * Compare cross-reference cases.
61 // * Compare complex expressions.
62 //
63 // All the three issues above could be described as ability to prove that
64 // fA == fB == fC == fE == fF == fG in example below:
65 //
66 // void fA() {
67 // fB();
68 // }
69 // void fB() {
70 // fA();
71 // }
72 //
73 // void fE() {
74 // fF();
75 // }
76 // void fF() {
77 // fG();
78 // }
79 // void fG() {
80 // fE();
81 // }
82 //
83 // Simplest cross-reference case (fA <--> fB) was implemented in previous
84 // versions of MergeFunctions, though it presented only in two function pairs
85 // in test-suite (that counts >50k functions)
86 // Though possibility to detect complex cross-referencing (e.g.: A->B->C->D->A)
87 // could cover much more cases.
88 //
89 //===----------------------------------------------------------------------===//
90 
91 #include "llvm/ADT/ArrayRef.h"
92 #include "llvm/ADT/SmallPtrSet.h"
93 #include "llvm/ADT/SmallVector.h"
94 #include "llvm/ADT/Statistic.h"
95 #include "llvm/IR/Argument.h"
96 #include "llvm/IR/Attributes.h"
97 #include "llvm/IR/BasicBlock.h"
98 #include "llvm/IR/Constant.h"
99 #include "llvm/IR/Constants.h"
101 #include "llvm/IR/DebugLoc.h"
102 #include "llvm/IR/DerivedTypes.h"
103 #include "llvm/IR/Function.h"
104 #include "llvm/IR/GlobalValue.h"
105 #include "llvm/IR/IRBuilder.h"
106 #include "llvm/IR/InstrTypes.h"
107 #include "llvm/IR/Instruction.h"
108 #include "llvm/IR/Instructions.h"
109 #include "llvm/IR/IntrinsicInst.h"
110 #include "llvm/IR/Module.h"
111 #include "llvm/IR/Type.h"
112 #include "llvm/IR/Use.h"
113 #include "llvm/IR/User.h"
114 #include "llvm/IR/Value.h"
115 #include "llvm/IR/ValueHandle.h"
116 #include "llvm/IR/ValueMap.h"
117 #include "llvm/InitializePasses.h"
118 #include "llvm/Pass.h"
119 #include "llvm/Support/Casting.h"
121 #include "llvm/Support/Debug.h"
123 #include "llvm/Transforms/IPO.h"
126 #include <algorithm>
127 #include <cassert>
128 #include <iterator>
129 #include <set>
130 #include <utility>
131 #include <vector>
132 
133 using namespace llvm;
134 
135 #define DEBUG_TYPE "mergefunc"
136 
137 STATISTIC(NumFunctionsMerged, "Number of functions merged");
138 STATISTIC(NumThunksWritten, "Number of thunks generated");
139 STATISTIC(NumAliasesWritten, "Number of aliases generated");
140 STATISTIC(NumDoubleWeak, "Number of new functions created");
141 
143  "mergefunc-sanity",
144  cl::desc("How many functions in module could be used for "
145  "MergeFunctions pass sanity check. "
146  "'0' disables this check. Works only with '-debug' key."),
147  cl::init(0), cl::Hidden);
148 
149 // Under option -mergefunc-preserve-debug-info we:
150 // - Do not create a new function for a thunk.
151 // - Retain the debug info for a thunk's parameters (and associated
152 // instructions for the debug info) from the entry block.
153 // Note: -debug will display the algorithm at work.
154 // - Create debug-info for the call (to the shared implementation) made by
155 // a thunk and its return value.
156 // - Erase the rest of the function, retaining the (minimally sized) entry
157 // block to create a thunk.
158 // - Preserve a thunk's call site to point to the thunk even when both occur
159 // within the same translation unit, to aid debugability. Note that this
160 // behaviour differs from the underlying -mergefunc implementation which
161 // modifies the thunk's call site to point to the shared implementation
162 // when both occur within the same translation unit.
163 static cl::opt<bool>
164  MergeFunctionsPDI("mergefunc-preserve-debug-info", cl::Hidden,
165  cl::init(false),
166  cl::desc("Preserve debug info in thunk when mergefunc "
167  "transformations are made."));
168 
169 static cl::opt<bool>
170  MergeFunctionsAliases("mergefunc-use-aliases", cl::Hidden,
171  cl::init(false),
172  cl::desc("Allow mergefunc to create aliases"));
173 
174 namespace {
175 
176 class FunctionNode {
177  mutable AssertingVH<Function> F;
179 
180 public:
181  // Note the hash is recalculated potentially multiple times, but it is cheap.
182  FunctionNode(Function *F)
183  : F(F), Hash(FunctionComparator::functionHash(*F)) {}
184 
185  Function *getFunc() const { return F; }
186  FunctionComparator::FunctionHash getHash() const { return Hash; }
187 
188  /// Replace the reference to the function F by the function G, assuming their
189  /// implementations are equal.
190  void replaceBy(Function *G) const {
191  F = G;
192  }
193 };
194 
195 /// MergeFunctions finds functions which will generate identical machine code,
196 /// by considering all pointer types to be equivalent. Once identified,
197 /// MergeFunctions will fold them by replacing a call to one to a call to a
198 /// bitcast of the other.
199 class MergeFunctions {
200 public:
201  MergeFunctions() : FnTree(FunctionNodeCmp(&GlobalNumbers)) {
202  }
203 
204  bool runOnModule(Module &M);
205 
206 private:
207  // The function comparison operator is provided here so that FunctionNodes do
208  // not need to become larger with another pointer.
209  class FunctionNodeCmp {
210  GlobalNumberState* GlobalNumbers;
211 
212  public:
213  FunctionNodeCmp(GlobalNumberState* GN) : GlobalNumbers(GN) {}
214 
215  bool operator()(const FunctionNode &LHS, const FunctionNode &RHS) const {
216  // Order first by hashes, then full function comparison.
217  if (LHS.getHash() != RHS.getHash())
218  return LHS.getHash() < RHS.getHash();
219  FunctionComparator FCmp(LHS.getFunc(), RHS.getFunc(), GlobalNumbers);
220  return FCmp.compare() == -1;
221  }
222  };
223  using FnTreeType = std::set<FunctionNode, FunctionNodeCmp>;
224 
225  GlobalNumberState GlobalNumbers;
226 
227  /// A work queue of functions that may have been modified and should be
228  /// analyzed again.
229  std::vector<WeakTrackingVH> Deferred;
230 
231 #ifndef NDEBUG
232  /// Checks the rules of order relation introduced among functions set.
233  /// Returns true, if sanity check has been passed, and false if failed.
234  bool doSanityCheck(std::vector<WeakTrackingVH> &Worklist);
235 #endif
236 
237  /// Insert a ComparableFunction into the FnTree, or merge it away if it's
238  /// equal to one that's already present.
239  bool insert(Function *NewFunction);
240 
241  /// Remove a Function from the FnTree and queue it up for a second sweep of
242  /// analysis.
243  void remove(Function *F);
244 
245  /// Find the functions that use this Value and remove them from FnTree and
246  /// queue the functions.
247  void removeUsers(Value *V);
248 
249  /// Replace all direct calls of Old with calls of New. Will bitcast New if
250  /// necessary to make types match.
251  void replaceDirectCallers(Function *Old, Function *New);
252 
253  /// Merge two equivalent functions. Upon completion, G may be deleted, or may
254  /// be converted into a thunk. In either case, it should never be visited
255  /// again.
256  void mergeTwoFunctions(Function *F, Function *G);
257 
258  /// Fill PDIUnrelatedWL with instructions from the entry block that are
259  /// unrelated to parameter related debug info.
260  void filterInstsUnrelatedToPDI(BasicBlock *GEntryBlock,
261  std::vector<Instruction *> &PDIUnrelatedWL);
262 
263  /// Erase the rest of the CFG (i.e. barring the entry block).
264  void eraseTail(Function *G);
265 
266  /// Erase the instructions in PDIUnrelatedWL as they are unrelated to the
267  /// parameter debug info, from the entry block.
268  void eraseInstsUnrelatedToPDI(std::vector<Instruction *> &PDIUnrelatedWL);
269 
270  /// Replace G with a simple tail call to bitcast(F). Also (unless
271  /// MergeFunctionsPDI holds) replace direct uses of G with bitcast(F),
272  /// delete G.
273  void writeThunk(Function *F, Function *G);
274 
275  // Replace G with an alias to F (deleting function G)
276  void writeAlias(Function *F, Function *G);
277 
278  // Replace G with an alias to F if possible, or a thunk to F if possible.
279  // Returns false if neither is the case.
280  bool writeThunkOrAlias(Function *F, Function *G);
281 
282  /// Replace function F with function G in the function tree.
283  void replaceFunctionInTree(const FunctionNode &FN, Function *G);
284 
285  /// The set of all distinct functions. Use the insert() and remove() methods
286  /// to modify it. The map allows efficient lookup and deferring of Functions.
287  FnTreeType FnTree;
288 
289  // Map functions to the iterators of the FunctionNode which contains them
290  // in the FnTree. This must be updated carefully whenever the FnTree is
291  // modified, i.e. in insert(), remove(), and replaceFunctionInTree(), to avoid
292  // dangling iterators into FnTree. The invariant that preserves this is that
293  // there is exactly one mapping F -> FN for each FunctionNode FN in FnTree.
294  DenseMap<AssertingVH<Function>, FnTreeType::iterator> FNodesInTree;
295 };
296 
297 class MergeFunctionsLegacyPass : public ModulePass {
298 public:
299  static char ID;
300 
301  MergeFunctionsLegacyPass(): ModulePass(ID) {
303  }
304 
305  bool runOnModule(Module &M) override {
306  if (skipModule(M))
307  return false;
308 
309  MergeFunctions MF;
310  return MF.runOnModule(M);
311  }
312 };
313 
314 } // end anonymous namespace
315 
317 INITIALIZE_PASS(MergeFunctionsLegacyPass, "mergefunc",
318  "Merge Functions", false, false)
319 
321  return new MergeFunctionsLegacyPass();
322 }
323 
325  ModuleAnalysisManager &AM) {
326  MergeFunctions MF;
327  if (!MF.runOnModule(M))
328  return PreservedAnalyses::all();
329  return PreservedAnalyses::none();
330 }
331 
332 #ifndef NDEBUG
333 bool MergeFunctions::doSanityCheck(std::vector<WeakTrackingVH> &Worklist) {
334  if (const unsigned Max = NumFunctionsForSanityCheck) {
335  unsigned TripleNumber = 0;
336  bool Valid = true;
337 
338  dbgs() << "MERGEFUNC-SANITY: Started for first " << Max << " functions.\n";
339 
340  unsigned i = 0;
341  for (std::vector<WeakTrackingVH>::iterator I = Worklist.begin(),
342  E = Worklist.end();
343  I != E && i < Max; ++I, ++i) {
344  unsigned j = i;
345  for (std::vector<WeakTrackingVH>::iterator J = I; J != E && j < Max;
346  ++J, ++j) {
347  Function *F1 = cast<Function>(*I);
348  Function *F2 = cast<Function>(*J);
349  int Res1 = FunctionComparator(F1, F2, &GlobalNumbers).compare();
350  int Res2 = FunctionComparator(F2, F1, &GlobalNumbers).compare();
351 
352  // If F1 <= F2, then F2 >= F1, otherwise report failure.
353  if (Res1 != -Res2) {
354  dbgs() << "MERGEFUNC-SANITY: Non-symmetric; triple: " << TripleNumber
355  << "\n";
356  dbgs() << *F1 << '\n' << *F2 << '\n';
357  Valid = false;
358  }
359 
360  if (Res1 == 0)
361  continue;
362 
363  unsigned k = j;
364  for (std::vector<WeakTrackingVH>::iterator K = J; K != E && k < Max;
365  ++k, ++K, ++TripleNumber) {
366  if (K == J)
367  continue;
368 
369  Function *F3 = cast<Function>(*K);
370  int Res3 = FunctionComparator(F1, F3, &GlobalNumbers).compare();
371  int Res4 = FunctionComparator(F2, F3, &GlobalNumbers).compare();
372 
373  bool Transitive = true;
374 
375  if (Res1 != 0 && Res1 == Res4) {
376  // F1 > F2, F2 > F3 => F1 > F3
377  Transitive = Res3 == Res1;
378  } else if (Res3 != 0 && Res3 == -Res4) {
379  // F1 > F3, F3 > F2 => F1 > F2
380  Transitive = Res3 == Res1;
381  } else if (Res4 != 0 && -Res3 == Res4) {
382  // F2 > F3, F3 > F1 => F2 > F1
383  Transitive = Res4 == -Res1;
384  }
385 
386  if (!Transitive) {
387  dbgs() << "MERGEFUNC-SANITY: Non-transitive; triple: "
388  << TripleNumber << "\n";
389  dbgs() << "Res1, Res3, Res4: " << Res1 << ", " << Res3 << ", "
390  << Res4 << "\n";
391  dbgs() << *F1 << '\n' << *F2 << '\n' << *F3 << '\n';
392  Valid = false;
393  }
394  }
395  }
396  }
397 
398  dbgs() << "MERGEFUNC-SANITY: " << (Valid ? "Passed." : "Failed.") << "\n";
399  return Valid;
400  }
401  return true;
402 }
403 #endif
404 
405 /// Check whether \p F is eligible for function merging.
407  return !F.isDeclaration() && !F.hasAvailableExternallyLinkage();
408 }
409 
410 bool MergeFunctions::runOnModule(Module &M) {
411  bool Changed = false;
412 
413  // All functions in the module, ordered by hash. Functions with a unique
414  // hash value are easily eliminated.
415  std::vector<std::pair<FunctionComparator::FunctionHash, Function *>>
416  HashedFuncs;
417  for (Function &Func : M) {
418  if (isEligibleForMerging(Func)) {
419  HashedFuncs.push_back({FunctionComparator::functionHash(Func), &Func});
420  }
421  }
422 
423  llvm::stable_sort(HashedFuncs, less_first());
424 
425  auto S = HashedFuncs.begin();
426  for (auto I = HashedFuncs.begin(), IE = HashedFuncs.end(); I != IE; ++I) {
427  // If the hash value matches the previous value or the next one, we must
428  // consider merging it. Otherwise it is dropped and never considered again.
429  if ((I != S && std::prev(I)->first == I->first) ||
430  (std::next(I) != IE && std::next(I)->first == I->first) ) {
431  Deferred.push_back(WeakTrackingVH(I->second));
432  }
433  }
434 
435  do {
436  std::vector<WeakTrackingVH> Worklist;
437  Deferred.swap(Worklist);
438 
439  LLVM_DEBUG(doSanityCheck(Worklist));
440 
441  LLVM_DEBUG(dbgs() << "size of module: " << M.size() << '\n');
442  LLVM_DEBUG(dbgs() << "size of worklist: " << Worklist.size() << '\n');
443 
444  // Insert functions and merge them.
445  for (WeakTrackingVH &I : Worklist) {
446  if (!I)
447  continue;
448  Function *F = cast<Function>(I);
449  if (!F->isDeclaration() && !F->hasAvailableExternallyLinkage()) {
450  Changed |= insert(F);
451  }
452  }
453  LLVM_DEBUG(dbgs() << "size of FnTree: " << FnTree.size() << '\n');
454  } while (!Deferred.empty());
455 
456  FnTree.clear();
457  FNodesInTree.clear();
458  GlobalNumbers.clear();
459 
460  return Changed;
461 }
462 
463 // Replace direct callers of Old with New.
464 void MergeFunctions::replaceDirectCallers(Function *Old, Function *New) {
465  Constant *BitcastNew = ConstantExpr::getBitCast(New, Old->getType());
466  for (auto UI = Old->use_begin(), UE = Old->use_end(); UI != UE;) {
467  Use *U = &*UI;
468  ++UI;
469  CallBase *CB = dyn_cast<CallBase>(U->getUser());
470  if (CB && CB->isCallee(U)) {
471  // Do not copy attributes from the called function to the call-site.
472  // Function comparison ensures that the attributes are the same up to
473  // type congruences in byval(), in which case we need to keep the byval
474  // type of the call-site, not the callee function.
475  remove(CB->getFunction());
476  U->set(BitcastNew);
477  }
478  }
479 }
480 
481 // Helper for writeThunk,
482 // Selects proper bitcast operation,
483 // but a bit simpler then CastInst::getCastOpcode.
484 static Value *createCast(IRBuilder<> &Builder, Value *V, Type *DestTy) {
485  Type *SrcTy = V->getType();
486  if (SrcTy->isStructTy()) {
487  assert(DestTy->isStructTy());
488  assert(SrcTy->getStructNumElements() == DestTy->getStructNumElements());
489  Value *Result = UndefValue::get(DestTy);
490  for (unsigned int I = 0, E = SrcTy->getStructNumElements(); I < E; ++I) {
491  Value *Element = createCast(
492  Builder, Builder.CreateExtractValue(V, makeArrayRef(I)),
493  DestTy->getStructElementType(I));
494 
495  Result =
496  Builder.CreateInsertValue(Result, Element, makeArrayRef(I));
497  }
498  return Result;
499  }
500  assert(!DestTy->isStructTy());
501  if (SrcTy->isIntegerTy() && DestTy->isPointerTy())
502  return Builder.CreateIntToPtr(V, DestTy);
503  else if (SrcTy->isPointerTy() && DestTy->isIntegerTy())
504  return Builder.CreatePtrToInt(V, DestTy);
505  else
506  return Builder.CreateBitCast(V, DestTy);
507 }
508 
509 // Erase the instructions in PDIUnrelatedWL as they are unrelated to the
510 // parameter debug info, from the entry block.
511 void MergeFunctions::eraseInstsUnrelatedToPDI(
512  std::vector<Instruction *> &PDIUnrelatedWL) {
513  LLVM_DEBUG(
514  dbgs() << " Erasing instructions (in reverse order of appearance in "
515  "entry block) unrelated to parameter debug info from entry "
516  "block: {\n");
517  while (!PDIUnrelatedWL.empty()) {
518  Instruction *I = PDIUnrelatedWL.back();
519  LLVM_DEBUG(dbgs() << " Deleting Instruction: ");
520  LLVM_DEBUG(I->print(dbgs()));
521  LLVM_DEBUG(dbgs() << "\n");
522  I->eraseFromParent();
523  PDIUnrelatedWL.pop_back();
524  }
525  LLVM_DEBUG(dbgs() << " } // Done erasing instructions unrelated to parameter "
526  "debug info from entry block. \n");
527 }
528 
529 // Reduce G to its entry block.
530 void MergeFunctions::eraseTail(Function *G) {
531  std::vector<BasicBlock *> WorklistBB;
532  for (Function::iterator BBI = std::next(G->begin()), BBE = G->end();
533  BBI != BBE; ++BBI) {
534  BBI->dropAllReferences();
535  WorklistBB.push_back(&*BBI);
536  }
537  while (!WorklistBB.empty()) {
538  BasicBlock *BB = WorklistBB.back();
539  BB->eraseFromParent();
540  WorklistBB.pop_back();
541  }
542 }
543 
544 // We are interested in the following instructions from the entry block as being
545 // related to parameter debug info:
546 // - @llvm.dbg.declare
547 // - stores from the incoming parameters to locations on the stack-frame
548 // - allocas that create these locations on the stack-frame
549 // - @llvm.dbg.value
550 // - the entry block's terminator
551 // The rest are unrelated to debug info for the parameters; fill up
552 // PDIUnrelatedWL with such instructions.
553 void MergeFunctions::filterInstsUnrelatedToPDI(
554  BasicBlock *GEntryBlock, std::vector<Instruction *> &PDIUnrelatedWL) {
555  std::set<Instruction *> PDIRelated;
556  for (BasicBlock::iterator BI = GEntryBlock->begin(), BIE = GEntryBlock->end();
557  BI != BIE; ++BI) {
558  if (auto *DVI = dyn_cast<DbgValueInst>(&*BI)) {
559  LLVM_DEBUG(dbgs() << " Deciding: ");
560  LLVM_DEBUG(BI->print(dbgs()));
561  LLVM_DEBUG(dbgs() << "\n");
562  DILocalVariable *DILocVar = DVI->getVariable();
563  if (DILocVar->isParameter()) {
564  LLVM_DEBUG(dbgs() << " Include (parameter): ");
565  LLVM_DEBUG(BI->print(dbgs()));
566  LLVM_DEBUG(dbgs() << "\n");
567  PDIRelated.insert(&*BI);
568  } else {
569  LLVM_DEBUG(dbgs() << " Delete (!parameter): ");
570  LLVM_DEBUG(BI->print(dbgs()));
571  LLVM_DEBUG(dbgs() << "\n");
572  }
573  } else if (auto *DDI = dyn_cast<DbgDeclareInst>(&*BI)) {
574  LLVM_DEBUG(dbgs() << " Deciding: ");
575  LLVM_DEBUG(BI->print(dbgs()));
576  LLVM_DEBUG(dbgs() << "\n");
577  DILocalVariable *DILocVar = DDI->getVariable();
578  if (DILocVar->isParameter()) {
579  LLVM_DEBUG(dbgs() << " Parameter: ");
580  LLVM_DEBUG(DILocVar->print(dbgs()));
581  AllocaInst *AI = dyn_cast_or_null<AllocaInst>(DDI->getAddress());
582  if (AI) {
583  LLVM_DEBUG(dbgs() << " Processing alloca users: ");
584  LLVM_DEBUG(dbgs() << "\n");
585  for (User *U : AI->users()) {
586  if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
587  if (Value *Arg = SI->getValueOperand()) {
588  if (dyn_cast<Argument>(Arg)) {
589  LLVM_DEBUG(dbgs() << " Include: ");
590  LLVM_DEBUG(AI->print(dbgs()));
591  LLVM_DEBUG(dbgs() << "\n");
592  PDIRelated.insert(AI);
593  LLVM_DEBUG(dbgs() << " Include (parameter): ");
594  LLVM_DEBUG(SI->print(dbgs()));
595  LLVM_DEBUG(dbgs() << "\n");
596  PDIRelated.insert(SI);
597  LLVM_DEBUG(dbgs() << " Include: ");
598  LLVM_DEBUG(BI->print(dbgs()));
599  LLVM_DEBUG(dbgs() << "\n");
600  PDIRelated.insert(&*BI);
601  } else {
602  LLVM_DEBUG(dbgs() << " Delete (!parameter): ");
603  LLVM_DEBUG(SI->print(dbgs()));
604  LLVM_DEBUG(dbgs() << "\n");
605  }
606  }
607  } else {
608  LLVM_DEBUG(dbgs() << " Defer: ");
609  LLVM_DEBUG(U->print(dbgs()));
610  LLVM_DEBUG(dbgs() << "\n");
611  }
612  }
613  } else {
614  LLVM_DEBUG(dbgs() << " Delete (alloca NULL): ");
615  LLVM_DEBUG(BI->print(dbgs()));
616  LLVM_DEBUG(dbgs() << "\n");
617  }
618  } else {
619  LLVM_DEBUG(dbgs() << " Delete (!parameter): ");
620  LLVM_DEBUG(BI->print(dbgs()));
621  LLVM_DEBUG(dbgs() << "\n");
622  }
623  } else if (BI->isTerminator() && &*BI == GEntryBlock->getTerminator()) {
624  LLVM_DEBUG(dbgs() << " Will Include Terminator: ");
625  LLVM_DEBUG(BI->print(dbgs()));
626  LLVM_DEBUG(dbgs() << "\n");
627  PDIRelated.insert(&*BI);
628  } else {
629  LLVM_DEBUG(dbgs() << " Defer: ");
630  LLVM_DEBUG(BI->print(dbgs()));
631  LLVM_DEBUG(dbgs() << "\n");
632  }
633  }
634  LLVM_DEBUG(
635  dbgs()
636  << " Report parameter debug info related/related instructions: {\n");
637  for (BasicBlock::iterator BI = GEntryBlock->begin(), BE = GEntryBlock->end();
638  BI != BE; ++BI) {
639 
640  Instruction *I = &*BI;
641  if (PDIRelated.find(I) == PDIRelated.end()) {
642  LLVM_DEBUG(dbgs() << " !PDIRelated: ");
643  LLVM_DEBUG(I->print(dbgs()));
644  LLVM_DEBUG(dbgs() << "\n");
645  PDIUnrelatedWL.push_back(I);
646  } else {
647  LLVM_DEBUG(dbgs() << " PDIRelated: ");
648  LLVM_DEBUG(I->print(dbgs()));
649  LLVM_DEBUG(dbgs() << "\n");
650  }
651  }
652  LLVM_DEBUG(dbgs() << " }\n");
653 }
654 
655 /// Whether this function may be replaced by a forwarding thunk.
656 static bool canCreateThunkFor(Function *F) {
657  if (F->isVarArg())
658  return false;
659 
660  // Don't merge tiny functions using a thunk, since it can just end up
661  // making the function larger.
662  if (F->size() == 1) {
663  if (F->front().size() <= 2) {
664  LLVM_DEBUG(dbgs() << "canCreateThunkFor: " << F->getName()
665  << " is too small to bother creating a thunk for\n");
666  return false;
667  }
668  }
669  return true;
670 }
671 
672 // Replace G with a simple tail call to bitcast(F). Also (unless
673 // MergeFunctionsPDI holds) replace direct uses of G with bitcast(F),
674 // delete G. Under MergeFunctionsPDI, we use G itself for creating
675 // the thunk as we preserve the debug info (and associated instructions)
676 // from G's entry block pertaining to G's incoming arguments which are
677 // passed on as corresponding arguments in the call that G makes to F.
678 // For better debugability, under MergeFunctionsPDI, we do not modify G's
679 // call sites to point to F even when within the same translation unit.
680 void MergeFunctions::writeThunk(Function *F, Function *G) {
681  BasicBlock *GEntryBlock = nullptr;
682  std::vector<Instruction *> PDIUnrelatedWL;
683  BasicBlock *BB = nullptr;
684  Function *NewG = nullptr;
685  if (MergeFunctionsPDI) {
686  LLVM_DEBUG(dbgs() << "writeThunk: (MergeFunctionsPDI) Do not create a new "
687  "function as thunk; retain original: "
688  << G->getName() << "()\n");
689  GEntryBlock = &G->getEntryBlock();
690  LLVM_DEBUG(
691  dbgs() << "writeThunk: (MergeFunctionsPDI) filter parameter related "
692  "debug info for "
693  << G->getName() << "() {\n");
694  filterInstsUnrelatedToPDI(GEntryBlock, PDIUnrelatedWL);
695  GEntryBlock->getTerminator()->eraseFromParent();
696  BB = GEntryBlock;
697  } else {
698  NewG = Function::Create(G->getFunctionType(), G->getLinkage(),
699  G->getAddressSpace(), "", G->getParent());
700  NewG->setComdat(G->getComdat());
701  BB = BasicBlock::Create(F->getContext(), "", NewG);
702  }
703 
704  IRBuilder<> Builder(BB);
705  Function *H = MergeFunctionsPDI ? G : NewG;
707  unsigned i = 0;
708  FunctionType *FFTy = F->getFunctionType();
709  for (Argument &AI : H->args()) {
710  Args.push_back(createCast(Builder, &AI, FFTy->getParamType(i)));
711  ++i;
712  }
713 
714  CallInst *CI = Builder.CreateCall(F, Args);
715  ReturnInst *RI = nullptr;
716  CI->setTailCall();
717  CI->setCallingConv(F->getCallingConv());
718  CI->setAttributes(F->getAttributes());
719  if (H->getReturnType()->isVoidTy()) {
720  RI = Builder.CreateRetVoid();
721  } else {
722  RI = Builder.CreateRet(createCast(Builder, CI, H->getReturnType()));
723  }
724 
725  if (MergeFunctionsPDI) {
726  DISubprogram *DIS = G->getSubprogram();
727  if (DIS) {
728  DebugLoc CIDbgLoc =
729  DILocation::get(DIS->getContext(), DIS->getScopeLine(), 0, DIS);
730  DebugLoc RIDbgLoc =
731  DILocation::get(DIS->getContext(), DIS->getScopeLine(), 0, DIS);
732  CI->setDebugLoc(CIDbgLoc);
733  RI->setDebugLoc(RIDbgLoc);
734  } else {
735  LLVM_DEBUG(
736  dbgs() << "writeThunk: (MergeFunctionsPDI) No DISubprogram for "
737  << G->getName() << "()\n");
738  }
739  eraseTail(G);
740  eraseInstsUnrelatedToPDI(PDIUnrelatedWL);
741  LLVM_DEBUG(
742  dbgs() << "} // End of parameter related debug info filtering for: "
743  << G->getName() << "()\n");
744  } else {
745  NewG->copyAttributesFrom(G);
746  NewG->takeName(G);
747  removeUsers(G);
748  G->replaceAllUsesWith(NewG);
749  G->eraseFromParent();
750  }
751 
752  LLVM_DEBUG(dbgs() << "writeThunk: " << H->getName() << '\n');
753  ++NumThunksWritten;
754 }
755 
756 // Whether this function may be replaced by an alias
757 static bool canCreateAliasFor(Function *F) {
758  if (!MergeFunctionsAliases || !F->hasGlobalUnnamedAddr())
759  return false;
760 
761  // We should only see linkages supported by aliases here
762  assert(F->hasLocalLinkage() || F->hasExternalLinkage()
763  || F->hasWeakLinkage() || F->hasLinkOnceLinkage());
764  return true;
765 }
766 
767 // Replace G with an alias to F (deleting function G)
768 void MergeFunctions::writeAlias(Function *F, Function *G) {
769  Constant *BitcastF = ConstantExpr::getBitCast(F, G->getType());
770  PointerType *PtrType = G->getType();
771  auto *GA = GlobalAlias::create(
772  PtrType->getElementType(), PtrType->getAddressSpace(),
773  G->getLinkage(), "", BitcastF, G->getParent());
774 
775  F->setAlignment(MaybeAlign(std::max(F->getAlignment(), G->getAlignment())));
776  GA->takeName(G);
777  GA->setVisibility(G->getVisibility());
778  GA->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
779 
780  removeUsers(G);
781  G->replaceAllUsesWith(GA);
782  G->eraseFromParent();
783 
784  LLVM_DEBUG(dbgs() << "writeAlias: " << GA->getName() << '\n');
785  ++NumAliasesWritten;
786 }
787 
788 // Replace G with an alias to F if possible, or a thunk to F if
789 // profitable. Returns false if neither is the case.
790 bool MergeFunctions::writeThunkOrAlias(Function *F, Function *G) {
791  if (canCreateAliasFor(G)) {
792  writeAlias(F, G);
793  return true;
794  }
795  if (canCreateThunkFor(F)) {
796  writeThunk(F, G);
797  return true;
798  }
799  return false;
800 }
801 
802 // Merge two equivalent functions. Upon completion, Function G is deleted.
803 void MergeFunctions::mergeTwoFunctions(Function *F, Function *G) {
804  if (F->isInterposable()) {
805  assert(G->isInterposable());
806 
807  // Both writeThunkOrAlias() calls below must succeed, either because we can
808  // create aliases for G and NewF, or because a thunk for F is profitable.
809  // F here has the same signature as NewF below, so that's what we check.
810  if (!canCreateThunkFor(F) &&
812  return;
813 
814  // Make them both thunks to the same internal function.
815  Function *NewF = Function::Create(F->getFunctionType(), F->getLinkage(),
816  F->getAddressSpace(), "", F->getParent());
817  NewF->copyAttributesFrom(F);
818  NewF->takeName(F);
819  removeUsers(F);
820  F->replaceAllUsesWith(NewF);
821 
822  MaybeAlign MaxAlignment(std::max(G->getAlignment(), NewF->getAlignment()));
823 
824  writeThunkOrAlias(F, G);
825  writeThunkOrAlias(F, NewF);
826 
827  F->setAlignment(MaxAlignment);
828  F->setLinkage(GlobalValue::PrivateLinkage);
829  ++NumDoubleWeak;
830  ++NumFunctionsMerged;
831  } else {
832  // For better debugability, under MergeFunctionsPDI, we do not modify G's
833  // call sites to point to F even when within the same translation unit.
834  if (!G->isInterposable() && !MergeFunctionsPDI) {
835  if (G->hasGlobalUnnamedAddr()) {
836  // G might have been a key in our GlobalNumberState, and it's illegal
837  // to replace a key in ValueMap<GlobalValue *> with a non-global.
838  GlobalNumbers.erase(G);
839  // If G's address is not significant, replace it entirely.
840  Constant *BitcastF = ConstantExpr::getBitCast(F, G->getType());
841  removeUsers(G);
842  G->replaceAllUsesWith(BitcastF);
843  } else {
844  // Redirect direct callers of G to F. (See note on MergeFunctionsPDI
845  // above).
846  replaceDirectCallers(G, F);
847  }
848  }
849 
850  // If G was internal then we may have replaced all uses of G with F. If so,
851  // stop here and delete G. There's no need for a thunk. (See note on
852  // MergeFunctionsPDI above).
853  if (G->isDiscardableIfUnused() && G->use_empty() && !MergeFunctionsPDI) {
854  G->eraseFromParent();
855  ++NumFunctionsMerged;
856  return;
857  }
858 
859  if (writeThunkOrAlias(F, G)) {
860  ++NumFunctionsMerged;
861  }
862  }
863 }
864 
865 /// Replace function F by function G.
866 void MergeFunctions::replaceFunctionInTree(const FunctionNode &FN,
867  Function *G) {
868  Function *F = FN.getFunc();
869  assert(FunctionComparator(F, G, &GlobalNumbers).compare() == 0 &&
870  "The two functions must be equal");
871 
872  auto I = FNodesInTree.find(F);
873  assert(I != FNodesInTree.end() && "F should be in FNodesInTree");
874  assert(FNodesInTree.count(G) == 0 && "FNodesInTree should not contain G");
875 
876  FnTreeType::iterator IterToFNInFnTree = I->second;
877  assert(&(*IterToFNInFnTree) == &FN && "F should map to FN in FNodesInTree.");
878  // Remove F -> FN and insert G -> FN
879  FNodesInTree.erase(I);
880  FNodesInTree.insert({G, IterToFNInFnTree});
881  // Replace F with G in FN, which is stored inside the FnTree.
882  FN.replaceBy(G);
883 }
884 
885 // Ordering for functions that are equal under FunctionComparator
886 static bool isFuncOrderCorrect(const Function *F, const Function *G) {
887  if (F->isInterposable() != G->isInterposable()) {
888  // Strong before weak, because the weak function may call the strong
889  // one, but not the other way around.
890  return !F->isInterposable();
891  }
892  if (F->hasLocalLinkage() != G->hasLocalLinkage()) {
893  // External before local, because we definitely have to keep the external
894  // function, but may be able to drop the local one.
895  return !F->hasLocalLinkage();
896  }
897  // Impose a total order (by name) on the replacement of functions. This is
898  // important when operating on more than one module independently to prevent
899  // cycles of thunks calling each other when the modules are linked together.
900  return F->getName() <= G->getName();
901 }
902 
903 // Insert a ComparableFunction into the FnTree, or merge it away if equal to one
904 // that was already inserted.
905 bool MergeFunctions::insert(Function *NewFunction) {
906  std::pair<FnTreeType::iterator, bool> Result =
907  FnTree.insert(FunctionNode(NewFunction));
908 
909  if (Result.second) {
910  assert(FNodesInTree.count(NewFunction) == 0);
911  FNodesInTree.insert({NewFunction, Result.first});
912  LLVM_DEBUG(dbgs() << "Inserting as unique: " << NewFunction->getName()
913  << '\n');
914  return false;
915  }
916 
917  const FunctionNode &OldF = *Result.first;
918 
919  if (!isFuncOrderCorrect(OldF.getFunc(), NewFunction)) {
920  // Swap the two functions.
921  Function *F = OldF.getFunc();
922  replaceFunctionInTree(*Result.first, NewFunction);
923  NewFunction = F;
924  assert(OldF.getFunc() != F && "Must have swapped the functions.");
925  }
926 
927  LLVM_DEBUG(dbgs() << " " << OldF.getFunc()->getName()
928  << " == " << NewFunction->getName() << '\n');
929 
930  Function *DeleteF = NewFunction;
931  mergeTwoFunctions(OldF.getFunc(), DeleteF);
932  return true;
933 }
934 
935 // Remove a function from FnTree. If it was already in FnTree, add
936 // it to Deferred so that we'll look at it in the next round.
938  auto I = FNodesInTree.find(F);
939  if (I != FNodesInTree.end()) {
940  LLVM_DEBUG(dbgs() << "Deferred " << F->getName() << ".\n");
941  FnTree.erase(I->second);
942  // I->second has been invalidated, remove it from the FNodesInTree map to
943  // preserve the invariant.
944  FNodesInTree.erase(I);
945  Deferred.emplace_back(F);
946  }
947 }
948 
949 // For each instruction used by the value, remove() the function that contains
950 // the instruction. This should happen right before a call to RAUW.
951 void MergeFunctions::removeUsers(Value *V) {
952  for (User *U : V->users())
953  if (auto *I = dyn_cast<Instruction>(U))
954  remove(I->getFunction());
955 }
Return a value (possibly void), from a function.
unsigned getAlignment() const
FIXME: Remove this function once transition to Align is over.
Definition: GlobalObject.h:73
use_iterator use_end()
Definition: Value.h:371
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
This class represents an incoming formal argument to a Function.
Definition: Argument.h:29
static Value * createCast(IRBuilder<> &Builder, Value *V, Type *DestTy)
This class represents lattice values for constants.
Definition: AllocatorList.h:23
ModulePass * createMergeFunctionsPass()
createMergeFunctionsPass - This pass discovers identical functions and collapses them.
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:134
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
std::error_code remove(const Twine &path, bool IgnoreNonExisting=true)
Remove path.
static bool isFuncOrderCorrect(const Function *F, const Function *G)
This class represents a function call, abstracting a target machine's calling convention.
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:56
STATISTIC(NumFunctions, "Total number of functions")
A debug info location.
Definition: DebugLoc.h:33
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1164
F(f)
Type * getStructElementType(unsigned N) const
Definition: DerivedTypes.h:351
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:148
This defines the Use class.
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:296
uint64_t FunctionHash
Hash a function.
static bool isEligibleForMerging(Function &F)
Check whether F is eligible for function merging.
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:458
A Use represents the edge between a Value definition and its users.
Definition: Use.h:44
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:202
This file contains the simple types necessary to represent the attributes associated with functions a...
void initializeMergeFunctionsLegacyPassPass(PassRegistry &)
Subprogram description.
Class to represent function types.
Definition: DerivedTypes.h:102
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:246
Value handle that is nullable, but tries to track the Value.
Definition: ValueHandle.h:204
LLVMContext & getContext() const
Definition: Metadata.h:930
void setComdat(Comdat *C)
Definition: GlobalObject.h:127
An instruction for storing to memory.
Definition: Instructions.h:303
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:373
static bool canCreateAliasFor(Function *F)
void erase(GlobalValue *Global)
Class to represent pointers.
Definition: DerivedTypes.h:655
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: PassManager.h:158
static cl::opt< unsigned > NumFunctionsForSanityCheck("mergefunc-sanity", cl::desc("How many functions in module could be used for " "MergeFunctions pass sanity check. " "'0' disables this check. Works only with '-debug' key."), cl::init(0), cl::Hidden)
static FunctionHash functionHash(Function &)
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2173
INITIALIZE_PASS(MergeFunctionsLegacyPass, "mergefunc", "Merge Functions", false, false) ModulePass *llvm
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:427
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:137
FunctionComparator - Compares two functions to determine whether or not they will generate machine co...
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:155
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:362
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:46
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:41
void copyAttributesFrom(const Function *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...
Definition: Function.cpp:621
This file contains the declarations for the subclasses of Constant, which represent the different fla...
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:229
#define H(x, y, z)
Definition: MD5.cpp:58
const Instruction & back() const
Definition: BasicBlock.h:310
void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on Value.
Definition: AsmWriter.cpp:4577
void setCallingConv(CallingConv::ID CC)
Definition: InstrTypes.h:1439
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
unsigned getStructNumElements() const
Definition: DerivedTypes.h:347
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:100
const Function * getFunction() const
Return the function this instruction belongs to.
Definition: Instruction.cpp:69
assume Assume Builder
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1742
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:161
void print(raw_ostream &OS, const Module *M=nullptr, bool IsForDebug=false) const
Print.
Definition: AsmWriter.cpp:4706
static cl::opt< bool > MergeFunctionsPDI("mergefunc-preserve-debug-info", cl::Hidden, cl::init(false), cl::desc("Preserve debug info in thunk when mergefunc " "transformations are made."))
Iterator for intrusive lists based on ilist_node.
static bool canCreateThunkFor(Function *F)
Whether this function may be replaced by a forwarding thunk.
bool isCallee(Value::const_user_iterator UI) const
Determine whether the passed iterator points to the callee operand's Use.
Definition: InstrTypes.h:1386
void setTailCall(bool IsTc=true)
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:350
iterator end()
Definition: BasicBlock.h:298
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:119
GlobalNumberState assigns an integer to each global value in the program, which is used by the compar...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1116
Module.h This file contains the declarations for the Module class.
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
Value handle that asserts if the Value is deleted.
Definition: ValueHandle.h:260
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
int compare()
Test whether the two functions have equivalent behaviour.
iterator_range< user_iterator > users()
Definition: Value.h:424
static cl::opt< bool > MergeFunctionsAliases("mergefunc-use-aliases", cl::Hidden, cl::init(false), cl::desc("Allow mergefunc to create aliases"))
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1171
use_iterator use_begin()
Definition: Value.h:363
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:295
SymbolTableList< BasicBlock >::iterator eraseFromParent()
Unlink 'this' from the containing function and delete it.
Definition: BasicBlock.cpp:129
#define I(x, y, z)
Definition: MD5.cpp:59
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:238
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Definition: InstrTypes.h:1458
int compare(DigitsT LDigits, int16_t LScale, DigitsT RDigits, int16_t RScale)
Compare two scaled numbers.
Definition: ScaledNumber.h:251
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void stable_sort(R &&Range)
Definition: STLExtras.h:1633
LLVM Value Representation.
Definition: Value.h:75
A container for analyses that lazily runs them and caches their results.
void pop_back()
Definition: ilist.h:318
#define LLVM_DEBUG(X)
Definition: Debug.h:122
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
Function object to check whether the first component of a std::pair compares less than the first comp...
Definition: STLExtras.h:1270
static GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)
If a parent module is specified, the alias is automatically inserted into the end of the specified mo...
Definition: Globals.cpp:485
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:271
bool isStructTy() const
True if this is an instance of StructType.
Definition: Type.h:223
an instruction to allocate memory on the stack
Definition: Instructions.h:61