[lld/coff] Add parsing for /pdbpagesize: flag

[thakis]

Summary

It's not used for anything yet, but we now accept /pdbpagesize:4096
(the default behavior) and we give arguably more useful diagnostics
for other values.

[thakis]

slightly more

[thakis]

slightly more test

[hans]

lgtm

Feel free to ignore the comment.

lld/COFF/Config.h

127

unsigned is probably more common LLVM-style (like ltoo or ltoPartitions), or maybe even size_t (like wordsize).

[thakis]

Thanks!

lld/COFF/Config.h

127

Given that this only stores a very limited set of small values, int has the advantage that writing 4096 instead of 4096u doesn't give you sign conversion warnings. So I (very weakly) prefer this here.

lld/COFF/Config.h

struct Configuration {
   bool driverUponly = false;
   bool driverWdm = false;
   bool showTiming = false;
   bool showSummary = false;
   unsigned debugTypes = static_cast<unsigned>(DebugType::None);
   std::vector<std::string> natvisFiles;
   llvm::StringMap<std::string> namedStreams;
   llvm::SmallString<128> pdbAltPath;
+  int pdbPageSize = 4096;
   llvm::SmallString<128> pdbPath;
   llvm::SmallString<128> pdbSourcePath;
   std::vector<llvm::StringRef> argv;
 
   // Symbols in this set are considered as live by the garbage collector.
   std::vector<Symbol *> gcroot;
 
   std::set<std::string> noDefaultLibs;

lld/COFF/Driver.h

 void parseVersion(StringRef arg, uint32_t *major, uint32_t *minor);
 
 // Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]".
 void parseSubsystem(StringRef arg, WindowsSubsystem *sys, uint32_t *major,
                     uint32_t *minor, bool *gotVersion = nullptr);
 
 void parseAlternateName(StringRef);
 void parseMerge(StringRef);
+void parsePDBPageSize(StringRef);
 void parseSection(StringRef);
 void parseAligncomm(StringRef);
 
 // Parses a string in the form of "[:<integer>]"
 void parseFunctionPadMin(llvm::opt::Arg *a, llvm::COFF::MachineTypes machine);
 
 // Parses a string in the form of "EMBED[,=<integer>]|NO".
 void parseManifest(StringRef arg);

lld/COFF/Driver.cpp

void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   bool shouldCreatePDB =
       (debug == DebugKind::Full || debug == DebugKind::GHash ||
        debug == DebugKind::NoGHash);
   if (shouldCreatePDB) {
     if (auto *arg = args.getLastArg(OPT_pdb))
       config->pdbPath = arg->getValue();
     if (auto *arg = args.getLastArg(OPT_pdbaltpath))
       config->pdbAltPath = arg->getValue();
+    if (auto *arg = args.getLastArg(OPT_pdbpagesize))
+      parsePDBPageSize(arg->getValue());
     if (args.hasArg(OPT_natvis))
       config->natvisFiles = args.getAllArgValues(OPT_natvis);
     if (args.hasArg(OPT_pdbstream)) {
       for (const StringRef value : args.getAllArgValues(OPT_pdbstream)) {
         const std::pair<StringRef, StringRef> nameFile = value.split("=");
         const StringRef name = nameFile.first;
         const std::string file = nameFile.second.str();
         config->namedStreams[name] = file;

lld/COFF/DriverUtils.cpp

void parseMerge(StringRef s) {
   bool inserted = pair.second;
   if (!inserted) {
     StringRef existing = pair.first->second;
     if (existing != to)
       warn(s + ": already merged into " + existing);
   }
 }
 
+void parsePDBPageSize(StringRef s) {
+  int v;
+  if (s.getAsInteger(0, v)) {
+    error("/pdbpagesize: invalid argument: " + s);
+    return;
+  }
+  if (v != 4096 && v != 8192 && v != 16384 && v != 32768) {
+    error("/pdbpagesize: invalid argument: " + s);
+    return;
+  }
+
+  // FIXME: Remove this once other page sizes work.
+  if (v != 4096) {
+    warn("/pdbpagesize: page sizes != 4096 not yet implemented, ignoring flag");
+    v = 4096;
+  }
+
+  config->pdbPageSize = v;
+}
+
 static uint32_t parseSectionAttributes(StringRef s) {
   uint32_t ret = 0;
   for (char c : s.lower()) {
     switch (c) {
     case 'd':
       ret |= IMAGE_SCN_MEM_DISCARDABLE;
       break;
     case 'e':

lld/COFF/Options.td

 def merge   : P<"merge", "Combine sections">;
 def mllvm   : P<"mllvm", "Options to pass to LLVM">;
 def nodefaultlib : P<"nodefaultlib", "Remove a default library">;
 def opt     : P<"opt", "Control optimizations">;
 def order   : P<"order", "Put functions in order">;
 def out     : P<"out", "Path to file to write output">;
 def natvis : P<"natvis", "Path to natvis file to embed in the PDB">;
 def pdb : P<"pdb", "PDB file path">;
-def pdbstripped : P<"pdbstripped", "Stripped PDB file path">;
 def pdbaltpath : P<"pdbaltpath", "PDB file path to embed in the image">;
+def pdbpagesize : P<"pdbpagesize", "PDB page size">;
+def pdbstripped : P<"pdbstripped", "Stripped PDB file path">;
 def pdbstream : Joined<["/", "-", "/?", "-?"], "pdbstream:">,
     MetaVarName<"<name>=<file>">,
     HelpText<"Embed the contents of <file> in the PDB as named stream <name>">;
 def section : P<"section", "Specify section attributes">;
 def stack   : P<"stack", "Size of the stack">;
 def stub    : P<"stub", "Specify DOS stub file">;
 def subsystem : P<"subsystem", "Specify subsystem">;
 def timestamp : P<"timestamp", "Specify the PE header timestamp">;

lld/COFF/PDB.cpp

void lld::coff::createPDB(COFFLinkerContext &ctx,
   memcpy(&buildId->PDB70.Signature, &guid, 16);
 
   t2.stop();
   t1.stop();
   pdb.printStats();
 }
 
 void PDBLinker::initialize(llvm::codeview::DebugInfo *buildId) {
-  exitOnErr(builder.initialize(4096)); // 4096 is blocksize
+  exitOnErr(builder.initialize(config->pdbPageSize));
 
   buildId->Signature.CVSignature = OMF::Signature::PDB70;
   // Signature is set to a hash of the PDB contents when the PDB is done.
   memset(buildId->PDB70.Signature, 0, 16);
   buildId->PDB70.Age = 1;
 
   // Create streams in MSF for predefined streams, namely
   // PDB, TPI, DBI and IPI.

lld/test/COFF/pdbpagesize.test

+# RUN: yaml2obj %p/Inputs/empty.yaml -o %t.obj
+
+# RUN: not lld-link /entry:main %t.obj /out:%t.exe /debug /pdbpagesize:hi 2>&1 \
+# RUN:     | FileCheck --check-prefix=INVALID %s
+# RUN: not lld-link /entry:main %t.obj /out:%t.exe /debug /pdbpagesize:15 2>&1 \
+# RUN:     | FileCheck --check-prefix=INVALID %s
+# INVALID: error: /pdbpagesize: invalid argument:
+
+# RUN: lld-link /entry:main %t.obj /out:%t.exe /debug /pdbpagesize:4096
+# RUN: llvm-pdbutil pdb2yaml %t.pdb | FileCheck --check-prefix=PAGE4096 %s
+# PAGE4096: BlockSize: 4096
+
+# RUN: lld-link /entry:main %t.obj /out:%t.exe /debug /pdbpagesize:8192 2>&1 \
+# RUN:     | FileCheck --check-prefix=TODO %s
+# TODO: warning: /pdbpagesize: page sizes != 4096 not yet implemented, ignoring flag

llvm/include/llvm/DebugInfo/MSF/MSFCommon.h

MSFStreamLayout getFpmStreamLayout(const MSFLayout &Msf,
                                    bool AltFpm = false);
 
 inline bool isValidBlockSize(uint32_t Size) {
   switch (Size) {
   case 512:
   case 1024:
   case 2048:
   case 4096:
+  case 8192:
+  case 16384:
+  case 32768:
     return true;
   }
   return false;
 }
 
 // Super Block, Fpm0, Fpm1, and Block Map
 inline uint32_t getMinimumBlockCount() { return 4; }