132 lines
4.8 KiB
C++
132 lines
4.8 KiB
C++
//===- ElimAvailExtern.cpp - DCE unreachable internal functions -----------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This transform is designed to eliminate available external global
|
|
// definitions from the program, turning them into declarations.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Transforms/IPO/ElimAvailExtern.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/ADT/Statistic.h"
|
|
#include "llvm/IR/Constant.h"
|
|
#include "llvm/IR/DebugInfoMetadata.h"
|
|
#include "llvm/IR/Function.h"
|
|
#include "llvm/IR/GlobalValue.h"
|
|
#include "llvm/IR/GlobalVariable.h"
|
|
#include "llvm/IR/MDBuilder.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
#include "llvm/Transforms/IPO.h"
|
|
#include "llvm/Transforms/Utils/GlobalStatus.h"
|
|
#include "llvm/Transforms/Utils/ModuleUtils.h"
|
|
|
|
using namespace llvm;
|
|
|
|
#define DEBUG_TYPE "elim-avail-extern"
|
|
|
|
cl::opt<bool> ConvertToLocal(
|
|
"avail-extern-to-local", cl::Hidden,
|
|
cl::desc("Convert available_externally into locals, renaming them "
|
|
"to avoid link-time clashes."));
|
|
|
|
STATISTIC(NumRemovals, "Number of functions removed");
|
|
STATISTIC(NumConversions, "Number of functions converted");
|
|
STATISTIC(NumVariables, "Number of global variables removed");
|
|
|
|
void deleteFunction(Function &F) {
|
|
// This will set the linkage to external
|
|
F.deleteBody();
|
|
++NumRemovals;
|
|
}
|
|
|
|
/// Create a copy of the thinlto import, mark it local, and redirect direct
|
|
/// calls to the copy. Only direct calls are replaced, so that e.g. indirect
|
|
/// call function pointer tests would use the global identity of the function.
|
|
///
|
|
/// Currently, Value Profiling ("VP") MD_prof data isn't updated to refer to the
|
|
/// clone's GUID (which will be different, because the name and linkage is
|
|
/// different), under the assumption that the last consumer of this data is
|
|
/// upstream the pipeline (e.g. ICP).
|
|
static void convertToLocalCopy(Module &M, Function &F) {
|
|
assert(F.hasAvailableExternallyLinkage());
|
|
assert(!F.isDeclaration());
|
|
// If we can't find a single use that's a call, just delete the function.
|
|
if (F.uses().end() == llvm::find_if(F.uses(), [&](Use &U) {
|
|
return isa<CallBase>(U.getUser());
|
|
}))
|
|
return deleteFunction(F);
|
|
|
|
auto OrigName = F.getName().str();
|
|
// Build a new name. We still need the old name (see below).
|
|
// We could just rely on internal linking allowing 2 modules have internal
|
|
// functions with the same name, but that just creates more trouble than
|
|
// necessary e.g. distinguishing profiles or debugging. Instead, we append the
|
|
// module identifier.
|
|
auto NewName = OrigName + ".__uniq" + getUniqueModuleId(&M);
|
|
F.setName(NewName);
|
|
if (auto *SP = F.getSubprogram())
|
|
SP->replaceLinkageName(MDString::get(F.getParent()->getContext(), NewName));
|
|
|
|
F.setLinkage(GlobalValue::InternalLinkage);
|
|
// Now make a declaration for the old name. We'll use it if there are non-call
|
|
// uses. For those, it would be incorrect to replace them with the local copy:
|
|
// for example, one such use could be taking the address of the function and
|
|
// passing it to an external function, which, in turn, might compare the
|
|
// function pointer to the original (non-local) function pointer, e.g. as part
|
|
// of indirect call promotion.
|
|
auto *Decl =
|
|
Function::Create(F.getFunctionType(), GlobalValue::ExternalLinkage,
|
|
F.getAddressSpace(), OrigName, F.getParent());
|
|
F.replaceUsesWithIf(Decl,
|
|
[&](Use &U) { return !isa<CallBase>(U.getUser()); });
|
|
++NumConversions;
|
|
}
|
|
|
|
static bool eliminateAvailableExternally(Module &M) {
|
|
bool Changed = false;
|
|
|
|
// Drop initializers of available externally global variables.
|
|
for (GlobalVariable &GV : M.globals()) {
|
|
if (!GV.hasAvailableExternallyLinkage())
|
|
continue;
|
|
if (GV.hasInitializer()) {
|
|
Constant *Init = GV.getInitializer();
|
|
GV.setInitializer(nullptr);
|
|
if (isSafeToDestroyConstant(Init))
|
|
Init->destroyConstant();
|
|
}
|
|
GV.removeDeadConstantUsers();
|
|
GV.setLinkage(GlobalValue::ExternalLinkage);
|
|
++NumVariables;
|
|
Changed = true;
|
|
}
|
|
|
|
// Drop the bodies of available externally functions.
|
|
for (Function &F : llvm::make_early_inc_range(M)) {
|
|
if (F.isDeclaration() || !F.hasAvailableExternallyLinkage())
|
|
continue;
|
|
|
|
if (ConvertToLocal)
|
|
convertToLocalCopy(M, F);
|
|
else
|
|
deleteFunction(F);
|
|
|
|
F.removeDeadConstantUsers();
|
|
Changed = true;
|
|
}
|
|
|
|
return Changed;
|
|
}
|
|
|
|
PreservedAnalyses
|
|
EliminateAvailableExternallyPass::run(Module &M, ModuleAnalysisManager &) {
|
|
if (!eliminateAvailableExternally(M))
|
|
return PreservedAnalyses::all();
|
|
return PreservedAnalyses::none();
|
|
}
|