<div dir="ltr">Interesting. I'll back out the patch while I try to reproduce. Thanks Takumi!<div><br></div><div>- Lang.</div></div><div class="gmail_extra"><br><br><div class="gmail_quote">On Mon, Feb 11, 2013 at 4:33 PM, NAKAMURA Takumi <span dir="ltr"><<a href="mailto:geek4civic@gmail.com" target="_blank">geek4civic@gmail.com</a>></span> wrote:<br>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Lang, seems it broke selfhosting...<br>
<a href="http://bb.pgr.jp/builders/clang-3stage-x86_64-linux/builds/1011" target="_blank">http://bb.pgr.jp/builders/clang-3stage-x86_64-linux/builds/1011</a><br>
<br>
2013/2/12 Lang Hames <<a href="mailto:lhames@gmail.com">lhames@gmail.com</a>>:<br>
<div class="HOEnZb"><div class="h5">> Author: lhames<br>
> Date: Mon Feb 11 17:44:11 2013<br>
> New Revision: 174919<br>
><br>
> URL: <a href="http://llvm.org/viewvc/llvm-project?rev=174919&view=rev" target="_blank">http://llvm.org/viewvc/llvm-project?rev=174919&view=rev</a><br>
> Log:<br>
> When generating IR for default copy-constructors, copy-assignment operators,<br>
> move-constructors and move-assignment operators, use memcpy to copy adjacent<br>
> POD members.<br>
><br>
> Previously, classes with one or more Non-POD members would fall back on<br>
> element-wise copies for all members, including POD members. This often<br>
> generated a lot of IR. Without padding metadata, it wasn't often possible<br>
> for the LLVM optimizers to turn the element-wise copies into a memcpy.<br>
><br>
> This code hasn't yet received any serious tuning. I didn't see any serious<br>
> regressions on a self-hosted clang build, or any of the nightly tests, but<br>
> I think it's important to get this out in the wild to get more testing.<br>
> Insights, feedback and comments welcome.<br>
><br>
> Many thanks to David Blaikie, Richard Smith, and especially John McCall for<br>
> their help and feedback on this work.<br>
><br>
><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=174919&r1=174918&r2=174919&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGClass.cpp?rev=174919&r1=174918&r2=174919&view=diff</a><br>
> ==============================================================================<br>
> --- cfe/trunk/lib/CodeGen/CGClass.cpp (original)<br>
> +++ cfe/trunk/lib/CodeGen/CGClass.cpp Mon Feb 11 17:44:11 2013<br>
> @@ -18,6 +18,7 @@<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 +743,342 @@ 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>
> + CGF.getContext().getTypeInfo(LastField->getType()).first;<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 =<br>
> + CGF.getContext().getTypeInfo(FirstField->getType()).second;<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 +1107,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 +1279,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=174919&r1=174918&r2=174919&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenFunction.cpp?rev=174919&r1=174918&r2=174919&view=diff</a><br>
> ==============================================================================<br>
> --- cfe/trunk/lib/CodeGen/CodeGenFunction.cpp (original)<br>
> +++ cfe/trunk/lib/CodeGen/CodeGenFunction.cpp Mon Feb 11 17:44:11 2013<br>
> @@ -559,6 +559,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=174919&r1=174918&r2=174919&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenFunction.h?rev=174919&r1=174918&r2=174919&view=diff</a><br>
> ==============================================================================<br>
> --- cfe/trunk/lib/CodeGen/CodeGenFunction.h (original)<br>
> +++ cfe/trunk/lib/CodeGen/CodeGenFunction.h Mon Feb 11 17:44:11 2013<br>
> @@ -1402,6 +1402,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=174919&r1=174918&r2=174919&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/copy-assign-synthesis-1.cpp?rev=174919&r1=174918&r2=174919&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 Mon Feb 11 17:44:11 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=174919&r1=174918&r2=174919&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/implicit-copy-assign-operator.cpp?rev=174919&r1=174918&r2=174919&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 Mon Feb 11 17:44:11 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=174919&r1=174918&r2=174919&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/implicit-copy-constructor.cpp?rev=174919&r1=174918&r2=174919&view=diff</a><br>
> ==============================================================================<br>
> --- cfe/trunk/test/CodeGenCXX/implicit-copy-constructor.cpp (original)<br>
> +++ cfe/trunk/test/CodeGenCXX/implicit-copy-constructor.cpp Mon Feb 11 17:44:11 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>
><br>
> _______________________________________________<br>
> cfe-commits mailing list<br>
> <a href="mailto:cfe-commits@cs.uiuc.edu">cfe-commits@cs.uiuc.edu</a><br>
> <a href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits" target="_blank">http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits</a><br>
</div></div></blockquote></div><br></div>