31 : S(S), SlotLabel(SlotLabel), ShouldAct(ShouldAct) {
66 }
else if (IsPackSet) {
68 RD->
addAttr(MaxFieldAlignmentAttr::CreateImplicit(
81 if (AlignPackedInclude.CurrentPragmaLocation !=
84 if (AlignPackedInclude.HasNonDefaultValue)
85 AlignPackedInclude.ShouldWarnOnInclude =
true;
97 RD->
addAttr(MSVtorDispAttr::CreateImplicit(
101template <
typename Attribute>
104 if (Record->hasAttr<OwnerAttr>() || Record->hasAttr<PointerAttr>())
107 for (
Decl *Redecl : Record->redecls())
108 Redecl->addAttr(Attribute::CreateImplicit(
Context,
nullptr));
113 if (!UnderlyingRecord)
120 static llvm::StringSet<> Containers{
136 "unordered_multiset",
137 "unordered_multimap",
140 static llvm::StringSet<> Iterators{
"iterator",
"const_iterator",
142 "const_reverse_iterator"};
144 if (
Parent->isInStdNamespace() && Iterators.count(ND->
getName()) &&
145 Containers.count(
Parent->getName()))
146 addGslOwnerPointerAttributeIfNotExisting<PointerAttr>(
Context,
157 dyn_cast<TemplateSpecializationType>(Canonical.
getTypePtr())) {
159 RD = dyn_cast_or_null<CXXRecordDecl>(
160 TST->getTemplateName().getAsTemplateDecl()->getTemplatedDecl());
168 static llvm::StringSet<> StdOwners{
188 "unordered_multiset",
189 "unordered_multimap",
192 static llvm::StringSet<> StdPointers{
198 if (!Record->getIdentifier())
202 if (Record->isInStdNamespace()) {
203 if (Record->hasAttr<OwnerAttr>() || Record->hasAttr<PointerAttr>())
206 if (StdOwners.count(Record->getName()))
207 addGslOwnerPointerAttributeIfNotExisting<OwnerAttr>(
Context, Record);
208 else if (StdPointers.count(Record->getName()))
209 addGslOwnerPointerAttributeIfNotExisting<PointerAttr>(
Context, Record);
247 Diag(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported);
262 Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed)
301 llvm_unreachable(
"invalid clang section kind");
310 Diag(PragmaLoc, diag::err_pragma_section_invalid_for_target)
325 StringRef SlotLabel,
Expr *alignment) {
328 if (IsXLPragma && !SlotLabel.empty()) {
329 Diag(PragmaLoc, diag::err_pragma_pack_identifer_not_supported);
334 Expr *Alignment =
static_cast<Expr *
>(alignment);
337 unsigned AlignmentVal = 0;
341 std::optional<llvm::APSInt> Val;
347 !(*Val == 0 || Val->isPowerOf2()) || Val->getZExtValue() > 16) {
348 Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment);
352 if (IsXLPragma && *Val == 0) {
354 Diag(PragmaLoc, diag::err_pragma_pack_invalid_alignment);
358 AlignmentVal = (
unsigned)Val->getZExtValue();
368 Diag(PragmaLoc, diag::warn_pragma_pack_show) <<
"mac68k";
370 Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;
376 if (Alignment && !SlotLabel.empty())
377 Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifier_and_alignment);
380 "Empty pack stack can only be at Native alignment mode.");
381 Diag(PragmaLoc, diag::warn_pragma_pop_failed) <<
"pack" <<
"stack empty";
393 for (
unsigned Idx = 0; Idx < Args.size(); Idx++) {
394 Expr *&E = Args.begin()[Idx];
395 assert(E &&
"error are handled before");
403 clang::CK_ArrayToPointerDecay)
408 clang::CK_FunctionToPointerDecay, E,
nullptr,
412 clang::CK_LValueToRValue, E,
nullptr,
424 if (!
Result || !Notes.empty()) {
427 for (
auto &
Note : Notes)
447 bool HasNonDefaultValue =
454 HasNonDefaultValue,
false});
467 Diag(IncludeLoc, diag::warn_pragma_pack_non_default_at_include);
472 Diag(IncludeLoc, diag::warn_pragma_pack_modified_after_include);
480 bool IsInnermost =
true;
485 for (
const auto &StackSlot : llvm::reverse(
AlignPackStack.Stack)) {
486 Diag(StackSlot.PragmaPushLocation, diag::warn_pragma_pack_no_pop_eof);
492 diag::note_pragma_pack_pop_instead_reset);
529 llvm_unreachable(
"invalid pragma eval_method kind");
541 Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 0;
543 Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 1;
545 Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 2;
559 Diag(Loc, diag::err_pragma_fc_pp_scope);
564 llvm_unreachable(
"invalid pragma float_control kind");
571 Diag(Loc, diag::err_pragma_fc_noprecise_requires_noexcept);
573 Diag(Loc, diag::err_pragma_fc_noprecise_requires_nofenv);
580 Diag(Loc, diag::err_pragma_fc_except_requires_precise);
594 Diag(Loc, diag::warn_pragma_pop_failed) <<
"float_control"
616 Diag(PragmaLoc, diag::warn_pragma_pop_failed) <<
"vtordisp"
624 llvm::StringRef StackSlotLabel,
625 AlignPackInfo
Value) {
627 CurrentValue = DefaultValue;
628 CurrentPragmaLocation = PragmaLocation;
632 Stack.emplace_back(Slot(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
635 if (!StackSlotLabel.empty()) {
637 auto I = llvm::find_if(llvm::reverse(Stack), [&](
const Slot &x) {
638 return x.StackSlotLabel == StackSlotLabel;
641 if (I != Stack.rend()) {
642 CurrentValue = I->Value;
643 CurrentPragmaLocation = I->PragmaLocation;
644 Stack.erase(std::prev(I.base()), Stack.end());
646 }
else if (
Value.IsXLStack() &&
Value.IsAlignAttr() &&
647 CurrentValue.IsPackAttr()) {
650 auto I = llvm::find_if(llvm::reverse(Stack), [&](
const Slot &x) {
651 return x.Value.IsAlignAttr();
654 if (I != Stack.rend()) {
655 Stack.erase(std::prev(I.base()), Stack.end());
657 CurrentValue = DefaultValue;
658 CurrentPragmaLocation = PragmaLocation;
660 CurrentValue = Stack.back().Value;
661 CurrentPragmaLocation = Stack.back().PragmaLocation;
665 }
else if (!Stack.empty()) {
668 if (
Value.IsXLStack() &&
Value.IsPackAttr() && CurrentValue.IsAlignAttr())
672 CurrentValue = Stack.back().Value;
673 CurrentPragmaLocation = Stack.back().PragmaLocation;
678 CurrentValue =
Value;
679 CurrentPragmaLocation = PragmaLocation;
688 PragmaLocation = A->getLocation();
696 const auto &Section = SectionIt->second;
697 if (Section.SectionFlags == SectionFlags ||
703 Diag(Section.
Decl->getLocation(), diag::note_declared_at)
704 << Section.
Decl->getName();
706 Diag(PragmaLocation, diag::note_pragma_entered_here);
707 if (Section.PragmaSectionLocation.isValid())
708 Diag(Section.PragmaSectionLocation, diag::note_pragma_entered_here);
717 const auto &Section = SectionIt->second;
718 if (Section.SectionFlags == SectionFlags)
721 Diag(PragmaSectionLocation, diag::err_section_conflict)
722 <<
"this" << Section;
724 Diag(Section.Decl->getLocation(), diag::note_declared_at)
725 << Section.Decl->getName();
726 if (Section.PragmaSectionLocation.isValid())
727 Diag(Section.PragmaSectionLocation, diag::note_pragma_entered_here);
739 llvm::StringRef StackSlotLabel,
741 llvm::StringRef PragmaName) {
743 llvm::StringSwitch<PragmaStack<StringLiteral *> *>(PragmaName)
748 if (Action &
PSK_Pop && Stack->Stack.empty())
749 Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName
755 if (SegmentName->
getString() ==
".drectve" &&
757 Diag(PragmaLocation, diag::warn_attribute_section_drectve) << PragmaName;
760 Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName);
768 Diag(PragmaLocation, diag::warn_pragma_pop_failed) <<
"strict_gs_check"
791 const SmallVector<std::tuple<IdentifierInfo *, SourceLocation>>
794 Diag(PragmaLocation, diag::err_pragma_expected_file_scope) <<
"alloc_text";
798 for (
auto &Function : Functions) {
801 std::tie(II, Loc) = Function;
806 Diag(Loc, diag::err_undeclared_use) << II->
getName();
812 Diag(Loc, diag::err_pragma_alloc_text_not_function);
817 Diag(Loc, diag::err_pragma_alloc_text_c_linkage);
832 if (Lookup.
empty()) {
833 Diag(PragmaLoc, diag::warn_pragma_unused_undeclared_var)
840 Diag(PragmaLoc, diag::warn_pragma_unused_expected_var_arg)
847 Diag(PragmaLoc, diag::warn_used_but_marked_unused) << Name;
851 UnusedAttr::GNU_unused));
861 if (D->
hasAttr<CFAuditedTransferAttr>() ||
862 D->
hasAttr<CFUnknownTransferAttr>())
872std::optional<attr::SubjectMatchRule>
874 using namespace attr;
878#define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)
879#define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated) \
882#include "clang/Basic/AttrSubMatchRulesList.inc"
887 using namespace attr;
891#define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)
892#define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated) \
895#include "clang/Basic/AttrSubMatchRulesList.inc"
914 llvm::raw_string_ostream
OS(
Result);
915 for (
const auto &I : llvm::enumerate(Rules)) {
917 OS << (I.index() == Rules.size() - 1 ?
", and " :
", ");
932 StrictSubjectMatchRuleSet;
936 if (StrictSubjectMatchRuleSet.empty()) {
943 llvm::SmallDenseMap<int, std::pair<int, SourceRange>, 2>
944 RulesToFirstSpecifiedNegatedSubRule;
945 for (
const auto &Rule : Rules) {
947 std::optional<attr::SubjectMatchRule> ParentRule =
948 getParentAttrMatcherRule(MatchRule);
951 auto It = Rules.find(*ParentRule);
952 if (It != Rules.end()) {
954 Diag(Rule.second.getBegin(),
955 diag::err_pragma_attribute_matcher_subrule_contradicts_rule)
959 replacementRangeForListElement(*
this, Rule.second));
964 if (isNegatedAttrMatcherSubRule(MatchRule))
965 RulesToFirstSpecifiedNegatedSubRule.insert(
966 std::make_pair(*ParentRule, Rule));
968 bool IgnoreNegatedSubRules =
false;
969 for (
const auto &Rule : Rules) {
971 std::optional<attr::SubjectMatchRule> ParentRule =
972 getParentAttrMatcherRule(MatchRule);
975 auto It = RulesToFirstSpecifiedNegatedSubRule.find(*ParentRule);
976 if (It != RulesToFirstSpecifiedNegatedSubRule.end() &&
977 It->second != Rule) {
980 It->second.second.getBegin(),
982 err_pragma_attribute_matcher_negated_subrule_contradicts_subrule)
987 replacementRangeForListElement(*
this, It->second.second));
989 IgnoreNegatedSubRules =
true;
990 RulesToFirstSpecifiedNegatedSubRule.erase(It);
994 if (!IgnoreNegatedSubRules) {
995 for (
const auto &Rule : Rules)
998 for (
const auto &Rule : Rules) {
1010 for (
const auto &StrictRule : StrictSubjectMatchRuleSet) {
1012 if (Rules.erase(StrictRule.first)) {
1015 if (StrictRule.second)
1016 SubjectMatchRules.push_back(StrictRule.first);
1020 auto RulesToCheck = Rules;
1021 for (
const auto &Rule : RulesToCheck) {
1023 if (
auto ParentRule = getParentAttrMatcherRule(MatchRule)) {
1024 if (llvm::any_of(StrictSubjectMatchRuleSet,
1025 [ParentRule](
const auto &StrictRule) {
1026 return StrictRule.first == *ParentRule &&
1029 SubjectMatchRules.push_back(MatchRule);
1030 Rules.erase(MatchRule);
1036 if (!Rules.empty()) {
1038 Diag(PragmaLoc, diag::err_pragma_attribute_invalid_matchers)
1041 for (
const auto &Rule : Rules) {
1044 replacementRangeForListElement(*
this, Rule.second));
1046 Diagnostic << attrMatcherRuleListToString(ExtraRules);
1050 Diag(PragmaLoc, diag::err_pragma_attr_attr_no_push);
1055 {PragmaLoc, &
Attribute, std::move(SubjectMatchRules),
false});
1068 Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;
1081 if (!Entry.IsUsed) {
1082 assert(Entry.Attribute &&
"Expected an attribute");
1083 Diag(Entry.Attribute->getLoc(), diag::warn_pragma_attribute_unused)
1084 << *Entry.Attribute;
1085 Diag(PragmaLoc, diag::note_pragma_attribute_region_ends_here);
1094 Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch)
1095 << 0 << Namespace->getName();
1097 Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;
1104 for (
auto &Entry : Group.Entries) {
1106 assert(
Attribute &&
"Expected an attribute");
1107 assert(
Attribute->isPragmaClangAttribute() &&
1108 "expected #pragma clang attribute");
1111 bool Applies =
false;
1112 for (
const auto &Rule : Entry.MatchRules) {
1113 if (
Attribute->appliesToDecl(D, Rule)) {
1120 Entry.IsUsed =
true;
1133 diag::note_pragma_attribute_applied_decl_here);
1151 Diag(Loc, diag::err_pragma_expected_file_scope) <<
"optimize";
1161 Diag(Loc, diag::err_pragma_expected_file_scope) <<
"function";
1179 StringRef Name = FD->
getName();
1184 std::tie(Section, Loc) = It->second;
1186 if (!FD->
hasAttr<SectionAttr>())
1201 if (FD->
hasAttr<MinSizeAttr>() || FD->
hasAttr<AlwaysInlineAttr>())
1206 if (!FD->
hasAttr<OptimizeNoneAttr>())
1208 if (!FD->
hasAttr<NoInlineAttr>())
1219typedef std::vector<std::pair<unsigned, SourceLocation> >
VisStack;
1231 unsigned rawType = Stack->back().first;
1234 VisibilityAttr::VisibilityType
type
1235 = (VisibilityAttr::VisibilityType) rawType;
1253 Stack->push_back(std::make_pair(
type, loc));
1260 VisibilityAttr::VisibilityType T;
1261 if (!VisibilityAttr::ConvertStrToVisibilityType(VisType->
getName(), T)) {
1262 Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType;
1285 llvm_unreachable(
"Should not happen");
1306 Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context)
1310 NewFPFeatures.setAllowFPReassociateOverride(IsEnabled);
1317 NewFPFeatures.setConstRoundingModeOverride(FPR);
1325 NewFPFeatures.setSpecifiedExceptionModeOverride(FPE);
1338 Diag(Loc, diag::err_pragma_fenv_requires_precise);
1340 NewFPFeatures.setAllowFEnvAccessOverride(IsEnabled);
1361 Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
1368 const std::pair<unsigned, SourceLocation> *Back = &Stack->back();
1370 if (StartsWithPragma && IsNamespaceEnd) {
1371 Diag(Back->second, diag::err_pragma_push_visibility_mismatch);
1372 Diag(EndLoc, diag::note_surrounding_namespace_ends_here);
1377 Back = &Stack->back();
1379 }
while (StartsWithPragma);
1380 }
else if (!StartsWithPragma && !IsNamespaceEnd) {
1381 Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
1382 Diag(Back->second, diag::note_surrounding_namespace_starts_here);
1392template <
typename Ty>
1395 bool SkipArgCountCheck) {
1421 if (!SkipArgCountCheck) {
1441 bool SkipArgCountCheck) {
1442 return ::checkCommonAttributeFeatures(*
this, D, A, SkipArgCountCheck);
1445 bool SkipArgCountCheck) {
1446 return ::checkCommonAttributeFeatures(*
this, S, A, SkipArgCountCheck);
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.
SourceLocation getLocation() const
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) ...
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
This represents one expression.
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant 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.
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.
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)
FPExceptionModeKind
Possible floating point exception behavior.
@ FPE_Ignore
Assume that floating-point exceptions are masked.
@ FPE_Strict
Strictly preserve the floating-point exception semantics.
FPEvalMethodKind
Possible float expression evaluation method choices.
@ 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.
@ FEM_Double
Use the type double for fp arithmetic.
@ FEM_Extended
Use extended type for fp arithmetic.
PragmaMSPointersToMembersKind
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.
ParsedAttr - Represents a syntactic attribute.
bool hasCustomParsing() 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
AttributeCommonInfo::Kind getKind() const
bool diagnoseLangOpts(class Sema &S) const
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
std::pair< IdentifierInfo *, SourceLocation > getPragmaARCCFCodeAuditedInfo() const
The location of the currently-active #pragma clang arc_cf_code_audited begin.
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.
Scope - A scope is a transient data structure that is used while parsing the program.
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.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
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...
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.
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 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
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
void ActOnPragmaAttributeAttribute(ParsedAttr &Attribute, SourceLocation PragmaLoc, attr::ParsedSubjectMatchRuleSet Rules)
PragmaStack< StringLiteral * > ConstSegStack
void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind, SourceLocation PragmaLoc)
ActOnPragmaOptionsAlign - Called on well formed #pragma options align.
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().
bool MSPragmaOptimizeIsOn
The "on" or "off" argument passed by #pragma optimize, that denotes whether the optimizations in the ...
SmallVector< PragmaAttributeGroup, 2 > PragmaAttributeStack
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
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.
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
void AddCFAuditedAttribute(Decl *D)
AddCFAuditedAttribute - Check whether we're currently within '#pragma clang arc_cf_code_audited' and,...
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
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.
void ActOnPragmaFPReassociate(SourceLocation Loc, bool IsEnabled)
Called on well formed #pragma clang fp reassociate.
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.
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
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.
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.
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)
@ 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.
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)