From 4ef7eafa3f823443d1b8921f6020d946612281db Mon Sep 17 00:00:00 2001 From: Rafael Espindola Date: Thu, 25 Jul 2013 03:23:25 +0000 Subject: [PATCH] Respect llvm.used in Internalize. The language reference says that: "If a symbol appears in the @llvm.used list, then the compiler, assembler, and linker are required to treat the symbol as if there is a reference to the symbol that it cannot see" Since even the linker cannot see the reference, we must assume that the reference can be using the symbol table. For example, a user can add __attribute__((used)) to a debug helper function like dump and use it from a debugger. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@187103 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Transforms/Utils/ModuleUtils.h | 8 +++++++ lib/Transforms/IPO/GlobalOpt.cpp | 24 +++------------------ lib/Transforms/IPO/Internalize.cpp | 20 +++++++++++++++++ lib/Transforms/Utils/ModuleUtils.cpp | 18 ++++++++++++++++ test/Transforms/Internalize/used.ll | 20 +++++++++++++++++ 5 files changed, 69 insertions(+), 21 deletions(-) create mode 100644 test/Transforms/Internalize/used.ll diff --git a/include/llvm/Transforms/Utils/ModuleUtils.h b/include/llvm/Transforms/Utils/ModuleUtils.h index bb7fc06bf53..98a19ed426a 100644 --- a/include/llvm/Transforms/Utils/ModuleUtils.h +++ b/include/llvm/Transforms/Utils/ModuleUtils.h @@ -18,6 +18,9 @@ namespace llvm { class Module; class Function; +class GlobalValue; +class GlobalVariable; +template class SmallPtrSet; /// Append F to the list of global ctors of module M with the given Priority. /// This wraps the function in the appropriate structure and stores it along @@ -28,6 +31,11 @@ void appendToGlobalCtors(Module &M, Function *F, int Priority); /// Same as appendToGlobalCtors(), but for global dtors. void appendToGlobalDtors(Module &M, Function *F, int Priority); +/// \brief Given "llvm.used" or "llvm.compiler.used" as a global name, collect +/// the initializer elements of that global in Set and return the global itself. +GlobalVariable *collectUsedGlobalVariables(Module &M, + SmallPtrSet &Set, + bool CompilerUsed); } // End llvm namespace #endif // LLVM_TRANSFORMS_UTILS_MODULEUTILS_H diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp index 20af15ed008..64cd515f673 100644 --- a/lib/Transforms/IPO/GlobalOpt.cpp +++ b/lib/Transforms/IPO/GlobalOpt.cpp @@ -38,6 +38,7 @@ #include "llvm/Support/MathExtras.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Target/TargetLibraryInfo.h" +#include "llvm/Transforms/Utils/ModuleUtils.h" #include using namespace llvm; @@ -3040,24 +3041,6 @@ bool GlobalOpt::OptimizeGlobalCtorsList(GlobalVariable *&GCL) { return true; } -/// \brief Given "llvm.used" or "llvm.compiler.used" as a global name, collect -/// the initializer elements of that global in Set and return the global itself. -static GlobalVariable * -collectUsedGlobalVariables(Module &M, const char *Name, - SmallPtrSet &Set) { - GlobalVariable *GV = M.getGlobalVariable(Name); - if (!GV || !GV->hasInitializer()) - return GV; - - const ConstantArray *Init = cast(GV->getInitializer()); - for (unsigned I = 0, E = Init->getNumOperands(); I != E; ++I) { - Value *Op = Init->getOperand(I); - GlobalValue *G = cast(Op->stripPointerCastsNoFollowAliases()); - Set.insert(G); - } - return GV; -} - static int compareNames(const void *A, const void *B) { const GlobalValue *VA = *reinterpret_cast(A); const GlobalValue *VB = *reinterpret_cast(B); @@ -3107,9 +3090,8 @@ class LLVMUsed { public: LLVMUsed(Module &M) { - UsedV = collectUsedGlobalVariables(M, "llvm.used", Used); - CompilerUsedV = - collectUsedGlobalVariables(M, "llvm.compiler.used", CompilerUsed); + UsedV = collectUsedGlobalVariables(M, Used, false); + CompilerUsedV = collectUsedGlobalVariables(M, CompilerUsed, true); } typedef SmallPtrSet::iterator iterator; iterator usedBegin() { return Used.begin(); } diff --git a/lib/Transforms/IPO/Internalize.cpp b/lib/Transforms/IPO/Internalize.cpp index 4bfab5b0afb..d56a06f8d6f 100644 --- a/lib/Transforms/IPO/Internalize.cpp +++ b/lib/Transforms/IPO/Internalize.cpp @@ -15,6 +15,7 @@ #define DEBUG_TYPE "internalize" #include "llvm/Transforms/IPO.h" +#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/Statistic.h" #include "llvm/Analysis/CallGraph.h" #include "llvm/IR/Module.h" @@ -22,6 +23,7 @@ #include "llvm/Support/CommandLine.h" #include "llvm/Support/Debug.h" #include "llvm/Support/raw_ostream.h" +#include "llvm/Transforms/Utils/ModuleUtils.h" #include #include using namespace llvm; @@ -117,6 +119,24 @@ bool InternalizePass::runOnModule(Module &M) { // type of call-back in CodeGen. ExternalNames.insert("__stack_chk_fail"); + SmallPtrSet Used; + collectUsedGlobalVariables(M, Used, false); + + // We must assume that globals in llvm.used have a reference that not even + // the linker can see, so we don't internalize them. + // For llvm.compiler.used the situation is a bit fuzzy. The assembler and + // linker can drop those symbols. If this pass is running as part of LTO, + // one might think that it could just drop llvm.compiler.used. The problem + // is that even in LTO llvm doesn't see every reference. For example, + // we don't see references from function local inline assembly. To be + // conservative, we internalize symbols in llvm.compiler.used, but we + // keep llvm.compiler.used so that the symbol is not deleted by llvm. + for (SmallPtrSet::iterator I = Used.begin(), E = Used.end(); + I != E; ++I) { + GlobalValue *V = *I; + ExternalNames.insert(V->getName()); + } + // Mark all functions not in the api as internal. // FIXME: maybe use private linkage? for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) diff --git a/lib/Transforms/Utils/ModuleUtils.cpp b/lib/Transforms/Utils/ModuleUtils.cpp index d090b487213..ff6e6f9c60d 100644 --- a/lib/Transforms/Utils/ModuleUtils.cpp +++ b/lib/Transforms/Utils/ModuleUtils.cpp @@ -12,6 +12,7 @@ //===----------------------------------------------------------------------===// #include "llvm/Transforms/Utils/ModuleUtils.h" +#include "llvm/ADT/SmallPtrSet.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/Function.h" #include "llvm/IR/IRBuilder.h" @@ -62,3 +63,20 @@ void llvm::appendToGlobalCtors(Module &M, Function *F, int Priority) { void llvm::appendToGlobalDtors(Module &M, Function *F, int Priority) { appendToGlobalArray("llvm.global_dtors", M, F, Priority); } + +GlobalVariable * +llvm::collectUsedGlobalVariables(Module &M, SmallPtrSet &Set, + bool CompilerUsed) { + const char *Name = CompilerUsed ? "llvm.compiler.used" : "llvm.used"; + GlobalVariable *GV = M.getGlobalVariable(Name); + if (!GV || !GV->hasInitializer()) + return GV; + + const ConstantArray *Init = cast(GV->getInitializer()); + for (unsigned I = 0, E = Init->getNumOperands(); I != E; ++I) { + Value *Op = Init->getOperand(I); + GlobalValue *G = cast(Op->stripPointerCastsNoFollowAliases()); + Set.insert(G); + } + return GV; +} diff --git a/test/Transforms/Internalize/used.ll b/test/Transforms/Internalize/used.ll new file mode 100644 index 00000000000..85b85acd508 --- /dev/null +++ b/test/Transforms/Internalize/used.ll @@ -0,0 +1,20 @@ +; RUN: opt < %s -internalize -S | FileCheck %s + +@llvm.used = appending global [1 x void ()*] [void ()* @f], section "llvm.metadata" + +@llvm.compiler.used = appending global [1 x void ()*] [void ()* @g], section "llvm.metadata" + +; CHECK: define void @f() +define void @f() { + ret void +} + +; CHECK: define internal void @g() +define void @g() { + ret void +} + +; CHECK: define internal void @h() +define void @h() { + ret void +} -- 2.34.1