CGExprAgg.cpp revision 8e587a15da6d3457a418239d5eb4146fcbd209f3 
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/ASTContext.h"
17#include "clang/AST/DeclCXX.h"
18#include "clang/AST/StmtVisitor.h"
19#include "llvm/Constants.h"
20#include "llvm/Function.h"
21#include "llvm/GlobalVariable.h"
22#include "llvm/Support/Compiler.h"
23#include "llvm/Intrinsics.h"
24using namespace clang;
25using namespace CodeGen;
26
27//===----------------------------------------------------------------------===//
28//                        Aggregate Expression Emitter
29//===----------------------------------------------------------------------===//
30
31namespace  {
32class VISIBILITY_HIDDEN AggExprEmitter : public StmtVisitor<AggExprEmitter> {
33  CodeGenFunction &CGF;
34  CGBuilderTy &Builder;
35  llvm::Value *DestPtr;
36  bool VolatileDest;
37  bool IgnoreResult;
38
39public:
40  AggExprEmitter(CodeGenFunction &cgf, llvm::Value *destPtr, bool v,
41                 bool ignore)
42    : CGF(cgf), Builder(CGF.Builder),
43      DestPtr(destPtr), VolatileDest(v), IgnoreResult(ignore) {
44  }
45
46  //===--------------------------------------------------------------------===//
47  //                               Utilities
48  //===--------------------------------------------------------------------===//
49
50  /// EmitAggLoadOfLValue - Given an expression with aggregate type that
51  /// represents a value lvalue, this method emits the address of the lvalue,
52  /// then loads the result into DestPtr.
53  void EmitAggLoadOfLValue(const Expr *E);
54
55  /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
56  void EmitFinalDestCopy(const Expr *E, LValue Src, bool Ignore = false);
57  void EmitFinalDestCopy(const Expr *E, RValue Src, bool Ignore = false);
58
59  //===--------------------------------------------------------------------===//
60  //                            Visitor Methods
61  //===--------------------------------------------------------------------===//
62
63  void VisitStmt(Stmt *S) {
64    CGF.ErrorUnsupported(S, "aggregate expression");
65  }
66  void VisitParenExpr(ParenExpr *PE) { Visit(PE->getSubExpr()); }
67  void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); }
68
69  // l-values.
70  void VisitDeclRefExpr(DeclRefExpr *DRE) { EmitAggLoadOfLValue(DRE); }
71  void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); }
72  void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); }
73  void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); }
74  void VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
75    EmitAggLoadOfLValue(E);
76  }
77  void VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
78    EmitAggLoadOfLValue(E);
79  }
80  void VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) {
81    EmitAggLoadOfLValue(E);
82  }
83  void VisitPredefinedExpr(const PredefinedExpr *E) {
84    EmitAggLoadOfLValue(E);
85  }
86
87  // Operators.
88  void VisitCStyleCastExpr(CStyleCastExpr *E);
89  void VisitImplicitCastExpr(ImplicitCastExpr *E);
90  void VisitCallExpr(const CallExpr *E);
91  void VisitStmtExpr(const StmtExpr *E);
92  void VisitBinaryOperator(const BinaryOperator *BO);
93  void VisitBinAssign(const BinaryOperator *E);
94  void VisitBinComma(const BinaryOperator *E);
95
96  void VisitObjCMessageExpr(ObjCMessageExpr *E);
97  void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
98    EmitAggLoadOfLValue(E);
99  }
100  void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E);
101  void VisitObjCKVCRefExpr(ObjCKVCRefExpr *E);
102
103  void VisitConditionalOperator(const ConditionalOperator *CO);
104  void VisitInitListExpr(InitListExpr *E);
105  void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
106    Visit(DAE->getExpr());
107  }
108  void VisitCXXConstructExpr(const CXXConstructExpr *E);
109  void VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E);
110
111  void VisitVAArgExpr(VAArgExpr *E);
112
113  void EmitInitializationToLValue(Expr *E, LValue Address);
114  void EmitNullInitializationToLValue(LValue Address, QualType T);
115  //  case Expr::ChooseExprClass:
116
117};
118}  // end anonymous namespace.
119
120//===----------------------------------------------------------------------===//
121//                                Utilities
122//===----------------------------------------------------------------------===//
123
124/// EmitAggLoadOfLValue - Given an expression with aggregate type that
125/// represents a value lvalue, this method emits the address of the lvalue,
126/// then loads the result into DestPtr.
127void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
128  LValue LV = CGF.EmitLValue(E);
129  EmitFinalDestCopy(E, LV);
130}
131
132/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
133void AggExprEmitter::EmitFinalDestCopy(const Expr *E, RValue Src, bool Ignore) {
134  assert(Src.isAggregate() && "value must be aggregate value!");
135
136  // If the result is ignored, don't copy from the value.
137  if (DestPtr == 0) {
138    if (!Src.isVolatileQualified() || (IgnoreResult && Ignore))
139      return;
140    // If the source is volatile, we must read from it; to do that, we need
141    // some place to put it.
142    DestPtr = CGF.CreateTempAlloca(CGF.ConvertType(E->getType()), "agg.tmp");
143  }
144
145  // If the result of the assignment is used, copy the LHS there also.
146  // FIXME: Pass VolatileDest as well.  I think we also need to merge volatile
147  // from the source as well, as we can't eliminate it if either operand
148  // is volatile, unless copy has volatile for both source and destination..
149  CGF.EmitAggregateCopy(DestPtr, Src.getAggregateAddr(), E->getType(),
150                        VolatileDest|Src.isVolatileQualified());
151}
152
153/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
154void AggExprEmitter::EmitFinalDestCopy(const Expr *E, LValue Src, bool Ignore) {
155  assert(Src.isSimple() && "Can't have aggregate bitfield, vector, etc");
156
157  EmitFinalDestCopy(E, RValue::getAggregate(Src.getAddress(),
158                                            Src.isVolatileQualified()),
159                    Ignore);
160}
161
162//===----------------------------------------------------------------------===//
163//                            Visitor Methods
164//===----------------------------------------------------------------------===//
165
166void AggExprEmitter::VisitCStyleCastExpr(CStyleCastExpr *E) {
167  // GCC union extension
168  if (E->getType()->isUnionType()) {
169    RecordDecl *SD = E->getType()->getAsRecordType()->getDecl();
170    LValue FieldLoc = CGF.EmitLValueForField(DestPtr,
171                                             *SD->field_begin(CGF.getContext()),
172                                             true, 0);
173    EmitInitializationToLValue(E->getSubExpr(), FieldLoc);
174    return;
175  }
176
177  Visit(E->getSubExpr());
178}
179
180void AggExprEmitter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
181  assert(CGF.getContext().hasSameUnqualifiedType(E->getSubExpr()->getType(),
182                                                 E->getType()) &&
183         "Implicit cast types must be compatible");
184  Visit(E->getSubExpr());
185}
186
187void AggExprEmitter::VisitCallExpr(const CallExpr *E) {
188  if (E->getCallReturnType()->isReferenceType()) {
189    EmitAggLoadOfLValue(E);
190    return;
191  }
192
193  RValue RV = CGF.EmitCallExpr(E);
194  EmitFinalDestCopy(E, RV);
195}
196
197void AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
198  RValue RV = CGF.EmitObjCMessageExpr(E);
199  EmitFinalDestCopy(E, RV);
200}
201
202void AggExprEmitter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
203  RValue RV = CGF.EmitObjCPropertyGet(E);
204  EmitFinalDestCopy(E, RV);
205}
206
207void AggExprEmitter::VisitObjCKVCRefExpr(ObjCKVCRefExpr *E) {
208  RValue RV = CGF.EmitObjCPropertyGet(E);
209  EmitFinalDestCopy(E, RV);
210}
211
212void AggExprEmitter::VisitBinComma(const BinaryOperator *E) {
213  CGF.EmitAnyExpr(E->getLHS(), 0, false, true);
214  CGF.EmitAggExpr(E->getRHS(), DestPtr, VolatileDest);
215}
216
217void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) {
218  CGF.EmitCompoundStmt(*E->getSubStmt(), true, DestPtr, VolatileDest);
219}
220
221void AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) {
222  CGF.ErrorUnsupported(E, "aggregate binary expression");
223}
224
225void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) {
226  // For an assignment to work, the value on the right has
227  // to be compatible with the value on the left.
228  assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
229                                                 E->getRHS()->getType())
230         && "Invalid assignment");
231  LValue LHS = CGF.EmitLValue(E->getLHS());
232
233  // We have to special case property setters, otherwise we must have
234  // a simple lvalue (no aggregates inside vectors, bitfields).
235  if (LHS.isPropertyRef()) {
236    llvm::Value *AggLoc = DestPtr;
237    if (!AggLoc)
238      AggLoc = CGF.CreateTempAlloca(CGF.ConvertType(E->getRHS()->getType()));
239    CGF.EmitAggExpr(E->getRHS(), AggLoc, VolatileDest);
240    CGF.EmitObjCPropertySet(LHS.getPropertyRefExpr(),
241                            RValue::getAggregate(AggLoc, VolatileDest));
242  }
243  else if (LHS.isKVCRef()) {
244    llvm::Value *AggLoc = DestPtr;
245    if (!AggLoc)
246      AggLoc = CGF.CreateTempAlloca(CGF.ConvertType(E->getRHS()->getType()));
247    CGF.EmitAggExpr(E->getRHS(), AggLoc, VolatileDest);
248    CGF.EmitObjCPropertySet(LHS.getKVCRefExpr(),
249                            RValue::getAggregate(AggLoc, VolatileDest));
250  } else {
251    // Codegen the RHS so that it stores directly into the LHS.
252    CGF.EmitAggExpr(E->getRHS(), LHS.getAddress(), LHS.isVolatileQualified());
253    EmitFinalDestCopy(E, LHS, true);
254  }
255}
256
257void AggExprEmitter::VisitConditionalOperator(const ConditionalOperator *E) {
258  llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
259  llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
260  llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
261
262  llvm::Value *Cond = CGF.EvaluateExprAsBool(E->getCond());
263  Builder.CreateCondBr(Cond, LHSBlock, RHSBlock);
264
265  CGF.EmitBlock(LHSBlock);
266
267  // Handle the GNU extension for missing LHS.
268  assert(E->getLHS() && "Must have LHS for aggregate value");
269
270  Visit(E->getLHS());
271  CGF.EmitBranch(ContBlock);
272
273  CGF.EmitBlock(RHSBlock);
274
275  Visit(E->getRHS());
276  CGF.EmitBranch(ContBlock);
277
278  CGF.EmitBlock(ContBlock);
279}
280
281void AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
282  llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr());
283  llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType());
284
285  if (!ArgPtr) {
286    CGF.ErrorUnsupported(VE, "aggregate va_arg expression");
287    return;
288  }
289
290  EmitFinalDestCopy(VE, LValue::MakeAddr(ArgPtr, 0));
291}
292
293void
294AggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) {
295  assert(DestPtr && "Must have somewhere to emit into!");
296
297  CGF.EmitCXXConstructExpr(DestPtr, E);
298}
299
300void AggExprEmitter::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) {
301  // FIXME: Do something with the temporaries!
302  Visit(E->getSubExpr());
303}
304
305void AggExprEmitter::EmitInitializationToLValue(Expr* E, LValue LV) {
306  // FIXME: Ignore result?
307  // FIXME: Are initializers affected by volatile?
308  if (isa<ImplicitValueInitExpr>(E)) {
309    EmitNullInitializationToLValue(LV, E->getType());
310  } else if (E->getType()->isComplexType()) {
311    CGF.EmitComplexExprIntoAddr(E, LV.getAddress(), false);
312  } else if (CGF.hasAggregateLLVMType(E->getType())) {
313    CGF.EmitAnyExpr(E, LV.getAddress(), false);
314  } else {
315    CGF.EmitStoreThroughLValue(CGF.EmitAnyExpr(E), LV, E->getType());
316  }
317}
318
319void AggExprEmitter::EmitNullInitializationToLValue(LValue LV, QualType T) {
320  if (!CGF.hasAggregateLLVMType(T)) {
321    // For non-aggregates, we can store zero
322    llvm::Value *Null = llvm::Constant::getNullValue(CGF.ConvertType(T));
323    CGF.EmitStoreThroughLValue(RValue::get(Null), LV, T);
324  } else {
325    // Otherwise, just memset the whole thing to zero.  This is legal
326    // because in LLVM, all default initializers are guaranteed to have a
327    // bit pattern of all zeros.
328    // FIXME: That isn't true for member pointers!
329    // There's a potential optimization opportunity in combining
330    // memsets; that would be easy for arrays, but relatively
331    // difficult for structures with the current code.
332    CGF.EmitMemSetToZero(LV.getAddress(), T);
333  }
334}
335
336void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
337#if 0
338  // FIXME: Disabled while we figure out what to do about
339  // test/CodeGen/bitfield.c
340  //
341  // If we can, prefer a copy from a global; this is a lot less code for long
342  // globals, and it's easier for the current optimizers to analyze.
343  // FIXME: Should we really be doing this? Should we try to avoid cases where
344  // we emit a global with a lot of zeros?  Should we try to avoid short
345  // globals?
346  if (E->isConstantInitializer(CGF.getContext(), 0)) {
347    llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, &CGF);
348    llvm::GlobalVariable* GV =
349    new llvm::GlobalVariable(C->getType(), true,
350                             llvm::GlobalValue::InternalLinkage,
351                             C, "", &CGF.CGM.getModule(), 0);
352    EmitFinalDestCopy(E, LValue::MakeAddr(GV, 0));
353    return;
354  }
355#endif
356  if (E->hadArrayRangeDesignator()) {
357    CGF.ErrorUnsupported(E, "GNU array range designator extension");
358  }
359
360  // Handle initialization of an array.
361  if (E->getType()->isArrayType()) {
362    const llvm::PointerType *APType =
363      cast<llvm::PointerType>(DestPtr->getType());
364    const llvm::ArrayType *AType =
365      cast<llvm::ArrayType>(APType->getElementType());
366
367    uint64_t NumInitElements = E->getNumInits();
368
369    if (E->getNumInits() > 0) {
370      QualType T1 = E->getType();
371      QualType T2 = E->getInit(0)->getType();
372      if (CGF.getContext().hasSameUnqualifiedType(T1, T2)) {
373        EmitAggLoadOfLValue(E->getInit(0));
374        return;
375      }
376    }
377
378    uint64_t NumArrayElements = AType->getNumElements();
379    QualType ElementType = CGF.getContext().getCanonicalType(E->getType());
380    ElementType = CGF.getContext().getAsArrayType(ElementType)->getElementType();
381
382    unsigned CVRqualifier = ElementType.getCVRQualifiers();
383
384    for (uint64_t i = 0; i != NumArrayElements; ++i) {
385      llvm::Value *NextVal = Builder.CreateStructGEP(DestPtr, i, ".array");
386      if (i < NumInitElements)
387        EmitInitializationToLValue(E->getInit(i),
388                                   LValue::MakeAddr(NextVal, CVRqualifier));
389      else
390        EmitNullInitializationToLValue(LValue::MakeAddr(NextVal, CVRqualifier),
391                                       ElementType);
392    }
393    return;
394  }
395
396  assert(E->getType()->isRecordType() && "Only support structs/unions here!");
397
398  // Do struct initialization; this code just sets each individual member
399  // to the approprate value.  This makes bitfield support automatic;
400  // the disadvantage is that the generated code is more difficult for
401  // the optimizer, especially with bitfields.
402  unsigned NumInitElements = E->getNumInits();
403  RecordDecl *SD = E->getType()->getAsRecordType()->getDecl();
404  unsigned CurInitVal = 0;
405
406  if (E->getType()->isUnionType()) {
407    // Only initialize one field of a union. The field itself is
408    // specified by the initializer list.
409    if (!E->getInitializedFieldInUnion()) {
410      // Empty union; we have nothing to do.
411
412#ifndef NDEBUG
413      // Make sure that it's really an empty and not a failure of
414      // semantic analysis.
415      for (RecordDecl::field_iterator Field = SD->field_begin(CGF.getContext()),
416                                   FieldEnd = SD->field_end(CGF.getContext());
417           Field != FieldEnd; ++Field)
418        assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed");
419#endif
420      return;
421    }
422
423    // FIXME: volatility
424    FieldDecl *Field = E->getInitializedFieldInUnion();
425    LValue FieldLoc = CGF.EmitLValueForField(DestPtr, Field, true, 0);
426
427    if (NumInitElements) {
428      // Store the initializer into the field
429      EmitInitializationToLValue(E->getInit(0), FieldLoc);
430    } else {
431      // Default-initialize to null
432      EmitNullInitializationToLValue(FieldLoc, Field->getType());
433    }
434
435    return;
436  }
437
438  // Here we iterate over the fields; this makes it simpler to both
439  // default-initialize fields and skip over unnamed fields.
440  for (RecordDecl::field_iterator Field = SD->field_begin(CGF.getContext()),
441                               FieldEnd = SD->field_end(CGF.getContext());
442       Field != FieldEnd; ++Field) {
443    // We're done once we hit the flexible array member
444    if (Field->getType()->isIncompleteArrayType())
445      break;
446
447    if (Field->isUnnamedBitfield())
448      continue;
449
450    // FIXME: volatility
451    LValue FieldLoc = CGF.EmitLValueForField(DestPtr, *Field, false, 0);
452    // We never generate write-barries for initialized fields.
453    LValue::SetObjCNonGC(FieldLoc, true);
454    if (CurInitVal < NumInitElements) {
455      // Store the initializer into the field
456      EmitInitializationToLValue(E->getInit(CurInitVal++), FieldLoc);
457    } else {
458      // We're out of initalizers; default-initialize to null
459      EmitNullInitializationToLValue(FieldLoc, Field->getType());
460    }
461  }
462}
463
464//===----------------------------------------------------------------------===//
465//                        Entry Points into this File
466//===----------------------------------------------------------------------===//
467
468/// EmitAggExpr - Emit the computation of the specified expression of aggregate
469/// type.  The result is computed into DestPtr.  Note that if DestPtr is null,
470/// the value of the aggregate expression is not needed.  If VolatileDest is
471/// true, DestPtr cannot be 0.
472void CodeGenFunction::EmitAggExpr(const Expr *E, llvm::Value *DestPtr,
473                                  bool VolatileDest, bool IgnoreResult) {
474  assert(E && hasAggregateLLVMType(E->getType()) &&
475         "Invalid aggregate expression to emit");
476  assert ((DestPtr != 0 || VolatileDest == false)
477          && "volatile aggregate can't be 0");
478
479  AggExprEmitter(*this, DestPtr, VolatileDest, IgnoreResult)
480    .Visit(const_cast<Expr*>(E));
481}
482
483void CodeGenFunction::EmitAggregateClear(llvm::Value *DestPtr, QualType Ty) {
484  assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex");
485
486  EmitMemSetToZero(DestPtr, Ty);
487}
488
489void CodeGenFunction::EmitAggregateCopy(llvm::Value *DestPtr,
490                                        llvm::Value *SrcPtr, QualType Ty,
491                                        bool isVolatile) {
492  assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex");
493
494  // Aggregate assignment turns into llvm.memcpy.  This is almost valid per
495  // C99 6.5.16.1p3, which states "If the value being stored in an object is
496  // read from another object that overlaps in anyway the storage of the first
497  // object, then the overlap shall be exact and the two objects shall have
498  // qualified or unqualified versions of a compatible type."
499  //
500  // memcpy is not defined if the source and destination pointers are exactly
501  // equal, but other compilers do this optimization, and almost every memcpy
502  // implementation handles this case safely.  If there is a libc that does not
503  // safely handle this, we can add a target hook.
504  const llvm::Type *BP = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
505  if (DestPtr->getType() != BP)
506    DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp");
507  if (SrcPtr->getType() != BP)
508    SrcPtr = Builder.CreateBitCast(SrcPtr, BP, "tmp");
509
510  // Get size and alignment info for this aggregate.
511  std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty);
512
513  // FIXME: Handle variable sized types.
514  const llvm::Type *IntPtr = llvm::IntegerType::get(LLVMPointerWidth);
515
516  // FIXME: If we have a volatile struct, the optimizer can remove what might
517  // appear to be `extra' memory ops:
518  //
519  // volatile struct { int i; } a, b;
520  //
521  // int main() {
522  //   a = b;
523  //   a = b;
524  // }
525  //
526  // we need to use a differnt call here.  We use isVolatile to indicate when
527  // either the source or the destination is volatile.
528  Builder.CreateCall4(CGM.getMemCpyFn(),
529                      DestPtr, SrcPtr,
530                      // TypeInfo.first describes size in bits.
531                      llvm::ConstantInt::get(IntPtr, TypeInfo.first/8),
532                      llvm::ConstantInt::get(llvm::Type::Int32Ty,
533                                             TypeInfo.second/8));
534}
535