1 //===--- CGExprAgg.cpp - Emit LLVM Code from Aggregate Expressions --------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This contains code to emit Aggregate Expr nodes as LLVM code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CodeGenFunction.h"
15 #include "CodeGenModule.h"
16 #include "clang/AST/AST.h"
17 #include "llvm/Constants.h"
18 #include "llvm/Function.h"
19 #include "llvm/GlobalVariable.h"
20 #include "llvm/Support/Compiler.h"
21 using namespace clang;
22 using namespace CodeGen;
23 
24 //===----------------------------------------------------------------------===//
25 //                        Aggregate Expression Emitter
26 //===----------------------------------------------------------------------===//
27 
28 namespace  {
29 class VISIBILITY_HIDDEN AggExprEmitter : public StmtVisitor<AggExprEmitter> {
30   CodeGenFunction &CGF;
31   llvm::LLVMFoldingBuilder &Builder;
32   llvm::Value *DestPtr;
33   bool VolatileDest;
34 public:
35   AggExprEmitter(CodeGenFunction &cgf, llvm::Value *destPtr, bool volatileDest)
36     : CGF(cgf), Builder(CGF.Builder),
37       DestPtr(destPtr), VolatileDest(volatileDest) {
38   }
39 
40   //===--------------------------------------------------------------------===//
41   //                               Utilities
42   //===--------------------------------------------------------------------===//
43 
44   /// EmitAggLoadOfLValue - Given an expression with aggregate type that
45   /// represents a value lvalue, this method emits the address of the lvalue,
46   /// then loads the result into DestPtr.
47   void EmitAggLoadOfLValue(const Expr *E);
48 
49   void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr,
50                          QualType EltTy);
51 
52   void EmitAggregateClear(llvm::Value *DestPtr, QualType Ty);
53 
54   void EmitNonConstInit(InitListExpr *E);
55 
56   //===--------------------------------------------------------------------===//
57   //                            Visitor Methods
58   //===--------------------------------------------------------------------===//
59 
60   void VisitStmt(Stmt *S) {
61     CGF.WarnUnsupported(S, "aggregate expression");
62   }
63   void VisitParenExpr(ParenExpr *PE) { Visit(PE->getSubExpr()); }
64 
65   // l-values.
66   void VisitDeclRefExpr(DeclRefExpr *DRE) { EmitAggLoadOfLValue(DRE); }
67   void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); }
68   void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); }
69   void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); }
70 
71   void VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
72     EmitAggLoadOfLValue(E);
73   }
74 
75   // Operators.
76   //  case Expr::UnaryOperatorClass:
77   //  case Expr::CastExprClass:
78   void VisitImplicitCastExpr(ImplicitCastExpr *E);
79   void VisitCallExpr(const CallExpr *E);
80   void VisitStmtExpr(const StmtExpr *E);
81   void VisitBinaryOperator(const BinaryOperator *BO);
82   void VisitBinAssign(const BinaryOperator *E);
83   void VisitOverloadExpr(const OverloadExpr *E);
84 
85 
86   void VisitConditionalOperator(const ConditionalOperator *CO);
87   void VisitInitListExpr(InitListExpr *E);
88   //  case Expr::ChooseExprClass:
89 
90 };
91 }  // end anonymous namespace.
92 
93 //===----------------------------------------------------------------------===//
94 //                                Utilities
95 //===----------------------------------------------------------------------===//
96 
97 void AggExprEmitter::EmitAggregateClear(llvm::Value *DestPtr, QualType Ty) {
98   assert(!Ty->isComplexType() && "Shouldn't happen for complex");
99 
100   // Aggregate assignment turns into llvm.memset.
101   const llvm::Type *BP = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
102   if (DestPtr->getType() != BP)
103     DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp");
104 
105   // Get size and alignment info for this aggregate.
106   std::pair<uint64_t, unsigned> TypeInfo = CGF.getContext().getTypeInfo(Ty);
107 
108   // FIXME: Handle variable sized types.
109   const llvm::Type *IntPtr = llvm::IntegerType::get(CGF.LLVMPointerWidth);
110 
111   llvm::Value *MemSetOps[4] = {
112     DestPtr,
113     llvm::ConstantInt::getNullValue(llvm::Type::Int8Ty),
114     // TypeInfo.first describes size in bits.
115     llvm::ConstantInt::get(IntPtr, TypeInfo.first/8),
116     llvm::ConstantInt::get(llvm::Type::Int32Ty, TypeInfo.second/8)
117   };
118 
119   Builder.CreateCall(CGF.CGM.getMemSetFn(), MemSetOps, MemSetOps+4);
120 }
121 
122 void AggExprEmitter::EmitAggregateCopy(llvm::Value *DestPtr,
123                                        llvm::Value *SrcPtr, QualType Ty) {
124   assert(!Ty->isComplexType() && "Shouldn't happen for complex");
125 
126   // Aggregate assignment turns into llvm.memcpy.
127   const llvm::Type *BP = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
128   if (DestPtr->getType() != BP)
129     DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp");
130   if (SrcPtr->getType() != BP)
131     SrcPtr = Builder.CreateBitCast(SrcPtr, BP, "tmp");
132 
133   // Get size and alignment info for this aggregate.
134   std::pair<uint64_t, unsigned> TypeInfo = CGF.getContext().getTypeInfo(Ty);
135 
136   // FIXME: Handle variable sized types.
137   const llvm::Type *IntPtr = llvm::IntegerType::get(CGF.LLVMPointerWidth);
138 
139   llvm::Value *MemCpyOps[4] = {
140     DestPtr, SrcPtr,
141     // TypeInfo.first describes size in bits.
142     llvm::ConstantInt::get(IntPtr, TypeInfo.first/8),
143     llvm::ConstantInt::get(llvm::Type::Int32Ty, TypeInfo.second/8)
144   };
145 
146   Builder.CreateCall(CGF.CGM.getMemCpyFn(), MemCpyOps, MemCpyOps+4);
147 }
148 
149 
150 /// EmitAggLoadOfLValue - Given an expression with aggregate type that
151 /// represents a value lvalue, this method emits the address of the lvalue,
152 /// then loads the result into DestPtr.
153 void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
154   LValue LV = CGF.EmitLValue(E);
155   assert(LV.isSimple() && "Can't have aggregate bitfield, vector, etc");
156   llvm::Value *SrcPtr = LV.getAddress();
157 
158   // If the result is ignored, don't copy from the value.
159   if (DestPtr == 0)
160     // FIXME: If the source is volatile, we must read from it.
161     return;
162 
163   EmitAggregateCopy(DestPtr, SrcPtr, E->getType());
164 }
165 
166 //===----------------------------------------------------------------------===//
167 //                            Visitor Methods
168 //===----------------------------------------------------------------------===//
169 
170 void AggExprEmitter::VisitImplicitCastExpr(ImplicitCastExpr *E)
171 {
172   QualType STy = E->getSubExpr()->getType().getCanonicalType();
173   QualType Ty = E->getType().getCanonicalType();
174 
175   assert(CGF.getContext().typesAreCompatible(
176              STy.getUnqualifiedType(), Ty.getUnqualifiedType())
177          && "Implicit cast types must be compatible");
178 
179   Visit(E->getSubExpr());
180 }
181 
182 void AggExprEmitter::VisitCallExpr(const CallExpr *E)
183 {
184   RValue RV = CGF.EmitCallExpr(E);
185   assert(RV.isAggregate() && "Return value must be aggregate value!");
186 
187   // If the result is ignored, don't copy from the value.
188   if (DestPtr == 0)
189     // FIXME: If the source is volatile, we must read from it.
190     return;
191 
192   EmitAggregateCopy(DestPtr, RV.getAggregateAddr(), E->getType());
193 }
194 
195 void AggExprEmitter::VisitOverloadExpr(const OverloadExpr *E)
196 {
197   RValue RV = CGF.EmitCallExpr(E->getFn(), E->arg_begin(),
198                                E->getNumArgs(CGF.getContext()));
199   assert(RV.isAggregate() && "Return value must be aggregate value!");
200 
201   // If the result is ignored, don't copy from the value.
202   if (DestPtr == 0)
203     // FIXME: If the source is volatile, we must read from it.
204     return;
205 
206   EmitAggregateCopy(DestPtr, RV.getAggregateAddr(), E->getType());
207 }
208 
209 void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) {
210   CGF.EmitCompoundStmt(*E->getSubStmt(), true, DestPtr, VolatileDest);
211 }
212 
213 void AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) {
214   CGF.WarnUnsupported(E, "aggregate binary expression");
215 }
216 
217 void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) {
218   // For an assignment to work, the value on the right has
219   // to be compatible with the value on the left.
220   assert(CGF.getContext().typesAreCompatible(
221              E->getLHS()->getType().getUnqualifiedType(),
222              E->getRHS()->getType().getUnqualifiedType())
223          && "Invalid assignment");
224   LValue LHS = CGF.EmitLValue(E->getLHS());
225 
226   // Codegen the RHS so that it stores directly into the LHS.
227   CGF.EmitAggExpr(E->getRHS(), LHS.getAddress(), false /*FIXME: VOLATILE LHS*/);
228 
229   if (DestPtr == 0)
230     return;
231 
232   // If the result of the assignment is used, copy the RHS there also.
233   EmitAggregateCopy(DestPtr, LHS.getAddress(), E->getType());
234 }
235 
236 void AggExprEmitter::VisitConditionalOperator(const ConditionalOperator *E) {
237   llvm::BasicBlock *LHSBlock = new llvm::BasicBlock("cond.?");
238   llvm::BasicBlock *RHSBlock = new llvm::BasicBlock("cond.:");
239   llvm::BasicBlock *ContBlock = new llvm::BasicBlock("cond.cont");
240 
241   llvm::Value *Cond = CGF.EvaluateExprAsBool(E->getCond());
242   Builder.CreateCondBr(Cond, LHSBlock, RHSBlock);
243 
244   CGF.EmitBlock(LHSBlock);
245 
246   // Handle the GNU extension for missing LHS.
247   assert(E->getLHS() && "Must have LHS for aggregate value");
248 
249   Visit(E->getLHS());
250   Builder.CreateBr(ContBlock);
251   LHSBlock = Builder.GetInsertBlock();
252 
253   CGF.EmitBlock(RHSBlock);
254 
255   Visit(E->getRHS());
256   Builder.CreateBr(ContBlock);
257   RHSBlock = Builder.GetInsertBlock();
258 
259   CGF.EmitBlock(ContBlock);
260 }
261 
262 void AggExprEmitter::EmitNonConstInit(InitListExpr *E) {
263 
264   const llvm::PointerType *APType =
265     cast<llvm::PointerType>(DestPtr->getType());
266   const llvm::Type *DestType = APType->getElementType();
267 
268   if (const llvm::ArrayType *AType = dyn_cast<llvm::ArrayType>(DestType)) {
269     unsigned NumInitElements = E->getNumInits();
270 
271     unsigned i;
272     for (i = 0; i != NumInitElements; ++i) {
273       llvm::Value *NextVal = Builder.CreateStructGEP(DestPtr, i, ".array");
274       Expr *Init = E->getInit(i);
275       if (isa<InitListExpr>(Init))
276         CGF.EmitAggExpr(Init, NextVal, VolatileDest);
277       else
278         Builder.CreateStore(CGF.EmitScalarExpr(Init), NextVal);
279     }
280 
281     // Emit remaining default initializers
282     unsigned NumArrayElements = AType->getNumElements();
283     QualType QType = E->getInit(0)->getType();
284     const llvm::Type *EType = AType->getElementType();
285     for (/*Do not initialize i*/; i < NumArrayElements; ++i) {
286       llvm::Value *NextVal = Builder.CreateStructGEP(DestPtr, i, ".array");
287       if (EType->isFirstClassType())
288         Builder.CreateStore(llvm::Constant::getNullValue(EType), NextVal);
289       else
290         EmitAggregateClear(NextVal, QType);
291     }
292   } else
293     assert(false && "Invalid initializer");
294 }
295 
296 void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
297 
298   if (E->isConstantExpr(CGF.CGM.getContext(), NULL)) {
299     llvm::Constant *V = CGF.CGM.EmitConstantExpr(E);
300     // Create global value to hold this array.
301     V = new llvm::GlobalVariable(V->getType(), true,
302                                  llvm::GlobalValue::InternalLinkage,
303                                  V, ".array",
304                                  &CGF.CGM.getModule());
305 
306     EmitAggregateCopy(DestPtr, V , E->getType());
307     return;
308   } else {
309     if (!E->getType()->isArrayType()) {
310       CGF.WarnUnsupported(E, "aggregate init-list expression");
311       return;
312     }
313     EmitNonConstInit(E);
314   }
315 }
316 
317 //===----------------------------------------------------------------------===//
318 //                        Entry Points into this File
319 //===----------------------------------------------------------------------===//
320 
321 /// EmitAggExpr - Emit the computation of the specified expression of
322 /// aggregate type.  The result is computed into DestPtr.  Note that if
323 /// DestPtr is null, the value of the aggregate expression is not needed.
324 void CodeGenFunction::EmitAggExpr(const Expr *E, llvm::Value *DestPtr,
325                                   bool VolatileDest) {
326   assert(E && hasAggregateLLVMType(E->getType()) &&
327          "Invalid aggregate expression to emit");
328 
329   AggExprEmitter(*this, DestPtr, VolatileDest).Visit(const_cast<Expr*>(E));
330 }
331