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

   1 //== DynamicTypeChecker.cpp ------------------------------------ -*- 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 checker looks for cases where the dynamic type of an object is unrelated
  11 // to its static type. The type information utilized by this check is collected
  12 // by the DynamicTypePropagation checker. This check does not report any type
  13 // error for ObjC Generic types, in order to avoid duplicate erros from the
  14 // ObjC Generics checker. This checker is not supposed to modify the program
  15 // state, it is just the observer of the type information provided by other
  16 // checkers.
  17 //
  18 //===----------------------------------------------------------------------===//
  19
  20 #include "ClangSACheckers.h"
  21 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
  22 #include "clang/StaticAnalyzer/Core/Checker.h"
  23 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
  24 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
  25 #include "clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeMap.h"
  26 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
  27 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
  28
  29 using namespace clang;
  30 using namespace ento;
  31
  32 namespace {
  33 class DynamicTypeChecker : public Checker<check::PostStmt<ImplicitCastExpr>> {
  34   mutable std::unique_ptr<BugType> BT;
  35   void initBugType() const {
  36     if (!BT)
  37       BT.reset(
  38           new BugType(this, "Dynamic and static type mismatch", "Type Error"));
  39   }
  40
  41   class DynamicTypeBugVisitor
  42       : public BugReporterVisitorImpl<DynamicTypeBugVisitor> {
  43   public:
  44     DynamicTypeBugVisitor(const MemRegion *Reg) : Reg(Reg) {}
  45
  46     void Profile(llvm::FoldingSetNodeID &ID) const override {
  47       static int X = 0;
  48       ID.AddPointer(&X);
  49       ID.AddPointer(Reg);
  50     }
  51
  52     std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
  53                                                    const ExplodedNode *PrevN,
  54                                                    BugReporterContext &BRC,
  55                                                    BugReport &BR) override;
  56
  57   private:
  58     // The tracked region.
  59     const MemRegion *Reg;
  60   };
  61
  62   void reportTypeError(QualType DynamicType, QualType StaticType,
  63                        const MemRegion *Reg, const Stmt *ReportedNode,
  64                        CheckerContext &C) const;
  65
  66 public:
  67   void checkPostStmt(const ImplicitCastExpr *CE, CheckerContext &C) const;
  68 };
  69 }
  70
  71 void DynamicTypeChecker::reportTypeError(QualType DynamicType,
  72                                          QualType StaticType,
  73                                          const MemRegion *Reg,
  74                                          const Stmt *ReportedNode,
  75                                          CheckerContext &C) const {
  76   initBugType();
  77   SmallString<192> Buf;
  78   llvm::raw_svector_ostream OS(Buf);
  79   OS << "Object has a dynamic type '";
  80   QualType::print(DynamicType.getTypePtr(), Qualifiers(), OS, C.getLangOpts(),
  81                   llvm::Twine());
  82   OS << "' which is incompatible with static type '";
  83   QualType::print(StaticType.getTypePtr(), Qualifiers(), OS, C.getLangOpts(),
  84                   llvm::Twine());
  85   OS << "'";
  86   std::unique_ptr<BugReport> R(
  87       new BugReport(*BT, OS.str(), C.generateNonFatalErrorNode()));
  88   R->markInteresting(Reg);
  89   R->addVisitor(llvm::make_unique<DynamicTypeBugVisitor>(Reg));
  90   R->addRange(ReportedNode->getSourceRange());
  91   C.emitReport(std::move(R));
  92 }
  93
  94 std::shared_ptr<PathDiagnosticPiece>
  95 DynamicTypeChecker::DynamicTypeBugVisitor::VisitNode(const ExplodedNode *N,
  96                                                      const ExplodedNode *PrevN,
  97                                                      BugReporterContext &BRC,
  98                                                      BugReport &BR) {
  99   ProgramStateRef State = N->getState();
 100   ProgramStateRef StatePrev = PrevN->getState();
 101
 102   DynamicTypeInfo TrackedType = getDynamicTypeInfo(State, Reg);
 103   DynamicTypeInfo TrackedTypePrev = getDynamicTypeInfo(StatePrev, Reg);
 104   if (!TrackedType.isValid())
 105     return nullptr;
 106
 107   if (TrackedTypePrev.isValid() &&
 108       TrackedTypePrev.getType() == TrackedType.getType())
 109     return nullptr;
 110
 111   // Retrieve the associated statement.
 112   const Stmt *S = PathDiagnosticLocation::getStmt(N);
 113   if (!S)
 114     return nullptr;
 115
 116   const LangOptions &LangOpts = BRC.getASTContext().getLangOpts();
 117
 118   SmallString<256> Buf;
 119   llvm::raw_svector_ostream OS(Buf);
 120   OS << "Type '";
 121   QualType::print(TrackedType.getType().getTypePtr(), Qualifiers(), OS,
 122                   LangOpts, llvm::Twine());
 123   OS << "' is inferred from ";
 124
 125   if (const auto *ExplicitCast = dyn_cast<ExplicitCastExpr>(S)) {
 126     OS << "explicit cast (from '";
 127     QualType::print(ExplicitCast->getSubExpr()->getType().getTypePtr(),
 128                     Qualifiers(), OS, LangOpts, llvm::Twine());
 129     OS << "' to '";
 130     QualType::print(ExplicitCast->getType().getTypePtr(), Qualifiers(), OS,
 131                     LangOpts, llvm::Twine());
 132     OS << "')";
 133   } else if (const auto *ImplicitCast = dyn_cast<ImplicitCastExpr>(S)) {
 134     OS << "implicit cast (from '";
 135     QualType::print(ImplicitCast->getSubExpr()->getType().getTypePtr(),
 136                     Qualifiers(), OS, LangOpts, llvm::Twine());
 137     OS << "' to '";
 138     QualType::print(ImplicitCast->getType().getTypePtr(), Qualifiers(), OS,
 139                     LangOpts, llvm::Twine());
 140     OS << "')";
 141   } else {
 142     OS << "this context";
 143   }
 144
 145   // Generate the extra diagnostic.
 146   PathDiagnosticLocation Pos(S, BRC.getSourceManager(),
 147                              N->getLocationContext());
 148   return std::make_shared<PathDiagnosticEventPiece>(Pos, OS.str(), true,
 149                                                     nullptr);
 150 }
 151
 152 static bool hasDefinition(const ObjCObjectPointerType *ObjPtr) {
 153   const ObjCInterfaceDecl *Decl = ObjPtr->getInterfaceDecl();
 154   if (!Decl)
 155     return false;
 156
 157   return Decl->getDefinition();
 158 }
 159
 160 // TODO: consider checking explicit casts?
 161 void DynamicTypeChecker::checkPostStmt(const ImplicitCastExpr *CE,
 162                                        CheckerContext &C) const {
 163   // TODO: C++ support.
 164   if (CE->getCastKind() != CK_BitCast)
 165     return;
 166
 167   const MemRegion *Region = C.getSVal(CE).getAsRegion();
 168   if (!Region)
 169     return;
 170
 171   ProgramStateRef State = C.getState();
 172   DynamicTypeInfo DynTypeInfo = getDynamicTypeInfo(State, Region);
 173
 174   if (!DynTypeInfo.isValid())
 175     return;
 176
 177   QualType DynType = DynTypeInfo.getType();
 178   QualType StaticType = CE->getType();
 179
 180   const auto *DynObjCType = DynType->getAs<ObjCObjectPointerType>();
 181   const auto *StaticObjCType = StaticType->getAs<ObjCObjectPointerType>();
 182
 183   if (!DynObjCType || !StaticObjCType)
 184     return;
 185
 186   if (!hasDefinition(DynObjCType) || !hasDefinition(StaticObjCType))
 187     return;
 188
 189   ASTContext &ASTCtxt = C.getASTContext();
 190
 191   // Strip kindeofness to correctly detect subtyping relationships.
 192   DynObjCType = DynObjCType->stripObjCKindOfTypeAndQuals(ASTCtxt);
 193   StaticObjCType = StaticObjCType->stripObjCKindOfTypeAndQuals(ASTCtxt);
 194
 195   // Specialized objects are handled by the generics checker.
 196   if (StaticObjCType->isSpecialized())
 197     return;
 198
 199   if (ASTCtxt.canAssignObjCInterfaces(StaticObjCType, DynObjCType))
 200     return;
 201
 202   if (DynTypeInfo.canBeASubClass() &&
 203       ASTCtxt.canAssignObjCInterfaces(DynObjCType, StaticObjCType))
 204     return;
 205
 206   reportTypeError(DynType, StaticType, Region, CE, C);
 207 }
 208
 209 void ento::registerDynamicTypeChecker(CheckerManager &mgr) {
 210   mgr.registerChecker<DynamicTypeChecker>();
 211 }