[DO NOT SUBMIT] Add --bloom-filter-bits

lld/ELF/Config.h

struct Configuration {
   Target2Policy Target2;
   BuildIdKind BuildId = BuildIdKind::None;
   ELFKind EKind = ELFNoneKind;
   uint16_t DefaultSymbolVersion = llvm::ELF::VER_NDX_GLOBAL;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   llvm::Optional<uint64_t> ImageBase;
   uint64_t MaxPageSize;
   uint64_t ZStackSize;
+  unsigned BloomFilterBits;
   unsigned LTOPartitions;
   unsigned LTOO;
   unsigned Optimize;
   unsigned ThinLTOJobs;
 
   // The following config options do not directly correspond to any
   // particualr command line options.
 

lld/ELF/Driver.cpp

static int parseInt(StringRef S, opt::Arg *Arg) {
   return V;
 }
 
 // Initializes Config members by the command line options.
 void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->AllowMultipleDefinition =
       Args.hasArg(OPT_allow_multiple_definition) || hasZOption(Args, "muldefs");
   Config->AuxiliaryList = args::getStrings(Args, OPT_auxiliary);
+  Config->BloomFilterBits = args::getInteger(Args, OPT_bloom_filter_bits, 8);
   Config->Bsymbolic = Args.hasArg(OPT_Bsymbolic);
   Config->BsymbolicFunctions = Args.hasArg(OPT_Bsymbolic_functions);
   Config->Chroot = Args.getLastArgValue(OPT_chroot);
   Config->CompressDebugSections = getCompressDebugSections(Args);
   Config->DefineCommon = Args.hasFlag(OPT_define_common, OPT_no_define_common,
                                       !Args.hasArg(OPT_relocatable));
   Config->Demangle = Args.hasFlag(OPT_demangle, OPT_no_demangle, true);
   Config->DisableVerify = Args.hasArg(OPT_disable_verify);

lld/ELF/Options.td

 include "llvm/Option/OptParser.td"
 
 // For options whose names are multiple letters, either one dash or
 // two can precede the option name except those that start with 'o'.
 class F<string name>: Flag<["--", "-"], name>;
 class J<string name>: Joined<["--", "-"], name>;
 class S<string name>: Separate<["--", "-"], name>;
 
 multiclass Eq<string name> {
   def "": Separate<["--", "-"], name>;
   def _eq: Joined<["--", "-"], name # "=">, Alias<!cast<Separate>(NAME)>;
 }
 
 def auxiliary: S<"auxiliary">, HelpText<"Set DT_AUXILIARY field to the specified name">;
 
+defm bloom_filter_bits: Eq<"bloom-filter-bits">;
+
 def Bsymbolic: F<"Bsymbolic">, HelpText<"Bind defined symbols locally">;
 
 def Bsymbolic_functions: F<"Bsymbolic-functions">,
   HelpText<"Bind defined function symbols locally">;
 
 def Bdynamic: F<"Bdynamic">, HelpText<"Link against shared libraries">;
 
 def Bstatic: F<"Bstatic">, HelpText<"Do not link against shared libraries">;

lld/ELF/SyntheticSections.cpp

 void GnuHashTableSection::finalizeContents() {
   getParent()->Link = InX::DynSymTab->getParent()->SectionIndex;
 
   // Computes bloom filter size in word size. We want to allocate 8
   // bits for each symbol. It must be a power of two.
   if (Symbols.empty())
     MaskWords = 1;
   else
-    MaskWords = NextPowerOf2((Symbols.size() - 1) / Config->Wordsize);
+    MaskWords = NextPowerOf2(Symbols.size() * Config->BloomFilterBits / Config->Wordsize / 8);
 
   Size = 16;                            // Header
   Size += Config->Wordsize * MaskWords; // Bloom filter
   Size += NBuckets * 4;                 // Hash buckets
   Size += Symbols.size() * 4;           // Hash values
 }
 
 void GnuHashTableSection::writeTo(uint8_t *Buf) {
void GnuHashTableSection::writeBloomFilter(uint8_t *Buf) {
   const unsigned C = Config->Wordsize * 8;
   for (const Entry &Sym : Symbols) {
     size_t I = (Sym.Hash / C) & (MaskWords - 1);
     uint64_t Val = readUint(Buf + I * Config->Wordsize);
     Val |= uint64_t(1) << (Sym.Hash % C);
     Val |= uint64_t(1) << ((Sym.Hash >> getShift2()) % C);
     writeUint(Buf + I * Config->Wordsize, Val);
   }
+
+  ArrayRef<uint8_t> Arr(Buf, Config->Wordsize * MaskWords);
+  message("Bloom filter size in bits: " + Twine(Arr.size() * 8));
+
+  size_t Ones = 0;
+  for (uint8_t Byte : Arr)
+    Ones += __builtin_popcount(Byte);
+  message(" # of 1 bits: " + Twine(Ones) + " (" + Twine((int)((double)Ones / Arr.size() * 8)) + "%)");
 }
 
 void GnuHashTableSection::writeHashTable(uint8_t *Buf) {
   uint32_t *Buckets = reinterpret_cast<uint32_t *>(Buf);
   uint32_t OldBucket = -1;
   uint32_t *Values = Buckets + NBuckets;
   for (auto I = Symbols.begin(), E = Symbols.end(); I != E; ++I) {
     // Write a hash value. It represents a sequence of chains that share the