[lld] [NFC] Match new variable names in comments

[abrachet]

Summary

rL365595 changed variables to start with a lower case letter, this change updates comments which declare the parameter to which a constant refers. Also, this patch normalizes such comments so they are in the form /*parameter=*/<value> as shown in the style guide.

[abrachet]

lld/ELF/DriverUtils.cpp

149

These parameters have been unchanged it exists in include/Option here.

lld/ELF/LTO.cpp

122

Also has been unchanged, still UseInputModulePath.

223

Again unchanged, still exists as HaveGVs

[ruiu]

lld/ELF/DWARF.cpp

62

Can you simply /**/ so that a becomes a paramter?

69

Ditto

[abrachet]

Uncommented unnamed parameter.

[ruiu]

LGTM

Thanks!

[abrachet]

Never got around to pushing this, oops. Looks like these were changed programmatically anyway.

lld/ELF/DWARF.cpp

template <class ELFT> LLDDwarfObj<ELFT>::LLDDwarfObj(ObjFile<ELFT> *obj) {
   }
 }
 
 namespace {
 template <class RelTy> struct LLDRelocationResolver {
   // In the ELF ABIs, S sepresents the value of the symbol in the relocation
   // entry. For Rela, the addend is stored as part of the relocation entry.
   static uint64_t resolve(object::RelocationRef ref, uint64_t s,
-                          uint64_t /* A */) {
+                          uint64_t /* a */) {
     return s + ref.getRawDataRefImpl().p;
   }
 };
 
 template <class ELFT> struct LLDRelocationResolver<Elf_Rel_Impl<ELFT, false>> {
   // For Rel, the addend A is supplied by the caller.
-  static uint64_t resolve(object::RelocationRef /*Ref*/, uint64_t s,
+  static uint64_t resolve(object::RelocationRef /*ref*/, uint64_t s,
                           uint64_t a) {
     return s + a;
   }
 };
 } // namespace
 
 // Find if there is a relocation at Pos in Sec.  The code is a bit
 // more complicated than usual because we need to pass a section index

lld/ELF/Driver.cpp

void LinkerDriver::addFile(StringRef path, bool withLOption) {
   default:
     error(path + ": unknown file type");
   }
 }
 
 // Add a given library by searching it from input search paths.
 void LinkerDriver::addLibrary(StringRef name) {
   if (Optional<std::string> path = searchLibrary(name))
-    addFile(*path, /*WithLOption=*/true);
+    addFile(*path, /*withLOption=*/true);
   else
     error("unable to find library -l" + name);
 }
 
 // This function is called on startup. We need this for LTO since
 // LTO calls LLVM functions to compile bitcode files to native code.
 // Technically this can be delayed until we read bitcode files, but
 // we don't bother to do lazily because the initialization is fast.
static void readConfigs(opt::InputArgList &args) {
 
   // If --retain-symbol-file is used, we'll keep only the symbols listed in
   // the file and discard all others.
   if (auto *arg = args.getLastArg(OPT_retain_symbols_file)) {
     config->defaultSymbolVersion = VER_NDX_LOCAL;
     if (Optional<MemoryBufferRef> buffer = readFile(arg->getValue()))
       for (StringRef s : args::getLines(*buffer))
         config->versionScriptGlobals.push_back(
-            {s, /*IsExternCpp*/ false, /*HasWildcard*/ false});
+            {s, /*isExternCpp=*/false, /*hasWildcard=*/false});
   }
 
   bool hasExportDynamic =
       args.hasFlag(OPT_export_dynamic, OPT_no_export_dynamic, false);
 
   // Parses -dynamic-list and -export-dynamic-symbol. They make some
   // symbols private. Note that -export-dynamic takes precedence over them
   // as it says all symbols should be exported.
   if (!hasExportDynamic) {
     for (auto *arg : args.filtered(OPT_dynamic_list))
       if (Optional<MemoryBufferRef> buffer = readFile(arg->getValue()))
         readDynamicList(*buffer);
 
     for (auto *arg : args.filtered(OPT_export_dynamic_symbol))
       config->dynamicList.push_back(
-          {arg->getValue(), /*IsExternCpp*/ false, /*HasWildcard*/ false});
+          {arg->getValue(), /*isExternCpp=*/false, /*hasWildcard=*/false});
   }
 
   // If --export-dynamic-symbol=foo is given and symbol foo is defined in
   // an object file in an archive file, that object file should be pulled
   // out and linked. (It doesn't have to behave like that from technical
   // point of view, but this is needed for compatibility with GNU.)
   for (auto *arg : args.filtered(OPT_export_dynamic_symbol))
     config->undefined.push_back(arg->getValue());
void LinkerDriver::createFiles(opt::InputArgList &args) {
 
   // Iterate over argv to process input files and positional arguments.
   for (auto *arg : args) {
     switch (arg->getOption().getID()) {
     case OPT_library:
       addLibrary(arg->getValue());
       break;
     case OPT_INPUT:
-      addFile(arg->getValue(), /*WithLOption=*/false);
+      addFile(arg->getValue(), /*withLOption=*/false);
       break;
     case OPT_defsym: {
       StringRef from;
       StringRef to;
       std::tie(from, to) = StringRef(arg->getValue()).split('=');
       if (from.empty() || to.empty())
         error("-defsym: syntax error: " + StringRef(arg->getValue()));
       else
symtab->forEachSymbol([](Symbol *sym) {
     if (!s)
       return;
 
     auto *bss = make<BssSection>("COMMON", s->size, s->alignment);
     bss->file = s->file;
     bss->markDead();
     inputSections.push_back(bss);
     s->replace(Defined{s->file, s->getName(), s->binding, s->stOther, s->type,
-                       /*Value=*/0, s->size, bss});
+                       /*value=*/0, s->size, bss});
   });
 }
 
 // If all references to a DSO happen to be weak, the DSO is not added
 // to DT_NEEDED. If that happens, we need to eliminate shared symbols
 // created from the DSO. Otherwise, they become dangling references
 // that point to a non-existent DSO.
 static void demoteSharedSymbols() {

 template <class ELFT> void LinkerDriver::compileBitcodeFiles() {
   // Compile bitcode files and replace bitcode symbols.
   lto.reset(new BitcodeCompiler);
   for (BitcodeFile *file : bitcodeFiles)
     lto->add(*file);
 
   for (InputFile *file : lto->compile()) {
     auto *obj = cast<ObjFile<ELFT>>(file);
-    obj->parse(/*IgnoreComdats=*/true);
+    obj->parse(/*ignoreComdats=*/true);
     for (Symbol *sym : obj->getGlobalSymbols())
       sym->parseSymbolVersion();
     objectFiles.push_back(file);
   }
 }
 
 // The --wrap option is a feature to rename symbols so that you can write
 // wrappers for existing functions. If you pass `-wrap=foo`, all

lld/ELF/DriverUtils.cpp

else
             "', did you mean '" + nearest + "'");
   }
   return args;
 }
 
 void elf::printHelp() {
   ELFOptTable().PrintHelp(
       outs(), (config->progName + " [options] file...").str().c_str(), "lld",
-      false /*ShowHidden*/, true /*ShowAllAliases*/);
+      /*showHidden=*/false, /*showAllAliases=*/true);
   outs() << "\n";
 
   // Scripts generated by Libtool versions up to at least 2.4.6 (the most
   // recent version as of March 2017) expect /: supported targets:.* elf/
   // in a message for the -help option. If it doesn't match, the scripts
   // assume that the linker doesn't support very basic features such as
   // shared libraries. Therefore, we need to print out at least "elf".
   outs() << config->progName << ": supported targets: elf\n";

lld/ELF/InputFiles.cpp

 // function resolves a given name by finding the first matching library checking
 // the various ways that a library can be specified to LLD. This ELF extension
 // is a form of autolinking and is called `dependent libraries`. It is currently
 // unique to LLVM and lld.
 static void addDependentLibrary(StringRef specifier, const InputFile *f) {
   if (!config->dependentLibraries)
     return;
   if (fs::exists(specifier))
-    driver->addFile(specifier, /*WithLOption=*/false);
+    driver->addFile(specifier, /*withLOption=*/false);
   else if (Optional<std::string> s = findFromSearchPaths(specifier))
-    driver->addFile(*s, /*WithLOption=*/true);
+    driver->addFile(*s, /*withLOption=*/true);
   else if (Optional<std::string> s = searchLibraryBaseName(specifier))
-    driver->addFile(*s, /*WithLOption=*/true);
+    driver->addFile(*s, /*withLOption=*/true);
   else
     error(toString(f) +
           ": unable to find library from dependent library specifier: " +
           specifier);
 }
 
 template <class ELFT>
 void ObjFile<ELFT>::initializeSections(bool ignoreComdats) {
if (binding == STB_LOCAL) {
 
       if (this->stringTable.size() <= eSym.st_name)
         fatal(toString(this) + ": invalid symbol name offset");
 
       if (eSym.st_shndx == SHN_UNDEF)
         this->symbols[i] = make<Undefined>(this, name, binding, stOther, type);
       else if (sec == &InputSection::discarded)
         this->symbols[i] = make<Undefined>(this, name, binding, stOther, type,
-                                           /*DiscardedSecIdx=*/secIdx);
+                                           /*discardedSecIdx=*/secIdx);
       else
         this->symbols[i] =
             make<Defined>(this, name, binding, stOther, type, value, size, sec);
       continue;
     }
 
     // Handle global undefined symbols.
     if (eSym.st_shndx == SHN_UNDEF) {

lld/ELF/InputSection.cpp

 }
 
 InputSection InputSection::discarded(nullptr, 0, 0, 0, ArrayRef<uint8_t>(), "");
 
 InputSection::InputSection(InputFile *f, uint64_t flags, uint32_t type,
                            uint32_t alignment, ArrayRef<uint8_t> data,
                            StringRef name, Kind k)
     : InputSectionBase(f, flags, type,
-                       /*Entsize*/ 0, /*Link*/ 0, /*Info*/ 0, alignment, data,
+                       /*entsize=*/0, /*link=*/0, /*info=*/0, alignment, data,
                        name, k) {}
 
 template <class ELFT>
 InputSection::InputSection(ObjFile<ELFT> &f, const typename ELFT::Shdr &header,
                            StringRef name)
     : InputSectionBase(f, header, name, InputSectionBase::Regular) {}
 
 bool InputSection::classof(const SectionBase *s) {

 MergeInputSection::MergeInputSection(ObjFile<ELFT> &f,
                                      const typename ELFT::Shdr &header,
                                      StringRef name)
     : InputSectionBase(f, header, name, InputSectionBase::Merge) {}
 
 MergeInputSection::MergeInputSection(uint64_t flags, uint32_t type,
                                      uint64_t entsize, ArrayRef<uint8_t> data,
                                      StringRef name)
-    : InputSectionBase(nullptr, flags, type, entsize, /*Link*/ 0, /*Info*/ 0,
-                       /*Alignment*/ entsize, data, name, SectionBase::Merge) {}
+    : InputSectionBase(nullptr, flags, type, entsize, /*link=*/0, /*info=*/0,
+                       /*alignment=*/entsize, data, name, SectionBase::Merge) {}
 
 // This function is called after we obtain a complete list of input sections
 // that need to be linked. This is responsible to split section contents
 // into small chunks for further processing.
 //
 // Note that this function is called from parallelForEach. This must be
 // thread-safe (i.e. no memory allocation from the pools).
 void MergeInputSection::splitIntoPieces() {

lld/ELF/LTO.cpp

c.PostInternalizeModuleHook = [](size_t task, const Module &m) {
       if (std::unique_ptr<raw_fd_ostream> os = openFile(config->outputFile))
         WriteBitcodeToFile(m, *os, false);
       return false;
     };
   }
 
   if (config->saveTemps)
     checkError(c.addSaveTemps(config->outputFile.str() + ".",
-                              /*UseInputModulePath*/ true));
+                              /*useInputModulePath=*/true));
   return c;
 }
 
 BitcodeCompiler::BitcodeCompiler() {
   // Initialize IndexFile.
   if (!config->thinLTOIndexOnlyArg.empty())
     indexFile = openFile(config->thinLTOIndexOnlyArg);
 
static void thinLTOCreateEmptyIndexFiles() {
   for (LazyObjFile *f : lazyObjFiles) {
     if (!isBitcode(f->mb))
       continue;
     std::string path = replaceThinLTOSuffix(getThinLTOOutputFile(f->getName()));
     std::unique_ptr<raw_fd_ostream> os = openFile(path + ".thinlto.bc");
     if (!os)
       continue;
 
-    ModuleSummaryIndex m(/*HaveGVs*/ false);
+    ModuleSummaryIndex m(/*haveGVs=*/false);
     m.setSkipModuleByDistributedBackend();
     WriteIndexToFile(m, *os);
     if (config->thinLTOEmitImportsFiles)
       openFile(path + ".imports");
   }
 }
 
 // Merge all the bitcode files we have seen, codegen the result

lld/ELF/OutputSections.cpp

void OutputSection::writeHeaderTo(typename ELFT::Shdr *shdr) {
   shdr->sh_link = link;
   shdr->sh_addr = addr;
   shdr->sh_size = size;
   shdr->sh_name = shName;
 }
 
 OutputSection::OutputSection(StringRef name, uint32_t type, uint64_t flags)
     : BaseCommand(OutputSectionKind),
-      SectionBase(Output, name, flags, /*Entsize*/ 0, /*Alignment*/ 1, type,
-                  /*Info*/ 0, /*Link*/ 0) {}
+      SectionBase(Output, name, flags, /*entsize=*/0, /*alignment=*/1, type,
+                  /*info=*/0, /*link=*/0) {}
 
 // We allow sections of types listed below to merged into a
 // single progbits section. This is typically done by linker
 // scripts. Merging nobits and progbits will force disk space
 // to be allocated for nobits sections. Other ones don't require
 // any special treatment on top of progbits, so there doesn't
 // seem to be a harm in merging them.
 static bool canMergeToProgbits(unsigned type) {

lld/ELF/ScriptParser.cpp

void ScriptParser::readDefsym(StringRef name) {
   script->sectionCommands.push_back(cmd);
 }
 
 void ScriptParser::addFile(StringRef s) {
   if (isUnderSysroot && s.startswith("/")) {
     SmallString<128> pathData;
     StringRef path = (config->sysroot + s).toStringRef(pathData);
     if (sys::fs::exists(path)) {
-      driver->addFile(Saver.save(path), /*WithLOption=*/false);
+      driver->addFile(Saver.save(path), /*withLOption=*/false);
       return;
     }
   }
 
   if (s.startswith("/")) {
-    driver->addFile(s, /*WithLOption=*/false);
+    driver->addFile(s, /*withLOption=*/false);
   } else if (s.startswith("=")) {
     if (config->sysroot.empty())
-      driver->addFile(s.substr(1), /*WithLOption=*/false);
+      driver->addFile(s.substr(1), /*withLOption=*/false);
     else
       driver->addFile(Saver.save(config->sysroot + "/" + s.substr(1)),
-                      /*WithLOption=*/false);
+                      /*withLOption=*/false);
   } else if (s.startswith("-l")) {
     driver->addLibrary(s.substr(2));
   } else if (sys::fs::exists(s)) {
-    driver->addFile(s, /*WithLOption=*/false);
+    driver->addFile(s, /*withLOption=*/false);
   } else {
     if (Optional<std::string> path = findFromSearchPaths(s))
-      driver->addFile(Saver.save(*path), /*WithLOption=*/true);
+      driver->addFile(Saver.save(*path), /*withLOption=*/true);
     else
       setError("unable to find " + s);
   }
 }
 
 void ScriptParser::readAsNeeded() {
   expect("(");
   bool orig = config->asNeeded;

lld/ELF/Thunks.cpp

if (!dest.isInPPC64Branchlt())
       in.ppc64LongBranchTarget->addEntry(dest);
   }
 };
 
 } // end anonymous namespace
 
 Defined *Thunk::addSymbol(StringRef name, uint8_t type, uint64_t value,
                           InputSectionBase &section) {
-  Defined *d = addSyntheticLocal(name, type, value, /*Size=*/0, section);
+  Defined *d = addSyntheticLocal(name, type, value, /*size=*/0, section);
   syms.push_back(d);
   return d;
 }
 
 void Thunk::setOffset(uint64_t newOffset) {
   for (Defined *d : syms)
     d->value = d->value - offset + newOffset;
   offset = newOffset;

lld/ELF/Writer.cpp

 
 static Defined *addOptionalRegular(StringRef name, SectionBase *sec,
                                    uint64_t val, uint8_t stOther = STV_HIDDEN,
                                    uint8_t binding = STB_GLOBAL) {
   Symbol *s = symtab->find(name);
   if (!s || s->isDefined())
     return nullptr;
 
-  s->resolve(Defined{/*File=*/nullptr, name, binding, stOther, STT_NOTYPE, val,
-                     /*Size=*/0, sec});
+  s->resolve(Defined{/*file=*/nullptr, name, binding, stOther, STT_NOTYPE, val,
+                     /*size=*/0, sec});
   return cast<Defined>(s);
 }
 
 static Defined *addAbsolute(StringRef name) {
   Symbol *sym = symtab->addSymbol(Defined{nullptr, name, STB_GLOBAL, STV_HIDDEN,
                                           STT_NOTYPE, 0, 0, nullptr});
   return cast<Defined>(sym);
 }
if (s->isDefined()) {
             gotSymName + "'");
       return;
     }
 
     uint64_t gotOff = 0;
     if (config->emachine == EM_PPC64)
       gotOff = 0x8000;
 
-    s->resolve(Defined{/*File=*/nullptr, gotSymName, STB_GLOBAL, STV_HIDDEN,
-                       STT_NOTYPE, gotOff, /*Size=*/0, Out::elfHeader});
+    s->resolve(Defined{/*file=*/nullptr, gotSymName, STB_GLOBAL, STV_HIDDEN,
+                       STT_NOTYPE, gotOff, /*size=*/0, Out::elfHeader});
     ElfSym::globalOffsetTable = cast<Defined>(s);
   }
 
   // __ehdr_start is the location of ELF file headers. Note that we define
   // this symbol unconditionally even when using a linker script, which
   // differs from the behavior implemented by GNU linker which only define
   // this symbol if ELF headers are in the memory mapped segment.
   addOptionalRegular("__ehdr_start", Out::elfHeader, 0, STV_HIDDEN);
template <class ELFT> static void createSyntheticSections() {
   }
 
   if (config->gdbIndex)
     add(GdbIndexSection::create<ELFT>());
 
   // We always need to add rel[a].plt to output if it has entries.
   // Even for static linking it can contain R_[*]_IRELATIVE relocations.
   in.relaPlt = make<RelocationSection<ELFT>>(
-      config->isRela ? ".rela.plt" : ".rel.plt", false /*Sort*/);
+      config->isRela ? ".rela.plt" : ".rel.plt", /*sort=*/false);
   add(in.relaPlt);
 
   // The RelaIplt immediately follows .rel.plt (.rel.dyn for ARM) to ensure
   // that the IRelative relocations are processed last by the dynamic loader.
   // We cannot place the iplt section in .rel.dyn when Android relocation
   // packing is enabled because that would cause a section type mismatch.
   // However, because the Android dynamic loader reads .rel.plt after .rel.dyn,
   // we can get the desired behaviour by placing the iplt section in .rel.plt.
   in.relaIplt = make<RelocationSection<ELFT>>(
       (config->emachine == EM_ARM && !config->androidPackDynRelocs)
           ? ".rel.dyn"
           : in.relaPlt->name,
-      false /*Sort*/);
+       /*sort=*/false);
   add(in.relaIplt);
 
   in.plt = make<PltSection>(false);
   add(in.plt);
   in.iplt = make<PltSection>(true);
   add(in.iplt);
 
   if (config->andFeatures)
for (BaseCommand *base : script->sectionCommands) {
 
     // Unlike other synthetic sections, mergeable output sections contain data
     // copied from input sections, and there may be a relocation pointing to its
     // contents if -r or -emit-reloc are given.
     if (isa<SyntheticSection>(isec) && !(isec->flags & SHF_MERGE))
       continue;
 
     auto *sym =
-        make<Defined>(isec->file, "", STB_LOCAL, /*StOther=*/0, STT_SECTION,
-                      /*Value=*/0, /*Size=*/0, isec);
+        make<Defined>(isec->file, "", STB_LOCAL, /*stOther=*/0, STT_SECTION,
+                      /*value=*/0, /*size=*/0, isec);
     in.symTab->addSymbol(sym);
   }
 }
 
 // Today's loaders have a feature to make segments read-only after
 // processing dynamic relocations to enhance security. PT_GNU_RELRO
 // is defined for that.
 //
for (BaseCommand *base : script->sectionCommands)
         addStartStopSymbols(sec);
   }
 
   // Add _DYNAMIC symbol. Unlike GNU gold, our _DYNAMIC symbol has no type.
   // It should be okay as no one seems to care about the type.
   // Even the author of gold doesn't remember why gold behaves that way.
   // https://sourceware.org/ml/binutils/2002-03/msg00360.html
   if (mainPart->dynamic->parent)
-    symtab->addSymbol(Defined{/*File=*/nullptr, "_DYNAMIC", STB_WEAK,
+    symtab->addSymbol(Defined{/*file=*/nullptr, "_DYNAMIC", STB_WEAK,
                               STV_HIDDEN, STT_NOTYPE,
-                              /*Value=*/0, /*Size=*/0, mainPart->dynamic});
+                              /*value=*/0, /*size=*/0, mainPart->dynamic});
 
   // Define __rel[a]_iplt_{start,end} symbols if needed.
   addRelIpltSymbols();
 
   // RISC-V's gp can address +/- 2 KiB, set it to .sdata + 0x800 if not defined.
   // This symbol should only be defined in an executable.
   if (config->emachine == EM_RISCV && !config->shared)
     ElfSym::riscvGlobalPointer =
if (config->emachine == EM_X86_64) {
     // 2) With LD->LE relaxation: _TLS_MODULE_BASE_@tpoff = 0 (lowest address in
     // the TLS block).
     //
     // 2) is special cased in @tpoff computation. To satisfy 1), we define it as
     // an absolute symbol of zero. This is different from GNU linkers which
     // define _TLS_MODULE_BASE_ relative to the first TLS section.
     Symbol *s = symtab->find("_TLS_MODULE_BASE_");
     if (s && s->isUndefined()) {
-      s->resolve(Defined{/*File=*/nullptr, s->getName(), STB_GLOBAL, STV_HIDDEN,
-                         STT_TLS, /*Value=*/0, 0,
-                         /*Section=*/nullptr});
+      s->resolve(Defined{/*file=*/nullptr, s->getName(), STB_GLOBAL, STV_HIDDEN,
+                         STT_TLS, /*value=*/0, 0,
+                         /*section=*/nullptr});
       ElfSym::tlsModuleBase = cast<Defined>(s);
     }
   }
 
   // This responsible for splitting up .eh_frame section into
   // pieces. The relocation scan uses those pieces, so this has to be
   // earlier.
   for (Partition &part : partitions)