* @{
*/
-#define LTO_API_VERSION 4
+#define LTO_API_VERSION 5
typedef enum {
LTO_SYMBOL_ALIGNMENT_MASK = 0x0000001F, /* log2 of alignment */
int nargs);
/**
- * Adds to a list of all global symbols that must exist in the final
- * generated code. If a function is not listed, it might be
- * inlined into every usage and optimized away.
+ * Tells LTO optimization passes that this symbol must be preserved
+ * because it is referenced by native code or a command line option.
*/
extern void
lto_codegen_add_must_preserve_symbol(lto_code_gen_t cg, const char* symbol);
+
+/**
+ * Tells LTO optimization passes that a dynamic shared library is being
+ * built and this symbol may be exported. Unless IR semantics allow the symbol
+ * to be made local to the library, it should remain so it can be exported by
+ * the shared library.
+ */
+extern void lto_codegen_add_dso_symbol(lto_code_gen_t cg, const char *symbol);
+
/**
* Writes a new object file at the specified path that contains the
* merged contents of all modules added so far.
void addMustPreserveSymbol(const char *sym) { MustPreserveSymbols[sym] = 1; }
+ void addDSOSymbol(const char* Sym) {
+ DSOSymbols[Sym] = 1;
+ }
+
// To pass options to the driver and optimization passes. These options are
// not necessarily for debugging purpose (The function name is misleading).
// This function should be called before LTOCodeGenerator::compilexxx(),
void applyScopeRestrictions();
void applyRestriction(llvm::GlobalValue &GV,
std::vector<const char*> &MustPreserveList,
+ std::vector<const char*> &SymtabList,
llvm::SmallPtrSet<llvm::GlobalValue*, 8> &AsmUsed,
llvm::Mangler &Mangler);
bool determineTarget(std::string &errMsg);
bool EmitDwarfDebugInfo;
bool ScopeRestrictionsDone;
lto_codegen_model CodeModel;
+ StringSet DSOSymbols;
StringSet MustPreserveSymbols;
StringSet AsmUndefinedRefs;
llvm::MemoryBuffer *NativeObjectFile;
//===----------------------------------------------------------------------===//
/// createInternalizePass - This pass loops over all of the functions in the
-/// input module, internalizing all globals (functions and variables) not in the
-/// given exportList.
+/// input module, internalizing all globals (functions and variables) it can.
+////
+/// The symbols in \p ExportList are never internalized.
+///
+/// The symbol in DSOList are internalized if it is safe to drop them from
+/// the symbol table.
+///
+/// For example of the difference, consider a dynamic library being built from
+/// two translation units. The first one compiled to a native object
+/// (ELF/MachO/COFF) and second one compiled to IL. Translation unit A has a
+/// copy of linkonce_odr unnamed_addr function F. The translation unit B has a
+/// copy of the linkonce_odr unnamed_addr functions F and G.
+///
+/// Assume the linker decides to keep the copy of F in B. This means that LLVM
+/// must produce F in the object file it passes to the linker, otherwise we
+/// will have an undefined reference. For G the situation is different. The
+/// linker puts the function in the DSOList, since it is only wanted for the
+/// symbol table. With this information internalize can now reason that since
+/// the function is a linkonce_odr and its address is not important, it can be
+/// omitted. Any other shared library needing this function will have a copy of
+/// it.
///
/// Note that commandline options that are used with the above function are not
/// used now!
-ModulePass *createInternalizePass(ArrayRef<const char *> ExportList);
+ModulePass *createInternalizePass(ArrayRef<const char *> ExportList,
+ ArrayRef<const char *> DSOList);
/// createInternalizePass - Same as above, but with an empty exportList.
ModulePass *createInternalizePass();
void LTOCodeGenerator::
applyRestriction(GlobalValue &GV,
std::vector<const char*> &MustPreserveList,
+ std::vector<const char*> &DSOList,
SmallPtrSet<GlobalValue*, 8> &AsmUsed,
Mangler &Mangler) {
SmallString<64> Buffer;
return;
if (MustPreserveSymbols.count(Buffer))
MustPreserveList.push_back(GV.getName().data());
+ if (DSOSymbols.count(Buffer))
+ DSOList.push_back(GV.getName().data());
if (AsmUndefinedRefs.count(Buffer))
AsmUsed.insert(&GV);
}
NULL);
Mangler Mangler(MContext, TargetMach);
std::vector<const char*> MustPreserveList;
+ std::vector<const char*> DSOList;
SmallPtrSet<GlobalValue*, 8> AsmUsed;
for (Module::iterator f = mergedModule->begin(),
e = mergedModule->end(); f != e; ++f)
- applyRestriction(*f, MustPreserveList, AsmUsed, Mangler);
+ applyRestriction(*f, MustPreserveList, DSOList, AsmUsed, Mangler);
for (Module::global_iterator v = mergedModule->global_begin(),
e = mergedModule->global_end(); v != e; ++v)
- applyRestriction(*v, MustPreserveList, AsmUsed, Mangler);
+ applyRestriction(*v, MustPreserveList, DSOList, AsmUsed, Mangler);
for (Module::alias_iterator a = mergedModule->alias_begin(),
e = mergedModule->alias_end(); a != e; ++a)
- applyRestriction(*a, MustPreserveList, AsmUsed, Mangler);
+ applyRestriction(*a, MustPreserveList, DSOList, AsmUsed, Mangler);
GlobalVariable *LLVMCompilerUsed =
mergedModule->getGlobalVariable("llvm.compiler.used");
LLVMCompilerUsed->setSection("llvm.metadata");
}
- passes.add(createInternalizePass(MustPreserveList));
+ passes.add(createInternalizePass(MustPreserveList, DSOList));
// apply scope restrictions
passes.run(*mergedModule);
std::vector<const char *> Export;
if (AllButMain)
Export.push_back("main");
- unwrap(PM)->add(createInternalizePass(Export));
+ unwrap(PM)->add(createInternalizePass(Export, None));
}
void LLVMAddStripDeadPrototypesPass(LLVMPassManagerRef PM) {
cl::desc("A list of symbol names to preserve"),
cl::CommaSeparated);
+static cl::list<std::string>
+DSOList("internalize-dso-list", cl::value_desc("list"),
+ cl::desc("A list of symbol names need for a dso symbol table"),
+ cl::CommaSeparated);
+
namespace {
class InternalizePass : public ModulePass {
std::set<std::string> ExternalNames;
+ std::set<std::string> DSONames;
public:
static char ID; // Pass identification, replacement for typeid
explicit InternalizePass();
- explicit InternalizePass(ArrayRef<const char *> ExportList);
+ explicit InternalizePass(ArrayRef<const char *> ExportList,
+ ArrayRef<const char *> DSOList);
void LoadFile(const char *Filename);
virtual bool runOnModule(Module &M);
if (!APIFile.empty()) // If a filename is specified, use it.
LoadFile(APIFile.c_str());
ExternalNames.insert(APIList.begin(), APIList.end());
+ DSONames.insert(DSOList.begin(), DSOList.end());
}
-InternalizePass::InternalizePass(ArrayRef<const char *> ExportList)
+InternalizePass::InternalizePass(ArrayRef<const char *> ExportList,
+ ArrayRef<const char *> DSOList)
: ModulePass(ID){
initializeInternalizePassPass(*PassRegistry::getPassRegistry());
for(ArrayRef<const char *>::const_iterator itr = ExportList.begin();
itr != ExportList.end(); itr++) {
ExternalNames.insert(*itr);
}
+ for(ArrayRef<const char *>::const_iterator itr = DSOList.begin();
+ itr != DSOList.end(); itr++) {
+ DSONames.insert(*itr);
+ }
}
void InternalizePass::LoadFile(const char *Filename) {
}
static bool shouldInternalize(const GlobalValue &GV,
- const std::set<std::string> &ExternalNames) {
+ const std::set<std::string> &ExternalNames,
+ const std::set<std::string> &DSONames) {
// Function must be defined here
if (GV.isDeclaration())
return false;
if (ExternalNames.count(GV.getName()))
return false;
- return true;
+ // Not needed for the symbol table?
+ if (!DSONames.count(GV.getName()))
+ return true;
+
+ // Not a linkonce. Someone can depend on it being on the symbol table.
+ if (!GV.hasLinkOnceLinkage())
+ return false;
+
+ // The address is not important, we can hide it.
+ if (GV.hasUnnamedAddr())
+ return true;
+
+ // FIXME: Check if the address is used.
+ return false;
}
bool InternalizePass::runOnModule(Module &M) {
// 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) {
- if (!shouldInternalize(*I, ExternalNames))
+ if (!shouldInternalize(*I, ExternalNames, DSONames))
continue;
I->setLinkage(GlobalValue::InternalLinkage);
// FIXME: maybe use private linkage?
for (Module::global_iterator I = M.global_begin(), E = M.global_end();
I != E; ++I) {
- if (!shouldInternalize(*I, ExternalNames))
+ if (!shouldInternalize(*I, ExternalNames, DSONames))
continue;
I->setLinkage(GlobalValue::InternalLinkage);
// Mark all aliases that are not in the api as internal as well.
for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end();
I != E; ++I) {
- if (!shouldInternalize(*I, ExternalNames))
+ if (!shouldInternalize(*I, ExternalNames, DSONames))
continue;
I->setLinkage(GlobalValue::InternalLinkage);
return new InternalizePass();
}
-ModulePass *llvm::createInternalizePass(ArrayRef<const char *> ExportList) {
- return new InternalizePass(ExportList);
+ModulePass *llvm::createInternalizePass(ArrayRef<const char *> ExportList,
+ ArrayRef<const char *> DSOList) {
+ return new InternalizePass(ExportList, DSOList);
}
// for a main function. If main is defined, mark all other functions
// internal.
if (Internalize)
- PM.add(createInternalizePass("main"));
+ PM.add(createInternalizePass("main", None));
// Propagate constants at call sites into the functions they call. This
// opens opportunities for globalopt (and inlining) by substituting function
call void @PR14512()
ret i32 0
}
+
+; RUN: llvm-lto -o %t -dso-symbol=zed1 -dso-symbol=zed2 %t1 -disable-opt
+; RUN: llvm-nm %t | FileCheck %s -check-prefix=ZED1_AND_ZED2
+; ZED1_AND_ZED2: V zed1
+@zed1 = linkonce_odr global i32 42
+
+; ZED1_AND_ZED2: d zed2
+@zed2 = linkonce_odr unnamed_addr global i32 42
; -file and -list options should be merged, the apifile contains foo and j
; RUN: opt < %s -internalize -internalize-public-api-list bar -internalize-public-api-file %S/apifile -S | FileCheck --check-prefix=FOO_J_AND_BAR %s
+; Put zed1 and zed2 in the symbol table. If the address is not relevant, we
+; internalize them.
+; RUN: opt < %s -internalize -internalize-dso-list zed1,zed2 -S | FileCheck --check-prefix=ZED1_AND_ZED2 %s
+
; ALL: @i = internal global
; FOO_AND_J: @i = internal global
; FOO_AND_BAR: @i = internal global
; FOO_J_AND_BAR: @j = global
@j = global i32 0
+; ZED1_AND_ZED2: @zed1 = linkonce_odr global i32 42
+@zed1 = linkonce_odr global i32 42
+
+; ZED1_AND_ZED2: @zed2 = internal unnamed_addr global i32 42
+@zed2 = linkonce_odr unnamed_addr global i32 42
+
; ALL: define internal void @main() {
; FOO_AND_J: define internal void @main() {
; FOO_AND_BAR: define internal void @main() {
case LDPT_ADD_SYMBOLS:
add_symbols = tv->tv_u.tv_add_symbols;
break;
- case LDPT_GET_SYMBOLS:
+ case LDPT_GET_SYMBOLS_V2:
get_symbols = tv->tv_u.tv_get_symbols;
break;
case LDPT_ADD_INPUT_FILE:
if (options::generate_api_file)
api_file << I->syms[i].name << "\n";
+ } else if (I->syms[i].resolution == LDPR_PREVAILING_DEF_IRONLY_EXP) {
+ lto_codegen_add_dso_symbol(code_gen, I->syms[i].name);
+
+ if (options::generate_api_file)
+ api_file << I->syms[i].name << " dso only\n";
}
}
}
cl::desc("Symbol to export from the resulting object file"),
cl::ZeroOrMore);
+static cl::list<std::string>
+DSOSymbols("dso-symbol",
+ cl::desc("Symbol to put in the symtab in the resulting dso"),
+ cl::ZeroOrMore);
int main(int argc, char **argv) {
// Print a stack trace if we signal out.
for (unsigned i = 0; i < ExportedSymbols.size(); ++i)
CodeGen.addMustPreserveSymbol(ExportedSymbols[i].c_str());
+ // Add all the dso symbols to the table of symbols to expose.
+ for (unsigned i = 0; i < DSOSymbols.size(); ++i)
+ CodeGen.addDSOSymbol(DSOSymbols[i].c_str());
+
if (!OutputFilename.empty()) {
size_t len = 0;
std::string ErrorInfo;
cg->addMustPreserveSymbol(symbol);
}
+void lto_codegen_add_dso_symbol(lto_code_gen_t cg, const char *symbol) {
+ cg->addDSOSymbol(symbol);
+}
+
/// lto_codegen_write_merged_modules - Writes a new file at the specified path
/// that contains the merged contents of all modules added so far. Returns true
/// on error (check lto_get_error_message() for details).
projects / oota-llvm.git / commitdiff