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

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

clang: lib/Analysis/ThreadSafety.cpp Source File

;

threadSafety;

*DeclExp, StringRef Kind) {

CapExprSet :

<CapabilityExpr, 4> {

CapE.

(CapE2);

FactEntryKind { Lockable, ScopedLockable };

FactEntryKind

: 8;

SourceKind Source : 8;

~FactEntry() =

;

FactEntryKind getFactEntryKind()

{

; }

asserted()

{

Source == Asserted; }

declared()

{

Source == Declared; }

managed()

{

Source == Managed; }

handleRemovalFromIntersection(

FactSet &FSet, FactManager &FactMan,

handleLock(FactSet &FSet, FactManager &FactMan,

FactEntry &entry,

handleUnlock(FactSet &FSet, FactManager &FactMan,

isAtLeast(

LK)

{

FactID =

short;

std::vector<std::unique_ptr<const FactEntry>> Facts;

FactID newFact(std::unique_ptr<FactEntry> Entry) {

Facts.push_back(std::move(Entry));

(Facts.size() - 1);

FactEntry &operator[](FactID F)

{

*Facts[F]; }

iterator = FactVec::iterator;

const_iterator = FactVec::const_iterator;

iterator begin() {

FactIDs.begin(); }

const_iterator begin()

{

FactIDs.begin(); }

iterator end() {

FactIDs.end(); }

const_iterator end()

{

FactIDs.end(); }

isEmpty()

{

FactIDs.size() == 0; }

isEmpty(FactManager &FactMan)

{

(

FID : *

) {

(!FactMan[FID].negative())

addLockByID(FactID ID) { FactIDs.push_back(ID); }

FactID addLock(FactManager &FM, std::unique_ptr<FactEntry> Entry) {

FactID F = FM.newFact(std::move(Entry));

FactIDs.push_back(F);

n = FactIDs.size();

(

i = 0; i < n-1; ++i) {

(FM[FactIDs[i]].

(CapE)) {

FactIDs[i] = FactIDs[n-1];

(FM[FactIDs[n-1]].

(CapE)) {

iterator findLockIter(FactManager &FM,

&CapE) {

std::find_if(begin(), end(), [&](FactID ID) {

FM[

].matches(CapE);

FactEntry *findLock(FactManager &FM,

&CapE)

{

I = std::find_if(begin(), end(), [&](FactID ID) {

FM[

].matches(CapE);

I != end() ? &FM[*I] :

;

FactEntry *findLockUniv(FactManager &FM,

I = std::find_if(begin(), end(), [&](FactID ID) ->

{

FM[

].matchesUniv(CapE);

I != end() ? &FM[*I] :

;

FactEntry *findPartialMatch(FactManager &FM,

I = std::find_if(begin(), end(), [&](FactID ID) ->

{

FM[

].partiallyMatches(CapE);

I != end() ? &FM[*I] :

;

containsMutexDecl(FactManager &FM,

* Vd)

{

I = std::find_if(begin(), end(), [&](FactID ID) ->

{

FM[

].valueDecl() == Vd;

ThreadSafetyAnalyzer;

threadSafety {

BeforeInfo() =

;

BeforeInfo(BeforeInfo &&) =

;

llvm::DenseMap<const ValueDecl *, std::unique_ptr<BeforeInfo>>;

CycleMap = llvm::DenseMap<const ValueDecl *, bool>;

ThreadSafetyAnalyzer& Analyzer);

ThreadSafetyAnalyzer &Analyzer);

ThreadSafetyAnalyzer& Analyzer,

LocalVariableMap;

LocalVarContext = llvm::ImmutableMap<const NamedDecl *, unsigned>;

CFGBlockSide { CBS_Entry, CBS_Exit };

LocalVarContext EntryContext;

LocalVarContext ExitContext;

Reachable =

;

FactSet &getSet(CFGBlockSide Side)

{

Side == CBS_Entry ? EntrySet : ExitSet;

Side == CBS_Entry ? EntryLoc : ExitLoc;

CFGBlockInfo(LocalVarContext EmptyCtx)

: EntryContext(EmptyCtx), ExitContext(EmptyCtx) {}

CFGBlockInfo getEmptyBlockInfo(LocalVariableMap &M);

LocalVariableMap {

Context = LocalVarContext;

VarDefinition {

LocalVariableMap;

*Exp =

;

isReference()

{

!Exp; }

:

(

), Exp(

), Ctx(

) {}

VarDefinition(

*

,

R, Context

)

:

(

), Ref(R), Ctx(

) {}

Context::Factory ContextFactory;

std::vector<VarDefinition> VarDefinitions;

std::vector<std::pair<const Stmt *, Context>> SavedContexts;

VarDefinitions.push_back(VarDefinition(

, 0u, getEmptyContext()));

VarDefinition* lookup(

*

, Context Ctx) {

*i = Ctx.lookup(

);

assert(*i < VarDefinitions.size());

&VarDefinitions[*i];

*

= Ctx.lookup(

);

(VarDefinitions[i].Exp) {

Ctx = VarDefinitions[i].Ctx;

VarDefinitions[i].Exp;

i = VarDefinitions[i].Ref;

Context getEmptyContext() {

ContextFactory.getEmptyMap(); }

Context getNextContext(

&CtxIndex,

*S, Context

) {

(SavedContexts[CtxIndex+1].first == S) {

Context Result = SavedContexts[CtxIndex].second;

dumpVarDefinitionName(

i) {

llvm::errs() <<

;

llvm::errs() <<

;

->printName(llvm::errs());

llvm::errs() <<

<< i <<

<< ((

*) Dec);

(

i = 1, e = VarDefinitions.size(); i < e; ++i) {

*Exp = VarDefinitions[i].Exp;

Ref = VarDefinitions[i].Ref;

dumpVarDefinitionName(i);

llvm::errs() <<

;

(Exp) Exp->

();

dumpVarDefinitionName(Ref);

llvm::errs() <<

;

dumpContext(Context

) {

(Context::iterator I =

.begin(),

=

.end(); I !=

; ++I) {

->printName(llvm::errs());

llvm::errs() <<

;

dumpVarDefinitionName(I.getData());

llvm::errs() <<

;

std::vector<CFGBlockInfo> &BlockInfo);

VarMapBuilder;

getContextIndex() {

SavedContexts.size()-1; }

saveContext(

*S, Context

) {

SavedContexts.push_back(std::make_pair(S,

));

Context addDefinition(

*

,

*Exp, Context Ctx) {

assert(!Ctx.contains(

));

newID = VarDefinitions.size();

Context NewCtx = ContextFactory.add(Ctx,

, newID);

VarDefinitions.push_back(VarDefinition(

, Exp, Ctx));

Context addReference(

*

,

i, Context Ctx) {

newID = VarDefinitions.size();

Context NewCtx = ContextFactory.add(Ctx,

, newID);

VarDefinitions.push_back(VarDefinition(

, i, Ctx));

Context updateDefinition(

*

,

*Exp, Context Ctx) {

(Ctx.contains(

)) {

newID = VarDefinitions.size();

Context NewCtx = ContextFactory.remove(Ctx,

);

NewCtx = ContextFactory.add(NewCtx,

, newID);

VarDefinitions.push_back(VarDefinition(

, Exp, Ctx));

Context clearDefinition(

*

, Context Ctx) {

Context NewCtx = Ctx;

(NewCtx.contains(

)) {

NewCtx = ContextFactory.remove(NewCtx,

);

NewCtx = ContextFactory.add(NewCtx,

, 0);

Context removeDefinition(

*

, Context Ctx) {

Context NewCtx = Ctx;

(NewCtx.contains(

)) {

NewCtx = ContextFactory.remove(NewCtx,

);

Context intersectContexts(Context C1, Context C2);

Context createReferenceContext(Context

);

intersectBackEdge(Context C1, Context C2);

CFGBlockInfo CFGBlockInfo::getEmptyBlockInfo(LocalVariableMap &M) {

CFGBlockInfo(M.getEmptyContext());

LocalVariableMap* VMap;

LocalVariableMap::Context Ctx;

VarMapBuilder(LocalVariableMap *VM, LocalVariableMap::Context

)

: VMap(VM), Ctx(

) {}

VisitDeclStmt(

*S);

VarMapBuilder::VisitDeclStmt(

*S) {

modifiedCtx =

;

(

*

: DGrp) {

(

*VD = dyn_cast_or_null<VarDecl>(

)) {

*

= VD->getInit();

(

.isTrivialType(VD->getASTContext())) {

Ctx = VMap->addDefinition(VD,

, Ctx);

VMap->saveContext(S, Ctx);

VarMapBuilder::VisitBinaryOperator(

*BO) {

(

*DRE = dyn_cast<DeclRefExpr>(LHSExp)) {

(Ctx.lookup(VDec)) {

Ctx = VMap->updateDefinition(VDec, BO->

(), Ctx);

Ctx = VMap->clearDefinition(VDec, Ctx);

VMap->saveContext(BO, Ctx);

LocalVariableMap::Context

LocalVariableMap::intersectContexts(Context C1, Context C2) {

(

&

: C1) {

*i2 = C2.lookup(Dec);

Result = removeDefinition(Dec, Result);

(*i2 !=

.second)

Result = clearDefinition(Dec, Result);

LocalVariableMap::Context LocalVariableMap::createReferenceContext(Context

) {

Context Result = getEmptyContext();

(

&

:

)

Result = addReference(

.first,

.second, Result);

LocalVariableMap::intersectBackEdge(Context C1, Context C2) {

(

&

: C1) {

i1 =

.second;

VarDefinition *VDef = &VarDefinitions[i1];

assert(VDef->isReference());

*i2 = C2.lookup(

.first);

(!i2 || (*i2 != i1))

LocalVariableMap::traverseCFG(

*CFGraph,

std::vector<CFGBlockInfo> &BlockInfo) {

(

*CurrBlock : *SortedGraph) {

CurrBlockID = CurrBlock->getBlockID();

CFGBlockInfo *CurrBlockInfo = &BlockInfo[CurrBlockID];

VisitedBlocks.insert(CurrBlock);

HasBackEdges =

;

CtxInit =

;

PE = CurrBlock->pred_end(); PI != PE; ++PI) {

(*PI ==

|| !VisitedBlocks.alreadySet(*PI)) {

HasBackEdges =

;

PrevBlockID = (*PI)->getBlockID();

CFGBlockInfo *PrevBlockInfo = &BlockInfo[PrevBlockID];

CurrBlockInfo->EntryContext = PrevBlockInfo->ExitContext;

CurrBlockInfo->EntryContext =

intersectContexts(CurrBlockInfo->EntryContext,

PrevBlockInfo->ExitContext);

CurrBlockInfo->EntryContext =

createReferenceContext(CurrBlockInfo->EntryContext);

saveContext(

, CurrBlockInfo->EntryContext);

CurrBlockInfo->EntryIndex = getContextIndex();

VarMapBuilder VMapBuilder(

, CurrBlockInfo->EntryContext);

(

&BI : *CurrBlock) {

(BI.getKind()) {

VMapBuilder.Visit(CS.

());

CurrBlockInfo->ExitContext = VMapBuilder.Ctx;

SE = CurrBlock->succ_end(); SI != SE; ++SI) {

(*SI ==

|| !VisitedBlocks.alreadySet(*SI))

Context LoopBegin = BlockInfo[FirstLoopBlock->

()].EntryContext;

Context LoopEnd = CurrBlockInfo->ExitContext;

intersectBackEdge(LoopBegin, LoopEnd);

saveContext(

, BlockInfo[exitID].ExitContext);

std::vector<CFGBlockInfo> &BlockInfo) {

(

*CurrBlock : *SortedGraph) {

CFGBlockInfo *CurrBlockInfo = &BlockInfo[CurrBlock->getBlockID()];

(

*S = CurrBlock->getTerminatorStmt()) {

CurrBlockInfo->EntryLoc = CurrBlockInfo->ExitLoc = S->getBeginLoc();

BE = CurrBlock->rend(); BI != BE; ++BI) {

(std::optional<CFGStmt> CS = BI->getAs<

>()) {

CurrBlockInfo->ExitLoc = CS->getStmt()->getBeginLoc();

(CurrBlockInfo->ExitLoc.isValid()) {

(

&BI : *CurrBlock) {

(std::optional<CFGStmt> CS = BI.getAs<

>()) {

CurrBlockInfo->EntryLoc = CS->getStmt()->getBeginLoc();

}

(CurrBlock->pred_size() == 1 && *CurrBlock->pred_begin() &&

CurrBlock != &CFGraph->

()) {

CurrBlockInfo->EntryLoc = CurrBlockInfo->ExitLoc =

BlockInfo[(*CurrBlock->pred_begin())->getBlockID()].ExitLoc;

}

(CurrBlock->succ_size() == 1 && *CurrBlock->succ_begin()) {

CurrBlockInfo->EntryLoc = CurrBlockInfo->ExitLoc =

BlockInfo[(*CurrBlock->succ_begin())->getBlockID()].EntryLoc;

LockableFactEntry :

FactEntry {

SourceKind Src = Acquired)

: FactEntry(Lockable, CE, LK,

, Src) {}

handleRemovalFromIntersection(

FactSet &FSet, FactManager &FactMan,

(!asserted() && !negative() && !isUniversal()) {

handleLock(FactSet &FSet, FactManager &FactMan,

FactEntry &entry,

handleUnlock(FactSet &FSet, FactManager &FactMan,

FSet.removeLock(FactMan, Cp);

FSet.addLock(FactMan, std::make_unique<LockableFactEntry>(

classof(

FactEntry *A) {

A->getFactEntryKind() == Lockable;

ScopedLockableFactEntry :

FactEntry {

UnderlyingCapabilityKind {

UCK_ReleasedExclusive,

UnderlyingCapability {

UnderlyingCapabilityKind

;

CapExprSet getUnderlyingMutexes()

{

CapExprSet UnderlyingMutexesSet;

(

UnderlyingCapability &UnderlyingMutex : UnderlyingMutexes)

UnderlyingMutexesSet.push_back(UnderlyingMutex.Cap);

UnderlyingMutexesSet;

UnderlyingMutexes.push_back(UnderlyingCapability{M, UCK_Acquired});

UnderlyingMutexes.push_back(UnderlyingCapability{M, UCK_ReleasedExclusive});

UnderlyingMutexes.push_back(UnderlyingCapability{M, UCK_ReleasedShared});

handleRemovalFromIntersection(

FactSet &FSet, FactManager &FactMan,

(

&UnderlyingMutex : UnderlyingMutexes) {

*Entry = FSet.findLock(FactMan, UnderlyingMutex.Cap);

((UnderlyingMutex.Kind == UCK_Acquired && Entry) ||

(UnderlyingMutex.Kind != UCK_Acquired && !Entry)) {

UnderlyingMutex.Cap.toString(), loc(),

handleLock(FactSet &FSet, FactManager &FactMan,

FactEntry &entry,

(

&UnderlyingMutex : UnderlyingMutexes) {

(UnderlyingMutex.Kind == UCK_Acquired)

lock(FSet, FactMan, UnderlyingMutex.Cap, entry.kind(), entry.loc(),

unlock(FSet, FactMan, UnderlyingMutex.Cap, entry.loc(), &Handler);

handleUnlock(FactSet &FSet, FactManager &FactMan,

assert(!Cp.

() &&

);

(

&UnderlyingMutex : UnderlyingMutexes) {

(UnderlyingMutex.Kind == UCK_Acquired) {

unlock(FSet, FactMan, UnderlyingMutex.Cap, UnlockLoc, TSHandler);

= UnderlyingMutex.Kind == UCK_ReleasedShared

lock(FSet, FactMan, UnderlyingMutex.Cap, kind, UnlockLoc, TSHandler);

FSet.removeLock(FactMan, Cp);

classof(

FactEntry *A) {

A->getFactEntryKind() == ScopedLockable;

lock(FactSet &FSet, FactManager &FactMan,

&Cp,

(

FactEntry *Fact = FSet.findLock(FactMan, Cp)) {

FSet.removeLock(FactMan, !Cp);

FSet.addLock(FactMan,

std::make_unique<LockableFactEntry>(Cp, kind, loc, Managed));

unlock(FactSet &FSet, FactManager &FactMan,

&Cp,

(FSet.findLock(FactMan, Cp)) {

FSet.removeLock(FactMan, Cp);

FSet.addLock(FactMan, std::make_unique<LockableFactEntry>(

}

(Handler) {

(

FactEntry *Neg = FSet.findLock(FactMan, !Cp))

PrevLoc =

->loc();

ThreadSafetyAnalyzer {

BuildLockset;

llvm::BumpPtrAllocator Bpa;

LocalVariableMap LocalVarMap;

llvm::SmallDenseMap<const Expr *, til::LiteralPtr *> ConstructedObjects;

FactManager FactMan;

std::vector<CFGBlockInfo> BlockInfo;

: Arena(&Bpa), SxBuilder(Arena), Handler(H), GlobalBeforeSet(Bset) {}

addLock(FactSet &FSet, std::unique_ptr<FactEntry> Entry,

ReqAttr =

);

<

AttrType>

getMutexIDs(CapExprSet &Mtxs, AttrType *

,

*Exp,

<

AttrType>

getMutexIDs(CapExprSet &Mtxs, AttrType *

,

*Exp,

*BrE,

Neg);

* getTrylockCallExpr(

*Cond, LocalVarContext

,

getEdgeLockset(FactSet &Result,

FactSet &ExitSet,

join(

FactEntry &a,

FactEntry &

,

CanModify);

intersectAndWarn(FactSet &EntrySet,

FactSet &ExitSet,

intersectAndWarn(FactSet &EntrySet,

FactSet &ExitSet,

intersectAndWarn(EntrySet, ExitSet, JoinLoc, LEK, LEK);

warnIfMutexNotHeld(

FactSet &FSet,

*

,

warnIfMutexHeld(

FactSet &FSet,

*

,

*Exp,

checkAccess(

FactSet &FSet,

*Exp,

AK,

checkPtAccess(

FactSet &FSet,

*Exp,

AK,

ThreadSafetyAnalyzer& Analyzer) {

BeforeInfo *Info =

;

std::unique_ptr<BeforeInfo> &InfoPtr = BMap[Vd];

InfoPtr.reset(

BeforeInfo());

Info = InfoPtr.get();

(

*At : Vd->

()) {

(At->getKind()) {

attr::AcquiredBefore: {

*A = cast<AcquiredBeforeAttr>(At);

(

*Arg : A->args()) {

Analyzer.SxBuilder.translateAttrExpr(Arg,

);

Info->Vect.push_back(Cpvd);

It = BMap.find(Cpvd);

(It == BMap.end())

attr::AcquiredAfter: {

*A = cast<AcquiredAfterAttr>(At);

(

*Arg : A->args()) {

Analyzer.SxBuilder.translateAttrExpr(Arg,

);

ArgInfo->Vect.push_back(Vd);

BeforeSet::BeforeInfo *

ThreadSafetyAnalyzer &Analyzer) {

It = BMap.find(Vd);

BeforeInfo *Info =

;

(It == BMap.end())

Info = It->second.get();

assert(Info &&

);

FactSet& FSet,

ThreadSafetyAnalyzer& Analyzer,

(Info->Visited == 1)

(Info->Visited == 2)

(Info->Vect.empty())

InfoVect.push_back(Info);

(

*Vdb : Info->Vect) {

(FSet.containsMutexDecl(Analyzer.FactMan, Vdb)) {

StringRef L1 = StartVd->

();

StringRef L2 = Vdb->getName();

Analyzer.Handler.handleLockAcquiredBefore(CapKind, L1, L2,

);

(CycMap.try_emplace(Vd,

).second) {

StringRef L1 = Vd->

();

Analyzer.Handler.handleBeforeAfterCycle(L1, Vd->

());

(

*Info : InfoVect)

(

*CE = dyn_cast<ImplicitCastExpr>(Exp))

(

*DR = dyn_cast<DeclRefExpr>(Exp))

DR->getDecl();

(

*ME = dyn_cast<MemberExpr>(Exp))

ME->getMemberDecl();

<

Ty>

has_arg_iterator_range {

yes =

[1];

no =

[2];

<

Inner>

yes& test(Inner *I,

(I->args()) * =

);

<

>

no& test(...);

value =

(test<Ty>(

)) ==

(yes);

ThreadSafetyAnalyzer::inCurrentScope(

&CapE) {

assert(SExp &&

);

(

*LP = dyn_cast<til::LiteralPtr>(SExp)) {

(

*

= dyn_cast<til::Project>(SExp)) {

(!isa_and_nonnull<CXXMethodDecl>(CurrentFunction))

ThreadSafetyAnalyzer::addLock(FactSet &FSet,

std::unique_ptr<FactEntry> Entry,

(Entry->shouldIgnore())

(!ReqAttr && !Entry->negative()) {

FactEntry *Nen = FSet.findLock(FactMan, NegC);

FSet.removeLock(FactMan, NegC);

(inCurrentScope(*Entry) && !Entry->asserted())

!Entry->asserted() && !Entry->declared()) {

GlobalBeforeSet->checkBeforeAfter(Entry->valueDecl(), FSet, *

,

Entry->loc(), Entry->getKind());

(

FactEntry *Cp = FSet.findLock(FactMan, *Entry)) {

(!Entry->asserted())

Cp->handleLock(FSet, FactMan, *Entry, Handler);

FSet.addLock(FactMan, std::move(Entry));

ThreadSafetyAnalyzer::removeLock(FactSet &FSet,

&Cp,

FullyRemove,

ReceivedKind) {

FactEntry *LDat = FSet.findLock(FactMan, Cp);

(

FactEntry *Neg = FSet.findLock(FactMan, !Cp))

PrevLoc =

->loc();

(ReceivedKind !=

&& LDat->kind() != ReceivedKind) {

ReceivedKind, LDat->loc(), UnlockLoc);

LDat->handleUnlock(FSet, FactMan, Cp, UnlockLoc, FullyRemove, Handler);

<

AttrType>

ThreadSafetyAnalyzer::getMutexIDs(CapExprSet &Mtxs, AttrType *

,

(

->args_size() == 0) {

Mtxs.push_back_nodup(Cp);

(

*Arg :

->args()) {

Mtxs.push_back_nodup(Cp);

<

AttrType>

ThreadSafetyAnalyzer::getMutexIDs(CapExprSet &Mtxs, AttrType *

,

*BrE,

Neg) {

branch =

;

(

*BLE = dyn_cast_or_null<CXXBoolLiteralExpr>(BrE))

branch = BLE->getValue();

(

*ILE = dyn_cast_or_null<IntegerLiteral>(BrE))

branch = ILE->getValue().getBoolValue();

branchnum = branch ? 0 : 1;

branchnum = !branchnum;

SE = PredBlock->

(); SI != SE && i < 2; ++SI, ++i) {

(*SI == CurrBlock && i == branchnum)

getMutexIDs(Mtxs,

, Exp,

);

(isa<CXXNullPtrLiteralExpr>(

) || isa<GNUNullExpr>(

)) {

}

(

*BLE = dyn_cast<CXXBoolLiteralExpr>(

)) {

TCond = BLE->getValue();

}

(

*ILE = dyn_cast<IntegerLiteral>(

)) {

TCond = ILE->getValue().getBoolValue();

}

(

*CE = dyn_cast<ImplicitCastExpr>(

))

* ThreadSafetyAnalyzer::getTrylockCallExpr(

*Cond,

(

*CallExp = dyn_cast<CallExpr>(Cond)) {

(CallExp->getBuiltinCallee() == Builtin::BI__builtin_expect)

getTrylockCallExpr(CallExp->getArg(0),

, Negate);

(

*PE = dyn_cast<ParenExpr>(Cond))

getTrylockCallExpr(PE->getSubExpr(),

, Negate);

(

*CE = dyn_cast<ImplicitCastExpr>(Cond))

getTrylockCallExpr(CE->getSubExpr(),

, Negate);

(

*FE = dyn_cast<FullExpr>(Cond))

getTrylockCallExpr(FE->getSubExpr(),

, Negate);

(

*DRE = dyn_cast<DeclRefExpr>(Cond)) {

*

= LocalVarMap.lookupExpr(DRE->getDecl(),

);

getTrylockCallExpr(

,

, Negate);

(

*UOP = dyn_cast<UnaryOperator>(Cond)) {

(UOP->getOpcode() == UO_LNot) {

getTrylockCallExpr(UOP->getSubExpr(),

, Negate);

(

*BOP = dyn_cast<BinaryOperator>(Cond)) {

(BOP->getOpcode() == BO_EQ || BOP->getOpcode() == BO_NE) {

(BOP->getOpcode() == BO_NE)

TCond =

;

(!TCond) Negate = !Negate;

getTrylockCallExpr(BOP->getLHS(),

, Negate);

(!TCond) Negate = !Negate;

getTrylockCallExpr(BOP->getRHS(),

, Negate);

(BOP->getOpcode() == BO_LAnd) {

getTrylockCallExpr(BOP->getRHS(),

, Negate);

(BOP->getOpcode() == BO_LOr)

getTrylockCallExpr(BOP->getRHS(),

, Negate);

}

(

*COP = dyn_cast<ConditionalOperator>(Cond)) {

(TCond && !FCond)

getTrylockCallExpr(COP->getCond(),

, Negate);

(!TCond && FCond) {

getTrylockCallExpr(COP->getCond(),

, Negate);

ThreadSafetyAnalyzer::getEdgeLockset(FactSet&

,

FactSet &ExitSet,

Negate =

;

CFGBlockInfo *PredBlockInfo = &BlockInfo[PredBlock->

()];

LocalVarContext &LVarCtx = PredBlockInfo->ExitContext;

*Exp = getTrylockCallExpr(Cond, LVarCtx, Negate);

*FunDecl = dyn_cast_or_null<NamedDecl>(Exp->getCalleeDecl());

(!FunDecl || !FunDecl->hasAttrs())

CapExprSet ExclusiveLocksToAdd;

CapExprSet SharedLocksToAdd;

(

*

: FunDecl->attrs()) {

attr::TryAcquireCapability: {

*A = cast<TryAcquireCapabilityAttr>(

);

getMutexIDs(A->isShared() ? SharedLocksToAdd : ExclusiveLocksToAdd, A,

Exp, FunDecl, PredBlock, CurrBlock, A->getSuccessValue(),

attr::ExclusiveTrylockFunction: {

*A = cast<ExclusiveTrylockFunctionAttr>(

);

getMutexIDs(ExclusiveLocksToAdd, A, Exp, FunDecl, PredBlock, CurrBlock,

A->getSuccessValue(), Negate);

attr::SharedTrylockFunction: {

*A = cast<SharedTrylockFunctionAttr>(

);

getMutexIDs(SharedLocksToAdd, A, Exp, FunDecl, PredBlock, CurrBlock,

A->getSuccessValue(), Negate);

(

&ExclusiveLockToAdd : ExclusiveLocksToAdd)

addLock(

, std::make_unique<LockableFactEntry>(ExclusiveLockToAdd,

(

&SharedLockToAdd : SharedLocksToAdd)

addLock(

, std::make_unique<LockableFactEntry>(SharedLockToAdd,

ThreadSafetyAnalyzer;

ThreadSafetyAnalyzer *Analyzer;

FactSet &FunctionExitFSet;

LocalVariableMap::Context LVarCtx;

Analyzer->checkAccess(FSet, Exp, AK, POK);

Analyzer->checkPtAccess(FSet, Exp, AK, POK);

SkipFirstParam =

);

BuildLockset(ThreadSafetyAnalyzer *Anlzr, CFGBlockInfo &Info,

FactSet &FunctionExitFSet)

FunctionExitFSet(FunctionExitFSet), LVarCtx(Info.EntryContext),

CtxIndex(Info.EntryIndex) {}

VisitCastExpr(

*CE);

VisitCallExpr(

*Exp);

VisitDeclStmt(

*S);

ThreadSafetyAnalyzer::warnIfMutexNotHeld(

FactEntry *LDat = FSet.findLock(FactMan, !Cp);

(!Cp).toString(),

);

(!inCurrentScope(Cp))

LDat = FSet.findLock(FactMan, Cp);

FactEntry *LDat = FSet.findLockUniv(FactMan, Cp);

NoError =

;

LDat = FSet.findPartialMatch(FactMan, Cp);

std::string PartMatchStr = LDat->toString();

StringRef PartMatchName(PartMatchStr);

(NoError && LDat && !LDat->isAtLeast(LK)) {

ThreadSafetyAnalyzer::warnIfMutexHeld(

FactSet &FSet,

FactEntry *LDat = FSet.findLock(FactMan, Cp);

ThreadSafetyAnalyzer::checkAccess(

FactSet &FSet,

*Exp,

(

*DRE = dyn_cast<DeclRefExpr>(Exp)) {

*VD = dyn_cast<VarDecl>(DRE->getDecl()->getCanonicalDecl());

(

*

= VD->getInit()) {

(

*UO = dyn_cast<UnaryOperator>(Exp)) {

(UO->getOpcode() == UO_Deref)

checkPtAccess(FSet, UO->getSubExpr(), AK, POK);

(

*BO = dyn_cast<BinaryOperator>(Exp)) {

checkAccess(FSet, BO->

(), AK, POK);

checkPtAccess(FSet, BO->

(), AK, POK);

(

*AE = dyn_cast<ArraySubscriptExpr>(Exp)) {

checkPtAccess(FSet, AE->getLHS(), AK, POK);

(

*ME = dyn_cast<MemberExpr>(Exp)) {

checkPtAccess(FSet, ME->getBase(), AK, POK);

checkAccess(FSet, ME->getBase(), AK, POK);

(

->

<GuardedVarAttr>() && FSet.isEmpty(FactMan)) {

warnIfMutexNotHeld(FSet,

, Exp, AK, I->getArg(), POK,

,

);

ThreadSafetyAnalyzer::checkPtAccess(

FactSet &FSet,

*Exp,

(

*PE = dyn_cast<ParenExpr>(Exp)) {

Exp = PE->getSubExpr();

(

*CE = dyn_cast<CastExpr>(Exp)) {

(CE->getCastKind() == CK_ArrayToPointerDecay) {

checkAccess(FSet, CE->getSubExpr(), AK, POK);

Exp = CE->getSubExpr();

(

->

<PtGuardedVarAttr>() && FSet.isEmpty(FactMan))

warnIfMutexNotHeld(FSet,

, Exp, AK, I->getArg(), PtPOK,

,

BuildLockset::handleCall(

*Exp,

*

,

CapExprSet ExclusiveLocksToAdd, SharedLocksToAdd;

CapExprSet ExclusiveLocksToRemove, SharedLocksToRemove, GenericLocksToRemove;

CapExprSet ScopedReqsAndExcludes;

std::pair<til::LiteralPtr *, StringRef> Placeholder =

Analyzer->SxBuilder.createThisPlaceholder(Exp);

[[maybe_unused]]

inserted =

Analyzer->ConstructedObjects.insert({Exp, Placeholder.first});

assert(inserted.second &&

);

(isa<CXXConstructExpr>(Exp))

= Placeholder.first;

(TagT->getDecl()->hasAttr<ScopedLockableAttr>())

Scp =

(Placeholder.first, Placeholder.second,

);

(At->getKind()) {

attr::AcquireCapability: {

*A = cast<AcquireCapabilityAttr>(At);

Analyzer->getMutexIDs(A->isShared() ? SharedLocksToAdd

: ExclusiveLocksToAdd,

attr::AssertExclusiveLock: {

*A = cast<AssertExclusiveLockAttr>(At);

CapExprSet AssertLocks;

Analyzer->getMutexIDs(AssertLocks, A, Exp,

,

);

(

&AssertLock : AssertLocks)

FSet, std::make_unique<LockableFactEntry>(

attr::AssertSharedLock: {

*A = cast<AssertSharedLockAttr>(At);

CapExprSet AssertLocks;

Analyzer->getMutexIDs(AssertLocks, A, Exp,

,

);

(

&AssertLock : AssertLocks)

FSet, std::make_unique<LockableFactEntry>(

attr::AssertCapability: {

*A = cast<AssertCapabilityAttr>(At);

CapExprSet AssertLocks;

Analyzer->getMutexIDs(AssertLocks, A, Exp,

,

);

(

&AssertLock : AssertLocks)

Analyzer->addLock(FSet, std::make_unique<LockableFactEntry>(

, FactEntry::Asserted));

attr::ReleaseCapability: {

*A = cast<ReleaseCapabilityAttr>(At);

Analyzer->getMutexIDs(GenericLocksToRemove, A, Exp,

,

);

(A->isShared())

Analyzer->getMutexIDs(SharedLocksToRemove, A, Exp,

,

);

Analyzer->getMutexIDs(ExclusiveLocksToRemove, A, Exp,

,

);

attr::RequiresCapability: {

*A = cast<RequiresCapabilityAttr>(At);

(

*Arg : A->args()) {

Analyzer->warnIfMutexNotHeld(FSet,

, Exp,

Analyzer->getMutexIDs(ScopedReqsAndExcludes, A, Exp,

,

);

attr::LocksExcluded: {

*A = cast<LocksExcludedAttr>(At);

(

*Arg : A->args()) {

Analyzer->warnIfMutexHeld(FSet,

, Exp, Arg,

,

);

Analyzer->getMutexIDs(ScopedReqsAndExcludes, A, Exp,

,

);

std::optional<CallExpr::const_arg_range> Args;

(

*CE = dyn_cast<CallExpr>(Exp))

Args = CE->arguments();

(

*CE = dyn_cast<CXXConstructExpr>(Exp))

Args = CE->arguments();

llvm_unreachable(

);

*CalledFunction = dyn_cast<FunctionDecl>(

);

(CalledFunction && Args.has_value()) {

(

[Param, Arg] : zip(CalledFunction->parameters(), *Args)) {

CapExprSet DeclaredLocks;

(

*At : Param->attrs()) {

(At->getKind()) {

attr::AcquireCapability: {

*A = cast<AcquireCapabilityAttr>(At);

Analyzer->getMutexIDs(A->isShared() ? SharedLocksToAdd

: ExclusiveLocksToAdd,

Analyzer->getMutexIDs(DeclaredLocks, A, Exp,

,

);

attr::ReleaseCapability: {

*A = cast<ReleaseCapabilityAttr>(At);

Analyzer->getMutexIDs(GenericLocksToRemove, A, Exp,

,

);

(A->isShared())

Analyzer->getMutexIDs(SharedLocksToRemove, A, Exp,

,

);

Analyzer->getMutexIDs(ExclusiveLocksToRemove, A, Exp,

,

);

Analyzer->getMutexIDs(DeclaredLocks, A, Exp,

,

);

attr::RequiresCapability: {

*A = cast<RequiresCapabilityAttr>(At);

(

*Arg : A->args())

Analyzer->warnIfMutexNotHeld(FSet,

, Exp,

Analyzer->getMutexIDs(DeclaredLocks, A, Exp,

,

);

attr::LocksExcluded: {

*A = cast<LocksExcludedAttr>(At);

(

*Arg : A->args())

Analyzer->warnIfMutexHeld(FSet,

, Exp, Arg,

,

);

Analyzer->getMutexIDs(DeclaredLocks, A, Exp,

,

);

(DeclaredLocks.empty())

StringRef(

),

);

(

*CBTE = dyn_cast<CXXBindTemporaryExpr>(Arg->IgnoreCasts());

(

Object = Analyzer->ConstructedObjects.find(CBTE->getSubExpr());

Object != Analyzer->ConstructedObjects.end())

FactEntry *Fact = FSet.findLock(Analyzer->FactMan, Cp);

*

= cast<ScopedLockableFactEntry>(Fact);

(

&[a,

] :

zip_longest(DeclaredLocks,

->getUnderlyingMutexes())) {

(!a.has_value()) {

Analyzer->Handler.handleExpectFewerUnderlyingMutexes(

.value().getKind(),

.value().toString());

}

(!

.has_value()) {

Analyzer->Handler.handleExpectMoreUnderlyingMutexes(

a.value().getKind(), a.value().toString());

}

(!a.value().equals(

.value())) {

Analyzer->Handler.handleUnmatchedUnderlyingMutexes(

a.value().getKind(), a.value().toString(),

.value().toString());

Dtor = isa<CXXDestructorDecl>(

);

(

&M : ExclusiveLocksToRemove)

(

&M : SharedLocksToRemove)

(

&M : GenericLocksToRemove)

FactEntry::SourceKind Source =

!Scp.

() ? FactEntry::Managed : FactEntry::Acquired;

(

&M : ExclusiveLocksToAdd)

Analyzer->addLock(FSet, std::make_unique<LockableFactEntry>(M,

,

(

&M : SharedLocksToAdd)

FSet, std::make_unique<LockableFactEntry>(M,

,

, Source));

ScopedEntry = std::make_unique<ScopedLockableFactEntry>(

Scp,

, FactEntry::Acquired);

(

&M : ExclusiveLocksToAdd)

ScopedEntry->addLock(M);

(

&M : SharedLocksToAdd)

ScopedEntry->addLock(M);

(

&M : ScopedReqsAndExcludes)

ScopedEntry->addLock(M);

(

&M : ExclusiveLocksToRemove)

ScopedEntry->addExclusiveUnlock(M);

(

&M : SharedLocksToRemove)

ScopedEntry->addSharedUnlock(M);

Analyzer->addLock(FSet, std::move(ScopedEntry));

BuildLockset::VisitUnaryOperator(

*UO) {

BuildLockset::VisitBinaryOperator(

*BO) {

LVarCtx = Analyzer->LocalVarMap.getNextContext(CtxIndex, BO, LVarCtx);

BuildLockset::VisitCastExpr(

*CE) {

BuildLockset::examineArguments(

*FD,

SkipFirstParam) {

(FD->

<NoThreadSafetyAnalysisAttr>())

Param = Params.begin();

(

Arg = ArgBegin; Param != Params.end() && Arg != ArgEnd;

BuildLockset::VisitCallExpr(

*Exp) {

(

*CE = dyn_cast<CXXMemberCallExpr>(Exp)) {

*ME = dyn_cast<MemberExpr>(CE->getCallee());

(ME->isArrow()) {

checkPtAccess(CE->getImplicitObjectArgument(),

);

checkAccess(CE->getImplicitObjectArgument(),

);

examineArguments(CE->getDirectCallee(), CE->arg_begin(), CE->arg_end());

}

(

*OE = dyn_cast<CXXOperatorCallExpr>(Exp)) {

OO_PercentEqual:

OO_LessLessEqual:

OO_GreaterGreaterEqual:

checkAccess(OE->getArg(1),

);

(!(OEop == OO_Star && OE->getNumArgs() > 1)) {

checkPtAccess(OE->getArg(0),

);

*Obj = OE->getArg(0);

examineArguments(FD, std::next(OE->arg_begin()), OE->arg_end(),

!isa<CXXMethodDecl>(FD));

handleCall(Exp,

);

(

&&

->isCopyConstructor()) {

checkAccess(Source,

);

handleCall(Exp,

);

(

*CE = dyn_cast<CastExpr>(

))

(

*CE = dyn_cast<CastExpr>(

))

(CE->

() == CK_ConstructorConversion ||

(

*BTE = dyn_cast<CXXBindTemporaryExpr>(

))

= BTE->getSubExpr();

BuildLockset::VisitDeclStmt(

*S) {

LVarCtx = Analyzer->LocalVarMap.getNextContext(CtxIndex, S, LVarCtx);

(

*

: S->getDeclGroup()) {

(

*VD = dyn_cast_or_null<VarDecl>(

)) {

*

= VD->getInit();

(

*EWC = dyn_cast<ExprWithCleanups>(

))

(

Object = Analyzer->ConstructedObjects.find(

);

Object != Analyzer->ConstructedObjects.end()) {

->second->setClangDecl(VD);

Analyzer->ConstructedObjects.erase(Object);

BuildLockset::VisitMaterializeTemporaryExpr(

(

Object = Analyzer->ConstructedObjects.find(

Object != Analyzer->ConstructedObjects.end()) {

->second->setClangDecl(ExtD);

Analyzer->ConstructedObjects.erase(Object);

BuildLockset::VisitReturnStmt(

*S) {

(Analyzer->CurrentFunction ==

)

*RetVal = S->getRetValue();

Analyzer->CurrentFunction->getReturnType().getCanonicalType();

Analyzer->checkAccess(

FunctionExitFSet, RetVal,

ThreadSafetyAnalyzer::join(

FactEntry &A,

FactEntry &B,

(A.kind() != B.kind()) {

((A.managed() || A.asserted()) && (B.managed() || B.asserted())) {

ShouldTakeB = B.kind() ==

;

(CanModify || !ShouldTakeB)

CanModify && A.asserted() && !B.asserted();

ThreadSafetyAnalyzer::intersectAndWarn(FactSet &EntrySet,

FactSet &ExitSet,

FactSet EntrySetOrig = EntrySet;

(

&Fact : ExitSet) {

FactEntry &ExitFact = FactMan[Fact];

FactSet::iterator EntryIt = EntrySet.findLockIter(FactMan, ExitFact);

(EntryIt != EntrySet.end()) {

(join(FactMan[*EntryIt], ExitFact,

ExitFact.handleRemovalFromIntersection(ExitSet, FactMan, JoinLoc,

(

&Fact : EntrySetOrig) {

FactEntry *EntryFact = &FactMan[Fact];

FactEntry *ExitFact = ExitSet.findLock(FactMan, *EntryFact);

EntryFact->handleRemovalFromIntersection(EntrySetOrig, FactMan, JoinLoc,

EntrySet.removeLock(FactMan, *EntryFact);

(std::optional<CFGStmt> S =

.getAs<

>()) {

(isa<CXXThrowExpr>(S->getStmt()))

(!walker.

(AC))

CurrentFunction = dyn_cast<FunctionDecl>(

);

(

->

<NoThreadSafetyAnalysisAttr>())

(isa<CXXConstructorDecl>(

))

(isa<CXXDestructorDecl>(

))

CFGBlockInfo::getEmptyBlockInfo(LocalVarMap));

Initial.Reachable =

;

LocalVarMap.traverseCFG(CFGraph, SortedGraph, BlockInfo);

CapExprSet ExclusiveLocksAcquired;

CapExprSet SharedLocksAcquired;

CapExprSet LocksReleased;

(!SortedGraph->

()) {

FactSet &InitialLockset = Initial.EntrySet;

CapExprSet ExclusiveLocksToAdd;

CapExprSet SharedLocksToAdd;

(

*A = dyn_cast<RequiresCapabilityAttr>(

)) {

getMutexIDs(A->isShared() ? SharedLocksToAdd : ExclusiveLocksToAdd, A,

}

(

*A = dyn_cast<ReleaseCapabilityAttr>(

)) {

(A->args_size() == 0)

getMutexIDs(A->isShared() ? SharedLocksToAdd : ExclusiveLocksToAdd, A,

getMutexIDs(LocksReleased, A,

,

);

}

(

*A = dyn_cast<AcquireCapabilityAttr>(

)) {

(A->args_size() == 0)

getMutexIDs(A->isShared() ? SharedLocksAcquired

: ExclusiveLocksAcquired,

}

(isa<ExclusiveTrylockFunctionAttr>(

)) {

}

(isa<SharedTrylockFunctionAttr>(

)) {

}

(isa<TryAcquireCapabilityAttr>(

)) {

(CurrentFunction)

(

CurrentMethod = dyn_cast<ObjCMethodDecl>(

))

Params = CurrentMethod->getCanonicalDecl()->parameters();

llvm_unreachable(

);

CapExprSet UnderlyingLocks;

(

*

: Param->attrs()) {

(

*A = dyn_cast<ReleaseCapabilityAttr>(

)) {

getMutexIDs(A->isShared() ? SharedLocksToAdd : ExclusiveLocksToAdd, A,

getMutexIDs(LocksReleased, A,

, Param);

getMutexIDs(UnderlyingLocks, A,

, Param);

}

(

*A = dyn_cast<RequiresCapabilityAttr>(

)) {

getMutexIDs(A->isShared() ? SharedLocksToAdd : ExclusiveLocksToAdd, A,

getMutexIDs(UnderlyingLocks, A,

, Param);

}

(

*A = dyn_cast<AcquireCapabilityAttr>(

)) {

getMutexIDs(A->isShared() ? SharedLocksAcquired

: ExclusiveLocksAcquired,

A,

, Param);

getMutexIDs(UnderlyingLocks, A,

, Param);

}

(

*A = dyn_cast<LocksExcludedAttr>(

)) {

getMutexIDs(UnderlyingLocks, A,

, Param);

(UnderlyingLocks.empty())

Cp(SxBuilder.createVariable(Param), StringRef(),

);

ScopedEntry = std::make_unique<ScopedLockableFactEntry>(

Cp, Param->getLocation(), FactEntry::Declared);

ScopedEntry->addLock(M);

addLock(InitialLockset, std::move(ScopedEntry),

);

(

&Mu : ExclusiveLocksToAdd) {

Entry = std::make_unique<LockableFactEntry>(Mu,

,

,

FactEntry::Declared);

addLock(InitialLockset, std::move(Entry),

);

(

&Mu : SharedLocksToAdd) {

Entry = std::make_unique<LockableFactEntry>(Mu,

,

,

FactEntry::Declared);

addLock(InitialLockset, std::move(Entry),

);

FactSet ExpectedFunctionExitSet = Initial.EntrySet;

(

&Lock : ExclusiveLocksAcquired)

ExpectedFunctionExitSet.addLock(

FactMan, std::make_unique<LockableFactEntry>(Lock,

,

(

&Lock : SharedLocksAcquired)

ExpectedFunctionExitSet.addLock(

(

&Lock : LocksReleased)

ExpectedFunctionExitSet.removeLock(FactMan, Lock);

(

*CurrBlock : *SortedGraph) {

CurrBlockID = CurrBlock->

();

CFGBlockInfo *CurrBlockInfo = &BlockInfo[CurrBlockID];

VisitedBlocks.insert(CurrBlock);

LocksetInitialized =

;

PE = CurrBlock->

(); PI != PE; ++PI) {

(*PI ==

|| !VisitedBlocks.alreadySet(*PI))

PrevBlockID = (*PI)->getBlockID();

CFGBlockInfo *PrevBlockInfo = &BlockInfo[PrevBlockID];

CurrBlockInfo->Reachable =

;

FactSet PrevLockset;

getEdgeLockset(PrevLockset, PrevBlockInfo->ExitSet, *PI, CurrBlock);

(!LocksetInitialized) {

CurrBlockInfo->EntrySet = PrevLockset;

LocksetInitialized =

;

CurrBlockInfo->EntrySet, PrevLockset, CurrBlockInfo->EntryLoc,

isa_and_nonnull<ContinueStmt>((*PI)->getTerminatorStmt())

(!CurrBlockInfo->Reachable)

BuildLockset LocksetBuilder(

, *CurrBlockInfo, ExpectedFunctionExitSet);

(

&BI : *CurrBlock) {

(BI.getKind()) {

LocksetBuilder.Visit(CS.

());

(!DD->hasAttrs())

LocksetBuilder.handleCall(

, DD,

LocksetBuilder.handleCall(

,

.getFunctionDecl(),

SxBuilder.createVariable(

.getVarDecl()),

.getVarDecl()->getLocation());

(

Object = ConstructedObjects.find(

TD.getBindTemporaryExpr()->getSubExpr());

!= ConstructedObjects.end()) {

LocksetBuilder.handleCall(

, DD,

->second,

TD.getBindTemporaryExpr()->getEndLoc());

ConstructedObjects.erase(Object);

CurrBlockInfo->ExitSet = LocksetBuilder.FSet;

SE = CurrBlock->succ_end(); SI != SE; ++SI) {

(*SI ==

|| !VisitedBlocks.alreadySet(*SI))

CFGBlockInfo *PreLoop = &BlockInfo[FirstLoopBlock->

()];

CFGBlockInfo *LoopEnd = &BlockInfo[CurrBlockID];

intersectAndWarn(PreLoop->EntrySet, LoopEnd->ExitSet, PreLoop->EntryLoc,

(!Final.Reachable)

intersectAndWarn(ExpectedFunctionExitSet, Final.ExitSet, Final.ExitLoc,

ThreadSafetyAnalyzer Analyzer(Handler, *BSet);

Analyzer.runAnalysis(AC);

llvm_unreachable(

);

This file defines AnalysisDeclContext, a class that manages the analysis context data for context sen...

Defines enum values for all the target-independent builtin functions.

enum clang::sema::@1704::IndirectLocalPathEntry::EntryKind Kind

static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)

static Decl::Kind getKind(const Decl *D)

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

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

llvm::DenseSet< const void * > Visited

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

Defines an enumeration for C++ overloaded operators.

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

Defines the clang::SourceLocation class and associated facilities.

Defines various enumerations that describe declaration and type specifiers.

static void warnInvalidLock(ThreadSafetyHandler &Handler, const Expr *MutexExp, const NamedDecl *D, const Expr *DeclExp, StringRef Kind)

Issue a warning about an invalid lock expression.

static bool getStaticBooleanValue(Expr *E, bool &TCond)

static bool neverReturns(const CFGBlock *B)

static void findBlockLocations(CFG *CFGraph, const PostOrderCFGView *SortedGraph, std::vector< CFGBlockInfo > &BlockInfo)

Find the appropriate source locations to use when producing diagnostics for each block in the CFG.

static const ValueDecl * getValueDecl(const Expr *Exp)

Gets the value decl pointer from DeclRefExprs or MemberExprs.

static const Expr * UnpackConstruction(const Expr *E)

C Language Family Type Representation.

AnalysisDeclContext contains the context data for the function, method or block under analysis.

Attr - This represents one attribute.

attr::Kind getKind() const

SourceLocation getLocation() const

A builtin binary operation expression such as "x + y" or "x <= y".

static bool isAssignmentOp(Opcode Opc)

Represents C++ object destructor implicitly generated for automatic object or temporary bound to cons...

const VarDecl * getVarDecl() const

const Stmt * getTriggerStmt() const

Represents a single basic block in a source-level CFG.

bool hasNoReturnElement() const

succ_iterator succ_begin()

Stmt * getTerminatorStmt()

AdjacentBlocks::const_iterator const_pred_iterator

pred_iterator pred_begin()

unsigned getBlockID() const

Stmt * getTerminatorCondition(bool StripParens=true)

AdjacentBlocks::const_iterator const_succ_iterator

Represents a top-level expression in a basic block.

T castAs() const

Convert to the specified CFGElement type, asserting that this CFGElement is of the desired type.

const CXXDestructorDecl * getDestructorDecl(ASTContext &astContext) const

const Stmt * getStmt() const

Represents C++ object destructor implicitly generated at the end of full expression for temporary obj...

Represents a source-level, intra-procedural CFG that represents the control-flow of a Stmt.

unsigned getNumBlockIDs() const

Returns the total number of BlockIDs allocated (which start at 0).

Represents a call to a C++ constructor.

Expr * getArg(unsigned Arg)

Return the specified argument.

CXXConstructorDecl * getConstructor() const

Get the constructor that this expression will (ultimately) call.

Represents a C++ constructor within a class.

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

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

FunctionDecl * getDirectCallee()

If the callee is a FunctionDecl, return it. Otherwise return null.

CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...

CastKind getCastKind() const

ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.

DeclStmt - Adaptor class for mixing declarations with statements and expressions.

llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const

SourceLocation getLocation() const

bool isDefinedOutsideFunctionOrMethod() const

isDefinedOutsideFunctionOrMethod - This predicate returns true if this scoped decl is defined outside...

DeclContext * getDeclContext()

This represents one expression.

Expr * IgnoreParenCasts() LLVM_READONLY

Skip past any parentheses and casts which might surround this expression until reaching a fixed point...

Expr * IgnoreImplicit() LLVM_READONLY

Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.

Expr * IgnoreParens() LLVM_READONLY

Skip past any parentheses which might surround this expression until reaching a fixed point.

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

Represents a function declaration or definition.

ArrayRef< ParmVarDecl * > parameters() const

FunctionDecl * getCanonicalDecl() override

Retrieves the "canonical" declaration of the given declaration.

Represents a prvalue temporary that is written into memory so that a reference can bind to it.

Expr * getSubExpr() const

Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.

ValueDecl * getExtendingDecl()

Get the declaration which triggered the lifetime-extension of this temporary, if any.

This represents a decl that may have a name.

StringRef getName() const

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

Represents a parameter to a function.

Implements a set of CFGBlocks using a BitVector.

A (possibly-)qualified type.

bool isConstQualified() const

Determine whether this type is const-qualified.

ReturnStmt - This represents a return, optionally of an expression: return; return 4;.

Scope - A scope is a transient data structure that is used while parsing the program.

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

Stmt - This represents one statement.

SourceLocation getEndLoc() const LLVM_READONLY

void dump() const

Dumps the specified AST fragment and all subtrees to llvm::errs().

bool isReferenceType() const

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

bool isLValueReferenceType() const

const T * getAs() const

Member-template getAs<specific type>'.

UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...

Expr * getSubExpr() const

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

void checkBeforeAfter(const ValueDecl *Vd, const FactSet &FSet, ThreadSafetyAnalyzer &Analyzer, SourceLocation Loc, StringRef CapKind)

Return true if any mutexes in FSet are in the acquired_before set of Vd.

BeforeInfo * insertAttrExprs(const ValueDecl *Vd, ThreadSafetyAnalyzer &Analyzer)

Process acquired_before and acquired_after attributes on Vd.

BeforeInfo * getBeforeInfoForDecl(const ValueDecl *Vd, ThreadSafetyAnalyzer &Analyzer)

const PostOrderCFGView * getSortedGraph() const

const NamedDecl * getDecl() const

bool init(AnalysisDeclContext &AC)

const CFG * getGraph() const

bool shouldIgnore() const

bool equals(const CapabilityExpr &other) const

const til::SExpr * sexpr() const

std::string toString() const

const ValueDecl * valueDecl() const

StringRef getKind() const

Handler class for thread safety warnings.

virtual ~ThreadSafetyHandler()

virtual void handleInvalidLockExp(SourceLocation Loc)

Warn about lock expressions which fail to resolve to lockable objects.

virtual void enterFunction(const FunctionDecl *FD)

Called by the analysis when starting analysis of a function.

virtual void handleIncorrectUnlockKind(StringRef Kind, Name LockName, LockKind Expected, LockKind Received, SourceLocation LocLocked, SourceLocation LocUnlock)

Warn about an unlock function call that attempts to unlock a lock with the incorrect lock kind.

virtual void leaveFunction(const FunctionDecl *FD)

Called by the analysis when finishing analysis of a function.

virtual void handleExclusiveAndShared(StringRef Kind, Name LockName, SourceLocation Loc1, SourceLocation Loc2)

Warn when a mutex is held exclusively and shared at the same point.

virtual void handleMutexNotHeld(StringRef Kind, const NamedDecl *D, ProtectedOperationKind POK, Name LockName, LockKind LK, SourceLocation Loc, Name *PossibleMatch=nullptr)

Warn when a protected operation occurs while the specific mutex protecting the operation is not locke...

virtual void handleFunExcludesLock(StringRef Kind, Name FunName, Name LockName, SourceLocation Loc)

Warn when a function is called while an excluded mutex is locked.

virtual void handleNoMutexHeld(const NamedDecl *D, ProtectedOperationKind POK, AccessKind AK, SourceLocation Loc)

Warn when a protected operation occurs while no locks are held.

virtual void handleUnmatchedUnlock(StringRef Kind, Name LockName, SourceLocation Loc, SourceLocation LocPreviousUnlock)

Warn about unlock function calls that do not have a prior matching lock expression.

virtual void handleNegativeNotHeld(StringRef Kind, Name LockName, Name Neg, SourceLocation Loc)

Warn when acquiring a lock that the negative capability is not held.

virtual void handleMutexHeldEndOfScope(StringRef Kind, Name LockName, SourceLocation LocLocked, SourceLocation LocEndOfScope, LockErrorKind LEK)

Warn about situations where a mutex is sometimes held and sometimes not.

virtual void handleDoubleLock(StringRef Kind, Name LockName, SourceLocation LocLocked, SourceLocation LocDoubleLock)

Warn about lock function calls for locks which are already held.

A Literal pointer to an object allocated in memory.

Base class for AST nodes in the typed intermediate language.

internal::Matcher< T > traverse(TraversalKind TK, const internal::Matcher< T > &InnerMatcher)

Causes all nested matchers to be matched with the specified traversal kind.

unsigned kind

All of the diagnostics that can be emitted by the frontend.

@ CF

Indicates that the tracked object is a CF object.

bool Dec(InterpState &S, CodePtr OpPC)

1) Pops a pointer from the stack 2) Load the value from the pointer 3) Writes the value decreased by ...

bool Neg(InterpState &S, CodePtr OpPC)

bool matches(const til::SExpr *E1, const til::SExpr *E2)

LockKind getLockKindFromAccessKind(AccessKind AK)

Helper function that returns a LockKind required for the given level of access.

@ LEK_NotLockedAtEndOfFunction

@ LEK_LockedSomePredecessors

@ LEK_LockedAtEndOfFunction

@ LEK_LockedSomeLoopIterations

void threadSafetyCleanup(BeforeSet *Cache)

AccessKind

This enum distinguishes between different ways to access (read or write) a variable.

@ AK_Written

Writing a variable.

@ AK_Read

Reading a variable.

LockKind

This enum distinguishes between different kinds of lock actions.

@ LK_Shared

Shared/reader lock of a mutex.

@ LK_Exclusive

Exclusive/writer lock of a mutex.

@ LK_Generic

Can be either Shared or Exclusive.

void runThreadSafetyAnalysis(AnalysisDeclContext &AC, ThreadSafetyHandler &Handler, BeforeSet **Bset)

Check a function's CFG for thread-safety violations.

ProtectedOperationKind

This enum distinguishes between different kinds of operations that may need to be protected by locks.

@ POK_PtPassByRef

Passing a pt-guarded variable by reference.

@ POK_VarDereference

Dereferencing a variable (e.g. p in *p = 5;)

@ POK_PassByRef

Passing a guarded variable by reference.

@ POK_ReturnByRef

Returning a guarded variable by reference.

@ POK_VarAccess

Reading or writing a variable (e.g. x in x = 5;)

@ POK_FunctionCall

Making a function call (e.g. fool())

@ POK_PtReturnByRef

Returning a pt-guarded variable by reference.

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

OverloadedOperatorKind

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

@ Self

'self' clause, allowed on Compute and Combined Constructs, plus 'update'.

@ Result

The result type of a method or function.

const FunctionProtoType * T

Iterator for iterating over Stmt * arrays that contain only T *.

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