Bug Summary

File:include/llvm/Support/Error.h
Warning:line 200, column 5
Potential leak of memory pointed to by 'Payload._M_t._M_head_impl'

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CallEvent.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-9/lib/clang/9.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-9~svn358860/build-llvm/tools/clang/lib/StaticAnalyzer/Core -I /build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core -I /build/llvm-toolchain-snapshot-9~svn358860/tools/clang/include -I /build/llvm-toolchain-snapshot-9~svn358860/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-9~svn358860/build-llvm/include -I /build/llvm-toolchain-snapshot-9~svn358860/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/9.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-9/lib/clang/9.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-9~svn358860/build-llvm/tools/clang/lib/StaticAnalyzer/Core -fdebug-prefix-map=/build/llvm-toolchain-snapshot-9~svn358860=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2019-04-22-050718-5320-1 -x c++ /build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp -faddrsig

/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp

1//===- CallEvent.cpp - Wrapper for all function and method calls ----------===//
2//
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
6//
7//===----------------------------------------------------------------------===//
8//
9/// \file This file defines CallEvent and its subclasses, which represent path-
10/// sensitive instances of different kinds of function and method calls
11/// (C, C++, and Objective-C).
12//
13//===----------------------------------------------------------------------===//
14
15#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/Decl.h"
18#include "clang/AST/DeclBase.h"
19#include "clang/AST/DeclCXX.h"
20#include "clang/AST/DeclObjC.h"
21#include "clang/AST/Expr.h"
22#include "clang/AST/ExprCXX.h"
23#include "clang/AST/ExprObjC.h"
24#include "clang/AST/ParentMap.h"
25#include "clang/AST/Stmt.h"
26#include "clang/AST/Type.h"
27#include "clang/Analysis/AnalysisDeclContext.h"
28#include "clang/Analysis/CFG.h"
29#include "clang/Analysis/CFGStmtMap.h"
30#include "clang/Analysis/ProgramPoint.h"
31#include "clang/CrossTU/CrossTranslationUnit.h"
32#include "clang/Basic/IdentifierTable.h"
33#include "clang/Basic/LLVM.h"
34#include "clang/Basic/SourceLocation.h"
35#include "clang/Basic/SourceManager.h"
36#include "clang/Basic/Specifiers.h"
37#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
38#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
39#include "clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeInfo.h"
40#include "clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeMap.h"
41#include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
42#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
43#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h"
44#include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
45#include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h"
46#include "clang/StaticAnalyzer/Core/PathSensitive/Store.h"
47#include "llvm/ADT/ArrayRef.h"
48#include "llvm/ADT/DenseMap.h"
49#include "llvm/ADT/None.h"
50#include "llvm/ADT/Optional.h"
51#include "llvm/ADT/PointerIntPair.h"
52#include "llvm/ADT/SmallSet.h"
53#include "llvm/ADT/SmallVector.h"
54#include "llvm/ADT/StringExtras.h"
55#include "llvm/ADT/StringRef.h"
56#include "llvm/Support/Casting.h"
57#include "llvm/Support/Compiler.h"
58#include "llvm/Support/Debug.h"
59#include "llvm/Support/ErrorHandling.h"
60#include "llvm/Support/raw_ostream.h"
61#include <cassert>
62#include <utility>
63
64#define DEBUG_TYPE"static-analyzer-call-event" "static-analyzer-call-event"
65
66using namespace clang;
67using namespace ento;
68
69QualType CallEvent::getResultType() const {
70 ASTContext &Ctx = getState()->getStateManager().getContext();
71 const Expr *E = getOriginExpr();
72 if (!E)
73 return Ctx.VoidTy;
74 assert(E)((E) ? static_cast<void> (0) : __assert_fail ("E", "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 74, __PRETTY_FUNCTION__))
;
75
76 QualType ResultTy = E->getType();
77
78 // A function that returns a reference to 'int' will have a result type
79 // of simply 'int'. Check the origin expr's value kind to recover the
80 // proper type.
81 switch (E->getValueKind()) {
82 case VK_LValue:
83 ResultTy = Ctx.getLValueReferenceType(ResultTy);
84 break;
85 case VK_XValue:
86 ResultTy = Ctx.getRValueReferenceType(ResultTy);
87 break;
88 case VK_RValue:
89 // No adjustment is necessary.
90 break;
91 }
92
93 return ResultTy;
94}
95
96static bool isCallback(QualType T) {
97 // If a parameter is a block or a callback, assume it can modify pointer.
98 if (T->isBlockPointerType() ||
99 T->isFunctionPointerType() ||
100 T->isObjCSelType())
101 return true;
102
103 // Check if a callback is passed inside a struct (for both, struct passed by
104 // reference and by value). Dig just one level into the struct for now.
105
106 if (T->isAnyPointerType() || T->isReferenceType())
107 T = T->getPointeeType();
108
109 if (const RecordType *RT = T->getAsStructureType()) {
110 const RecordDecl *RD = RT->getDecl();
111 for (const auto *I : RD->fields()) {
112 QualType FieldT = I->getType();
113 if (FieldT->isBlockPointerType() || FieldT->isFunctionPointerType())
114 return true;
115 }
116 }
117 return false;
118}
119
120static bool isVoidPointerToNonConst(QualType T) {
121 if (const auto *PT = T->getAs<PointerType>()) {
122 QualType PointeeTy = PT->getPointeeType();
123 if (PointeeTy.isConstQualified())
124 return false;
125 return PointeeTy->isVoidType();
126 } else
127 return false;
128}
129
130bool CallEvent::hasNonNullArgumentsWithType(bool (*Condition)(QualType)) const {
131 unsigned NumOfArgs = getNumArgs();
132
133 // If calling using a function pointer, assume the function does not
134 // satisfy the callback.
135 // TODO: We could check the types of the arguments here.
136 if (!getDecl())
137 return false;
138
139 unsigned Idx = 0;
140 for (CallEvent::param_type_iterator I = param_type_begin(),
141 E = param_type_end();
142 I != E && Idx < NumOfArgs; ++I, ++Idx) {
143 // If the parameter is 0, it's harmless.
144 if (getArgSVal(Idx).isZeroConstant())
145 continue;
146
147 if (Condition(*I))
148 return true;
149 }
150 return false;
151}
152
153bool CallEvent::hasNonZeroCallbackArg() const {
154 return hasNonNullArgumentsWithType(isCallback);
155}
156
157bool CallEvent::hasVoidPointerToNonConstArg() const {
158 return hasNonNullArgumentsWithType(isVoidPointerToNonConst);
159}
160
161bool CallEvent::isGlobalCFunction(StringRef FunctionName) const {
162 const auto *FD = dyn_cast_or_null<FunctionDecl>(getDecl());
163 if (!FD)
164 return false;
165
166 return CheckerContext::isCLibraryFunction(FD, FunctionName);
167}
168
169AnalysisDeclContext *CallEvent::getCalleeAnalysisDeclContext() const {
170 const Decl *D = getDecl();
171 if (!D)
172 return nullptr;
173
174 // TODO: For now we skip functions without definitions, even if we have
175 // our own getDecl(), because it's hard to find out which re-declaration
176 // is going to be used, and usually clients don't really care about this
177 // situation because there's a loss of precision anyway because we cannot
178 // inline the call.
179 RuntimeDefinition RD = getRuntimeDefinition();
180 if (!RD.getDecl())
181 return nullptr;
182
183 AnalysisDeclContext *ADC =
184 LCtx->getAnalysisDeclContext()->getManager()->getContext(D);
185
186 // TODO: For now we skip virtual functions, because this also rises
187 // the problem of which decl to use, but now it's across different classes.
188 if (RD.mayHaveOtherDefinitions() || RD.getDecl() != ADC->getDecl())
189 return nullptr;
190
191 return ADC;
192}
193
194const StackFrameContext *CallEvent::getCalleeStackFrame() const {
195 AnalysisDeclContext *ADC = getCalleeAnalysisDeclContext();
196 if (!ADC)
197 return nullptr;
198
199 const Expr *E = getOriginExpr();
200 if (!E)
201 return nullptr;
202
203 // Recover CFG block via reverse lookup.
204 // TODO: If we were to keep CFG element information as part of the CallEvent
205 // instead of doing this reverse lookup, we would be able to build the stack
206 // frame for non-expression-based calls, and also we wouldn't need the reverse
207 // lookup.
208 CFGStmtMap *Map = LCtx->getAnalysisDeclContext()->getCFGStmtMap();
209 const CFGBlock *B = Map->getBlock(E);
210 assert(B)((B) ? static_cast<void> (0) : __assert_fail ("B", "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 210, __PRETTY_FUNCTION__))
;
211
212 // Also recover CFG index by scanning the CFG block.
213 unsigned Idx = 0, Sz = B->size();
214 for (; Idx < Sz; ++Idx)
215 if (auto StmtElem = (*B)[Idx].getAs<CFGStmt>())
216 if (StmtElem->getStmt() == E)
217 break;
218 assert(Idx < Sz)((Idx < Sz) ? static_cast<void> (0) : __assert_fail (
"Idx < Sz", "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 218, __PRETTY_FUNCTION__))
;
219
220 return ADC->getManager()->getStackFrame(ADC, LCtx, E, B, Idx);
221}
222
223const VarRegion *CallEvent::getParameterLocation(unsigned Index) const {
224 const StackFrameContext *SFC = getCalleeStackFrame();
225 // We cannot construct a VarRegion without a stack frame.
226 if (!SFC)
227 return nullptr;
228
229 // Retrieve parameters of the definition, which are different from
230 // CallEvent's parameters() because getDecl() isn't necessarily
231 // the definition. SFC contains the definition that would be used
232 // during analysis.
233 const Decl *D = SFC->getDecl();
234
235 // TODO: Refactor into a virtual method of CallEvent, like parameters().
236 const ParmVarDecl *PVD = nullptr;
237 if (const auto *FD = dyn_cast<FunctionDecl>(D))
238 PVD = FD->parameters()[Index];
239 else if (const auto *BD = dyn_cast<BlockDecl>(D))
240 PVD = BD->parameters()[Index];
241 else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
242 PVD = MD->parameters()[Index];
243 else if (const auto *CD = dyn_cast<CXXConstructorDecl>(D))
244 PVD = CD->parameters()[Index];
245 assert(PVD && "Unexpected Decl kind!")((PVD && "Unexpected Decl kind!") ? static_cast<void
> (0) : __assert_fail ("PVD && \"Unexpected Decl kind!\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 245, __PRETTY_FUNCTION__))
;
246
247 const VarRegion *VR =
248 State->getStateManager().getRegionManager().getVarRegion(PVD, SFC);
249
250 // This sanity check would fail if our parameter declaration doesn't
251 // correspond to the stack frame's function declaration.
252 assert(VR->getStackFrame() == SFC)((VR->getStackFrame() == SFC) ? static_cast<void> (0
) : __assert_fail ("VR->getStackFrame() == SFC", "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 252, __PRETTY_FUNCTION__))
;
253
254 return VR;
255}
256
257/// Returns true if a type is a pointer-to-const or reference-to-const
258/// with no further indirection.
259static bool isPointerToConst(QualType Ty) {
260 QualType PointeeTy = Ty->getPointeeType();
261 if (PointeeTy == QualType())
262 return false;
263 if (!PointeeTy.isConstQualified())
264 return false;
265 if (PointeeTy->isAnyPointerType())
266 return false;
267 return true;
268}
269
270// Try to retrieve the function declaration and find the function parameter
271// types which are pointers/references to a non-pointer const.
272// We will not invalidate the corresponding argument regions.
273static void findPtrToConstParams(llvm::SmallSet<unsigned, 4> &PreserveArgs,
274 const CallEvent &Call) {
275 unsigned Idx = 0;
276 for (CallEvent::param_type_iterator I = Call.param_type_begin(),
277 E = Call.param_type_end();
278 I != E; ++I, ++Idx) {
279 if (isPointerToConst(*I))
280 PreserveArgs.insert(Idx);
281 }
282}
283
284ProgramStateRef CallEvent::invalidateRegions(unsigned BlockCount,
285 ProgramStateRef Orig) const {
286 ProgramStateRef Result = (Orig ? Orig : getState());
287
288 // Don't invalidate anything if the callee is marked pure/const.
289 if (const Decl *callee = getDecl())
290 if (callee->hasAttr<PureAttr>() || callee->hasAttr<ConstAttr>())
291 return Result;
292
293 SmallVector<SVal, 8> ValuesToInvalidate;
294 RegionAndSymbolInvalidationTraits ETraits;
295
296 getExtraInvalidatedValues(ValuesToInvalidate, &ETraits);
297
298 // Indexes of arguments whose values will be preserved by the call.
299 llvm::SmallSet<unsigned, 4> PreserveArgs;
300 if (!argumentsMayEscape())
301 findPtrToConstParams(PreserveArgs, *this);
302
303 for (unsigned Idx = 0, Count = getNumArgs(); Idx != Count; ++Idx) {
304 // Mark this region for invalidation. We batch invalidate regions
305 // below for efficiency.
306 if (PreserveArgs.count(Idx))
307 if (const MemRegion *MR = getArgSVal(Idx).getAsRegion())
308 ETraits.setTrait(MR->getBaseRegion(),
309 RegionAndSymbolInvalidationTraits::TK_PreserveContents);
310 // TODO: Factor this out + handle the lower level const pointers.
311
312 ValuesToInvalidate.push_back(getArgSVal(Idx));
313
314 // If a function accepts an object by argument (which would of course be a
315 // temporary that isn't lifetime-extended), invalidate the object itself,
316 // not only other objects reachable from it. This is necessary because the
317 // destructor has access to the temporary object after the call.
318 // TODO: Support placement arguments once we start
319 // constructing them directly.
320 // TODO: This is unnecessary when there's no destructor, but that's
321 // currently hard to figure out.
322 if (getKind() != CE_CXXAllocator)
323 if (isArgumentConstructedDirectly(Idx))
324 if (auto AdjIdx = getAdjustedParameterIndex(Idx))
325 if (const VarRegion *VR = getParameterLocation(*AdjIdx))
326 ValuesToInvalidate.push_back(loc::MemRegionVal(VR));
327 }
328
329 // Invalidate designated regions using the batch invalidation API.
330 // NOTE: Even if RegionsToInvalidate is empty, we may still invalidate
331 // global variables.
332 return Result->invalidateRegions(ValuesToInvalidate, getOriginExpr(),
333 BlockCount, getLocationContext(),
334 /*CausedByPointerEscape*/ true,
335 /*Symbols=*/nullptr, this, &ETraits);
336}
337
338ProgramPoint CallEvent::getProgramPoint(bool IsPreVisit,
339 const ProgramPointTag *Tag) const {
340 if (const Expr *E = getOriginExpr()) {
341 if (IsPreVisit)
342 return PreStmt(E, getLocationContext(), Tag);
343 return PostStmt(E, getLocationContext(), Tag);
344 }
345
346 const Decl *D = getDecl();
347 assert(D && "Cannot get a program point without a statement or decl")((D && "Cannot get a program point without a statement or decl"
) ? static_cast<void> (0) : __assert_fail ("D && \"Cannot get a program point without a statement or decl\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 347, __PRETTY_FUNCTION__))
;
348
349 SourceLocation Loc = getSourceRange().getBegin();
350 if (IsPreVisit)
351 return PreImplicitCall(D, Loc, getLocationContext(), Tag);
352 return PostImplicitCall(D, Loc, getLocationContext(), Tag);
353}
354
355bool CallEvent::isCalled(const CallDescription &CD) const {
356 // FIXME: Add ObjC Message support.
357 if (getKind() == CE_ObjCMessage)
358 return false;
359 if (!CD.IsLookupDone) {
360 CD.IsLookupDone = true;
361 CD.II = &getState()->getStateManager().getContext().Idents.get(
362 CD.getFunctionName());
363 }
364 const IdentifierInfo *II = getCalleeIdentifier();
365 if (!II || II != CD.II)
366 return false;
367
368 const Decl *D = getDecl();
369 // If CallDescription provides prefix names, use them to improve matching
370 // accuracy.
371 if (CD.QualifiedName.size() > 1 && D) {
372 const DeclContext *Ctx = D->getDeclContext();
373 // See if we'll be able to match them all.
374 size_t NumUnmatched = CD.QualifiedName.size() - 1;
375 for (; Ctx && isa<NamedDecl>(Ctx); Ctx = Ctx->getParent()) {
376 if (NumUnmatched == 0)
377 break;
378
379 if (const auto *ND = dyn_cast<NamespaceDecl>(Ctx)) {
380 if (ND->getName() == CD.QualifiedName[NumUnmatched - 1])
381 --NumUnmatched;
382 continue;
383 }
384
385 if (const auto *RD = dyn_cast<RecordDecl>(Ctx)) {
386 if (RD->getName() == CD.QualifiedName[NumUnmatched - 1])
387 --NumUnmatched;
388 continue;
389 }
390 }
391
392 if (NumUnmatched > 0)
393 return false;
394 }
395
396 return (CD.RequiredArgs == CallDescription::NoArgRequirement ||
397 CD.RequiredArgs == getNumArgs());
398}
399
400SVal CallEvent::getArgSVal(unsigned Index) const {
401 const Expr *ArgE = getArgExpr(Index);
402 if (!ArgE)
403 return UnknownVal();
404 return getSVal(ArgE);
405}
406
407SourceRange CallEvent::getArgSourceRange(unsigned Index) const {
408 const Expr *ArgE = getArgExpr(Index);
409 if (!ArgE)
410 return {};
411 return ArgE->getSourceRange();
412}
413
414SVal CallEvent::getReturnValue() const {
415 const Expr *E = getOriginExpr();
416 if (!E)
417 return UndefinedVal();
418 return getSVal(E);
419}
420
421LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void CallEvent::dump() const { dump(llvm::errs()); }
422
423void CallEvent::dump(raw_ostream &Out) const {
424 ASTContext &Ctx = getState()->getStateManager().getContext();
425 if (const Expr *E = getOriginExpr()) {
426 E->printPretty(Out, nullptr, Ctx.getPrintingPolicy());
427 Out << "\n";
428 return;
429 }
430
431 if (const Decl *D = getDecl()) {
432 Out << "Call to ";
433 D->print(Out, Ctx.getPrintingPolicy());
434 return;
435 }
436
437 // FIXME: a string representation of the kind would be nice.
438 Out << "Unknown call (type " << getKind() << ")";
439}
440
441bool CallEvent::isCallStmt(const Stmt *S) {
442 return isa<CallExpr>(S) || isa<ObjCMessageExpr>(S)
443 || isa<CXXConstructExpr>(S)
444 || isa<CXXNewExpr>(S);
445}
446
447QualType CallEvent::getDeclaredResultType(const Decl *D) {
448 assert(D)((D) ? static_cast<void> (0) : __assert_fail ("D", "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 448, __PRETTY_FUNCTION__))
;
449 if (const auto *FD = dyn_cast<FunctionDecl>(D))
450 return FD->getReturnType();
451 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
452 return MD->getReturnType();
453 if (const auto *BD = dyn_cast<BlockDecl>(D)) {
454 // Blocks are difficult because the return type may not be stored in the
455 // BlockDecl itself. The AST should probably be enhanced, but for now we
456 // just do what we can.
457 // If the block is declared without an explicit argument list, the
458 // signature-as-written just includes the return type, not the entire
459 // function type.
460 // FIXME: All blocks should have signatures-as-written, even if the return
461 // type is inferred. (That's signified with a dependent result type.)
462 if (const TypeSourceInfo *TSI = BD->getSignatureAsWritten()) {
463 QualType Ty = TSI->getType();
464 if (const FunctionType *FT = Ty->getAs<FunctionType>())
465 Ty = FT->getReturnType();
466 if (!Ty->isDependentType())
467 return Ty;
468 }
469
470 return {};
471 }
472
473 llvm_unreachable("unknown callable kind")::llvm::llvm_unreachable_internal("unknown callable kind", "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 473)
;
474}
475
476bool CallEvent::isVariadic(const Decl *D) {
477 assert(D)((D) ? static_cast<void> (0) : __assert_fail ("D", "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 477, __PRETTY_FUNCTION__))
;
478
479 if (const auto *FD = dyn_cast<FunctionDecl>(D))
480 return FD->isVariadic();
481 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
482 return MD->isVariadic();
483 if (const auto *BD = dyn_cast<BlockDecl>(D))
484 return BD->isVariadic();
485
486 llvm_unreachable("unknown callable kind")::llvm::llvm_unreachable_internal("unknown callable kind", "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 486)
;
487}
488
489static void addParameterValuesToBindings(const StackFrameContext *CalleeCtx,
490 CallEvent::BindingsTy &Bindings,
491 SValBuilder &SVB,
492 const CallEvent &Call,
493 ArrayRef<ParmVarDecl*> parameters) {
494 MemRegionManager &MRMgr = SVB.getRegionManager();
495
496 // If the function has fewer parameters than the call has arguments, we simply
497 // do not bind any values to them.
498 unsigned NumArgs = Call.getNumArgs();
499 unsigned Idx = 0;
500 ArrayRef<ParmVarDecl*>::iterator I = parameters.begin(), E = parameters.end();
501 for (; I != E && Idx < NumArgs; ++I, ++Idx) {
502 const ParmVarDecl *ParamDecl = *I;
503 assert(ParamDecl && "Formal parameter has no decl?")((ParamDecl && "Formal parameter has no decl?") ? static_cast
<void> (0) : __assert_fail ("ParamDecl && \"Formal parameter has no decl?\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 503, __PRETTY_FUNCTION__))
;
504
505 // TODO: Support allocator calls.
506 if (Call.getKind() != CE_CXXAllocator)
507 if (Call.isArgumentConstructedDirectly(Idx))
508 continue;
509
510 // TODO: Allocators should receive the correct size and possibly alignment,
511 // determined in compile-time but not represented as arg-expressions,
512 // which makes getArgSVal() fail and return UnknownVal.
513 SVal ArgVal = Call.getArgSVal(Idx);
514 if (!ArgVal.isUnknown()) {
515 Loc ParamLoc = SVB.makeLoc(MRMgr.getVarRegion(ParamDecl, CalleeCtx));
516 Bindings.push_back(std::make_pair(ParamLoc, ArgVal));
517 }
518 }
519
520 // FIXME: Variadic arguments are not handled at all right now.
521}
522
523ArrayRef<ParmVarDecl*> AnyFunctionCall::parameters() const {
524 const FunctionDecl *D = getDecl();
525 if (!D)
526 return None;
527 return D->parameters();
528}
529
530RuntimeDefinition AnyFunctionCall::getRuntimeDefinition() const {
531 const FunctionDecl *FD = getDecl();
532 if (!FD)
8
Assuming 'FD' is non-null
9
Taking false branch
533 return {};
534
535 // Note that the AnalysisDeclContext will have the FunctionDecl with
536 // the definition (if one exists).
537 AnalysisDeclContext *AD =
538 getLocationContext()->getAnalysisDeclContext()->
539 getManager()->getContext(FD);
540 bool IsAutosynthesized;
541 Stmt* Body = AD->getBody(IsAutosynthesized);
542 LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("static-analyzer-call-event")) { { if (IsAutosynthesized) llvm
::dbgs() << "Using autosynthesized body for " << FD
->getName() << "\n"; }; } } while (false)
10
Assuming 'DebugFlag' is 0
11
Loop condition is false. Exiting loop
543 if (IsAutosynthesized)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("static-analyzer-call-event")) { { if (IsAutosynthesized) llvm
::dbgs() << "Using autosynthesized body for " << FD
->getName() << "\n"; }; } } while (false)
544 llvm::dbgs() << "Using autosynthesized body for " << FD->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("static-analyzer-call-event")) { { if (IsAutosynthesized) llvm
::dbgs() << "Using autosynthesized body for " << FD
->getName() << "\n"; }; } } while (false)
545 << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("static-analyzer-call-event")) { { if (IsAutosynthesized) llvm
::dbgs() << "Using autosynthesized body for " << FD
->getName() << "\n"; }; } } while (false)
546 })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("static-analyzer-call-event")) { { if (IsAutosynthesized) llvm
::dbgs() << "Using autosynthesized body for " << FD
->getName() << "\n"; }; } } while (false)
;
547 if (Body) {
12
Assuming 'Body' is null
13
Taking false branch
548 const Decl* Decl = AD->getDecl();
549 return RuntimeDefinition(Decl);
550 }
551
552 SubEngine &Engine = getState()->getStateManager().getOwningEngine();
553 AnalyzerOptions &Opts = Engine.getAnalysisManager().options;
554
555 // Try to get CTU definition only if CTUDir is provided.
556 if (!Opts.IsNaiveCTUEnabled)
14
Assuming the condition is false
15
Taking false branch
557 return {};
558
559 cross_tu::CrossTranslationUnitContext &CTUCtx =
560 *Engine.getCrossTranslationUnitContext();
561 llvm::Expected<const FunctionDecl *> CTUDeclOrError =
562 CTUCtx.getCrossTUDefinition(FD, Opts.CTUDir, Opts.CTUIndexName,
563 Opts.DisplayCTUProgress);
564
565 if (!CTUDeclOrError) {
16
Taking true branch
566 handleAllErrors(CTUDeclOrError.takeError(),
17
Calling 'handleAllErrors<(lambda at /build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp:567:21)>'
567 [&](const cross_tu::IndexError &IE) {
568 CTUCtx.emitCrossTUDiagnostics(IE);
569 });
570 return {};
571 }
572
573 return RuntimeDefinition(*CTUDeclOrError);
574}
575
576void AnyFunctionCall::getInitialStackFrameContents(
577 const StackFrameContext *CalleeCtx,
578 BindingsTy &Bindings) const {
579 const auto *D = cast<FunctionDecl>(CalleeCtx->getDecl());
580 SValBuilder &SVB = getState()->getStateManager().getSValBuilder();
581 addParameterValuesToBindings(CalleeCtx, Bindings, SVB, *this,
582 D->parameters());
583}
584
585bool AnyFunctionCall::argumentsMayEscape() const {
586 if (CallEvent::argumentsMayEscape() || hasVoidPointerToNonConstArg())
587 return true;
588
589 const FunctionDecl *D = getDecl();
590 if (!D)
591 return true;
592
593 const IdentifierInfo *II = D->getIdentifier();
594 if (!II)
595 return false;
596
597 // This set of "escaping" APIs is
598
599 // - 'int pthread_setspecific(ptheread_key k, const void *)' stores a
600 // value into thread local storage. The value can later be retrieved with
601 // 'void *ptheread_getspecific(pthread_key)'. So even thought the
602 // parameter is 'const void *', the region escapes through the call.
603 if (II->isStr("pthread_setspecific"))
604 return true;
605
606 // - xpc_connection_set_context stores a value which can be retrieved later
607 // with xpc_connection_get_context.
608 if (II->isStr("xpc_connection_set_context"))
609 return true;
610
611 // - funopen - sets a buffer for future IO calls.
612 if (II->isStr("funopen"))
613 return true;
614
615 // - __cxa_demangle - can reallocate memory and can return the pointer to
616 // the input buffer.
617 if (II->isStr("__cxa_demangle"))
618 return true;
619
620 StringRef FName = II->getName();
621
622 // - CoreFoundation functions that end with "NoCopy" can free a passed-in
623 // buffer even if it is const.
624 if (FName.endswith("NoCopy"))
625 return true;
626
627 // - NSXXInsertXX, for example NSMapInsertIfAbsent, since they can
628 // be deallocated by NSMapRemove.
629 if (FName.startswith("NS") && (FName.find("Insert") != StringRef::npos))
630 return true;
631
632 // - Many CF containers allow objects to escape through custom
633 // allocators/deallocators upon container construction. (PR12101)
634 if (FName.startswith("CF") || FName.startswith("CG")) {
635 return StrInStrNoCase(FName, "InsertValue") != StringRef::npos ||
636 StrInStrNoCase(FName, "AddValue") != StringRef::npos ||
637 StrInStrNoCase(FName, "SetValue") != StringRef::npos ||
638 StrInStrNoCase(FName, "WithData") != StringRef::npos ||
639 StrInStrNoCase(FName, "AppendValue") != StringRef::npos ||
640 StrInStrNoCase(FName, "SetAttribute") != StringRef::npos;
641 }
642
643 return false;
644}
645
646const FunctionDecl *SimpleFunctionCall::getDecl() const {
647 const FunctionDecl *D = getOriginExpr()->getDirectCallee();
648 if (D)
649 return D;
650
651 return getSVal(getOriginExpr()->getCallee()).getAsFunctionDecl();
652}
653
654const FunctionDecl *CXXInstanceCall::getDecl() const {
655 const auto *CE = cast_or_null<CallExpr>(getOriginExpr());
656 if (!CE)
657 return AnyFunctionCall::getDecl();
658
659 const FunctionDecl *D = CE->getDirectCallee();
660 if (D)
661 return D;
662
663 return getSVal(CE->getCallee()).getAsFunctionDecl();
664}
665
666void CXXInstanceCall::getExtraInvalidatedValues(
667 ValueList &Values, RegionAndSymbolInvalidationTraits *ETraits) const {
668 SVal ThisVal = getCXXThisVal();
669 Values.push_back(ThisVal);
670
671 // Don't invalidate if the method is const and there are no mutable fields.
672 if (const auto *D = cast_or_null<CXXMethodDecl>(getDecl())) {
673 if (!D->isConst())
674 return;
675 // Get the record decl for the class of 'This'. D->getParent() may return a
676 // base class decl, rather than the class of the instance which needs to be
677 // checked for mutable fields.
678 // TODO: We might as well look at the dynamic type of the object.
679 const Expr *Ex = getCXXThisExpr()->ignoreParenBaseCasts();
680 QualType T = Ex->getType();
681 if (T->isPointerType()) // Arrow or implicit-this syntax?
682 T = T->getPointeeType();
683 const CXXRecordDecl *ParentRecord = T->getAsCXXRecordDecl();
684 assert(ParentRecord)((ParentRecord) ? static_cast<void> (0) : __assert_fail
("ParentRecord", "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 684, __PRETTY_FUNCTION__))
;
685 if (ParentRecord->hasMutableFields())
686 return;
687 // Preserve CXXThis.
688 const MemRegion *ThisRegion = ThisVal.getAsRegion();
689 if (!ThisRegion)
690 return;
691
692 ETraits->setTrait(ThisRegion->getBaseRegion(),
693 RegionAndSymbolInvalidationTraits::TK_PreserveContents);
694 }
695}
696
697SVal CXXInstanceCall::getCXXThisVal() const {
698 const Expr *Base = getCXXThisExpr();
699 // FIXME: This doesn't handle an overloaded ->* operator.
700 if (!Base)
701 return UnknownVal();
702
703 SVal ThisVal = getSVal(Base);
704 assert(ThisVal.isUnknownOrUndef() || ThisVal.getAs<Loc>())((ThisVal.isUnknownOrUndef() || ThisVal.getAs<Loc>()) ?
static_cast<void> (0) : __assert_fail ("ThisVal.isUnknownOrUndef() || ThisVal.getAs<Loc>()"
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 704, __PRETTY_FUNCTION__))
;
705 return ThisVal;
706}
707
708RuntimeDefinition CXXInstanceCall::getRuntimeDefinition() const {
709 // Do we have a decl at all?
710 const Decl *D = getDecl();
711 if (!D)
4
Assuming 'D' is non-null
5
Taking false branch
712 return {};
713
714 // If the method is non-virtual, we know we can inline it.
715 const auto *MD = cast<CXXMethodDecl>(D);
716 if (!MD->isVirtual())
6
Taking true branch
717 return AnyFunctionCall::getRuntimeDefinition();
7
Calling 'AnyFunctionCall::getRuntimeDefinition'
718
719 // Do we know the implicit 'this' object being called?
720 const MemRegion *R = getCXXThisVal().getAsRegion();
721 if (!R)
722 return {};
723
724 // Do we know anything about the type of 'this'?
725 DynamicTypeInfo DynType = getDynamicTypeInfo(getState(), R);
726 if (!DynType.isValid())
727 return {};
728
729 // Is the type a C++ class? (This is mostly a defensive check.)
730 QualType RegionType = DynType.getType()->getPointeeType();
731 assert(!RegionType.isNull() && "DynamicTypeInfo should always be a pointer.")((!RegionType.isNull() && "DynamicTypeInfo should always be a pointer."
) ? static_cast<void> (0) : __assert_fail ("!RegionType.isNull() && \"DynamicTypeInfo should always be a pointer.\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 731, __PRETTY_FUNCTION__))
;
732
733 const CXXRecordDecl *RD = RegionType->getAsCXXRecordDecl();
734 if (!RD || !RD->hasDefinition())
735 return {};
736
737 // Find the decl for this method in that class.
738 const CXXMethodDecl *Result = MD->getCorrespondingMethodInClass(RD, true);
739 if (!Result) {
740 // We might not even get the original statically-resolved method due to
741 // some particularly nasty casting (e.g. casts to sister classes).
742 // However, we should at least be able to search up and down our own class
743 // hierarchy, and some real bugs have been caught by checking this.
744 assert(!RD->isDerivedFrom(MD->getParent()) && "Couldn't find known method")((!RD->isDerivedFrom(MD->getParent()) && "Couldn't find known method"
) ? static_cast<void> (0) : __assert_fail ("!RD->isDerivedFrom(MD->getParent()) && \"Couldn't find known method\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 744, __PRETTY_FUNCTION__))
;
745
746 // FIXME: This is checking that our DynamicTypeInfo is at least as good as
747 // the static type. However, because we currently don't update
748 // DynamicTypeInfo when an object is cast, we can't actually be sure the
749 // DynamicTypeInfo is up to date. This assert should be re-enabled once
750 // this is fixed. <rdar://problem/12287087>
751 //assert(!MD->getParent()->isDerivedFrom(RD) && "Bad DynamicTypeInfo");
752
753 return {};
754 }
755
756 // Does the decl that we found have an implementation?
757 const FunctionDecl *Definition;
758 if (!Result->hasBody(Definition))
759 return {};
760
761 // We found a definition. If we're not sure that this devirtualization is
762 // actually what will happen at runtime, make sure to provide the region so
763 // that ExprEngine can decide what to do with it.
764 if (DynType.canBeASubClass())
765 return RuntimeDefinition(Definition, R->StripCasts());
766 return RuntimeDefinition(Definition, /*DispatchRegion=*/nullptr);
767}
768
769void CXXInstanceCall::getInitialStackFrameContents(
770 const StackFrameContext *CalleeCtx,
771 BindingsTy &Bindings) const {
772 AnyFunctionCall::getInitialStackFrameContents(CalleeCtx, Bindings);
773
774 // Handle the binding of 'this' in the new stack frame.
775 SVal ThisVal = getCXXThisVal();
776 if (!ThisVal.isUnknown()) {
777 ProgramStateManager &StateMgr = getState()->getStateManager();
778 SValBuilder &SVB = StateMgr.getSValBuilder();
779
780 const auto *MD = cast<CXXMethodDecl>(CalleeCtx->getDecl());
781 Loc ThisLoc = SVB.getCXXThis(MD, CalleeCtx);
782
783 // If we devirtualized to a different member function, we need to make sure
784 // we have the proper layering of CXXBaseObjectRegions.
785 if (MD->getCanonicalDecl() != getDecl()->getCanonicalDecl()) {
786 ASTContext &Ctx = SVB.getContext();
787 const CXXRecordDecl *Class = MD->getParent();
788 QualType Ty = Ctx.getPointerType(Ctx.getRecordType(Class));
789
790 // FIXME: CallEvent maybe shouldn't be directly accessing StoreManager.
791 bool Failed;
792 ThisVal = StateMgr.getStoreManager().attemptDownCast(ThisVal, Ty, Failed);
793 if (Failed) {
794 // We might have suffered some sort of placement new earlier, so
795 // we're constructing in a completely unexpected storage.
796 // Fall back to a generic pointer cast for this-value.
797 const CXXMethodDecl *StaticMD = cast<CXXMethodDecl>(getDecl());
798 const CXXRecordDecl *StaticClass = StaticMD->getParent();
799 QualType StaticTy = Ctx.getPointerType(Ctx.getRecordType(StaticClass));
800 ThisVal = SVB.evalCast(ThisVal, Ty, StaticTy);
801 }
802 }
803
804 if (!ThisVal.isUnknown())
805 Bindings.push_back(std::make_pair(ThisLoc, ThisVal));
806 }
807}
808
809const Expr *CXXMemberCall::getCXXThisExpr() const {
810 return getOriginExpr()->getImplicitObjectArgument();
811}
812
813RuntimeDefinition CXXMemberCall::getRuntimeDefinition() const {
814 // C++11 [expr.call]p1: ...If the selected function is non-virtual, or if the
815 // id-expression in the class member access expression is a qualified-id,
816 // that function is called. Otherwise, its final overrider in the dynamic type
817 // of the object expression is called.
818 if (const auto *ME = dyn_cast<MemberExpr>(getOriginExpr()->getCallee()))
819 if (ME->hasQualifier())
820 return AnyFunctionCall::getRuntimeDefinition();
821
822 return CXXInstanceCall::getRuntimeDefinition();
823}
824
825const Expr *CXXMemberOperatorCall::getCXXThisExpr() const {
826 return getOriginExpr()->getArg(0);
827}
828
829const BlockDataRegion *BlockCall::getBlockRegion() const {
830 const Expr *Callee = getOriginExpr()->getCallee();
831 const MemRegion *DataReg = getSVal(Callee).getAsRegion();
832
833 return dyn_cast_or_null<BlockDataRegion>(DataReg);
834}
835
836ArrayRef<ParmVarDecl*> BlockCall::parameters() const {
837 const BlockDecl *D = getDecl();
838 if (!D)
839 return None;
840 return D->parameters();
841}
842
843void BlockCall::getExtraInvalidatedValues(ValueList &Values,
844 RegionAndSymbolInvalidationTraits *ETraits) const {
845 // FIXME: This also needs to invalidate captured globals.
846 if (const MemRegion *R = getBlockRegion())
847 Values.push_back(loc::MemRegionVal(R));
848}
849
850void BlockCall::getInitialStackFrameContents(const StackFrameContext *CalleeCtx,
851 BindingsTy &Bindings) const {
852 SValBuilder &SVB = getState()->getStateManager().getSValBuilder();
853 ArrayRef<ParmVarDecl*> Params;
854 if (isConversionFromLambda()) {
855 auto *LambdaOperatorDecl = cast<CXXMethodDecl>(CalleeCtx->getDecl());
856 Params = LambdaOperatorDecl->parameters();
857
858 // For blocks converted from a C++ lambda, the callee declaration is the
859 // operator() method on the lambda so we bind "this" to
860 // the lambda captured by the block.
861 const VarRegion *CapturedLambdaRegion = getRegionStoringCapturedLambda();
862 SVal ThisVal = loc::MemRegionVal(CapturedLambdaRegion);
863 Loc ThisLoc = SVB.getCXXThis(LambdaOperatorDecl, CalleeCtx);
864 Bindings.push_back(std::make_pair(ThisLoc, ThisVal));
865 } else {
866 Params = cast<BlockDecl>(CalleeCtx->getDecl())->parameters();
867 }
868
869 addParameterValuesToBindings(CalleeCtx, Bindings, SVB, *this,
870 Params);
871}
872
873SVal CXXConstructorCall::getCXXThisVal() const {
874 if (Data)
875 return loc::MemRegionVal(static_cast<const MemRegion *>(Data));
876 return UnknownVal();
877}
878
879void CXXConstructorCall::getExtraInvalidatedValues(ValueList &Values,
880 RegionAndSymbolInvalidationTraits *ETraits) const {
881 if (Data) {
882 loc::MemRegionVal MV(static_cast<const MemRegion *>(Data));
883 if (SymbolRef Sym = MV.getAsSymbol(true))
884 ETraits->setTrait(Sym,
885 RegionAndSymbolInvalidationTraits::TK_SuppressEscape);
886 Values.push_back(MV);
887 }
888}
889
890void CXXConstructorCall::getInitialStackFrameContents(
891 const StackFrameContext *CalleeCtx,
892 BindingsTy &Bindings) const {
893 AnyFunctionCall::getInitialStackFrameContents(CalleeCtx, Bindings);
894
895 SVal ThisVal = getCXXThisVal();
896 if (!ThisVal.isUnknown()) {
897 SValBuilder &SVB = getState()->getStateManager().getSValBuilder();
898 const auto *MD = cast<CXXMethodDecl>(CalleeCtx->getDecl());
899 Loc ThisLoc = SVB.getCXXThis(MD, CalleeCtx);
900 Bindings.push_back(std::make_pair(ThisLoc, ThisVal));
901 }
902}
903
904SVal CXXDestructorCall::getCXXThisVal() const {
905 if (Data)
906 return loc::MemRegionVal(DtorDataTy::getFromOpaqueValue(Data).getPointer());
907 return UnknownVal();
908}
909
910RuntimeDefinition CXXDestructorCall::getRuntimeDefinition() const {
911 // Base destructors are always called non-virtually.
912 // Skip CXXInstanceCall's devirtualization logic in this case.
913 if (isBaseDestructor())
1
Assuming the condition is false
2
Taking false branch
914 return AnyFunctionCall::getRuntimeDefinition();
915
916 return CXXInstanceCall::getRuntimeDefinition();
3
Calling 'CXXInstanceCall::getRuntimeDefinition'
917}
918
919ArrayRef<ParmVarDecl*> ObjCMethodCall::parameters() const {
920 const ObjCMethodDecl *D = getDecl();
921 if (!D)
922 return None;
923 return D->parameters();
924}
925
926void ObjCMethodCall::getExtraInvalidatedValues(
927 ValueList &Values, RegionAndSymbolInvalidationTraits *ETraits) const {
928
929 // If the method call is a setter for property known to be backed by
930 // an instance variable, don't invalidate the entire receiver, just
931 // the storage for that instance variable.
932 if (const ObjCPropertyDecl *PropDecl = getAccessedProperty()) {
933 if (const ObjCIvarDecl *PropIvar = PropDecl->getPropertyIvarDecl()) {
934 SVal IvarLVal = getState()->getLValue(PropIvar, getReceiverSVal());
935 if (const MemRegion *IvarRegion = IvarLVal.getAsRegion()) {
936 ETraits->setTrait(
937 IvarRegion,
938 RegionAndSymbolInvalidationTraits::TK_DoNotInvalidateSuperRegion);
939 ETraits->setTrait(
940 IvarRegion,
941 RegionAndSymbolInvalidationTraits::TK_SuppressEscape);
942 Values.push_back(IvarLVal);
943 }
944 return;
945 }
946 }
947
948 Values.push_back(getReceiverSVal());
949}
950
951SVal ObjCMethodCall::getSelfSVal() const {
952 const LocationContext *LCtx = getLocationContext();
953 const ImplicitParamDecl *SelfDecl = LCtx->getSelfDecl();
954 if (!SelfDecl)
955 return SVal();
956 return getState()->getSVal(getState()->getRegion(SelfDecl, LCtx));
957}
958
959SVal ObjCMethodCall::getReceiverSVal() const {
960 // FIXME: Is this the best way to handle class receivers?
961 if (!isInstanceMessage())
962 return UnknownVal();
963
964 if (const Expr *RecE = getOriginExpr()->getInstanceReceiver())
965 return getSVal(RecE);
966
967 // An instance message with no expression means we are sending to super.
968 // In this case the object reference is the same as 'self'.
969 assert(getOriginExpr()->getReceiverKind() == ObjCMessageExpr::SuperInstance)((getOriginExpr()->getReceiverKind() == ObjCMessageExpr::SuperInstance
) ? static_cast<void> (0) : __assert_fail ("getOriginExpr()->getReceiverKind() == ObjCMessageExpr::SuperInstance"
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 969, __PRETTY_FUNCTION__))
;
970 SVal SelfVal = getSelfSVal();
971 assert(SelfVal.isValid() && "Calling super but not in ObjC method")((SelfVal.isValid() && "Calling super but not in ObjC method"
) ? static_cast<void> (0) : __assert_fail ("SelfVal.isValid() && \"Calling super but not in ObjC method\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 971, __PRETTY_FUNCTION__))
;
972 return SelfVal;
973}
974
975bool ObjCMethodCall::isReceiverSelfOrSuper() const {
976 if (getOriginExpr()->getReceiverKind() == ObjCMessageExpr::SuperInstance ||
977 getOriginExpr()->getReceiverKind() == ObjCMessageExpr::SuperClass)
978 return true;
979
980 if (!isInstanceMessage())
981 return false;
982
983 SVal RecVal = getSVal(getOriginExpr()->getInstanceReceiver());
984
985 return (RecVal == getSelfSVal());
986}
987
988SourceRange ObjCMethodCall::getSourceRange() const {
989 switch (getMessageKind()) {
990 case OCM_Message:
991 return getOriginExpr()->getSourceRange();
992 case OCM_PropertyAccess:
993 case OCM_Subscript:
994 return getContainingPseudoObjectExpr()->getSourceRange();
995 }
996 llvm_unreachable("unknown message kind")::llvm::llvm_unreachable_internal("unknown message kind", "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 996)
;
997}
998
999using ObjCMessageDataTy = llvm::PointerIntPair<const PseudoObjectExpr *, 2>;
1000
1001const PseudoObjectExpr *ObjCMethodCall::getContainingPseudoObjectExpr() const {
1002 assert(Data && "Lazy lookup not yet performed.")((Data && "Lazy lookup not yet performed.") ? static_cast
<void> (0) : __assert_fail ("Data && \"Lazy lookup not yet performed.\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1002, __PRETTY_FUNCTION__))
;
1003 assert(getMessageKind() != OCM_Message && "Explicit message send.")((getMessageKind() != OCM_Message && "Explicit message send."
) ? static_cast<void> (0) : __assert_fail ("getMessageKind() != OCM_Message && \"Explicit message send.\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1003, __PRETTY_FUNCTION__))
;
1004 return ObjCMessageDataTy::getFromOpaqueValue(Data).getPointer();
1005}
1006
1007static const Expr *
1008getSyntacticFromForPseudoObjectExpr(const PseudoObjectExpr *POE) {
1009 const Expr *Syntactic = POE->getSyntacticForm();
1010
1011 // This handles the funny case of assigning to the result of a getter.
1012 // This can happen if the getter returns a non-const reference.
1013 if (const auto *BO = dyn_cast<BinaryOperator>(Syntactic))
1014 Syntactic = BO->getLHS();
1015
1016 return Syntactic;
1017}
1018
1019ObjCMessageKind ObjCMethodCall::getMessageKind() const {
1020 if (!Data) {
1021 // Find the parent, ignoring implicit casts.
1022 ParentMap &PM = getLocationContext()->getParentMap();
1023 const Stmt *S = PM.getParentIgnoreParenCasts(getOriginExpr());
1024
1025 // Check if parent is a PseudoObjectExpr.
1026 if (const auto *POE = dyn_cast_or_null<PseudoObjectExpr>(S)) {
1027 const Expr *Syntactic = getSyntacticFromForPseudoObjectExpr(POE);
1028
1029 ObjCMessageKind K;
1030 switch (Syntactic->getStmtClass()) {
1031 case Stmt::ObjCPropertyRefExprClass:
1032 K = OCM_PropertyAccess;
1033 break;
1034 case Stmt::ObjCSubscriptRefExprClass:
1035 K = OCM_Subscript;
1036 break;
1037 default:
1038 // FIXME: Can this ever happen?
1039 K = OCM_Message;
1040 break;
1041 }
1042
1043 if (K != OCM_Message) {
1044 const_cast<ObjCMethodCall *>(this)->Data
1045 = ObjCMessageDataTy(POE, K).getOpaqueValue();
1046 assert(getMessageKind() == K)((getMessageKind() == K) ? static_cast<void> (0) : __assert_fail
("getMessageKind() == K", "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1046, __PRETTY_FUNCTION__))
;
1047 return K;
1048 }
1049 }
1050
1051 const_cast<ObjCMethodCall *>(this)->Data
1052 = ObjCMessageDataTy(nullptr, 1).getOpaqueValue();
1053 assert(getMessageKind() == OCM_Message)((getMessageKind() == OCM_Message) ? static_cast<void> (
0) : __assert_fail ("getMessageKind() == OCM_Message", "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1053, __PRETTY_FUNCTION__))
;
1054 return OCM_Message;
1055 }
1056
1057 ObjCMessageDataTy Info = ObjCMessageDataTy::getFromOpaqueValue(Data);
1058 if (!Info.getPointer())
1059 return OCM_Message;
1060 return static_cast<ObjCMessageKind>(Info.getInt());
1061}
1062
1063const ObjCPropertyDecl *ObjCMethodCall::getAccessedProperty() const {
1064 // Look for properties accessed with property syntax (foo.bar = ...)
1065 if ( getMessageKind() == OCM_PropertyAccess) {
1066 const PseudoObjectExpr *POE = getContainingPseudoObjectExpr();
1067 assert(POE && "Property access without PseudoObjectExpr?")((POE && "Property access without PseudoObjectExpr?")
? static_cast<void> (0) : __assert_fail ("POE && \"Property access without PseudoObjectExpr?\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1067, __PRETTY_FUNCTION__))
;
1068
1069 const Expr *Syntactic = getSyntacticFromForPseudoObjectExpr(POE);
1070 auto *RefExpr = cast<ObjCPropertyRefExpr>(Syntactic);
1071
1072 if (RefExpr->isExplicitProperty())
1073 return RefExpr->getExplicitProperty();
1074 }
1075
1076 // Look for properties accessed with method syntax ([foo setBar:...]).
1077 const ObjCMethodDecl *MD = getDecl();
1078 if (!MD || !MD->isPropertyAccessor())
1079 return nullptr;
1080
1081 // Note: This is potentially quite slow.
1082 return MD->findPropertyDecl();
1083}
1084
1085bool ObjCMethodCall::canBeOverridenInSubclass(ObjCInterfaceDecl *IDecl,
1086 Selector Sel) const {
1087 assert(IDecl)((IDecl) ? static_cast<void> (0) : __assert_fail ("IDecl"
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1087, __PRETTY_FUNCTION__))
;
1088 AnalysisManager &AMgr =
1089 getState()->getStateManager().getOwningEngine().getAnalysisManager();
1090 // If the class interface is declared inside the main file, assume it is not
1091 // subcassed.
1092 // TODO: It could actually be subclassed if the subclass is private as well.
1093 // This is probably very rare.
1094 SourceLocation InterfLoc = IDecl->getEndOfDefinitionLoc();
1095 if (InterfLoc.isValid() && AMgr.isInCodeFile(InterfLoc))
1096 return false;
1097
1098 // Assume that property accessors are not overridden.
1099 if (getMessageKind() == OCM_PropertyAccess)
1100 return false;
1101
1102 // We assume that if the method is public (declared outside of main file) or
1103 // has a parent which publicly declares the method, the method could be
1104 // overridden in a subclass.
1105
1106 // Find the first declaration in the class hierarchy that declares
1107 // the selector.
1108 ObjCMethodDecl *D = nullptr;
1109 while (true) {
1110 D = IDecl->lookupMethod(Sel, true);
1111
1112 // Cannot find a public definition.
1113 if (!D)
1114 return false;
1115
1116 // If outside the main file,
1117 if (D->getLocation().isValid() && !AMgr.isInCodeFile(D->getLocation()))
1118 return true;
1119
1120 if (D->isOverriding()) {
1121 // Search in the superclass on the next iteration.
1122 IDecl = D->getClassInterface();
1123 if (!IDecl)
1124 return false;
1125
1126 IDecl = IDecl->getSuperClass();
1127 if (!IDecl)
1128 return false;
1129
1130 continue;
1131 }
1132
1133 return false;
1134 };
1135
1136 llvm_unreachable("The while loop should always terminate.")::llvm::llvm_unreachable_internal("The while loop should always terminate."
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1136)
;
1137}
1138
1139static const ObjCMethodDecl *findDefiningRedecl(const ObjCMethodDecl *MD) {
1140 if (!MD)
1141 return MD;
1142
1143 // Find the redeclaration that defines the method.
1144 if (!MD->hasBody()) {
1145 for (auto I : MD->redecls())
1146 if (I->hasBody())
1147 MD = cast<ObjCMethodDecl>(I);
1148 }
1149 return MD;
1150}
1151
1152static bool isCallToSelfClass(const ObjCMessageExpr *ME) {
1153 const Expr* InstRec = ME->getInstanceReceiver();
1154 if (!InstRec)
1155 return false;
1156 const auto *InstRecIg = dyn_cast<DeclRefExpr>(InstRec->IgnoreParenImpCasts());
1157
1158 // Check that receiver is called 'self'.
1159 if (!InstRecIg || !InstRecIg->getFoundDecl() ||
1160 !InstRecIg->getFoundDecl()->getName().equals("self"))
1161 return false;
1162
1163 // Check that the method name is 'class'.
1164 if (ME->getSelector().getNumArgs() != 0 ||
1165 !ME->getSelector().getNameForSlot(0).equals("class"))
1166 return false;
1167
1168 return true;
1169}
1170
1171RuntimeDefinition ObjCMethodCall::getRuntimeDefinition() const {
1172 const ObjCMessageExpr *E = getOriginExpr();
1173 assert(E)((E) ? static_cast<void> (0) : __assert_fail ("E", "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1173, __PRETTY_FUNCTION__))
;
1174 Selector Sel = E->getSelector();
1175
1176 if (E->isInstanceMessage()) {
1177 // Find the receiver type.
1178 const ObjCObjectPointerType *ReceiverT = nullptr;
1179 bool CanBeSubClassed = false;
1180 QualType SupersType = E->getSuperType();
1181 const MemRegion *Receiver = nullptr;
1182
1183 if (!SupersType.isNull()) {
1184 // The receiver is guaranteed to be 'super' in this case.
1185 // Super always means the type of immediate predecessor to the method
1186 // where the call occurs.
1187 ReceiverT = cast<ObjCObjectPointerType>(SupersType);
1188 } else {
1189 Receiver = getReceiverSVal().getAsRegion();
1190 if (!Receiver)
1191 return {};
1192
1193 DynamicTypeInfo DTI = getDynamicTypeInfo(getState(), Receiver);
1194 if (!DTI.isValid()) {
1195 assert(isa<AllocaRegion>(Receiver) &&((isa<AllocaRegion>(Receiver) && "Unhandled untyped region class!"
) ? static_cast<void> (0) : __assert_fail ("isa<AllocaRegion>(Receiver) && \"Unhandled untyped region class!\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1196, __PRETTY_FUNCTION__))
1196 "Unhandled untyped region class!")((isa<AllocaRegion>(Receiver) && "Unhandled untyped region class!"
) ? static_cast<void> (0) : __assert_fail ("isa<AllocaRegion>(Receiver) && \"Unhandled untyped region class!\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1196, __PRETTY_FUNCTION__))
;
1197 return {};
1198 }
1199
1200 QualType DynType = DTI.getType();
1201 CanBeSubClassed = DTI.canBeASubClass();
1202 ReceiverT = dyn_cast<ObjCObjectPointerType>(DynType.getCanonicalType());
1203
1204 if (ReceiverT && CanBeSubClassed)
1205 if (ObjCInterfaceDecl *IDecl = ReceiverT->getInterfaceDecl())
1206 if (!canBeOverridenInSubclass(IDecl, Sel))
1207 CanBeSubClassed = false;
1208 }
1209
1210 // Handle special cases of '[self classMethod]' and
1211 // '[[self class] classMethod]', which are treated by the compiler as
1212 // instance (not class) messages. We will statically dispatch to those.
1213 if (auto *PT = dyn_cast_or_null<ObjCObjectPointerType>(ReceiverT)) {
1214 // For [self classMethod], return the compiler visible declaration.
1215 if (PT->getObjectType()->isObjCClass() &&
1216 Receiver == getSelfSVal().getAsRegion())
1217 return RuntimeDefinition(findDefiningRedecl(E->getMethodDecl()));
1218
1219 // Similarly, handle [[self class] classMethod].
1220 // TODO: We are currently doing a syntactic match for this pattern with is
1221 // limiting as the test cases in Analysis/inlining/InlineObjCClassMethod.m
1222 // shows. A better way would be to associate the meta type with the symbol
1223 // using the dynamic type info tracking and use it here. We can add a new
1224 // SVal for ObjC 'Class' values that know what interface declaration they
1225 // come from. Then 'self' in a class method would be filled in with
1226 // something meaningful in ObjCMethodCall::getReceiverSVal() and we could
1227 // do proper dynamic dispatch for class methods just like we do for
1228 // instance methods now.
1229 if (E->getInstanceReceiver())
1230 if (const auto *M = dyn_cast<ObjCMessageExpr>(E->getInstanceReceiver()))
1231 if (isCallToSelfClass(M))
1232 return RuntimeDefinition(findDefiningRedecl(E->getMethodDecl()));
1233 }
1234
1235 // Lookup the instance method implementation.
1236 if (ReceiverT)
1237 if (ObjCInterfaceDecl *IDecl = ReceiverT->getInterfaceDecl()) {
1238 // Repeatedly calling lookupPrivateMethod() is expensive, especially
1239 // when in many cases it returns null. We cache the results so
1240 // that repeated queries on the same ObjCIntefaceDecl and Selector
1241 // don't incur the same cost. On some test cases, we can see the
1242 // same query being issued thousands of times.
1243 //
1244 // NOTE: This cache is essentially a "global" variable, but it
1245 // only gets lazily created when we get here. The value of the
1246 // cache probably comes from it being global across ExprEngines,
1247 // where the same queries may get issued. If we are worried about
1248 // concurrency, or possibly loading/unloading ASTs, etc., we may
1249 // need to revisit this someday. In terms of memory, this table
1250 // stays around until clang quits, which also may be bad if we
1251 // need to release memory.
1252 using PrivateMethodKey = std::pair<const ObjCInterfaceDecl *, Selector>;
1253 using PrivateMethodCache =
1254 llvm::DenseMap<PrivateMethodKey, Optional<const ObjCMethodDecl *>>;
1255
1256 static PrivateMethodCache PMC;
1257 Optional<const ObjCMethodDecl *> &Val = PMC[std::make_pair(IDecl, Sel)];
1258
1259 // Query lookupPrivateMethod() if the cache does not hit.
1260 if (!Val.hasValue()) {
1261 Val = IDecl->lookupPrivateMethod(Sel);
1262
1263 // If the method is a property accessor, we should try to "inline" it
1264 // even if we don't actually have an implementation.
1265 if (!*Val)
1266 if (const ObjCMethodDecl *CompileTimeMD = E->getMethodDecl())
1267 if (CompileTimeMD->isPropertyAccessor()) {
1268 if (!CompileTimeMD->getSelfDecl() &&
1269 isa<ObjCCategoryDecl>(CompileTimeMD->getDeclContext())) {
1270 // If the method is an accessor in a category, and it doesn't
1271 // have a self declaration, first
1272 // try to find the method in a class extension. This
1273 // works around a bug in Sema where multiple accessors
1274 // are synthesized for properties in class
1275 // extensions that are redeclared in a category and the
1276 // the implicit parameters are not filled in for
1277 // the method on the category.
1278 // This ensures we find the accessor in the extension, which
1279 // has the implicit parameters filled in.
1280 auto *ID = CompileTimeMD->getClassInterface();
1281 for (auto *CatDecl : ID->visible_extensions()) {
1282 Val = CatDecl->getMethod(Sel,
1283 CompileTimeMD->isInstanceMethod());
1284 if (*Val)
1285 break;
1286 }
1287 }
1288 if (!*Val)
1289 Val = IDecl->lookupInstanceMethod(Sel);
1290 }
1291 }
1292
1293 const ObjCMethodDecl *MD = Val.getValue();
1294 if (CanBeSubClassed)
1295 return RuntimeDefinition(MD, Receiver);
1296 else
1297 return RuntimeDefinition(MD, nullptr);
1298 }
1299 } else {
1300 // This is a class method.
1301 // If we have type info for the receiver class, we are calling via
1302 // class name.
1303 if (ObjCInterfaceDecl *IDecl = E->getReceiverInterface()) {
1304 // Find/Return the method implementation.
1305 return RuntimeDefinition(IDecl->lookupPrivateClassMethod(Sel));
1306 }
1307 }
1308
1309 return {};
1310}
1311
1312bool ObjCMethodCall::argumentsMayEscape() const {
1313 if (isInSystemHeader() && !isInstanceMessage()) {
1314 Selector Sel = getSelector();
1315 if (Sel.getNumArgs() == 1 &&
1316 Sel.getIdentifierInfoForSlot(0)->isStr("valueWithPointer"))
1317 return true;
1318 }
1319
1320 return CallEvent::argumentsMayEscape();
1321}
1322
1323void ObjCMethodCall::getInitialStackFrameContents(
1324 const StackFrameContext *CalleeCtx,
1325 BindingsTy &Bindings) const {
1326 const auto *D = cast<ObjCMethodDecl>(CalleeCtx->getDecl());
1327 SValBuilder &SVB = getState()->getStateManager().getSValBuilder();
1328 addParameterValuesToBindings(CalleeCtx, Bindings, SVB, *this,
1329 D->parameters());
1330
1331 SVal SelfVal = getReceiverSVal();
1332 if (!SelfVal.isUnknown()) {
1333 const VarDecl *SelfD = CalleeCtx->getAnalysisDeclContext()->getSelfDecl();
1334 MemRegionManager &MRMgr = SVB.getRegionManager();
1335 Loc SelfLoc = SVB.makeLoc(MRMgr.getVarRegion(SelfD, CalleeCtx));
1336 Bindings.push_back(std::make_pair(SelfLoc, SelfVal));
1337 }
1338}
1339
1340CallEventRef<>
1341CallEventManager::getSimpleCall(const CallExpr *CE, ProgramStateRef State,
1342 const LocationContext *LCtx) {
1343 if (const auto *MCE = dyn_cast<CXXMemberCallExpr>(CE))
1344 return create<CXXMemberCall>(MCE, State, LCtx);
1345
1346 if (const auto *OpCE = dyn_cast<CXXOperatorCallExpr>(CE)) {
1347 const FunctionDecl *DirectCallee = OpCE->getDirectCallee();
1348 if (const auto *MD = dyn_cast<CXXMethodDecl>(DirectCallee))
1349 if (MD->isInstance())
1350 return create<CXXMemberOperatorCall>(OpCE, State, LCtx);
1351
1352 } else if (CE->getCallee()->getType()->isBlockPointerType()) {
1353 return create<BlockCall>(CE, State, LCtx);
1354 }
1355
1356 // Otherwise, it's a normal function call, static member function call, or
1357 // something we can't reason about.
1358 return create<SimpleFunctionCall>(CE, State, LCtx);
1359}
1360
1361CallEventRef<>
1362CallEventManager::getCaller(const StackFrameContext *CalleeCtx,
1363 ProgramStateRef State) {
1364 const LocationContext *ParentCtx = CalleeCtx->getParent();
1365 const LocationContext *CallerCtx = ParentCtx->getStackFrame();
1366 assert(CallerCtx && "This should not be used for top-level stack frames")((CallerCtx && "This should not be used for top-level stack frames"
) ? static_cast<void> (0) : __assert_fail ("CallerCtx && \"This should not be used for top-level stack frames\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1366, __PRETTY_FUNCTION__))
;
1367
1368 const Stmt *CallSite = CalleeCtx->getCallSite();
1369
1370 if (CallSite) {
1371 if (CallEventRef<> Out = getCall(CallSite, State, CallerCtx))
1372 return Out;
1373
1374 // All other cases are handled by getCall.
1375 assert(isa<CXXConstructExpr>(CallSite) &&((isa<CXXConstructExpr>(CallSite) && "This is not an inlineable statement"
) ? static_cast<void> (0) : __assert_fail ("isa<CXXConstructExpr>(CallSite) && \"This is not an inlineable statement\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1376, __PRETTY_FUNCTION__))
1376 "This is not an inlineable statement")((isa<CXXConstructExpr>(CallSite) && "This is not an inlineable statement"
) ? static_cast<void> (0) : __assert_fail ("isa<CXXConstructExpr>(CallSite) && \"This is not an inlineable statement\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1376, __PRETTY_FUNCTION__))
;
1377
1378 SValBuilder &SVB = State->getStateManager().getSValBuilder();
1379 const auto *Ctor = cast<CXXMethodDecl>(CalleeCtx->getDecl());
1380 Loc ThisPtr = SVB.getCXXThis(Ctor, CalleeCtx);
1381 SVal ThisVal = State->getSVal(ThisPtr);
1382
1383 return getCXXConstructorCall(cast<CXXConstructExpr>(CallSite),
1384 ThisVal.getAsRegion(), State, CallerCtx);
1385 }
1386
1387 // Fall back to the CFG. The only thing we haven't handled yet is
1388 // destructors, though this could change in the future.
1389 const CFGBlock *B = CalleeCtx->getCallSiteBlock();
1390 CFGElement E = (*B)[CalleeCtx->getIndex()];
1391 assert((E.getAs<CFGImplicitDtor>() || E.getAs<CFGTemporaryDtor>()) &&(((E.getAs<CFGImplicitDtor>() || E.getAs<CFGTemporaryDtor
>()) && "All other CFG elements should have exprs"
) ? static_cast<void> (0) : __assert_fail ("(E.getAs<CFGImplicitDtor>() || E.getAs<CFGTemporaryDtor>()) && \"All other CFG elements should have exprs\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1392, __PRETTY_FUNCTION__))
1392 "All other CFG elements should have exprs")(((E.getAs<CFGImplicitDtor>() || E.getAs<CFGTemporaryDtor
>()) && "All other CFG elements should have exprs"
) ? static_cast<void> (0) : __assert_fail ("(E.getAs<CFGImplicitDtor>() || E.getAs<CFGTemporaryDtor>()) && \"All other CFG elements should have exprs\""
, "/build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp"
, 1392, __PRETTY_FUNCTION__))
;
1393
1394 SValBuilder &SVB = State->getStateManager().getSValBuilder();
1395 const auto *Dtor = cast<CXXDestructorDecl>(CalleeCtx->getDecl());
1396 Loc ThisPtr = SVB.getCXXThis(Dtor, CalleeCtx);
1397 SVal ThisVal = State->getSVal(ThisPtr);
1398
1399 const Stmt *Trigger;
1400 if (Optional<CFGAutomaticObjDtor> AutoDtor = E.getAs<CFGAutomaticObjDtor>())
1401 Trigger = AutoDtor->getTriggerStmt();
1402 else if (Optional<CFGDeleteDtor> DeleteDtor = E.getAs<CFGDeleteDtor>())
1403 Trigger = DeleteDtor->getDeleteExpr();
1404 else
1405 Trigger = Dtor->getBody();
1406
1407 return getCXXDestructorCall(Dtor, Trigger, ThisVal.getAsRegion(),
1408 E.getAs<CFGBaseDtor>().hasValue(), State,
1409 CallerCtx);
1410}
1411
1412CallEventRef<> CallEventManager::getCall(const Stmt *S, ProgramStateRef State,
1413 const LocationContext *LC) {
1414 if (const auto *CE = dyn_cast<CallExpr>(S)) {
1415 return getSimpleCall(CE, State, LC);
1416 } else if (const auto *NE = dyn_cast<CXXNewExpr>(S)) {
1417 return getCXXAllocatorCall(NE, State, LC);
1418 } else if (const auto *ME = dyn_cast<ObjCMessageExpr>(S)) {
1419 return getObjCMethodCall(ME, State, LC);
1420 } else {
1421 return nullptr;
1422 }
1423}

/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h

1//===- llvm/Support/Error.h - Recoverable error handling --------*- C++ -*-===//
2//
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
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines an API used to report recoverable errors.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_SUPPORT_ERROR_H
14#define LLVM_SUPPORT_ERROR_H
15
16#include "llvm-c/Error.h"
17#include "llvm/ADT/STLExtras.h"
18#include "llvm/ADT/SmallVector.h"
19#include "llvm/ADT/StringExtras.h"
20#include "llvm/ADT/Twine.h"
21#include "llvm/Config/abi-breaking.h"
22#include "llvm/Support/AlignOf.h"
23#include "llvm/Support/Compiler.h"
24#include "llvm/Support/Debug.h"
25#include "llvm/Support/ErrorHandling.h"
26#include "llvm/Support/ErrorOr.h"
27#include "llvm/Support/Format.h"
28#include "llvm/Support/raw_ostream.h"
29#include <algorithm>
30#include <cassert>
31#include <cstdint>
32#include <cstdlib>
33#include <functional>
34#include <memory>
35#include <new>
36#include <string>
37#include <system_error>
38#include <type_traits>
39#include <utility>
40#include <vector>
41
42namespace llvm {
43
44class ErrorSuccess;
45
46/// Base class for error info classes. Do not extend this directly: Extend
47/// the ErrorInfo template subclass instead.
48class ErrorInfoBase {
49public:
50 virtual ~ErrorInfoBase() = default;
51
52 /// Print an error message to an output stream.
53 virtual void log(raw_ostream &OS) const = 0;
54
55 /// Return the error message as a string.
56 virtual std::string message() const {
57 std::string Msg;
58 raw_string_ostream OS(Msg);
59 log(OS);
60 return OS.str();
61 }
62
63 /// Convert this error to a std::error_code.
64 ///
65 /// This is a temporary crutch to enable interaction with code still
66 /// using std::error_code. It will be removed in the future.
67 virtual std::error_code convertToErrorCode() const = 0;
68
69 // Returns the class ID for this type.
70 static const void *classID() { return &ID; }
71
72 // Returns the class ID for the dynamic type of this ErrorInfoBase instance.
73 virtual const void *dynamicClassID() const = 0;
74
75 // Check whether this instance is a subclass of the class identified by
76 // ClassID.
77 virtual bool isA(const void *const ClassID) const {
78 return ClassID == classID();
79 }
80
81 // Check whether this instance is a subclass of ErrorInfoT.
82 template <typename ErrorInfoT> bool isA() const {
83 return isA(ErrorInfoT::classID());
84 }
85
86private:
87 virtual void anchor();
88
89 static char ID;
90};
91
92/// Lightweight error class with error context and mandatory checking.
93///
94/// Instances of this class wrap a ErrorInfoBase pointer. Failure states
95/// are represented by setting the pointer to a ErrorInfoBase subclass
96/// instance containing information describing the failure. Success is
97/// represented by a null pointer value.
98///
99/// Instances of Error also contains a 'Checked' flag, which must be set
100/// before the destructor is called, otherwise the destructor will trigger a
101/// runtime error. This enforces at runtime the requirement that all Error
102/// instances be checked or returned to the caller.
103///
104/// There are two ways to set the checked flag, depending on what state the
105/// Error instance is in. For Error instances indicating success, it
106/// is sufficient to invoke the boolean conversion operator. E.g.:
107///
108/// @code{.cpp}
109/// Error foo(<...>);
110///
111/// if (auto E = foo(<...>))
112/// return E; // <- Return E if it is in the error state.
113/// // We have verified that E was in the success state. It can now be safely
114/// // destroyed.
115/// @endcode
116///
117/// A success value *can not* be dropped. For example, just calling 'foo(<...>)'
118/// without testing the return value will raise a runtime error, even if foo
119/// returns success.
120///
121/// For Error instances representing failure, you must use either the
122/// handleErrors or handleAllErrors function with a typed handler. E.g.:
123///
124/// @code{.cpp}
125/// class MyErrorInfo : public ErrorInfo<MyErrorInfo> {
126/// // Custom error info.
127/// };
128///
129/// Error foo(<...>) { return make_error<MyErrorInfo>(...); }
130///
131/// auto E = foo(<...>); // <- foo returns failure with MyErrorInfo.
132/// auto NewE =
133/// handleErrors(E,
134/// [](const MyErrorInfo &M) {
135/// // Deal with the error.
136/// },
137/// [](std::unique_ptr<OtherError> M) -> Error {
138/// if (canHandle(*M)) {
139/// // handle error.
140/// return Error::success();
141/// }
142/// // Couldn't handle this error instance. Pass it up the stack.
143/// return Error(std::move(M));
144/// );
145/// // Note - we must check or return NewE in case any of the handlers
146/// // returned a new error.
147/// @endcode
148///
149/// The handleAllErrors function is identical to handleErrors, except
150/// that it has a void return type, and requires all errors to be handled and
151/// no new errors be returned. It prevents errors (assuming they can all be
152/// handled) from having to be bubbled all the way to the top-level.
153///
154/// *All* Error instances must be checked before destruction, even if
155/// they're moved-assigned or constructed from Success values that have already
156/// been checked. This enforces checking through all levels of the call stack.
157class LLVM_NODISCARD[[clang::warn_unused_result]] Error {
158 // Both ErrorList and FileError need to be able to yank ErrorInfoBase
159 // pointers out of this class to add to the error list.
160 friend class ErrorList;
161 friend class FileError;
162
163 // handleErrors needs to be able to set the Checked flag.
164 template <typename... HandlerTs>
165 friend Error handleErrors(Error E, HandlerTs &&... Handlers);
166
167 // Expected<T> needs to be able to steal the payload when constructed from an
168 // error.
169 template <typename T> friend class Expected;
170
171 // wrap needs to be able to steal the payload.
172 friend LLVMErrorRef wrap(Error);
173
174protected:
175 /// Create a success value. Prefer using 'Error::success()' for readability
176 Error() {
177 setPtr(nullptr);
178 setChecked(false);
179 }
180
181public:
182 /// Create a success value.
183 static ErrorSuccess success();
184
185 // Errors are not copy-constructable.
186 Error(const Error &Other) = delete;
187
188 /// Move-construct an error value. The newly constructed error is considered
189 /// unchecked, even if the source error had been checked. The original error
190 /// becomes a checked Success value, regardless of its original state.
191 Error(Error &&Other) {
192 setChecked(true);
193 *this = std::move(Other);
194 }
195
196 /// Create an error value. Prefer using the 'make_error' function, but
197 /// this constructor can be useful when "re-throwing" errors from handlers.
198 Error(std::unique_ptr<ErrorInfoBase> Payload) {
199 setPtr(Payload.release());
200 setChecked(false);
34
Potential leak of memory pointed to by 'Payload._M_t._M_head_impl'
201 }
202
203 // Errors are not copy-assignable.
204 Error &operator=(const Error &Other) = delete;
205
206 /// Move-assign an error value. The current error must represent success, you
207 /// you cannot overwrite an unhandled error. The current error is then
208 /// considered unchecked. The source error becomes a checked success value,
209 /// regardless of its original state.
210 Error &operator=(Error &&Other) {
211 // Don't allow overwriting of unchecked values.
212 assertIsChecked();
213 setPtr(Other.getPtr());
214
215 // This Error is unchecked, even if the source error was checked.
216 setChecked(false);
217
218 // Null out Other's payload and set its checked bit.
219 Other.setPtr(nullptr);
220 Other.setChecked(true);
221
222 return *this;
223 }
224
225 /// Destroy a Error. Fails with a call to abort() if the error is
226 /// unchecked.
227 ~Error() {
228 assertIsChecked();
229 delete getPtr();
230 }
231
232 /// Bool conversion. Returns true if this Error is in a failure state,
233 /// and false if it is in an accept state. If the error is in a Success state
234 /// it will be considered checked.
235 explicit operator bool() {
236 setChecked(getPtr() == nullptr);
237 return getPtr() != nullptr;
238 }
239
240 /// Check whether one error is a subclass of another.
241 template <typename ErrT> bool isA() const {
242 return getPtr() && getPtr()->isA(ErrT::classID());
243 }
244
245 /// Returns the dynamic class id of this error, or null if this is a success
246 /// value.
247 const void* dynamicClassID() const {
248 if (!getPtr())
249 return nullptr;
250 return getPtr()->dynamicClassID();
251 }
252
253private:
254#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
255 // assertIsChecked() happens very frequently, but under normal circumstances
256 // is supposed to be a no-op. So we want it to be inlined, but having a bunch
257 // of debug prints can cause the function to be too large for inlining. So
258 // it's important that we define this function out of line so that it can't be
259 // inlined.
260 LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn))
261 void fatalUncheckedError() const;
262#endif
263
264 void assertIsChecked() {
265#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
266 if (LLVM_UNLIKELY(!getChecked() || getPtr())__builtin_expect((bool)(!getChecked() || getPtr()), false))
267 fatalUncheckedError();
268#endif
269 }
270
271 ErrorInfoBase *getPtr() const {
272 return reinterpret_cast<ErrorInfoBase*>(
273 reinterpret_cast<uintptr_t>(Payload) &
274 ~static_cast<uintptr_t>(0x1));
275 }
276
277 void setPtr(ErrorInfoBase *EI) {
278#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
279 Payload = reinterpret_cast<ErrorInfoBase*>(
280 (reinterpret_cast<uintptr_t>(EI) &
281 ~static_cast<uintptr_t>(0x1)) |
282 (reinterpret_cast<uintptr_t>(Payload) & 0x1));
283#else
284 Payload = EI;
285#endif
286 }
287
288 bool getChecked() const {
289#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
290 return (reinterpret_cast<uintptr_t>(Payload) & 0x1) == 0;
291#else
292 return true;
293#endif
294 }
295
296 void setChecked(bool V) {
297 Payload = reinterpret_cast<ErrorInfoBase*>(
298 (reinterpret_cast<uintptr_t>(Payload) &
299 ~static_cast<uintptr_t>(0x1)) |
300 (V ? 0 : 1));
301 }
302
303 std::unique_ptr<ErrorInfoBase> takePayload() {
304 std::unique_ptr<ErrorInfoBase> Tmp(getPtr());
305 setPtr(nullptr);
306 setChecked(true);
307 return Tmp;
308 }
309
310 friend raw_ostream &operator<<(raw_ostream &OS, const Error &E) {
311 if (auto P = E.getPtr())
312 P->log(OS);
313 else
314 OS << "success";
315 return OS;
316 }
317
318 ErrorInfoBase *Payload = nullptr;
319};
320
321/// Subclass of Error for the sole purpose of identifying the success path in
322/// the type system. This allows to catch invalid conversion to Expected<T> at
323/// compile time.
324class ErrorSuccess final : public Error {};
325
326inline ErrorSuccess Error::success() { return ErrorSuccess(); }
327
328/// Make a Error instance representing failure using the given error info
329/// type.
330template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
331 return Error(llvm::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
332}
333
334/// Base class for user error types. Users should declare their error types
335/// like:
336///
337/// class MyError : public ErrorInfo<MyError> {
338/// ....
339/// };
340///
341/// This class provides an implementation of the ErrorInfoBase::kind
342/// method, which is used by the Error RTTI system.
343template <typename ThisErrT, typename ParentErrT = ErrorInfoBase>
344class ErrorInfo : public ParentErrT {
345public:
346 using ParentErrT::ParentErrT; // inherit constructors
347
348 static const void *classID() { return &ThisErrT::ID; }
349
350 const void *dynamicClassID() const override { return &ThisErrT::ID; }
351
352 bool isA(const void *const ClassID) const override {
353 return ClassID == classID() || ParentErrT::isA(ClassID);
354 }
355};
356
357/// Special ErrorInfo subclass representing a list of ErrorInfos.
358/// Instances of this class are constructed by joinError.
359class ErrorList final : public ErrorInfo<ErrorList> {
360 // handleErrors needs to be able to iterate the payload list of an
361 // ErrorList.
362 template <typename... HandlerTs>
363 friend Error handleErrors(Error E, HandlerTs &&... Handlers);
364
365 // joinErrors is implemented in terms of join.
366 friend Error joinErrors(Error, Error);
367
368public:
369 void log(raw_ostream &OS) const override {
370 OS << "Multiple errors:\n";
371 for (auto &ErrPayload : Payloads) {
372 ErrPayload->log(OS);
373 OS << "\n";
374 }
375 }
376
377 std::error_code convertToErrorCode() const override;
378
379 // Used by ErrorInfo::classID.
380 static char ID;
381
382private:
383 ErrorList(std::unique_ptr<ErrorInfoBase> Payload1,
384 std::unique_ptr<ErrorInfoBase> Payload2) {
385 assert(!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() &&((!Payload1->isA<ErrorList>() && !Payload2->
isA<ErrorList>() && "ErrorList constructor payloads should be singleton errors"
) ? static_cast<void> (0) : __assert_fail ("!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() && \"ErrorList constructor payloads should be singleton errors\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 386, __PRETTY_FUNCTION__))
386 "ErrorList constructor payloads should be singleton errors")((!Payload1->isA<ErrorList>() && !Payload2->
isA<ErrorList>() && "ErrorList constructor payloads should be singleton errors"
) ? static_cast<void> (0) : __assert_fail ("!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() && \"ErrorList constructor payloads should be singleton errors\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 386, __PRETTY_FUNCTION__))
;
387 Payloads.push_back(std::move(Payload1));
388 Payloads.push_back(std::move(Payload2));
389 }
390
391 static Error join(Error E1, Error E2) {
392 if (!E1)
24
Assuming the condition is false
25
Taking false branch
393 return E2;
394 if (!E2)
26
Assuming the condition is false
27
Taking false branch
395 return E1;
396 if (E1.isA<ErrorList>()) {
28
Assuming the condition is false
29
Taking false branch
397 auto &E1List = static_cast<ErrorList &>(*E1.getPtr());
398 if (E2.isA<ErrorList>()) {
399 auto E2Payload = E2.takePayload();
400 auto &E2List = static_cast<ErrorList &>(*E2Payload);
401 for (auto &Payload : E2List.Payloads)
402 E1List.Payloads.push_back(std::move(Payload));
403 } else
404 E1List.Payloads.push_back(E2.takePayload());
405
406 return E1;
407 }
408 if (E2.isA<ErrorList>()) {
30
Assuming the condition is false
31
Taking false branch
409 auto &E2List = static_cast<ErrorList &>(*E2.getPtr());
410 E2List.Payloads.insert(E2List.Payloads.begin(), E1.takePayload());
411 return E2;
412 }
413 return Error(std::unique_ptr<ErrorList>(
33
Calling constructor for 'Error'
414 new ErrorList(E1.takePayload(), E2.takePayload())));
32
Memory is allocated
415 }
416
417 std::vector<std::unique_ptr<ErrorInfoBase>> Payloads;
418};
419
420/// Concatenate errors. The resulting Error is unchecked, and contains the
421/// ErrorInfo(s), if any, contained in E1, followed by the
422/// ErrorInfo(s), if any, contained in E2.
423inline Error joinErrors(Error E1, Error E2) {
424 return ErrorList::join(std::move(E1), std::move(E2));
425}
426
427/// Tagged union holding either a T or a Error.
428///
429/// This class parallels ErrorOr, but replaces error_code with Error. Since
430/// Error cannot be copied, this class replaces getError() with
431/// takeError(). It also adds an bool errorIsA<ErrT>() method for testing the
432/// error class type.
433template <class T> class LLVM_NODISCARD[[clang::warn_unused_result]] Expected {
434 template <class T1> friend class ExpectedAsOutParameter;
435 template <class OtherT> friend class Expected;
436
437 static const bool isRef = std::is_reference<T>::value;
438
439 using wrap = std::reference_wrapper<typename std::remove_reference<T>::type>;
440
441 using error_type = std::unique_ptr<ErrorInfoBase>;
442
443public:
444 using storage_type = typename std::conditional<isRef, wrap, T>::type;
445 using value_type = T;
446
447private:
448 using reference = typename std::remove_reference<T>::type &;
449 using const_reference = const typename std::remove_reference<T>::type &;
450 using pointer = typename std::remove_reference<T>::type *;
451 using const_pointer = const typename std::remove_reference<T>::type *;
452
453public:
454 /// Create an Expected<T> error value from the given Error.
455 Expected(Error Err)
456 : HasError(true)
457#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
458 // Expected is unchecked upon construction in Debug builds.
459 , Unchecked(true)
460#endif
461 {
462 assert(Err && "Cannot create Expected<T> from Error success value.")((Err && "Cannot create Expected<T> from Error success value."
) ? static_cast<void> (0) : __assert_fail ("Err && \"Cannot create Expected<T> from Error success value.\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 462, __PRETTY_FUNCTION__))
;
463 new (getErrorStorage()) error_type(Err.takePayload());
464 }
465
466 /// Forbid to convert from Error::success() implicitly, this avoids having
467 /// Expected<T> foo() { return Error::success(); } which compiles otherwise
468 /// but triggers the assertion above.
469 Expected(ErrorSuccess) = delete;
470
471 /// Create an Expected<T> success value from the given OtherT value, which
472 /// must be convertible to T.
473 template <typename OtherT>
474 Expected(OtherT &&Val,
475 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
476 * = nullptr)
477 : HasError(false)
478#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
479 // Expected is unchecked upon construction in Debug builds.
480 , Unchecked(true)
481#endif
482 {
483 new (getStorage()) storage_type(std::forward<OtherT>(Val));
484 }
485
486 /// Move construct an Expected<T> value.
487 Expected(Expected &&Other) { moveConstruct(std::move(Other)); }
488
489 /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
490 /// must be convertible to T.
491 template <class OtherT>
492 Expected(Expected<OtherT> &&Other,
493 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
494 * = nullptr) {
495 moveConstruct(std::move(Other));
496 }
497
498 /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
499 /// isn't convertible to T.
500 template <class OtherT>
501 explicit Expected(
502 Expected<OtherT> &&Other,
503 typename std::enable_if<!std::is_convertible<OtherT, T>::value>::type * =
504 nullptr) {
505 moveConstruct(std::move(Other));
506 }
507
508 /// Move-assign from another Expected<T>.
509 Expected &operator=(Expected &&Other) {
510 moveAssign(std::move(Other));
511 return *this;
512 }
513
514 /// Destroy an Expected<T>.
515 ~Expected() {
516 assertIsChecked();
517 if (!HasError)
518 getStorage()->~storage_type();
519 else
520 getErrorStorage()->~error_type();
521 }
522
523 /// Return false if there is an error.
524 explicit operator bool() {
525#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
526 Unchecked = HasError;
527#endif
528 return !HasError;
529 }
530
531 /// Returns a reference to the stored T value.
532 reference get() {
533 assertIsChecked();
534 return *getStorage();
535 }
536
537 /// Returns a const reference to the stored T value.
538 const_reference get() const {
539 assertIsChecked();
540 return const_cast<Expected<T> *>(this)->get();
541 }
542
543 /// Check that this Expected<T> is an error of type ErrT.
544 template <typename ErrT> bool errorIsA() const {
545 return HasError && (*getErrorStorage())->template isA<ErrT>();
546 }
547
548 /// Take ownership of the stored error.
549 /// After calling this the Expected<T> is in an indeterminate state that can
550 /// only be safely destructed. No further calls (beside the destructor) should
551 /// be made on the Expected<T> vaule.
552 Error takeError() {
553#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
554 Unchecked = false;
555#endif
556 return HasError ? Error(std::move(*getErrorStorage())) : Error::success();
557 }
558
559 /// Returns a pointer to the stored T value.
560 pointer operator->() {
561 assertIsChecked();
562 return toPointer(getStorage());
563 }
564
565 /// Returns a const pointer to the stored T value.
566 const_pointer operator->() const {
567 assertIsChecked();
568 return toPointer(getStorage());
569 }
570
571 /// Returns a reference to the stored T value.
572 reference operator*() {
573 assertIsChecked();
574 return *getStorage();
575 }
576
577 /// Returns a const reference to the stored T value.
578 const_reference operator*() const {
579 assertIsChecked();
580 return *getStorage();
581 }
582
583private:
584 template <class T1>
585 static bool compareThisIfSameType(const T1 &a, const T1 &b) {
586 return &a == &b;
587 }
588
589 template <class T1, class T2>
590 static bool compareThisIfSameType(const T1 &a, const T2 &b) {
591 return false;
592 }
593
594 template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
595 HasError = Other.HasError;
596#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
597 Unchecked = true;
598 Other.Unchecked = false;
599#endif
600
601 if (!HasError)
602 new (getStorage()) storage_type(std::move(*Other.getStorage()));
603 else
604 new (getErrorStorage()) error_type(std::move(*Other.getErrorStorage()));
605 }
606
607 template <class OtherT> void moveAssign(Expected<OtherT> &&Other) {
608 assertIsChecked();
609
610 if (compareThisIfSameType(*this, Other))
611 return;
612
613 this->~Expected();
614 new (this) Expected(std::move(Other));
615 }
616
617 pointer toPointer(pointer Val) { return Val; }
618
619 const_pointer toPointer(const_pointer Val) const { return Val; }
620
621 pointer toPointer(wrap *Val) { return &Val->get(); }
622
623 const_pointer toPointer(const wrap *Val) const { return &Val->get(); }
624
625 storage_type *getStorage() {
626 assert(!HasError && "Cannot get value when an error exists!")((!HasError && "Cannot get value when an error exists!"
) ? static_cast<void> (0) : __assert_fail ("!HasError && \"Cannot get value when an error exists!\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 626, __PRETTY_FUNCTION__))
;
627 return reinterpret_cast<storage_type *>(TStorage.buffer);
628 }
629
630 const storage_type *getStorage() const {
631 assert(!HasError && "Cannot get value when an error exists!")((!HasError && "Cannot get value when an error exists!"
) ? static_cast<void> (0) : __assert_fail ("!HasError && \"Cannot get value when an error exists!\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 631, __PRETTY_FUNCTION__))
;
632 return reinterpret_cast<const storage_type *>(TStorage.buffer);
633 }
634
635 error_type *getErrorStorage() {
636 assert(HasError && "Cannot get error when a value exists!")((HasError && "Cannot get error when a value exists!"
) ? static_cast<void> (0) : __assert_fail ("HasError && \"Cannot get error when a value exists!\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 636, __PRETTY_FUNCTION__))
;
637 return reinterpret_cast<error_type *>(ErrorStorage.buffer);
638 }
639
640 const error_type *getErrorStorage() const {
641 assert(HasError && "Cannot get error when a value exists!")((HasError && "Cannot get error when a value exists!"
) ? static_cast<void> (0) : __assert_fail ("HasError && \"Cannot get error when a value exists!\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 641, __PRETTY_FUNCTION__))
;
642 return reinterpret_cast<const error_type *>(ErrorStorage.buffer);
643 }
644
645 // Used by ExpectedAsOutParameter to reset the checked flag.
646 void setUnchecked() {
647#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
648 Unchecked = true;
649#endif
650 }
651
652#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
653 LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn))
654 LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline))
655 void fatalUncheckedExpected() const {
656 dbgs() << "Expected<T> must be checked before access or destruction.\n";
657 if (HasError) {
658 dbgs() << "Unchecked Expected<T> contained error:\n";
659 (*getErrorStorage())->log(dbgs());
660 } else
661 dbgs() << "Expected<T> value was in success state. (Note: Expected<T> "
662 "values in success mode must still be checked prior to being "
663 "destroyed).\n";
664 abort();
665 }
666#endif
667
668 void assertIsChecked() {
669#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
670 if (LLVM_UNLIKELY(Unchecked)__builtin_expect((bool)(Unchecked), false))
671 fatalUncheckedExpected();
672#endif
673 }
674
675 union {
676 AlignedCharArrayUnion<storage_type> TStorage;
677 AlignedCharArrayUnion<error_type> ErrorStorage;
678 };
679 bool HasError : 1;
680#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
681 bool Unchecked : 1;
682#endif
683};
684
685/// Report a serious error, calling any installed error handler. See
686/// ErrorHandling.h.
687LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn)) void report_fatal_error(Error Err,
688 bool gen_crash_diag = true);
689
690/// Report a fatal error if Err is a failure value.
691///
692/// This function can be used to wrap calls to fallible functions ONLY when it
693/// is known that the Error will always be a success value. E.g.
694///
695/// @code{.cpp}
696/// // foo only attempts the fallible operation if DoFallibleOperation is
697/// // true. If DoFallibleOperation is false then foo always returns
698/// // Error::success().
699/// Error foo(bool DoFallibleOperation);
700///
701/// cantFail(foo(false));
702/// @endcode
703inline void cantFail(Error Err, const char *Msg = nullptr) {
704 if (Err) {
705 if (!Msg)
706 Msg = "Failure value returned from cantFail wrapped call";
707 llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 707)
;
708 }
709}
710
711/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
712/// returns the contained value.
713///
714/// This function can be used to wrap calls to fallible functions ONLY when it
715/// is known that the Error will always be a success value. E.g.
716///
717/// @code{.cpp}
718/// // foo only attempts the fallible operation if DoFallibleOperation is
719/// // true. If DoFallibleOperation is false then foo always returns an int.
720/// Expected<int> foo(bool DoFallibleOperation);
721///
722/// int X = cantFail(foo(false));
723/// @endcode
724template <typename T>
725T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
726 if (ValOrErr)
727 return std::move(*ValOrErr);
728 else {
729 if (!Msg)
730 Msg = "Failure value returned from cantFail wrapped call";
731 llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 731)
;
732 }
733}
734
735/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
736/// returns the contained reference.
737///
738/// This function can be used to wrap calls to fallible functions ONLY when it
739/// is known that the Error will always be a success value. E.g.
740///
741/// @code{.cpp}
742/// // foo only attempts the fallible operation if DoFallibleOperation is
743/// // true. If DoFallibleOperation is false then foo always returns a Bar&.
744/// Expected<Bar&> foo(bool DoFallibleOperation);
745///
746/// Bar &X = cantFail(foo(false));
747/// @endcode
748template <typename T>
749T& cantFail(Expected<T&> ValOrErr, const char *Msg = nullptr) {
750 if (ValOrErr)
751 return *ValOrErr;
752 else {
753 if (!Msg)
754 Msg = "Failure value returned from cantFail wrapped call";
755 llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 755)
;
756 }
757}
758
759/// Helper for testing applicability of, and applying, handlers for
760/// ErrorInfo types.
761template <typename HandlerT>
762class ErrorHandlerTraits
763 : public ErrorHandlerTraits<decltype(
764 &std::remove_reference<HandlerT>::type::operator())> {};
765
766// Specialization functions of the form 'Error (const ErrT&)'.
767template <typename ErrT> class ErrorHandlerTraits<Error (&)(ErrT &)> {
768public:
769 static bool appliesTo(const ErrorInfoBase &E) {
770 return E.template isA<ErrT>();
771 }
772
773 template <typename HandlerT>
774 static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
775 assert(appliesTo(*E) && "Applying incorrect handler")((appliesTo(*E) && "Applying incorrect handler") ? static_cast
<void> (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 775, __PRETTY_FUNCTION__))
;
776 return H(static_cast<ErrT &>(*E));
777 }
778};
779
780// Specialization functions of the form 'void (const ErrT&)'.
781template <typename ErrT> class ErrorHandlerTraits<void (&)(ErrT &)> {
782public:
783 static bool appliesTo(const ErrorInfoBase &E) {
784 return E.template isA<ErrT>();
785 }
786
787 template <typename HandlerT>
788 static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
789 assert(appliesTo(*E) && "Applying incorrect handler")((appliesTo(*E) && "Applying incorrect handler") ? static_cast
<void> (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 789, __PRETTY_FUNCTION__))
;
790 H(static_cast<ErrT &>(*E));
791 return Error::success();
792 }
793};
794
795/// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
796template <typename ErrT>
797class ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
798public:
799 static bool appliesTo(const ErrorInfoBase &E) {
800 return E.template isA<ErrT>();
801 }
802
803 template <typename HandlerT>
804 static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
805 assert(appliesTo(*E) && "Applying incorrect handler")((appliesTo(*E) && "Applying incorrect handler") ? static_cast
<void> (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 805, __PRETTY_FUNCTION__))
;
806 std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
807 return H(std::move(SubE));
808 }
809};
810
811/// Specialization for functions of the form 'void (std::unique_ptr<ErrT>)'.
812template <typename ErrT>
813class ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
814public:
815 static bool appliesTo(const ErrorInfoBase &E) {
816 return E.template isA<ErrT>();
817 }
818
819 template <typename HandlerT>
820 static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
821 assert(appliesTo(*E) && "Applying incorrect handler")((appliesTo(*E) && "Applying incorrect handler") ? static_cast
<void> (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 821, __PRETTY_FUNCTION__))
;
822 std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
823 H(std::move(SubE));
824 return Error::success();
825 }
826};
827
828// Specialization for member functions of the form 'RetT (const ErrT&)'.
829template <typename C, typename RetT, typename ErrT>
830class ErrorHandlerTraits<RetT (C::*)(ErrT &)>
831 : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
832
833// Specialization for member functions of the form 'RetT (const ErrT&) const'.
834template <typename C, typename RetT, typename ErrT>
835class ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
836 : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
837
838// Specialization for member functions of the form 'RetT (const ErrT&)'.
839template <typename C, typename RetT, typename ErrT>
840class ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
841 : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
842
843// Specialization for member functions of the form 'RetT (const ErrT&) const'.
844template <typename C, typename RetT, typename ErrT>
845class ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
846 : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
847
848/// Specialization for member functions of the form
849/// 'RetT (std::unique_ptr<ErrT>)'.
850template <typename C, typename RetT, typename ErrT>
851class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
852 : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
853
854/// Specialization for member functions of the form
855/// 'RetT (std::unique_ptr<ErrT>) const'.
856template <typename C, typename RetT, typename ErrT>
857class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
858 : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
859
860inline Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload) {
861 return Error(std::move(Payload));
862}
863
864template <typename HandlerT, typename... HandlerTs>
865Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload,
866 HandlerT &&Handler, HandlerTs &&... Handlers) {
867 if (ErrorHandlerTraits<HandlerT>::appliesTo(*Payload))
868 return ErrorHandlerTraits<HandlerT>::apply(std::forward<HandlerT>(Handler),
869 std::move(Payload));
870 return handleErrorImpl(std::move(Payload),
871 std::forward<HandlerTs>(Handlers)...);
872}
873
874/// Pass the ErrorInfo(s) contained in E to their respective handlers. Any
875/// unhandled errors (or Errors returned by handlers) are re-concatenated and
876/// returned.
877/// Because this function returns an error, its result must also be checked
878/// or returned. If you intend to handle all errors use handleAllErrors
879/// (which returns void, and will abort() on unhandled errors) instead.
880template <typename... HandlerTs>
881Error handleErrors(Error E, HandlerTs &&... Hs) {
882 if (!E)
19
Assuming the condition is false
20
Taking false branch
883 return Error::success();
884
885 std::unique_ptr<ErrorInfoBase> Payload = E.takePayload();
886
887 if (Payload->isA<ErrorList>()) {
21
Assuming the condition is true
22
Taking true branch
888 ErrorList &List = static_cast<ErrorList &>(*Payload);
889 Error R;
890 for (auto &P : List.Payloads)
891 R = ErrorList::join(
23
Calling 'ErrorList::join'
892 std::move(R),
893 handleErrorImpl(std::move(P), std::forward<HandlerTs>(Hs)...));
894 return R;
895 }
896
897 return handleErrorImpl(std::move(Payload), std::forward<HandlerTs>(Hs)...);
898}
899
900/// Behaves the same as handleErrors, except that by contract all errors
901/// *must* be handled by the given handlers (i.e. there must be no remaining
902/// errors after running the handlers, or llvm_unreachable is called).
903template <typename... HandlerTs>
904void handleAllErrors(Error E, HandlerTs &&... Handlers) {
905 cantFail(handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...));
18
Calling 'handleErrors<(lambda at /build/llvm-toolchain-snapshot-9~svn358860/tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp:567:21)>'
906}
907
908/// Check that E is a non-error, then drop it.
909/// If E is an error, llvm_unreachable will be called.
910inline void handleAllErrors(Error E) {
911 cantFail(std::move(E));
912}
913
914/// Handle any errors (if present) in an Expected<T>, then try a recovery path.
915///
916/// If the incoming value is a success value it is returned unmodified. If it
917/// is a failure value then it the contained error is passed to handleErrors.
918/// If handleErrors is able to handle the error then the RecoveryPath functor
919/// is called to supply the final result. If handleErrors is not able to
920/// handle all errors then the unhandled errors are returned.
921///
922/// This utility enables the follow pattern:
923///
924/// @code{.cpp}
925/// enum FooStrategy { Aggressive, Conservative };
926/// Expected<Foo> foo(FooStrategy S);
927///
928/// auto ResultOrErr =
929/// handleExpected(
930/// foo(Aggressive),
931/// []() { return foo(Conservative); },
932/// [](AggressiveStrategyError&) {
933/// // Implicitly conusme this - we'll recover by using a conservative
934/// // strategy.
935/// });
936///
937/// @endcode
938template <typename T, typename RecoveryFtor, typename... HandlerTs>
939Expected<T> handleExpected(Expected<T> ValOrErr, RecoveryFtor &&RecoveryPath,
940 HandlerTs &&... Handlers) {
941 if (ValOrErr)
942 return ValOrErr;
943
944 if (auto Err = handleErrors(ValOrErr.takeError(),
945 std::forward<HandlerTs>(Handlers)...))
946 return std::move(Err);
947
948 return RecoveryPath();
949}
950
951/// Log all errors (if any) in E to OS. If there are any errors, ErrorBanner
952/// will be printed before the first one is logged. A newline will be printed
953/// after each error.
954///
955/// This function is compatible with the helpers from Support/WithColor.h. You
956/// can pass any of them as the OS. Please consider using them instead of
957/// including 'error: ' in the ErrorBanner.
958///
959/// This is useful in the base level of your program to allow clean termination
960/// (allowing clean deallocation of resources, etc.), while reporting error
961/// information to the user.
962void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner = {});
963
964/// Write all error messages (if any) in E to a string. The newline character
965/// is used to separate error messages.
966inline std::string toString(Error E) {
967 SmallVector<std::string, 2> Errors;
968 handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
969 Errors.push_back(EI.message());
970 });
971 return join(Errors.begin(), Errors.end(), "\n");
972}
973
974/// Consume a Error without doing anything. This method should be used
975/// only where an error can be considered a reasonable and expected return
976/// value.
977///
978/// Uses of this method are potentially indicative of design problems: If it's
979/// legitimate to do nothing while processing an "error", the error-producer
980/// might be more clearly refactored to return an Optional<T>.
981inline void consumeError(Error Err) {
982 handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
983}
984
985/// Helper for converting an Error to a bool.
986///
987/// This method returns true if Err is in an error state, or false if it is
988/// in a success state. Puts Err in a checked state in both cases (unlike
989/// Error::operator bool(), which only does this for success states).
990inline bool errorToBool(Error Err) {
991 bool IsError = static_cast<bool>(Err);
992 if (IsError)
993 consumeError(std::move(Err));
994 return IsError;
995}
996
997/// Helper for Errors used as out-parameters.
998///
999/// This helper is for use with the Error-as-out-parameter idiom, where an error
1000/// is passed to a function or method by reference, rather than being returned.
1001/// In such cases it is helpful to set the checked bit on entry to the function
1002/// so that the error can be written to (unchecked Errors abort on assignment)
1003/// and clear the checked bit on exit so that clients cannot accidentally forget
1004/// to check the result. This helper performs these actions automatically using
1005/// RAII:
1006///
1007/// @code{.cpp}
1008/// Result foo(Error &Err) {
1009/// ErrorAsOutParameter ErrAsOutParam(&Err); // 'Checked' flag set
1010/// // <body of foo>
1011/// // <- 'Checked' flag auto-cleared when ErrAsOutParam is destructed.
1012/// }
1013/// @endcode
1014///
1015/// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
1016/// used with optional Errors (Error pointers that are allowed to be null). If
1017/// ErrorAsOutParameter took an Error reference, an instance would have to be
1018/// created inside every condition that verified that Error was non-null. By
1019/// taking an Error pointer we can just create one instance at the top of the
1020/// function.
1021class ErrorAsOutParameter {
1022public:
1023 ErrorAsOutParameter(Error *Err) : Err(Err) {
1024 // Raise the checked bit if Err is success.
1025 if (Err)
1026 (void)!!*Err;
1027 }
1028
1029 ~ErrorAsOutParameter() {
1030 // Clear the checked bit.
1031 if (Err && !*Err)
1032 *Err = Error::success();
1033 }
1034
1035private:
1036 Error *Err;
1037};
1038
1039/// Helper for Expected<T>s used as out-parameters.
1040///
1041/// See ErrorAsOutParameter.
1042template <typename T>
1043class ExpectedAsOutParameter {
1044public:
1045 ExpectedAsOutParameter(Expected<T> *ValOrErr)
1046 : ValOrErr(ValOrErr) {
1047 if (ValOrErr)
1048 (void)!!*ValOrErr;
1049 }
1050
1051 ~ExpectedAsOutParameter() {
1052 if (ValOrErr)
1053 ValOrErr->setUnchecked();
1054 }
1055
1056private:
1057 Expected<T> *ValOrErr;
1058};
1059
1060/// This class wraps a std::error_code in a Error.
1061///
1062/// This is useful if you're writing an interface that returns a Error
1063/// (or Expected) and you want to call code that still returns
1064/// std::error_codes.
1065class ECError : public ErrorInfo<ECError> {
1066 friend Error errorCodeToError(std::error_code);
1067
1068 virtual void anchor() override;
1069
1070public:
1071 void setErrorCode(std::error_code EC) { this->EC = EC; }
1072 std::error_code convertToErrorCode() const override { return EC; }
1073 void log(raw_ostream &OS) const override { OS << EC.message(); }
1074
1075 // Used by ErrorInfo::classID.
1076 static char ID;
1077
1078protected:
1079 ECError() = default;
1080 ECError(std::error_code EC) : EC(EC) {}
1081
1082 std::error_code EC;
1083};
1084
1085/// The value returned by this function can be returned from convertToErrorCode
1086/// for Error values where no sensible translation to std::error_code exists.
1087/// It should only be used in this situation, and should never be used where a
1088/// sensible conversion to std::error_code is available, as attempts to convert
1089/// to/from this error will result in a fatal error. (i.e. it is a programmatic
1090///error to try to convert such a value).
1091std::error_code inconvertibleErrorCode();
1092
1093/// Helper for converting an std::error_code to a Error.
1094Error errorCodeToError(std::error_code EC);
1095
1096/// Helper for converting an ECError to a std::error_code.
1097///
1098/// This method requires that Err be Error() or an ECError, otherwise it
1099/// will trigger a call to abort().
1100std::error_code errorToErrorCode(Error Err);
1101
1102/// Convert an ErrorOr<T> to an Expected<T>.
1103template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1104 if (auto EC = EO.getError())
1105 return errorCodeToError(EC);
1106 return std::move(*EO);
1107}
1108
1109/// Convert an Expected<T> to an ErrorOr<T>.
1110template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1111 if (auto Err = E.takeError())
1112 return errorToErrorCode(std::move(Err));
1113 return std::move(*E);
1114}
1115
1116/// This class wraps a string in an Error.
1117///
1118/// StringError is useful in cases where the client is not expected to be able
1119/// to consume the specific error message programmatically (for example, if the
1120/// error message is to be presented to the user).
1121///
1122/// StringError can also be used when additional information is to be printed
1123/// along with a error_code message. Depending on the constructor called, this
1124/// class can either display:
1125/// 1. the error_code message (ECError behavior)
1126/// 2. a string
1127/// 3. the error_code message and a string
1128///
1129/// These behaviors are useful when subtyping is required; for example, when a
1130/// specific library needs an explicit error type. In the example below,
1131/// PDBError is derived from StringError:
1132///
1133/// @code{.cpp}
1134/// Expected<int> foo() {
1135/// return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
1136/// "Additional information");
1137/// }
1138/// @endcode
1139///
1140class StringError : public ErrorInfo<StringError> {
1141public:
1142 static char ID;
1143
1144 // Prints EC + S and converts to EC
1145 StringError(std::error_code EC, const Twine &S = Twine());
1146
1147 // Prints S and converts to EC
1148 StringError(const Twine &S, std::error_code EC);
1149
1150 void log(raw_ostream &OS) const override;
1151 std::error_code convertToErrorCode() const override;
1152
1153 const std::string &getMessage() const { return Msg; }
1154
1155private:
1156 std::string Msg;
1157 std::error_code EC;
1158 const bool PrintMsgOnly = false;
1159};
1160
1161/// Create formatted StringError object.
1162template <typename... Ts>
1163Error createStringError(std::error_code EC, char const *Fmt,
1164 const Ts &... Vals) {
1165 std::string Buffer;
1166 raw_string_ostream Stream(Buffer);
1167 Stream << format(Fmt, Vals...);
1168 return make_error<StringError>(Stream.str(), EC);
1169}
1170
1171Error createStringError(std::error_code EC, char const *Msg);
1172
1173/// This class wraps a filename and another Error.
1174///
1175/// In some cases, an error needs to live along a 'source' name, in order to
1176/// show more detailed information to the user.
1177class FileError final : public ErrorInfo<FileError> {
1178
1179 friend Error createFileError(const Twine &, Error);
1180
1181public:
1182 void log(raw_ostream &OS) const override {
1183 assert(Err && !FileName.empty() && "Trying to log after takeError().")((Err && !FileName.empty() && "Trying to log after takeError()."
) ? static_cast<void> (0) : __assert_fail ("Err && !FileName.empty() && \"Trying to log after takeError().\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 1183, __PRETTY_FUNCTION__))
;
1184 OS << "'" << FileName << "': ";
1185 Err->log(OS);
1186 }
1187
1188 Error takeError() { return Error(std::move(Err)); }
1189
1190 std::error_code convertToErrorCode() const override;
1191
1192 // Used by ErrorInfo::classID.
1193 static char ID;
1194
1195private:
1196 FileError(const Twine &F, std::unique_ptr<ErrorInfoBase> E) {
1197 assert(E && "Cannot create FileError from Error success value.")((E && "Cannot create FileError from Error success value."
) ? static_cast<void> (0) : __assert_fail ("E && \"Cannot create FileError from Error success value.\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 1197, __PRETTY_FUNCTION__))
;
1198 assert(!F.isTriviallyEmpty() &&((!F.isTriviallyEmpty() && "The file name provided to FileError must not be empty."
) ? static_cast<void> (0) : __assert_fail ("!F.isTriviallyEmpty() && \"The file name provided to FileError must not be empty.\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 1199, __PRETTY_FUNCTION__))
1199 "The file name provided to FileError must not be empty.")((!F.isTriviallyEmpty() && "The file name provided to FileError must not be empty."
) ? static_cast<void> (0) : __assert_fail ("!F.isTriviallyEmpty() && \"The file name provided to FileError must not be empty.\""
, "/build/llvm-toolchain-snapshot-9~svn358860/include/llvm/Support/Error.h"
, 1199, __PRETTY_FUNCTION__))
;
1200 FileName = F.str();
1201 Err = std::move(E);
1202 }
1203
1204 static Error build(const Twine &F, Error E) {
1205 return Error(std::unique_ptr<FileError>(new FileError(F, E.takePayload())));
1206 }
1207
1208 std::string FileName;
1209 std::unique_ptr<ErrorInfoBase> Err;
1210};
1211
1212/// Concatenate a source file path and/or name with an Error. The resulting
1213/// Error is unchecked.
1214inline Error createFileError(const Twine &F, Error E) {
1215 return FileError::build(F, std::move(E));
1216}
1217
1218/// Concatenate a source file path and/or name with a std::error_code
1219/// to form an Error object.
1220inline Error createFileError(const Twine &F, std::error_code EC) {
1221 return createFileError(F, errorCodeToError(EC));
1222}
1223
1224Error createFileError(const Twine &F, ErrorSuccess) = delete;
1225
1226/// Helper for check-and-exit error handling.
1227///
1228/// For tool use only. NOT FOR USE IN LIBRARY CODE.
1229///
1230class ExitOnError {
1231public:
1232 /// Create an error on exit helper.
1233 ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1234 : Banner(std::move(Banner)),
1235 GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1236
1237 /// Set the banner string for any errors caught by operator().
1238 void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1239
1240 /// Set the exit-code mapper function.
1241 void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1242 this->GetExitCode = std::move(GetExitCode);
1243 }
1244
1245 /// Check Err. If it's in a failure state log the error(s) and exit.
1246 void operator()(Error Err) const { checkError(std::move(Err)); }
1247
1248 /// Check E. If it's in a success state then return the contained value. If
1249 /// it's in a failure state log the error(s) and exit.
1250 template <typename T> T operator()(Expected<T> &&E) const {
1251 checkError(E.takeError());
1252 return std::move(*E);
1253 }
1254
1255 /// Check E. If it's in a success state then return the contained reference. If
1256 /// it's in a failure state log the error(s) and exit.
1257 template <typename T> T& operator()(Expected<T&> &&E) const {
1258 checkError(E.takeError());
1259 return *E;
1260 }
1261
1262private:
1263 void checkError(Error Err) const {
1264 if (Err) {
1265 int ExitCode = GetExitCode(Err);
1266 logAllUnhandledErrors(std::move(Err), errs(), Banner);
1267 exit(ExitCode);
1268 }
1269 }
1270
1271 std::string Banner;
1272 std::function<int(const Error &)> GetExitCode;
1273};
1274
1275/// Conversion from Error to LLVMErrorRef for C error bindings.
1276inline LLVMErrorRef wrap(Error Err) {
1277 return reinterpret_cast<LLVMErrorRef>(Err.takePayload().release());
1278}
1279
1280/// Conversion from LLVMErrorRef to Error for C error bindings.
1281inline Error unwrap(LLVMErrorRef ErrRef) {
1282 return Error(std::unique_ptr<ErrorInfoBase>(
1283 reinterpret_cast<ErrorInfoBase *>(ErrRef)));
1284}
1285
1286} // end namespace llvm
1287
1288#endif // LLVM_SUPPORT_ERROR_H