X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fgold%2Fgold-plugin.cpp;h=6d52f62b210021c637e5cfa94869c395cf0b0e69;hb=04e43e64a9e179d707f16cd09ccad4c135d82d6e;hp=7059210a4b692827e57b86fe8ad7f8703f52ed67;hpb=c72f8e9f9d5b7a9c1717428f02ba30ad3f401799;p=oota-llvm.git diff --git a/tools/gold/gold-plugin.cpp b/tools/gold/gold-plugin.cpp index 7059210a4b6..6d52f62b210 100644 --- a/tools/gold/gold-plugin.cpp +++ b/tools/gold/gold-plugin.cpp @@ -12,87 +12,118 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Config/config.h" -#include "plugin-api.h" - +#include "llvm/Config/config.h" // plugin-api.h requires HAVE_STDINT_H #include "llvm-c/lto.h" - -#include "llvm/Support/raw_ostream.h" -#include "llvm/System/Errno.h" -#include "llvm/System/Path.h" -#include "llvm/System/Program.h" - +#include "llvm/ADT/StringSet.h" +#include "llvm/CodeGen/CommandFlags.h" +#include "llvm/LTO/LTOCodeGenerator.h" +#include "llvm/LTO/LTOModule.h" +#include "llvm/Support/Errno.h" +#include "llvm/Support/FileSystem.h" +#include "llvm/Support/MemoryBuffer.h" +#include "llvm/Support/Path.h" +#include "llvm/Support/Program.h" +#include "llvm/Support/TargetSelect.h" +#include "llvm/Support/ToolOutputFile.h" #include #include #include #include #include +#include +#include #include -using namespace llvm; +// Support Windows/MinGW crazyness. +#ifdef _WIN32 +# include +# define lseek _lseek +# define read _read +#endif -namespace { - ld_plugin_status discard_message(int level, const char *format, ...) { - // Die loudly. Recent versions of Gold pass ld_plugin_message as the first - // callback in the transfer vector. This should never be called. - abort(); - } +#ifndef LDPO_PIE +// FIXME: remove this declaration when we stop maintaining Ubuntu Quantal and +// Precise and Debian Wheezy (binutils 2.23 is required) +# define LDPO_PIE 3 +#endif - ld_plugin_add_symbols add_symbols = NULL; - ld_plugin_get_symbols get_symbols = NULL; - ld_plugin_add_input_file add_input_file = NULL; - ld_plugin_message message = discard_message; - - int api_version = 0; - int gold_version = 0; +using namespace llvm; - struct claimed_file { - lto_module_t M; - void *handle; - std::vector syms; - }; +namespace { +struct claimed_file { + void *handle; + std::vector syms; +}; +} - lto_codegen_model output_type = LTO_CODEGEN_PIC_MODEL_STATIC; - std::list Modules; - std::vector Cleanup; +static ld_plugin_status discard_message(int level, const char *format, ...) { + // Die loudly. Recent versions of Gold pass ld_plugin_message as the first + // callback in the transfer vector. This should never be called. + abort(); } +static ld_plugin_add_symbols add_symbols = NULL; +static ld_plugin_get_symbols get_symbols = NULL; +static ld_plugin_add_input_file add_input_file = NULL; +static ld_plugin_set_extra_library_path set_extra_library_path = NULL; +static ld_plugin_get_view get_view = NULL; +static ld_plugin_message message = discard_message; +static lto_codegen_model output_type = LTO_CODEGEN_PIC_MODEL_STATIC; +static std::string output_name = ""; +static std::list Modules; +static std::vector Cleanup; +static LTOCodeGenerator *CodeGen = nullptr; +static StringSet<> CannotBeHidden; +static llvm::TargetOptions TargetOpts; + namespace options { + enum generate_bc { BC_NO, BC_ALSO, BC_ONLY }; static bool generate_api_file = false; + static generate_bc generate_bc_file = BC_NO; static std::string bc_path; - static const char *as_path = NULL; + static std::string obj_path; + static std::string extra_library_path; + static std::string triple; + static std::string mcpu; // Additional options to pass into the code generator. - // Note: This array will contain all plugin options which are not claimed + // Note: This array will contain all plugin options which are not claimed // as plugin exclusive to pass to the code generator. - // For example, "generate-api-file" and "as"options are for the plugin + // For example, "generate-api-file" and "as"options are for the plugin // use only and will not be passed. static std::vector extra; - static void process_plugin_option(const char* opt) + static void process_plugin_option(const char* opt_) { - if (opt == NULL) + if (opt_ == NULL) return; + llvm::StringRef opt = opt_; - if (strcmp("generate-api-file", opt) == 0) { + if (opt == "generate-api-file") { generate_api_file = true; - } else if (strncmp("as=", opt, 3) == 0) { - if (as_path) { - (*message)(LDPL_WARNING, "Path to as specified twice. " - "Discarding %s", opt); - } else { - as_path = strdup(opt + 3); - } - } else if(llvm::StringRef(opt).startswith("also-emit-llvm=")) { - const char *path = opt + strlen("also-emit-llvm="); - if (bc_path != "") { + } else if (opt.startswith("mcpu=")) { + mcpu = opt.substr(strlen("mcpu=")); + } else if (opt.startswith("extra-library-path=")) { + extra_library_path = opt.substr(strlen("extra_library_path=")); + } else if (opt.startswith("mtriple=")) { + triple = opt.substr(strlen("mtriple=")); + } else if (opt.startswith("obj-path=")) { + obj_path = opt.substr(strlen("obj-path=")); + } else if (opt == "emit-llvm") { + generate_bc_file = BC_ONLY; + } else if (opt == "also-emit-llvm") { + generate_bc_file = BC_ALSO; + } else if (opt.startswith("also-emit-llvm=")) { + llvm::StringRef path = opt.substr(strlen("also-emit-llvm=")); + generate_bc_file = BC_ALSO; + if (!bc_path.empty()) { (*message)(LDPL_WARNING, "Path to the output IL file specified twice. " - "Discarding %s", opt); + "Discarding %s", opt_); } else { bc_path = path; } } else { // Save this option to pass to the code generator. - extra.push_back(std::string(opt)); + extra.push_back(opt); } } } @@ -104,6 +135,12 @@ static ld_plugin_status cleanup_hook(void); extern "C" ld_plugin_status onload(ld_plugin_tv *tv); ld_plugin_status onload(ld_plugin_tv *tv) { + InitializeAllTargetInfos(); + InitializeAllTargets(); + InitializeAllTargetMCs(); + InitializeAllAsmParsers(); + InitializeAllAsmPrinters(); + // We're given a pointer to the first transfer vector. We read through them // until we find one where tv_tag == LDPT_NULL. The REGISTER_* tagged values // contain pointers to functions that we need to call to register our own @@ -111,21 +148,18 @@ ld_plugin_status onload(ld_plugin_tv *tv) { // for services. bool registeredClaimFile = false; - bool registeredAllSymbolsRead = false; - bool registeredCleanup = false; + bool RegisteredAllSymbolsRead = false; for (; tv->tv_tag != LDPT_NULL; ++tv) { switch (tv->tv_tag) { - case LDPT_API_VERSION: - api_version = tv->tv_u.tv_val; - break; - case LDPT_GOLD_VERSION: // major * 100 + minor - gold_version = tv->tv_u.tv_val; + case LDPT_OUTPUT_NAME: + output_name = tv->tv_u.tv_string; break; case LDPT_LINKER_OUTPUT: switch (tv->tv_u.tv_val) { case LDPO_REL: // .o case LDPO_DYN: // .so + case LDPO_PIE: // position independent executable output_type = LTO_CODEGEN_PIC_MODEL_DYNAMIC; break; case LDPO_EXEC: // .exe @@ -136,8 +170,6 @@ ld_plugin_status onload(ld_plugin_tv *tv) { tv->tv_u.tv_val); return LDPS_ERR; } - // TODO: add an option to disable PIC. - //output_type = LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC; break; case LDPT_OPTION: options::process_plugin_option(tv->tv_u.tv_string); @@ -158,7 +190,7 @@ ld_plugin_status onload(ld_plugin_tv *tv) { if ((*callback)(all_symbols_read_hook) != LDPS_OK) return LDPS_ERR; - registeredAllSymbolsRead = true; + RegisteredAllSymbolsRead = true; } break; case LDPT_REGISTER_CLEANUP_HOOK: { ld_plugin_register_cleanup callback; @@ -166,18 +198,22 @@ ld_plugin_status onload(ld_plugin_tv *tv) { if ((*callback)(cleanup_hook) != LDPS_OK) return LDPS_ERR; - - registeredCleanup = true; } break; 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: add_input_file = tv->tv_u.tv_add_input_file; break; + case LDPT_SET_EXTRA_LIBRARY_PATH: + set_extra_library_path = tv->tv_u.tv_set_extra_library_path; + break; + case LDPT_GET_VIEW: + get_view = tv->tv_u.tv_get_view; + break; case LDPT_MESSAGE: message = tv->tv_u.tv_message; break; @@ -195,75 +231,101 @@ ld_plugin_status onload(ld_plugin_tv *tv) { return LDPS_ERR; } + if (!RegisteredAllSymbolsRead) + return LDPS_OK; + + CodeGen = new LTOCodeGenerator(); + + // Pass through extra options to the code generator. + if (!options::extra.empty()) { + for (std::vector::iterator it = options::extra.begin(); + it != options::extra.end(); ++it) { + CodeGen->setCodeGenDebugOptions((*it).c_str()); + } + } + + CodeGen->parseCodeGenDebugOptions(); + if (MAttrs.size()) { + std::string Attrs; + for (unsigned I = 0; I < MAttrs.size(); ++I) { + if (I > 0) + Attrs.append(","); + Attrs.append(MAttrs[I]); + } + CodeGen->setAttr(Attrs.c_str()); + } + + TargetOpts = InitTargetOptionsFromCodeGenFlags(); + CodeGen->setTargetOptions(TargetOpts); + return LDPS_OK; } -/// claim_file_hook - called by gold to see whether this file is one that -/// our plugin can handle. We'll try to open it and register all the symbols -/// with add_symbol if possible. +/// Called by gold to see whether this file is one that our plugin can handle. +/// We'll try to open it and register all the symbols with add_symbol if +/// possible. static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file, int *claimed) { - void *buf = NULL; - if (file->offset) { - // Gold has found what might be IR part-way inside of a file, such as - // an .a archive. - if (lseek(file->fd, file->offset, SEEK_SET) == -1) { - (*message)(LDPL_ERROR, - "Failed to seek to archive member of %s at offset %d: %s\n", - file->name, - file->offset, sys::StrError(errno).c_str()); + const void *view; + std::unique_ptr buffer; + if (get_view) { + if (get_view(file->handle, &view) != LDPS_OK) { + (*message)(LDPL_ERROR, "Failed to get a view of %s", file->name); return LDPS_ERR; } - buf = malloc(file->filesize); - if (!buf) { - (*message)(LDPL_ERROR, - "Failed to allocate buffer for archive member of size: %d\n", - file->filesize); - return LDPS_ERR; + } else { + int64_t offset = 0; + // Gold has found what might be IR part-way inside of a file, such as + // an .a archive. + if (file->offset) { + offset = file->offset; } - if (read(file->fd, buf, file->filesize) != file->filesize) { - (*message)(LDPL_ERROR, - "Failed to read archive member of %s at offset %d: %s\n", - file->name, - file->offset, - sys::StrError(errno).c_str()); - free(buf); + if (std::error_code ec = MemoryBuffer::getOpenFileSlice( + file->fd, file->name, buffer, file->filesize, offset)) { + (*message)(LDPL_ERROR, ec.message().c_str()); return LDPS_ERR; } - if (!lto_module_is_object_file_in_memory(buf, file->filesize)) { - free(buf); - return LDPS_OK; - } - } else if (!lto_module_is_object_file(file->name)) + view = buffer->getBufferStart(); + } + + if (!LTOModule::isBitcodeFile(view, file->filesize)) return LDPS_OK; + std::string Error; + LTOModule *M = + LTOModule::createFromBuffer(view, file->filesize, TargetOpts, Error); + if (!M) { + (*message)(LDPL_ERROR, + "LLVM gold plugin has failed to create LTO module: %s", + Error.c_str()); + return LDPS_OK; + } + *claimed = 1; Modules.resize(Modules.size() + 1); claimed_file &cf = Modules.back(); - cf.M = buf ? lto_module_create_from_memory(buf, file->filesize) : - lto_module_create(file->name); - free(buf); - if (!cf.M) { - (*message)(LDPL_ERROR, "Failed to create LLVM module: %s", - lto_get_error_message()); - return LDPS_ERR; - } + if (!options::triple.empty()) + M->setTargetTriple(options::triple.c_str()); + cf.handle = file->handle; - unsigned sym_count = lto_module_get_num_symbols(cf.M); + unsigned sym_count = M->getSymbolCount(); cf.syms.reserve(sym_count); for (unsigned i = 0; i != sym_count; ++i) { - lto_symbol_attributes attrs = lto_module_get_symbol_attribute(cf.M, i); + lto_symbol_attributes attrs = M->getSymbolAttributes(i); if ((attrs & LTO_SYMBOL_SCOPE_MASK) == LTO_SYMBOL_SCOPE_INTERNAL) continue; cf.syms.push_back(ld_plugin_symbol()); ld_plugin_symbol &sym = cf.syms.back(); - sym.name = const_cast(lto_module_get_symbol_name(cf.M, i)); + sym.name = strdup(M->getSymbolName(i)); sym.version = NULL; int scope = attrs & LTO_SYMBOL_SCOPE_MASK; + bool CanBeHidden = scope == LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN; + if (!CanBeHidden) + CannotBeHidden.insert(sym.name); switch (scope) { case LTO_SYMBOL_SCOPE_HIDDEN: sym.visibility = LDPV_HIDDEN; @@ -273,6 +335,7 @@ static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file, break; case 0: // extern case LTO_SYMBOL_SCOPE_DEFAULT: + case LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN: sym.visibility = LDPV_DEFAULT; break; default: @@ -281,6 +344,7 @@ static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file, } int definition = attrs & LTO_SYMBOL_DEFINITION_MASK; + sym.comdat_key = NULL; switch (definition) { case LTO_SYMBOL_DEFINITION_REGULAR: sym.def = LDPK_DEF; @@ -292,6 +356,7 @@ static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file, sym.def = LDPK_COMMON; break; case LTO_SYMBOL_DEFINITION_WEAK: + sym.comdat_key = sym.name; sym.def = LDPK_WEAKDEF; break; case LTO_SYMBOL_DEFINITION_WEAKUNDEF: @@ -302,9 +367,7 @@ static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file, return LDPS_ERR; } - // LLVM never emits COMDAT. sym.size = 0; - sym.comdat_key = NULL; sym.resolution = LDPR_UNKNOWN; } @@ -318,21 +381,35 @@ static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file, } } + if (CodeGen) { + std::string Error; + if (!CodeGen->addModule(M, Error)) { + (*message)(LDPL_ERROR, "Error linking module: %s", Error.c_str()); + return LDPS_ERR; + } + } + + delete M; + return LDPS_OK; } +static bool mustPreserve(const claimed_file &F, int i) { + if (F.syms[i].resolution == LDPR_PREVAILING_DEF) + return true; + if (F.syms[i].resolution == LDPR_PREVAILING_DEF_IRONLY_EXP) + return CannotBeHidden.count(F.syms[i].name); + return false; +} + /// all_symbols_read_hook - gold informs us that all symbols have been read. /// At this point, we use get_symbols to see if any of our definitions have /// been overridden by a native object file. Then, perform optimization and /// codegen. static ld_plugin_status all_symbols_read_hook(void) { - lto_code_gen_t cg = lto_codegen_create(); - - for (std::list::iterator I = Modules.begin(), - E = Modules.end(); I != E; ++I) - lto_codegen_add_module(cg, I->M); - std::ofstream api_file; + assert(CodeGen); + if (options::generate_api_file) { api_file.open("apifile.txt", std::ofstream::out | std::ofstream::trunc); if (!api_file.is_open()) { @@ -341,94 +418,90 @@ static ld_plugin_status all_symbols_read_hook(void) { } } - // If we don't preserve any symbols, libLTO will assume that all symbols are - // needed. Keep all symbols unless we're producing a final executable. - bool anySymbolsPreserved = false; for (std::list::iterator I = Modules.begin(), E = Modules.end(); I != E; ++I) { + if (I->syms.empty()) + continue; (*get_symbols)(I->handle, I->syms.size(), &I->syms[0]); for (unsigned i = 0, e = I->syms.size(); i != e; i++) { - if (I->syms[i].resolution == LDPR_PREVAILING_DEF) { - lto_codegen_add_must_preserve_symbol(cg, I->syms[i].name); - anySymbolsPreserved = true; + if (mustPreserve(*I, i)) { + CodeGen->addMustPreserveSymbol(I->syms[i].name); if (options::generate_api_file) api_file << I->syms[i].name << "\n"; } } - - if (options::generate_api_file) - api_file.close(); - - if (!anySymbolsPreserved) { - // This entire file is unnecessary! - lto_codegen_dispose(cg); - return LDPS_OK; - } } - lto_codegen_set_pic_model(cg, output_type); - lto_codegen_set_debug_model(cg, LTO_DEBUG_MODEL_DWARF); - if (options::as_path) { - sys::Path p = sys::Program::FindProgramByName(options::as_path); - lto_codegen_set_assembler_path(cg, p.c_str()); - } - // Pass through extra options to the code generator. - if (!options::extra.empty()) { - for (std::vector::iterator it = options::extra.begin(); - it != options::extra.end(); ++it) { - lto_codegen_debug_options(cg, (*it).c_str()); + if (options::generate_api_file) + api_file.close(); + + CodeGen->setCodePICModel(output_type); + CodeGen->setDebugInfo(LTO_DEBUG_MODEL_DWARF); + if (!options::mcpu.empty()) + CodeGen->setCpu(options::mcpu.c_str()); + + if (options::generate_bc_file != options::BC_NO) { + std::string path; + if (options::generate_bc_file == options::BC_ONLY) + path = output_name; + else if (!options::bc_path.empty()) + path = options::bc_path; + else + path = output_name + ".bc"; + std::string Error; + if (!CodeGen->writeMergedModules(path.c_str(), Error)) + (*message)(LDPL_FATAL, "Failed to write the output file."); + if (options::generate_bc_file == options::BC_ONLY) { + delete CodeGen; + exit(0); } } - if (options::bc_path != "") { - bool err = lto_codegen_write_merged_modules(cg, options::bc_path.c_str()); - if (err) - (*message)(LDPL_FATAL, "Failed to write the output file."); + std::string ObjPath; + { + const char *Temp; + std::string Error; + if (!CodeGen->compile_to_file(&Temp, /*DisableOpt*/ false, /*DisableInline*/ + false, /*DisableGVNLoadPRE*/ false, Error)) + (*message)(LDPL_ERROR, "Could not produce a combined object file\n"); + ObjPath = Temp; } - size_t bufsize = 0; - const char *buffer = static_cast(lto_codegen_compile(cg, - &bufsize)); - std::string ErrMsg; - - sys::Path uniqueObjPath("/tmp/llvmgold.o"); - if (uniqueObjPath.createTemporaryFileOnDisk(true, &ErrMsg)) { - (*message)(LDPL_ERROR, "%s", ErrMsg.c_str()); - return LDPS_ERR; + delete CodeGen; + for (std::list::iterator I = Modules.begin(), + E = Modules.end(); I != E; ++I) { + for (unsigned i = 0; i != I->syms.size(); ++i) { + ld_plugin_symbol &sym = I->syms[i]; + free(sym.name); + } } - raw_fd_ostream *objFile = - new raw_fd_ostream(uniqueObjPath.c_str(), ErrMsg, - raw_fd_ostream::F_Binary); - if (!ErrMsg.empty()) { - delete objFile; - (*message)(LDPL_ERROR, "%s", ErrMsg.c_str()); + + if ((*add_input_file)(ObjPath.c_str()) != LDPS_OK) { + (*message)(LDPL_ERROR, "Unable to add .o file to the link."); + (*message)(LDPL_ERROR, "File left behind in: %s", ObjPath.c_str()); return LDPS_ERR; } - objFile->write(buffer, bufsize); - objFile->close(); - - lto_codegen_dispose(cg); - - if ((*add_input_file)(const_cast(uniqueObjPath.c_str())) != LDPS_OK) { - (*message)(LDPL_ERROR, "Unable to add .o file to the link."); - (*message)(LDPL_ERROR, "File left behind in: %s", uniqueObjPath.c_str()); + if (!options::extra_library_path.empty() && + set_extra_library_path(options::extra_library_path.c_str()) != LDPS_OK) { + (*message)(LDPL_ERROR, "Unable to set the extra library path."); return LDPS_ERR; } - Cleanup.push_back(uniqueObjPath); + if (options::obj_path.empty()) + Cleanup.push_back(ObjPath); return LDPS_OK; } static ld_plugin_status cleanup_hook(void) { - std::string ErrMsg; - - for (int i = 0, e = Cleanup.size(); i != e; ++i) - if (Cleanup[i].eraseFromDisk(false, &ErrMsg)) + for (int i = 0, e = Cleanup.size(); i != e; ++i) { + std::error_code EC = sys::fs::remove(Cleanup[i]); + if (EC) (*message)(LDPL_ERROR, "Failed to delete '%s': %s", Cleanup[i].c_str(), - ErrMsg.c_str()); + EC.message().c_str()); + } return LDPS_OK; }