toString function take a const refs where possible

[sbc100]

• revert part

[ruiu]

Common/Reproduce.cpp

58

Did you have to change * to &?

[sbc100]

Common/Reproduce.cpp

58

Its not necessary, but its consistent with the rest of the code here and in llvm (although they use operator<< on streams there it seems).

Its also a nice hint the reader that this function doesn't accept null isn't it?

If you like I can revert this part.

[ruiu]

I was just wondering if there's a deeper meaning than that. LGTM.

COFF/Driver.cpp

for (auto *Arg : Args) {
     case OPT_manifest:
     case OPT_manifest_colon:
     case OPT_manifestdependency:
     case OPT_manifestfile:
     case OPT_manifestinput:
     case OPT_manifestuac:
       break;
     default:
-      OS << toString(Arg) << "\n";
+      OS << toString(*Arg) << "\n";
     }
   }
 
   for (StringRef Path : SearchPaths) {
     std::string RelPath = relativeToRoot(Path);
     OS << "/libpath:" << quote(RelPath) << "\n";
   }
 
for (auto *Arg : Args) {
     case OPT_lldmap:
     case OPT_lldmap_file:
     case OPT_lldsavetemps:
     case OPT_msvclto:
       // LLD-specific options are stripped.
       break;
     case OPT_opt:
       if (!StringRef(Arg->getValue()).startswith("lld"))
-        Rsp += toString(Arg) + " ";
+        Rsp += toString(*Arg) + " ";
       break;
     case OPT_INPUT: {
       if (Optional<StringRef> Path = doFindFile(Arg->getValue())) {
         if (Optional<std::string> S = filterBitcodeFiles(*Path, Temps))
           Rsp += quote(*S) + "\n";
         continue;
       }
       Rsp += quote(Arg->getValue()) + "\n";
       break;
     }
     default:
-      Rsp += toString(Arg) + "\n";
+      Rsp += toString(*Arg) + "\n";
     }
   }
 
   std::vector<StringRef> ObjFiles = Symtab->compileBitcodeFiles();
   runMSVCLinker(Rsp, ObjFiles);
 
   for (StringRef Path : Temps)
     sys::fs::remove(Path);

COFF/InputFiles.h

 // The root class of input files.
 class InputFile {
 public:
   enum Kind { ArchiveKind, ObjectKind, ImportKind, BitcodeKind };
   Kind kind() const { return FileKind; }
   virtual ~InputFile() {}
 
   // Returns the filename.
-  StringRef getName() { return MB.getBufferIdentifier(); }
+  StringRef getName() const { return MB.getBufferIdentifier(); }
 
   // Reads a file (the constructor doesn't do that).
   virtual void parse() = 0;
 
   // Returns the CPU type this file was compiled to.
   virtual MachineTypes getMachineType() { return IMAGE_FILE_MACHINE_UNKNOWN; }
 
   MemoryBufferRef MB;

 
 private:
   void parse() override;
 
   std::vector<Symbol *> SymbolBodies;
 };
 } // namespace coff
 
-std::string toString(coff::InputFile *File);
+std::string toString(const coff::InputFile *File);
 } // namespace lld
 
 #endif

COFF/InputFiles.cpp

 static StringRef getBasename(StringRef Path) {
   size_t Pos = Path.find_last_of("\\/");
   if (Pos == StringRef::npos)
     return Path;
   return Path.substr(Pos + 1);
 }
 
 // Returns a string in the format of "foo.obj" or "foo.obj(bar.lib)".
-std::string lld::toString(coff::InputFile *File) {
+std::string lld::toString(const coff::InputFile *File) {
   if (!File)
     return "<internal>";
   if (File->ParentName.empty())
     return File->getName().lower();
 
   std::string Res =
       (getBasename(File->ParentName) + "(" + getBasename(File->getName()) + ")")
           .str();
   return StringRef(Res).lower();
 }

Common/Reproduce.cpp

 }
 
 std::string lld::rewritePath(StringRef S) {
   if (fs::exists(S))
     return relativeToRoot(S);
   return S;
 }
 
-std::string lld::toString(opt::Arg *Arg) {
-  std::string K = Arg->getSpelling();
-  if (Arg->getNumValues() == 0)
+std::string lld::toString(const opt::Arg &Arg) {
+  std::string K = Arg.getSpelling();
+  if (Arg.getNumValues() == 0)
     return K;
-  std::string V = quote(Arg->getValue());
-  if (Arg->getOption().getRenderStyle() == opt::Option::RenderJoinedStyle)
+  std::string V = quote(Arg.getValue());
+  if (Arg.getOption().getRenderStyle() == opt::Option::RenderJoinedStyle)
     return K + V;
   return K + " " + V;
 }

ELF/Driver.cpp

static StripPolicy getStrip(opt::InputArgList &Args) {
   auto *Arg = Args.getLastArg(OPT_strip_all, OPT_strip_debug);
   if (!Arg)
     return StripPolicy::None;
   if (Arg->getOption().getID() == OPT_strip_all)
     return StripPolicy::All;
   return StripPolicy::Debug;
 }
 
-static uint64_t parseSectionAddress(StringRef S, opt::Arg *Arg) {
+static uint64_t parseSectionAddress(StringRef S, const opt::Arg &Arg) {
   uint64_t VA = 0;
   if (S.startswith("0x"))
     S = S.drop_front(2);
   if (!to_integer(S, VA, 16))
     error("invalid argument: " + toString(Arg));
   return VA;
 }
 
 static StringMap<uint64_t> getSectionStartMap(opt::InputArgList &Args) {
   StringMap<uint64_t> Ret;
   for (auto *Arg : Args.filtered(OPT_section_start)) {
     StringRef Name;
     StringRef Addr;
     std::tie(Name, Addr) = StringRef(Arg->getValue()).split('=');
-    Ret[Name] = parseSectionAddress(Addr, Arg);
+    Ret[Name] = parseSectionAddress(Addr, *Arg);
   }
 
   if (auto *Arg = Args.getLastArg(OPT_Ttext))
-    Ret[".text"] = parseSectionAddress(Arg->getValue(), Arg);
+    Ret[".text"] = parseSectionAddress(Arg->getValue(), *Arg);
   if (auto *Arg = Args.getLastArg(OPT_Tdata))
-    Ret[".data"] = parseSectionAddress(Arg->getValue(), Arg);
+    Ret[".data"] = parseSectionAddress(Arg->getValue(), *Arg);
   if (auto *Arg = Args.getLastArg(OPT_Tbss))
-    Ret[".bss"] = parseSectionAddress(Arg->getValue(), Arg);
+    Ret[".bss"] = parseSectionAddress(Arg->getValue(), *Arg);
   return Ret;
 }
 
 static SortSectionPolicy getSortSection(opt::InputArgList &Args) {
   StringRef S = Args.getLastArgValue(OPT_sort_section);
   if (S == "alignment")
     return SortSectionPolicy::Alignment;
   if (S == "name")

ELF/DriverUtils.cpp

for (auto *Arg : Args) {
     case OPT_script:
     case OPT_symbol_ordering_file:
     case OPT_sysroot:
     case OPT_version_script:
       OS << Arg->getSpelling() << " " << quote(rewritePath(Arg->getValue()))
          << "\n";
       break;
     default:
-      OS << toString(Arg) << "\n";
+      OS << toString(*Arg) << "\n";
     }
   }
   return Data.str();
 }
 
 // Find a file by concatenating given paths. If a resulting path
 // starts with "=", the character is replaced with a --sysroot value.
 static Optional<std::string> findFile(StringRef Path1, const Twine &Path2) {

include/lld/Common/Reproduce.h

 // Quote a given string if it contains a space character.
 std::string quote(StringRef S);
 
 // Rewrite the given path if a file exists with that pathname, otherwise
 // returns the original path.
 std::string rewritePath(StringRef S);
 
 // Returns the string form of the given argument.
-std::string toString(llvm::opt::Arg *Arg);
+std::string toString(const llvm::opt::Arg &Arg);
 }
 
 #endif

wasm/InputFiles.h

private:
   std::unique_ptr<WasmObjectFile> WasmObj;
 };
 
 // Opens a given file.
 llvm::Optional<MemoryBufferRef> readFile(StringRef Path);
 
 } // namespace wasm
 
-std::string toString(wasm::InputFile *File);
+std::string toString(const wasm::InputFile *File);
 
 } // namespace lld
 
 #endif

wasm/InputFiles.cpp

void ArchiveFile::addMember(const Archive::Symbol *Sym) {
   }
 
   InputFile *Obj = make<ObjFile>(MB);
   Obj->ParentName = ParentName;
   Symtab->addFile(Obj);
 }
 
 // Returns a string in the format of "foo.o" or "foo.a(bar.o)".
-std::string lld::toString(wasm::InputFile *File) {
+std::string lld::toString(const wasm::InputFile *File) {
   if (!File)
     return "<internal>";
 
   if (File->ParentName.empty())
     return File->getName();
 
   return (File->ParentName + "(" + File->getName() + ")").str();
 }

wasm/Symbols.h

protected:
   const InputSegment *Segment = nullptr;
   llvm::Optional<uint32_t> OutputIndex;
   const WasmSignature *FunctionType;
 };
 
 } // namespace wasm
 
 // Returns a symbol name for an error message.
-std::string toString(wasm::Symbol &Sym);
-std::string toString(wasm::Symbol::Kind &Kind);
+std::string toString(const wasm::Symbol &Sym);
+std::string toString(wasm::Symbol::Kind Kind);
 
 } // namespace lld
 
 #endif

wasm/Symbols.cpp

void Symbol::update(Kind K, InputFile *F, const WasmSymbol *WasmSym,
   Segment = Seg;
   FunctionType = Sig;
 }
 
 bool Symbol::isWeak() const { return Sym && Sym->isWeak(); }
 
 bool Symbol::isHidden() const { return Sym && Sym->isHidden(); }
 
-std::string lld::toString(wasm::Symbol &Sym) {
+std::string lld::toString(const wasm::Symbol &Sym) {
   return wasm::displayName(Sym.getName());
 }
 
-std::string lld::toString(wasm::Symbol::Kind &Kind) {
+std::string lld::toString(wasm::Symbol::Kind Kind) {
   switch (Kind) {
   case wasm::Symbol::DefinedFunctionKind:
     return "DefinedFunction";
   case wasm::Symbol::DefinedGlobalKind:
     return "DefinedGlobal";
   case wasm::Symbol::UndefinedFunctionKind:
     return "UndefinedFunction";
   case wasm::Symbol::UndefinedGlobalKind:
     return "UndefinedGlobal";
   case wasm::Symbol::LazyKind:
     return "LazyKind";
   }
   llvm_unreachable("Invalid symbol kind!");
 }