contrib/llvm-project/clang/lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp

   1 //=== BuiltinFunctionChecker.cpp --------------------------------*- 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 checker evaluates clang builtin functions.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/Basic/Builtins.h"
  14 #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
  15 #include "clang/StaticAnalyzer/Core/Checker.h"
  16 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
  17 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
  18 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
  19 #include "clang/StaticAnalyzer/Core/PathSensitive/DynamicSize.h"
  20
  21 using namespace clang;
  22 using namespace ento;
  23
  24 namespace {
  25
  26 class BuiltinFunctionChecker : public Checker<eval::Call> {
  27 public:
  28   bool evalCall(const CallEvent &Call, CheckerContext &C) const;
  29 };
  30
  31 }
  32
  33 bool BuiltinFunctionChecker::evalCall(const CallEvent &Call,
  34                                       CheckerContext &C) const {
  35   ProgramStateRef state = C.getState();
  36   const auto *FD = dyn_cast_or_null<FunctionDecl>(Call.getDecl());
  37   if (!FD)
  38     return false;
  39
  40   const LocationContext *LCtx = C.getLocationContext();
  41   const Expr *CE = Call.getOriginExpr();
  42
  43   switch (FD->getBuiltinID()) {
  44   default:
  45     return false;
  46
  47   case Builtin::BI__builtin_assume: {
  48     assert (Call.getNumArgs() > 0);
  49     SVal Arg = Call.getArgSVal(0);
  50     if (Arg.isUndef())
  51       return true; // Return true to model purity.
  52
  53     state = state->assume(Arg.castAs<DefinedOrUnknownSVal>(), true);
  54     // FIXME: do we want to warn here? Not right now. The most reports might
  55     // come from infeasible paths, thus being false positives.
  56     if (!state) {
  57       C.generateSink(C.getState(), C.getPredecessor());
  58       return true;
  59     }
  60
  61     C.addTransition(state);
  62     return true;
  63   }
  64
  65   case Builtin::BI__builtin_unpredictable:
  66   case Builtin::BI__builtin_expect:
  67   case Builtin::BI__builtin_expect_with_probability:
  68   case Builtin::BI__builtin_assume_aligned:
  69   case Builtin::BI__builtin_addressof: {
  70     // For __builtin_unpredictable, __builtin_expect,
  71     // __builtin_expect_with_probability and __builtin_assume_aligned,
  72     // just return the value of the subexpression.
  73     // __builtin_addressof is going from a reference to a pointer, but those
  74     // are represented the same way in the analyzer.
  75     assert (Call.getNumArgs() > 0);
  76     SVal Arg = Call.getArgSVal(0);
  77     C.addTransition(state->BindExpr(CE, LCtx, Arg));
  78     return true;
  79   }
  80
  81   case Builtin::BI__builtin_alloca_with_align:
  82   case Builtin::BI__builtin_alloca: {
  83     // FIXME: Refactor into StoreManager itself?
  84     MemRegionManager& RM = C.getStoreManager().getRegionManager();
  85     const AllocaRegion* R =
  86       RM.getAllocaRegion(CE, C.blockCount(), C.getLocationContext());
  87
  88     // Set the extent of the region in bytes. This enables us to use the
  89     // SVal of the argument directly. If we save the extent in bits, we
  90     // cannot represent values like symbol*8.
  91     auto Size = Call.getArgSVal(0);
  92     if (Size.isUndef())
  93       return true; // Return true to model purity.
  94
  95     SValBuilder& svalBuilder = C.getSValBuilder();
  96     DefinedOrUnknownSVal DynSize = getDynamicSize(state, R, svalBuilder);
  97     DefinedOrUnknownSVal DynSizeMatchesSizeArg =
  98         svalBuilder.evalEQ(state, DynSize, Size.castAs<DefinedOrUnknownSVal>());
  99     state = state->assume(DynSizeMatchesSizeArg, true);
 100     assert(state && "The region should not have any previous constraints");
 101
 102     C.addTransition(state->BindExpr(CE, LCtx, loc::MemRegionVal(R)));
 103     return true;
 104   }
 105
 106   case Builtin::BI__builtin_dynamic_object_size:
 107   case Builtin::BI__builtin_object_size:
 108   case Builtin::BI__builtin_constant_p: {
 109     // This must be resolvable at compile time, so we defer to the constant
 110     // evaluator for a value.
 111     SValBuilder &SVB = C.getSValBuilder();
 112     SVal V = UnknownVal();
 113     Expr::EvalResult EVResult;
 114     if (CE->EvaluateAsInt(EVResult, C.getASTContext(), Expr::SE_NoSideEffects)) {
 115       // Make sure the result has the correct type.
 116       llvm::APSInt Result = EVResult.Val.getInt();
 117       BasicValueFactory &BVF = SVB.getBasicValueFactory();
 118       BVF.getAPSIntType(CE->getType()).apply(Result);
 119       V = SVB.makeIntVal(Result);
 120     }
 121
 122     if (FD->getBuiltinID() == Builtin::BI__builtin_constant_p) {
 123       // If we didn't manage to figure out if the value is constant or not,
 124       // it is safe to assume that it's not constant and unsafe to assume
 125       // that it's constant.
 126       if (V.isUnknown())
 127         V = SVB.makeIntVal(0, CE->getType());
 128     }
 129
 130     C.addTransition(state->BindExpr(CE, LCtx, V));
 131     return true;
 132   }
 133   }
 134 }
 135
 136 void ento::registerBuiltinFunctionChecker(CheckerManager &mgr) {
 137   mgr.registerChecker<BuiltinFunctionChecker>();
 138 }
 139
 140 bool ento::shouldRegisterBuiltinFunctionChecker(const CheckerManager &mgr) {
 141   return true;
 142 }