From 290c93ec0dea0188c4478a3d73ff48ae5b693498 Mon Sep 17 00:00:00 2001 From: Douglas Gregor Date: Sat, 15 May 2010 06:46:45 +0000 Subject: [PATCH] Implement a simple form of the C++ named return value optimization for return statements. We perform NRVO only when all of the return statements in the function return the same variable. Fixes some link failures in Boost.Interprocess (which is relying on NRVO), and probably improves performance for some C++ applications. llvm-svn: 103867 --- clang/lib/CodeGen/CGDecl.cpp | 56 +++++++++++++++++++++------------- clang/lib/CodeGen/CGStmt.cpp | 7 ++++- clang/lib/Sema/SemaStmt.cpp | 3 +- clang/test/CodeGenCXX/nrvo.cpp | 55 +++++++++++++++++++++++++++++++++ 4 files changed, 98 insertions(+), 23 deletions(-) create mode 100644 clang/test/CodeGenCXX/nrvo.cpp diff --git a/clang/lib/CodeGen/CGDecl.cpp b/clang/lib/CodeGen/CGDecl.cpp index 48198ff5761b..c93d9ba33df6 100644 --- a/clang/lib/CodeGen/CGDecl.cpp +++ b/clang/lib/CodeGen/CGDecl.cpp @@ -398,16 +398,19 @@ void CodeGenFunction::EmitLocalBlockVarDecl(const VarDecl &D) { CharUnits Align = CharUnits::Zero(); bool IsSimpleConstantInitializer = false; + bool NRVO = false; llvm::Value *DeclPtr; if (Ty->isConstantSizeType()) { if (!Target.useGlobalsForAutomaticVariables()) { - + NRVO = getContext().getLangOptions().ElideConstructors && + D.isNRVOVariable(); // If this value is an array or struct, is POD, and if the initializer is - // a staticly determinable constant, try to optimize it. + // a staticly determinable constant, try to optimize it (unless the NRVO + // is already optimizing this). if (D.getInit() && !isByRef && (Ty->isArrayType() || Ty->isRecordType()) && Ty->isPODType() && - D.getInit()->isConstantInitializer(getContext())) { + D.getInit()->isConstantInitializer(getContext()) && !NRVO) { // If this variable is marked 'const', emit the value as a global. if (CGM.getCodeGenOpts().MergeAllConstants && Ty.isConstant(getContext())) { @@ -418,19 +421,29 @@ void CodeGenFunction::EmitLocalBlockVarDecl(const VarDecl &D) { IsSimpleConstantInitializer = true; } - // A normal fixed sized variable becomes an alloca in the entry block. + // A normal fixed sized variable becomes an alloca in the entry block, + // unless it's an NRVO variable. const llvm::Type *LTy = ConvertTypeForMem(Ty); - if (isByRef) - LTy = BuildByRefType(&D); - llvm::AllocaInst *Alloc = CreateTempAlloca(LTy); - Alloc->setName(D.getNameAsString()); + + if (NRVO) { + // The named return value optimization: allocate this variable in the + // return slot, so that we can elide the copy when returning this + // variable (C++0x [class.copy]p34). + DeclPtr = ReturnValue; + } else { + if (isByRef) + LTy = BuildByRefType(&D); + + llvm::AllocaInst *Alloc = CreateTempAlloca(LTy); + Alloc->setName(D.getNameAsString()); - Align = getContext().getDeclAlign(&D); - if (isByRef) - Align = std::max(Align, - CharUnits::fromQuantity(Target.getPointerAlign(0) / 8)); - Alloc->setAlignment(Align.getQuantity()); - DeclPtr = Alloc; + Align = getContext().getDeclAlign(&D); + if (isByRef) + Align = std::max(Align, + CharUnits::fromQuantity(Target.getPointerAlign(0) / 8)); + Alloc->setAlignment(Align.getQuantity()); + DeclPtr = Alloc; + } } else { // Targets that don't support recursion emit locals as globals. const char *Class = @@ -645,13 +658,14 @@ void CodeGenFunction::EmitLocalBlockVarDecl(const VarDecl &D) { while (const ArrayType *Array = getContext().getAsArrayType(DtorTy)) DtorTy = getContext().getBaseElementType(Array); if (const RecordType *RT = DtorTy->getAs()) - if (CXXRecordDecl *ClassDecl = dyn_cast(RT->getDecl())) { - llvm::Value *Loc = DeclPtr; - if (isByRef) - Loc = Builder.CreateStructGEP(DeclPtr, getByRefValueLLVMField(&D), - D.getNameAsString()); - - if (!ClassDecl->hasTrivialDestructor()) { + if (CXXRecordDecl *ClassDecl = dyn_cast(RT->getDecl())) { + if (!ClassDecl->hasTrivialDestructor() && !NRVO) { + // Note: We suppress the destructor call when this is an NRVO variable. + llvm::Value *Loc = DeclPtr; + if (isByRef) + Loc = Builder.CreateStructGEP(DeclPtr, getByRefValueLLVMField(&D), + D.getNameAsString()); + const CXXDestructorDecl *D = ClassDecl->getDestructor(getContext()); assert(D && "EmitLocalBlockVarDecl - destructor is nul"); diff --git a/clang/lib/CodeGen/CGStmt.cpp b/clang/lib/CodeGen/CGStmt.cpp index 772f640ed01f..f51a899e7ffa 100644 --- a/clang/lib/CodeGen/CGStmt.cpp +++ b/clang/lib/CodeGen/CGStmt.cpp @@ -607,7 +607,12 @@ void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) { // FIXME: Clean this up by using an LValue for ReturnTemp, // EmitStoreThroughLValue, and EmitAnyExpr. - if (!ReturnValue) { + if (S.getNRVOCandidate() && S.getNRVOCandidate()->isNRVOVariable() && + !Target.useGlobalsForAutomaticVariables()) { + // Apply the named return value optimization for this return statement, + // which means doing nothing: the appropriate result has already been + // constructed into the NRVO variable. + } else if (!ReturnValue) { // Make sure not to return anything, but evaluate the expression // for side effects. if (RV) diff --git a/clang/lib/Sema/SemaStmt.cpp b/clang/lib/Sema/SemaStmt.cpp index f8fe4fe21c04..d904907e97d9 100644 --- a/clang/lib/Sema/SemaStmt.cpp +++ b/clang/lib/Sema/SemaStmt.cpp @@ -1090,7 +1090,8 @@ static const VarDecl *getNRVOCandidate(ASTContext &Ctx, QualType RetType, return 0; if (VD->getKind() == Decl::Var && VD->hasLocalStorage() && - !VD->getType()->isReferenceType() && !VD->getType().isVolatileQualified()) + !VD->getType()->isReferenceType() && !VD->hasAttr() && + !VD->getType().isVolatileQualified()) return VD; return 0; diff --git a/clang/test/CodeGenCXX/nrvo.cpp b/clang/test/CodeGenCXX/nrvo.cpp new file mode 100644 index 000000000000..7b4f20398d80 --- /dev/null +++ b/clang/test/CodeGenCXX/nrvo.cpp @@ -0,0 +1,55 @@ +// RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s + +// Test code generation for the named return value optimization. +class X { +public: + X(); + X(const X&); + ~X(); +}; + +// CHECK: define void @_Z5test0v +X test0() { + X x; + // CHECK-NOT: call void @_ZN1XD1Ev + // CHECK: ret void + return x; +} + +// CHECK: define void @_Z5test1b( +X test1(bool B) { + // CHECK: call void @_ZN1XC1Ev + X x; + // CHECK-NOT: call void @_ZN1XD1Ev + // CHECK: ret void + if (B) + return (x); + return x; +} + +// CHECK: define void @_Z5test2b +X test2(bool B) { + // No NRVO + // CHECK: call void @_ZN1XC1Ev + X x; + // CHECK: call void @_ZN1XC1Ev + X y; + // CHECK: call void @_ZN1XC1ERKS_ + if (B) + return y; + // CHECK: call void @_ZN1XC1ERKS_ + return x; + // CHECK: call void @_ZN1XD1Ev + // CHECK: call void @_ZN1XD1Ev + // CHECK: ret void +} + +X test3(bool B) { + // FIXME: We don't manage to apply NRVO here, although we could. + { + X y; + return y; + } + X x; + return x; +}