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/Transforms/IPO/MergeFunctions.h"
92#include "llvm/ADT/ArrayRef.h"
93#include "llvm/ADT/SmallVector.h"
94#include "llvm/ADT/Statistic.h"
95#include "llvm/IR/Argument.h"
96#include "llvm/IR/BasicBlock.h"
97#include "llvm/IR/Constant.h"
98#include "llvm/IR/Constants.h"
99#include "llvm/IR/DebugInfoMetadata.h"
100#include "llvm/IR/DebugLoc.h"
101#include "llvm/IR/DerivedTypes.h"
102#include "llvm/IR/Function.h"
103#include "llvm/IR/GlobalValue.h"
104#include "llvm/IR/IRBuilder.h"
105#include "llvm/IR/InstrTypes.h"
106#include "llvm/IR/Instruction.h"
107#include "llvm/IR/Instructions.h"
108#include "llvm/IR/IntrinsicInst.h"
109#include "llvm/IR/Module.h"
110#include "llvm/IR/StructuralHash.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/Support/Casting.h"
117#include "llvm/Support/CommandLine.h"
118#include "llvm/Support/Debug.h"
119#include "llvm/Support/raw_ostream.h"
120#include "llvm/Transforms/IPO.h"
121#include "llvm/Transforms/Utils/FunctionComparator.h"
122#include "llvm/Transforms/Utils/ModuleUtils.h"
123#include <algorithm>
124#include <cassert>
125#include <iterator>
126#include <set>
127#include <utility>
128#include <vector>
129
130using namespace llvm;
131
132#define DEBUG_TYPE "mergefunc"
133
134STATISTIC(NumFunctionsMerged, "Number of functions merged");
135STATISTIC(NumThunksWritten, "Number of thunks generated");
136STATISTIC(NumAliasesWritten, "Number of aliases generated");
137STATISTIC(NumDoubleWeak, "Number of new functions created");
138
139static cl::opt<unsigned> NumFunctionsForVerificationCheck(
140 "mergefunc-verify",
141 cl::desc("How many functions in a module could be used for "
142 "MergeFunctions to pass a basic correctness check. "
143 "'0' disables this check. Works only with '-debug' key."),
144 cl::init(Val: 0), cl::Hidden);
145
146// Under option -mergefunc-preserve-debug-info we:
147// - Do not create a new function for a thunk.
148// - Retain the debug info for a thunk's parameters (and associated
149// instructions for the debug info) from the entry block.
150// Note: -debug will display the algorithm at work.
151// - Create debug-info for the call (to the shared implementation) made by
152// a thunk and its return value.
153// - Erase the rest of the function, retaining the (minimally sized) entry
154// block to create a thunk.
155// - Preserve a thunk's call site to point to the thunk even when both occur
156// within the same translation unit, to aid debugability. Note that this
157// behaviour differs from the underlying -mergefunc implementation which
158// modifies the thunk's call site to point to the shared implementation
159// when both occur within the same translation unit.
160static cl::opt<bool>
161 MergeFunctionsPDI("mergefunc-preserve-debug-info", cl::Hidden,
162 cl::init(Val: false),
163 cl::desc("Preserve debug info in thunk when mergefunc "
164 "transformations are made."));
165
166static cl::opt<bool>
167 MergeFunctionsAliases("mergefunc-use-aliases", cl::Hidden,
168 cl::init(Val: false),
169 cl::desc("Allow mergefunc to create aliases"));
170
171namespace {
172
173class FunctionNode {
174 mutable AssertingVH<Function> F;
175 IRHash Hash;
176
177public:
178 // Note the hash is recalculated potentially multiple times, but it is cheap.
179 FunctionNode(Function *F) : F(F), Hash(StructuralHash(F: *F)) {}
180
181 Function *getFunc() const { return F; }
182 IRHash getHash() const { return Hash; }
183
184 /// Replace the reference to the function F by the function G, assuming their
185 /// implementations are equal.
186 void replaceBy(Function *G) const {
187 F = G;
188 }
189};
190
191/// MergeFunctions finds functions which will generate identical machine code,
192/// by considering all pointer types to be equivalent. Once identified,
193/// MergeFunctions will fold them by replacing a call to one to a call to a
194/// bitcast of the other.
195class MergeFunctions {
196public:
197 MergeFunctions() : FnTree(FunctionNodeCmp(&GlobalNumbers)) {
198 }
199
200 bool runOnModule(Module &M);
201
202private:
203 // The function comparison operator is provided here so that FunctionNodes do
204 // not need to become larger with another pointer.
205 class FunctionNodeCmp {
206 GlobalNumberState* GlobalNumbers;
207
208 public:
209 FunctionNodeCmp(GlobalNumberState* GN) : GlobalNumbers(GN) {}
210
211 bool operator()(const FunctionNode &LHS, const FunctionNode &RHS) const {
212 // Order first by hashes, then full function comparison.
213 if (LHS.getHash() != RHS.getHash())
214 return LHS.getHash() < RHS.getHash();
215 FunctionComparator FCmp(LHS.getFunc(), RHS.getFunc(), GlobalNumbers);
216 return FCmp.compare() < 0;
217 }
218 };
219 using FnTreeType = std::set<FunctionNode, FunctionNodeCmp>;
220
221 GlobalNumberState GlobalNumbers;
222
223 /// A work queue of functions that may have been modified and should be
224 /// analyzed again.
225 std::vector<WeakTrackingVH> Deferred;
226
227 /// Set of values marked as used in llvm.used and llvm.compiler.used.
228 SmallPtrSet<GlobalValue *, 4> Used;
229
230#ifndef NDEBUG
231 /// Checks the rules of order relation introduced among functions set.
232 /// Returns true, if check has been passed, and false if failed.
233 bool doFunctionalCheck(std::vector<WeakTrackingVH> &Worklist);
234#endif
235
236 /// Insert a ComparableFunction into the FnTree, or merge it away if it's
237 /// equal to one that's already present.
238 bool insert(Function *NewFunction);
239
240 /// Remove a Function from the FnTree and queue it up for a second sweep of
241 /// analysis.
242 void remove(Function *F);
243
244 /// Find the functions that use this Value and remove them from FnTree and
245 /// queue the functions.
246 void removeUsers(Value *V);
247
248 /// Replace all direct calls of Old with calls of New. Will bitcast New if
249 /// necessary to make types match.
250 void replaceDirectCallers(Function *Old, Function *New);
251
252 /// Merge two equivalent functions. Upon completion, G may be deleted, or may
253 /// be converted into a thunk. In either case, it should never be visited
254 /// again.
255 void mergeTwoFunctions(Function *F, Function *G);
256
257 /// Fill PDIUnrelatedWL with instructions from the entry block that are
258 /// unrelated to parameter related debug info.
259 /// \param PDVRUnrelatedWL The equivalent non-intrinsic debug records.
260 void
261 filterInstsUnrelatedToPDI(BasicBlock *GEntryBlock,
262 std::vector<Instruction *> &PDIUnrelatedWL,
263 std::vector<DbgVariableRecord *> &PDVRUnrelatedWL);
264
265 /// Erase the rest of the CFG (i.e. barring the entry block).
266 void eraseTail(Function *G);
267
268 /// Erase the instructions in PDIUnrelatedWL as they are unrelated to the
269 /// parameter debug info, from the entry block.
270 /// \param PDVRUnrelatedWL contains the equivalent set of non-instruction
271 /// debug-info records.
272 void
273 eraseInstsUnrelatedToPDI(std::vector<Instruction *> &PDIUnrelatedWL,
274 std::vector<DbgVariableRecord *> &PDVRUnrelatedWL);
275
276 /// Replace G with a simple tail call to bitcast(F). Also (unless
277 /// MergeFunctionsPDI holds) replace direct uses of G with bitcast(F),
278 /// delete G.
279 void writeThunk(Function *F, Function *G);
280
281 // Replace G with an alias to F (deleting function G)
282 void writeAlias(Function *F, Function *G);
283
284 // Replace G with an alias to F if possible, or a thunk to F if possible.
285 // Returns false if neither is the case.
286 bool writeThunkOrAlias(Function *F, Function *G);
287
288 /// Replace function F with function G in the function tree.
289 void replaceFunctionInTree(const FunctionNode &FN, Function *G);
290
291 /// The set of all distinct functions. Use the insert() and remove() methods
292 /// to modify it. The map allows efficient lookup and deferring of Functions.
293 FnTreeType FnTree;
294
295 // Map functions to the iterators of the FunctionNode which contains them
296 // in the FnTree. This must be updated carefully whenever the FnTree is
297 // modified, i.e. in insert(), remove(), and replaceFunctionInTree(), to avoid
298 // dangling iterators into FnTree. The invariant that preserves this is that
299 // there is exactly one mapping F -> FN for each FunctionNode FN in FnTree.
300 DenseMap<AssertingVH<Function>, FnTreeType::iterator> FNodesInTree;
301};
302} // end anonymous namespace
303
304PreservedAnalyses MergeFunctionsPass::run(Module &M,
305 ModuleAnalysisManager &AM) {
306 MergeFunctions MF;
307 if (!MF.runOnModule(M))
308 return PreservedAnalyses::all();
309 return PreservedAnalyses::none();
310}
311
312#ifndef NDEBUG
313bool MergeFunctions::doFunctionalCheck(std::vector<WeakTrackingVH> &Worklist) {
314 if (const unsigned Max = NumFunctionsForVerificationCheck) {
315 unsigned TripleNumber = 0;
316 bool Valid = true;
317
318 dbgs() << "MERGEFUNC-VERIFY: Started for first " << Max << " functions.\n";
319
320 unsigned i = 0;
321 for (std::vector<WeakTrackingVH>::iterator I = Worklist.begin(),
322 E = Worklist.end();
323 I != E && i < Max; ++I, ++i) {
324 unsigned j = i;
325 for (std::vector<WeakTrackingVH>::iterator J = I; J != E && j < Max;
326 ++J, ++j) {
327 Function *F1 = cast<Function>(*I);
328 Function *F2 = cast<Function>(*J);
329 int Res1 = FunctionComparator(F1, F2, &GlobalNumbers).compare();
330 int Res2 = FunctionComparator(F2, F1, &GlobalNumbers).compare();
331
332 // If F1 <= F2, then F2 >= F1, otherwise report failure.
333 if (Res1 != -Res2) {
334 dbgs() << "MERGEFUNC-VERIFY: Non-symmetric; triple: " << TripleNumber
335 << "\n";
336 dbgs() << *F1 << '\n' << *F2 << '\n';
337 Valid = false;
338 }
339
340 if (Res1 == 0)
341 continue;
342
343 unsigned k = j;
344 for (std::vector<WeakTrackingVH>::iterator K = J; K != E && k < Max;
345 ++k, ++K, ++TripleNumber) {
346 if (K == J)
347 continue;
348
349 Function *F3 = cast<Function>(*K);
350 int Res3 = FunctionComparator(F1, F3, &GlobalNumbers).compare();
351 int Res4 = FunctionComparator(F2, F3, &GlobalNumbers).compare();
352
353 bool Transitive = true;
354
355 if (Res1 != 0 && Res1 == Res4) {
356 // F1 > F2, F2 > F3 => F1 > F3
357 Transitive = Res3 == Res1;
358 } else if (Res3 != 0 && Res3 == -Res4) {
359 // F1 > F3, F3 > F2 => F1 > F2
360 Transitive = Res3 == Res1;
361 } else if (Res4 != 0 && -Res3 == Res4) {
362 // F2 > F3, F3 > F1 => F2 > F1
363 Transitive = Res4 == -Res1;
364 }
365
366 if (!Transitive) {
367 dbgs() << "MERGEFUNC-VERIFY: Non-transitive; triple: "
368 << TripleNumber << "\n";
369 dbgs() << "Res1, Res3, Res4: " << Res1 << ", " << Res3 << ", "
370 << Res4 << "\n";
371 dbgs() << *F1 << '\n' << *F2 << '\n' << *F3 << '\n';
372 Valid = false;
373 }
374 }
375 }
376 }
377
378 dbgs() << "MERGEFUNC-VERIFY: " << (Valid ? "Passed." : "Failed.") << "\n";
379 return Valid;
380 }
381 return true;
382}
383#endif
384
385/// Check whether \p F has an intrinsic which references
386/// distinct metadata as an operand. The most common
387/// instance of this would be CFI checks for function-local types.
388static bool hasDistinctMetadataIntrinsic(const Function &F) {
389 for (const BasicBlock &BB : F) {
390 for (const Instruction &I : BB.instructionsWithoutDebug()) {
391 if (!isa<IntrinsicInst>(Val: &I))
392 continue;
393
394 for (Value *Op : I.operands()) {
395 auto *MDL = dyn_cast<MetadataAsValue>(Val: Op);
396 if (!MDL)
397 continue;
398 if (MDNode *N = dyn_cast<MDNode>(Val: MDL->getMetadata()))
399 if (N->isDistinct())
400 return true;
401 }
402 }
403 }
404 return false;
405}
406
407/// Check whether \p F is eligible for function merging.
408static bool isEligibleForMerging(Function &F) {
409 return !F.isDeclaration() && !F.hasAvailableExternallyLinkage() &&
410 !hasDistinctMetadataIntrinsic(F);
411}
412
413bool MergeFunctions::runOnModule(Module &M) {
414 bool Changed = false;
415
416 SmallVector<GlobalValue *, 4> UsedV;
417 collectUsedGlobalVariables(M, Vec&: UsedV, /*CompilerUsed=*/false);
418 collectUsedGlobalVariables(M, Vec&: UsedV, /*CompilerUsed=*/true);
419 Used.insert(I: UsedV.begin(), E: UsedV.end());
420
421 // All functions in the module, ordered by hash. Functions with a unique
422 // hash value are easily eliminated.
423 std::vector<std::pair<IRHash, Function *>> HashedFuncs;
424 for (Function &Func : M) {
425 if (isEligibleForMerging(F&: Func)) {
426 HashedFuncs.push_back(x: {StructuralHash(F: Func), &Func});
427 }
428 }
429
430 llvm::stable_sort(Range&: HashedFuncs, C: less_first());
431
432 auto S = HashedFuncs.begin();
433 for (auto I = HashedFuncs.begin(), IE = HashedFuncs.end(); I != IE; ++I) {
434 // If the hash value matches the previous value or the next one, we must
435 // consider merging it. Otherwise it is dropped and never considered again.
436 if ((I != S && std::prev(x: I)->first == I->first) ||
437 (std::next(x: I) != IE && std::next(x: I)->first == I->first) ) {
438 Deferred.push_back(x: WeakTrackingVH(I->second));
439 }
440 }
441
442 do {
443 std::vector<WeakTrackingVH> Worklist;
444 Deferred.swap(x&: Worklist);
445
446 LLVM_DEBUG(doFunctionalCheck(Worklist));
447
448 LLVM_DEBUG(dbgs() << "size of module: " << M.size() << '\n');
449 LLVM_DEBUG(dbgs() << "size of worklist: " << Worklist.size() << '\n');
450
451 // Insert functions and merge them.
452 for (WeakTrackingVH &I : Worklist) {
453 if (!I)
454 continue;
455 Function *F = cast<Function>(Val&: I);
456 if (!F->isDeclaration() && !F->hasAvailableExternallyLinkage()) {
457 Changed |= insert(NewFunction: F);
458 }
459 }
460 LLVM_DEBUG(dbgs() << "size of FnTree: " << FnTree.size() << '\n');
461 } while (!Deferred.empty());
462
463 FnTree.clear();
464 FNodesInTree.clear();
465 GlobalNumbers.clear();
466 Used.clear();
467
468 return Changed;
469}
470
471// Replace direct callers of Old with New.
472void MergeFunctions::replaceDirectCallers(Function *Old, Function *New) {
473 for (Use &U : llvm::make_early_inc_range(Range: Old->uses())) {
474 CallBase *CB = dyn_cast<CallBase>(Val: U.getUser());
475 if (CB && CB->isCallee(U: &U)) {
476 // Do not copy attributes from the called function to the call-site.
477 // Function comparison ensures that the attributes are the same up to
478 // type congruences in byval(), in which case we need to keep the byval
479 // type of the call-site, not the callee function.
480 remove(F: CB->getFunction());
481 U.set(New);
482 }
483 }
484}
485
486// Helper for writeThunk,
487// Selects proper bitcast operation,
488// but a bit simpler then CastInst::getCastOpcode.
489static Value *createCast(IRBuilder<> &Builder, Value *V, Type *DestTy) {
490 Type *SrcTy = V->getType();
491 if (SrcTy->isStructTy()) {
492 assert(DestTy->isStructTy());
493 assert(SrcTy->getStructNumElements() == DestTy->getStructNumElements());
494 Value *Result = PoisonValue::get(T: DestTy);
495 for (unsigned int I = 0, E = SrcTy->getStructNumElements(); I < E; ++I) {
496 Value *Element =
497 createCast(Builder, V: Builder.CreateExtractValue(Agg: V, Idxs: ArrayRef(I)),
498 DestTy: DestTy->getStructElementType(N: I));
499
500 Result = Builder.CreateInsertValue(Agg: Result, Val: Element, Idxs: ArrayRef(I));
501 }
502 return Result;
503 }
504 assert(!DestTy->isStructTy());
505 if (SrcTy->isIntegerTy() && DestTy->isPointerTy())
506 return Builder.CreateIntToPtr(V, DestTy);
507 else if (SrcTy->isPointerTy() && DestTy->isIntegerTy())
508 return Builder.CreatePtrToInt(V, DestTy);
509 else
510 return Builder.CreateBitCast(V, DestTy);
511}
512
513// Erase the instructions in PDIUnrelatedWL as they are unrelated to the
514// parameter debug info, from the entry block.
515void MergeFunctions::eraseInstsUnrelatedToPDI(
516 std::vector<Instruction *> &PDIUnrelatedWL,
517 std::vector<DbgVariableRecord *> &PDVRUnrelatedWL) {
518 LLVM_DEBUG(
519 dbgs() << " Erasing instructions (in reverse order of appearance in "
520 "entry block) unrelated to parameter debug info from entry "
521 "block: {\n");
522 while (!PDIUnrelatedWL.empty()) {
523 Instruction *I = PDIUnrelatedWL.back();
524 LLVM_DEBUG(dbgs() << " Deleting Instruction: ");
525 LLVM_DEBUG(I->print(dbgs()));
526 LLVM_DEBUG(dbgs() << "\n");
527 I->eraseFromParent();
528 PDIUnrelatedWL.pop_back();
529 }
530
531 while (!PDVRUnrelatedWL.empty()) {
532 DbgVariableRecord *DVR = PDVRUnrelatedWL.back();
533 LLVM_DEBUG(dbgs() << " Deleting DbgVariableRecord ");
534 LLVM_DEBUG(DVR->print(dbgs()));
535 LLVM_DEBUG(dbgs() << "\n");
536 DVR->eraseFromParent();
537 PDVRUnrelatedWL.pop_back();
538 }
539
540 LLVM_DEBUG(dbgs() << " } // Done erasing instructions unrelated to parameter "
541 "debug info from entry block. \n");
542}
543
544// Reduce G to its entry block.
545void MergeFunctions::eraseTail(Function *G) {
546 std::vector<BasicBlock *> WorklistBB;
547 for (BasicBlock &BB : drop_begin(RangeOrContainer&: *G)) {
548 BB.dropAllReferences();
549 WorklistBB.push_back(x: &BB);
550 }
551 while (!WorklistBB.empty()) {
552 BasicBlock *BB = WorklistBB.back();
553 BB->eraseFromParent();
554 WorklistBB.pop_back();
555 }
556}
557
558// We are interested in the following instructions from the entry block as being
559// related to parameter debug info:
560// - @llvm.dbg.declare
561// - stores from the incoming parameters to locations on the stack-frame
562// - allocas that create these locations on the stack-frame
563// - @llvm.dbg.value
564// - the entry block's terminator
565// The rest are unrelated to debug info for the parameters; fill up
566// PDIUnrelatedWL with such instructions.
567void MergeFunctions::filterInstsUnrelatedToPDI(
568 BasicBlock *GEntryBlock, std::vector<Instruction *> &PDIUnrelatedWL,
569 std::vector<DbgVariableRecord *> &PDVRUnrelatedWL) {
570 std::set<Instruction *> PDIRelated;
571 std::set<DbgVariableRecord *> PDVRRelated;
572
573 // Work out whether a dbg.value intrinsic or an equivalent DbgVariableRecord
574 // is a parameter to be preserved.
575 auto ExamineDbgValue = [](auto *DbgVal, auto &Container) {
576 LLVM_DEBUG(dbgs() << " Deciding: ");
577 LLVM_DEBUG(DbgVal->print(dbgs()));
578 LLVM_DEBUG(dbgs() << "\n");
579 DILocalVariable *DILocVar = DbgVal->getVariable();
580 if (DILocVar->isParameter()) {
581 LLVM_DEBUG(dbgs() << " Include (parameter): ");
582 LLVM_DEBUG(DbgVal->print(dbgs()));
583 LLVM_DEBUG(dbgs() << "\n");
584 Container.insert(DbgVal);
585 } else {
586 LLVM_DEBUG(dbgs() << " Delete (!parameter): ");
587 LLVM_DEBUG(DbgVal->print(dbgs()));
588 LLVM_DEBUG(dbgs() << "\n");
589 }
590 };
591
592 auto ExamineDbgDeclare = [&PDIRelated](auto *DbgDecl, auto &Container) {
593 LLVM_DEBUG(dbgs() << " Deciding: ");
594 LLVM_DEBUG(DbgDecl->print(dbgs()));
595 LLVM_DEBUG(dbgs() << "\n");
596 DILocalVariable *DILocVar = DbgDecl->getVariable();
597 if (DILocVar->isParameter()) {
598 LLVM_DEBUG(dbgs() << " Parameter: ");
599 LLVM_DEBUG(DILocVar->print(dbgs()));
600 AllocaInst *AI = dyn_cast_or_null<AllocaInst>(DbgDecl->getAddress());
601 if (AI) {
602 LLVM_DEBUG(dbgs() << " Processing alloca users: ");
603 LLVM_DEBUG(dbgs() << "\n");
604 for (User *U : AI->users()) {
605 if (StoreInst *SI = dyn_cast<StoreInst>(Val: U)) {
606 if (Value *Arg = SI->getValueOperand()) {
607 if (isa<Argument>(Val: Arg)) {
608 LLVM_DEBUG(dbgs() << " Include: ");
609 LLVM_DEBUG(AI->print(dbgs()));
610 LLVM_DEBUG(dbgs() << "\n");
611 PDIRelated.insert(x: AI);
612 LLVM_DEBUG(dbgs() << " Include (parameter): ");
613 LLVM_DEBUG(SI->print(dbgs()));
614 LLVM_DEBUG(dbgs() << "\n");
615 PDIRelated.insert(x: SI);
616 LLVM_DEBUG(dbgs() << " Include: ");
617 LLVM_DEBUG(DbgDecl->print(dbgs()));
618 LLVM_DEBUG(dbgs() << "\n");
619 Container.insert(DbgDecl);
620 } else {
621 LLVM_DEBUG(dbgs() << " Delete (!parameter): ");
622 LLVM_DEBUG(SI->print(dbgs()));
623 LLVM_DEBUG(dbgs() << "\n");
624 }
625 }
626 } else {
627 LLVM_DEBUG(dbgs() << " Defer: ");
628 LLVM_DEBUG(U->print(dbgs()));
629 LLVM_DEBUG(dbgs() << "\n");
630 }
631 }
632 } else {
633 LLVM_DEBUG(dbgs() << " Delete (alloca NULL): ");
634 LLVM_DEBUG(DbgDecl->print(dbgs()));
635 LLVM_DEBUG(dbgs() << "\n");
636 }
637 } else {
638 LLVM_DEBUG(dbgs() << " Delete (!parameter): ");
639 LLVM_DEBUG(DbgDecl->print(dbgs()));
640 LLVM_DEBUG(dbgs() << "\n");
641 }
642 };
643
644 for (BasicBlock::iterator BI = GEntryBlock->begin(), BIE = GEntryBlock->end();
645 BI != BIE; ++BI) {
646 // Examine DbgVariableRecords as they happen "before" the instruction. Are
647 // they connected to parameters?
648 for (DbgVariableRecord &DVR : filterDbgVars(R: BI->getDbgRecordRange())) {
649 if (DVR.isDbgValue() || DVR.isDbgAssign()) {
650 ExamineDbgValue(&DVR, PDVRRelated);
651 } else {
652 assert(DVR.isDbgDeclare());
653 ExamineDbgDeclare(&DVR, PDVRRelated);
654 }
655 }
656
657 if (auto *DVI = dyn_cast<DbgValueInst>(Val: &*BI)) {
658 ExamineDbgValue(DVI, PDIRelated);
659 } else if (auto *DDI = dyn_cast<DbgDeclareInst>(Val: &*BI)) {
660 ExamineDbgDeclare(DDI, PDIRelated);
661 } else if (BI->isTerminator() && &*BI == GEntryBlock->getTerminator()) {
662 LLVM_DEBUG(dbgs() << " Will Include Terminator: ");
663 LLVM_DEBUG(BI->print(dbgs()));
664 LLVM_DEBUG(dbgs() << "\n");
665 PDIRelated.insert(x: &*BI);
666 } else {
667 LLVM_DEBUG(dbgs() << " Defer: ");
668 LLVM_DEBUG(BI->print(dbgs()));
669 LLVM_DEBUG(dbgs() << "\n");
670 }
671 }
672 LLVM_DEBUG(
673 dbgs()
674 << " Report parameter debug info related/related instructions: {\n");
675
676 auto IsPDIRelated = [](auto *Rec, auto &Container, auto &UnrelatedCont) {
677 if (Container.find(Rec) == Container.end()) {
678 LLVM_DEBUG(dbgs() << " !PDIRelated: ");
679 LLVM_DEBUG(Rec->print(dbgs()));
680 LLVM_DEBUG(dbgs() << "\n");
681 UnrelatedCont.push_back(Rec);
682 } else {
683 LLVM_DEBUG(dbgs() << " PDIRelated: ");
684 LLVM_DEBUG(Rec->print(dbgs()));
685 LLVM_DEBUG(dbgs() << "\n");
686 }
687 };
688
689 // Collect the set of unrelated instructions and debug records.
690 for (Instruction &I : *GEntryBlock) {
691 for (DbgVariableRecord &DVR : filterDbgVars(R: I.getDbgRecordRange()))
692 IsPDIRelated(&DVR, PDVRRelated, PDVRUnrelatedWL);
693 IsPDIRelated(&I, PDIRelated, PDIUnrelatedWL);
694 }
695 LLVM_DEBUG(dbgs() << " }\n");
696}
697
698/// Whether this function may be replaced by a forwarding thunk.
699static bool canCreateThunkFor(Function *F) {
700 if (F->isVarArg())
701 return false;
702
703 // Don't merge tiny functions using a thunk, since it can just end up
704 // making the function larger.
705 if (F->size() == 1) {
706 if (F->front().sizeWithoutDebug() < 2) {
707 LLVM_DEBUG(dbgs() << "canCreateThunkFor: " << F->getName()
708 << " is too small to bother creating a thunk for\n");
709 return false;
710 }
711 }
712 return true;
713}
714
715/// Copy all metadata of a specific kind from one function to another.
716static void copyMetadataIfPresent(Function *From, Function *To,
717 StringRef Kind) {
718 SmallVector<MDNode *, 4> MDs;
719 From->getMetadata(Kind, MDs);
720 for (MDNode *MD : MDs)
721 To->addMetadata(Kind, MD&: *MD);
722}
723
724// Replace G with a simple tail call to bitcast(F). Also (unless
725// MergeFunctionsPDI holds) replace direct uses of G with bitcast(F),
726// delete G. Under MergeFunctionsPDI, we use G itself for creating
727// the thunk as we preserve the debug info (and associated instructions)
728// from G's entry block pertaining to G's incoming arguments which are
729// passed on as corresponding arguments in the call that G makes to F.
730// For better debugability, under MergeFunctionsPDI, we do not modify G's
731// call sites to point to F even when within the same translation unit.
732void MergeFunctions::writeThunk(Function *F, Function *G) {
733 BasicBlock *GEntryBlock = nullptr;
734 std::vector<Instruction *> PDIUnrelatedWL;
735 std::vector<DbgVariableRecord *> PDVRUnrelatedWL;
736 BasicBlock *BB = nullptr;
737 Function *NewG = nullptr;
738 if (MergeFunctionsPDI) {
739 LLVM_DEBUG(dbgs() << "writeThunk: (MergeFunctionsPDI) Do not create a new "
740 "function as thunk; retain original: "
741 << G->getName() << "()\n");
742 GEntryBlock = &G->getEntryBlock();
743 LLVM_DEBUG(
744 dbgs() << "writeThunk: (MergeFunctionsPDI) filter parameter related "
745 "debug info for "
746 << G->getName() << "() {\n");
747 filterInstsUnrelatedToPDI(GEntryBlock, PDIUnrelatedWL, PDVRUnrelatedWL);
748 GEntryBlock->getTerminator()->eraseFromParent();
749 BB = GEntryBlock;
750 } else {
751 NewG = Function::Create(Ty: G->getFunctionType(), Linkage: G->getLinkage(),
752 AddrSpace: G->getAddressSpace(), N: "", M: G->getParent());
753 NewG->setComdat(G->getComdat());
754 NewG->IsNewDbgInfoFormat = G->IsNewDbgInfoFormat;
755 BB = BasicBlock::Create(Context&: F->getContext(), Name: "", Parent: NewG);
756 }
757
758 IRBuilder<> Builder(BB);
759 Function *H = MergeFunctionsPDI ? G : NewG;
760 SmallVector<Value *, 16> Args;
761 unsigned i = 0;
762 FunctionType *FFTy = F->getFunctionType();
763 for (Argument &AI : H->args()) {
764 Args.push_back(Elt: createCast(Builder, V: &AI, DestTy: FFTy->getParamType(i)));
765 ++i;
766 }
767
768 CallInst *CI = Builder.CreateCall(Callee: F, Args);
769 ReturnInst *RI = nullptr;
770 bool isSwiftTailCall = F->getCallingConv() == CallingConv::SwiftTail &&
771 G->getCallingConv() == CallingConv::SwiftTail;
772 CI->setTailCallKind(isSwiftTailCall ? llvm::CallInst::TCK_MustTail
773 : llvm::CallInst::TCK_Tail);
774 CI->setCallingConv(F->getCallingConv());
775 CI->setAttributes(F->getAttributes());
776 if (H->getReturnType()->isVoidTy()) {
777 RI = Builder.CreateRetVoid();
778 } else {
779 RI = Builder.CreateRet(V: createCast(Builder, V: CI, DestTy: H->getReturnType()));
780 }
781
782 if (MergeFunctionsPDI) {
783 DISubprogram *DIS = G->getSubprogram();
784 if (DIS) {
785 DebugLoc CIDbgLoc =
786 DILocation::get(Context&: DIS->getContext(), Line: DIS->getScopeLine(), Column: 0, Scope: DIS);
787 DebugLoc RIDbgLoc =
788 DILocation::get(Context&: DIS->getContext(), Line: DIS->getScopeLine(), Column: 0, Scope: DIS);
789 CI->setDebugLoc(CIDbgLoc);
790 RI->setDebugLoc(RIDbgLoc);
791 } else {
792 LLVM_DEBUG(
793 dbgs() << "writeThunk: (MergeFunctionsPDI) No DISubprogram for "
794 << G->getName() << "()\n");
795 }
796 eraseTail(G);
797 eraseInstsUnrelatedToPDI(PDIUnrelatedWL, PDVRUnrelatedWL);
798 LLVM_DEBUG(
799 dbgs() << "} // End of parameter related debug info filtering for: "
800 << G->getName() << "()\n");
801 } else {
802 NewG->copyAttributesFrom(Src: G);
803 NewG->takeName(V: G);
804 // Ensure CFI type metadata is propagated to the new function.
805 copyMetadataIfPresent(From: G, To: NewG, Kind: "type");
806 copyMetadataIfPresent(From: G, To: NewG, Kind: "kcfi_type");
807 removeUsers(V: G);
808 G->replaceAllUsesWith(V: NewG);
809 G->eraseFromParent();
810 }
811
812 LLVM_DEBUG(dbgs() << "writeThunk: " << H->getName() << '\n');
813 ++NumThunksWritten;
814}
815
816// Whether this function may be replaced by an alias
817static bool canCreateAliasFor(Function *F) {
818 if (!MergeFunctionsAliases || !F->hasGlobalUnnamedAddr())
819 return false;
820
821 // We should only see linkages supported by aliases here
822 assert(F->hasLocalLinkage() || F->hasExternalLinkage()
823 || F->hasWeakLinkage() || F->hasLinkOnceLinkage());
824 return true;
825}
826
827// Replace G with an alias to F (deleting function G)
828void MergeFunctions::writeAlias(Function *F, Function *G) {
829 PointerType *PtrType = G->getType();
830 auto *GA = GlobalAlias::create(Ty: G->getValueType(), AddressSpace: PtrType->getAddressSpace(),
831 Linkage: G->getLinkage(), Name: "", Aliasee: F, Parent: G->getParent());
832
833 const MaybeAlign FAlign = F->getAlign();
834 const MaybeAlign GAlign = G->getAlign();
835 if (FAlign || GAlign)
836 F->setAlignment(std::max(a: FAlign.valueOrOne(), b: GAlign.valueOrOne()));
837 else
838 F->setAlignment(std::nullopt);
839 GA->takeName(V: G);
840 GA->setVisibility(G->getVisibility());
841 GA->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
842
843 removeUsers(V: G);
844 G->replaceAllUsesWith(V: GA);
845 G->eraseFromParent();
846
847 LLVM_DEBUG(dbgs() << "writeAlias: " << GA->getName() << '\n');
848 ++NumAliasesWritten;
849}
850
851// Replace G with an alias to F if possible, or a thunk to F if
852// profitable. Returns false if neither is the case.
853bool MergeFunctions::writeThunkOrAlias(Function *F, Function *G) {
854 if (canCreateAliasFor(F: G)) {
855 writeAlias(F, G);
856 return true;
857 }
858 if (canCreateThunkFor(F)) {
859 writeThunk(F, G);
860 return true;
861 }
862 return false;
863}
864
865// Merge two equivalent functions. Upon completion, Function G is deleted.
866void MergeFunctions::mergeTwoFunctions(Function *F, Function *G) {
867 if (F->isInterposable()) {
868 assert(G->isInterposable());
869
870 // Both writeThunkOrAlias() calls below must succeed, either because we can
871 // create aliases for G and NewF, or because a thunk for F is profitable.
872 // F here has the same signature as NewF below, so that's what we check.
873 if (!canCreateThunkFor(F) &&
874 (!canCreateAliasFor(F) || !canCreateAliasFor(F: G)))
875 return;
876
877 // Make them both thunks to the same internal function.
878 Function *NewF = Function::Create(Ty: F->getFunctionType(), Linkage: F->getLinkage(),
879 AddrSpace: F->getAddressSpace(), N: "", M: F->getParent());
880 NewF->copyAttributesFrom(Src: F);
881 NewF->takeName(V: F);
882 NewF->IsNewDbgInfoFormat = F->IsNewDbgInfoFormat;
883 // Ensure CFI type metadata is propagated to the new function.
884 copyMetadataIfPresent(From: F, To: NewF, Kind: "type");
885 copyMetadataIfPresent(From: F, To: NewF, Kind: "kcfi_type");
886 removeUsers(V: F);
887 F->replaceAllUsesWith(V: NewF);
888
889 // We collect alignment before writeThunkOrAlias that overwrites NewF and
890 // G's content.
891 const MaybeAlign NewFAlign = NewF->getAlign();
892 const MaybeAlign GAlign = G->getAlign();
893
894 writeThunkOrAlias(F, G);
895 writeThunkOrAlias(F, G: NewF);
896
897 if (NewFAlign || GAlign)
898 F->setAlignment(std::max(a: NewFAlign.valueOrOne(), b: GAlign.valueOrOne()));
899 else
900 F->setAlignment(std::nullopt);
901 F->setLinkage(GlobalValue::PrivateLinkage);
902 ++NumDoubleWeak;
903 ++NumFunctionsMerged;
904 } else {
905 // For better debugability, under MergeFunctionsPDI, we do not modify G's
906 // call sites to point to F even when within the same translation unit.
907 if (!G->isInterposable() && !MergeFunctionsPDI) {
908 // Functions referred to by llvm.used/llvm.compiler.used are special:
909 // there are uses of the symbol name that are not visible to LLVM,
910 // usually from inline asm.
911 if (G->hasGlobalUnnamedAddr() && !Used.contains(Ptr: G)) {
912 // G might have been a key in our GlobalNumberState, and it's illegal
913 // to replace a key in ValueMap<GlobalValue *> with a non-global.
914 GlobalNumbers.erase(Global: G);
915 // If G's address is not significant, replace it entirely.
916 removeUsers(V: G);
917 G->replaceAllUsesWith(V: F);
918 } else {
919 // Redirect direct callers of G to F. (See note on MergeFunctionsPDI
920 // above).
921 replaceDirectCallers(Old: G, New: F);
922 }
923 }
924
925 // If G was internal then we may have replaced all uses of G with F. If so,
926 // stop here and delete G. There's no need for a thunk. (See note on
927 // MergeFunctionsPDI above).
928 if (G->isDiscardableIfUnused() && G->use_empty() && !MergeFunctionsPDI) {
929 G->eraseFromParent();
930 ++NumFunctionsMerged;
931 return;
932 }
933
934 if (writeThunkOrAlias(F, G)) {
935 ++NumFunctionsMerged;
936 }
937 }
938}
939
940/// Replace function F by function G.
941void MergeFunctions::replaceFunctionInTree(const FunctionNode &FN,
942 Function *G) {
943 Function *F = FN.getFunc();
944 assert(FunctionComparator(F, G, &GlobalNumbers).compare() == 0 &&
945 "The two functions must be equal");
946
947 auto I = FNodesInTree.find(Val: F);
948 assert(I != FNodesInTree.end() && "F should be in FNodesInTree");
949 assert(FNodesInTree.count(G) == 0 && "FNodesInTree should not contain G");
950
951 FnTreeType::iterator IterToFNInFnTree = I->second;
952 assert(&(*IterToFNInFnTree) == &FN && "F should map to FN in FNodesInTree.");
953 // Remove F -> FN and insert G -> FN
954 FNodesInTree.erase(I);
955 FNodesInTree.insert(KV: {G, IterToFNInFnTree});
956 // Replace F with G in FN, which is stored inside the FnTree.
957 FN.replaceBy(G);
958}
959
960// Ordering for functions that are equal under FunctionComparator
961static bool isFuncOrderCorrect(const Function *F, const Function *G) {
962 if (F->isInterposable() != G->isInterposable()) {
963 // Strong before weak, because the weak function may call the strong
964 // one, but not the other way around.
965 return !F->isInterposable();
966 }
967 if (F->hasLocalLinkage() != G->hasLocalLinkage()) {
968 // External before local, because we definitely have to keep the external
969 // function, but may be able to drop the local one.
970 return !F->hasLocalLinkage();
971 }
972 // Impose a total order (by name) on the replacement of functions. This is
973 // important when operating on more than one module independently to prevent
974 // cycles of thunks calling each other when the modules are linked together.
975 return F->getName() <= G->getName();
976}
977
978// Insert a ComparableFunction into the FnTree, or merge it away if equal to one
979// that was already inserted.
980bool MergeFunctions::insert(Function *NewFunction) {
981 std::pair<FnTreeType::iterator, bool> Result =
982 FnTree.insert(x: FunctionNode(NewFunction));
983
984 if (Result.second) {
985 assert(FNodesInTree.count(NewFunction) == 0);
986 FNodesInTree.insert(KV: {NewFunction, Result.first});
987 LLVM_DEBUG(dbgs() << "Inserting as unique: " << NewFunction->getName()
988 << '\n');
989 return false;
990 }
991
992 const FunctionNode &OldF = *Result.first;
993
994 if (!isFuncOrderCorrect(F: OldF.getFunc(), G: NewFunction)) {
995 // Swap the two functions.
996 Function *F = OldF.getFunc();
997 replaceFunctionInTree(FN: *Result.first, G: NewFunction);
998 NewFunction = F;
999 assert(OldF.getFunc() != F && "Must have swapped the functions.");
1000 }
1001
1002 LLVM_DEBUG(dbgs() << " " << OldF.getFunc()->getName()
1003 << " == " << NewFunction->getName() << '\n');
1004
1005 Function *DeleteF = NewFunction;
1006 mergeTwoFunctions(F: OldF.getFunc(), G: DeleteF);
1007 return true;
1008}
1009
1010// Remove a function from FnTree. If it was already in FnTree, add
1011// it to Deferred so that we'll look at it in the next round.
1012void MergeFunctions::remove(Function *F) {
1013 auto I = FNodesInTree.find(Val: F);
1014 if (I != FNodesInTree.end()) {
1015 LLVM_DEBUG(dbgs() << "Deferred " << F->getName() << ".\n");
1016 FnTree.erase(position: I->second);
1017 // I->second has been invalidated, remove it from the FNodesInTree map to
1018 // preserve the invariant.
1019 FNodesInTree.erase(I);
1020 Deferred.emplace_back(args&: F);
1021 }
1022}
1023
1024// For each instruction used by the value, remove() the function that contains
1025// the instruction. This should happen right before a call to RAUW.
1026void MergeFunctions::removeUsers(Value *V) {
1027 for (User *U : V->users())
1028 if (auto *I = dyn_cast<Instruction>(Val: U))
1029 remove(F: I->getFunction());
1030}
1031