llvm/clang/lib/StaticAnalyzer/Checkers/Iterator.cpp

//=== Iterator.cpp - Common functions for iterator 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
//
//===----------------------------------------------------------------------===//
//
// Defines common functions to be used by the itertor checkers .
//
//===----------------------------------------------------------------------===//

#include "Iterator.h"

namespace clang {
namespace ento {
namespace iterator {

bool isIteratorType(const QualType &Type) { … }

bool isIterator(const CXXRecordDecl *CRD) { … }

bool isComparisonOperator(OverloadedOperatorKind OK) { … }

bool isInsertCall(const FunctionDecl *Func) { … }

bool isEmplaceCall(const FunctionDecl *Func) { … }

bool isEraseCall(const FunctionDecl *Func) { … }

bool isEraseAfterCall(const FunctionDecl *Func) { … }

bool isAccessOperator(OverloadedOperatorKind OK) { … }

bool isAccessOperator(UnaryOperatorKind OK) { … }

bool isAccessOperator(BinaryOperatorKind OK) { … }

bool isDereferenceOperator(OverloadedOperatorKind OK) { … }

bool isDereferenceOperator(UnaryOperatorKind OK) { … }

bool isDereferenceOperator(BinaryOperatorKind OK) { … }

bool isIncrementOperator(OverloadedOperatorKind OK) { … }

bool isIncrementOperator(UnaryOperatorKind OK) { … }

bool isDecrementOperator(OverloadedOperatorKind OK) { … }

bool isDecrementOperator(UnaryOperatorKind OK) { … }

bool isRandomIncrOrDecrOperator(OverloadedOperatorKind OK) { … }

bool isRandomIncrOrDecrOperator(BinaryOperatorKind OK) { … }

const ContainerData *getContainerData(ProgramStateRef State,
                                      const MemRegion *Cont) { … }

const IteratorPosition *getIteratorPosition(ProgramStateRef State, SVal Val) { … }

ProgramStateRef setIteratorPosition(ProgramStateRef State, SVal Val,
                                    const IteratorPosition &Pos) { … }

ProgramStateRef createIteratorPosition(ProgramStateRef State, SVal Val,
                                       const MemRegion *Cont, const Stmt *S,
                                       const LocationContext *LCtx,
                                       unsigned blockCount) { … }

ProgramStateRef advancePosition(ProgramStateRef State, SVal Iter,
                                OverloadedOperatorKind Op, SVal Distance) { … }

// This function tells the analyzer's engine that symbols produced by our
// checker, most notably iterator positions, are relatively small.
// A distance between items in the container should not be very large.
// By assuming that it is within around 1/8 of the address space,
// we can help the analyzer perform operations on these symbols
// without being afraid of integer overflows.
// FIXME: Should we provide it as an API, so that all checkers could use it?
ProgramStateRef assumeNoOverflow(ProgramStateRef State, SymbolRef Sym,
                                 long Scale) { … }

bool compare(ProgramStateRef State, SymbolRef Sym1, SymbolRef Sym2,
             BinaryOperator::Opcode Opc) { … }

bool compare(ProgramStateRef State, NonLoc NL1, NonLoc NL2,
             BinaryOperator::Opcode Opc) { … }

} // namespace iterator
} // namespace ento
} // namespace clang