Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 1 | //===- Driver.cpp ---------------------------------------------------------===// |
| 2 | // |
| 3 | // The LLVM Linker |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | |
| 10 | #include "Config.h" |
| 11 | #include "Driver.h" |
Rui Ueyama | 562daa8 | 2015-06-18 21:50:38 +0000 | [diff] [blame] | 12 | #include "Error.h" |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 13 | #include "InputFiles.h" |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 14 | #include "SymbolTable.h" |
Rui Ueyama | 685c41c | 2015-08-05 23:43:53 +0000 | [diff] [blame] | 15 | #include "Symbols.h" |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 16 | #include "Writer.h" |
Rui Ueyama | a453c0a | 2016-03-02 19:08:05 +0000 | [diff] [blame] | 17 | #include "lld/Driver/Driver.h" |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 18 | #include "llvm/ADT/Optional.h" |
Peter Collingbourne | bd1cb79 | 2015-06-09 21:52:48 +0000 | [diff] [blame] | 19 | #include "llvm/LibDriver/LibDriver.h" |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 20 | #include "llvm/Option/Arg.h" |
| 21 | #include "llvm/Option/ArgList.h" |
| 22 | #include "llvm/Option/Option.h" |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 23 | #include "llvm/Support/Debug.h" |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 24 | #include "llvm/Support/Path.h" |
Rui Ueyama | 54b71da | 2015-05-31 19:17:12 +0000 | [diff] [blame] | 25 | #include "llvm/Support/Process.h" |
Peter Collingbourne | 60c1616 | 2015-06-01 20:10:10 +0000 | [diff] [blame] | 26 | #include "llvm/Support/TargetSelect.h" |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 27 | #include "llvm/Support/raw_ostream.h" |
Rui Ueyama | 2bf6a12 | 2015-06-14 21:50:50 +0000 | [diff] [blame] | 28 | #include <algorithm> |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 29 | #include <memory> |
| 30 | |
| 31 | using namespace llvm; |
Rui Ueyama | 84936e0 | 2015-07-07 23:39:18 +0000 | [diff] [blame] | 32 | using namespace llvm::COFF; |
Rui Ueyama | 54b71da | 2015-05-31 19:17:12 +0000 | [diff] [blame] | 33 | using llvm::sys::Process; |
Peter Collingbourne | baf5f87 | 2015-06-26 19:20:09 +0000 | [diff] [blame] | 34 | using llvm::sys::fs::OpenFlags; |
Rui Ueyama | 711cd2d | 2015-05-31 21:17:10 +0000 | [diff] [blame] | 35 | using llvm::sys::fs::file_magic; |
| 36 | using llvm::sys::fs::identify_magic; |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 37 | |
Rui Ueyama | 3500f66 | 2015-05-28 20:30:06 +0000 | [diff] [blame] | 38 | namespace lld { |
| 39 | namespace coff { |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 40 | |
Rui Ueyama | 3500f66 | 2015-05-28 20:30:06 +0000 | [diff] [blame] | 41 | Configuration *Config; |
Rui Ueyama | a9cbbf8 | 2015-05-31 19:17:09 +0000 | [diff] [blame] | 42 | LinkerDriver *Driver; |
| 43 | |
Rui Ueyama | 417553d | 2016-02-28 19:54:51 +0000 | [diff] [blame] | 44 | bool link(llvm::ArrayRef<const char *> Args) { |
Rui Ueyama | 570752c | 2015-08-18 09:13:25 +0000 | [diff] [blame] | 45 | Configuration C; |
| 46 | LinkerDriver D; |
| 47 | Config = &C; |
| 48 | Driver = &D; |
Rui Ueyama | 417553d | 2016-02-28 19:54:51 +0000 | [diff] [blame] | 49 | Driver->link(Args); |
| 50 | return true; |
Rui Ueyama | a9cbbf8 | 2015-05-31 19:17:09 +0000 | [diff] [blame] | 51 | } |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 52 | |
Nico Weber | 5660de7 | 2016-04-20 22:34:15 +0000 | [diff] [blame] | 53 | // Drop directory components and replace extension with ".exe" or ".dll". |
Rui Ueyama | ad66098 | 2015-06-07 00:20:32 +0000 | [diff] [blame] | 54 | static std::string getOutputPath(StringRef Path) { |
| 55 | auto P = Path.find_last_of("\\/"); |
| 56 | StringRef S = (P == StringRef::npos) ? Path : Path.substr(P + 1); |
Nico Weber | 5660de7 | 2016-04-20 22:34:15 +0000 | [diff] [blame] | 57 | const char* E = Config->DLL ? ".dll" : ".exe"; |
| 58 | return (S.substr(0, S.rfind('.')) + E).str(); |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 59 | } |
| 60 | |
Rui Ueyama | d7c2f58 | 2015-05-31 21:04:56 +0000 | [diff] [blame] | 61 | // Opens a file. Path has to be resolved already. |
| 62 | // Newly created memory buffers are owned by this driver. |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 63 | MemoryBufferRef LinkerDriver::openFile(StringRef Path) { |
Rui Ueyama | d7c2f58 | 2015-05-31 21:04:56 +0000 | [diff] [blame] | 64 | auto MBOrErr = MemoryBuffer::getFile(Path); |
Rui Ueyama | 7e75866 | 2016-07-14 23:37:10 +0000 | [diff] [blame^] | 65 | check(MBOrErr, Twine("Could not open ") + Path); |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 66 | std::unique_ptr<MemoryBuffer> &MB = *MBOrErr; |
Rui Ueyama | d7c2f58 | 2015-05-31 21:04:56 +0000 | [diff] [blame] | 67 | MemoryBufferRef MBRef = MB->getMemBufferRef(); |
| 68 | OwningMBs.push_back(std::move(MB)); // take ownership |
Rui Ueyama | 2bf6a12 | 2015-06-14 21:50:50 +0000 | [diff] [blame] | 69 | return MBRef; |
| 70 | } |
Rui Ueyama | 711cd2d | 2015-05-31 21:17:10 +0000 | [diff] [blame] | 71 | |
Rui Ueyama | 2bf6a12 | 2015-06-14 21:50:50 +0000 | [diff] [blame] | 72 | static std::unique_ptr<InputFile> createFile(MemoryBufferRef MB) { |
Rui Ueyama | 711cd2d | 2015-05-31 21:17:10 +0000 | [diff] [blame] | 73 | // File type is detected by contents, not by file extension. |
Rui Ueyama | 2bf6a12 | 2015-06-14 21:50:50 +0000 | [diff] [blame] | 74 | file_magic Magic = identify_magic(MB.getBuffer()); |
Rui Ueyama | 711cd2d | 2015-05-31 21:17:10 +0000 | [diff] [blame] | 75 | if (Magic == file_magic::archive) |
Rui Ueyama | 2bf6a12 | 2015-06-14 21:50:50 +0000 | [diff] [blame] | 76 | return std::unique_ptr<InputFile>(new ArchiveFile(MB)); |
Peter Collingbourne | 60c1616 | 2015-06-01 20:10:10 +0000 | [diff] [blame] | 77 | if (Magic == file_magic::bitcode) |
Rui Ueyama | 2bf6a12 | 2015-06-14 21:50:50 +0000 | [diff] [blame] | 78 | return std::unique_ptr<InputFile>(new BitcodeFile(MB)); |
Rui Ueyama | ad66098 | 2015-06-07 00:20:32 +0000 | [diff] [blame] | 79 | if (Config->OutputFile == "") |
Rui Ueyama | 2bf6a12 | 2015-06-14 21:50:50 +0000 | [diff] [blame] | 80 | Config->OutputFile = getOutputPath(MB.getBufferIdentifier()); |
| 81 | return std::unique_ptr<InputFile>(new ObjectFile(MB)); |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 82 | } |
| 83 | |
Rui Ueyama | f10a320 | 2015-08-31 08:43:21 +0000 | [diff] [blame] | 84 | static bool isDecorated(StringRef Sym) { |
| 85 | return Sym.startswith("_") || Sym.startswith("@") || Sym.startswith("?"); |
| 86 | } |
| 87 | |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 88 | // Parses .drectve section contents and returns a list of files |
| 89 | // specified by /defaultlib. |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 90 | void LinkerDriver::parseDirectives(StringRef S) { |
| 91 | llvm::opt::InputArgList Args = Parser.parse(S); |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 92 | |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 93 | for (auto *Arg : Args) { |
Rui Ueyama | 562daa8 | 2015-06-18 21:50:38 +0000 | [diff] [blame] | 94 | switch (Arg->getOption().getID()) { |
| 95 | case OPT_alternatename: |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 96 | parseAlternateName(Arg->getValue()); |
Rui Ueyama | 562daa8 | 2015-06-18 21:50:38 +0000 | [diff] [blame] | 97 | break; |
| 98 | case OPT_defaultlib: |
| 99 | if (Optional<StringRef> Path = findLib(Arg->getValue())) { |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 100 | MemoryBufferRef MB = openFile(*Path); |
| 101 | Symtab.addFile(createFile(MB)); |
Rui Ueyama | 562daa8 | 2015-06-18 21:50:38 +0000 | [diff] [blame] | 102 | } |
| 103 | break; |
| 104 | case OPT_export: { |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 105 | Export E = parseExport(Arg->getValue()); |
Rui Ueyama | f10a320 | 2015-08-31 08:43:21 +0000 | [diff] [blame] | 106 | E.Directives = true; |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 107 | Config->Exports.push_back(E); |
Rui Ueyama | 562daa8 | 2015-06-18 21:50:38 +0000 | [diff] [blame] | 108 | break; |
| 109 | } |
| 110 | case OPT_failifmismatch: |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 111 | checkFailIfMismatch(Arg->getValue()); |
Rui Ueyama | 562daa8 | 2015-06-18 21:50:38 +0000 | [diff] [blame] | 112 | break; |
Rui Ueyama | 08d5e18 | 2015-06-18 23:20:11 +0000 | [diff] [blame] | 113 | case OPT_incl: |
Rui Ueyama | 32f8e1c | 2015-06-26 03:44:00 +0000 | [diff] [blame] | 114 | addUndefined(Arg->getValue()); |
Rui Ueyama | 08d5e18 | 2015-06-18 23:20:11 +0000 | [diff] [blame] | 115 | break; |
Rui Ueyama | ce86c99 | 2015-06-18 23:22:39 +0000 | [diff] [blame] | 116 | case OPT_merge: |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 117 | parseMerge(Arg->getValue()); |
Rui Ueyama | ce86c99 | 2015-06-18 23:22:39 +0000 | [diff] [blame] | 118 | break; |
| 119 | case OPT_nodefaultlib: |
| 120 | Config->NoDefaultLibs.insert(doFindLib(Arg->getValue())); |
| 121 | break; |
Rui Ueyama | 440138c | 2016-06-20 03:39:39 +0000 | [diff] [blame] | 122 | case OPT_section: |
| 123 | parseSection(Arg->getValue()); |
| 124 | break; |
Rui Ueyama | 3c4737d | 2015-08-11 16:46:08 +0000 | [diff] [blame] | 125 | case OPT_editandcontinue: |
Reid Kleckner | 9cd77ce | 2016-03-25 18:09:29 +0000 | [diff] [blame] | 126 | case OPT_fastfail: |
Rui Ueyama | 31e66e3 | 2015-09-03 16:20:47 +0000 | [diff] [blame] | 127 | case OPT_guardsym: |
Rui Ueyama | 43238317 | 2015-07-29 21:01:15 +0000 | [diff] [blame] | 128 | case OPT_throwingnew: |
Rui Ueyama | 4668263 | 2015-07-29 20:29:15 +0000 | [diff] [blame] | 129 | break; |
Rui Ueyama | 562daa8 | 2015-06-18 21:50:38 +0000 | [diff] [blame] | 130 | default: |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 131 | error(Twine(Arg->getSpelling()) + " is not allowed in .drectve"); |
Rui Ueyama | d7c2f58 | 2015-05-31 21:04:56 +0000 | [diff] [blame] | 132 | } |
| 133 | } |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 134 | } |
| 135 | |
Rui Ueyama | 54b71da | 2015-05-31 19:17:12 +0000 | [diff] [blame] | 136 | // Find file from search paths. You can omit ".obj", this function takes |
| 137 | // care of that. Note that the returned path is not guaranteed to exist. |
Rui Ueyama | d21b00b | 2015-05-31 19:17:14 +0000 | [diff] [blame] | 138 | StringRef LinkerDriver::doFindFile(StringRef Filename) { |
Rui Ueyama | 54b71da | 2015-05-31 19:17:12 +0000 | [diff] [blame] | 139 | bool hasPathSep = (Filename.find_first_of("/\\") != StringRef::npos); |
| 140 | if (hasPathSep) |
| 141 | return Filename; |
| 142 | bool hasExt = (Filename.find('.') != StringRef::npos); |
| 143 | for (StringRef Dir : SearchPaths) { |
| 144 | SmallString<128> Path = Dir; |
| 145 | llvm::sys::path::append(Path, Filename); |
| 146 | if (llvm::sys::fs::exists(Path.str())) |
| 147 | return Alloc.save(Path.str()); |
| 148 | if (!hasExt) { |
| 149 | Path.append(".obj"); |
| 150 | if (llvm::sys::fs::exists(Path.str())) |
| 151 | return Alloc.save(Path.str()); |
| 152 | } |
| 153 | } |
| 154 | return Filename; |
| 155 | } |
| 156 | |
Rui Ueyama | d21b00b | 2015-05-31 19:17:14 +0000 | [diff] [blame] | 157 | // Resolves a file path. This never returns the same path |
| 158 | // (in that case, it returns None). |
| 159 | Optional<StringRef> LinkerDriver::findFile(StringRef Filename) { |
| 160 | StringRef Path = doFindFile(Filename); |
| 161 | bool Seen = !VisitedFiles.insert(Path.lower()).second; |
| 162 | if (Seen) |
| 163 | return None; |
| 164 | return Path; |
Rui Ueyama | 54b71da | 2015-05-31 19:17:12 +0000 | [diff] [blame] | 165 | } |
| 166 | |
Rui Ueyama | d21b00b | 2015-05-31 19:17:14 +0000 | [diff] [blame] | 167 | // Find library file from search path. |
| 168 | StringRef LinkerDriver::doFindLib(StringRef Filename) { |
| 169 | // Add ".lib" to Filename if that has no file extension. |
Rui Ueyama | 54b71da | 2015-05-31 19:17:12 +0000 | [diff] [blame] | 170 | bool hasExt = (Filename.find('.') != StringRef::npos); |
Rui Ueyama | d21b00b | 2015-05-31 19:17:14 +0000 | [diff] [blame] | 171 | if (!hasExt) |
| 172 | Filename = Alloc.save(Filename + ".lib"); |
| 173 | return doFindFile(Filename); |
| 174 | } |
| 175 | |
| 176 | // Resolves a library path. /nodefaultlib options are taken into |
| 177 | // consideration. This never returns the same path (in that case, |
| 178 | // it returns None). |
| 179 | Optional<StringRef> LinkerDriver::findLib(StringRef Filename) { |
| 180 | if (Config->NoDefaultLibAll) |
| 181 | return None; |
| 182 | StringRef Path = doFindLib(Filename); |
| 183 | if (Config->NoDefaultLibs.count(Path)) |
| 184 | return None; |
| 185 | bool Seen = !VisitedFiles.insert(Path.lower()).second; |
| 186 | if (Seen) |
| 187 | return None; |
| 188 | return Path; |
Rui Ueyama | 54b71da | 2015-05-31 19:17:12 +0000 | [diff] [blame] | 189 | } |
| 190 | |
| 191 | // Parses LIB environment which contains a list of search paths. |
Rui Ueyama | f00df0a | 2015-06-19 22:39:48 +0000 | [diff] [blame] | 192 | void LinkerDriver::addLibSearchPaths() { |
Rui Ueyama | 54b71da | 2015-05-31 19:17:12 +0000 | [diff] [blame] | 193 | Optional<std::string> EnvOpt = Process::GetEnv("LIB"); |
| 194 | if (!EnvOpt.hasValue()) |
Rui Ueyama | f00df0a | 2015-06-19 22:39:48 +0000 | [diff] [blame] | 195 | return; |
Rui Ueyama | 54b71da | 2015-05-31 19:17:12 +0000 | [diff] [blame] | 196 | StringRef Env = Alloc.save(*EnvOpt); |
| 197 | while (!Env.empty()) { |
| 198 | StringRef Path; |
| 199 | std::tie(Path, Env) = Env.split(';'); |
Rui Ueyama | f00df0a | 2015-06-19 22:39:48 +0000 | [diff] [blame] | 200 | SearchPaths.push_back(Path); |
Rui Ueyama | 54b71da | 2015-05-31 19:17:12 +0000 | [diff] [blame] | 201 | } |
Rui Ueyama | 54b71da | 2015-05-31 19:17:12 +0000 | [diff] [blame] | 202 | } |
| 203 | |
Rui Ueyama | 6bf638e | 2015-07-02 00:04:14 +0000 | [diff] [blame] | 204 | Undefined *LinkerDriver::addUndefined(StringRef Name) { |
| 205 | Undefined *U = Symtab.addUndefined(Name); |
Rui Ueyama | 18f8d2c | 2015-07-02 00:21:08 +0000 | [diff] [blame] | 206 | Config->GCRoot.insert(U); |
Rui Ueyama | 6bf638e | 2015-07-02 00:04:14 +0000 | [diff] [blame] | 207 | return U; |
Rui Ueyama | 32f8e1c | 2015-06-26 03:44:00 +0000 | [diff] [blame] | 208 | } |
| 209 | |
Rui Ueyama | 7c3e23f | 2015-07-09 01:25:49 +0000 | [diff] [blame] | 210 | // Symbol names are mangled by appending "_" prefix on x86. |
| 211 | StringRef LinkerDriver::mangle(StringRef Sym) { |
Rui Ueyama | 5e706b3 | 2015-07-25 21:54:50 +0000 | [diff] [blame] | 212 | assert(Config->Machine != IMAGE_FILE_MACHINE_UNKNOWN); |
| 213 | if (Config->Machine == I386) |
Rui Ueyama | 7c3e23f | 2015-07-09 01:25:49 +0000 | [diff] [blame] | 214 | return Alloc.save("_" + Sym); |
| 215 | return Sym; |
| 216 | } |
| 217 | |
Rui Ueyama | 45044f4 | 2015-06-29 01:03:53 +0000 | [diff] [blame] | 218 | // Windows specific -- find default entry point name. |
| 219 | StringRef LinkerDriver::findDefaultEntry() { |
| 220 | // User-defined main functions and their corresponding entry points. |
| 221 | static const char *Entries[][2] = { |
| 222 | {"main", "mainCRTStartup"}, |
| 223 | {"wmain", "wmainCRTStartup"}, |
| 224 | {"WinMain", "WinMainCRTStartup"}, |
| 225 | {"wWinMain", "wWinMainCRTStartup"}, |
| 226 | }; |
| 227 | for (auto E : Entries) { |
Rui Ueyama | a50387f | 2015-07-14 02:58:13 +0000 | [diff] [blame] | 228 | StringRef Entry = Symtab.findMangle(mangle(E[0])); |
| 229 | if (!Entry.empty() && !isa<Undefined>(Symtab.find(Entry)->Body)) |
Rui Ueyama | 7c3e23f | 2015-07-09 01:25:49 +0000 | [diff] [blame] | 230 | return mangle(E[1]); |
Rui Ueyama | 45044f4 | 2015-06-29 01:03:53 +0000 | [diff] [blame] | 231 | } |
| 232 | return ""; |
| 233 | } |
| 234 | |
| 235 | WindowsSubsystem LinkerDriver::inferSubsystem() { |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 236 | if (Config->DLL) |
| 237 | return IMAGE_SUBSYSTEM_WINDOWS_GUI; |
Rui Ueyama | 611add2 | 2015-08-08 00:23:37 +0000 | [diff] [blame] | 238 | if (Symtab.findUnderscore("main") || Symtab.findUnderscore("wmain")) |
Rui Ueyama | 45044f4 | 2015-06-29 01:03:53 +0000 | [diff] [blame] | 239 | return IMAGE_SUBSYSTEM_WINDOWS_CUI; |
Rui Ueyama | 611add2 | 2015-08-08 00:23:37 +0000 | [diff] [blame] | 240 | if (Symtab.findUnderscore("WinMain") || Symtab.findUnderscore("wWinMain")) |
Rui Ueyama | 45044f4 | 2015-06-29 01:03:53 +0000 | [diff] [blame] | 241 | return IMAGE_SUBSYSTEM_WINDOWS_GUI; |
| 242 | return IMAGE_SUBSYSTEM_UNKNOWN; |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 243 | } |
| 244 | |
Rui Ueyama | 5c437cd | 2015-07-25 21:42:33 +0000 | [diff] [blame] | 245 | static uint64_t getDefaultImageBase() { |
| 246 | if (Config->is64()) |
| 247 | return Config->DLL ? 0x180000000 : 0x140000000; |
| 248 | return Config->DLL ? 0x10000000 : 0x400000; |
| 249 | } |
| 250 | |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 251 | void LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) { |
Rui Ueyama | 27e470a | 2015-08-09 20:45:17 +0000 | [diff] [blame] | 252 | // If the first command line argument is "/lib", link.exe acts like lib.exe. |
| 253 | // We call our own implementation of lib.exe that understands bitcode files. |
| 254 | if (ArgsArr.size() > 1 && StringRef(ArgsArr[1]).equals_lower("/lib")) { |
| 255 | if (llvm::libDriverMain(ArgsArr.slice(1)) != 0) |
| 256 | error("lib failed"); |
| 257 | return; |
| 258 | } |
| 259 | |
Peter Collingbourne | 60c1616 | 2015-06-01 20:10:10 +0000 | [diff] [blame] | 260 | // Needed for LTO. |
| 261 | llvm::InitializeAllTargetInfos(); |
| 262 | llvm::InitializeAllTargets(); |
| 263 | llvm::InitializeAllTargetMCs(); |
| 264 | llvm::InitializeAllAsmParsers(); |
| 265 | llvm::InitializeAllAsmPrinters(); |
| 266 | llvm::InitializeAllDisassemblers(); |
| 267 | |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 268 | // Parse command line options. |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 269 | llvm::opt::InputArgList Args = Parser.parseLINK(ArgsArr.slice(1)); |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 270 | |
Rui Ueyama | 5c72643 | 2015-05-29 16:11:52 +0000 | [diff] [blame] | 271 | // Handle /help |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 272 | if (Args.hasArg(OPT_help)) { |
David Blaikie | b2b1c7c | 2015-06-21 06:32:10 +0000 | [diff] [blame] | 273 | printHelp(ArgsArr[0]); |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 274 | return; |
Rui Ueyama | 5c72643 | 2015-05-29 16:11:52 +0000 | [diff] [blame] | 275 | } |
| 276 | |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 277 | if (Args.filtered_begin(OPT_INPUT) == Args.filtered_end()) |
| 278 | error("no input files."); |
Rui Ueyama | 3d3e6fb | 2015-05-29 16:06:00 +0000 | [diff] [blame] | 279 | |
Rui Ueyama | f00df0a | 2015-06-19 22:39:48 +0000 | [diff] [blame] | 280 | // Construct search path list. |
| 281 | SearchPaths.push_back(""); |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 282 | for (auto *Arg : Args.filtered(OPT_libpath)) |
Rui Ueyama | f00df0a | 2015-06-19 22:39:48 +0000 | [diff] [blame] | 283 | SearchPaths.push_back(Arg->getValue()); |
| 284 | addLibSearchPaths(); |
| 285 | |
Rui Ueyama | ad66098 | 2015-06-07 00:20:32 +0000 | [diff] [blame] | 286 | // Handle /out |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 287 | if (auto *Arg = Args.getLastArg(OPT_out)) |
Rui Ueyama | ad66098 | 2015-06-07 00:20:32 +0000 | [diff] [blame] | 288 | Config->OutputFile = Arg->getValue(); |
| 289 | |
Rui Ueyama | 3d3e6fb | 2015-05-29 16:06:00 +0000 | [diff] [blame] | 290 | // Handle /verbose |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 291 | if (Args.hasArg(OPT_verbose)) |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 292 | Config->Verbose = true; |
Rui Ueyama | 3d3e6fb | 2015-05-29 16:06:00 +0000 | [diff] [blame] | 293 | |
Rui Ueyama | 95925fd | 2015-06-28 19:35:15 +0000 | [diff] [blame] | 294 | // Handle /force or /force:unresolved |
| 295 | if (Args.hasArg(OPT_force) || Args.hasArg(OPT_force_unresolved)) |
| 296 | Config->Force = true; |
| 297 | |
Rui Ueyama | 6600eb1 | 2015-07-04 23:37:32 +0000 | [diff] [blame] | 298 | // Handle /debug |
| 299 | if (Args.hasArg(OPT_debug)) |
| 300 | Config->Debug = true; |
| 301 | |
Rui Ueyama | a8b6045 | 2015-06-28 19:56:30 +0000 | [diff] [blame] | 302 | // Handle /noentry |
| 303 | if (Args.hasArg(OPT_noentry)) { |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 304 | if (!Args.hasArg(OPT_dll)) |
| 305 | error("/noentry must be specified with /dll"); |
Rui Ueyama | a8b6045 | 2015-06-28 19:56:30 +0000 | [diff] [blame] | 306 | Config->NoEntry = true; |
| 307 | } |
| 308 | |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 309 | // Handle /dll |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 310 | if (Args.hasArg(OPT_dll)) { |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 311 | Config->DLL = true; |
Rui Ueyama | 24c5fd0 | 2015-06-18 00:12:42 +0000 | [diff] [blame] | 312 | Config->ManifestID = 2; |
| 313 | } |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 314 | |
Rui Ueyama | 588e832 | 2015-06-15 01:23:58 +0000 | [diff] [blame] | 315 | // Handle /fixed |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 316 | if (Args.hasArg(OPT_fixed)) { |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 317 | if (Args.hasArg(OPT_dynamicbase)) |
| 318 | error("/fixed must not be specified with /dynamicbase"); |
Rui Ueyama | 588e832 | 2015-06-15 01:23:58 +0000 | [diff] [blame] | 319 | Config->Relocatable = false; |
Rui Ueyama | 6592ff8 | 2015-06-16 23:13:00 +0000 | [diff] [blame] | 320 | Config->DynamicBase = false; |
| 321 | } |
Rui Ueyama | 588e832 | 2015-06-15 01:23:58 +0000 | [diff] [blame] | 322 | |
Rui Ueyama | 3d3e6fb | 2015-05-29 16:06:00 +0000 | [diff] [blame] | 323 | // Handle /machine |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 324 | if (auto *Arg = Args.getLastArg(OPT_machine)) |
| 325 | Config->Machine = getMachineType(Arg->getValue()); |
Rui Ueyama | 3d3e6fb | 2015-05-29 16:06:00 +0000 | [diff] [blame] | 326 | |
Rui Ueyama | d21b00b | 2015-05-31 19:17:14 +0000 | [diff] [blame] | 327 | // Handle /nodefaultlib:<filename> |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 328 | for (auto *Arg : Args.filtered(OPT_nodefaultlib)) |
Rui Ueyama | d21b00b | 2015-05-31 19:17:14 +0000 | [diff] [blame] | 329 | Config->NoDefaultLibs.insert(doFindLib(Arg->getValue())); |
| 330 | |
| 331 | // Handle /nodefaultlib |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 332 | if (Args.hasArg(OPT_nodefaultlib_all)) |
Rui Ueyama | d21b00b | 2015-05-31 19:17:14 +0000 | [diff] [blame] | 333 | Config->NoDefaultLibAll = true; |
| 334 | |
Rui Ueyama | 804a8b6 | 2015-05-29 16:18:15 +0000 | [diff] [blame] | 335 | // Handle /base |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 336 | if (auto *Arg = Args.getLastArg(OPT_base)) |
| 337 | parseNumbers(Arg->getValue(), &Config->ImageBase); |
Rui Ueyama | b41b7e5 | 2015-05-29 16:21:11 +0000 | [diff] [blame] | 338 | |
| 339 | // Handle /stack |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 340 | if (auto *Arg = Args.getLastArg(OPT_stack)) |
| 341 | parseNumbers(Arg->getValue(), &Config->StackReserve, &Config->StackCommit); |
Rui Ueyama | 804a8b6 | 2015-05-29 16:18:15 +0000 | [diff] [blame] | 342 | |
Rui Ueyama | c377e9a | 2015-05-29 16:23:40 +0000 | [diff] [blame] | 343 | // Handle /heap |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 344 | if (auto *Arg = Args.getLastArg(OPT_heap)) |
| 345 | parseNumbers(Arg->getValue(), &Config->HeapReserve, &Config->HeapCommit); |
Rui Ueyama | c377e9a | 2015-05-29 16:23:40 +0000 | [diff] [blame] | 346 | |
Rui Ueyama | b9dcdb5 | 2015-05-29 16:28:29 +0000 | [diff] [blame] | 347 | // Handle /version |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 348 | if (auto *Arg = Args.getLastArg(OPT_version)) |
| 349 | parseVersion(Arg->getValue(), &Config->MajorImageVersion, |
| 350 | &Config->MinorImageVersion); |
Rui Ueyama | b9dcdb5 | 2015-05-29 16:28:29 +0000 | [diff] [blame] | 351 | |
Rui Ueyama | 15cc47e | 2015-05-29 16:34:31 +0000 | [diff] [blame] | 352 | // Handle /subsystem |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 353 | if (auto *Arg = Args.getLastArg(OPT_subsystem)) |
| 354 | parseSubsystem(Arg->getValue(), &Config->Subsystem, &Config->MajorOSVersion, |
| 355 | &Config->MinorOSVersion); |
Rui Ueyama | 15cc47e | 2015-05-29 16:34:31 +0000 | [diff] [blame] | 356 | |
Rui Ueyama | 2edb35a | 2015-06-18 19:09:30 +0000 | [diff] [blame] | 357 | // Handle /alternatename |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 358 | for (auto *Arg : Args.filtered(OPT_alternatename)) |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 359 | parseAlternateName(Arg->getValue()); |
Rui Ueyama | 2edb35a | 2015-06-18 19:09:30 +0000 | [diff] [blame] | 360 | |
Rui Ueyama | 08d5e18 | 2015-06-18 23:20:11 +0000 | [diff] [blame] | 361 | // Handle /include |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 362 | for (auto *Arg : Args.filtered(OPT_incl)) |
Rui Ueyama | 32f8e1c | 2015-06-26 03:44:00 +0000 | [diff] [blame] | 363 | addUndefined(Arg->getValue()); |
Rui Ueyama | 08d5e18 | 2015-06-18 23:20:11 +0000 | [diff] [blame] | 364 | |
Rui Ueyama | b95188c | 2015-06-18 20:27:09 +0000 | [diff] [blame] | 365 | // Handle /implib |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 366 | if (auto *Arg = Args.getLastArg(OPT_implib)) |
Rui Ueyama | b95188c | 2015-06-18 20:27:09 +0000 | [diff] [blame] | 367 | Config->Implib = Arg->getValue(); |
| 368 | |
Rui Ueyama | e2cbfea | 2015-06-07 03:17:42 +0000 | [diff] [blame] | 369 | // Handle /opt |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 370 | for (auto *Arg : Args.filtered(OPT_opt)) { |
Rui Ueyama | 75656ee | 2015-10-19 19:40:43 +0000 | [diff] [blame] | 371 | std::string Str = StringRef(Arg->getValue()).lower(); |
| 372 | SmallVector<StringRef, 1> Vec; |
| 373 | StringRef(Str).split(Vec, ','); |
| 374 | for (StringRef S : Vec) { |
| 375 | if (S == "noref") { |
| 376 | Config->DoGC = false; |
| 377 | Config->DoICF = false; |
| 378 | continue; |
| 379 | } |
| 380 | if (S == "icf" || StringRef(S).startswith("icf=")) { |
| 381 | Config->DoICF = true; |
| 382 | continue; |
| 383 | } |
| 384 | if (S == "noicf") { |
| 385 | Config->DoICF = false; |
| 386 | continue; |
| 387 | } |
| 388 | if (StringRef(S).startswith("lldlto=")) { |
| 389 | StringRef OptLevel = StringRef(S).substr(7); |
| 390 | if (OptLevel.getAsInteger(10, Config->LTOOptLevel) || |
| 391 | Config->LTOOptLevel > 3) |
| 392 | error("/opt:lldlto: invalid optimization level: " + OptLevel); |
| 393 | continue; |
| 394 | } |
| 395 | if (StringRef(S).startswith("lldltojobs=")) { |
| 396 | StringRef Jobs = StringRef(S).substr(11); |
| 397 | if (Jobs.getAsInteger(10, Config->LTOJobs) || Config->LTOJobs == 0) |
| 398 | error("/opt:lldltojobs: invalid job count: " + Jobs); |
| 399 | continue; |
| 400 | } |
| 401 | if (S != "ref" && S != "lbr" && S != "nolbr") |
| 402 | error(Twine("/opt: unknown option: ") + S); |
Rui Ueyama | e2cbfea | 2015-06-07 03:17:42 +0000 | [diff] [blame] | 403 | } |
Rui Ueyama | e2cbfea | 2015-06-07 03:17:42 +0000 | [diff] [blame] | 404 | } |
| 405 | |
Rui Ueyama | 8854d8a | 2015-06-04 19:21:24 +0000 | [diff] [blame] | 406 | // Handle /failifmismatch |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 407 | for (auto *Arg : Args.filtered(OPT_failifmismatch)) |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 408 | checkFailIfMismatch(Arg->getValue()); |
Rui Ueyama | 8854d8a | 2015-06-04 19:21:24 +0000 | [diff] [blame] | 409 | |
Rui Ueyama | 6600eb1 | 2015-07-04 23:37:32 +0000 | [diff] [blame] | 410 | // Handle /merge |
| 411 | for (auto *Arg : Args.filtered(OPT_merge)) |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 412 | parseMerge(Arg->getValue()); |
Rui Ueyama | 6600eb1 | 2015-07-04 23:37:32 +0000 | [diff] [blame] | 413 | |
Rui Ueyama | 440138c | 2016-06-20 03:39:39 +0000 | [diff] [blame] | 414 | // Handle /section |
| 415 | for (auto *Arg : Args.filtered(OPT_section)) |
| 416 | parseSection(Arg->getValue()); |
| 417 | |
Rui Ueyama | 24c5fd0 | 2015-06-18 00:12:42 +0000 | [diff] [blame] | 418 | // Handle /manifest |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 419 | if (auto *Arg = Args.getLastArg(OPT_manifest_colon)) |
| 420 | parseManifest(Arg->getValue()); |
Rui Ueyama | 24c5fd0 | 2015-06-18 00:12:42 +0000 | [diff] [blame] | 421 | |
| 422 | // Handle /manifestuac |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 423 | if (auto *Arg = Args.getLastArg(OPT_manifestuac)) |
| 424 | parseManifestUAC(Arg->getValue()); |
Rui Ueyama | 24c5fd0 | 2015-06-18 00:12:42 +0000 | [diff] [blame] | 425 | |
| 426 | // Handle /manifestdependency |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 427 | if (auto *Arg = Args.getLastArg(OPT_manifestdependency)) |
Rui Ueyama | 24c5fd0 | 2015-06-18 00:12:42 +0000 | [diff] [blame] | 428 | Config->ManifestDependency = Arg->getValue(); |
| 429 | |
| 430 | // Handle /manifestfile |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 431 | if (auto *Arg = Args.getLastArg(OPT_manifestfile)) |
Rui Ueyama | 24c5fd0 | 2015-06-18 00:12:42 +0000 | [diff] [blame] | 432 | Config->ManifestFile = Arg->getValue(); |
| 433 | |
Rui Ueyama | afb1901 | 2016-04-19 01:21:58 +0000 | [diff] [blame] | 434 | // Handle /manifestinput |
| 435 | for (auto *Arg : Args.filtered(OPT_manifestinput)) |
| 436 | Config->ManifestInput.push_back(Arg->getValue()); |
| 437 | |
Rui Ueyama | 6592ff8 | 2015-06-16 23:13:00 +0000 | [diff] [blame] | 438 | // Handle miscellaneous boolean flags. |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 439 | if (Args.hasArg(OPT_allowbind_no)) |
| 440 | Config->AllowBind = false; |
| 441 | if (Args.hasArg(OPT_allowisolation_no)) |
| 442 | Config->AllowIsolation = false; |
| 443 | if (Args.hasArg(OPT_dynamicbase_no)) |
| 444 | Config->DynamicBase = false; |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 445 | if (Args.hasArg(OPT_nxcompat_no)) |
| 446 | Config->NxCompat = false; |
| 447 | if (Args.hasArg(OPT_tsaware_no)) |
| 448 | Config->TerminalServerAware = false; |
Rui Ueyama | 9640173 | 2015-09-21 23:43:31 +0000 | [diff] [blame] | 449 | if (Args.hasArg(OPT_nosymtab)) |
| 450 | Config->WriteSymtab = false; |
Rui Ueyama | 6592ff8 | 2015-06-16 23:13:00 +0000 | [diff] [blame] | 451 | |
Rui Ueyama | d21b00b | 2015-05-31 19:17:14 +0000 | [diff] [blame] | 452 | // Create a list of input files. Files can be given as arguments |
| 453 | // for /defaultlib option. |
Rui Ueyama | ea533cd | 2015-07-09 19:54:13 +0000 | [diff] [blame] | 454 | std::vector<StringRef> Paths; |
| 455 | std::vector<MemoryBufferRef> MBs; |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 456 | for (auto *Arg : Args.filtered(OPT_INPUT)) |
Rui Ueyama | d21b00b | 2015-05-31 19:17:14 +0000 | [diff] [blame] | 457 | if (Optional<StringRef> Path = findFile(Arg->getValue())) |
Rui Ueyama | ea533cd | 2015-07-09 19:54:13 +0000 | [diff] [blame] | 458 | Paths.push_back(*Path); |
David Blaikie | 6521ed9 | 2015-06-22 22:06:52 +0000 | [diff] [blame] | 459 | for (auto *Arg : Args.filtered(OPT_defaultlib)) |
Rui Ueyama | d21b00b | 2015-05-31 19:17:14 +0000 | [diff] [blame] | 460 | if (Optional<StringRef> Path = findLib(Arg->getValue())) |
Rui Ueyama | ea533cd | 2015-07-09 19:54:13 +0000 | [diff] [blame] | 461 | Paths.push_back(*Path); |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 462 | for (StringRef Path : Paths) |
| 463 | MBs.push_back(openFile(Path)); |
Rui Ueyama | d21b00b | 2015-05-31 19:17:14 +0000 | [diff] [blame] | 464 | |
Rui Ueyama | 24c5fd0 | 2015-06-18 00:12:42 +0000 | [diff] [blame] | 465 | // Windows specific -- Create a resource file containing a manifest file. |
| 466 | if (Config->Manifest == Configuration::Embed) { |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 467 | std::unique_ptr<MemoryBuffer> MB = createManifestRes(); |
Rui Ueyama | ea533cd | 2015-07-09 19:54:13 +0000 | [diff] [blame] | 468 | MBs.push_back(MB->getMemBufferRef()); |
Rui Ueyama | 24c5fd0 | 2015-06-18 00:12:42 +0000 | [diff] [blame] | 469 | OwningMBs.push_back(std::move(MB)); // take ownership |
| 470 | } |
| 471 | |
Rui Ueyama | 2bf6a12 | 2015-06-14 21:50:50 +0000 | [diff] [blame] | 472 | // Windows specific -- Input files can be Windows resource files (.res files). |
| 473 | // We invoke cvtres.exe to convert resource files to a regular COFF file |
| 474 | // then link the result file normally. |
Rui Ueyama | ea533cd | 2015-07-09 19:54:13 +0000 | [diff] [blame] | 475 | std::vector<MemoryBufferRef> Resources; |
Rui Ueyama | 77731b4 | 2015-06-26 23:59:13 +0000 | [diff] [blame] | 476 | auto NotResource = [](MemoryBufferRef MB) { |
| 477 | return identify_magic(MB.getBuffer()) != file_magic::windows_resource; |
Rui Ueyama | 2bf6a12 | 2015-06-14 21:50:50 +0000 | [diff] [blame] | 478 | }; |
Rui Ueyama | ea533cd | 2015-07-09 19:54:13 +0000 | [diff] [blame] | 479 | auto It = std::stable_partition(MBs.begin(), MBs.end(), NotResource); |
| 480 | if (It != MBs.end()) { |
| 481 | Resources.insert(Resources.end(), It, MBs.end()); |
| 482 | MBs.erase(It, MBs.end()); |
Rui Ueyama | 2bf6a12 | 2015-06-14 21:50:50 +0000 | [diff] [blame] | 483 | } |
| 484 | |
Rui Ueyama | 85225b0 | 2015-07-02 03:15:15 +0000 | [diff] [blame] | 485 | // Read all input files given via the command line. Note that step() |
| 486 | // doesn't read files that are specified by directive sections. |
Rui Ueyama | ea533cd | 2015-07-09 19:54:13 +0000 | [diff] [blame] | 487 | for (MemoryBufferRef MB : MBs) |
Rui Ueyama | 0d2e999 | 2015-06-23 23:56:39 +0000 | [diff] [blame] | 488 | Symtab.addFile(createFile(MB)); |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 489 | Symtab.step(); |
Rui Ueyama | 5cff685 | 2015-05-31 03:34:08 +0000 | [diff] [blame] | 490 | |
Rui Ueyama | ea533cd | 2015-07-09 19:54:13 +0000 | [diff] [blame] | 491 | // Determine machine type and check if all object files are |
| 492 | // for the same CPU type. Note that this needs to be done before |
| 493 | // any call to mangle(). |
| 494 | for (std::unique_ptr<InputFile> &File : Symtab.getFiles()) { |
| 495 | MachineTypes MT = File->getMachineType(); |
| 496 | if (MT == IMAGE_FILE_MACHINE_UNKNOWN) |
| 497 | continue; |
Rui Ueyama | 5e706b3 | 2015-07-25 21:54:50 +0000 | [diff] [blame] | 498 | if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) { |
| 499 | Config->Machine = MT; |
Rui Ueyama | ea533cd | 2015-07-09 19:54:13 +0000 | [diff] [blame] | 500 | continue; |
| 501 | } |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 502 | if (Config->Machine != MT) |
| 503 | error(Twine(File->getShortName()) + ": machine type " + machineToStr(MT) + |
| 504 | " conflicts with " + machineToStr(Config->Machine)); |
Rui Ueyama | ea533cd | 2015-07-09 19:54:13 +0000 | [diff] [blame] | 505 | } |
Rui Ueyama | 5e706b3 | 2015-07-25 21:54:50 +0000 | [diff] [blame] | 506 | if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) { |
Rui Ueyama | ea533cd | 2015-07-09 19:54:13 +0000 | [diff] [blame] | 507 | llvm::errs() << "warning: /machine is not specified. x64 is assumed.\n"; |
Rui Ueyama | 5e706b3 | 2015-07-25 21:54:50 +0000 | [diff] [blame] | 508 | Config->Machine = AMD64; |
Rui Ueyama | ea533cd | 2015-07-09 19:54:13 +0000 | [diff] [blame] | 509 | } |
| 510 | |
| 511 | // Windows specific -- Convert Windows resource files to a COFF file. |
| 512 | if (!Resources.empty()) { |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 513 | std::unique_ptr<MemoryBuffer> MB = convertResToCOFF(Resources); |
Rui Ueyama | ea533cd | 2015-07-09 19:54:13 +0000 | [diff] [blame] | 514 | Symtab.addFile(createFile(MB->getMemBufferRef())); |
| 515 | OwningMBs.push_back(std::move(MB)); // take ownership |
| 516 | } |
| 517 | |
Rui Ueyama | 4d54534 | 2015-07-28 03:12:00 +0000 | [diff] [blame] | 518 | // Handle /largeaddressaware |
| 519 | if (Config->is64() || Args.hasArg(OPT_largeaddressaware)) |
| 520 | Config->LargeAddressAware = true; |
| 521 | |
Rui Ueyama | d68e211 | 2015-07-28 03:15:57 +0000 | [diff] [blame] | 522 | // Handle /highentropyva |
| 523 | if (Config->is64() && !Args.hasArg(OPT_highentropyva_no)) |
| 524 | Config->HighEntropyVA = true; |
| 525 | |
Rui Ueyama | bbdec4f | 2015-07-09 22:51:41 +0000 | [diff] [blame] | 526 | // Handle /entry and /dll |
| 527 | if (auto *Arg = Args.getLastArg(OPT_entry)) { |
| 528 | Config->Entry = addUndefined(mangle(Arg->getValue())); |
| 529 | } else if (Args.hasArg(OPT_dll) && !Config->NoEntry) { |
Rui Ueyama | 5e706b3 | 2015-07-25 21:54:50 +0000 | [diff] [blame] | 530 | StringRef S = (Config->Machine == I386) ? "__DllMainCRTStartup@12" |
| 531 | : "_DllMainCRTStartup"; |
Rui Ueyama | bbdec4f | 2015-07-09 22:51:41 +0000 | [diff] [blame] | 532 | Config->Entry = addUndefined(S); |
| 533 | } else if (!Config->NoEntry) { |
| 534 | // Windows specific -- If entry point name is not given, we need to |
| 535 | // infer that from user-defined entry name. |
Rui Ueyama | 45044f4 | 2015-06-29 01:03:53 +0000 | [diff] [blame] | 536 | StringRef S = findDefaultEntry(); |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 537 | if (S.empty()) |
| 538 | error("entry point must be defined"); |
Rui Ueyama | 6bf638e | 2015-07-02 00:04:14 +0000 | [diff] [blame] | 539 | Config->Entry = addUndefined(S); |
Rui Ueyama | 85225b0 | 2015-07-02 03:15:15 +0000 | [diff] [blame] | 540 | if (Config->Verbose) |
| 541 | llvm::outs() << "Entry name inferred: " << S << "\n"; |
Rui Ueyama | 45044f4 | 2015-06-29 01:03:53 +0000 | [diff] [blame] | 542 | } |
| 543 | |
Rui Ueyama | bbdec4f | 2015-07-09 22:51:41 +0000 | [diff] [blame] | 544 | // Handle /export |
| 545 | for (auto *Arg : Args.filtered(OPT_export)) { |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 546 | Export E = parseExport(Arg->getValue()); |
Rui Ueyama | f10a320 | 2015-08-31 08:43:21 +0000 | [diff] [blame] | 547 | if (Config->Machine == I386) { |
| 548 | if (!isDecorated(E.Name)) |
| 549 | E.Name = Alloc.save("_" + E.Name); |
| 550 | if (!E.ExtName.empty() && !isDecorated(E.ExtName)) |
| 551 | E.ExtName = Alloc.save("_" + E.ExtName); |
| 552 | } |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 553 | Config->Exports.push_back(E); |
Rui Ueyama | bbdec4f | 2015-07-09 22:51:41 +0000 | [diff] [blame] | 554 | } |
| 555 | |
| 556 | // Handle /def |
| 557 | if (auto *Arg = Args.getLastArg(OPT_deffile)) { |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 558 | MemoryBufferRef MB = openFile(Arg->getValue()); |
Rui Ueyama | bbdec4f | 2015-07-09 22:51:41 +0000 | [diff] [blame] | 559 | // parseModuleDefs mutates Config object. |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 560 | parseModuleDefs(MB, &Alloc); |
Rui Ueyama | bbdec4f | 2015-07-09 22:51:41 +0000 | [diff] [blame] | 561 | } |
| 562 | |
Rui Ueyama | 6d24908 | 2015-07-13 22:31:45 +0000 | [diff] [blame] | 563 | // Handle /delayload |
| 564 | for (auto *Arg : Args.filtered(OPT_delayload)) { |
| 565 | Config->DelayLoads.insert(StringRef(Arg->getValue()).lower()); |
Rui Ueyama | 5e706b3 | 2015-07-25 21:54:50 +0000 | [diff] [blame] | 566 | if (Config->Machine == I386) { |
Rui Ueyama | 6d24908 | 2015-07-13 22:31:45 +0000 | [diff] [blame] | 567 | Config->DelayLoadHelper = addUndefined("___delayLoadHelper2@8"); |
Rui Ueyama | 35ccb0f | 2015-07-25 00:20:06 +0000 | [diff] [blame] | 568 | } else { |
| 569 | Config->DelayLoadHelper = addUndefined("__delayLoadHelper2"); |
Rui Ueyama | 6d24908 | 2015-07-13 22:31:45 +0000 | [diff] [blame] | 570 | } |
| 571 | } |
| 572 | |
Rui Ueyama | 5c437cd | 2015-07-25 21:42:33 +0000 | [diff] [blame] | 573 | // Set default image base if /base is not given. |
| 574 | if (Config->ImageBase == uint64_t(-1)) |
| 575 | Config->ImageBase = getDefaultImageBase(); |
| 576 | |
Rui Ueyama | 3cb895c | 2015-07-24 22:58:44 +0000 | [diff] [blame] | 577 | Symtab.addRelative(mangle("__ImageBase"), 0); |
Rui Ueyama | 5e706b3 | 2015-07-25 21:54:50 +0000 | [diff] [blame] | 578 | if (Config->Machine == I386) { |
Rui Ueyama | cd3f99b | 2015-07-24 23:51:14 +0000 | [diff] [blame] | 579 | Config->SEHTable = Symtab.addRelative("___safe_se_handler_table", 0); |
| 580 | Config->SEHCount = Symtab.addAbsolute("___safe_se_handler_count", 0); |
| 581 | } |
Rui Ueyama | bbdec4f | 2015-07-09 22:51:41 +0000 | [diff] [blame] | 582 | |
Rui Ueyama | 107db55 | 2015-08-09 21:01:06 +0000 | [diff] [blame] | 583 | // We do not support /guard:cf (control flow protection) yet. |
| 584 | // Define CFG symbols anyway so that we can link MSVC 2015 CRT. |
| 585 | Symtab.addAbsolute(mangle("__guard_fids_table"), 0); |
| 586 | Symtab.addAbsolute(mangle("__guard_fids_count"), 0); |
| 587 | Symtab.addAbsolute(mangle("__guard_flags"), 0x100); |
| 588 | |
Rui Ueyama | ea533cd | 2015-07-09 19:54:13 +0000 | [diff] [blame] | 589 | // Read as much files as we can from directives sections. |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 590 | Symtab.run(); |
Rui Ueyama | 85225b0 | 2015-07-02 03:15:15 +0000 | [diff] [blame] | 591 | |
| 592 | // Resolve auxiliary symbols until we get a convergence. |
Rui Ueyama | 573bf7d | 2015-06-19 21:12:48 +0000 | [diff] [blame] | 593 | // (Trying to resolve a symbol may trigger a Lazy symbol to load a new file. |
| 594 | // A new file may contain a directive section to add new command line options. |
| 595 | // That's why we have to repeat until converge.) |
| 596 | for (;;) { |
Rui Ueyama | 6bf638e | 2015-07-02 00:04:14 +0000 | [diff] [blame] | 597 | // Windows specific -- if entry point is not found, |
| 598 | // search for its mangled names. |
| 599 | if (Config->Entry) |
| 600 | Symtab.mangleMaybe(Config->Entry); |
| 601 | |
Rui Ueyama | 573bf7d | 2015-06-19 21:12:48 +0000 | [diff] [blame] | 602 | // Windows specific -- Make sure we resolve all dllexported symbols. |
Rui Ueyama | 6bf638e | 2015-07-02 00:04:14 +0000 | [diff] [blame] | 603 | for (Export &E : Config->Exports) { |
Rui Ueyama | 84425d7 | 2016-01-09 01:22:00 +0000 | [diff] [blame] | 604 | if (!E.ForwardTo.empty()) |
| 605 | continue; |
Rui Ueyama | 6bf638e | 2015-07-02 00:04:14 +0000 | [diff] [blame] | 606 | E.Sym = addUndefined(E.Name); |
Rui Ueyama | f10a320 | 2015-08-31 08:43:21 +0000 | [diff] [blame] | 607 | if (!E.Directives) |
| 608 | Symtab.mangleMaybe(E.Sym); |
Rui Ueyama | 6bf638e | 2015-07-02 00:04:14 +0000 | [diff] [blame] | 609 | } |
Rui Ueyama | 573bf7d | 2015-06-19 21:12:48 +0000 | [diff] [blame] | 610 | |
| 611 | // Add weak aliases. Weak aliases is a mechanism to give remaining |
| 612 | // undefined symbols final chance to be resolved successfully. |
Rui Ueyama | 3d4c69c | 2015-07-02 02:38:59 +0000 | [diff] [blame] | 613 | for (auto Pair : Config->AlternateNames) { |
| 614 | StringRef From = Pair.first; |
| 615 | StringRef To = Pair.second; |
Rui Ueyama | 458d744 | 2015-07-02 03:59:04 +0000 | [diff] [blame] | 616 | Symbol *Sym = Symtab.find(From); |
Rui Ueyama | 3d4c69c | 2015-07-02 02:38:59 +0000 | [diff] [blame] | 617 | if (!Sym) |
| 618 | continue; |
Rui Ueyama | 183f53f | 2015-07-06 17:45:22 +0000 | [diff] [blame] | 619 | if (auto *U = dyn_cast<Undefined>(Sym->Body)) |
Rui Ueyama | 3d4c69c | 2015-07-02 02:38:59 +0000 | [diff] [blame] | 620 | if (!U->WeakAlias) |
| 621 | U->WeakAlias = Symtab.addUndefined(To); |
Rui Ueyama | 2edb35a | 2015-06-18 19:09:30 +0000 | [diff] [blame] | 622 | } |
Rui Ueyama | 573bf7d | 2015-06-19 21:12:48 +0000 | [diff] [blame] | 623 | |
Rui Ueyama | cd3f99b | 2015-07-24 23:51:14 +0000 | [diff] [blame] | 624 | // Windows specific -- if __load_config_used can be resolved, resolve it. |
Rui Ueyama | 8ebdc8c | 2015-08-07 22:43:53 +0000 | [diff] [blame] | 625 | if (Symtab.findUnderscore("_load_config_used")) |
| 626 | addUndefined(mangle("_load_config_used")); |
Rui Ueyama | cd3f99b | 2015-07-24 23:51:14 +0000 | [diff] [blame] | 627 | |
Rui Ueyama | 3d4c69c | 2015-07-02 02:38:59 +0000 | [diff] [blame] | 628 | if (Symtab.queueEmpty()) |
| 629 | break; |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 630 | Symtab.run(); |
Rui Ueyama | 2edb35a | 2015-06-18 19:09:30 +0000 | [diff] [blame] | 631 | } |
| 632 | |
Peter Collingbourne | df5783b | 2015-08-28 22:16:09 +0000 | [diff] [blame] | 633 | // Do LTO by compiling bitcode input files to a set of native COFF files then |
| 634 | // link those files. |
| 635 | Symtab.addCombinedLTOObjects(); |
Peter Collingbourne | 60c1616 | 2015-06-01 20:10:10 +0000 | [diff] [blame] | 636 | |
Peter Collingbourne | 2612a32 | 2015-07-04 05:28:41 +0000 | [diff] [blame] | 637 | // Make sure we have resolved all symbols. |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 638 | Symtab.reportRemainingUndefines(/*Resolve=*/true); |
Peter Collingbourne | 2612a32 | 2015-07-04 05:28:41 +0000 | [diff] [blame] | 639 | |
Rui Ueyama | 3ee0fe4 | 2015-05-31 03:55:46 +0000 | [diff] [blame] | 640 | // Windows specific -- if no /subsystem is given, we need to infer |
| 641 | // that from entry point name. |
| 642 | if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) { |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 643 | Config->Subsystem = inferSubsystem(); |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 644 | if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) |
| 645 | error("subsystem must be defined"); |
Rui Ueyama | 3ee0fe4 | 2015-05-31 03:55:46 +0000 | [diff] [blame] | 646 | } |
| 647 | |
Rui Ueyama | ff88d5a | 2015-07-29 20:25:40 +0000 | [diff] [blame] | 648 | // Handle /safeseh. |
Rui Ueyama | 13563d8 | 2015-09-15 00:33:11 +0000 | [diff] [blame] | 649 | if (Args.hasArg(OPT_safeseh)) |
| 650 | for (ObjectFile *File : Symtab.ObjectFiles) |
| 651 | if (!File->SEHCompat) |
| 652 | error("/safeseh: " + File->getName() + " is not compatible with SEH"); |
Rui Ueyama | ff88d5a | 2015-07-29 20:25:40 +0000 | [diff] [blame] | 653 | |
Rui Ueyama | 151d862 | 2015-06-17 20:40:43 +0000 | [diff] [blame] | 654 | // Windows specific -- when we are creating a .dll file, we also |
| 655 | // need to create a .lib file. |
Rui Ueyama | 100ffac | 2015-09-01 09:15:58 +0000 | [diff] [blame] | 656 | if (!Config->Exports.empty() || Config->DLL) { |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 657 | fixupExports(); |
| 658 | writeImportLibrary(); |
Rui Ueyama | 8765fba | 2015-07-15 22:21:08 +0000 | [diff] [blame] | 659 | assignExportOrdinals(); |
| 660 | } |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 661 | |
Rui Ueyama | 24c5fd0 | 2015-06-18 00:12:42 +0000 | [diff] [blame] | 662 | // Windows specific -- Create a side-by-side manifest file. |
| 663 | if (Config->Manifest == Configuration::SideBySide) |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 664 | createSideBySideManifest(); |
Rui Ueyama | 24c5fd0 | 2015-06-18 00:12:42 +0000 | [diff] [blame] | 665 | |
Rui Ueyama | 0fc26d2 | 2015-06-29 14:27:12 +0000 | [diff] [blame] | 666 | // Create a dummy PDB file to satisfy build sytem rules. |
| 667 | if (auto *Arg = Args.getLastArg(OPT_pdb)) |
Rui Ueyama | e737824 | 2015-12-04 23:11:05 +0000 | [diff] [blame] | 668 | createPDB(Arg->getValue()); |
Rui Ueyama | 0fc26d2 | 2015-06-29 14:27:12 +0000 | [diff] [blame] | 669 | |
Rui Ueyama | a5f0f75 | 2015-09-19 21:36:28 +0000 | [diff] [blame] | 670 | // Identify unreferenced COMDAT sections. |
| 671 | if (Config->DoGC) |
| 672 | markLive(Symtab.getChunks()); |
| 673 | |
| 674 | // Identify identical COMDAT sections to merge them. |
| 675 | if (Config->DoICF) |
| 676 | doICF(Symtab.getChunks()); |
| 677 | |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 678 | // Write the result. |
Rafael Espindola | b835ae8 | 2015-08-06 14:58:50 +0000 | [diff] [blame] | 679 | writeResult(&Symtab); |
Peter Collingbourne | be54955 | 2015-06-26 18:58:24 +0000 | [diff] [blame] | 680 | |
Rui Ueyama | 016414f | 2015-06-28 20:07:08 +0000 | [diff] [blame] | 681 | // Create a symbol map file containing symbol VAs and their names |
| 682 | // to help debugging. |
Peter Collingbourne | be54955 | 2015-06-26 18:58:24 +0000 | [diff] [blame] | 683 | if (auto *Arg = Args.getLastArg(OPT_lldmap)) { |
| 684 | std::error_code EC; |
Peter Collingbourne | baf5f87 | 2015-06-26 19:20:09 +0000 | [diff] [blame] | 685 | llvm::raw_fd_ostream Out(Arg->getValue(), EC, OpenFlags::F_Text); |
Rui Ueyama | 7e75866 | 2016-07-14 23:37:10 +0000 | [diff] [blame^] | 686 | check(EC, "Could not create the symbol map"); |
Peter Collingbourne | be54955 | 2015-06-26 18:58:24 +0000 | [diff] [blame] | 687 | Symtab.printMap(Out); |
| 688 | } |
Rui Ueyama | a51ce71 | 2015-07-03 05:31:35 +0000 | [diff] [blame] | 689 | // Call exit to avoid calling destructors. |
| 690 | exit(0); |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 691 | } |
| 692 | |
Rui Ueyama | 411c6360 | 2015-05-28 19:09:30 +0000 | [diff] [blame] | 693 | } // namespace coff |
| 694 | } // namespace lld |