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