<div dir="ltr">On Sat, Feb 16, 2013 at 11:22 PM, Lang Hames <span dir="ltr"><<a href="mailto:lhames@gmail.com" target="_blank" class="cremed">lhames@gmail.com</a>></span> wrote:<br><div class="gmail_extra"><div class="gmail_quote">
<blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left-width:1px;border-left-color:rgb(204,204,204);border-left-style:solid;padding-left:1ex">Author: lhames<br>
Date: Sun Feb 17 01:22:09 2013<br>
New Revision: 175389<br>
<br>
URL: <a href="http://llvm.org/viewvc/llvm-project?rev=175389&view=rev" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project?rev=175389&view=rev</a><br>
Log:<br>
Re-apply r174919 - smarter copy/move assignment/construction, with fixes for<br>
bitfield related issues.<br>
<br>
The original commit broke Takumi's builder. The bug was caused by bitfield sizes<br>
being determined by their underlying type, rather than the field info. A similar<br>
issue with bitfield alignments showed up on closer testing. Both have been fixed<br>
in this patch.<br></blockquote><div><br></div><div style>This seems to have caused (less exciting looking) test failures: <a href="http://bb.pgr.jp/builders/cmake-clang-x86_64-linux/builds/4670">http://bb.pgr.jp/builders/cmake-clang-x86_64-linux/builds/4670</a></div>
<div style><br></div><div style>I'm also seeing a bunch of asan failures, but not 100% certain they're related to this patch.</div><div> </div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left-width:1px;border-left-color:rgb(204,204,204);border-left-style:solid;padding-left:1ex">
<br>
<br>
Added:<br>
cfe/trunk/test/CodeGenCXX/pod-member-memcpys.cpp<br>
Modified:<br>
cfe/trunk/lib/CodeGen/CGClass.cpp<br>
cfe/trunk/lib/CodeGen/CodeGenFunction.cpp<br>
cfe/trunk/lib/CodeGen/CodeGenFunction.h<br>
cfe/trunk/test/CodeGenCXX/copy-assign-synthesis-1.cpp<br>
cfe/trunk/test/CodeGenCXX/implicit-copy-assign-operator.cpp<br>
cfe/trunk/test/CodeGenCXX/implicit-copy-constructor.cpp<br>
<br>
Modified: cfe/trunk/lib/CodeGen/CGClass.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGClass.cpp?rev=175389&r1=175388&r2=175389&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGClass.cpp?rev=175389&r1=175388&r2=175389&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/lib/CodeGen/CGClass.cpp (original)<br>
+++ cfe/trunk/lib/CodeGen/CGClass.cpp Sun Feb 17 01:22:09 2013<br>
@@ -13,11 +13,13 @@<br>
<br>
#include "CGBlocks.h"<br>
#include "CGDebugInfo.h"<br>
+#include "CGRecordLayout.h"<br>
#include "CodeGenFunction.h"<br>
#include "clang/AST/CXXInheritance.h"<br>
#include "clang/AST/EvaluatedExprVisitor.h"<br>
#include "clang/AST/RecordLayout.h"<br>
#include "clang/AST/StmtCXX.h"<br>
+#include "clang/Basic/TargetBuiltins.h"<br>
#include "clang/Frontend/CodeGenOptions.h"<br>
<br>
using namespace clang;<br>
@@ -742,6 +744,352 @@ void CodeGenFunction::EmitConstructorBod<br>
ExitCXXTryStmt(*cast<CXXTryStmt>(Body), true);<br>
}<br>
<br>
+namespace {<br>
+ class FieldMemcpyizer {<br>
+ public:<br>
+ FieldMemcpyizer(CodeGenFunction &CGF, const CXXRecordDecl *ClassDecl,<br>
+ const VarDecl *SrcRec)<br>
+ : CGF(CGF), ClassDecl(ClassDecl), SrcRec(SrcRec),<br>
+ RecLayout(CGF.getContext().getASTRecordLayout(ClassDecl)),<br>
+ FirstField(0), LastField(0), FirstFieldOffset(0), LastFieldOffset(0),<br>
+ LastAddedFieldIndex(0) { }<br>
+<br>
+ static bool isMemcpyableField(FieldDecl *F) {<br>
+ Qualifiers Qual = F->getType().getQualifiers();<br>
+ if (Qual.hasVolatile() || Qual.hasObjCLifetime())<br>
+ return false;<br>
+ return true;<br>
+ }<br>
+<br>
+ void addMemcpyableField(FieldDecl *F) {<br>
+ if (FirstField == 0)<br>
+ addInitialField(F);<br>
+ else<br>
+ addNextField(F);<br>
+ }<br>
+<br>
+ CharUnits getMemcpySize() const {<br>
+ unsigned LastFieldSize =<br>
+ LastField->isBitField() ?<br>
+ LastField->getBitWidthValue(CGF.getContext()) :<br>
+ CGF.getContext().getTypeSize(LastField->getType());<br>
+ uint64_t MemcpySizeBits =<br>
+ LastFieldOffset + LastFieldSize - FirstFieldOffset +<br>
+ CGF.getContext().getCharWidth() - 1;<br>
+ CharUnits MemcpySize =<br>
+ CGF.getContext().toCharUnitsFromBits(MemcpySizeBits);<br>
+ return MemcpySize;<br>
+ }<br>
+<br>
+ void emitMemcpy() {<br>
+ // Give the subclass a chance to bail out if it feels the memcpy isn't<br>
+ // worth it (e.g. Hasn't aggregated enough data).<br>
+ if (FirstField == 0) {<br>
+ return;<br>
+ }<br>
+<br>
+ unsigned FirstFieldAlign = ~0U; // Set to invalid.<br>
+<br>
+ if (FirstField->isBitField()) {<br>
+ const CGRecordLayout &RL =<br>
+ CGF.getTypes().getCGRecordLayout(FirstField->getParent());<br>
+ const CGBitFieldInfo &BFInfo = RL.getBitFieldInfo(FirstField);<br>
+ FirstFieldAlign = BFInfo.StorageAlignment;<br>
+ } else<br>
+ FirstFieldAlign = CGF.getContext().getTypeAlign(FirstField->getType());<br>
+<br>
+ assert(FirstFieldOffset % FirstFieldAlign == 0 && "Bad field alignment.");<br>
+ CharUnits Alignment =<br>
+ CGF.getContext().toCharUnitsFromBits(FirstFieldAlign);<br>
+ CharUnits MemcpySize = getMemcpySize();<br>
+ QualType RecordTy = CGF.getContext().getTypeDeclType(ClassDecl);<br>
+ llvm::Value *ThisPtr = CGF.LoadCXXThis();<br>
+ LValue DestLV = CGF.MakeNaturalAlignAddrLValue(ThisPtr, RecordTy);<br>
+ LValue Dest = CGF.EmitLValueForFieldInitialization(DestLV, FirstField);<br>
+ llvm::Value *SrcPtr = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(SrcRec));<br>
+ LValue SrcLV = CGF.MakeNaturalAlignAddrLValue(SrcPtr, RecordTy);<br>
+ LValue Src = CGF.EmitLValueForFieldInitialization(SrcLV, FirstField);<br>
+<br>
+ emitMemcpyIR(Dest.isBitField() ? Dest.getBitFieldAddr() : Dest.getAddress(),<br>
+ Src.isBitField() ? Src.getBitFieldAddr() : Src.getAddress(),<br>
+ MemcpySize, Alignment);<br>
+ reset();<br>
+ }<br>
+<br>
+ void reset() {<br>
+ FirstField = 0;<br>
+ }<br>
+<br>
+ protected:<br>
+ CodeGenFunction &CGF;<br>
+ const CXXRecordDecl *ClassDecl;<br>
+<br>
+ private:<br>
+<br>
+ void emitMemcpyIR(llvm::Value *DestPtr, llvm::Value *SrcPtr,<br>
+ CharUnits Size, CharUnits Alignment) {<br>
+ llvm::PointerType *DPT = cast<llvm::PointerType>(DestPtr->getType());<br>
+ llvm::Type *DBP =<br>
+ llvm::Type::getInt8PtrTy(CGF.getLLVMContext(), DPT->getAddressSpace());<br>
+ DestPtr = CGF.Builder.CreateBitCast(DestPtr, DBP);<br>
+<br>
+ llvm::PointerType *SPT = cast<llvm::PointerType>(SrcPtr->getType());<br>
+ llvm::Type *SBP =<br>
+ llvm::Type::getInt8PtrTy(CGF.getLLVMContext(), SPT->getAddressSpace());<br>
+ SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, SBP);<br>
+<br>
+ CGF.Builder.CreateMemCpy(DestPtr, SrcPtr, Size.getQuantity(),<br>
+ Alignment.getQuantity());<br>
+ }<br>
+<br>
+ void addInitialField(FieldDecl *F) {<br>
+ FirstField = F;<br>
+ LastField = F;<br>
+ FirstFieldOffset = RecLayout.getFieldOffset(F->getFieldIndex());<br>
+ LastFieldOffset = FirstFieldOffset;<br>
+ LastAddedFieldIndex = F->getFieldIndex();<br>
+ return;<br>
+ }<br>
+<br>
+ void addNextField(FieldDecl *F) {<br>
+ assert(F->getFieldIndex() == LastAddedFieldIndex + 1 &&<br>
+ "Cannot aggregate non-contiguous fields.");<br>
+ LastAddedFieldIndex = F->getFieldIndex();<br>
+<br>
+ // The 'first' and 'last' fields are chosen by offset, rather than field<br>
+ // index. This allows the code to support bitfields, as well as regular<br>
+ // fields.<br>
+ uint64_t FOffset = RecLayout.getFieldOffset(F->getFieldIndex());<br>
+ if (FOffset < FirstFieldOffset) {<br>
+ FirstField = F;<br>
+ FirstFieldOffset = FOffset;<br>
+ } else if (FOffset > LastFieldOffset) {<br>
+ LastField = F;<br>
+ LastFieldOffset = FOffset;<br>
+ }<br>
+ }<br>
+<br>
+ const VarDecl *SrcRec;<br>
+ const ASTRecordLayout &RecLayout;<br>
+ FieldDecl *FirstField;<br>
+ FieldDecl *LastField;<br>
+ uint64_t FirstFieldOffset, LastFieldOffset;<br>
+ unsigned LastAddedFieldIndex;<br>
+ };<br>
+<br>
+ class ConstructorMemcpyizer : public FieldMemcpyizer {<br>
+ private:<br>
+<br>
+ /// Get source argument for copy constructor. Returns null if not a copy<br>
+ /// constructor.<br>
+ static const VarDecl* getTrivialCopySource(const CXXConstructorDecl *CD,<br>
+ FunctionArgList &Args) {<br>
+ if (CD->isCopyOrMoveConstructor() && CD->isImplicitlyDefined())<br>
+ return Args[Args.size() - 1];<br>
+ return 0;<br>
+ }<br>
+<br>
+ // Returns true if a CXXCtorInitializer represents a member initialization<br>
+ // that can be rolled into a memcpy.<br>
+ bool isMemberInitMemcpyable(CXXCtorInitializer *MemberInit) const {<br>
+ if (!MemcpyableCtor)<br>
+ return false;<br>
+ FieldDecl *Field = MemberInit->getMember();<br>
+ assert(Field != 0 && "No field for member init.");<br>
+ QualType FieldType = Field->getType();<br>
+ CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(MemberInit->getInit());<br>
+<br>
+ // Bail out on non-POD, not-trivially-constructable members.<br>
+ if (!(CE && CE->getConstructor()->isTrivial()) &&<br>
+ !(FieldType.isTriviallyCopyableType(CGF.getContext()) ||<br>
+ FieldType->isReferenceType()))<br>
+ return false;<br>
+<br>
+ // Bail out on volatile fields.<br>
+ if (!isMemcpyableField(Field))<br>
+ return false;<br>
+<br>
+ // Otherwise we're good.<br>
+ return true;<br>
+ }<br>
+<br>
+ public:<br>
+ ConstructorMemcpyizer(CodeGenFunction &CGF, const CXXConstructorDecl *CD,<br>
+ FunctionArgList &Args)<br>
+ : FieldMemcpyizer(CGF, CD->getParent(), getTrivialCopySource(CD, Args)),<br>
+ ConstructorDecl(CD),<br>
+ MemcpyableCtor(CD->isImplicitlyDefined() &&<br>
+ CD->isCopyOrMoveConstructor() &&<br>
+ CGF.getLangOpts().getGC() == LangOptions::NonGC),<br>
+ Args(Args) { }<br>
+<br>
+ void addMemberInitializer(CXXCtorInitializer *MemberInit) {<br>
+ if (isMemberInitMemcpyable(MemberInit)) {<br>
+ AggregatedInits.push_back(MemberInit);<br>
+ addMemcpyableField(MemberInit->getMember());<br>
+ } else {<br>
+ emitAggregatedInits();<br>
+ EmitMemberInitializer(CGF, ConstructorDecl->getParent(), MemberInit,<br>
+ ConstructorDecl, Args);<br>
+ }<br>
+ }<br>
+<br>
+ void emitAggregatedInits() {<br>
+ if (AggregatedInits.size() <= 1) {<br>
+ // This memcpy is too small to be worthwhile. Fall back on default<br>
+ // codegen.<br>
+ for (unsigned i = 0; i < AggregatedInits.size(); ++i) {<br>
+ EmitMemberInitializer(CGF, ConstructorDecl->getParent(),<br>
+ AggregatedInits[i], ConstructorDecl, Args);<br>
+ }<br>
+ reset();<br>
+ return;<br>
+ }<br>
+<br>
+ pushEHDestructors();<br>
+ emitMemcpy();<br>
+ AggregatedInits.clear();<br>
+ }<br>
+<br>
+ void pushEHDestructors() {<br>
+ llvm::Value *ThisPtr = CGF.LoadCXXThis();<br>
+ QualType RecordTy = CGF.getContext().getTypeDeclType(ClassDecl);<br>
+ LValue LHS = CGF.MakeNaturalAlignAddrLValue(ThisPtr, RecordTy);<br>
+<br>
+ for (unsigned i = 0; i < AggregatedInits.size(); ++i) {<br>
+ QualType FieldType = AggregatedInits[i]->getMember()->getType();<br>
+ QualType::DestructionKind dtorKind = FieldType.isDestructedType();<br>
+ if (CGF.needsEHCleanup(dtorKind))<br>
+ CGF.pushEHDestroy(dtorKind, LHS.getAddress(), FieldType);<br>
+ }<br>
+ }<br>
+<br>
+ void finish() {<br>
+ emitAggregatedInits();<br>
+ }<br>
+<br>
+ private:<br>
+ const CXXConstructorDecl *ConstructorDecl;<br>
+ bool MemcpyableCtor;<br>
+ FunctionArgList &Args;<br>
+ SmallVector<CXXCtorInitializer*, 16> AggregatedInits;<br>
+ };<br>
+<br>
+ class AssignmentMemcpyizer : public FieldMemcpyizer {<br>
+ private:<br>
+<br>
+ // Returns the memcpyable field copied by the given statement, if one<br>
+ // exists. Otherwise r<br>
+ FieldDecl* getMemcpyableField(Stmt *S) {<br>
+ if (!AssignmentsMemcpyable)<br>
+ return 0;<br>
+ if (BinaryOperator *BO = dyn_cast<BinaryOperator>(S)) {<br>
+ // Recognise trivial assignments.<br>
+ if (BO->getOpcode() != BO_Assign)<br>
+ return 0;<br>
+ MemberExpr *ME = dyn_cast<MemberExpr>(BO->getLHS());<br>
+ if (!ME)<br>
+ return 0;<br>
+ FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl());<br>
+ if (!Field || !isMemcpyableField(Field))<br>
+ return 0;<br>
+ Stmt *RHS = BO->getRHS();<br>
+ if (ImplicitCastExpr *EC = dyn_cast<ImplicitCastExpr>(RHS))<br>
+ RHS = EC->getSubExpr();<br>
+ if (!RHS)<br>
+ return 0;<br>
+ MemberExpr *ME2 = dyn_cast<MemberExpr>(RHS);<br>
+ if (dyn_cast<FieldDecl>(ME2->getMemberDecl()) != Field)<br>
+ return 0;<br>
+ return Field;<br>
+ } else if (CXXMemberCallExpr *MCE = dyn_cast<CXXMemberCallExpr>(S)) {<br>
+ CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MCE->getCalleeDecl());<br>
+ if (!(MD && (MD->isCopyAssignmentOperator() ||<br>
+ MD->isMoveAssignmentOperator()) &&<br>
+ MD->isTrivial()))<br>
+ return 0;<br>
+ MemberExpr *IOA = dyn_cast<MemberExpr>(MCE->getImplicitObjectArgument());<br>
+ if (!IOA)<br>
+ return 0;<br>
+ FieldDecl *Field = dyn_cast<FieldDecl>(IOA->getMemberDecl());<br>
+ if (!Field || !isMemcpyableField(Field))<br>
+ return 0;<br>
+ MemberExpr *Arg0 = dyn_cast<MemberExpr>(MCE->getArg(0));<br>
+ if (!Arg0 || Field != dyn_cast<FieldDecl>(Arg0->getMemberDecl()))<br>
+ return 0;<br>
+ return Field;<br>
+ } else if (CallExpr *CE = dyn_cast<CallExpr>(S)) {<br>
+ FunctionDecl *FD = dyn_cast<FunctionDecl>(CE->getCalleeDecl());<br>
+ if (!FD || FD->getBuiltinID() != Builtin::BI__builtin_memcpy)<br>
+ return 0;<br>
+ Expr *DstPtr = CE->getArg(0);<br>
+ if (ImplicitCastExpr *DC = dyn_cast<ImplicitCastExpr>(DstPtr))<br>
+ DstPtr = DC->getSubExpr();<br>
+ UnaryOperator *DUO = dyn_cast<UnaryOperator>(DstPtr);<br>
+ if (!DUO || DUO->getOpcode() != UO_AddrOf)<br>
+ return 0;<br>
+ MemberExpr *ME = dyn_cast<MemberExpr>(DUO->getSubExpr());<br>
+ if (!ME)<br>
+ return 0;<br>
+ FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl());<br>
+ if (!Field || !isMemcpyableField(Field))<br>
+ return 0;<br>
+ Expr *SrcPtr = CE->getArg(1);<br>
+ if (ImplicitCastExpr *SC = dyn_cast<ImplicitCastExpr>(SrcPtr))<br>
+ SrcPtr = SC->getSubExpr();<br>
+ UnaryOperator *SUO = dyn_cast<UnaryOperator>(SrcPtr);<br>
+ if (!SUO || SUO->getOpcode() != UO_AddrOf)<br>
+ return 0;<br>
+ MemberExpr *ME2 = dyn_cast<MemberExpr>(SUO->getSubExpr());<br>
+ if (!ME2 || Field != dyn_cast<FieldDecl>(ME2->getMemberDecl()))<br>
+ return 0;<br>
+ return Field;<br>
+ }<br>
+<br>
+ return 0;<br>
+ }<br>
+<br>
+ bool AssignmentsMemcpyable;<br>
+ SmallVector<Stmt*, 16> AggregatedStmts;<br>
+<br>
+ public:<br>
+<br>
+ AssignmentMemcpyizer(CodeGenFunction &CGF, const CXXMethodDecl *AD,<br>
+ FunctionArgList &Args)<br>
+ : FieldMemcpyizer(CGF, AD->getParent(), Args[Args.size() - 1]),<br>
+ AssignmentsMemcpyable(CGF.getLangOpts().getGC() == LangOptions::NonGC) {<br>
+ assert(Args.size() == 2);<br>
+ }<br>
+<br>
+ void emitAssignment(Stmt *S) {<br>
+ FieldDecl *F = getMemcpyableField(S);<br>
+ if (F) {<br>
+ addMemcpyableField(F);<br>
+ AggregatedStmts.push_back(S);<br>
+ } else {<br>
+ emitAggregatedStmts();<br>
+ CGF.EmitStmt(S);<br>
+ }<br>
+ }<br>
+<br>
+ void emitAggregatedStmts() {<br>
+ if (AggregatedStmts.size() <= 1) {<br>
+ for (unsigned i = 0; i < AggregatedStmts.size(); ++i)<br>
+ CGF.EmitStmt(AggregatedStmts[i]);<br>
+ reset();<br>
+ }<br>
+<br>
+ emitMemcpy();<br>
+ AggregatedStmts.clear();<br>
+ }<br>
+<br>
+ void finish() {<br>
+ emitAggregatedStmts();<br>
+ }<br>
+ };<br>
+<br>
+}<br>
+<br>
/// EmitCtorPrologue - This routine generates necessary code to initialize<br>
/// base classes and non-static data members belonging to this constructor.<br>
void CodeGenFunction::EmitCtorPrologue(const CXXConstructorDecl *CD,<br>
@@ -770,8 +1118,10 @@ void CodeGenFunction::EmitCtorPrologue(c<br>
<br>
InitializeVTablePointers(ClassDecl);<br>
<br>
+ ConstructorMemcpyizer CM(*this, CD, Args);<br>
for (unsigned I = 0, E = MemberInitializers.size(); I != E; ++I)<br>
- EmitMemberInitializer(*this, ClassDecl, MemberInitializers[I], CD, Args);<br>
+ CM.addMemberInitializer(MemberInitializers[I]);<br>
+ CM.finish();<br>
}<br>
<br>
static bool<br>
@@ -940,6 +1290,24 @@ void CodeGenFunction::EmitDestructorBody<br>
ExitCXXTryStmt(*cast<CXXTryStmt>(Body), true);<br>
}<br>
<br>
+void CodeGenFunction::emitImplicitAssignmentOperatorBody(FunctionArgList &Args) {<br>
+ const CXXMethodDecl *AssignOp = cast<CXXMethodDecl>(CurGD.getDecl());<br>
+ const Stmt *RootS = AssignOp->getBody();<br>
+ assert(isa<CompoundStmt>(RootS) &&<br>
+ "Body of an implicit assignment operator should be compound stmt.");<br>
+ const CompoundStmt *RootCS = cast<CompoundStmt>(RootS);<br>
+<br>
+ LexicalScope Scope(*this, RootCS->getSourceRange());<br>
+<br>
+ AssignmentMemcpyizer AM(*this, AssignOp, Args);<br>
+ for (CompoundStmt::const_body_iterator I = RootCS->body_begin(),<br>
+ E = RootCS->body_end();<br>
+ I != E; ++I) {<br>
+ AM.emitAssignment(*I);<br>
+ }<br>
+ AM.finish();<br>
+}<br>
+<br>
namespace {<br>
/// Call the operator delete associated with the current destructor.<br>
struct CallDtorDelete : EHScopeStack::Cleanup {<br>
<br>
Modified: cfe/trunk/lib/CodeGen/CodeGenFunction.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenFunction.cpp?rev=175389&r1=175388&r2=175389&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenFunction.cpp?rev=175389&r1=175388&r2=175389&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/lib/CodeGen/CodeGenFunction.cpp (original)<br>
+++ cfe/trunk/lib/CodeGen/CodeGenFunction.cpp Sun Feb 17 01:22:09 2013<br>
@@ -560,6 +560,11 @@ void CodeGenFunction::GenerateCode(Globa<br>
// The lambda "__invoke" function is special, because it forwards or<br>
// clones the body of the function call operator (but is actually static).<br>
EmitLambdaStaticInvokeFunction(cast<CXXMethodDecl>(FD));<br>
+ } else if (FD->isDefaulted() && isa<CXXMethodDecl>(FD) &&<br>
+ cast<CXXMethodDecl>(FD)->isCopyAssignmentOperator()) {<br>
+ // Implicit copy-assignment gets the same special treatment as implicit<br>
+ // copy-constructors.<br>
+ emitImplicitAssignmentOperatorBody(Args);<br>
}<br>
else<br>
EmitFunctionBody(Args);<br>
<br>
Modified: cfe/trunk/lib/CodeGen/CodeGenFunction.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenFunction.h?rev=175389&r1=175388&r2=175389&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenFunction.h?rev=175389&r1=175388&r2=175389&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/lib/CodeGen/CodeGenFunction.h (original)<br>
+++ cfe/trunk/lib/CodeGen/CodeGenFunction.h Sun Feb 17 01:22:09 2013<br>
@@ -1401,6 +1401,7 @@ public:<br>
<br>
void EmitConstructorBody(FunctionArgList &Args);<br>
void EmitDestructorBody(FunctionArgList &Args);<br>
+ void emitImplicitAssignmentOperatorBody(FunctionArgList &Args);<br>
void EmitFunctionBody(FunctionArgList &Args);<br>
<br>
void EmitForwardingCallToLambda(const CXXRecordDecl *Lambda,<br>
<br>
Modified: cfe/trunk/test/CodeGenCXX/copy-assign-synthesis-1.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/copy-assign-synthesis-1.cpp?rev=175389&r1=175388&r2=175389&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/copy-assign-synthesis-1.cpp?rev=175389&r1=175388&r2=175389&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/test/CodeGenCXX/copy-assign-synthesis-1.cpp (original)<br>
+++ cfe/trunk/test/CodeGenCXX/copy-assign-synthesis-1.cpp Sun Feb 17 01:22:09 2013<br>
@@ -96,14 +96,8 @@ int main() {<br>
// CHECK-LP64: .globl __ZN1XaSERKS_<br>
// CHECK-LP64: .weak_definition __ZN1XaSERKS_<br>
// CHECK-LP64: __ZN1XaSERKS_:<br>
-// CHECK-LP64: .globl __ZN1QaSERKS_<br>
-// CHECK-LP64: .weak_definition __ZN1QaSERKS_<br>
-// CHECK-LP64: __ZN1QaSERKS_:<br>
<br>
// CHECK-LP32: .globl __ZN1XaSERKS_<br>
// CHECK-LP32: .weak_definition __ZN1XaSERKS_<br>
// CHECK-LP32: __ZN1XaSERKS_:<br>
-// CHECK-LP32: .globl __ZN1QaSERKS_<br>
-// CHECK-LP32: .weak_definition __ZN1QaSERKS_<br>
-// CHECK-LP32: __ZN1QaSERKS_:<br>
<br>
<br>
Modified: cfe/trunk/test/CodeGenCXX/implicit-copy-assign-operator.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/implicit-copy-assign-operator.cpp?rev=175389&r1=175388&r2=175389&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/implicit-copy-assign-operator.cpp?rev=175389&r1=175388&r2=175389&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/test/CodeGenCXX/implicit-copy-assign-operator.cpp (original)<br>
+++ cfe/trunk/test/CodeGenCXX/implicit-copy-assign-operator.cpp Sun Feb 17 01:22:09 2013<br>
@@ -44,7 +44,7 @@ void test_D(D d1, D d2) {<br>
// CHECK: {{call.*_ZN1AaSERS_}}<br>
// CHECK: {{call.*_ZN1BaSERS_}}<br>
// CHECK: {{call.*_ZN1CaSERKS_}}<br>
-// CHECK: {{call void @llvm.memcpy.p0i8.p0i8.i64.*i64 24}}<br>
+// CHECK: {{call void @llvm.memcpy.p0i8.p0i8.i64.*i64 28}}<br>
// CHECK: {{call.*_ZN1BaSERS_}}<br>
// CHECK: br<br>
// CHECK: {{call.*_ZN1CaSERKS_}}<br>
<br>
Modified: cfe/trunk/test/CodeGenCXX/implicit-copy-constructor.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/implicit-copy-constructor.cpp?rev=175389&r1=175388&r2=175389&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/implicit-copy-constructor.cpp?rev=175389&r1=175388&r2=175389&view=diff</a><br>
==============================================================================<br>
--- cfe/trunk/test/CodeGenCXX/implicit-copy-constructor.cpp (original)<br>
+++ cfe/trunk/test/CodeGenCXX/implicit-copy-constructor.cpp Sun Feb 17 01:22:09 2013<br>
@@ -46,7 +46,7 @@ void f(D d) {<br>
// CHECK: call void @_ZN1AD1Ev<br>
// CHECK: call void @_ZN1AC2ERS_<br>
// CHECK: call void @_ZN1BC2ERS_<br>
-// CHECK: {{call void @llvm.memcpy.p0i8.p0i8.i64.*i64 24}}<br>
+// CHECK: {{call void @llvm.memcpy.p0i8.p0i8.i64.*i64 28}}<br>
// CHECK: call void @_ZN1BC1ERS_<br>
// CHECK: br<br>
// CHECK: {{icmp ult.*, 2}}<br>
@@ -54,8 +54,7 @@ void f(D d) {<br>
// CHECK: call void @_ZN1AC1Ev<br>
// CHECK: call void @_ZN1CC1ERS_1A<br>
// CHECK: call void @_ZN1AD1Ev<br>
-// CHECK: {{call void @llvm.memcpy.p0i8.p0i8.i64.*i64 288}}<br>
-// CHECK: {{call void @llvm.memcpy.p0i8.p0i8.i64.*i64 12}}<br>
+// CHECK: {{call void @llvm.memcpy.p0i8.p0i8.i64.*i64 300}}<br>
// CHECK: ret void<br>
<br>
<br>
<br>
Added: cfe/trunk/test/CodeGenCXX/pod-member-memcpys.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/pod-member-memcpys.cpp?rev=175389&view=auto" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/pod-member-memcpys.cpp?rev=175389&view=auto</a><br>
==============================================================================<br>
--- cfe/trunk/test/CodeGenCXX/pod-member-memcpys.cpp (added)<br>
+++ cfe/trunk/test/CodeGenCXX/pod-member-memcpys.cpp Sun Feb 17 01:22:09 2013<br>
@@ -0,0 +1,224 @@<br>
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -std=c++03 -fexceptions -fcxx-exceptions -O1 -o - %s | FileCheck %s<br>
+<br>
+struct POD {<br>
+ int w, x, y, z;<br>
+};<br>
+<br>
+struct PODLike {<br>
+ int w, x, y, z;<br>
+ PODLike();<br>
+ ~PODLike();<br>
+};<br>
+<br>
+struct NonPOD {<br>
+ NonPOD();<br>
+ NonPOD(const NonPOD&);<br>
+ NonPOD& operator=(const NonPOD&);<br>
+};<br>
+<br>
+struct Basic {<br>
+ int a, b, c, d;<br>
+ NonPOD np;<br>
+ int w, x, y, z;<br>
+};<br>
+<br>
+struct PODMember {<br>
+ int a, b, c, d;<br>
+ POD p;<br>
+ NonPOD np;<br>
+ int w, x, y, z;<br>
+};<br>
+<br>
+struct PODLikeMember {<br>
+ int a, b, c, d;<br>
+ PODLike pl;<br>
+ NonPOD np;<br>
+ int w, x, y, z;<br>
+};<br>
+<br>
+struct ArrayMember {<br>
+ int a, b, c, d;<br>
+ int e[12];<br>
+ NonPOD np;<br>
+ int f[12];<br>
+ int w, x, y, z;<br>
+};<br>
+<br>
+struct VolatileMember {<br>
+ int a, b, c, d;<br>
+ volatile int v;<br>
+ NonPOD np;<br>
+ int w, x, y, z;<br>
+};<br>
+<br>
+struct BitfieldMember {<br>
+ int a, b, c, d;<br>
+ NonPOD np;<br>
+ int w : 6;<br>
+ int x : 6;<br>
+ int y : 6;<br>
+ int z : 6;<br>
+};<br>
+<br>
+struct InnerClassMember {<br>
+ struct {<br>
+ int a, b, c, d;<br>
+ } a;<br>
+ int b, c, d, e;<br>
+ NonPOD np;<br>
+ int w, x, y, z;<br>
+};<br>
+<br>
+struct ReferenceMember {<br>
+ ReferenceMember(int &a, int &b, int &c, int &d)<br>
+ : a(a), b(b), c(c), d(d) {}<br>
+ int &a;<br>
+ int &b;<br>
+ NonPOD np;<br>
+ int &c;<br>
+ int &d;<br>
+};<br>
+<br>
+// COPY-ASSIGNMENT OPERATORS:<br>
+<br>
+// Assignment operators are output in the order they're encountered.<br>
+<br>
+#define CALL_AO(T) void callAO##T(T& a, const T& b) { a = b; }<br>
+<br>
+CALL_AO(Basic)<br>
+CALL_AO(PODMember)<br>
+CALL_AO(PODLikeMember)<br>
+CALL_AO(ArrayMember)<br>
+CALL_AO(VolatileMember)<br>
+CALL_AO(BitfieldMember)<br>
+CALL_AO(InnerClassMember)<br>
+<br>
+// Basic copy-assignment:<br>
+// CHECK: define linkonce_odr %struct.Basic* @_ZN5BasicaSERKS_(%struct.Basic* %this, %struct.Basic*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: tail call %struct.NonPOD* @_ZN6NonPODaSERKS_<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: ret %struct.Basic* %this<br>
+<br>
+// PODMember copy-assignment:<br>
+// CHECK: define linkonce_odr %struct.PODMember* @_ZN9PODMemberaSERKS_(%struct.PODMember* %this, %struct.PODMember*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 32, i32 4{{.*}})<br>
+// CHECK: tail call %struct.NonPOD* @_ZN6NonPODaSERKS_<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: ret %struct.PODMember* %this<br>
+<br>
+// PODLikeMember copy-assignment:<br>
+// CHECK: define linkonce_odr %struct.PODLikeMember* @_ZN13PODLikeMemberaSERKS_(%struct.PODLikeMember* %this, %struct.PODLikeMember*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 32, i32 4{{.*}})<br>
+// CHECK: tail call %struct.NonPOD* @_ZN6NonPODaSERKS_<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: ret %struct.PODLikeMember* %this<br>
+<br>
+// ArrayMember copy-assignment:<br>
+// CHECK: define linkonce_odr %struct.ArrayMember* @_ZN11ArrayMemberaSERKS_(%struct.ArrayMember* %this, %struct.ArrayMember*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 64, i32 4{{.*}})<br>
+// CHECK: tail call %struct.NonPOD* @_ZN6NonPODaSERKS_<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 64, i32 4{{.*}})<br>
+// CHECK: ret %struct.ArrayMember* %this<br>
+<br>
+// VolatileMember copy-assignment:<br>
+// CHECK: define linkonce_odr %struct.VolatileMember* @_ZN14VolatileMemberaSERKS_(%struct.VolatileMember* %this, %struct.VolatileMember*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: load volatile i32* {{.*}}, align 4<br>
+// CHECK: store volatile i32 {{.*}}, align 4<br>
+// CHECK: tail call %struct.NonPOD* @_ZN6NonPODaSERKS_<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: ret %struct.VolatileMember* %this<br>
+<br>
+// BitfieldMember copy-assignment:<br>
+// CHECK: define linkonce_odr %struct.BitfieldMember* @_ZN14BitfieldMemberaSERKS_(%struct.BitfieldMember* %this, %struct.BitfieldMember*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: tail call %struct.NonPOD* @_ZN6NonPODaSERKS_<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 3, i32 1{{.*}})<br>
+// CHECK: ret %struct.BitfieldMember* %this<br>
+<br>
+// InnerClass copy-assignment:<br>
+// CHECK: define linkonce_odr %struct.InnerClassMember* @_ZN16InnerClassMemberaSERKS_(%struct.InnerClassMember* %this, %struct.InnerClassMember*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 32, i32 4{{.*}})<br>
+// CHECK: tail call %struct.NonPOD* @_ZN6NonPODaSERKS_<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: ret %struct.InnerClassMember* %this<br>
+<br>
+// COPY-CONSTRUCTORS:<br>
+<br>
+// Clang outputs copy-constructors in the reverse of the order that<br>
+// copy-constructor calls are encountered. Add functions that call the copy<br>
+// constructors of the classes above in reverse order here.<br>
+<br>
+#define CALL_CC(T) T callCC##T(const T& b) { return b; }<br>
+<br>
+CALL_CC(ReferenceMember)<br>
+CALL_CC(InnerClassMember)<br>
+CALL_CC(BitfieldMember)<br>
+CALL_CC(VolatileMember)<br>
+CALL_CC(ArrayMember)<br>
+CALL_CC(PODLikeMember)<br>
+CALL_CC(PODMember)<br>
+CALL_CC(Basic)<br>
+<br>
+// Basic copy-constructor:<br>
+// CHECK: define linkonce_odr void @_ZN5BasicC2ERKS_(%struct.Basic* %this, %struct.Basic*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: tail call void @_ZN6NonPODC1ERKS_<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: ret void<br>
+<br>
+// PODMember copy-constructor:<br>
+// CHECK: define linkonce_odr void @_ZN9PODMemberC2ERKS_(%struct.PODMember* %this, %struct.PODMember*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 32, i32 4{{.*}})<br>
+// CHECK: tail call void @_ZN6NonPODC1ERKS_<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: ret void<br>
+<br>
+// PODLikeMember copy-constructor:<br>
+// CHECK: define linkonce_odr void @_ZN13PODLikeMemberC2ERKS_(%struct.PODLikeMember* %this, %struct.PODLikeMember*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 32, i32 4{{.*}})<br>
+// CHECK: invoke void @_ZN6NonPODC1ERKS_<br>
+// CHECK: invoke.cont:<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: ret void<br>
+// CHECK: lpad:<br>
+// CHECK: landingpad<br>
+// CHECK: invoke void @_ZN7PODLikeD1Ev<br>
+<br>
+// ArrayMember copy-constructor:<br>
+// CHECK: define linkonce_odr void @_ZN11ArrayMemberC2ERKS_(%struct.ArrayMember* %this, %struct.ArrayMember*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 64, i32 4{{.*}})<br>
+// CHECK: tail call void @_ZN6NonPODC1ERKS_<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 64, i32 4{{.*}})<br>
+// CHECK: ret void<br>
+<br>
+// VolatileMember copy-constructor:<br>
+// CHECK: define linkonce_odr void @_ZN14VolatileMemberC2ERKS_(%struct.VolatileMember* %this, %struct.VolatileMember*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: load volatile i32* {{.*}}, align 4<br>
+// CHECK: store volatile i32 {{.*}}, align 4<br>
+// CHECK: tail call void @_ZN6NonPODC1ERKS_<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: ret void<br>
+<br>
+// BitfieldMember copy-constructor:<br>
+// CHECK: define linkonce_odr void @_ZN14BitfieldMemberC2ERKS_(%struct.BitfieldMember* %this, %struct.BitfieldMember*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: tail call void @_ZN6NonPODC1ERKS_<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 3, i32 1{{.*}})<br>
+// CHECK: ret void<br>
+<br>
+// InnerClass copy-constructor:<br>
+// CHECK: define linkonce_odr void @_ZN16InnerClassMemberC2ERKS_(%struct.InnerClassMember* %this, %struct.InnerClassMember*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 32, i32 4{{.*}})<br>
+// CHECK: tail call void @_ZN6NonPODC1ERKS_<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 4{{.*}})<br>
+// CHECK: ret void<br>
+<br>
+// ReferenceMember copy-constructor:<br>
+// CHECK: define linkonce_odr void @_ZN15ReferenceMemberC2ERKS_(%struct.ReferenceMember* %this, %struct.ReferenceMember*)<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 8{{.*}})<br>
+// CHECK: tail call void @_ZN6NonPODC1ERKS_<br>
+// CHECK: tail call void @llvm.memcpy.p0i8.p0i8.i64({{.*}}i64 16, i32 8{{.*}})<br>
+// CHECK: ret void<br>
<br>
<br>
_______________________________________________<br>
cfe-commits mailing list<br>
<a href="mailto:cfe-commits@cs.uiuc.edu" class="cremed">cfe-commits@cs.uiuc.edu</a><br>
<a href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits" target="_blank" class="cremed">http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits</a><br>
</blockquote></div><br></div></div>