Prefer `ArrayRef` over `const std::vector&`

[ruiu]

LGTM

Thank you for doing this!

COFF/Driver.h

 class LinkerDriver;
 extern LinkerDriver *Driver;
 
 using llvm::COFF::MachineTypes;
 using llvm::COFF::WindowsSubsystem;
 using llvm::Optional;
 
 // Implemented in MarkLive.cpp.
-void markLive(const std::vector<Chunk *> &Chunks);
+void markLive(ArrayRef<Chunk *> Chunks);
 
 // Implemented in ICF.cpp.
-void doICF(const std::vector<Chunk *> &Chunks);
+void doICF(ArrayRef<Chunk *> Chunks);
 
 class COFFOptTable : public llvm::opt::OptTable {
 public:
   COFFOptTable();
 };
 
 class ArgParser {
 public:

 
 // Parses a string in the form of "key=value" and check
 // if value matches previous values for the key.
 // This feature used in the directive section to reject
 // incompatible objects.
 void checkFailIfMismatch(StringRef Arg);
 
 // Convert Windows resource files (.res files) to a .obj file.
-MemoryBufferRef convertResToCOFF(const std::vector<MemoryBufferRef> &MBs);
+MemoryBufferRef convertResToCOFF(ArrayRef<MemoryBufferRef> MBs);
 
 void runMSVCLinker(std::string Rsp, ArrayRef<StringRef> Objects);
 
 // Create enum with OPT_xxx values for each option in Options.td
 enum {
   OPT_INVALID = 0,
 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
 #include "Options.inc"
 #undef OPTION
 };
 
 } // namespace coff
 } // namespace lld
 
 #endif

COFF/DriverUtils.cpp

void checkFailIfMismatch(StringRef Arg) {
   StringRef Existing = Config->MustMatch[K];
   if (!Existing.empty() && V != Existing)
     fatal("/failifmismatch: mismatch detected: " + Existing + " and " + V +
           " for key " + K);
   Config->MustMatch[K] = V;
 }
 
 // Convert Windows resource files (.res files) to a .obj file.
-MemoryBufferRef convertResToCOFF(const std::vector<MemoryBufferRef> &MBs) {
+MemoryBufferRef convertResToCOFF(ArrayRef<MemoryBufferRef> MBs) {
   object::WindowsResourceParser Parser;
 
   for (MemoryBufferRef MB : MBs) {
     std::unique_ptr<object::Binary> Bin = check(object::createBinary(MB));
     object::WindowsResource *RF = dyn_cast<object::WindowsResource>(Bin.get());
     if (!RF)
       fatal("cannot compile non-resource file as resource");
     if (auto EC = Parser.parse(RF))

COFF/ICF.cpp

 
 using namespace llvm;
 
 namespace lld {
 namespace coff {
 
 class ICF {
 public:
-  void run(const std::vector<Chunk *> &V);
+  void run(ArrayRef<Chunk *> V);
 
 private:
   void segregate(size_t Begin, size_t End, bool Constant);
 
   bool equalsConstant(const SectionChunk *A, const SectionChunk *B);
   bool equalsVariable(const SectionChunk *A, const SectionChunk *B);
 
   uint32_t getHash(SectionChunk *C);
for_each_n(parallel::par, size_t(0), NumShards, [&](size_t I) {
     forEachClassRange(I * Step, End, Fn);
   });
   ++Cnt;
 }
 
 // Merge identical COMDAT sections.
 // Two sections are considered the same if their section headers,
 // contents and relocations are all the same.
-void ICF::run(const std::vector<Chunk *> &Vec) {
+void ICF::run(ArrayRef<Chunk *> Vec) {
   // Collect only mergeable sections and group by hash value.
   uint32_t NextId = 1;
   for (Chunk *C : Vec) {
     if (auto *SC = dyn_cast<SectionChunk>(C)) {
       if (isEligible(SC))
         Chunks.push_back(SC);
       else
         SC->Class[0] = NextId++;
forEachClass([&](size_t Begin, size_t End) {
     for (size_t I = Begin + 1; I < End; ++I) {
       log("  Removed " + Chunks[I]->getDebugName());
       Chunks[Begin]->replace(Chunks[I]);
     }
   });
 }
 
 // Entry point to ICF.
-void doICF(const std::vector<Chunk *> &Chunks) { ICF().run(Chunks); }
+void doICF(ArrayRef<Chunk *> Chunks) { ICF().run(Chunks); }
 
 } // namespace coff
 } // namespace lld

COFF/InputFiles.h

 
 // .obj or .o file. This may be a member of an archive file.
 class ObjFile : public InputFile {
 public:
   explicit ObjFile(MemoryBufferRef M) : InputFile(ObjectKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }
   void parse() override;
   MachineTypes getMachineType() override;
-  std::vector<Chunk *> &getChunks() { return Chunks; }
-  std::vector<SectionChunk *> &getDebugChunks() { return DebugChunks; }
-  std::vector<Symbol *> &getSymbols() { return Symbols; }
+  ArrayRef<Chunk *> getChunks() { return Chunks; }
+  ArrayRef<SectionChunk *> getDebugChunks() { return DebugChunks; }
+  ArrayRef<Symbol *> getSymbols() { return Symbols; }
 
   // Returns a Symbol object for the SymbolIndex'th symbol in the
   // underlying object file.
   Symbol *getSymbol(uint32_t SymbolIndex) {
     return Symbols[SymbolIndex];
   }
 
   // Returns the underying COFF file.
public:
   bool Live;
 };
 
 // Used for LTO.
 class BitcodeFile : public InputFile {
 public:
   explicit BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
-  std::vector<Symbol *> &getSymbols() { return SymbolBodies; }
+  ArrayRef<Symbol *> getSymbols() { return SymbolBodies; }
   MachineTypes getMachineType() override;
   static std::vector<BitcodeFile *> Instances;
   std::unique_ptr<llvm::lto::InputFile> Obj;
 
 private:
   void parse() override;
 
   std::vector<Symbol *> SymbolBodies;
 };
 } // namespace coff
 
 std::string toString(const coff::InputFile *File);
 } // namespace lld
 
 #endif

COFF/MarkLive.cpp

 #include <vector>
 
 namespace lld {
 namespace coff {
 
 // Set live bit on for each reachable chunk. Unmarked (unreachable)
 // COMDAT chunks will be ignored by Writer, so they will be excluded
 // from the final output.
-void markLive(const std::vector<Chunk *> &Chunks) {
+void markLive(ArrayRef<Chunk *> Chunks) {
   // We build up a worklist of sections which have been marked as live. We only
   // push into the worklist when we discover an unmarked section, and we mark
   // as we push, so sections never appear twice in the list.
   SmallVector<SectionChunk *, 256> Worklist;
 
   // COMDAT section chunks are dead by default. Add non-COMDAT chunks.
   for (Chunk *C : Chunks)
     if (auto *SC = dyn_cast<SectionChunk>(C))

COFF/PDB.cpp

private:
 
   std::vector<pdb::SecMapEntry> SectionMap;
 
   /// Type index mappings of type server PDBs that we've loaded so far.
   std::map<GUID, CVIndexMap> TypeServerIndexMappings;
 };
 }
 
-static SectionChunk *findByName(std::vector<SectionChunk *> &Sections,
+static SectionChunk *findByName(ArrayRef<SectionChunk *> Sections,
                                 StringRef Name) {
   for (SectionChunk *C : Sections)
     if (C->getSectionName() == Name)
       return C;
   return nullptr;
 }
 
 static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> Data,

COFF/SymbolTable.cpp

DefinedImportThunk *SymbolTable::addImportThunk(StringRef Name,
 
   reportDuplicate(S, ID->File);
   return nullptr;
 }
 
 std::vector<Chunk *> SymbolTable::getChunks() {
   std::vector<Chunk *> Res;
   for (ObjFile *File : ObjFile::Instances) {
-    std::vector<Chunk *> &V = File->getChunks();
+    ArrayRef<Chunk *> V = File->getChunks();
     Res.insert(Res.end(), V.begin(), V.end());
   }
   return Res;
 }
 
 Symbol *SymbolTable::find(StringRef Name) {
   auto It = SymMap.find(CachedHashStringRef(Name));
   if (It == SymMap.end())

COFF/Writer.h

 // non-overlapping file offsets and RVAs.
 class OutputSection {
 public:
   OutputSection(llvm::StringRef N) : Name(N), Header({}) {}
   void setRVA(uint64_t);
   void setFileOffset(uint64_t);
   void addChunk(Chunk *C);
   llvm::StringRef getName() { return Name; }
-  std::vector<Chunk *> &getChunks() { return Chunks; }
+  ArrayRef<Chunk *> getChunks() { return Chunks; }
   void addPermissions(uint32_t C);
   void setPermissions(uint32_t C);
   uint32_t getPermissions() { return Header.Characteristics & PermMask; }
   uint32_t getCharacteristics() { return Header.Characteristics; }
   uint64_t getRVA() { return Header.VirtualAddress; }
   uint64_t getFileOff() { return Header.PointerToRawData; }
   void writeHeaderTo(uint8_t *Buf);
 

include/lld/Core/LinkingContext.h

public:
   /// this method returns false for main executables, but true for dynamic
   /// shared libraries.
   bool globalsAreDeadStripRoots() const { return _globalsAreDeadStripRoots; }
 
   /// Only used if deadStrip() returns true.  This method returns the names
   /// of DefinedAtoms that should be marked live (along with all Atoms they
   /// reference). Only Atoms with scope scopeLinkageUnit or scopeGlobal can
   /// be kept live using this method.
-  const std::vector<StringRef> &deadStripRoots() const {
+  ArrayRef<StringRef> deadStripRoots() const {
     return _deadStripRoots;
   }
 
   /// Add the given symbol name to the dead strip root set. Only used if
   /// deadStrip() returns true.
   void addDeadStripRoot(StringRef symbolName) {
     assert(!symbolName.empty() && "Empty symbol cannot be a dead strip root");
     _deadStripRoots.push_back(symbolName);
public:
   /// format the line as needed.
   bool logInputFiles() const { return _logInputFiles; }
 
   /// Parts of LLVM use global variables which are bound to command line
   /// options (see llvm::cl::Options). This method returns "command line"
   /// options which are used to configure LLVM's command line settings.
   /// For instance the -debug-only XXX option can be used to dynamically
   /// trace different parts of LLVM and lld.
-  const std::vector<const char *> &llvmOptions() const { return _llvmOptions; }
+  ArrayRef<const char *> llvmOptions() const { return _llvmOptions; }
 
   /// \name Methods used by Drivers to configure TargetInfo
   /// @{
   void setOutputPath(StringRef str) { _outputPath = str; }
 
   // Set the entry symbol name. You may also need to call addDeadStripRoot() for
   // the symbol if your platform supports dead-stripping, so that the symbol
   // will not be removed from the output.

wasm/InputFiles.h

public:
   const WasmSection *CodeSection = nullptr;
   std::vector<OutputRelocation> CodeRelocations;
   int32_t CodeOffset = 0;
   const WasmSection *DataSection = nullptr;
 
   std::vector<uint32_t> TypeMap;
   std::vector<InputSegment *> Segments;
 
-  const std::vector<Symbol *> &getSymbols() { return Symbols; }
+  ArrayRef<Symbol *> getSymbols() { return Symbols; }
 
 private:
   Symbol *createDefined(const WasmSymbol &Sym,
                         const InputSegment *Segment = nullptr);
   Symbol *createUndefined(const WasmSymbol &Sym);
   void initializeSymbols();
   InputSegment *getSegment(const WasmSymbol &WasmSym);
   const Symbol *getFunctionSymbol(uint32_t Index) const;

wasm/OutputSections.h

public:
   void writeToStream(raw_ostream &OS) {
     writeBytes(OS, Header.data(), Header.size());
     writeBytes(OS, Body.data(), Body.size());
   }
 };
 
 class CodeSection : public OutputSection {
 public:
-  explicit CodeSection(uint32_t NumFunctions, std::vector<ObjFile *> &Objs);
+  explicit CodeSection(uint32_t NumFunctions, ArrayRef<ObjFile *> Objs);
   size_t getSize() const override { return Header.size() + BodySize; }
   void writeTo(uint8_t *Buf) override;
   uint32_t numRelocations() const override;
   void writeRelocations(raw_ostream &OS) const override;
 
 protected:
-  std::vector<ObjFile *> &InputObjects;
+  ArrayRef<ObjFile *> InputObjects;
   std::string CodeSectionHeader;
   size_t BodySize = 0;
 };
 
 class DataSection : public OutputSection {
 public:
-  explicit DataSection(std::vector<OutputSegment *> &Segments);
+  explicit DataSection(ArrayRef<OutputSegment *> Segments);
   size_t getSize() const override { return Header.size() + BodySize; }
   void writeTo(uint8_t *Buf) override;
   uint32_t numRelocations() const override { return Relocations.size(); }
   void writeRelocations(raw_ostream &OS) const override;
 
 protected:
   std::vector<OutputRelocation> Relocations;
-  std::vector<OutputSegment *> &Segments;
+  ArrayRef<OutputSegment *> Segments;
   std::string DataSectionHeader;
   size_t BodySize = 0;
 };
 
 } // namespace wasm
 } // namespace lld
 
 #endif // LLD_WASM_OUTPUT_SECTIONS_H

wasm/OutputSections.cpp

case R_WEBASSEMBLY_MEMORY_ADDR_I32:
     support::endian::write32<support::little>(Buf, Reloc.Value);
     break;
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
 
 static void applyRelocations(uint8_t *Buf,
-                             const std::vector<OutputRelocation> &Relocs) {
+                             ArrayRef<OutputRelocation> Relocs) {
   log("applyRelocations: count=" + Twine(Relocs.size()));
   for (const OutputRelocation &Reloc : Relocs) {
     applyRelocation(Buf, Reloc);
   }
 }
 
 // Relocations contain an index into the function, global or table index
 // space of the input file.  This function takes a relocation and returns the
debugWrite(OS.tell(),
              "section type [" + Twine(sectionTypeToString(Type)) + "]");
   writeUleb128(OS, Type, nullptr);
   writeUleb128(OS, BodySize, "section size");
   OS.flush();
   log("createHeader: " + toString(this) + " body=" + Twine(BodySize) +
       " total=" + Twine(getSize()));
 }
 
-CodeSection::CodeSection(uint32_t NumFunctions, std::vector<ObjFile *> &Objs)
+CodeSection::CodeSection(uint32_t NumFunctions, ArrayRef<ObjFile *> Objs)
     : OutputSection(WASM_SEC_CODE), InputObjects(Objs) {
   raw_string_ostream OS(CodeSectionHeader);
   writeUleb128(OS, NumFunctions, "function count");
   OS.flush();
   BodySize = CodeSectionHeader.size();
 
   for (ObjFile *File : InputObjects) {
     if (!File->CodeSection)

 }
 
 void CodeSection::writeRelocations(raw_ostream &OS) const {
   for (ObjFile *File : InputObjects)
     for (const OutputRelocation &Reloc : File->CodeRelocations)
       writeReloc(OS, Reloc);
 }
 
-DataSection::DataSection(std::vector<OutputSegment *> &Segments)
+DataSection::DataSection(ArrayRef<OutputSegment *> Segments)
     : OutputSection(WASM_SEC_DATA), Segments(Segments) {
   raw_string_ostream OS(DataSectionHeader);
 
   writeUleb128(OS, Segments.size(), "data segment count");
   OS.flush();
   BodySize = DataSectionHeader.size();
 
   for (OutputSegment *Segment : Segments) {