[libfuzzer] avoid unneccessary copy

[yingcong-wu]

Summary

Avoid some unneccessary copy

[fmayer]

Can those be const auto&?

[yingcong-wu]

In D145758#4183509, @fmayer wrote:

Can those be const auto&?

Yes, that would be better, I will change to that.

[yingcong-wu]

add const to references

[fmayer]

Could you please rebase to fix pre-merge check patch application?

[yingcong-wu]

In D145758#4183561, @fmayer wrote:

Could you please rebase to fix pre-merge check patch application?

Sure.

[yingcong-wu]

resolve merge conflict

[yingcong-wu]

another try to resolve merge conflict

[yingcong-wu]

Hi @fmayer, I don’t have commit access, can you land this patch for me? Thanks.

compiler-rt/lib/fuzzer/FuzzerCommand.h

public:
 
   // Sets whether to redirect the command's stderr to its stdout.
   void combineOutAndErr(bool combine = true) { CombinedOutAndErr = combine; }
 
   // Returns a string representation of the command.  On many systems this will
   // be the equivalent command line.
   std::string toString() const {
     std::stringstream SS;
-    for (auto arg : getArguments())
+    for (const auto &arg : getArguments())
       SS << arg << " ";
     if (hasOutputFile())
       SS << ">" << getOutputFile() << " ";
     if (isOutAndErrCombined())
       SS << "2>&1 ";
     std::string result = SS.str();
     if (!result.empty())
       result = result.substr(0, result.length() - 1);

compiler-rt/lib/fuzzer/FuzzerDataFlowTrace.cpp

 
 // Assign weights to each function.
 // General principles:
 //   * any uncovered function gets weight 0.
 //   * a function with lots of uncovered blocks gets bigger weight.
 //   * a function with a less frequently executed code gets bigger weight.
 std::vector<double> BlockCoverage::FunctionWeights(size_t NumFunctions) const {
   std::vector<double> Res(NumFunctions);
-  for (auto It : Functions) {
+  for (const auto &It : Functions) {
     auto FunctionID = It.first;
     auto Counters = It.second;
     assert(FunctionID < NumFunctions);
     auto &Weight = Res[FunctionID];
     // Give higher weight if the function has a DFT.
     Weight = FunctionsWithDFT.count(FunctionID) ? 1000. : 1;
     // Give higher weight to functions with less frequently seen basic blocks.
     Weight /= SmallestNonZeroCounter(Counters);

compiler-rt/lib/fuzzer/FuzzerInternal.h

 #include <string.h>
 
 namespace fuzzer {
 
 using namespace std::chrono;
 
 class Fuzzer final {
 public:
-
   Fuzzer(UserCallback CB, InputCorpus &Corpus, MutationDispatcher &MD,
-         FuzzingOptions Options);
+         FuzzingOptions &Options);
   ~Fuzzer() = delete;
   void Loop(std::vector<SizedFile> &CorporaFiles);
   void ReadAndExecuteSeedCorpora(std::vector<SizedFile> &CorporaFiles);
   void MinimizeCrashLoop(const Unit &U);
   void RereadOutputCorpus(size_t MaxSize);
 
   size_t secondsSinceProcessStartUp() {
     return duration_cast<seconds>(system_clock::now() - ProcessStartTime)

compiler-rt/lib/fuzzer/FuzzerLoop.cpp

void Fuzzer::HandleMalloc(size_t Size) {
   PrintStackTrace();
   DumpCurrentUnit("oom-");
   Printf("SUMMARY: libFuzzer: out-of-memory\n");
   PrintFinalStats();
   _Exit(Options.OOMExitCode); // Stop right now.
 }
 
 Fuzzer::Fuzzer(UserCallback CB, InputCorpus &Corpus, MutationDispatcher &MD,
-               FuzzingOptions Options)
+               const FuzzingOptions &Options)
     : CB(CB), Corpus(Corpus), MD(MD), Options(Options) {
   if (EF->__sanitizer_set_death_callback)
     EF->__sanitizer_set_death_callback(StaticDeathCallback);
   assert(!F);
   F = this;
   TPC.ResetMaps();
   IsMyThread = true;
   if (Options.DetectLeaks && EF->__sanitizer_install_malloc_and_free_hooks)

compiler-rt/lib/fuzzer/FuzzerMutate.cpp

for (size_t i = 0; i < EntriesToPrint; i++) {
       Printf("\"");
       PrintASCII(CurrentDictionaryEntrySequence[i]->GetW(), "\"-");
     }
   }
 }
 
 std::string MutationDispatcher::MutationSequence() {
   std::string MS;
-  for (auto M : CurrentMutatorSequence) {
+  for (const auto &M : CurrentMutatorSequence) {
     MS += M.Name;
     MS += "-";
   }
   return MS;
 }
 
 size_t MutationDispatcher::Mutate(uint8_t *Data, size_t Size, size_t MaxSize) {
   return MutateImpl(Data, Size, MaxSize, Mutators);