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

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

clang: lib/Sema/SemaAttr.cpp Source File

;

: S(S), SlotLabel(SlotLabel), ShouldAct(ShouldAct) {

}

(IsPackSet) {

RD->

(MaxFieldAlignmentAttr::CreateImplicit(

(AlignPackedInclude.CurrentPragmaLocation !=

(AlignPackedInclude.HasNonDefaultValue)

AlignPackedInclude.ShouldWarnOnInclude =

;

RD->

(MSVtorDispAttr::CreateImplicit(

<

Attribute>

(

->hasAttr<OwnerAttr>() ||

->hasAttr<PointerAttr>())

Redecl->addAttr(Attribute::CreateImplicit(

,

));

(!UnderlyingRecord)

llvm::StringSet<> Containers{

,

,

llvm::StringSet<> Iterators{

,

,

};

(

->isInStdNamespace() && Iterators.count(ND->

()) &&

Containers.count(

->getName()))

addGslOwnerPointerAttributeIfNotExisting<PointerAttr>(

,

dyn_cast<TemplateSpecializationType>(Canonical.

())) {

RD = dyn_cast_or_null<CXXRecordDecl>(

TST->getTemplateName().getAsTemplateDecl()->getTemplatedDecl());

llvm::StringSet<> StdOwners{

,

,

llvm::StringSet<> StdPointers{

,

,

(!

->getIdentifier())

(

->isInStdNamespace()) {

(

->hasAttr<OwnerAttr>() ||

->hasAttr<PointerAttr>())

(StdOwners.count(

->getName()))

addGslOwnerPointerAttributeIfNotExisting<OwnerAttr>(

,

);

(StdPointers.count(

->getName()))

addGslOwnerPointerAttributeIfNotExisting<PointerAttr>(

,

);

Builtin::BIaddressof:

Builtin::BI__addressof:

Builtin::BI__builtin_addressof:

Builtin::BIas_const:

Builtin::BIforward:

Builtin::BIforward_like:

Builtin::BImove:

Builtin::BImove_if_noexcept:

!

->hasAttr<LifetimeBoundAttr>())

(

*CMD = dyn_cast<CXXMethodDecl>(FD)) {

*CRD = CMD->getParent();

(!CRD->isInStdNamespace() || !CRD->getIdentifier())

(isa<CXXConstructorDecl>(CMD)) {

*Param = CMD->getParamDecl(0);

(Param->hasAttr<LifetimeBoundAttr>())

(CRD->getName() ==

&&

Param->getType()->isPointerType()) {

}

(CRD->getName() ==

) {

(LRT && LRT->getPointeeType().IgnoreParens()->isArrayType())

*MD = dyn_cast_if_present<CXXMethodDecl>(FD);

(!MD || !MD->getParent()->isInStdNamespace())

(PVD->hasAttr<LifetimeCaptureByAttr>())

(PVD->getType()->isReferenceType() &&

CaptureByThis[] = {LifetimeCaptureByAttr::THIS};

LifetimeCaptureByAttr::CreateImplicit(

, CaptureByThis, 1));

(!MD->getIdentifier()) {

llvm::StringSet<> MapLikeContainer{

,

(MD->getOverloadedOperator() == OO_Subscript &&

MapLikeContainer.contains(MD->getParent()->getName()))

llvm::StringSet<> CapturingMethods{

,

,

,

,

};

(!CapturingMethods.contains(MD->getName()))

llvm::StringSet<>

{

,

,

,

,

,

,

,

!CRD->

<TypeNullableAttr>())

Redecl->addAttr(TypeNullableAttr::CreateImplicit(

));

(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported);

(PragmaLoc, diag::warn_pragma_options_align_reset_failed)

llvm_unreachable(

);

CSec->

=

;

(PragmaLoc, diag::err_pragma_section_invalid_for_target)

CSec->

=

;

CSec->

=

;

StringRef SlotLabel,

*alignment) {

(IsXLPragma && !SlotLabel.empty()) {

(PragmaLoc, diag::err_pragma_pack_identifer_not_supported);

*Alignment =

*

(alignment);

AlignmentVal = 0;

std::optional<llvm::APSInt> Val;

!(*Val == 0 || Val->isPowerOf2()) || Val->getZExtValue() > 16) {

(PragmaLoc, diag::warn_pragma_pack_invalid_alignment);

(IsXLPragma && *Val == 0) {

(PragmaLoc, diag::err_pragma_pack_invalid_alignment);

AlignmentVal = (

)Val->getZExtValue();

(PragmaLoc, diag::warn_pragma_pack_show) <<

;

(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;

(Alignment && !SlotLabel.empty())

(PragmaLoc, diag::warn_pragma_pack_pop_identifier_and_alignment);

);

(PragmaLoc, diag::warn_pragma_pop_failed) <<

<<

;

(

Idx = 0; Idx < Args.size(); Idx++) {

*&

= Args.begin()[Idx];

assert(

&&

);

clang::CK_ArrayToPointerDecay)

clang::CK_FunctionToPointerDecay,

,

,

clang::CK_LValueToRValue,

,

,

(!

|| !Notes.empty()) {

(

&

: Notes)

HasNonDefaultValue =

HasNonDefaultValue,

});

(IncludeLoc, diag::warn_pragma_pack_non_default_at_include);

(IncludeLoc, diag::warn_pragma_pack_modified_after_include);

IsInnermost =

;

(

&StackSlot : llvm::reverse(

.Stack)) {

(StackSlot.PragmaPushLocation, diag::warn_pragma_pack_no_pop_eof);

diag::note_pragma_pack_pop_instead_reset);

IsInnermost =

;

llvm_unreachable(

);

(

, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 0;

(

, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 1;

(

, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 2;

(

, diag::err_pragma_fc_pp_scope);

llvm_unreachable(

);

(

, diag::err_pragma_fc_noprecise_requires_noexcept);

(

, diag::err_pragma_fc_noprecise_requires_nofenv);

(

, diag::err_pragma_fc_except_requires_precise);

(

, diag::warn_pragma_pop_failed) <<

(PragmaLoc, diag::warn_pragma_pop_failed) <<

llvm::StringRef StackSlotLabel,

AlignPackInfo

) {

CurrentValue = DefaultValue;

CurrentPragmaLocation = PragmaLocation;

Stack.emplace_back(Slot(StackSlotLabel, CurrentValue, CurrentPragmaLocation,

(!StackSlotLabel.empty()) {

I = llvm::find_if(llvm::reverse(Stack), [&](

Slot &x) {

x.StackSlotLabel == StackSlotLabel;

(I != Stack.rend()) {

CurrentValue = I->Value;

CurrentPragmaLocation = I->PragmaLocation;

Stack.erase(std::prev(I.base()), Stack.end());

}

(

.IsXLStack() &&

.IsAlignAttr() &&

CurrentValue.IsPackAttr()) {

I = llvm::find_if(llvm::reverse(Stack), [&](

Slot &x) {

x.Value.IsAlignAttr();

(I != Stack.rend()) {

Stack.erase(std::prev(I.base()), Stack.end());

CurrentValue = DefaultValue;

CurrentPragmaLocation = PragmaLocation;

CurrentValue = Stack.back().Value;

CurrentPragmaLocation = Stack.back().PragmaLocation;

}

(!Stack.empty()) {

(

.IsXLStack() &&

.IsPackAttr() && CurrentValue.IsAlignAttr())

CurrentValue = Stack.back().Value;

CurrentPragmaLocation = Stack.back().PragmaLocation;

CurrentValue =

;

CurrentPragmaLocation = PragmaLocation;

PragmaLocation = A->getLocation();

SectionName,

, PragmaLocation, SectionFlags);

&Section = SectionIt->second;

(Section.SectionFlags == SectionFlags ||

(Section.

->getLocation(), diag::note_declared_at)

<< Section.

->getName();

(PragmaLocation.

())

(PragmaLocation, diag::note_pragma_entered_here);

(Section.PragmaSectionLocation.isValid())

(Section.PragmaSectionLocation, diag::note_pragma_entered_here);

&Section = SectionIt->second;

(Section.SectionFlags == SectionFlags)

(PragmaSectionLocation, diag::err_section_conflict)

<<

<< Section;

(Section.Decl->getLocation(), diag::note_declared_at)

<< Section.Decl->getName();

(Section.PragmaSectionLocation.isValid())

(Section.PragmaSectionLocation, diag::note_pragma_entered_here);

llvm::StringRef StackSlotLabel,

llvm::StringRef PragmaName) {

llvm::StringSwitch<PragmaStack<StringLiteral *> *>(PragmaName)

(Action &

&& Stack->Stack.empty())

(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName

(SegmentName->

() ==

&&

(PragmaLocation, diag::warn_attribute_section_drectve) << PragmaName;

Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName);

(PragmaLocation, diag::warn_pragma_pop_failed) <<

<std::tuple<IdentifierInfo *, SourceLocation>>

(PragmaLocation, diag::err_pragma_expected_file_scope) <<

;

(

&

: Functions) {

(

, diag::err_pragma_alloc_text_not_function);

(

, diag::err_pragma_alloc_text_c_linkage);

(Lookup.

()) {

(PragmaLoc, diag::warn_pragma_unused_undeclared_var)

(PragmaLoc, diag::warn_pragma_unused_expected_var_arg)

(PragmaLoc, diag::warn_used_but_marked_unused) << Name;

UnusedAttr::GNU_unused));

std::optional<attr::SubjectMatchRule>

;

;

llvm::raw_string_ostream

(

);

(

&I : llvm::enumerate(Rules)) {

<< (I.index() == Rules.size() - 1 ?

:

);

StrictSubjectMatchRuleSet;

(StrictSubjectMatchRuleSet.empty()) {

llvm::SmallDenseMap<int, std::pair<int, SourceRange>, 2>

RulesToFirstSpecifiedNegatedSubRule;

(

&Rule : Rules) {

std::optional<attr::SubjectMatchRule> ParentRule =

getParentAttrMatcherRule(MatchRule);

It = Rules.find(*ParentRule);

(It != Rules.end()) {

(Rule.second.getBegin(),

diag::err_pragma_attribute_matcher_subrule_contradicts_rule)

replacementRangeForListElement(*

, Rule.second));

(isNegatedAttrMatcherSubRule(MatchRule))

RulesToFirstSpecifiedNegatedSubRule.insert(

std::make_pair(*ParentRule, Rule));

IgnoreNegatedSubRules =

;

(

&Rule : Rules) {

std::optional<attr::SubjectMatchRule> ParentRule =

getParentAttrMatcherRule(MatchRule);

It = RulesToFirstSpecifiedNegatedSubRule.find(*ParentRule);

(It != RulesToFirstSpecifiedNegatedSubRule.end() &&

It->second != Rule) {

It->second.second.getBegin(),

err_pragma_attribute_matcher_negated_subrule_contradicts_subrule)

replacementRangeForListElement(*

, It->second.second));

IgnoreNegatedSubRules =

;

RulesToFirstSpecifiedNegatedSubRule.erase(It);

(!IgnoreNegatedSubRules) {

(

&Rule : Rules)

(

&Rule : Rules) {

(

&StrictRule : StrictSubjectMatchRuleSet) {

(Rules.erase(StrictRule.first)) {

(StrictRule.second)

SubjectMatchRules.push_back(StrictRule.first);

RulesToCheck = Rules;

(

&Rule : RulesToCheck) {

(

ParentRule = getParentAttrMatcherRule(MatchRule)) {

(llvm::any_of(StrictSubjectMatchRuleSet,

[ParentRule](

&StrictRule) {

StrictRule.first == *ParentRule &&

SubjectMatchRules.push_back(MatchRule);

Rules.erase(MatchRule);

(!Rules.empty()) {

(PragmaLoc, diag::err_pragma_attribute_invalid_matchers)

(

&Rule : Rules) {

replacementRangeForListElement(*

, Rule.second));

<< attrMatcherRuleListToString(ExtraRules);

(PragmaLoc, diag::err_pragma_attr_attr_no_push);

{PragmaLoc, &Attribute, std::move(SubjectMatchRules),

});

(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;

(!Entry.IsUsed) {

assert(Entry.Attribute &&

);

(Entry.Attribute->getLoc(), diag::warn_pragma_attribute_unused)

<< *Entry.Attribute;

(PragmaLoc, diag::note_pragma_attribute_region_ends_here);

(PragmaLoc, diag::err_pragma_attribute_stack_mismatch)

<< 0 << Namespace->getName();

(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;

(

&Entry : Group.Entries) {

assert(Attribute &&

);

);

Applies =

;

(

&Rule : Entry.MatchRules) {

Entry.IsUsed =

;

diag::note_pragma_attribute_applied_decl_here);

);

diag::warn_excess_precision_not_supported)

<<

(

);

(

, diag::err_pragma_expected_file_scope) <<

;

(

, diag::err_pragma_expected_file_scope) <<

;

StringRef Name = FD->

();

std::tie(Section,

) = It->second;

(!FD->

<SectionAttr>())

(FD->

<MinSizeAttr>() || FD->

<AlwaysInlineAttr>())

(!FD->

<OptimizeNoneAttr>())

(!FD->

<NoInlineAttr>())

FD->

(NoBuiltinAttr::CreateImplicit(

,

.data(),

.size()));

std::vector<std::pair<unsigned, SourceLocation> >

;

rawType = Stack->back().first;

VisibilityAttr::VisibilityType

= (VisibilityAttr::VisibilityType) rawType;

Stack->push_back(std::make_pair(

, loc));

VisibilityAttr::VisibilityType

;

(!VisibilityAttr::ConvertStrToVisibilityType(VisType->

(),

)) {

(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType;

(

, diag::err_setting_eval_method_used_in_unsafe_context)

NewFPFeatures.setAllowFPReassociateOverride(IsEnabled);

NewFPFeatures.setAllowReciprocalOverride(IsEnabled);

llvm_unreachable(

);

NewFPFeatures.setConstRoundingModeOverride(FPR);

NewFPFeatures.setSpecifiedExceptionModeOverride(FPE);

(

, diag::err_pragma_fenv_requires_precise);

NewFPFeatures.setAllowFEnvAccessOverride(IsEnabled);

NewFPFeatures.setRoundingMathOverride(IsEnabled);

NewFPFeatures.setComplexRangeOverride(

);

(EndLoc, diag::err_pragma_pop_visibility_mismatch);

std::pair<unsigned, SourceLocation> *Back = &Stack->back();

(StartsWithPragma && IsNamespaceEnd) {

(Back->second, diag::err_pragma_push_visibility_mismatch);

(EndLoc, diag::note_surrounding_namespace_ends_here);

Back = &Stack->back();

}

(StartsWithPragma);

}

(!StartsWithPragma && !IsNamespaceEnd) {

(EndLoc, diag::err_pragma_pop_visibility_mismatch);

(Back->second, diag::note_surrounding_namespace_starts_here);

<

Ty>

SkipArgCountCheck) {

(!SkipArgCountCheck) {

SkipArgCountCheck) {

return ::checkCommonAttributeFeatures(*

,

, A, SkipArgCountCheck);

SkipArgCountCheck) {

return ::checkCommonAttributeFeatures(*

, S, A, SkipArgCountCheck);

llvm::MachO::Record Record

Defines the clang::Preprocessor interface.

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

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

std::vector< std::pair< unsigned, SourceLocation > > VisStack

static void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc)

static void addGslOwnerPointerAttributeIfNotExisting(ASTContext &Context, CXXRecordDecl *Record)

virtual bool HandleTopLevelDecl(DeclGroupRef D)

HandleTopLevelDecl - Handle the specified top-level declaration.

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

TranslationUnitDecl * getTranslationUnitDecl() const

llvm::StringMap< SectionInfo > SectionInfos

QualType getPointerType(QualType T) const

Return the uniqued reference to the type for a pointer to the specified type.

const TargetInfo & getTargetInfo() const

Attr - This represents one attribute.

Represents a C++ struct/union/class.

Represents a character-granular source range.

static CharSourceRange getCharRange(SourceRange R)

static CharSourceRange getTokenRange(SourceRange R)

static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)

bool isFileContext() const

DeclContext * getRedeclContext()

getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...

void addDecl(Decl *D)

Add the declaration D into this context.

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

bool isInStdNamespace() const

SourceLocation getLocation() const

redecl_range redecls() const

Returns an iterator range for all the redeclarations of the same decl.

bool isUsed(bool CheckUsedAttr=true) const

Whether any (re-)declaration of the entity was used, meaning that a definition is required.

DeclContext * getDeclContext()

SourceLocation getBeginLoc() const LLVM_READONLY

virtual Decl * getCanonicalDecl()

Retrieves the "canonical" declaration of the given declaration.

The name of a declaration.

SourceLocation getBeginLoc() const LLVM_READONLY

A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine a...

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

This represents one expression.

bool isValueDependent() const

Determines whether the value of this expression depends on.

bool isTypeDependent() const

Determines whether the type of this expression depends on.

bool isLValue() const

isLValue - True if this expression is an "l-value" according to the rules of the current language.

bool EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx, ConstantExprKind Kind=ConstantExprKind::Normal) const

Evaluate an expression that is required to be a constant expression.

std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const

isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.

Represents difference between two FPOptions values.

void setAllowFPContractAcrossStatement()

void setFPPreciseEnabled(bool Value)

void setAllowFPContractWithinStatement()

FPOptions applyOverrides(FPOptions Base)

void setDisallowFPContract()

LangOptions::FPExceptionModeKind getExceptionMode() const

static FixItHint CreateRemoval(CharSourceRange RemoveRange)

Create a code modification hint that removes the given source range.

static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)

Create a code modification hint that inserts the given code string at a specific location.

Represents a function declaration or definition.

const ParmVarDecl * getParamDecl(unsigned i) const

unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const

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

bool isDeleted() const

Whether this function has been deleted.

bool isDefaulted() const

Whether this function is defaulted.

unsigned getNumParams() const

Return the number of parameters this function must have based on its FunctionType.

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

StringRef getName() const

Return the actual identifier string.

static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)

An lvalue reference type, per C++11 [dcl.ref].

ComplexRangeKind

Controls the various implementations for complex multiplication and.

FPEvalMethodKind

Possible float expression evaluation method choices.

@ FEM_Extended

Use extended type for fp arithmetic.

@ FEM_Double

Use the type double for fp arithmetic.

@ FEM_UnsetOnCommandLine

Used only for FE option processing; this is only used to indicate that the user did not specify an ex...

@ FEM_Source

Use the declared type for fp arithmetic.

PragmaMSPointersToMembersKind

FPExceptionModeKind

Possible floating point exception behavior.

@ FPE_Strict

Strictly preserve the floating-point exception semantics.

@ FPE_Ignore

Assume that floating-point exceptions are masked.

static SourceLocation findLocationAfterToken(SourceLocation loc, tok::TokenKind TKind, const SourceManager &SM, const LangOptions &LangOpts, bool SkipTrailingWhitespaceAndNewLine)

Checks that the given token is the first token that occurs after the given location (this excludes co...

Represents the results of name lookup.

DeclClass * getAsSingle() const

bool empty() const

Return true if no decls were found.

This represents a decl that may have a name.

@ VisibilityForValue

Do an LV computation for, ultimately, a non-type declaration.

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.

std::optional< Visibility > getExplicitVisibility(ExplicitVisibilityKind kind) const

If visibility was explicitly specified for this declaration, return that visibility.

Represents a parameter to a function.

ParsedAttr - Represents a syntactic attribute.

bool hasCustomParsing() const

bool appliesToDecl(const Decl *D, attr::SubjectMatchRule MatchRule) const

unsigned getMinArgs() const

bool checkExactlyNumArgs(class Sema &S, unsigned Num) const

Check if the attribute has exactly as many args as Num.

bool hasVariadicArg() const

bool diagnoseMutualExclusion(class Sema &S, const Decl *D) const

bool diagnoseAppertainsTo(class Sema &S, const Decl *D) const

bool checkAtLeastNumArgs(class Sema &S, unsigned Num) const

Check if the attribute has at least as many args as Num.

unsigned getMaxArgs() const

bool isPragmaClangAttribute() const

True if the attribute is specified using '#pragma clang attribute'.

AttributeCommonInfo::Kind getKind() const

void getMatchRules(const LangOptions &LangOpts, SmallVectorImpl< std::pair< attr::SubjectMatchRule, bool > > &MatchRules) const

bool diagnoseLangOpts(class Sema &S) const

void setIsPragmaClangAttribute()

bool checkAtMostNumArgs(class Sema &S, unsigned Num) const

Check if the attribute has at most as many args as Num.

void addAtEnd(ParsedAttr *newAttr)

static PragmaDetectMismatchDecl * Create(const ASTContext &C, TranslationUnitDecl *DC, SourceLocation Loc, StringRef Name, StringRef Value)

SourceLocation getLastFPEvalPragmaLocation() const

void setCurrentFPEvalMethod(SourceLocation PragmaLoc, LangOptions::FPEvalMethodKind Val)

A (possibly-)qualified type.

const Type * getTypePtr() const

Retrieves a pointer to the underlying (unqualified) type.

QualType getNonReferenceType() const

If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...

QualType getCanonicalType() const

Represents a struct/union/class.

redecl_range redecls() const

Returns an iterator range for all the redeclarations of the same decl.

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

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

Emit a diagnostic.

unsigned getPackNumber() const

Mode getAlignMode() const

~PragmaStackSentinelRAII()

PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct)

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

void ActOnPragmaMSOptimize(SourceLocation Loc, bool IsOn)

#pragma optimize("[optimization-list]", on | off).

bool ConstantFoldAttrArgs(const AttributeCommonInfo &CI, MutableArrayRef< Expr * > Args)

ConstantFoldAttrArgs - Folds attribute arguments into ConstantExprs (unless they are value dependent ...

void ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc, const IdentifierInfo *Namespace)

@ LookupOrdinaryName

Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....

void ActOnPragmaAttributePop(SourceLocation PragmaLoc, const IdentifierInfo *Namespace)

Called on well-formed '#pragma clang attribute pop'.

void ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name, StringRef Value)

ActOnPragmaDetectMismatch - Call on well-formed #pragma detect_mismatch.

const Decl * PragmaAttributeCurrentTargetDecl

The declaration that is currently receiving an attribute from the #pragma attribute stack.

void ActOnPragmaFEnvRound(SourceLocation Loc, llvm::RoundingMode)

Called to set constant rounding mode for floating point operations.

PragmaClangSection PragmaClangRodataSection

bool checkSectionName(SourceLocation LiteralLoc, StringRef Str)

void AddPragmaAttributes(Scope *S, Decl *D)

Adds the attributes that have been specified using the '#pragma clang attribute push' directives to t...

bool checkCommonAttributeFeatures(const Decl *D, const ParsedAttr &A, bool SkipArgCountCheck=false)

Handles semantic checking for features that are common to all attributes, such as checking whether a ...

void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc)

Adds the 'optnone' attribute to the function declaration if there are no conflicts; Loc represents th...

SourceLocation LocationOfExcessPrecisionNotSatisfied

void inferLifetimeCaptureByAttribute(FunctionDecl *FD)

Add [[clang:::lifetime_capture_by(this)]] to STL container methods.

PragmaStack< FPOptionsOverride > FpPragmaStack

PragmaStack< StringLiteral * > CodeSegStack

void AddRangeBasedOptnone(FunctionDecl *FD)

Only called on function definitions; if there is a pragma in scope with the effect of a range-based o...

void ActOnPragmaMSComment(SourceLocation CommentLoc, PragmaMSCommentKind Kind, StringRef Arg)

ActOnPragmaMSComment - Called on well formed #pragma comment(kind, "arg").

SmallVector< AlignPackIncludeState, 8 > AlignPackIncludeStack

void AddAlignmentAttributesForRecord(RecordDecl *RD)

AddAlignmentAttributesForRecord - Adds any needed alignment attributes to a the record decl,...

FPOptionsOverride CurFPFeatureOverrides()

void ActOnPragmaMSSeg(SourceLocation PragmaLocation, PragmaMsStackAction Action, llvm::StringRef StackSlotLabel, StringLiteral *SegmentName, llvm::StringRef PragmaName)

Called on well formed #pragma bss_seg/data_seg/const_seg/code_seg.

NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=RedeclarationKind::NotForRedeclaration)

Look up a name, looking for a single declaration.

void ActOnPragmaFloatControl(SourceLocation Loc, PragmaMsStackAction Action, PragmaFloatControlKind Value)

ActOnPragmaFloatControl - Call on well-formed #pragma float_control.

void ActOnPragmaMSPointersToMembers(LangOptions::PragmaMSPointersToMembersKind Kind, SourceLocation PragmaLoc)

ActOnPragmaMSPointersToMembers - called on well formed #pragma pointers_to_members(representation met...

void DiagnosePrecisionLossInComplexDivision()

void ActOnPragmaUnused(const Token &Identifier, Scope *curScope, SourceLocation PragmaLoc)

ActOnPragmaUnused - Called on well-formed '#pragma unused'.

void ActOnPragmaMSAllocText(SourceLocation PragmaLocation, StringRef Section, const SmallVector< std::tuple< IdentifierInfo *, SourceLocation > > &Functions)

Called on well-formed #pragma alloc_text().

PragmaStack< bool > StrictGuardStackCheckStack

void ActOnPragmaAttributeAttribute(ParsedAttr &Attribute, SourceLocation PragmaLoc, attr::ParsedSubjectMatchRuleSet Rules)

PragmaStack< StringLiteral * > ConstSegStack

ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)

ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.

void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind, SourceLocation PragmaLoc)

ActOnPragmaOptionsAlign - Called on well formed #pragma options align.

void ActOnPragmaCXLimitedRange(SourceLocation Loc, LangOptions::ComplexRangeKind Range)

ActOnPragmaCXLimitedRange - Called on well formed #pragma STDC CX_LIMITED_RANGE.

void ActOnPragmaFPExceptions(SourceLocation Loc, LangOptions::FPExceptionModeKind)

Called on well formed '#pragma clang fp' that has option 'exceptions'.

void inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord)

Add gsl::Pointer attribute to std::container::iterator.

void ActOnPragmaFPEvalMethod(SourceLocation Loc, LangOptions::FPEvalMethodKind Value)

void ActOnPragmaClangSection(SourceLocation PragmaLoc, PragmaClangSectionAction Action, PragmaClangSectionKind SecKind, StringRef SecName)

ActOnPragmaClangSection - Called on well formed #pragma clang section.

bool UnifySection(StringRef SectionName, int SectionFlags, NamedDecl *TheDecl)

void setExceptionMode(SourceLocation Loc, LangOptions::FPExceptionModeKind)

Called to set exception behavior for floating point operations.

void PrintPragmaAttributeInstantiationPoint()

void inferGslOwnerPointerAttribute(CXXRecordDecl *Record)

Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.

const LangOptions & getLangOpts() const

SourceLocation CurInitSegLoc

void ActOnPragmaMSVtorDisp(PragmaMsStackAction Action, SourceLocation PragmaLoc, MSVtorDispMode Value)

Called on well formed #pragma vtordisp().

void inferLifetimeBoundAttribute(FunctionDecl *FD)

Add [[clang:::lifetimebound]] attr for std:: functions and methods.

bool MSPragmaOptimizeIsOn

The "on" or "off" argument passed by #pragma optimize, that denotes whether the optimizations in the ...

SmallVector< PragmaAttributeGroup, 2 > PragmaAttributeStack

const LangOptions & LangOpts

PragmaClangSection PragmaClangRelroSection

SourceLocation ImplicitMSInheritanceAttrLoc

Source location for newly created implicit MSInheritanceAttrs.

void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AttrList, const ProcessDeclAttributeOptions &Options=ProcessDeclAttributeOptions())

ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...

void AddImplicitMSFunctionNoBuiltinAttr(FunctionDecl *FD)

Only called on function definitions; if there is a pragma in scope with the effect of a range-based n...

PragmaStack< AlignPackInfo > AlignPackStack

PragmaStack< StringLiteral * > BSSSegStack

llvm::StringMap< std::tuple< StringRef, SourceLocation > > FunctionToSectionMap

Sections used with #pragma alloc_text.

llvm::SmallSetVector< StringRef, 4 > MSFunctionNoBuiltins

Set of no-builtin functions listed by #pragma function.

void AddPushedVisibilityAttribute(Decl *RD)

AddPushedVisibilityAttribute - If '#pragma GCC visibility' was used, add an appropriate visibility at...

StringLiteral * CurInitSeg

Last section used with #pragma init_seg.

DeclContext * CurContext

CurContext - This is the current declaration context of parsing.

void ActOnPragmaMSFunction(SourceLocation Loc, const llvm::SmallVectorImpl< StringRef > &NoBuiltins)

Call on well formed #pragma function.

void ActOnPragmaMSStruct(PragmaMSStructKind Kind)

ActOnPragmaMSStruct - Called on well formed #pragma ms_struct [on|off].

bool isPreciseFPEnabled()

Are precise floating point semantics currently enabled?

void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation, StringLiteral *SegmentName)

Called on well-formed #pragma init_seg().

SourceManager & getSourceManager() const

void DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind, SourceLocation IncludeLoc)

PragmaClangSection PragmaClangTextSection

void ActOnPragmaFPValueChangingOption(SourceLocation Loc, PragmaFPKind Kind, bool IsEnabled)

Called on well formed #pragma clang fp reassociate or #pragma clang fp reciprocal.

std::vector< std::pair< QualType, unsigned > > ExcessPrecisionNotSatisfied

PragmaClangSection PragmaClangDataSection

llvm::Error isValidSectionSpecifier(StringRef Str)

Used to implement to perform semantic checking on attribute((section("foo"))) specifiers.

void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr, SourceLocation Loc)

PushNamespaceVisibilityAttr - Note that we've entered a namespace with a visibility attribute.

PragmaStack< MSVtorDispMode > VtorDispStack

Whether to insert vtordisps prior to virtual bases in the Microsoft C++ ABI.

void AddMsStructLayoutForRecord(RecordDecl *RD)

AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.

void * VisContext

VisContext - Manages the stack for #pragma GCC visibility.

bool CheckAttrTarget(const ParsedAttr &CurrAttr)

PragmaAlignPackDiagnoseKind

@ NonDefaultStateAtInclude

Scope * TUScope

Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...

void DiagnoseUnterminatedPragmaAttribute()

void FreeVisContext()

FreeVisContext - Deallocate and null out VisContext.

void ModifyFnAttributesMSPragmaOptimize(FunctionDecl *FD)

Only called on function definitions; if there is a MSVC #pragma optimize in scope,...

void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc)

PopPragmaVisibility - Pop the top element of the visibility stack; used for '#pragma GCC visibility' ...

SourceManager & SourceMgr

void ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action, StringRef SlotLabel, Expr *Alignment)

ActOnPragmaPack - Called on well formed #pragma pack(...).

DiagnosticsEngine & Diags

void DiagnoseUnterminatedPragmaAlignPack()

PragmaStack< StringLiteral * > DataSegStack

void ActOnPragmaVisibility(const IdentifierInfo *VisType, SourceLocation PragmaLoc)

ActOnPragmaVisibility - Called on well formed #pragma GCC visibility... .

SourceLocation OptimizeOffPragmaLocation

This represents the last location of a "#pragma clang optimize off" directive if such a directive has...

LangOptions::PragmaMSPointersToMembersKind MSPointerToMemberRepresentationMethod

Controls member pointer representation format under the MS ABI.

void ActOnPragmaMSStrictGuardStackCheck(SourceLocation PragmaLocation, PragmaMsStackAction Action, bool Value)

ActOnPragmaMSStrictGuardStackCheck - Called on well formed #pragma strict_gs_check.

PragmaClangSection PragmaClangBSSSection

void ActOnPragmaFPContract(SourceLocation Loc, LangOptions::FPModeKind FPC)

ActOnPragmaFPContract - Called on well formed #pragma {STDC,OPENCL} FP_CONTRACT and #pragma clang fp ...

void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc)

Called on well formed #pragma clang optimize.

bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)

Perform unqualified name lookup starting from a given scope.

void ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled)

ActOnPragmaFenvAccess - Called on well formed #pragma STDC FENV_ACCESS.

void AddSectionMSAllocText(FunctionDecl *FD)

Only called on function definitions; if there is a #pragma alloc_text that decides which code section...

void ActOnPragmaMSSection(SourceLocation PragmaLocation, int SectionFlags, StringLiteral *SegmentName)

Called on well formed #pragma section().

PragmaClangSectionKind

pragma clang section kind

void inferNullableClassAttribute(CXXRecordDecl *CRD)

Add _Nullable attributes for std:: types.

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

A trivial tuple used to represent a source range.

SourceLocation getEnd() const

SourceLocation getBegin() const

Stmt - This represents one statement.

SourceLocation getBeginLoc() const LLVM_READONLY

StringLiteral - This represents a string literal expression, e.g.

SourceLocation getBeginLoc() const LLVM_READONLY

StringRef getString() const

bool isMicrosoft() const

Is this ABI an MSVC-compatible ABI?

bool hasAlignMac68kSupport() const

Check whether this target support '#pragma options align=mac68k'.

TargetCXXABI getCXXABI() const

Get the C++ ABI currently in use.

Token - This structure provides full information about a lexed token.

IdentifierInfo * getIdentifierInfo() const

SourceLocation getLocation() const

Return a source location identifier for the specified offset in the current file.

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...

bool isFunctionType() const

Base class for declarations which introduce a typedef-name.

QualType getUnderlyingType() const

Represents a variable declaration or definition.

Defines the clang::TargetInfo interface.

const internal::VariadicAllOfMatcher< Attr > attr

Matches attributes.

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

llvm::DenseMap< int, SourceRange > ParsedSubjectMatchRuleSet

SubjectMatchRule

A list of all the recognized kinds of attributes.

const char * getSubjectMatchRuleSpelling(SubjectMatchRule Rule)

bool isGLSPointerType(QualType QT)

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

@ Nullable

Values of this type can be null.

@ AANT_ArgumentConstantExpr

@ Result

The result type of a method or function.

MSVtorDispMode

In the Microsoft ABI, this controls the placement of virtual displacement members used to implement v...

@ VK_PRValue

A pr-value expression (in the C++11 taxonomy) produces a temporary value.

const FunctionProtoType * T

EvalResult is a struct with detailed info about an evaluated expression.

APValue Val

Val - This is the value the expression can be folded to.

SmallVectorImpl< PartialDiagnosticAt > * Diag

Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...

AlignPackInfo CurrentValue

SourceLocation CurrentPragmaLocation

This an attribute introduced by #pragma clang attribute.

SourceLocation PragmaLocation

void SentinelAction(PragmaMsStackAction Action, StringRef Label)

SmallVector< Slot, 2 > Stack

void Act(SourceLocation PragmaLocation, PragmaMsStackAction Action, llvm::StringRef StackSlotLabel, ValueType Value)

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