Reid Spencer | 903f21d | 2004-12-13 03:50:50 +0000 | [diff] [blame] | 1 | //===- lib/Linker/Linker.cpp - Basic Linker functionality ----------------===// |
Misha Brukman | f976c85 | 2005-04-21 22:55:34 +0000 | [diff] [blame] | 2 | // |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Misha Brukman | f976c85 | 2005-04-21 22:55:34 +0000 | [diff] [blame] | 5 | // This file was developed by Reid Spencer and is distributed under the |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 6 | // University of Illinois Open Source License. See LICENSE.TXT for details. |
Misha Brukman | f976c85 | 2005-04-21 22:55:34 +0000 | [diff] [blame] | 7 | // |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
Reid Spencer | 903f21d | 2004-12-13 03:50:50 +0000 | [diff] [blame] | 10 | // This file contains basic Linker functionality that all usages will need. |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #include "llvm/Linker.h" |
| 15 | #include "llvm/Module.h" |
| 16 | #include "llvm/Bytecode/Reader.h" |
Chris Lattner | 1a019e5 | 2007-05-06 06:02:13 +0000 | [diff] [blame^] | 17 | #include "llvm/Bitcode/ReaderWriter.h" |
Reid Spencer | a834f5d | 2004-12-16 19:19:24 +0000 | [diff] [blame] | 18 | #include "llvm/Config/config.h" |
Chris Lattner | 1a019e5 | 2007-05-06 06:02:13 +0000 | [diff] [blame^] | 19 | #include "llvm/Support/MemoryBuffer.h" |
Bill Wendling | 41edad7 | 2006-11-27 10:09:12 +0000 | [diff] [blame] | 20 | #include "llvm/Support/Streams.h" |
Chris Lattner | f2e292c | 2007-02-07 21:41:02 +0000 | [diff] [blame] | 21 | #include "llvm/Support/Compressor.h" |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 22 | using namespace llvm; |
| 23 | |
Chris Lattner | 1a019e5 | 2007-05-06 06:02:13 +0000 | [diff] [blame^] | 24 | static const bool Bitcode = false; |
| 25 | |
Reid Spencer | 328ead9 | 2005-12-13 20:00:37 +0000 | [diff] [blame] | 26 | Linker::Linker(const std::string& progname, const std::string& modname, unsigned flags) |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 27 | : Composite(0) |
| 28 | , LibPaths() |
| 29 | , Flags(flags) |
| 30 | , Error() |
| 31 | , ProgramName(progname) |
| 32 | { |
Reid Spencer | 328ead9 | 2005-12-13 20:00:37 +0000 | [diff] [blame] | 33 | Composite = new Module(modname); |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 34 | } |
| 35 | |
| 36 | Linker::Linker(const std::string& progname, Module* aModule, unsigned flags) |
| 37 | : Composite(aModule) |
| 38 | , LibPaths() |
| 39 | , Flags(flags) |
| 40 | , Error() |
| 41 | , ProgramName(progname) |
| 42 | { |
| 43 | } |
| 44 | |
| 45 | Linker::~Linker() { |
| 46 | delete Composite; |
| 47 | } |
| 48 | |
Misha Brukman | f976c85 | 2005-04-21 22:55:34 +0000 | [diff] [blame] | 49 | bool |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 50 | Linker::error(const std::string& message) { |
| 51 | Error = message; |
Bill Wendling | 41edad7 | 2006-11-27 10:09:12 +0000 | [diff] [blame] | 52 | if (!(Flags&QuietErrors)) |
Bill Wendling | e815619 | 2006-12-07 01:30:32 +0000 | [diff] [blame] | 53 | cerr << ProgramName << ": error: " << message << "\n"; |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 54 | return true; |
| 55 | } |
| 56 | |
| 57 | bool |
| 58 | Linker::warning(const std::string& message) { |
| 59 | Error = message; |
Bill Wendling | 41edad7 | 2006-11-27 10:09:12 +0000 | [diff] [blame] | 60 | if (!(Flags&QuietErrors)) |
Bill Wendling | e815619 | 2006-12-07 01:30:32 +0000 | [diff] [blame] | 61 | cerr << ProgramName << ": warning: " << message << "\n"; |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 62 | return false; |
| 63 | } |
| 64 | |
| 65 | void |
| 66 | Linker::verbose(const std::string& message) { |
Bill Wendling | 41edad7 | 2006-11-27 10:09:12 +0000 | [diff] [blame] | 67 | if (Flags&Verbose) |
Bill Wendling | e815619 | 2006-12-07 01:30:32 +0000 | [diff] [blame] | 68 | cerr << " " << message << "\n"; |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 69 | } |
| 70 | |
| 71 | void |
| 72 | Linker::addPath(const sys::Path& path) { |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 73 | LibPaths.push_back(path); |
| 74 | } |
| 75 | |
| 76 | void |
| 77 | Linker::addPaths(const std::vector<std::string>& paths) { |
Reid Spencer | 903f21d | 2004-12-13 03:50:50 +0000 | [diff] [blame] | 78 | for (unsigned i = 0; i != paths.size(); ++i) { |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 79 | sys::Path aPath; |
Reid Spencer | dd04df0 | 2005-07-07 23:21:43 +0000 | [diff] [blame] | 80 | aPath.set(paths[i]); |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 81 | LibPaths.push_back(aPath); |
| 82 | } |
| 83 | } |
| 84 | |
| 85 | void |
| 86 | Linker::addSystemPaths() { |
| 87 | sys::Path::GetBytecodeLibraryPaths(LibPaths); |
| 88 | LibPaths.insert(LibPaths.begin(),sys::Path("./")); |
| 89 | } |
| 90 | |
| 91 | Module* |
| 92 | Linker::releaseModule() { |
| 93 | Module* result = Composite; |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 94 | LibPaths.clear(); |
| 95 | Error.clear(); |
Reid Spencer | 903f21d | 2004-12-13 03:50:50 +0000 | [diff] [blame] | 96 | Composite = 0; |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 97 | Flags = 0; |
| 98 | return result; |
| 99 | } |
| 100 | |
| 101 | // LoadObject - Read in and parse the bytecode file named by FN and return the |
Misha Brukman | f976c85 | 2005-04-21 22:55:34 +0000 | [diff] [blame] | 102 | // module it contains (wrapped in an auto_ptr), or auto_ptr<Module>() and set |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 103 | // Error if an error occurs. |
Misha Brukman | f976c85 | 2005-04-21 22:55:34 +0000 | [diff] [blame] | 104 | std::auto_ptr<Module> |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 105 | Linker::LoadObject(const sys::Path &FN) { |
| 106 | std::string ParseErrorMessage; |
Chris Lattner | 1a019e5 | 2007-05-06 06:02:13 +0000 | [diff] [blame^] | 107 | Module *Result = 0; |
| 108 | |
| 109 | const std::string &FNS = FN.toString(); |
| 110 | if (Bitcode) { |
| 111 | std::auto_ptr<MemoryBuffer> Buffer( |
| 112 | MemoryBuffer::getFileOrSTDIN(&FNS[0], FNS.size())); |
| 113 | if (Buffer.get()) |
| 114 | Result = ParseBitcodeFile(Buffer.get(), &ParseErrorMessage); |
| 115 | else |
| 116 | ParseErrorMessage = "Error reading file '" + FNS + "'"; |
| 117 | |
| 118 | } else { |
| 119 | Result = ParseBytecodeFile(FNS, Compressor::decompressToNewBuffer, |
| 120 | &ParseErrorMessage); |
| 121 | } |
Misha Brukman | f976c85 | 2005-04-21 22:55:34 +0000 | [diff] [blame] | 122 | if (Result) |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 123 | return std::auto_ptr<Module>(Result); |
| 124 | Error = "Bytecode file '" + FN.toString() + "' could not be loaded"; |
Misha Brukman | f976c85 | 2005-04-21 22:55:34 +0000 | [diff] [blame] | 125 | if (ParseErrorMessage.size()) |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 126 | Error += ": " + ParseErrorMessage; |
| 127 | return std::auto_ptr<Module>(); |
| 128 | } |
| 129 | |
Misha Brukman | f976c85 | 2005-04-21 22:55:34 +0000 | [diff] [blame] | 130 | // IsLibrary - Determine if "Name" is a library in "Directory". Return |
Reid Spencer | 903f21d | 2004-12-13 03:50:50 +0000 | [diff] [blame] | 131 | // a non-empty sys::Path if its found, an empty one otherwise. |
Misha Brukman | f976c85 | 2005-04-21 22:55:34 +0000 | [diff] [blame] | 132 | static inline sys::Path IsLibrary(const std::string& Name, |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 133 | const sys::Path& Directory) { |
| 134 | |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 135 | sys::Path FullPath(Directory); |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 136 | |
Chris Lattner | 501d529 | 2006-07-28 22:52:11 +0000 | [diff] [blame] | 137 | // Try the libX.a form |
| 138 | FullPath.appendComponent("lib" + Name); |
| 139 | FullPath.appendSuffix("a"); |
| 140 | if (FullPath.isArchive()) |
| 141 | return FullPath; |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 142 | |
Chris Lattner | 501d529 | 2006-07-28 22:52:11 +0000 | [diff] [blame] | 143 | // Try the libX.bca form |
| 144 | FullPath.eraseSuffix(); |
| 145 | FullPath.appendSuffix("bca"); |
| 146 | if (FullPath.isArchive()) |
| 147 | return FullPath; |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 148 | |
Chris Lattner | 501d529 | 2006-07-28 22:52:11 +0000 | [diff] [blame] | 149 | // Try the libX.so (or .dylib) form |
| 150 | FullPath.eraseSuffix(); |
| 151 | FullPath.appendSuffix(&(LTDL_SHLIB_EXT[1])); |
| 152 | if (FullPath.isDynamicLibrary()) // Native shared library? |
| 153 | return FullPath; |
| 154 | if (FullPath.isBytecodeFile()) // .so file containing bytecode? |
| 155 | return FullPath; |
Chris Lattner | 1a019e5 | 2007-05-06 06:02:13 +0000 | [diff] [blame^] | 156 | if (FullPath.isBitcodeFile()) // .so file containing bitcode? |
| 157 | return FullPath; |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 158 | |
Chris Lattner | 501d529 | 2006-07-28 22:52:11 +0000 | [diff] [blame] | 159 | // Not found .. fall through |
Reid Spencer | dd04df0 | 2005-07-07 23:21:43 +0000 | [diff] [blame] | 160 | |
| 161 | // Indicate that the library was not found in the directory. |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 162 | FullPath.clear(); |
| 163 | return FullPath; |
| 164 | } |
| 165 | |
| 166 | /// FindLib - Try to convert Filename into the name of a file that we can open, |
| 167 | /// if it does not already name a file we can open, by first trying to open |
| 168 | /// Filename, then libFilename.[suffix] for each of a set of several common |
Misha Brukman | f976c85 | 2005-04-21 22:55:34 +0000 | [diff] [blame] | 169 | /// library suffixes, in each of the directories in LibPaths. Returns an empty |
Reid Spencer | 903f21d | 2004-12-13 03:50:50 +0000 | [diff] [blame] | 170 | /// Path if no matching file can be found. |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 171 | /// |
Misha Brukman | f976c85 | 2005-04-21 22:55:34 +0000 | [diff] [blame] | 172 | sys::Path |
John Criswell | 43da9c6 | 2006-01-17 22:01:57 +0000 | [diff] [blame] | 173 | Linker::FindLib(const std::string &Filename) { |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 174 | // Determine if the pathname can be found as it stands. |
| 175 | sys::Path FilePath(Filename); |
Reid Spencer | c7f0832 | 2005-07-07 18:21:42 +0000 | [diff] [blame] | 176 | if (FilePath.canRead() && |
Reid Spencer | de4cedc | 2004-12-13 03:00:28 +0000 | [diff] [blame] | 177 | (FilePath.isArchive() || FilePath.isDynamicLibrary())) |
| 178 | return FilePath; |
| 179 | |
| 180 | // Iterate over the directories in Paths to see if we can find the library |
| 181 | // there. |
| 182 | for (unsigned Index = 0; Index != LibPaths.size(); ++Index) { |
| 183 | sys::Path Directory(LibPaths[Index]); |
| 184 | sys::Path FullPath = IsLibrary(Filename,Directory); |
| 185 | if (!FullPath.isEmpty()) |
| 186 | return FullPath; |
| 187 | } |
| 188 | return sys::Path(); |
| 189 | } |