lib/CodeGen/CGExprAgg.cpp

   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 "CGObjCRuntime.h"
  17 #include "clang/AST/ASTContext.h"
  18 #include "clang/AST/DeclCXX.h"
  19 #include "clang/AST/StmtVisitor.h"
  20 #include "llvm/Constants.h"
  21 #include "llvm/Function.h"
  22 #include "llvm/GlobalVariable.h"
  23 #include "llvm/Intrinsics.h"
  24 using namespace clang;
  25 using namespace CodeGen;
  26
  27 //===----------------------------------------------------------------------===//
  28 //                        Aggregate Expression Emitter
  29 //===----------------------------------------------------------------------===//
  30
  31 namespace  {
  32 class AggExprEmitter : public StmtVisitor<AggExprEmitter> {
  33   CodeGenFunction &CGF;
  34   CGBuilderTy &Builder;
  35   AggValueSlot Dest;
  36   bool IgnoreResult;
  37
  38   ReturnValueSlot getReturnValueSlot() const {
  39     // If the destination slot requires garbage collection, we can't
  40     // use the real return value slot, because we have to use the GC
  41     // API.
  42     if (Dest.requiresGCollection()) return ReturnValueSlot();
  43
  44     return ReturnValueSlot(Dest.getAddr(), Dest.isVolatile());
  45   }
  46
  47   AggValueSlot EnsureSlot(QualType T) {
  48     if (!Dest.isIgnored()) return Dest;
  49     return CGF.CreateAggTemp(T, "agg.tmp.ensured");
  50   }
  51
  52 public:
  53   AggExprEmitter(CodeGenFunction &cgf, AggValueSlot Dest,
  54                  bool ignore)
  55     : CGF(cgf), Builder(CGF.Builder), Dest(Dest),
  56       IgnoreResult(ignore) {
  57   }
  58
  59   //===--------------------------------------------------------------------===//
  60   //                               Utilities
  61   //===--------------------------------------------------------------------===//
  62
  63   /// EmitAggLoadOfLValue - Given an expression with aggregate type that
  64   /// represents a value lvalue, this method emits the address of the lvalue,
  65   /// then loads the result into DestPtr.
  66   void EmitAggLoadOfLValue(const Expr *E);
  67
  68   /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
  69   void EmitFinalDestCopy(const Expr *E, LValue Src, bool Ignore = false);
  70   void EmitFinalDestCopy(const Expr *E, RValue Src, bool Ignore = false);
  71
  72   void EmitGCMove(const Expr *E, RValue Src);
  73
  74   bool TypeRequiresGCollection(QualType T);
  75
  76   //===--------------------------------------------------------------------===//
  77   //                            Visitor Methods
  78   //===--------------------------------------------------------------------===//
  79
  80   void VisitStmt(Stmt *S) {
  81     CGF.ErrorUnsupported(S, "aggregate expression");
  82   }
  83   void VisitParenExpr(ParenExpr *PE) { Visit(PE->getSubExpr()); }
  84   void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); }
  85
  86   // l-values.
  87   void VisitDeclRefExpr(DeclRefExpr *DRE) { EmitAggLoadOfLValue(DRE); }
  88   void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); }
  89   void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); }
  90   void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); }
  91   void VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
  92     EmitAggLoadOfLValue(E);
  93   }
  94   void VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
  95     EmitAggLoadOfLValue(E);
  96   }
  97   void VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) {
  98     EmitAggLoadOfLValue(E);
  99   }
 100   void VisitPredefinedExpr(const PredefinedExpr *E) {
 101     EmitAggLoadOfLValue(E);
 102   }
 103
 104   // Operators.
 105   void VisitCastExpr(CastExpr *E);
 106   void VisitCallExpr(const CallExpr *E);
 107   void VisitStmtExpr(const StmtExpr *E);
 108   void VisitBinaryOperator(const BinaryOperator *BO);
 109   void VisitPointerToDataMemberBinaryOperator(const BinaryOperator *BO);
 110   void VisitBinAssign(const BinaryOperator *E);
 111   void VisitBinComma(const BinaryOperator *E);
 112
 113   void VisitObjCMessageExpr(ObjCMessageExpr *E);
 114   void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
 115     EmitAggLoadOfLValue(E);
 116   }
 117   void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E);
 118
 119   void VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
 120   void VisitChooseExpr(const ChooseExpr *CE);
 121   void VisitInitListExpr(InitListExpr *E);
 122   void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
 123   void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
 124     Visit(DAE->getExpr());
 125   }
 126   void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
 127   void VisitCXXConstructExpr(const CXXConstructExpr *E);
 128   void VisitExprWithCleanups(ExprWithCleanups *E);
 129   void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
 130   void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); }
 131
 132   void VisitOpaqueValueExpr(OpaqueValueExpr *E);
 133
 134   void VisitVAArgExpr(VAArgExpr *E);
 135
 136   void EmitInitializationToLValue(Expr *E, LValue Address, QualType T);
 137   void EmitNullInitializationToLValue(LValue Address, QualType T);
 138   //  case Expr::ChooseExprClass:
 139   void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); }
 140 };
 141 }  // end anonymous namespace.
 142
 143 //===----------------------------------------------------------------------===//
 144 //                                Utilities
 145 //===----------------------------------------------------------------------===//
 146
 147 /// EmitAggLoadOfLValue - Given an expression with aggregate type that
 148 /// represents a value lvalue, this method emits the address of the lvalue,
 149 /// then loads the result into DestPtr.
 150 void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
 151   LValue LV = CGF.EmitLValue(E);
 152   EmitFinalDestCopy(E, LV);
 153 }
 154
 155 /// \brief True if the given aggregate type requires special GC API calls.
 156 bool AggExprEmitter::TypeRequiresGCollection(QualType T) {
 157   // Only record types have members that might require garbage collection.
 158   const RecordType *RecordTy = T->getAs<RecordType>();
 159   if (!RecordTy) return false;
 160
 161   // Don't mess with non-trivial C++ types.
 162   RecordDecl *Record = RecordTy->getDecl();
 163   if (isa<CXXRecordDecl>(Record) &&
 164       (!cast<CXXRecordDecl>(Record)->hasTrivialCopyConstructor() ||
 165        !cast<CXXRecordDecl>(Record)->hasTrivialDestructor()))
 166     return false;
 167
 168   // Check whether the type has an object member.
 169   return Record->hasObjectMember();
 170 }
 171
 172 /// \brief Perform the final move to DestPtr if RequiresGCollection is set.
 173 ///
 174 /// The idea is that you do something like this:
 175 ///   RValue Result = EmitSomething(..., getReturnValueSlot());
 176 ///   EmitGCMove(E, Result);
 177 /// If GC doesn't interfere, this will cause the result to be emitted
 178 /// directly into the return value slot.  If GC does interfere, a final
 179 /// move will be performed.
 180 void AggExprEmitter::EmitGCMove(const Expr *E, RValue Src) {
 181   if (Dest.requiresGCollection()) {
 182     std::pair<uint64_t, unsigned> TypeInfo =
 183       CGF.getContext().getTypeInfo(E->getType());
 184     unsigned long size = TypeInfo.first/8;
 185     const llvm::Type *SizeTy = CGF.ConvertType(CGF.getContext().getSizeType());
 186     llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size);
 187     CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF, Dest.getAddr(),
 188                                                     Src.getAggregateAddr(),
 189                                                     SizeVal);
 190   }
 191 }
 192
 193 /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
 194 void AggExprEmitter::EmitFinalDestCopy(const Expr *E, RValue Src, bool Ignore) {
 195   assert(Src.isAggregate() && "value must be aggregate value!");
 196
 197   // If Dest is ignored, then we're evaluating an aggregate expression
 198   // in a context (like an expression statement) that doesn't care
 199   // about the result.  C says that an lvalue-to-rvalue conversion is
 200   // performed in these cases; C++ says that it is not.  In either
 201   // case, we don't actually need to do anything unless the value is
 202   // volatile.
 203   if (Dest.isIgnored()) {
 204     if (!Src.isVolatileQualified() ||
 205         CGF.CGM.getLangOptions().CPlusPlus ||
 206         (IgnoreResult && Ignore))
 207       return;
 208
 209     // If the source is volatile, we must read from it; to do that, we need
 210     // some place to put it.
 211     Dest = CGF.CreateAggTemp(E->getType(), "agg.tmp");
 212   }
 213
 214   if (Dest.requiresGCollection()) {
 215     std::pair<uint64_t, unsigned> TypeInfo =
 216     CGF.getContext().getTypeInfo(E->getType());
 217     unsigned long size = TypeInfo.first/8;
 218     const llvm::Type *SizeTy = CGF.ConvertType(CGF.getContext().getSizeType());
 219     llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size);
 220     CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF,
 221                                                       Dest.getAddr(),
 222                                                       Src.getAggregateAddr(),
 223                                                       SizeVal);
 224     return;
 225   }
 226   // If the result of the assignment is used, copy the LHS there also.
 227   // FIXME: Pass VolatileDest as well.  I think we also need to merge volatile
 228   // from the source as well, as we can't eliminate it if either operand
 229   // is volatile, unless copy has volatile for both source and destination..
 230   CGF.EmitAggregateCopy(Dest.getAddr(), Src.getAggregateAddr(), E->getType(),
 231                         Dest.isVolatile()|Src.isVolatileQualified());
 232 }
 233
 234 /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
 235 void AggExprEmitter::EmitFinalDestCopy(const Expr *E, LValue Src, bool Ignore) {
 236   assert(Src.isSimple() && "Can't have aggregate bitfield, vector, etc");
 237
 238   EmitFinalDestCopy(E, RValue::getAggregate(Src.getAddress(),
 239                                             Src.isVolatileQualified()),
 240                     Ignore);
 241 }
 242
 243 //===----------------------------------------------------------------------===//
 244 //                            Visitor Methods
 245 //===----------------------------------------------------------------------===//
 246
 247 void AggExprEmitter::VisitOpaqueValueExpr(OpaqueValueExpr *e) {
 248   EmitFinalDestCopy(e, CGF.getOpaqueLValueMapping(e));
 249 }
 250
 251 void AggExprEmitter::VisitCastExpr(CastExpr *E) {
 252   if (Dest.isIgnored() && E->getCastKind() != CK_Dynamic) {
 253     Visit(E->getSubExpr());
 254     return;
 255   }
 256
 257   switch (E->getCastKind()) {
 258   case CK_Dynamic: {
 259     assert(isa<CXXDynamicCastExpr>(E) && "CK_Dynamic without a dynamic_cast?");
 260     LValue LV = CGF.EmitCheckedLValue(E->getSubExpr());
 261     // FIXME: Do we also need to handle property references here?
 262     if (LV.isSimple())
 263       CGF.EmitDynamicCast(LV.getAddress(), cast<CXXDynamicCastExpr>(E));
 264     else
 265       CGF.CGM.ErrorUnsupported(E, "non-simple lvalue dynamic_cast");
 266
 267     if (!Dest.isIgnored())
 268       CGF.CGM.ErrorUnsupported(E, "lvalue dynamic_cast with a destination");
 269     break;
 270   }
 271
 272   case CK_ToUnion: {
 273     // GCC union extension
 274     QualType Ty = E->getSubExpr()->getType();
 275     QualType PtrTy = CGF.getContext().getPointerType(Ty);
 276     llvm::Value *CastPtr = Builder.CreateBitCast(Dest.getAddr(),
 277                                                  CGF.ConvertType(PtrTy));
 278     EmitInitializationToLValue(E->getSubExpr(), CGF.MakeAddrLValue(CastPtr, Ty),
 279                                Ty);
 280     break;
 281   }
 282
 283   case CK_DerivedToBase:
 284   case CK_BaseToDerived:
 285   case CK_UncheckedDerivedToBase: {
 286     assert(0 && "cannot perform hierarchy conversion in EmitAggExpr: "
 287                 "should have been unpacked before we got here");
 288     break;
 289   }
 290
 291   case CK_GetObjCProperty: {
 292     LValue LV = CGF.EmitLValue(E->getSubExpr());
 293     assert(LV.isPropertyRef());
 294     RValue RV = CGF.EmitLoadOfPropertyRefLValue(LV, getReturnValueSlot());
 295     EmitGCMove(E, RV);
 296     break;
 297   }
 298
 299   case CK_LValueToRValue: // hope for downstream optimization
 300   case CK_NoOp:
 301   case CK_UserDefinedConversion:
 302   case CK_ConstructorConversion:
 303     assert(CGF.getContext().hasSameUnqualifiedType(E->getSubExpr()->getType(),
 304                                                    E->getType()) &&
 305            "Implicit cast types must be compatible");
 306     Visit(E->getSubExpr());
 307     break;
 308
 309   case CK_LValueBitCast:
 310     llvm_unreachable("should not be emitting lvalue bitcast as rvalue");
 311     break;
 312
 313   case CK_Dependent:
 314   case CK_BitCast:
 315   case CK_ArrayToPointerDecay:
 316   case CK_FunctionToPointerDecay:
 317   case CK_NullToPointer:
 318   case CK_NullToMemberPointer:
 319   case CK_BaseToDerivedMemberPointer:
 320   case CK_DerivedToBaseMemberPointer:
 321   case CK_MemberPointerToBoolean:
 322   case CK_IntegralToPointer:
 323   case CK_PointerToIntegral:
 324   case CK_PointerToBoolean:
 325   case CK_ToVoid:
 326   case CK_VectorSplat:
 327   case CK_IntegralCast:
 328   case CK_IntegralToBoolean:
 329   case CK_IntegralToFloating:
 330   case CK_FloatingToIntegral:
 331   case CK_FloatingToBoolean:
 332   case CK_FloatingCast:
 333   case CK_AnyPointerToObjCPointerCast:
 334   case CK_AnyPointerToBlockPointerCast:
 335   case CK_ObjCObjectLValueCast:
 336   case CK_FloatingRealToComplex:
 337   case CK_FloatingComplexToReal:
 338   case CK_FloatingComplexToBoolean:
 339   case CK_FloatingComplexCast:
 340   case CK_FloatingComplexToIntegralComplex:
 341   case CK_IntegralRealToComplex:
 342   case CK_IntegralComplexToReal:
 343   case CK_IntegralComplexToBoolean:
 344   case CK_IntegralComplexCast:
 345   case CK_IntegralComplexToFloatingComplex:
 346     llvm_unreachable("cast kind invalid for aggregate types");
 347   }
 348 }
 349
 350 void AggExprEmitter::VisitCallExpr(const CallExpr *E) {
 351   if (E->getCallReturnType()->isReferenceType()) {
 352     EmitAggLoadOfLValue(E);
 353     return;
 354   }
 355
 356   RValue RV = CGF.EmitCallExpr(E, getReturnValueSlot());
 357   EmitGCMove(E, RV);
 358 }
 359
 360 void AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
 361   RValue RV = CGF.EmitObjCMessageExpr(E, getReturnValueSlot());
 362   EmitGCMove(E, RV);
 363 }
 364
 365 void AggExprEmitter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
 366   llvm_unreachable("direct property access not surrounded by "
 367                    "lvalue-to-rvalue cast");
 368 }
 369
 370 void AggExprEmitter::VisitBinComma(const BinaryOperator *E) {
 371   CGF.EmitIgnoredExpr(E->getLHS());
 372   Visit(E->getRHS());
 373 }
 374
 375 void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) {
 376   CodeGenFunction::StmtExprEvaluation eval(CGF);
 377   CGF.EmitCompoundStmt(*E->getSubStmt(), true, Dest);
 378 }
 379
 380 void AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) {
 381   if (E->getOpcode() == BO_PtrMemD || E->getOpcode() == BO_PtrMemI)
 382     VisitPointerToDataMemberBinaryOperator(E);
 383   else
 384     CGF.ErrorUnsupported(E, "aggregate binary expression");
 385 }
 386
 387 void AggExprEmitter::VisitPointerToDataMemberBinaryOperator(
 388                                                     const BinaryOperator *E) {
 389   LValue LV = CGF.EmitPointerToDataMemberBinaryExpr(E);
 390   EmitFinalDestCopy(E, LV);
 391 }
 392
 393 void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) {
 394   // For an assignment to work, the value on the right has
 395   // to be compatible with the value on the left.
 396   assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
 397                                                  E->getRHS()->getType())
 398          && "Invalid assignment");
 399
 400   // FIXME:  __block variables need the RHS evaluated first!
 401   LValue LHS = CGF.EmitLValue(E->getLHS());
 402
 403   // We have to special case property setters, otherwise we must have
 404   // a simple lvalue (no aggregates inside vectors, bitfields).
 405   if (LHS.isPropertyRef()) {
 406     AggValueSlot Slot = EnsureSlot(E->getRHS()->getType());
 407     CGF.EmitAggExpr(E->getRHS(), Slot);
 408     CGF.EmitStoreThroughPropertyRefLValue(Slot.asRValue(), LHS);
 409   } else {
 410     bool GCollection = false;
 411     if (CGF.getContext().getLangOptions().getGCMode())
 412       GCollection = TypeRequiresGCollection(E->getLHS()->getType());
 413
 414     // Codegen the RHS so that it stores directly into the LHS.
 415     AggValueSlot LHSSlot = AggValueSlot::forLValue(LHS, true,
 416                                                    GCollection);
 417     CGF.EmitAggExpr(E->getRHS(), LHSSlot, false);
 418     EmitFinalDestCopy(E, LHS, true);
 419   }
 420 }
 421
 422 void AggExprEmitter::
 423 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
 424   llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
 425   llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
 426   llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
 427
 428   // Bind the common expression if necessary.
 429   CodeGenFunction::OpaqueValueMapping binding(CGF, E);
 430
 431   CodeGenFunction::ConditionalEvaluation eval(CGF);
 432   CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
 433
 434   // Save whether the destination's lifetime is externally managed.
 435   bool DestLifetimeManaged = Dest.isLifetimeExternallyManaged();
 436
 437   eval.begin(CGF);
 438   CGF.EmitBlock(LHSBlock);
 439   Visit(E->getTrueExpr());
 440   eval.end(CGF);
 441
 442   assert(CGF.HaveInsertPoint() && "expression evaluation ended with no IP!");
 443   CGF.Builder.CreateBr(ContBlock);
 444
 445   // If the result of an agg expression is unused, then the emission
 446   // of the LHS might need to create a destination slot.  That's fine
 447   // with us, and we can safely emit the RHS into the same slot, but
 448   // we shouldn't claim that its lifetime is externally managed.
 449   Dest.setLifetimeExternallyManaged(DestLifetimeManaged);
 450
 451   eval.begin(CGF);
 452   CGF.EmitBlock(RHSBlock);
 453   Visit(E->getFalseExpr());
 454   eval.end(CGF);
 455
 456   CGF.EmitBlock(ContBlock);
 457 }
 458
 459 void AggExprEmitter::VisitChooseExpr(const ChooseExpr *CE) {
 460   Visit(CE->getChosenSubExpr(CGF.getContext()));
 461 }
 462
 463 void AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
 464   llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr());
 465   llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType());
 466
 467   if (!ArgPtr) {
 468     CGF.ErrorUnsupported(VE, "aggregate va_arg expression");
 469     return;
 470   }
 471
 472   EmitFinalDestCopy(VE, CGF.MakeAddrLValue(ArgPtr, VE->getType()));
 473 }
 474
 475 void AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
 476   // Ensure that we have a slot, but if we already do, remember
 477   // whether its lifetime was externally managed.
 478   bool WasManaged = Dest.isLifetimeExternallyManaged();
 479   Dest = EnsureSlot(E->getType());
 480   Dest.setLifetimeExternallyManaged();
 481
 482   Visit(E->getSubExpr());
 483
 484   // Set up the temporary's destructor if its lifetime wasn't already
 485   // being managed.
 486   if (!WasManaged)
 487     CGF.EmitCXXTemporary(E->getTemporary(), Dest.getAddr());
 488 }
 489
 490 void
 491 AggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) {
 492   AggValueSlot Slot = EnsureSlot(E->getType());
 493   CGF.EmitCXXConstructExpr(E, Slot);
 494 }
 495
 496 void AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
 497   CGF.EmitExprWithCleanups(E, Dest);
 498 }
 499
 500 void AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
 501   QualType T = E->getType();
 502   AggValueSlot Slot = EnsureSlot(T);
 503   EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddr(), T), T);
 504 }
 505
 506 void AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
 507   QualType T = E->getType();
 508   AggValueSlot Slot = EnsureSlot(T);
 509   EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddr(), T), T);
 510 }
 511
 512 /// isSimpleZero - If emitting this value will obviously just cause a store of
 513 /// zero to memory, return true.  This can return false if uncertain, so it just
 514 /// handles simple cases.
 515 static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) {
 516   // (0)
 517   if (const ParenExpr *PE = dyn_cast<ParenExpr>(E))
 518     return isSimpleZero(PE->getSubExpr(), CGF);
 519   // 0
 520   if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E))
 521     return IL->getValue() == 0;
 522   // +0.0
 523   if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E))
 524     return FL->getValue().isPosZero();
 525   // int()
 526   if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) &&
 527       CGF.getTypes().isZeroInitializable(E->getType()))
 528     return true;
 529   // (int*)0 - Null pointer expressions.
 530   if (const CastExpr *ICE = dyn_cast<CastExpr>(E))
 531     return ICE->getCastKind() == CK_NullToPointer;
 532   // '\0'
 533   if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E))
 534     return CL->getValue() == 0;
 535
 536   // Otherwise, hard case: conservatively return false.
 537   return false;
 538 }
 539
 540
 541 void
 542 AggExprEmitter::EmitInitializationToLValue(Expr* E, LValue LV, QualType T) {
 543   // FIXME: Ignore result?
 544   // FIXME: Are initializers affected by volatile?
 545   if (Dest.isZeroed() && isSimpleZero(E, CGF)) {
 546     // Storing "i32 0" to a zero'd memory location is a noop.
 547   } else if (isa<ImplicitValueInitExpr>(E)) {
 548     EmitNullInitializationToLValue(LV, T);
 549   } else if (T->isReferenceType()) {
 550     RValue RV = CGF.EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0);
 551     CGF.EmitStoreThroughLValue(RV, LV, T);
 552   } else if (T->isAnyComplexType()) {
 553     CGF.EmitComplexExprIntoAddr(E, LV.getAddress(), false);
 554   } else if (CGF.hasAggregateLLVMType(T)) {
 555     CGF.EmitAggExpr(E, AggValueSlot::forAddr(LV.getAddress(), false, true,
 556                                              false, Dest.isZeroed()));
 557   } else {
 558     CGF.EmitStoreThroughLValue(RValue::get(CGF.EmitScalarExpr(E)), LV, T);
 559   }
 560 }
 561
 562 void AggExprEmitter::EmitNullInitializationToLValue(LValue LV, QualType T) {
 563   // If the destination slot is already zeroed out before the aggregate is
 564   // copied into it, we don't have to emit any zeros here.
 565   if (Dest.isZeroed() && CGF.getTypes().isZeroInitializable(T))
 566     return;
 567
 568   if (!CGF.hasAggregateLLVMType(T)) {
 569     // For non-aggregates, we can store zero
 570     llvm::Value *Null = llvm::Constant::getNullValue(CGF.ConvertType(T));
 571     CGF.EmitStoreThroughLValue(RValue::get(Null), LV, T);
 572   } else {
 573     // There's a potential optimization opportunity in combining
 574     // memsets; that would be easy for arrays, but relatively
 575     // difficult for structures with the current code.
 576     CGF.EmitNullInitialization(LV.getAddress(), T);
 577   }
 578 }
 579
 580 void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
 581 #if 0
 582   // FIXME: Assess perf here?  Figure out what cases are worth optimizing here
 583   // (Length of globals? Chunks of zeroed-out space?).
 584   //
 585   // If we can, prefer a copy from a global; this is a lot less code for long
 586   // globals, and it's easier for the current optimizers to analyze.
 587   if (llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, E->getType(), &CGF)) {
 588     llvm::GlobalVariable* GV =
 589     new llvm::GlobalVariable(CGF.CGM.getModule(), C->getType(), true,
 590                              llvm::GlobalValue::InternalLinkage, C, "");
 591     EmitFinalDestCopy(E, CGF.MakeAddrLValue(GV, E->getType()));
 592     return;
 593   }
 594 #endif
 595   if (E->hadArrayRangeDesignator())
 596     CGF.ErrorUnsupported(E, "GNU array range designator extension");
 597
 598   llvm::Value *DestPtr = Dest.getAddr();
 599
 600   // Handle initialization of an array.
 601   if (E->getType()->isArrayType()) {
 602     const llvm::PointerType *APType =
 603       cast<llvm::PointerType>(DestPtr->getType());
 604     const llvm::ArrayType *AType =
 605       cast<llvm::ArrayType>(APType->getElementType());
 606
 607     uint64_t NumInitElements = E->getNumInits();
 608
 609     if (E->getNumInits() > 0) {
 610       QualType T1 = E->getType();
 611       QualType T2 = E->getInit(0)->getType();
 612       if (CGF.getContext().hasSameUnqualifiedType(T1, T2)) {
 613         EmitAggLoadOfLValue(E->getInit(0));
 614         return;
 615       }
 616     }
 617
 618     uint64_t NumArrayElements = AType->getNumElements();
 619     QualType ElementType = CGF.getContext().getCanonicalType(E->getType());
 620     ElementType = CGF.getContext().getAsArrayType(ElementType)->getElementType();
 621
 622     // FIXME: were we intentionally ignoring address spaces and GC attributes?
 623
 624     for (uint64_t i = 0; i != NumArrayElements; ++i) {
 625       // If we're done emitting initializers and the destination is known-zeroed
 626       // then we're done.
 627       if (i == NumInitElements &&
 628           Dest.isZeroed() &&
 629           CGF.getTypes().isZeroInitializable(ElementType))
 630         break;
 631
 632       llvm::Value *NextVal = Builder.CreateStructGEP(DestPtr, i, ".array");
 633       LValue LV = CGF.MakeAddrLValue(NextVal, ElementType);
 634
 635       if (i < NumInitElements)
 636         EmitInitializationToLValue(E->getInit(i), LV, ElementType);
 637       else
 638         EmitNullInitializationToLValue(LV, ElementType);
 639
 640       // If the GEP didn't get used because of a dead zero init or something
 641       // else, clean it up for -O0 builds and general tidiness.
 642       if (llvm::GetElementPtrInst *GEP =
 643             dyn_cast<llvm::GetElementPtrInst>(NextVal))
 644         if (GEP->use_empty())
 645           GEP->eraseFromParent();
 646     }
 647     return;
 648   }
 649
 650   assert(E->getType()->isRecordType() && "Only support structs/unions here!");
 651
 652   // Do struct initialization; this code just sets each individual member
 653   // to the approprate value.  This makes bitfield support automatic;
 654   // the disadvantage is that the generated code is more difficult for
 655   // the optimizer, especially with bitfields.
 656   unsigned NumInitElements = E->getNumInits();
 657   RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl();
 658
 659   if (E->getType()->isUnionType()) {
 660     // Only initialize one field of a union. The field itself is
 661     // specified by the initializer list.
 662     if (!E->getInitializedFieldInUnion()) {
 663       // Empty union; we have nothing to do.
 664
 665 #ifndef NDEBUG
 666       // Make sure that it's really an empty and not a failure of
 667       // semantic analysis.
 668       for (RecordDecl::field_iterator Field = SD->field_begin(),
 669                                    FieldEnd = SD->field_end();
 670            Field != FieldEnd; ++Field)
 671         assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed");
 672 #endif
 673       return;
 674     }
 675
 676     // FIXME: volatility
 677     FieldDecl *Field = E->getInitializedFieldInUnion();
 678
 679     LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestPtr, Field, 0);
 680     if (NumInitElements) {
 681       // Store the initializer into the field
 682       EmitInitializationToLValue(E->getInit(0), FieldLoc, Field->getType());
 683     } else {
 684       // Default-initialize to null.
 685       EmitNullInitializationToLValue(FieldLoc, Field->getType());
 686     }
 687
 688     return;
 689   }
 690
 691   // Here we iterate over the fields; this makes it simpler to both
 692   // default-initialize fields and skip over unnamed fields.
 693   unsigned CurInitVal = 0;
 694   for (RecordDecl::field_iterator Field = SD->field_begin(),
 695                                FieldEnd = SD->field_end();
 696        Field != FieldEnd; ++Field) {
 697     // We're done once we hit the flexible array member
 698     if (Field->getType()->isIncompleteArrayType())
 699       break;
 700
 701     if (Field->isUnnamedBitfield())
 702       continue;
 703
 704     // Don't emit GEP before a noop store of zero.
 705     if (CurInitVal == NumInitElements && Dest.isZeroed() &&
 706         CGF.getTypes().isZeroInitializable(E->getType()))
 707       break;
 708
 709     // FIXME: volatility
 710     LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestPtr, *Field, 0);
 711     // We never generate write-barries for initialized fields.
 712     FieldLoc.setNonGC(true);
 713
 714     if (CurInitVal < NumInitElements) {
 715       // Store the initializer into the field.
 716       EmitInitializationToLValue(E->getInit(CurInitVal++), FieldLoc,
 717                                  Field->getType());
 718     } else {
 719       // We're out of initalizers; default-initialize to null
 720       EmitNullInitializationToLValue(FieldLoc, Field->getType());
 721     }
 722
 723     // If the GEP didn't get used because of a dead zero init or something
 724     // else, clean it up for -O0 builds and general tidiness.
 725     if (FieldLoc.isSimple())
 726       if (llvm::GetElementPtrInst *GEP =
 727             dyn_cast<llvm::GetElementPtrInst>(FieldLoc.getAddress()))
 728         if (GEP->use_empty())
 729           GEP->eraseFromParent();
 730   }
 731 }
 732
 733 //===----------------------------------------------------------------------===//
 734 //                        Entry Points into this File
 735 //===----------------------------------------------------------------------===//
 736
 737 /// GetNumNonZeroBytesInInit - Get an approximate count of the number of
 738 /// non-zero bytes that will be stored when outputting the initializer for the
 739 /// specified initializer expression.
 740 static uint64_t GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF) {
 741   if (const ParenExpr *PE = dyn_cast<ParenExpr>(E))
 742     return GetNumNonZeroBytesInInit(PE->getSubExpr(), CGF);
 743
 744   // 0 and 0.0 won't require any non-zero stores!
 745   if (isSimpleZero(E, CGF)) return 0;
 746
 747   // If this is an initlist expr, sum up the size of sizes of the (present)
 748   // elements.  If this is something weird, assume the whole thing is non-zero.
 749   const InitListExpr *ILE = dyn_cast<InitListExpr>(E);
 750   if (ILE == 0 || !CGF.getTypes().isZeroInitializable(ILE->getType()))
 751     return CGF.getContext().getTypeSize(E->getType())/8;
 752
 753   // InitListExprs for structs have to be handled carefully.  If there are
 754   // reference members, we need to consider the size of the reference, not the
 755   // referencee.  InitListExprs for unions and arrays can't have references.
 756   if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
 757     if (!RT->isUnionType()) {
 758       RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl();
 759       uint64_t NumNonZeroBytes = 0;
 760
 761       unsigned ILEElement = 0;
 762       for (RecordDecl::field_iterator Field = SD->field_begin(),
 763            FieldEnd = SD->field_end(); Field != FieldEnd; ++Field) {
 764         // We're done once we hit the flexible array member or run out of
 765         // InitListExpr elements.
 766         if (Field->getType()->isIncompleteArrayType() ||
 767             ILEElement == ILE->getNumInits())
 768           break;
 769         if (Field->isUnnamedBitfield())
 770           continue;
 771
 772         const Expr *E = ILE->getInit(ILEElement++);
 773
 774         // Reference values are always non-null and have the width of a pointer.
 775         if (Field->getType()->isReferenceType())
 776           NumNonZeroBytes += CGF.getContext().Target.getPointerWidth(0);
 777         else
 778           NumNonZeroBytes += GetNumNonZeroBytesInInit(E, CGF);
 779       }
 780
 781       return NumNonZeroBytes;
 782     }
 783   }
 784
 785
 786   uint64_t NumNonZeroBytes = 0;
 787   for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i)
 788     NumNonZeroBytes += GetNumNonZeroBytesInInit(ILE->getInit(i), CGF);
 789   return NumNonZeroBytes;
 790 }
 791
 792 /// CheckAggExprForMemSetUse - If the initializer is large and has a lot of
 793 /// zeros in it, emit a memset and avoid storing the individual zeros.
 794 ///
 795 static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E,
 796                                      CodeGenFunction &CGF) {
 797   // If the slot is already known to be zeroed, nothing to do.  Don't mess with
 798   // volatile stores.
 799   if (Slot.isZeroed() || Slot.isVolatile() || Slot.getAddr() == 0) return;
 800
 801   // If the type is 16-bytes or smaller, prefer individual stores over memset.
 802   std::pair<uint64_t, unsigned> TypeInfo =
 803     CGF.getContext().getTypeInfo(E->getType());
 804   if (TypeInfo.first/8 <= 16)
 805     return;
 806
 807   // Check to see if over 3/4 of the initializer are known to be zero.  If so,
 808   // we prefer to emit memset + individual stores for the rest.
 809   uint64_t NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF);
 810   if (NumNonZeroBytes*4 > TypeInfo.first/8)
 811     return;
 812
 813   // Okay, it seems like a good idea to use an initial memset, emit the call.
 814   llvm::Constant *SizeVal = CGF.Builder.getInt64(TypeInfo.first/8);
 815   unsigned Align = TypeInfo.second/8;
 816
 817   llvm::Value *Loc = Slot.getAddr();
 818   const llvm::Type *BP = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
 819
 820   Loc = CGF.Builder.CreateBitCast(Loc, BP);
 821   CGF.Builder.CreateMemSet(Loc, CGF.Builder.getInt8(0), SizeVal, Align, false);
 822
 823   // Tell the AggExprEmitter that the slot is known zero.
 824   Slot.setZeroed();
 825 }
 826
 827
 828
 829
 830 /// EmitAggExpr - Emit the computation of the specified expression of aggregate
 831 /// type.  The result is computed into DestPtr.  Note that if DestPtr is null,
 832 /// the value of the aggregate expression is not needed.  If VolatileDest is
 833 /// true, DestPtr cannot be 0.
 834 ///
 835 /// \param IsInitializer - true if this evaluation is initializing an
 836 /// object whose lifetime is already being managed.
 837 //
 838 // FIXME: Take Qualifiers object.
 839 void CodeGenFunction::EmitAggExpr(const Expr *E, AggValueSlot Slot,
 840                                   bool IgnoreResult) {
 841   assert(E && hasAggregateLLVMType(E->getType()) &&
 842          "Invalid aggregate expression to emit");
 843   assert((Slot.getAddr() != 0 || Slot.isIgnored()) &&
 844          "slot has bits but no address");
 845
 846   // Optimize the slot if possible.
 847   CheckAggExprForMemSetUse(Slot, E, *this);
 848
 849   AggExprEmitter(*this, Slot, IgnoreResult).Visit(const_cast<Expr*>(E));
 850 }
 851
 852 LValue CodeGenFunction::EmitAggExprToLValue(const Expr *E) {
 853   assert(hasAggregateLLVMType(E->getType()) && "Invalid argument!");
 854   llvm::Value *Temp = CreateMemTemp(E->getType());
 855   LValue LV = MakeAddrLValue(Temp, E->getType());
 856   EmitAggExpr(E, AggValueSlot::forAddr(Temp, LV.isVolatileQualified(), false));
 857   return LV;
 858 }
 859
 860 void CodeGenFunction::EmitAggregateCopy(llvm::Value *DestPtr,
 861                                         llvm::Value *SrcPtr, QualType Ty,
 862                                         bool isVolatile) {
 863   assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex");
 864
 865   if (getContext().getLangOptions().CPlusPlus) {
 866     if (const RecordType *RT = Ty->getAs<RecordType>()) {
 867       CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
 868       assert((Record->hasTrivialCopyConstructor() ||
 869               Record->hasTrivialCopyAssignment()) &&
 870              "Trying to aggregate-copy a type without a trivial copy "
 871              "constructor or assignment operator");
 872       // Ignore empty classes in C++.
 873       if (Record->isEmpty())
 874         return;
 875     }
 876   }
 877
 878   // Aggregate assignment turns into llvm.memcpy.  This is almost valid per
 879   // C99 6.5.16.1p3, which states "If the value being stored in an object is
 880   // read from another object that overlaps in anyway the storage of the first
 881   // object, then the overlap shall be exact and the two objects shall have
 882   // qualified or unqualified versions of a compatible type."
 883   //
 884   // memcpy is not defined if the source and destination pointers are exactly
 885   // equal, but other compilers do this optimization, and almost every memcpy
 886   // implementation handles this case safely.  If there is a libc that does not
 887   // safely handle this, we can add a target hook.
 888
 889   // Get size and alignment info for this aggregate.
 890   std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty);
 891
 892   // FIXME: Handle variable sized types.
 893
 894   // FIXME: If we have a volatile struct, the optimizer can remove what might
 895   // appear to be `extra' memory ops:
 896   //
 897   // volatile struct { int i; } a, b;
 898   //
 899   // int main() {
 900   //   a = b;
 901   //   a = b;
 902   // }
 903   //
 904   // we need to use a different call here.  We use isVolatile to indicate when
 905   // either the source or the destination is volatile.
 906
 907   const llvm::PointerType *DPT = cast<llvm::PointerType>(DestPtr->getType());
 908   const llvm::Type *DBP =
 909     llvm::Type::getInt8PtrTy(getLLVMContext(), DPT->getAddressSpace());
 910   DestPtr = Builder.CreateBitCast(DestPtr, DBP, "tmp");
 911
 912   const llvm::PointerType *SPT = cast<llvm::PointerType>(SrcPtr->getType());
 913   const llvm::Type *SBP =
 914     llvm::Type::getInt8PtrTy(getLLVMContext(), SPT->getAddressSpace());
 915   SrcPtr = Builder.CreateBitCast(SrcPtr, SBP, "tmp");
 916
 917   if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
 918     RecordDecl *Record = RecordTy->getDecl();
 919     if (Record->hasObjectMember()) {
 920       unsigned long size = TypeInfo.first/8;
 921       const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
 922       llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size);
 923       CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
 924                                                     SizeVal);
 925       return;
 926     }
 927   } else if (getContext().getAsArrayType(Ty)) {
 928     QualType BaseType = getContext().getBaseElementType(Ty);
 929     if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
 930       if (RecordTy->getDecl()->hasObjectMember()) {
 931         unsigned long size = TypeInfo.first/8;
 932         const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
 933         llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size);
 934         CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
 935                                                       SizeVal);
 936         return;
 937       }
 938     }
 939   }
 940
 941   Builder.CreateMemCpy(DestPtr, SrcPtr,
 942                        llvm::ConstantInt::get(IntPtrTy, TypeInfo.first/8),
 943                        TypeInfo.second/8, isVolatile);
 944 }