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

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

clang: lib/Sema/SemaFunctionEffects.cpp Source File

;

ViolationID : uint8_t {

AllocatesMemory = BaseDiagnosticIndex,

ThrowsOrCatchesExceptions,

HasStaticLocalVariable,

AccessesThreadLocalVariable,

AccessesObjCMethodOrProperty,

DeclDisallowsInference,

CallsDeclWithoutEffect,

CallsExprWithoutEffect,

Kind : uint8_t {

llvm::PointerIntPair<CXXDefaultArgExpr *, 2, Kind> Impl;

ViolationSite() =

;

: Impl(

, Kind::DefaultArgExpr) {}

Kind kind()

{

Kind

(Impl.getInt()); }

setKind(Kind K) { Impl.setPointerAndInt(

, K); }

std::optional<FunctionEffect>

CalleeEffectPreventingInference;

ViolationID ID = ViolationID::None;

Violation(

Effect, ViolationID ID, ViolationSite VS,

std::optional<FunctionEffect> CalleeEffect = std::nullopt)

: Effect(Effect), CalleeEffectPreventingInference(CalleeEffect), ID(ID),

Site(VS),

(

), Callee(Callee) {}

diagnosticSelectIndex()

{

SpecialFuncType : uint8_t {

, OperatorNew, OperatorDelete };

CallableType : uint8_t {

functionIsVerifiable(

*FD) {

FPT && (FPT->isNothrow() || FD->

<NoThrowAttr>());

Builtin::ID::BI__builtin_calloc:

Builtin::ID::BI__builtin_malloc:

Builtin::ID::BI__builtin_realloc:

Builtin::ID::BI__builtin_free:

Builtin::ID::BI__builtin_operator_delete:

Builtin::ID::BI__builtin_operator_new:

Builtin::ID::BIaligned_alloc:

Builtin::ID::BIcalloc:

Builtin::ID::BImalloc:

Builtin::ID::BImemalign:

Builtin::ID::BIrealloc:

Builtin::ID::BIfree:

Builtin::ID::BIfopen:

Builtin::ID::BIpthread_create:

Builtin::ID::BI_Block_object_dispose:

Result.insert(

(FunctionEffect::Kind::Allocating));

Builtin::ID::BIlongjmp:

Builtin::ID::BI_longjmp:

Builtin::ID::BIsiglongjmp:

Builtin::ID::BI__builtin_longjmp:

Builtin::ID::BIobjc_exception_throw:

Builtin::ID::BIobjc_msgSend:

Builtin::ID::BIobjc_msgSend_fpret:

Builtin::ID::BIobjc_msgSend_fp2ret:

Builtin::ID::BIobjc_msgSend_stret:

Builtin::ID::BIobjc_msgSendSuper:

Builtin::ID::BIobjc_getClass:

Builtin::ID::BIobjc_getMetaClass:

Builtin::ID::BIobjc_enumerationMutation:

Builtin::ID::BIobjc_assign_ivar:

Builtin::ID::BIobjc_assign_global:

Builtin::ID::BIobjc_sync_enter:

Builtin::ID::BIobjc_sync_exit:

Builtin::ID::BINSLog:

Builtin::ID::BINSLogv:

Builtin::ID::BIfread:

Builtin::ID::BIfwrite:

Builtin::ID::BIprintf:

Builtin::ID::BI__builtin_printf:

Builtin::ID::BIfprintf:

Builtin::ID::BIsnprintf:

Builtin::ID::BIsprintf:

Builtin::ID::BIvprintf:

Builtin::ID::BIvfprintf:

Builtin::ID::BIvsnprintf:

Builtin::ID::BIvsprintf:

Builtin::ID::BIscanf:

Builtin::ID::BIfscanf:

Builtin::ID::BIsscanf:

Builtin::ID::BIvscanf:

Builtin::ID::BIvfscanf:

Builtin::ID::BIvsscanf:

CallableType CType = CallableType::Unknown;

SpecialFuncType FuncType = SpecialFuncType::None;

CallableInfo(

&CD, SpecialFuncType FT = SpecialFuncType::None)

: CDecl(&CD), FuncType(FT) {

(

*FD = dyn_cast<FunctionDecl>(CDecl)) {

CType = CallableType::Function;

(

*Method = dyn_cast<CXXMethodDecl>(FD);

Method && Method->isVirtual())

CType = CallableType::Virtual;

}

(

*BD = dyn_cast<BlockDecl>(CDecl)) {

CType = CallableType::Block;

DeclEffects = BD->getFunctionEffects();

}

(

*VD = dyn_cast<ValueDecl>(CDecl)) {

CallableType

()

{

CType; }

isCalledDirectly()

{

CType == CallableType::Function || CType == CallableType::Block;

isVerifiable()

{

CallableType::Unknown:

CallableType::Virtual:

CallableType::Block:

CallableType::Function:

functionIsVerifiable(dyn_cast<FunctionDecl>(CDecl));

llvm_unreachable(

);

std::string getNameForDiagnostic(

&S)

{

llvm::raw_string_ostream OS(Name);

(

*FD = dyn_cast<FunctionDecl>(CDecl))

(

*BD = dyn_cast<BlockDecl>(CDecl))

OS <<

<< BD->getBlockManglingNumber() <<

;

(

*VD = dyn_cast<NamedDecl>(CDecl))

VD->printQualifiedName(OS);

EffectToViolationMap {

std::unique_ptr<ImplVec> Impl;

maybeInsert(

Violation &Viol) {

(Impl ==

)

Impl = std::make_unique<ImplVec>();

(lookup(Viol.Effect) !=

)

Impl->push_back(Viol);

(Impl ==

)

*

= llvm::find_if(

*Impl, [&](

&Item) {

Item.Effect == Key; });

!= Impl->end() ? &*

:

;

size()

{

Impl ? Impl->size() : 0; }

PendingFunctionAnalysis {

CompleteFunctionAnalysis;

Recursed =

;

: Callee(

), CallLoc(CallLoc), VSite(VSite) {}

EffectToViolationMap InferrableEffectToFirstViolation;

PendingFunctionAnalysis(

&S,

CallableInfo &CInfo,

: DeclaredVerifiableEffects(CInfo.Effects) {

std::optional<FunctionEffect> ProblemCalleeEffect =

effect.effectProhibitingInference(*CInfo.CDecl, CInfo.Effects);

(!ProblemCalleeEffect)

InferrableEffects.

(effect);

InferrableEffectToFirstViolation.maybeInsert(Violation(

effect, ViolationID::DeclDisallowsInference, ViolationSite{},

CInfo.CDecl->getLocation(),

, ProblemCalleeEffect));

InferrableEffects, DeclaredVerifiableEffects);

checkAddViolation(

Inferring,

Violation &NewViol) {

ViolationsForExplicitEffects.push_back(NewViol);

InferrableEffectToFirstViolation.maybeInsert(NewViol);

ViolationSite VSite) {

UnverifiedDirectCalls.emplace_back(

, CallLoc, VSite);

isComplete()

{

UnverifiedDirectCalls.empty(); }

Violation *violationForInferrableEffect(

effect) {

InferrableEffectToFirstViolation.lookup(effect);

assert(!isComplete());

UnverifiedDirectCalls;

(!ViolationsForExplicitEffects.empty())

llvm::sort(ViolationsForExplicitEffects,

[&

](

Violation &LHS,

Violation &RHS) {

.isBeforeInTranslationUnit(LHS.Loc, RHS.Loc);

ViolationsForExplicitEffects;

(

&SemaRef, llvm::raw_ostream &OS)

{

OS <<

;

DeclaredVerifiableEffects.

(OS);

OS <<

<< ViolationsForExplicitEffects.size() <<

;

EffectsToInfer.

(OS);

OS <<

<< InferrableEffectToFirstViolation.size() <<

;

(!UnverifiedDirectCalls.empty()) {

(

DirectCall &

: UnverifiedDirectCalls) {

CallableInfo CI(*

.Callee);

OS <<

<< CI.getNameForDiagnostic(SemaRef);

CompleteFunctionAnalysis {

EffectToViolationMap InferrableEffectToFirstViolation;

CompleteFunctionAnalysis(

&Ctx, PendingFunctionAnalysis &&Pending,

: VerifiedEffects(DeclaredEffects) {

(Pending.violationForInferrableEffect(effect) ==

)

VerifiedEffects.

(effect);

InferrableEffectToFirstViolation =

std::move(Pending.InferrableEffectToFirstViolation);

Violation *firstViolationForEffect(

Effect) {

InferrableEffectToFirstViolation.lookup(Effect);

(llvm::raw_ostream &OS)

{

OS <<

;

VerifiedEffects.

(OS);

OS << InferrableEffectToFirstViolation.size() <<

;

FuncAnalysisPtr =

llvm::PointerUnion<PendingFunctionAnalysis *, CompleteFunctionAnalysis *>;

AnalysisMap : llvm::DenseMap<const Decl *, FuncAnalysisPtr> {

= llvm::DenseMap<const Decl *, FuncAnalysisPtr>;

FuncAnalysisPtr lookup(

*Key)

{

FuncAnalysisPtr &operator[](

*Key) {

CompleteFunctionAnalysis *completedAnalysisForDecl(

*

)

{

(FuncAnalysisPtr AP = lookup(

);

isa_and_nonnull<CompleteFunctionAnalysis *>(AP))

cast<CompleteFunctionAnalysis *>(AP);

(

&SemaRef, llvm::raw_ostream &OS) {

OS <<

;

(

&item : *

) {

CallableInfo CI(*item.first);

AP = item.second;

OS << item.first <<

<< CI.getNameForDiagnostic(SemaRef) <<

;

}

(

*CFA = dyn_cast<CompleteFunctionAnalysis *>(AP)) {

}

(

*PFA = dyn_cast<PendingFunctionAnalysis *>(AP)) {

PFA->dump(SemaRef, OS);

llvm_unreachable(

);

AnalysisMap DeclAnalysis;

Analyzer(

&S) : S(S) {}

AllInferrableEffectsToVerify.

(Effect);

LLVM_DEBUG(llvm::dbgs() <<

;

AllInferrableEffectsToVerify.

(llvm::dbgs());

llvm::dbgs() <<

;);

std::reverse(VerificationQueue.begin(), VerificationQueue.end());

(!VerificationQueue.empty()) {

*

= VerificationQueue.back();

(FuncAnalysisPtr AP = DeclAnalysis.lookup(

)) {

(

*Pending = dyn_cast<PendingFunctionAnalysis *>(AP)) {

finishPendingAnalysis(

, Pending);

VerificationQueue.pop_back();

PendingFunctionAnalysis *Pending = verifyDecl(

);

(Pending ==

) {

VerificationQueue.pop_back();

(PendingFunctionAnalysis::DirectCall &

:

Pending->unverifiedCalls()) {

FuncAnalysisPtr AP = DeclAnalysis.lookup(

.Callee);

VerificationQueue.push_back(

.Callee);

assert(isa<PendingFunctionAnalysis *>(AP));

.Recursed =

;

PendingFunctionAnalysis *verifyDecl(

*

) {

CallableInfo CInfo(*

);

IsNoexcept =

;

}

(

*BD = dyn_cast<BlockDecl>(

)) {

(

*TSI = BD->getSignatureAsWritten()) {

IsNoexcept = FPT->

() || BD->hasAttr<NoThrowAttr>();

<< GetCallableDeclKind(

,

) << Effect.

();

PendingFunctionAnalysis FAnalysis(S, CInfo, AllInferrableEffectsToVerify);

LLVM_DEBUG(llvm::dbgs()

<<

<< CInfo.getNameForDiagnostic(S) <<

;

FAnalysis.dump(S, llvm::dbgs()););

FunctionBodyASTVisitor Visitor(*

, FAnalysis, CInfo);

(FAnalysis.isComplete()) {

completeAnalysis(CInfo, std::move(FAnalysis));

PendingFunctionAnalysis *PendingPtr =

PendingFunctionAnalysis(std::move(FAnalysis));

DeclAnalysis[

] = PendingPtr;

LLVM_DEBUG(llvm::dbgs() <<

<< PendingPtr <<

;

DeclAnalysis.dump(S, llvm::dbgs()););

completeAnalysis(

CallableInfo &CInfo,

PendingFunctionAnalysis &&Pending) {

CompleteFunctionAnalysis *CompletePtr =

CompleteFunctionAnalysis(

AllInferrableEffectsToVerify);

DeclAnalysis[CInfo.CDecl] = CompletePtr;

LLVM_DEBUG(llvm::dbgs() <<

<< CompletePtr <<

;

DeclAnalysis.dump(S, llvm::dbgs()););

finishPendingAnalysis(

*

, PendingFunctionAnalysis *Pending) {

CallableInfo Caller(*

);

LLVM_DEBUG(llvm::dbgs() <<

<< Caller.getNameForDiagnostic(S) <<

;

Pending->dump(S, llvm::dbgs()); llvm::dbgs() <<

;);

(

PendingFunctionAnalysis::DirectCall &

:

Pending->unverifiedCalls()) {

CallableInfo Callee(*

.Callee);

followCall(Caller, *Pending, Callee,

.CallLoc,

completeAnalysis(Caller, std::move(*Pending));

followCall(

CallableInfo &Caller, PendingFunctionAnalysis &PFA,

AssertNoFurtherInference, ViolationSite VSite) {

DirectCall = Callee.isCalledDirectly();

IsInferencePossible = DirectCall;

(CompleteFunctionAnalysis *CFA =

DeclAnalysis.completedAnalysisForDecl(Callee.CDecl)) {

CalleeEffects.

(CFA->VerifiedEffects);

IsInferencePossible =

;

(AssertNoFurtherInference) {

assert(!IsInferencePossible);

(!Callee.isVerifiable())

IsInferencePossible =

;

LLVM_DEBUG(llvm::dbgs()

<<

<< Caller.getNameForDiagnostic(S)

<<

<< Callee.getNameForDiagnostic(S)

<<

<< Callee.isVerifiable() <<

;

CalleeEffects.

(llvm::dbgs()); llvm::dbgs() <<

;

llvm::dbgs() <<

<< Callee.CDecl <<

<< Callee.CDecl->getCanonicalDecl() <<

;);

(!IsInferencePossible ||

(Callee.FuncType == SpecialFuncType::None)

PFA.checkAddViolation(Inferring,

{Effect, ViolationID::CallsDeclWithoutEffect,

VSite, CallLoc, Callee.CDecl});

PFA.checkAddViolation(

{Effect, ViolationID::AllocatesMemory, VSite, CallLoc});

PFA.addUnverifiedDirectCall(Callee.CDecl, CallLoc, VSite);

Check1Effect(Effect,

);

Check1Effect(Effect,

);

CallableDeclKind {

CDK_MemberInitializer,

CallableDeclKind GetCallableDeclKind(

*

,

Violation *

) {

->Site.kind() == ViolationSite::Kind::MemberInitializer)

CDK_MemberInitializer;

(isa<BlockDecl>(

))

(

*Method = dyn_cast<CXXMethodDecl>(

)) {

(isa<CXXConstructorDecl>(

))

CDK_Constructor;

(isa<CXXDestructorDecl>(

))

CDK_Destructor;

MaybeAddTemplateNote = [&](

*

) {

diag::note_func_effect_from_template);

{ Indirect_VirtualMethod, Indirect_FunctionPtr };

MaybeAddSiteContext = [&](

*

,

Violation &

) {

(

.Site.kind() == ViolationSite::Kind::MemberInitializer) {

ImplicitCtor = 0;

(

*Ctor = dyn_cast<CXXConstructorDecl>(

);

Ctor && Ctor->isImplicit())

(

.Site.kind() == ViolationSite::Kind::DefaultArgExpr)

S.

(

.Site.defaultArgExpr()->getUsedLocation(),

diag::note_in_evaluating_default_argument);

(

Violation &Viol1 : Viols) {

StringRef effectName = Viol1.Effect.name();

ViolationID::None:

ViolationID::DeclDisallowsInference:

llvm_unreachable(

);

ViolationID::AllocatesMemory:

ViolationID::ThrowsOrCatchesExceptions:

ViolationID::HasStaticLocalVariable:

ViolationID::AccessesThreadLocalVariable:

ViolationID::AccessesObjCMethodOrProperty:

S.

(Viol1.Loc, diag::warn_func_effect_violation)

<< GetCallableDeclKind(CInfo.CDecl, &Viol1) << effectName

<< Viol1.diagnosticSelectIndex();

MaybeAddSiteContext(CInfo.CDecl, Viol1);

MaybeAddTemplateNote(CInfo.CDecl);

ViolationID::CallsExprWithoutEffect:

S.

(Viol1.Loc, diag::warn_func_effect_calls_expr_without_effect)

<< GetCallableDeclKind(CInfo.CDecl, &Viol1) << effectName;

MaybeAddSiteContext(CInfo.CDecl, Viol1);

MaybeAddTemplateNote(CInfo.CDecl);

ViolationID::CallsDeclWithoutEffect: {

CallableInfo CalleeInfo(*Viol1.Callee);

std::string CalleeName = CalleeInfo.getNameForDiagnostic(S);

S.

(Viol1.Loc, diag::warn_func_effect_calls_func_without_effect)

<< GetCallableDeclKind(CInfo.CDecl, &Viol1) << effectName

<< GetCallableDeclKind(CalleeInfo.CDecl,

) << CalleeName;

MaybeAddSiteContext(CInfo.CDecl, Viol1);

MaybeAddTemplateNote(CInfo.CDecl);

(

*Callee = Viol1.Callee; Callee !=

;) {

std::optional<CallableInfo> MaybeNextCallee;

CompleteFunctionAnalysis *Completed =

DeclAnalysis.completedAnalysisForDecl(CalleeInfo.CDecl);

(Completed ==

) {

CallableType CType = CalleeInfo.type();

(CType == CallableType::Virtual)

S.

(Callee->getLocation(),

diag::note_func_effect_call_indirect)

<< Indirect_VirtualMethod << effectName;

(CType == CallableType::Unknown)

S.

(Callee->getLocation(),

diag::note_func_effect_call_indirect)

<< Indirect_FunctionPtr << effectName;

(CalleeInfo.Effects.contains(Viol1.Effect.oppositeKind()))

S.

(Callee->getLocation(),

diag::note_func_effect_call_disallows_inference)

<< GetCallableDeclKind(CInfo.CDecl,

) << effectName

(

*FD = dyn_cast<FunctionDecl>(Callee);

S.

(Callee->getLocation(), diag::note_func_effect_call_extern)

Violation *PtrViol2 =

Completed->firstViolationForEffect(Viol1.Effect);

(PtrViol2 ==

)

Violation &Viol2 = *PtrViol2;

ViolationID::None:

llvm_unreachable(

);

ViolationID::DeclDisallowsInference:

S.

(Viol2.Loc, diag::note_func_effect_call_disallows_inference)

<< GetCallableDeclKind(CalleeInfo.CDecl,

) << effectName

<< Viol2.CalleeEffectPreventingInference->name();

ViolationID::CallsExprWithoutEffect:

S.

(Viol2.Loc, diag::note_func_effect_call_indirect)

<< Indirect_FunctionPtr << effectName;

ViolationID::AllocatesMemory:

ViolationID::ThrowsOrCatchesExceptions:

ViolationID::HasStaticLocalVariable:

ViolationID::AccessesThreadLocalVariable:

ViolationID::AccessesObjCMethodOrProperty:

S.

(Viol2.Loc, diag::note_func_effect_violation)

<< GetCallableDeclKind(CalleeInfo.CDecl, &Viol2) << effectName

<< Viol2.diagnosticSelectIndex();

MaybeAddSiteContext(CalleeInfo.CDecl, Viol2);

ViolationID::CallsDeclWithoutEffect:

MaybeNextCallee.emplace(*Viol2.Callee);

S.

(Viol2.Loc, diag::note_func_effect_calls_func_without_effect)

<< GetCallableDeclKind(CalleeInfo.CDecl, &Viol2) << effectName

<< GetCallableDeclKind(Viol2.Callee,

)

<< MaybeNextCallee->getNameForDiagnostic(S);

MaybeAddTemplateNote(Callee);

Callee = Viol2.Callee;

(MaybeNextCallee) {

CalleeInfo = *MaybeNextCallee;

CalleeName = CalleeInfo.getNameForDiagnostic(S);

PendingFunctionAnalysis &CurrentFunction;

CallableInfo &CurrentCaller;

*TrailingRequiresClause =

;

*NoexceptExpr =

;

FunctionBodyASTVisitor(Analyzer &Outer,

PendingFunctionAnalysis &CurrentFunction,

CallableInfo &CurrentCaller)

: Outer(Outer), CurrentFunction(CurrentFunction),

CurrentCaller(CurrentCaller) {

ShouldVisitImplicitCode =

;

ShouldWalkTypesOfTypeLocs =

;

(

*Dtor = dyn_cast<CXXDestructorDecl>(CurrentCaller.CDecl))

followDestructor(dyn_cast<CXXRecordDecl>(Dtor->getParent()), Dtor);

(

*FD = dyn_cast<FunctionDecl>(CurrentCaller.CDecl)) {

NoexceptExpr = FPT->getNoexceptExpr();

TraverseDecl(

*

(CurrentCaller.CDecl));

*Callee =

) {

(

Effect : CurrentFunction.DeclaredVerifiableEffects) {

(Effect.

() & Flag) {

addViolation(

, Effect, VID,

, Callee);

(Effect.

() & Flag)

addViolation(

, Effect, VID,

, Callee);

addViolation(

Inferring,

Effect, ViolationID VID,

CurrentFunction.checkAddViolation(

Inferring, Violation(Effect, VID, VSite,

, Callee));

(

*FD = dyn_cast<FunctionDecl>(CI.CDecl)) {

CI.Effects = getBuiltinFunctionEffects(BuiltinID);

(CI.Effects.empty()) {

(!Outer.S.getLangOpts().CPlusPlus ||

(FD)))

Outer.followCall(CurrentCaller, CurrentFunction, CI, CallLoc,

CalleeEffects.

(Effects);

Check1Effect = [&](

Effect,

Inferring) {

, CalleeEffects))

addViolation(Inferring, Effect, ViolationID::CallsExprWithoutEffect,

->getBeginLoc());

(

Effect : CurrentFunction.DeclaredVerifiableEffects)

Check1Effect(Effect,

);

Check1Effect(Effect,

);

followTypeDtor(Field->getType(), DtorLoc);

(

*

= dyn_cast<CXXRecordDecl>(Rec))

followTypeDtor(

.getType(), DtorLoc);

CallableInfo CI(*Dtor);

followCall(CI, CallSite);

VisitCXXThrowExpr(

*Throw)

{

ViolationID::ThrowsOrCatchesExceptions,

VisitCXXCatchStmt(

*Catch)

{

ViolationID::ThrowsOrCatchesExceptions,

ViolationID::ThrowsOrCatchesExceptions,

ViolationID::ThrowsOrCatchesExceptions,

ViolationID::ThrowsOrCatchesExceptions,

ViolationID::AccessesObjCMethodOrProperty,

ViolationID::AccessesObjCMethodOrProperty,

ViolationID::AccessesObjCMethodOrProperty,

ViolationID::ThrowsOrCatchesExceptions,

LLVM_DEBUG(llvm::dbgs()

<<

<<

->getBeginLoc().printToString(Outer.S.SourceMgr)

*CalleeExpr =

->getCallee();

CallableInfo CI(*Callee);

followCall(CI,

->getBeginLoc());

(isa<CXXPseudoDestructorExpr>(CalleeExpr)) {

checkIndirectCall(

, CalleeExpr->

());

VisitVarDecl(

*Var)

{

LLVM_DEBUG(llvm::dbgs()

<<

ViolationID::HasStaticLocalVariable,

VisitCXXNewExpr(

*New)

{

CallableInfo CI(*FD, SpecialFuncType::OperatorNew);

CallableInfo CI(*FD, SpecialFuncType::OperatorDelete);

followCall(CI,

->getBeginLoc());

LLVM_DEBUG(llvm::dbgs() <<

CallableInfo CI(*Ctor);

TraverseStmt(

*Statement)

{

(Statement != TrailingRequiresClause && Statement != NoexceptExpr)

ViolationSite PrevVS = VSite;

(

->isAnyMemberInitializer())

VSite.setKind(ViolationSite::Kind::MemberInitializer);

LLVM_DEBUG(llvm::dbgs()

<<

<<

->getUsedLocation().printToString(Outer.S.SourceMgr)

ViolationSite PrevVS = VSite;

(VSite.kind() == ViolationSite::Kind::Default)

VSite = ViolationSite{

};

Result = DynamicRecursiveASTVisitor::TraverseCXXDefaultArgExpr(

);

TraverseLambdaExpr(

*Lambda)

{

(

I = 0, N = Lambda->

(); I < N; ++I)

TraverseLambdaCapture(Lambda, Lambda->

() + I,

TraverseBlockExpr(

*

)

{

(

*Var = dyn_cast<VarDecl>(Val)) {

ViolationID::AccessesThreadLocalVariable,

TraverseStmt(

->getResultExpr());

Analyzer::AnalysisMap::~AnalysisMap() {

(

&Item : *

) {

FuncAnalysisPtr AP = Item.second;

(

*PFA = dyn_cast<PendingFunctionAnalysis *>(AP))

cast<CompleteFunctionAnalysis *>(AP);

(NewAttrLoc, diag::err_attributes_are_not_compatible)

<< (

+ PrevEC.description() +

) <<

;

(PrevEC.Cond.getCondition() !=

)

(PrevEC.Effect.oppositeKind() == NewKind)

(NewLoc, diag::warn_conflicting_func_effects)

<< Conflict.Kept.description() << Conflict.Rejected.description();

(OldLoc, diag::note_previous_declaration);

(cast<DeclContext>(

)->isDependentContext())

AnyVerifiable =

;

AnyVerifiable =

;

Analyzer{*

}.run(*TU);

(POld == OldEnd) {

}

(PNew == NewEnd)

}

(cmp > 0) {

std::nullopt, New});

(EffectKind) {

(DiffKind == Kind::Added) {

(

&CFE : SrcFX) {

Kind::ConditionMismatch:

llvm_unreachable(

);

(EffectKind) {

Kind::ConditionMismatch:

llvm_unreachable(

);

(EffectKind) {

OverrideResult::NoAction;

OverrideResult::Merge;

Kind::ConditionMismatch:

OverrideResult::Warn;

OverrideResult::NoAction;

llvm_unreachable(

);

static bool isNoexcept(const FunctionDecl *FD)

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

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

static bool isExternC(const NamedDecl *ND)

static void emitDiagnostics(BoundNodes &Match, const Decl *D, BugReporter &BR, AnalysisManager &AM, const ObjCAutoreleaseWriteChecker *Checker)

Defines the SourceManager interface.

Defines the Objective-C statement AST node classes.

C Language Family Type Representation.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

Represents an array type, per C99 6.7.5.2 - Array Declarators.

QualType getElementType() const

BlockExpr - Adaptor class for mixing a BlockDecl with expressions.

Represents a base class of a C++ class.

CXXCatchStmt - This represents a C++ catch block.

SourceLocation getCatchLoc() const

Represents a call to a C++ constructor.

SourceLocation getLocation() const

SourceLocation getBeginLoc() const LLVM_READONLY

CXXConstructorDecl * getConstructor() const

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

Represents a C++ constructor within a class.

Represents a C++ base or member initializer.

A default argument (C++ [dcl.fct.default]).

Represents a delete expression for memory deallocation and destructor calls, e.g.

Represents a C++ destructor within a class.

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

Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".

SourceLocation getBeginLoc() const

FunctionDecl * getOperatorNew() const

Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).

Represents a C++ struct/union/class.

bool isLambda() const

Determine whether this class describes a lambda function object.

A C++ throw-expression (C++ [except.throw]).

SourceLocation getThrowLoc() const

A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...

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

DeclContext * getParent()

getParent - Returns the containing DeclContext.

bool isExternCContext() const

Determines whether this context or some of its ancestors is a linkage specification context that spec...

A reference to a declared variable, function, enum, etc.

Decl - This represents one declaration (or definition), e.g.

FunctionDecl * getAsFunction() LLVM_READONLY

Returns the function itself, or the templated function if this is a function template.

virtual bool hasBody() const

Returns true if this Decl represents a declaration for a body of code, such as a function or method d...

SourceLocation getLocation() const

SourceLocation getBeginLoc() const LLVM_READONLY

virtual Decl * getCanonicalDecl()

Retrieves the "canonical" declaration of the given declaration.

SourceLocation getBeginLoc() const LLVM_READONLY

Expr * getTrailingRequiresClause()

Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...

TypeSourceInfo * getTypeSourceInfo() const

bool getIgnoreAllWarnings() const

bool getSuppressSystemWarnings() const

Recursive AST visitor that supports extension via dynamic dispatch.

virtual bool TraverseConstructorInitializer(MaybeConst< CXXCtorInitializer > *Init)

Recursively visit a constructor initializer.

virtual bool TraverseStmt(MaybeConst< Stmt > *S)

Recursively visit a statement or expression, by dispatching to Traverse*() based on the argument's dy...

Expr * getCondition() const

This represents one expression.

Decl * getReferencedDeclOfCallee()

Represents a member of a struct/union/class.

Represents a function declaration or definition.

unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const

Returns a value indicating whether this function corresponds to a builtin function.

SourceLocation getPointOfInstantiation() const

Retrieve the (first) point of instantiation of a function template specialization or a member of a cl...

bool isNoReturn() const

Determines whether this function is known to be 'noreturn', through an attribute on its declaration o...

FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const

Retrieve the function declaration from which this function could be instantiated, if it is an instant...

bool isTrivial() const

Whether this function is "trivial" in some specialized C++ senses.

FunctionDecl * getCanonicalDecl() override

Retrieves the "canonical" declaration of the given declaration.

bool isDeleted() const

Whether this function has been deleted.

FunctionEffectsRef getFunctionEffects() const

bool isTemplateInstantiation() const

Determines if the given function was instantiated from a function template.

FunctionDecl * getDefinition()

Get the definition for this declaration.

bool hasBody(const FunctionDecl *&Definition) const

Returns true if the function has a body.

void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override

Appends a human-readable name for this declaration into the given stream.

bool willHaveBody() const

True if this function will eventually have a body, once it's fully parsed.

Support iteration in parallel through a pair of FunctionEffect and EffectConditionExpr containers.

A mutable set of FunctionEffect::Kind.

static FunctionEffectKindSet difference(FunctionEffectKindSet LHS, FunctionEffectKindSet RHS)

void dump(llvm::raw_ostream &OS) const

void insert(FunctionEffect Effect)

Represents an abstract function effect, using just an enumeration describing its kind.

Kind kind() const

The kind of the effect.

@ FE_ExcludeStaticLocalVars

@ FE_ExcludeThreadLocalVars

@ FE_ExcludeObjCMessageSend

Kind

Identifies the particular effect.

Flags flags() const

Flags describing some behaviors of the effect.

bool shouldDiagnoseFunctionCall(bool Direct, FunctionEffectKindSet CalleeFX) const

StringRef name() const

The description printed in diagnostics, e.g. 'nonblocking'.

An immutable set of FunctionEffects and possibly conditions attached to them.

static FunctionEffectsRef get(QualType QT)

Extract the effects from a Type if it is a function, block, or member function pointer,...

Represents a prototype with parameter type info, e.g.

bool isNothrow(bool ResultIfDependent=false) const

Determine whether this function type has a non-throwing exception specification.

Represents a C11 generic selection.

A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...

capture_iterator capture_begin() const

Retrieve an iterator pointing to the first lambda capture.

unsigned capture_size() const

Determine the number of captures in this lambda.

capture_init_iterator capture_init_begin()

Retrieve the first initialization argument for this lambda expression (which initializes the first ca...

Represents Objective-C's @catch statement.

SourceLocation getAtCatchLoc() const

Represents Objective-C's @finally statement.

SourceLocation getAtFinallyLoc() const

Represents Objective-C's @synchronized statement.

SourceLocation getBeginLoc() const LLVM_READONLY

Represents Objective-C's @throw statement.

SourceLocation getThrowLoc() const LLVM_READONLY

Represents Objective-C's @autoreleasepool Statement.

SourceLocation getBeginLoc() const LLVM_READONLY

An expression that sends a message to the given Objective-C object or class.

SourceLocation getBeginLoc() const LLVM_READONLY

A (possibly-)qualified type.

const Type * getTypePtr() const

Retrieves a pointer to the underlying (unqualified) type.

field_range fields() const

SourceLocation getExceptLoc() const

SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)

Emit a diagnostic.

Sema - This implements semantic analysis and AST building for C.

void addDeclWithEffects(const Decl *D, const FunctionEffectsRef &FX)

Unconditionally add a Decl to DeclsWithEfffectsToVerify.

FunctionEffectKindSet AllEffectsToVerify

The union of all effects present on DeclsWithEffectsToVerify.

ASTContext & getASTContext() const

SmallVector< const Decl * > DeclsWithEffectsToVerify

All functions/lambdas/blocks which have bodies and which have a non-empty FunctionEffectsRef to be ve...

PrintingPolicy getPrintingPolicy() const

Retrieve a suitable printing policy for diagnostics.

const LangOptions & getLangOpts() const

void maybeAddDeclWithEffects(FuncOrBlockDecl *D)

Inline checks from the start of maybeAddDeclWithEffects, to minimize performance impact on code not u...

void performFunctionEffectAnalysis(TranslationUnitDecl *TU)

@ Incompatible

Incompatible - We reject this conversion outright, it is invalid to represent it in the AST.

SourceManager & getSourceManager() const

void diagnoseFunctionEffectMergeConflicts(const FunctionEffectSet::Conflicts &Errs, SourceLocation NewLoc, SourceLocation OldLoc)

bool diagnoseConflictingFunctionEffect(const FunctionEffectsRef &FX, const FunctionEffectWithCondition &EC, SourceLocation NewAttrLoc)

Warn and return true if adding a function effect to a set would create a conflict.

bool hasUncompilableErrorOccurred() const

Whether uncompilable error has occurred.

SourceManager & SourceMgr

DiagnosticsEngine & Diags

Encodes a location in the source.

std::string printToString(const SourceManager &SM) const

bool isValid() const

Return true if this is a valid SourceLocation object.

This class handles loading and caching of source files into memory.

bool isInSystemHeader(SourceLocation Loc) const

Returns if a SourceLocation is in a system header.

Stmt - This represents one statement.

The top declaration context.

T getAs() const

Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...

A container of type source information.

The base class of the type hierarchy.

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

const ArrayType * getAsArrayTypeUnsafe() const

A variant of getAs<> for array types which silently discards qualifiers from the outermost type.

const T * getAs() const

Member-template getAs<specific type>'.

bool isRecordType() const

UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.

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

Represents a variable declaration or definition.

TLSKind getTLSKind() const

bool isStaticLocal() const

Returns true if a variable with function scope is a static local variable.

QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const

Would the destruction of this variable have any effect, and if so, what kind?

@ TLS_None

Not a TLS variable.

A static requirement that can be used in a requires-expression to check properties of types and expre...

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

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

@ Delete

'delete' clause, allowed on the 'exit data' construct.

@ None

The alignment was not explicit in code.

@ Class

The "class" keyword introduces the elaborated-type-specifier.

A FunctionEffect plus a potential boolean expression determining whether the effect is declared (e....

std::string description() const

Return a textual description of the effect, and its condition, if any.

FunctionEffectDiffVector(const FunctionEffectsRef &Old, const FunctionEffectsRef &New)

Caller should short-circuit by checking for equality first.

bool shouldDiagnoseConversion(QualType SrcType, const FunctionEffectsRef &SrcFX, QualType DstType, const FunctionEffectsRef &DstFX) const

Return true if adding or removing the effect as part of a type conversion should generate a diagnosti...

bool shouldDiagnoseRedeclaration(const FunctionDecl &OldFunction, const FunctionEffectsRef &OldFX, const FunctionDecl &NewFunction, const FunctionEffectsRef &NewFX) const

Return true if adding or removing the effect in a redeclaration should generate a diagnostic.

OverrideResult shouldDiagnoseMethodOverride(const CXXMethodDecl &OldMethod, const FunctionEffectsRef &OldFX, const CXXMethodDecl &NewMethod, const FunctionEffectsRef &NewFX) const

Return true if adding or removing the effect in a C++ virtual method override should generate a diagn...

OverrideResult

Describes the result of effects differing between a base class's virtual method and an overriding met...

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