Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 1 | //===--- SemaExceptionSpec.cpp - C++ Exception Specifications ---*- C++ -*-===// |
| 2 | // |
Chandler Carruth | 2946cd7 | 2019-01-19 08:50:56 +0000 | [diff] [blame] | 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 | // See https://llvm.org/LICENSE.txt for license information. |
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 6 | // |
| 7 | //===----------------------------------------------------------------------===// |
| 8 | // |
| 9 | // This file provides Sema routines for C++ exception specification testing. |
| 10 | // |
| 11 | //===----------------------------------------------------------------------===// |
| 12 | |
Richard Smith | 564417a | 2014-03-20 21:47:22 +0000 | [diff] [blame] | 13 | #include "clang/AST/ASTMutationListener.h" |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 14 | #include "clang/AST/CXXInheritance.h" |
| 15 | #include "clang/AST/Expr.h" |
| 16 | #include "clang/AST/ExprCXX.h" |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 17 | #include "clang/AST/StmtObjC.h" |
Douglas Gregor | d6bc5e6 | 2010-03-24 07:14:45 +0000 | [diff] [blame] | 18 | #include "clang/AST/TypeLoc.h" |
Douglas Gregor | f40863c | 2010-02-12 07:32:17 +0000 | [diff] [blame] | 19 | #include "clang/Basic/Diagnostic.h" |
| 20 | #include "clang/Basic/SourceManager.h" |
Kazu Hirata | 46d750b | 2024-11-16 07:37:33 -0800 | [diff] [blame] | 21 | #include "clang/Sema/SemaInternal.h" |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 22 | #include "llvm/ADT/SmallPtrSet.h" |
Kazu Hirata | a1580d7 | 2023-01-14 11:07:21 -0800 | [diff] [blame] | 23 | #include <optional> |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 24 | |
| 25 | namespace clang { |
| 26 | |
| 27 | static const FunctionProtoType *GetUnderlyingFunction(QualType T) |
| 28 | { |
| 29 | if (const PointerType *PtrTy = T->getAs<PointerType>()) |
| 30 | T = PtrTy->getPointeeType(); |
| 31 | else if (const ReferenceType *RefTy = T->getAs<ReferenceType>()) |
| 32 | T = RefTy->getPointeeType(); |
Sebastian Redl | 075b21d | 2009-10-14 14:38:54 +0000 | [diff] [blame] | 33 | else if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>()) |
| 34 | T = MPTy->getPointeeType(); |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 35 | return T->getAs<FunctionProtoType>(); |
| 36 | } |
| 37 | |
Nathan Sidwell | 0ff41c2 | 2021-04-28 04:03:11 -0700 | [diff] [blame] | 38 | /// HACK: 2014-11-14 libstdc++ had a bug where it shadows std::swap with a |
| 39 | /// member swap function then tries to call std::swap unqualified from the |
| 40 | /// exception specification of that function. This function detects whether |
| 41 | /// we're in such a case and turns off delay-parsing of exception |
| 42 | /// specifications. Libstdc++ 6.1 (released 2016-04-27) appears to have |
| 43 | /// resolved it as side-effect of commit ddb63209a8d (2015-06-05). |
Richard Smith | 6403e93 | 2014-11-14 00:37:55 +0000 | [diff] [blame] | 44 | bool Sema::isLibstdcxxEagerExceptionSpecHack(const Declarator &D) { |
| 45 | auto *RD = dyn_cast<CXXRecordDecl>(CurContext); |
| 46 | |
| 47 | // All the problem cases are member functions named "swap" within class |
Richard Smith | 6289546 | 2016-10-19 23:47:37 +0000 | [diff] [blame] | 48 | // templates declared directly within namespace std or std::__debug or |
| 49 | // std::__profile. |
| 50 | if (!RD || !RD->getIdentifier() || !RD->getDescribedClassTemplate() || |
Richard Smith | 6403e93 | 2014-11-14 00:37:55 +0000 | [diff] [blame] | 51 | !D.getIdentifier() || !D.getIdentifier()->isStr("swap")) |
| 52 | return false; |
| 53 | |
Richard Smith | 6289546 | 2016-10-19 23:47:37 +0000 | [diff] [blame] | 54 | auto *ND = dyn_cast<NamespaceDecl>(RD->getDeclContext()); |
| 55 | if (!ND) |
| 56 | return false; |
| 57 | |
| 58 | bool IsInStd = ND->isStdNamespace(); |
| 59 | if (!IsInStd) { |
| 60 | // This isn't a direct member of namespace std, but it might still be |
| 61 | // libstdc++'s std::__debug::array or std::__profile::array. |
| 62 | IdentifierInfo *II = ND->getIdentifier(); |
| 63 | if (!II || !(II->isStr("__debug") || II->isStr("__profile")) || |
| 64 | !ND->isInStdNamespace()) |
| 65 | return false; |
| 66 | } |
| 67 | |
Richard Smith | 6403e93 | 2014-11-14 00:37:55 +0000 | [diff] [blame] | 68 | // Only apply this hack within a system header. |
Stephen Kelly | f2ceec4 | 2018-08-09 21:08:08 +0000 | [diff] [blame] | 69 | if (!Context.getSourceManager().isInSystemHeader(D.getBeginLoc())) |
Richard Smith | 6403e93 | 2014-11-14 00:37:55 +0000 | [diff] [blame] | 70 | return false; |
| 71 | |
| 72 | return llvm::StringSwitch<bool>(RD->getIdentifier()->getName()) |
| 73 | .Case("array", true) |
Richard Smith | 6289546 | 2016-10-19 23:47:37 +0000 | [diff] [blame] | 74 | .Case("pair", IsInStd) |
| 75 | .Case("priority_queue", IsInStd) |
| 76 | .Case("stack", IsInStd) |
| 77 | .Case("queue", IsInStd) |
Richard Smith | 6403e93 | 2014-11-14 00:37:55 +0000 | [diff] [blame] | 78 | .Default(false); |
| 79 | } |
| 80 | |
Corentin Jabot | 3c8e94b | 2021-08-06 10:26:39 -0400 | [diff] [blame] | 81 | ExprResult Sema::ActOnNoexceptSpec(Expr *NoexceptExpr, |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 82 | ExceptionSpecificationType &EST) { |
Corentin Jabot | 3c8e94b | 2021-08-06 10:26:39 -0400 | [diff] [blame] | 83 | |
| 84 | if (NoexceptExpr->isTypeDependent() || |
| 85 | NoexceptExpr->containsUnexpandedParameterPack()) { |
| 86 | EST = EST_DependentNoexcept; |
| 87 | return NoexceptExpr; |
| 88 | } |
| 89 | |
| 90 | llvm::APSInt Result; |
| 91 | ExprResult Converted = CheckConvertedConstantExpression( |
Vlad Serebrennikov | cf2f13a | 2025-05-02 14:01:15 +0300 | [diff] [blame^] | 92 | NoexceptExpr, Context.BoolTy, Result, CCEKind::Noexcept); |
Corentin Jabot | 3c8e94b | 2021-08-06 10:26:39 -0400 | [diff] [blame] | 93 | |
Erich Keane | f0719bf | 2020-01-13 07:45:17 -0800 | [diff] [blame] | 94 | if (Converted.isInvalid()) { |
| 95 | EST = EST_NoexceptFalse; |
Erich Keane | f0719bf | 2020-01-13 07:45:17 -0800 | [diff] [blame] | 96 | // Fill in an expression of 'false' as a fixup. |
| 97 | auto *BoolExpr = new (Context) |
| 98 | CXXBoolLiteralExpr(false, Context.BoolTy, NoexceptExpr->getBeginLoc()); |
| 99 | llvm::APSInt Value{1}; |
| 100 | Value = 0; |
| 101 | return ConstantExpr::Create(Context, BoolExpr, APValue{Value}); |
| 102 | } |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 103 | |
| 104 | if (Converted.get()->isValueDependent()) { |
| 105 | EST = EST_DependentNoexcept; |
| 106 | return Converted; |
| 107 | } |
| 108 | |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 109 | if (!Converted.isInvalid()) |
| 110 | EST = !Result ? EST_NoexceptFalse : EST_NoexceptTrue; |
| 111 | return Converted; |
| 112 | } |
| 113 | |
Craig Topper | e335f25 | 2015-10-04 04:53:55 +0000 | [diff] [blame] | 114 | bool Sema::CheckSpecifiedExceptionType(QualType &T, SourceRange Range) { |
Richard Smith | a118c6a | 2012-11-28 22:52:42 +0000 | [diff] [blame] | 115 | // C++11 [except.spec]p2: |
| 116 | // A type cv T, "array of T", or "function returning T" denoted |
Richard Smith | 8606d75 | 2012-11-28 22:33:28 +0000 | [diff] [blame] | 117 | // in an exception-specification is adjusted to type T, "pointer to T", or |
| 118 | // "pointer to function returning T", respectively. |
Richard Smith | a118c6a | 2012-11-28 22:52:42 +0000 | [diff] [blame] | 119 | // |
| 120 | // We also apply this rule in C++98. |
Richard Smith | 8606d75 | 2012-11-28 22:33:28 +0000 | [diff] [blame] | 121 | if (T->isArrayType()) |
| 122 | T = Context.getArrayDecayedType(T); |
| 123 | else if (T->isFunctionType()) |
| 124 | T = Context.getPointerType(T); |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 125 | |
Richard Smith | a118c6a | 2012-11-28 22:52:42 +0000 | [diff] [blame] | 126 | int Kind = 0; |
Richard Smith | 8606d75 | 2012-11-28 22:33:28 +0000 | [diff] [blame] | 127 | QualType PointeeT = T; |
Richard Smith | a118c6a | 2012-11-28 22:52:42 +0000 | [diff] [blame] | 128 | if (const PointerType *PT = T->getAs<PointerType>()) { |
| 129 | PointeeT = PT->getPointeeType(); |
| 130 | Kind = 1; |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 131 | |
Richard Smith | a118c6a | 2012-11-28 22:52:42 +0000 | [diff] [blame] | 132 | // cv void* is explicitly permitted, despite being a pointer to an |
| 133 | // incomplete type. |
| 134 | if (PointeeT->isVoidType()) |
| 135 | return false; |
| 136 | } else if (const ReferenceType *RT = T->getAs<ReferenceType>()) { |
| 137 | PointeeT = RT->getPointeeType(); |
| 138 | Kind = 2; |
Richard Smith | 8606d75 | 2012-11-28 22:33:28 +0000 | [diff] [blame] | 139 | |
Richard Smith | a118c6a | 2012-11-28 22:52:42 +0000 | [diff] [blame] | 140 | if (RT->isRValueReferenceType()) { |
| 141 | // C++11 [except.spec]p2: |
| 142 | // A type denoted in an exception-specification shall not denote [...] |
| 143 | // an rvalue reference type. |
| 144 | Diag(Range.getBegin(), diag::err_rref_in_exception_spec) |
| 145 | << T << Range; |
| 146 | return true; |
| 147 | } |
| 148 | } |
| 149 | |
| 150 | // C++11 [except.spec]p2: |
| 151 | // A type denoted in an exception-specification shall not denote an |
| 152 | // incomplete type other than a class currently being defined [...]. |
| 153 | // A type denoted in an exception-specification shall not denote a |
| 154 | // pointer or reference to an incomplete type, other than (cv) void* or a |
| 155 | // pointer or reference to a class currently being defined. |
David Majnemer | b2b0da4 | 2016-06-10 18:24:41 +0000 | [diff] [blame] | 156 | // In Microsoft mode, downgrade this to a warning. |
| 157 | unsigned DiagID = diag::err_incomplete_in_exception_spec; |
David Majnemer | 5d321e6 | 2016-06-11 01:25:04 +0000 | [diff] [blame] | 158 | bool ReturnValueOnError = true; |
Reid Kleckner | 39aa895 | 2019-08-27 17:52:03 +0000 | [diff] [blame] | 159 | if (getLangOpts().MSVCCompat) { |
David Majnemer | b2b0da4 | 2016-06-10 18:24:41 +0000 | [diff] [blame] | 160 | DiagID = diag::ext_incomplete_in_exception_spec; |
David Majnemer | 5d321e6 | 2016-06-11 01:25:04 +0000 | [diff] [blame] | 161 | ReturnValueOnError = false; |
| 162 | } |
Richard Smith | a118c6a | 2012-11-28 22:52:42 +0000 | [diff] [blame] | 163 | if (!(PointeeT->isRecordType() && |
Simon Pilgrim | 1cd399c | 2019-10-03 11:22:48 +0000 | [diff] [blame] | 164 | PointeeT->castAs<RecordType>()->isBeingDefined()) && |
David Majnemer | b2b0da4 | 2016-06-10 18:24:41 +0000 | [diff] [blame] | 165 | RequireCompleteType(Range.getBegin(), PointeeT, DiagID, Kind, Range)) |
David Majnemer | 5d321e6 | 2016-06-11 01:25:04 +0000 | [diff] [blame] | 166 | return ReturnValueOnError; |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 167 | |
Paulo Matos | 55aeb23 | 2023-06-10 15:51:05 +0200 | [diff] [blame] | 168 | // WebAssembly reference types can't be used in exception specifications. |
| 169 | if (PointeeT.isWebAssemblyReferenceType()) { |
| 170 | Diag(Range.getBegin(), diag::err_wasm_reftype_exception_spec); |
| 171 | return true; |
| 172 | } |
| 173 | |
Richard Sandiford | 0947296 | 2020-03-03 10:39:57 +0000 | [diff] [blame] | 174 | // The MSVC compatibility mode doesn't extend to sizeless types, |
| 175 | // so diagnose them separately. |
| 176 | if (PointeeT->isSizelessType() && Kind != 1) { |
| 177 | Diag(Range.getBegin(), diag::err_sizeless_in_exception_spec) |
| 178 | << (Kind == 2 ? 1 : 0) << PointeeT << Range; |
| 179 | return true; |
| 180 | } |
| 181 | |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 182 | return false; |
| 183 | } |
| 184 | |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 185 | bool Sema::CheckDistantExceptionSpec(QualType T) { |
Richard Smith | 3c4f8d2 | 2016-10-16 17:54:23 +0000 | [diff] [blame] | 186 | // C++17 removes this rule in favor of putting exception specifications into |
| 187 | // the type system. |
Aaron Ballman | c351fba | 2017-12-04 20:27:34 +0000 | [diff] [blame] | 188 | if (getLangOpts().CPlusPlus17) |
Richard Smith | 3c4f8d2 | 2016-10-16 17:54:23 +0000 | [diff] [blame] | 189 | return false; |
| 190 | |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 191 | if (const PointerType *PT = T->getAs<PointerType>()) |
| 192 | T = PT->getPointeeType(); |
| 193 | else if (const MemberPointerType *PT = T->getAs<MemberPointerType>()) |
| 194 | T = PT->getPointeeType(); |
| 195 | else |
| 196 | return false; |
| 197 | |
| 198 | const FunctionProtoType *FnT = T->getAs<FunctionProtoType>(); |
| 199 | if (!FnT) |
| 200 | return false; |
| 201 | |
| 202 | return FnT->hasExceptionSpec(); |
| 203 | } |
| 204 | |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 205 | const FunctionProtoType * |
| 206 | Sema::ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT) { |
Richard Smith | 0b3a462 | 2014-11-13 20:01:57 +0000 | [diff] [blame] | 207 | if (FPT->getExceptionSpecType() == EST_Unparsed) { |
| 208 | Diag(Loc, diag::err_exception_spec_not_parsed); |
| 209 | return nullptr; |
| 210 | } |
| 211 | |
Richard Smith | d3b5c908 | 2012-07-27 04:22:15 +0000 | [diff] [blame] | 212 | if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 213 | return FPT; |
| 214 | |
| 215 | FunctionDecl *SourceDecl = FPT->getExceptionSpecDecl(); |
| 216 | const FunctionProtoType *SourceFPT = |
| 217 | SourceDecl->getType()->castAs<FunctionProtoType>(); |
| 218 | |
Richard Smith | d3b5c908 | 2012-07-27 04:22:15 +0000 | [diff] [blame] | 219 | // If the exception specification has already been resolved, just return it. |
| 220 | if (!isUnresolvedExceptionSpec(SourceFPT->getExceptionSpecType())) |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 221 | return SourceFPT; |
| 222 | |
Richard Smith | d3b5c908 | 2012-07-27 04:22:15 +0000 | [diff] [blame] | 223 | // Compute or instantiate the exception specification now. |
Richard Smith | 3901dfe | 2013-03-27 00:22:47 +0000 | [diff] [blame] | 224 | if (SourceFPT->getExceptionSpecType() == EST_Unevaluated) |
Richard Smith | 4a4e90a | 2019-12-13 14:11:04 -0800 | [diff] [blame] | 225 | EvaluateImplicitExceptionSpec(Loc, SourceDecl); |
Richard Smith | d3b5c908 | 2012-07-27 04:22:15 +0000 | [diff] [blame] | 226 | else |
| 227 | InstantiateExceptionSpec(Loc, SourceDecl); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 228 | |
Davide Italiano | 922b702 | 2015-07-25 01:19:32 +0000 | [diff] [blame] | 229 | const FunctionProtoType *Proto = |
| 230 | SourceDecl->getType()->castAs<FunctionProtoType>(); |
| 231 | if (Proto->getExceptionSpecType() == clang::EST_Unparsed) { |
| 232 | Diag(Loc, diag::err_exception_spec_not_parsed); |
| 233 | Proto = nullptr; |
| 234 | } |
| 235 | return Proto; |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 236 | } |
| 237 | |
Richard Smith | 8acb428 | 2014-07-31 21:57:55 +0000 | [diff] [blame] | 238 | void |
| 239 | Sema::UpdateExceptionSpec(FunctionDecl *FD, |
| 240 | const FunctionProtoType::ExceptionSpecInfo &ESI) { |
Richard Smith | 564417a | 2014-03-20 21:47:22 +0000 | [diff] [blame] | 241 | // If we've fully resolved the exception specification, notify listeners. |
Richard Smith | 8acb428 | 2014-07-31 21:57:55 +0000 | [diff] [blame] | 242 | if (!isUnresolvedExceptionSpec(ESI.Type)) |
Richard Smith | 564417a | 2014-03-20 21:47:22 +0000 | [diff] [blame] | 243 | if (auto *Listener = getASTMutationListener()) |
| 244 | Listener->ResolvedExceptionSpec(FD); |
Richard Smith | 9e2341d | 2015-03-23 03:25:59 +0000 | [diff] [blame] | 245 | |
George Burgess IV | 00f70bd | 2018-03-01 05:43:23 +0000 | [diff] [blame] | 246 | for (FunctionDecl *Redecl : FD->redecls()) |
| 247 | Context.adjustExceptionSpec(Redecl, ESI); |
Richard Smith | 564417a | 2014-03-20 21:47:22 +0000 | [diff] [blame] | 248 | } |
| 249 | |
Richard Smith | 5159bbad | 2018-09-05 22:30:37 +0000 | [diff] [blame] | 250 | static bool exceptionSpecNotKnownYet(const FunctionDecl *FD) { |
Krystian Stasiowski | f061a39 | 2024-04-30 14:23:02 -0400 | [diff] [blame] | 251 | ExceptionSpecificationType EST = |
| 252 | FD->getType()->castAs<FunctionProtoType>()->getExceptionSpecType(); |
| 253 | if (EST == EST_Unparsed) |
| 254 | return true; |
| 255 | else if (EST != EST_Unevaluated) |
Richard Smith | 5159bbad | 2018-09-05 22:30:37 +0000 | [diff] [blame] | 256 | return false; |
Krystian Stasiowski | f061a39 | 2024-04-30 14:23:02 -0400 | [diff] [blame] | 257 | const DeclContext *DC = FD->getLexicalDeclContext(); |
| 258 | return DC->isRecord() && cast<RecordDecl>(DC)->isBeingDefined(); |
Simon Pilgrim | 58310ec | 2018-09-06 15:16:17 +0000 | [diff] [blame] | 259 | } |
Richard Smith | 5159bbad | 2018-09-05 22:30:37 +0000 | [diff] [blame] | 260 | |
Richard Smith | 13b40bc | 2016-11-30 00:13:55 +0000 | [diff] [blame] | 261 | static bool CheckEquivalentExceptionSpecImpl( |
| 262 | Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, |
| 263 | const FunctionProtoType *Old, SourceLocation OldLoc, |
| 264 | const FunctionProtoType *New, SourceLocation NewLoc, |
| 265 | bool *MissingExceptionSpecification = nullptr, |
| 266 | bool *MissingEmptyExceptionSpecification = nullptr, |
| 267 | bool AllowNoexceptAllMatchWithNoSpec = false, bool IsOperatorNew = false); |
| 268 | |
Richard Smith | 66f3ac9 | 2012-10-20 08:26:51 +0000 | [diff] [blame] | 269 | /// Determine whether a function has an implicitly-generated exception |
Richard Smith | 1ee6352 | 2012-10-16 23:30:16 +0000 | [diff] [blame] | 270 | /// specification. |
Richard Smith | 66f3ac9 | 2012-10-20 08:26:51 +0000 | [diff] [blame] | 271 | static bool hasImplicitExceptionSpec(FunctionDecl *Decl) { |
| 272 | if (!isa<CXXDestructorDecl>(Decl) && |
| 273 | Decl->getDeclName().getCXXOverloadedOperator() != OO_Delete && |
| 274 | Decl->getDeclName().getCXXOverloadedOperator() != OO_Array_Delete) |
| 275 | return false; |
Richard Smith | 1ee6352 | 2012-10-16 23:30:16 +0000 | [diff] [blame] | 276 | |
Richard Smith | c7fb225 | 2014-02-07 22:51:16 +0000 | [diff] [blame] | 277 | // For a function that the user didn't declare: |
| 278 | // - if this is a destructor, its exception specification is implicit. |
| 279 | // - if this is 'operator delete' or 'operator delete[]', the exception |
| 280 | // specification is as-if an explicit exception specification was given |
| 281 | // (per [basic.stc.dynamic]p2). |
Richard Smith | 66f3ac9 | 2012-10-20 08:26:51 +0000 | [diff] [blame] | 282 | if (!Decl->getTypeSourceInfo()) |
Richard Smith | c7fb225 | 2014-02-07 22:51:16 +0000 | [diff] [blame] | 283 | return isa<CXXDestructorDecl>(Decl); |
Richard Smith | 66f3ac9 | 2012-10-20 08:26:51 +0000 | [diff] [blame] | 284 | |
Simon Pilgrim | afb163f | 2019-10-21 18:28:31 +0000 | [diff] [blame] | 285 | auto *Ty = Decl->getTypeSourceInfo()->getType()->castAs<FunctionProtoType>(); |
Richard Smith | 66f3ac9 | 2012-10-20 08:26:51 +0000 | [diff] [blame] | 286 | return !Ty->hasExceptionSpec(); |
Richard Smith | 1ee6352 | 2012-10-16 23:30:16 +0000 | [diff] [blame] | 287 | } |
| 288 | |
Douglas Gregor | f40863c | 2010-02-12 07:32:17 +0000 | [diff] [blame] | 289 | bool Sema::CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New) { |
Aaron Ballman | c351fba | 2017-12-04 20:27:34 +0000 | [diff] [blame] | 290 | // Just completely ignore this under -fno-exceptions prior to C++17. |
| 291 | // In C++17 onwards, the exception specification is part of the type and |
Richard Smith | 13b40bc | 2016-11-30 00:13:55 +0000 | [diff] [blame] | 292 | // we will diagnose mismatches anyway, so it's better to check for them here. |
Aaron Ballman | c351fba | 2017-12-04 20:27:34 +0000 | [diff] [blame] | 293 | if (!getLangOpts().CXXExceptions && !getLangOpts().CPlusPlus17) |
Richard Smith | 13b40bc | 2016-11-30 00:13:55 +0000 | [diff] [blame] | 294 | return false; |
| 295 | |
Sebastian Redl | cb5dd00 | 2011-03-15 19:52:30 +0000 | [diff] [blame] | 296 | OverloadedOperatorKind OO = New->getDeclName().getCXXOverloadedOperator(); |
| 297 | bool IsOperatorNew = OO == OO_New || OO == OO_Array_New; |
Douglas Gregor | d6bc5e6 | 2010-03-24 07:14:45 +0000 | [diff] [blame] | 298 | bool MissingExceptionSpecification = false; |
Douglas Gregor | f40863c | 2010-02-12 07:32:17 +0000 | [diff] [blame] | 299 | bool MissingEmptyExceptionSpecification = false; |
Hans Wennborg | 39a509a | 2014-02-05 02:37:58 +0000 | [diff] [blame] | 300 | |
Francois Pichet | 13b4e68 | 2011-03-19 23:05:18 +0000 | [diff] [blame] | 301 | unsigned DiagID = diag::err_mismatched_exception_spec; |
Hans Wennborg | 39a509a | 2014-02-05 02:37:58 +0000 | [diff] [blame] | 302 | bool ReturnValueOnError = true; |
Reid Kleckner | 39aa895 | 2019-08-27 17:52:03 +0000 | [diff] [blame] | 303 | if (getLangOpts().MSVCCompat) { |
Richard Smith | 1b98ccc | 2014-07-19 01:39:17 +0000 | [diff] [blame] | 304 | DiagID = diag::ext_mismatched_exception_spec; |
Hans Wennborg | 39a509a | 2014-02-05 02:37:58 +0000 | [diff] [blame] | 305 | ReturnValueOnError = false; |
| 306 | } |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 307 | |
Richard Smith | 5159bbad | 2018-09-05 22:30:37 +0000 | [diff] [blame] | 308 | // If we're befriending a member function of a class that's currently being |
| 309 | // defined, we might not be able to work out its exception specification yet. |
| 310 | // If not, defer the check until later. |
| 311 | if (exceptionSpecNotKnownYet(Old) || exceptionSpecNotKnownYet(New)) { |
| 312 | DelayedEquivalentExceptionSpecChecks.push_back({New, Old}); |
| 313 | return false; |
| 314 | } |
| 315 | |
Richard Smith | 1ee6352 | 2012-10-16 23:30:16 +0000 | [diff] [blame] | 316 | // Check the types as written: they must match before any exception |
| 317 | // specification adjustment is applied. |
Richard Smith | 13b40bc | 2016-11-30 00:13:55 +0000 | [diff] [blame] | 318 | if (!CheckEquivalentExceptionSpecImpl( |
| 319 | *this, PDiag(DiagID), PDiag(diag::note_previous_declaration), |
Richard Smith | 66f3ac9 | 2012-10-20 08:26:51 +0000 | [diff] [blame] | 320 | Old->getType()->getAs<FunctionProtoType>(), Old->getLocation(), |
| 321 | New->getType()->getAs<FunctionProtoType>(), New->getLocation(), |
Richard Smith | 1ee6352 | 2012-10-16 23:30:16 +0000 | [diff] [blame] | 322 | &MissingExceptionSpecification, &MissingEmptyExceptionSpecification, |
Richard Smith | 66f3ac9 | 2012-10-20 08:26:51 +0000 | [diff] [blame] | 323 | /*AllowNoexceptAllMatchWithNoSpec=*/true, IsOperatorNew)) { |
| 324 | // C++11 [except.spec]p4 [DR1492]: |
| 325 | // If a declaration of a function has an implicit |
| 326 | // exception-specification, other declarations of the function shall |
| 327 | // not specify an exception-specification. |
Richard Smith | e3ea001 | 2016-08-31 20:38:32 +0000 | [diff] [blame] | 328 | if (getLangOpts().CPlusPlus11 && getLangOpts().CXXExceptions && |
Richard Smith | 66f3ac9 | 2012-10-20 08:26:51 +0000 | [diff] [blame] | 329 | hasImplicitExceptionSpec(Old) != hasImplicitExceptionSpec(New)) { |
| 330 | Diag(New->getLocation(), diag::ext_implicit_exception_spec_mismatch) |
| 331 | << hasImplicitExceptionSpec(Old); |
Yaron Keren | 8b56366 | 2015-10-03 10:46:20 +0000 | [diff] [blame] | 332 | if (Old->getLocation().isValid()) |
Richard Smith | 66f3ac9 | 2012-10-20 08:26:51 +0000 | [diff] [blame] | 333 | Diag(Old->getLocation(), diag::note_previous_declaration); |
| 334 | } |
Douglas Gregor | f40863c | 2010-02-12 07:32:17 +0000 | [diff] [blame] | 335 | return false; |
Richard Smith | 66f3ac9 | 2012-10-20 08:26:51 +0000 | [diff] [blame] | 336 | } |
Douglas Gregor | f40863c | 2010-02-12 07:32:17 +0000 | [diff] [blame] | 337 | |
Eli Friedman | 96dbf6f | 2013-06-25 00:46:32 +0000 | [diff] [blame] | 338 | // The failure was something other than an missing exception |
Hans Wennborg | 39a509a | 2014-02-05 02:37:58 +0000 | [diff] [blame] | 339 | // specification; return an error, except in MS mode where this is a warning. |
Eli Friedman | 96dbf6f | 2013-06-25 00:46:32 +0000 | [diff] [blame] | 340 | if (!MissingExceptionSpecification) |
Hans Wennborg | 39a509a | 2014-02-05 02:37:58 +0000 | [diff] [blame] | 341 | return ReturnValueOnError; |
Douglas Gregor | f40863c | 2010-02-12 07:32:17 +0000 | [diff] [blame] | 342 | |
Simon Pilgrim | 5fe64d2 | 2022-02-17 16:59:41 +0000 | [diff] [blame] | 343 | const auto *NewProto = New->getType()->castAs<FunctionProtoType>(); |
John McCall | db40c7f | 2010-12-14 08:05:40 +0000 | [diff] [blame] | 344 | |
Douglas Gregor | f40863c | 2010-02-12 07:32:17 +0000 | [diff] [blame] | 345 | // The new function declaration is only missing an empty exception |
| 346 | // specification "throw()". If the throw() specification came from a |
| 347 | // function in a system header that has C linkage, just add an empty |
Richard Smith | 836de6b | 2016-12-19 23:59:34 +0000 | [diff] [blame] | 348 | // exception specification to the "new" declaration. Note that C library |
| 349 | // implementations are permitted to add these nothrow exception |
| 350 | // specifications. |
| 351 | // |
| 352 | // Likewise if the old function is a builtin. |
Simon Pilgrim | 5fe64d2 | 2022-02-17 16:59:41 +0000 | [diff] [blame] | 353 | if (MissingEmptyExceptionSpecification && |
Douglas Gregor | d6bc5e6 | 2010-03-24 07:14:45 +0000 | [diff] [blame] | 354 | (Old->getLocation().isInvalid() || |
Richard Smith | 836de6b | 2016-12-19 23:59:34 +0000 | [diff] [blame] | 355 | Context.getSourceManager().isInSystemHeader(Old->getLocation()) || |
| 356 | Old->getBuiltinID()) && |
Douglas Gregor | f40863c | 2010-02-12 07:32:17 +0000 | [diff] [blame] | 357 | Old->isExternC()) { |
Richard Smith | 8acb428 | 2014-07-31 21:57:55 +0000 | [diff] [blame] | 358 | New->setType(Context.getFunctionType( |
| 359 | NewProto->getReturnType(), NewProto->getParamTypes(), |
| 360 | NewProto->getExtProtoInfo().withExceptionSpec(EST_DynamicNone))); |
Douglas Gregor | f40863c | 2010-02-12 07:32:17 +0000 | [diff] [blame] | 361 | return false; |
| 362 | } |
| 363 | |
Simon Pilgrim | 5fe64d2 | 2022-02-17 16:59:41 +0000 | [diff] [blame] | 364 | const auto *OldProto = Old->getType()->castAs<FunctionProtoType>(); |
Douglas Gregor | d6bc5e6 | 2010-03-24 07:14:45 +0000 | [diff] [blame] | 365 | |
Richard Smith | 8acb428 | 2014-07-31 21:57:55 +0000 | [diff] [blame] | 366 | FunctionProtoType::ExceptionSpecInfo ESI = OldProto->getExceptionSpecType(); |
| 367 | if (ESI.Type == EST_Dynamic) { |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 368 | // FIXME: What if the exceptions are described in terms of the old |
| 369 | // prototype's parameters? |
Richard Smith | 8acb428 | 2014-07-31 21:57:55 +0000 | [diff] [blame] | 370 | ESI.Exceptions = OldProto->exceptions(); |
Douglas Gregor | d6bc5e6 | 2010-03-24 07:14:45 +0000 | [diff] [blame] | 371 | } |
| 372 | |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 373 | if (ESI.Type == EST_NoexceptFalse) |
| 374 | ESI.Type = EST_None; |
| 375 | if (ESI.Type == EST_NoexceptTrue) |
| 376 | ESI.Type = EST_BasicNoexcept; |
| 377 | |
| 378 | // For dependent noexcept, we can't just take the expression from the old |
| 379 | // prototype. It likely contains references to the old prototype's parameters. |
| 380 | if (ESI.Type == EST_DependentNoexcept) { |
Richard Smith | a91de37 | 2015-09-30 00:48:50 +0000 | [diff] [blame] | 381 | New->setInvalidDecl(); |
| 382 | } else { |
| 383 | // Update the type of the function with the appropriate exception |
| 384 | // specification. |
| 385 | New->setType(Context.getFunctionType( |
| 386 | NewProto->getReturnType(), NewProto->getParamTypes(), |
| 387 | NewProto->getExtProtoInfo().withExceptionSpec(ESI))); |
| 388 | } |
| 389 | |
Amy Huang | 28d2977 | 2021-12-23 15:09:30 -0800 | [diff] [blame] | 390 | if (getLangOpts().MSVCCompat && isDynamicExceptionSpec(ESI.Type)) { |
| 391 | DiagID = diag::ext_missing_exception_specification; |
David Majnemer | 06ce8a4 | 2015-10-20 20:49:21 +0000 | [diff] [blame] | 392 | ReturnValueOnError = false; |
| 393 | } else if (New->isReplaceableGlobalAllocationFunction() && |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 394 | ESI.Type != EST_DependentNoexcept) { |
David Majnemer | 06ce8a4 | 2015-10-20 20:49:21 +0000 | [diff] [blame] | 395 | // Allow missing exception specifications in redeclarations as an extension, |
| 396 | // when declaring a replaceable global allocation function. |
Richard Smith | a91de37 | 2015-09-30 00:48:50 +0000 | [diff] [blame] | 397 | DiagID = diag::ext_missing_exception_specification; |
| 398 | ReturnValueOnError = false; |
Erich Keane | 54182eb | 2019-05-31 14:26:19 +0000 | [diff] [blame] | 399 | } else if (ESI.Type == EST_NoThrow) { |
Amy Huang | 28d2977 | 2021-12-23 15:09:30 -0800 | [diff] [blame] | 400 | // Don't emit any warning for missing 'nothrow' in MSVC. |
| 401 | if (getLangOpts().MSVCCompat) { |
| 402 | return false; |
| 403 | } |
Erich Keane | 54182eb | 2019-05-31 14:26:19 +0000 | [diff] [blame] | 404 | // Allow missing attribute 'nothrow' in redeclarations, since this is a very |
| 405 | // common omission. |
| 406 | DiagID = diag::ext_missing_exception_specification; |
| 407 | ReturnValueOnError = false; |
Richard Smith | a91de37 | 2015-09-30 00:48:50 +0000 | [diff] [blame] | 408 | } else { |
| 409 | DiagID = diag::err_missing_exception_specification; |
| 410 | ReturnValueOnError = true; |
| 411 | } |
Eli Friedman | 96dbf6f | 2013-06-25 00:46:32 +0000 | [diff] [blame] | 412 | |
| 413 | // Warn about the lack of exception specification. |
| 414 | SmallString<128> ExceptionSpecString; |
| 415 | llvm::raw_svector_ostream OS(ExceptionSpecString); |
| 416 | switch (OldProto->getExceptionSpecType()) { |
| 417 | case EST_DynamicNone: |
| 418 | OS << "throw()"; |
| 419 | break; |
| 420 | |
| 421 | case EST_Dynamic: { |
| 422 | OS << "throw("; |
| 423 | bool OnFirstException = true; |
Aaron Ballman | b088fbe | 2014-03-17 15:38:09 +0000 | [diff] [blame] | 424 | for (const auto &E : OldProto->exceptions()) { |
Eli Friedman | 96dbf6f | 2013-06-25 00:46:32 +0000 | [diff] [blame] | 425 | if (OnFirstException) |
| 426 | OnFirstException = false; |
| 427 | else |
| 428 | OS << ", "; |
Fangrui Song | 6907ce2 | 2018-07-30 19:24:48 +0000 | [diff] [blame] | 429 | |
Aaron Ballman | b088fbe | 2014-03-17 15:38:09 +0000 | [diff] [blame] | 430 | OS << E.getAsString(getPrintingPolicy()); |
Eli Friedman | 96dbf6f | 2013-06-25 00:46:32 +0000 | [diff] [blame] | 431 | } |
| 432 | OS << ")"; |
| 433 | break; |
| 434 | } |
| 435 | |
| 436 | case EST_BasicNoexcept: |
| 437 | OS << "noexcept"; |
| 438 | break; |
| 439 | |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 440 | case EST_DependentNoexcept: |
| 441 | case EST_NoexceptFalse: |
| 442 | case EST_NoexceptTrue: |
Eli Friedman | 96dbf6f | 2013-06-25 00:46:32 +0000 | [diff] [blame] | 443 | OS << "noexcept("; |
Richard Trieu | ddd01ce | 2014-06-09 22:53:25 +0000 | [diff] [blame] | 444 | assert(OldProto->getNoexceptExpr() != nullptr && "Expected non-null Expr"); |
Craig Topper | c3ec149 | 2014-05-26 06:22:03 +0000 | [diff] [blame] | 445 | OldProto->getNoexceptExpr()->printPretty(OS, nullptr, getPrintingPolicy()); |
Eli Friedman | 96dbf6f | 2013-06-25 00:46:32 +0000 | [diff] [blame] | 446 | OS << ")"; |
| 447 | break; |
Erich Keane | 54182eb | 2019-05-31 14:26:19 +0000 | [diff] [blame] | 448 | case EST_NoThrow: |
| 449 | OS <<"__attribute__((nothrow))"; |
| 450 | break; |
Erich Keane | 68fa6dd | 2019-05-31 17:00:48 +0000 | [diff] [blame] | 451 | case EST_None: |
| 452 | case EST_MSAny: |
| 453 | case EST_Unevaluated: |
| 454 | case EST_Uninstantiated: |
| 455 | case EST_Unparsed: |
Eli Friedman | 96dbf6f | 2013-06-25 00:46:32 +0000 | [diff] [blame] | 456 | llvm_unreachable("This spec type is compatible with none."); |
| 457 | } |
Eli Friedman | 96dbf6f | 2013-06-25 00:46:32 +0000 | [diff] [blame] | 458 | |
| 459 | SourceLocation FixItLoc; |
| 460 | if (TypeSourceInfo *TSInfo = New->getTypeSourceInfo()) { |
| 461 | TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens(); |
Richard Smith | a91de37 | 2015-09-30 00:48:50 +0000 | [diff] [blame] | 462 | // FIXME: Preserve enough information so that we can produce a correct fixit |
| 463 | // location when there is a trailing return type. |
| 464 | if (auto FTLoc = TL.getAs<FunctionProtoTypeLoc>()) |
| 465 | if (!FTLoc.getTypePtr()->hasTrailingReturn()) |
| 466 | FixItLoc = getLocForEndOfToken(FTLoc.getLocalRangeEnd()); |
Eli Friedman | 96dbf6f | 2013-06-25 00:46:32 +0000 | [diff] [blame] | 467 | } |
| 468 | |
| 469 | if (FixItLoc.isInvalid()) |
Richard Smith | a91de37 | 2015-09-30 00:48:50 +0000 | [diff] [blame] | 470 | Diag(New->getLocation(), DiagID) |
Eli Friedman | 96dbf6f | 2013-06-25 00:46:32 +0000 | [diff] [blame] | 471 | << New << OS.str(); |
| 472 | else { |
Richard Smith | a91de37 | 2015-09-30 00:48:50 +0000 | [diff] [blame] | 473 | Diag(New->getLocation(), DiagID) |
Eli Friedman | 96dbf6f | 2013-06-25 00:46:32 +0000 | [diff] [blame] | 474 | << New << OS.str() |
| 475 | << FixItHint::CreateInsertion(FixItLoc, " " + OS.str().str()); |
| 476 | } |
| 477 | |
Yaron Keren | 8b56366 | 2015-10-03 10:46:20 +0000 | [diff] [blame] | 478 | if (Old->getLocation().isValid()) |
Eli Friedman | 96dbf6f | 2013-06-25 00:46:32 +0000 | [diff] [blame] | 479 | Diag(Old->getLocation(), diag::note_previous_declaration); |
| 480 | |
Richard Smith | a91de37 | 2015-09-30 00:48:50 +0000 | [diff] [blame] | 481 | return ReturnValueOnError; |
Douglas Gregor | f40863c | 2010-02-12 07:32:17 +0000 | [diff] [blame] | 482 | } |
| 483 | |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 484 | bool Sema::CheckEquivalentExceptionSpec( |
| 485 | const FunctionProtoType *Old, SourceLocation OldLoc, |
| 486 | const FunctionProtoType *New, SourceLocation NewLoc) { |
Richard Smith | 13b40bc | 2016-11-30 00:13:55 +0000 | [diff] [blame] | 487 | if (!getLangOpts().CXXExceptions) |
| 488 | return false; |
| 489 | |
Francois Pichet | 13b4e68 | 2011-03-19 23:05:18 +0000 | [diff] [blame] | 490 | unsigned DiagID = diag::err_mismatched_exception_spec; |
Reid Kleckner | 39aa895 | 2019-08-27 17:52:03 +0000 | [diff] [blame] | 491 | if (getLangOpts().MSVCCompat) |
Richard Smith | 1b98ccc | 2014-07-19 01:39:17 +0000 | [diff] [blame] | 492 | DiagID = diag::ext_mismatched_exception_spec; |
Richard Smith | 13b40bc | 2016-11-30 00:13:55 +0000 | [diff] [blame] | 493 | bool Result = CheckEquivalentExceptionSpecImpl( |
| 494 | *this, PDiag(DiagID), PDiag(diag::note_previous_declaration), |
| 495 | Old, OldLoc, New, NewLoc); |
Hans Wennborg | 39a509a | 2014-02-05 02:37:58 +0000 | [diff] [blame] | 496 | |
| 497 | // In Microsoft mode, mismatching exception specifications just cause a warning. |
Reid Kleckner | 39aa895 | 2019-08-27 17:52:03 +0000 | [diff] [blame] | 498 | if (getLangOpts().MSVCCompat) |
Hans Wennborg | 39a509a | 2014-02-05 02:37:58 +0000 | [diff] [blame] | 499 | return false; |
| 500 | return Result; |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 501 | } |
| 502 | |
Sebastian Redl | fa453cf | 2011-03-12 11:50:43 +0000 | [diff] [blame] | 503 | /// CheckEquivalentExceptionSpec - Check if the two types have compatible |
| 504 | /// exception specifications. See C++ [except.spec]p3. |
Richard Smith | 66f3ac9 | 2012-10-20 08:26:51 +0000 | [diff] [blame] | 505 | /// |
| 506 | /// \return \c false if the exception specifications match, \c true if there is |
| 507 | /// a problem. If \c true is returned, either a diagnostic has already been |
| 508 | /// produced or \c *MissingExceptionSpecification is set to \c true. |
Richard Smith | 13b40bc | 2016-11-30 00:13:55 +0000 | [diff] [blame] | 509 | static bool CheckEquivalentExceptionSpecImpl( |
| 510 | Sema &S, const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, |
| 511 | const FunctionProtoType *Old, SourceLocation OldLoc, |
| 512 | const FunctionProtoType *New, SourceLocation NewLoc, |
| 513 | bool *MissingExceptionSpecification, |
| 514 | bool *MissingEmptyExceptionSpecification, |
| 515 | bool AllowNoexceptAllMatchWithNoSpec, bool IsOperatorNew) { |
Douglas Gregor | d6bc5e6 | 2010-03-24 07:14:45 +0000 | [diff] [blame] | 516 | if (MissingExceptionSpecification) |
| 517 | *MissingExceptionSpecification = false; |
| 518 | |
Douglas Gregor | f40863c | 2010-02-12 07:32:17 +0000 | [diff] [blame] | 519 | if (MissingEmptyExceptionSpecification) |
| 520 | *MissingEmptyExceptionSpecification = false; |
| 521 | |
Richard Smith | 13b40bc | 2016-11-30 00:13:55 +0000 | [diff] [blame] | 522 | Old = S.ResolveExceptionSpec(NewLoc, Old); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 523 | if (!Old) |
| 524 | return false; |
Richard Smith | 13b40bc | 2016-11-30 00:13:55 +0000 | [diff] [blame] | 525 | New = S.ResolveExceptionSpec(NewLoc, New); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 526 | if (!New) |
| 527 | return false; |
| 528 | |
Sebastian Redl | fa453cf | 2011-03-12 11:50:43 +0000 | [diff] [blame] | 529 | // C++0x [except.spec]p3: Two exception-specifications are compatible if: |
| 530 | // - both are non-throwing, regardless of their form, |
| 531 | // - both have the form noexcept(constant-expression) and the constant- |
| 532 | // expressions are equivalent, |
Sebastian Redl | fa453cf | 2011-03-12 11:50:43 +0000 | [diff] [blame] | 533 | // - both are dynamic-exception-specifications that have the same set of |
| 534 | // adjusted types. |
| 535 | // |
Eric Christopher | e6b7cf4 | 2015-07-10 18:25:52 +0000 | [diff] [blame] | 536 | // C++0x [except.spec]p12: An exception-specification is non-throwing if it is |
Sebastian Redl | fa453cf | 2011-03-12 11:50:43 +0000 | [diff] [blame] | 537 | // of the form throw(), noexcept, or noexcept(constant-expression) where the |
| 538 | // constant-expression yields true. |
| 539 | // |
Sebastian Redl | fa453cf | 2011-03-12 11:50:43 +0000 | [diff] [blame] | 540 | // C++0x [except.spec]p4: If any declaration of a function has an exception- |
| 541 | // specifier that is not a noexcept-specification allowing all exceptions, |
| 542 | // all declarations [...] of that function shall have a compatible |
| 543 | // exception-specification. |
| 544 | // |
| 545 | // That last point basically means that noexcept(false) matches no spec. |
| 546 | // It's considered when AllowNoexceptAllMatchWithNoSpec is true. |
| 547 | |
| 548 | ExceptionSpecificationType OldEST = Old->getExceptionSpecType(); |
| 549 | ExceptionSpecificationType NewEST = New->getExceptionSpecType(); |
| 550 | |
Richard Smith | d3b5c908 | 2012-07-27 04:22:15 +0000 | [diff] [blame] | 551 | assert(!isUnresolvedExceptionSpec(OldEST) && |
| 552 | !isUnresolvedExceptionSpec(NewEST) && |
Richard Smith | 938f40b | 2011-06-11 17:19:42 +0000 | [diff] [blame] | 553 | "Shouldn't see unknown exception specifications here"); |
| 554 | |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 555 | CanThrowResult OldCanThrow = Old->canThrow(); |
| 556 | CanThrowResult NewCanThrow = New->canThrow(); |
Sebastian Redl | fa453cf | 2011-03-12 11:50:43 +0000 | [diff] [blame] | 557 | |
| 558 | // Any non-throwing specifications are compatible. |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 559 | if (OldCanThrow == CT_Cannot && NewCanThrow == CT_Cannot) |
Sebastian Redl | fa453cf | 2011-03-12 11:50:43 +0000 | [diff] [blame] | 560 | return false; |
| 561 | |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 562 | // Any throws-anything specifications are usually compatible. |
| 563 | if (OldCanThrow == CT_Can && OldEST != EST_Dynamic && |
| 564 | NewCanThrow == CT_Can && NewEST != EST_Dynamic) { |
| 565 | // The exception is that the absence of an exception specification only |
| 566 | // matches noexcept(false) for functions, as described above. |
| 567 | if (!AllowNoexceptAllMatchWithNoSpec && |
| 568 | ((OldEST == EST_None && NewEST == EST_NoexceptFalse) || |
| 569 | (OldEST == EST_NoexceptFalse && NewEST == EST_None))) { |
| 570 | // This is the disallowed case. |
| 571 | } else { |
| 572 | return false; |
| 573 | } |
| 574 | } |
| 575 | |
Richard Smith | b64764a | 2018-07-12 21:11:25 +0000 | [diff] [blame] | 576 | // C++14 [except.spec]p3: |
| 577 | // Two exception-specifications are compatible if [...] both have the form |
| 578 | // noexcept(constant-expression) and the constant-expressions are equivalent |
| 579 | if (OldEST == EST_DependentNoexcept && NewEST == EST_DependentNoexcept) { |
| 580 | llvm::FoldingSetNodeID OldFSN, NewFSN; |
| 581 | Old->getNoexceptExpr()->Profile(OldFSN, S.Context, true); |
| 582 | New->getNoexceptExpr()->Profile(NewFSN, S.Context, true); |
| 583 | if (OldFSN == NewFSN) |
| 584 | return false; |
| 585 | } |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 586 | |
| 587 | // Dynamic exception specifications with the same set of adjusted types |
| 588 | // are compatible. |
| 589 | if (OldEST == EST_Dynamic && NewEST == EST_Dynamic) { |
| 590 | bool Success = true; |
| 591 | // Both have a dynamic exception spec. Collect the first set, then compare |
| 592 | // to the second. |
| 593 | llvm::SmallPtrSet<CanQualType, 8> OldTypes, NewTypes; |
| 594 | for (const auto &I : Old->exceptions()) |
| 595 | OldTypes.insert(S.Context.getCanonicalType(I).getUnqualifiedType()); |
| 596 | |
| 597 | for (const auto &I : New->exceptions()) { |
| 598 | CanQualType TypePtr = S.Context.getCanonicalType(I).getUnqualifiedType(); |
| 599 | if (OldTypes.count(TypePtr)) |
| 600 | NewTypes.insert(TypePtr); |
| 601 | else { |
| 602 | Success = false; |
| 603 | break; |
| 604 | } |
| 605 | } |
| 606 | |
| 607 | if (Success && OldTypes.size() == NewTypes.size()) |
| 608 | return false; |
| 609 | } |
| 610 | |
Sebastian Redl | cb5dd00 | 2011-03-15 19:52:30 +0000 | [diff] [blame] | 611 | // As a special compatibility feature, under C++0x we accept no spec and |
| 612 | // throw(std::bad_alloc) as equivalent for operator new and operator new[]. |
| 613 | // This is because the implicit declaration changed, but old code would break. |
Richard Smith | 13b40bc | 2016-11-30 00:13:55 +0000 | [diff] [blame] | 614 | if (S.getLangOpts().CPlusPlus11 && IsOperatorNew) { |
Craig Topper | c3ec149 | 2014-05-26 06:22:03 +0000 | [diff] [blame] | 615 | const FunctionProtoType *WithExceptions = nullptr; |
Sebastian Redl | cb5dd00 | 2011-03-15 19:52:30 +0000 | [diff] [blame] | 616 | if (OldEST == EST_None && NewEST == EST_Dynamic) |
| 617 | WithExceptions = New; |
| 618 | else if (OldEST == EST_Dynamic && NewEST == EST_None) |
| 619 | WithExceptions = Old; |
| 620 | if (WithExceptions && WithExceptions->getNumExceptions() == 1) { |
| 621 | // One has no spec, the other throw(something). If that something is |
| 622 | // std::bad_alloc, all conditions are met. |
| 623 | QualType Exception = *WithExceptions->exception_begin(); |
| 624 | if (CXXRecordDecl *ExRecord = Exception->getAsCXXRecordDecl()) { |
| 625 | IdentifierInfo* Name = ExRecord->getIdentifier(); |
| 626 | if (Name && Name->getName() == "bad_alloc") { |
| 627 | // It's called bad_alloc, but is it in std? |
Richard Trieu | c771d5d | 2014-05-28 02:16:01 +0000 | [diff] [blame] | 628 | if (ExRecord->isInStdNamespace()) { |
| 629 | return false; |
Sebastian Redl | cb5dd00 | 2011-03-15 19:52:30 +0000 | [diff] [blame] | 630 | } |
| 631 | } |
| 632 | } |
| 633 | } |
| 634 | } |
| 635 | |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 636 | // If the caller wants to handle the case that the new function is |
| 637 | // incompatible due to a missing exception specification, let it. |
| 638 | if (MissingExceptionSpecification && OldEST != EST_None && |
| 639 | NewEST == EST_None) { |
| 640 | // The old type has an exception specification of some sort, but |
| 641 | // the new type does not. |
| 642 | *MissingExceptionSpecification = true; |
Douglas Gregor | d6bc5e6 | 2010-03-24 07:14:45 +0000 | [diff] [blame] | 643 | |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 644 | if (MissingEmptyExceptionSpecification && OldCanThrow == CT_Cannot) { |
| 645 | // The old type has a throw() or noexcept(true) exception specification |
| 646 | // and the new type has no exception specification, and the caller asked |
| 647 | // to handle this itself. |
| 648 | *MissingEmptyExceptionSpecification = true; |
Douglas Gregor | f40863c | 2010-02-12 07:32:17 +0000 | [diff] [blame] | 649 | } |
| 650 | |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 651 | return true; |
| 652 | } |
| 653 | |
Richard Smith | 13b40bc | 2016-11-30 00:13:55 +0000 | [diff] [blame] | 654 | S.Diag(NewLoc, DiagID); |
David Majnemer | 7da2302 | 2015-02-19 07:28:55 +0000 | [diff] [blame] | 655 | if (NoteID.getDiagID() != 0 && OldLoc.isValid()) |
Richard Smith | 13b40bc | 2016-11-30 00:13:55 +0000 | [diff] [blame] | 656 | S.Diag(OldLoc, NoteID); |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 657 | return true; |
| 658 | } |
| 659 | |
Richard Smith | 13b40bc | 2016-11-30 00:13:55 +0000 | [diff] [blame] | 660 | bool Sema::CheckEquivalentExceptionSpec(const PartialDiagnostic &DiagID, |
| 661 | const PartialDiagnostic &NoteID, |
| 662 | const FunctionProtoType *Old, |
| 663 | SourceLocation OldLoc, |
| 664 | const FunctionProtoType *New, |
| 665 | SourceLocation NewLoc) { |
| 666 | if (!getLangOpts().CXXExceptions) |
| 667 | return false; |
| 668 | return CheckEquivalentExceptionSpecImpl(*this, DiagID, NoteID, Old, OldLoc, |
| 669 | New, NewLoc); |
| 670 | } |
| 671 | |
Richard Smith | 56ae0a6 | 2018-01-13 05:05:45 +0000 | [diff] [blame] | 672 | bool Sema::handlerCanCatch(QualType HandlerType, QualType ExceptionType) { |
| 673 | // [except.handle]p3: |
| 674 | // A handler is a match for an exception object of type E if: |
| 675 | |
| 676 | // HandlerType must be ExceptionType or derived from it, or pointer or |
| 677 | // reference to such types. |
| 678 | const ReferenceType *RefTy = HandlerType->getAs<ReferenceType>(); |
| 679 | if (RefTy) |
| 680 | HandlerType = RefTy->getPointeeType(); |
| 681 | |
| 682 | // -- the handler is of type cv T or cv T& and E and T are the same type |
| 683 | if (Context.hasSameUnqualifiedType(ExceptionType, HandlerType)) |
| 684 | return true; |
| 685 | |
| 686 | // FIXME: ObjC pointer types? |
| 687 | if (HandlerType->isPointerType() || HandlerType->isMemberPointerType()) { |
| 688 | if (RefTy && (!HandlerType.isConstQualified() || |
| 689 | HandlerType.isVolatileQualified())) |
| 690 | return false; |
| 691 | |
| 692 | // -- the handler is of type cv T or const T& where T is a pointer or |
| 693 | // pointer to member type and E is std::nullptr_t |
| 694 | if (ExceptionType->isNullPtrType()) |
| 695 | return true; |
| 696 | |
| 697 | // -- the handler is of type cv T or const T& where T is a pointer or |
| 698 | // pointer to member type and E is a pointer or pointer to member type |
| 699 | // that can be converted to T by one or more of |
| 700 | // -- a qualification conversion |
| 701 | // -- a function pointer conversion |
| 702 | bool LifetimeConv; |
| 703 | QualType Result; |
| 704 | // FIXME: Should we treat the exception as catchable if a lifetime |
| 705 | // conversion is required? |
| 706 | if (IsQualificationConversion(ExceptionType, HandlerType, false, |
| 707 | LifetimeConv) || |
| 708 | IsFunctionConversion(ExceptionType, HandlerType, Result)) |
| 709 | return true; |
| 710 | |
| 711 | // -- a standard pointer conversion [...] |
| 712 | if (!ExceptionType->isPointerType() || !HandlerType->isPointerType()) |
| 713 | return false; |
| 714 | |
| 715 | // Handle the "qualification conversion" portion. |
| 716 | Qualifiers EQuals, HQuals; |
| 717 | ExceptionType = Context.getUnqualifiedArrayType( |
| 718 | ExceptionType->getPointeeType(), EQuals); |
Joseph Huber | b9d678d | 2024-11-15 06:58:36 -0600 | [diff] [blame] | 719 | HandlerType = |
| 720 | Context.getUnqualifiedArrayType(HandlerType->getPointeeType(), HQuals); |
| 721 | if (!HQuals.compatiblyIncludes(EQuals, getASTContext())) |
Richard Smith | 56ae0a6 | 2018-01-13 05:05:45 +0000 | [diff] [blame] | 722 | return false; |
| 723 | |
| 724 | if (HandlerType->isVoidType() && ExceptionType->isObjectType()) |
| 725 | return true; |
| 726 | |
| 727 | // The only remaining case is a derived-to-base conversion. |
| 728 | } |
| 729 | |
| 730 | // -- the handler is of type cg T or cv T& and T is an unambiguous public |
| 731 | // base class of E |
| 732 | if (!ExceptionType->isRecordType() || !HandlerType->isRecordType()) |
| 733 | return false; |
| 734 | CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, |
| 735 | /*DetectVirtual=*/false); |
| 736 | if (!IsDerivedFrom(SourceLocation(), ExceptionType, HandlerType, Paths) || |
| 737 | Paths.isAmbiguous(Context.getCanonicalType(HandlerType))) |
| 738 | return false; |
| 739 | |
| 740 | // Do this check from a context without privileges. |
| 741 | switch (CheckBaseClassAccess(SourceLocation(), HandlerType, ExceptionType, |
| 742 | Paths.front(), |
| 743 | /*Diagnostic*/ 0, |
| 744 | /*ForceCheck*/ true, |
| 745 | /*ForceUnprivileged*/ true)) { |
| 746 | case AR_accessible: return true; |
| 747 | case AR_inaccessible: return false; |
| 748 | case AR_dependent: |
| 749 | llvm_unreachable("access check dependent for unprivileged context"); |
| 750 | case AR_delayed: |
| 751 | llvm_unreachable("access check delayed in non-declaration"); |
| 752 | } |
| 753 | llvm_unreachable("unexpected access check result"); |
| 754 | } |
| 755 | |
Corentin Jabot | af47517 | 2022-01-27 13:55:08 +0100 | [diff] [blame] | 756 | bool Sema::CheckExceptionSpecSubset( |
| 757 | const PartialDiagnostic &DiagID, const PartialDiagnostic &NestedDiagID, |
| 758 | const PartialDiagnostic &NoteID, const PartialDiagnostic &NoThrowDiagID, |
| 759 | const FunctionProtoType *Superset, bool SkipSupersetFirstParameter, |
| 760 | SourceLocation SuperLoc, const FunctionProtoType *Subset, |
| 761 | bool SkipSubsetFirstParameter, SourceLocation SubLoc) { |
John McCall | f9c9409 | 2010-05-28 08:37:35 +0000 | [diff] [blame] | 762 | |
| 763 | // Just auto-succeed under -fno-exceptions. |
David Blaikie | bbafb8a | 2012-03-11 07:00:24 +0000 | [diff] [blame] | 764 | if (!getLangOpts().CXXExceptions) |
John McCall | f9c9409 | 2010-05-28 08:37:35 +0000 | [diff] [blame] | 765 | return false; |
| 766 | |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 767 | // FIXME: As usual, we could be more specific in our error messages, but |
| 768 | // that better waits until we've got types with source locations. |
| 769 | |
| 770 | if (!SubLoc.isValid()) |
| 771 | SubLoc = SuperLoc; |
| 772 | |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 773 | // Resolve the exception specifications, if needed. |
| 774 | Superset = ResolveExceptionSpec(SuperLoc, Superset); |
| 775 | if (!Superset) |
| 776 | return false; |
| 777 | Subset = ResolveExceptionSpec(SubLoc, Subset); |
| 778 | if (!Subset) |
| 779 | return false; |
| 780 | |
Sebastian Redl | fa453cf | 2011-03-12 11:50:43 +0000 | [diff] [blame] | 781 | ExceptionSpecificationType SuperEST = Superset->getExceptionSpecType(); |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 782 | ExceptionSpecificationType SubEST = Subset->getExceptionSpecType(); |
| 783 | assert(!isUnresolvedExceptionSpec(SuperEST) && |
| 784 | !isUnresolvedExceptionSpec(SubEST) && |
| 785 | "Shouldn't see unknown exception specifications here"); |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 786 | |
Sebastian Redl | fa453cf | 2011-03-12 11:50:43 +0000 | [diff] [blame] | 787 | // If there are dependent noexcept specs, assume everything is fine. Unlike |
| 788 | // with the equivalency check, this is safe in this case, because we don't |
| 789 | // want to merge declarations. Checks after instantiation will catch any |
| 790 | // omissions we make here. |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 791 | if (SuperEST == EST_DependentNoexcept || SubEST == EST_DependentNoexcept) |
Sebastian Redl | fa453cf | 2011-03-12 11:50:43 +0000 | [diff] [blame] | 792 | return false; |
| 793 | |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 794 | CanThrowResult SuperCanThrow = Superset->canThrow(); |
| 795 | CanThrowResult SubCanThrow = Subset->canThrow(); |
| 796 | |
| 797 | // If the superset contains everything or the subset contains nothing, we're |
| 798 | // done. |
| 799 | if ((SuperCanThrow == CT_Can && SuperEST != EST_Dynamic) || |
| 800 | SubCanThrow == CT_Cannot) |
Corentin Jabot | af47517 | 2022-01-27 13:55:08 +0100 | [diff] [blame] | 801 | return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, |
| 802 | SkipSupersetFirstParameter, SuperLoc, Subset, |
| 803 | SkipSubsetFirstParameter, SubLoc); |
Sebastian Redl | fa453cf | 2011-03-12 11:50:43 +0000 | [diff] [blame] | 804 | |
Erich Keane | 81ef625 | 2019-06-03 18:36:26 +0000 | [diff] [blame] | 805 | // Allow __declspec(nothrow) to be missing on redeclaration as an extension in |
| 806 | // some cases. |
| 807 | if (NoThrowDiagID.getDiagID() != 0 && SubCanThrow == CT_Can && |
| 808 | SuperCanThrow == CT_Cannot && SuperEST == EST_NoThrow) { |
| 809 | Diag(SubLoc, NoThrowDiagID); |
| 810 | if (NoteID.getDiagID() != 0) |
| 811 | Diag(SuperLoc, NoteID); |
| 812 | return true; |
| 813 | } |
| 814 | |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 815 | // If the subset contains everything or the superset contains nothing, we've |
| 816 | // failed. |
| 817 | if ((SubCanThrow == CT_Can && SubEST != EST_Dynamic) || |
| 818 | SuperCanThrow == CT_Cannot) { |
Sebastian Redl | fa453cf | 2011-03-12 11:50:43 +0000 | [diff] [blame] | 819 | Diag(SubLoc, DiagID); |
| 820 | if (NoteID.getDiagID() != 0) |
| 821 | Diag(SuperLoc, NoteID); |
| 822 | return true; |
| 823 | } |
| 824 | |
| 825 | assert(SuperEST == EST_Dynamic && SubEST == EST_Dynamic && |
| 826 | "Exception spec subset: non-dynamic case slipped through."); |
| 827 | |
| 828 | // Neither contains everything or nothing. Do a proper comparison. |
Richard Smith | 56ae0a6 | 2018-01-13 05:05:45 +0000 | [diff] [blame] | 829 | for (QualType SubI : Subset->exceptions()) { |
| 830 | if (const ReferenceType *RefTy = SubI->getAs<ReferenceType>()) |
| 831 | SubI = RefTy->getPointeeType(); |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 832 | |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 833 | // Make sure it's in the superset. |
Richard Smith | 56ae0a6 | 2018-01-13 05:05:45 +0000 | [diff] [blame] | 834 | bool Contained = false; |
| 835 | for (QualType SuperI : Superset->exceptions()) { |
| 836 | // [except.spec]p5: |
| 837 | // the target entity shall allow at least the exceptions allowed by the |
| 838 | // source |
| 839 | // |
| 840 | // We interpret this as meaning that a handler for some target type would |
| 841 | // catch an exception of each source type. |
| 842 | if (handlerCanCatch(SuperI, SubI)) { |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 843 | Contained = true; |
| 844 | break; |
| 845 | } |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 846 | } |
| 847 | if (!Contained) { |
| 848 | Diag(SubLoc, DiagID); |
Sebastian Redl | a44822f | 2009-10-14 16:09:29 +0000 | [diff] [blame] | 849 | if (NoteID.getDiagID() != 0) |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 850 | Diag(SuperLoc, NoteID); |
| 851 | return true; |
| 852 | } |
| 853 | } |
| 854 | // We've run half the gauntlet. |
Corentin Jabot | af47517 | 2022-01-27 13:55:08 +0100 | [diff] [blame] | 855 | return CheckParamExceptionSpec(NestedDiagID, NoteID, Superset, |
| 856 | SkipSupersetFirstParameter, SuperLoc, Subset, |
| 857 | SkipSupersetFirstParameter, SubLoc); |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 858 | } |
| 859 | |
Richard Smith | 1be59c5 | 2016-10-22 01:32:19 +0000 | [diff] [blame] | 860 | static bool |
| 861 | CheckSpecForTypesEquivalent(Sema &S, const PartialDiagnostic &DiagID, |
| 862 | const PartialDiagnostic &NoteID, QualType Target, |
| 863 | SourceLocation TargetLoc, QualType Source, |
| 864 | SourceLocation SourceLoc) { |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 865 | const FunctionProtoType *TFunc = GetUnderlyingFunction(Target); |
| 866 | if (!TFunc) |
| 867 | return false; |
| 868 | const FunctionProtoType *SFunc = GetUnderlyingFunction(Source); |
| 869 | if (!SFunc) |
| 870 | return false; |
| 871 | |
| 872 | return S.CheckEquivalentExceptionSpec(DiagID, NoteID, TFunc, TargetLoc, |
| 873 | SFunc, SourceLoc); |
| 874 | } |
| 875 | |
Corentin Jabot | af47517 | 2022-01-27 13:55:08 +0100 | [diff] [blame] | 876 | bool Sema::CheckParamExceptionSpec( |
| 877 | const PartialDiagnostic &DiagID, const PartialDiagnostic &NoteID, |
| 878 | const FunctionProtoType *Target, bool SkipTargetFirstParameter, |
| 879 | SourceLocation TargetLoc, const FunctionProtoType *Source, |
| 880 | bool SkipSourceFirstParameter, SourceLocation SourceLoc) { |
Richard Smith | 1be59c5 | 2016-10-22 01:32:19 +0000 | [diff] [blame] | 881 | auto RetDiag = DiagID; |
| 882 | RetDiag << 0; |
Alp Toker | 314cc81 | 2014-01-25 16:55:45 +0000 | [diff] [blame] | 883 | if (CheckSpecForTypesEquivalent( |
Richard Smith | 1be59c5 | 2016-10-22 01:32:19 +0000 | [diff] [blame] | 884 | *this, RetDiag, PDiag(), |
Alp Toker | 314cc81 | 2014-01-25 16:55:45 +0000 | [diff] [blame] | 885 | Target->getReturnType(), TargetLoc, Source->getReturnType(), |
| 886 | SourceLoc)) |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 887 | return true; |
| 888 | |
Sebastian Redl | a44822f | 2009-10-14 16:09:29 +0000 | [diff] [blame] | 889 | // We shouldn't even be testing this unless the arguments are otherwise |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 890 | // compatible. |
Corentin Jabot | af47517 | 2022-01-27 13:55:08 +0100 | [diff] [blame] | 891 | assert((Target->getNumParams() - (unsigned)SkipTargetFirstParameter) == |
| 892 | (Source->getNumParams() - (unsigned)SkipSourceFirstParameter) && |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 893 | "Functions have different argument counts."); |
Alp Toker | 9cacbab | 2014-01-20 20:26:09 +0000 | [diff] [blame] | 894 | for (unsigned i = 0, E = Target->getNumParams(); i != E; ++i) { |
Richard Smith | 1be59c5 | 2016-10-22 01:32:19 +0000 | [diff] [blame] | 895 | auto ParamDiag = DiagID; |
| 896 | ParamDiag << 1; |
Alp Toker | 9cacbab | 2014-01-20 20:26:09 +0000 | [diff] [blame] | 897 | if (CheckSpecForTypesEquivalent( |
Richard Smith | 1be59c5 | 2016-10-22 01:32:19 +0000 | [diff] [blame] | 898 | *this, ParamDiag, PDiag(), |
Corentin Jabot | af47517 | 2022-01-27 13:55:08 +0100 | [diff] [blame] | 899 | Target->getParamType(i + (SkipTargetFirstParameter ? 1 : 0)), |
| 900 | TargetLoc, Source->getParamType(SkipSourceFirstParameter ? 1 : 0), |
Alp Toker | 9cacbab | 2014-01-20 20:26:09 +0000 | [diff] [blame] | 901 | SourceLoc)) |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 902 | return true; |
| 903 | } |
| 904 | return false; |
| 905 | } |
| 906 | |
Richard Smith | 2e32155 | 2014-11-12 02:00:47 +0000 | [diff] [blame] | 907 | bool Sema::CheckExceptionSpecCompatibility(Expr *From, QualType ToType) { |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 908 | // First we check for applicability. |
| 909 | // Target type must be a function, function pointer or function reference. |
| 910 | const FunctionProtoType *ToFunc = GetUnderlyingFunction(ToType); |
Richard Smith | 2e32155 | 2014-11-12 02:00:47 +0000 | [diff] [blame] | 911 | if (!ToFunc || ToFunc->hasDependentExceptionSpec()) |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 912 | return false; |
| 913 | |
| 914 | // SourceType must be a function or function pointer. |
| 915 | const FunctionProtoType *FromFunc = GetUnderlyingFunction(From->getType()); |
Richard Smith | 2e32155 | 2014-11-12 02:00:47 +0000 | [diff] [blame] | 916 | if (!FromFunc || FromFunc->hasDependentExceptionSpec()) |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 917 | return false; |
| 918 | |
Richard Smith | 1be59c5 | 2016-10-22 01:32:19 +0000 | [diff] [blame] | 919 | unsigned DiagID = diag::err_incompatible_exception_specs; |
| 920 | unsigned NestedDiagID = diag::err_deep_exception_specs_differ; |
| 921 | // This is not an error in C++17 onwards, unless the noexceptness doesn't |
| 922 | // match, but in that case we have a full-on type mismatch, not just a |
| 923 | // type sugar mismatch. |
Aaron Ballman | c351fba | 2017-12-04 20:27:34 +0000 | [diff] [blame] | 924 | if (getLangOpts().CPlusPlus17) { |
Richard Smith | 1be59c5 | 2016-10-22 01:32:19 +0000 | [diff] [blame] | 925 | DiagID = diag::warn_incompatible_exception_specs; |
| 926 | NestedDiagID = diag::warn_deep_exception_specs_differ; |
| 927 | } |
| 928 | |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 929 | // Now we've got the correct types on both sides, check their compatibility. |
| 930 | // This means that the source of the conversion can only throw a subset of |
| 931 | // the exceptions of the target, and any exception specs on arguments or |
| 932 | // return types must be equivalent. |
Richard Smith | 2e32155 | 2014-11-12 02:00:47 +0000 | [diff] [blame] | 933 | // |
| 934 | // FIXME: If there is a nested dependent exception specification, we should |
| 935 | // not be checking it here. This is fine: |
| 936 | // template<typename T> void f() { |
| 937 | // void (*p)(void (*) throw(T)); |
| 938 | // void (*q)(void (*) throw(int)) = p; |
| 939 | // } |
| 940 | // ... because it might be instantiated with T=int. |
Corentin Jabot | af47517 | 2022-01-27 13:55:08 +0100 | [diff] [blame] | 941 | return CheckExceptionSpecSubset(PDiag(DiagID), PDiag(NestedDiagID), PDiag(), |
| 942 | PDiag(), ToFunc, 0, |
| 943 | From->getSourceRange().getBegin(), FromFunc, |
| 944 | 0, SourceLocation()) && |
Aaron Ballman | c351fba | 2017-12-04 20:27:34 +0000 | [diff] [blame] | 945 | !getLangOpts().CPlusPlus17; |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 946 | } |
| 947 | |
| 948 | bool Sema::CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, |
| 949 | const CXXMethodDecl *Old) { |
Richard Smith | 88f4549 | 2014-11-22 03:09:05 +0000 | [diff] [blame] | 950 | // If the new exception specification hasn't been parsed yet, skip the check. |
| 951 | // We'll get called again once it's been parsed. |
| 952 | if (New->getType()->castAs<FunctionProtoType>()->getExceptionSpecType() == |
| 953 | EST_Unparsed) |
| 954 | return false; |
Richard Smith | 5159bbad | 2018-09-05 22:30:37 +0000 | [diff] [blame] | 955 | |
| 956 | // Don't check uninstantiated template destructors at all. We can only |
| 957 | // synthesize correct specs after the template is instantiated. |
| 958 | if (isa<CXXDestructorDecl>(New) && New->getParent()->isDependentType()) |
| 959 | return false; |
| 960 | |
| 961 | // If the old exception specification hasn't been parsed yet, or the new |
| 962 | // exception specification can't be computed yet, remember that we need to |
| 963 | // perform this check when we get to the end of the outermost |
Richard Smith | 88f4549 | 2014-11-22 03:09:05 +0000 | [diff] [blame] | 964 | // lexically-surrounding class. |
Richard Smith | 5159bbad | 2018-09-05 22:30:37 +0000 | [diff] [blame] | 965 | if (exceptionSpecNotKnownYet(Old) || exceptionSpecNotKnownYet(New)) { |
| 966 | DelayedOverridingExceptionSpecChecks.push_back({New, Old}); |
Richard Smith | 0b3a462 | 2014-11-13 20:01:57 +0000 | [diff] [blame] | 967 | return false; |
Richard Smith | 88f4549 | 2014-11-22 03:09:05 +0000 | [diff] [blame] | 968 | } |
Richard Smith | 5159bbad | 2018-09-05 22:30:37 +0000 | [diff] [blame] | 969 | |
Francois Pichet | a8032e9 | 2011-05-24 02:11:43 +0000 | [diff] [blame] | 970 | unsigned DiagID = diag::err_override_exception_spec; |
Reid Kleckner | 39aa895 | 2019-08-27 17:52:03 +0000 | [diff] [blame] | 971 | if (getLangOpts().MSVCCompat) |
Richard Smith | 1b98ccc | 2014-07-19 01:39:17 +0000 | [diff] [blame] | 972 | DiagID = diag::ext_override_exception_spec; |
Corentin Jabot | af47517 | 2022-01-27 13:55:08 +0100 | [diff] [blame] | 973 | return CheckExceptionSpecSubset( |
| 974 | PDiag(DiagID), PDiag(diag::err_deep_exception_specs_differ), |
| 975 | PDiag(diag::note_overridden_virtual_function), |
| 976 | PDiag(diag::ext_override_exception_spec), |
| 977 | Old->getType()->castAs<FunctionProtoType>(), |
| 978 | Old->hasCXXExplicitFunctionObjectParameter(), Old->getLocation(), |
| 979 | New->getType()->castAs<FunctionProtoType>(), |
| 980 | New->hasCXXExplicitFunctionObjectParameter(), New->getLocation()); |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 981 | } |
| 982 | |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 983 | static CanThrowResult canSubStmtsThrow(Sema &Self, const Stmt *S) { |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 984 | CanThrowResult R = CT_Cannot; |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 985 | for (const Stmt *SubStmt : S->children()) { |
| 986 | if (!SubStmt) |
| 987 | continue; |
| 988 | R = mergeCanThrow(R, Self.canThrow(SubStmt)); |
Benjamin Kramer | 642f173 | 2015-07-02 21:03:14 +0000 | [diff] [blame] | 989 | if (R == CT_Can) |
| 990 | break; |
| 991 | } |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 992 | return R; |
| 993 | } |
| 994 | |
Xun Li | 516803d | 2020-06-15 16:27:41 -0700 | [diff] [blame] | 995 | CanThrowResult Sema::canCalleeThrow(Sema &S, const Expr *E, const Decl *D, |
| 996 | SourceLocation Loc) { |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 997 | // As an extension, we assume that __attribute__((nothrow)) functions don't |
| 998 | // throw. |
ZERO-N | 28e30b4 | 2024-03-07 00:07:15 +0800 | [diff] [blame] | 999 | if (isa_and_nonnull<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>()) |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1000 | return CT_Cannot; |
| 1001 | |
Richard Smith | 3a8f13a | 2016-12-03 00:29:06 +0000 | [diff] [blame] | 1002 | QualType T; |
| 1003 | |
| 1004 | // In C++1z, just look at the function type of the callee. |
ZERO-N | 28e30b4 | 2024-03-07 00:07:15 +0800 | [diff] [blame] | 1005 | if (S.getLangOpts().CPlusPlus17 && isa_and_nonnull<CallExpr>(E)) { |
Richard Smith | 3a8f13a | 2016-12-03 00:29:06 +0000 | [diff] [blame] | 1006 | E = cast<CallExpr>(E)->getCallee(); |
| 1007 | T = E->getType(); |
| 1008 | if (T->isSpecificPlaceholderType(BuiltinType::BoundMember)) { |
| 1009 | // Sadly we don't preserve the actual type as part of the "bound member" |
| 1010 | // placeholder, so we need to reconstruct it. |
| 1011 | E = E->IgnoreParenImpCasts(); |
| 1012 | |
| 1013 | // Could be a call to a pointer-to-member or a plain member access. |
| 1014 | if (auto *Op = dyn_cast<BinaryOperator>(E)) { |
| 1015 | assert(Op->getOpcode() == BO_PtrMemD || Op->getOpcode() == BO_PtrMemI); |
| 1016 | T = Op->getRHS()->getType() |
| 1017 | ->castAs<MemberPointerType>()->getPointeeType(); |
| 1018 | } else { |
| 1019 | T = cast<MemberExpr>(E)->getMemberDecl()->getType(); |
| 1020 | } |
| 1021 | } |
| 1022 | } else if (const ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D)) |
| 1023 | T = VD->getType(); |
| 1024 | else |
| 1025 | // If we have no clue what we're calling, assume the worst. |
| 1026 | return CT_Can; |
| 1027 | |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1028 | const FunctionProtoType *FT; |
| 1029 | if ((FT = T->getAs<FunctionProtoType>())) { |
| 1030 | } else if (const PointerType *PT = T->getAs<PointerType>()) |
| 1031 | FT = PT->getPointeeType()->getAs<FunctionProtoType>(); |
| 1032 | else if (const ReferenceType *RT = T->getAs<ReferenceType>()) |
| 1033 | FT = RT->getPointeeType()->getAs<FunctionProtoType>(); |
| 1034 | else if (const MemberPointerType *MT = T->getAs<MemberPointerType>()) |
| 1035 | FT = MT->getPointeeType()->getAs<FunctionProtoType>(); |
| 1036 | else if (const BlockPointerType *BT = T->getAs<BlockPointerType>()) |
| 1037 | FT = BT->getPointeeType()->getAs<FunctionProtoType>(); |
| 1038 | |
| 1039 | if (!FT) |
| 1040 | return CT_Can; |
| 1041 | |
Xun Li | 516803d | 2020-06-15 16:27:41 -0700 | [diff] [blame] | 1042 | if (Loc.isValid() || (Loc.isInvalid() && E)) |
| 1043 | FT = S.ResolveExceptionSpec(Loc.isInvalid() ? E->getBeginLoc() : Loc, FT); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1044 | if (!FT) |
| 1045 | return CT_Can; |
| 1046 | |
Richard Smith | eaf11ad | 2018-05-03 03:58:32 +0000 | [diff] [blame] | 1047 | return FT->canThrow(); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1048 | } |
| 1049 | |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1050 | static CanThrowResult canVarDeclThrow(Sema &Self, const VarDecl *VD) { |
| 1051 | CanThrowResult CT = CT_Cannot; |
| 1052 | |
| 1053 | // Initialization might throw. |
| 1054 | if (!VD->isUsableInConstantExpressions(Self.Context)) |
| 1055 | if (const Expr *Init = VD->getInit()) |
| 1056 | CT = mergeCanThrow(CT, Self.canThrow(Init)); |
| 1057 | |
| 1058 | // Destructor might throw. |
| 1059 | if (VD->needsDestruction(Self.Context) == QualType::DK_cxx_destructor) { |
| 1060 | if (auto *RD = |
| 1061 | VD->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) { |
| 1062 | if (auto *Dtor = RD->getDestructor()) { |
| 1063 | CT = mergeCanThrow( |
Xun Li | 516803d | 2020-06-15 16:27:41 -0700 | [diff] [blame] | 1064 | CT, Sema::canCalleeThrow(Self, nullptr, Dtor, VD->getLocation())); |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1065 | } |
| 1066 | } |
| 1067 | } |
| 1068 | |
| 1069 | // If this is a decomposition declaration, bindings might throw. |
| 1070 | if (auto *DD = dyn_cast<DecompositionDecl>(VD)) |
Jason Rice | abc8812 | 2025-01-29 12:43:52 -0800 | [diff] [blame] | 1071 | for (auto *B : DD->flat_bindings()) |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1072 | if (auto *HD = B->getHoldingVar()) |
| 1073 | CT = mergeCanThrow(CT, canVarDeclThrow(Self, HD)); |
| 1074 | |
| 1075 | return CT; |
| 1076 | } |
| 1077 | |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1078 | static CanThrowResult canDynamicCastThrow(const CXXDynamicCastExpr *DC) { |
| 1079 | if (DC->isTypeDependent()) |
| 1080 | return CT_Dependent; |
| 1081 | |
| 1082 | if (!DC->getTypeAsWritten()->isReferenceType()) |
| 1083 | return CT_Cannot; |
| 1084 | |
| 1085 | if (DC->getSubExpr()->isTypeDependent()) |
| 1086 | return CT_Dependent; |
| 1087 | |
| 1088 | return DC->getCastKind() == clang::CK_Dynamic? CT_Can : CT_Cannot; |
| 1089 | } |
| 1090 | |
| 1091 | static CanThrowResult canTypeidThrow(Sema &S, const CXXTypeidExpr *DC) { |
Mital Ashok | b608b22 | 2024-06-20 14:43:14 +0100 | [diff] [blame] | 1092 | // A typeid of a type is a constant and does not throw. |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1093 | if (DC->isTypeOperand()) |
| 1094 | return CT_Cannot; |
| 1095 | |
Mital Ashok | 3ad31e1 | 2024-06-17 18:31:54 +0100 | [diff] [blame] | 1096 | if (DC->isValueDependent()) |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1097 | return CT_Dependent; |
| 1098 | |
Mital Ashok | b608b22 | 2024-06-20 14:43:14 +0100 | [diff] [blame] | 1099 | // If this operand is not evaluated it cannot possibly throw. |
| 1100 | if (!DC->isPotentiallyEvaluated()) |
| 1101 | return CT_Cannot; |
| 1102 | |
| 1103 | // Can throw std::bad_typeid if a nullptr is dereferenced. |
| 1104 | if (DC->hasNullCheck()) |
| 1105 | return CT_Can; |
| 1106 | |
| 1107 | return S.canThrow(DC->getExprOperand()); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1108 | } |
| 1109 | |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1110 | CanThrowResult Sema::canThrow(const Stmt *S) { |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1111 | // C++ [expr.unary.noexcept]p3: |
| 1112 | // [Can throw] if in a potentially-evaluated context the expression would |
| 1113 | // contain: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1114 | switch (S->getStmtClass()) { |
Bill Wendling | 7c44da2 | 2018-10-31 03:48:47 +0000 | [diff] [blame] | 1115 | case Expr::ConstantExprClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1116 | return canThrow(cast<ConstantExpr>(S)->getSubExpr()); |
Bill Wendling | 7c44da2 | 2018-10-31 03:48:47 +0000 | [diff] [blame] | 1117 | |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1118 | case Expr::CXXThrowExprClass: |
| 1119 | // - a potentially evaluated throw-expression |
| 1120 | return CT_Can; |
| 1121 | |
| 1122 | case Expr::CXXDynamicCastExprClass: { |
| 1123 | // - a potentially evaluated dynamic_cast expression dynamic_cast<T>(v), |
| 1124 | // where T is a reference type, that requires a run-time check |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1125 | auto *CE = cast<CXXDynamicCastExpr>(S); |
| 1126 | // FIXME: Properly determine whether a variably-modified type can throw. |
| 1127 | if (CE->getType()->isVariablyModifiedType()) |
| 1128 | return CT_Can; |
| 1129 | CanThrowResult CT = canDynamicCastThrow(CE); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1130 | if (CT == CT_Can) |
| 1131 | return CT; |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1132 | return mergeCanThrow(CT, canSubStmtsThrow(*this, CE)); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1133 | } |
| 1134 | |
| 1135 | case Expr::CXXTypeidExprClass: |
Mital Ashok | 3ad31e1 | 2024-06-17 18:31:54 +0100 | [diff] [blame] | 1136 | // - a potentially evaluated typeid expression applied to a (possibly |
| 1137 | // parenthesized) built-in unary * operator applied to a pointer to a |
| 1138 | // polymorphic class type |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1139 | return canTypeidThrow(*this, cast<CXXTypeidExpr>(S)); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1140 | |
| 1141 | // - a potentially evaluated call to a function, member function, function |
| 1142 | // pointer, or member function pointer that does not have a non-throwing |
| 1143 | // exception-specification |
| 1144 | case Expr::CallExprClass: |
| 1145 | case Expr::CXXMemberCallExprClass: |
| 1146 | case Expr::CXXOperatorCallExprClass: |
| 1147 | case Expr::UserDefinedLiteralClass: { |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1148 | const CallExpr *CE = cast<CallExpr>(S); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1149 | CanThrowResult CT; |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1150 | if (CE->isTypeDependent()) |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1151 | CT = CT_Dependent; |
| 1152 | else if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens())) |
| 1153 | CT = CT_Cannot; |
Eli Friedman | 5a8738f | 2013-06-25 01:55:41 +0000 | [diff] [blame] | 1154 | else |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1155 | CT = canCalleeThrow(*this, CE, CE->getCalleeDecl()); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1156 | if (CT == CT_Can) |
| 1157 | return CT; |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1158 | return mergeCanThrow(CT, canSubStmtsThrow(*this, CE)); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1159 | } |
| 1160 | |
| 1161 | case Expr::CXXConstructExprClass: |
| 1162 | case Expr::CXXTemporaryObjectExprClass: { |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1163 | auto *CE = cast<CXXConstructExpr>(S); |
| 1164 | // FIXME: Properly determine whether a variably-modified type can throw. |
| 1165 | if (CE->getType()->isVariablyModifiedType()) |
| 1166 | return CT_Can; |
| 1167 | CanThrowResult CT = canCalleeThrow(*this, CE, CE->getConstructor()); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1168 | if (CT == CT_Can) |
| 1169 | return CT; |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1170 | return mergeCanThrow(CT, canSubStmtsThrow(*this, CE)); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1171 | } |
| 1172 | |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1173 | case Expr::CXXInheritedCtorInitExprClass: { |
| 1174 | auto *ICIE = cast<CXXInheritedCtorInitExpr>(S); |
| 1175 | return canCalleeThrow(*this, ICIE, ICIE->getConstructor()); |
| 1176 | } |
Richard Smith | 5179eb7 | 2016-06-28 19:03:57 +0000 | [diff] [blame] | 1177 | |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1178 | case Expr::LambdaExprClass: { |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1179 | const LambdaExpr *Lambda = cast<LambdaExpr>(S); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1180 | CanThrowResult CT = CT_Cannot; |
James Y Knight | 53c7616 | 2015-07-17 18:21:37 +0000 | [diff] [blame] | 1181 | for (LambdaExpr::const_capture_init_iterator |
| 1182 | Cap = Lambda->capture_init_begin(), |
| 1183 | CapEnd = Lambda->capture_init_end(); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1184 | Cap != CapEnd; ++Cap) |
| 1185 | CT = mergeCanThrow(CT, canThrow(*Cap)); |
| 1186 | return CT; |
| 1187 | } |
| 1188 | |
| 1189 | case Expr::CXXNewExprClass: { |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1190 | auto *NE = cast<CXXNewExpr>(S); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1191 | CanThrowResult CT; |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1192 | if (NE->isTypeDependent()) |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1193 | CT = CT_Dependent; |
| 1194 | else |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1195 | CT = canCalleeThrow(*this, NE, NE->getOperatorNew()); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1196 | if (CT == CT_Can) |
| 1197 | return CT; |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1198 | return mergeCanThrow(CT, canSubStmtsThrow(*this, NE)); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1199 | } |
| 1200 | |
| 1201 | case Expr::CXXDeleteExprClass: { |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1202 | auto *DE = cast<CXXDeleteExpr>(S); |
Aaron Ballman | 5ff7f47 | 2025-01-09 08:29:19 -0500 | [diff] [blame] | 1203 | CanThrowResult CT = CT_Cannot; |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1204 | QualType DTy = DE->getDestroyedType(); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1205 | if (DTy.isNull() || DTy->isDependentType()) { |
| 1206 | CT = CT_Dependent; |
| 1207 | } else { |
Aaron Ballman | 5ff7f47 | 2025-01-09 08:29:19 -0500 | [diff] [blame] | 1208 | // C++20 [expr.delete]p6: If the value of the operand of the delete- |
| 1209 | // expression is not a null pointer value and the selected deallocation |
| 1210 | // function (see below) is not a destroying operator delete, the delete- |
| 1211 | // expression will invoke the destructor (if any) for the object or the |
| 1212 | // elements of the array being deleted. |
Aaron Ballman | 91354fb | 2024-12-05 14:26:33 -0500 | [diff] [blame] | 1213 | const FunctionDecl *OperatorDelete = DE->getOperatorDelete(); |
Aaron Ballman | 5ff7f47 | 2025-01-09 08:29:19 -0500 | [diff] [blame] | 1214 | if (const auto *RD = DTy->getAsCXXRecordDecl()) { |
| 1215 | if (const CXXDestructorDecl *DD = RD->getDestructor(); |
| 1216 | DD && DD->isCalledByDelete(OperatorDelete)) |
| 1217 | CT = canCalleeThrow(*this, DE, DD); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1218 | } |
Aaron Ballman | 5ff7f47 | 2025-01-09 08:29:19 -0500 | [diff] [blame] | 1219 | |
| 1220 | // We always look at the exception specification of the operator delete. |
| 1221 | CT = mergeCanThrow(CT, canCalleeThrow(*this, DE, OperatorDelete)); |
| 1222 | |
| 1223 | // If we know we can throw, we're done. |
| 1224 | if (CT == CT_Can) |
| 1225 | return CT; |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1226 | } |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1227 | return mergeCanThrow(CT, canSubStmtsThrow(*this, DE)); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1228 | } |
| 1229 | |
| 1230 | case Expr::CXXBindTemporaryExprClass: { |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1231 | auto *BTE = cast<CXXBindTemporaryExpr>(S); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1232 | // The bound temporary has to be destroyed again, which might throw. |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1233 | CanThrowResult CT = |
| 1234 | canCalleeThrow(*this, BTE, BTE->getTemporary()->getDestructor()); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1235 | if (CT == CT_Can) |
| 1236 | return CT; |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1237 | return mergeCanThrow(CT, canSubStmtsThrow(*this, BTE)); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1238 | } |
| 1239 | |
Richard Smith | 4a4e90a | 2019-12-13 14:11:04 -0800 | [diff] [blame] | 1240 | case Expr::PseudoObjectExprClass: { |
| 1241 | auto *POE = cast<PseudoObjectExpr>(S); |
| 1242 | CanThrowResult CT = CT_Cannot; |
| 1243 | for (const Expr *E : POE->semantics()) { |
| 1244 | CT = mergeCanThrow(CT, canThrow(E)); |
| 1245 | if (CT == CT_Can) |
| 1246 | break; |
| 1247 | } |
| 1248 | return CT; |
| 1249 | } |
| 1250 | |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1251 | // ObjC message sends are like function calls, but never have exception |
| 1252 | // specs. |
| 1253 | case Expr::ObjCMessageExprClass: |
| 1254 | case Expr::ObjCPropertyRefExprClass: |
| 1255 | case Expr::ObjCSubscriptRefExprClass: |
| 1256 | return CT_Can; |
| 1257 | |
| 1258 | // All the ObjC literals that are implemented as calls are |
| 1259 | // potentially throwing unless we decide to close off that |
| 1260 | // possibility. |
| 1261 | case Expr::ObjCArrayLiteralClass: |
| 1262 | case Expr::ObjCDictionaryLiteralClass: |
Patrick Beard | 0caa394 | 2012-04-19 00:25:12 +0000 | [diff] [blame] | 1263 | case Expr::ObjCBoxedExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1264 | return CT_Can; |
| 1265 | |
| 1266 | // Many other things have subexpressions, so we have to test those. |
| 1267 | // Some are simple: |
Richard Smith | 9f690bd | 2015-10-27 06:02:45 +0000 | [diff] [blame] | 1268 | case Expr::CoawaitExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1269 | case Expr::ConditionalOperatorClass: |
Richard Smith | 9f690bd | 2015-10-27 06:02:45 +0000 | [diff] [blame] | 1270 | case Expr::CoyieldExprClass: |
Richard Smith | 778dc0f | 2019-10-19 00:04:38 +0000 | [diff] [blame] | 1271 | case Expr::CXXRewrittenBinaryOperatorClass: |
Richard Smith | cc1b96d | 2013-06-12 22:31:48 +0000 | [diff] [blame] | 1272 | case Expr::CXXStdInitializerListExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1273 | case Expr::DesignatedInitExprClass: |
Yunzhong Gao | cb77930 | 2015-06-10 00:27:52 +0000 | [diff] [blame] | 1274 | case Expr::DesignatedInitUpdateExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1275 | case Expr::ExprWithCleanupsClass: |
| 1276 | case Expr::ExtVectorElementExprClass: |
| 1277 | case Expr::InitListExprClass: |
Richard Smith | 410306b | 2016-12-12 02:53:20 +0000 | [diff] [blame] | 1278 | case Expr::ArrayInitLoopExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1279 | case Expr::MemberExprClass: |
| 1280 | case Expr::ObjCIsaExprClass: |
| 1281 | case Expr::ObjCIvarRefExprClass: |
| 1282 | case Expr::ParenExprClass: |
| 1283 | case Expr::ParenListExprClass: |
| 1284 | case Expr::ShuffleVectorExprClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1285 | case Expr::StmtExprClass: |
Hal Finkel | c4d7c82 | 2013-09-18 03:29:45 +0000 | [diff] [blame] | 1286 | case Expr::ConvertVectorExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1287 | case Expr::VAArgExprClass: |
Alan Zhao | 95a4c0c | 2023-01-04 15:12:00 -0800 | [diff] [blame] | 1288 | case Expr::CXXParenListInitExprClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1289 | return canSubStmtsThrow(*this, S); |
| 1290 | |
| 1291 | case Expr::CompoundLiteralExprClass: |
| 1292 | case Expr::CXXConstCastExprClass: |
Anastasia Stulova | a6a237f | 2020-05-18 11:02:01 +0100 | [diff] [blame] | 1293 | case Expr::CXXAddrspaceCastExprClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1294 | case Expr::CXXReinterpretCastExprClass: |
| 1295 | case Expr::BuiltinBitCastExprClass: |
| 1296 | // FIXME: Properly determine whether a variably-modified type can throw. |
| 1297 | if (cast<Expr>(S)->getType()->isVariablyModifiedType()) |
| 1298 | return CT_Can; |
| 1299 | return canSubStmtsThrow(*this, S); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1300 | |
| 1301 | // Some might be dependent for other reasons. |
| 1302 | case Expr::ArraySubscriptExprClass: |
Florian Hahn | 8f3f88d | 2020-06-01 19:42:03 +0100 | [diff] [blame] | 1303 | case Expr::MatrixSubscriptExprClass: |
Erich Keane | 39adc8f | 2024-04-25 10:22:03 -0700 | [diff] [blame] | 1304 | case Expr::ArraySectionExprClass: |
Alexey Bataev | 7ac9efb | 2020-02-05 09:33:05 -0500 | [diff] [blame] | 1305 | case Expr::OMPArrayShapingExprClass: |
Alexey Bataev | 13a1504 | 2020-04-01 15:06:38 -0400 | [diff] [blame] | 1306 | case Expr::OMPIteratorExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1307 | case Expr::BinaryOperatorClass: |
Eric Fiselier | 20f25cb | 2017-03-06 23:38:15 +0000 | [diff] [blame] | 1308 | case Expr::DependentCoawaitExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1309 | case Expr::CompoundAssignOperatorClass: |
| 1310 | case Expr::CStyleCastExprClass: |
| 1311 | case Expr::CXXStaticCastExprClass: |
| 1312 | case Expr::CXXFunctionalCastExprClass: |
| 1313 | case Expr::ImplicitCastExprClass: |
| 1314 | case Expr::MaterializeTemporaryExprClass: |
| 1315 | case Expr::UnaryOperatorClass: { |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1316 | // FIXME: Properly determine whether a variably-modified type can throw. |
| 1317 | if (auto *CE = dyn_cast<CastExpr>(S)) |
| 1318 | if (CE->getType()->isVariablyModifiedType()) |
| 1319 | return CT_Can; |
| 1320 | CanThrowResult CT = |
| 1321 | cast<Expr>(S)->isTypeDependent() ? CT_Dependent : CT_Cannot; |
| 1322 | return mergeCanThrow(CT, canSubStmtsThrow(*this, S)); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1323 | } |
| 1324 | |
Richard Smith | 852c9db | 2013-04-20 22:23:05 +0000 | [diff] [blame] | 1325 | case Expr::CXXDefaultArgExprClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1326 | return canThrow(cast<CXXDefaultArgExpr>(S)->getExpr()); |
Richard Smith | 852c9db | 2013-04-20 22:23:05 +0000 | [diff] [blame] | 1327 | |
| 1328 | case Expr::CXXDefaultInitExprClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1329 | return canThrow(cast<CXXDefaultInitExpr>(S)->getExpr()); |
Richard Smith | 852c9db | 2013-04-20 22:23:05 +0000 | [diff] [blame] | 1330 | |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1331 | case Expr::ChooseExprClass: { |
| 1332 | auto *CE = cast<ChooseExpr>(S); |
| 1333 | if (CE->isTypeDependent() || CE->isValueDependent()) |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1334 | return CT_Dependent; |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1335 | return canThrow(CE->getChosenSubExpr()); |
| 1336 | } |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1337 | |
| 1338 | case Expr::GenericSelectionExprClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1339 | if (cast<GenericSelectionExpr>(S)->isResultDependent()) |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1340 | return CT_Dependent; |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1341 | return canThrow(cast<GenericSelectionExpr>(S)->getResultExpr()); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1342 | |
| 1343 | // Some expressions are always dependent. |
| 1344 | case Expr::CXXDependentScopeMemberExprClass: |
| 1345 | case Expr::CXXUnresolvedConstructExprClass: |
| 1346 | case Expr::DependentScopeDeclRefExprClass: |
Richard Smith | 0f0af19 | 2014-11-08 05:07:16 +0000 | [diff] [blame] | 1347 | case Expr::CXXFoldExprClass: |
Haojian Wu | 733edf9 | 2020-03-19 16:30:40 +0100 | [diff] [blame] | 1348 | case Expr::RecoveryExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1349 | return CT_Dependent; |
| 1350 | |
| 1351 | case Expr::AsTypeExprClass: |
| 1352 | case Expr::BinaryConditionalOperatorClass: |
| 1353 | case Expr::BlockExprClass: |
| 1354 | case Expr::CUDAKernelCallExprClass: |
| 1355 | case Expr::DeclRefExprClass: |
| 1356 | case Expr::ObjCBridgedCastExprClass: |
| 1357 | case Expr::ObjCIndirectCopyRestoreExprClass: |
| 1358 | case Expr::ObjCProtocolExprClass: |
| 1359 | case Expr::ObjCSelectorExprClass: |
Erik Pilkington | 29099de | 2016-07-16 00:35:23 +0000 | [diff] [blame] | 1360 | case Expr::ObjCAvailabilityCheckExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1361 | case Expr::OffsetOfExprClass: |
| 1362 | case Expr::PackExpansionExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1363 | case Expr::SubstNonTypeTemplateParmExprClass: |
| 1364 | case Expr::SubstNonTypeTemplateParmPackExprClass: |
Richard Smith | b15fe3a | 2012-09-12 00:56:43 +0000 | [diff] [blame] | 1365 | case Expr::FunctionParmPackExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1366 | case Expr::UnaryExprOrTypeTraitExprClass: |
| 1367 | case Expr::UnresolvedLookupExprClass: |
| 1368 | case Expr::UnresolvedMemberExprClass: |
Kaelyn Takata | e1f49d5 | 2014-10-27 18:07:20 +0000 | [diff] [blame] | 1369 | case Expr::TypoExprClass: |
Richard Smith | 4a4e90a | 2019-12-13 14:11:04 -0800 | [diff] [blame] | 1370 | // FIXME: Many of the above can throw. |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1371 | return CT_Cannot; |
| 1372 | |
| 1373 | case Expr::AddrLabelExprClass: |
| 1374 | case Expr::ArrayTypeTraitExprClass: |
| 1375 | case Expr::AtomicExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1376 | case Expr::TypeTraitExprClass: |
| 1377 | case Expr::CXXBoolLiteralExprClass: |
| 1378 | case Expr::CXXNoexceptExprClass: |
| 1379 | case Expr::CXXNullPtrLiteralExprClass: |
| 1380 | case Expr::CXXPseudoDestructorExprClass: |
| 1381 | case Expr::CXXScalarValueInitExprClass: |
| 1382 | case Expr::CXXThisExprClass: |
| 1383 | case Expr::CXXUuidofExprClass: |
| 1384 | case Expr::CharacterLiteralClass: |
| 1385 | case Expr::ExpressionTraitExprClass: |
| 1386 | case Expr::FloatingLiteralClass: |
| 1387 | case Expr::GNUNullExprClass: |
| 1388 | case Expr::ImaginaryLiteralClass: |
| 1389 | case Expr::ImplicitValueInitExprClass: |
| 1390 | case Expr::IntegerLiteralClass: |
Leonard Chan | db01c3a | 2018-06-20 17:19:40 +0000 | [diff] [blame] | 1391 | case Expr::FixedPointLiteralClass: |
Richard Smith | 410306b | 2016-12-12 02:53:20 +0000 | [diff] [blame] | 1392 | case Expr::ArrayInitIndexExprClass: |
Yunzhong Gao | cb77930 | 2015-06-10 00:27:52 +0000 | [diff] [blame] | 1393 | case Expr::NoInitExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1394 | case Expr::ObjCEncodeExprClass: |
| 1395 | case Expr::ObjCStringLiteralClass: |
| 1396 | case Expr::ObjCBoolLiteralExprClass: |
| 1397 | case Expr::OpaqueValueExprClass: |
| 1398 | case Expr::PredefinedExprClass: |
| 1399 | case Expr::SizeOfPackExprClass: |
cor3ntin | ad1a65f | 2024-01-27 10:23:38 +0100 | [diff] [blame] | 1400 | case Expr::PackIndexingExprClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1401 | case Expr::StringLiteralClass: |
Eric Fiselier | 708afb5 | 2019-05-16 21:04:15 +0000 | [diff] [blame] | 1402 | case Expr::SourceLocExprClass: |
Mariya Podchishchaeva | 41c6e43 | 2024-06-20 14:38:46 +0200 | [diff] [blame] | 1403 | case Expr::EmbedExprClass: |
Saar Raz | 5d98ba6 | 2019-10-15 15:24:26 +0000 | [diff] [blame] | 1404 | case Expr::ConceptSpecializationExprClass: |
Saar Raz | a0f50d7 | 2020-01-18 09:11:43 +0200 | [diff] [blame] | 1405 | case Expr::RequiresExprClass: |
Chris B | 89fb849 | 2024-08-31 10:59:08 -0500 | [diff] [blame] | 1406 | case Expr::HLSLOutArgExprClass: |
erichkeane | 010d011 | 2024-12-10 12:55:15 -0800 | [diff] [blame] | 1407 | case Stmt::OpenACCEnterDataConstructClass: |
| 1408 | case Stmt::OpenACCExitDataConstructClass: |
erichkeane | e34cc7c | 2024-12-17 07:39:20 -0800 | [diff] [blame] | 1409 | case Stmt::OpenACCWaitConstructClass: |
erichkeane | d5cec38 | 2025-03-03 10:26:53 -0800 | [diff] [blame] | 1410 | case Stmt::OpenACCCacheConstructClass: |
erichkeane | 4bbdb01 | 2024-12-19 06:11:36 -0800 | [diff] [blame] | 1411 | case Stmt::OpenACCInitConstructClass: |
| 1412 | case Stmt::OpenACCShutdownConstructClass: |
erichkeane | 21c785d | 2025-01-03 10:00:12 -0800 | [diff] [blame] | 1413 | case Stmt::OpenACCSetConstructClass: |
erichkeane | db81e8c | 2025-01-06 11:59:04 -0800 | [diff] [blame] | 1414 | case Stmt::OpenACCUpdateConstructClass: |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1415 | // These expressions can never throw. |
| 1416 | return CT_Cannot; |
| 1417 | |
John McCall | 5e77d76 | 2013-04-16 07:28:30 +0000 | [diff] [blame] | 1418 | case Expr::MSPropertyRefExprClass: |
Alexey Bataev | f763027 | 2015-11-25 12:01:00 +0000 | [diff] [blame] | 1419 | case Expr::MSPropertySubscriptExprClass: |
John McCall | 5e77d76 | 2013-04-16 07:28:30 +0000 | [diff] [blame] | 1420 | llvm_unreachable("Invalid class for expression"); |
| 1421 | |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1422 | // Most statements can throw if any substatement can throw. |
Erich Keane | f655778 | 2024-02-13 06:02:13 -0800 | [diff] [blame] | 1423 | case Stmt::OpenACCComputeConstructClass: |
Erich Keane | 42f4e50 | 2024-06-05 06:21:48 -0700 | [diff] [blame] | 1424 | case Stmt::OpenACCLoopConstructClass: |
erichkeane | 39351f8 | 2024-11-07 14:17:55 -0800 | [diff] [blame] | 1425 | case Stmt::OpenACCCombinedConstructClass: |
erichkeane | 010d011 | 2024-12-10 12:55:15 -0800 | [diff] [blame] | 1426 | case Stmt::OpenACCDataConstructClass: |
| 1427 | case Stmt::OpenACCHostDataConstructClass: |
erichkeane | 99a9133 | 2025-01-22 12:22:03 -0800 | [diff] [blame] | 1428 | case Stmt::OpenACCAtomicConstructClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1429 | case Stmt::AttributedStmtClass: |
| 1430 | case Stmt::BreakStmtClass: |
| 1431 | case Stmt::CapturedStmtClass: |
Tom Honermann | 8fb4230 | 2025-01-22 16:39:08 -0500 | [diff] [blame] | 1432 | case Stmt::SYCLKernelCallStmtClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1433 | case Stmt::CaseStmtClass: |
| 1434 | case Stmt::CompoundStmtClass: |
| 1435 | case Stmt::ContinueStmtClass: |
| 1436 | case Stmt::CoreturnStmtClass: |
| 1437 | case Stmt::CoroutineBodyStmtClass: |
| 1438 | case Stmt::CXXCatchStmtClass: |
| 1439 | case Stmt::CXXForRangeStmtClass: |
| 1440 | case Stmt::DefaultStmtClass: |
| 1441 | case Stmt::DoStmtClass: |
| 1442 | case Stmt::ForStmtClass: |
| 1443 | case Stmt::GCCAsmStmtClass: |
| 1444 | case Stmt::GotoStmtClass: |
| 1445 | case Stmt::IndirectGotoStmtClass: |
| 1446 | case Stmt::LabelStmtClass: |
| 1447 | case Stmt::MSAsmStmtClass: |
| 1448 | case Stmt::MSDependentExistsStmtClass: |
| 1449 | case Stmt::NullStmtClass: |
| 1450 | case Stmt::ObjCAtCatchStmtClass: |
| 1451 | case Stmt::ObjCAtFinallyStmtClass: |
| 1452 | case Stmt::ObjCAtSynchronizedStmtClass: |
| 1453 | case Stmt::ObjCAutoreleasePoolStmtClass: |
| 1454 | case Stmt::ObjCForCollectionStmtClass: |
| 1455 | case Stmt::OMPAtomicDirectiveClass: |
Haojian Wu | 31bb759 | 2024-08-05 14:04:09 +0200 | [diff] [blame] | 1456 | case Stmt::OMPAssumeDirectiveClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1457 | case Stmt::OMPBarrierDirectiveClass: |
| 1458 | case Stmt::OMPCancelDirectiveClass: |
| 1459 | case Stmt::OMPCancellationPointDirectiveClass: |
| 1460 | case Stmt::OMPCriticalDirectiveClass: |
| 1461 | case Stmt::OMPDistributeDirectiveClass: |
| 1462 | case Stmt::OMPDistributeParallelForDirectiveClass: |
| 1463 | case Stmt::OMPDistributeParallelForSimdDirectiveClass: |
| 1464 | case Stmt::OMPDistributeSimdDirectiveClass: |
| 1465 | case Stmt::OMPFlushDirectiveClass: |
Alexey Bataev | c112e941 | 2020-02-28 09:52:15 -0500 | [diff] [blame] | 1466 | case Stmt::OMPDepobjDirectiveClass: |
Alexey Bataev | fcba7c3 | 2020-03-20 07:03:01 -0400 | [diff] [blame] | 1467 | case Stmt::OMPScanDirectiveClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1468 | case Stmt::OMPForDirectiveClass: |
| 1469 | case Stmt::OMPForSimdDirectiveClass: |
| 1470 | case Stmt::OMPMasterDirectiveClass: |
| 1471 | case Stmt::OMPMasterTaskLoopDirectiveClass: |
Fazlay Rabbi | 42bb88e | 2022-06-24 08:42:21 -0700 | [diff] [blame] | 1472 | case Stmt::OMPMaskedTaskLoopDirectiveClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1473 | case Stmt::OMPMasterTaskLoopSimdDirectiveClass: |
Fazlay Rabbi | 73e5d7b | 2022-06-28 14:35:43 -0700 | [diff] [blame] | 1474 | case Stmt::OMPMaskedTaskLoopSimdDirectiveClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1475 | case Stmt::OMPOrderedDirectiveClass: |
Michael Kruse | b119120 | 2021-03-03 17:15:32 -0600 | [diff] [blame] | 1476 | case Stmt::OMPCanonicalLoopClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1477 | case Stmt::OMPParallelDirectiveClass: |
| 1478 | case Stmt::OMPParallelForDirectiveClass: |
| 1479 | case Stmt::OMPParallelForSimdDirectiveClass: |
| 1480 | case Stmt::OMPParallelMasterDirectiveClass: |
Jennifer Yu | bb83f8e | 2022-06-16 16:32:30 -0700 | [diff] [blame] | 1481 | case Stmt::OMPParallelMaskedDirectiveClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1482 | case Stmt::OMPParallelMasterTaskLoopDirectiveClass: |
Fazlay Rabbi | d64ba89 | 2022-06-30 10:59:33 -0700 | [diff] [blame] | 1483 | case Stmt::OMPParallelMaskedTaskLoopDirectiveClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1484 | case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass: |
Fazlay Rabbi | 38bcd48 | 2022-06-30 17:08:17 -0700 | [diff] [blame] | 1485 | case Stmt::OMPParallelMaskedTaskLoopSimdDirectiveClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1486 | case Stmt::OMPParallelSectionsDirectiveClass: |
| 1487 | case Stmt::OMPSectionDirectiveClass: |
| 1488 | case Stmt::OMPSectionsDirectiveClass: |
| 1489 | case Stmt::OMPSimdDirectiveClass: |
Michael Kruse | 6c05005 | 2021-02-12 11:26:59 -0800 | [diff] [blame] | 1490 | case Stmt::OMPTileDirectiveClass: |
Zahira Ammarguellat | cf69b4c | 2025-02-13 07:14:36 -0500 | [diff] [blame] | 1491 | case Stmt::OMPStripeDirectiveClass: |
Michael Kruse | a222361 | 2021-06-10 14:24:17 -0500 | [diff] [blame] | 1492 | case Stmt::OMPUnrollDirectiveClass: |
Michael Kruse | 80865c01 | 2024-07-18 10:35:32 +0200 | [diff] [blame] | 1493 | case Stmt::OMPReverseDirectiveClass: |
Michael Kruse | 5c93a94 | 2024-07-19 09:24:40 +0200 | [diff] [blame] | 1494 | case Stmt::OMPInterchangeDirectiveClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1495 | case Stmt::OMPSingleDirectiveClass: |
| 1496 | case Stmt::OMPTargetDataDirectiveClass: |
| 1497 | case Stmt::OMPTargetDirectiveClass: |
| 1498 | case Stmt::OMPTargetEnterDataDirectiveClass: |
| 1499 | case Stmt::OMPTargetExitDataDirectiveClass: |
| 1500 | case Stmt::OMPTargetParallelDirectiveClass: |
| 1501 | case Stmt::OMPTargetParallelForDirectiveClass: |
| 1502 | case Stmt::OMPTargetParallelForSimdDirectiveClass: |
| 1503 | case Stmt::OMPTargetSimdDirectiveClass: |
| 1504 | case Stmt::OMPTargetTeamsDirectiveClass: |
| 1505 | case Stmt::OMPTargetTeamsDistributeDirectiveClass: |
| 1506 | case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass: |
| 1507 | case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass: |
| 1508 | case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass: |
| 1509 | case Stmt::OMPTargetUpdateDirectiveClass: |
Fazlay Rabbi | e4c7298 | 2023-08-09 15:28:09 -0700 | [diff] [blame] | 1510 | case Stmt::OMPScopeDirectiveClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1511 | case Stmt::OMPTaskDirectiveClass: |
| 1512 | case Stmt::OMPTaskgroupDirectiveClass: |
| 1513 | case Stmt::OMPTaskLoopDirectiveClass: |
| 1514 | case Stmt::OMPTaskLoopSimdDirectiveClass: |
| 1515 | case Stmt::OMPTaskwaitDirectiveClass: |
| 1516 | case Stmt::OMPTaskyieldDirectiveClass: |
Jennifer Yu | ea64e66 | 2022-11-01 14:46:12 -0700 | [diff] [blame] | 1517 | case Stmt::OMPErrorDirectiveClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1518 | case Stmt::OMPTeamsDirectiveClass: |
| 1519 | case Stmt::OMPTeamsDistributeDirectiveClass: |
| 1520 | case Stmt::OMPTeamsDistributeParallelForDirectiveClass: |
| 1521 | case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass: |
| 1522 | case Stmt::OMPTeamsDistributeSimdDirectiveClass: |
Mike Rice | 410f09a | 2021-03-15 13:09:46 -0700 | [diff] [blame] | 1523 | case Stmt::OMPInteropDirectiveClass: |
Mike Rice | b7899ba | 2021-03-22 18:13:29 -0700 | [diff] [blame] | 1524 | case Stmt::OMPDispatchDirectiveClass: |
cchen | 1a43fd2 | 2021-04-09 14:00:36 -0500 | [diff] [blame] | 1525 | case Stmt::OMPMaskedDirectiveClass: |
alokmishra.besu | 000875c | 2021-09-17 16:03:01 -0500 | [diff] [blame] | 1526 | case Stmt::OMPMetaDirectiveClass: |
Mike Rice | 6f9c251 | 2021-10-28 08:10:40 -0700 | [diff] [blame] | 1527 | case Stmt::OMPGenericLoopDirectiveClass: |
Mike Rice | 79f661e | 2022-03-15 08:35:59 -0700 | [diff] [blame] | 1528 | case Stmt::OMPTeamsGenericLoopDirectiveClass: |
Mike Rice | 6bd8dc9 | 2022-03-18 11:02:02 -0700 | [diff] [blame] | 1529 | case Stmt::OMPTargetTeamsGenericLoopDirectiveClass: |
Mike Rice | 2cedaee | 2022-03-22 10:55:21 -0700 | [diff] [blame] | 1530 | case Stmt::OMPParallelGenericLoopDirectiveClass: |
Mike Rice | f82ec55 | 2022-03-23 15:37:06 -0700 | [diff] [blame] | 1531 | case Stmt::OMPTargetParallelGenericLoopDirectiveClass: |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1532 | case Stmt::ReturnStmtClass: |
| 1533 | case Stmt::SEHExceptStmtClass: |
| 1534 | case Stmt::SEHFinallyStmtClass: |
| 1535 | case Stmt::SEHLeaveStmtClass: |
| 1536 | case Stmt::SEHTryStmtClass: |
| 1537 | case Stmt::SwitchStmtClass: |
| 1538 | case Stmt::WhileStmtClass: |
| 1539 | return canSubStmtsThrow(*this, S); |
| 1540 | |
| 1541 | case Stmt::DeclStmtClass: { |
| 1542 | CanThrowResult CT = CT_Cannot; |
| 1543 | for (const Decl *D : cast<DeclStmt>(S)->decls()) { |
| 1544 | if (auto *VD = dyn_cast<VarDecl>(D)) |
| 1545 | CT = mergeCanThrow(CT, canVarDeclThrow(*this, VD)); |
| 1546 | |
| 1547 | // FIXME: Properly determine whether a variably-modified type can throw. |
| 1548 | if (auto *TND = dyn_cast<TypedefNameDecl>(D)) |
| 1549 | if (TND->getUnderlyingType()->isVariablyModifiedType()) |
| 1550 | return CT_Can; |
| 1551 | if (auto *VD = dyn_cast<ValueDecl>(D)) |
| 1552 | if (VD->getType()->isVariablyModifiedType()) |
| 1553 | return CT_Can; |
| 1554 | } |
| 1555 | return CT; |
| 1556 | } |
| 1557 | |
| 1558 | case Stmt::IfStmtClass: { |
| 1559 | auto *IS = cast<IfStmt>(S); |
| 1560 | CanThrowResult CT = CT_Cannot; |
| 1561 | if (const Stmt *Init = IS->getInit()) |
| 1562 | CT = mergeCanThrow(CT, canThrow(Init)); |
| 1563 | if (const Stmt *CondDS = IS->getConditionVariableDeclStmt()) |
| 1564 | CT = mergeCanThrow(CT, canThrow(CondDS)); |
| 1565 | CT = mergeCanThrow(CT, canThrow(IS->getCond())); |
| 1566 | |
| 1567 | // For 'if constexpr', consider only the non-discarded case. |
| 1568 | // FIXME: We should add a DiscardedStmt marker to the AST. |
Kazu Hirata | 6ad0788 | 2023-01-14 12:31:01 -0800 | [diff] [blame] | 1569 | if (std::optional<const Stmt *> Case = IS->getNondiscardedCase(Context)) |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1570 | return *Case ? mergeCanThrow(CT, canThrow(*Case)) : CT; |
| 1571 | |
| 1572 | CanThrowResult Then = canThrow(IS->getThen()); |
| 1573 | CanThrowResult Else = IS->getElse() ? canThrow(IS->getElse()) : CT_Cannot; |
| 1574 | if (Then == Else) |
| 1575 | return mergeCanThrow(CT, Then); |
| 1576 | |
| 1577 | // For a dependent 'if constexpr', the result is dependent if it depends on |
| 1578 | // the value of the condition. |
| 1579 | return mergeCanThrow(CT, IS->isConstexpr() ? CT_Dependent |
| 1580 | : mergeCanThrow(Then, Else)); |
| 1581 | } |
| 1582 | |
| 1583 | case Stmt::CXXTryStmtClass: { |
| 1584 | auto *TS = cast<CXXTryStmt>(S); |
| 1585 | // try /*...*/ catch (...) { H } can throw only if H can throw. |
| 1586 | // Any other try-catch can throw if any substatement can throw. |
| 1587 | const CXXCatchStmt *FinalHandler = TS->getHandler(TS->getNumHandlers() - 1); |
| 1588 | if (!FinalHandler->getExceptionDecl()) |
| 1589 | return canThrow(FinalHandler->getHandlerBlock()); |
| 1590 | return canSubStmtsThrow(*this, S); |
| 1591 | } |
| 1592 | |
| 1593 | case Stmt::ObjCAtThrowStmtClass: |
| 1594 | return CT_Can; |
| 1595 | |
| 1596 | case Stmt::ObjCAtTryStmtClass: { |
| 1597 | auto *TS = cast<ObjCAtTryStmt>(S); |
| 1598 | |
| 1599 | // @catch(...) need not be last in Objective-C. Walk backwards until we |
| 1600 | // see one or hit the @try. |
| 1601 | CanThrowResult CT = CT_Cannot; |
| 1602 | if (const Stmt *Finally = TS->getFinallyStmt()) |
| 1603 | CT = mergeCanThrow(CT, canThrow(Finally)); |
| 1604 | for (unsigned I = TS->getNumCatchStmts(); I != 0; --I) { |
| 1605 | const ObjCAtCatchStmt *Catch = TS->getCatchStmt(I - 1); |
| 1606 | CT = mergeCanThrow(CT, canThrow(Catch)); |
| 1607 | // If we reach a @catch(...), no earlier exceptions can escape. |
| 1608 | if (Catch->hasEllipsis()) |
| 1609 | return CT; |
| 1610 | } |
| 1611 | |
| 1612 | // Didn't find an @catch(...). Exceptions from the @try body can escape. |
| 1613 | return mergeCanThrow(CT, canThrow(TS->getTryBody())); |
| 1614 | } |
| 1615 | |
Erich Keane | eba69b5 | 2021-04-23 08:22:35 -0700 | [diff] [blame] | 1616 | case Stmt::SYCLUniqueStableNameExprClass: |
| 1617 | return CT_Cannot; |
Erich Keane | d412cea | 2024-10-03 08:34:43 -0700 | [diff] [blame] | 1618 | case Stmt::OpenACCAsteriskSizeExprClass: |
| 1619 | return CT_Cannot; |
Richard Smith | fbf60b7 | 2019-12-13 14:10:13 -0800 | [diff] [blame] | 1620 | case Stmt::NoStmtClass: |
| 1621 | llvm_unreachable("Invalid class for statement"); |
Richard Smith | f623c96 | 2012-04-17 00:58:00 +0000 | [diff] [blame] | 1622 | } |
| 1623 | llvm_unreachable("Bogus StmtClass"); |
| 1624 | } |
| 1625 | |
Sebastian Redl | 4915e63 | 2009-10-11 09:03:14 +0000 | [diff] [blame] | 1626 | } // end namespace clang |