X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FLinker%2FLinkItems.cpp;h=52a0d175a5cdd8bd66a81b04b05279bc46eea4a4;hb=0d18174f0f138e98fcb8348b735a90add45428b8;hp=2899d69eec167c676b675d71b767a13a2a543609;hpb=ad988f397d63c99cf141eee0f9e6743f53543842;p=oota-llvm.git diff --git a/lib/Linker/LinkItems.cpp b/lib/Linker/LinkItems.cpp index 2899d69eec1..52a0d175a5c 100644 --- a/lib/Linker/LinkItems.cpp +++ b/lib/Linker/LinkItems.cpp @@ -1,35 +1,53 @@ //===- lib/Linker/LinkItems.cpp - Link LLVM objects and libraries ---------===// -// +// // The LLVM Compiler Infrastructure // -// This file was developed by Reid Spencer and is distributed under the -// University of Illinois Open Source License. See LICENSE.TXT for details. -// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// //===----------------------------------------------------------------------===// // -// This file contains routines to handle linking together LLVM bytecode files, +// This file contains routines to handle linking together LLVM bitcode files, // and to handle annoying things like static libraries. // //===----------------------------------------------------------------------===// #include "llvm/Linker.h" #include "llvm/Module.h" - +#include "llvm/Bitcode/ReaderWriter.h" +#include "llvm/Support/Path.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/MemoryBuffer.h" +#include "llvm/Support/system_error.h" using namespace llvm; -// LinkItems - preserve link order for an arbitrary set of linkage items. +// LinkItems - This function is the main entry point into linking. It takes a +// list of LinkItem which indicates the order the files should be linked and +// how each file should be treated (plain file or with library search). The +// function only links bitcode and produces a result list of items that are +// native objects. bool -Linker::LinkInItems(const ItemList& Items) { +Linker::LinkInItems(const ItemList& Items, ItemList& NativeItems) { + // Clear the NativeItems just in case + NativeItems.clear(); + // For each linkage item ... - for (ItemList::const_iterator I = Items.begin(), E = Items.end(); + for (ItemList::const_iterator I = Items.begin(), E = Items.end(); I != E; ++I) { if (I->second) { // Link in the library suggested. - if (LinkInLibrary(I->first)) + bool is_native = false; + if (LinkInLibrary(I->first, is_native)) return true; + if (is_native) + NativeItems.push_back(*I); } else { - if (LinkInFile(sys::Path(I->first))) + // Link in the file suggested + bool is_native = false; + if (LinkInFile(sys::Path(I->first), is_native)) return true; + if (is_native) + NativeItems.push_back(*I); } } @@ -38,11 +56,13 @@ Linker::LinkInItems(const ItemList& Items) { // that module should also be aggregated with duplicates eliminated. This is // now the time to process the dependent libraries to resolve any remaining // symbols. - const Module::LibraryListType& DepLibs = Composite->getLibraries(); - for (Module::LibraryListType::const_iterator I = DepLibs.begin(), - E = DepLibs.end(); I != E; ++I) { - if(LinkInLibrary(*I)) + bool is_native; + for (Module::lib_iterator I = Composite->lib_begin(), + E = Composite->lib_end(); I != E; ++I) { + if(LinkInLibrary(*I, is_native)) return true; + if (is_native) + NativeItems.push_back(std::make_pair(*I, true)); } return false; @@ -51,31 +71,47 @@ Linker::LinkInItems(const ItemList& Items) { /// LinkInLibrary - links one library into the HeadModule. /// -bool Linker::LinkInLibrary(const std::string& Lib) { +bool Linker::LinkInLibrary(StringRef Lib, bool& is_native) { + is_native = false; // Determine where this library lives. sys::Path Pathname = FindLib(Lib); if (Pathname.isEmpty()) - return warning("Cannot find library '" + Lib + "'"); + return error("Cannot find library '" + Lib.str() + "'"); // If its an archive, try to link it in - if (Pathname.isArchive()) { - if (LinkInArchive(Pathname)) - return error("Cannot link archive '" + Pathname.toString() + "'"); - } else if (Pathname.isBytecodeFile()) { - // LLVM ".so" file. - if (LinkInFile(Pathname)) - return error("Cannot link file '" + Pathname.toString() + "'"); - - } else if (Pathname.isDynamicLibrary()) { - return warning("Library '" + Lib + "' is a native dynamic library."); - } else { - return warning("Supposed library '" + Lib + "' isn't a library."); + std::string Magic; + Pathname.getMagicNumber(Magic, 64); + switch (sys::IdentifyFileType(Magic.c_str(), 64)) { + default: llvm_unreachable("Bad file type identification"); + case sys::Unknown_FileType: + return warning("Supposed library '" + Lib.str() + "' isn't a library."); + + case sys::Bitcode_FileType: + // LLVM ".so" file. + if (LinkInFile(Pathname, is_native)) + return true; + break; + + case sys::Archive_FileType: + if (LinkInArchive(Pathname, is_native)) + return error("Cannot link archive '" + Pathname.str() + "'"); + break; + + case sys::ELF_Relocatable_FileType: + case sys::ELF_SharedObject_FileType: + case sys::Mach_O_Object_FileType: + case sys::Mach_O_FixedVirtualMemorySharedLib_FileType: + case sys::Mach_O_DynamicallyLinkedSharedLib_FileType: + case sys::Mach_O_DynamicallyLinkedSharedLibStub_FileType: + case sys::COFF_FileType: + is_native = true; + break; } return false; } /// LinkLibraries - takes the specified library files and links them into the -/// main bytecode object file. +/// main bitcode object file. /// /// Inputs: /// Libraries - The list of libraries to link into the module. @@ -87,8 +123,9 @@ bool Linker::LinkInLibrary(const std::string& Lib) { bool Linker::LinkInLibraries(const std::vector &Libraries) { // Process the set of libraries we've been provided. + bool is_native = false; for (unsigned i = 0; i < Libraries.size(); ++i) - if (LinkInLibrary(Libraries[i])) + if (LinkInLibrary(Libraries[i], is_native)) return true; // At this point we have processed all the libraries provided to us. Since @@ -97,10 +134,108 @@ bool Linker::LinkInLibraries(const std::vector &Libraries) { // now the time to process the dependent libraries to resolve any remaining // symbols. const Module::LibraryListType& DepLibs = Composite->getLibraries(); - for (Module::LibraryListType::const_iterator I = DepLibs.begin(), - E = DepLibs.end(); I != E; ++I) - if (LinkInLibrary(*I)) + for (Module::LibraryListType::const_iterator I = DepLibs.begin(), + E = DepLibs.end(); I != E; ++I) + if (LinkInLibrary(*I, is_native)) return true; return false; } + +/// LinkInFile - opens a bitcode file and links in all objects which +/// provide symbols that are currently undefined. +/// +/// Inputs: +/// File - The pathname of the bitcode file. +/// +/// Outputs: +/// ErrorMessage - A C++ string detailing what error occurred, if any. +/// +/// Return Value: +/// TRUE - An error occurred. +/// FALSE - No errors. +/// +bool Linker::LinkInFile(const sys::Path &File, bool &is_native) { + is_native = false; + + // Check for a file of name "-", which means "read standard input" + if (File.str() == "-") { + std::auto_ptr M; + OwningPtr Buffer; + error_code ec; + if (!(ec = MemoryBuffer::getSTDIN(Buffer))) { + if (!Buffer->getBufferSize()) { + Error = "standard input is empty"; + } else { + M.reset(ParseBitcodeFile(Buffer.get(), Context, &Error)); + if (M.get()) + if (!LinkInModule(M.get(), &Error)) + return false; + } + } + return error("Cannot link stdin: " + ec.message()); + } + + // Determine what variety of file it is. + std::string Magic; + if (!File.getMagicNumber(Magic, 64)) + return error("Cannot find linker input '" + File.str() + "'"); + + switch (sys::IdentifyFileType(Magic.c_str(), 64)) { + default: llvm_unreachable("Bad file type identification"); + case sys::Unknown_FileType: + return warning("Ignoring file '" + File.str() + + "' because does not contain bitcode."); + + case sys::Archive_FileType: + // A user may specify an ar archive without -l, perhaps because it + // is not installed as a library. Detect that and link the archive. + if (LinkInArchive(File, is_native)) + return true; + break; + + case sys::Bitcode_FileType: { + verbose("Linking bitcode file '" + File.str() + "'"); + std::auto_ptr M(LoadObject(File)); + if (M.get() == 0) + return error("Cannot load file '" + File.str() + "': " + Error); + if (LinkInModule(M.get(), &Error)) + return error("Cannot link file '" + File.str() + "': " + Error); + + verbose("Linked in file '" + File.str() + "'"); + break; + } + + case sys::ELF_Relocatable_FileType: + case sys::ELF_SharedObject_FileType: + case sys::Mach_O_Object_FileType: + case sys::Mach_O_FixedVirtualMemorySharedLib_FileType: + case sys::Mach_O_DynamicallyLinkedSharedLib_FileType: + case sys::Mach_O_DynamicallyLinkedSharedLibStub_FileType: + case sys::COFF_FileType: + is_native = true; + break; + } + return false; +} + +/// LinkFiles - takes a module and a list of files and links them all together. +/// It locates the file either in the current directory, as its absolute +/// or relative pathname, or as a file somewhere in LLVM_LIB_SEARCH_PATH. +/// +/// Inputs: +/// Files - A vector of sys::Path indicating the LLVM bitcode filenames +/// to be linked. The names can refer to a mixture of pure LLVM +/// bitcode files and archive (ar) formatted files. +/// +/// Return value: +/// FALSE - No errors. +/// TRUE - Some error occurred. +/// +bool Linker::LinkInFiles(const std::vector &Files) { + bool is_native; + for (unsigned i = 0; i < Files.size(); ++i) + if (LinkInFile(Files[i], is_native)) + return true; + return false; +}