lld/COFF/Driver.h

   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