Avoid by-value copies of referenced objects

[urnathan]

Summary

These were detected by the new -Wauto-by-value-copy (D114989) warning, these by-value
constant copies need only be references.

[aaron.ballman]

LGTM! I think it's reasonable to not have test coverage for this change as it is functionally equivalent code, despite not being quite NFC.

llvm/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp

ScanOperands:
     {
     unsigned NumOperands = N->getNumOperands();
     bool NeedsReanalyzing = false;
     unsigned i;
     for (i = 0; i != NumOperands; ++i) {
       if (IgnoreNodeResults(N->getOperand(i).getNode()))
         continue;
 
-      const auto Op = N->getOperand(i);
+      const auto &Op = N->getOperand(i);
       LLVM_DEBUG(dbgs() << "Analyzing operand: "; Op.dump(&DAG));
       EVT OpVT = Op.getValueType();
       switch (getTypeAction(OpVT)) {
       case TargetLowering::TypeLegal:
         LLVM_DEBUG(dbgs() << "Legal operand\n");
         continue;
       case TargetLowering::TypeScalarizeScalableVector:
         report_fatal_error(

llvm/lib/DebugInfo/GSYM/DwarfTransformer.cpp

for (auto Addr = *FuncAddr; Addr < *FuncAddr + FI->size(); ++Addr) {
       }
       if (NumDwarfInlineInfos > 0 &&
           NumDwarfInlineInfos != LR->Locations.size()) {
         Log << "error: address " << HEX64(Addr) << " has "
             << NumDwarfInlineInfos << " DWARF inline frames and GSYM has "
             << LR->Locations.size() << "\n";
         Log << "    " << NumDwarfInlineInfos << " DWARF frames:\n";
         for (size_t Idx = 0; Idx < NumDwarfInlineInfos; ++Idx) {
-          const auto dii = DwarfInlineInfos.getFrame(Idx);
+          const auto &dii = DwarfInlineInfos.getFrame(Idx);
           Log << "    [" << Idx << "]: " << dii.FunctionName << " @ "
               << dii.FileName << ':' << dii.Line << '\n';
         }
         Log << "    " << LR->Locations.size() << " GSYM frames:\n";
         for (size_t Idx = 0, count = LR->Locations.size();
               Idx < count; ++Idx) {
           const auto &gii = LR->Locations[Idx];
           Log << "    [" << Idx << "]: " << gii.Name << " @ " << gii.Dir
               << '/' << gii.Base << ':' << gii.Line << '\n';
         }
         DwarfInlineInfos = DICtx.getInliningInfoForAddress(SectAddr, DLIS);
         Gsym->dump(Log, *FI);
         continue;
       }
 
       for (size_t Idx = 0, count = LR->Locations.size(); Idx < count;
             ++Idx) {
         const auto &gii = LR->Locations[Idx];
         if (Idx < NumDwarfInlineInfos) {
-          const auto dii = DwarfInlineInfos.getFrame(Idx);
+          const auto &dii = DwarfInlineInfos.getFrame(Idx);
           gsymFilename = LR->getSourceFile(Idx);
           // Verify function name
           if (dii.FunctionName.find(gii.Name.str()) != 0)
             Log << "error: address " << HEX64(Addr) << " DWARF function \""
                 << dii.FunctionName.c_str()
                 << "\" doesn't match GSYM function \"" << gii.Name << "\"\n";
           // Verify source file path
           if (dii.FileName != gsymFilename)

llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp

for (auto I = Nodes.rbegin() + 1, E = Nodes.rend(); I != E; ++I) {
                                       *RegisterInfo)) {
           if (!canLoad || !InstrDesc.mayLoad())
             return Node;
           canLoad = false;
           CurRegisterNumbers.erase(RI);
           // Add the registers this load reads to those we check for clobbers.
           for (unsigned i = InstrDesc.getNumDefs(),
                         e = InstrDesc.getNumOperands(); i != e; i++) {
-            const auto Operand = NodeInstr.Instruction.getOperand(i);
+            const auto &Operand = NodeInstr.Instruction.getOperand(i);
             if (Operand.isReg())
               CurRegisterNumbers.insert(Operand.getReg());
           }
           break;
         }
       }
     }
   }