[NFC][clang] Fix coverity static analyzer concerns about AUTO_CAUSES_COPY

[Manna]

Summary

AUTO_CAUSES_COPY
Unnecessary object copies can affect performance.

[NFC] Fix auto keyword use without an & causes the copy of an object of type SimpleRegistryEntry in clang::​getAttributePluginInstances()
[NFC] Fix auto keyword use without an & causes the copy of an object of type tuple in CheckStmtInlineAttr<clang::​NoInlineAttr, 2>(clang::​Sema &, clang::​Stmt const *, clang::​Stmt const *, clang::​AttributeCommonInfo const &)
[NFC] Fix auto keyword use without an & causes the copy of an object of type QualType in <unnamed>::​SystemZTargetCodeGenInfo::​isVectorTypeBased(clang::​Type const *, bool)
[NFC] Fix auto keyword use without an & causes the copy of an object of type Policy in <unnamed>::​RISCVIntrinsicManagerImpl::​InitIntrinsicList()
[NFC] Fix auto keyword use without an & causes the copy of an object of type pair in checkUndefinedButUsed(clang::​Sema &)

[tahonermann]

These changes all seem reasonable to me. Some of them look like clear wins (e.g., ParsedAttrInfo).

[Manna]

Thank you @tahonermann for reviews!

[Manna]

I have committed the patch: https://reviews.llvm.org/rG18a3d9e5b318

clang/lib/Basic/ParsedAttrInfo.cpp

 
 LLVM_INSTANTIATE_REGISTRY(ParsedAttrInfoRegistry)
 
 const std::list<std::unique_ptr<ParsedAttrInfo>> &
 clang::getAttributePluginInstances() {
   static llvm::ManagedStatic<std::list<std::unique_ptr<ParsedAttrInfo>>>
       PluginAttrInstances;
   if (PluginAttrInstances->empty())
-    for (auto It : ParsedAttrInfoRegistry::entries())
+    for (const auto &It : ParsedAttrInfoRegistry::entries())
       PluginAttrInstances->emplace_back(It.instantiate());
 
   return *PluginAttrInstances;
 }

clang/lib/CodeGen/TargetInfo.cpp

for (const auto *FD : RD->fields())
       if (isVectorTypeBased(FD->getType().getTypePtr(), /*IsParam*/false))
         return true;
   }
 
   if (const auto *FT = Ty->getAs<FunctionType>())
     if (isVectorTypeBased(FT->getReturnType().getTypePtr(), /*IsParam*/true))
       return true;
   if (const FunctionProtoType *Proto = Ty->getAs<FunctionProtoType>())
-    for (auto ParamType : Proto->getParamTypes())
+    for (const auto &ParamType : Proto->getParamTypes())
       if (isVectorTypeBased(ParamType.getTypePtr(), /*IsParam*/true))
         return true;
 
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // MSP430 ABI Implementation

clang/lib/Sema/Sema.cpp

 static void checkUndefinedButUsed(Sema &S) {
   if (S.UndefinedButUsed.empty()) return;
 
   // Collect all the still-undefined entities with internal linkage.
   SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
   S.getUndefinedButUsed(Undefined);
   if (Undefined.empty()) return;
 
-  for (auto Undef : Undefined) {
+  for (const auto &Undef : Undefined) {
     ValueDecl *VD = cast<ValueDecl>(Undef.first);
     SourceLocation UseLoc = Undef.second;
 
     if (S.isExternalWithNoLinkageType(VD)) {
       // C++ [basic.link]p8:
       //   A type without linkage shall not be used as the type of a variable
       //   or function with external linkage unless
       //    -- the entity has C language linkage

clang/lib/Sema/SemaRISCVVectorLookup.cpp

for (unsigned int TypeRangeMaskShift = 0;
             TypeCache, BaseType, Log2LMUL, OverloadedSuffixProto);
 
         // Create non-masked intrinsic.
         InitRVVIntrinsic(Record, SuffixStr, OverloadedSuffixStr, false, *Types,
                          UnMaskedHasPolicy, DefaultPolicy);
 
         // Create non-masked policy intrinsic.
         if (Record.UnMaskedPolicyScheme != PolicyScheme::SchemeNone) {
-          for (auto P : SupportedUnMaskedPolicies) {
+          for (const auto &P : SupportedUnMaskedPolicies) {
             llvm::SmallVector<PrototypeDescriptor> PolicyPrototype =
                 RVVIntrinsic::computeBuiltinTypes(
                     BasicProtoSeq, /*IsMasked=*/false,
                     /*HasMaskedOffOperand=*/false, Record.HasVL, Record.NF,
                     UnMaskedPolicyScheme, P);
             std::optional<RVVTypes> PolicyTypes = TypeCache.computeTypes(
                 BaseType, Log2LMUL, Record.NF, PolicyPrototype);
             InitRVVIntrinsic(Record, SuffixStr, OverloadedSuffixStr,

clang/lib/Sema/SemaStmtAttr.cpp

bool CanSuppressDiag =
       OrigSt && CEF.getCallExprs().size() == OrigCEF.getCallExprs().size();
 
   if (!CEF.foundCallExpr()) {
     return SemaRef.Diag(CurSt->getBeginLoc(),
                         diag::warn_attribute_ignored_no_calls_in_stmt)
            << A;
   }
 
-  for (auto Tup :
+  for (const auto &Tup :
        llvm::zip_longest(OrigCEF.getCallExprs(), CEF.getCallExprs())) {
     // If the original call expression already had a callee, we already
     // diagnosed this, so skip it here. We can't skip if there isn't a 1:1
     // relationship between the two lists of call expressions.
     if (!CanSuppressDiag || !(*std::get<0>(Tup))->getCalleeDecl()) {
       const Decl *Callee = (*std::get<1>(Tup))->getCalleeDecl();
       if (Callee &&
           (Callee->hasAttr<OtherAttr>() || Callee->hasAttr<FlattenAttr>())) {