X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FLinker%2FLinkItems.cpp;h=52a0d175a5cdd8bd66a81b04b05279bc46eea4a4;hb=0d18174f0f138e98fcb8348b735a90add45428b8;hp=f43166c861b46e9875135ebd6899c2c818fc8206;hpb=e84de29663f4b8fc0540218540b93b74ca145e1b;p=oota-llvm.git diff --git a/lib/Linker/LinkItems.cpp b/lib/Linker/LinkItems.cpp index f43166c861b..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,12 +56,186 @@ 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. + 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; +} + + +/// LinkInLibrary - links one library into the HeadModule. +/// +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 error("Cannot find library '" + Lib.str() + "'"); + + // If its an archive, try to link it in + 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 bitcode object file. +/// +/// Inputs: +/// Libraries - The list of libraries to link into the module. +/// +/// Return value: +/// FALSE - No error. +/// TRUE - Error. +/// +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], is_native)) + return true; + + // At this point we have processed all the libraries provided to us. Since + // we have an aggregated module at this point, the dependent libraries in + // 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)) + 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; }