Coverage Report

Created: 2022-01-25 06:29

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/StaticAnalyzer/Checkers/DeadStoresChecker.cpp
Line
Count
Source (jump to first uncovered line)
1
//==- DeadStoresChecker.cpp - Check for stores to dead variables -*- 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 a DeadStores, a flow-sensitive checker that looks for
10
//  stores to variables that are no longer live.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#include "clang/AST/ASTContext.h"
15
#include "clang/AST/Attr.h"
16
#include "clang/AST/ParentMap.h"
17
#include "clang/AST/RecursiveASTVisitor.h"
18
#include "clang/Analysis/Analyses/LiveVariables.h"
19
#include "clang/Lex/Lexer.h"
20
#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
21
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
22
#include "clang/StaticAnalyzer/Core/Checker.h"
23
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
24
#include "llvm/ADT/BitVector.h"
25
#include "llvm/ADT/STLExtras.h"
26
#include "llvm/ADT/SmallString.h"
27
#include "llvm/Support/SaveAndRestore.h"
28
29
using namespace clang;
30
using namespace ento;
31
32
namespace {
33
34
/// A simple visitor to record what VarDecls occur in EH-handling code.
35
class EHCodeVisitor : public RecursiveASTVisitor<EHCodeVisitor> {
36
public:
37
  bool inEH;
38
  llvm::DenseSet<const VarDecl *> &S;
39
40
0
  bool TraverseObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
41
0
    SaveAndRestore<bool> inFinally(inEH, true);
42
0
    return ::RecursiveASTVisitor<EHCodeVisitor>::TraverseObjCAtFinallyStmt(S);
43
0
  }
44
45
0
  bool TraverseObjCAtCatchStmt(ObjCAtCatchStmt *S) {
46
0
    SaveAndRestore<bool> inCatch(inEH, true);
47
0
    return ::RecursiveASTVisitor<EHCodeVisitor>::TraverseObjCAtCatchStmt(S);
48
0
  }
49
50
6
  bool TraverseCXXCatchStmt(CXXCatchStmt *S) {
51
6
    SaveAndRestore<bool> inCatch(inEH, true);
52
6
    return TraverseStmt(S->getHandlerBlock());
53
6
  }
54
55
601
  bool VisitDeclRefExpr(DeclRefExpr *DR) {
56
601
    if (inEH)
57
6
      if (const VarDecl *D = dyn_cast<VarDecl>(DR->getDecl()))
58
6
        S.insert(D);
59
601
    return true;
60
601
  }
61
62
  EHCodeVisitor(llvm::DenseSet<const VarDecl *> &S) :
63
133
  inEH(false), S(S) {}
64
};
65
66
// FIXME: Eventually migrate into its own file, and have it managed by
67
// AnalysisManager.
68
class ReachableCode {
69
  const CFG &cfg;
70
  llvm::BitVector reachable;
71
public:
72
  ReachableCode(const CFG &cfg)
73
89
    : cfg(cfg), reachable(cfg.getNumBlockIDs(), false) {}
74
75
  void computeReachableBlocks();
76
77
127
  bool isReachable(const CFGBlock *block) const {
78
127
    return reachable[block->getBlockID()];
79
127
  }
80
};
81
}
82
83
89
void ReachableCode::computeReachableBlocks() {
84
89
  if (!cfg.getNumBlockIDs())
85
0
    return;
86
87
89
  SmallVector<const CFGBlock*, 10> worklist;
88
89
  worklist.push_back(&cfg.getEntry());
89
90
614
  while (!worklist.empty()) {
91
525
    const CFGBlock *block = worklist.pop_back_val();
92
525
    llvm::BitVector::reference isReachable = reachable[block->getBlockID()];
93
525
    if (isReachable)
94
69
      continue;
95
456
    isReachable = true;
96
456
    for (CFGBlock::const_succ_iterator i = block->succ_begin(),
97
949
                                       e = block->succ_end(); i != e; 
++i493
)
98
493
      if (const CFGBlock *succ = *i)
99
436
        worklist.push_back(succ);
100
456
  }
101
89
}
102
103
static const Expr *
104
750
LookThroughTransitiveAssignmentsAndCommaOperators(const Expr *Ex) {
105
781
  while (Ex) {
106
781
    const BinaryOperator *BO =
107
781
      dyn_cast<BinaryOperator>(Ex->IgnoreParenCasts());
108
781
    if (!BO)
109
689
      break;
110
92
    if (BO->getOpcode() == BO_Assign) {
111
13
      Ex = BO->getRHS();
112
13
      continue;
113
13
    }
114
79
    if (BO->getOpcode() == BO_Comma) {
115
18
      Ex = BO->getRHS();
116
18
      continue;
117
18
    }
118
61
    break;
119
79
  }
120
750
  return Ex;
121
750
}
122
123
namespace {
124
class DeadStoresChecker : public Checker<check::ASTCodeBody> {
125
public:
126
  bool ShowFixIts = false;
127
  bool WarnForDeadNestedAssignments = true;
128
129
  void checkASTCodeBody(const Decl *D, AnalysisManager &Mgr,
130
                        BugReporter &BR) const;
131
};
132
133
class DeadStoreObs : public LiveVariables::Observer {
134
  const CFG &cfg;
135
  ASTContext &Ctx;
136
  BugReporter& BR;
137
  const DeadStoresChecker *Checker;
138
  AnalysisDeclContext* AC;
139
  ParentMap& Parents;
140
  llvm::SmallPtrSet<const VarDecl*, 20> Escaped;
141
  std::unique_ptr<ReachableCode> reachableCode;
142
  const CFGBlock *currentBlock;
143
  std::unique_ptr<llvm::DenseSet<const VarDecl *>> InEH;
144
145
  enum DeadStoreKind { Standard, Enclosing, DeadIncrement, DeadInit };
146
147
public:
148
  DeadStoreObs(const CFG &cfg, ASTContext &ctx, BugReporter &br,
149
               const DeadStoresChecker *checker, AnalysisDeclContext *ac,
150
               ParentMap &parents,
151
               llvm::SmallPtrSet<const VarDecl *, 20> &escaped,
152
               bool warnForDeadNestedAssignments)
153
      : cfg(cfg), Ctx(ctx), BR(br), Checker(checker), AC(ac), Parents(parents),
154
517
        Escaped(escaped), currentBlock(nullptr) {}
155
156
517
  ~DeadStoreObs() override {}
157
158
669
  bool isLive(const LiveVariables::LivenessValues &Live, const VarDecl *D) {
159
669
    if (Live.isLive(D))
160
469
      return true;
161
    // Lazily construct the set that records which VarDecls are in
162
    // EH code.
163
200
    if (!InEH.get()) {
164
133
      InEH.reset(new llvm::DenseSet<const VarDecl *>());
165
133
      EHCodeVisitor V(*InEH.get());
166
133
      V.TraverseStmt(AC->getBody());
167
133
    }
168
    // Treat all VarDecls that occur in EH code as being "always live"
169
    // when considering to suppress dead stores.  Frequently stores
170
    // are followed by reads in EH code, but we don't have the ability
171
    // to analyze that yet.
172
200
    return InEH->count(D);
173
669
  }
174
175
119
  bool isSuppressed(SourceRange R) {
176
119
    SourceManager &SMgr = Ctx.getSourceManager();
177
119
    SourceLocation Loc = R.getBegin();
178
119
    if (!Loc.isValid())
179
0
      return false;
180
181
119
    FileID FID = SMgr.getFileID(Loc);
182
119
    bool Invalid = false;
183
119
    StringRef Data = SMgr.getBufferData(FID, &Invalid);
184
119
    if (Invalid)
185
0
      return false;
186
187
    // Files autogenerated by DriverKit IIG contain some dead stores that
188
    // we don't want to report.
189
119
    if (Data.startswith("/* iig"))
190
2
      return true;
191
192
117
    return false;
193
119
  }
194
195
  void Report(const VarDecl *V, DeadStoreKind dsk,
196
129
              PathDiagnosticLocation L, SourceRange R) {
197
129
    if (Escaped.count(V))
198
2
      return;
199
200
    // Compute reachable blocks within the CFG for trivial cases
201
    // where a bogus dead store can be reported because itself is unreachable.
202
127
    if (!reachableCode.get()) {
203
89
      reachableCode.reset(new ReachableCode(cfg));
204
89
      reachableCode->computeReachableBlocks();
205
89
    }
206
207
127
    if (!reachableCode->isReachable(currentBlock))
208
8
      return;
209
210
119
    if (isSuppressed(R))
211
2
      return;
212
213
117
    SmallString<64> buf;
214
117
    llvm::raw_svector_ostream os(buf);
215
117
    const char *BugType = nullptr;
216
217
117
    SmallVector<FixItHint, 1> Fixits;
218
219
117
    switch (dsk) {
220
50
      case DeadInit: {
221
50
        BugType = "Dead initialization";
222
50
        os << "Value stored to '" << *V
223
50
           << "' during its initialization is never read";
224
225
50
        ASTContext &ACtx = V->getASTContext();
226
50
        if (Checker->ShowFixIts) {
227
35
          if (V->getInit()->HasSideEffects(ACtx,
228
35
                                           /*IncludePossibleEffects=*/true)) {
229
25
            break;
230
25
          }
231
10
          SourceManager &SM = ACtx.getSourceManager();
232
10
          const LangOptions &LO = ACtx.getLangOpts();
233
10
          SourceLocation L1 =
234
10
              Lexer::findNextToken(
235
10
                  V->getTypeSourceInfo()->getTypeLoc().getEndLoc(),
236
10
                  SM, LO)->getEndLoc();
237
10
          SourceLocation L2 =
238
10
              Lexer::getLocForEndOfToken(V->getInit()->getEndLoc(), 1, SM, LO);
239
10
          Fixits.push_back(FixItHint::CreateRemoval({L1, L2}));
240
10
        }
241
25
        break;
242
50
      }
243
244
25
      case DeadIncrement:
245
24
        BugType = "Dead increment";
246
24
        LLVM_FALLTHROUGH;
247
51
      case Standard:
248
51
        if (!BugType) 
BugType = "Dead assignment"27
;
249
51
        os << "Value stored to '" << *V << "' is never read";
250
51
        break;
251
252
      // eg.: f((x = foo()))
253
16
      case Enclosing:
254
16
        if (!Checker->WarnForDeadNestedAssignments)
255
8
          return;
256
8
        BugType = "Dead nested assignment";
257
8
        os << "Although the value stored to '" << *V
258
8
           << "' is used in the enclosing expression, the value is never "
259
8
              "actually read from '"
260
8
           << *V << "'";
261
8
        break;
262
117
    }
263
264
109
    BR.EmitBasicReport(AC->getDecl(), Checker, BugType, categories::UnusedCode,
265
109
                       os.str(), L, R, Fixits);
266
109
  }
267
268
  void CheckVarDecl(const VarDecl *VD, const Expr *Ex, const Expr *Val,
269
                    DeadStoreKind dsk,
270
223
                    const LiveVariables::LivenessValues &Live) {
271
272
223
    if (!VD->hasLocalStorage())
273
8
      return;
274
    // Reference types confuse the dead stores checker.  Skip them
275
    // for now.
276
215
    if (VD->getType()->getAs<ReferenceType>())
277
6
      return;
278
279
209
    if (!isLive(Live, VD) &&
280
209
        
!(94
VD->hasAttr<UnusedAttr>()94
||
VD->hasAttr<BlocksAttr>()94
||
281
94
          
VD->hasAttr<ObjCPreciseLifetimeAttr>()80
)) {
282
283
79
      PathDiagnosticLocation ExLoc =
284
79
        PathDiagnosticLocation::createBegin(Ex, BR.getSourceManager(), AC);
285
79
      Report(VD, dsk, ExLoc, Val->getSourceRange());
286
79
    }
287
209
  }
288
289
  void CheckDeclRef(const DeclRefExpr *DR, const Expr *Val, DeadStoreKind dsk,
290
2
                    const LiveVariables::LivenessValues& Live) {
291
2
    if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl()))
292
2
      CheckVarDecl(VD, DR, Val, dsk, Live);
293
2
  }
294
295
194
  bool isIncrement(VarDecl *VD, const BinaryOperator* B) {
296
194
    if (B->isCompoundAssignmentOp())
297
21
      return true;
298
299
173
    const Expr *RHS = B->getRHS()->IgnoreParenCasts();
300
173
    const BinaryOperator* BRHS = dyn_cast<BinaryOperator>(RHS);
301
302
173
    if (!BRHS)
303
135
      return false;
304
305
38
    const DeclRefExpr *DR;
306
307
38
    if ((DR = dyn_cast<DeclRefExpr>(BRHS->getLHS()->IgnoreParenCasts())))
308
33
      if (DR->getDecl() == VD)
309
20
        return true;
310
311
18
    if ((DR = dyn_cast<DeclRefExpr>(BRHS->getRHS()->IgnoreParenCasts())))
312
7
      if (DR->getDecl() == VD)
313
3
        return true;
314
315
15
    return false;
316
18
  }
317
318
  void observeStmt(const Stmt *S, const CFGBlock *block,
319
8.95k
                   const LiveVariables::LivenessValues &Live) override {
320
321
8.95k
    currentBlock = block;
322
323
    // Skip statements in macros.
324
8.95k
    if (S->getBeginLoc().isMacroID())
325
140
      return;
326
327
    // Only cover dead stores from regular assignments.  ++/-- dead stores
328
    // have never flagged a real bug.
329
8.81k
    if (const BinaryOperator* B = dyn_cast<BinaryOperator>(S)) {
330
838
      if (!B->isAssignmentOp()) 
return429
; // Skip non-assignments.
331
332
409
      if (DeclRefExpr *DR = dyn_cast<DeclRefExpr>(B->getLHS()))
333
266
        if (VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) {
334
          // Special case: check for assigning null to a pointer.
335
          //  This is a common form of defensive programming.
336
259
          const Expr *RHS =
337
259
            LookThroughTransitiveAssignmentsAndCommaOperators(B->getRHS());
338
259
          RHS = RHS->IgnoreParenCasts();
339
340
259
          QualType T = VD->getType();
341
259
          if (T.isVolatileQualified())
342
2
            return;
343
257
          if (T->isPointerType() || 
T->isObjCObjectPointerType()191
) {
344
73
            if (RHS->isNullPointerConstant(Ctx, Expr::NPC_ValueDependentIsNull))
345
34
              return;
346
73
          }
347
348
          // Special case: self-assignments.  These are often used to shut up
349
          //  "unused variable" compiler warnings.
350
223
          if (const DeclRefExpr *RhsDR = dyn_cast<DeclRefExpr>(RHS))
351
17
            if (VD == dyn_cast<VarDecl>(RhsDR->getDecl()))
352
2
              return;
353
354
          // Otherwise, issue a warning.
355
221
          DeadStoreKind dsk = Parents.isConsumedExpr(B)
356
221
                              ? 
Enclosing27
357
221
                              : 
(194
isIncrement(VD,B)194
?
DeadIncrement44
:
Standard150
);
358
359
221
          CheckVarDecl(VD, DR, B->getRHS(), dsk, Live);
360
221
        }
361
409
    }
362
7.97k
    else if (const UnaryOperator* U = dyn_cast<UnaryOperator>(S)) {
363
361
      if (!U->isIncrementOp() || 
U->isPrefix()112
)
364
342
        return;
365
366
19
      const Stmt *parent = Parents.getParentIgnoreParenCasts(U);
367
19
      if (!parent || !isa<ReturnStmt>(parent))
368
13
        return;
369
370
6
      const Expr *Ex = U->getSubExpr()->IgnoreParenCasts();
371
372
6
      if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Ex))
373
2
        CheckDeclRef(DR, U, DeadIncrement, Live);
374
6
    }
375
7.61k
    else if (const DeclStmt *DS = dyn_cast<DeclStmt>(S))
376
      // Iterate through the decls.  Warn if any initializers are complex
377
      // expressions that are not live (never used).
378
632
      for (const auto *DI : DS->decls()) {
379
632
        const auto *V = dyn_cast<VarDecl>(DI);
380
381
632
        if (!V)
382
0
          continue;
383
384
632
        if (V->hasLocalStorage()) {
385
          // Reference types confuse the dead stores checker.  Skip them
386
          // for now.
387
612
          if (V->getType()->getAs<ReferenceType>())
388
14
            return;
389
390
598
          if (const Expr *E = V->getInit()) {
391
542
            while (const FullExpr *FE = dyn_cast<FullExpr>(E))
392
51
              E = FE->getSubExpr();
393
394
            // Look through transitive assignments, e.g.:
395
            // int x = y = 0;
396
491
            E = LookThroughTransitiveAssignmentsAndCommaOperators(E);
397
398
            // Don't warn on C++ objects (yet) until we can show that their
399
            // constructors/destructors don't have side effects.
400
491
            if (isa<CXXConstructExpr>(E))
401
31
              return;
402
403
            // A dead initialization is a variable that is dead after it
404
            // is initialized.  We don't flag warnings for those variables
405
            // marked 'unused' or 'objc_precise_lifetime'.
406
460
            if (!isLive(Live, V) &&
407
460
                
!V->hasAttr<UnusedAttr>()100
&&
408
460
                
!V->hasAttr<ObjCPreciseLifetimeAttr>()96
) {
409
              // Special case: check for initializations with constants.
410
              //
411
              //  e.g. : int x = 0;
412
              //         struct A = {0, 1};
413
              //         struct B = {{0}, {1, 2}};
414
              //
415
              // If x is EVER assigned a new value later, don't issue
416
              // a warning.  This is because such initialization can be
417
              // due to defensive programming.
418
95
              if (isConstant(E))
419
38
                return;
420
421
57
              if (const DeclRefExpr *DRE =
422
57
                      dyn_cast<DeclRefExpr>(E->IgnoreParenCasts()))
423
7
                if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
424
                  // Special case: check for initialization from constant
425
                  //  variables.
426
                  //
427
                  //  e.g. extern const int MyConstant;
428
                  //       int x = MyConstant;
429
                  //
430
7
                  if (VD->hasGlobalStorage() &&
431
7
                      
VD->getType().isConstQualified()2
)
432
2
                    return;
433
                  // Special case: check for initialization from scalar
434
                  //  parameters.  This is often a form of defensive
435
                  //  programming.  Non-scalars are still an error since
436
                  //  because it more likely represents an actual algorithmic
437
                  //  bug.
438
5
                  if (isa<ParmVarDecl>(VD) && VD->getType()->isScalarType())
439
5
                    return;
440
5
                }
441
442
50
              PathDiagnosticLocation Loc =
443
50
                PathDiagnosticLocation::create(V, BR.getSourceManager());
444
50
              Report(V, DeadInit, Loc, E->getSourceRange());
445
50
            }
446
460
          }
447
598
        }
448
632
      }
449
8.81k
  }
450
451
private:
452
  /// Return true if the given init list can be interpreted as constant
453
8
  bool isConstant(const InitListExpr *Candidate) const {
454
    // We consider init list to be constant if each member of the list can be
455
    // interpreted as constant.
456
8
    return llvm::all_of(Candidate->inits(),
457
16
                        [this](const Expr *Init) { return isConstant(Init); });
458
8
  }
459
460
  /// Return true if the given expression can be interpreted as constant
461
111
  bool isConstant(const Expr *E) const {
462
    // It looks like E itself is a constant
463
111
    if (E->isEvaluatable(Ctx))
464
46
      return true;
465
466
    // We should also allow defensive initialization of structs, i.e. { 0 }
467
65
    if (const auto *ILE = dyn_cast<InitListExpr>(E->IgnoreParenCasts())) {
468
8
      return isConstant(ILE);
469
8
    }
470
471
57
    return false;
472
65
  }
473
};
474
475
} // end anonymous namespace
476
477
//===----------------------------------------------------------------------===//
478
// Driver function to invoke the Dead-Stores checker on a CFG.
479
//===----------------------------------------------------------------------===//
480
481
namespace {
482
class FindEscaped {
483
public:
484
  llvm::SmallPtrSet<const VarDecl*, 20> Escaped;
485
486
8.50k
  void operator()(const Stmt *S) {
487
    // Check for '&'. Any VarDecl whose address has been taken we treat as
488
    // escaped.
489
    // FIXME: What about references?
490
8.50k
    if (auto *LE = dyn_cast<LambdaExpr>(S)) {
491
53
      findLambdaReferenceCaptures(LE);
492
53
      return;
493
53
    }
494
495
8.45k
    const UnaryOperator *U = dyn_cast<UnaryOperator>(S);
496
8.45k
    if (!U)
497
8.08k
      return;
498
363
    if (U->getOpcode() != UO_AddrOf)
499
335
      return;
500
501
28
    const Expr *E = U->getSubExpr()->IgnoreParenCasts();
502
28
    if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E))
503
26
      if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl()))
504
25
        Escaped.insert(VD);
505
28
  }
506
507
  // Treat local variables captured by reference in C++ lambdas as escaped.
508
53
  void findLambdaReferenceCaptures(const LambdaExpr *LE)  {
509
53
    const CXXRecordDecl *LambdaClass = LE->getLambdaClass();
510
53
    llvm::DenseMap<const VarDecl *, FieldDecl *> CaptureFields;
511
53
    FieldDecl *ThisCaptureField;
512
53
    LambdaClass->getCaptureFields(CaptureFields, ThisCaptureField);
513
514
57
    for (const LambdaCapture &C : LE->captures()) {
515
57
      if (!C.capturesVariable())
516
5
        continue;
517
518
52
      VarDecl *VD = C.getCapturedVar();
519
52
      const FieldDecl *FD = CaptureFields[VD];
520
52
      if (!FD)
521
0
        continue;
522
523
      // If the capture field is a reference type, it is capture-by-reference.
524
52
      if (FD->getType()->isReferenceType())
525
20
        Escaped.insert(VD);
526
52
    }
527
53
  }
528
};
529
} // end anonymous namespace
530
531
532
//===----------------------------------------------------------------------===//
533
// DeadStoresChecker
534
//===----------------------------------------------------------------------===//
535
536
void DeadStoresChecker::checkASTCodeBody(const Decl *D, AnalysisManager &mgr,
537
538
                                         BugReporter &BR) const {
538
539
  // Don't do anything for template instantiations.
540
  // Proving that code in a template instantiation is "dead"
541
  // means proving that it is dead in all instantiations.
542
  // This same problem exists with -Wunreachable-code.
543
538
  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
544
491
    if (FD->isTemplateInstantiation())
545
21
      return;
546
547
517
  if (LiveVariables *L = mgr.getAnalysis<LiveVariables>(D)) {
548
517
    CFG &cfg = *mgr.getCFG(D);
549
517
    AnalysisDeclContext *AC = mgr.getAnalysisDeclContext(D);
550
517
    ParentMap &pmap = mgr.getParentMap(D);
551
517
    FindEscaped FS;
552
517
    cfg.VisitBlockStmts(FS);
553
517
    DeadStoreObs A(cfg, BR.getContext(), BR, this, AC, pmap, FS.Escaped,
554
517
                   WarnForDeadNestedAssignments);
555
517
    L->runOnAllBlocks(A);
556
517
  }
557
517
}
558
559
56
void ento::registerDeadStoresChecker(CheckerManager &Mgr) {
560
56
  auto *Chk = Mgr.registerChecker<DeadStoresChecker>();
561
562
56
  const AnalyzerOptions &AnOpts = Mgr.getAnalyzerOptions();
563
56
  Chk->WarnForDeadNestedAssignments =
564
56
      AnOpts.getCheckerBooleanOption(Chk, "WarnForDeadNestedAssignments");
565
56
  Chk->ShowFixIts =
566
56
      AnOpts.getCheckerBooleanOption(Chk, "ShowFixIts");
567
56
}
568
569
116
bool ento::shouldRegisterDeadStoresChecker(const CheckerManager &mgr) {
570
116
  return true;
571
116
}