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 "CGObjCRuntime.h" 16#include "CodeGenModule.h" 17#include "clang/AST/ASTContext.h" 18#include "clang/AST/DeclCXX.h" 19#include "clang/AST/DeclTemplate.h" 20#include "clang/AST/StmtVisitor.h" 21#include "llvm/IR/Constants.h" 22#include "llvm/IR/Function.h" 23#include "llvm/IR/GlobalVariable.h" 24#include "llvm/IR/Intrinsics.h" 25using namespace clang; 26using namespace CodeGen; 27 28//===----------------------------------------------------------------------===// 29// Aggregate Expression Emitter 30//===----------------------------------------------------------------------===// 31 32namespace { 33class AggExprEmitter : public StmtVisitor<AggExprEmitter> { 34 CodeGenFunction &CGF; 35 CGBuilderTy &Builder; 36 AggValueSlot Dest; 37 bool IsResultUnused; 38 39 /// We want to use 'dest' as the return slot except under two 40 /// conditions: 41 /// - The destination slot requires garbage collection, so we 42 /// need to use the GC API. 43 /// - The destination slot is potentially aliased. 44 bool shouldUseDestForReturnSlot() const { 45 return !(Dest.requiresGCollection() || Dest.isPotentiallyAliased()); 46 } 47 48 ReturnValueSlot getReturnValueSlot() const { 49 if (!shouldUseDestForReturnSlot()) 50 return ReturnValueSlot(); 51 52 return ReturnValueSlot(Dest.getAddress(), Dest.isVolatile(), 53 IsResultUnused); 54 } 55 56 AggValueSlot EnsureSlot(QualType T) { 57 if (!Dest.isIgnored()) return Dest; 58 return CGF.CreateAggTemp(T, "agg.tmp.ensured"); 59 } 60 void EnsureDest(QualType T) { 61 if (!Dest.isIgnored()) return; 62 Dest = CGF.CreateAggTemp(T, "agg.tmp.ensured"); 63 } 64 65public: 66 AggExprEmitter(CodeGenFunction &cgf, AggValueSlot Dest, bool IsResultUnused) 67 : CGF(cgf), Builder(CGF.Builder), Dest(Dest), 68 IsResultUnused(IsResultUnused) { } 69 70 //===--------------------------------------------------------------------===// 71 // Utilities 72 //===--------------------------------------------------------------------===// 73 74 /// EmitAggLoadOfLValue - Given an expression with aggregate type that 75 /// represents a value lvalue, this method emits the address of the lvalue, 76 /// then loads the result into DestPtr. 77 void EmitAggLoadOfLValue(const Expr *E); 78 79 /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired. 80 void EmitFinalDestCopy(QualType type, const LValue &src); 81 void EmitFinalDestCopy(QualType type, RValue src); 82 void EmitCopy(QualType type, const AggValueSlot &dest, 83 const AggValueSlot &src); 84 85 void EmitMoveFromReturnSlot(const Expr *E, RValue Src); 86 87 void EmitArrayInit(Address DestPtr, llvm::ArrayType *AType, 88 QualType elementType, InitListExpr *E); 89 90 AggValueSlot::NeedsGCBarriers_t needsGC(QualType T) { 91 if (CGF.getLangOpts().getGC() && TypeRequiresGCollection(T)) 92 return AggValueSlot::NeedsGCBarriers; 93 return AggValueSlot::DoesNotNeedGCBarriers; 94 } 95 96 bool TypeRequiresGCollection(QualType T); 97 98 //===--------------------------------------------------------------------===// 99 // Visitor Methods 100 //===--------------------------------------------------------------------===// 101 102 void Visit(Expr *E) { 103 ApplyDebugLocation DL(CGF, E); 104 StmtVisitor<AggExprEmitter>::Visit(E); 105 } 106 107 void VisitStmt(Stmt *S) { 108 CGF.ErrorUnsupported(S, "aggregate expression"); 109 } 110 void VisitParenExpr(ParenExpr *PE) { Visit(PE->getSubExpr()); } 111 void VisitGenericSelectionExpr(GenericSelectionExpr *GE) { 112 Visit(GE->getResultExpr()); 113 } 114 void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); } 115 void VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) { 116 return Visit(E->getReplacement()); 117 } 118 119 // l-values. 120 void VisitDeclRefExpr(DeclRefExpr *E) { 121 // For aggregates, we should always be able to emit the variable 122 // as an l-value unless it's a reference. This is due to the fact 123 // that we can't actually ever see a normal l2r conversion on an 124 // aggregate in C++, and in C there's no language standard 125 // actively preventing us from listing variables in the captures 126 // list of a block. 127 if (E->getDecl()->getType()->isReferenceType()) { 128 if (CodeGenFunction::ConstantEmission result 129 = CGF.tryEmitAsConstant(E)) { 130 EmitFinalDestCopy(E->getType(), result.getReferenceLValue(CGF, E)); 131 return; 132 } 133 } 134 135 EmitAggLoadOfLValue(E); 136 } 137 138 void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); } 139 void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); } 140 void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); } 141 void VisitCompoundLiteralExpr(CompoundLiteralExpr *E); 142 void VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 143 EmitAggLoadOfLValue(E); 144 } 145 void VisitPredefinedExpr(const PredefinedExpr *E) { 146 EmitAggLoadOfLValue(E); 147 } 148 149 // Operators. 150 void VisitCastExpr(CastExpr *E); 151 void VisitCallExpr(const CallExpr *E); 152 void VisitStmtExpr(const StmtExpr *E); 153 void VisitBinaryOperator(const BinaryOperator *BO); 154 void VisitPointerToDataMemberBinaryOperator(const BinaryOperator *BO); 155 void VisitBinAssign(const BinaryOperator *E); 156 void VisitBinComma(const BinaryOperator *E); 157 158 void VisitObjCMessageExpr(ObjCMessageExpr *E); 159 void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 160 EmitAggLoadOfLValue(E); 161 } 162 163 void VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E); 164 void VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO); 165 void VisitChooseExpr(const ChooseExpr *CE); 166 void VisitInitListExpr(InitListExpr *E); 167 void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E); 168 void VisitNoInitExpr(NoInitExpr *E) { } // Do nothing. 169 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 170 Visit(DAE->getExpr()); 171 } 172 void VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) { 173 CodeGenFunction::CXXDefaultInitExprScope Scope(CGF); 174 Visit(DIE->getExpr()); 175 } 176 void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E); 177 void VisitCXXConstructExpr(const CXXConstructExpr *E); 178 void VisitLambdaExpr(LambdaExpr *E); 179 void VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E); 180 void VisitExprWithCleanups(ExprWithCleanups *E); 181 void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E); 182 void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); } 183 void VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E); 184 void VisitOpaqueValueExpr(OpaqueValueExpr *E); 185 186 void VisitPseudoObjectExpr(PseudoObjectExpr *E) { 187 if (E->isGLValue()) { 188 LValue LV = CGF.EmitPseudoObjectLValue(E); 189 return EmitFinalDestCopy(E->getType(), LV); 190 } 191 192 CGF.EmitPseudoObjectRValue(E, EnsureSlot(E->getType())); 193 } 194 195 void VisitVAArgExpr(VAArgExpr *E); 196 197 void EmitInitializationToLValue(Expr *E, LValue Address); 198 void EmitNullInitializationToLValue(LValue Address); 199 // case Expr::ChooseExprClass: 200 void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); } 201 void VisitAtomicExpr(AtomicExpr *E) { 202 RValue Res = CGF.EmitAtomicExpr(E); 203 EmitFinalDestCopy(E->getType(), Res); 204 } 205}; 206} // end anonymous namespace. 207 208//===----------------------------------------------------------------------===// 209// Utilities 210//===----------------------------------------------------------------------===// 211 212/// EmitAggLoadOfLValue - Given an expression with aggregate type that 213/// represents a value lvalue, this method emits the address of the lvalue, 214/// then loads the result into DestPtr. 215void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) { 216 LValue LV = CGF.EmitLValue(E); 217 218 // If the type of the l-value is atomic, then do an atomic load. 219 if (LV.getType()->isAtomicType() || CGF.LValueIsSuitableForInlineAtomic(LV)) { 220 CGF.EmitAtomicLoad(LV, E->getExprLoc(), Dest); 221 return; 222 } 223 224 EmitFinalDestCopy(E->getType(), LV); 225} 226 227/// \brief True if the given aggregate type requires special GC API calls. 228bool AggExprEmitter::TypeRequiresGCollection(QualType T) { 229 // Only record types have members that might require garbage collection. 230 const RecordType *RecordTy = T->getAs<RecordType>(); 231 if (!RecordTy) return false; 232 233 // Don't mess with non-trivial C++ types. 234 RecordDecl *Record = RecordTy->getDecl(); 235 if (isa<CXXRecordDecl>(Record) && 236 (cast<CXXRecordDecl>(Record)->hasNonTrivialCopyConstructor() || 237 !cast<CXXRecordDecl>(Record)->hasTrivialDestructor())) 238 return false; 239 240 // Check whether the type has an object member. 241 return Record->hasObjectMember(); 242} 243 244/// \brief Perform the final move to DestPtr if for some reason 245/// getReturnValueSlot() didn't use it directly. 246/// 247/// The idea is that you do something like this: 248/// RValue Result = EmitSomething(..., getReturnValueSlot()); 249/// EmitMoveFromReturnSlot(E, Result); 250/// 251/// If nothing interferes, this will cause the result to be emitted 252/// directly into the return value slot. Otherwise, a final move 253/// will be performed. 254void AggExprEmitter::EmitMoveFromReturnSlot(const Expr *E, RValue src) { 255 if (shouldUseDestForReturnSlot()) { 256 // Logically, Dest.getAddr() should equal Src.getAggregateAddr(). 257 // The possibility of undef rvalues complicates that a lot, 258 // though, so we can't really assert. 259 return; 260 } 261 262 // Otherwise, copy from there to the destination. 263 assert(Dest.getPointer() != src.getAggregatePointer()); 264 EmitFinalDestCopy(E->getType(), src); 265} 266 267/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired. 268void AggExprEmitter::EmitFinalDestCopy(QualType type, RValue src) { 269 assert(src.isAggregate() && "value must be aggregate value!"); 270 LValue srcLV = CGF.MakeAddrLValue(src.getAggregateAddress(), type); 271 EmitFinalDestCopy(type, srcLV); 272} 273 274/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired. 275void AggExprEmitter::EmitFinalDestCopy(QualType type, const LValue &src) { 276 // If Dest is ignored, then we're evaluating an aggregate expression 277 // in a context that doesn't care about the result. Note that loads 278 // from volatile l-values force the existence of a non-ignored 279 // destination. 280 if (Dest.isIgnored()) 281 return; 282 283 AggValueSlot srcAgg = 284 AggValueSlot::forLValue(src, AggValueSlot::IsDestructed, 285 needsGC(type), AggValueSlot::IsAliased); 286 EmitCopy(type, Dest, srcAgg); 287} 288 289/// Perform a copy from the source into the destination. 290/// 291/// \param type - the type of the aggregate being copied; qualifiers are 292/// ignored 293void AggExprEmitter::EmitCopy(QualType type, const AggValueSlot &dest, 294 const AggValueSlot &src) { 295 if (dest.requiresGCollection()) { 296 CharUnits sz = CGF.getContext().getTypeSizeInChars(type); 297 llvm::Value *size = llvm::ConstantInt::get(CGF.SizeTy, sz.getQuantity()); 298 CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF, 299 dest.getAddress(), 300 src.getAddress(), 301 size); 302 return; 303 } 304 305 // If the result of the assignment is used, copy the LHS there also. 306 // It's volatile if either side is. Use the minimum alignment of 307 // the two sides. 308 CGF.EmitAggregateCopy(dest.getAddress(), src.getAddress(), type, 309 dest.isVolatile() || src.isVolatile()); 310} 311 312/// \brief Emit the initializer for a std::initializer_list initialized with a 313/// real initializer list. 314void 315AggExprEmitter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { 316 // Emit an array containing the elements. The array is externally destructed 317 // if the std::initializer_list object is. 318 ASTContext &Ctx = CGF.getContext(); 319 LValue Array = CGF.EmitLValue(E->getSubExpr()); 320 assert(Array.isSimple() && "initializer_list array not a simple lvalue"); 321 Address ArrayPtr = Array.getAddress(); 322 323 const ConstantArrayType *ArrayType = 324 Ctx.getAsConstantArrayType(E->getSubExpr()->getType()); 325 assert(ArrayType && "std::initializer_list constructed from non-array"); 326 327 // FIXME: Perform the checks on the field types in SemaInit. 328 RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl(); 329 RecordDecl::field_iterator Field = Record->field_begin(); 330 if (Field == Record->field_end()) { 331 CGF.ErrorUnsupported(E, "weird std::initializer_list"); 332 return; 333 } 334 335 // Start pointer. 336 if (!Field->getType()->isPointerType() || 337 !Ctx.hasSameType(Field->getType()->getPointeeType(), 338 ArrayType->getElementType())) { 339 CGF.ErrorUnsupported(E, "weird std::initializer_list"); 340 return; 341 } 342 343 AggValueSlot Dest = EnsureSlot(E->getType()); 344 LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType()); 345 LValue Start = CGF.EmitLValueForFieldInitialization(DestLV, *Field); 346 llvm::Value *Zero = llvm::ConstantInt::get(CGF.PtrDiffTy, 0); 347 llvm::Value *IdxStart[] = { Zero, Zero }; 348 llvm::Value *ArrayStart = 349 Builder.CreateInBoundsGEP(ArrayPtr.getPointer(), IdxStart, "arraystart"); 350 CGF.EmitStoreThroughLValue(RValue::get(ArrayStart), Start); 351 ++Field; 352 353 if (Field == Record->field_end()) { 354 CGF.ErrorUnsupported(E, "weird std::initializer_list"); 355 return; 356 } 357 358 llvm::Value *Size = Builder.getInt(ArrayType->getSize()); 359 LValue EndOrLength = CGF.EmitLValueForFieldInitialization(DestLV, *Field); 360 if (Field->getType()->isPointerType() && 361 Ctx.hasSameType(Field->getType()->getPointeeType(), 362 ArrayType->getElementType())) { 363 // End pointer. 364 llvm::Value *IdxEnd[] = { Zero, Size }; 365 llvm::Value *ArrayEnd = 366 Builder.CreateInBoundsGEP(ArrayPtr.getPointer(), IdxEnd, "arrayend"); 367 CGF.EmitStoreThroughLValue(RValue::get(ArrayEnd), EndOrLength); 368 } else if (Ctx.hasSameType(Field->getType(), Ctx.getSizeType())) { 369 // Length. 370 CGF.EmitStoreThroughLValue(RValue::get(Size), EndOrLength); 371 } else { 372 CGF.ErrorUnsupported(E, "weird std::initializer_list"); 373 return; 374 } 375} 376 377/// \brief Determine if E is a trivial array filler, that is, one that is 378/// equivalent to zero-initialization. 379static bool isTrivialFiller(Expr *E) { 380 if (!E) 381 return true; 382 383 if (isa<ImplicitValueInitExpr>(E)) 384 return true; 385 386 if (auto *ILE = dyn_cast<InitListExpr>(E)) { 387 if (ILE->getNumInits()) 388 return false; 389 return isTrivialFiller(ILE->getArrayFiller()); 390 } 391 392 if (auto *Cons = dyn_cast_or_null<CXXConstructExpr>(E)) 393 return Cons->getConstructor()->isDefaultConstructor() && 394 Cons->getConstructor()->isTrivial(); 395 396 // FIXME: Are there other cases where we can avoid emitting an initializer? 397 return false; 398} 399 400/// \brief Emit initialization of an array from an initializer list. 401void AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType, 402 QualType elementType, InitListExpr *E) { 403 uint64_t NumInitElements = E->getNumInits(); 404 405 uint64_t NumArrayElements = AType->getNumElements(); 406 assert(NumInitElements <= NumArrayElements); 407 408 // DestPtr is an array*. Construct an elementType* by drilling 409 // down a level. 410 llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0); 411 llvm::Value *indices[] = { zero, zero }; 412 llvm::Value *begin = 413 Builder.CreateInBoundsGEP(DestPtr.getPointer(), indices, "arrayinit.begin"); 414 415 CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType); 416 CharUnits elementAlign = 417 DestPtr.getAlignment().alignmentOfArrayElement(elementSize); 418 419 // Exception safety requires us to destroy all the 420 // already-constructed members if an initializer throws. 421 // For that, we'll need an EH cleanup. 422 QualType::DestructionKind dtorKind = elementType.isDestructedType(); 423 Address endOfInit = Address::invalid(); 424 EHScopeStack::stable_iterator cleanup; 425 llvm::Instruction *cleanupDominator = nullptr; 426 if (CGF.needsEHCleanup(dtorKind)) { 427 // In principle we could tell the cleanup where we are more 428 // directly, but the control flow can get so varied here that it 429 // would actually be quite complex. Therefore we go through an 430 // alloca. 431 endOfInit = CGF.CreateTempAlloca(begin->getType(), CGF.getPointerAlign(), 432 "arrayinit.endOfInit"); 433 cleanupDominator = Builder.CreateStore(begin, endOfInit); 434 CGF.pushIrregularPartialArrayCleanup(begin, endOfInit, elementType, 435 elementAlign, 436 CGF.getDestroyer(dtorKind)); 437 cleanup = CGF.EHStack.stable_begin(); 438 439 // Otherwise, remember that we didn't need a cleanup. 440 } else { 441 dtorKind = QualType::DK_none; 442 } 443 444 llvm::Value *one = llvm::ConstantInt::get(CGF.SizeTy, 1); 445 446 // The 'current element to initialize'. The invariants on this 447 // variable are complicated. Essentially, after each iteration of 448 // the loop, it points to the last initialized element, except 449 // that it points to the beginning of the array before any 450 // elements have been initialized. 451 llvm::Value *element = begin; 452 453 // Emit the explicit initializers. 454 for (uint64_t i = 0; i != NumInitElements; ++i) { 455 // Advance to the next element. 456 if (i > 0) { 457 element = Builder.CreateInBoundsGEP(element, one, "arrayinit.element"); 458 459 // Tell the cleanup that it needs to destroy up to this 460 // element. TODO: some of these stores can be trivially 461 // observed to be unnecessary. 462 if (endOfInit.isValid()) Builder.CreateStore(element, endOfInit); 463 } 464 465 LValue elementLV = 466 CGF.MakeAddrLValue(Address(element, elementAlign), elementType); 467 EmitInitializationToLValue(E->getInit(i), elementLV); 468 } 469 470 // Check whether there's a non-trivial array-fill expression. 471 Expr *filler = E->getArrayFiller(); 472 bool hasTrivialFiller = isTrivialFiller(filler); 473 474 // Any remaining elements need to be zero-initialized, possibly 475 // using the filler expression. We can skip this if the we're 476 // emitting to zeroed memory. 477 if (NumInitElements != NumArrayElements && 478 !(Dest.isZeroed() && hasTrivialFiller && 479 CGF.getTypes().isZeroInitializable(elementType))) { 480 481 // Use an actual loop. This is basically 482 // do { *array++ = filler; } while (array != end); 483 484 // Advance to the start of the rest of the array. 485 if (NumInitElements) { 486 element = Builder.CreateInBoundsGEP(element, one, "arrayinit.start"); 487 if (endOfInit.isValid()) Builder.CreateStore(element, endOfInit); 488 } 489 490 // Compute the end of the array. 491 llvm::Value *end = Builder.CreateInBoundsGEP(begin, 492 llvm::ConstantInt::get(CGF.SizeTy, NumArrayElements), 493 "arrayinit.end"); 494 495 llvm::BasicBlock *entryBB = Builder.GetInsertBlock(); 496 llvm::BasicBlock *bodyBB = CGF.createBasicBlock("arrayinit.body"); 497 498 // Jump into the body. 499 CGF.EmitBlock(bodyBB); 500 llvm::PHINode *currentElement = 501 Builder.CreatePHI(element->getType(), 2, "arrayinit.cur"); 502 currentElement->addIncoming(element, entryBB); 503 504 // Emit the actual filler expression. 505 LValue elementLV = 506 CGF.MakeAddrLValue(Address(currentElement, elementAlign), elementType); 507 if (filler) 508 EmitInitializationToLValue(filler, elementLV); 509 else 510 EmitNullInitializationToLValue(elementLV); 511 512 // Move on to the next element. 513 llvm::Value *nextElement = 514 Builder.CreateInBoundsGEP(currentElement, one, "arrayinit.next"); 515 516 // Tell the EH cleanup that we finished with the last element. 517 if (endOfInit.isValid()) Builder.CreateStore(nextElement, endOfInit); 518 519 // Leave the loop if we're done. 520 llvm::Value *done = Builder.CreateICmpEQ(nextElement, end, 521 "arrayinit.done"); 522 llvm::BasicBlock *endBB = CGF.createBasicBlock("arrayinit.end"); 523 Builder.CreateCondBr(done, endBB, bodyBB); 524 currentElement->addIncoming(nextElement, Builder.GetInsertBlock()); 525 526 CGF.EmitBlock(endBB); 527 } 528 529 // Leave the partial-array cleanup if we entered one. 530 if (dtorKind) CGF.DeactivateCleanupBlock(cleanup, cleanupDominator); 531} 532 533//===----------------------------------------------------------------------===// 534// Visitor Methods 535//===----------------------------------------------------------------------===// 536 537void AggExprEmitter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E){ 538 Visit(E->GetTemporaryExpr()); 539} 540 541void AggExprEmitter::VisitOpaqueValueExpr(OpaqueValueExpr *e) { 542 EmitFinalDestCopy(e->getType(), CGF.getOpaqueLValueMapping(e)); 543} 544 545void 546AggExprEmitter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 547 if (Dest.isPotentiallyAliased() && 548 E->getType().isPODType(CGF.getContext())) { 549 // For a POD type, just emit a load of the lvalue + a copy, because our 550 // compound literal might alias the destination. 551 EmitAggLoadOfLValue(E); 552 return; 553 } 554 555 AggValueSlot Slot = EnsureSlot(E->getType()); 556 CGF.EmitAggExpr(E->getInitializer(), Slot); 557} 558 559/// Attempt to look through various unimportant expressions to find a 560/// cast of the given kind. 561static Expr *findPeephole(Expr *op, CastKind kind) { 562 while (true) { 563 op = op->IgnoreParens(); 564 if (CastExpr *castE = dyn_cast<CastExpr>(op)) { 565 if (castE->getCastKind() == kind) 566 return castE->getSubExpr(); 567 if (castE->getCastKind() == CK_NoOp) 568 continue; 569 } 570 return nullptr; 571 } 572} 573 574void AggExprEmitter::VisitCastExpr(CastExpr *E) { 575 if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E)) 576 CGF.CGM.EmitExplicitCastExprType(ECE, &CGF); 577 switch (E->getCastKind()) { 578 case CK_Dynamic: { 579 // FIXME: Can this actually happen? We have no test coverage for it. 580 assert(isa<CXXDynamicCastExpr>(E) && "CK_Dynamic without a dynamic_cast?"); 581 LValue LV = CGF.EmitCheckedLValue(E->getSubExpr(), 582 CodeGenFunction::TCK_Load); 583 // FIXME: Do we also need to handle property references here? 584 if (LV.isSimple()) 585 CGF.EmitDynamicCast(LV.getAddress(), cast<CXXDynamicCastExpr>(E)); 586 else 587 CGF.CGM.ErrorUnsupported(E, "non-simple lvalue dynamic_cast"); 588 589 if (!Dest.isIgnored()) 590 CGF.CGM.ErrorUnsupported(E, "lvalue dynamic_cast with a destination"); 591 break; 592 } 593 594 case CK_ToUnion: { 595 // Evaluate even if the destination is ignored. 596 if (Dest.isIgnored()) { 597 CGF.EmitAnyExpr(E->getSubExpr(), AggValueSlot::ignored(), 598 /*ignoreResult=*/true); 599 break; 600 } 601 602 // GCC union extension 603 QualType Ty = E->getSubExpr()->getType(); 604 Address CastPtr = 605 Builder.CreateElementBitCast(Dest.getAddress(), CGF.ConvertType(Ty)); 606 EmitInitializationToLValue(E->getSubExpr(), 607 CGF.MakeAddrLValue(CastPtr, Ty)); 608 break; 609 } 610 611 case CK_DerivedToBase: 612 case CK_BaseToDerived: 613 case CK_UncheckedDerivedToBase: { 614 llvm_unreachable("cannot perform hierarchy conversion in EmitAggExpr: " 615 "should have been unpacked before we got here"); 616 } 617 618 case CK_NonAtomicToAtomic: 619 case CK_AtomicToNonAtomic: { 620 bool isToAtomic = (E->getCastKind() == CK_NonAtomicToAtomic); 621 622 // Determine the atomic and value types. 623 QualType atomicType = E->getSubExpr()->getType(); 624 QualType valueType = E->getType(); 625 if (isToAtomic) std::swap(atomicType, valueType); 626 627 assert(atomicType->isAtomicType()); 628 assert(CGF.getContext().hasSameUnqualifiedType(valueType, 629 atomicType->castAs<AtomicType>()->getValueType())); 630 631 // Just recurse normally if we're ignoring the result or the 632 // atomic type doesn't change representation. 633 if (Dest.isIgnored() || !CGF.CGM.isPaddedAtomicType(atomicType)) { 634 return Visit(E->getSubExpr()); 635 } 636 637 CastKind peepholeTarget = 638 (isToAtomic ? CK_AtomicToNonAtomic : CK_NonAtomicToAtomic); 639 640 // These two cases are reverses of each other; try to peephole them. 641 if (Expr *op = findPeephole(E->getSubExpr(), peepholeTarget)) { 642 assert(CGF.getContext().hasSameUnqualifiedType(op->getType(), 643 E->getType()) && 644 "peephole significantly changed types?"); 645 return Visit(op); 646 } 647 648 // If we're converting an r-value of non-atomic type to an r-value 649 // of atomic type, just emit directly into the relevant sub-object. 650 if (isToAtomic) { 651 AggValueSlot valueDest = Dest; 652 if (!valueDest.isIgnored() && CGF.CGM.isPaddedAtomicType(atomicType)) { 653 // Zero-initialize. (Strictly speaking, we only need to intialize 654 // the padding at the end, but this is simpler.) 655 if (!Dest.isZeroed()) 656 CGF.EmitNullInitialization(Dest.getAddress(), atomicType); 657 658 // Build a GEP to refer to the subobject. 659 Address valueAddr = 660 CGF.Builder.CreateStructGEP(valueDest.getAddress(), 0, 661 CharUnits()); 662 valueDest = AggValueSlot::forAddr(valueAddr, 663 valueDest.getQualifiers(), 664 valueDest.isExternallyDestructed(), 665 valueDest.requiresGCollection(), 666 valueDest.isPotentiallyAliased(), 667 AggValueSlot::IsZeroed); 668 } 669 670 CGF.EmitAggExpr(E->getSubExpr(), valueDest); 671 return; 672 } 673 674 // Otherwise, we're converting an atomic type to a non-atomic type. 675 // Make an atomic temporary, emit into that, and then copy the value out. 676 AggValueSlot atomicSlot = 677 CGF.CreateAggTemp(atomicType, "atomic-to-nonatomic.temp"); 678 CGF.EmitAggExpr(E->getSubExpr(), atomicSlot); 679 680 Address valueAddr = 681 Builder.CreateStructGEP(atomicSlot.getAddress(), 0, CharUnits()); 682 RValue rvalue = RValue::getAggregate(valueAddr, atomicSlot.isVolatile()); 683 return EmitFinalDestCopy(valueType, rvalue); 684 } 685 686 case CK_LValueToRValue: 687 // If we're loading from a volatile type, force the destination 688 // into existence. 689 if (E->getSubExpr()->getType().isVolatileQualified()) { 690 EnsureDest(E->getType()); 691 return Visit(E->getSubExpr()); 692 } 693 694 // fallthrough 695 696 case CK_NoOp: 697 case CK_UserDefinedConversion: 698 case CK_ConstructorConversion: 699 assert(CGF.getContext().hasSameUnqualifiedType(E->getSubExpr()->getType(), 700 E->getType()) && 701 "Implicit cast types must be compatible"); 702 Visit(E->getSubExpr()); 703 break; 704 705 case CK_LValueBitCast: 706 llvm_unreachable("should not be emitting lvalue bitcast as rvalue"); 707 708 case CK_Dependent: 709 case CK_BitCast: 710 case CK_ArrayToPointerDecay: 711 case CK_FunctionToPointerDecay: 712 case CK_NullToPointer: 713 case CK_NullToMemberPointer: 714 case CK_BaseToDerivedMemberPointer: 715 case CK_DerivedToBaseMemberPointer: 716 case CK_MemberPointerToBoolean: 717 case CK_ReinterpretMemberPointer: 718 case CK_IntegralToPointer: 719 case CK_PointerToIntegral: 720 case CK_PointerToBoolean: 721 case CK_ToVoid: 722 case CK_VectorSplat: 723 case CK_IntegralCast: 724 case CK_BooleanToSignedIntegral: 725 case CK_IntegralToBoolean: 726 case CK_IntegralToFloating: 727 case CK_FloatingToIntegral: 728 case CK_FloatingToBoolean: 729 case CK_FloatingCast: 730 case CK_CPointerToObjCPointerCast: 731 case CK_BlockPointerToObjCPointerCast: 732 case CK_AnyPointerToBlockPointerCast: 733 case CK_ObjCObjectLValueCast: 734 case CK_FloatingRealToComplex: 735 case CK_FloatingComplexToReal: 736 case CK_FloatingComplexToBoolean: 737 case CK_FloatingComplexCast: 738 case CK_FloatingComplexToIntegralComplex: 739 case CK_IntegralRealToComplex: 740 case CK_IntegralComplexToReal: 741 case CK_IntegralComplexToBoolean: 742 case CK_IntegralComplexCast: 743 case CK_IntegralComplexToFloatingComplex: 744 case CK_ARCProduceObject: 745 case CK_ARCConsumeObject: 746 case CK_ARCReclaimReturnedObject: 747 case CK_ARCExtendBlockObject: 748 case CK_CopyAndAutoreleaseBlockObject: 749 case CK_BuiltinFnToFnPtr: 750 case CK_ZeroToOCLEvent: 751 case CK_AddressSpaceConversion: 752 llvm_unreachable("cast kind invalid for aggregate types"); 753 } 754} 755 756void AggExprEmitter::VisitCallExpr(const CallExpr *E) { 757 if (E->getCallReturnType(CGF.getContext())->isReferenceType()) { 758 EmitAggLoadOfLValue(E); 759 return; 760 } 761 762 RValue RV = CGF.EmitCallExpr(E, getReturnValueSlot()); 763 EmitMoveFromReturnSlot(E, RV); 764} 765 766void AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) { 767 RValue RV = CGF.EmitObjCMessageExpr(E, getReturnValueSlot()); 768 EmitMoveFromReturnSlot(E, RV); 769} 770 771void AggExprEmitter::VisitBinComma(const BinaryOperator *E) { 772 CGF.EmitIgnoredExpr(E->getLHS()); 773 Visit(E->getRHS()); 774} 775 776void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) { 777 CodeGenFunction::StmtExprEvaluation eval(CGF); 778 CGF.EmitCompoundStmt(*E->getSubStmt(), true, Dest); 779} 780 781void AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) { 782 if (E->getOpcode() == BO_PtrMemD || E->getOpcode() == BO_PtrMemI) 783 VisitPointerToDataMemberBinaryOperator(E); 784 else 785 CGF.ErrorUnsupported(E, "aggregate binary expression"); 786} 787 788void AggExprEmitter::VisitPointerToDataMemberBinaryOperator( 789 const BinaryOperator *E) { 790 LValue LV = CGF.EmitPointerToDataMemberBinaryExpr(E); 791 EmitFinalDestCopy(E->getType(), LV); 792} 793 794/// Is the value of the given expression possibly a reference to or 795/// into a __block variable? 796static bool isBlockVarRef(const Expr *E) { 797 // Make sure we look through parens. 798 E = E->IgnoreParens(); 799 800 // Check for a direct reference to a __block variable. 801 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) { 802 const VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl()); 803 return (var && var->hasAttr<BlocksAttr>()); 804 } 805 806 // More complicated stuff. 807 808 // Binary operators. 809 if (const BinaryOperator *op = dyn_cast<BinaryOperator>(E)) { 810 // For an assignment or pointer-to-member operation, just care 811 // about the LHS. 812 if (op->isAssignmentOp() || op->isPtrMemOp()) 813 return isBlockVarRef(op->getLHS()); 814 815 // For a comma, just care about the RHS. 816 if (op->getOpcode() == BO_Comma) 817 return isBlockVarRef(op->getRHS()); 818 819 // FIXME: pointer arithmetic? 820 return false; 821 822 // Check both sides of a conditional operator. 823 } else if (const AbstractConditionalOperator *op 824 = dyn_cast<AbstractConditionalOperator>(E)) { 825 return isBlockVarRef(op->getTrueExpr()) 826 || isBlockVarRef(op->getFalseExpr()); 827 828 // OVEs are required to support BinaryConditionalOperators. 829 } else if (const OpaqueValueExpr *op 830 = dyn_cast<OpaqueValueExpr>(E)) { 831 if (const Expr *src = op->getSourceExpr()) 832 return isBlockVarRef(src); 833 834 // Casts are necessary to get things like (*(int*)&var) = foo(). 835 // We don't really care about the kind of cast here, except 836 // we don't want to look through l2r casts, because it's okay 837 // to get the *value* in a __block variable. 838 } else if (const CastExpr *cast = dyn_cast<CastExpr>(E)) { 839 if (cast->getCastKind() == CK_LValueToRValue) 840 return false; 841 return isBlockVarRef(cast->getSubExpr()); 842 843 // Handle unary operators. Again, just aggressively look through 844 // it, ignoring the operation. 845 } else if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E)) { 846 return isBlockVarRef(uop->getSubExpr()); 847 848 // Look into the base of a field access. 849 } else if (const MemberExpr *mem = dyn_cast<MemberExpr>(E)) { 850 return isBlockVarRef(mem->getBase()); 851 852 // Look into the base of a subscript. 853 } else if (const ArraySubscriptExpr *sub = dyn_cast<ArraySubscriptExpr>(E)) { 854 return isBlockVarRef(sub->getBase()); 855 } 856 857 return false; 858} 859 860void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) { 861 // For an assignment to work, the value on the right has 862 // to be compatible with the value on the left. 863 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(), 864 E->getRHS()->getType()) 865 && "Invalid assignment"); 866 867 // If the LHS might be a __block variable, and the RHS can 868 // potentially cause a block copy, we need to evaluate the RHS first 869 // so that the assignment goes the right place. 870 // This is pretty semantically fragile. 871 if (isBlockVarRef(E->getLHS()) && 872 E->getRHS()->HasSideEffects(CGF.getContext())) { 873 // Ensure that we have a destination, and evaluate the RHS into that. 874 EnsureDest(E->getRHS()->getType()); 875 Visit(E->getRHS()); 876 877 // Now emit the LHS and copy into it. 878 LValue LHS = CGF.EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store); 879 880 // That copy is an atomic copy if the LHS is atomic. 881 if (LHS.getType()->isAtomicType() || 882 CGF.LValueIsSuitableForInlineAtomic(LHS)) { 883 CGF.EmitAtomicStore(Dest.asRValue(), LHS, /*isInit*/ false); 884 return; 885 } 886 887 EmitCopy(E->getLHS()->getType(), 888 AggValueSlot::forLValue(LHS, AggValueSlot::IsDestructed, 889 needsGC(E->getLHS()->getType()), 890 AggValueSlot::IsAliased), 891 Dest); 892 return; 893 } 894 895 LValue LHS = CGF.EmitLValue(E->getLHS()); 896 897 // If we have an atomic type, evaluate into the destination and then 898 // do an atomic copy. 899 if (LHS.getType()->isAtomicType() || 900 CGF.LValueIsSuitableForInlineAtomic(LHS)) { 901 EnsureDest(E->getRHS()->getType()); 902 Visit(E->getRHS()); 903 CGF.EmitAtomicStore(Dest.asRValue(), LHS, /*isInit*/ false); 904 return; 905 } 906 907 // Codegen the RHS so that it stores directly into the LHS. 908 AggValueSlot LHSSlot = 909 AggValueSlot::forLValue(LHS, AggValueSlot::IsDestructed, 910 needsGC(E->getLHS()->getType()), 911 AggValueSlot::IsAliased); 912 // A non-volatile aggregate destination might have volatile member. 913 if (!LHSSlot.isVolatile() && 914 CGF.hasVolatileMember(E->getLHS()->getType())) 915 LHSSlot.setVolatile(true); 916 917 CGF.EmitAggExpr(E->getRHS(), LHSSlot); 918 919 // Copy into the destination if the assignment isn't ignored. 920 EmitFinalDestCopy(E->getType(), LHS); 921} 922 923void AggExprEmitter:: 924VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 925 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 926 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 927 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 928 929 // Bind the common expression if necessary. 930 CodeGenFunction::OpaqueValueMapping binding(CGF, E); 931 932 CodeGenFunction::ConditionalEvaluation eval(CGF); 933 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock, 934 CGF.getProfileCount(E)); 935 936 // Save whether the destination's lifetime is externally managed. 937 bool isExternallyDestructed = Dest.isExternallyDestructed(); 938 939 eval.begin(CGF); 940 CGF.EmitBlock(LHSBlock); 941 CGF.incrementProfileCounter(E); 942 Visit(E->getTrueExpr()); 943 eval.end(CGF); 944 945 assert(CGF.HaveInsertPoint() && "expression evaluation ended with no IP!"); 946 CGF.Builder.CreateBr(ContBlock); 947 948 // If the result of an agg expression is unused, then the emission 949 // of the LHS might need to create a destination slot. That's fine 950 // with us, and we can safely emit the RHS into the same slot, but 951 // we shouldn't claim that it's already being destructed. 952 Dest.setExternallyDestructed(isExternallyDestructed); 953 954 eval.begin(CGF); 955 CGF.EmitBlock(RHSBlock); 956 Visit(E->getFalseExpr()); 957 eval.end(CGF); 958 959 CGF.EmitBlock(ContBlock); 960} 961 962void AggExprEmitter::VisitChooseExpr(const ChooseExpr *CE) { 963 Visit(CE->getChosenSubExpr()); 964} 965 966void AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 967 Address ArgValue = Address::invalid(); 968 Address ArgPtr = CGF.EmitVAArg(VE, ArgValue); 969 970 if (!ArgPtr.isValid()) { 971 // If EmitVAArg fails, we fall back to the LLVM instruction. 972 llvm::Value *Val = Builder.CreateVAArg(ArgValue.getPointer(), 973 CGF.ConvertType(VE->getType())); 974 if (!Dest.isIgnored()) 975 Builder.CreateStore(Val, Dest.getAddress()); 976 return; 977 } 978 979 EmitFinalDestCopy(VE->getType(), CGF.MakeAddrLValue(ArgPtr, VE->getType())); 980} 981 982void AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 983 // Ensure that we have a slot, but if we already do, remember 984 // whether it was externally destructed. 985 bool wasExternallyDestructed = Dest.isExternallyDestructed(); 986 EnsureDest(E->getType()); 987 988 // We're going to push a destructor if there isn't already one. 989 Dest.setExternallyDestructed(); 990 991 Visit(E->getSubExpr()); 992 993 // Push that destructor we promised. 994 if (!wasExternallyDestructed) 995 CGF.EmitCXXTemporary(E->getTemporary(), E->getType(), Dest.getAddress()); 996} 997 998void 999AggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) { 1000 AggValueSlot Slot = EnsureSlot(E->getType()); 1001 CGF.EmitCXXConstructExpr(E, Slot); 1002} 1003 1004void 1005AggExprEmitter::VisitLambdaExpr(LambdaExpr *E) { 1006 AggValueSlot Slot = EnsureSlot(E->getType()); 1007 CGF.EmitLambdaExpr(E, Slot); 1008} 1009 1010void AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) { 1011 CGF.enterFullExpression(E); 1012 CodeGenFunction::RunCleanupsScope cleanups(CGF); 1013 Visit(E->getSubExpr()); 1014} 1015 1016void AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 1017 QualType T = E->getType(); 1018 AggValueSlot Slot = EnsureSlot(T); 1019 EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddress(), T)); 1020} 1021 1022void AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 1023 QualType T = E->getType(); 1024 AggValueSlot Slot = EnsureSlot(T); 1025 EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddress(), T)); 1026} 1027 1028/// isSimpleZero - If emitting this value will obviously just cause a store of 1029/// zero to memory, return true. This can return false if uncertain, so it just 1030/// handles simple cases. 1031static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) { 1032 E = E->IgnoreParens(); 1033 1034 // 0 1035 if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E)) 1036 return IL->getValue() == 0; 1037 // +0.0 1038 if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E)) 1039 return FL->getValue().isPosZero(); 1040 // int() 1041 if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) && 1042 CGF.getTypes().isZeroInitializable(E->getType())) 1043 return true; 1044 // (int*)0 - Null pointer expressions. 1045 if (const CastExpr *ICE = dyn_cast<CastExpr>(E)) 1046 return ICE->getCastKind() == CK_NullToPointer; 1047 // '\0' 1048 if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E)) 1049 return CL->getValue() == 0; 1050 1051 // Otherwise, hard case: conservatively return false. 1052 return false; 1053} 1054 1055 1056void 1057AggExprEmitter::EmitInitializationToLValue(Expr *E, LValue LV) { 1058 QualType type = LV.getType(); 1059 // FIXME: Ignore result? 1060 // FIXME: Are initializers affected by volatile? 1061 if (Dest.isZeroed() && isSimpleZero(E, CGF)) { 1062 // Storing "i32 0" to a zero'd memory location is a noop. 1063 return; 1064 } else if (isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) { 1065 return EmitNullInitializationToLValue(LV); 1066 } else if (isa<NoInitExpr>(E)) { 1067 // Do nothing. 1068 return; 1069 } else if (type->isReferenceType()) { 1070 RValue RV = CGF.EmitReferenceBindingToExpr(E); 1071 return CGF.EmitStoreThroughLValue(RV, LV); 1072 } 1073 1074 switch (CGF.getEvaluationKind(type)) { 1075 case TEK_Complex: 1076 CGF.EmitComplexExprIntoLValue(E, LV, /*isInit*/ true); 1077 return; 1078 case TEK_Aggregate: 1079 CGF.EmitAggExpr(E, AggValueSlot::forLValue(LV, 1080 AggValueSlot::IsDestructed, 1081 AggValueSlot::DoesNotNeedGCBarriers, 1082 AggValueSlot::IsNotAliased, 1083 Dest.isZeroed())); 1084 return; 1085 case TEK_Scalar: 1086 if (LV.isSimple()) { 1087 CGF.EmitScalarInit(E, /*D=*/nullptr, LV, /*Captured=*/false); 1088 } else { 1089 CGF.EmitStoreThroughLValue(RValue::get(CGF.EmitScalarExpr(E)), LV); 1090 } 1091 return; 1092 } 1093 llvm_unreachable("bad evaluation kind"); 1094} 1095 1096void AggExprEmitter::EmitNullInitializationToLValue(LValue lv) { 1097 QualType type = lv.getType(); 1098 1099 // If the destination slot is already zeroed out before the aggregate is 1100 // copied into it, we don't have to emit any zeros here. 1101 if (Dest.isZeroed() && CGF.getTypes().isZeroInitializable(type)) 1102 return; 1103 1104 if (CGF.hasScalarEvaluationKind(type)) { 1105 // For non-aggregates, we can store the appropriate null constant. 1106 llvm::Value *null = CGF.CGM.EmitNullConstant(type); 1107 // Note that the following is not equivalent to 1108 // EmitStoreThroughBitfieldLValue for ARC types. 1109 if (lv.isBitField()) { 1110 CGF.EmitStoreThroughBitfieldLValue(RValue::get(null), lv); 1111 } else { 1112 assert(lv.isSimple()); 1113 CGF.EmitStoreOfScalar(null, lv, /* isInitialization */ true); 1114 } 1115 } else { 1116 // There's a potential optimization opportunity in combining 1117 // memsets; that would be easy for arrays, but relatively 1118 // difficult for structures with the current code. 1119 CGF.EmitNullInitialization(lv.getAddress(), lv.getType()); 1120 } 1121} 1122 1123void AggExprEmitter::VisitInitListExpr(InitListExpr *E) { 1124#if 0 1125 // FIXME: Assess perf here? Figure out what cases are worth optimizing here 1126 // (Length of globals? Chunks of zeroed-out space?). 1127 // 1128 // If we can, prefer a copy from a global; this is a lot less code for long 1129 // globals, and it's easier for the current optimizers to analyze. 1130 if (llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, E->getType(), &CGF)) { 1131 llvm::GlobalVariable* GV = 1132 new llvm::GlobalVariable(CGF.CGM.getModule(), C->getType(), true, 1133 llvm::GlobalValue::InternalLinkage, C, ""); 1134 EmitFinalDestCopy(E->getType(), CGF.MakeAddrLValue(GV, E->getType())); 1135 return; 1136 } 1137#endif 1138 if (E->hadArrayRangeDesignator()) 1139 CGF.ErrorUnsupported(E, "GNU array range designator extension"); 1140 1141 AggValueSlot Dest = EnsureSlot(E->getType()); 1142 1143 LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType()); 1144 1145 // Handle initialization of an array. 1146 if (E->getType()->isArrayType()) { 1147 if (E->isStringLiteralInit()) 1148 return Visit(E->getInit(0)); 1149 1150 QualType elementType = 1151 CGF.getContext().getAsArrayType(E->getType())->getElementType(); 1152 1153 auto AType = cast<llvm::ArrayType>(Dest.getAddress().getElementType()); 1154 EmitArrayInit(Dest.getAddress(), AType, elementType, E); 1155 return; 1156 } 1157 1158 if (E->getType()->isAtomicType()) { 1159 // An _Atomic(T) object can be list-initialized from an expression 1160 // of the same type. 1161 assert(E->getNumInits() == 1 && 1162 CGF.getContext().hasSameUnqualifiedType(E->getInit(0)->getType(), 1163 E->getType()) && 1164 "unexpected list initialization for atomic object"); 1165 return Visit(E->getInit(0)); 1166 } 1167 1168 assert(E->getType()->isRecordType() && "Only support structs/unions here!"); 1169 1170 // Do struct initialization; this code just sets each individual member 1171 // to the approprate value. This makes bitfield support automatic; 1172 // the disadvantage is that the generated code is more difficult for 1173 // the optimizer, especially with bitfields. 1174 unsigned NumInitElements = E->getNumInits(); 1175 RecordDecl *record = E->getType()->castAs<RecordType>()->getDecl(); 1176 1177 // Prepare a 'this' for CXXDefaultInitExprs. 1178 CodeGenFunction::FieldConstructionScope FCS(CGF, Dest.getAddress()); 1179 1180 if (record->isUnion()) { 1181 // Only initialize one field of a union. The field itself is 1182 // specified by the initializer list. 1183 if (!E->getInitializedFieldInUnion()) { 1184 // Empty union; we have nothing to do. 1185 1186#ifndef NDEBUG 1187 // Make sure that it's really an empty and not a failure of 1188 // semantic analysis. 1189 for (const auto *Field : record->fields()) 1190 assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed"); 1191#endif 1192 return; 1193 } 1194 1195 // FIXME: volatility 1196 FieldDecl *Field = E->getInitializedFieldInUnion(); 1197 1198 LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestLV, Field); 1199 if (NumInitElements) { 1200 // Store the initializer into the field 1201 EmitInitializationToLValue(E->getInit(0), FieldLoc); 1202 } else { 1203 // Default-initialize to null. 1204 EmitNullInitializationToLValue(FieldLoc); 1205 } 1206 1207 return; 1208 } 1209 1210 // We'll need to enter cleanup scopes in case any of the member 1211 // initializers throw an exception. 1212 SmallVector<EHScopeStack::stable_iterator, 16> cleanups; 1213 llvm::Instruction *cleanupDominator = nullptr; 1214 1215 // Here we iterate over the fields; this makes it simpler to both 1216 // default-initialize fields and skip over unnamed fields. 1217 unsigned curInitIndex = 0; 1218 for (const auto *field : record->fields()) { 1219 // We're done once we hit the flexible array member. 1220 if (field->getType()->isIncompleteArrayType()) 1221 break; 1222 1223 // Always skip anonymous bitfields. 1224 if (field->isUnnamedBitfield()) 1225 continue; 1226 1227 // We're done if we reach the end of the explicit initializers, we 1228 // have a zeroed object, and the rest of the fields are 1229 // zero-initializable. 1230 if (curInitIndex == NumInitElements && Dest.isZeroed() && 1231 CGF.getTypes().isZeroInitializable(E->getType())) 1232 break; 1233 1234 1235 LValue LV = CGF.EmitLValueForFieldInitialization(DestLV, field); 1236 // We never generate write-barries for initialized fields. 1237 LV.setNonGC(true); 1238 1239 if (curInitIndex < NumInitElements) { 1240 // Store the initializer into the field. 1241 EmitInitializationToLValue(E->getInit(curInitIndex++), LV); 1242 } else { 1243 // We're out of initalizers; default-initialize to null 1244 EmitNullInitializationToLValue(LV); 1245 } 1246 1247 // Push a destructor if necessary. 1248 // FIXME: if we have an array of structures, all explicitly 1249 // initialized, we can end up pushing a linear number of cleanups. 1250 bool pushedCleanup = false; 1251 if (QualType::DestructionKind dtorKind 1252 = field->getType().isDestructedType()) { 1253 assert(LV.isSimple()); 1254 if (CGF.needsEHCleanup(dtorKind)) { 1255 if (!cleanupDominator) 1256 cleanupDominator = CGF.Builder.CreateAlignedLoad( 1257 CGF.Int8Ty, 1258 llvm::Constant::getNullValue(CGF.Int8PtrTy), 1259 CharUnits::One()); // placeholder 1260 1261 CGF.pushDestroy(EHCleanup, LV.getAddress(), field->getType(), 1262 CGF.getDestroyer(dtorKind), false); 1263 cleanups.push_back(CGF.EHStack.stable_begin()); 1264 pushedCleanup = true; 1265 } 1266 } 1267 1268 // If the GEP didn't get used because of a dead zero init or something 1269 // else, clean it up for -O0 builds and general tidiness. 1270 if (!pushedCleanup && LV.isSimple()) 1271 if (llvm::GetElementPtrInst *GEP = 1272 dyn_cast<llvm::GetElementPtrInst>(LV.getPointer())) 1273 if (GEP->use_empty()) 1274 GEP->eraseFromParent(); 1275 } 1276 1277 // Deactivate all the partial cleanups in reverse order, which 1278 // generally means popping them. 1279 for (unsigned i = cleanups.size(); i != 0; --i) 1280 CGF.DeactivateCleanupBlock(cleanups[i-1], cleanupDominator); 1281 1282 // Destroy the placeholder if we made one. 1283 if (cleanupDominator) 1284 cleanupDominator->eraseFromParent(); 1285} 1286 1287void AggExprEmitter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) { 1288 AggValueSlot Dest = EnsureSlot(E->getType()); 1289 1290 LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType()); 1291 EmitInitializationToLValue(E->getBase(), DestLV); 1292 VisitInitListExpr(E->getUpdater()); 1293} 1294 1295//===----------------------------------------------------------------------===// 1296// Entry Points into this File 1297//===----------------------------------------------------------------------===// 1298 1299/// GetNumNonZeroBytesInInit - Get an approximate count of the number of 1300/// non-zero bytes that will be stored when outputting the initializer for the 1301/// specified initializer expression. 1302static CharUnits GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF) { 1303 E = E->IgnoreParens(); 1304 1305 // 0 and 0.0 won't require any non-zero stores! 1306 if (isSimpleZero(E, CGF)) return CharUnits::Zero(); 1307 1308 // If this is an initlist expr, sum up the size of sizes of the (present) 1309 // elements. If this is something weird, assume the whole thing is non-zero. 1310 const InitListExpr *ILE = dyn_cast<InitListExpr>(E); 1311 if (!ILE || !CGF.getTypes().isZeroInitializable(ILE->getType())) 1312 return CGF.getContext().getTypeSizeInChars(E->getType()); 1313 1314 // InitListExprs for structs have to be handled carefully. If there are 1315 // reference members, we need to consider the size of the reference, not the 1316 // referencee. InitListExprs for unions and arrays can't have references. 1317 if (const RecordType *RT = E->getType()->getAs<RecordType>()) { 1318 if (!RT->isUnionType()) { 1319 RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl(); 1320 CharUnits NumNonZeroBytes = CharUnits::Zero(); 1321 1322 unsigned ILEElement = 0; 1323 for (const auto *Field : SD->fields()) { 1324 // We're done once we hit the flexible array member or run out of 1325 // InitListExpr elements. 1326 if (Field->getType()->isIncompleteArrayType() || 1327 ILEElement == ILE->getNumInits()) 1328 break; 1329 if (Field->isUnnamedBitfield()) 1330 continue; 1331 1332 const Expr *E = ILE->getInit(ILEElement++); 1333 1334 // Reference values are always non-null and have the width of a pointer. 1335 if (Field->getType()->isReferenceType()) 1336 NumNonZeroBytes += CGF.getContext().toCharUnitsFromBits( 1337 CGF.getTarget().getPointerWidth(0)); 1338 else 1339 NumNonZeroBytes += GetNumNonZeroBytesInInit(E, CGF); 1340 } 1341 1342 return NumNonZeroBytes; 1343 } 1344 } 1345 1346 1347 CharUnits NumNonZeroBytes = CharUnits::Zero(); 1348 for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i) 1349 NumNonZeroBytes += GetNumNonZeroBytesInInit(ILE->getInit(i), CGF); 1350 return NumNonZeroBytes; 1351} 1352 1353/// CheckAggExprForMemSetUse - If the initializer is large and has a lot of 1354/// zeros in it, emit a memset and avoid storing the individual zeros. 1355/// 1356static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E, 1357 CodeGenFunction &CGF) { 1358 // If the slot is already known to be zeroed, nothing to do. Don't mess with 1359 // volatile stores. 1360 if (Slot.isZeroed() || Slot.isVolatile() || !Slot.getAddress().isValid()) 1361 return; 1362 1363 // C++ objects with a user-declared constructor don't need zero'ing. 1364 if (CGF.getLangOpts().CPlusPlus) 1365 if (const RecordType *RT = CGF.getContext() 1366 .getBaseElementType(E->getType())->getAs<RecordType>()) { 1367 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1368 if (RD->hasUserDeclaredConstructor()) 1369 return; 1370 } 1371 1372 // If the type is 16-bytes or smaller, prefer individual stores over memset. 1373 CharUnits Size = CGF.getContext().getTypeSizeInChars(E->getType()); 1374 if (Size <= CharUnits::fromQuantity(16)) 1375 return; 1376 1377 // Check to see if over 3/4 of the initializer are known to be zero. If so, 1378 // we prefer to emit memset + individual stores for the rest. 1379 CharUnits NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF); 1380 if (NumNonZeroBytes*4 > Size) 1381 return; 1382 1383 // Okay, it seems like a good idea to use an initial memset, emit the call. 1384 llvm::Constant *SizeVal = CGF.Builder.getInt64(Size.getQuantity()); 1385 1386 Address Loc = Slot.getAddress(); 1387 Loc = CGF.Builder.CreateElementBitCast(Loc, CGF.Int8Ty); 1388 CGF.Builder.CreateMemSet(Loc, CGF.Builder.getInt8(0), SizeVal, false); 1389 1390 // Tell the AggExprEmitter that the slot is known zero. 1391 Slot.setZeroed(); 1392} 1393 1394 1395 1396 1397/// EmitAggExpr - Emit the computation of the specified expression of aggregate 1398/// type. The result is computed into DestPtr. Note that if DestPtr is null, 1399/// the value of the aggregate expression is not needed. If VolatileDest is 1400/// true, DestPtr cannot be 0. 1401void CodeGenFunction::EmitAggExpr(const Expr *E, AggValueSlot Slot) { 1402 assert(E && hasAggregateEvaluationKind(E->getType()) && 1403 "Invalid aggregate expression to emit"); 1404 assert((Slot.getAddress().isValid() || Slot.isIgnored()) && 1405 "slot has bits but no address"); 1406 1407 // Optimize the slot if possible. 1408 CheckAggExprForMemSetUse(Slot, E, *this); 1409 1410 AggExprEmitter(*this, Slot, Slot.isIgnored()).Visit(const_cast<Expr*>(E)); 1411} 1412 1413LValue CodeGenFunction::EmitAggExprToLValue(const Expr *E) { 1414 assert(hasAggregateEvaluationKind(E->getType()) && "Invalid argument!"); 1415 Address Temp = CreateMemTemp(E->getType()); 1416 LValue LV = MakeAddrLValue(Temp, E->getType()); 1417 EmitAggExpr(E, AggValueSlot::forLValue(LV, AggValueSlot::IsNotDestructed, 1418 AggValueSlot::DoesNotNeedGCBarriers, 1419 AggValueSlot::IsNotAliased)); 1420 return LV; 1421} 1422 1423void CodeGenFunction::EmitAggregateCopy(Address DestPtr, 1424 Address SrcPtr, QualType Ty, 1425 bool isVolatile, 1426 bool isAssignment) { 1427 assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex"); 1428 1429 if (getLangOpts().CPlusPlus) { 1430 if (const RecordType *RT = Ty->getAs<RecordType>()) { 1431 CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl()); 1432 assert((Record->hasTrivialCopyConstructor() || 1433 Record->hasTrivialCopyAssignment() || 1434 Record->hasTrivialMoveConstructor() || 1435 Record->hasTrivialMoveAssignment() || 1436 Record->isUnion()) && 1437 "Trying to aggregate-copy a type without a trivial copy/move " 1438 "constructor or assignment operator"); 1439 // Ignore empty classes in C++. 1440 if (Record->isEmpty()) 1441 return; 1442 } 1443 } 1444 1445 // Aggregate assignment turns into llvm.memcpy. This is almost valid per 1446 // C99 6.5.16.1p3, which states "If the value being stored in an object is 1447 // read from another object that overlaps in anyway the storage of the first 1448 // object, then the overlap shall be exact and the two objects shall have 1449 // qualified or unqualified versions of a compatible type." 1450 // 1451 // memcpy is not defined if the source and destination pointers are exactly 1452 // equal, but other compilers do this optimization, and almost every memcpy 1453 // implementation handles this case safely. If there is a libc that does not 1454 // safely handle this, we can add a target hook. 1455 1456 // Get data size info for this aggregate. If this is an assignment, 1457 // don't copy the tail padding, because we might be assigning into a 1458 // base subobject where the tail padding is claimed. Otherwise, 1459 // copying it is fine. 1460 std::pair<CharUnits, CharUnits> TypeInfo; 1461 if (isAssignment) 1462 TypeInfo = getContext().getTypeInfoDataSizeInChars(Ty); 1463 else 1464 TypeInfo = getContext().getTypeInfoInChars(Ty); 1465 1466 llvm::Value *SizeVal = nullptr; 1467 if (TypeInfo.first.isZero()) { 1468 // But note that getTypeInfo returns 0 for a VLA. 1469 if (auto *VAT = dyn_cast_or_null<VariableArrayType>( 1470 getContext().getAsArrayType(Ty))) { 1471 QualType BaseEltTy; 1472 SizeVal = emitArrayLength(VAT, BaseEltTy, DestPtr); 1473 TypeInfo = getContext().getTypeInfoDataSizeInChars(BaseEltTy); 1474 std::pair<CharUnits, CharUnits> LastElementTypeInfo; 1475 if (!isAssignment) 1476 LastElementTypeInfo = getContext().getTypeInfoInChars(BaseEltTy); 1477 assert(!TypeInfo.first.isZero()); 1478 SizeVal = Builder.CreateNUWMul( 1479 SizeVal, 1480 llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity())); 1481 if (!isAssignment) { 1482 SizeVal = Builder.CreateNUWSub( 1483 SizeVal, 1484 llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity())); 1485 SizeVal = Builder.CreateNUWAdd( 1486 SizeVal, llvm::ConstantInt::get( 1487 SizeTy, LastElementTypeInfo.first.getQuantity())); 1488 } 1489 } 1490 } 1491 if (!SizeVal) { 1492 SizeVal = llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity()); 1493 } 1494 1495 // FIXME: If we have a volatile struct, the optimizer can remove what might 1496 // appear to be `extra' memory ops: 1497 // 1498 // volatile struct { int i; } a, b; 1499 // 1500 // int main() { 1501 // a = b; 1502 // a = b; 1503 // } 1504 // 1505 // we need to use a different call here. We use isVolatile to indicate when 1506 // either the source or the destination is volatile. 1507 1508 DestPtr = Builder.CreateElementBitCast(DestPtr, Int8Ty); 1509 SrcPtr = Builder.CreateElementBitCast(SrcPtr, Int8Ty); 1510 1511 // Don't do any of the memmove_collectable tests if GC isn't set. 1512 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) { 1513 // fall through 1514 } else if (const RecordType *RecordTy = Ty->getAs<RecordType>()) { 1515 RecordDecl *Record = RecordTy->getDecl(); 1516 if (Record->hasObjectMember()) { 1517 CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr, 1518 SizeVal); 1519 return; 1520 } 1521 } else if (Ty->isArrayType()) { 1522 QualType BaseType = getContext().getBaseElementType(Ty); 1523 if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) { 1524 if (RecordTy->getDecl()->hasObjectMember()) { 1525 CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr, 1526 SizeVal); 1527 return; 1528 } 1529 } 1530 } 1531 1532 auto Inst = Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, isVolatile); 1533 1534 // Determine the metadata to describe the position of any padding in this 1535 // memcpy, as well as the TBAA tags for the members of the struct, in case 1536 // the optimizer wishes to expand it in to scalar memory operations. 1537 if (llvm::MDNode *TBAAStructTag = CGM.getTBAAStructInfo(Ty)) 1538 Inst->setMetadata(llvm::LLVMContext::MD_tbaa_struct, TBAAStructTag); 1539} 1540