head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.11 netbsd-11-0-RC3:1.1.1.11 netbsd-11-0-RC2:1.1.1.11 netbsd-11-0-RC1:1.1.1.11 perseant-exfatfs-base-20250801:1.1.1.11 netbsd-11:1.1.1.11.0.10 netbsd-11-base:1.1.1.11 netbsd-10-1-RELEASE:1.1.1.11 perseant-exfatfs-base-20240630:1.1.1.11 perseant-exfatfs:1.1.1.11.0.8 perseant-exfatfs-base:1.1.1.11 netbsd-8-3-RELEASE:1.1.1.8 netbsd-9-4-RELEASE:1.1.1.10 netbsd-10-0-RELEASE:1.1.1.11 netbsd-10-0-RC6:1.1.1.11 netbsd-10-0-RC5:1.1.1.11 netbsd-10-0-RC4:1.1.1.11 netbsd-10-0-RC3:1.1.1.11 netbsd-10-0-RC2:1.1.1.11 netbsd-10-0-RC1:1.1.1.11 netbsd-10:1.1.1.11.0.6 netbsd-10-base:1.1.1.11 netbsd-9-3-RELEASE:1.1.1.10 cjep_sun2x:1.1.1.11.0.4 cjep_sun2x-base:1.1.1.11 cjep_staticlib_x-base1:1.1.1.11 netbsd-9-2-RELEASE:1.1.1.10 cjep_staticlib_x:1.1.1.11.0.2 cjep_staticlib_x-base:1.1.1.11 netbsd-9-1-RELEASE:1.1.1.10 phil-wifi-20200421:1.1.1.11 phil-wifi-20200411:1.1.1.11 phil-wifi-20200406:1.1.1.11 netbsd-8-2-RELEASE:1.1.1.8 netbsd-9-0-RELEASE:1.1.1.10 netbsd-9-0-RC2:1.1.1.10 netbsd-9-0-RC1:1.1.1.10 netbsd-9:1.1.1.10.0.2 netbsd-9-base:1.1.1.10 phil-wifi-20190609:1.1.1.10 netbsd-8-1-RELEASE:1.1.1.8 netbsd-8-1-RC1:1.1.1.8 pgoyette-compat-merge-20190127:1.1.1.9.2.1 pgoyette-compat-20190127:1.1.1.10 pgoyette-compat-20190118:1.1.1.10 pgoyette-compat-1226:1.1.1.10 pgoyette-compat-1126:1.1.1.10 pgoyette-compat-1020:1.1.1.10 pgoyette-compat-0930:1.1.1.10 pgoyette-compat-0906:1.1.1.10 netbsd-7-2-RELEASE:1.1.1.5.2.1 pgoyette-compat-0728:1.1.1.10 clang-337282:1.1.1.10 netbsd-8-0-RELEASE:1.1.1.8 phil-wifi:1.1.1.9.0.4 phil-wifi-base:1.1.1.9 pgoyette-compat-0625:1.1.1.9 netbsd-8-0-RC2:1.1.1.8 pgoyette-compat-0521:1.1.1.9 pgoyette-compat-0502:1.1.1.9 pgoyette-compat-0422:1.1.1.9 netbsd-8-0-RC1:1.1.1.8 pgoyette-compat-0415:1.1.1.9 pgoyette-compat-0407:1.1.1.9 pgoyette-compat-0330:1.1.1.9 pgoyette-compat-0322:1.1.1.9 pgoyette-compat-0315:1.1.1.9 netbsd-7-1-2-RELEASE:1.1.1.5.2.1 pgoyette-compat:1.1.1.9.0.2 pgoyette-compat-base:1.1.1.9 netbsd-7-1-1-RELEASE:1.1.1.5.2.1 clang-319952:1.1.1.9 matt-nb8-mediatek:1.1.1.8.0.10 matt-nb8-mediatek-base:1.1.1.8 clang-309604:1.1.1.9 perseant-stdc-iso10646:1.1.1.8.0.8 perseant-stdc-iso10646-base:1.1.1.8 netbsd-8:1.1.1.8.0.6 netbsd-8-base:1.1.1.8 prg-localcount2-base3:1.1.1.8 prg-localcount2-base2:1.1.1.8 prg-localcount2-base1:1.1.1.8 prg-localcount2:1.1.1.8.0.4 prg-localcount2-base:1.1.1.8 pgoyette-localcount-20170426:1.1.1.8 bouyer-socketcan-base1:1.1.1.8 pgoyette-localcount-20170320:1.1.1.8 netbsd-7-1:1.1.1.5.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.5.2.1 netbsd-7-1-RC2:1.1.1.5.2.1 clang-294123:1.1.1.8 netbsd-7-nhusb-base-20170116:1.1.1.5.2.1 bouyer-socketcan:1.1.1.8.0.2 bouyer-socketcan-base:1.1.1.8 clang-291444:1.1.1.8 pgoyette-localcount-20170107:1.1.1.7 netbsd-7-1-RC1:1.1.1.5.2.1 pgoyette-localcount-20161104:1.1.1.7 netbsd-7-0-2-RELEASE:1.1.1.5.2.1 localcount-20160914:1.1.1.7 netbsd-7-nhusb:1.1.1.5.2.1.0.4 netbsd-7-nhusb-base:1.1.1.5.2.1 clang-280599:1.1.1.7 pgoyette-localcount-20160806:1.1.1.7 pgoyette-localcount-20160726:1.1.1.7 pgoyette-localcount:1.1.1.7.0.2 pgoyette-localcount-base:1.1.1.7 netbsd-7-0-1-RELEASE:1.1.1.5.2.1 clang-261930:1.1.1.7 netbsd-7-0:1.1.1.5.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.5.2.1 netbsd-7-0-RC3:1.1.1.5.2.1 netbsd-7-0-RC2:1.1.1.5.2.1 netbsd-7-0-RC1:1.1.1.5.2.1 clang-237755:1.1.1.6 clang-232565:1.1.1.6 clang-227398:1.1.1.6 tls-maxphys-base:1.1.1.5 tls-maxphys:1.1.1.5.0.4 netbsd-7:1.1.1.5.0.2 netbsd-7-base:1.1.1.5 clang-215315:1.1.1.5 clang-209886:1.1.1.4 yamt-pagecache:1.1.1.3.0.4 yamt-pagecache-base9:1.1.1.3 tls-earlyentropy:1.1.1.3.0.2 tls-earlyentropy-base:1.1.1.4 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.3 riastradh-drm2-base3:1.1.1.3 clang-202566:1.1.1.3 clang-201163:1.1.1.3 clang-199312:1.1.1.2 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.50; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.50; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.48; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.02.14.20.07.17; author joerg; state Exp; branches 1.1.1.3.2.1 1.1.1.3.4.1; next 1.1.1.4; commitid annVkZ1sc17rF6px; 1.1.1.4 date 2014.05.30.18.14.43; author joerg; state Exp; branches; next 1.1.1.5; commitid 8q0kdlBlCn09GACx; 1.1.1.5 date 2014.08.10.17.08.29; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid N85tXAN6Ex9VZPLx; 1.1.1.6 date 2015.01.29.19.57.28; author joerg; state Exp; branches; next 1.1.1.7; commitid mlISSizlPKvepX7y; 1.1.1.7 date 2016.02.27.22.11.59; author joerg; state Exp; branches 1.1.1.7.2.1; next 1.1.1.8; commitid tIimz3oDlh1NpBWy; 1.1.1.8 date 2017.01.11.10.34.14; author joerg; state Exp; branches; next 1.1.1.9; commitid CNnUNfII1jgNmxBz; 1.1.1.9 date 2017.08.01.19.35.03; author joerg; state Exp; branches 1.1.1.9.2.1 1.1.1.9.4.1; next 1.1.1.10; commitid pMuDy65V0VicSx1A; 1.1.1.10 date 2018.07.17.18.31.17; author joerg; state Exp; branches; next 1.1.1.11; commitid wDzL46ALjrCZgwKA; 1.1.1.11 date 2019.11.13.22.19.27; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.3.2.1 date 2014.08.10.07.08.09; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.3.4.1 date 2014.02.14.20.07.17; author yamt; state dead; branches; next 1.1.1.3.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.3.4.2 date 2014.05.22.16.18.29; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.2.1 date 2015.06.04.20.04.30; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.5.4.1 date 2014.08.10.17.08.29; author tls; state dead; branches; next 1.1.1.5.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.5.4.2 date 2014.08.19.23.47.30; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.2.1 date 2017.03.20.06.52.40; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.9.2.1 date 2018.07.28.04.33.22; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.9.4.1 date 2019.06.10.21.45.27; author christos; state Exp; branches; next 1.1.1.9.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.9.4.2 date 2020.04.13.07.46.37; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- SemaExceptionSpec.cpp - C++ Exception Specifications ---*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file provides Sema routines for C++ exception specification testing. // //===----------------------------------------------------------------------===// #include "clang/Sema/SemaInternal.h" #include "clang/AST/CXXInheritance.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/TypeLoc.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/SourceManager.h" #include "clang/Lex/Preprocessor.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallString.h" namespace clang { static const FunctionProtoType *GetUnderlyingFunction(QualType T) { if (const PointerType *PtrTy = T->getAs()) T = PtrTy->getPointeeType(); else if (const ReferenceType *RefTy = T->getAs()) T = RefTy->getPointeeType(); else if (const MemberPointerType *MPTy = T->getAs()) T = MPTy->getPointeeType(); return T->getAs(); } /// CheckSpecifiedExceptionType - Check if the given type is valid in an /// exception specification. Incomplete types, or pointers to incomplete types /// other than void are not allowed. /// /// \param[in,out] T The exception type. This will be decayed to a pointer type /// when the input is an array or a function type. bool Sema::CheckSpecifiedExceptionType(QualType &T, const SourceRange &Range) { // C++11 [except.spec]p2: // A type cv T, "array of T", or "function returning T" denoted // in an exception-specification is adjusted to type T, "pointer to T", or // "pointer to function returning T", respectively. // // We also apply this rule in C++98. if (T->isArrayType()) T = Context.getArrayDecayedType(T); else if (T->isFunctionType()) T = Context.getPointerType(T); int Kind = 0; QualType PointeeT = T; if (const PointerType *PT = T->getAs()) { PointeeT = PT->getPointeeType(); Kind = 1; // cv void* is explicitly permitted, despite being a pointer to an // incomplete type. if (PointeeT->isVoidType()) return false; } else if (const ReferenceType *RT = T->getAs()) { PointeeT = RT->getPointeeType(); Kind = 2; if (RT->isRValueReferenceType()) { // C++11 [except.spec]p2: // A type denoted in an exception-specification shall not denote [...] // an rvalue reference type. Diag(Range.getBegin(), diag::err_rref_in_exception_spec) << T << Range; return true; } } // C++11 [except.spec]p2: // A type denoted in an exception-specification shall not denote an // incomplete type other than a class currently being defined [...]. // A type denoted in an exception-specification shall not denote a // pointer or reference to an incomplete type, other than (cv) void* or a // pointer or reference to a class currently being defined. if (!(PointeeT->isRecordType() && PointeeT->getAs()->isBeingDefined()) && RequireCompleteType(Range.getBegin(), PointeeT, diag::err_incomplete_in_exception_spec, Kind, Range)) return true; return false; } /// CheckDistantExceptionSpec - Check if the given type is a pointer or pointer /// to member to a function with an exception specification. This means that /// it is invalid to add another level of indirection. bool Sema::CheckDistantExceptionSpec(QualType T) { if (const PointerType *PT = T->getAs()) T = PT->getPointeeType(); else if (const MemberPointerType *PT = T->getAs()) T = PT->getPointeeType(); else return false; const FunctionProtoType *FnT = T->getAs(); if (!FnT) return false; return FnT->hasExceptionSpec(); } const FunctionProtoType * Sema::ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT) { if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) return FPT; FunctionDecl *SourceDecl = FPT->getExceptionSpecDecl(); const FunctionProtoType *SourceFPT = SourceDecl->getType()->castAs(); // If the exception specification has already been resolved, just return it. if (!isUnresolvedExceptionSpec(SourceFPT->getExceptionSpecType())) return SourceFPT; // Compute or instantiate the exception specification now. if (SourceFPT->getExceptionSpecType() == EST_Unevaluated) EvaluateImplicitExceptionSpec(Loc, cast(SourceDecl)); else InstantiateExceptionSpec(Loc, SourceDecl); return SourceDecl->getType()->castAs(); } /// Determine whether a function has an implicitly-generated exception /// specification. static bool hasImplicitExceptionSpec(FunctionDecl *Decl) { if (!isa(Decl) && Decl->getDeclName().getCXXOverloadedOperator() != OO_Delete && Decl->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete) return false; // If the user didn't declare the function, its exception specification must // be implicit. if (!Decl->getTypeSourceInfo()) return true; const FunctionProtoType *Ty = Decl->getTypeSourceInfo()->getType()->getAs(); return !Ty->hasExceptionSpec(); } bool Sema::CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New) { OverloadedOperatorKind OO = New->getDeclName().getCXXOverloadedOperator(); bool IsOperatorNew = OO == OO_New || OO == OO_Array_New; bool MissingExceptionSpecification = false; bool MissingEmptyExceptionSpecification = false; unsigned DiagID = diag::err_mismatched_exception_spec; if (getLangOpts().MicrosoftExt) DiagID = diag::warn_mismatched_exception_spec; // Check the types as written: they must match before any exception // specification adjustment is applied. if (!CheckEquivalentExceptionSpec( PDiag(DiagID), PDiag(diag::note_previous_declaration), Old->getType()->getAs(), Old->getLocation(), New->getType()->getAs(), New->getLocation(), &MissingExceptionSpecification, &MissingEmptyExceptionSpecification, /*AllowNoexceptAllMatchWithNoSpec=*/true, IsOperatorNew)) { // C++11 [except.spec]p4 [DR1492]: // If a declaration of a function has an implicit // exception-specification, other declarations of the function shall // not specify an exception-specification. if (getLangOpts().CPlusPlus11 && hasImplicitExceptionSpec(Old) != hasImplicitExceptionSpec(New)) { Diag(New->getLocation(), diag::ext_implicit_exception_spec_mismatch) << hasImplicitExceptionSpec(Old); if (!Old->getLocation().isInvalid()) Diag(Old->getLocation(), diag::note_previous_declaration); } return false; } // The failure was something other than an missing exception // specification; return an error. if (!MissingExceptionSpecification) return true; const FunctionProtoType *NewProto = New->getType()->castAs(); // The new function declaration is only missing an empty exception // specification "throw()". If the throw() specification came from a // function in a system header that has C linkage, just add an empty // exception specification to the "new" declaration. This is an // egregious workaround for glibc, which adds throw() specifications // to many libc functions as an optimization. Unfortunately, that // optimization isn't permitted by the C++ standard, so we're forced // to work around it here. if (MissingEmptyExceptionSpecification && NewProto && (Old->getLocation().isInvalid() || Context.getSourceManager().isInSystemHeader(Old->getLocation())) && Old->isExternC()) { FunctionProtoType::ExtProtoInfo EPI = NewProto->getExtProtoInfo(); EPI.ExceptionSpecType = EST_DynamicNone; QualType NewType = Context.getFunctionType(NewProto->getResultType(), NewProto->getArgTypes(), EPI); New->setType(NewType); return false; } const FunctionProtoType *OldProto = Old->getType()->castAs(); FunctionProtoType::ExtProtoInfo EPI = NewProto->getExtProtoInfo(); EPI.ExceptionSpecType = OldProto->getExceptionSpecType(); if (EPI.ExceptionSpecType == EST_Dynamic) { EPI.NumExceptions = OldProto->getNumExceptions(); EPI.Exceptions = OldProto->exception_begin(); } else if (EPI.ExceptionSpecType == EST_ComputedNoexcept) { // FIXME: We can't just take the expression from the old prototype. It // likely contains references to the old prototype's parameters. } // Update the type of the function with the appropriate exception // specification. QualType NewType = Context.getFunctionType(NewProto->getResultType(), NewProto->getArgTypes(), EPI); New->setType(NewType); // Warn about the lack of exception specification. SmallString<128> ExceptionSpecString; llvm::raw_svector_ostream OS(ExceptionSpecString); switch (OldProto->getExceptionSpecType()) { case EST_DynamicNone: OS << "throw()"; break; case EST_Dynamic: { OS << "throw("; bool OnFirstException = true; for (FunctionProtoType::exception_iterator E = OldProto->exception_begin(), EEnd = OldProto->exception_end(); E != EEnd; ++E) { if (OnFirstException) OnFirstException = false; else OS << ", "; OS << E->getAsString(getPrintingPolicy()); } OS << ")"; break; } case EST_BasicNoexcept: OS << "noexcept"; break; case EST_ComputedNoexcept: OS << "noexcept("; OldProto->getNoexceptExpr()->printPretty(OS, 0, getPrintingPolicy()); OS << ")"; break; default: llvm_unreachable("This spec type is compatible with none."); } OS.flush(); SourceLocation FixItLoc; if (TypeSourceInfo *TSInfo = New->getTypeSourceInfo()) { TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens(); if (FunctionTypeLoc FTLoc = TL.getAs()) FixItLoc = PP.getLocForEndOfToken(FTLoc.getLocalRangeEnd()); } if (FixItLoc.isInvalid()) Diag(New->getLocation(), diag::warn_missing_exception_specification) << New << OS.str(); else { // FIXME: This will get more complicated with C++0x // late-specified return types. Diag(New->getLocation(), diag::warn_missing_exception_specification) << New << OS.str() << FixItHint::CreateInsertion(FixItLoc, " " + OS.str().str()); } if (!Old->getLocation().isInvalid()) Diag(Old->getLocation(), diag::note_previous_declaration); return false; } /// CheckEquivalentExceptionSpec - Check if the two types have equivalent /// exception specifications. Exception specifications are equivalent if /// they allow exactly the same set of exception types. It does not matter how /// that is achieved. See C++ [except.spec]p2. bool Sema::CheckEquivalentExceptionSpec( const FunctionProtoType *Old, SourceLocation OldLoc, const FunctionProtoType *New, SourceLocation NewLoc) { unsigned DiagID = diag::err_mismatched_exception_spec; if (getLangOpts().MicrosoftExt) DiagID = diag::warn_mismatched_exception_spec; return CheckEquivalentExceptionSpec(PDiag(DiagID), PDiag(diag::note_previous_declaration), Old, OldLoc, New, NewLoc); } /// CheckEquivalentExceptionSpec - Check if the two types have compatible /// exception specifications. See C++ [except.spec]p3. /// /// \return \c false if the exception specifications match, \c true if there is /// a problem. If \c true is returned, either a diagnostic has already been /// produced or \c *MissingExceptionSpecification is set to \c true. bool Sema::CheckEquivalentExceptionSpec(const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID, const FunctionProtoType *Old, SourceLocation OldLoc, const FunctionProtoType *New, SourceLocation NewLoc, bool *MissingExceptionSpecification, bool*MissingEmptyExceptionSpecification, bool AllowNoexceptAllMatchWithNoSpec, bool IsOperatorNew) { // Just completely ignore this under -fno-exceptions. if (!getLangOpts().CXXExceptions) return false; if (MissingExceptionSpecification) *MissingExceptionSpecification = false; if (MissingEmptyExceptionSpecification) *MissingEmptyExceptionSpecification = false; Old = ResolveExceptionSpec(NewLoc, Old); if (!Old) return false; New = ResolveExceptionSpec(NewLoc, New); if (!New) return false; // C++0x [except.spec]p3: Two exception-specifications are compatible if: // - both are non-throwing, regardless of their form, // - both have the form noexcept(constant-expression) and the constant- // expressions are equivalent, // - both are dynamic-exception-specifications that have the same set of // adjusted types. // // C++0x [except.spec]p12: An exception-specifcation is non-throwing if it is // of the form throw(), noexcept, or noexcept(constant-expression) where the // constant-expression yields true. // // C++0x [except.spec]p4: If any declaration of a function has an exception- // specifier that is not a noexcept-specification allowing all exceptions, // all declarations [...] of that function shall have a compatible // exception-specification. // // That last point basically means that noexcept(false) matches no spec. // It's considered when AllowNoexceptAllMatchWithNoSpec is true. ExceptionSpecificationType OldEST = Old->getExceptionSpecType(); ExceptionSpecificationType NewEST = New->getExceptionSpecType(); assert(!isUnresolvedExceptionSpec(OldEST) && !isUnresolvedExceptionSpec(NewEST) && "Shouldn't see unknown exception specifications here"); // Shortcut the case where both have no spec. if (OldEST == EST_None && NewEST == EST_None) return false; FunctionProtoType::NoexceptResult OldNR = Old->getNoexceptSpec(Context); FunctionProtoType::NoexceptResult NewNR = New->getNoexceptSpec(Context); if (OldNR == FunctionProtoType::NR_BadNoexcept || NewNR == FunctionProtoType::NR_BadNoexcept) return false; // Dependent noexcept specifiers are compatible with each other, but nothing // else. // One noexcept is compatible with another if the argument is the same if (OldNR == NewNR && OldNR != FunctionProtoType::NR_NoNoexcept && NewNR != FunctionProtoType::NR_NoNoexcept) return false; if (OldNR != NewNR && OldNR != FunctionProtoType::NR_NoNoexcept && NewNR != FunctionProtoType::NR_NoNoexcept) { Diag(NewLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(OldLoc, NoteID); return true; } // The MS extension throw(...) is compatible with itself. if (OldEST == EST_MSAny && NewEST == EST_MSAny) return false; // It's also compatible with no spec. if ((OldEST == EST_None && NewEST == EST_MSAny) || (OldEST == EST_MSAny && NewEST == EST_None)) return false; // It's also compatible with noexcept(false). if (OldEST == EST_MSAny && NewNR == FunctionProtoType::NR_Throw) return false; if (NewEST == EST_MSAny && OldNR == FunctionProtoType::NR_Throw) return false; // As described above, noexcept(false) matches no spec only for functions. if (AllowNoexceptAllMatchWithNoSpec) { if (OldEST == EST_None && NewNR == FunctionProtoType::NR_Throw) return false; if (NewEST == EST_None && OldNR == FunctionProtoType::NR_Throw) return false; } // Any non-throwing specifications are compatible. bool OldNonThrowing = OldNR == FunctionProtoType::NR_Nothrow || OldEST == EST_DynamicNone; bool NewNonThrowing = NewNR == FunctionProtoType::NR_Nothrow || NewEST == EST_DynamicNone; if (OldNonThrowing && NewNonThrowing) return false; // As a special compatibility feature, under C++0x we accept no spec and // throw(std::bad_alloc) as equivalent for operator new and operator new[]. // This is because the implicit declaration changed, but old code would break. if (getLangOpts().CPlusPlus11 && IsOperatorNew) { const FunctionProtoType *WithExceptions = 0; if (OldEST == EST_None && NewEST == EST_Dynamic) WithExceptions = New; else if (OldEST == EST_Dynamic && NewEST == EST_None) WithExceptions = Old; if (WithExceptions && WithExceptions->getNumExceptions() == 1) { // One has no spec, the other throw(something). If that something is // std::bad_alloc, all conditions are met. QualType Exception = *WithExceptions->exception_begin(); if (CXXRecordDecl *ExRecord = Exception->getAsCXXRecordDecl()) { IdentifierInfo* Name = ExRecord->getIdentifier(); if (Name && Name->getName() == "bad_alloc") { // It's called bad_alloc, but is it in std? DeclContext* DC = ExRecord->getDeclContext(); DC = DC->getEnclosingNamespaceContext(); if (NamespaceDecl* NS = dyn_cast(DC)) { IdentifierInfo* NSName = NS->getIdentifier(); DC = DC->getParent(); if (NSName && NSName->getName() == "std" && DC->getEnclosingNamespaceContext()->isTranslationUnit()) { return false; } } } } } } // At this point, the only remaining valid case is two matching dynamic // specifications. We return here unless both specifications are dynamic. if (OldEST != EST_Dynamic || NewEST != EST_Dynamic) { if (MissingExceptionSpecification && Old->hasExceptionSpec() && !New->hasExceptionSpec()) { // The old type has an exception specification of some sort, but // the new type does not. *MissingExceptionSpecification = true; if (MissingEmptyExceptionSpecification && OldNonThrowing) { // The old type has a throw() or noexcept(true) exception specification // and the new type has no exception specification, and the caller asked // to handle this itself. *MissingEmptyExceptionSpecification = true; } return true; } Diag(NewLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(OldLoc, NoteID); return true; } assert(OldEST == EST_Dynamic && NewEST == EST_Dynamic && "Exception compatibility logic error: non-dynamic spec slipped through."); bool Success = true; // Both have a dynamic exception spec. Collect the first set, then compare // to the second. llvm::SmallPtrSet OldTypes, NewTypes; for (FunctionProtoType::exception_iterator I = Old->exception_begin(), E = Old->exception_end(); I != E; ++I) OldTypes.insert(Context.getCanonicalType(*I).getUnqualifiedType()); for (FunctionProtoType::exception_iterator I = New->exception_begin(), E = New->exception_end(); I != E && Success; ++I) { CanQualType TypePtr = Context.getCanonicalType(*I).getUnqualifiedType(); if(OldTypes.count(TypePtr)) NewTypes.insert(TypePtr); else Success = false; } Success = Success && OldTypes.size() == NewTypes.size(); if (Success) { return false; } Diag(NewLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(OldLoc, NoteID); return true; } /// CheckExceptionSpecSubset - Check whether the second function type's /// exception specification is a subset (or equivalent) of the first function /// type. This is used by override and pointer assignment checks. bool Sema::CheckExceptionSpecSubset( const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID, const FunctionProtoType *Superset, SourceLocation SuperLoc, const FunctionProtoType *Subset, SourceLocation SubLoc) { // Just auto-succeed under -fno-exceptions. if (!getLangOpts().CXXExceptions) return false; // FIXME: As usual, we could be more specific in our error messages, but // that better waits until we've got types with source locations. if (!SubLoc.isValid()) SubLoc = SuperLoc; // Resolve the exception specifications, if needed. Superset = ResolveExceptionSpec(SuperLoc, Superset); if (!Superset) return false; Subset = ResolveExceptionSpec(SubLoc, Subset); if (!Subset) return false; ExceptionSpecificationType SuperEST = Superset->getExceptionSpecType(); // If superset contains everything, we're done. if (SuperEST == EST_None || SuperEST == EST_MSAny) return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); // If there are dependent noexcept specs, assume everything is fine. Unlike // with the equivalency check, this is safe in this case, because we don't // want to merge declarations. Checks after instantiation will catch any // omissions we make here. // We also shortcut checking if a noexcept expression was bad. FunctionProtoType::NoexceptResult SuperNR =Superset->getNoexceptSpec(Context); if (SuperNR == FunctionProtoType::NR_BadNoexcept || SuperNR == FunctionProtoType::NR_Dependent) return false; // Another case of the superset containing everything. if (SuperNR == FunctionProtoType::NR_Throw) return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); ExceptionSpecificationType SubEST = Subset->getExceptionSpecType(); assert(!isUnresolvedExceptionSpec(SuperEST) && !isUnresolvedExceptionSpec(SubEST) && "Shouldn't see unknown exception specifications here"); // It does not. If the subset contains everything, we've failed. if (SubEST == EST_None || SubEST == EST_MSAny) { Diag(SubLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(SuperLoc, NoteID); return true; } FunctionProtoType::NoexceptResult SubNR = Subset->getNoexceptSpec(Context); if (SubNR == FunctionProtoType::NR_BadNoexcept || SubNR == FunctionProtoType::NR_Dependent) return false; // Another case of the subset containing everything. if (SubNR == FunctionProtoType::NR_Throw) { Diag(SubLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(SuperLoc, NoteID); return true; } // If the subset contains nothing, we're done. if (SubEST == EST_DynamicNone || SubNR == FunctionProtoType::NR_Nothrow) return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); // Otherwise, if the superset contains nothing, we've failed. if (SuperEST == EST_DynamicNone || SuperNR == FunctionProtoType::NR_Nothrow) { Diag(SubLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(SuperLoc, NoteID); return true; } assert(SuperEST == EST_Dynamic && SubEST == EST_Dynamic && "Exception spec subset: non-dynamic case slipped through."); // Neither contains everything or nothing. Do a proper comparison. for (FunctionProtoType::exception_iterator SubI = Subset->exception_begin(), SubE = Subset->exception_end(); SubI != SubE; ++SubI) { // Take one type from the subset. QualType CanonicalSubT = Context.getCanonicalType(*SubI); // Unwrap pointers and references so that we can do checks within a class // hierarchy. Don't unwrap member pointers; they don't have hierarchy // conversions on the pointee. bool SubIsPointer = false; if (const ReferenceType *RefTy = CanonicalSubT->getAs()) CanonicalSubT = RefTy->getPointeeType(); if (const PointerType *PtrTy = CanonicalSubT->getAs()) { CanonicalSubT = PtrTy->getPointeeType(); SubIsPointer = true; } bool SubIsClass = CanonicalSubT->isRecordType(); CanonicalSubT = CanonicalSubT.getLocalUnqualifiedType(); CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, /*DetectVirtual=*/false); bool Contained = false; // Make sure it's in the superset. for (FunctionProtoType::exception_iterator SuperI = Superset->exception_begin(), SuperE = Superset->exception_end(); SuperI != SuperE; ++SuperI) { QualType CanonicalSuperT = Context.getCanonicalType(*SuperI); // SubT must be SuperT or derived from it, or pointer or reference to // such types. if (const ReferenceType *RefTy = CanonicalSuperT->getAs()) CanonicalSuperT = RefTy->getPointeeType(); if (SubIsPointer) { if (const PointerType *PtrTy = CanonicalSuperT->getAs()) CanonicalSuperT = PtrTy->getPointeeType(); else { continue; } } CanonicalSuperT = CanonicalSuperT.getLocalUnqualifiedType(); // If the types are the same, move on to the next type in the subset. if (CanonicalSubT == CanonicalSuperT) { Contained = true; break; } // Otherwise we need to check the inheritance. if (!SubIsClass || !CanonicalSuperT->isRecordType()) continue; Paths.clear(); if (!IsDerivedFrom(CanonicalSubT, CanonicalSuperT, Paths)) continue; if (Paths.isAmbiguous(Context.getCanonicalType(CanonicalSuperT))) continue; // Do this check from a context without privileges. switch (CheckBaseClassAccess(SourceLocation(), CanonicalSuperT, CanonicalSubT, Paths.front(), /*Diagnostic*/ 0, /*ForceCheck*/ true, /*ForceUnprivileged*/ true)) { case AR_accessible: break; case AR_inaccessible: continue; case AR_dependent: llvm_unreachable("access check dependent for unprivileged context"); case AR_delayed: llvm_unreachable("access check delayed in non-declaration"); } Contained = true; break; } if (!Contained) { Diag(SubLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(SuperLoc, NoteID); return true; } } // We've run half the gauntlet. return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); } static bool CheckSpecForTypesEquivalent(Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID, QualType Target, SourceLocation TargetLoc, QualType Source, SourceLocation SourceLoc) { const FunctionProtoType *TFunc = GetUnderlyingFunction(Target); if (!TFunc) return false; const FunctionProtoType *SFunc = GetUnderlyingFunction(Source); if (!SFunc) return false; return S.CheckEquivalentExceptionSpec(DiagID, NoteID, TFunc, TargetLoc, SFunc, SourceLoc); } /// CheckParamExceptionSpec - Check if the parameter and return types of the /// two functions have equivalent exception specs. This is part of the /// assignment and override compatibility check. We do not check the parameters /// of parameter function pointers recursively, as no sane programmer would /// even be able to write such a function type. bool Sema::CheckParamExceptionSpec(const PartialDiagnostic & NoteID, const FunctionProtoType *Target, SourceLocation TargetLoc, const FunctionProtoType *Source, SourceLocation SourceLoc) { if (CheckSpecForTypesEquivalent(*this, PDiag(diag::err_deep_exception_specs_differ) << 0, PDiag(), Target->getResultType(), TargetLoc, Source->getResultType(), SourceLoc)) return true; // We shouldn't even be testing this unless the arguments are otherwise // compatible. assert(Target->getNumArgs() == Source->getNumArgs() && "Functions have different argument counts."); for (unsigned i = 0, E = Target->getNumArgs(); i != E; ++i) { if (CheckSpecForTypesEquivalent(*this, PDiag(diag::err_deep_exception_specs_differ) << 1, PDiag(), Target->getArgType(i), TargetLoc, Source->getArgType(i), SourceLoc)) return true; } return false; } bool Sema::CheckExceptionSpecCompatibility(Expr *From, QualType ToType) { // First we check for applicability. // Target type must be a function, function pointer or function reference. const FunctionProtoType *ToFunc = GetUnderlyingFunction(ToType); if (!ToFunc) return false; // SourceType must be a function or function pointer. const FunctionProtoType *FromFunc = GetUnderlyingFunction(From->getType()); if (!FromFunc) return false; // Now we've got the correct types on both sides, check their compatibility. // This means that the source of the conversion can only throw a subset of // the exceptions of the target, and any exception specs on arguments or // return types must be equivalent. return CheckExceptionSpecSubset(PDiag(diag::err_incompatible_exception_specs), PDiag(), ToFunc, From->getSourceRange().getBegin(), FromFunc, SourceLocation()); } bool Sema::CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old) { if (getLangOpts().CPlusPlus11 && isa(New)) { // Don't check uninstantiated template destructors at all. We can only // synthesize correct specs after the template is instantiated. if (New->getParent()->isDependentType()) return false; if (New->getParent()->isBeingDefined()) { // The destructor might be updated once the definition is finished. So // remember it and check later. DelayedDestructorExceptionSpecChecks.push_back(std::make_pair( cast(New), cast(Old))); return false; } } unsigned DiagID = diag::err_override_exception_spec; if (getLangOpts().MicrosoftExt) DiagID = diag::warn_override_exception_spec; return CheckExceptionSpecSubset(PDiag(DiagID), PDiag(diag::note_overridden_virtual_function), Old->getType()->getAs(), Old->getLocation(), New->getType()->getAs(), New->getLocation()); } static CanThrowResult canSubExprsThrow(Sema &S, const Expr *CE) { Expr *E = const_cast(CE); CanThrowResult R = CT_Cannot; for (Expr::child_range I = E->children(); I && R != CT_Can; ++I) R = mergeCanThrow(R, S.canThrow(cast(*I))); return R; } static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D) { assert(D && "Expected decl"); // See if we can get a function type from the decl somehow. const ValueDecl *VD = dyn_cast(D); if (!VD) // If we have no clue what we're calling, assume the worst. return CT_Can; // As an extension, we assume that __attribute__((nothrow)) functions don't // throw. if (isa(D) && D->hasAttr()) return CT_Cannot; QualType T = VD->getType(); const FunctionProtoType *FT; if ((FT = T->getAs())) { } else if (const PointerType *PT = T->getAs()) FT = PT->getPointeeType()->getAs(); else if (const ReferenceType *RT = T->getAs()) FT = RT->getPointeeType()->getAs(); else if (const MemberPointerType *MT = T->getAs()) FT = MT->getPointeeType()->getAs(); else if (const BlockPointerType *BT = T->getAs()) FT = BT->getPointeeType()->getAs(); if (!FT) return CT_Can; FT = S.ResolveExceptionSpec(E->getLocStart(), FT); if (!FT) return CT_Can; return FT->isNothrow(S.Context) ? CT_Cannot : CT_Can; } static CanThrowResult canDynamicCastThrow(const CXXDynamicCastExpr *DC) { if (DC->isTypeDependent()) return CT_Dependent; if (!DC->getTypeAsWritten()->isReferenceType()) return CT_Cannot; if (DC->getSubExpr()->isTypeDependent()) return CT_Dependent; return DC->getCastKind() == clang::CK_Dynamic? CT_Can : CT_Cannot; } static CanThrowResult canTypeidThrow(Sema &S, const CXXTypeidExpr *DC) { if (DC->isTypeOperand()) return CT_Cannot; Expr *Op = DC->getExprOperand(); if (Op->isTypeDependent()) return CT_Dependent; const RecordType *RT = Op->getType()->getAs(); if (!RT) return CT_Cannot; if (!cast(RT->getDecl())->isPolymorphic()) return CT_Cannot; if (Op->Classify(S.Context).isPRValue()) return CT_Cannot; return CT_Can; } CanThrowResult Sema::canThrow(const Expr *E) { // C++ [expr.unary.noexcept]p3: // [Can throw] if in a potentially-evaluated context the expression would // contain: switch (E->getStmtClass()) { case Expr::CXXThrowExprClass: // - a potentially evaluated throw-expression return CT_Can; case Expr::CXXDynamicCastExprClass: { // - a potentially evaluated dynamic_cast expression dynamic_cast(v), // where T is a reference type, that requires a run-time check CanThrowResult CT = canDynamicCastThrow(cast(E)); if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::CXXTypeidExprClass: // - a potentially evaluated typeid expression applied to a glvalue // expression whose type is a polymorphic class type return canTypeidThrow(*this, cast(E)); // - a potentially evaluated call to a function, member function, function // pointer, or member function pointer that does not have a non-throwing // exception-specification case Expr::CallExprClass: case Expr::CXXMemberCallExprClass: case Expr::CXXOperatorCallExprClass: case Expr::UserDefinedLiteralClass: { const CallExpr *CE = cast(E); CanThrowResult CT; if (E->isTypeDependent()) CT = CT_Dependent; else if (isa(CE->getCallee()->IgnoreParens())) CT = CT_Cannot; else if (CE->getCalleeDecl()) CT = canCalleeThrow(*this, E, CE->getCalleeDecl()); else CT = CT_Can; if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::CXXConstructExprClass: case Expr::CXXTemporaryObjectExprClass: { CanThrowResult CT = canCalleeThrow(*this, E, cast(E)->getConstructor()); if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::LambdaExprClass: { const LambdaExpr *Lambda = cast(E); CanThrowResult CT = CT_Cannot; for (LambdaExpr::capture_init_iterator Cap = Lambda->capture_init_begin(), CapEnd = Lambda->capture_init_end(); Cap != CapEnd; ++Cap) CT = mergeCanThrow(CT, canThrow(*Cap)); return CT; } case Expr::CXXNewExprClass: { CanThrowResult CT; if (E->isTypeDependent()) CT = CT_Dependent; else CT = canCalleeThrow(*this, E, cast(E)->getOperatorNew()); if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::CXXDeleteExprClass: { CanThrowResult CT; QualType DTy = cast(E)->getDestroyedType(); if (DTy.isNull() || DTy->isDependentType()) { CT = CT_Dependent; } else { CT = canCalleeThrow(*this, E, cast(E)->getOperatorDelete()); if (const RecordType *RT = DTy->getAs()) { const CXXRecordDecl *RD = cast(RT->getDecl()); const CXXDestructorDecl *DD = RD->getDestructor(); if (DD) CT = mergeCanThrow(CT, canCalleeThrow(*this, E, DD)); } if (CT == CT_Can) return CT; } return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::CXXBindTemporaryExprClass: { // The bound temporary has to be destroyed again, which might throw. CanThrowResult CT = canCalleeThrow(*this, E, cast(E)->getTemporary()->getDestructor()); if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } // ObjC message sends are like function calls, but never have exception // specs. case Expr::ObjCMessageExprClass: case Expr::ObjCPropertyRefExprClass: case Expr::ObjCSubscriptRefExprClass: return CT_Can; // All the ObjC literals that are implemented as calls are // potentially throwing unless we decide to close off that // possibility. case Expr::ObjCArrayLiteralClass: case Expr::ObjCDictionaryLiteralClass: case Expr::ObjCBoxedExprClass: return CT_Can; // Many other things have subexpressions, so we have to test those. // Some are simple: case Expr::ConditionalOperatorClass: case Expr::CompoundLiteralExprClass: case Expr::CXXConstCastExprClass: case Expr::CXXReinterpretCastExprClass: case Expr::CXXStdInitializerListExprClass: case Expr::DesignatedInitExprClass: case Expr::ExprWithCleanupsClass: case Expr::ExtVectorElementExprClass: case Expr::InitListExprClass: case Expr::MemberExprClass: case Expr::ObjCIsaExprClass: case Expr::ObjCIvarRefExprClass: case Expr::ParenExprClass: case Expr::ParenListExprClass: case Expr::ShuffleVectorExprClass: case Expr::ConvertVectorExprClass: case Expr::VAArgExprClass: return canSubExprsThrow(*this, E); // Some might be dependent for other reasons. case Expr::ArraySubscriptExprClass: case Expr::BinaryOperatorClass: case Expr::CompoundAssignOperatorClass: case Expr::CStyleCastExprClass: case Expr::CXXStaticCastExprClass: case Expr::CXXFunctionalCastExprClass: case Expr::ImplicitCastExprClass: case Expr::MaterializeTemporaryExprClass: case Expr::UnaryOperatorClass: { CanThrowResult CT = E->isTypeDependent() ? CT_Dependent : CT_Cannot; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } // FIXME: We should handle StmtExpr, but that opens a MASSIVE can of worms. case Expr::StmtExprClass: return CT_Can; case Expr::CXXDefaultArgExprClass: return canThrow(cast(E)->getExpr()); case Expr::CXXDefaultInitExprClass: return canThrow(cast(E)->getExpr()); case Expr::ChooseExprClass: if (E->isTypeDependent() || E->isValueDependent()) return CT_Dependent; return canThrow(cast(E)->getChosenSubExpr()); case Expr::GenericSelectionExprClass: if (cast(E)->isResultDependent()) return CT_Dependent; return canThrow(cast(E)->getResultExpr()); // Some expressions are always dependent. case Expr::CXXDependentScopeMemberExprClass: case Expr::CXXUnresolvedConstructExprClass: case Expr::DependentScopeDeclRefExprClass: return CT_Dependent; case Expr::AsTypeExprClass: case Expr::BinaryConditionalOperatorClass: case Expr::BlockExprClass: case Expr::CUDAKernelCallExprClass: case Expr::DeclRefExprClass: case Expr::ObjCBridgedCastExprClass: case Expr::ObjCIndirectCopyRestoreExprClass: case Expr::ObjCProtocolExprClass: case Expr::ObjCSelectorExprClass: case Expr::OffsetOfExprClass: case Expr::PackExpansionExprClass: case Expr::PseudoObjectExprClass: case Expr::SubstNonTypeTemplateParmExprClass: case Expr::SubstNonTypeTemplateParmPackExprClass: case Expr::FunctionParmPackExprClass: case Expr::UnaryExprOrTypeTraitExprClass: case Expr::UnresolvedLookupExprClass: case Expr::UnresolvedMemberExprClass: // FIXME: Can any of the above throw? If so, when? return CT_Cannot; case Expr::AddrLabelExprClass: case Expr::ArrayTypeTraitExprClass: case Expr::AtomicExprClass: case Expr::BinaryTypeTraitExprClass: case Expr::TypeTraitExprClass: case Expr::CXXBoolLiteralExprClass: case Expr::CXXNoexceptExprClass: case Expr::CXXNullPtrLiteralExprClass: case Expr::CXXPseudoDestructorExprClass: case Expr::CXXScalarValueInitExprClass: case Expr::CXXThisExprClass: case Expr::CXXUuidofExprClass: case Expr::CharacterLiteralClass: case Expr::ExpressionTraitExprClass: case Expr::FloatingLiteralClass: case Expr::GNUNullExprClass: case Expr::ImaginaryLiteralClass: case Expr::ImplicitValueInitExprClass: case Expr::IntegerLiteralClass: case Expr::ObjCEncodeExprClass: case Expr::ObjCStringLiteralClass: case Expr::ObjCBoolLiteralExprClass: case Expr::OpaqueValueExprClass: case Expr::PredefinedExprClass: case Expr::SizeOfPackExprClass: case Expr::StringLiteralClass: case Expr::UnaryTypeTraitExprClass: // These expressions can never throw. return CT_Cannot; case Expr::MSPropertyRefExprClass: llvm_unreachable("Invalid class for expression"); #define STMT(CLASS, PARENT) case Expr::CLASS##Class: #define STMT_RANGE(Base, First, Last) #define LAST_STMT_RANGE(BASE, FIRST, LAST) #define EXPR(CLASS, PARENT) #define ABSTRACT_STMT(STMT) #include "clang/AST/StmtNodes.inc" case Expr::NoStmtClass: llvm_unreachable("Invalid class for expression"); } llvm_unreachable("Bogus StmtClass"); } } // end namespace clang @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d1066 1 d1089 1 @ 1.1.1.3 log @Import Clang 3.5svn r201163. @ text @d143 2 a144 5 // For a function that the user didn't declare: // - if this is a destructor, its exception specification is implicit. // - if this is 'operator delete' or 'operator delete[]', the exception // specification is as-if an explicit exception specification was given // (per [basic.stc.dynamic]p2). d146 1 a146 1 return isa(Decl); a157 1 d159 1 a159 2 bool ReturnValueOnError = true; if (getLangOpts().MicrosoftExt) { a160 2 ReturnValueOnError = false; } d185 1 a185 1 // specification; return an error, except in MS mode where this is a warning. d187 1 a187 1 return ReturnValueOnError; d206 2 a207 2 QualType NewType = Context.getFunctionType(NewProto->getReturnType(), NewProto->getParamTypes(), EPI); d227 2 a228 2 QualType NewType = Context.getFunctionType(NewProto->getReturnType(), NewProto->getParamTypes(), EPI); d305 4 a308 8 DiagID = diag::warn_mismatched_exception_spec; bool Result = CheckEquivalentExceptionSpec(PDiag(DiagID), PDiag(diag::note_previous_declaration), Old, OldLoc, New, NewLoc); // In Microsoft mode, mismatching exception specifications just cause a warning. if (getLangOpts().MicrosoftExt) return false; return Result; d714 5 a718 4 if (CheckSpecForTypesEquivalent( *this, PDiag(diag::err_deep_exception_specs_differ) << 0, PDiag(), Target->getReturnType(), TargetLoc, Source->getReturnType(), SourceLoc)) d723 1 a723 1 assert(Target->getNumParams() == Source->getNumParams() && d725 6 a730 5 for (unsigned i = 0, E = Target->getNumParams(); i != E; ++i) { if (CheckSpecForTypesEquivalent( *this, PDiag(diag::err_deep_exception_specs_differ) << 1, PDiag(), Target->getParamType(i), TargetLoc, Source->getParamType(i), SourceLoc)) @ 1.1.1.3.2.1 log @Rebase. @ text @a14 1 #include "clang/AST/ASTMutationListener.h" d21 1 a134 19 void Sema::UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExtProtoInfo &EPI) { const FunctionProtoType *Proto = FD->getType()->castAs(); // Overwrite the exception spec and rebuild the function type. FunctionProtoType::ExtProtoInfo NewEPI = Proto->getExtProtoInfo(); NewEPI.ExceptionSpecType = EPI.ExceptionSpecType; NewEPI.NumExceptions = EPI.NumExceptions; NewEPI.Exceptions = EPI.Exceptions; NewEPI.NoexceptExpr = EPI.NoexceptExpr; FD->setType(Context.getFunctionType(Proto->getReturnType(), Proto->getParamTypes(), NewEPI)); // If we've fully resolved the exception specification, notify listeners. if (!isUnresolvedExceptionSpec(EPI.ExceptionSpecType)) if (auto *Listener = getASTMutationListener()) Listener->ResolvedExceptionSpec(FD); } d249 4 a252 1 for (const auto &E : OldProto->exceptions()) { d258 1 a258 1 OS << E.getAsString(getPrintingPolicy()); d270 1 a270 1 OldProto->getNoexceptExpr()->printPretty(OS, nullptr, getPrintingPolicy()); d283 1 a283 1 FixItLoc = getLocForEndOfToken(FTLoc.getLocalRangeEnd()); d442 1 a442 1 const FunctionProtoType *WithExceptions = nullptr; d455 9 a463 2 if (ExRecord->isInStdNamespace()) { return false; d502 7 a508 5 for (const auto &I : Old->exceptions()) OldTypes.insert(Context.getCanonicalType(I).getUnqualifiedType()); for (const auto &I : New->exceptions()) { CanQualType TypePtr = Context.getCanonicalType(I).getUnqualifiedType(); d616 2 a617 1 for (const auto &SubI : Subset->exceptions()) { d619 1 a619 1 QualType CanonicalSubT = Context.getCanonicalType(SubI); d638 4 a641 2 for (const auto &SuperI : Superset->exceptions()) { QualType CanonicalSuperT = Context.getCanonicalType(SuperI); @ 1.1.1.4 log @Import Clang 3.5svn r209886. @ text @a14 1 #include "clang/AST/ASTMutationListener.h" d21 1 a134 19 void Sema::UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExtProtoInfo &EPI) { const FunctionProtoType *Proto = FD->getType()->castAs(); // Overwrite the exception spec and rebuild the function type. FunctionProtoType::ExtProtoInfo NewEPI = Proto->getExtProtoInfo(); NewEPI.ExceptionSpecType = EPI.ExceptionSpecType; NewEPI.NumExceptions = EPI.NumExceptions; NewEPI.Exceptions = EPI.Exceptions; NewEPI.NoexceptExpr = EPI.NoexceptExpr; FD->setType(Context.getFunctionType(Proto->getReturnType(), Proto->getParamTypes(), NewEPI)); // If we've fully resolved the exception specification, notify listeners. if (!isUnresolvedExceptionSpec(EPI.ExceptionSpecType)) if (auto *Listener = getASTMutationListener()) Listener->ResolvedExceptionSpec(FD); } d249 4 a252 1 for (const auto &E : OldProto->exceptions()) { d258 1 a258 1 OS << E.getAsString(getPrintingPolicy()); d270 1 a270 1 OldProto->getNoexceptExpr()->printPretty(OS, nullptr, getPrintingPolicy()); d283 1 a283 1 FixItLoc = getLocForEndOfToken(FTLoc.getLocalRangeEnd()); d442 1 a442 1 const FunctionProtoType *WithExceptions = nullptr; d455 9 a463 2 if (ExRecord->isInStdNamespace()) { return false; d502 7 a508 5 for (const auto &I : Old->exceptions()) OldTypes.insert(Context.getCanonicalType(I).getUnqualifiedType()); for (const auto &I : New->exceptions()) { CanQualType TypePtr = Context.getCanonicalType(I).getUnqualifiedType(); d616 2 a617 1 for (const auto &SubI : Subset->exceptions()) { d619 1 a619 1 QualType CanonicalSubT = Context.getCanonicalType(SubI); d638 4 a641 2 for (const auto &SuperI : Superset->exceptions()) { QualType CanonicalSuperT = Context.getCanonicalType(SuperI); @ 1.1.1.5 log @Import clang 3.6svn r215315. @ text @d135 12 a146 13 void Sema::UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI) { for (auto *Redecl : FD->redecls()) { auto *RedeclFD = dyn_cast(Redecl); const FunctionProtoType *Proto = RedeclFD->getType()->castAs(); // Overwrite the exception spec and rebuild the function type. RedeclFD->setType(Context.getFunctionType( Proto->getReturnType(), Proto->getParamTypes(), Proto->getExtProtoInfo().withExceptionSpec(ESI))); } d149 1 a149 1 if (!isUnresolvedExceptionSpec(ESI.Type)) d184 1 a184 1 DiagID = diag::ext_mismatched_exception_spec; d230 5 a234 3 New->setType(Context.getFunctionType( NewProto->getReturnType(), NewProto->getParamTypes(), NewProto->getExtProtoInfo().withExceptionSpec(EST_DynamicNone))); d241 6 a246 4 FunctionProtoType::ExceptionSpecInfo ESI = OldProto->getExceptionSpecType(); if (ESI.Type == EST_Dynamic) { ESI.Exceptions = OldProto->exceptions(); } else if (ESI.Type == EST_ComputedNoexcept) { d253 3 a255 3 New->setType(Context.getFunctionType( NewProto->getReturnType(), NewProto->getParamTypes(), NewProto->getExtProtoInfo().withExceptionSpec(ESI))); a285 1 assert(OldProto->getNoexceptExpr() != nullptr && "Expected non-null Expr"); d328 1 a328 1 DiagID = diag::ext_mismatched_exception_spec; d789 1 a789 1 DiagID = diag::ext_override_exception_spec; @ 1.1.1.5.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @a37 27 /// HACK: libstdc++ has a bug where it shadows std::swap with a member /// swap function then tries to call std::swap unqualified from the exception /// specification of that function. This function detects whether we're in /// such a case and turns off delay-parsing of exception specifications. bool Sema::isLibstdcxxEagerExceptionSpecHack(const Declarator &D) { auto *RD = dyn_cast(CurContext); // All the problem cases are member functions named "swap" within class // templates declared directly within namespace std. if (!RD || RD->getEnclosingNamespaceContext() != getStdNamespace() || !RD->getIdentifier() || !RD->getDescribedClassTemplate() || !D.getIdentifier() || !D.getIdentifier()->isStr("swap")) return false; // Only apply this hack within a system header. if (!Context.getSourceManager().isInSystemHeader(D.getLocStart())) return false; return llvm::StringSwitch(RD->getIdentifier()->getName()) .Case("array", true) .Case("pair", true) .Case("priority_queue", true) .Case("stack", true) .Case("queue", true) .Default(false); } a114 5 if (FPT->getExceptionSpecType() == EST_Unparsed) { Diag(Loc, diag::err_exception_spec_not_parsed); return nullptr; } d138 10 a147 2 for (auto *Redecl : FD->redecls()) Context.adjustExceptionSpec(cast(Redecl), ESI); d723 4 a726 5 bool Sema::CheckParamExceptionSpec(const PartialDiagnostic &NoteID, const FunctionProtoType *Target, SourceLocation TargetLoc, const FunctionProtoType *Source, SourceLocation SourceLoc) { d747 2 a748 1 bool Sema::CheckExceptionSpecCompatibility(Expr *From, QualType ToType) { d752 1 a752 1 if (!ToFunc || ToFunc->hasDependentExceptionSpec()) d757 1 a757 1 if (!FromFunc || FromFunc->hasDependentExceptionSpec()) a763 8 // // FIXME: If there is a nested dependent exception specification, we should // not be checking it here. This is fine: // template void f() { // void (*p)(void (*) throw(T)); // void (*q)(void (*) throw(int)) = p; // } // ... because it might be instantiated with T=int. a771 5 // If the new exception specification hasn't been parsed yet, skip the check. // We'll get called again once it's been parsed. if (New->getType()->castAs()->getExceptionSpecType() == EST_Unparsed) return false; d780 2 a781 1 DelayedExceptionSpecChecks.push_back(std::make_pair(New, Old)); a784 8 // If the old exception specification hasn't been parsed yet, remember that // we need to perform this check when we get to the end of the outermost // lexically-surrounding class. if (Old->getType()->castAs()->getExceptionSpecType() == EST_Unparsed) { DelayedExceptionSpecChecks.push_back(std::make_pair(New, Old)); return false; } a1050 1 case Expr::CXXFoldExprClass: a1070 1 case Expr::TypoExprClass: @ 1.1.1.6 log @Import Clang 3.6RC1 r227398. @ text @a37 27 /// HACK: libstdc++ has a bug where it shadows std::swap with a member /// swap function then tries to call std::swap unqualified from the exception /// specification of that function. This function detects whether we're in /// such a case and turns off delay-parsing of exception specifications. bool Sema::isLibstdcxxEagerExceptionSpecHack(const Declarator &D) { auto *RD = dyn_cast(CurContext); // All the problem cases are member functions named "swap" within class // templates declared directly within namespace std. if (!RD || RD->getEnclosingNamespaceContext() != getStdNamespace() || !RD->getIdentifier() || !RD->getDescribedClassTemplate() || !D.getIdentifier() || !D.getIdentifier()->isStr("swap")) return false; // Only apply this hack within a system header. if (!Context.getSourceManager().isInSystemHeader(D.getLocStart())) return false; return llvm::StringSwitch(RD->getIdentifier()->getName()) .Case("array", true) .Case("pair", true) .Case("priority_queue", true) .Case("stack", true) .Case("queue", true) .Default(false); } a114 5 if (FPT->getExceptionSpecType() == EST_Unparsed) { Diag(Loc, diag::err_exception_spec_not_parsed); return nullptr; } d138 10 a147 2 for (auto *Redecl : FD->redecls()) Context.adjustExceptionSpec(cast(Redecl), ESI); d723 4 a726 5 bool Sema::CheckParamExceptionSpec(const PartialDiagnostic &NoteID, const FunctionProtoType *Target, SourceLocation TargetLoc, const FunctionProtoType *Source, SourceLocation SourceLoc) { d747 2 a748 1 bool Sema::CheckExceptionSpecCompatibility(Expr *From, QualType ToType) { d752 1 a752 1 if (!ToFunc || ToFunc->hasDependentExceptionSpec()) d757 1 a757 1 if (!FromFunc || FromFunc->hasDependentExceptionSpec()) a763 8 // // FIXME: If there is a nested dependent exception specification, we should // not be checking it here. This is fine: // template void f() { // void (*p)(void (*) throw(T)); // void (*q)(void (*) throw(int)) = p; // } // ... because it might be instantiated with T=int. a771 5 // If the new exception specification hasn't been parsed yet, skip the check. // We'll get called again once it's been parsed. if (New->getType()->castAs()->getExceptionSpecType() == EST_Unparsed) return false; d780 2 a781 1 DelayedExceptionSpecChecks.push_back(std::make_pair(New, Old)); a784 8 // If the old exception specification hasn't been parsed yet, remember that // we need to perform this check when we get to the end of the outermost // lexically-surrounding class. if (Old->getType()->castAs()->getExceptionSpecType() == EST_Unparsed) { DelayedExceptionSpecChecks.push_back(std::make_pair(New, Old)); return false; } a1050 1 case Expr::CXXFoldExprClass: a1070 1 case Expr::TypoExprClass: @ 1.1.1.7 log @Import Clang 3.8.0rc3 r261930. @ text @d71 1 a71 1 bool Sema::CheckSpecifiedExceptionType(QualType &T, SourceRange Range) { d164 1 a164 7 const FunctionProtoType *Proto = SourceDecl->getType()->castAs(); if (Proto->getExceptionSpecType() == clang::EST_Unparsed) { Diag(Loc, diag::err_exception_spec_not_parsed); Proto = nullptr; } return Proto; d170 3 a176 3 for (auto *Redecl : FD->redecls()) Context.adjustExceptionSpec(cast(Redecl), ESI); d229 1 a229 1 if (Old->getLocation().isValid()) d267 3 d272 5 a276 27 if (ESI.Type == EST_ComputedNoexcept) { // For computed noexcept, we can't just take the expression from the old // prototype. It likely contains references to the old prototype's // parameters. New->setInvalidDecl(); } else { // Update the type of the function with the appropriate exception // specification. New->setType(Context.getFunctionType( NewProto->getReturnType(), NewProto->getParamTypes(), NewProto->getExtProtoInfo().withExceptionSpec(ESI))); } if (getLangOpts().MicrosoftExt && ESI.Type != EST_ComputedNoexcept) { // Allow missing exception specifications in redeclarations as an extension. DiagID = diag::ext_ms_missing_exception_specification; ReturnValueOnError = false; } else if (New->isReplaceableGlobalAllocationFunction() && ESI.Type != EST_ComputedNoexcept) { // Allow missing exception specifications in redeclarations as an extension, // when declaring a replaceable global allocation function. DiagID = diag::ext_missing_exception_specification; ReturnValueOnError = false; } else { DiagID = diag::err_missing_exception_specification; ReturnValueOnError = true; } d315 1 d320 2 a321 5 // FIXME: Preserve enough information so that we can produce a correct fixit // location when there is a trailing return type. if (auto FTLoc = TL.getAs()) if (!FTLoc.getTypePtr()->hasTrailingReturn()) FixItLoc = getLocForEndOfToken(FTLoc.getLocalRangeEnd()); d325 1 a325 1 Diag(New->getLocation(), DiagID) d328 3 a330 1 Diag(New->getLocation(), DiagID) d335 1 a335 1 if (Old->getLocation().isValid()) d338 1 a338 1 return ReturnValueOnError; d400 1 a400 1 // C++0x [except.spec]p12: An exception-specification is non-throwing if it is d440 1 a440 1 if (NoteID.getDiagID() != 0 && OldLoc.isValid()) d521 1 a521 1 if (NoteID.getDiagID() != 0 && OldLoc.isValid()) d550 1 a550 1 if (NoteID.getDiagID() != 0 && OldLoc.isValid()) d691 1 a691 1 if (!IsDerivedFrom(SubLoc, CanonicalSubT, CanonicalSuperT, Paths)) d840 2 a841 1 static CanThrowResult canSubExprsThrow(Sema &S, const Expr *E) { d843 2 a844 5 for (const Stmt *SubStmt : E->children()) { R = mergeCanThrow(R, S.canThrow(cast(SubStmt))); if (R == CT_Can) break; } d974 2 a975 3 for (LambdaExpr::const_capture_init_iterator Cap = Lambda->capture_init_begin(), CapEnd = Lambda->capture_init_end(); a1037 1 case Expr::CoawaitExprClass: a1039 1 case Expr::CoyieldExprClass: a1043 1 case Expr::DesignatedInitUpdateExprClass: a1058 1 case Expr::OMPArraySectionExprClass: a1137 1 case Expr::NoInitExprClass: a1148 1 case Expr::MSPropertySubscriptExprClass: @ 1.1.1.7.2.1 log @Sync with HEAD @ text @d46 3 a48 3 // templates declared directly within namespace std or std::__debug or // std::__profile. if (!RD || !RD->getIdentifier() || !RD->getDescribedClassTemplate() || a51 14 auto *ND = dyn_cast(RD->getDeclContext()); if (!ND) return false; bool IsInStd = ND->isStdNamespace(); if (!IsInStd) { // This isn't a direct member of namespace std, but it might still be // libstdc++'s std::__debug::array or std::__profile::array. IdentifierInfo *II = ND->getIdentifier(); if (!II || !(II->isStr("__debug") || II->isStr("__profile")) || !ND->isInStdNamespace()) return false; } d58 4 a61 4 .Case("pair", IsInStd) .Case("priority_queue", IsInStd) .Case("stack", IsInStd) .Case("queue", IsInStd) a112 7 // In Microsoft mode, downgrade this to a warning. unsigned DiagID = diag::err_incomplete_in_exception_spec; bool ReturnValueOnError = true; if (getLangOpts().MicrosoftExt) { DiagID = diag::ext_incomplete_in_exception_spec; ReturnValueOnError = false; } d115 3 a117 2 RequireCompleteType(Range.getBegin(), PointeeT, DiagID, Kind, Range)) return ReturnValueOnError; a125 5 // C++17 removes this rule in favor of putting exception specifications into // the type system. if (getLangOpts().CPlusPlus1z) return false; a184 8 static bool CheckEquivalentExceptionSpecImpl( Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Old, SourceLocation OldLoc, const FunctionProtoType *New, SourceLocation NewLoc, bool *MissingExceptionSpecification = nullptr, bool *MissingEmptyExceptionSpecification = nullptr, bool AllowNoexceptAllMatchWithNoSpec = false, bool IsOperatorNew = false); a206 6 // Just completely ignore this under -fno-exceptions prior to C++1z. // In C++1z onwards, the exception specification is part of the type and // we will diagnose mismatches anyway, so it's better to check for them here. if (!getLangOpts().CXXExceptions && !getLangOpts().CPlusPlus1z) return false; d221 2 a222 2 if (!CheckEquivalentExceptionSpecImpl( *this, PDiag(DiagID), PDiag(diag::note_previous_declaration), d231 1 a231 1 if (getLangOpts().CPlusPlus11 && getLangOpts().CXXExceptions && d252 5 a256 5 // exception specification to the "new" declaration. Note that C library // implementations are permitted to add these nothrow exception // specifications. // // Likewise if the old function is a builtin. d259 1 a259 2 Context.getSourceManager().isInSystemHeader(Old->getLocation()) || Old->getBuiltinID()) && a372 3 if (!getLangOpts().CXXExceptions) return false; d376 2 a377 3 bool Result = CheckEquivalentExceptionSpecImpl( *this, PDiag(DiagID), PDiag(diag::note_previous_declaration), Old, OldLoc, New, NewLoc); d391 14 a404 7 static bool CheckEquivalentExceptionSpecImpl( Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Old, SourceLocation OldLoc, const FunctionProtoType *New, SourceLocation NewLoc, bool *MissingExceptionSpecification, bool *MissingEmptyExceptionSpecification, bool AllowNoexceptAllMatchWithNoSpec, bool IsOperatorNew) { d411 1 a411 1 Old = S.ResolveExceptionSpec(NewLoc, Old); d414 1 a414 1 New = S.ResolveExceptionSpec(NewLoc, New); d448 2 a449 2 FunctionProtoType::NoexceptResult OldNR = Old->getNoexceptSpec(S.Context); FunctionProtoType::NoexceptResult NewNR = New->getNoexceptSpec(S.Context); d464 1 a464 1 S.Diag(NewLoc, DiagID); d466 1 a466 1 S.Diag(OldLoc, NoteID); d504 1 a504 1 if (S.getLangOpts().CPlusPlus11 && IsOperatorNew) { d545 1 a545 1 S.Diag(NewLoc, DiagID); d547 1 a547 1 S.Diag(OldLoc, NoteID); d559 1 a559 1 OldTypes.insert(S.Context.getCanonicalType(I).getUnqualifiedType()); d562 2 a563 2 CanQualType TypePtr = S.Context.getCanonicalType(I).getUnqualifiedType(); if (OldTypes.count(TypePtr)) d574 1 a574 1 S.Diag(NewLoc, DiagID); d576 1 a576 1 S.Diag(OldLoc, NoteID); a579 12 bool Sema::CheckEquivalentExceptionSpec(const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Old, SourceLocation OldLoc, const FunctionProtoType *New, SourceLocation NewLoc) { if (!getLangOpts().CXXExceptions) return false; return CheckEquivalentExceptionSpecImpl(*this, DiagID, NoteID, Old, OldLoc, New, NewLoc); } d583 4 a586 7 bool Sema::CheckExceptionSpecSubset(const PartialDiagnostic &DiagID, const PartialDiagnostic &NestedDiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Superset, SourceLocation SuperLoc, const FunctionProtoType *Subset, SourceLocation SubLoc) { d610 1 a610 2 return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc, Subset, SubLoc); d625 1 a625 2 return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc, Subset, SubLoc); d656 1 a656 2 return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc, Subset, SubLoc); d748 1 a748 2 return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc, Subset, SubLoc); d751 5 a755 5 static bool CheckSpecForTypesEquivalent(Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, QualType Target, SourceLocation TargetLoc, QualType Source, SourceLocation SourceLoc) { d772 1 a772 2 bool Sema::CheckParamExceptionSpec(const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, a776 2 auto RetDiag = DiagID; RetDiag << 0; d778 1 a778 1 *this, RetDiag, PDiag(), a787 2 auto ParamDiag = DiagID; ParamDiag << 1; d789 1 a789 1 *this, ParamDiag, PDiag(), a808 10 unsigned DiagID = diag::err_incompatible_exception_specs; unsigned NestedDiagID = diag::err_deep_exception_specs_differ; // This is not an error in C++17 onwards, unless the noexceptness doesn't // match, but in that case we have a full-on type mismatch, not just a // type sugar mismatch. if (getLangOpts().CPlusPlus1z) { DiagID = diag::warn_incompatible_exception_specs; NestedDiagID = diag::warn_deep_exception_specs_differ; } d821 4 a824 4 return CheckExceptionSpecSubset(PDiag(DiagID), PDiag(NestedDiagID), PDiag(), ToFunc, From->getSourceRange().getBegin(), FromFunc, SourceLocation()) && !getLangOpts().CPlusPlus1z; a857 1 PDiag(diag::err_deep_exception_specs_differ), d876 7 d885 1 a885 1 if (D && isa(D) && D->hasAttr()) d888 1 a888 26 QualType T; // In C++1z, just look at the function type of the callee. if (S.getLangOpts().CPlusPlus1z && isa(E)) { E = cast(E)->getCallee(); T = E->getType(); if (T->isSpecificPlaceholderType(BuiltinType::BoundMember)) { // Sadly we don't preserve the actual type as part of the "bound member" // placeholder, so we need to reconstruct it. E = E->IgnoreParenImpCasts(); // Could be a call to a pointer-to-member or a plain member access. if (auto *Op = dyn_cast(E)) { assert(Op->getOpcode() == BO_PtrMemD || Op->getOpcode() == BO_PtrMemI); T = Op->getRHS()->getType() ->castAs()->getPointeeType(); } else { T = cast(E)->getMemberDecl()->getType(); } } } else if (const ValueDecl *VD = dyn_cast_or_null(D)) T = VD->getType(); else // If we have no clue what we're calling, assume the worst. return CT_Can; d980 2 d983 1 a983 1 CT = canCalleeThrow(*this, E, CE->getCalleeDecl()); a997 4 case Expr::CXXInheritedCtorInitExprClass: return canCalleeThrow(*this, E, cast(E)->getConstructor()); a1077 1 case Expr::ArrayInitLoopExprClass: a1138 1 case Expr::ObjCAvailabilityCheckExprClass: a1169 1 case Expr::ArrayInitIndexExprClass: @ 1.1.1.8 log @Import Clang pre-4.0.0 r291444. @ text @d46 3 a48 3 // templates declared directly within namespace std or std::__debug or // std::__profile. if (!RD || !RD->getIdentifier() || !RD->getDescribedClassTemplate() || a51 14 auto *ND = dyn_cast(RD->getDeclContext()); if (!ND) return false; bool IsInStd = ND->isStdNamespace(); if (!IsInStd) { // This isn't a direct member of namespace std, but it might still be // libstdc++'s std::__debug::array or std::__profile::array. IdentifierInfo *II = ND->getIdentifier(); if (!II || !(II->isStr("__debug") || II->isStr("__profile")) || !ND->isInStdNamespace()) return false; } d58 4 a61 4 .Case("pair", IsInStd) .Case("priority_queue", IsInStd) .Case("stack", IsInStd) .Case("queue", IsInStd) a112 7 // In Microsoft mode, downgrade this to a warning. unsigned DiagID = diag::err_incomplete_in_exception_spec; bool ReturnValueOnError = true; if (getLangOpts().MicrosoftExt) { DiagID = diag::ext_incomplete_in_exception_spec; ReturnValueOnError = false; } d115 3 a117 2 RequireCompleteType(Range.getBegin(), PointeeT, DiagID, Kind, Range)) return ReturnValueOnError; a125 5 // C++17 removes this rule in favor of putting exception specifications into // the type system. if (getLangOpts().CPlusPlus1z) return false; a184 8 static bool CheckEquivalentExceptionSpecImpl( Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Old, SourceLocation OldLoc, const FunctionProtoType *New, SourceLocation NewLoc, bool *MissingExceptionSpecification = nullptr, bool *MissingEmptyExceptionSpecification = nullptr, bool AllowNoexceptAllMatchWithNoSpec = false, bool IsOperatorNew = false); a206 6 // Just completely ignore this under -fno-exceptions prior to C++1z. // In C++1z onwards, the exception specification is part of the type and // we will diagnose mismatches anyway, so it's better to check for them here. if (!getLangOpts().CXXExceptions && !getLangOpts().CPlusPlus1z) return false; d221 2 a222 2 if (!CheckEquivalentExceptionSpecImpl( *this, PDiag(DiagID), PDiag(diag::note_previous_declaration), d231 1 a231 1 if (getLangOpts().CPlusPlus11 && getLangOpts().CXXExceptions && d252 5 a256 5 // exception specification to the "new" declaration. Note that C library // implementations are permitted to add these nothrow exception // specifications. // // Likewise if the old function is a builtin. d259 1 a259 2 Context.getSourceManager().isInSystemHeader(Old->getLocation()) || Old->getBuiltinID()) && a372 3 if (!getLangOpts().CXXExceptions) return false; d376 2 a377 3 bool Result = CheckEquivalentExceptionSpecImpl( *this, PDiag(DiagID), PDiag(diag::note_previous_declaration), Old, OldLoc, New, NewLoc); d391 14 a404 7 static bool CheckEquivalentExceptionSpecImpl( Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Old, SourceLocation OldLoc, const FunctionProtoType *New, SourceLocation NewLoc, bool *MissingExceptionSpecification, bool *MissingEmptyExceptionSpecification, bool AllowNoexceptAllMatchWithNoSpec, bool IsOperatorNew) { d411 1 a411 1 Old = S.ResolveExceptionSpec(NewLoc, Old); d414 1 a414 1 New = S.ResolveExceptionSpec(NewLoc, New); d448 2 a449 2 FunctionProtoType::NoexceptResult OldNR = Old->getNoexceptSpec(S.Context); FunctionProtoType::NoexceptResult NewNR = New->getNoexceptSpec(S.Context); d464 1 a464 1 S.Diag(NewLoc, DiagID); d466 1 a466 1 S.Diag(OldLoc, NoteID); d504 1 a504 1 if (S.getLangOpts().CPlusPlus11 && IsOperatorNew) { d545 1 a545 1 S.Diag(NewLoc, DiagID); d547 1 a547 1 S.Diag(OldLoc, NoteID); d559 1 a559 1 OldTypes.insert(S.Context.getCanonicalType(I).getUnqualifiedType()); d562 2 a563 2 CanQualType TypePtr = S.Context.getCanonicalType(I).getUnqualifiedType(); if (OldTypes.count(TypePtr)) d574 1 a574 1 S.Diag(NewLoc, DiagID); d576 1 a576 1 S.Diag(OldLoc, NoteID); a579 12 bool Sema::CheckEquivalentExceptionSpec(const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Old, SourceLocation OldLoc, const FunctionProtoType *New, SourceLocation NewLoc) { if (!getLangOpts().CXXExceptions) return false; return CheckEquivalentExceptionSpecImpl(*this, DiagID, NoteID, Old, OldLoc, New, NewLoc); } d583 4 a586 7 bool Sema::CheckExceptionSpecSubset(const PartialDiagnostic &DiagID, const PartialDiagnostic &NestedDiagID, const PartialDiagnostic &NoteID, const FunctionProtoType *Superset, SourceLocation SuperLoc, const FunctionProtoType *Subset, SourceLocation SubLoc) { d610 1 a610 2 return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc, Subset, SubLoc); d625 1 a625 2 return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc, Subset, SubLoc); d656 1 a656 2 return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc, Subset, SubLoc); d748 1 a748 2 return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, SuperLoc, Subset, SubLoc); d751 5 a755 5 static bool CheckSpecForTypesEquivalent(Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, QualType Target, SourceLocation TargetLoc, QualType Source, SourceLocation SourceLoc) { d772 1 a772 2 bool Sema::CheckParamExceptionSpec(const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, a776 2 auto RetDiag = DiagID; RetDiag << 0; d778 1 a778 1 *this, RetDiag, PDiag(), a787 2 auto ParamDiag = DiagID; ParamDiag << 1; d789 1 a789 1 *this, ParamDiag, PDiag(), a808 10 unsigned DiagID = diag::err_incompatible_exception_specs; unsigned NestedDiagID = diag::err_deep_exception_specs_differ; // This is not an error in C++17 onwards, unless the noexceptness doesn't // match, but in that case we have a full-on type mismatch, not just a // type sugar mismatch. if (getLangOpts().CPlusPlus1z) { DiagID = diag::warn_incompatible_exception_specs; NestedDiagID = diag::warn_deep_exception_specs_differ; } d821 4 a824 4 return CheckExceptionSpecSubset(PDiag(DiagID), PDiag(NestedDiagID), PDiag(), ToFunc, From->getSourceRange().getBegin(), FromFunc, SourceLocation()) && !getLangOpts().CPlusPlus1z; a857 1 PDiag(diag::err_deep_exception_specs_differ), d876 7 d885 1 a885 1 if (D && isa(D) && D->hasAttr()) d888 1 a888 26 QualType T; // In C++1z, just look at the function type of the callee. if (S.getLangOpts().CPlusPlus1z && isa(E)) { E = cast(E)->getCallee(); T = E->getType(); if (T->isSpecificPlaceholderType(BuiltinType::BoundMember)) { // Sadly we don't preserve the actual type as part of the "bound member" // placeholder, so we need to reconstruct it. E = E->IgnoreParenImpCasts(); // Could be a call to a pointer-to-member or a plain member access. if (auto *Op = dyn_cast(E)) { assert(Op->getOpcode() == BO_PtrMemD || Op->getOpcode() == BO_PtrMemI); T = Op->getRHS()->getType() ->castAs()->getPointeeType(); } else { T = cast(E)->getMemberDecl()->getType(); } } } else if (const ValueDecl *VD = dyn_cast_or_null(D)) T = VD->getType(); else // If we have no clue what we're calling, assume the worst. return CT_Can; d980 2 d983 1 a983 1 CT = canCalleeThrow(*this, E, CE->getCalleeDecl()); a997 4 case Expr::CXXInheritedCtorInitExprClass: return canCalleeThrow(*this, E, cast(E)->getConstructor()); a1077 1 case Expr::ArrayInitLoopExprClass: a1138 1 case Expr::ObjCAvailabilityCheckExprClass: a1169 1 case Expr::ArrayInitIndexExprClass: @ 1.1.1.9 log @Import clang r309604 from branches/release_50 @ text @a1184 1 case Expr::DependentCoawaitExprClass: @ 1.1.1.9.4.1 log @Sync with HEAD @ text @a78 23 ExprResult Sema::ActOnNoexceptSpec(SourceLocation NoexceptLoc, Expr *NoexceptExpr, ExceptionSpecificationType &EST) { // FIXME: This is bogus, a noexcept expression is not a condition. ExprResult Converted = CheckBooleanCondition(NoexceptLoc, NoexceptExpr); if (Converted.isInvalid()) return Converted; if (Converted.get()->isValueDependent()) { EST = EST_DependentNoexcept; return Converted; } llvm::APSInt Result; Converted = VerifyIntegerConstantExpression( Converted.get(), &Result, diag::err_noexcept_needs_constant_expression, /*AllowFold*/ false); if (!Converted.isInvalid()) EST = !Result ? EST_NoexceptFalse : EST_NoexceptTrue; return Converted; } d148 1 a148 1 if (getLangOpts().CPlusPlus17) d206 2 a207 2 for (FunctionDecl *Redecl : FD->redecls()) Context.adjustExceptionSpec(Redecl, ESI); d240 2 a241 2 // Just completely ignore this under -fno-exceptions prior to C++17. // In C++17 onwards, the exception specification is part of the type and d243 1 a243 1 if (!getLangOpts().CXXExceptions && !getLangOpts().CPlusPlus17) a311 2 // FIXME: What if the exceptions are described in terms of the old // prototype's parameters? d315 4 a318 8 if (ESI.Type == EST_NoexceptFalse) ESI.Type = EST_None; if (ESI.Type == EST_NoexceptTrue) ESI.Type = EST_BasicNoexcept; // For dependent noexcept, we can't just take the expression from the old // prototype. It likely contains references to the old prototype's parameters. if (ESI.Type == EST_DependentNoexcept) { d328 1 a328 1 if (getLangOpts().MicrosoftExt && ESI.Type != EST_DependentNoexcept) { d333 1 a333 1 ESI.Type != EST_DependentNoexcept) { d370 1 a370 3 case EST_DependentNoexcept: case EST_NoexceptFalse: case EST_NoexceptTrue: d481 2 a482 5 CanThrowResult OldCanThrow = Old->canThrow(); CanThrowResult NewCanThrow = New->canThrow(); // Any non-throwing specifications are compatible. if (OldCanThrow == CT_Cannot && NewCanThrow == CT_Cannot) d485 20 a504 12 // Any throws-anything specifications are usually compatible. if (OldCanThrow == CT_Can && OldEST != EST_Dynamic && NewCanThrow == CT_Can && NewEST != EST_Dynamic) { // The exception is that the absence of an exception specification only // matches noexcept(false) for functions, as described above. if (!AllowNoexceptAllMatchWithNoSpec && ((OldEST == EST_None && NewEST == EST_NoexceptFalse) || (OldEST == EST_NoexceptFalse && NewEST == EST_None))) { // This is the disallowed case. } else { return false; } d507 8 a514 10 // C++14 [except.spec]p3: // Two exception-specifications are compatible if [...] both have the form // noexcept(constant-expression) and the constant-expressions are equivalent if (OldEST == EST_DependentNoexcept && NewEST == EST_DependentNoexcept) { llvm::FoldingSetNodeID OldFSN, NewFSN; Old->getNoexceptExpr()->Profile(OldFSN, S.Context, true); New->getNoexceptExpr()->Profile(NewFSN, S.Context, true); if (OldFSN == NewFSN) return false; } d516 5 a520 19 // Dynamic exception specifications with the same set of adjusted types // are compatible. if (OldEST == EST_Dynamic && NewEST == EST_Dynamic) { bool Success = true; // Both have a dynamic exception spec. Collect the first set, then compare // to the second. llvm::SmallPtrSet OldTypes, NewTypes; for (const auto &I : Old->exceptions()) OldTypes.insert(S.Context.getCanonicalType(I).getUnqualifiedType()); for (const auto &I : New->exceptions()) { CanQualType TypePtr = S.Context.getCanonicalType(I).getUnqualifiedType(); if (OldTypes.count(TypePtr)) NewTypes.insert(TypePtr); else { Success = false; break; } } d522 5 a526 1 if (Success && OldTypes.size() == NewTypes.size()) d530 8 d563 17 a579 13 // If the caller wants to handle the case that the new function is // incompatible due to a missing exception specification, let it. if (MissingExceptionSpecification && OldEST != EST_None && NewEST == EST_None) { // The old type has an exception specification of some sort, but // the new type does not. *MissingExceptionSpecification = true; if (MissingEmptyExceptionSpecification && OldCanThrow == CT_Cannot) { // The old type has a throw() or noexcept(true) exception specification // and the new type has no exception specification, and the caller asked // to handle this itself. *MissingEmptyExceptionSpecification = true; d582 3 d588 23 a628 84 bool Sema::handlerCanCatch(QualType HandlerType, QualType ExceptionType) { // [except.handle]p3: // A handler is a match for an exception object of type E if: // HandlerType must be ExceptionType or derived from it, or pointer or // reference to such types. const ReferenceType *RefTy = HandlerType->getAs(); if (RefTy) HandlerType = RefTy->getPointeeType(); // -- the handler is of type cv T or cv T& and E and T are the same type if (Context.hasSameUnqualifiedType(ExceptionType, HandlerType)) return true; // FIXME: ObjC pointer types? if (HandlerType->isPointerType() || HandlerType->isMemberPointerType()) { if (RefTy && (!HandlerType.isConstQualified() || HandlerType.isVolatileQualified())) return false; // -- the handler is of type cv T or const T& where T is a pointer or // pointer to member type and E is std::nullptr_t if (ExceptionType->isNullPtrType()) return true; // -- the handler is of type cv T or const T& where T is a pointer or // pointer to member type and E is a pointer or pointer to member type // that can be converted to T by one or more of // -- a qualification conversion // -- a function pointer conversion bool LifetimeConv; QualType Result; // FIXME: Should we treat the exception as catchable if a lifetime // conversion is required? if (IsQualificationConversion(ExceptionType, HandlerType, false, LifetimeConv) || IsFunctionConversion(ExceptionType, HandlerType, Result)) return true; // -- a standard pointer conversion [...] if (!ExceptionType->isPointerType() || !HandlerType->isPointerType()) return false; // Handle the "qualification conversion" portion. Qualifiers EQuals, HQuals; ExceptionType = Context.getUnqualifiedArrayType( ExceptionType->getPointeeType(), EQuals); HandlerType = Context.getUnqualifiedArrayType( HandlerType->getPointeeType(), HQuals); if (!HQuals.compatiblyIncludes(EQuals)) return false; if (HandlerType->isVoidType() && ExceptionType->isObjectType()) return true; // The only remaining case is a derived-to-base conversion. } // -- the handler is of type cg T or cv T& and T is an unambiguous public // base class of E if (!ExceptionType->isRecordType() || !HandlerType->isRecordType()) return false; CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, /*DetectVirtual=*/false); if (!IsDerivedFrom(SourceLocation(), ExceptionType, HandlerType, Paths) || Paths.isAmbiguous(Context.getCanonicalType(HandlerType))) return false; // Do this check from a context without privileges. switch (CheckBaseClassAccess(SourceLocation(), HandlerType, ExceptionType, Paths.front(), /*Diagnostic*/ 0, /*ForceCheck*/ true, /*ForceUnprivileged*/ true)) { case AR_accessible: return true; case AR_inaccessible: return false; case AR_dependent: llvm_unreachable("access check dependent for unprivileged context"); case AR_delayed: llvm_unreachable("access check delayed in non-declaration"); } llvm_unreachable("unexpected access check result"); } d659 22 d682 1 d687 11 a697 5 // If there are dependent noexcept specs, assume everything is fine. Unlike // with the equivalency check, this is safe in this case, because we don't // want to merge declarations. Checks after instantiation will catch any // omissions we make here. if (SuperEST == EST_DependentNoexcept || SubEST == EST_DependentNoexcept) d700 7 a706 2 CanThrowResult SuperCanThrow = Superset->canThrow(); CanThrowResult SubCanThrow = Subset->canThrow(); d708 2 a709 4 // If the superset contains everything or the subset contains nothing, we're // done. if ((SuperCanThrow == CT_Can && SuperEST != EST_Dynamic) || SubCanThrow == CT_Cannot) d713 2 a714 4 // If the subset contains everything or the superset contains nothing, we've // failed. if ((SubCanThrow == CT_Can && SubEST != EST_Dynamic) || SuperCanThrow == CT_Cannot) { d725 18 a742 3 for (QualType SubI : Subset->exceptions()) { if (const ReferenceType *RefTy = SubI->getAs()) SubI = RefTy->getPointeeType(); d744 1 d746 16 a761 9 bool Contained = false; for (QualType SuperI : Superset->exceptions()) { // [except.spec]p5: // the target entity shall allow at least the exceptions allowed by the // source // // We interpret this as meaning that a handler for some target type would // catch an exception of each source type. if (handlerCanCatch(SuperI, SubI)) { d765 29 d875 1 a875 1 if (getLangOpts().CPlusPlus17) { d895 1 a895 1 !getLangOpts().CPlusPlus17; d956 1 a956 1 if (S.getLangOpts().CPlusPlus17 && isa(E)) { d997 1 a997 1 return FT->canThrow(); a1264 1 case Expr::FixedPointLiteralClass: @ 1.1.1.9.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.9.2.1 log @Sync with HEAD @ text @a78 23 ExprResult Sema::ActOnNoexceptSpec(SourceLocation NoexceptLoc, Expr *NoexceptExpr, ExceptionSpecificationType &EST) { // FIXME: This is bogus, a noexcept expression is not a condition. ExprResult Converted = CheckBooleanCondition(NoexceptLoc, NoexceptExpr); if (Converted.isInvalid()) return Converted; if (Converted.get()->isValueDependent()) { EST = EST_DependentNoexcept; return Converted; } llvm::APSInt Result; Converted = VerifyIntegerConstantExpression( Converted.get(), &Result, diag::err_noexcept_needs_constant_expression, /*AllowFold*/ false); if (!Converted.isInvalid()) EST = !Result ? EST_NoexceptFalse : EST_NoexceptTrue; return Converted; } d148 1 a148 1 if (getLangOpts().CPlusPlus17) d206 2 a207 2 for (FunctionDecl *Redecl : FD->redecls()) Context.adjustExceptionSpec(Redecl, ESI); d240 2 a241 2 // Just completely ignore this under -fno-exceptions prior to C++17. // In C++17 onwards, the exception specification is part of the type and d243 1 a243 1 if (!getLangOpts().CXXExceptions && !getLangOpts().CPlusPlus17) a311 2 // FIXME: What if the exceptions are described in terms of the old // prototype's parameters? d315 4 a318 8 if (ESI.Type == EST_NoexceptFalse) ESI.Type = EST_None; if (ESI.Type == EST_NoexceptTrue) ESI.Type = EST_BasicNoexcept; // For dependent noexcept, we can't just take the expression from the old // prototype. It likely contains references to the old prototype's parameters. if (ESI.Type == EST_DependentNoexcept) { d328 1 a328 1 if (getLangOpts().MicrosoftExt && ESI.Type != EST_DependentNoexcept) { d333 1 a333 1 ESI.Type != EST_DependentNoexcept) { d370 1 a370 3 case EST_DependentNoexcept: case EST_NoexceptFalse: case EST_NoexceptTrue: d481 2 a482 5 CanThrowResult OldCanThrow = Old->canThrow(); CanThrowResult NewCanThrow = New->canThrow(); // Any non-throwing specifications are compatible. if (OldCanThrow == CT_Cannot && NewCanThrow == CT_Cannot) d485 20 a504 12 // Any throws-anything specifications are usually compatible. if (OldCanThrow == CT_Can && OldEST != EST_Dynamic && NewCanThrow == CT_Can && NewEST != EST_Dynamic) { // The exception is that the absence of an exception specification only // matches noexcept(false) for functions, as described above. if (!AllowNoexceptAllMatchWithNoSpec && ((OldEST == EST_None && NewEST == EST_NoexceptFalse) || (OldEST == EST_NoexceptFalse && NewEST == EST_None))) { // This is the disallowed case. } else { return false; } d507 8 a514 10 // C++14 [except.spec]p3: // Two exception-specifications are compatible if [...] both have the form // noexcept(constant-expression) and the constant-expressions are equivalent if (OldEST == EST_DependentNoexcept && NewEST == EST_DependentNoexcept) { llvm::FoldingSetNodeID OldFSN, NewFSN; Old->getNoexceptExpr()->Profile(OldFSN, S.Context, true); New->getNoexceptExpr()->Profile(NewFSN, S.Context, true); if (OldFSN == NewFSN) return false; } d516 5 a520 19 // Dynamic exception specifications with the same set of adjusted types // are compatible. if (OldEST == EST_Dynamic && NewEST == EST_Dynamic) { bool Success = true; // Both have a dynamic exception spec. Collect the first set, then compare // to the second. llvm::SmallPtrSet OldTypes, NewTypes; for (const auto &I : Old->exceptions()) OldTypes.insert(S.Context.getCanonicalType(I).getUnqualifiedType()); for (const auto &I : New->exceptions()) { CanQualType TypePtr = S.Context.getCanonicalType(I).getUnqualifiedType(); if (OldTypes.count(TypePtr)) NewTypes.insert(TypePtr); else { Success = false; break; } } d522 5 a526 1 if (Success && OldTypes.size() == NewTypes.size()) d530 8 d563 17 a579 13 // If the caller wants to handle the case that the new function is // incompatible due to a missing exception specification, let it. if (MissingExceptionSpecification && OldEST != EST_None && NewEST == EST_None) { // The old type has an exception specification of some sort, but // the new type does not. *MissingExceptionSpecification = true; if (MissingEmptyExceptionSpecification && OldCanThrow == CT_Cannot) { // The old type has a throw() or noexcept(true) exception specification // and the new type has no exception specification, and the caller asked // to handle this itself. *MissingEmptyExceptionSpecification = true; d582 3 d588 23 a628 84 bool Sema::handlerCanCatch(QualType HandlerType, QualType ExceptionType) { // [except.handle]p3: // A handler is a match for an exception object of type E if: // HandlerType must be ExceptionType or derived from it, or pointer or // reference to such types. const ReferenceType *RefTy = HandlerType->getAs(); if (RefTy) HandlerType = RefTy->getPointeeType(); // -- the handler is of type cv T or cv T& and E and T are the same type if (Context.hasSameUnqualifiedType(ExceptionType, HandlerType)) return true; // FIXME: ObjC pointer types? if (HandlerType->isPointerType() || HandlerType->isMemberPointerType()) { if (RefTy && (!HandlerType.isConstQualified() || HandlerType.isVolatileQualified())) return false; // -- the handler is of type cv T or const T& where T is a pointer or // pointer to member type and E is std::nullptr_t if (ExceptionType->isNullPtrType()) return true; // -- the handler is of type cv T or const T& where T is a pointer or // pointer to member type and E is a pointer or pointer to member type // that can be converted to T by one or more of // -- a qualification conversion // -- a function pointer conversion bool LifetimeConv; QualType Result; // FIXME: Should we treat the exception as catchable if a lifetime // conversion is required? if (IsQualificationConversion(ExceptionType, HandlerType, false, LifetimeConv) || IsFunctionConversion(ExceptionType, HandlerType, Result)) return true; // -- a standard pointer conversion [...] if (!ExceptionType->isPointerType() || !HandlerType->isPointerType()) return false; // Handle the "qualification conversion" portion. Qualifiers EQuals, HQuals; ExceptionType = Context.getUnqualifiedArrayType( ExceptionType->getPointeeType(), EQuals); HandlerType = Context.getUnqualifiedArrayType( HandlerType->getPointeeType(), HQuals); if (!HQuals.compatiblyIncludes(EQuals)) return false; if (HandlerType->isVoidType() && ExceptionType->isObjectType()) return true; // The only remaining case is a derived-to-base conversion. } // -- the handler is of type cg T or cv T& and T is an unambiguous public // base class of E if (!ExceptionType->isRecordType() || !HandlerType->isRecordType()) return false; CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, /*DetectVirtual=*/false); if (!IsDerivedFrom(SourceLocation(), ExceptionType, HandlerType, Paths) || Paths.isAmbiguous(Context.getCanonicalType(HandlerType))) return false; // Do this check from a context without privileges. switch (CheckBaseClassAccess(SourceLocation(), HandlerType, ExceptionType, Paths.front(), /*Diagnostic*/ 0, /*ForceCheck*/ true, /*ForceUnprivileged*/ true)) { case AR_accessible: return true; case AR_inaccessible: return false; case AR_dependent: llvm_unreachable("access check dependent for unprivileged context"); case AR_delayed: llvm_unreachable("access check delayed in non-declaration"); } llvm_unreachable("unexpected access check result"); } d659 22 d682 1 d687 11 a697 5 // If there are dependent noexcept specs, assume everything is fine. Unlike // with the equivalency check, this is safe in this case, because we don't // want to merge declarations. Checks after instantiation will catch any // omissions we make here. if (SuperEST == EST_DependentNoexcept || SubEST == EST_DependentNoexcept) d700 7 a706 2 CanThrowResult SuperCanThrow = Superset->canThrow(); CanThrowResult SubCanThrow = Subset->canThrow(); d708 2 a709 4 // If the superset contains everything or the subset contains nothing, we're // done. if ((SuperCanThrow == CT_Can && SuperEST != EST_Dynamic) || SubCanThrow == CT_Cannot) d713 2 a714 4 // If the subset contains everything or the superset contains nothing, we've // failed. if ((SubCanThrow == CT_Can && SubEST != EST_Dynamic) || SuperCanThrow == CT_Cannot) { d725 18 a742 3 for (QualType SubI : Subset->exceptions()) { if (const ReferenceType *RefTy = SubI->getAs()) SubI = RefTy->getPointeeType(); d744 1 d746 16 a761 9 bool Contained = false; for (QualType SuperI : Superset->exceptions()) { // [except.spec]p5: // the target entity shall allow at least the exceptions allowed by the // source // // We interpret this as meaning that a handler for some target type would // catch an exception of each source type. if (handlerCanCatch(SuperI, SubI)) { d765 29 d875 1 a875 1 if (getLangOpts().CPlusPlus17) { d895 1 a895 1 !getLangOpts().CPlusPlus17; d956 1 a956 1 if (S.getLangOpts().CPlusPlus17 && isa(E)) { d997 1 a997 1 return FT->canThrow(); a1264 1 case Expr::FixedPointLiteralClass: @ 1.1.1.10 log @Import clang r337282 from trunk @ text @a78 23 ExprResult Sema::ActOnNoexceptSpec(SourceLocation NoexceptLoc, Expr *NoexceptExpr, ExceptionSpecificationType &EST) { // FIXME: This is bogus, a noexcept expression is not a condition. ExprResult Converted = CheckBooleanCondition(NoexceptLoc, NoexceptExpr); if (Converted.isInvalid()) return Converted; if (Converted.get()->isValueDependent()) { EST = EST_DependentNoexcept; return Converted; } llvm::APSInt Result; Converted = VerifyIntegerConstantExpression( Converted.get(), &Result, diag::err_noexcept_needs_constant_expression, /*AllowFold*/ false); if (!Converted.isInvalid()) EST = !Result ? EST_NoexceptFalse : EST_NoexceptTrue; return Converted; } d148 1 a148 1 if (getLangOpts().CPlusPlus17) d206 2 a207 2 for (FunctionDecl *Redecl : FD->redecls()) Context.adjustExceptionSpec(Redecl, ESI); d240 2 a241 2 // Just completely ignore this under -fno-exceptions prior to C++17. // In C++17 onwards, the exception specification is part of the type and d243 1 a243 1 if (!getLangOpts().CXXExceptions && !getLangOpts().CPlusPlus17) a311 2 // FIXME: What if the exceptions are described in terms of the old // prototype's parameters? d315 4 a318 8 if (ESI.Type == EST_NoexceptFalse) ESI.Type = EST_None; if (ESI.Type == EST_NoexceptTrue) ESI.Type = EST_BasicNoexcept; // For dependent noexcept, we can't just take the expression from the old // prototype. It likely contains references to the old prototype's parameters. if (ESI.Type == EST_DependentNoexcept) { d328 1 a328 1 if (getLangOpts().MicrosoftExt && ESI.Type != EST_DependentNoexcept) { d333 1 a333 1 ESI.Type != EST_DependentNoexcept) { d370 1 a370 3 case EST_DependentNoexcept: case EST_NoexceptFalse: case EST_NoexceptTrue: d481 2 a482 5 CanThrowResult OldCanThrow = Old->canThrow(); CanThrowResult NewCanThrow = New->canThrow(); // Any non-throwing specifications are compatible. if (OldCanThrow == CT_Cannot && NewCanThrow == CT_Cannot) d485 20 a504 12 // Any throws-anything specifications are usually compatible. if (OldCanThrow == CT_Can && OldEST != EST_Dynamic && NewCanThrow == CT_Can && NewEST != EST_Dynamic) { // The exception is that the absence of an exception specification only // matches noexcept(false) for functions, as described above. if (!AllowNoexceptAllMatchWithNoSpec && ((OldEST == EST_None && NewEST == EST_NoexceptFalse) || (OldEST == EST_NoexceptFalse && NewEST == EST_None))) { // This is the disallowed case. } else { return false; } d507 8 a514 10 // C++14 [except.spec]p3: // Two exception-specifications are compatible if [...] both have the form // noexcept(constant-expression) and the constant-expressions are equivalent if (OldEST == EST_DependentNoexcept && NewEST == EST_DependentNoexcept) { llvm::FoldingSetNodeID OldFSN, NewFSN; Old->getNoexceptExpr()->Profile(OldFSN, S.Context, true); New->getNoexceptExpr()->Profile(NewFSN, S.Context, true); if (OldFSN == NewFSN) return false; } d516 5 a520 19 // Dynamic exception specifications with the same set of adjusted types // are compatible. if (OldEST == EST_Dynamic && NewEST == EST_Dynamic) { bool Success = true; // Both have a dynamic exception spec. Collect the first set, then compare // to the second. llvm::SmallPtrSet OldTypes, NewTypes; for (const auto &I : Old->exceptions()) OldTypes.insert(S.Context.getCanonicalType(I).getUnqualifiedType()); for (const auto &I : New->exceptions()) { CanQualType TypePtr = S.Context.getCanonicalType(I).getUnqualifiedType(); if (OldTypes.count(TypePtr)) NewTypes.insert(TypePtr); else { Success = false; break; } } d522 5 a526 1 if (Success && OldTypes.size() == NewTypes.size()) d530 8 d563 17 a579 13 // If the caller wants to handle the case that the new function is // incompatible due to a missing exception specification, let it. if (MissingExceptionSpecification && OldEST != EST_None && NewEST == EST_None) { // The old type has an exception specification of some sort, but // the new type does not. *MissingExceptionSpecification = true; if (MissingEmptyExceptionSpecification && OldCanThrow == CT_Cannot) { // The old type has a throw() or noexcept(true) exception specification // and the new type has no exception specification, and the caller asked // to handle this itself. *MissingEmptyExceptionSpecification = true; d582 3 d588 23 a628 84 bool Sema::handlerCanCatch(QualType HandlerType, QualType ExceptionType) { // [except.handle]p3: // A handler is a match for an exception object of type E if: // HandlerType must be ExceptionType or derived from it, or pointer or // reference to such types. const ReferenceType *RefTy = HandlerType->getAs(); if (RefTy) HandlerType = RefTy->getPointeeType(); // -- the handler is of type cv T or cv T& and E and T are the same type if (Context.hasSameUnqualifiedType(ExceptionType, HandlerType)) return true; // FIXME: ObjC pointer types? if (HandlerType->isPointerType() || HandlerType->isMemberPointerType()) { if (RefTy && (!HandlerType.isConstQualified() || HandlerType.isVolatileQualified())) return false; // -- the handler is of type cv T or const T& where T is a pointer or // pointer to member type and E is std::nullptr_t if (ExceptionType->isNullPtrType()) return true; // -- the handler is of type cv T or const T& where T is a pointer or // pointer to member type and E is a pointer or pointer to member type // that can be converted to T by one or more of // -- a qualification conversion // -- a function pointer conversion bool LifetimeConv; QualType Result; // FIXME: Should we treat the exception as catchable if a lifetime // conversion is required? if (IsQualificationConversion(ExceptionType, HandlerType, false, LifetimeConv) || IsFunctionConversion(ExceptionType, HandlerType, Result)) return true; // -- a standard pointer conversion [...] if (!ExceptionType->isPointerType() || !HandlerType->isPointerType()) return false; // Handle the "qualification conversion" portion. Qualifiers EQuals, HQuals; ExceptionType = Context.getUnqualifiedArrayType( ExceptionType->getPointeeType(), EQuals); HandlerType = Context.getUnqualifiedArrayType( HandlerType->getPointeeType(), HQuals); if (!HQuals.compatiblyIncludes(EQuals)) return false; if (HandlerType->isVoidType() && ExceptionType->isObjectType()) return true; // The only remaining case is a derived-to-base conversion. } // -- the handler is of type cg T or cv T& and T is an unambiguous public // base class of E if (!ExceptionType->isRecordType() || !HandlerType->isRecordType()) return false; CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, /*DetectVirtual=*/false); if (!IsDerivedFrom(SourceLocation(), ExceptionType, HandlerType, Paths) || Paths.isAmbiguous(Context.getCanonicalType(HandlerType))) return false; // Do this check from a context without privileges. switch (CheckBaseClassAccess(SourceLocation(), HandlerType, ExceptionType, Paths.front(), /*Diagnostic*/ 0, /*ForceCheck*/ true, /*ForceUnprivileged*/ true)) { case AR_accessible: return true; case AR_inaccessible: return false; case AR_dependent: llvm_unreachable("access check dependent for unprivileged context"); case AR_delayed: llvm_unreachable("access check delayed in non-declaration"); } llvm_unreachable("unexpected access check result"); } d659 22 d682 1 d687 11 a697 5 // If there are dependent noexcept specs, assume everything is fine. Unlike // with the equivalency check, this is safe in this case, because we don't // want to merge declarations. Checks after instantiation will catch any // omissions we make here. if (SuperEST == EST_DependentNoexcept || SubEST == EST_DependentNoexcept) d700 7 a706 2 CanThrowResult SuperCanThrow = Superset->canThrow(); CanThrowResult SubCanThrow = Subset->canThrow(); d708 2 a709 4 // If the superset contains everything or the subset contains nothing, we're // done. if ((SuperCanThrow == CT_Can && SuperEST != EST_Dynamic) || SubCanThrow == CT_Cannot) d713 2 a714 4 // If the subset contains everything or the superset contains nothing, we've // failed. if ((SubCanThrow == CT_Can && SubEST != EST_Dynamic) || SuperCanThrow == CT_Cannot) { d725 18 a742 3 for (QualType SubI : Subset->exceptions()) { if (const ReferenceType *RefTy = SubI->getAs()) SubI = RefTy->getPointeeType(); d744 1 d746 16 a761 9 bool Contained = false; for (QualType SuperI : Superset->exceptions()) { // [except.spec]p5: // the target entity shall allow at least the exceptions allowed by the // source // // We interpret this as meaning that a handler for some target type would // catch an exception of each source type. if (handlerCanCatch(SuperI, SubI)) { d765 29 d875 1 a875 1 if (getLangOpts().CPlusPlus17) { d895 1 a895 1 !getLangOpts().CPlusPlus17; d956 1 a956 1 if (S.getLangOpts().CPlusPlus17 && isa(E)) { d997 1 a997 1 return FT->canThrow(); a1264 1 case Expr::FixedPointLiteralClass: @ 1.1.1.11 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.5.4.1 log @file SemaExceptionSpec.cpp was added on branch tls-maxphys on 2014-08-19 23:47:30 +0000 @ text @d1 1117 @ 1.1.1.5.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 1117 //===--- SemaExceptionSpec.cpp - C++ Exception Specifications ---*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file provides Sema routines for C++ exception specification testing. // //===----------------------------------------------------------------------===// #include "clang/Sema/SemaInternal.h" #include "clang/AST/ASTMutationListener.h" #include "clang/AST/CXXInheritance.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/TypeLoc.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/SourceManager.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallString.h" namespace clang { static const FunctionProtoType *GetUnderlyingFunction(QualType T) { if (const PointerType *PtrTy = T->getAs()) T = PtrTy->getPointeeType(); else if (const ReferenceType *RefTy = T->getAs()) T = RefTy->getPointeeType(); else if (const MemberPointerType *MPTy = T->getAs()) T = MPTy->getPointeeType(); return T->getAs(); } /// CheckSpecifiedExceptionType - Check if the given type is valid in an /// exception specification. Incomplete types, or pointers to incomplete types /// other than void are not allowed. /// /// \param[in,out] T The exception type. This will be decayed to a pointer type /// when the input is an array or a function type. bool Sema::CheckSpecifiedExceptionType(QualType &T, const SourceRange &Range) { // C++11 [except.spec]p2: // A type cv T, "array of T", or "function returning T" denoted // in an exception-specification is adjusted to type T, "pointer to T", or // "pointer to function returning T", respectively. // // We also apply this rule in C++98. if (T->isArrayType()) T = Context.getArrayDecayedType(T); else if (T->isFunctionType()) T = Context.getPointerType(T); int Kind = 0; QualType PointeeT = T; if (const PointerType *PT = T->getAs()) { PointeeT = PT->getPointeeType(); Kind = 1; // cv void* is explicitly permitted, despite being a pointer to an // incomplete type. if (PointeeT->isVoidType()) return false; } else if (const ReferenceType *RT = T->getAs()) { PointeeT = RT->getPointeeType(); Kind = 2; if (RT->isRValueReferenceType()) { // C++11 [except.spec]p2: // A type denoted in an exception-specification shall not denote [...] // an rvalue reference type. Diag(Range.getBegin(), diag::err_rref_in_exception_spec) << T << Range; return true; } } // C++11 [except.spec]p2: // A type denoted in an exception-specification shall not denote an // incomplete type other than a class currently being defined [...]. // A type denoted in an exception-specification shall not denote a // pointer or reference to an incomplete type, other than (cv) void* or a // pointer or reference to a class currently being defined. if (!(PointeeT->isRecordType() && PointeeT->getAs()->isBeingDefined()) && RequireCompleteType(Range.getBegin(), PointeeT, diag::err_incomplete_in_exception_spec, Kind, Range)) return true; return false; } /// CheckDistantExceptionSpec - Check if the given type is a pointer or pointer /// to member to a function with an exception specification. This means that /// it is invalid to add another level of indirection. bool Sema::CheckDistantExceptionSpec(QualType T) { if (const PointerType *PT = T->getAs()) T = PT->getPointeeType(); else if (const MemberPointerType *PT = T->getAs()) T = PT->getPointeeType(); else return false; const FunctionProtoType *FnT = T->getAs(); if (!FnT) return false; return FnT->hasExceptionSpec(); } const FunctionProtoType * Sema::ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT) { if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) return FPT; FunctionDecl *SourceDecl = FPT->getExceptionSpecDecl(); const FunctionProtoType *SourceFPT = SourceDecl->getType()->castAs(); // If the exception specification has already been resolved, just return it. if (!isUnresolvedExceptionSpec(SourceFPT->getExceptionSpecType())) return SourceFPT; // Compute or instantiate the exception specification now. if (SourceFPT->getExceptionSpecType() == EST_Unevaluated) EvaluateImplicitExceptionSpec(Loc, cast(SourceDecl)); else InstantiateExceptionSpec(Loc, SourceDecl); return SourceDecl->getType()->castAs(); } void Sema::UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI) { for (auto *Redecl : FD->redecls()) { auto *RedeclFD = dyn_cast(Redecl); const FunctionProtoType *Proto = RedeclFD->getType()->castAs(); // Overwrite the exception spec and rebuild the function type. RedeclFD->setType(Context.getFunctionType( Proto->getReturnType(), Proto->getParamTypes(), Proto->getExtProtoInfo().withExceptionSpec(ESI))); } // If we've fully resolved the exception specification, notify listeners. if (!isUnresolvedExceptionSpec(ESI.Type)) if (auto *Listener = getASTMutationListener()) Listener->ResolvedExceptionSpec(FD); } /// Determine whether a function has an implicitly-generated exception /// specification. static bool hasImplicitExceptionSpec(FunctionDecl *Decl) { if (!isa(Decl) && Decl->getDeclName().getCXXOverloadedOperator() != OO_Delete && Decl->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete) return false; // For a function that the user didn't declare: // - if this is a destructor, its exception specification is implicit. // - if this is 'operator delete' or 'operator delete[]', the exception // specification is as-if an explicit exception specification was given // (per [basic.stc.dynamic]p2). if (!Decl->getTypeSourceInfo()) return isa(Decl); const FunctionProtoType *Ty = Decl->getTypeSourceInfo()->getType()->getAs(); return !Ty->hasExceptionSpec(); } bool Sema::CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New) { OverloadedOperatorKind OO = New->getDeclName().getCXXOverloadedOperator(); bool IsOperatorNew = OO == OO_New || OO == OO_Array_New; bool MissingExceptionSpecification = false; bool MissingEmptyExceptionSpecification = false; unsigned DiagID = diag::err_mismatched_exception_spec; bool ReturnValueOnError = true; if (getLangOpts().MicrosoftExt) { DiagID = diag::ext_mismatched_exception_spec; ReturnValueOnError = false; } // Check the types as written: they must match before any exception // specification adjustment is applied. if (!CheckEquivalentExceptionSpec( PDiag(DiagID), PDiag(diag::note_previous_declaration), Old->getType()->getAs(), Old->getLocation(), New->getType()->getAs(), New->getLocation(), &MissingExceptionSpecification, &MissingEmptyExceptionSpecification, /*AllowNoexceptAllMatchWithNoSpec=*/true, IsOperatorNew)) { // C++11 [except.spec]p4 [DR1492]: // If a declaration of a function has an implicit // exception-specification, other declarations of the function shall // not specify an exception-specification. if (getLangOpts().CPlusPlus11 && hasImplicitExceptionSpec(Old) != hasImplicitExceptionSpec(New)) { Diag(New->getLocation(), diag::ext_implicit_exception_spec_mismatch) << hasImplicitExceptionSpec(Old); if (!Old->getLocation().isInvalid()) Diag(Old->getLocation(), diag::note_previous_declaration); } return false; } // The failure was something other than an missing exception // specification; return an error, except in MS mode where this is a warning. if (!MissingExceptionSpecification) return ReturnValueOnError; const FunctionProtoType *NewProto = New->getType()->castAs(); // The new function declaration is only missing an empty exception // specification "throw()". If the throw() specification came from a // function in a system header that has C linkage, just add an empty // exception specification to the "new" declaration. This is an // egregious workaround for glibc, which adds throw() specifications // to many libc functions as an optimization. Unfortunately, that // optimization isn't permitted by the C++ standard, so we're forced // to work around it here. if (MissingEmptyExceptionSpecification && NewProto && (Old->getLocation().isInvalid() || Context.getSourceManager().isInSystemHeader(Old->getLocation())) && Old->isExternC()) { New->setType(Context.getFunctionType( NewProto->getReturnType(), NewProto->getParamTypes(), NewProto->getExtProtoInfo().withExceptionSpec(EST_DynamicNone))); return false; } const FunctionProtoType *OldProto = Old->getType()->castAs(); FunctionProtoType::ExceptionSpecInfo ESI = OldProto->getExceptionSpecType(); if (ESI.Type == EST_Dynamic) { ESI.Exceptions = OldProto->exceptions(); } else if (ESI.Type == EST_ComputedNoexcept) { // FIXME: We can't just take the expression from the old prototype. It // likely contains references to the old prototype's parameters. } // Update the type of the function with the appropriate exception // specification. New->setType(Context.getFunctionType( NewProto->getReturnType(), NewProto->getParamTypes(), NewProto->getExtProtoInfo().withExceptionSpec(ESI))); // Warn about the lack of exception specification. SmallString<128> ExceptionSpecString; llvm::raw_svector_ostream OS(ExceptionSpecString); switch (OldProto->getExceptionSpecType()) { case EST_DynamicNone: OS << "throw()"; break; case EST_Dynamic: { OS << "throw("; bool OnFirstException = true; for (const auto &E : OldProto->exceptions()) { if (OnFirstException) OnFirstException = false; else OS << ", "; OS << E.getAsString(getPrintingPolicy()); } OS << ")"; break; } case EST_BasicNoexcept: OS << "noexcept"; break; case EST_ComputedNoexcept: OS << "noexcept("; assert(OldProto->getNoexceptExpr() != nullptr && "Expected non-null Expr"); OldProto->getNoexceptExpr()->printPretty(OS, nullptr, getPrintingPolicy()); OS << ")"; break; default: llvm_unreachable("This spec type is compatible with none."); } OS.flush(); SourceLocation FixItLoc; if (TypeSourceInfo *TSInfo = New->getTypeSourceInfo()) { TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens(); if (FunctionTypeLoc FTLoc = TL.getAs()) FixItLoc = getLocForEndOfToken(FTLoc.getLocalRangeEnd()); } if (FixItLoc.isInvalid()) Diag(New->getLocation(), diag::warn_missing_exception_specification) << New << OS.str(); else { // FIXME: This will get more complicated with C++0x // late-specified return types. Diag(New->getLocation(), diag::warn_missing_exception_specification) << New << OS.str() << FixItHint::CreateInsertion(FixItLoc, " " + OS.str().str()); } if (!Old->getLocation().isInvalid()) Diag(Old->getLocation(), diag::note_previous_declaration); return false; } /// CheckEquivalentExceptionSpec - Check if the two types have equivalent /// exception specifications. Exception specifications are equivalent if /// they allow exactly the same set of exception types. It does not matter how /// that is achieved. See C++ [except.spec]p2. bool Sema::CheckEquivalentExceptionSpec( const FunctionProtoType *Old, SourceLocation OldLoc, const FunctionProtoType *New, SourceLocation NewLoc) { unsigned DiagID = diag::err_mismatched_exception_spec; if (getLangOpts().MicrosoftExt) DiagID = diag::ext_mismatched_exception_spec; bool Result = CheckEquivalentExceptionSpec(PDiag(DiagID), PDiag(diag::note_previous_declaration), Old, OldLoc, New, NewLoc); // In Microsoft mode, mismatching exception specifications just cause a warning. if (getLangOpts().MicrosoftExt) return false; return Result; } /// CheckEquivalentExceptionSpec - Check if the two types have compatible /// exception specifications. See C++ [except.spec]p3. /// /// \return \c false if the exception specifications match, \c true if there is /// a problem. If \c true is returned, either a diagnostic has already been /// produced or \c *MissingExceptionSpecification is set to \c true. bool Sema::CheckEquivalentExceptionSpec(const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID, const FunctionProtoType *Old, SourceLocation OldLoc, const FunctionProtoType *New, SourceLocation NewLoc, bool *MissingExceptionSpecification, bool*MissingEmptyExceptionSpecification, bool AllowNoexceptAllMatchWithNoSpec, bool IsOperatorNew) { // Just completely ignore this under -fno-exceptions. if (!getLangOpts().CXXExceptions) return false; if (MissingExceptionSpecification) *MissingExceptionSpecification = false; if (MissingEmptyExceptionSpecification) *MissingEmptyExceptionSpecification = false; Old = ResolveExceptionSpec(NewLoc, Old); if (!Old) return false; New = ResolveExceptionSpec(NewLoc, New); if (!New) return false; // C++0x [except.spec]p3: Two exception-specifications are compatible if: // - both are non-throwing, regardless of their form, // - both have the form noexcept(constant-expression) and the constant- // expressions are equivalent, // - both are dynamic-exception-specifications that have the same set of // adjusted types. // // C++0x [except.spec]p12: An exception-specifcation is non-throwing if it is // of the form throw(), noexcept, or noexcept(constant-expression) where the // constant-expression yields true. // // C++0x [except.spec]p4: If any declaration of a function has an exception- // specifier that is not a noexcept-specification allowing all exceptions, // all declarations [...] of that function shall have a compatible // exception-specification. // // That last point basically means that noexcept(false) matches no spec. // It's considered when AllowNoexceptAllMatchWithNoSpec is true. ExceptionSpecificationType OldEST = Old->getExceptionSpecType(); ExceptionSpecificationType NewEST = New->getExceptionSpecType(); assert(!isUnresolvedExceptionSpec(OldEST) && !isUnresolvedExceptionSpec(NewEST) && "Shouldn't see unknown exception specifications here"); // Shortcut the case where both have no spec. if (OldEST == EST_None && NewEST == EST_None) return false; FunctionProtoType::NoexceptResult OldNR = Old->getNoexceptSpec(Context); FunctionProtoType::NoexceptResult NewNR = New->getNoexceptSpec(Context); if (OldNR == FunctionProtoType::NR_BadNoexcept || NewNR == FunctionProtoType::NR_BadNoexcept) return false; // Dependent noexcept specifiers are compatible with each other, but nothing // else. // One noexcept is compatible with another if the argument is the same if (OldNR == NewNR && OldNR != FunctionProtoType::NR_NoNoexcept && NewNR != FunctionProtoType::NR_NoNoexcept) return false; if (OldNR != NewNR && OldNR != FunctionProtoType::NR_NoNoexcept && NewNR != FunctionProtoType::NR_NoNoexcept) { Diag(NewLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(OldLoc, NoteID); return true; } // The MS extension throw(...) is compatible with itself. if (OldEST == EST_MSAny && NewEST == EST_MSAny) return false; // It's also compatible with no spec. if ((OldEST == EST_None && NewEST == EST_MSAny) || (OldEST == EST_MSAny && NewEST == EST_None)) return false; // It's also compatible with noexcept(false). if (OldEST == EST_MSAny && NewNR == FunctionProtoType::NR_Throw) return false; if (NewEST == EST_MSAny && OldNR == FunctionProtoType::NR_Throw) return false; // As described above, noexcept(false) matches no spec only for functions. if (AllowNoexceptAllMatchWithNoSpec) { if (OldEST == EST_None && NewNR == FunctionProtoType::NR_Throw) return false; if (NewEST == EST_None && OldNR == FunctionProtoType::NR_Throw) return false; } // Any non-throwing specifications are compatible. bool OldNonThrowing = OldNR == FunctionProtoType::NR_Nothrow || OldEST == EST_DynamicNone; bool NewNonThrowing = NewNR == FunctionProtoType::NR_Nothrow || NewEST == EST_DynamicNone; if (OldNonThrowing && NewNonThrowing) return false; // As a special compatibility feature, under C++0x we accept no spec and // throw(std::bad_alloc) as equivalent for operator new and operator new[]. // This is because the implicit declaration changed, but old code would break. if (getLangOpts().CPlusPlus11 && IsOperatorNew) { const FunctionProtoType *WithExceptions = nullptr; if (OldEST == EST_None && NewEST == EST_Dynamic) WithExceptions = New; else if (OldEST == EST_Dynamic && NewEST == EST_None) WithExceptions = Old; if (WithExceptions && WithExceptions->getNumExceptions() == 1) { // One has no spec, the other throw(something). If that something is // std::bad_alloc, all conditions are met. QualType Exception = *WithExceptions->exception_begin(); if (CXXRecordDecl *ExRecord = Exception->getAsCXXRecordDecl()) { IdentifierInfo* Name = ExRecord->getIdentifier(); if (Name && Name->getName() == "bad_alloc") { // It's called bad_alloc, but is it in std? if (ExRecord->isInStdNamespace()) { return false; } } } } } // At this point, the only remaining valid case is two matching dynamic // specifications. We return here unless both specifications are dynamic. if (OldEST != EST_Dynamic || NewEST != EST_Dynamic) { if (MissingExceptionSpecification && Old->hasExceptionSpec() && !New->hasExceptionSpec()) { // The old type has an exception specification of some sort, but // the new type does not. *MissingExceptionSpecification = true; if (MissingEmptyExceptionSpecification && OldNonThrowing) { // The old type has a throw() or noexcept(true) exception specification // and the new type has no exception specification, and the caller asked // to handle this itself. *MissingEmptyExceptionSpecification = true; } return true; } Diag(NewLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(OldLoc, NoteID); return true; } assert(OldEST == EST_Dynamic && NewEST == EST_Dynamic && "Exception compatibility logic error: non-dynamic spec slipped through."); bool Success = true; // Both have a dynamic exception spec. Collect the first set, then compare // to the second. llvm::SmallPtrSet OldTypes, NewTypes; for (const auto &I : Old->exceptions()) OldTypes.insert(Context.getCanonicalType(I).getUnqualifiedType()); for (const auto &I : New->exceptions()) { CanQualType TypePtr = Context.getCanonicalType(I).getUnqualifiedType(); if(OldTypes.count(TypePtr)) NewTypes.insert(TypePtr); else Success = false; } Success = Success && OldTypes.size() == NewTypes.size(); if (Success) { return false; } Diag(NewLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(OldLoc, NoteID); return true; } /// CheckExceptionSpecSubset - Check whether the second function type's /// exception specification is a subset (or equivalent) of the first function /// type. This is used by override and pointer assignment checks. bool Sema::CheckExceptionSpecSubset( const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID, const FunctionProtoType *Superset, SourceLocation SuperLoc, const FunctionProtoType *Subset, SourceLocation SubLoc) { // Just auto-succeed under -fno-exceptions. if (!getLangOpts().CXXExceptions) return false; // FIXME: As usual, we could be more specific in our error messages, but // that better waits until we've got types with source locations. if (!SubLoc.isValid()) SubLoc = SuperLoc; // Resolve the exception specifications, if needed. Superset = ResolveExceptionSpec(SuperLoc, Superset); if (!Superset) return false; Subset = ResolveExceptionSpec(SubLoc, Subset); if (!Subset) return false; ExceptionSpecificationType SuperEST = Superset->getExceptionSpecType(); // If superset contains everything, we're done. if (SuperEST == EST_None || SuperEST == EST_MSAny) return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); // If there are dependent noexcept specs, assume everything is fine. Unlike // with the equivalency check, this is safe in this case, because we don't // want to merge declarations. Checks after instantiation will catch any // omissions we make here. // We also shortcut checking if a noexcept expression was bad. FunctionProtoType::NoexceptResult SuperNR =Superset->getNoexceptSpec(Context); if (SuperNR == FunctionProtoType::NR_BadNoexcept || SuperNR == FunctionProtoType::NR_Dependent) return false; // Another case of the superset containing everything. if (SuperNR == FunctionProtoType::NR_Throw) return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); ExceptionSpecificationType SubEST = Subset->getExceptionSpecType(); assert(!isUnresolvedExceptionSpec(SuperEST) && !isUnresolvedExceptionSpec(SubEST) && "Shouldn't see unknown exception specifications here"); // It does not. If the subset contains everything, we've failed. if (SubEST == EST_None || SubEST == EST_MSAny) { Diag(SubLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(SuperLoc, NoteID); return true; } FunctionProtoType::NoexceptResult SubNR = Subset->getNoexceptSpec(Context); if (SubNR == FunctionProtoType::NR_BadNoexcept || SubNR == FunctionProtoType::NR_Dependent) return false; // Another case of the subset containing everything. if (SubNR == FunctionProtoType::NR_Throw) { Diag(SubLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(SuperLoc, NoteID); return true; } // If the subset contains nothing, we're done. if (SubEST == EST_DynamicNone || SubNR == FunctionProtoType::NR_Nothrow) return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); // Otherwise, if the superset contains nothing, we've failed. if (SuperEST == EST_DynamicNone || SuperNR == FunctionProtoType::NR_Nothrow) { Diag(SubLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(SuperLoc, NoteID); return true; } assert(SuperEST == EST_Dynamic && SubEST == EST_Dynamic && "Exception spec subset: non-dynamic case slipped through."); // Neither contains everything or nothing. Do a proper comparison. for (const auto &SubI : Subset->exceptions()) { // Take one type from the subset. QualType CanonicalSubT = Context.getCanonicalType(SubI); // Unwrap pointers and references so that we can do checks within a class // hierarchy. Don't unwrap member pointers; they don't have hierarchy // conversions on the pointee. bool SubIsPointer = false; if (const ReferenceType *RefTy = CanonicalSubT->getAs()) CanonicalSubT = RefTy->getPointeeType(); if (const PointerType *PtrTy = CanonicalSubT->getAs()) { CanonicalSubT = PtrTy->getPointeeType(); SubIsPointer = true; } bool SubIsClass = CanonicalSubT->isRecordType(); CanonicalSubT = CanonicalSubT.getLocalUnqualifiedType(); CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, /*DetectVirtual=*/false); bool Contained = false; // Make sure it's in the superset. for (const auto &SuperI : Superset->exceptions()) { QualType CanonicalSuperT = Context.getCanonicalType(SuperI); // SubT must be SuperT or derived from it, or pointer or reference to // such types. if (const ReferenceType *RefTy = CanonicalSuperT->getAs()) CanonicalSuperT = RefTy->getPointeeType(); if (SubIsPointer) { if (const PointerType *PtrTy = CanonicalSuperT->getAs()) CanonicalSuperT = PtrTy->getPointeeType(); else { continue; } } CanonicalSuperT = CanonicalSuperT.getLocalUnqualifiedType(); // If the types are the same, move on to the next type in the subset. if (CanonicalSubT == CanonicalSuperT) { Contained = true; break; } // Otherwise we need to check the inheritance. if (!SubIsClass || !CanonicalSuperT->isRecordType()) continue; Paths.clear(); if (!IsDerivedFrom(CanonicalSubT, CanonicalSuperT, Paths)) continue; if (Paths.isAmbiguous(Context.getCanonicalType(CanonicalSuperT))) continue; // Do this check from a context without privileges. switch (CheckBaseClassAccess(SourceLocation(), CanonicalSuperT, CanonicalSubT, Paths.front(), /*Diagnostic*/ 0, /*ForceCheck*/ true, /*ForceUnprivileged*/ true)) { case AR_accessible: break; case AR_inaccessible: continue; case AR_dependent: llvm_unreachable("access check dependent for unprivileged context"); case AR_delayed: llvm_unreachable("access check delayed in non-declaration"); } Contained = true; break; } if (!Contained) { Diag(SubLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(SuperLoc, NoteID); return true; } } // We've run half the gauntlet. return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); } static bool CheckSpecForTypesEquivalent(Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID, QualType Target, SourceLocation TargetLoc, QualType Source, SourceLocation SourceLoc) { const FunctionProtoType *TFunc = GetUnderlyingFunction(Target); if (!TFunc) return false; const FunctionProtoType *SFunc = GetUnderlyingFunction(Source); if (!SFunc) return false; return S.CheckEquivalentExceptionSpec(DiagID, NoteID, TFunc, TargetLoc, SFunc, SourceLoc); } /// CheckParamExceptionSpec - Check if the parameter and return types of the /// two functions have equivalent exception specs. This is part of the /// assignment and override compatibility check. We do not check the parameters /// of parameter function pointers recursively, as no sane programmer would /// even be able to write such a function type. bool Sema::CheckParamExceptionSpec(const PartialDiagnostic & NoteID, const FunctionProtoType *Target, SourceLocation TargetLoc, const FunctionProtoType *Source, SourceLocation SourceLoc) { if (CheckSpecForTypesEquivalent( *this, PDiag(diag::err_deep_exception_specs_differ) << 0, PDiag(), Target->getReturnType(), TargetLoc, Source->getReturnType(), SourceLoc)) return true; // We shouldn't even be testing this unless the arguments are otherwise // compatible. assert(Target->getNumParams() == Source->getNumParams() && "Functions have different argument counts."); for (unsigned i = 0, E = Target->getNumParams(); i != E; ++i) { if (CheckSpecForTypesEquivalent( *this, PDiag(diag::err_deep_exception_specs_differ) << 1, PDiag(), Target->getParamType(i), TargetLoc, Source->getParamType(i), SourceLoc)) return true; } return false; } bool Sema::CheckExceptionSpecCompatibility(Expr *From, QualType ToType) { // First we check for applicability. // Target type must be a function, function pointer or function reference. const FunctionProtoType *ToFunc = GetUnderlyingFunction(ToType); if (!ToFunc) return false; // SourceType must be a function or function pointer. const FunctionProtoType *FromFunc = GetUnderlyingFunction(From->getType()); if (!FromFunc) return false; // Now we've got the correct types on both sides, check their compatibility. // This means that the source of the conversion can only throw a subset of // the exceptions of the target, and any exception specs on arguments or // return types must be equivalent. return CheckExceptionSpecSubset(PDiag(diag::err_incompatible_exception_specs), PDiag(), ToFunc, From->getSourceRange().getBegin(), FromFunc, SourceLocation()); } bool Sema::CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old) { if (getLangOpts().CPlusPlus11 && isa(New)) { // Don't check uninstantiated template destructors at all. We can only // synthesize correct specs after the template is instantiated. if (New->getParent()->isDependentType()) return false; if (New->getParent()->isBeingDefined()) { // The destructor might be updated once the definition is finished. So // remember it and check later. DelayedDestructorExceptionSpecChecks.push_back(std::make_pair( cast(New), cast(Old))); return false; } } unsigned DiagID = diag::err_override_exception_spec; if (getLangOpts().MicrosoftExt) DiagID = diag::ext_override_exception_spec; return CheckExceptionSpecSubset(PDiag(DiagID), PDiag(diag::note_overridden_virtual_function), Old->getType()->getAs(), Old->getLocation(), New->getType()->getAs(), New->getLocation()); } static CanThrowResult canSubExprsThrow(Sema &S, const Expr *CE) { Expr *E = const_cast(CE); CanThrowResult R = CT_Cannot; for (Expr::child_range I = E->children(); I && R != CT_Can; ++I) R = mergeCanThrow(R, S.canThrow(cast(*I))); return R; } static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D) { assert(D && "Expected decl"); // See if we can get a function type from the decl somehow. const ValueDecl *VD = dyn_cast(D); if (!VD) // If we have no clue what we're calling, assume the worst. return CT_Can; // As an extension, we assume that __attribute__((nothrow)) functions don't // throw. if (isa(D) && D->hasAttr()) return CT_Cannot; QualType T = VD->getType(); const FunctionProtoType *FT; if ((FT = T->getAs())) { } else if (const PointerType *PT = T->getAs()) FT = PT->getPointeeType()->getAs(); else if (const ReferenceType *RT = T->getAs()) FT = RT->getPointeeType()->getAs(); else if (const MemberPointerType *MT = T->getAs()) FT = MT->getPointeeType()->getAs(); else if (const BlockPointerType *BT = T->getAs()) FT = BT->getPointeeType()->getAs(); if (!FT) return CT_Can; FT = S.ResolveExceptionSpec(E->getLocStart(), FT); if (!FT) return CT_Can; return FT->isNothrow(S.Context) ? CT_Cannot : CT_Can; } static CanThrowResult canDynamicCastThrow(const CXXDynamicCastExpr *DC) { if (DC->isTypeDependent()) return CT_Dependent; if (!DC->getTypeAsWritten()->isReferenceType()) return CT_Cannot; if (DC->getSubExpr()->isTypeDependent()) return CT_Dependent; return DC->getCastKind() == clang::CK_Dynamic? CT_Can : CT_Cannot; } static CanThrowResult canTypeidThrow(Sema &S, const CXXTypeidExpr *DC) { if (DC->isTypeOperand()) return CT_Cannot; Expr *Op = DC->getExprOperand(); if (Op->isTypeDependent()) return CT_Dependent; const RecordType *RT = Op->getType()->getAs(); if (!RT) return CT_Cannot; if (!cast(RT->getDecl())->isPolymorphic()) return CT_Cannot; if (Op->Classify(S.Context).isPRValue()) return CT_Cannot; return CT_Can; } CanThrowResult Sema::canThrow(const Expr *E) { // C++ [expr.unary.noexcept]p3: // [Can throw] if in a potentially-evaluated context the expression would // contain: switch (E->getStmtClass()) { case Expr::CXXThrowExprClass: // - a potentially evaluated throw-expression return CT_Can; case Expr::CXXDynamicCastExprClass: { // - a potentially evaluated dynamic_cast expression dynamic_cast(v), // where T is a reference type, that requires a run-time check CanThrowResult CT = canDynamicCastThrow(cast(E)); if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::CXXTypeidExprClass: // - a potentially evaluated typeid expression applied to a glvalue // expression whose type is a polymorphic class type return canTypeidThrow(*this, cast(E)); // - a potentially evaluated call to a function, member function, function // pointer, or member function pointer that does not have a non-throwing // exception-specification case Expr::CallExprClass: case Expr::CXXMemberCallExprClass: case Expr::CXXOperatorCallExprClass: case Expr::UserDefinedLiteralClass: { const CallExpr *CE = cast(E); CanThrowResult CT; if (E->isTypeDependent()) CT = CT_Dependent; else if (isa(CE->getCallee()->IgnoreParens())) CT = CT_Cannot; else if (CE->getCalleeDecl()) CT = canCalleeThrow(*this, E, CE->getCalleeDecl()); else CT = CT_Can; if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::CXXConstructExprClass: case Expr::CXXTemporaryObjectExprClass: { CanThrowResult CT = canCalleeThrow(*this, E, cast(E)->getConstructor()); if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::LambdaExprClass: { const LambdaExpr *Lambda = cast(E); CanThrowResult CT = CT_Cannot; for (LambdaExpr::capture_init_iterator Cap = Lambda->capture_init_begin(), CapEnd = Lambda->capture_init_end(); Cap != CapEnd; ++Cap) CT = mergeCanThrow(CT, canThrow(*Cap)); return CT; } case Expr::CXXNewExprClass: { CanThrowResult CT; if (E->isTypeDependent()) CT = CT_Dependent; else CT = canCalleeThrow(*this, E, cast(E)->getOperatorNew()); if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::CXXDeleteExprClass: { CanThrowResult CT; QualType DTy = cast(E)->getDestroyedType(); if (DTy.isNull() || DTy->isDependentType()) { CT = CT_Dependent; } else { CT = canCalleeThrow(*this, E, cast(E)->getOperatorDelete()); if (const RecordType *RT = DTy->getAs()) { const CXXRecordDecl *RD = cast(RT->getDecl()); const CXXDestructorDecl *DD = RD->getDestructor(); if (DD) CT = mergeCanThrow(CT, canCalleeThrow(*this, E, DD)); } if (CT == CT_Can) return CT; } return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::CXXBindTemporaryExprClass: { // The bound temporary has to be destroyed again, which might throw. CanThrowResult CT = canCalleeThrow(*this, E, cast(E)->getTemporary()->getDestructor()); if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } // ObjC message sends are like function calls, but never have exception // specs. case Expr::ObjCMessageExprClass: case Expr::ObjCPropertyRefExprClass: case Expr::ObjCSubscriptRefExprClass: return CT_Can; // All the ObjC literals that are implemented as calls are // potentially throwing unless we decide to close off that // possibility. case Expr::ObjCArrayLiteralClass: case Expr::ObjCDictionaryLiteralClass: case Expr::ObjCBoxedExprClass: return CT_Can; // Many other things have subexpressions, so we have to test those. // Some are simple: case Expr::ConditionalOperatorClass: case Expr::CompoundLiteralExprClass: case Expr::CXXConstCastExprClass: case Expr::CXXReinterpretCastExprClass: case Expr::CXXStdInitializerListExprClass: case Expr::DesignatedInitExprClass: case Expr::ExprWithCleanupsClass: case Expr::ExtVectorElementExprClass: case Expr::InitListExprClass: case Expr::MemberExprClass: case Expr::ObjCIsaExprClass: case Expr::ObjCIvarRefExprClass: case Expr::ParenExprClass: case Expr::ParenListExprClass: case Expr::ShuffleVectorExprClass: case Expr::ConvertVectorExprClass: case Expr::VAArgExprClass: return canSubExprsThrow(*this, E); // Some might be dependent for other reasons. case Expr::ArraySubscriptExprClass: case Expr::BinaryOperatorClass: case Expr::CompoundAssignOperatorClass: case Expr::CStyleCastExprClass: case Expr::CXXStaticCastExprClass: case Expr::CXXFunctionalCastExprClass: case Expr::ImplicitCastExprClass: case Expr::MaterializeTemporaryExprClass: case Expr::UnaryOperatorClass: { CanThrowResult CT = E->isTypeDependent() ? CT_Dependent : CT_Cannot; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } // FIXME: We should handle StmtExpr, but that opens a MASSIVE can of worms. case Expr::StmtExprClass: return CT_Can; case Expr::CXXDefaultArgExprClass: return canThrow(cast(E)->getExpr()); case Expr::CXXDefaultInitExprClass: return canThrow(cast(E)->getExpr()); case Expr::ChooseExprClass: if (E->isTypeDependent() || E->isValueDependent()) return CT_Dependent; return canThrow(cast(E)->getChosenSubExpr()); case Expr::GenericSelectionExprClass: if (cast(E)->isResultDependent()) return CT_Dependent; return canThrow(cast(E)->getResultExpr()); // Some expressions are always dependent. case Expr::CXXDependentScopeMemberExprClass: case Expr::CXXUnresolvedConstructExprClass: case Expr::DependentScopeDeclRefExprClass: return CT_Dependent; case Expr::AsTypeExprClass: case Expr::BinaryConditionalOperatorClass: case Expr::BlockExprClass: case Expr::CUDAKernelCallExprClass: case Expr::DeclRefExprClass: case Expr::ObjCBridgedCastExprClass: case Expr::ObjCIndirectCopyRestoreExprClass: case Expr::ObjCProtocolExprClass: case Expr::ObjCSelectorExprClass: case Expr::OffsetOfExprClass: case Expr::PackExpansionExprClass: case Expr::PseudoObjectExprClass: case Expr::SubstNonTypeTemplateParmExprClass: case Expr::SubstNonTypeTemplateParmPackExprClass: case Expr::FunctionParmPackExprClass: case Expr::UnaryExprOrTypeTraitExprClass: case Expr::UnresolvedLookupExprClass: case Expr::UnresolvedMemberExprClass: // FIXME: Can any of the above throw? If so, when? return CT_Cannot; case Expr::AddrLabelExprClass: case Expr::ArrayTypeTraitExprClass: case Expr::AtomicExprClass: case Expr::TypeTraitExprClass: case Expr::CXXBoolLiteralExprClass: case Expr::CXXNoexceptExprClass: case Expr::CXXNullPtrLiteralExprClass: case Expr::CXXPseudoDestructorExprClass: case Expr::CXXScalarValueInitExprClass: case Expr::CXXThisExprClass: case Expr::CXXUuidofExprClass: case Expr::CharacterLiteralClass: case Expr::ExpressionTraitExprClass: case Expr::FloatingLiteralClass: case Expr::GNUNullExprClass: case Expr::ImaginaryLiteralClass: case Expr::ImplicitValueInitExprClass: case Expr::IntegerLiteralClass: case Expr::ObjCEncodeExprClass: case Expr::ObjCStringLiteralClass: case Expr::ObjCBoolLiteralExprClass: case Expr::OpaqueValueExprClass: case Expr::PredefinedExprClass: case Expr::SizeOfPackExprClass: case Expr::StringLiteralClass: // These expressions can never throw. return CT_Cannot; case Expr::MSPropertyRefExprClass: llvm_unreachable("Invalid class for expression"); #define STMT(CLASS, PARENT) case Expr::CLASS##Class: #define STMT_RANGE(Base, First, Last) #define LAST_STMT_RANGE(BASE, FIRST, LAST) #define EXPR(CLASS, PARENT) #define ABSTRACT_STMT(STMT) #include "clang/AST/StmtNodes.inc" case Expr::NoStmtClass: llvm_unreachable("Invalid class for expression"); } llvm_unreachable("Bogus StmtClass"); } } // end namespace clang @ 1.1.1.3.4.1 log @file SemaExceptionSpec.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:29 +0000 @ text @d1 1115 @ 1.1.1.3.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 1115 //===--- SemaExceptionSpec.cpp - C++ Exception Specifications ---*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file provides Sema routines for C++ exception specification testing. // //===----------------------------------------------------------------------===// #include "clang/Sema/SemaInternal.h" #include "clang/AST/CXXInheritance.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/TypeLoc.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/SourceManager.h" #include "clang/Lex/Preprocessor.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallString.h" namespace clang { static const FunctionProtoType *GetUnderlyingFunction(QualType T) { if (const PointerType *PtrTy = T->getAs()) T = PtrTy->getPointeeType(); else if (const ReferenceType *RefTy = T->getAs()) T = RefTy->getPointeeType(); else if (const MemberPointerType *MPTy = T->getAs()) T = MPTy->getPointeeType(); return T->getAs(); } /// CheckSpecifiedExceptionType - Check if the given type is valid in an /// exception specification. Incomplete types, or pointers to incomplete types /// other than void are not allowed. /// /// \param[in,out] T The exception type. This will be decayed to a pointer type /// when the input is an array or a function type. bool Sema::CheckSpecifiedExceptionType(QualType &T, const SourceRange &Range) { // C++11 [except.spec]p2: // A type cv T, "array of T", or "function returning T" denoted // in an exception-specification is adjusted to type T, "pointer to T", or // "pointer to function returning T", respectively. // // We also apply this rule in C++98. if (T->isArrayType()) T = Context.getArrayDecayedType(T); else if (T->isFunctionType()) T = Context.getPointerType(T); int Kind = 0; QualType PointeeT = T; if (const PointerType *PT = T->getAs()) { PointeeT = PT->getPointeeType(); Kind = 1; // cv void* is explicitly permitted, despite being a pointer to an // incomplete type. if (PointeeT->isVoidType()) return false; } else if (const ReferenceType *RT = T->getAs()) { PointeeT = RT->getPointeeType(); Kind = 2; if (RT->isRValueReferenceType()) { // C++11 [except.spec]p2: // A type denoted in an exception-specification shall not denote [...] // an rvalue reference type. Diag(Range.getBegin(), diag::err_rref_in_exception_spec) << T << Range; return true; } } // C++11 [except.spec]p2: // A type denoted in an exception-specification shall not denote an // incomplete type other than a class currently being defined [...]. // A type denoted in an exception-specification shall not denote a // pointer or reference to an incomplete type, other than (cv) void* or a // pointer or reference to a class currently being defined. if (!(PointeeT->isRecordType() && PointeeT->getAs()->isBeingDefined()) && RequireCompleteType(Range.getBegin(), PointeeT, diag::err_incomplete_in_exception_spec, Kind, Range)) return true; return false; } /// CheckDistantExceptionSpec - Check if the given type is a pointer or pointer /// to member to a function with an exception specification. This means that /// it is invalid to add another level of indirection. bool Sema::CheckDistantExceptionSpec(QualType T) { if (const PointerType *PT = T->getAs()) T = PT->getPointeeType(); else if (const MemberPointerType *PT = T->getAs()) T = PT->getPointeeType(); else return false; const FunctionProtoType *FnT = T->getAs(); if (!FnT) return false; return FnT->hasExceptionSpec(); } const FunctionProtoType * Sema::ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT) { if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) return FPT; FunctionDecl *SourceDecl = FPT->getExceptionSpecDecl(); const FunctionProtoType *SourceFPT = SourceDecl->getType()->castAs(); // If the exception specification has already been resolved, just return it. if (!isUnresolvedExceptionSpec(SourceFPT->getExceptionSpecType())) return SourceFPT; // Compute or instantiate the exception specification now. if (SourceFPT->getExceptionSpecType() == EST_Unevaluated) EvaluateImplicitExceptionSpec(Loc, cast(SourceDecl)); else InstantiateExceptionSpec(Loc, SourceDecl); return SourceDecl->getType()->castAs(); } /// Determine whether a function has an implicitly-generated exception /// specification. static bool hasImplicitExceptionSpec(FunctionDecl *Decl) { if (!isa(Decl) && Decl->getDeclName().getCXXOverloadedOperator() != OO_Delete && Decl->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete) return false; // For a function that the user didn't declare: // - if this is a destructor, its exception specification is implicit. // - if this is 'operator delete' or 'operator delete[]', the exception // specification is as-if an explicit exception specification was given // (per [basic.stc.dynamic]p2). if (!Decl->getTypeSourceInfo()) return isa(Decl); const FunctionProtoType *Ty = Decl->getTypeSourceInfo()->getType()->getAs(); return !Ty->hasExceptionSpec(); } bool Sema::CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New) { OverloadedOperatorKind OO = New->getDeclName().getCXXOverloadedOperator(); bool IsOperatorNew = OO == OO_New || OO == OO_Array_New; bool MissingExceptionSpecification = false; bool MissingEmptyExceptionSpecification = false; unsigned DiagID = diag::err_mismatched_exception_spec; bool ReturnValueOnError = true; if (getLangOpts().MicrosoftExt) { DiagID = diag::warn_mismatched_exception_spec; ReturnValueOnError = false; } // Check the types as written: they must match before any exception // specification adjustment is applied. if (!CheckEquivalentExceptionSpec( PDiag(DiagID), PDiag(diag::note_previous_declaration), Old->getType()->getAs(), Old->getLocation(), New->getType()->getAs(), New->getLocation(), &MissingExceptionSpecification, &MissingEmptyExceptionSpecification, /*AllowNoexceptAllMatchWithNoSpec=*/true, IsOperatorNew)) { // C++11 [except.spec]p4 [DR1492]: // If a declaration of a function has an implicit // exception-specification, other declarations of the function shall // not specify an exception-specification. if (getLangOpts().CPlusPlus11 && hasImplicitExceptionSpec(Old) != hasImplicitExceptionSpec(New)) { Diag(New->getLocation(), diag::ext_implicit_exception_spec_mismatch) << hasImplicitExceptionSpec(Old); if (!Old->getLocation().isInvalid()) Diag(Old->getLocation(), diag::note_previous_declaration); } return false; } // The failure was something other than an missing exception // specification; return an error, except in MS mode where this is a warning. if (!MissingExceptionSpecification) return ReturnValueOnError; const FunctionProtoType *NewProto = New->getType()->castAs(); // The new function declaration is only missing an empty exception // specification "throw()". If the throw() specification came from a // function in a system header that has C linkage, just add an empty // exception specification to the "new" declaration. This is an // egregious workaround for glibc, which adds throw() specifications // to many libc functions as an optimization. Unfortunately, that // optimization isn't permitted by the C++ standard, so we're forced // to work around it here. if (MissingEmptyExceptionSpecification && NewProto && (Old->getLocation().isInvalid() || Context.getSourceManager().isInSystemHeader(Old->getLocation())) && Old->isExternC()) { FunctionProtoType::ExtProtoInfo EPI = NewProto->getExtProtoInfo(); EPI.ExceptionSpecType = EST_DynamicNone; QualType NewType = Context.getFunctionType(NewProto->getReturnType(), NewProto->getParamTypes(), EPI); New->setType(NewType); return false; } const FunctionProtoType *OldProto = Old->getType()->castAs(); FunctionProtoType::ExtProtoInfo EPI = NewProto->getExtProtoInfo(); EPI.ExceptionSpecType = OldProto->getExceptionSpecType(); if (EPI.ExceptionSpecType == EST_Dynamic) { EPI.NumExceptions = OldProto->getNumExceptions(); EPI.Exceptions = OldProto->exception_begin(); } else if (EPI.ExceptionSpecType == EST_ComputedNoexcept) { // FIXME: We can't just take the expression from the old prototype. It // likely contains references to the old prototype's parameters. } // Update the type of the function with the appropriate exception // specification. QualType NewType = Context.getFunctionType(NewProto->getReturnType(), NewProto->getParamTypes(), EPI); New->setType(NewType); // Warn about the lack of exception specification. SmallString<128> ExceptionSpecString; llvm::raw_svector_ostream OS(ExceptionSpecString); switch (OldProto->getExceptionSpecType()) { case EST_DynamicNone: OS << "throw()"; break; case EST_Dynamic: { OS << "throw("; bool OnFirstException = true; for (FunctionProtoType::exception_iterator E = OldProto->exception_begin(), EEnd = OldProto->exception_end(); E != EEnd; ++E) { if (OnFirstException) OnFirstException = false; else OS << ", "; OS << E->getAsString(getPrintingPolicy()); } OS << ")"; break; } case EST_BasicNoexcept: OS << "noexcept"; break; case EST_ComputedNoexcept: OS << "noexcept("; OldProto->getNoexceptExpr()->printPretty(OS, 0, getPrintingPolicy()); OS << ")"; break; default: llvm_unreachable("This spec type is compatible with none."); } OS.flush(); SourceLocation FixItLoc; if (TypeSourceInfo *TSInfo = New->getTypeSourceInfo()) { TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens(); if (FunctionTypeLoc FTLoc = TL.getAs()) FixItLoc = PP.getLocForEndOfToken(FTLoc.getLocalRangeEnd()); } if (FixItLoc.isInvalid()) Diag(New->getLocation(), diag::warn_missing_exception_specification) << New << OS.str(); else { // FIXME: This will get more complicated with C++0x // late-specified return types. Diag(New->getLocation(), diag::warn_missing_exception_specification) << New << OS.str() << FixItHint::CreateInsertion(FixItLoc, " " + OS.str().str()); } if (!Old->getLocation().isInvalid()) Diag(Old->getLocation(), diag::note_previous_declaration); return false; } /// CheckEquivalentExceptionSpec - Check if the two types have equivalent /// exception specifications. Exception specifications are equivalent if /// they allow exactly the same set of exception types. It does not matter how /// that is achieved. See C++ [except.spec]p2. bool Sema::CheckEquivalentExceptionSpec( const FunctionProtoType *Old, SourceLocation OldLoc, const FunctionProtoType *New, SourceLocation NewLoc) { unsigned DiagID = diag::err_mismatched_exception_spec; if (getLangOpts().MicrosoftExt) DiagID = diag::warn_mismatched_exception_spec; bool Result = CheckEquivalentExceptionSpec(PDiag(DiagID), PDiag(diag::note_previous_declaration), Old, OldLoc, New, NewLoc); // In Microsoft mode, mismatching exception specifications just cause a warning. if (getLangOpts().MicrosoftExt) return false; return Result; } /// CheckEquivalentExceptionSpec - Check if the two types have compatible /// exception specifications. See C++ [except.spec]p3. /// /// \return \c false if the exception specifications match, \c true if there is /// a problem. If \c true is returned, either a diagnostic has already been /// produced or \c *MissingExceptionSpecification is set to \c true. bool Sema::CheckEquivalentExceptionSpec(const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID, const FunctionProtoType *Old, SourceLocation OldLoc, const FunctionProtoType *New, SourceLocation NewLoc, bool *MissingExceptionSpecification, bool*MissingEmptyExceptionSpecification, bool AllowNoexceptAllMatchWithNoSpec, bool IsOperatorNew) { // Just completely ignore this under -fno-exceptions. if (!getLangOpts().CXXExceptions) return false; if (MissingExceptionSpecification) *MissingExceptionSpecification = false; if (MissingEmptyExceptionSpecification) *MissingEmptyExceptionSpecification = false; Old = ResolveExceptionSpec(NewLoc, Old); if (!Old) return false; New = ResolveExceptionSpec(NewLoc, New); if (!New) return false; // C++0x [except.spec]p3: Two exception-specifications are compatible if: // - both are non-throwing, regardless of their form, // - both have the form noexcept(constant-expression) and the constant- // expressions are equivalent, // - both are dynamic-exception-specifications that have the same set of // adjusted types. // // C++0x [except.spec]p12: An exception-specifcation is non-throwing if it is // of the form throw(), noexcept, or noexcept(constant-expression) where the // constant-expression yields true. // // C++0x [except.spec]p4: If any declaration of a function has an exception- // specifier that is not a noexcept-specification allowing all exceptions, // all declarations [...] of that function shall have a compatible // exception-specification. // // That last point basically means that noexcept(false) matches no spec. // It's considered when AllowNoexceptAllMatchWithNoSpec is true. ExceptionSpecificationType OldEST = Old->getExceptionSpecType(); ExceptionSpecificationType NewEST = New->getExceptionSpecType(); assert(!isUnresolvedExceptionSpec(OldEST) && !isUnresolvedExceptionSpec(NewEST) && "Shouldn't see unknown exception specifications here"); // Shortcut the case where both have no spec. if (OldEST == EST_None && NewEST == EST_None) return false; FunctionProtoType::NoexceptResult OldNR = Old->getNoexceptSpec(Context); FunctionProtoType::NoexceptResult NewNR = New->getNoexceptSpec(Context); if (OldNR == FunctionProtoType::NR_BadNoexcept || NewNR == FunctionProtoType::NR_BadNoexcept) return false; // Dependent noexcept specifiers are compatible with each other, but nothing // else. // One noexcept is compatible with another if the argument is the same if (OldNR == NewNR && OldNR != FunctionProtoType::NR_NoNoexcept && NewNR != FunctionProtoType::NR_NoNoexcept) return false; if (OldNR != NewNR && OldNR != FunctionProtoType::NR_NoNoexcept && NewNR != FunctionProtoType::NR_NoNoexcept) { Diag(NewLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(OldLoc, NoteID); return true; } // The MS extension throw(...) is compatible with itself. if (OldEST == EST_MSAny && NewEST == EST_MSAny) return false; // It's also compatible with no spec. if ((OldEST == EST_None && NewEST == EST_MSAny) || (OldEST == EST_MSAny && NewEST == EST_None)) return false; // It's also compatible with noexcept(false). if (OldEST == EST_MSAny && NewNR == FunctionProtoType::NR_Throw) return false; if (NewEST == EST_MSAny && OldNR == FunctionProtoType::NR_Throw) return false; // As described above, noexcept(false) matches no spec only for functions. if (AllowNoexceptAllMatchWithNoSpec) { if (OldEST == EST_None && NewNR == FunctionProtoType::NR_Throw) return false; if (NewEST == EST_None && OldNR == FunctionProtoType::NR_Throw) return false; } // Any non-throwing specifications are compatible. bool OldNonThrowing = OldNR == FunctionProtoType::NR_Nothrow || OldEST == EST_DynamicNone; bool NewNonThrowing = NewNR == FunctionProtoType::NR_Nothrow || NewEST == EST_DynamicNone; if (OldNonThrowing && NewNonThrowing) return false; // As a special compatibility feature, under C++0x we accept no spec and // throw(std::bad_alloc) as equivalent for operator new and operator new[]. // This is because the implicit declaration changed, but old code would break. if (getLangOpts().CPlusPlus11 && IsOperatorNew) { const FunctionProtoType *WithExceptions = 0; if (OldEST == EST_None && NewEST == EST_Dynamic) WithExceptions = New; else if (OldEST == EST_Dynamic && NewEST == EST_None) WithExceptions = Old; if (WithExceptions && WithExceptions->getNumExceptions() == 1) { // One has no spec, the other throw(something). If that something is // std::bad_alloc, all conditions are met. QualType Exception = *WithExceptions->exception_begin(); if (CXXRecordDecl *ExRecord = Exception->getAsCXXRecordDecl()) { IdentifierInfo* Name = ExRecord->getIdentifier(); if (Name && Name->getName() == "bad_alloc") { // It's called bad_alloc, but is it in std? DeclContext* DC = ExRecord->getDeclContext(); DC = DC->getEnclosingNamespaceContext(); if (NamespaceDecl* NS = dyn_cast(DC)) { IdentifierInfo* NSName = NS->getIdentifier(); DC = DC->getParent(); if (NSName && NSName->getName() == "std" && DC->getEnclosingNamespaceContext()->isTranslationUnit()) { return false; } } } } } } // At this point, the only remaining valid case is two matching dynamic // specifications. We return here unless both specifications are dynamic. if (OldEST != EST_Dynamic || NewEST != EST_Dynamic) { if (MissingExceptionSpecification && Old->hasExceptionSpec() && !New->hasExceptionSpec()) { // The old type has an exception specification of some sort, but // the new type does not. *MissingExceptionSpecification = true; if (MissingEmptyExceptionSpecification && OldNonThrowing) { // The old type has a throw() or noexcept(true) exception specification // and the new type has no exception specification, and the caller asked // to handle this itself. *MissingEmptyExceptionSpecification = true; } return true; } Diag(NewLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(OldLoc, NoteID); return true; } assert(OldEST == EST_Dynamic && NewEST == EST_Dynamic && "Exception compatibility logic error: non-dynamic spec slipped through."); bool Success = true; // Both have a dynamic exception spec. Collect the first set, then compare // to the second. llvm::SmallPtrSet OldTypes, NewTypes; for (FunctionProtoType::exception_iterator I = Old->exception_begin(), E = Old->exception_end(); I != E; ++I) OldTypes.insert(Context.getCanonicalType(*I).getUnqualifiedType()); for (FunctionProtoType::exception_iterator I = New->exception_begin(), E = New->exception_end(); I != E && Success; ++I) { CanQualType TypePtr = Context.getCanonicalType(*I).getUnqualifiedType(); if(OldTypes.count(TypePtr)) NewTypes.insert(TypePtr); else Success = false; } Success = Success && OldTypes.size() == NewTypes.size(); if (Success) { return false; } Diag(NewLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(OldLoc, NoteID); return true; } /// CheckExceptionSpecSubset - Check whether the second function type's /// exception specification is a subset (or equivalent) of the first function /// type. This is used by override and pointer assignment checks. bool Sema::CheckExceptionSpecSubset( const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID, const FunctionProtoType *Superset, SourceLocation SuperLoc, const FunctionProtoType *Subset, SourceLocation SubLoc) { // Just auto-succeed under -fno-exceptions. if (!getLangOpts().CXXExceptions) return false; // FIXME: As usual, we could be more specific in our error messages, but // that better waits until we've got types with source locations. if (!SubLoc.isValid()) SubLoc = SuperLoc; // Resolve the exception specifications, if needed. Superset = ResolveExceptionSpec(SuperLoc, Superset); if (!Superset) return false; Subset = ResolveExceptionSpec(SubLoc, Subset); if (!Subset) return false; ExceptionSpecificationType SuperEST = Superset->getExceptionSpecType(); // If superset contains everything, we're done. if (SuperEST == EST_None || SuperEST == EST_MSAny) return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); // If there are dependent noexcept specs, assume everything is fine. Unlike // with the equivalency check, this is safe in this case, because we don't // want to merge declarations. Checks after instantiation will catch any // omissions we make here. // We also shortcut checking if a noexcept expression was bad. FunctionProtoType::NoexceptResult SuperNR =Superset->getNoexceptSpec(Context); if (SuperNR == FunctionProtoType::NR_BadNoexcept || SuperNR == FunctionProtoType::NR_Dependent) return false; // Another case of the superset containing everything. if (SuperNR == FunctionProtoType::NR_Throw) return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); ExceptionSpecificationType SubEST = Subset->getExceptionSpecType(); assert(!isUnresolvedExceptionSpec(SuperEST) && !isUnresolvedExceptionSpec(SubEST) && "Shouldn't see unknown exception specifications here"); // It does not. If the subset contains everything, we've failed. if (SubEST == EST_None || SubEST == EST_MSAny) { Diag(SubLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(SuperLoc, NoteID); return true; } FunctionProtoType::NoexceptResult SubNR = Subset->getNoexceptSpec(Context); if (SubNR == FunctionProtoType::NR_BadNoexcept || SubNR == FunctionProtoType::NR_Dependent) return false; // Another case of the subset containing everything. if (SubNR == FunctionProtoType::NR_Throw) { Diag(SubLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(SuperLoc, NoteID); return true; } // If the subset contains nothing, we're done. if (SubEST == EST_DynamicNone || SubNR == FunctionProtoType::NR_Nothrow) return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); // Otherwise, if the superset contains nothing, we've failed. if (SuperEST == EST_DynamicNone || SuperNR == FunctionProtoType::NR_Nothrow) { Diag(SubLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(SuperLoc, NoteID); return true; } assert(SuperEST == EST_Dynamic && SubEST == EST_Dynamic && "Exception spec subset: non-dynamic case slipped through."); // Neither contains everything or nothing. Do a proper comparison. for (FunctionProtoType::exception_iterator SubI = Subset->exception_begin(), SubE = Subset->exception_end(); SubI != SubE; ++SubI) { // Take one type from the subset. QualType CanonicalSubT = Context.getCanonicalType(*SubI); // Unwrap pointers and references so that we can do checks within a class // hierarchy. Don't unwrap member pointers; they don't have hierarchy // conversions on the pointee. bool SubIsPointer = false; if (const ReferenceType *RefTy = CanonicalSubT->getAs()) CanonicalSubT = RefTy->getPointeeType(); if (const PointerType *PtrTy = CanonicalSubT->getAs()) { CanonicalSubT = PtrTy->getPointeeType(); SubIsPointer = true; } bool SubIsClass = CanonicalSubT->isRecordType(); CanonicalSubT = CanonicalSubT.getLocalUnqualifiedType(); CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, /*DetectVirtual=*/false); bool Contained = false; // Make sure it's in the superset. for (FunctionProtoType::exception_iterator SuperI = Superset->exception_begin(), SuperE = Superset->exception_end(); SuperI != SuperE; ++SuperI) { QualType CanonicalSuperT = Context.getCanonicalType(*SuperI); // SubT must be SuperT or derived from it, or pointer or reference to // such types. if (const ReferenceType *RefTy = CanonicalSuperT->getAs()) CanonicalSuperT = RefTy->getPointeeType(); if (SubIsPointer) { if (const PointerType *PtrTy = CanonicalSuperT->getAs()) CanonicalSuperT = PtrTy->getPointeeType(); else { continue; } } CanonicalSuperT = CanonicalSuperT.getLocalUnqualifiedType(); // If the types are the same, move on to the next type in the subset. if (CanonicalSubT == CanonicalSuperT) { Contained = true; break; } // Otherwise we need to check the inheritance. if (!SubIsClass || !CanonicalSuperT->isRecordType()) continue; Paths.clear(); if (!IsDerivedFrom(CanonicalSubT, CanonicalSuperT, Paths)) continue; if (Paths.isAmbiguous(Context.getCanonicalType(CanonicalSuperT))) continue; // Do this check from a context without privileges. switch (CheckBaseClassAccess(SourceLocation(), CanonicalSuperT, CanonicalSubT, Paths.front(), /*Diagnostic*/ 0, /*ForceCheck*/ true, /*ForceUnprivileged*/ true)) { case AR_accessible: break; case AR_inaccessible: continue; case AR_dependent: llvm_unreachable("access check dependent for unprivileged context"); case AR_delayed: llvm_unreachable("access check delayed in non-declaration"); } Contained = true; break; } if (!Contained) { Diag(SubLoc, DiagID); if (NoteID.getDiagID() != 0) Diag(SuperLoc, NoteID); return true; } } // We've run half the gauntlet. return CheckParamExceptionSpec(NoteID, Superset, SuperLoc, Subset, SubLoc); } static bool CheckSpecForTypesEquivalent(Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID, QualType Target, SourceLocation TargetLoc, QualType Source, SourceLocation SourceLoc) { const FunctionProtoType *TFunc = GetUnderlyingFunction(Target); if (!TFunc) return false; const FunctionProtoType *SFunc = GetUnderlyingFunction(Source); if (!SFunc) return false; return S.CheckEquivalentExceptionSpec(DiagID, NoteID, TFunc, TargetLoc, SFunc, SourceLoc); } /// CheckParamExceptionSpec - Check if the parameter and return types of the /// two functions have equivalent exception specs. This is part of the /// assignment and override compatibility check. We do not check the parameters /// of parameter function pointers recursively, as no sane programmer would /// even be able to write such a function type. bool Sema::CheckParamExceptionSpec(const PartialDiagnostic & NoteID, const FunctionProtoType *Target, SourceLocation TargetLoc, const FunctionProtoType *Source, SourceLocation SourceLoc) { if (CheckSpecForTypesEquivalent( *this, PDiag(diag::err_deep_exception_specs_differ) << 0, PDiag(), Target->getReturnType(), TargetLoc, Source->getReturnType(), SourceLoc)) return true; // We shouldn't even be testing this unless the arguments are otherwise // compatible. assert(Target->getNumParams() == Source->getNumParams() && "Functions have different argument counts."); for (unsigned i = 0, E = Target->getNumParams(); i != E; ++i) { if (CheckSpecForTypesEquivalent( *this, PDiag(diag::err_deep_exception_specs_differ) << 1, PDiag(), Target->getParamType(i), TargetLoc, Source->getParamType(i), SourceLoc)) return true; } return false; } bool Sema::CheckExceptionSpecCompatibility(Expr *From, QualType ToType) { // First we check for applicability. // Target type must be a function, function pointer or function reference. const FunctionProtoType *ToFunc = GetUnderlyingFunction(ToType); if (!ToFunc) return false; // SourceType must be a function or function pointer. const FunctionProtoType *FromFunc = GetUnderlyingFunction(From->getType()); if (!FromFunc) return false; // Now we've got the correct types on both sides, check their compatibility. // This means that the source of the conversion can only throw a subset of // the exceptions of the target, and any exception specs on arguments or // return types must be equivalent. return CheckExceptionSpecSubset(PDiag(diag::err_incompatible_exception_specs), PDiag(), ToFunc, From->getSourceRange().getBegin(), FromFunc, SourceLocation()); } bool Sema::CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old) { if (getLangOpts().CPlusPlus11 && isa(New)) { // Don't check uninstantiated template destructors at all. We can only // synthesize correct specs after the template is instantiated. if (New->getParent()->isDependentType()) return false; if (New->getParent()->isBeingDefined()) { // The destructor might be updated once the definition is finished. So // remember it and check later. DelayedDestructorExceptionSpecChecks.push_back(std::make_pair( cast(New), cast(Old))); return false; } } unsigned DiagID = diag::err_override_exception_spec; if (getLangOpts().MicrosoftExt) DiagID = diag::warn_override_exception_spec; return CheckExceptionSpecSubset(PDiag(DiagID), PDiag(diag::note_overridden_virtual_function), Old->getType()->getAs(), Old->getLocation(), New->getType()->getAs(), New->getLocation()); } static CanThrowResult canSubExprsThrow(Sema &S, const Expr *CE) { Expr *E = const_cast(CE); CanThrowResult R = CT_Cannot; for (Expr::child_range I = E->children(); I && R != CT_Can; ++I) R = mergeCanThrow(R, S.canThrow(cast(*I))); return R; } static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D) { assert(D && "Expected decl"); // See if we can get a function type from the decl somehow. const ValueDecl *VD = dyn_cast(D); if (!VD) // If we have no clue what we're calling, assume the worst. return CT_Can; // As an extension, we assume that __attribute__((nothrow)) functions don't // throw. if (isa(D) && D->hasAttr()) return CT_Cannot; QualType T = VD->getType(); const FunctionProtoType *FT; if ((FT = T->getAs())) { } else if (const PointerType *PT = T->getAs()) FT = PT->getPointeeType()->getAs(); else if (const ReferenceType *RT = T->getAs()) FT = RT->getPointeeType()->getAs(); else if (const MemberPointerType *MT = T->getAs()) FT = MT->getPointeeType()->getAs(); else if (const BlockPointerType *BT = T->getAs()) FT = BT->getPointeeType()->getAs(); if (!FT) return CT_Can; FT = S.ResolveExceptionSpec(E->getLocStart(), FT); if (!FT) return CT_Can; return FT->isNothrow(S.Context) ? CT_Cannot : CT_Can; } static CanThrowResult canDynamicCastThrow(const CXXDynamicCastExpr *DC) { if (DC->isTypeDependent()) return CT_Dependent; if (!DC->getTypeAsWritten()->isReferenceType()) return CT_Cannot; if (DC->getSubExpr()->isTypeDependent()) return CT_Dependent; return DC->getCastKind() == clang::CK_Dynamic? CT_Can : CT_Cannot; } static CanThrowResult canTypeidThrow(Sema &S, const CXXTypeidExpr *DC) { if (DC->isTypeOperand()) return CT_Cannot; Expr *Op = DC->getExprOperand(); if (Op->isTypeDependent()) return CT_Dependent; const RecordType *RT = Op->getType()->getAs(); if (!RT) return CT_Cannot; if (!cast(RT->getDecl())->isPolymorphic()) return CT_Cannot; if (Op->Classify(S.Context).isPRValue()) return CT_Cannot; return CT_Can; } CanThrowResult Sema::canThrow(const Expr *E) { // C++ [expr.unary.noexcept]p3: // [Can throw] if in a potentially-evaluated context the expression would // contain: switch (E->getStmtClass()) { case Expr::CXXThrowExprClass: // - a potentially evaluated throw-expression return CT_Can; case Expr::CXXDynamicCastExprClass: { // - a potentially evaluated dynamic_cast expression dynamic_cast(v), // where T is a reference type, that requires a run-time check CanThrowResult CT = canDynamicCastThrow(cast(E)); if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::CXXTypeidExprClass: // - a potentially evaluated typeid expression applied to a glvalue // expression whose type is a polymorphic class type return canTypeidThrow(*this, cast(E)); // - a potentially evaluated call to a function, member function, function // pointer, or member function pointer that does not have a non-throwing // exception-specification case Expr::CallExprClass: case Expr::CXXMemberCallExprClass: case Expr::CXXOperatorCallExprClass: case Expr::UserDefinedLiteralClass: { const CallExpr *CE = cast(E); CanThrowResult CT; if (E->isTypeDependent()) CT = CT_Dependent; else if (isa(CE->getCallee()->IgnoreParens())) CT = CT_Cannot; else if (CE->getCalleeDecl()) CT = canCalleeThrow(*this, E, CE->getCalleeDecl()); else CT = CT_Can; if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::CXXConstructExprClass: case Expr::CXXTemporaryObjectExprClass: { CanThrowResult CT = canCalleeThrow(*this, E, cast(E)->getConstructor()); if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::LambdaExprClass: { const LambdaExpr *Lambda = cast(E); CanThrowResult CT = CT_Cannot; for (LambdaExpr::capture_init_iterator Cap = Lambda->capture_init_begin(), CapEnd = Lambda->capture_init_end(); Cap != CapEnd; ++Cap) CT = mergeCanThrow(CT, canThrow(*Cap)); return CT; } case Expr::CXXNewExprClass: { CanThrowResult CT; if (E->isTypeDependent()) CT = CT_Dependent; else CT = canCalleeThrow(*this, E, cast(E)->getOperatorNew()); if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::CXXDeleteExprClass: { CanThrowResult CT; QualType DTy = cast(E)->getDestroyedType(); if (DTy.isNull() || DTy->isDependentType()) { CT = CT_Dependent; } else { CT = canCalleeThrow(*this, E, cast(E)->getOperatorDelete()); if (const RecordType *RT = DTy->getAs()) { const CXXRecordDecl *RD = cast(RT->getDecl()); const CXXDestructorDecl *DD = RD->getDestructor(); if (DD) CT = mergeCanThrow(CT, canCalleeThrow(*this, E, DD)); } if (CT == CT_Can) return CT; } return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } case Expr::CXXBindTemporaryExprClass: { // The bound temporary has to be destroyed again, which might throw. CanThrowResult CT = canCalleeThrow(*this, E, cast(E)->getTemporary()->getDestructor()); if (CT == CT_Can) return CT; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } // ObjC message sends are like function calls, but never have exception // specs. case Expr::ObjCMessageExprClass: case Expr::ObjCPropertyRefExprClass: case Expr::ObjCSubscriptRefExprClass: return CT_Can; // All the ObjC literals that are implemented as calls are // potentially throwing unless we decide to close off that // possibility. case Expr::ObjCArrayLiteralClass: case Expr::ObjCDictionaryLiteralClass: case Expr::ObjCBoxedExprClass: return CT_Can; // Many other things have subexpressions, so we have to test those. // Some are simple: case Expr::ConditionalOperatorClass: case Expr::CompoundLiteralExprClass: case Expr::CXXConstCastExprClass: case Expr::CXXReinterpretCastExprClass: case Expr::CXXStdInitializerListExprClass: case Expr::DesignatedInitExprClass: case Expr::ExprWithCleanupsClass: case Expr::ExtVectorElementExprClass: case Expr::InitListExprClass: case Expr::MemberExprClass: case Expr::ObjCIsaExprClass: case Expr::ObjCIvarRefExprClass: case Expr::ParenExprClass: case Expr::ParenListExprClass: case Expr::ShuffleVectorExprClass: case Expr::ConvertVectorExprClass: case Expr::VAArgExprClass: return canSubExprsThrow(*this, E); // Some might be dependent for other reasons. case Expr::ArraySubscriptExprClass: case Expr::BinaryOperatorClass: case Expr::CompoundAssignOperatorClass: case Expr::CStyleCastExprClass: case Expr::CXXStaticCastExprClass: case Expr::CXXFunctionalCastExprClass: case Expr::ImplicitCastExprClass: case Expr::MaterializeTemporaryExprClass: case Expr::UnaryOperatorClass: { CanThrowResult CT = E->isTypeDependent() ? CT_Dependent : CT_Cannot; return mergeCanThrow(CT, canSubExprsThrow(*this, E)); } // FIXME: We should handle StmtExpr, but that opens a MASSIVE can of worms. case Expr::StmtExprClass: return CT_Can; case Expr::CXXDefaultArgExprClass: return canThrow(cast(E)->getExpr()); case Expr::CXXDefaultInitExprClass: return canThrow(cast(E)->getExpr()); case Expr::ChooseExprClass: if (E->isTypeDependent() || E->isValueDependent()) return CT_Dependent; return canThrow(cast(E)->getChosenSubExpr()); case Expr::GenericSelectionExprClass: if (cast(E)->isResultDependent()) return CT_Dependent; return canThrow(cast(E)->getResultExpr()); // Some expressions are always dependent. case Expr::CXXDependentScopeMemberExprClass: case Expr::CXXUnresolvedConstructExprClass: case Expr::DependentScopeDeclRefExprClass: return CT_Dependent; case Expr::AsTypeExprClass: case Expr::BinaryConditionalOperatorClass: case Expr::BlockExprClass: case Expr::CUDAKernelCallExprClass: case Expr::DeclRefExprClass: case Expr::ObjCBridgedCastExprClass: case Expr::ObjCIndirectCopyRestoreExprClass: case Expr::ObjCProtocolExprClass: case Expr::ObjCSelectorExprClass: case Expr::OffsetOfExprClass: case Expr::PackExpansionExprClass: case Expr::PseudoObjectExprClass: case Expr::SubstNonTypeTemplateParmExprClass: case Expr::SubstNonTypeTemplateParmPackExprClass: case Expr::FunctionParmPackExprClass: case Expr::UnaryExprOrTypeTraitExprClass: case Expr::UnresolvedLookupExprClass: case Expr::UnresolvedMemberExprClass: // FIXME: Can any of the above throw? If so, when? return CT_Cannot; case Expr::AddrLabelExprClass: case Expr::ArrayTypeTraitExprClass: case Expr::AtomicExprClass: case Expr::TypeTraitExprClass: case Expr::CXXBoolLiteralExprClass: case Expr::CXXNoexceptExprClass: case Expr::CXXNullPtrLiteralExprClass: case Expr::CXXPseudoDestructorExprClass: case Expr::CXXScalarValueInitExprClass: case Expr::CXXThisExprClass: case Expr::CXXUuidofExprClass: case Expr::CharacterLiteralClass: case Expr::ExpressionTraitExprClass: case Expr::FloatingLiteralClass: case Expr::GNUNullExprClass: case Expr::ImaginaryLiteralClass: case Expr::ImplicitValueInitExprClass: case Expr::IntegerLiteralClass: case Expr::ObjCEncodeExprClass: case Expr::ObjCStringLiteralClass: case Expr::ObjCBoolLiteralExprClass: case Expr::OpaqueValueExprClass: case Expr::PredefinedExprClass: case Expr::SizeOfPackExprClass: case Expr::StringLiteralClass: // These expressions can never throw. return CT_Cannot; case Expr::MSPropertyRefExprClass: llvm_unreachable("Invalid class for expression"); #define STMT(CLASS, PARENT) case Expr::CLASS##Class: #define STMT_RANGE(Base, First, Last) #define LAST_STMT_RANGE(BASE, FIRST, LAST) #define EXPR(CLASS, PARENT) #define ABSTRACT_STMT(STMT) #include "clang/AST/StmtNodes.inc" case Expr::NoStmtClass: llvm_unreachable("Invalid class for expression"); } llvm_unreachable("Bogus StmtClass"); } } // end namespace clang @