X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FLinker%2FLinkItems.cpp;h=61f3c26c6a1ca50bfc4cb1699d0e8f755ad7f160;hb=74382b7c699120fbec5cb5603c9cf4212eb37f06;hp=34677ce3654927be575355ab7918a71e3b859bff;hpb=f976c856fcc5055f3fc7d9f070d72c2d027c1d9d;p=oota-llvm.git diff --git a/lib/Linker/LinkItems.cpp b/lib/Linker/LinkItems.cpp index 34677ce3654..61f3c26c6a1 100644 --- a/lib/Linker/LinkItems.cpp +++ b/lib/Linker/LinkItems.cpp @@ -2,34 +2,51 @@ // // 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/System/Path.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/MemoryBuffer.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(); 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,10 +55,14 @@ 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)) + 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; } @@ -49,31 +70,47 @@ Linker::LinkInItems(const ItemList& Items) { /// LinkInLibrary - links one library into the HeadModule. /// -bool Linker::LinkInLibrary(const std::string& Lib) { +bool Linker::LinkInLibrary(const 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. @@ -85,8 +122,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,17 +135,17 @@ bool Linker::LinkInLibraries(const std::vector &Libraries) { const Module::LibraryListType& DepLibs = Composite->getLibraries(); for (Module::LibraryListType::const_iterator I = DepLibs.begin(), E = DepLibs.end(); I != E; ++I) - if (LinkInLibrary(*I)) + if (LinkInLibrary(*I, is_native)) return true; return false; } -/// LinkInFile - opens a bytecode file and links in all objects which +/// LinkInFile - opens a bitcode file and links in all objects which /// provide symbols that are currently undefined. /// /// Inputs: -/// File - The pathname of the bytecode file. +/// File - The pathname of the bitcode file. /// /// Outputs: /// ErrorMessage - A C++ string detailing what error occurred, if any. @@ -116,28 +154,65 @@ bool Linker::LinkInLibraries(const std::vector &Libraries) { /// TRUE - An error occurred. /// FALSE - No errors. /// -bool Linker::LinkInFile(const sys::Path &File) { +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; + if (MemoryBuffer *Buffer = MemoryBuffer::getSTDIN()) { + M.reset(ParseBitcodeFile(Buffer, Context, &Error)); + delete Buffer; + if (M.get()) + if (!LinkInModule(M.get(), &Error)) + return false; + } else + Error = "standard input is empty"; + return error("Cannot link stdin: " + Error); + } + // Make sure we can at least read the file - if (!File.readable()) - return error("Cannot find linker input '" + File.toString() + "'"); - - // A user may specify an ar archive without -l, perhaps because it - // is not installed as a library. Detect that and link the library. - if (File.isArchive()) { - if (LinkInArchive(File)) - return error("Cannot link archive '" + File.toString() + "'"); - } else if (File.isBytecodeFile()) { - verbose("Linking bytecode file '" + File.toString() + "'"); - - std::auto_ptr M(LoadObject(File)); - if (M.get() == 0) - return error("Cannot load file '" + File.toString() + "'" + Error); - if (LinkInModule(M.get())) - return error("Cannot link file '" + File.toString() + "'" + Error); - - verbose("Linked in file '" + File.toString() + "'"); - } else { - return warning("File of unknown type '" + File.toString() + "' ignored."); + if (!File.canRead()) + return error("Cannot find linker input '" + File.str() + "'"); + + // If its an archive, try to link it in + std::string Magic; + File.getMagicNumber(Magic, 64); + 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. + verbose("Linking archive file '" + File.str() + "'"); + 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; } @@ -147,17 +222,18 @@ bool Linker::LinkInFile(const sys::Path &File) { /// or relative pathname, or as a file somewhere in LLVM_LIB_SEARCH_PATH. /// /// Inputs: -/// Files - A vector of sys::Path indicating the LLVM bytecode filenames +/// Files - A vector of sys::Path indicating the LLVM bitcode filenames /// to be linked. The names can refer to a mixture of pure LLVM -/// bytecode files and archive (ar) formatted files. +/// 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])) + if (LinkInFile(Files[i], is_native)) return true; return false; }