1 //===--- SemaExceptionSpec.cpp - C++ Exception Specifications ---*- C++ -*-===// 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 file provides Sema routines for C++ exception specification testing. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Sema/SemaInternal.h" 15 #include "clang/AST/CXXInheritance.h" 16 #include "clang/AST/Expr.h" 17 #include "clang/AST/ExprCXX.h" 18 #include "clang/AST/TypeLoc.h" 19 #include "clang/Basic/Diagnostic.h" 20 #include "clang/Basic/SourceManager.h" 21 #include "clang/Lex/Preprocessor.h" 22 #include "llvm/ADT/SmallPtrSet.h" 23 #include "llvm/ADT/SmallString.h" 24 25 namespace clang { 26 27 static const FunctionProtoType *GetUnderlyingFunction(QualType T) 28 { 29 if (const PointerType *PtrTy = T->getAs<PointerType>()) 30 T = PtrTy->getPointeeType(); 31 else if (const ReferenceType *RefTy = T->getAs<ReferenceType>()) 32 T = RefTy->getPointeeType(); 33 else if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>()) 34 T = MPTy->getPointeeType(); 35 return T->getAs<FunctionProtoType>(); 36 } 37 38 /// CheckSpecifiedExceptionType - Check if the given type is valid in an 39 /// exception specification. Incomplete types, or pointers to incomplete types 40 /// other than void are not allowed. 41 /// 42 /// \param[in,out] T The exception type. This will be decayed to a pointer type 43 /// when the input is an array or a function type. 44 bool Sema::CheckSpecifiedExceptionType(QualType &T, const SourceRange &Range) { 45 // C++11 [except.spec]p2: 46 // A type cv T, "array of T", or "function returning T" denoted 47 // in an exception-specification is adjusted to type T, "pointer to T", or 48 // "pointer to function returning T", respectively. 49 // 50 // We also apply this rule in C++98. 51 if (T->isArrayType()) 52 T = Context.getArrayDecayedType(T); 53 else if (T->isFunctionType()) 54 T = Context.getPointerType(T); 55 56 int Kind = 0; 57 QualType PointeeT = T; 58 if (const PointerType *PT = T->getAs<PointerType>()) { 59 PointeeT = PT->getPointeeType(); 60 Kind = 1; 61 62 // cv void* is explicitly permitted, despite being a pointer to an 63 // incomplete type. 64 if (PointeeT->isVoidType()) 65 return false; 66 } else if (const ReferenceType *RT = T->getAs<ReferenceType>()) { 67 PointeeT = RT->getPointeeType(); 68 Kind = 2; 69 70 if (RT->isRValueReferenceType()) { 71 // C++11 [except.spec]p2: 72 // A type denoted in an exception-specification shall not denote [...] 73 // an rvalue reference type. 74 Diag(Range.getBegin(), diag::err_rref_in_exception_spec) 75 << T << Range; 76 return true; 77 } 78 } 79 80 // C++11 [except.spec]p2: 81 // A type denoted in an exception-specification shall not denote an 82 // incomplete type other than a class currently being defined [...]. 83 // A type denoted in an exception-specification shall not denote a 84 // pointer or reference to an incomplete type, other than (cv) void* or a 85 // pointer or reference to a class currently being defined. 86 if (!(PointeeT->isRecordType() && 87 PointeeT->getAs<RecordType>()->isBeingDefined()) && 88 RequireCompleteType(Range.getBegin(), PointeeT, 89 diag::err_incomplete_in_exception_spec, Kind, Range)) 90 return true; 91 92 return false; 93 } 94 95 /// CheckDistantExceptionSpec - Check if the given type is a pointer or pointer 96 /// to member to a function with an exception specification. This means that 97 /// it is invalid to add another level of indirection. 98 bool Sema::CheckDistantExceptionSpec(QualType T) { 99 if (const PointerType *PT = T->getAs<PointerType>()) 100 T = PT->getPointeeType(); 101 else if (const MemberPointerType *PT = T->getAs<MemberPointerType>()) 102 T = PT->getPointeeType(); 103 else 104 return false; 105 106 const FunctionProtoType *FnT = T->getAs<FunctionProtoType>(); 107 if (!FnT) 108 return false; 109 110 return FnT->hasExceptionSpec(); 111 } 112 113 const FunctionProtoType * 114 Sema::ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT) { 115 if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) 116 return FPT; 117 118 FunctionDecl *SourceDecl = FPT->getExceptionSpecDecl(); 119 const FunctionProtoType *SourceFPT = 120 SourceDecl->getType()->castAs<FunctionProtoType>(); 121 122 // If the exception specification has already been resolved, just return it. 123 if (!isUnresolvedExceptionSpec(SourceFPT->getExceptionSpecType())) 124 return SourceFPT; 125 126 // Compute or instantiate the exception specification now. 127 if (FPT->getExceptionSpecType() == EST_Unevaluated) 128 EvaluateImplicitExceptionSpec(Loc, cast<CXXMethodDecl>(SourceDecl)); 129 else 130 InstantiateExceptionSpec(Loc, SourceDecl); 131 132 return SourceDecl->getType()->castAs<FunctionProtoType>(); 133 } 134 135 /// Determine whether a function has an implicitly-generated exception 136 /// specification. 137 static bool hasImplicitExceptionSpec(FunctionDecl *Decl) { 138 if (!isa<CXXDestructorDecl>(Decl) && 139 Decl->getDeclName().getCXXOverloadedOperator() != OO_Delete && 140 Decl->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete) 141 return false; 142 143 // If the user didn't declare the function, its exception specification must 144 // be implicit. 145 if (!Decl->getTypeSourceInfo()) 146 return true; 147 148 const FunctionProtoType *Ty = 149 Decl->getTypeSourceInfo()->getType()->getAs<FunctionProtoType>(); 150 return !Ty->hasExceptionSpec(); 151 } 152 153 bool Sema::CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New) { 154 OverloadedOperatorKind OO = New->getDeclName().getCXXOverloadedOperator(); 155 bool IsOperatorNew = OO == OO_New || OO == OO_Array_New; 156 bool MissingExceptionSpecification = false; 157 bool MissingEmptyExceptionSpecification = false; 158 unsigned DiagID = diag::err_mismatched_exception_spec; 159 if (getLangOpts().MicrosoftExt) 160 DiagID = diag::warn_mismatched_exception_spec; 161 162 // Check the types as written: they must match before any exception 163 // specification adjustment is applied. 164 if (!CheckEquivalentExceptionSpec( 165 PDiag(DiagID), PDiag(diag::note_previous_declaration), 166 Old->getType()->getAs<FunctionProtoType>(), Old->getLocation(), 167 New->getType()->getAs<FunctionProtoType>(), New->getLocation(), 168 &MissingExceptionSpecification, &MissingEmptyExceptionSpecification, 169 /*AllowNoexceptAllMatchWithNoSpec=*/true, IsOperatorNew)) { 170 // C++11 [except.spec]p4 [DR1492]: 171 // If a declaration of a function has an implicit 172 // exception-specification, other declarations of the function shall 173 // not specify an exception-specification. 174 if (getLangOpts().CPlusPlus11 && 175 hasImplicitExceptionSpec(Old) != hasImplicitExceptionSpec(New)) { 176 Diag(New->getLocation(), diag::ext_implicit_exception_spec_mismatch) 177 << hasImplicitExceptionSpec(Old); 178 if (!Old->getLocation().isInvalid()) 179 Diag(Old->getLocation(), diag::note_previous_declaration); 180 } 181 return false; 182 } 183 184 // The failure was something other than an empty exception 185 // specification; return an error. 186 if (!MissingExceptionSpecification && !MissingEmptyExceptionSpecification) 187 return true; 188 189 const FunctionProtoType *NewProto = 190 New->getType()->getAs<FunctionProtoType>(); 191 192 // The new function declaration is only missing an empty exception 193 // specification "throw()". If the throw() specification came from a 194 // function in a system header that has C linkage, just add an empty 195 // exception specification to the "new" declaration. This is an 196 // egregious workaround for glibc, which adds throw() specifications 197 // to many libc functions as an optimization. Unfortunately, that 198 // optimization isn't permitted by the C++ standard, so we're forced 199 // to work around it here. 200 if (MissingEmptyExceptionSpecification && NewProto && 201 (Old->getLocation().isInvalid() || 202 Context.getSourceManager().isInSystemHeader(Old->getLocation())) && 203 Old->isExternC()) { 204 FunctionProtoType::ExtProtoInfo EPI = NewProto->getExtProtoInfo(); 205 EPI.ExceptionSpecType = EST_DynamicNone; 206 QualType NewType = 207 Context.getFunctionType(NewProto->getResultType(), 208 ArrayRef<QualType>(NewProto->arg_type_begin(), 209 NewProto->getNumArgs()), 210 EPI); 211 New->setType(NewType); 212 return false; 213 } 214 215 if (MissingExceptionSpecification && NewProto) { 216 const FunctionProtoType *OldProto = 217 Old->getType()->getAs<FunctionProtoType>(); 218 219 FunctionProtoType::ExtProtoInfo EPI = NewProto->getExtProtoInfo(); 220 EPI.ExceptionSpecType = OldProto->getExceptionSpecType(); 221 if (EPI.ExceptionSpecType == EST_Dynamic) { 222 EPI.NumExceptions = OldProto->getNumExceptions(); 223 EPI.Exceptions = OldProto->exception_begin(); 224 } else if (EPI.ExceptionSpecType == EST_ComputedNoexcept) { 225 // FIXME: We can't just take the expression from the old prototype. It 226 // likely contains references to the old prototype's parameters. 227 } 228 229 // Update the type of the function with the appropriate exception 230 // specification. 231 QualType NewType = 232 Context.getFunctionType(NewProto->getResultType(), 233 ArrayRef<QualType>(NewProto->arg_type_begin(), 234 NewProto->getNumArgs()), 235 EPI); 236 New->setType(NewType); 237 238 // If exceptions are disabled, suppress the warning about missing 239 // exception specifications for new and delete operators. 240 if (!getLangOpts().CXXExceptions) { 241 switch (New->getDeclName().getCXXOverloadedOperator()) { 242 case OO_New: 243 case OO_Array_New: 244 case OO_Delete: 245 case OO_Array_Delete: 246 if (New->getDeclContext()->isTranslationUnit()) 247 return false; 248 break; 249 250 default: 251 break; 252 } 253 } 254 255 // Warn about the lack of exception specification. 256 SmallString<128> ExceptionSpecString; 257 llvm::raw_svector_ostream OS(ExceptionSpecString); 258 switch (OldProto->getExceptionSpecType()) { 259 case EST_DynamicNone: 260 OS << "throw()"; 261 break; 262 263 case EST_Dynamic: { 264 OS << "throw("; 265 bool OnFirstException = true; 266 for (FunctionProtoType::exception_iterator E = OldProto->exception_begin(), 267 EEnd = OldProto->exception_end(); 268 E != EEnd; 269 ++E) { 270 if (OnFirstException) 271 OnFirstException = false; 272 else 273 OS << ", "; 274 275 OS << E->getAsString(getPrintingPolicy()); 276 } 277 OS << ")"; 278 break; 279 } 280 281 case EST_BasicNoexcept: 282 OS << "noexcept"; 283 break; 284 285 case EST_ComputedNoexcept: 286 OS << "noexcept("; 287 OldProto->getNoexceptExpr()->printPretty(OS, 0, getPrintingPolicy()); 288 OS << ")"; 289 break; 290 291 default: 292 llvm_unreachable("This spec type is compatible with none."); 293 } 294 OS.flush(); 295 296 SourceLocation FixItLoc; 297 if (TypeSourceInfo *TSInfo = New->getTypeSourceInfo()) { 298 TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens(); 299 if (FunctionTypeLoc FTLoc = TL.getAs<FunctionTypeLoc>()) 300 FixItLoc = PP.getLocForEndOfToken(FTLoc.getLocalRangeEnd()); 301 } 302 303 if (FixItLoc.isInvalid()) 304 Diag(New->getLocation(), diag::warn_missing_exception_specification) 305 << New << OS.str(); 306 else { 307 // FIXME: This will get more complicated with C++0x 308 // late-specified return types. 309 Diag(New->getLocation(), diag::warn_missing_exception_specification) 310 << New << OS.str() 311 << FixItHint::CreateInsertion(FixItLoc, " " + OS.str().str()); 312 } 313 314 if (!Old->getLocation().isInvalid()) 315 Diag(Old->getLocation(), diag::note_previous_declaration); 316 317 return false; 318 } 319 320 Diag(New->getLocation(), DiagID); 321 Diag(Old->getLocation(), diag::note_previous_declaration); 322 return true; 323 } 324 325 /// CheckEquivalentExceptionSpec - Check if the two types have equivalent 326 /// exception specifications. Exception specifications are equivalent if 327 /// they allow exactly the same set of exception types. It does not matter how 328 /// that is achieved. See C++ [except.spec]p2. 329 bool Sema::CheckEquivalentExceptionSpec( 330 const FunctionProtoType *Old, SourceLocation OldLoc, 331 const FunctionProtoType *New, SourceLocation NewLoc) { 332 unsigned DiagID = diag::err_mismatched_exception_spec; 333 if (getLangOpts().MicrosoftExt) 334 DiagID = diag::warn_mismatched_exception_spec; 335 return CheckEquivalentExceptionSpec(PDiag(DiagID), 336 PDiag(diag::note_previous_declaration), 337 Old, OldLoc, New, NewLoc); 338 } 339 340 /// CheckEquivalentExceptionSpec - Check if the two types have compatible 341 /// exception specifications. See C++ [except.spec]p3. 342 /// 343 /// \return \c false if the exception specifications match, \c true if there is 344 /// a problem. If \c true is returned, either a diagnostic has already been 345 /// produced or \c *MissingExceptionSpecification is set to \c true. 346 bool Sema::CheckEquivalentExceptionSpec(const PartialDiagnostic &DiagID, 347 const PartialDiagnostic & NoteID, 348 const FunctionProtoType *Old, 349 SourceLocation OldLoc, 350 const FunctionProtoType *New, 351 SourceLocation NewLoc, 352 bool *MissingExceptionSpecification, 353 bool*MissingEmptyExceptionSpecification, 354 bool AllowNoexceptAllMatchWithNoSpec, 355 bool IsOperatorNew) { 356 // Just completely ignore this under -fno-exceptions. 357 if (!getLangOpts().CXXExceptions) 358 return false; 359 360 if (MissingExceptionSpecification) 361 *MissingExceptionSpecification = false; 362 363 if (MissingEmptyExceptionSpecification) 364 *MissingEmptyExceptionSpecification = false; 365 366 Old = ResolveExceptionSpec(NewLoc, Old); 367 if (!Old) 368 return false; 369 New = ResolveExceptionSpec(NewLoc, New); 370 if (!New) 371 return false; 372 373 // C++0x [except.spec]p3: Two exception-specifications are compatible if: 374 // - both are non-throwing, regardless of their form, 375 // - both have the form noexcept(constant-expression) and the constant- 376 // expressions are equivalent, 377 // - both are dynamic-exception-specifications that have the same set of 378 // adjusted types. 379 // 380 // C++0x [except.spec]p12: An exception-specifcation is non-throwing if it is 381 // of the form throw(), noexcept, or noexcept(constant-expression) where the 382 // constant-expression yields true. 383 // 384 // C++0x [except.spec]p4: If any declaration of a function has an exception- 385 // specifier that is not a noexcept-specification allowing all exceptions, 386 // all declarations [...] of that function shall have a compatible 387 // exception-specification. 388 // 389 // That last point basically means that noexcept(false) matches no spec. 390 // It's considered when AllowNoexceptAllMatchWithNoSpec is true. 391 392 ExceptionSpecificationType OldEST = Old->getExceptionSpecType(); 393 ExceptionSpecificationType NewEST = New->getExceptionSpecType(); 394 395 assert(!isUnresolvedExceptionSpec(OldEST) && 396 !isUnresolvedExceptionSpec(NewEST) && 397 "Shouldn't see unknown exception specifications here"); 398 399 // Shortcut the case where both have no spec. 400 if (OldEST == EST_None && NewEST == EST_None) 401 return false; 402 403 FunctionProtoType::NoexceptResult OldNR = Old->getNoexceptSpec(Context); 404 FunctionProtoType::NoexceptResult NewNR = New->getNoexceptSpec(Context); 405 if (OldNR == FunctionProtoType::NR_BadNoexcept || 406 NewNR == FunctionProtoType::NR_BadNoexcept) 407 return false; 408 409 // Dependent noexcept specifiers are compatible with each other, but nothing 410 // else. 411 // One noexcept is compatible with another if the argument is the same 412 if (OldNR == NewNR && 413 OldNR != FunctionProtoType::NR_NoNoexcept && 414 NewNR != FunctionProtoType::NR_NoNoexcept) 415 return false; 416 if (OldNR != NewNR && 417 OldNR != FunctionProtoType::NR_NoNoexcept && 418 NewNR != FunctionProtoType::NR_NoNoexcept) { 419 Diag(NewLoc, DiagID); 420 if (NoteID.getDiagID() != 0) 421 Diag(OldLoc, NoteID); 422 return true; 423 } 424 425 // The MS extension throw(...) is compatible with itself. 426 if (OldEST == EST_MSAny && NewEST == EST_MSAny) 427 return false; 428 429 // It's also compatible with no spec. 430 if ((OldEST == EST_None && NewEST == EST_MSAny) || 431 (OldEST == EST_MSAny && NewEST == EST_None)) 432 return false; 433 434 // It's also compatible with noexcept(false). 435 if (OldEST == EST_MSAny && NewNR == FunctionProtoType::NR_Throw) 436 return false; 437 if (NewEST == EST_MSAny && OldNR == FunctionProtoType::NR_Throw) 438 return false; 439 440 // As described above, noexcept(false) matches no spec only for functions. 441 if (AllowNoexceptAllMatchWithNoSpec) { 442 if (OldEST == EST_None && NewNR == FunctionProtoType::NR_Throw) 443 return false; 444 if (NewEST == EST_None && OldNR == FunctionProtoType::NR_Throw) 445 return false; 446 } 447 448 // Any non-throwing specifications are compatible. 449 bool OldNonThrowing = OldNR == FunctionProtoType::NR_Nothrow || 450 OldEST == EST_DynamicNone; 451 bool NewNonThrowing = NewNR == FunctionProtoType::NR_Nothrow || 452 NewEST == EST_DynamicNone; 453 if (OldNonThrowing && NewNonThrowing) 454 return false; 455 456 // As a special compatibility feature, under C++0x we accept no spec and 457 // throw(std::bad_alloc) as equivalent for operator new and operator new[]. 458 // This is because the implicit declaration changed, but old code would break. 459 if (getLangOpts().CPlusPlus11 && IsOperatorNew) { 460 const FunctionProtoType *WithExceptions = 0; 461 if (OldEST == EST_None && NewEST == EST_Dynamic) 462 WithExceptions = New; 463 else if (OldEST == EST_Dynamic && NewEST == EST_None) 464 WithExceptions = Old; 465 if (WithExceptions && WithExceptions->getNumExceptions() == 1) { 466 // One has no spec, the other throw(something). If that something is 467 // std::bad_alloc, all conditions are met. 468 QualType Exception = *WithExceptions->exception_begin(); 469 if (CXXRecordDecl *ExRecord = Exception->getAsCXXRecordDecl()) { 470 IdentifierInfo* Name = ExRecord->getIdentifier(); 471 if (Name && Name->getName() == "bad_alloc") { 472 // It's called bad_alloc, but is it in std? 473 DeclContext* DC = ExRecord->getDeclContext(); 474 DC = DC->getEnclosingNamespaceContext(); 475 if (NamespaceDecl* NS = dyn_cast<NamespaceDecl>(DC)) { 476 IdentifierInfo* NSName = NS->getIdentifier(); 477 DC = DC->getParent(); 478 if (NSName && NSName->getName() == "std" && 479 DC->getEnclosingNamespaceContext()->isTranslationUnit()) { 480 return false; 481 } 482 } 483 } 484 } 485 } 486 } 487 488 // At this point, the only remaining valid case is two matching dynamic 489 // specifications. We return here unless both specifications are dynamic. 490 if (OldEST != EST_Dynamic || NewEST != EST_Dynamic) { 491 if (MissingExceptionSpecification && Old->hasExceptionSpec() && 492 !New->hasExceptionSpec()) { 493 // The old type has an exception specification of some sort, but 494 // the new type does not. 495 *MissingExceptionSpecification = true; 496 497 if (MissingEmptyExceptionSpecification && OldNonThrowing) { 498 // The old type has a throw() or noexcept(true) exception specification 499 // and the new type has no exception specification, and the caller asked 500 // to handle this itself. 501 *MissingEmptyExceptionSpecification = true; 502 } 503 504 return true; 505 } 506 507 Diag(NewLoc, DiagID); 508 if (NoteID.getDiagID() != 0) 509 Diag(OldLoc, NoteID); 510 return true; 511 } 512 513 assert(OldEST == EST_Dynamic && NewEST == EST_Dynamic && 514 "Exception compatibility logic error: non-dynamic spec slipped through."); 515 516 bool Success = true; 517 // Both have a dynamic exception spec. Collect the first set, then compare 518 // to the second. 519 llvm::SmallPtrSet<CanQualType, 8> OldTypes, NewTypes; 520 for (FunctionProtoType::exception_iterator I = Old->exception_begin(), 521 E = Old->exception_end(); I != E; ++I) 522 OldTypes.insert(Context.getCanonicalType(*I).getUnqualifiedType()); 523 524 for (FunctionProtoType::exception_iterator I = New->exception_begin(), 525 E = New->exception_end(); I != E && Success; ++I) { 526 CanQualType TypePtr = Context.getCanonicalType(*I).getUnqualifiedType(); 527 if(OldTypes.count(TypePtr)) 528 NewTypes.insert(TypePtr); 529 else 530 Success = false; 531 } 532 533 Success = Success && OldTypes.size() == NewTypes.size(); 534 535 if (Success) { 536 return false; 537 } 538 Diag(NewLoc, DiagID); 539 if (NoteID.getDiagID() != 0) 540 Diag(OldLoc, NoteID); 541 return true; 542 } 543 544 /// CheckExceptionSpecSubset - Check whether the second function type's 545 /// exception specification is a subset (or equivalent) of the first function 546 /// type. This is used by override and pointer assignment checks. 547 bool Sema::CheckExceptionSpecSubset( 548 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID, 549 const FunctionProtoType *Superset, SourceLocation SuperLoc, 550 const FunctionProtoType *Subset, SourceLocation SubLoc) { 551 552 // Just auto-succeed under -fno-exceptions. 553 if (!getLangOpts().CXXExceptions) 554 return false; 555 556 // FIXME: As usual, we could be more specific in our error messages, but 557 // that better waits until we've got types with source locations. 558 559 if (!SubLoc.isValid()) 560 SubLoc = SuperLoc; 561 562 // Resolve the exception specifications, if needed. 563 Superset = ResolveExceptionSpec(SuperLoc, Superset); 564 if (!Superset) 565 return false; 566 Subset = ResolveExceptionSpec(SubLoc, Subset); 567 if (!Subset) 568 return false; 569 570 ExceptionSpecificationType SuperEST = Superset->getExceptionSpecType(); 571 572 // If superset contains everything, we're done. 573 if (SuperEST == EST_None || SuperEST == EST_MSAny) 574 return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); 575 576 // If there are dependent noexcept specs, assume everything is fine. Unlike 577 // with the equivalency check, this is safe in this case, because we don't 578 // want to merge declarations. Checks after instantiation will catch any 579 // omissions we make here. 580 // We also shortcut checking if a noexcept expression was bad. 581 582 FunctionProtoType::NoexceptResult SuperNR =Superset->getNoexceptSpec(Context); 583 if (SuperNR == FunctionProtoType::NR_BadNoexcept || 584 SuperNR == FunctionProtoType::NR_Dependent) 585 return false; 586 587 // Another case of the superset containing everything. 588 if (SuperNR == FunctionProtoType::NR_Throw) 589 return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); 590 591 ExceptionSpecificationType SubEST = Subset->getExceptionSpecType(); 592 593 assert(!isUnresolvedExceptionSpec(SuperEST) && 594 !isUnresolvedExceptionSpec(SubEST) && 595 "Shouldn't see unknown exception specifications here"); 596 597 // It does not. If the subset contains everything, we've failed. 598 if (SubEST == EST_None || SubEST == EST_MSAny) { 599 Diag(SubLoc, DiagID); 600 if (NoteID.getDiagID() != 0) 601 Diag(SuperLoc, NoteID); 602 return true; 603 } 604 605 FunctionProtoType::NoexceptResult SubNR = Subset->getNoexceptSpec(Context); 606 if (SubNR == FunctionProtoType::NR_BadNoexcept || 607 SubNR == FunctionProtoType::NR_Dependent) 608 return false; 609 610 // Another case of the subset containing everything. 611 if (SubNR == FunctionProtoType::NR_Throw) { 612 Diag(SubLoc, DiagID); 613 if (NoteID.getDiagID() != 0) 614 Diag(SuperLoc, NoteID); 615 return true; 616 } 617 618 // If the subset contains nothing, we're done. 619 if (SubEST == EST_DynamicNone || SubNR == FunctionProtoType::NR_Nothrow) 620 return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); 621 622 // Otherwise, if the superset contains nothing, we've failed. 623 if (SuperEST == EST_DynamicNone || SuperNR == FunctionProtoType::NR_Nothrow) { 624 Diag(SubLoc, DiagID); 625 if (NoteID.getDiagID() != 0) 626 Diag(SuperLoc, NoteID); 627 return true; 628 } 629 630 assert(SuperEST == EST_Dynamic && SubEST == EST_Dynamic && 631 "Exception spec subset: non-dynamic case slipped through."); 632 633 // Neither contains everything or nothing. Do a proper comparison. 634 for (FunctionProtoType::exception_iterator SubI = Subset->exception_begin(), 635 SubE = Subset->exception_end(); SubI != SubE; ++SubI) { 636 // Take one type from the subset. 637 QualType CanonicalSubT = Context.getCanonicalType(*SubI); 638 // Unwrap pointers and references so that we can do checks within a class 639 // hierarchy. Don't unwrap member pointers; they don't have hierarchy 640 // conversions on the pointee. 641 bool SubIsPointer = false; 642 if (const ReferenceType *RefTy = CanonicalSubT->getAs<ReferenceType>()) 643 CanonicalSubT = RefTy->getPointeeType(); 644 if (const PointerType *PtrTy = CanonicalSubT->getAs<PointerType>()) { 645 CanonicalSubT = PtrTy->getPointeeType(); 646 SubIsPointer = true; 647 } 648 bool SubIsClass = CanonicalSubT->isRecordType(); 649 CanonicalSubT = CanonicalSubT.getLocalUnqualifiedType(); 650 651 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 652 /*DetectVirtual=*/false); 653 654 bool Contained = false; 655 // Make sure it's in the superset. 656 for (FunctionProtoType::exception_iterator SuperI = 657 Superset->exception_begin(), SuperE = Superset->exception_end(); 658 SuperI != SuperE; ++SuperI) { 659 QualType CanonicalSuperT = Context.getCanonicalType(*SuperI); 660 // SubT must be SuperT or derived from it, or pointer or reference to 661 // such types. 662 if (const ReferenceType *RefTy = CanonicalSuperT->getAs<ReferenceType>()) 663 CanonicalSuperT = RefTy->getPointeeType(); 664 if (SubIsPointer) { 665 if (const PointerType *PtrTy = CanonicalSuperT->getAs<PointerType>()) 666 CanonicalSuperT = PtrTy->getPointeeType(); 667 else { 668 continue; 669 } 670 } 671 CanonicalSuperT = CanonicalSuperT.getLocalUnqualifiedType(); 672 // If the types are the same, move on to the next type in the subset. 673 if (CanonicalSubT == CanonicalSuperT) { 674 Contained = true; 675 break; 676 } 677 678 // Otherwise we need to check the inheritance. 679 if (!SubIsClass || !CanonicalSuperT->isRecordType()) 680 continue; 681 682 Paths.clear(); 683 if (!IsDerivedFrom(CanonicalSubT, CanonicalSuperT, Paths)) 684 continue; 685 686 if (Paths.isAmbiguous(Context.getCanonicalType(CanonicalSuperT))) 687 continue; 688 689 // Do this check from a context without privileges. 690 switch (CheckBaseClassAccess(SourceLocation(), 691 CanonicalSuperT, CanonicalSubT, 692 Paths.front(), 693 /*Diagnostic*/ 0, 694 /*ForceCheck*/ true, 695 /*ForceUnprivileged*/ true)) { 696 case AR_accessible: break; 697 case AR_inaccessible: continue; 698 case AR_dependent: 699 llvm_unreachable("access check dependent for unprivileged context"); 700 case AR_delayed: 701 llvm_unreachable("access check delayed in non-declaration"); 702 } 703 704 Contained = true; 705 break; 706 } 707 if (!Contained) { 708 Diag(SubLoc, DiagID); 709 if (NoteID.getDiagID() != 0) 710 Diag(SuperLoc, NoteID); 711 return true; 712 } 713 } 714 // We've run half the gauntlet. 715 return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); 716 } 717 718 static bool CheckSpecForTypesEquivalent(Sema &S, 719 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID, 720 QualType Target, SourceLocation TargetLoc, 721 QualType Source, SourceLocation SourceLoc) 722 { 723 const FunctionProtoType *TFunc = GetUnderlyingFunction(Target); 724 if (!TFunc) 725 return false; 726 const FunctionProtoType *SFunc = GetUnderlyingFunction(Source); 727 if (!SFunc) 728 return false; 729 730 return S.CheckEquivalentExceptionSpec(DiagID, NoteID, TFunc, TargetLoc, 731 SFunc, SourceLoc); 732 } 733 734 /// CheckParamExceptionSpec - Check if the parameter and return types of the 735 /// two functions have equivalent exception specs. This is part of the 736 /// assignment and override compatibility check. We do not check the parameters 737 /// of parameter function pointers recursively, as no sane programmer would 738 /// even be able to write such a function type. 739 bool Sema::CheckParamExceptionSpec(const PartialDiagnostic & NoteID, 740 const FunctionProtoType *Target, SourceLocation TargetLoc, 741 const FunctionProtoType *Source, SourceLocation SourceLoc) 742 { 743 if (CheckSpecForTypesEquivalent(*this, 744 PDiag(diag::err_deep_exception_specs_differ) << 0, 745 PDiag(), 746 Target->getResultType(), TargetLoc, 747 Source->getResultType(), SourceLoc)) 748 return true; 749 750 // We shouldn't even be testing this unless the arguments are otherwise 751 // compatible. 752 assert(Target->getNumArgs() == Source->getNumArgs() && 753 "Functions have different argument counts."); 754 for (unsigned i = 0, E = Target->getNumArgs(); i != E; ++i) { 755 if (CheckSpecForTypesEquivalent(*this, 756 PDiag(diag::err_deep_exception_specs_differ) << 1, 757 PDiag(), 758 Target->getArgType(i), TargetLoc, 759 Source->getArgType(i), SourceLoc)) 760 return true; 761 } 762 return false; 763 } 764 765 bool Sema::CheckExceptionSpecCompatibility(Expr *From, QualType ToType) 766 { 767 // First we check for applicability. 768 // Target type must be a function, function pointer or function reference. 769 const FunctionProtoType *ToFunc = GetUnderlyingFunction(ToType); 770 if (!ToFunc) 771 return false; 772 773 // SourceType must be a function or function pointer. 774 const FunctionProtoType *FromFunc = GetUnderlyingFunction(From->getType()); 775 if (!FromFunc) 776 return false; 777 778 // Now we've got the correct types on both sides, check their compatibility. 779 // This means that the source of the conversion can only throw a subset of 780 // the exceptions of the target, and any exception specs on arguments or 781 // return types must be equivalent. 782 return CheckExceptionSpecSubset(PDiag(diag::err_incompatible_exception_specs), 783 PDiag(), ToFunc, 784 From->getSourceRange().getBegin(), 785 FromFunc, SourceLocation()); 786 } 787 788 bool Sema::CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, 789 const CXXMethodDecl *Old) { 790 if (getLangOpts().CPlusPlus11 && isa<CXXDestructorDecl>(New)) { 791 // Don't check uninstantiated template destructors at all. We can only 792 // synthesize correct specs after the template is instantiated. 793 if (New->getParent()->isDependentType()) 794 return false; 795 if (New->getParent()->isBeingDefined()) { 796 // The destructor might be updated once the definition is finished. So 797 // remember it and check later. 798 DelayedDestructorExceptionSpecChecks.push_back(std::make_pair( 799 cast<CXXDestructorDecl>(New), cast<CXXDestructorDecl>(Old))); 800 return false; 801 } 802 } 803 unsigned DiagID = diag::err_override_exception_spec; 804 if (getLangOpts().MicrosoftExt) 805 DiagID = diag::warn_override_exception_spec; 806 return CheckExceptionSpecSubset(PDiag(DiagID), 807 PDiag(diag::note_overridden_virtual_function), 808 Old->getType()->getAs<FunctionProtoType>(), 809 Old->getLocation(), 810 New->getType()->getAs<FunctionProtoType>(), 811 New->getLocation()); 812 } 813 814 static CanThrowResult canSubExprsThrow(Sema &S, const Expr *CE) { 815 Expr *E = const_cast<Expr*>(CE); 816 CanThrowResult R = CT_Cannot; 817 for (Expr::child_range I = E->children(); I && R != CT_Can; ++I) 818 R = mergeCanThrow(R, S.canThrow(cast<Expr>(*I))); 819 return R; 820 } 821 822 static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, 823 const Decl *D, 824 bool NullThrows = true) { 825 if (!D) 826 return NullThrows ? CT_Can : CT_Cannot; 827 828 // See if we can get a function type from the decl somehow. 829 const ValueDecl *VD = dyn_cast<ValueDecl>(D); 830 if (!VD) // If we have no clue what we're calling, assume the worst. 831 return CT_Can; 832 833 // As an extension, we assume that __attribute__((nothrow)) functions don't 834 // throw. 835 if (isa<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>()) 836 return CT_Cannot; 837 838 QualType T = VD->getType(); 839 const FunctionProtoType *FT; 840 if ((FT = T->getAs<FunctionProtoType>())) { 841 } else if (const PointerType *PT = T->getAs<PointerType>()) 842 FT = PT->getPointeeType()->getAs<FunctionProtoType>(); 843 else if (const ReferenceType *RT = T->getAs<ReferenceType>()) 844 FT = RT->getPointeeType()->getAs<FunctionProtoType>(); 845 else if (const MemberPointerType *MT = T->getAs<MemberPointerType>()) 846 FT = MT->getPointeeType()->getAs<FunctionProtoType>(); 847 else if (const BlockPointerType *BT = T->getAs<BlockPointerType>()) 848 FT = BT->getPointeeType()->getAs<FunctionProtoType>(); 849 850 if (!FT) 851 return CT_Can; 852 853 FT = S.ResolveExceptionSpec(E->getLocStart(), FT); 854 if (!FT) 855 return CT_Can; 856 857 return FT->isNothrow(S.Context) ? CT_Cannot : CT_Can; 858 } 859 860 static CanThrowResult canDynamicCastThrow(const CXXDynamicCastExpr *DC) { 861 if (DC->isTypeDependent()) 862 return CT_Dependent; 863 864 if (!DC->getTypeAsWritten()->isReferenceType()) 865 return CT_Cannot; 866 867 if (DC->getSubExpr()->isTypeDependent()) 868 return CT_Dependent; 869 870 return DC->getCastKind() == clang::CK_Dynamic? CT_Can : CT_Cannot; 871 } 872 873 static CanThrowResult canTypeidThrow(Sema &S, const CXXTypeidExpr *DC) { 874 if (DC->isTypeOperand()) 875 return CT_Cannot; 876 877 Expr *Op = DC->getExprOperand(); 878 if (Op->isTypeDependent()) 879 return CT_Dependent; 880 881 const RecordType *RT = Op->getType()->getAs<RecordType>(); 882 if (!RT) 883 return CT_Cannot; 884 885 if (!cast<CXXRecordDecl>(RT->getDecl())->isPolymorphic()) 886 return CT_Cannot; 887 888 if (Op->Classify(S.Context).isPRValue()) 889 return CT_Cannot; 890 891 return CT_Can; 892 } 893 894 CanThrowResult Sema::canThrow(const Expr *E) { 895 // C++ [expr.unary.noexcept]p3: 896 // [Can throw] if in a potentially-evaluated context the expression would 897 // contain: 898 switch (E->getStmtClass()) { 899 case Expr::CXXThrowExprClass: 900 // - a potentially evaluated throw-expression 901 return CT_Can; 902 903 case Expr::CXXDynamicCastExprClass: { 904 // - a potentially evaluated dynamic_cast expression dynamic_cast<T>(v), 905 // where T is a reference type, that requires a run-time check 906 CanThrowResult CT = canDynamicCastThrow(cast<CXXDynamicCastExpr>(E)); 907 if (CT == CT_Can) 908 return CT; 909 return mergeCanThrow(CT, canSubExprsThrow(*this, E)); 910 } 911 912 case Expr::CXXTypeidExprClass: 913 // - a potentially evaluated typeid expression applied to a glvalue 914 // expression whose type is a polymorphic class type 915 return canTypeidThrow(*this, cast<CXXTypeidExpr>(E)); 916 917 // - a potentially evaluated call to a function, member function, function 918 // pointer, or member function pointer that does not have a non-throwing 919 // exception-specification 920 case Expr::CallExprClass: 921 case Expr::CXXMemberCallExprClass: 922 case Expr::CXXOperatorCallExprClass: 923 case Expr::UserDefinedLiteralClass: { 924 const CallExpr *CE = cast<CallExpr>(E); 925 CanThrowResult CT; 926 if (E->isTypeDependent()) 927 CT = CT_Dependent; 928 else if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens())) 929 CT = CT_Cannot; 930 else 931 CT = canCalleeThrow(*this, E, CE->getCalleeDecl()); 932 if (CT == CT_Can) 933 return CT; 934 return mergeCanThrow(CT, canSubExprsThrow(*this, E)); 935 } 936 937 case Expr::CXXConstructExprClass: 938 case Expr::CXXTemporaryObjectExprClass: { 939 CanThrowResult CT = canCalleeThrow(*this, E, 940 cast<CXXConstructExpr>(E)->getConstructor()); 941 if (CT == CT_Can) 942 return CT; 943 return mergeCanThrow(CT, canSubExprsThrow(*this, E)); 944 } 945 946 case Expr::LambdaExprClass: { 947 const LambdaExpr *Lambda = cast<LambdaExpr>(E); 948 CanThrowResult CT = CT_Cannot; 949 for (LambdaExpr::capture_init_iterator Cap = Lambda->capture_init_begin(), 950 CapEnd = Lambda->capture_init_end(); 951 Cap != CapEnd; ++Cap) 952 CT = mergeCanThrow(CT, canThrow(*Cap)); 953 return CT; 954 } 955 956 case Expr::CXXNewExprClass: { 957 CanThrowResult CT; 958 if (E->isTypeDependent()) 959 CT = CT_Dependent; 960 else 961 CT = canCalleeThrow(*this, E, cast<CXXNewExpr>(E)->getOperatorNew()); 962 if (CT == CT_Can) 963 return CT; 964 return mergeCanThrow(CT, canSubExprsThrow(*this, E)); 965 } 966 967 case Expr::CXXDeleteExprClass: { 968 CanThrowResult CT; 969 QualType DTy = cast<CXXDeleteExpr>(E)->getDestroyedType(); 970 if (DTy.isNull() || DTy->isDependentType()) { 971 CT = CT_Dependent; 972 } else { 973 CT = canCalleeThrow(*this, E, 974 cast<CXXDeleteExpr>(E)->getOperatorDelete()); 975 if (const RecordType *RT = DTy->getAs<RecordType>()) { 976 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 977 CT = mergeCanThrow(CT, canCalleeThrow(*this, E, RD->getDestructor())); 978 } 979 if (CT == CT_Can) 980 return CT; 981 } 982 return mergeCanThrow(CT, canSubExprsThrow(*this, E)); 983 } 984 985 case Expr::CXXBindTemporaryExprClass: { 986 // The bound temporary has to be destroyed again, which might throw. 987 CanThrowResult CT = canCalleeThrow(*this, E, 988 cast<CXXBindTemporaryExpr>(E)->getTemporary()->getDestructor()); 989 if (CT == CT_Can) 990 return CT; 991 return mergeCanThrow(CT, canSubExprsThrow(*this, E)); 992 } 993 994 // ObjC message sends are like function calls, but never have exception 995 // specs. 996 case Expr::ObjCMessageExprClass: 997 case Expr::ObjCPropertyRefExprClass: 998 case Expr::ObjCSubscriptRefExprClass: 999 return CT_Can; 1000 1001 // All the ObjC literals that are implemented as calls are 1002 // potentially throwing unless we decide to close off that 1003 // possibility. 1004 case Expr::ObjCArrayLiteralClass: 1005 case Expr::ObjCDictionaryLiteralClass: 1006 case Expr::ObjCBoxedExprClass: 1007 return CT_Can; 1008 1009 // Many other things have subexpressions, so we have to test those. 1010 // Some are simple: 1011 case Expr::ConditionalOperatorClass: 1012 case Expr::CompoundLiteralExprClass: 1013 case Expr::CXXConstCastExprClass: 1014 case Expr::CXXDefaultArgExprClass: 1015 case Expr::CXXReinterpretCastExprClass: 1016 case Expr::DesignatedInitExprClass: 1017 case Expr::ExprWithCleanupsClass: 1018 case Expr::ExtVectorElementExprClass: 1019 case Expr::InitListExprClass: 1020 case Expr::MemberExprClass: 1021 case Expr::ObjCIsaExprClass: 1022 case Expr::ObjCIvarRefExprClass: 1023 case Expr::ParenExprClass: 1024 case Expr::ParenListExprClass: 1025 case Expr::ShuffleVectorExprClass: 1026 case Expr::VAArgExprClass: 1027 return canSubExprsThrow(*this, E); 1028 1029 // Some might be dependent for other reasons. 1030 case Expr::ArraySubscriptExprClass: 1031 case Expr::BinaryOperatorClass: 1032 case Expr::CompoundAssignOperatorClass: 1033 case Expr::CStyleCastExprClass: 1034 case Expr::CXXStaticCastExprClass: 1035 case Expr::CXXFunctionalCastExprClass: 1036 case Expr::ImplicitCastExprClass: 1037 case Expr::MaterializeTemporaryExprClass: 1038 case Expr::UnaryOperatorClass: { 1039 CanThrowResult CT = E->isTypeDependent() ? CT_Dependent : CT_Cannot; 1040 return mergeCanThrow(CT, canSubExprsThrow(*this, E)); 1041 } 1042 1043 // FIXME: We should handle StmtExpr, but that opens a MASSIVE can of worms. 1044 case Expr::StmtExprClass: 1045 return CT_Can; 1046 1047 case Expr::ChooseExprClass: 1048 if (E->isTypeDependent() || E->isValueDependent()) 1049 return CT_Dependent; 1050 return canThrow(cast<ChooseExpr>(E)->getChosenSubExpr(Context)); 1051 1052 case Expr::GenericSelectionExprClass: 1053 if (cast<GenericSelectionExpr>(E)->isResultDependent()) 1054 return CT_Dependent; 1055 return canThrow(cast<GenericSelectionExpr>(E)->getResultExpr()); 1056 1057 // Some expressions are always dependent. 1058 case Expr::CXXDependentScopeMemberExprClass: 1059 case Expr::CXXUnresolvedConstructExprClass: 1060 case Expr::DependentScopeDeclRefExprClass: 1061 return CT_Dependent; 1062 1063 case Expr::AsTypeExprClass: 1064 case Expr::BinaryConditionalOperatorClass: 1065 case Expr::BlockExprClass: 1066 case Expr::CUDAKernelCallExprClass: 1067 case Expr::DeclRefExprClass: 1068 case Expr::ObjCBridgedCastExprClass: 1069 case Expr::ObjCIndirectCopyRestoreExprClass: 1070 case Expr::ObjCProtocolExprClass: 1071 case Expr::ObjCSelectorExprClass: 1072 case Expr::OffsetOfExprClass: 1073 case Expr::PackExpansionExprClass: 1074 case Expr::PseudoObjectExprClass: 1075 case Expr::SubstNonTypeTemplateParmExprClass: 1076 case Expr::SubstNonTypeTemplateParmPackExprClass: 1077 case Expr::FunctionParmPackExprClass: 1078 case Expr::UnaryExprOrTypeTraitExprClass: 1079 case Expr::UnresolvedLookupExprClass: 1080 case Expr::UnresolvedMemberExprClass: 1081 // FIXME: Can any of the above throw? If so, when? 1082 return CT_Cannot; 1083 1084 case Expr::AddrLabelExprClass: 1085 case Expr::ArrayTypeTraitExprClass: 1086 case Expr::AtomicExprClass: 1087 case Expr::BinaryTypeTraitExprClass: 1088 case Expr::TypeTraitExprClass: 1089 case Expr::CXXBoolLiteralExprClass: 1090 case Expr::CXXNoexceptExprClass: 1091 case Expr::CXXNullPtrLiteralExprClass: 1092 case Expr::CXXPseudoDestructorExprClass: 1093 case Expr::CXXScalarValueInitExprClass: 1094 case Expr::CXXThisExprClass: 1095 case Expr::CXXUuidofExprClass: 1096 case Expr::CharacterLiteralClass: 1097 case Expr::ExpressionTraitExprClass: 1098 case Expr::FloatingLiteralClass: 1099 case Expr::GNUNullExprClass: 1100 case Expr::ImaginaryLiteralClass: 1101 case Expr::ImplicitValueInitExprClass: 1102 case Expr::IntegerLiteralClass: 1103 case Expr::ObjCEncodeExprClass: 1104 case Expr::ObjCStringLiteralClass: 1105 case Expr::ObjCBoolLiteralExprClass: 1106 case Expr::OpaqueValueExprClass: 1107 case Expr::PredefinedExprClass: 1108 case Expr::SizeOfPackExprClass: 1109 case Expr::StringLiteralClass: 1110 case Expr::UnaryTypeTraitExprClass: 1111 // These expressions can never throw. 1112 return CT_Cannot; 1113 1114 #define STMT(CLASS, PARENT) case Expr::CLASS##Class: 1115 #define STMT_RANGE(Base, First, Last) 1116 #define LAST_STMT_RANGE(BASE, FIRST, LAST) 1117 #define EXPR(CLASS, PARENT) 1118 #define ABSTRACT_STMT(STMT) 1119 #include "clang/AST/StmtNodes.inc" 1120 case Expr::NoStmtClass: 1121 llvm_unreachable("Invalid class for expression"); 1122 } 1123 llvm_unreachable("Bogus StmtClass"); 1124 } 1125 1126 } // end namespace clang 1127