mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-28 07:49:01 -04:00
2946cd7010
to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
115 lines
3.2 KiB
C++
115 lines
3.2 KiB
C++
//===---- CheckerHelpers.cpp - Helper functions for checkers ----*- 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines several static functions for use in checkers.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h"
|
|
#include "clang/AST/Decl.h"
|
|
#include "clang/AST/Expr.h"
|
|
|
|
namespace clang {
|
|
|
|
namespace ento {
|
|
|
|
// Recursively find any substatements containing macros
|
|
bool containsMacro(const Stmt *S) {
|
|
if (S->getBeginLoc().isMacroID())
|
|
return true;
|
|
|
|
if (S->getEndLoc().isMacroID())
|
|
return true;
|
|
|
|
for (const Stmt *Child : S->children())
|
|
if (Child && containsMacro(Child))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
// Recursively find any substatements containing enum constants
|
|
bool containsEnum(const Stmt *S) {
|
|
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(S);
|
|
|
|
if (DR && isa<EnumConstantDecl>(DR->getDecl()))
|
|
return true;
|
|
|
|
for (const Stmt *Child : S->children())
|
|
if (Child && containsEnum(Child))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
// Recursively find any substatements containing static vars
|
|
bool containsStaticLocal(const Stmt *S) {
|
|
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(S);
|
|
|
|
if (DR)
|
|
if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl()))
|
|
if (VD->isStaticLocal())
|
|
return true;
|
|
|
|
for (const Stmt *Child : S->children())
|
|
if (Child && containsStaticLocal(Child))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
// Recursively find any substatements containing __builtin_offsetof
|
|
bool containsBuiltinOffsetOf(const Stmt *S) {
|
|
if (isa<OffsetOfExpr>(S))
|
|
return true;
|
|
|
|
for (const Stmt *Child : S->children())
|
|
if (Child && containsBuiltinOffsetOf(Child))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
// Extract lhs and rhs from assignment statement
|
|
std::pair<const clang::VarDecl *, const clang::Expr *>
|
|
parseAssignment(const Stmt *S) {
|
|
const VarDecl *VD = nullptr;
|
|
const Expr *RHS = nullptr;
|
|
|
|
if (auto Assign = dyn_cast_or_null<BinaryOperator>(S)) {
|
|
if (Assign->isAssignmentOp()) {
|
|
// Ordinary assignment
|
|
RHS = Assign->getRHS();
|
|
if (auto DE = dyn_cast_or_null<DeclRefExpr>(Assign->getLHS()))
|
|
VD = dyn_cast_or_null<VarDecl>(DE->getDecl());
|
|
}
|
|
} else if (auto PD = dyn_cast_or_null<DeclStmt>(S)) {
|
|
// Initialization
|
|
assert(PD->isSingleDecl() && "We process decls one by one");
|
|
VD = dyn_cast_or_null<VarDecl>(PD->getSingleDecl());
|
|
RHS = VD->getAnyInitializer();
|
|
}
|
|
|
|
return std::make_pair(VD, RHS);
|
|
}
|
|
|
|
Nullability getNullabilityAnnotation(QualType Type) {
|
|
const auto *AttrType = Type->getAs<AttributedType>();
|
|
if (!AttrType)
|
|
return Nullability::Unspecified;
|
|
if (AttrType->getAttrKind() == attr::TypeNullable)
|
|
return Nullability::Nullable;
|
|
else if (AttrType->getAttrKind() == attr::TypeNonNull)
|
|
return Nullability::Nonnull;
|
|
return Nullability::Unspecified;
|
|
}
|
|
|
|
|
|
} // end namespace ento
|
|
} // end namespace clang
|