[NFC] ][CLANG] Fix static code analyzer concerns

[Manna]

Summary

Reported by Coverity:

1. Inside "ASTReader.cpp" file, in clang::​ASTReader::​FindExternalLexicalDecls(clang::​DeclContext const *, llvm::​function_ref<bool (clang::​Decl::​Kind)>, llvm::​SmallVectorImpl<clang::​Decl *> &): Using the auto keyword without an & causes a copy.

auto_causes_copy: Using the auto keyword without an & causes the copy of an object of type pair.

2. Inside "ASTReader.cpp" file, in clang::​ASTReader::​ReadAST(llvm::​StringRef, clang::​serialization::​ModuleKind, clang::​SourceLocation, unsigned int, llvm::​SmallVectorImpl<clang::​ASTReader::​ImportedSubmodule> *): Using the auto keyword without an & causes a copy.

auto_causes_copy: Using the auto keyword without an & causes the copy of an object of type DenseMapPair.

3. Inside "CGOpenMPRuntimeGPU.cpp" file, in clang::​CodeGen::​CGOpenMPRuntimeGPU::​emitGenericVarsEpilog(clang::​CodeGen::​CodeGenFunction &, bool): Using the auto keyword without an & causes a copy.

auto_causes_copy: Using the auto keyword without an & causes the copy of an object of type pair.

4. In clang::​ASTWriter::​WriteHeaderSearch(clang::​HeaderSearch const &): Using the auto keyword without an & causes a copy.

auto_causes_copy: Using the auto keyword without an & causes the copy of an object of type UnresolvedHeaderDirective.

[Manna]

clang/lib/Serialization/ASTReader.cpp

0–1

Here Object of type is DenseMapPair. SelectorGeneration returns llvm::DenseMap<Selector, Unsigned>' in ASTReader.h' file.

clang/lib/Serialization/ASTWriter.cpp

0–1

Object of type KnownHeader returns ArrayRef<ModuleMap::KnownHeader> in ASTWriter.cpp file.

0–1

This returns SmallVector<UnresolvedHeaderDirective, 1> in `Module.h' file

[Manna]

clang/lib/Serialization/ASTReader.cpp

0–1

This returns std::vector<std::pair<ModuleFile*, LexicalContents> in 'ASTReader.h` file

[tahonermann]

These changes look good to me and I agree with not making a change for the KnownHeaders case.

clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp

0–1

EscapedVariableLengthDeclsAddrs is a llvm::SmallVector; this looks like a good change.

clang/lib/Serialization/ASTReader.cpp

0–1

Yes, looks like a good change.

0–1

Yes, this looks like a good change.

clang/lib/Serialization/ASTWriter.cpp

0–1

Yes, looks like a good change.

[Manna]

In D149461#4323175, @tahonermann wrote:

These changes look good to me and I agree with not making a change for the KnownHeaders case.

I agree with not making a change for the KnownHeaders case.

Yup. I closed them as a false positive.

Thanks @tahonermann for reviews!

clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp

 //===---- CGOpenMPRuntimeGPU.cpp - Interface to OpenMP GPU Runtimes ----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This provides a generalized class for OpenMP runtime code generation
void CGOpenMPRuntimeGPU::emitGenericVarsEpilog(CodeGenFunction &CGF,
                                                  bool WithSPMDCheck) {
   if (getDataSharingMode(CGM) != CGOpenMPRuntimeGPU::Generic &&
       getExecutionMode() != CGOpenMPRuntimeGPU::EM_SPMD)
     return;
 
   const auto I = FunctionGlobalizedDecls.find(CGF.CurFn);
   if (I != FunctionGlobalizedDecls.end()) {
     // Deallocate the memory for each globalized VLA object
-    for (auto AddrSizePair :
+    for (const auto &AddrSizePair :
          llvm::reverse(I->getSecond().EscapedVariableLengthDeclsAddrs)) {
       CGF.EmitRuntimeCall(OMPBuilder.getOrCreateRuntimeFunction(
                               CGM.getModule(), OMPRTL___kmpc_free_shared),
                           {AddrSizePair.first, AddrSizePair.second});
     }
     // Deallocate the memory for each globalized value
     for (auto &Rec : llvm::reverse(I->getSecond().LocalVarData)) {
       const auto *VD = cast<VarDecl>(Rec.first);

clang/lib/Serialization/ASTReader.cpp

 //===- ASTReader.cpp - AST File Reader ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the ASTReader class, which reads AST files.
if (!PP.getLangOpts().CPlusPlus ||
     // those that provide macros or are poisoned), so we mark all of
     // the interesting ones via PreloadIdentifierOffsets.
     for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
                                 IdEnd = PP.getIdentifierTable().end();
          Id != IdEnd; ++Id)
       Id->second->setOutOfDate(true);
   }
   // Mark selectors as out of date.
-  for (auto Sel : SelectorGeneration)
+  for (const auto &Sel : SelectorGeneration)
     SelectorOutOfDate[Sel.first] = true;
 
   // Resolve any unresolved module exports.
   for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
     UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
     SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
     Module *ResolvedMod = getSubmodule(GlobalID);
 
for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
         assert(D->getKind() == K && "wrong kind for lexical decl");
         if (!DC->isDeclInLexicalTraversal(D))
           Decls.push_back(D);
       }
     }
   };
 
   if (isa<TranslationUnitDecl>(DC)) {
-    for (auto Lexical : TULexicalDecls)
+    for (const auto &Lexical : TULexicalDecls)
       Visit(Lexical.first, Lexical.second);
   } else {
     auto I = LexicalDecls.find(DC);
     if (I != LexicalDecls.end())
       Visit(I->second.first, I->second.second);
   }
 
   ++NumLexicalDeclContextsRead;

clang/lib/Serialization/ASTWriter.cpp

 //===- ASTWriter.cpp - AST File Writer ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the ASTWriter class, which writes AST files.
hash_value_type ComputeHash(key_type_ref key) {
       // change the form of the name. However, complete path is still the key.
       return llvm::hash_combine(key.Size, key.ModTime);
     }
 
     std::pair<unsigned, unsigned>
     EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref Data) {
       unsigned KeyLen = key.Filename.size() + 1 + 8 + 8;
       unsigned DataLen = 1 + 4 + 4;
-      for (auto ModInfo : Data.KnownHeaders)
+      for (const auto &ModInfo : Data.KnownHeaders)
         if (Writer.getLocalOrImportedSubmoduleID(ModInfo.getModule()))
           DataLen += 4;
       if (Data.Unresolved.getPointer())
         DataLen += 4;
       return emitULEBKeyDataLength(KeyLen, DataLen, Out);
     }
 
     void EmitKey(raw_ostream& Out, key_type_ref key, unsigned KeyLen) {
void EmitData(raw_ostream &Out, key_type_ref key,
       auto EmitModule = [&](Module *M, ModuleMap::ModuleHeaderRole Role) {
         if (uint32_t ModID = Writer.getLocalOrImportedSubmoduleID(M)) {
           uint32_t Value = (ModID << 3) | (unsigned)Role;
           assert((Value >> 3) == ModID && "overflow in header module info");
           LE.write<uint32_t>(Value);
         }
       };
 
-      for (auto ModInfo : Data.KnownHeaders)
+      for (const auto &ModInfo : Data.KnownHeaders)
         EmitModule(ModInfo.getModule(), ModInfo.getRole());
       if (Data.Unresolved.getPointer())
         EmitModule(Data.Unresolved.getPointer(), Data.Unresolved.getInt());
 
       assert(Out.tell() - Start == DataLen && "Wrong data length");
     }
 
     const char *strings_begin() const { return FrameworkStringData.begin(); }
while (!Worklist.empty()) {
       // information. This also means we don't need to check the unresolved
       // headers list when emitting resolved headers in the first loop below.
       // FIXME: It'd be preferable to avoid doing this if we were given
       // sufficient stat information in the module map.
       HS.getModuleMap().resolveHeaderDirectives(M, /*File=*/std::nullopt);
 
       // If the file didn't exist, we can still create a module if we were given
       // enough information in the module map.
-      for (auto U : M->MissingHeaders) {
+      for (const auto &U : M->MissingHeaders) {
         // Check that we were given enough information to build a module
         // without this file existing on disk.
         if (!U.Size || (!U.ModTime && IncludeTimestamps)) {
           PP->Diag(U.FileNameLoc, diag::err_module_no_size_mtime_for_header)
               << WritingModule->getFullModuleName() << U.Size.has_value()
               << U.FileName;
           continue;
         }