Support member reference on ?: of struct type.

llvm-svn: 67603

4 files changed, 43 insertions, 0 deletions

diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp
index 45cd6a70a5d..b52c81eb0bc 100644
--- a/clang/lib/CodeGen/CGExpr.cpp
+++ b/clang/lib/CodeGen/CGExpr.cpp
@@ -179,6 +179,8 @@ LValue CodeGenFunction::EmitLValue(const Expr *E) {
   case Expr::MemberExprClass: return EmitMemberExpr(cast<MemberExpr>(E));
   case Expr::CompoundLiteralExprClass:
     return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E));
+  case Expr::ConditionalOperatorClass:
+    return EmitConditionalOperator(cast<ConditionalOperator>(E));
   case Expr::ChooseExprClass:
     return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext()));
   case Expr::ImplicitCastExprClass:
@@ -1009,6 +1011,24 @@ LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr* E){
   return Result;
 }
 
+LValue CodeGenFunction::EmitConditionalOperator(const ConditionalOperator* E) {
+  // We don't handle vectors yet.
+  if (E->getType()->isVectorType())
+    return EmitUnsupportedLValue(E, "conditional operator");
+
+  // ?: here should be an aggregate.
+  assert((hasAggregateLLVMType(E->getType()) && 
+          !E->getType()->isAnyComplexType()) &&
+         "Unexpected conditional operator!");
+
+  llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType()));
+  EmitAggExpr(E, Temp, false);
+
+  return LValue::MakeAddr(Temp, E->getType().getCVRQualifiers(),
+                          getContext().getObjCGCAttrKind(E->getType()));
+ 
+}
+
 /// EmitCastLValue - Casts are never lvalues.  If a cast is needed by the code
 /// generator in an lvalue context, then it must mean that we need the address
 /// of an aggregate in order to access one of its fields.  This can happen for
diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h
index 9771c83d84c..acac86d8c2b 100644
--- a/clang/lib/CodeGen/CodeGenFunction.h
+++ b/clang/lib/CodeGen/CodeGenFunction.h
@@ -608,6 +608,7 @@ public:
   LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
   LValue EmitMemberExpr(const MemberExpr *E);
   LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
+  LValue EmitConditionalOperator(const ConditionalOperator *E);
   LValue EmitCastLValue(const CastExpr *E);
 
   llvm::Value *EmitIvarOffset(ObjCInterfaceDecl *Interface,
diff --git a/clang/test/CodeGen/exprs.c b/clang/test/CodeGen/exprs.c
index 808db178ef8..0e74b8c7732 100644
--- a/clang/test/CodeGen/exprs.c
+++ b/clang/test/CodeGen/exprs.c
@@ -88,3 +88,9 @@ _Complex float f4() {return ((union f4_y)(_Complex float)2.0).y;}
 struct f5_a { int a; } f5_a;
 union f5_z {int x; struct f5_a y;};
 struct f5_a f5() {return ((union f5_z)f5_a).y;}
+
+// ?: in "lvalue"
+struct s6 { int f0; };
+int f6(int a0, struct s6 a1, struct s6 a2) {
+  return (a0 ? a1 : a2).f0;
+}
diff --git a/clang/test/Coverage/c-language-features.inc b/clang/test/Coverage/c-language-features.inc
index 6a475d6c2fd..656e8fe0c62 100644
--- a/clang/test/Coverage/c-language-features.inc
+++ b/clang/test/Coverage/c-language-features.inc
@@ -128,16 +128,32 @@ void f4(int a0, int a1, int a2, va_list ap) {
   struct { char f0[10]; } *t28;
   int t29 = t28 - t28;
   char *t30 = &t28->f0[1];
+
+  struct s1 { int f0; };
+  struct s1 t31_a, t31_b;
+  int t31_cond;
+  int t31 = (t31_cond ? t31_a : t31_b).f0;
+
+  _Complex float t32_a, t32_b;
+  int t32_cond;
+  int t32 = __real (t32_cond ? t32_a : t32_b);
 }
 
 // Extended vectors
 
+typedef __attribute__((ext_vector_type(2))) float float2;
 typedef __attribute__((ext_vector_type(4))) float float4;
 
 void f5() {
   float4 t0 = (float4) { 0, 1, 2, 3 };
   float4 t1 = t0;
   t0.lo.even = t1.hi.x;
+
+  // irgen doesn't support this yet.
+#if 0
+  int t2_cond;
+  float2 t2 = (t2_cond ? t0 : t1).lo;
+#endif
 }
 
 void f6() {