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>())
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);
220 "auto_ptr",
"shared_ptr",
"unique_ptr",
"exception_ptr",
221 "coroutine_handle",
"function",
"move_only_function",
225 !CRD->
hasAttr<TypeNullableAttr>())
227 Redecl->addAttr(TypeNullableAttr::CreateImplicit(
Context));
257 Diag(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported);
272 Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed)
311 llvm_unreachable(
"invalid clang section kind");
320 Diag(PragmaLoc, diag::err_pragma_section_invalid_for_target)
335 StringRef SlotLabel,
Expr *alignment) {
338 if (IsXLPragma && !SlotLabel.empty()) {
339 Diag(PragmaLoc, diag::err_pragma_pack_identifer_not_supported);
344 Expr *Alignment =
static_cast<Expr *
>(alignment);
347 unsigned AlignmentVal = 0;
351 std::optional<llvm::APSInt> Val;
357 !(*Val == 0 || Val->isPowerOf2()) || Val->getZExtValue() > 16) {
358 Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment);
362 if (IsXLPragma && *Val == 0) {
364 Diag(PragmaLoc, diag::err_pragma_pack_invalid_alignment);
368 AlignmentVal = (
unsigned)Val->getZExtValue();
378 Diag(PragmaLoc, diag::warn_pragma_pack_show) <<
"mac68k";
380 Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;
386 if (Alignment && !SlotLabel.empty())
387 Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifier_and_alignment);
390 "Empty pack stack can only be at Native alignment mode.");
391 Diag(PragmaLoc, diag::warn_pragma_pop_failed) <<
"pack" <<
"stack empty";
403 for (
unsigned Idx = 0; Idx < Args.size(); Idx++) {
404 Expr *&E = Args.begin()[Idx];
405 assert(E &&
"error are handled before");
413 clang::CK_ArrayToPointerDecay)
418 clang::CK_FunctionToPointerDecay, E,
nullptr,
422 clang::CK_LValueToRValue, E,
nullptr,
434 if (!
Result || !Notes.empty()) {
437 for (
auto &
Note : Notes)
457 bool HasNonDefaultValue =
464 HasNonDefaultValue,
false});
477 Diag(IncludeLoc, diag::warn_pragma_pack_non_default_at_include);
482 Diag(IncludeLoc, diag::warn_pragma_pack_modified_after_include);
490 bool IsInnermost =
true;
495 for (
const auto &StackSlot : llvm::reverse(
AlignPackStack.Stack)) {
496 Diag(StackSlot.PragmaPushLocation, diag::warn_pragma_pack_no_pop_eof);
502 diag::note_pragma_pack_pop_instead_reset);
539 llvm_unreachable(
"invalid pragma eval_method kind");
551 Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 0;
553 Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 1;
555 Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 2;
569 Diag(Loc, diag::err_pragma_fc_pp_scope);
574 llvm_unreachable(
"invalid pragma float_control kind");
581 Diag(Loc, diag::err_pragma_fc_noprecise_requires_noexcept);
583 Diag(Loc, diag::err_pragma_fc_noprecise_requires_nofenv);
590 Diag(Loc, diag::err_pragma_fc_except_requires_precise);
604 Diag(Loc, diag::warn_pragma_pop_failed) <<
"float_control"
626 Diag(PragmaLoc, diag::warn_pragma_pop_failed) <<
"vtordisp"
634 llvm::StringRef StackSlotLabel,
635 AlignPackInfo
Value) {
637 CurrentValue = DefaultValue;
638 CurrentPragmaLocation = PragmaLocation;
642 Stack.emplace_back(Slot(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
645 if (!StackSlotLabel.empty()) {
647 auto I = llvm::find_if(llvm::reverse(Stack), [&](
const Slot &x) {
648 return x.StackSlotLabel == StackSlotLabel;
651 if (I != Stack.rend()) {
652 CurrentValue = I->Value;
653 CurrentPragmaLocation = I->PragmaLocation;
654 Stack.erase(std::prev(I.base()), Stack.end());
656 }
else if (
Value.IsXLStack() &&
Value.IsAlignAttr() &&
657 CurrentValue.IsPackAttr()) {
660 auto I = llvm::find_if(llvm::reverse(Stack), [&](
const Slot &x) {
661 return x.Value.IsAlignAttr();
664 if (I != Stack.rend()) {
665 Stack.erase(std::prev(I.base()), Stack.end());
667 CurrentValue = DefaultValue;
668 CurrentPragmaLocation = PragmaLocation;
670 CurrentValue = Stack.back().Value;
671 CurrentPragmaLocation = Stack.back().PragmaLocation;
675 }
else if (!Stack.empty()) {
678 if (
Value.IsXLStack() &&
Value.IsPackAttr() && CurrentValue.IsAlignAttr())
682 CurrentValue = Stack.back().Value;
683 CurrentPragmaLocation = Stack.back().PragmaLocation;
688 CurrentValue =
Value;
689 CurrentPragmaLocation = PragmaLocation;
698 PragmaLocation = A->getLocation();
706 const auto &Section = SectionIt->second;
707 if (Section.SectionFlags == SectionFlags ||
713 Diag(Section.
Decl->getLocation(), diag::note_declared_at)
714 << Section.
Decl->getName();
716 Diag(PragmaLocation, diag::note_pragma_entered_here);
717 if (Section.PragmaSectionLocation.isValid())
718 Diag(Section.PragmaSectionLocation, diag::note_pragma_entered_here);
727 const auto &Section = SectionIt->second;
728 if (Section.SectionFlags == SectionFlags)
731 Diag(PragmaSectionLocation, diag::err_section_conflict)
732 <<
"this" << Section;
734 Diag(Section.Decl->getLocation(), diag::note_declared_at)
735 << Section.Decl->getName();
736 if (Section.PragmaSectionLocation.isValid())
737 Diag(Section.PragmaSectionLocation, diag::note_pragma_entered_here);
749 llvm::StringRef StackSlotLabel,
751 llvm::StringRef PragmaName) {
753 llvm::StringSwitch<PragmaStack<StringLiteral *> *>(PragmaName)
758 if (Action &
PSK_Pop && Stack->Stack.empty())
759 Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName
765 if (SegmentName->
getString() ==
".drectve" &&
767 Diag(PragmaLocation, diag::warn_attribute_section_drectve) << PragmaName;
770 Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName);
778 Diag(PragmaLocation, diag::warn_pragma_pop_failed) <<
"strict_gs_check"
801 const SmallVector<std::tuple<IdentifierInfo *, SourceLocation>>
804 Diag(PragmaLocation, diag::err_pragma_expected_file_scope) <<
"alloc_text";
816 Diag(Loc, diag::err_undeclared_use) << II->
getName();
822 Diag(Loc, diag::err_pragma_alloc_text_not_function);
827 Diag(Loc, diag::err_pragma_alloc_text_c_linkage);
842 if (Lookup.
empty()) {
843 Diag(PragmaLoc, diag::warn_pragma_unused_undeclared_var)
850 Diag(PragmaLoc, diag::warn_pragma_unused_expected_var_arg)
857 Diag(PragmaLoc, diag::warn_used_but_marked_unused) << Name;
860 UnusedAttr::GNU_unused));
870 if (D->
hasAttr<CFAuditedTransferAttr>() ||
871 D->
hasAttr<CFUnknownTransferAttr>())
881std::optional<attr::SubjectMatchRule>
883 using namespace attr;
887#define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)
888#define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated) \
891#include "clang/Basic/AttrSubMatchRulesList.inc"
896 using namespace attr;
900#define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)
901#define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated) \
904#include "clang/Basic/AttrSubMatchRulesList.inc"
923 llvm::raw_string_ostream
OS(
Result);
924 for (
const auto &I : llvm::enumerate(Rules)) {
926 OS << (I.index() == Rules.size() - 1 ?
", and " :
", ");
941 StrictSubjectMatchRuleSet;
945 if (StrictSubjectMatchRuleSet.empty()) {
952 llvm::SmallDenseMap<int, std::pair<int, SourceRange>, 2>
953 RulesToFirstSpecifiedNegatedSubRule;
954 for (
const auto &Rule : Rules) {
956 std::optional<attr::SubjectMatchRule> ParentRule =
957 getParentAttrMatcherRule(MatchRule);
960 auto It = Rules.find(*ParentRule);
961 if (It != Rules.end()) {
963 Diag(Rule.second.getBegin(),
964 diag::err_pragma_attribute_matcher_subrule_contradicts_rule)
968 replacementRangeForListElement(*
this, Rule.second));
973 if (isNegatedAttrMatcherSubRule(MatchRule))
974 RulesToFirstSpecifiedNegatedSubRule.insert(
975 std::make_pair(*ParentRule, Rule));
977 bool IgnoreNegatedSubRules =
false;
978 for (
const auto &Rule : Rules) {
980 std::optional<attr::SubjectMatchRule> ParentRule =
981 getParentAttrMatcherRule(MatchRule);
984 auto It = RulesToFirstSpecifiedNegatedSubRule.find(*ParentRule);
985 if (It != RulesToFirstSpecifiedNegatedSubRule.end() &&
986 It->second != Rule) {
989 It->second.second.getBegin(),
991 err_pragma_attribute_matcher_negated_subrule_contradicts_subrule)
996 replacementRangeForListElement(*
this, It->second.second));
998 IgnoreNegatedSubRules =
true;
999 RulesToFirstSpecifiedNegatedSubRule.erase(It);
1003 if (!IgnoreNegatedSubRules) {
1004 for (
const auto &Rule : Rules)
1007 for (
const auto &Rule : Rules) {
1019 for (
const auto &StrictRule : StrictSubjectMatchRuleSet) {
1021 if (Rules.erase(StrictRule.first)) {
1024 if (StrictRule.second)
1025 SubjectMatchRules.push_back(StrictRule.first);
1029 auto RulesToCheck = Rules;
1030 for (
const auto &Rule : RulesToCheck) {
1032 if (
auto ParentRule = getParentAttrMatcherRule(MatchRule)) {
1033 if (llvm::any_of(StrictSubjectMatchRuleSet,
1034 [ParentRule](
const auto &StrictRule) {
1035 return StrictRule.first == *ParentRule &&
1038 SubjectMatchRules.push_back(MatchRule);
1039 Rules.erase(MatchRule);
1045 if (!Rules.empty()) {
1047 Diag(PragmaLoc, diag::err_pragma_attribute_invalid_matchers)
1050 for (
const auto &Rule : Rules) {
1053 replacementRangeForListElement(*
this, Rule.second));
1055 Diagnostic << attrMatcherRuleListToString(ExtraRules);
1059 Diag(PragmaLoc, diag::err_pragma_attr_attr_no_push);
1064 {PragmaLoc, &
Attribute, std::move(SubjectMatchRules),
false});
1077 Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;
1090 if (!Entry.IsUsed) {
1091 assert(Entry.Attribute &&
"Expected an attribute");
1092 Diag(Entry.Attribute->getLoc(), diag::warn_pragma_attribute_unused)
1093 << *Entry.Attribute;
1094 Diag(PragmaLoc, diag::note_pragma_attribute_region_ends_here);
1103 Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch)
1104 << 0 << Namespace->getName();
1106 Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;
1113 for (
auto &Entry : Group.Entries) {
1115 assert(
Attribute &&
"Expected an attribute");
1116 assert(
Attribute->isPragmaClangAttribute() &&
1117 "expected #pragma clang attribute");
1120 bool Applies =
false;
1121 for (
const auto &Rule : Entry.MatchRules) {
1122 if (
Attribute->appliesToDecl(D, Rule)) {
1129 Entry.IsUsed =
true;
1142 diag::note_pragma_attribute_applied_decl_here);
1160 Diag(Loc, diag::err_pragma_expected_file_scope) <<
"optimize";
1170 Diag(Loc, diag::err_pragma_expected_file_scope) <<
"function";
1188 StringRef Name = FD->
getName();
1193 std::tie(Section, Loc) = It->second;
1195 if (!FD->
hasAttr<SectionAttr>())
1210 if (FD->
hasAttr<MinSizeAttr>() || FD->
hasAttr<AlwaysInlineAttr>())
1215 if (!FD->
hasAttr<OptimizeNoneAttr>())
1217 if (!FD->
hasAttr<NoInlineAttr>())
1228typedef std::vector<std::pair<unsigned, SourceLocation> >
VisStack;
1240 unsigned rawType = Stack->back().first;
1243 VisibilityAttr::VisibilityType
type
1244 = (VisibilityAttr::VisibilityType) rawType;
1262 Stack->push_back(std::make_pair(
type, loc));
1269 VisibilityAttr::VisibilityType
T;
1270 if (!VisibilityAttr::ConvertStrToVisibilityType(VisType->
getName(),
T)) {
1271 Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType;
1294 llvm_unreachable(
"Should not happen");
1316 Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context)
1323 NewFPFeatures.setAllowFPReassociateOverride(IsEnabled);
1326 NewFPFeatures.setAllowReciprocalOverride(IsEnabled);
1329 llvm_unreachable(
"unhandled value changing pragma fp");
1338 NewFPFeatures.setConstRoundingModeOverride(FPR);
1346 NewFPFeatures.setSpecifiedExceptionModeOverride(FPE);
1359 Diag(Loc, diag::err_pragma_fenv_requires_precise);
1361 NewFPFeatures.setAllowFEnvAccessOverride(IsEnabled);
1362 NewFPFeatures.setRoundingMathOverride(IsEnabled);
1370 NewFPFeatures.setComplexRangeOverride(Range);
1391 Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
1398 const std::pair<unsigned, SourceLocation> *Back = &Stack->back();
1400 if (StartsWithPragma && IsNamespaceEnd) {
1401 Diag(Back->second, diag::err_pragma_push_visibility_mismatch);
1402 Diag(EndLoc, diag::note_surrounding_namespace_ends_here);
1407 Back = &Stack->back();
1409 }
while (StartsWithPragma);
1410 }
else if (!StartsWithPragma && !IsNamespaceEnd) {
1411 Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
1412 Diag(Back->second, diag::note_surrounding_namespace_starts_here);
1422template <
typename Ty>
1425 bool SkipArgCountCheck) {
1451 if (!SkipArgCountCheck) {
1471 bool SkipArgCountCheck) {
1472 return ::checkCommonAttributeFeatures(*
this, D, A, SkipArgCountCheck);
1475 bool SkipArgCountCheck) {
1476 return ::checkCommonAttributeFeatures(*
this, 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) ...
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.
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)
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.
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.
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...
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 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().
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.
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
void ActOnPragmaFPValueChangingOption(SourceLocation Loc, PragmaFPKind Kind, bool IsEnabled)
Called on well formed #pragma clang fp reassociate or #pragma clang fp reciprocal.
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.
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.
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)
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)