contrib/llvm/tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

   1 // BugReporterVisitors.cpp - Helpers for reporting bugs -----------*- 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 defines a set of BugReporter "visitors" which can be used to
  11 //  enhance the diagnostics reported for a bug.
  12 //
  13 //===----------------------------------------------------------------------===//
  14 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitor.h"
  15
  16 #include "clang/AST/Expr.h"
  17 #include "clang/AST/ExprObjC.h"
  18 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
  19 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
  20 #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h"
  21 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
  22 #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
  23
  24 using namespace clang;
  25 using namespace ento;
  26
  27 //===----------------------------------------------------------------------===//
  28 // Utility functions.
  29 //===----------------------------------------------------------------------===//
  30
  31 const Stmt *bugreporter::GetDerefExpr(const ExplodedNode *N) {
  32   // Pattern match for a few useful cases (do something smarter later):
  33   //   a[0], p->f, *p
  34   const Stmt *S = N->getLocationAs<PostStmt>()->getStmt();
  35
  36   if (const UnaryOperator *U = dyn_cast<UnaryOperator>(S)) {
  37     if (U->getOpcode() == UO_Deref)
  38       return U->getSubExpr()->IgnoreParenCasts();
  39   }
  40   else if (const MemberExpr *ME = dyn_cast<MemberExpr>(S)) {
  41     return ME->getBase()->IgnoreParenCasts();
  42   }
  43   else if (const ArraySubscriptExpr *AE = dyn_cast<ArraySubscriptExpr>(S)) {
  44     return AE->getBase();
  45   }
  46
  47   return NULL;
  48 }
  49
  50 const Stmt *bugreporter::GetDenomExpr(const ExplodedNode *N) {
  51   const Stmt *S = N->getLocationAs<PreStmt>()->getStmt();
  52   if (const BinaryOperator *BE = dyn_cast<BinaryOperator>(S))
  53     return BE->getRHS();
  54   return NULL;
  55 }
  56
  57 const Stmt *bugreporter::GetCalleeExpr(const ExplodedNode *N) {
  58   // Callee is checked as a PreVisit to the CallExpr.
  59   const Stmt *S = N->getLocationAs<PreStmt>()->getStmt();
  60   if (const CallExpr *CE = dyn_cast<CallExpr>(S))
  61     return CE->getCallee();
  62   return NULL;
  63 }
  64
  65 const Stmt *bugreporter::GetRetValExpr(const ExplodedNode *N) {
  66   const Stmt *S = N->getLocationAs<PostStmt>()->getStmt();
  67   if (const ReturnStmt *RS = dyn_cast<ReturnStmt>(S))
  68     return RS->getRetValue();
  69   return NULL;
  70 }
  71
  72 //===----------------------------------------------------------------------===//
  73 // Definitions for bug reporter visitors.
  74 //===----------------------------------------------------------------------===//
  75
  76 PathDiagnosticPiece*
  77 BugReporterVisitor::getEndPath(BugReporterContext &BRC,
  78                                const ExplodedNode *EndPathNode,
  79                                BugReport &BR) {
  80   return 0;
  81 }
  82
  83 PathDiagnosticPiece*
  84 BugReporterVisitor::getDefaultEndPath(BugReporterContext &BRC,
  85                                       const ExplodedNode *EndPathNode,
  86                                       BugReport &BR) {
  87   const ProgramPoint &PP = EndPathNode->getLocation();
  88   PathDiagnosticLocation L;
  89
  90   if (const BlockEntrance *BE = dyn_cast<BlockEntrance>(&PP)) {
  91     const CFGBlock *block = BE->getBlock();
  92     if (block->getBlockID() == 0) {
  93       L = PathDiagnosticLocation::createDeclEnd(PP.getLocationContext(),
  94                                                 BRC.getSourceManager());
  95     }
  96   }
  97
  98   if (!L.isValid()) {
  99     const Stmt *S = BR.getStmt();
 100
 101     if (!S)
 102       return NULL;
 103
 104     L = PathDiagnosticLocation(S, BRC.getSourceManager(),
 105                                   PP.getLocationContext());
 106   }
 107
 108   BugReport::ranges_iterator Beg, End;
 109   llvm::tie(Beg, End) = BR.getRanges();
 110
 111   // Only add the statement itself as a range if we didn't specify any
 112   // special ranges for this report.
 113   PathDiagnosticPiece *P = new PathDiagnosticEventPiece(L,
 114       BR.getDescription(),
 115       Beg == End);
 116   for (; Beg != End; ++Beg)
 117     P->addRange(*Beg);
 118
 119   return P;
 120 }
 121
 122
 123 void FindLastStoreBRVisitor ::Profile(llvm::FoldingSetNodeID &ID) const {
 124   static int tag = 0;
 125   ID.AddPointer(&tag);
 126   ID.AddPointer(R);
 127   ID.Add(V);
 128 }
 129
 130 PathDiagnosticPiece *FindLastStoreBRVisitor::VisitNode(const ExplodedNode *N,
 131                                                      const ExplodedNode *PrevN,
 132                                                      BugReporterContext &BRC,
 133                                                      BugReport &BR) {
 134
 135   if (satisfied)
 136     return NULL;
 137
 138   if (!StoreSite) {
 139     const ExplodedNode *Node = N, *Last = NULL;
 140
 141     for ( ; Node ; Last = Node, Node = Node->getFirstPred()) {
 142
 143       if (const VarRegion *VR = dyn_cast<VarRegion>(R)) {
 144         if (const PostStmt *P = Node->getLocationAs<PostStmt>())
 145           if (const DeclStmt *DS = P->getStmtAs<DeclStmt>())
 146             if (DS->getSingleDecl() == VR->getDecl()) {
 147               Last = Node;
 148               break;
 149             }
 150       }
 151
 152       if (Node->getState()->getSVal(R) != V)
 153         break;
 154     }
 155
 156     if (!Node || !Last) {
 157       satisfied = true;
 158       return NULL;
 159     }
 160
 161     StoreSite = Last;
 162   }
 163
 164   if (StoreSite != N)
 165     return NULL;
 166
 167   satisfied = true;
 168   llvm::SmallString<256> sbuf;
 169   llvm::raw_svector_ostream os(sbuf);
 170
 171   if (const PostStmt *PS = N->getLocationAs<PostStmt>()) {
 172     if (const DeclStmt *DS = PS->getStmtAs<DeclStmt>()) {
 173
 174       if (const VarRegion *VR = dyn_cast<VarRegion>(R)) {
 175         os << "Variable '" << *VR->getDecl() << "' ";
 176       }
 177       else
 178         return NULL;
 179
 180       if (isa<loc::ConcreteInt>(V)) {
 181         bool b = false;
 182         if (R->isBoundable()) {
 183           if (const TypedValueRegion *TR = dyn_cast<TypedValueRegion>(R)) {
 184             if (TR->getValueType()->isObjCObjectPointerType()) {
 185               os << "initialized to nil";
 186               b = true;
 187             }
 188           }
 189         }
 190
 191         if (!b)
 192           os << "initialized to a null pointer value";
 193       }
 194       else if (isa<nonloc::ConcreteInt>(V)) {
 195         os << "initialized to " << cast<nonloc::ConcreteInt>(V).getValue();
 196       }
 197       else if (V.isUndef()) {
 198         if (isa<VarRegion>(R)) {
 199           const VarDecl *VD = cast<VarDecl>(DS->getSingleDecl());
 200           if (VD->getInit())
 201             os << "initialized to a garbage value";
 202           else
 203             os << "declared without an initial value";
 204         }
 205       }
 206     }
 207   }
 208
 209   if (os.str().empty()) {
 210     if (isa<loc::ConcreteInt>(V)) {
 211       bool b = false;
 212       if (R->isBoundable()) {
 213         if (const TypedValueRegion *TR = dyn_cast<TypedValueRegion>(R)) {
 214           if (TR->getValueType()->isObjCObjectPointerType()) {
 215             os << "nil object reference stored to ";
 216             b = true;
 217           }
 218         }
 219       }
 220
 221       if (!b)
 222         os << "Null pointer value stored to ";
 223     }
 224     else if (V.isUndef()) {
 225       os << "Uninitialized value stored to ";
 226     }
 227     else if (isa<nonloc::ConcreteInt>(V)) {
 228       os << "The value " << cast<nonloc::ConcreteInt>(V).getValue()
 229                << " is assigned to ";
 230     }
 231     else
 232       return NULL;
 233
 234     if (const VarRegion *VR = dyn_cast<VarRegion>(R)) {
 235       os << '\'' << *VR->getDecl() << '\'';
 236     }
 237     else
 238       return NULL;
 239   }
 240
 241   // Construct a new PathDiagnosticPiece.
 242   ProgramPoint P = N->getLocation();
 243   PathDiagnosticLocation L =
 244     PathDiagnosticLocation::create(P, BRC.getSourceManager());
 245   if (!L.isValid())
 246     return NULL;
 247   return new PathDiagnosticEventPiece(L, os.str());
 248 }
 249
 250 void TrackConstraintBRVisitor::Profile(llvm::FoldingSetNodeID &ID) const {
 251   static int tag = 0;
 252   ID.AddPointer(&tag);
 253   ID.AddBoolean(Assumption);
 254   ID.Add(Constraint);
 255 }
 256
 257 PathDiagnosticPiece *
 258 TrackConstraintBRVisitor::VisitNode(const ExplodedNode *N,
 259                                     const ExplodedNode *PrevN,
 260                                     BugReporterContext &BRC,
 261                                     BugReport &BR) {
 262   if (isSatisfied)
 263     return NULL;
 264
 265   // Check if in the previous state it was feasible for this constraint
 266   // to *not* be true.
 267   if (PrevN->getState()->assume(Constraint, !Assumption)) {
 268
 269     isSatisfied = true;
 270
 271     // As a sanity check, make sure that the negation of the constraint
 272     // was infeasible in the current state.  If it is feasible, we somehow
 273     // missed the transition point.
 274     if (N->getState()->assume(Constraint, !Assumption))
 275       return NULL;
 276
 277     // We found the transition point for the constraint.  We now need to
 278     // pretty-print the constraint. (work-in-progress)
 279     std::string sbuf;
 280     llvm::raw_string_ostream os(sbuf);
 281
 282     if (isa<Loc>(Constraint)) {
 283       os << "Assuming pointer value is ";
 284       os << (Assumption ? "non-null" : "null");
 285     }
 286
 287     if (os.str().empty())
 288       return NULL;
 289
 290     // Construct a new PathDiagnosticPiece.
 291     ProgramPoint P = N->getLocation();
 292     PathDiagnosticLocation L =
 293       PathDiagnosticLocation::create(P, BRC.getSourceManager());
 294     if (!L.isValid())
 295       return NULL;
 296     return new PathDiagnosticEventPiece(L, os.str());
 297   }
 298
 299   return NULL;
 300 }
 301
 302 BugReporterVisitor *
 303 bugreporter::getTrackNullOrUndefValueVisitor(const ExplodedNode *N,
 304                                              const Stmt *S) {
 305   if (!S || !N)
 306     return 0;
 307
 308   ProgramStateManager &StateMgr = N->getState()->getStateManager();
 309
 310   // Walk through nodes until we get one that matches the statement
 311   // exactly.
 312   while (N) {
 313     const ProgramPoint &pp = N->getLocation();
 314     if (const PostStmt *ps = dyn_cast<PostStmt>(&pp)) {
 315       if (ps->getStmt() == S)
 316         break;
 317     }
 318     N = N->getFirstPred();
 319   }
 320
 321   if (!N)
 322     return 0;
 323
 324   const ProgramState *state = N->getState();
 325
 326   // Walk through lvalue-to-rvalue conversions.
 327   if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(S)) {
 328     if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) {
 329       const VarRegion *R =
 330         StateMgr.getRegionManager().getVarRegion(VD, N->getLocationContext());
 331
 332       // What did we load?
 333       SVal V = state->getSVal(loc::MemRegionVal(R));
 334
 335       if (isa<loc::ConcreteInt>(V) || isa<nonloc::ConcreteInt>(V)
 336           || V.isUndef()) {
 337         return new FindLastStoreBRVisitor(V, R);
 338       }
 339     }
 340   }
 341
 342   SVal V = state->getSValAsScalarOrLoc(S);
 343
 344   // Uncomment this to find cases where we aren't properly getting the
 345   // base value that was dereferenced.
 346   // assert(!V.isUnknownOrUndef());
 347
 348   // Is it a symbolic value?
 349   if (loc::MemRegionVal *L = dyn_cast<loc::MemRegionVal>(&V)) {
 350     const SubRegion *R = cast<SubRegion>(L->getRegion());
 351     while (R && !isa<SymbolicRegion>(R)) {
 352       R = dyn_cast<SubRegion>(R->getSuperRegion());
 353     }
 354
 355     if (R) {
 356       assert(isa<SymbolicRegion>(R));
 357       return new TrackConstraintBRVisitor(loc::MemRegionVal(R), false);
 358     }
 359   }
 360
 361   return 0;
 362 }
 363
 364 BugReporterVisitor *
 365 FindLastStoreBRVisitor::createVisitorObject(const ExplodedNode *N,
 366                                             const MemRegion *R) {
 367   assert(R && "The memory region is null.");
 368
 369   const ProgramState *state = N->getState();
 370   SVal V = state->getSVal(R);
 371   if (V.isUnknown())
 372     return 0;
 373
 374   return new FindLastStoreBRVisitor(V, R);
 375 }
 376
 377
 378 PathDiagnosticPiece *NilReceiverBRVisitor::VisitNode(const ExplodedNode *N,
 379                                                      const ExplodedNode *PrevN,
 380                                                      BugReporterContext &BRC,
 381                                                      BugReport &BR) {
 382   const PostStmt *P = N->getLocationAs<PostStmt>();
 383   if (!P)
 384     return 0;
 385   const ObjCMessageExpr *ME = P->getStmtAs<ObjCMessageExpr>();
 386   if (!ME)
 387     return 0;
 388   const Expr *Receiver = ME->getInstanceReceiver();
 389   if (!Receiver)
 390     return 0;
 391   const ProgramState *state = N->getState();
 392   const SVal &V = state->getSVal(Receiver);
 393   const DefinedOrUnknownSVal *DV = dyn_cast<DefinedOrUnknownSVal>(&V);
 394   if (!DV)
 395     return 0;
 396   state = state->assume(*DV, true);
 397   if (state)
 398     return 0;
 399
 400   // The receiver was nil, and hence the method was skipped.
 401   // Register a BugReporterVisitor to issue a message telling us how
 402   // the receiver was null.
 403   BR.addVisitor(bugreporter::getTrackNullOrUndefValueVisitor(N, Receiver));
 404   // Issue a message saying that the method was skipped.
 405   PathDiagnosticLocation L(Receiver, BRC.getSourceManager(),
 406                                      N->getLocationContext());
 407   return new PathDiagnosticEventPiece(L, "No method actually called "
 408       "because the receiver is nil");
 409 }
 410
 411 // Registers every VarDecl inside a Stmt with a last store visitor.
 412 void FindLastStoreBRVisitor::registerStatementVarDecls(BugReport &BR,
 413                                                        const Stmt *S) {
 414   const ExplodedNode *N = BR.getErrorNode();
 415   std::deque<const Stmt *> WorkList;
 416   WorkList.push_back(S);
 417
 418   while (!WorkList.empty()) {
 419     const Stmt *Head = WorkList.front();
 420     WorkList.pop_front();
 421
 422     const ProgramState *state = N->getState();
 423     ProgramStateManager &StateMgr = state->getStateManager();
 424
 425     if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Head)) {
 426       if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) {
 427         const VarRegion *R =
 428         StateMgr.getRegionManager().getVarRegion(VD, N->getLocationContext());
 429
 430         // What did we load?
 431         SVal V = state->getSVal(S);
 432
 433         if (isa<loc::ConcreteInt>(V) || isa<nonloc::ConcreteInt>(V)) {
 434           // Register a new visitor with the BugReport.
 435           BR.addVisitor(new FindLastStoreBRVisitor(V, R));
 436         }
 437       }
 438     }
 439
 440     for (Stmt::const_child_iterator I = Head->child_begin();
 441         I != Head->child_end(); ++I)
 442       WorkList.push_back(*I);
 443   }
 444 }
 445
 446 //===----------------------------------------------------------------------===//
 447 // Visitor that tries to report interesting diagnostics from conditions.
 448 //===----------------------------------------------------------------------===//
 449 PathDiagnosticPiece *ConditionBRVisitor::VisitNode(const ExplodedNode *N,
 450                                                    const ExplodedNode *Prev,
 451                                                    BugReporterContext &BRC,
 452                                                    BugReport &BR) {
 453
 454   const ProgramPoint &progPoint = N->getLocation();
 455
 456   const ProgramState *CurrentState = N->getState();
 457   const ProgramState *PrevState = Prev->getState();
 458
 459   // Compare the GDMs of the state, because that is where constraints
 460   // are managed.  Note that ensure that we only look at nodes that
 461   // were generated by the analyzer engine proper, not checkers.
 462   if (CurrentState->getGDM().getRoot() ==
 463       PrevState->getGDM().getRoot())
 464     return 0;
 465
 466   // If an assumption was made on a branch, it should be caught
 467   // here by looking at the state transition.
 468   if (const BlockEdge *BE = dyn_cast<BlockEdge>(&progPoint)) {
 469     const CFGBlock *srcBlk = BE->getSrc();
 470     if (const Stmt *term = srcBlk->getTerminator())
 471       return VisitTerminator(term, N, srcBlk, BE->getDst(), BRC);
 472     return 0;
 473   }
 474
 475   if (const PostStmt *PS = dyn_cast<PostStmt>(&progPoint)) {
 476     // FIXME: Assuming that BugReporter is a GRBugReporter is a layering
 477     // violation.
 478     const std::pair<const ProgramPointTag *, const ProgramPointTag *> &tags =
 479       cast<GRBugReporter>(BRC.getBugReporter()).
 480         getEngine().getEagerlyAssumeTags();
 481
 482     const ProgramPointTag *tag = PS->getTag();
 483     if (tag == tags.first)
 484       return VisitTrueTest(cast<Expr>(PS->getStmt()), true,
 485                            BRC, N->getLocationContext());
 486     if (tag == tags.second)
 487       return VisitTrueTest(cast<Expr>(PS->getStmt()), false,
 488                            BRC, N->getLocationContext());
 489
 490     return 0;
 491   }
 492
 493   return 0;
 494 }
 495
 496 PathDiagnosticPiece *
 497 ConditionBRVisitor::VisitTerminator(const Stmt *Term,
 498                                     const ExplodedNode *N,
 499                                     const CFGBlock *srcBlk,
 500                                     const CFGBlock *dstBlk,
 501                                     BugReporterContext &BRC) {
 502   const Expr *Cond = 0;
 503
 504   switch (Term->getStmtClass()) {
 505   default:
 506     return 0;
 507   case Stmt::IfStmtClass:
 508     Cond = cast<IfStmt>(Term)->getCond();
 509     break;
 510   case Stmt::ConditionalOperatorClass:
 511     Cond = cast<ConditionalOperator>(Term)->getCond();
 512     break;
 513   }
 514
 515   assert(Cond);
 516   assert(srcBlk->succ_size() == 2);
 517   const bool tookTrue = *(srcBlk->succ_begin()) == dstBlk;
 518   return VisitTrueTest(Cond->IgnoreParenNoopCasts(BRC.getASTContext()),
 519                        tookTrue, BRC, N->getLocationContext());
 520 }
 521
 522 PathDiagnosticPiece *
 523 ConditionBRVisitor::VisitTrueTest(const Expr *Cond,
 524                                   bool tookTrue,
 525                                   BugReporterContext &BRC,
 526                                   const LocationContext *LC) {
 527
 528   const Expr *Ex = Cond;
 529
 530   while (true) {
 531     Ex = Ex->IgnoreParens();
 532     switch (Ex->getStmtClass()) {
 533       default:
 534         return 0;
 535       case Stmt::BinaryOperatorClass:
 536         return VisitTrueTest(Cond, cast<BinaryOperator>(Ex), tookTrue, BRC, LC);
 537       case Stmt::DeclRefExprClass:
 538         return VisitTrueTest(Cond, cast<DeclRefExpr>(Ex), tookTrue, BRC, LC);
 539       case Stmt::UnaryOperatorClass: {
 540         const UnaryOperator *UO = cast<UnaryOperator>(Ex);
 541         if (UO->getOpcode() == UO_LNot) {
 542           tookTrue = !tookTrue;
 543           Ex = UO->getSubExpr()->IgnoreParenNoopCasts(BRC.getASTContext());
 544           continue;
 545         }
 546         return 0;
 547       }
 548     }
 549   }
 550 }
 551
 552 bool ConditionBRVisitor::patternMatch(const Expr *Ex, llvm::raw_ostream &Out,
 553                                       BugReporterContext &BRC) {
 554   const Expr *OriginalExpr = Ex;
 555   Ex = Ex->IgnoreParenCasts();
 556
 557   if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Ex)) {
 558     const bool quotes = isa<VarDecl>(DR->getDecl());
 559     if (quotes)
 560       Out << '\'';
 561     Out << DR->getDecl()->getDeclName().getAsString();
 562     if (quotes)
 563       Out << '\'';
 564     return quotes;
 565   }
 566
 567   if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(Ex)) {
 568     QualType OriginalTy = OriginalExpr->getType();
 569     if (OriginalTy->isPointerType()) {
 570       if (IL->getValue() == 0) {
 571         Out << "null";
 572         return false;
 573       }
 574     }
 575     else if (OriginalTy->isObjCObjectPointerType()) {
 576       if (IL->getValue() == 0) {
 577         Out << "nil";
 578         return false;
 579       }
 580     }
 581
 582     Out << IL->getValue();
 583     return false;
 584   }
 585
 586   return false;
 587 }
 588
 589 PathDiagnosticPiece *
 590 ConditionBRVisitor::VisitTrueTest(const Expr *Cond,
 591                                   const BinaryOperator *BExpr,
 592                                   const bool tookTrue,
 593                                   BugReporterContext &BRC,
 594                                   const LocationContext *LC) {
 595
 596   bool shouldInvert = false;
 597
 598   llvm::SmallString<128> LhsString, RhsString;
 599   {
 600     llvm::raw_svector_ostream OutLHS(LhsString), OutRHS(RhsString);
 601     const bool isVarLHS = patternMatch(BExpr->getLHS(), OutLHS, BRC);
 602     const bool isVarRHS = patternMatch(BExpr->getRHS(), OutRHS, BRC);
 603
 604     shouldInvert = !isVarLHS && isVarRHS;
 605   }
 606
 607   if (LhsString.empty() || RhsString.empty())
 608     return 0;
 609
 610   // Should we invert the strings if the LHS is not a variable name?
 611
 612   llvm::SmallString<256> buf;
 613   llvm::raw_svector_ostream Out(buf);
 614   Out << "Assuming " << (shouldInvert ? RhsString : LhsString) << " is ";
 615
 616   // Do we need to invert the opcode?
 617   BinaryOperator::Opcode Op = BExpr->getOpcode();
 618
 619   if (shouldInvert)
 620     switch (Op) {
 621       default: break;
 622       case BO_LT: Op = BO_GT; break;
 623       case BO_GT: Op = BO_LT; break;
 624       case BO_LE: Op = BO_GE; break;
 625       case BO_GE: Op = BO_LE; break;
 626     }
 627
 628   if (!tookTrue)
 629     switch (Op) {
 630       case BO_EQ: Op = BO_NE; break;
 631       case BO_NE: Op = BO_EQ; break;
 632       case BO_LT: Op = BO_GE; break;
 633       case BO_GT: Op = BO_LE; break;
 634       case BO_LE: Op = BO_GT; break;
 635       case BO_GE: Op = BO_LT; break;
 636       default:
 637         return 0;
 638     }
 639
 640   switch (BExpr->getOpcode()) {
 641     case BO_EQ:
 642       Out << "equal to ";
 643       break;
 644     case BO_NE:
 645       Out << "not equal to ";
 646       break;
 647     default:
 648       Out << BinaryOperator::getOpcodeStr(Op) << ' ';
 649       break;
 650   }
 651
 652   Out << (shouldInvert ? LhsString : RhsString);
 653
 654   PathDiagnosticLocation Loc(Cond, BRC.getSourceManager(), LC);
 655   return new PathDiagnosticEventPiece(Loc, Out.str());
 656 }
 657
 658 PathDiagnosticPiece *
 659 ConditionBRVisitor::VisitTrueTest(const Expr *Cond,
 660                                   const DeclRefExpr *DR,
 661                                   const bool tookTrue,
 662                                   BugReporterContext &BRC,
 663                                   const LocationContext *LC) {
 664
 665   const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl());
 666   if (!VD)
 667     return 0;
 668
 669   llvm::SmallString<256> Buf;
 670   llvm::raw_svector_ostream Out(Buf);
 671
 672   Out << "Assuming '";
 673   VD->getDeclName().printName(Out);
 674   Out << "' is ";
 675
 676   QualType VDTy = VD->getType();
 677
 678   if (VDTy->isPointerType())
 679     Out << (tookTrue ? "non-null" : "null");
 680   else if (VDTy->isObjCObjectPointerType())
 681     Out << (tookTrue ? "non-nil" : "nil");
 682   else if (VDTy->isScalarType())
 683     Out << (tookTrue ? "not equal to 0" : "0");
 684   else
 685     return 0;
 686
 687   PathDiagnosticLocation Loc(Cond, BRC.getSourceManager(), LC);
 688   return new PathDiagnosticEventPiece(Loc, Out.str());
 689 }