Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/MoveChecker_8cpp_source.html below:

clang: lib/StaticAnalyzer/Checkers/MoveChecker.cpp Source File

;

{ Moved, Reported } K;

RegionState(Kind InK) : K(InK) {}

isReported()

{

K == Reported; }

isMoved()

{

K == Moved; }

RegionState getReported() {

RegionState(Reported); }

RegionState getMoved() {

RegionState(Moved); }

(

RegionState &

)

{

K ==

.K; }

Profile(llvm::FoldingSetNodeID &ID)

{

.AddInteger(K); }

:

<check::PreCall, check::PostCall,

check::DeadSymbols, check::RegionChanges> {

*NL,

*Sep)

;

MisuseKind { MK_FunCall, MK_Copy, MK_Move, MK_Dereference };

StdObjectKind { SK_NonStd, SK_Unsafe, SK_Safe, SK_SmartPtr };

AggressivenessKind {

AK_KnownsAndLocals = 1,

misuseCausesCrash(MisuseKind MK) {

MK == MK_Dereference;

StdObjectKind StdKind;

llvm::StringSet<> StdSmartPtrClasses = {

llvm::StringSet<> StdSafeClasses = {

shouldBeTracked(ObjectKind OK)

{

(Aggressiveness == AK_All) ||

(Aggressiveness >= AK_KnownsAndLocals && OK.IsLocal) ||

OK.StdKind == SK_Unsafe || OK.StdKind == SK_SmartPtr;

shouldWarnAbout(ObjectKind OK, MisuseKind MK)

{

shouldBeTracked(OK) &&

((Aggressiveness == AK_All) ||

(Aggressiveness >= AK_KnownsAndLocals && OK.IsLocal) ||

OK.StdKind != SK_SmartPtr || MK == MK_Dereference);

explainObject(llvm::raw_ostream &OS,

*MR,

belongsTo(

*RD,

llvm::StringSet<> &

)

;

MovedBugVisitor(

MoveChecker &Chk,

*R,

: Chk(Chk), Region(R), RD(RD), MK(MK),

(

) {}

Profile(llvm::FoldingSetNodeID &ID)

{

.AddPointer(&

);

.AddPointer(Region);

MoveChecker &Chk;

AggressivenessKind Aggressiveness = AK_KnownsAndLocals;

llvm::StringSwitch<AggressivenessKind>(Str)

.Case(

, AK_KnownsOnly)

.Case(

, AK_KnownsAndLocals)

.Case(

, AK_All)

.Default(AK_Invalid);

(Aggressiveness == AK_Invalid)

);

isStateResetMethod(

*MethodDec)

;

isMoveSafeMethod(

*MethodDec)

;

RegionState *RS = State->get<TrackedRegionMap>(Region);

RS && (RS->isMoved() || RS->isReported());

(

&

: State->get<TrackedRegionMap>()) {

(

.first->isSubRegionOf(Region))

State = State->remove<TrackedRegionMap>(

.first);

(

&

: State->get<TrackedRegionMap>()) {

(

*SR = dyn_cast_or_null<SymbolicRegion>(MR)) {

MoveChecker::MovedBugVisitor::VisitNode(

*N,

RegionState *TrackedObject = State->get<TrackedRegionMap>(Region);

RegionState *TrackedObjectPrev =

StatePrev->get<TrackedRegionMap>(Region);

(TrackedObjectPrev && TrackedObject)

llvm::raw_svector_ostream OS(Str);

ObjectKind OK = Chk.classifyObject(Region, RD);

(OK.StdKind) {

(MK == MK_Dereference) {

OS <<

;

Chk.explainObject(OS, Region, RD, MK);

OS <<

;

Chk.explainObject(OS, Region, RD, MK);

Chk.explainObject(OS, Region, RD, MK);

OS <<

;

std::make_shared<PathDiagnosticEventPiece>(Pos, OS.str(),

);

(!State->get<TrackedRegionMap>(Region))

assert(!

.isDifferent() &&

);

RegionState *RS = State->get<TrackedRegionMap>(Region);

ObjectKind OK = classifyObject(Region, RD);

(MK == MK_Dereference && OK.StdKind != SK_SmartPtr)

(!RS || !shouldWarnAbout(OK, MK)

|| isInMoveSafeContext(

.getLocationContext())) {

.addTransition(State);

(misuseCausesCrash(MK)) {

.generateSink(State,

.getPredecessor());

.addTransition(State);

State = State->set<TrackedRegionMap>(Region, RegionState::getReported());

.addTransition(State, N);

MisuseKind MK)

{

(

*N = misuseCausesCrash(MK) ?

.generateErrorNode()

:

.generateNonFatalErrorNode()) {

*MoveNode = getMoveLocation(N, Region,

);

llvm::raw_svector_ostream OS(Str);

OS <<

;

explainObject(OS, Region, RD, MK);

OS <<

;

explainObject(OS, Region, RD, MK);

OS <<

;

explainObject(OS, Region, RD, MK);

OS <<

;

explainObject(OS, Region, RD, MK);

R = std::make_unique<PathSensitiveBugReport>(

BT, OS.str(), N, LocUsedForUniqueing,

R->addVisitor(std::make_unique<MovedBugVisitor>(*

, Region, RD, MK));

.emitReport(std::move(R));

*AFC = dyn_cast<AnyFunctionCall>(&

);

MethodDecl = dyn_cast_or_null<CXXMethodDecl>(AFC->getDecl());

*ConstructorDecl = dyn_cast<CXXConstructorDecl>(MethodDecl);

(ConstructorDecl && !ConstructorDecl->isMoveConstructor())

(!ConstructorDecl && !MethodDecl->isMoveAssignmentOperator())

ArgRegion = AFC->getArgSVal(0).getAsRegion();

*CC = dyn_cast_or_null<CXXConstructorCall>(&

);

(CC && CC->getCXXThisVal().getAsRegion() == ArgRegion)

(

*IC = dyn_cast<CXXInstanceCall>(AFC))

(IC->getCXXThisVal().getAsRegion() == ArgRegion)

AFC->getArgExpr(0)->isPRValue())

(State->get<TrackedRegionMap>(ArgRegion))

ObjectKind OK = classifyObject(ArgRegion, RD);

(shouldBeTracked(OK)) {

State = State->set<TrackedRegionMap>(ArgRegion, RegionState::getMoved());

.addTransition(State);

assert(!

.isDifferent() &&

);

MoveChecker::isMoveSafeMethod(

*MethodDec)

{

(

*ConversionDec =

dyn_cast_or_null<CXXConversionDecl>(MethodDec)) {

*Tp = ConversionDec->getConversionType().getTypePtrOrNull();

(MethodDec->

().lower() ==

||

MethodDec->

().lower() ==

));

MoveChecker::isStateResetMethod(

*MethodDec)

{

(MethodDec->

<ReinitializesAttr>())

std::string MethodName = MethodDec->

().lower();

(MethodName ==

|| MethodName ==

||

MethodName ==

|| MethodName ==

||

MethodName ==

|| MethodName ==

)

MoveChecker::isInMoveSafeContext(

*LC)

{

*CtxDec = LC->

();

*CtorDec = dyn_cast_or_null<CXXConstructorDecl>(CtxDec);

*DtorDec = dyn_cast_or_null<CXXDestructorDecl>(CtxDec);

*MethodDec = dyn_cast_or_null<CXXMethodDecl>(CtxDec);

(DtorDec || (CtorDec && CtorDec->isCopyOrMoveConstructor()) ||

isStateResetMethod(MethodDec) || isMoveSafeMethod(MethodDec))

llvm::StringSet<> &

)

{

MoveChecker::ObjectKind

MoveChecker::classifyObject(

*MR,

isa_and_nonnull<VarRegion, CXXLifetimeExtendedObjectRegion>(MR) &&

{ IsLocal, SK_NonStd };

(belongsTo(RD, StdSmartPtrClasses))

{ IsLocal, SK_SmartPtr };

(belongsTo(RD, StdSafeClasses))

{ IsLocal, SK_Safe };

{ IsLocal, SK_Unsafe };

MoveChecker::explainObject(llvm::raw_ostream &OS,

*MR,

*RegionDecl = cast<NamedDecl>(DR->getDecl());

OS <<

<< RegionDecl->getDeclName() <<

;

ObjectKind OK = classifyObject(MR, RD);

(OK.StdKind) {

(MK != MK_Dereference)

(

*CC = dyn_cast<CXXConstructorCall>(&

)) {

CtorDec = CC->getDecl();

(CtorDec && CtorDec->isCopyOrMoveConstructor()) {

*ArgRegion = CC->getArgSVal(0).getAsRegion();

MisuseKind MK = CtorDec->isMoveConstructor() ? MK_Move : MK_Copy;

modelUse(State, ArgRegion, RD, MK,

);

IC = dyn_cast<CXXInstanceCall>(&

);

*ThisRegion = IC->getCXXThisVal().getAsRegion();

MethodDecl = dyn_cast_or_null<CXXMethodDecl>(IC->getDecl());

(isa<CXXDestructorDecl>(MethodDecl))

(isStateResetMethod(MethodDecl)) {

.addTransition(State);

(isMoveSafeMethod(MethodDecl))

(MethodDecl->isOverloadedOperator()) {

(OOK == OO_Equal) {

(MethodDecl->isCopyAssignmentOperator() ||

MethodDecl->isMoveAssignmentOperator()) {

*ArgRegion = IC->getArgSVal(0).getAsRegion();

MethodDecl->isMoveAssignmentOperator() ? MK_Move : MK_Copy;

modelUse(State, ArgRegion, RD, MK,

);

.addTransition(State);

(OOK == OO_Star || OOK == OO_Arrow) {

modelUse(State, ThisRegion, RD, MK_Dereference,

);

modelUse(State, ThisRegion, RD, MK_FunCall,

);

MoveChecker::checkDeadSymbols(

&SymReaper,

TrackedRegionMapTy TrackedRegions = State->get<TrackedRegionMap>();

(

: TrackedRegions) {

State = State->remove<TrackedRegionMap>(Region);

.addTransition(State);

(

*IC = dyn_cast<CXXInstanceCall>(

))

ThisRegion = IC->getCXXThisVal().getAsRegion();

(

*Region : RequestedRegions) {

(ThisRegion != Region &&

llvm::is_contained(InvalidatedRegions, Region))

(

*Region : InvalidatedRegions)

*NL,

*Sep)

{

TrackedRegionMapTy RS = State->get<TrackedRegionMap>();

Out << Sep <<

<< NL;

I.first->dumpToStream(Out);

(I.second.isMoved())

Out <<

;

chk->setAggressiveness(

Defines the clang::Expr interface and subclasses for C++ expressions.

static bool isAnyBaseRegionReported(ProgramStateRef State, const MemRegion *Region)

static ProgramStateRef removeFromState(ProgramStateRef State, const MemRegion *Region)

static const MemRegion * unwrapRValueReferenceIndirection(const MemRegion *MR)

#define REGISTER_MAP_WITH_PROGRAMSTATE(Name, Key, Value)

Declares an immutable map of type NameTy, suitable for placement into the ProgramState.

StringRef getCheckerStringOption(StringRef CheckerName, StringRef OptionName, bool SearchInParents=false) const

Query an option's string value.

Represents a static or instance method of a struct/union/class.

Represents a C++ struct/union/class.

DeclContext * getParent()

getParent - Returns the containing DeclContext.

bool isStdNamespace() const

DeclContext * getDeclContext()

bool isIdentifier() const

Predicate functions for querying what type of name this is.

bool isOverloadedOperator() const

Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".

OverloadedOperatorKind getOverloadedOperator() const

getOverloadedOperator - Which C++ overloaded operator this function represents, if any.

One of these records is kept for each identifier that is lexed.

StringRef getName() const

Return the actual identifier string.

It wraps the AnalysisDeclContext to represent both the call stack with the help of StackFrameContext ...

const Decl * getDecl() const

const LocationContext * getParent() const

It might return null.

IdentifierInfo * getIdentifier() const

Get the identifier that names this declaration, if there is one.

StringRef getName() const

Get the name of identifier for this declaration as a StringRef.

DeclarationName getDeclName() const

Get the actual, stored name of the declaration, which may be a special name.

std::string getQualifiedNameAsString() const

Stmt - This represents one statement.

The base class of the type hierarchy.

bool isBooleanType() const

bool isRValueReferenceType() const

bool isVoidPointerType() const

const SourceManager & getSourceManager() const

BugReporterVisitors are used to add custom diagnostics along a path.

Represents an abstract call to a function or method along a particular path.

virtual void printState(raw_ostream &Out, ProgramStateRef State, const char *NL, const char *Sep) const

See CheckerManager::runCheckersForPrintState.

const AnalyzerOptions & getAnalyzerOptions() const

CHECKER * registerChecker(AT &&... Args)

Used to register checkers.

void reportInvalidCheckerOptionValue(const CheckerBase *C, StringRef OptionName, StringRef ExpectedValueDesc) const

Emits an error through a DiagnosticsEngine about an invalid user supplied checker option value.

const ProgramStateRef & getState() const

pred_iterator pred_begin()

const Stmt * getStmtForDiagnostics() const

If the node's program point corresponds to a statement, retrieve that statement.

const LocationContext * getLocationContext() const

ExplodedNode * getFirstPred()

MemRegion - The root abstract class for all memory regions.

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemSpaceRegion * getMemorySpace() const

virtual bool isSubRegionOf(const MemRegion *R) const

Check if the region is a subregion of the given region.

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemRegion * getBaseRegion() const

const RegionTy * getAs() const

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemRegion * getMostDerivedObjectRegion() const

Recursively retrieve the region of the most derived class instance of regions of C++ base class insta...

static PathDiagnosticLocation createBegin(const Decl *D, const SourceManager &SM)

Create a location for the beginning of the declaration.

virtual const MemRegion * getOriginRegion() const

Find the region from which this symbol originates.

virtual QualType getType() const =0

A class responsible for cleaning up unused symbols.

bool isLiveRegion(const MemRegion *region)

const char *const CXXMoveSemantics

bool isMovedFrom(ProgramStateRef State, const MemRegion *Region)

Returns true if the object is known to have been recently std::moved.

llvm::DenseSet< SymbolRef > InvalidatedSymbols

std::shared_ptr< PathDiagnosticPiece > PathDiagnosticPieceRef

The JSON file list parser is used to communicate input to InstallAPI.

OverloadedOperatorKind

Enumeration specifying the different kinds of C++ overloaded operators.

bool operator==(const CallGraphNode::CallRecord &LHS, const CallGraphNode::CallRecord &RHS)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4