blob: 0906cf2d0cb29b2347a758153d9fc164aaa4fa59 [file] [edit]
//=======- RawPtrRefCallArgsChecker.cpp --------------------------*- C++ -*-==//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "ASTUtils.h"
#include "DiagOutputUtils.h"
#include "PtrTypesSemantics.h"
#include "RawPtrRefSafetyModel.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DynamicRecursiveASTVisitor.h"
#include "clang/Analysis/DomainSpecific/CocoaConventions.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Lex/Lexer.h"
#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "llvm/Support/SaveAndRestore.h"
#include <optional>
using namespace clang;
using namespace ento;
namespace {
class RawPtrRefCallArgsChecker
: public Checker<check::ASTDecl<TranslationUnitDecl>> {
BugType Bug;
TrivialFunctionAnalysis TFA;
EnsureFunctionAnalysis EFA;
protected:
mutable BugReporter *BR;
const std::unique_ptr<PtrRefSafetyModel> Model;
public:
RawPtrRefCallArgsChecker(const char *description,
std::unique_ptr<PtrRefSafetyModel> Model)
: Bug(this, description, "WebKit coding guidelines"),
Model(std::move(Model)) {}
void checkASTDecl(const TranslationUnitDecl *TUD, AnalysisManager &MGR,
BugReporter &BRArg) const {
BR = &BRArg;
// The calls to checkAST* from AnalysisConsumer don't
// visit template instantiations or lambda classes. We
// want to visit those, so we make our own RecursiveASTVisitor.
struct LocalVisitor : DynamicRecursiveASTVisitor {
const RawPtrRefCallArgsChecker *Checker;
Decl *DeclWithIssue{nullptr};
explicit LocalVisitor(const RawPtrRefCallArgsChecker *Checker)
: Checker(Checker) {
assert(Checker);
ShouldVisitTemplateInstantiations = true;
ShouldVisitImplicitCode = false;
}
bool TraverseClassTemplateDecl(ClassTemplateDecl *Decl) override {
if (isSmartPtrClass(safeGetName(Decl)))
return true;
return DynamicRecursiveASTVisitor::TraverseClassTemplateDecl(Decl);
}
bool TraverseDecl(Decl *D) override {
// A template pattern is checked through its instantiations, which are
// traversed from the TemplateDecl itself. In the pattern the callee of
// a call may still be an unresolved overload set and the type of an
// expression may still be dependent, neither of which can be reasoned
// about, so don't enter it at all.
if (D && !isa<TemplateDecl>(D) && D->isTemplated())
return true;
llvm::SaveAndRestore SavedDecl(DeclWithIssue);
if (D && (isa<FunctionDecl>(D) || isa<ObjCMethodDecl>(D)))
DeclWithIssue = D;
return DynamicRecursiveASTVisitor::TraverseDecl(D);
}
bool TraverseLambdaExpr(LambdaExpr *L) override {
auto *FTD = L->getLambdaClass()->getDependentLambdaCallOperator();
if (!FTD)
return DynamicRecursiveASTVisitor::TraverseLambdaExpr(L);
// The body of a generic lambda is the pattern of its call operator,
// but it is reached from the LambdaExpr as a statement, so TraverseDecl
// never gets to skip it. Traverse the capture initializers, which are
// evaluated in the enclosing scope, and then the call operator itself,
// of which the pattern is skipped like any other and the instantiations
// are traversed. The initializers are traversed as expressions because
// the variable of an init capture is declared in the pattern.
for (unsigned I = 0, N = L->capture_size(); I != N; ++I) {
if (!(L->capture_begin() + I)->isExplicit())
continue;
if (auto *Init = L->capture_init_begin()[I];
Init && !TraverseStmt(Init))
return false;
}
return TraverseDecl(FTD);
}
bool VisitCallExpr(CallExpr *CE) override {
Checker->visitCallExpr(CE, DeclWithIssue);
return true;
}
bool VisitCXXConstructExpr(CXXConstructExpr *CE) override {
Checker->visitConstructExpr(CE, DeclWithIssue);
return true;
}
bool VisitTypedefDecl(TypedefDecl *TD) override {
if (auto *RTC = Checker->Model->retainTypeChecker())
RTC->visitTypedef(TD);
return true;
}
bool VisitObjCMessageExpr(ObjCMessageExpr *ObjCMsgExpr) override {
Checker->visitObjCMessageExpr(ObjCMsgExpr, DeclWithIssue);
return true;
}
};
LocalVisitor visitor(this);
if (auto *RTC = Model->retainTypeChecker())
RTC->visitTranslationUnitDecl(TUD);
visitor.TraverseDecl(const_cast<TranslationUnitDecl *>(TUD));
}
template <typename CallOrConstruct>
void visitCallOrConstructExpr(const CallOrConstruct *CE,
const FunctionDecl *F, const Decl *D) const {
if (F) {
unsigned ArgIdx = 0;
if (auto *MemberCallExpr = dyn_cast<CXXMemberCallExpr>(CE)) {
checkThisArg(F, MemberCallExpr, D);
} else if (isa<CXXOperatorCallExpr>(CE) && isa<CXXMethodDecl>(F)) {
// An overloaded member operator (e.g. lambda or std::function call
// operator) receives the receiver object as argument 0; start the
// parameter loop at 1 so we don't match it against the operator's
// first declared parameter.
auto *Receiver = CE->getArg(0);
checkThisArg(F, Receiver, Receiver->getType(), D);
ArgIdx = 1;
}
for (auto P = F->param_begin();
P < F->param_end() && ArgIdx < CE->getNumArgs(); ++P, ++ArgIdx) {
// TODO: attributes.
// if ((*P)->hasAttr<SafeRefCntblRawPtrAttr>())
// continue;
checkArg(F, CE->getArg(ArgIdx), (*P)->getType(), *P, D);
}
for (; ArgIdx < CE->getNumArgs(); ++ArgIdx) {
auto *Arg = CE->getArg(ArgIdx);
checkArg(F, Arg, Arg->getType(), nullptr, D);
}
}
}
void visitCallExpr(const CallExpr *CE, const Decl *D) const {
auto *Callee = CE->getDirectCallee();
if (shouldSkipCall(CE, Callee))
return;
if (Callee)
visitCallOrConstructExpr(CE, Callee, D);
else if (auto *Decl = CE->getCalleeDecl()) {
if (auto *FnType = Decl->getFunctionType()) {
if (auto *ProtoType = dyn_cast<FunctionProtoType>(FnType)) {
if (auto *MemberCallExpr = dyn_cast<CXXMemberCallExpr>(CE))
checkThisArg(nullptr, MemberCallExpr, D);
unsigned ArgIdx = 0;
for (auto PT = ProtoType->param_type_begin();
PT < ProtoType->param_type_end() && ArgIdx < CE->getNumArgs();
++PT, ++ArgIdx)
checkArg(nullptr, CE->getArg(ArgIdx), *PT, nullptr, D);
for (; ArgIdx < CE->getNumArgs(); ++ArgIdx) {
auto *Arg = CE->getArg(ArgIdx);
checkArg(nullptr, Arg, Arg->getType(), nullptr, D);
}
}
}
}
}
void visitConstructExpr(const CXXConstructExpr *CE, const Decl *D) const {
auto *Constructor = CE->getConstructor();
if (shouldSkipCall(CE, Constructor))
return;
if (Constructor)
visitCallOrConstructExpr(CE, Constructor, D);
}
void visitObjCMessageExpr(const ObjCMessageExpr *E, const Decl *D) const {
if (BR->getSourceManager().isInSystemHeader(E->getExprLoc()))
return;
if (auto *Receiver = E->getInstanceReceiver()) {
std::optional<bool> IsUnsafe = Model->isUnsafePtr(E->getReceiverType());
const Expr *Origin = nullptr;
if (IsUnsafe && *IsUnsafe &&
!isPtrOriginSafe(Receiver, &Origin, E->getReceiverType())) {
if (isAllocInit(E))
return;
reportBugOnReceiver(E->getMethodDecl(), Receiver, D, Origin);
}
}
auto *MethodDecl = E->getMethodDecl();
if (!MethodDecl)
return;
auto ArgCount = E->getNumArgs();
for (unsigned i = 0; i < ArgCount; ++i) {
auto *Arg = E->getArg(i);
bool hasParam = i < MethodDecl->param_size();
auto *Param = hasParam ? MethodDecl->getParamDecl(i) : nullptr;
auto ArgType = Arg->getType();
std::optional<bool> IsUnsafe = Model->isUnsafePtr(ArgType);
if (!IsUnsafe || !(*IsUnsafe))
continue;
const Expr *Origin = nullptr;
if (isPtrOriginSafe(Arg, &Origin, ArgType))
continue;
reportBug(MethodDecl, Arg, Param, D, Origin);
}
}
static bool isRefCountingOperation(const CXXMethodDecl *MD) {
if (!MD)
return false;
auto name = safeGetName(MD);
return name == "ref" || name == "deref" ||
name == "incrementCheckedPtrCount" ||
name == "decrementCheckedPtrCount";
}
void checkThisArg(const NamedDecl *Callee,
const CXXMemberCallExpr *MemberCallExpr,
const Decl *DeclWithIssue) const {
if (isRefCountingOperation(MemberCallExpr->getMethodDecl()))
return;
checkThisArg(Callee, MemberCallExpr->getImplicitObjectArgument(),
MemberCallExpr->getObjectType(), DeclWithIssue);
}
void checkThisArg(const NamedDecl *Callee, const Expr *Receiver,
QualType ReceiverType, const Decl *DeclWithIssue) const {
// There is no ParmVarDecl for the implicit object parameter, so
// synthesize its type ('T&' per [over.match.funcs]) for the model to
// classify.
QualType ParamType = BR->getContext().getLValueReferenceType(
ReceiverType.getCanonicalType());
std::optional<bool> IsUnsafe = Model->isUnsafePtr(ParamType);
if (!IsUnsafe || !*IsUnsafe)
return;
const Expr *Origin = nullptr;
if (isPtrOriginSafe(Receiver, &Origin, ParamType))
return;
reportBugOnThis(Callee, Receiver, DeclWithIssue, Origin);
}
void checkArg(const NamedDecl *Callee, const Expr *Arg, QualType ParamType,
const ParmVarDecl *Param, const Decl *DeclWithIssue) const {
std::optional<bool> IsUncounted = Model->isUnsafePtr(ParamType);
if (!IsUncounted || !(*IsUncounted))
return;
if (auto *DefaultArg = dyn_cast<CXXDefaultArgExpr>(Arg))
Arg = DefaultArg->getExpr();
const Expr *Origin = nullptr;
if (isPtrOriginSafe(Arg, &Origin, ParamType))
return;
reportBug(Callee, Arg, Param, DeclWithIssue, Origin);
}
bool isPtrOriginSafe(const Expr *Arg, const Expr **Origin = nullptr,
QualType SinkType = QualType()) const {
return tryToFindPtrOrigin(
Arg, /*StopAtFirstRefCountedObj=*/true,
Model->checksForInteriorDestruction(),
[&](const clang::CXXRecordDecl *Record) {
return Model->isSafePtr(Record);
},
[&](const clang::QualType T) { return Model->isSafePtrType(T); },
[&](const clang::Decl *D) {
return Model->isSafeDecl(D, BR->getSourceManager());
},
// A temporary on the path to an argument's origin is safe: the full
// expression does not end until the call returns.
[&](const clang::Expr *ArgOrigin, bool IsSafe,
bool /*OriginDependsOnFullExpressionTemporary*/,
bool PtrIsLifetimeBoundToOrigin) {
if (IsSafe)
return true;
if (isNullPtr(ArgOrigin))
return true;
if (isa<IntegerLiteral>(ArgOrigin)) {
// FIXME: Check the value.
// foo(123)
return true;
}
if (isa<CXXBoolLiteralExpr>(ArgOrigin))
return true;
if (isa<ObjCStringLiteral>(ArgOrigin))
return true;
if (!Model->checksForInteriorDestruction() &&
originOutlivesCall(ArgOrigin))
return true;
if (EFA.isACallToEnsureFn(ArgOrigin)) {
auto *MCE = dyn_cast<CXXMemberCallExpr>(ArgOrigin);
assert(MCE);
if (isPtrOriginSafe(MCE->getImplicitObjectArgument()))
return true;
}
if (Model->isSafeExpr(ArgOrigin, PtrIsLifetimeBoundToOrigin, SinkType,
/*SinkMayEscape=*/false))
return true;
if (Origin && !*Origin)
*Origin = ArgOrigin;
return false;
});
}
template <typename CallOrConstruct>
bool shouldSkipCall(const CallOrConstruct *CE,
const FunctionDecl *Callee) const {
if (BR->getSourceManager().isInSystemHeader(CE->getExprLoc()))
return true;
if (Callee && TFA.isTrivial(Callee))
return true;
if (isTrivialBuiltinFunction(Callee))
return true;
if (CE->getNumArgs() == 0)
return false;
// If an assignment is problematic we should warn about the sole existence
// of object on LHS.
if (auto *MemberOp = dyn_cast<CXXOperatorCallExpr>(CE)) {
// Note: assignemnt to built-in type isn't derived from CallExpr.
if (MemberOp->getOperator() ==
OO_Equal) { // Ignore assignment to Ref/RefPtr.
auto *callee = MemberOp->getDirectCallee();
if (auto *calleeDecl = dyn_cast<CXXMethodDecl>(callee)) {
if (const CXXRecordDecl *classDecl = calleeDecl->getParent()) {
if (Model->isSafePtr(classDecl))
return true;
}
}
}
if (MemberOp->isAssignmentOp())
return false;
}
if (!Callee)
return false;
if (isMethodOnWTFContainerType(Callee))
return true;
auto overloadedOperatorType = Callee->getOverloadedOperator();
if (overloadedOperatorType == OO_EqualEqual ||
overloadedOperatorType == OO_ExclaimEqual ||
overloadedOperatorType == OO_LessEqual ||
overloadedOperatorType == OO_GreaterEqual ||
overloadedOperatorType == OO_Spaceship ||
overloadedOperatorType == OO_AmpAmp ||
overloadedOperatorType == OO_PipePipe)
return true;
if (isCtorOfSafePtr(Callee) || isPtrConversion(Callee))
return true;
auto name = safeGetName(Callee);
if (name == "adoptRef" || name == "getPtr" || name == "WeakPtr" ||
name == "is" || name == "equal" || name == "hash" || name == "isType" ||
// FIXME: Most/all of these should be implemented via attributes.
name == "CFEqual" || name == "equalIgnoringASCIICase" ||
name == "equalIgnoringASCIICaseCommon" ||
name == "equalIgnoringNullity" || name == "toString")
return true;
return false;
}
bool isMethodOnWTFContainerType(const FunctionDecl *Decl) const {
if (!isa<CXXMethodDecl>(Decl))
return false;
auto *ClassDecl = Decl->getParent();
if (!ClassDecl || !isa<CXXRecordDecl>(ClassDecl))
return false;
auto *NsDecl = ClassDecl->getParent();
if (!NsDecl || !isa<NamespaceDecl>(NsDecl))
return false;
auto MethodName = safeGetName(Decl);
auto ClsNameStr = safeGetName(ClassDecl);
StringRef ClsName = ClsNameStr; // FIXME: Make safeGetName return StringRef.
auto NamespaceName = safeGetName(NsDecl);
// FIXME: These should be implemented via attributes.
return NamespaceName == "WTF" &&
(MethodName == "find" || MethodName == "findIf" ||
MethodName == "reverseFind" || MethodName == "reverseFindIf" ||
MethodName == "findIgnoringASCIICase" || MethodName == "get" ||
MethodName == "inlineGet" || MethodName == "contains" ||
MethodName == "containsIf" ||
MethodName == "containsIgnoringASCIICase" ||
MethodName == "startsWith" || MethodName == "endsWith" ||
MethodName == "startsWithIgnoringASCIICase" ||
MethodName == "endsWithIgnoringASCIICase" ||
MethodName == "substring") &&
(ClsName.ends_with("Vector") || ClsName.ends_with("Set") ||
ClsName.ends_with("Map") || ClsName == "StringImpl" ||
ClsName.ends_with("String"));
}
void reportBug(const NamedDecl *Callee, const Expr *CallArg,
const ParmVarDecl *Param, const Decl *DeclWithIssue,
const Expr *Origin) const {
assert(CallArg);
SmallString<100> Buf;
llvm::raw_svector_ostream Os(Buf);
const std::string paramName = safeGetName(Param);
Os << "Function argument";
printArgument(Os, CallArg);
if (!paramName.empty() || Callee)
Os << " (";
if (!paramName.empty()) {
Os << "parameter ";
printQuotedQualifiedName(Os, Param);
}
if (Callee) {
if (!paramName.empty())
Os << " ";
Os << "to ";
printQuotedQualifiedName(Os, Callee);
}
if (!paramName.empty() || Callee)
Os << ")";
Os << " is a ";
Model->describeHazard(Os, Origin, CallArg->getType());
bool usesDefaultArgValue = isa<CXXDefaultArgExpr>(CallArg) && Param;
const SourceLocation SrcLocToReport =
usesDefaultArgValue ? Param->getDefaultArg()->getExprLoc()
: CallArg->getSourceRange().getBegin();
PathDiagnosticLocation BSLoc(SrcLocToReport, BR->getSourceManager());
auto Report = std::make_unique<BasicBugReport>(Bug, Os.str(), BSLoc);
Report->addRange(CallArg->getSourceRange());
Report->setDeclWithIssue(DeclWithIssue);
BR->emitReport(std::move(Report));
}
void reportBugOnThis(const NamedDecl *Callee, const Expr *CallArg,
const Decl *DeclWithIssue, const Expr *Origin) const {
assert(CallArg);
const SourceLocation SrcLocToReport = CallArg->getSourceRange().getBegin();
SmallString<100> Buf;
llvm::raw_svector_ostream Os(Buf);
Os << "Function argument";
printArgument(Os, CallArg);
Os << " (parameter 'this'";
if (Callee) {
Os << " to ";
printQuotedQualifiedName(Os, Callee);
}
Os << ") is a ";
printHazardOrPointerTo(Os, CallArg, Origin);
PathDiagnosticLocation BSLoc(SrcLocToReport, BR->getSourceManager());
auto Report = std::make_unique<BasicBugReport>(Bug, Os.str(), BSLoc);
Report->addRange(CallArg->getSourceRange());
Report->setDeclWithIssue(DeclWithIssue);
BR->emitReport(std::move(Report));
}
void reportBugOnReceiver(const NamedDecl *Callee, const Expr *CallArg,
const Decl *DeclWithIssue,
const Expr *Origin) const {
assert(CallArg);
const SourceLocation SrcLocToReport = CallArg->getSourceRange().getBegin();
SmallString<100> Buf;
llvm::raw_svector_ostream Os(Buf);
Os << "Receiver";
printArgument(Os, CallArg);
if (Callee) {
Os << " (to ";
printQuotedQualifiedName(Os, Callee);
Os << ")";
}
Os << " is a ";
printHazardOrPointerTo(Os, CallArg, Origin);
PathDiagnosticLocation BSLoc(SrcLocToReport, BR->getSourceManager());
auto Report = std::make_unique<BasicBugReport>(Bug, Os.str(), BSLoc);
Report->addRange(CallArg->getSourceRange());
Report->setDeclWithIssue(DeclWithIssue);
BR->emitReport(std::move(Report));
}
void printHazardOrPointerTo(llvm::raw_svector_ostream &Os,
const Expr *CallArg, const Expr *Origin) const {
if (Model->checksForInteriorDestruction()) {
Model->describeHazard(Os, Origin, CallArg->getType());
return;
}
// 'this' is a pointer even when the call is spelled with '.', so don't
// infer pointer vs reference from the argument type.
Os << "raw pointer to " << Model->typeName() << " ";
printTypeName(Os, CallArg->getType());
}
void printArgument(llvm::raw_svector_ostream &Os, const Expr *Arg) const {
SmallString<100> Buf;
llvm::raw_svector_ostream ArgOs(Buf);
Arg->printPretty(ArgOs, /*Helper=*/nullptr,
BR->getContext().getPrintingPolicy());
StringRef ArgCode = ArgOs.str();
if (ArgCode.contains('\n'))
return;
ArgCode = ArgCode.take_front(50);
if (ArgCode.size() == 50)
Os << " '" << ArgCode << "...'";
else
Os << " '" << ArgCode << "'";
}
};
class UncountedCallArgsChecker final : public RawPtrRefCallArgsChecker {
public:
UncountedCallArgsChecker()
: RawPtrRefCallArgsChecker("Uncounted call argument for a raw "
"pointer/reference parameter",
makeRefPtrSafetyModel()) {}
};
class UncheckedCallArgsChecker final : public RawPtrRefCallArgsChecker {
public:
UncheckedCallArgsChecker()
: RawPtrRefCallArgsChecker("Unchecked call argument for a raw "
"pointer/reference parameter",
makeCheckedPtrSafetyModel()) {}
};
class UnretainedCallArgsChecker final : public RawPtrRefCallArgsChecker {
public:
UnretainedCallArgsChecker()
: RawPtrRefCallArgsChecker("Unretained call argument for a raw "
"pointer/reference parameter",
makeRetainPtrSafetyModel()) {}
};
class UnborrowedCallArgsChecker final : public RawPtrRefCallArgsChecker {
public:
UnborrowedCallArgsChecker()
: RawPtrRefCallArgsChecker("Unborrowed call argument for a raw "
"pointer/reference parameter",
makeBorrowSafetyModel()) {}
};
} // namespace
void ento::registerUncountedCallArgsChecker(CheckerManager &Mgr) {
Mgr.registerChecker<UncountedCallArgsChecker>();
}
bool ento::shouldRegisterUncountedCallArgsChecker(const CheckerManager &) {
return true;
}
void ento::registerUncheckedCallArgsChecker(CheckerManager &Mgr) {
Mgr.registerChecker<UncheckedCallArgsChecker>();
}
bool ento::shouldRegisterUncheckedCallArgsChecker(const CheckerManager &) {
return true;
}
void ento::registerUnretainedCallArgsChecker(CheckerManager &Mgr) {
Mgr.registerChecker<UnretainedCallArgsChecker>();
}
bool ento::shouldRegisterUnretainedCallArgsChecker(const CheckerManager &) {
return true;
}
void ento::registerUnborrowedCallArgsChecker(CheckerManager &Mgr) {
Mgr.registerChecker<UnborrowedCallArgsChecker>();
}
bool ento::shouldRegisterUnborrowedCallArgsChecker(const CheckerManager &) {
return true;
}