clang  3.7.0
JumpDiagnostics.cpp
Go to the documentation of this file.
1 //===--- JumpDiagnostics.cpp - Protected scope jump analysis ------*- C++ -*-=//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the JumpScopeChecker class, which is used to diagnose
11 // jumps that enter a protected scope in an invalid way.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/Expr.h"
18 #include "clang/AST/ExprCXX.h"
19 #include "clang/AST/StmtCXX.h"
20 #include "clang/AST/StmtObjC.h"
21 #include "llvm/ADT/BitVector.h"
22 using namespace clang;
23 
24 namespace {
25 
26 /// JumpScopeChecker - This object is used by Sema to diagnose invalid jumps
27 /// into VLA and other protected scopes. For example, this rejects:
28 /// goto L;
29 /// int a[n];
30 /// L:
31 ///
32 class JumpScopeChecker {
33  Sema &S;
34 
35  /// Permissive - True when recovering from errors, in which case precautions
36  /// are taken to handle incomplete scope information.
37  const bool Permissive;
38 
39  /// GotoScope - This is a record that we use to keep track of all of the
40  /// scopes that are introduced by VLAs and other things that scope jumps like
41  /// gotos. This scope tree has nothing to do with the source scope tree,
42  /// because you can have multiple VLA scopes per compound statement, and most
43  /// compound statements don't introduce any scopes.
44  struct GotoScope {
45  /// ParentScope - The index in ScopeMap of the parent scope. This is 0 for
46  /// the parent scope is the function body.
47  unsigned ParentScope;
48 
49  /// InDiag - The note to emit if there is a jump into this scope.
50  unsigned InDiag;
51 
52  /// OutDiag - The note to emit if there is an indirect jump out
53  /// of this scope. Direct jumps always clean up their current scope
54  /// in an orderly way.
55  unsigned OutDiag;
56 
57  /// Loc - Location to emit the diagnostic.
58  SourceLocation Loc;
59 
60  GotoScope(unsigned parentScope, unsigned InDiag, unsigned OutDiag,
62  : ParentScope(parentScope), InDiag(InDiag), OutDiag(OutDiag), Loc(L) {}
63  };
64 
66  llvm::DenseMap<Stmt*, unsigned> LabelAndGotoScopes;
68 
70  SmallVector<LabelDecl*, 4> IndirectJumpTargets;
71 public:
72  JumpScopeChecker(Stmt *Body, Sema &S);
73 private:
74  void BuildScopeInformation(Decl *D, unsigned &ParentScope);
75  void BuildScopeInformation(VarDecl *D, const BlockDecl *BDecl,
76  unsigned &ParentScope);
77  void BuildScopeInformation(Stmt *S, unsigned &origParentScope);
78 
79  void VerifyJumps();
80  void VerifyIndirectJumps();
81  void NoteJumpIntoScopes(ArrayRef<unsigned> ToScopes);
82  void DiagnoseIndirectJump(IndirectGotoStmt *IG, unsigned IGScope,
83  LabelDecl *Target, unsigned TargetScope);
84  void CheckJump(Stmt *From, Stmt *To, SourceLocation DiagLoc,
85  unsigned JumpDiag, unsigned JumpDiagWarning,
86  unsigned JumpDiagCXX98Compat);
87  void CheckGotoStmt(GotoStmt *GS);
88 
89  unsigned GetDeepestCommonScope(unsigned A, unsigned B);
90 };
91 } // end anonymous namespace
92 
93 #define CHECK_PERMISSIVE(x) (assert(Permissive || !(x)), (Permissive && (x)))
94 
95 JumpScopeChecker::JumpScopeChecker(Stmt *Body, Sema &s)
96  : S(s), Permissive(s.hasAnyUnrecoverableErrorsInThisFunction()) {
97  // Add a scope entry for function scope.
98  Scopes.push_back(GotoScope(~0U, ~0U, ~0U, SourceLocation()));
99 
100  // Build information for the top level compound statement, so that we have a
101  // defined scope record for every "goto" and label.
102  unsigned BodyParentScope = 0;
103  BuildScopeInformation(Body, BodyParentScope);
104 
105  // Check that all jumps we saw are kosher.
106  VerifyJumps();
107  VerifyIndirectJumps();
108 }
109 
110 /// GetDeepestCommonScope - Finds the innermost scope enclosing the
111 /// two scopes.
112 unsigned JumpScopeChecker::GetDeepestCommonScope(unsigned A, unsigned B) {
113  while (A != B) {
114  // Inner scopes are created after outer scopes and therefore have
115  // higher indices.
116  if (A < B) {
117  assert(Scopes[B].ParentScope < B);
118  B = Scopes[B].ParentScope;
119  } else {
120  assert(Scopes[A].ParentScope < A);
121  A = Scopes[A].ParentScope;
122  }
123  }
124  return A;
125 }
126 
127 typedef std::pair<unsigned,unsigned> ScopePair;
128 
129 /// GetDiagForGotoScopeDecl - If this decl induces a new goto scope, return a
130 /// diagnostic that should be emitted if control goes over it. If not, return 0.
132  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
133  unsigned InDiag = 0;
134  unsigned OutDiag = 0;
135 
136  if (VD->getType()->isVariablyModifiedType())
137  InDiag = diag::note_protected_by_vla;
138 
139  if (VD->hasAttr<BlocksAttr>())
140  return ScopePair(diag::note_protected_by___block,
141  diag::note_exits___block);
142 
143  if (VD->hasAttr<CleanupAttr>())
144  return ScopePair(diag::note_protected_by_cleanup,
145  diag::note_exits_cleanup);
146 
147  if (VD->hasLocalStorage()) {
148  switch (VD->getType().isDestructedType()) {
149  case QualType::DK_objc_strong_lifetime:
150  case QualType::DK_objc_weak_lifetime:
151  return ScopePair(diag::note_protected_by_objc_ownership,
152  diag::note_exits_objc_ownership);
153 
154  case QualType::DK_cxx_destructor:
155  OutDiag = diag::note_exits_dtor;
156  break;
157 
158  case QualType::DK_none:
159  break;
160  }
161  }
162 
163  const Expr *Init = VD->getInit();
164  if (S.Context.getLangOpts().CPlusPlus && VD->hasLocalStorage() && Init) {
165  // C++11 [stmt.dcl]p3:
166  // A program that jumps from a point where a variable with automatic
167  // storage duration is not in scope to a point where it is in scope
168  // is ill-formed unless the variable has scalar type, class type with
169  // a trivial default constructor and a trivial destructor, a
170  // cv-qualified version of one of these types, or an array of one of
171  // the preceding types and is declared without an initializer.
172 
173  // C++03 [stmt.dcl.p3:
174  // A program that jumps from a point where a local variable
175  // with automatic storage duration is not in scope to a point
176  // where it is in scope is ill-formed unless the variable has
177  // POD type and is declared without an initializer.
178 
179  InDiag = diag::note_protected_by_variable_init;
180 
181  // For a variable of (array of) class type declared without an
182  // initializer, we will have call-style initialization and the initializer
183  // will be the CXXConstructExpr with no intervening nodes.
184  if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init)) {
185  const CXXConstructorDecl *Ctor = CCE->getConstructor();
186  if (Ctor->isTrivial() && Ctor->isDefaultConstructor() &&
187  VD->getInitStyle() == VarDecl::CallInit) {
188  if (OutDiag)
189  InDiag = diag::note_protected_by_variable_nontriv_destructor;
190  else if (!Ctor->getParent()->isPOD())
191  InDiag = diag::note_protected_by_variable_non_pod;
192  else
193  InDiag = 0;
194  }
195  }
196  }
197 
198  return ScopePair(InDiag, OutDiag);
199  }
200 
201  if (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
202  if (TD->getUnderlyingType()->isVariablyModifiedType())
203  return ScopePair(isa<TypedefDecl>(TD)
204  ? diag::note_protected_by_vla_typedef
205  : diag::note_protected_by_vla_type_alias,
206  0);
207  }
208 
209  return ScopePair(0U, 0U);
210 }
211 
212 /// \brief Build scope information for a declaration that is part of a DeclStmt.
213 void JumpScopeChecker::BuildScopeInformation(Decl *D, unsigned &ParentScope) {
214  // If this decl causes a new scope, push and switch to it.
215  std::pair<unsigned,unsigned> Diags = GetDiagForGotoScopeDecl(S, D);
216  if (Diags.first || Diags.second) {
217  Scopes.push_back(GotoScope(ParentScope, Diags.first, Diags.second,
218  D->getLocation()));
219  ParentScope = Scopes.size()-1;
220  }
221 
222  // If the decl has an initializer, walk it with the potentially new
223  // scope we just installed.
224  if (VarDecl *VD = dyn_cast<VarDecl>(D))
225  if (Expr *Init = VD->getInit())
226  BuildScopeInformation(Init, ParentScope);
227 }
228 
229 /// \brief Build scope information for a captured block literal variables.
230 void JumpScopeChecker::BuildScopeInformation(VarDecl *D,
231  const BlockDecl *BDecl,
232  unsigned &ParentScope) {
233  // exclude captured __block variables; there's no destructor
234  // associated with the block literal for them.
235  if (D->hasAttr<BlocksAttr>())
236  return;
237  QualType T = D->getType();
238  QualType::DestructionKind destructKind = T.isDestructedType();
239  if (destructKind != QualType::DK_none) {
240  std::pair<unsigned,unsigned> Diags;
241  switch (destructKind) {
242  case QualType::DK_cxx_destructor:
243  Diags = ScopePair(diag::note_enters_block_captures_cxx_obj,
244  diag::note_exits_block_captures_cxx_obj);
245  break;
246  case QualType::DK_objc_strong_lifetime:
247  Diags = ScopePair(diag::note_enters_block_captures_strong,
248  diag::note_exits_block_captures_strong);
249  break;
250  case QualType::DK_objc_weak_lifetime:
251  Diags = ScopePair(diag::note_enters_block_captures_weak,
252  diag::note_exits_block_captures_weak);
253  break;
254  case QualType::DK_none:
255  llvm_unreachable("non-lifetime captured variable");
256  }
257  SourceLocation Loc = D->getLocation();
258  if (Loc.isInvalid())
259  Loc = BDecl->getLocation();
260  Scopes.push_back(GotoScope(ParentScope,
261  Diags.first, Diags.second, Loc));
262  ParentScope = Scopes.size()-1;
263  }
264 }
265 
266 /// BuildScopeInformation - The statements from CI to CE are known to form a
267 /// coherent VLA scope with a specified parent node. Walk through the
268 /// statements, adding any labels or gotos to LabelAndGotoScopes and recursively
269 /// walking the AST as needed.
270 void JumpScopeChecker::BuildScopeInformation(Stmt *S, unsigned &origParentScope) {
271  // If this is a statement, rather than an expression, scopes within it don't
272  // propagate out into the enclosing scope. Otherwise we have to worry
273  // about block literals, which have the lifetime of their enclosing statement.
274  unsigned independentParentScope = origParentScope;
275  unsigned &ParentScope = ((isa<Expr>(S) && !isa<StmtExpr>(S))
276  ? origParentScope : independentParentScope);
277 
278  bool SkipFirstSubStmt = false;
279 
280  // If we found a label, remember that it is in ParentScope scope.
281  switch (S->getStmtClass()) {
282  case Stmt::AddrLabelExprClass:
283  IndirectJumpTargets.push_back(cast<AddrLabelExpr>(S)->getLabel());
284  break;
285 
286  case Stmt::IndirectGotoStmtClass:
287  // "goto *&&lbl;" is a special case which we treat as equivalent
288  // to a normal goto. In addition, we don't calculate scope in the
289  // operand (to avoid recording the address-of-label use), which
290  // works only because of the restricted set of expressions which
291  // we detect as constant targets.
292  if (cast<IndirectGotoStmt>(S)->getConstantTarget()) {
293  LabelAndGotoScopes[S] = ParentScope;
294  Jumps.push_back(S);
295  return;
296  }
297 
298  LabelAndGotoScopes[S] = ParentScope;
299  IndirectJumps.push_back(cast<IndirectGotoStmt>(S));
300  break;
301 
302  case Stmt::SwitchStmtClass:
303  // Evaluate the condition variable before entering the scope of the switch
304  // statement.
305  if (VarDecl *Var = cast<SwitchStmt>(S)->getConditionVariable()) {
306  BuildScopeInformation(Var, ParentScope);
307  SkipFirstSubStmt = true;
308  }
309  // Fall through
310 
311  case Stmt::GotoStmtClass:
312  // Remember both what scope a goto is in as well as the fact that we have
313  // it. This makes the second scan not have to walk the AST again.
314  LabelAndGotoScopes[S] = ParentScope;
315  Jumps.push_back(S);
316  break;
317 
318  case Stmt::CXXTryStmtClass: {
319  CXXTryStmt *TS = cast<CXXTryStmt>(S);
320  unsigned newParentScope;
321  Scopes.push_back(GotoScope(ParentScope,
322  diag::note_protected_by_cxx_try,
323  diag::note_exits_cxx_try,
324  TS->getSourceRange().getBegin()));
325  if (Stmt *TryBlock = TS->getTryBlock())
326  BuildScopeInformation(TryBlock, (newParentScope = Scopes.size()-1));
327 
328  // Jump from the catch into the try is not allowed either.
329  for (unsigned I = 0, E = TS->getNumHandlers(); I != E; ++I) {
330  CXXCatchStmt *CS = TS->getHandler(I);
331  Scopes.push_back(GotoScope(ParentScope,
332  diag::note_protected_by_cxx_catch,
333  diag::note_exits_cxx_catch,
334  CS->getSourceRange().getBegin()));
335  BuildScopeInformation(CS->getHandlerBlock(),
336  (newParentScope = Scopes.size()-1));
337  }
338  return;
339  }
340 
341  case Stmt::SEHTryStmtClass: {
342  SEHTryStmt *TS = cast<SEHTryStmt>(S);
343  unsigned newParentScope;
344  Scopes.push_back(GotoScope(ParentScope,
345  diag::note_protected_by_seh_try,
346  diag::note_exits_seh_try,
347  TS->getSourceRange().getBegin()));
348  if (Stmt *TryBlock = TS->getTryBlock())
349  BuildScopeInformation(TryBlock, (newParentScope = Scopes.size()-1));
350 
351  // Jump from __except or __finally into the __try are not allowed either.
352  if (SEHExceptStmt *Except = TS->getExceptHandler()) {
353  Scopes.push_back(GotoScope(ParentScope,
354  diag::note_protected_by_seh_except,
355  diag::note_exits_seh_except,
356  Except->getSourceRange().getBegin()));
357  BuildScopeInformation(Except->getBlock(),
358  (newParentScope = Scopes.size()-1));
359  } else if (SEHFinallyStmt *Finally = TS->getFinallyHandler()) {
360  Scopes.push_back(GotoScope(ParentScope,
361  diag::note_protected_by_seh_finally,
362  diag::note_exits_seh_finally,
363  Finally->getSourceRange().getBegin()));
364  BuildScopeInformation(Finally->getBlock(),
365  (newParentScope = Scopes.size()-1));
366  }
367 
368  return;
369  }
370 
371  default:
372  break;
373  }
374 
375  for (Stmt *SubStmt : S->children()) {
376  if (SkipFirstSubStmt) {
377  SkipFirstSubStmt = false;
378  continue;
379  }
380 
381  if (!SubStmt) continue;
382 
383  // Cases, labels, and defaults aren't "scope parents". It's also
384  // important to handle these iteratively instead of recursively in
385  // order to avoid blowing out the stack.
386  while (true) {
387  Stmt *Next;
388  if (CaseStmt *CS = dyn_cast<CaseStmt>(SubStmt))
389  Next = CS->getSubStmt();
390  else if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SubStmt))
391  Next = DS->getSubStmt();
392  else if (LabelStmt *LS = dyn_cast<LabelStmt>(SubStmt))
393  Next = LS->getSubStmt();
394  else
395  break;
396 
397  LabelAndGotoScopes[SubStmt] = ParentScope;
398  SubStmt = Next;
399  }
400 
401  // If this is a declstmt with a VLA definition, it defines a scope from here
402  // to the end of the containing context.
403  if (DeclStmt *DS = dyn_cast<DeclStmt>(SubStmt)) {
404  // The decl statement creates a scope if any of the decls in it are VLAs
405  // or have the cleanup attribute.
406  for (auto *I : DS->decls())
407  BuildScopeInformation(I, ParentScope);
408  continue;
409  }
410  // Disallow jumps into any part of an @try statement by pushing a scope and
411  // walking all sub-stmts in that scope.
412  if (ObjCAtTryStmt *AT = dyn_cast<ObjCAtTryStmt>(SubStmt)) {
413  unsigned newParentScope;
414  // Recursively walk the AST for the @try part.
415  Scopes.push_back(GotoScope(ParentScope,
416  diag::note_protected_by_objc_try,
417  diag::note_exits_objc_try,
418  AT->getAtTryLoc()));
419  if (Stmt *TryPart = AT->getTryBody())
420  BuildScopeInformation(TryPart, (newParentScope = Scopes.size()-1));
421 
422  // Jump from the catch to the finally or try is not valid.
423  for (unsigned I = 0, N = AT->getNumCatchStmts(); I != N; ++I) {
424  ObjCAtCatchStmt *AC = AT->getCatchStmt(I);
425  Scopes.push_back(GotoScope(ParentScope,
426  diag::note_protected_by_objc_catch,
427  diag::note_exits_objc_catch,
428  AC->getAtCatchLoc()));
429  // @catches are nested and it isn't
430  BuildScopeInformation(AC->getCatchBody(),
431  (newParentScope = Scopes.size()-1));
432  }
433 
434  // Jump from the finally to the try or catch is not valid.
435  if (ObjCAtFinallyStmt *AF = AT->getFinallyStmt()) {
436  Scopes.push_back(GotoScope(ParentScope,
437  diag::note_protected_by_objc_finally,
438  diag::note_exits_objc_finally,
439  AF->getAtFinallyLoc()));
440  BuildScopeInformation(AF, (newParentScope = Scopes.size()-1));
441  }
442 
443  continue;
444  }
445 
446  unsigned newParentScope;
447  // Disallow jumps into the protected statement of an @synchronized, but
448  // allow jumps into the object expression it protects.
449  if (ObjCAtSynchronizedStmt *AS =
450  dyn_cast<ObjCAtSynchronizedStmt>(SubStmt)) {
451  // Recursively walk the AST for the @synchronized object expr, it is
452  // evaluated in the normal scope.
453  BuildScopeInformation(AS->getSynchExpr(), ParentScope);
454 
455  // Recursively walk the AST for the @synchronized part, protected by a new
456  // scope.
457  Scopes.push_back(GotoScope(ParentScope,
458  diag::note_protected_by_objc_synchronized,
459  diag::note_exits_objc_synchronized,
460  AS->getAtSynchronizedLoc()));
461  BuildScopeInformation(AS->getSynchBody(),
462  (newParentScope = Scopes.size()-1));
463  continue;
464  }
465 
466  // Disallow jumps into the protected statement of an @autoreleasepool.
467  if (ObjCAutoreleasePoolStmt *AS =
468  dyn_cast<ObjCAutoreleasePoolStmt>(SubStmt)) {
469  // Recursively walk the AST for the @autoreleasepool part, protected by a
470  // new scope.
471  Scopes.push_back(GotoScope(ParentScope,
472  diag::note_protected_by_objc_autoreleasepool,
473  diag::note_exits_objc_autoreleasepool,
474  AS->getAtLoc()));
475  BuildScopeInformation(AS->getSubStmt(),
476  (newParentScope = Scopes.size() - 1));
477  continue;
478  }
479 
480  // Disallow jumps past full-expressions that use blocks with
481  // non-trivial cleanups of their captures. This is theoretically
482  // implementable but a lot of work which we haven't felt up to doing.
483  if (ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(SubStmt)) {
484  for (unsigned i = 0, e = EWC->getNumObjects(); i != e; ++i) {
485  const BlockDecl *BDecl = EWC->getObject(i);
486  for (const auto &CI : BDecl->captures()) {
487  VarDecl *variable = CI.getVariable();
488  BuildScopeInformation(variable, BDecl, ParentScope);
489  }
490  }
491  }
492 
493  // Disallow jumps out of scopes containing temporaries lifetime-extended to
494  // automatic storage duration.
495  if (MaterializeTemporaryExpr *MTE =
496  dyn_cast<MaterializeTemporaryExpr>(SubStmt)) {
497  if (MTE->getStorageDuration() == SD_Automatic) {
500  const Expr *ExtendedObject =
501  MTE->GetTemporaryExpr()->skipRValueSubobjectAdjustments(
502  CommaLHS, Adjustments);
503  if (ExtendedObject->getType().isDestructedType()) {
504  Scopes.push_back(GotoScope(ParentScope, 0,
505  diag::note_exits_temporary_dtor,
506  ExtendedObject->getExprLoc()));
507  ParentScope = Scopes.size()-1;
508  }
509  }
510  }
511 
512  // Recursively walk the AST.
513  BuildScopeInformation(SubStmt, ParentScope);
514  }
515 }
516 
517 /// VerifyJumps - Verify each element of the Jumps array to see if they are
518 /// valid, emitting diagnostics if not.
519 void JumpScopeChecker::VerifyJumps() {
520  while (!Jumps.empty()) {
521  Stmt *Jump = Jumps.pop_back_val();
522 
523  // With a goto,
524  if (GotoStmt *GS = dyn_cast<GotoStmt>(Jump)) {
525  // The label may not have a statement if it's coming from inline MS ASM.
526  if (GS->getLabel()->getStmt()) {
527  CheckJump(GS, GS->getLabel()->getStmt(), GS->getGotoLoc(),
528  diag::err_goto_into_protected_scope,
529  diag::ext_goto_into_protected_scope,
530  diag::warn_cxx98_compat_goto_into_protected_scope);
531  }
532  CheckGotoStmt(GS);
533  continue;
534  }
535 
536  // We only get indirect gotos here when they have a constant target.
537  if (IndirectGotoStmt *IGS = dyn_cast<IndirectGotoStmt>(Jump)) {
538  LabelDecl *Target = IGS->getConstantTarget();
539  CheckJump(IGS, Target->getStmt(), IGS->getGotoLoc(),
540  diag::err_goto_into_protected_scope,
541  diag::ext_goto_into_protected_scope,
542  diag::warn_cxx98_compat_goto_into_protected_scope);
543  continue;
544  }
545 
546  SwitchStmt *SS = cast<SwitchStmt>(Jump);
547  for (SwitchCase *SC = SS->getSwitchCaseList(); SC;
548  SC = SC->getNextSwitchCase()) {
549  if (CHECK_PERMISSIVE(!LabelAndGotoScopes.count(SC)))
550  continue;
551  SourceLocation Loc;
552  if (CaseStmt *CS = dyn_cast<CaseStmt>(SC))
553  Loc = CS->getLocStart();
554  else if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC))
555  Loc = DS->getLocStart();
556  else
557  Loc = SC->getLocStart();
558  CheckJump(SS, SC, Loc, diag::err_switch_into_protected_scope, 0,
559  diag::warn_cxx98_compat_switch_into_protected_scope);
560  }
561  }
562 }
563 
564 /// VerifyIndirectJumps - Verify whether any possible indirect jump
565 /// might cross a protection boundary. Unlike direct jumps, indirect
566 /// jumps count cleanups as protection boundaries: since there's no
567 /// way to know where the jump is going, we can't implicitly run the
568 /// right cleanups the way we can with direct jumps.
569 ///
570 /// Thus, an indirect jump is "trivial" if it bypasses no
571 /// initializations and no teardowns. More formally, an indirect jump
572 /// from A to B is trivial if the path out from A to DCA(A,B) is
573 /// trivial and the path in from DCA(A,B) to B is trivial, where
574 /// DCA(A,B) is the deepest common ancestor of A and B.
575 /// Jump-triviality is transitive but asymmetric.
576 ///
577 /// A path in is trivial if none of the entered scopes have an InDiag.
578 /// A path out is trivial is none of the exited scopes have an OutDiag.
579 ///
580 /// Under these definitions, this function checks that the indirect
581 /// jump between A and B is trivial for every indirect goto statement A
582 /// and every label B whose address was taken in the function.
583 void JumpScopeChecker::VerifyIndirectJumps() {
584  if (IndirectJumps.empty()) return;
585 
586  // If there aren't any address-of-label expressions in this function,
587  // complain about the first indirect goto.
588  if (IndirectJumpTargets.empty()) {
589  S.Diag(IndirectJumps[0]->getGotoLoc(),
590  diag::err_indirect_goto_without_addrlabel);
591  return;
592  }
593 
594  // Collect a single representative of every scope containing an
595  // indirect goto. For most code bases, this substantially cuts
596  // down on the number of jump sites we'll have to consider later.
597  typedef std::pair<unsigned, IndirectGotoStmt*> JumpScope;
598  SmallVector<JumpScope, 32> JumpScopes;
599  {
600  llvm::DenseMap<unsigned, IndirectGotoStmt*> JumpScopesMap;
602  I = IndirectJumps.begin(), E = IndirectJumps.end(); I != E; ++I) {
603  IndirectGotoStmt *IG = *I;
604  if (CHECK_PERMISSIVE(!LabelAndGotoScopes.count(IG)))
605  continue;
606  unsigned IGScope = LabelAndGotoScopes[IG];
607  IndirectGotoStmt *&Entry = JumpScopesMap[IGScope];
608  if (!Entry) Entry = IG;
609  }
610  JumpScopes.reserve(JumpScopesMap.size());
611  for (llvm::DenseMap<unsigned, IndirectGotoStmt*>::iterator
612  I = JumpScopesMap.begin(), E = JumpScopesMap.end(); I != E; ++I)
613  JumpScopes.push_back(*I);
614  }
615 
616  // Collect a single representative of every scope containing a
617  // label whose address was taken somewhere in the function.
618  // For most code bases, there will be only one such scope.
619  llvm::DenseMap<unsigned, LabelDecl*> TargetScopes;
621  I = IndirectJumpTargets.begin(), E = IndirectJumpTargets.end();
622  I != E; ++I) {
623  LabelDecl *TheLabel = *I;
624  if (CHECK_PERMISSIVE(!LabelAndGotoScopes.count(TheLabel->getStmt())))
625  continue;
626  unsigned LabelScope = LabelAndGotoScopes[TheLabel->getStmt()];
627  LabelDecl *&Target = TargetScopes[LabelScope];
628  if (!Target) Target = TheLabel;
629  }
630 
631  // For each target scope, make sure it's trivially reachable from
632  // every scope containing a jump site.
633  //
634  // A path between scopes always consists of exitting zero or more
635  // scopes, then entering zero or more scopes. We build a set of
636  // of scopes S from which the target scope can be trivially
637  // entered, then verify that every jump scope can be trivially
638  // exitted to reach a scope in S.
639  llvm::BitVector Reachable(Scopes.size(), false);
640  for (llvm::DenseMap<unsigned,LabelDecl*>::iterator
641  TI = TargetScopes.begin(), TE = TargetScopes.end(); TI != TE; ++TI) {
642  unsigned TargetScope = TI->first;
643  LabelDecl *TargetLabel = TI->second;
644 
645  Reachable.reset();
646 
647  // Mark all the enclosing scopes from which you can safely jump
648  // into the target scope. 'Min' will end up being the index of
649  // the shallowest such scope.
650  unsigned Min = TargetScope;
651  while (true) {
652  Reachable.set(Min);
653 
654  // Don't go beyond the outermost scope.
655  if (Min == 0) break;
656 
657  // Stop if we can't trivially enter the current scope.
658  if (Scopes[Min].InDiag) break;
659 
660  Min = Scopes[Min].ParentScope;
661  }
662 
663  // Walk through all the jump sites, checking that they can trivially
664  // reach this label scope.
666  I = JumpScopes.begin(), E = JumpScopes.end(); I != E; ++I) {
667  unsigned Scope = I->first;
668 
669  // Walk out the "scope chain" for this scope, looking for a scope
670  // we've marked reachable. For well-formed code this amortizes
671  // to O(JumpScopes.size() / Scopes.size()): we only iterate
672  // when we see something unmarked, and in well-formed code we
673  // mark everything we iterate past.
674  bool IsReachable = false;
675  while (true) {
676  if (Reachable.test(Scope)) {
677  // If we find something reachable, mark all the scopes we just
678  // walked through as reachable.
679  for (unsigned S = I->first; S != Scope; S = Scopes[S].ParentScope)
680  Reachable.set(S);
681  IsReachable = true;
682  break;
683  }
684 
685  // Don't walk out if we've reached the top-level scope or we've
686  // gotten shallower than the shallowest reachable scope.
687  if (Scope == 0 || Scope < Min) break;
688 
689  // Don't walk out through an out-diagnostic.
690  if (Scopes[Scope].OutDiag) break;
691 
692  Scope = Scopes[Scope].ParentScope;
693  }
694 
695  // Only diagnose if we didn't find something.
696  if (IsReachable) continue;
697 
698  DiagnoseIndirectJump(I->second, I->first, TargetLabel, TargetScope);
699  }
700  }
701 }
702 
703 /// Return true if a particular error+note combination must be downgraded to a
704 /// warning in Microsoft mode.
705 static bool IsMicrosoftJumpWarning(unsigned JumpDiag, unsigned InDiagNote) {
706  return (JumpDiag == diag::err_goto_into_protected_scope &&
707  (InDiagNote == diag::note_protected_by_variable_init ||
708  InDiagNote == diag::note_protected_by_variable_nontriv_destructor));
709 }
710 
711 /// Return true if a particular note should be downgraded to a compatibility
712 /// warning in C++11 mode.
713 static bool IsCXX98CompatWarning(Sema &S, unsigned InDiagNote) {
714  return S.getLangOpts().CPlusPlus11 &&
715  InDiagNote == diag::note_protected_by_variable_non_pod;
716 }
717 
718 /// Produce primary diagnostic for an indirect jump statement.
720  LabelDecl *Target, bool &Diagnosed) {
721  if (Diagnosed)
722  return;
723  S.Diag(Jump->getGotoLoc(), diag::err_indirect_goto_in_protected_scope);
724  S.Diag(Target->getStmt()->getIdentLoc(), diag::note_indirect_goto_target);
725  Diagnosed = true;
726 }
727 
728 /// Produce note diagnostics for a jump into a protected scope.
729 void JumpScopeChecker::NoteJumpIntoScopes(ArrayRef<unsigned> ToScopes) {
730  if (CHECK_PERMISSIVE(ToScopes.empty()))
731  return;
732  for (unsigned I = 0, E = ToScopes.size(); I != E; ++I)
733  if (Scopes[ToScopes[I]].InDiag)
734  S.Diag(Scopes[ToScopes[I]].Loc, Scopes[ToScopes[I]].InDiag);
735 }
736 
737 /// Diagnose an indirect jump which is known to cross scopes.
738 void JumpScopeChecker::DiagnoseIndirectJump(IndirectGotoStmt *Jump,
739  unsigned JumpScope,
740  LabelDecl *Target,
741  unsigned TargetScope) {
742  if (CHECK_PERMISSIVE(JumpScope == TargetScope))
743  return;
744 
745  unsigned Common = GetDeepestCommonScope(JumpScope, TargetScope);
746  bool Diagnosed = false;
747 
748  // Walk out the scope chain until we reach the common ancestor.
749  for (unsigned I = JumpScope; I != Common; I = Scopes[I].ParentScope)
750  if (Scopes[I].OutDiag) {
751  DiagnoseIndirectJumpStmt(S, Jump, Target, Diagnosed);
752  S.Diag(Scopes[I].Loc, Scopes[I].OutDiag);
753  }
754 
755  SmallVector<unsigned, 10> ToScopesCXX98Compat;
756 
757  // Now walk into the scopes containing the label whose address was taken.
758  for (unsigned I = TargetScope; I != Common; I = Scopes[I].ParentScope)
759  if (IsCXX98CompatWarning(S, Scopes[I].InDiag))
760  ToScopesCXX98Compat.push_back(I);
761  else if (Scopes[I].InDiag) {
762  DiagnoseIndirectJumpStmt(S, Jump, Target, Diagnosed);
763  S.Diag(Scopes[I].Loc, Scopes[I].InDiag);
764  }
765 
766  // Diagnose this jump if it would be ill-formed in C++98.
767  if (!Diagnosed && !ToScopesCXX98Compat.empty()) {
768  S.Diag(Jump->getGotoLoc(),
769  diag::warn_cxx98_compat_indirect_goto_in_protected_scope);
770  S.Diag(Target->getStmt()->getIdentLoc(), diag::note_indirect_goto_target);
771  NoteJumpIntoScopes(ToScopesCXX98Compat);
772  }
773 }
774 
775 /// CheckJump - Validate that the specified jump statement is valid: that it is
776 /// jumping within or out of its current scope, not into a deeper one.
777 void JumpScopeChecker::CheckJump(Stmt *From, Stmt *To, SourceLocation DiagLoc,
778  unsigned JumpDiagError, unsigned JumpDiagWarning,
779  unsigned JumpDiagCXX98Compat) {
780  if (CHECK_PERMISSIVE(!LabelAndGotoScopes.count(From)))
781  return;
782  if (CHECK_PERMISSIVE(!LabelAndGotoScopes.count(To)))
783  return;
784 
785  unsigned FromScope = LabelAndGotoScopes[From];
786  unsigned ToScope = LabelAndGotoScopes[To];
787 
788  // Common case: exactly the same scope, which is fine.
789  if (FromScope == ToScope) return;
790 
791  // Warn on gotos out of __finally blocks.
792  if (isa<GotoStmt>(From) || isa<IndirectGotoStmt>(From)) {
793  // If FromScope > ToScope, FromScope is more nested and the jump goes to a
794  // less nested scope. Check if it crosses a __finally along the way.
795  for (unsigned I = FromScope; I > ToScope; I = Scopes[I].ParentScope) {
796  if (Scopes[I].InDiag == diag::note_protected_by_seh_finally) {
797  S.Diag(From->getLocStart(), diag::warn_jump_out_of_seh_finally);
798  break;
799  }
800  }
801  }
802 
803  unsigned CommonScope = GetDeepestCommonScope(FromScope, ToScope);
804 
805  // It's okay to jump out from a nested scope.
806  if (CommonScope == ToScope) return;
807 
808  // Pull out (and reverse) any scopes we might need to diagnose skipping.
809  SmallVector<unsigned, 10> ToScopesCXX98Compat;
810  SmallVector<unsigned, 10> ToScopesError;
811  SmallVector<unsigned, 10> ToScopesWarning;
812  for (unsigned I = ToScope; I != CommonScope; I = Scopes[I].ParentScope) {
813  if (S.getLangOpts().MSVCCompat && JumpDiagWarning != 0 &&
814  IsMicrosoftJumpWarning(JumpDiagError, Scopes[I].InDiag))
815  ToScopesWarning.push_back(I);
816  else if (IsCXX98CompatWarning(S, Scopes[I].InDiag))
817  ToScopesCXX98Compat.push_back(I);
818  else if (Scopes[I].InDiag)
819  ToScopesError.push_back(I);
820  }
821 
822  // Handle warnings.
823  if (!ToScopesWarning.empty()) {
824  S.Diag(DiagLoc, JumpDiagWarning);
825  NoteJumpIntoScopes(ToScopesWarning);
826  }
827 
828  // Handle errors.
829  if (!ToScopesError.empty()) {
830  S.Diag(DiagLoc, JumpDiagError);
831  NoteJumpIntoScopes(ToScopesError);
832  }
833 
834  // Handle -Wc++98-compat warnings if the jump is well-formed.
835  if (ToScopesError.empty() && !ToScopesCXX98Compat.empty()) {
836  S.Diag(DiagLoc, JumpDiagCXX98Compat);
837  NoteJumpIntoScopes(ToScopesCXX98Compat);
838  }
839 }
840 
841 void JumpScopeChecker::CheckGotoStmt(GotoStmt *GS) {
842  if (GS->getLabel()->isMSAsmLabel()) {
843  S.Diag(GS->getGotoLoc(), diag::err_goto_ms_asm_label)
844  << GS->getLabel()->getIdentifier();
845  S.Diag(GS->getLabel()->getLocation(), diag::note_goto_ms_asm_label)
846  << GS->getLabel()->getIdentifier();
847  }
848 }
849 
850 void Sema::DiagnoseInvalidJumps(Stmt *Body) {
851  (void)JumpScopeChecker(Body, *this);
852 }
const SwitchCase * getNextSwitchCase() const
Definition: Stmt.h:667
DestructionKind isDestructedType() const
Definition: Type.h:999
IdentifierInfo * getIdentifier() const
Definition: Decl.h:163
const LangOptions & getLangOpts() const
Definition: Sema.h:1019
CXXCatchStmt * getHandler(unsigned i)
Definition: StmtCXX.h:104
static bool IsMicrosoftJumpWarning(unsigned JumpDiag, unsigned InDiagNote)
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1088
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1075
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2147
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:3746
SourceLocation getLocStart() const LLVM_READONLY
Definition: StmtCXX.h:44
#define CHECK_PERMISSIVE(x)
capture_range captures()
Definition: Decl.h:3563
Defines the Objective-C statement AST node classes.
Defines the clang::Expr interface and subclasses for C++ expressions.
bool hasAttr() const
Definition: DeclBase.h:487
Represents Objective-C's @catch statement.
Definition: StmtObjC.h:74
const LangOptions & getLangOpts() const
Definition: ASTContext.h:533
const CXXRecordDecl * getParent() const
Definition: DeclCXX.h:1817
Stmt * getHandlerBlock() const
Definition: StmtCXX.h:52
const Expr * skipRValueSubobjectAdjustments(SmallVectorImpl< const Expr * > &CommaLHS, SmallVectorImpl< SubobjectAdjustment > &Adjustments) const
Definition: Expr.cpp:54
LabelStmt * getStmt() const
Definition: Decl.h:378
const Stmt * getCatchBody() const
Definition: StmtObjC.h:90
QualType getType() const
Definition: Decl.h:538
bool isInvalid() const
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:258
SourceLocation getGotoLoc() const
Definition: Stmt.h:1229
Represents Objective-C's @synchronized statement.
Definition: StmtObjC.h:262
bool isMSAsmLabel() const
Definition: Decl.h:388
const SwitchCase * getSwitchCaseList() const
Definition: Stmt.h:987
std::pair< unsigned, unsigned > ScopePair
LabelDecl * getLabel() const
Definition: Stmt.h:1226
SourceLocation getGotoLoc() const
Definition: Stmt.h:1262
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
SourceLocation getIdentLoc() const
Definition: Stmt.h:808
SEHExceptStmt * getExceptHandler() const
Returns 0 if not defined.
Definition: Stmt.cpp:1038
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.cpp:193
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2576
QualType getType() const
Definition: Expr.h:125
unsigned getNumHandlers() const
Definition: StmtCXX.h:103
SourceLocation getAtCatchLoc() const
Definition: StmtObjC.h:102
bool isTrivial() const
Definition: Decl.h:1800
Represents Objective-C's @finally statement.
Definition: StmtObjC.h:120
bool isDefaultConstructor() const
Definition: DeclCXX.cpp:1777
static ScopePair GetDiagForGotoScopeDecl(Sema &S, const Decl *D)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
static void DiagnoseIndirectJumpStmt(Sema &S, IndirectGotoStmt *Jump, LabelDecl *Target, bool &Diagnosed)
Produce primary diagnostic for an indirect jump statement.
CompoundStmt * getTryBlock()
Definition: StmtCXX.h:96
Represents Objective-C's @try ... @catch ... @finally statement.
Definition: StmtObjC.h:154
SourceLocation getLocation() const
Definition: DeclBase.h:372
ASTContext & Context
Definition: Sema.h:295
CompoundStmt * getTryBlock() const
Definition: Stmt.h:1936
Automatic storage duration (most local variables).
Definition: Specifiers.h:240
Represents Objective-C's @autoreleasepool Statement.
Definition: StmtObjC.h:345
SEHFinallyStmt * getFinallyHandler() const
Definition: Stmt.cpp:1042
static bool IsCXX98CompatWarning(Sema &S, unsigned InDiagNote)
bool isPOD() const
Whether this class is a POD-type (C++ [class]p4)
Definition: DeclCXX.h:1130