CGExprCXX.cpp revision 7c2349be2d11143a2e59a167fd43362a3bf4585e
1//===--- CGExprCXX.cpp - Emit LLVM Code for C++ 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 dealing with code generation of C++ expressions 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Frontend/CodeGenOptions.h" 15#include "CodeGenFunction.h" 16#include "CGCXXABI.h" 17#include "CGObjCRuntime.h" 18#include "CGDebugInfo.h" 19#include "llvm/Intrinsics.h" 20#include "llvm/Support/CallSite.h" 21 22using namespace clang; 23using namespace CodeGen; 24 25RValue CodeGenFunction::EmitCXXMemberCall(const CXXMethodDecl *MD, 26 llvm::Value *Callee, 27 ReturnValueSlot ReturnValue, 28 llvm::Value *This, 29 llvm::Value *VTT, 30 CallExpr::const_arg_iterator ArgBeg, 31 CallExpr::const_arg_iterator ArgEnd) { 32 assert(MD->isInstance() && 33 "Trying to emit a member call expr on a static method!"); 34 35 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>(); 36 37 CallArgList Args; 38 39 // Push the this ptr. 40 Args.add(RValue::get(This), MD->getThisType(getContext())); 41 42 // If there is a VTT parameter, emit it. 43 if (VTT) { 44 QualType T = getContext().getPointerType(getContext().VoidPtrTy); 45 Args.add(RValue::get(VTT), T); 46 } 47 48 // And the rest of the call args 49 EmitCallArgs(Args, FPT, ArgBeg, ArgEnd); 50 51 QualType ResultType = FPT->getResultType(); 52 return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args, 53 FPT->getExtInfo()), 54 Callee, ReturnValue, Args, MD); 55} 56 57static const CXXRecordDecl *getMostDerivedClassDecl(const Expr *Base) { 58 const Expr *E = Base; 59 60 while (true) { 61 E = E->IgnoreParens(); 62 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) { 63 if (CE->getCastKind() == CK_DerivedToBase || 64 CE->getCastKind() == CK_UncheckedDerivedToBase || 65 CE->getCastKind() == CK_NoOp) { 66 E = CE->getSubExpr(); 67 continue; 68 } 69 } 70 71 break; 72 } 73 74 QualType DerivedType = E->getType(); 75 if (const PointerType *PTy = DerivedType->getAs<PointerType>()) 76 DerivedType = PTy->getPointeeType(); 77 78 return cast<CXXRecordDecl>(DerivedType->castAs<RecordType>()->getDecl()); 79} 80 81// FIXME: Ideally Expr::IgnoreParenNoopCasts should do this, but it doesn't do 82// quite what we want. 83static const Expr *skipNoOpCastsAndParens(const Expr *E) { 84 while (true) { 85 if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) { 86 E = PE->getSubExpr(); 87 continue; 88 } 89 90 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) { 91 if (CE->getCastKind() == CK_NoOp) { 92 E = CE->getSubExpr(); 93 continue; 94 } 95 } 96 if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) { 97 if (UO->getOpcode() == UO_Extension) { 98 E = UO->getSubExpr(); 99 continue; 100 } 101 } 102 return E; 103 } 104} 105 106/// canDevirtualizeMemberFunctionCalls - Checks whether virtual calls on given 107/// expr can be devirtualized. 108static bool canDevirtualizeMemberFunctionCalls(ASTContext &Context, 109 const Expr *Base, 110 const CXXMethodDecl *MD) { 111 112 // When building with -fapple-kext, all calls must go through the vtable since 113 // the kernel linker can do runtime patching of vtables. 114 if (Context.getLangOptions().AppleKext) 115 return false; 116 117 // If the most derived class is marked final, we know that no subclass can 118 // override this member function and so we can devirtualize it. For example: 119 // 120 // struct A { virtual void f(); } 121 // struct B final : A { }; 122 // 123 // void f(B *b) { 124 // b->f(); 125 // } 126 // 127 const CXXRecordDecl *MostDerivedClassDecl = getMostDerivedClassDecl(Base); 128 if (MostDerivedClassDecl->hasAttr<FinalAttr>()) 129 return true; 130 131 // If the member function is marked 'final', we know that it can't be 132 // overridden and can therefore devirtualize it. 133 if (MD->hasAttr<FinalAttr>()) 134 return true; 135 136 // Similarly, if the class itself is marked 'final' it can't be overridden 137 // and we can therefore devirtualize the member function call. 138 if (MD->getParent()->hasAttr<FinalAttr>()) 139 return true; 140 141 Base = skipNoOpCastsAndParens(Base); 142 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) { 143 if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) { 144 // This is a record decl. We know the type and can devirtualize it. 145 return VD->getType()->isRecordType(); 146 } 147 148 return false; 149 } 150 151 // We can always devirtualize calls on temporary object expressions. 152 if (isa<CXXConstructExpr>(Base)) 153 return true; 154 155 // And calls on bound temporaries. 156 if (isa<CXXBindTemporaryExpr>(Base)) 157 return true; 158 159 // Check if this is a call expr that returns a record type. 160 if (const CallExpr *CE = dyn_cast<CallExpr>(Base)) 161 return CE->getCallReturnType()->isRecordType(); 162 163 // We can't devirtualize the call. 164 return false; 165} 166 167// Note: This function also emit constructor calls to support a MSVC 168// extensions allowing explicit constructor function call. 169RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE, 170 ReturnValueSlot ReturnValue) { 171 const Expr *callee = CE->getCallee()->IgnoreParens(); 172 173 if (isa<BinaryOperator>(callee)) 174 return EmitCXXMemberPointerCallExpr(CE, ReturnValue); 175 176 const MemberExpr *ME = cast<MemberExpr>(callee); 177 const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl()); 178 179 CGDebugInfo *DI = getDebugInfo(); 180 if (DI && CGM.getCodeGenOpts().LimitDebugInfo 181 && !isa<CallExpr>(ME->getBase())) { 182 QualType PQTy = ME->getBase()->IgnoreParenImpCasts()->getType(); 183 if (const PointerType * PTy = dyn_cast<PointerType>(PQTy)) { 184 DI->getOrCreateRecordType(PTy->getPointeeType(), 185 MD->getParent()->getLocation()); 186 } 187 } 188 189 if (MD->isStatic()) { 190 // The method is static, emit it as we would a regular call. 191 llvm::Value *Callee = CGM.GetAddrOfFunction(MD); 192 return EmitCall(getContext().getPointerType(MD->getType()), Callee, 193 ReturnValue, CE->arg_begin(), CE->arg_end()); 194 } 195 196 // Compute the object pointer. 197 llvm::Value *This; 198 if (ME->isArrow()) 199 This = EmitScalarExpr(ME->getBase()); 200 else 201 This = EmitLValue(ME->getBase()).getAddress(); 202 203 if (MD->isTrivial()) { 204 if (isa<CXXDestructorDecl>(MD)) return RValue::get(0); 205 if (isa<CXXConstructorDecl>(MD) && 206 cast<CXXConstructorDecl>(MD)->isDefaultConstructor()) 207 return RValue::get(0); 208 209 if (MD->isCopyAssignmentOperator()) { 210 // We don't like to generate the trivial copy assignment operator when 211 // it isn't necessary; just produce the proper effect here. 212 llvm::Value *RHS = EmitLValue(*CE->arg_begin()).getAddress(); 213 EmitAggregateCopy(This, RHS, CE->getType()); 214 return RValue::get(This); 215 } 216 217 if (isa<CXXConstructorDecl>(MD) && 218 cast<CXXConstructorDecl>(MD)->isCopyConstructor()) { 219 llvm::Value *RHS = EmitLValue(*CE->arg_begin()).getAddress(); 220 EmitSynthesizedCXXCopyCtorCall(cast<CXXConstructorDecl>(MD), This, RHS, 221 CE->arg_begin(), CE->arg_end()); 222 return RValue::get(This); 223 } 224 llvm_unreachable("unknown trivial member function"); 225 } 226 227 // Compute the function type we're calling. 228 const CGFunctionInfo *FInfo = 0; 229 if (isa<CXXDestructorDecl>(MD)) 230 FInfo = &CGM.getTypes().getFunctionInfo(cast<CXXDestructorDecl>(MD), 231 Dtor_Complete); 232 else if (isa<CXXConstructorDecl>(MD)) 233 FInfo = &CGM.getTypes().getFunctionInfo(cast<CXXConstructorDecl>(MD), 234 Ctor_Complete); 235 else 236 FInfo = &CGM.getTypes().getFunctionInfo(MD); 237 238 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>(); 239 llvm::Type *Ty 240 = CGM.getTypes().GetFunctionType(*FInfo, FPT->isVariadic()); 241 242 // C++ [class.virtual]p12: 243 // Explicit qualification with the scope operator (5.1) suppresses the 244 // virtual call mechanism. 245 // 246 // We also don't emit a virtual call if the base expression has a record type 247 // because then we know what the type is. 248 bool UseVirtualCall; 249 UseVirtualCall = MD->isVirtual() && !ME->hasQualifier() 250 && !canDevirtualizeMemberFunctionCalls(getContext(), 251 ME->getBase(), MD); 252 llvm::Value *Callee; 253 if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(MD)) { 254 if (UseVirtualCall) { 255 Callee = BuildVirtualCall(Dtor, Dtor_Complete, This, Ty); 256 } else { 257 if (getContext().getLangOptions().AppleKext && 258 MD->isVirtual() && 259 ME->hasQualifier()) 260 Callee = BuildAppleKextVirtualCall(MD, ME->getQualifier(), Ty); 261 else 262 Callee = CGM.GetAddrOfFunction(GlobalDecl(Dtor, Dtor_Complete), Ty); 263 } 264 } else if (const CXXConstructorDecl *Ctor = 265 dyn_cast<CXXConstructorDecl>(MD)) { 266 Callee = CGM.GetAddrOfFunction(GlobalDecl(Ctor, Ctor_Complete), Ty); 267 } else if (UseVirtualCall) { 268 Callee = BuildVirtualCall(MD, This, Ty); 269 } else { 270 if (getContext().getLangOptions().AppleKext && 271 MD->isVirtual() && 272 ME->hasQualifier()) 273 Callee = BuildAppleKextVirtualCall(MD, ME->getQualifier(), Ty); 274 else 275 Callee = CGM.GetAddrOfFunction(MD, Ty); 276 } 277 278 return EmitCXXMemberCall(MD, Callee, ReturnValue, This, /*VTT=*/0, 279 CE->arg_begin(), CE->arg_end()); 280} 281 282RValue 283CodeGenFunction::EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E, 284 ReturnValueSlot ReturnValue) { 285 const BinaryOperator *BO = 286 cast<BinaryOperator>(E->getCallee()->IgnoreParens()); 287 const Expr *BaseExpr = BO->getLHS(); 288 const Expr *MemFnExpr = BO->getRHS(); 289 290 const MemberPointerType *MPT = 291 MemFnExpr->getType()->castAs<MemberPointerType>(); 292 293 const FunctionProtoType *FPT = 294 MPT->getPointeeType()->castAs<FunctionProtoType>(); 295 const CXXRecordDecl *RD = 296 cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl()); 297 298 // Get the member function pointer. 299 llvm::Value *MemFnPtr = EmitScalarExpr(MemFnExpr); 300 301 // Emit the 'this' pointer. 302 llvm::Value *This; 303 304 if (BO->getOpcode() == BO_PtrMemI) 305 This = EmitScalarExpr(BaseExpr); 306 else 307 This = EmitLValue(BaseExpr).getAddress(); 308 309 // Ask the ABI to load the callee. Note that This is modified. 310 llvm::Value *Callee = 311 CGM.getCXXABI().EmitLoadOfMemberFunctionPointer(*this, This, MemFnPtr, MPT); 312 313 CallArgList Args; 314 315 QualType ThisType = 316 getContext().getPointerType(getContext().getTagDeclType(RD)); 317 318 // Push the this ptr. 319 Args.add(RValue::get(This), ThisType); 320 321 // And the rest of the call args 322 EmitCallArgs(Args, FPT, E->arg_begin(), E->arg_end()); 323 return EmitCall(CGM.getTypes().getFunctionInfo(Args, FPT), Callee, 324 ReturnValue, Args); 325} 326 327RValue 328CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E, 329 const CXXMethodDecl *MD, 330 ReturnValueSlot ReturnValue) { 331 assert(MD->isInstance() && 332 "Trying to emit a member call expr on a static method!"); 333 LValue LV = EmitLValue(E->getArg(0)); 334 llvm::Value *This = LV.getAddress(); 335 336 if (MD->isCopyAssignmentOperator()) { 337 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(MD->getDeclContext()); 338 if (ClassDecl->hasTrivialCopyAssignment()) { 339 assert(!ClassDecl->hasUserDeclaredCopyAssignment() && 340 "EmitCXXOperatorMemberCallExpr - user declared copy assignment"); 341 llvm::Value *Src = EmitLValue(E->getArg(1)).getAddress(); 342 QualType Ty = E->getType(); 343 EmitAggregateCopy(This, Src, Ty); 344 return RValue::get(This); 345 } 346 } 347 348 llvm::Value *Callee = EmitCXXOperatorMemberCallee(E, MD, This); 349 return EmitCXXMemberCall(MD, Callee, ReturnValue, This, /*VTT=*/0, 350 E->arg_begin() + 1, E->arg_end()); 351} 352 353void 354CodeGenFunction::EmitCXXConstructExpr(const CXXConstructExpr *E, 355 AggValueSlot Dest) { 356 assert(!Dest.isIgnored() && "Must have a destination!"); 357 const CXXConstructorDecl *CD = E->getConstructor(); 358 359 // If we require zero initialization before (or instead of) calling the 360 // constructor, as can be the case with a non-user-provided default 361 // constructor, emit the zero initialization now, unless destination is 362 // already zeroed. 363 if (E->requiresZeroInitialization() && !Dest.isZeroed()) 364 EmitNullInitialization(Dest.getAddr(), E->getType()); 365 366 // If this is a call to a trivial default constructor, do nothing. 367 if (CD->isTrivial() && CD->isDefaultConstructor()) 368 return; 369 370 // Elide the constructor if we're constructing from a temporary. 371 // The temporary check is required because Sema sets this on NRVO 372 // returns. 373 if (getContext().getLangOptions().ElideConstructors && E->isElidable()) { 374 assert(getContext().hasSameUnqualifiedType(E->getType(), 375 E->getArg(0)->getType())); 376 if (E->getArg(0)->isTemporaryObject(getContext(), CD->getParent())) { 377 EmitAggExpr(E->getArg(0), Dest); 378 return; 379 } 380 } 381 382 if (const ConstantArrayType *arrayType 383 = getContext().getAsConstantArrayType(E->getType())) { 384 EmitCXXAggrConstructorCall(CD, arrayType, Dest.getAddr(), 385 E->arg_begin(), E->arg_end()); 386 } else { 387 CXXCtorType Type = Ctor_Complete; 388 bool ForVirtualBase = false; 389 390 switch (E->getConstructionKind()) { 391 case CXXConstructExpr::CK_Delegating: 392 // We should be emitting a constructor; GlobalDecl will assert this 393 Type = CurGD.getCtorType(); 394 break; 395 396 case CXXConstructExpr::CK_Complete: 397 Type = Ctor_Complete; 398 break; 399 400 case CXXConstructExpr::CK_VirtualBase: 401 ForVirtualBase = true; 402 // fall-through 403 404 case CXXConstructExpr::CK_NonVirtualBase: 405 Type = Ctor_Base; 406 } 407 408 // Call the constructor. 409 EmitCXXConstructorCall(CD, Type, ForVirtualBase, Dest.getAddr(), 410 E->arg_begin(), E->arg_end()); 411 } 412} 413 414void 415CodeGenFunction::EmitSynthesizedCXXCopyCtor(llvm::Value *Dest, 416 llvm::Value *Src, 417 const Expr *Exp) { 418 if (const ExprWithCleanups *E = dyn_cast<ExprWithCleanups>(Exp)) 419 Exp = E->getSubExpr(); 420 assert(isa<CXXConstructExpr>(Exp) && 421 "EmitSynthesizedCXXCopyCtor - unknown copy ctor expr"); 422 const CXXConstructExpr* E = cast<CXXConstructExpr>(Exp); 423 const CXXConstructorDecl *CD = E->getConstructor(); 424 RunCleanupsScope Scope(*this); 425 426 // If we require zero initialization before (or instead of) calling the 427 // constructor, as can be the case with a non-user-provided default 428 // constructor, emit the zero initialization now. 429 // FIXME. Do I still need this for a copy ctor synthesis? 430 if (E->requiresZeroInitialization()) 431 EmitNullInitialization(Dest, E->getType()); 432 433 assert(!getContext().getAsConstantArrayType(E->getType()) 434 && "EmitSynthesizedCXXCopyCtor - Copied-in Array"); 435 EmitSynthesizedCXXCopyCtorCall(CD, Dest, Src, 436 E->arg_begin(), E->arg_end()); 437} 438 439static CharUnits CalculateCookiePadding(CodeGenFunction &CGF, 440 const CXXNewExpr *E) { 441 if (!E->isArray()) 442 return CharUnits::Zero(); 443 444 // No cookie is required if the operator new[] being used is the 445 // reserved placement operator new[]. 446 if (E->getOperatorNew()->isReservedGlobalPlacementOperator()) 447 return CharUnits::Zero(); 448 449 return CGF.CGM.getCXXABI().GetArrayCookieSize(E); 450} 451 452static llvm::Value *EmitCXXNewAllocSize(CodeGenFunction &CGF, 453 const CXXNewExpr *e, 454 llvm::Value *&numElements, 455 llvm::Value *&sizeWithoutCookie) { 456 QualType type = e->getAllocatedType(); 457 458 if (!e->isArray()) { 459 CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type); 460 sizeWithoutCookie 461 = llvm::ConstantInt::get(CGF.SizeTy, typeSize.getQuantity()); 462 return sizeWithoutCookie; 463 } 464 465 // The width of size_t. 466 unsigned sizeWidth = CGF.SizeTy->getBitWidth(); 467 468 // Figure out the cookie size. 469 llvm::APInt cookieSize(sizeWidth, 470 CalculateCookiePadding(CGF, e).getQuantity()); 471 472 // Emit the array size expression. 473 // We multiply the size of all dimensions for NumElements. 474 // e.g for 'int[2][3]', ElemType is 'int' and NumElements is 6. 475 numElements = CGF.EmitScalarExpr(e->getArraySize()); 476 assert(isa<llvm::IntegerType>(numElements->getType())); 477 478 // The number of elements can be have an arbitrary integer type; 479 // essentially, we need to multiply it by a constant factor, add a 480 // cookie size, and verify that the result is representable as a 481 // size_t. That's just a gloss, though, and it's wrong in one 482 // important way: if the count is negative, it's an error even if 483 // the cookie size would bring the total size >= 0. 484 bool isSigned 485 = e->getArraySize()->getType()->isSignedIntegerOrEnumerationType(); 486 llvm::IntegerType *numElementsType 487 = cast<llvm::IntegerType>(numElements->getType()); 488 unsigned numElementsWidth = numElementsType->getBitWidth(); 489 490 // Compute the constant factor. 491 llvm::APInt arraySizeMultiplier(sizeWidth, 1); 492 while (const ConstantArrayType *CAT 493 = CGF.getContext().getAsConstantArrayType(type)) { 494 type = CAT->getElementType(); 495 arraySizeMultiplier *= CAT->getSize(); 496 } 497 498 CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type); 499 llvm::APInt typeSizeMultiplier(sizeWidth, typeSize.getQuantity()); 500 typeSizeMultiplier *= arraySizeMultiplier; 501 502 // This will be a size_t. 503 llvm::Value *size; 504 505 // If someone is doing 'new int[42]' there is no need to do a dynamic check. 506 // Don't bloat the -O0 code. 507 if (llvm::ConstantInt *numElementsC = 508 dyn_cast<llvm::ConstantInt>(numElements)) { 509 const llvm::APInt &count = numElementsC->getValue(); 510 511 bool hasAnyOverflow = false; 512 513 // If 'count' was a negative number, it's an overflow. 514 if (isSigned && count.isNegative()) 515 hasAnyOverflow = true; 516 517 // We want to do all this arithmetic in size_t. If numElements is 518 // wider than that, check whether it's already too big, and if so, 519 // overflow. 520 else if (numElementsWidth > sizeWidth && 521 numElementsWidth - sizeWidth > count.countLeadingZeros()) 522 hasAnyOverflow = true; 523 524 // Okay, compute a count at the right width. 525 llvm::APInt adjustedCount = count.zextOrTrunc(sizeWidth); 526 527 // Scale numElements by that. This might overflow, but we don't 528 // care because it only overflows if allocationSize does, too, and 529 // if that overflows then we shouldn't use this. 530 numElements = llvm::ConstantInt::get(CGF.SizeTy, 531 adjustedCount * arraySizeMultiplier); 532 533 // Compute the size before cookie, and track whether it overflowed. 534 bool overflow; 535 llvm::APInt allocationSize 536 = adjustedCount.umul_ov(typeSizeMultiplier, overflow); 537 hasAnyOverflow |= overflow; 538 539 // Add in the cookie, and check whether it's overflowed. 540 if (cookieSize != 0) { 541 // Save the current size without a cookie. This shouldn't be 542 // used if there was overflow. 543 sizeWithoutCookie = llvm::ConstantInt::get(CGF.SizeTy, allocationSize); 544 545 allocationSize = allocationSize.uadd_ov(cookieSize, overflow); 546 hasAnyOverflow |= overflow; 547 } 548 549 // On overflow, produce a -1 so operator new will fail. 550 if (hasAnyOverflow) { 551 size = llvm::Constant::getAllOnesValue(CGF.SizeTy); 552 } else { 553 size = llvm::ConstantInt::get(CGF.SizeTy, allocationSize); 554 } 555 556 // Otherwise, we might need to use the overflow intrinsics. 557 } else { 558 // There are up to four conditions we need to test for: 559 // 1) if isSigned, we need to check whether numElements is negative; 560 // 2) if numElementsWidth > sizeWidth, we need to check whether 561 // numElements is larger than something representable in size_t; 562 // 3) we need to compute 563 // sizeWithoutCookie := numElements * typeSizeMultiplier 564 // and check whether it overflows; and 565 // 4) if we need a cookie, we need to compute 566 // size := sizeWithoutCookie + cookieSize 567 // and check whether it overflows. 568 569 llvm::Value *hasOverflow = 0; 570 571 // If numElementsWidth > sizeWidth, then one way or another, we're 572 // going to have to do a comparison for (2), and this happens to 573 // take care of (1), too. 574 if (numElementsWidth > sizeWidth) { 575 llvm::APInt threshold(numElementsWidth, 1); 576 threshold <<= sizeWidth; 577 578 llvm::Value *thresholdV 579 = llvm::ConstantInt::get(numElementsType, threshold); 580 581 hasOverflow = CGF.Builder.CreateICmpUGE(numElements, thresholdV); 582 numElements = CGF.Builder.CreateTrunc(numElements, CGF.SizeTy); 583 584 // Otherwise, if we're signed, we want to sext up to size_t. 585 } else if (isSigned) { 586 if (numElementsWidth < sizeWidth) 587 numElements = CGF.Builder.CreateSExt(numElements, CGF.SizeTy); 588 589 // If there's a non-1 type size multiplier, then we can do the 590 // signedness check at the same time as we do the multiply 591 // because a negative number times anything will cause an 592 // unsigned overflow. Otherwise, we have to do it here. 593 if (typeSizeMultiplier == 1) 594 hasOverflow = CGF.Builder.CreateICmpSLT(numElements, 595 llvm::ConstantInt::get(CGF.SizeTy, 0)); 596 597 // Otherwise, zext up to size_t if necessary. 598 } else if (numElementsWidth < sizeWidth) { 599 numElements = CGF.Builder.CreateZExt(numElements, CGF.SizeTy); 600 } 601 602 assert(numElements->getType() == CGF.SizeTy); 603 604 size = numElements; 605 606 // Multiply by the type size if necessary. This multiplier 607 // includes all the factors for nested arrays. 608 // 609 // This step also causes numElements to be scaled up by the 610 // nested-array factor if necessary. Overflow on this computation 611 // can be ignored because the result shouldn't be used if 612 // allocation fails. 613 if (typeSizeMultiplier != 1) { 614 llvm::Value *umul_with_overflow 615 = CGF.CGM.getIntrinsic(llvm::Intrinsic::umul_with_overflow, CGF.SizeTy); 616 617 llvm::Value *tsmV = 618 llvm::ConstantInt::get(CGF.SizeTy, typeSizeMultiplier); 619 llvm::Value *result = 620 CGF.Builder.CreateCall2(umul_with_overflow, size, tsmV); 621 622 llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1); 623 if (hasOverflow) 624 hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed); 625 else 626 hasOverflow = overflowed; 627 628 size = CGF.Builder.CreateExtractValue(result, 0); 629 630 // Also scale up numElements by the array size multiplier. 631 if (arraySizeMultiplier != 1) { 632 // If the base element type size is 1, then we can re-use the 633 // multiply we just did. 634 if (typeSize.isOne()) { 635 assert(arraySizeMultiplier == typeSizeMultiplier); 636 numElements = size; 637 638 // Otherwise we need a separate multiply. 639 } else { 640 llvm::Value *asmV = 641 llvm::ConstantInt::get(CGF.SizeTy, arraySizeMultiplier); 642 numElements = CGF.Builder.CreateMul(numElements, asmV); 643 } 644 } 645 } else { 646 // numElements doesn't need to be scaled. 647 assert(arraySizeMultiplier == 1); 648 } 649 650 // Add in the cookie size if necessary. 651 if (cookieSize != 0) { 652 sizeWithoutCookie = size; 653 654 llvm::Value *uadd_with_overflow 655 = CGF.CGM.getIntrinsic(llvm::Intrinsic::uadd_with_overflow, CGF.SizeTy); 656 657 llvm::Value *cookieSizeV = llvm::ConstantInt::get(CGF.SizeTy, cookieSize); 658 llvm::Value *result = 659 CGF.Builder.CreateCall2(uadd_with_overflow, size, cookieSizeV); 660 661 llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1); 662 if (hasOverflow) 663 hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed); 664 else 665 hasOverflow = overflowed; 666 667 size = CGF.Builder.CreateExtractValue(result, 0); 668 } 669 670 // If we had any possibility of dynamic overflow, make a select to 671 // overwrite 'size' with an all-ones value, which should cause 672 // operator new to throw. 673 if (hasOverflow) 674 size = CGF.Builder.CreateSelect(hasOverflow, 675 llvm::Constant::getAllOnesValue(CGF.SizeTy), 676 size); 677 } 678 679 if (cookieSize == 0) 680 sizeWithoutCookie = size; 681 else 682 assert(sizeWithoutCookie && "didn't set sizeWithoutCookie?"); 683 684 return size; 685} 686 687static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const CXXNewExpr *E, 688 llvm::Value *NewPtr) { 689 690 assert(E->getNumConstructorArgs() == 1 && 691 "Can only have one argument to initializer of POD type."); 692 693 const Expr *Init = E->getConstructorArg(0); 694 QualType AllocType = E->getAllocatedType(); 695 696 unsigned Alignment = 697 CGF.getContext().getTypeAlignInChars(AllocType).getQuantity(); 698 if (!CGF.hasAggregateLLVMType(AllocType)) 699 CGF.EmitScalarInit(Init, 0, CGF.MakeAddrLValue(NewPtr, AllocType, Alignment), 700 false); 701 else if (AllocType->isAnyComplexType()) 702 CGF.EmitComplexExprIntoAddr(Init, NewPtr, 703 AllocType.isVolatileQualified()); 704 else { 705 AggValueSlot Slot 706 = AggValueSlot::forAddr(NewPtr, AllocType.getQualifiers(), 707 AggValueSlot::IsDestructed, 708 AggValueSlot::DoesNotNeedGCBarriers); 709 CGF.EmitAggExpr(Init, Slot); 710 } 711} 712 713void 714CodeGenFunction::EmitNewArrayInitializer(const CXXNewExpr *E, 715 llvm::Value *NewPtr, 716 llvm::Value *NumElements) { 717 // We have a POD type. 718 if (E->getNumConstructorArgs() == 0) 719 return; 720 721 llvm::Type *SizeTy = ConvertType(getContext().getSizeType()); 722 723 // Create a temporary for the loop index and initialize it with 0. 724 llvm::Value *IndexPtr = CreateTempAlloca(SizeTy, "loop.index"); 725 llvm::Value *Zero = llvm::Constant::getNullValue(SizeTy); 726 Builder.CreateStore(Zero, IndexPtr); 727 728 // Start the loop with a block that tests the condition. 729 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond"); 730 llvm::BasicBlock *AfterFor = createBasicBlock("for.end"); 731 732 EmitBlock(CondBlock); 733 734 llvm::BasicBlock *ForBody = createBasicBlock("for.body"); 735 736 // Generate: if (loop-index < number-of-elements fall to the loop body, 737 // otherwise, go to the block after the for-loop. 738 llvm::Value *Counter = Builder.CreateLoad(IndexPtr); 739 llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElements, "isless"); 740 // If the condition is true, execute the body. 741 Builder.CreateCondBr(IsLess, ForBody, AfterFor); 742 743 EmitBlock(ForBody); 744 745 llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc"); 746 // Inside the loop body, emit the constructor call on the array element. 747 Counter = Builder.CreateLoad(IndexPtr); 748 llvm::Value *Address = Builder.CreateInBoundsGEP(NewPtr, Counter, 749 "arrayidx"); 750 StoreAnyExprIntoOneUnit(*this, E, Address); 751 752 EmitBlock(ContinueBlock); 753 754 // Emit the increment of the loop counter. 755 llvm::Value *NextVal = llvm::ConstantInt::get(SizeTy, 1); 756 Counter = Builder.CreateLoad(IndexPtr); 757 NextVal = Builder.CreateAdd(Counter, NextVal, "inc"); 758 Builder.CreateStore(NextVal, IndexPtr); 759 760 // Finally, branch back up to the condition for the next iteration. 761 EmitBranch(CondBlock); 762 763 // Emit the fall-through block. 764 EmitBlock(AfterFor, true); 765} 766 767static void EmitZeroMemSet(CodeGenFunction &CGF, QualType T, 768 llvm::Value *NewPtr, llvm::Value *Size) { 769 CGF.EmitCastToVoidPtr(NewPtr); 770 CharUnits Alignment = CGF.getContext().getTypeAlignInChars(T); 771 CGF.Builder.CreateMemSet(NewPtr, CGF.Builder.getInt8(0), Size, 772 Alignment.getQuantity(), false); 773} 774 775static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E, 776 llvm::Value *NewPtr, 777 llvm::Value *NumElements, 778 llvm::Value *AllocSizeWithoutCookie) { 779 if (E->isArray()) { 780 if (CXXConstructorDecl *Ctor = E->getConstructor()) { 781 bool RequiresZeroInitialization = false; 782 if (Ctor->getParent()->hasTrivialDefaultConstructor()) { 783 // If new expression did not specify value-initialization, then there 784 // is no initialization. 785 if (!E->hasInitializer() || Ctor->getParent()->isEmpty()) 786 return; 787 788 if (CGF.CGM.getTypes().isZeroInitializable(E->getAllocatedType())) { 789 // Optimization: since zero initialization will just set the memory 790 // to all zeroes, generate a single memset to do it in one shot. 791 EmitZeroMemSet(CGF, E->getAllocatedType(), NewPtr, 792 AllocSizeWithoutCookie); 793 return; 794 } 795 796 RequiresZeroInitialization = true; 797 } 798 799 CGF.EmitCXXAggrConstructorCall(Ctor, NumElements, NewPtr, 800 E->constructor_arg_begin(), 801 E->constructor_arg_end(), 802 RequiresZeroInitialization); 803 return; 804 } else if (E->getNumConstructorArgs() == 1 && 805 isa<ImplicitValueInitExpr>(E->getConstructorArg(0))) { 806 // Optimization: since zero initialization will just set the memory 807 // to all zeroes, generate a single memset to do it in one shot. 808 EmitZeroMemSet(CGF, E->getAllocatedType(), NewPtr, 809 AllocSizeWithoutCookie); 810 return; 811 } else { 812 CGF.EmitNewArrayInitializer(E, NewPtr, NumElements); 813 return; 814 } 815 } 816 817 if (CXXConstructorDecl *Ctor = E->getConstructor()) { 818 // Per C++ [expr.new]p15, if we have an initializer, then we're performing 819 // direct initialization. C++ [dcl.init]p5 requires that we 820 // zero-initialize storage if there are no user-declared constructors. 821 if (E->hasInitializer() && 822 !Ctor->getParent()->hasUserDeclaredConstructor() && 823 !Ctor->getParent()->isEmpty()) 824 CGF.EmitNullInitialization(NewPtr, E->getAllocatedType()); 825 826 CGF.EmitCXXConstructorCall(Ctor, Ctor_Complete, /*ForVirtualBase=*/false, 827 NewPtr, E->constructor_arg_begin(), 828 E->constructor_arg_end()); 829 830 return; 831 } 832 // We have a POD type. 833 if (E->getNumConstructorArgs() == 0) 834 return; 835 836 StoreAnyExprIntoOneUnit(CGF, E, NewPtr); 837} 838 839namespace { 840 /// A cleanup to call the given 'operator delete' function upon 841 /// abnormal exit from a new expression. 842 class CallDeleteDuringNew : public EHScopeStack::Cleanup { 843 size_t NumPlacementArgs; 844 const FunctionDecl *OperatorDelete; 845 llvm::Value *Ptr; 846 llvm::Value *AllocSize; 847 848 RValue *getPlacementArgs() { return reinterpret_cast<RValue*>(this+1); } 849 850 public: 851 static size_t getExtraSize(size_t NumPlacementArgs) { 852 return NumPlacementArgs * sizeof(RValue); 853 } 854 855 CallDeleteDuringNew(size_t NumPlacementArgs, 856 const FunctionDecl *OperatorDelete, 857 llvm::Value *Ptr, 858 llvm::Value *AllocSize) 859 : NumPlacementArgs(NumPlacementArgs), OperatorDelete(OperatorDelete), 860 Ptr(Ptr), AllocSize(AllocSize) {} 861 862 void setPlacementArg(unsigned I, RValue Arg) { 863 assert(I < NumPlacementArgs && "index out of range"); 864 getPlacementArgs()[I] = Arg; 865 } 866 867 void Emit(CodeGenFunction &CGF, Flags flags) { 868 const FunctionProtoType *FPT 869 = OperatorDelete->getType()->getAs<FunctionProtoType>(); 870 assert(FPT->getNumArgs() == NumPlacementArgs + 1 || 871 (FPT->getNumArgs() == 2 && NumPlacementArgs == 0)); 872 873 CallArgList DeleteArgs; 874 875 // The first argument is always a void*. 876 FunctionProtoType::arg_type_iterator AI = FPT->arg_type_begin(); 877 DeleteArgs.add(RValue::get(Ptr), *AI++); 878 879 // A member 'operator delete' can take an extra 'size_t' argument. 880 if (FPT->getNumArgs() == NumPlacementArgs + 2) 881 DeleteArgs.add(RValue::get(AllocSize), *AI++); 882 883 // Pass the rest of the arguments, which must match exactly. 884 for (unsigned I = 0; I != NumPlacementArgs; ++I) 885 DeleteArgs.add(getPlacementArgs()[I], *AI++); 886 887 // Call 'operator delete'. 888 CGF.EmitCall(CGF.CGM.getTypes().getFunctionInfo(DeleteArgs, FPT), 889 CGF.CGM.GetAddrOfFunction(OperatorDelete), 890 ReturnValueSlot(), DeleteArgs, OperatorDelete); 891 } 892 }; 893 894 /// A cleanup to call the given 'operator delete' function upon 895 /// abnormal exit from a new expression when the new expression is 896 /// conditional. 897 class CallDeleteDuringConditionalNew : public EHScopeStack::Cleanup { 898 size_t NumPlacementArgs; 899 const FunctionDecl *OperatorDelete; 900 DominatingValue<RValue>::saved_type Ptr; 901 DominatingValue<RValue>::saved_type AllocSize; 902 903 DominatingValue<RValue>::saved_type *getPlacementArgs() { 904 return reinterpret_cast<DominatingValue<RValue>::saved_type*>(this+1); 905 } 906 907 public: 908 static size_t getExtraSize(size_t NumPlacementArgs) { 909 return NumPlacementArgs * sizeof(DominatingValue<RValue>::saved_type); 910 } 911 912 CallDeleteDuringConditionalNew(size_t NumPlacementArgs, 913 const FunctionDecl *OperatorDelete, 914 DominatingValue<RValue>::saved_type Ptr, 915 DominatingValue<RValue>::saved_type AllocSize) 916 : NumPlacementArgs(NumPlacementArgs), OperatorDelete(OperatorDelete), 917 Ptr(Ptr), AllocSize(AllocSize) {} 918 919 void setPlacementArg(unsigned I, DominatingValue<RValue>::saved_type Arg) { 920 assert(I < NumPlacementArgs && "index out of range"); 921 getPlacementArgs()[I] = Arg; 922 } 923 924 void Emit(CodeGenFunction &CGF, Flags flags) { 925 const FunctionProtoType *FPT 926 = OperatorDelete->getType()->getAs<FunctionProtoType>(); 927 assert(FPT->getNumArgs() == NumPlacementArgs + 1 || 928 (FPT->getNumArgs() == 2 && NumPlacementArgs == 0)); 929 930 CallArgList DeleteArgs; 931 932 // The first argument is always a void*. 933 FunctionProtoType::arg_type_iterator AI = FPT->arg_type_begin(); 934 DeleteArgs.add(Ptr.restore(CGF), *AI++); 935 936 // A member 'operator delete' can take an extra 'size_t' argument. 937 if (FPT->getNumArgs() == NumPlacementArgs + 2) { 938 RValue RV = AllocSize.restore(CGF); 939 DeleteArgs.add(RV, *AI++); 940 } 941 942 // Pass the rest of the arguments, which must match exactly. 943 for (unsigned I = 0; I != NumPlacementArgs; ++I) { 944 RValue RV = getPlacementArgs()[I].restore(CGF); 945 DeleteArgs.add(RV, *AI++); 946 } 947 948 // Call 'operator delete'. 949 CGF.EmitCall(CGF.CGM.getTypes().getFunctionInfo(DeleteArgs, FPT), 950 CGF.CGM.GetAddrOfFunction(OperatorDelete), 951 ReturnValueSlot(), DeleteArgs, OperatorDelete); 952 } 953 }; 954} 955 956/// Enter a cleanup to call 'operator delete' if the initializer in a 957/// new-expression throws. 958static void EnterNewDeleteCleanup(CodeGenFunction &CGF, 959 const CXXNewExpr *E, 960 llvm::Value *NewPtr, 961 llvm::Value *AllocSize, 962 const CallArgList &NewArgs) { 963 // If we're not inside a conditional branch, then the cleanup will 964 // dominate and we can do the easier (and more efficient) thing. 965 if (!CGF.isInConditionalBranch()) { 966 CallDeleteDuringNew *Cleanup = CGF.EHStack 967 .pushCleanupWithExtra<CallDeleteDuringNew>(EHCleanup, 968 E->getNumPlacementArgs(), 969 E->getOperatorDelete(), 970 NewPtr, AllocSize); 971 for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) 972 Cleanup->setPlacementArg(I, NewArgs[I+1].RV); 973 974 return; 975 } 976 977 // Otherwise, we need to save all this stuff. 978 DominatingValue<RValue>::saved_type SavedNewPtr = 979 DominatingValue<RValue>::save(CGF, RValue::get(NewPtr)); 980 DominatingValue<RValue>::saved_type SavedAllocSize = 981 DominatingValue<RValue>::save(CGF, RValue::get(AllocSize)); 982 983 CallDeleteDuringConditionalNew *Cleanup = CGF.EHStack 984 .pushCleanupWithExtra<CallDeleteDuringConditionalNew>(InactiveEHCleanup, 985 E->getNumPlacementArgs(), 986 E->getOperatorDelete(), 987 SavedNewPtr, 988 SavedAllocSize); 989 for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) 990 Cleanup->setPlacementArg(I, 991 DominatingValue<RValue>::save(CGF, NewArgs[I+1].RV)); 992 993 CGF.ActivateCleanupBlock(CGF.EHStack.stable_begin()); 994} 995 996llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) { 997 // The element type being allocated. 998 QualType allocType = getContext().getBaseElementType(E->getAllocatedType()); 999 1000 // 1. Build a call to the allocation function. 1001 FunctionDecl *allocator = E->getOperatorNew(); 1002 const FunctionProtoType *allocatorType = 1003 allocator->getType()->castAs<FunctionProtoType>(); 1004 1005 CallArgList allocatorArgs; 1006 1007 // The allocation size is the first argument. 1008 QualType sizeType = getContext().getSizeType(); 1009 1010 llvm::Value *numElements = 0; 1011 llvm::Value *allocSizeWithoutCookie = 0; 1012 llvm::Value *allocSize = 1013 EmitCXXNewAllocSize(*this, E, numElements, allocSizeWithoutCookie); 1014 1015 allocatorArgs.add(RValue::get(allocSize), sizeType); 1016 1017 // Emit the rest of the arguments. 1018 // FIXME: Ideally, this should just use EmitCallArgs. 1019 CXXNewExpr::const_arg_iterator placementArg = E->placement_arg_begin(); 1020 1021 // First, use the types from the function type. 1022 // We start at 1 here because the first argument (the allocation size) 1023 // has already been emitted. 1024 for (unsigned i = 1, e = allocatorType->getNumArgs(); i != e; 1025 ++i, ++placementArg) { 1026 QualType argType = allocatorType->getArgType(i); 1027 1028 assert(getContext().hasSameUnqualifiedType(argType.getNonReferenceType(), 1029 placementArg->getType()) && 1030 "type mismatch in call argument!"); 1031 1032 EmitCallArg(allocatorArgs, *placementArg, argType); 1033 } 1034 1035 // Either we've emitted all the call args, or we have a call to a 1036 // variadic function. 1037 assert((placementArg == E->placement_arg_end() || 1038 allocatorType->isVariadic()) && 1039 "Extra arguments to non-variadic function!"); 1040 1041 // If we still have any arguments, emit them using the type of the argument. 1042 for (CXXNewExpr::const_arg_iterator placementArgsEnd = E->placement_arg_end(); 1043 placementArg != placementArgsEnd; ++placementArg) { 1044 EmitCallArg(allocatorArgs, *placementArg, placementArg->getType()); 1045 } 1046 1047 // Emit the allocation call. If the allocator is a global placement 1048 // operator, just "inline" it directly. 1049 RValue RV; 1050 if (allocator->isReservedGlobalPlacementOperator()) { 1051 assert(allocatorArgs.size() == 2); 1052 RV = allocatorArgs[1].RV; 1053 // TODO: kill any unnecessary computations done for the size 1054 // argument. 1055 } else { 1056 RV = EmitCall(CGM.getTypes().getFunctionInfo(allocatorArgs, allocatorType), 1057 CGM.GetAddrOfFunction(allocator), ReturnValueSlot(), 1058 allocatorArgs, allocator); 1059 } 1060 1061 // Emit a null check on the allocation result if the allocation 1062 // function is allowed to return null (because it has a non-throwing 1063 // exception spec; for this part, we inline 1064 // CXXNewExpr::shouldNullCheckAllocation()) and we have an 1065 // interesting initializer. 1066 bool nullCheck = allocatorType->isNothrow(getContext()) && 1067 !(allocType.isPODType(getContext()) && !E->hasInitializer()); 1068 1069 llvm::BasicBlock *nullCheckBB = 0; 1070 llvm::BasicBlock *contBB = 0; 1071 1072 llvm::Value *allocation = RV.getScalarVal(); 1073 unsigned AS = 1074 cast<llvm::PointerType>(allocation->getType())->getAddressSpace(); 1075 1076 // The null-check means that the initializer is conditionally 1077 // evaluated. 1078 ConditionalEvaluation conditional(*this); 1079 1080 if (nullCheck) { 1081 conditional.begin(*this); 1082 1083 nullCheckBB = Builder.GetInsertBlock(); 1084 llvm::BasicBlock *notNullBB = createBasicBlock("new.notnull"); 1085 contBB = createBasicBlock("new.cont"); 1086 1087 llvm::Value *isNull = Builder.CreateIsNull(allocation, "new.isnull"); 1088 Builder.CreateCondBr(isNull, contBB, notNullBB); 1089 EmitBlock(notNullBB); 1090 } 1091 1092 assert((allocSize == allocSizeWithoutCookie) == 1093 CalculateCookiePadding(*this, E).isZero()); 1094 if (allocSize != allocSizeWithoutCookie) { 1095 assert(E->isArray()); 1096 allocation = CGM.getCXXABI().InitializeArrayCookie(*this, allocation, 1097 numElements, 1098 E, allocType); 1099 } 1100 1101 // If there's an operator delete, enter a cleanup to call it if an 1102 // exception is thrown. 1103 EHScopeStack::stable_iterator operatorDeleteCleanup; 1104 if (E->getOperatorDelete() && 1105 !E->getOperatorDelete()->isReservedGlobalPlacementOperator()) { 1106 EnterNewDeleteCleanup(*this, E, allocation, allocSize, allocatorArgs); 1107 operatorDeleteCleanup = EHStack.stable_begin(); 1108 } 1109 1110 llvm::Type *elementPtrTy 1111 = ConvertTypeForMem(allocType)->getPointerTo(AS); 1112 llvm::Value *result = Builder.CreateBitCast(allocation, elementPtrTy); 1113 1114 if (E->isArray()) { 1115 EmitNewInitializer(*this, E, result, numElements, allocSizeWithoutCookie); 1116 1117 // NewPtr is a pointer to the base element type. If we're 1118 // allocating an array of arrays, we'll need to cast back to the 1119 // array pointer type. 1120 llvm::Type *resultType = ConvertTypeForMem(E->getType()); 1121 if (result->getType() != resultType) 1122 result = Builder.CreateBitCast(result, resultType); 1123 } else { 1124 EmitNewInitializer(*this, E, result, numElements, allocSizeWithoutCookie); 1125 } 1126 1127 // Deactivate the 'operator delete' cleanup if we finished 1128 // initialization. 1129 if (operatorDeleteCleanup.isValid()) 1130 DeactivateCleanupBlock(operatorDeleteCleanup); 1131 1132 if (nullCheck) { 1133 conditional.end(*this); 1134 1135 llvm::BasicBlock *notNullBB = Builder.GetInsertBlock(); 1136 EmitBlock(contBB); 1137 1138 llvm::PHINode *PHI = Builder.CreatePHI(result->getType(), 2); 1139 PHI->addIncoming(result, notNullBB); 1140 PHI->addIncoming(llvm::Constant::getNullValue(result->getType()), 1141 nullCheckBB); 1142 1143 result = PHI; 1144 } 1145 1146 return result; 1147} 1148 1149void CodeGenFunction::EmitDeleteCall(const FunctionDecl *DeleteFD, 1150 llvm::Value *Ptr, 1151 QualType DeleteTy) { 1152 assert(DeleteFD->getOverloadedOperator() == OO_Delete); 1153 1154 const FunctionProtoType *DeleteFTy = 1155 DeleteFD->getType()->getAs<FunctionProtoType>(); 1156 1157 CallArgList DeleteArgs; 1158 1159 // Check if we need to pass the size to the delete operator. 1160 llvm::Value *Size = 0; 1161 QualType SizeTy; 1162 if (DeleteFTy->getNumArgs() == 2) { 1163 SizeTy = DeleteFTy->getArgType(1); 1164 CharUnits DeleteTypeSize = getContext().getTypeSizeInChars(DeleteTy); 1165 Size = llvm::ConstantInt::get(ConvertType(SizeTy), 1166 DeleteTypeSize.getQuantity()); 1167 } 1168 1169 QualType ArgTy = DeleteFTy->getArgType(0); 1170 llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy)); 1171 DeleteArgs.add(RValue::get(DeletePtr), ArgTy); 1172 1173 if (Size) 1174 DeleteArgs.add(RValue::get(Size), SizeTy); 1175 1176 // Emit the call to delete. 1177 EmitCall(CGM.getTypes().getFunctionInfo(DeleteArgs, DeleteFTy), 1178 CGM.GetAddrOfFunction(DeleteFD), ReturnValueSlot(), 1179 DeleteArgs, DeleteFD); 1180} 1181 1182namespace { 1183 /// Calls the given 'operator delete' on a single object. 1184 struct CallObjectDelete : EHScopeStack::Cleanup { 1185 llvm::Value *Ptr; 1186 const FunctionDecl *OperatorDelete; 1187 QualType ElementType; 1188 1189 CallObjectDelete(llvm::Value *Ptr, 1190 const FunctionDecl *OperatorDelete, 1191 QualType ElementType) 1192 : Ptr(Ptr), OperatorDelete(OperatorDelete), ElementType(ElementType) {} 1193 1194 void Emit(CodeGenFunction &CGF, Flags flags) { 1195 CGF.EmitDeleteCall(OperatorDelete, Ptr, ElementType); 1196 } 1197 }; 1198} 1199 1200/// Emit the code for deleting a single object. 1201static void EmitObjectDelete(CodeGenFunction &CGF, 1202 const FunctionDecl *OperatorDelete, 1203 llvm::Value *Ptr, 1204 QualType ElementType, 1205 bool UseGlobalDelete) { 1206 // Find the destructor for the type, if applicable. If the 1207 // destructor is virtual, we'll just emit the vcall and return. 1208 const CXXDestructorDecl *Dtor = 0; 1209 if (const RecordType *RT = ElementType->getAs<RecordType>()) { 1210 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1211 if (RD->hasDefinition() && !RD->hasTrivialDestructor()) { 1212 Dtor = RD->getDestructor(); 1213 1214 if (Dtor->isVirtual()) { 1215 if (UseGlobalDelete) { 1216 // If we're supposed to call the global delete, make sure we do so 1217 // even if the destructor throws. 1218 CGF.EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup, 1219 Ptr, OperatorDelete, 1220 ElementType); 1221 } 1222 1223 llvm::Type *Ty = 1224 CGF.getTypes().GetFunctionType(CGF.getTypes().getFunctionInfo(Dtor, 1225 Dtor_Complete), 1226 /*isVariadic=*/false); 1227 1228 llvm::Value *Callee 1229 = CGF.BuildVirtualCall(Dtor, 1230 UseGlobalDelete? Dtor_Complete : Dtor_Deleting, 1231 Ptr, Ty); 1232 CGF.EmitCXXMemberCall(Dtor, Callee, ReturnValueSlot(), Ptr, /*VTT=*/0, 1233 0, 0); 1234 1235 if (UseGlobalDelete) { 1236 CGF.PopCleanupBlock(); 1237 } 1238 1239 return; 1240 } 1241 } 1242 } 1243 1244 // Make sure that we call delete even if the dtor throws. 1245 // This doesn't have to a conditional cleanup because we're going 1246 // to pop it off in a second. 1247 CGF.EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup, 1248 Ptr, OperatorDelete, ElementType); 1249 1250 if (Dtor) 1251 CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete, 1252 /*ForVirtualBase=*/false, Ptr); 1253 else if (CGF.getLangOptions().ObjCAutoRefCount && 1254 ElementType->isObjCLifetimeType()) { 1255 switch (ElementType.getObjCLifetime()) { 1256 case Qualifiers::OCL_None: 1257 case Qualifiers::OCL_ExplicitNone: 1258 case Qualifiers::OCL_Autoreleasing: 1259 break; 1260 1261 case Qualifiers::OCL_Strong: { 1262 // Load the pointer value. 1263 llvm::Value *PtrValue = CGF.Builder.CreateLoad(Ptr, 1264 ElementType.isVolatileQualified()); 1265 1266 CGF.EmitARCRelease(PtrValue, /*precise*/ true); 1267 break; 1268 } 1269 1270 case Qualifiers::OCL_Weak: 1271 CGF.EmitARCDestroyWeak(Ptr); 1272 break; 1273 } 1274 } 1275 1276 CGF.PopCleanupBlock(); 1277} 1278 1279namespace { 1280 /// Calls the given 'operator delete' on an array of objects. 1281 struct CallArrayDelete : EHScopeStack::Cleanup { 1282 llvm::Value *Ptr; 1283 const FunctionDecl *OperatorDelete; 1284 llvm::Value *NumElements; 1285 QualType ElementType; 1286 CharUnits CookieSize; 1287 1288 CallArrayDelete(llvm::Value *Ptr, 1289 const FunctionDecl *OperatorDelete, 1290 llvm::Value *NumElements, 1291 QualType ElementType, 1292 CharUnits CookieSize) 1293 : Ptr(Ptr), OperatorDelete(OperatorDelete), NumElements(NumElements), 1294 ElementType(ElementType), CookieSize(CookieSize) {} 1295 1296 void Emit(CodeGenFunction &CGF, Flags flags) { 1297 const FunctionProtoType *DeleteFTy = 1298 OperatorDelete->getType()->getAs<FunctionProtoType>(); 1299 assert(DeleteFTy->getNumArgs() == 1 || DeleteFTy->getNumArgs() == 2); 1300 1301 CallArgList Args; 1302 1303 // Pass the pointer as the first argument. 1304 QualType VoidPtrTy = DeleteFTy->getArgType(0); 1305 llvm::Value *DeletePtr 1306 = CGF.Builder.CreateBitCast(Ptr, CGF.ConvertType(VoidPtrTy)); 1307 Args.add(RValue::get(DeletePtr), VoidPtrTy); 1308 1309 // Pass the original requested size as the second argument. 1310 if (DeleteFTy->getNumArgs() == 2) { 1311 QualType size_t = DeleteFTy->getArgType(1); 1312 llvm::IntegerType *SizeTy 1313 = cast<llvm::IntegerType>(CGF.ConvertType(size_t)); 1314 1315 CharUnits ElementTypeSize = 1316 CGF.CGM.getContext().getTypeSizeInChars(ElementType); 1317 1318 // The size of an element, multiplied by the number of elements. 1319 llvm::Value *Size 1320 = llvm::ConstantInt::get(SizeTy, ElementTypeSize.getQuantity()); 1321 Size = CGF.Builder.CreateMul(Size, NumElements); 1322 1323 // Plus the size of the cookie if applicable. 1324 if (!CookieSize.isZero()) { 1325 llvm::Value *CookieSizeV 1326 = llvm::ConstantInt::get(SizeTy, CookieSize.getQuantity()); 1327 Size = CGF.Builder.CreateAdd(Size, CookieSizeV); 1328 } 1329 1330 Args.add(RValue::get(Size), size_t); 1331 } 1332 1333 // Emit the call to delete. 1334 CGF.EmitCall(CGF.getTypes().getFunctionInfo(Args, DeleteFTy), 1335 CGF.CGM.GetAddrOfFunction(OperatorDelete), 1336 ReturnValueSlot(), Args, OperatorDelete); 1337 } 1338 }; 1339} 1340 1341/// Emit the code for deleting an array of objects. 1342static void EmitArrayDelete(CodeGenFunction &CGF, 1343 const CXXDeleteExpr *E, 1344 llvm::Value *deletedPtr, 1345 QualType elementType) { 1346 llvm::Value *numElements = 0; 1347 llvm::Value *allocatedPtr = 0; 1348 CharUnits cookieSize; 1349 CGF.CGM.getCXXABI().ReadArrayCookie(CGF, deletedPtr, E, elementType, 1350 numElements, allocatedPtr, cookieSize); 1351 1352 assert(allocatedPtr && "ReadArrayCookie didn't set allocated pointer"); 1353 1354 // Make sure that we call delete even if one of the dtors throws. 1355 const FunctionDecl *operatorDelete = E->getOperatorDelete(); 1356 CGF.EHStack.pushCleanup<CallArrayDelete>(NormalAndEHCleanup, 1357 allocatedPtr, operatorDelete, 1358 numElements, elementType, 1359 cookieSize); 1360 1361 // Destroy the elements. 1362 if (QualType::DestructionKind dtorKind = elementType.isDestructedType()) { 1363 assert(numElements && "no element count for a type with a destructor!"); 1364 1365 llvm::Value *arrayEnd = 1366 CGF.Builder.CreateInBoundsGEP(deletedPtr, numElements, "delete.end"); 1367 1368 // Note that it is legal to allocate a zero-length array, and we 1369 // can never fold the check away because the length should always 1370 // come from a cookie. 1371 CGF.emitArrayDestroy(deletedPtr, arrayEnd, elementType, 1372 CGF.getDestroyer(dtorKind), 1373 /*checkZeroLength*/ true, 1374 CGF.needsEHCleanup(dtorKind)); 1375 } 1376 1377 // Pop the cleanup block. 1378 CGF.PopCleanupBlock(); 1379} 1380 1381void CodeGenFunction::EmitCXXDeleteExpr(const CXXDeleteExpr *E) { 1382 1383 // Get at the argument before we performed the implicit conversion 1384 // to void*. 1385 const Expr *Arg = E->getArgument(); 1386 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) { 1387 if (ICE->getCastKind() != CK_UserDefinedConversion && 1388 ICE->getType()->isVoidPointerType()) 1389 Arg = ICE->getSubExpr(); 1390 else 1391 break; 1392 } 1393 1394 llvm::Value *Ptr = EmitScalarExpr(Arg); 1395 1396 // Null check the pointer. 1397 llvm::BasicBlock *DeleteNotNull = createBasicBlock("delete.notnull"); 1398 llvm::BasicBlock *DeleteEnd = createBasicBlock("delete.end"); 1399 1400 llvm::Value *IsNull = Builder.CreateIsNull(Ptr, "isnull"); 1401 1402 Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull); 1403 EmitBlock(DeleteNotNull); 1404 1405 // We might be deleting a pointer to array. If so, GEP down to the 1406 // first non-array element. 1407 // (this assumes that A(*)[3][7] is converted to [3 x [7 x %A]]*) 1408 QualType DeleteTy = Arg->getType()->getAs<PointerType>()->getPointeeType(); 1409 if (DeleteTy->isConstantArrayType()) { 1410 llvm::Value *Zero = Builder.getInt32(0); 1411 SmallVector<llvm::Value*,8> GEP; 1412 1413 GEP.push_back(Zero); // point at the outermost array 1414 1415 // For each layer of array type we're pointing at: 1416 while (const ConstantArrayType *Arr 1417 = getContext().getAsConstantArrayType(DeleteTy)) { 1418 // 1. Unpeel the array type. 1419 DeleteTy = Arr->getElementType(); 1420 1421 // 2. GEP to the first element of the array. 1422 GEP.push_back(Zero); 1423 } 1424 1425 Ptr = Builder.CreateInBoundsGEP(Ptr, GEP, "del.first"); 1426 } 1427 1428 assert(ConvertTypeForMem(DeleteTy) == 1429 cast<llvm::PointerType>(Ptr->getType())->getElementType()); 1430 1431 if (E->isArrayForm()) { 1432 EmitArrayDelete(*this, E, Ptr, DeleteTy); 1433 } else { 1434 EmitObjectDelete(*this, E->getOperatorDelete(), Ptr, DeleteTy, 1435 E->isGlobalDelete()); 1436 } 1437 1438 EmitBlock(DeleteEnd); 1439} 1440 1441static llvm::Constant *getBadTypeidFn(CodeGenFunction &CGF) { 1442 // void __cxa_bad_typeid(); 1443 1444 llvm::Type *VoidTy = llvm::Type::getVoidTy(CGF.getLLVMContext()); 1445 llvm::FunctionType *FTy = 1446 llvm::FunctionType::get(VoidTy, false); 1447 1448 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_typeid"); 1449} 1450 1451static void EmitBadTypeidCall(CodeGenFunction &CGF) { 1452 llvm::Value *Fn = getBadTypeidFn(CGF); 1453 CGF.EmitCallOrInvoke(Fn).setDoesNotReturn(); 1454 CGF.Builder.CreateUnreachable(); 1455} 1456 1457static llvm::Value *EmitTypeidFromVTable(CodeGenFunction &CGF, 1458 const Expr *E, 1459 llvm::Type *StdTypeInfoPtrTy) { 1460 // Get the vtable pointer. 1461 llvm::Value *ThisPtr = CGF.EmitLValue(E).getAddress(); 1462 1463 // C++ [expr.typeid]p2: 1464 // If the glvalue expression is obtained by applying the unary * operator to 1465 // a pointer and the pointer is a null pointer value, the typeid expression 1466 // throws the std::bad_typeid exception. 1467 if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParens())) { 1468 if (UO->getOpcode() == UO_Deref) { 1469 llvm::BasicBlock *BadTypeidBlock = 1470 CGF.createBasicBlock("typeid.bad_typeid"); 1471 llvm::BasicBlock *EndBlock = 1472 CGF.createBasicBlock("typeid.end"); 1473 1474 llvm::Value *IsNull = CGF.Builder.CreateIsNull(ThisPtr); 1475 CGF.Builder.CreateCondBr(IsNull, BadTypeidBlock, EndBlock); 1476 1477 CGF.EmitBlock(BadTypeidBlock); 1478 EmitBadTypeidCall(CGF); 1479 CGF.EmitBlock(EndBlock); 1480 } 1481 } 1482 1483 llvm::Value *Value = CGF.GetVTablePtr(ThisPtr, 1484 StdTypeInfoPtrTy->getPointerTo()); 1485 1486 // Load the type info. 1487 Value = CGF.Builder.CreateConstInBoundsGEP1_64(Value, -1ULL); 1488 return CGF.Builder.CreateLoad(Value); 1489} 1490 1491llvm::Value *CodeGenFunction::EmitCXXTypeidExpr(const CXXTypeidExpr *E) { 1492 llvm::Type *StdTypeInfoPtrTy = 1493 ConvertType(E->getType())->getPointerTo(); 1494 1495 if (E->isTypeOperand()) { 1496 llvm::Constant *TypeInfo = 1497 CGM.GetAddrOfRTTIDescriptor(E->getTypeOperand()); 1498 return Builder.CreateBitCast(TypeInfo, StdTypeInfoPtrTy); 1499 } 1500 1501 // C++ [expr.typeid]p2: 1502 // When typeid is applied to a glvalue expression whose type is a 1503 // polymorphic class type, the result refers to a std::type_info object 1504 // representing the type of the most derived object (that is, the dynamic 1505 // type) to which the glvalue refers. 1506 if (E->getExprOperand()->isGLValue()) { 1507 if (const RecordType *RT = 1508 E->getExprOperand()->getType()->getAs<RecordType>()) { 1509 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1510 if (RD->isPolymorphic()) 1511 return EmitTypeidFromVTable(*this, E->getExprOperand(), 1512 StdTypeInfoPtrTy); 1513 } 1514 } 1515 1516 QualType OperandTy = E->getExprOperand()->getType(); 1517 return Builder.CreateBitCast(CGM.GetAddrOfRTTIDescriptor(OperandTy), 1518 StdTypeInfoPtrTy); 1519} 1520 1521static llvm::Constant *getDynamicCastFn(CodeGenFunction &CGF) { 1522 // void *__dynamic_cast(const void *sub, 1523 // const abi::__class_type_info *src, 1524 // const abi::__class_type_info *dst, 1525 // std::ptrdiff_t src2dst_offset); 1526 1527 llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext()); 1528 llvm::Type *PtrDiffTy = 1529 CGF.ConvertType(CGF.getContext().getPointerDiffType()); 1530 1531 llvm::Type *Args[4] = { Int8PtrTy, Int8PtrTy, Int8PtrTy, PtrDiffTy }; 1532 1533 llvm::FunctionType *FTy = 1534 llvm::FunctionType::get(Int8PtrTy, Args, false); 1535 1536 return CGF.CGM.CreateRuntimeFunction(FTy, "__dynamic_cast"); 1537} 1538 1539static llvm::Constant *getBadCastFn(CodeGenFunction &CGF) { 1540 // void __cxa_bad_cast(); 1541 1542 llvm::Type *VoidTy = llvm::Type::getVoidTy(CGF.getLLVMContext()); 1543 llvm::FunctionType *FTy = 1544 llvm::FunctionType::get(VoidTy, false); 1545 1546 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_cast"); 1547} 1548 1549static void EmitBadCastCall(CodeGenFunction &CGF) { 1550 llvm::Value *Fn = getBadCastFn(CGF); 1551 CGF.EmitCallOrInvoke(Fn).setDoesNotReturn(); 1552 CGF.Builder.CreateUnreachable(); 1553} 1554 1555static llvm::Value * 1556EmitDynamicCastCall(CodeGenFunction &CGF, llvm::Value *Value, 1557 QualType SrcTy, QualType DestTy, 1558 llvm::BasicBlock *CastEnd) { 1559 llvm::Type *PtrDiffLTy = 1560 CGF.ConvertType(CGF.getContext().getPointerDiffType()); 1561 llvm::Type *DestLTy = CGF.ConvertType(DestTy); 1562 1563 if (const PointerType *PTy = DestTy->getAs<PointerType>()) { 1564 if (PTy->getPointeeType()->isVoidType()) { 1565 // C++ [expr.dynamic.cast]p7: 1566 // If T is "pointer to cv void," then the result is a pointer to the 1567 // most derived object pointed to by v. 1568 1569 // Get the vtable pointer. 1570 llvm::Value *VTable = CGF.GetVTablePtr(Value, PtrDiffLTy->getPointerTo()); 1571 1572 // Get the offset-to-top from the vtable. 1573 llvm::Value *OffsetToTop = 1574 CGF.Builder.CreateConstInBoundsGEP1_64(VTable, -2ULL); 1575 OffsetToTop = CGF.Builder.CreateLoad(OffsetToTop, "offset.to.top"); 1576 1577 // Finally, add the offset to the pointer. 1578 Value = CGF.EmitCastToVoidPtr(Value); 1579 Value = CGF.Builder.CreateInBoundsGEP(Value, OffsetToTop); 1580 1581 return CGF.Builder.CreateBitCast(Value, DestLTy); 1582 } 1583 } 1584 1585 QualType SrcRecordTy; 1586 QualType DestRecordTy; 1587 1588 if (const PointerType *DestPTy = DestTy->getAs<PointerType>()) { 1589 SrcRecordTy = SrcTy->castAs<PointerType>()->getPointeeType(); 1590 DestRecordTy = DestPTy->getPointeeType(); 1591 } else { 1592 SrcRecordTy = SrcTy; 1593 DestRecordTy = DestTy->castAs<ReferenceType>()->getPointeeType(); 1594 } 1595 1596 assert(SrcRecordTy->isRecordType() && "source type must be a record type!"); 1597 assert(DestRecordTy->isRecordType() && "dest type must be a record type!"); 1598 1599 llvm::Value *SrcRTTI = 1600 CGF.CGM.GetAddrOfRTTIDescriptor(SrcRecordTy.getUnqualifiedType()); 1601 llvm::Value *DestRTTI = 1602 CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType()); 1603 1604 // FIXME: Actually compute a hint here. 1605 llvm::Value *OffsetHint = llvm::ConstantInt::get(PtrDiffLTy, -1ULL); 1606 1607 // Emit the call to __dynamic_cast. 1608 Value = CGF.EmitCastToVoidPtr(Value); 1609 Value = CGF.Builder.CreateCall4(getDynamicCastFn(CGF), Value, 1610 SrcRTTI, DestRTTI, OffsetHint); 1611 Value = CGF.Builder.CreateBitCast(Value, DestLTy); 1612 1613 /// C++ [expr.dynamic.cast]p9: 1614 /// A failed cast to reference type throws std::bad_cast 1615 if (DestTy->isReferenceType()) { 1616 llvm::BasicBlock *BadCastBlock = 1617 CGF.createBasicBlock("dynamic_cast.bad_cast"); 1618 1619 llvm::Value *IsNull = CGF.Builder.CreateIsNull(Value); 1620 CGF.Builder.CreateCondBr(IsNull, BadCastBlock, CastEnd); 1621 1622 CGF.EmitBlock(BadCastBlock); 1623 EmitBadCastCall(CGF); 1624 } 1625 1626 return Value; 1627} 1628 1629static llvm::Value *EmitDynamicCastToNull(CodeGenFunction &CGF, 1630 QualType DestTy) { 1631 llvm::Type *DestLTy = CGF.ConvertType(DestTy); 1632 if (DestTy->isPointerType()) 1633 return llvm::Constant::getNullValue(DestLTy); 1634 1635 /// C++ [expr.dynamic.cast]p9: 1636 /// A failed cast to reference type throws std::bad_cast 1637 EmitBadCastCall(CGF); 1638 1639 CGF.EmitBlock(CGF.createBasicBlock("dynamic_cast.end")); 1640 return llvm::UndefValue::get(DestLTy); 1641} 1642 1643llvm::Value *CodeGenFunction::EmitDynamicCast(llvm::Value *Value, 1644 const CXXDynamicCastExpr *DCE) { 1645 QualType DestTy = DCE->getTypeAsWritten(); 1646 1647 if (DCE->isAlwaysNull()) 1648 return EmitDynamicCastToNull(*this, DestTy); 1649 1650 QualType SrcTy = DCE->getSubExpr()->getType(); 1651 1652 // C++ [expr.dynamic.cast]p4: 1653 // If the value of v is a null pointer value in the pointer case, the result 1654 // is the null pointer value of type T. 1655 bool ShouldNullCheckSrcValue = SrcTy->isPointerType(); 1656 1657 llvm::BasicBlock *CastNull = 0; 1658 llvm::BasicBlock *CastNotNull = 0; 1659 llvm::BasicBlock *CastEnd = createBasicBlock("dynamic_cast.end"); 1660 1661 if (ShouldNullCheckSrcValue) { 1662 CastNull = createBasicBlock("dynamic_cast.null"); 1663 CastNotNull = createBasicBlock("dynamic_cast.notnull"); 1664 1665 llvm::Value *IsNull = Builder.CreateIsNull(Value); 1666 Builder.CreateCondBr(IsNull, CastNull, CastNotNull); 1667 EmitBlock(CastNotNull); 1668 } 1669 1670 Value = EmitDynamicCastCall(*this, Value, SrcTy, DestTy, CastEnd); 1671 1672 if (ShouldNullCheckSrcValue) { 1673 EmitBranch(CastEnd); 1674 1675 EmitBlock(CastNull); 1676 EmitBranch(CastEnd); 1677 } 1678 1679 EmitBlock(CastEnd); 1680 1681 if (ShouldNullCheckSrcValue) { 1682 llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2); 1683 PHI->addIncoming(Value, CastNotNull); 1684 PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), CastNull); 1685 1686 Value = PHI; 1687 } 1688 1689 return Value; 1690} 1691