1 //===- Driver.h -------------------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLD_COFF_DRIVER_H 10 #define LLD_COFF_DRIVER_H 11 12 #include "Config.h" 13 #include "SymbolTable.h" 14 #include "lld/Common/LLVM.h" 15 #include "lld/Common/Reproduce.h" 16 #include "llvm/ADT/StringRef.h" 17 #include "llvm/ADT/StringSet.h" 18 #include "llvm/Object/Archive.h" 19 #include "llvm/Object/COFF.h" 20 #include "llvm/Option/Arg.h" 21 #include "llvm/Option/ArgList.h" 22 #include "llvm/Support/FileSystem.h" 23 #include "llvm/Support/TarWriter.h" 24 #include "llvm/WindowsDriver/MSVCPaths.h" 25 #include <memory> 26 #include <optional> 27 #include <set> 28 #include <vector> 29 30 namespace lld::coff { 31 32 using llvm::COFF::MachineTypes; 33 using llvm::COFF::WindowsSubsystem; 34 using std::optional; 35 36 class COFFOptTable : public llvm::opt::GenericOptTable { 37 public: 38 COFFOptTable(); 39 }; 40 41 // The result of parsing the .drective section. The /export: and /include: 42 // options are handled separately because they reference symbols, and the number 43 // of symbols can be quite large. The LLVM Option library will perform at least 44 // one memory allocation per argument, and that is prohibitively slow for 45 // parsing directives. 46 struct ParsedDirectives { 47 std::vector<StringRef> exports; 48 std::vector<StringRef> includes; 49 std::vector<StringRef> excludes; 50 llvm::opt::InputArgList args; 51 }; 52 53 class ArgParser { 54 public: 55 ArgParser(COFFLinkerContext &ctx); 56 57 // Parses command line options. 58 llvm::opt::InputArgList parse(llvm::ArrayRef<const char *> args); 59 60 // Tokenizes a given string and then parses as command line options. 61 llvm::opt::InputArgList parse(StringRef s) { return parse(tokenize(s)); } 62 63 // Tokenizes a given string and then parses as command line options in 64 // .drectve section. /EXPORT options are returned in second element 65 // to be processed in fastpath. 66 ParsedDirectives parseDirectives(StringRef s); 67 68 private: 69 // Concatenate LINK environment variable. 70 void addLINK(SmallVector<const char *, 256> &argv); 71 72 std::vector<const char *> tokenize(StringRef s); 73 74 COFFLinkerContext &ctx; 75 }; 76 77 class LinkerDriver { 78 public: 79 LinkerDriver(COFFLinkerContext &ctx) : ctx(ctx) {} 80 81 void linkerMain(llvm::ArrayRef<const char *> args); 82 83 void addFile(InputFile *file); 84 85 void addClangLibSearchPaths(const std::string &argv0); 86 87 // Used by ArchiveFile to enqueue members. 88 void enqueueArchiveMember(const Archive::Child &c, const Archive::Symbol &sym, 89 StringRef parentName); 90 91 void enqueuePDB(StringRef Path) { enqueuePath(Path, false, false); } 92 93 MemoryBufferRef takeBuffer(std::unique_ptr<MemoryBuffer> mb); 94 95 void enqueuePath(StringRef path, bool wholeArchive, bool lazy); 96 97 // Returns a list of chunks of selected symbols. 98 std::vector<Chunk *> getChunks() const; 99 100 std::unique_ptr<llvm::TarWriter> tar; // for /linkrepro 101 102 void pullArm64ECIcallHelper(); 103 104 private: 105 // Searches a file from search paths. 106 std::optional<StringRef> findFileIfNew(StringRef filename); 107 std::optional<StringRef> findLibIfNew(StringRef filename); 108 StringRef findFile(StringRef filename); 109 StringRef findLib(StringRef filename); 110 StringRef findLibMinGW(StringRef filename); 111 112 // Determines the location of the sysroot based on `args`, environment, etc. 113 void detectWinSysRoot(const llvm::opt::InputArgList &args); 114 115 // Adds various search paths based on the sysroot. Must only be called once 116 // config.machine has been set. 117 void addWinSysRootLibSearchPaths(); 118 119 void setMachine(llvm::COFF::MachineTypes machine); 120 llvm::Triple::ArchType getArch(); 121 122 uint64_t getDefaultImageBase(); 123 124 bool isDecorated(StringRef sym); 125 126 std::string getMapFile(const llvm::opt::InputArgList &args, 127 llvm::opt::OptSpecifier os, 128 llvm::opt::OptSpecifier osFile); 129 130 std::string getImplibPath(); 131 132 // The import name is calculated as follows: 133 // 134 // | LIBRARY w/ ext | LIBRARY w/o ext | no LIBRARY 135 // -----+----------------+---------------------+------------------ 136 // LINK | {value} | {value}.{.dll/.exe} | {output name} 137 // LIB | {value} | {value}.dll | {output name}.dll 138 // 139 std::string getImportName(bool asLib); 140 141 void createImportLibrary(bool asLib); 142 143 // Used by the resolver to parse .drectve section contents. 144 void parseDirectives(InputFile *file); 145 146 // Parse an /order file. If an option is given, the linker places COMDAT 147 // sections int he same order as their names appear in the given file. 148 void parseOrderFile(StringRef arg); 149 150 void parseCallGraphFile(StringRef path); 151 152 void parsePDBAltPath(); 153 154 // Parses LIB environment which contains a list of search paths. 155 void addLibSearchPaths(); 156 157 // Library search path. The first element is always "" (current directory). 158 std::vector<StringRef> searchPaths; 159 160 // Convert resource files and potentially merge input resource object 161 // trees into one resource tree. 162 void convertResources(); 163 164 void maybeExportMinGWSymbols(const llvm::opt::InputArgList &args); 165 166 // We don't want to add the same file more than once. 167 // Files are uniquified by their filesystem and file number. 168 std::set<llvm::sys::fs::UniqueID> visitedFiles; 169 170 std::set<std::string> visitedLibs; 171 172 void addBuffer(std::unique_ptr<MemoryBuffer> mb, bool wholeArchive, 173 bool lazy); 174 void addArchiveBuffer(MemoryBufferRef mbref, StringRef symName, 175 StringRef parentName, uint64_t offsetInArchive); 176 177 void enqueueTask(std::function<void()> task); 178 bool run(); 179 180 std::list<std::function<void()>> taskQueue; 181 std::vector<MemoryBufferRef> resources; 182 183 llvm::DenseSet<StringRef> excludedSymbols; 184 185 COFFLinkerContext &ctx; 186 187 llvm::ToolsetLayout vsLayout = llvm::ToolsetLayout::OlderVS; 188 std::string vcToolChainPath; 189 llvm::SmallString<128> diaPath; 190 bool useWinSysRootLibPath = false; 191 llvm::SmallString<128> universalCRTLibPath; 192 int sdkMajor = 0; 193 llvm::SmallString<128> windowsSdkLibPath; 194 195 // Functions below this line are defined in DriverUtils.cpp. 196 197 void printHelp(const char *argv0); 198 199 // Parses a string in the form of "<integer>[,<integer>]". 200 void parseNumbers(StringRef arg, uint64_t *addr, uint64_t *size = nullptr); 201 202 void parseGuard(StringRef arg); 203 204 // Parses a string in the form of "<integer>[.<integer>]". 205 // Minor's default value is 0. 206 void parseVersion(StringRef arg, uint32_t *major, uint32_t *minor); 207 208 // Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]". 209 void parseSubsystem(StringRef arg, WindowsSubsystem *sys, uint32_t *major, 210 uint32_t *minor, bool *gotVersion = nullptr); 211 212 void parseAlternateName(StringRef); 213 void parseMerge(StringRef); 214 void parsePDBPageSize(StringRef); 215 void parseSection(StringRef); 216 void parseAligncomm(StringRef); 217 218 // Parses a MS-DOS stub file 219 void parseDosStub(StringRef path); 220 221 // Parses a string in the form of "[:<integer>]" 222 void parseFunctionPadMin(llvm::opt::Arg *a); 223 224 // Parses a string in the form of "[:<integer>]" 225 void parseDependentLoadFlags(llvm::opt::Arg *a); 226 227 // Parses a string in the form of "EMBED[,=<integer>]|NO". 228 void parseManifest(StringRef arg); 229 230 // Parses a string in the form of "level=<string>|uiAccess=<string>" 231 void parseManifestUAC(StringRef arg); 232 233 // Parses a string in the form of "cd|net[,(cd|net)]*" 234 void parseSwaprun(StringRef arg); 235 236 // Create a resource file containing a manifest XML. 237 std::unique_ptr<MemoryBuffer> createManifestRes(); 238 void createSideBySideManifest(); 239 std::string createDefaultXml(); 240 std::string createManifestXmlWithInternalMt(StringRef defaultXml); 241 std::string createManifestXmlWithExternalMt(StringRef defaultXml); 242 std::string createManifestXml(); 243 244 std::unique_ptr<llvm::WritableMemoryBuffer> 245 createMemoryBufferForManifestRes(size_t manifestRes); 246 247 // Used for dllexported symbols. 248 Export parseExport(StringRef arg); 249 250 // Parses a string in the form of "key=value" and check 251 // if value matches previous values for the key. 252 // This feature used in the directive section to reject 253 // incompatible objects. 254 void checkFailIfMismatch(StringRef arg, InputFile *source); 255 256 // Convert Windows resource files (.res files) to a .obj file. 257 MemoryBufferRef convertResToCOFF(ArrayRef<MemoryBufferRef> mbs, 258 ArrayRef<ObjFile *> objs); 259 260 // Create export thunks for exported and patchable Arm64EC function symbols. 261 void createECExportThunks(); 262 void maybeCreateECExportThunk(StringRef name, Symbol *&sym); 263 264 bool ltoCompilationDone = false; 265 }; 266 267 // Create enum with OPT_xxx values for each option in Options.td 268 enum { 269 OPT_INVALID = 0, 270 #define OPTION(...) LLVM_MAKE_OPT_ID(__VA_ARGS__), 271 #include "Options.inc" 272 #undef OPTION 273 }; 274 275 } // namespace lld::coff 276 277 #endif 278