contrib/llvm/tools/clang/lib/StaticAnalyzer/Checkers/MallocSizeofChecker.cpp

   1 // MallocSizeofChecker.cpp - Check for dubious malloc arguments ---*- 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 // Reports inconsistencies between the casted type of the return value of a
  11 // malloc/calloc/realloc call and the operand of any sizeof expressions
  12 // contained within its argument(s).
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "ClangSACheckers.h"
  17 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
  18 #include "clang/StaticAnalyzer/Core/Checker.h"
  19 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
  20 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
  21 #include "clang/AST/StmtVisitor.h"
  22 #include "clang/AST/TypeLoc.h"
  23 #include "llvm/ADT/SmallString.h"
  24
  25 using namespace clang;
  26 using namespace ento;
  27
  28 namespace {
  29
  30 typedef std::pair<const TypeSourceInfo *, const CallExpr *> TypeCallPair;
  31 typedef llvm::PointerUnion<const Stmt *, const VarDecl *> ExprParent;
  32
  33 class CastedAllocFinder
  34   : public ConstStmtVisitor<CastedAllocFinder, TypeCallPair> {
  35   IdentifierInfo *II_malloc, *II_calloc, *II_realloc;
  36
  37 public:
  38   struct CallRecord {
  39     ExprParent CastedExprParent;
  40     const Expr *CastedExpr;
  41     const TypeSourceInfo *ExplicitCastType;
  42     const CallExpr *AllocCall;
  43
  44     CallRecord(ExprParent CastedExprParent, const Expr *CastedExpr,
  45                const TypeSourceInfo *ExplicitCastType,
  46                const CallExpr *AllocCall)
  47       : CastedExprParent(CastedExprParent), CastedExpr(CastedExpr),
  48         ExplicitCastType(ExplicitCastType), AllocCall(AllocCall) {}
  49   };
  50
  51   typedef std::vector<CallRecord> CallVec;
  52   CallVec Calls;
  53
  54   CastedAllocFinder(ASTContext *Ctx) :
  55     II_malloc(&Ctx->Idents.get("malloc")),
  56     II_calloc(&Ctx->Idents.get("calloc")),
  57     II_realloc(&Ctx->Idents.get("realloc")) {}
  58
  59   void VisitChild(ExprParent Parent, const Stmt *S) {
  60     TypeCallPair AllocCall = Visit(S);
  61     if (AllocCall.second && AllocCall.second != S)
  62       Calls.push_back(CallRecord(Parent, cast<Expr>(S), AllocCall.first,
  63                                  AllocCall.second));
  64   }
  65
  66   void VisitChildren(const Stmt *S) {
  67     for (Stmt::const_child_iterator I = S->child_begin(), E = S->child_end();
  68          I!=E; ++I)
  69       if (const Stmt *child = *I)
  70         VisitChild(S, child);
  71   }
  72
  73   TypeCallPair VisitCastExpr(const CastExpr *E) {
  74     return Visit(E->getSubExpr());
  75   }
  76
  77   TypeCallPair VisitExplicitCastExpr(const ExplicitCastExpr *E) {
  78     return TypeCallPair(E->getTypeInfoAsWritten(),
  79                         Visit(E->getSubExpr()).second);
  80   }
  81
  82   TypeCallPair VisitParenExpr(const ParenExpr *E) {
  83     return Visit(E->getSubExpr());
  84   }
  85
  86   TypeCallPair VisitStmt(const Stmt *S) {
  87     VisitChildren(S);
  88     return TypeCallPair();
  89   }
  90
  91   TypeCallPair VisitCallExpr(const CallExpr *E) {
  92     VisitChildren(E);
  93     const FunctionDecl *FD = E->getDirectCallee();
  94     if (FD) {
  95       IdentifierInfo *II = FD->getIdentifier();
  96       if (II == II_malloc || II == II_calloc || II == II_realloc)
  97         return TypeCallPair((const TypeSourceInfo *)0, E);
  98     }
  99     return TypeCallPair();
 100   }
 101
 102   TypeCallPair VisitDeclStmt(const DeclStmt *S) {
 103     for (DeclStmt::const_decl_iterator I = S->decl_begin(), E = S->decl_end();
 104          I!=E; ++I)
 105       if (const VarDecl *VD = dyn_cast<VarDecl>(*I))
 106         if (const Expr *Init = VD->getInit())
 107           VisitChild(VD, Init);
 108     return TypeCallPair();
 109   }
 110 };
 111
 112 class SizeofFinder : public ConstStmtVisitor<SizeofFinder> {
 113 public:
 114   std::vector<const UnaryExprOrTypeTraitExpr *> Sizeofs;
 115
 116   void VisitBinMul(const BinaryOperator *E) {
 117     Visit(E->getLHS());
 118     Visit(E->getRHS());
 119   }
 120
 121   void VisitBinAdd(const BinaryOperator *E) {
 122     Visit(E->getLHS());
 123     Visit(E->getRHS());
 124   }
 125
 126   void VisitImplicitCastExpr(const ImplicitCastExpr *E) {
 127     return Visit(E->getSubExpr());
 128   }
 129
 130   void VisitParenExpr(const ParenExpr *E) {
 131     return Visit(E->getSubExpr());
 132   }
 133
 134   void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E) {
 135     if (E->getKind() != UETT_SizeOf)
 136       return;
 137
 138     Sizeofs.push_back(E);
 139   }
 140 };
 141
 142 class MallocSizeofChecker : public Checker<check::ASTCodeBody> {
 143 public:
 144   void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
 145                         BugReporter &BR) const {
 146     AnalysisDeclContext *ADC = mgr.getAnalysisDeclContext(D);
 147     CastedAllocFinder Finder(&BR.getContext());
 148     Finder.Visit(D->getBody());
 149     for (CastedAllocFinder::CallVec::iterator i = Finder.Calls.begin(),
 150          e = Finder.Calls.end(); i != e; ++i) {
 151       QualType CastedType = i->CastedExpr->getType();
 152       if (!CastedType->isPointerType())
 153         continue;
 154       QualType PointeeType = CastedType->getAs<PointerType>()->getPointeeType();
 155       if (PointeeType->isVoidType())
 156         continue;
 157
 158       for (CallExpr::const_arg_iterator ai = i->AllocCall->arg_begin(),
 159            ae = i->AllocCall->arg_end(); ai != ae; ++ai) {
 160         if (!(*ai)->getType()->isIntegerType())
 161           continue;
 162
 163         SizeofFinder SFinder;
 164         SFinder.Visit(*ai);
 165         if (SFinder.Sizeofs.size() != 1)
 166           continue;
 167
 168         QualType SizeofType = SFinder.Sizeofs[0]->getTypeOfArgument();
 169         if (!BR.getContext().hasSameUnqualifiedType(PointeeType, SizeofType)) {
 170           const TypeSourceInfo *TSI = 0;
 171           if (i->CastedExprParent.is<const VarDecl *>()) {
 172             TSI =
 173               i->CastedExprParent.get<const VarDecl *>()->getTypeSourceInfo();
 174           } else {
 175             TSI = i->ExplicitCastType;
 176           }
 177
 178           SmallString<64> buf;
 179           llvm::raw_svector_ostream OS(buf);
 180
 181           OS << "Result of '"
 182              << i->AllocCall->getDirectCallee()->getIdentifier()->getName()
 183              << "' is converted to type '"
 184              << CastedType.getAsString() << "', whose pointee type '"
 185              << PointeeType.getAsString() << "' is incompatible with "
 186              << "sizeof operand type '" << SizeofType.getAsString() << "'";
 187           llvm::SmallVector<SourceRange, 4> Ranges;
 188           Ranges.push_back(i->AllocCall->getCallee()->getSourceRange());
 189           Ranges.push_back(SFinder.Sizeofs[0]->getSourceRange());
 190           if (TSI)
 191             Ranges.push_back(TSI->getTypeLoc().getSourceRange());
 192
 193           PathDiagnosticLocation L =
 194             PathDiagnosticLocation::createBegin(i->AllocCall->getCallee(),
 195                                                 BR.getSourceManager(), ADC);
 196
 197           BR.EmitBasicReport(D, "allocator sizeof operand mismatch",
 198                              categories::UnixAPI,
 199                              OS.str(),
 200                              L, Ranges.data(), Ranges.size());
 201         }
 202       }
 203     }
 204   }
 205 };
 206
 207 }
 208
 209 void ento::registerMallocSizeofChecker(CheckerManager &mgr) {
 210   mgr.registerChecker<MallocSizeofChecker>();
 211 }