/// represents a value lvalue, this method emits the address of the lvalue,
/// then loads the result into DestPtr.
void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
+ if (CGF.getContext().getLangOptions().CPlusPlus) {
+ if (const CXXConstructExpr *CE = Dest.getCtorExpr()) {
+ // Perform copy initialization of Src into Dest.
+ const CXXConstructorDecl *CD = CE->getConstructor();
+ CXXCtorType Type =
+ (CE->getConstructionKind() == CXXConstructExpr::CK_Complete)
+ ? Ctor_Complete : Ctor_Base;
+ bool ForVirtualBase =
+ CE->getConstructionKind() == CXXConstructExpr::CK_VirtualBase;
+ // Call the constructor.
+ const Stmt * S = dyn_cast<Stmt>(E);
+ clang::ConstExprIterator BegExp(&S);
+ CGF.EmitCXXConstructorCall(CD, Type, ForVirtualBase, Dest.getAddr(),
+ BegExp, (BegExp+1));
+ return;
+ }
+ }
LValue LV = CGF.EmitLValue(E);
EmitFinalDestCopy(E, LV);
}
CGF.CGM.getLangOptions().CPlusPlus ||
(IgnoreResult && Ignore))
return;
-
// If the source is volatile, we must read from it; to do that, we need
// some place to put it.
Dest = CGF.CreateAggTemp(E->getType(), "agg.tmp");
SizeVal);
return;
}
+
// If the result of the assignment is used, copy the LHS there also.
// FIXME: Pass VolatileDest as well. I think we also need to merge volatile
// from the source as well, as we can't eliminate it if either operand
assert(getContext().hasSameUnqualifiedType(E->getType(),
E->getArg(0)->getType()));
if (E->getArg(0)->isTemporaryObject(getContext(), CD->getParent())) {
+ Dest.setCtorExpr(const_cast<CXXConstructExpr*>(E));
EmitAggExpr(E->getArg(0), Dest);
return;
}
namespace clang {
class ObjCPropertyRefExpr;
class ObjCImplicitSetterGetterRefExpr;
+ class CXXConstructExpr;
namespace CodeGen {
class CGBitFieldInfo;
class AggValueSlot {
/// The address.
llvm::Value *Addr;
+ CXXConstructExpr *CtorExpr;
// Associated flags.
bool VolatileFlag : 1;
static AggValueSlot ignored() {
AggValueSlot AV;
AV.Addr = 0;
+ AV.CtorExpr = 0;
AV.VolatileFlag = AV.LifetimeFlag = AV.RequiresGCollection = 0;
return AV;
}
bool RequiresGCollection=false) {
AggValueSlot AV;
AV.Addr = Addr;
+ AV.CtorExpr = 0;
AV.VolatileFlag = Volatile;
AV.LifetimeFlag = LifetimeExternallyManaged;
AV.RequiresGCollection = RequiresGCollection;
return forAddr(LV.getAddress(), LV.isVolatileQualified(),
LifetimeExternallyManaged, RequiresGCollection);
}
-
+
+ void setCtorExpr(CXXConstructExpr *E) { CtorExpr = E; }
+ CXXConstructExpr *getCtorExpr() const { return CtorExpr; }
+
bool isLifetimeExternallyManaged() const {
return LifetimeFlag;
}
--- /dev/null
+// RUN: %clang_cc1 -emit-llvm -o - %s
+// rdar //8540501
+
+struct A
+{
+ int i;
+ A (int j) : i(j) {}
+ A (const A &j) : i(j.i) {}
+ A& operator= (const A &j) { i = j.i; return *this; }
+};
+
+A foo(int j)
+{
+ return ({ j ? A(1) : A(0); });
+}
+
+int main()
+{
+ return foo(1).i-1;
+}
+
+void foo2()
+{
+ A b = ({ A a(1); a; });
+}
+