[NFC][CLANG] Fix coverity remarks about large copy by values

[Manna]

Summary

Reported By Static Analyzer Tool, Coverity:

Big parameter passed by value
Copying large values is inefficient, consider passing by reference; Low, medium, and high size thresholds for detection can be adjusted.

1. Inside "CodeGenModule.cpp" file, in clang::​CodeGen::​CodeGenModule::​EmitBackendOptionsMetadata(clang::​CodeGenOptions): A very large function call parameter exceeding the high threshold is passed by value.

pass_by_value: Passing parameter CodeGenOpts of type clang::CodeGenOptions const (size 2168 bytes) by value, which exceeds the high threshold of 512 bytes.

2. Inside "SemaType.cpp" file, in IsNoDerefableChunk(clang::​DeclaratorChunk): A large function call parameter exceeding the low threshold is passed by value.

pass_by_value: Passing parameter Chunk of type clang::DeclaratorChunk (size 176 bytes) by value, which exceeds the low threshold of 128 bytes.

3. Inside "CGNonTrivialStruct.cpp" file, in <unnamed>::​getParamAddrs<2ul, <0ul, 1ul...>>(std::​integer_sequence<unsigned long, T2...>, std::​array<clang::​CharUnits, T1>, clang::​CodeGen::​FunctionArgList, clang::​CodeGen::​CodeGenFunction *): A large function call parameter exceeding the low threshold is passed by value.

pass_by_value: Passing parameter Args of type clang::CodeGen::FunctionArgList (size 144 bytes) by value, which exceeds the low threshold of 128 bytes.

4. Inside "CGGPUBuiltin.cpp" file, in <unnamed>::​containsNonScalarVarargs(clang::​CodeGen::​CodeGenFunction *, clang::​CodeGen::​CallArgList): A very large function call parameter exceeding the high threshold is passed by value.

pass_by_value: Passing parameter Args of type clang::CodeGen::CallArgList (size 1176 bytes) by value, which exceeds the high threshold of 512 bytes.

[Manna]

Fix bot failures

[tahonermann]

These changes all look good to me. For the DeclaratorChunk case, I noted an additional removal of a comment that I think should be considered. Assuming I haven't misread the code, DeclaratorChunk does not look like a small value type (at least not any more).

clang/lib/CodeGen/CGGPUBuiltin.cpp

128

This looks like a good change; CallArgList derives from SmallVector<CallArg, 8> and holds a few other SmallVector specializations as data members.

clang/lib/CodeGen/CGNonTrivialStruct.cpp

326

This looks like a good change. FunctionArgList derives from SmallVector<const VarDecl *, 16>.

clang/lib/CodeGen/CodeGenModule.h

1714

This is definitely a good change; it seems likely that the omission of the & was not intentional.

clang/lib/Sema/SemaType.cpp

4556

The definition of DeclaratorChunk has this comment:

/// This is intended to be a small value object.

However, it contains what looks likely to be a sizable anonymous union. See clang/include/clang/Sema/DeclSpec.h lines 1587-1595 and the definition of FunctionTypeInfo in that same file. I don't see other pass-by-value uses of this type. Perhaps the above comment should be removed.

[Manna]

clang/lib/CodeGen/CGGPUBuiltin.cpp

128

CallArgList derives from SmallVector<CallArg, 8> and holds a few other SmallVector specializations as data members.

Yes

clang/lib/CodeGen/CodeGenModule.h

1714

Agreed

clang/lib/Sema/SemaType.cpp

4556

Thanks @tahonermann for reviews and feedbacks.

See clang/include/clang/Sema/DeclSpec.h lines 1587-1595 and the definition of FunctionTypeInfo in that same file. I don't see other pass-by-value uses of this type.

Yes, this is what i saw in same file (https://clang.llvm.org/doxygen/SemaType_8cpp_source.html) while investigating this bug - it is usually passing by const references.

clang/lib/CodeGen/CGGPUBuiltin.cpp

for (unsigned I = 1, NumArgs = Args.size(); I < NumArgs; ++I) {
       Builder.CreateAlignedStore(Arg, P, DL.getPrefTypeAlign(Arg->getType()));
     }
     llvm::Value *BufferPtr =
         Builder.CreatePointerCast(Alloca, llvm::Type::getInt8PtrTy(Ctx));
     return {BufferPtr, DL.getTypeAllocSize(AllocaTy)};
   }
 }
 
-bool containsNonScalarVarargs(CodeGenFunction *CGF, CallArgList Args) {
+bool containsNonScalarVarargs(CodeGenFunction *CGF, const CallArgList &Args) {
   return llvm::any_of(llvm::drop_begin(Args), [&](const CallArg &A) {
     return !A.getRValue(*CGF).isScalar();
   });
 }
 
 RValue EmitDevicePrintfCallExpr(const CallExpr *E, CodeGenFunction *CGF,
                                 llvm::Function *Decl, bool WithSizeArg) {
   CodeGenModule &CGM = CGF->CGM;

clang/lib/CodeGen/CGNonTrivialStruct.cpp

static const CGFunctionInfo &getFunctionInfo(CodeGenModule &CGM,
   llvm::append_range(Args, Params);
 
   return CGM.getTypes().arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Args);
 }
 
 template <size_t N, size_t... Ints>
 static std::array<Address, N> getParamAddrs(std::index_sequence<Ints...> IntSeq,
                                             std::array<CharUnits, N> Alignments,
-                                            FunctionArgList Args,
+                                            const FunctionArgList &Args,
                                             CodeGenFunction *CGF) {
   return std::array<Address, N>{
       {Address(CGF->Builder.CreateLoad(CGF->GetAddrOfLocalVar(Args[Ints])),
                CGF->VoidPtrTy, Alignments[Ints], KnownNonNull)...}};
 }
 
 // Template classes that are used as bases for classes that emit special
 // functions.

clang/lib/CodeGen/CodeGenModule.h

private:
   /// Emit the Clang version as llvm.ident metadata.
   void EmitVersionIdentMetadata();
 
   /// Emit the Clang commandline as llvm.commandline metadata.
   void EmitCommandLineMetadata();
 
   /// Emit the module flag metadata used to pass options controlling the
   /// the backend to LLVM.
-  void EmitBackendOptionsMetadata(const CodeGenOptions CodeGenOpts);
+  void EmitBackendOptionsMetadata(const CodeGenOptions &CodeGenOpts);
 
   /// Emits OpenCL specific Metadata e.g. OpenCL version.
   void EmitOpenCLMetadata();
 
   /// Emit the llvm.gcov metadata used to tell LLVM where to emit the .gcno and
   /// .gcda files in a way that persists in .bc files.
   void EmitCoverageFile();
 

clang/lib/CodeGen/CodeGenModule.cpp

llvm::Metadata *OCLVerElts[] = {
           Int32Ty, (Version % 100) / 10))};
   llvm::NamedMDNode *OCLVerMD =
       TheModule.getOrInsertNamedMetadata("opencl.ocl.version");
   llvm::LLVMContext &Ctx = TheModule.getContext();
   OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
 }
 
 void CodeGenModule::EmitBackendOptionsMetadata(
-    const CodeGenOptions CodeGenOpts) {
+    const CodeGenOptions &CodeGenOpts) {
   if (getTriple().isRISCV()) {
     getModule().addModuleFlag(llvm::Module::Min, "SmallDataLimit",
                               CodeGenOpts.SmallDataLimit);
   }
 }
 
 void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
   // Make sure that this type is translated.

clang/lib/Sema/SemaType.cpp

while (i != 0) {
     case DeclaratorChunk::Pipe:
       // These are invalid anyway, so just ignore.
       break;
     }
   }
   return false;
 }
 
-static bool IsNoDerefableChunk(DeclaratorChunk Chunk) {
+static bool IsNoDerefableChunk(const DeclaratorChunk &Chunk) {
   return (Chunk.Kind == DeclaratorChunk::Pointer ||
           Chunk.Kind == DeclaratorChunk::Array);
 }
 
 template<typename AttrT>
 static AttrT *createSimpleAttr(ASTContext &Ctx, ParsedAttr &AL) {
   AL.setUsedAsTypeAttr();
   return ::new (Ctx) AttrT(Ctx, AL);