1 //===- lib/Linker/LinkItems.cpp - Link LLVM objects and libraries ---------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file contains routines to handle linking together LLVM bitcode files, 11 // and to handle annoying things like static libraries. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "llvm/Linker.h" 16 #include "llvm/Module.h" 17 #include "llvm/Bitcode/ReaderWriter.h" 18 #include "llvm/Support/Path.h" 19 #include "llvm/Support/ErrorHandling.h" 20 #include "llvm/Support/MemoryBuffer.h" 21 #include "llvm/Support/system_error.h" 22 using namespace llvm; 23 24 // LinkItems - This function is the main entry point into linking. It takes a 25 // list of LinkItem which indicates the order the files should be linked and 26 // how each file should be treated (plain file or with library search). The 27 // function only links bitcode and produces a result list of items that are 28 // native objects. 29 bool 30 Linker::LinkInItems(const ItemList& Items, ItemList& NativeItems) { 31 // Clear the NativeItems just in case 32 NativeItems.clear(); 33 34 // For each linkage item ... 35 for (ItemList::const_iterator I = Items.begin(), E = Items.end(); 36 I != E; ++I) { 37 if (I->second) { 38 // Link in the library suggested. 39 bool is_native = false; 40 if (LinkInLibrary(I->first, is_native)) 41 return true; 42 if (is_native) 43 NativeItems.push_back(*I); 44 } else { 45 // Link in the file suggested 46 bool is_native = false; 47 if (LinkInFile(sys::Path(I->first), is_native)) 48 return true; 49 if (is_native) 50 NativeItems.push_back(*I); 51 } 52 } 53 54 // At this point we have processed all the link items provided to us. Since 55 // we have an aggregated module at this point, the dependent libraries in 56 // that module should also be aggregated with duplicates eliminated. This is 57 // now the time to process the dependent libraries to resolve any remaining 58 // symbols. 59 bool is_native; 60 for (Module::lib_iterator I = Composite->lib_begin(), 61 E = Composite->lib_end(); I != E; ++I) { 62 if(LinkInLibrary(*I, is_native)) 63 return true; 64 if (is_native) 65 NativeItems.push_back(std::make_pair(*I, true)); 66 } 67 68 return false; 69 } 70 71 72 /// LinkInLibrary - links one library into the HeadModule. 73 /// 74 bool Linker::LinkInLibrary(StringRef Lib, bool& is_native) { 75 is_native = false; 76 // Determine where this library lives. 77 sys::Path Pathname = FindLib(Lib); 78 if (Pathname.isEmpty()) 79 return error("Cannot find library '" + Lib.str() + "'"); 80 81 // If its an archive, try to link it in 82 std::string Magic; 83 Pathname.getMagicNumber(Magic, 64); 84 switch (sys::IdentifyFileType(Magic.c_str(), 64)) { 85 default: llvm_unreachable("Bad file type identification"); 86 case sys::Unknown_FileType: 87 return warning("Supposed library '" + Lib.str() + "' isn't a library."); 88 89 case sys::Bitcode_FileType: 90 // LLVM ".so" file. 91 if (LinkInFile(Pathname, is_native)) 92 return true; 93 break; 94 95 case sys::Archive_FileType: 96 if (LinkInArchive(Pathname, is_native)) 97 return error("Cannot link archive '" + Pathname.str() + "'"); 98 break; 99 100 case sys::ELF_Relocatable_FileType: 101 case sys::ELF_SharedObject_FileType: 102 case sys::Mach_O_Object_FileType: 103 case sys::Mach_O_FixedVirtualMemorySharedLib_FileType: 104 case sys::Mach_O_DynamicallyLinkedSharedLib_FileType: 105 case sys::Mach_O_DynamicallyLinkedSharedLibStub_FileType: 106 case sys::COFF_FileType: 107 is_native = true; 108 break; 109 } 110 return false; 111 } 112 113 /// LinkLibraries - takes the specified library files and links them into the 114 /// main bitcode object file. 115 /// 116 /// Inputs: 117 /// Libraries - The list of libraries to link into the module. 118 /// 119 /// Return value: 120 /// FALSE - No error. 121 /// TRUE - Error. 122 /// 123 bool Linker::LinkInLibraries(const std::vector<std::string> &Libraries) { 124 125 // Process the set of libraries we've been provided. 126 bool is_native = false; 127 for (unsigned i = 0; i < Libraries.size(); ++i) 128 if (LinkInLibrary(Libraries[i], is_native)) 129 return true; 130 131 // At this point we have processed all the libraries provided to us. Since 132 // we have an aggregated module at this point, the dependent libraries in 133 // that module should also be aggregated with duplicates eliminated. This is 134 // now the time to process the dependent libraries to resolve any remaining 135 // symbols. 136 const Module::LibraryListType& DepLibs = Composite->getLibraries(); 137 for (Module::LibraryListType::const_iterator I = DepLibs.begin(), 138 E = DepLibs.end(); I != E; ++I) 139 if (LinkInLibrary(*I, is_native)) 140 return true; 141 142 return false; 143 } 144 145 /// LinkInFile - opens a bitcode file and links in all objects which 146 /// provide symbols that are currently undefined. 147 /// 148 /// Inputs: 149 /// File - The pathname of the bitcode file. 150 /// 151 /// Outputs: 152 /// ErrorMessage - A C++ string detailing what error occurred, if any. 153 /// 154 /// Return Value: 155 /// TRUE - An error occurred. 156 /// FALSE - No errors. 157 /// 158 bool Linker::LinkInFile(const sys::Path &File, bool &is_native) { 159 is_native = false; 160 161 // Check for a file of name "-", which means "read standard input" 162 if (File.str() == "-") { 163 std::auto_ptr<Module> M; 164 OwningPtr<MemoryBuffer> Buffer; 165 error_code ec; 166 if (!(ec = MemoryBuffer::getSTDIN(Buffer))) { 167 if (!Buffer->getBufferSize()) { 168 Error = "standard input is empty"; 169 } else { 170 M.reset(ParseBitcodeFile(Buffer.get(), Context, &Error)); 171 if (M.get()) 172 if (!LinkInModule(M.get(), &Error)) 173 return false; 174 } 175 } 176 return error("Cannot link stdin: " + ec.message()); 177 } 178 179 // Determine what variety of file it is. 180 std::string Magic; 181 if (!File.getMagicNumber(Magic, 64)) 182 return error("Cannot find linker input '" + File.str() + "'"); 183 184 switch (sys::IdentifyFileType(Magic.c_str(), 64)) { 185 default: llvm_unreachable("Bad file type identification"); 186 case sys::Unknown_FileType: 187 return warning("Ignoring file '" + File.str() + 188 "' because does not contain bitcode."); 189 190 case sys::Archive_FileType: 191 // A user may specify an ar archive without -l, perhaps because it 192 // is not installed as a library. Detect that and link the archive. 193 if (LinkInArchive(File, is_native)) 194 return true; 195 break; 196 197 case sys::Bitcode_FileType: { 198 verbose("Linking bitcode file '" + File.str() + "'"); 199 std::auto_ptr<Module> M(LoadObject(File)); 200 if (M.get() == 0) 201 return error("Cannot load file '" + File.str() + "': " + Error); 202 if (LinkInModule(M.get(), &Error)) 203 return error("Cannot link file '" + File.str() + "': " + Error); 204 205 verbose("Linked in file '" + File.str() + "'"); 206 break; 207 } 208 209 case sys::ELF_Relocatable_FileType: 210 case sys::ELF_SharedObject_FileType: 211 case sys::Mach_O_Object_FileType: 212 case sys::Mach_O_FixedVirtualMemorySharedLib_FileType: 213 case sys::Mach_O_DynamicallyLinkedSharedLib_FileType: 214 case sys::Mach_O_DynamicallyLinkedSharedLibStub_FileType: 215 case sys::COFF_FileType: 216 is_native = true; 217 break; 218 } 219 return false; 220 } 221 222 /// LinkFiles - takes a module and a list of files and links them all together. 223 /// It locates the file either in the current directory, as its absolute 224 /// or relative pathname, or as a file somewhere in LLVM_LIB_SEARCH_PATH. 225 /// 226 /// Inputs: 227 /// Files - A vector of sys::Path indicating the LLVM bitcode filenames 228 /// to be linked. The names can refer to a mixture of pure LLVM 229 /// bitcode files and archive (ar) formatted files. 230 /// 231 /// Return value: 232 /// FALSE - No errors. 233 /// TRUE - Some error occurred. 234 /// 235 bool Linker::LinkInFiles(const std::vector<sys::Path> &Files) { 236 bool is_native; 237 for (unsigned i = 0; i < Files.size(); ++i) 238 if (LinkInFile(Files[i], is_native)) 239 return true; 240 return false; 241 } 242
