1 //===--- SemaAttr.cpp - Semantic Analysis for Attributes ------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements semantic analysis for non-trivial attributes and
13 //===----------------------------------------------------------------------===//
15 #include "clang/AST/ASTConsumer.h"
16 #include "clang/AST/Attr.h"
17 #include "clang/AST/Expr.h"
18 #include "clang/Basic/TargetInfo.h"
19 #include "clang/Lex/Preprocessor.h"
20 #include "clang/Sema/Lookup.h"
21 #include "clang/Sema/SemaInternal.h"
22 using namespace clang;
24 //===----------------------------------------------------------------------===//
25 // Pragma 'pack' and 'options align'
26 //===----------------------------------------------------------------------===//
28 Sema::PragmaStackSentinelRAII::PragmaStackSentinelRAII(Sema &S,
31 : S(S), SlotLabel(SlotLabel), ShouldAct(ShouldAct) {
33 S.VtorDispStack.SentinelAction(PSK_Push, SlotLabel);
34 S.DataSegStack.SentinelAction(PSK_Push, SlotLabel);
35 S.BSSSegStack.SentinelAction(PSK_Push, SlotLabel);
36 S.ConstSegStack.SentinelAction(PSK_Push, SlotLabel);
37 S.CodeSegStack.SentinelAction(PSK_Push, SlotLabel);
41 Sema::PragmaStackSentinelRAII::~PragmaStackSentinelRAII() {
43 S.VtorDispStack.SentinelAction(PSK_Pop, SlotLabel);
44 S.DataSegStack.SentinelAction(PSK_Pop, SlotLabel);
45 S.BSSSegStack.SentinelAction(PSK_Pop, SlotLabel);
46 S.ConstSegStack.SentinelAction(PSK_Pop, SlotLabel);
47 S.CodeSegStack.SentinelAction(PSK_Pop, SlotLabel);
51 void Sema::AddAlignmentAttributesForRecord(RecordDecl *RD) {
52 // If there is no pack value, we don't need any attributes.
53 if (!PackStack.CurrentValue)
56 // Otherwise, check to see if we need a max field alignment attribute.
57 if (unsigned Alignment = PackStack.CurrentValue) {
58 if (Alignment == Sema::kMac68kAlignmentSentinel)
59 RD->addAttr(AlignMac68kAttr::CreateImplicit(Context));
61 RD->addAttr(MaxFieldAlignmentAttr::CreateImplicit(Context,
64 if (PackIncludeStack.empty())
66 // The #pragma pack affected a record in an included file, so Clang should
67 // warn when that pragma was written in a file that included the included
69 for (auto &PackedInclude : llvm::reverse(PackIncludeStack)) {
70 if (PackedInclude.CurrentPragmaLocation != PackStack.CurrentPragmaLocation)
72 if (PackedInclude.HasNonDefaultValue)
73 PackedInclude.ShouldWarnOnInclude = true;
77 void Sema::AddMsStructLayoutForRecord(RecordDecl *RD) {
79 RD->addAttr(MSStructAttr::CreateImplicit(Context));
81 // FIXME: We should merge AddAlignmentAttributesForRecord with
82 // AddMsStructLayoutForRecord into AddPragmaAttributesForRecord, which takes
83 // all active pragmas and applies them as attributes to class definitions.
84 if (VtorDispStack.CurrentValue != getLangOpts().VtorDispMode)
86 MSVtorDispAttr::CreateImplicit(Context, VtorDispStack.CurrentValue));
89 void Sema::ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
90 SourceLocation PragmaLoc) {
91 PragmaMsStackAction Action = Sema::PSK_Reset;
92 unsigned Alignment = 0;
94 // For all targets we support native and natural are the same.
96 // FIXME: This is not true on Darwin/PPC.
100 Action = Sema::PSK_Push_Set;
104 // Note that '#pragma options align=packed' is not equivalent to attribute
105 // packed, it has a different precedence relative to attribute aligned.
107 Action = Sema::PSK_Push_Set;
112 // Check if the target supports this.
113 if (!this->Context.getTargetInfo().hasAlignMac68kSupport()) {
114 Diag(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported);
117 Action = Sema::PSK_Push_Set;
118 Alignment = Sema::kMac68kAlignmentSentinel;
122 // Reset just pops the top of the stack, or resets the current alignment to
124 Action = Sema::PSK_Pop;
125 if (PackStack.Stack.empty()) {
126 if (PackStack.CurrentValue) {
127 Action = Sema::PSK_Reset;
129 Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed)
137 PackStack.Act(PragmaLoc, Action, StringRef(), Alignment);
140 void Sema::ActOnPragmaClangSection(SourceLocation PragmaLoc, PragmaClangSectionAction Action,
141 PragmaClangSectionKind SecKind, StringRef SecName) {
142 PragmaClangSection *CSec;
144 case PragmaClangSectionKind::PCSK_BSS:
145 CSec = &PragmaClangBSSSection;
147 case PragmaClangSectionKind::PCSK_Data:
148 CSec = &PragmaClangDataSection;
150 case PragmaClangSectionKind::PCSK_Rodata:
151 CSec = &PragmaClangRodataSection;
153 case PragmaClangSectionKind::PCSK_Text:
154 CSec = &PragmaClangTextSection;
157 llvm_unreachable("invalid clang section kind");
160 if (Action == PragmaClangSectionAction::PCSA_Clear) {
166 CSec->SectionName = SecName;
167 CSec->PragmaLocation = PragmaLoc;
170 void Sema::ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
171 StringRef SlotLabel, Expr *alignment) {
172 Expr *Alignment = static_cast<Expr *>(alignment);
174 // If specified then alignment must be a "small" power of two.
175 unsigned AlignmentVal = 0;
179 // pack(0) is like pack(), which just works out since that is what
180 // we use 0 for in PackAttr.
181 if (Alignment->isTypeDependent() ||
182 Alignment->isValueDependent() ||
183 !Alignment->isIntegerConstantExpr(Val, Context) ||
184 !(Val == 0 || Val.isPowerOf2()) ||
185 Val.getZExtValue() > 16) {
186 Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment);
190 AlignmentVal = (unsigned) Val.getZExtValue();
192 if (Action == Sema::PSK_Show) {
193 // Show the current alignment, making sure to show the right value
195 // FIXME: This should come from the target.
196 AlignmentVal = PackStack.CurrentValue;
197 if (AlignmentVal == 0)
199 if (AlignmentVal == Sema::kMac68kAlignmentSentinel)
200 Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k";
202 Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;
204 // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack:
205 // "#pragma pack(pop, identifier, n) is undefined"
206 if (Action & Sema::PSK_Pop) {
207 if (Alignment && !SlotLabel.empty())
208 Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifer_and_alignment);
209 if (PackStack.Stack.empty())
210 Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << "stack empty";
213 PackStack.Act(PragmaLoc, Action, SlotLabel, AlignmentVal);
216 void Sema::DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind,
217 SourceLocation IncludeLoc) {
218 if (Kind == PragmaPackDiagnoseKind::NonDefaultStateAtInclude) {
219 SourceLocation PrevLocation = PackStack.CurrentPragmaLocation;
220 // Warn about non-default alignment at #includes (without redundant
221 // warnings for the same directive in nested includes).
222 // The warning is delayed until the end of the file to avoid warnings
223 // for files that don't have any records that are affected by the modified
225 bool HasNonDefaultValue =
226 PackStack.hasValue() &&
227 (PackIncludeStack.empty() ||
228 PackIncludeStack.back().CurrentPragmaLocation != PrevLocation);
229 PackIncludeStack.push_back(
230 {PackStack.CurrentValue,
231 PackStack.hasValue() ? PrevLocation : SourceLocation(),
232 HasNonDefaultValue, /*ShouldWarnOnInclude*/ false});
236 assert(Kind == PragmaPackDiagnoseKind::ChangedStateAtExit && "invalid kind");
237 PackIncludeState PrevPackState = PackIncludeStack.pop_back_val();
238 if (PrevPackState.ShouldWarnOnInclude) {
239 // Emit the delayed non-default alignment at #include warning.
240 Diag(IncludeLoc, diag::warn_pragma_pack_non_default_at_include);
241 Diag(PrevPackState.CurrentPragmaLocation, diag::note_pragma_pack_here);
243 // Warn about modified alignment after #includes.
244 if (PrevPackState.CurrentValue != PackStack.CurrentValue) {
245 Diag(IncludeLoc, diag::warn_pragma_pack_modified_after_include);
246 Diag(PackStack.CurrentPragmaLocation, diag::note_pragma_pack_here);
250 void Sema::DiagnoseUnterminatedPragmaPack() {
251 if (PackStack.Stack.empty())
253 bool IsInnermost = true;
254 for (const auto &StackSlot : llvm::reverse(PackStack.Stack)) {
255 Diag(StackSlot.PragmaPushLocation, diag::warn_pragma_pack_no_pop_eof);
256 // The user might have already reset the alignment, so suggest replacing
257 // the reset with a pop.
258 if (IsInnermost && PackStack.CurrentValue == PackStack.DefaultValue) {
259 DiagnosticBuilder DB = Diag(PackStack.CurrentPragmaLocation,
260 diag::note_pragma_pack_pop_instead_reset);
261 SourceLocation FixItLoc = Lexer::findLocationAfterToken(
262 PackStack.CurrentPragmaLocation, tok::l_paren, SourceMgr, LangOpts,
263 /*SkipTrailing=*/false);
264 if (FixItLoc.isValid())
265 DB << FixItHint::CreateInsertion(FixItLoc, "pop");
271 void Sema::ActOnPragmaMSStruct(PragmaMSStructKind Kind) {
272 MSStructPragmaOn = (Kind == PMSST_ON);
275 void Sema::ActOnPragmaMSComment(SourceLocation CommentLoc,
276 PragmaMSCommentKind Kind, StringRef Arg) {
277 auto *PCD = PragmaCommentDecl::Create(
278 Context, Context.getTranslationUnitDecl(), CommentLoc, Kind, Arg);
279 Context.getTranslationUnitDecl()->addDecl(PCD);
280 Consumer.HandleTopLevelDecl(DeclGroupRef(PCD));
283 void Sema::ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
285 auto *PDMD = PragmaDetectMismatchDecl::Create(
286 Context, Context.getTranslationUnitDecl(), Loc, Name, Value);
287 Context.getTranslationUnitDecl()->addDecl(PDMD);
288 Consumer.HandleTopLevelDecl(DeclGroupRef(PDMD));
291 void Sema::ActOnPragmaMSPointersToMembers(
292 LangOptions::PragmaMSPointersToMembersKind RepresentationMethod,
293 SourceLocation PragmaLoc) {
294 MSPointerToMemberRepresentationMethod = RepresentationMethod;
295 ImplicitMSInheritanceAttrLoc = PragmaLoc;
298 void Sema::ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,
299 SourceLocation PragmaLoc,
300 MSVtorDispAttr::Mode Mode) {
301 if (Action & PSK_Pop && VtorDispStack.Stack.empty())
302 Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "vtordisp"
304 VtorDispStack.Act(PragmaLoc, Action, StringRef(), Mode);
307 template<typename ValueType>
308 void Sema::PragmaStack<ValueType>::Act(SourceLocation PragmaLocation,
309 PragmaMsStackAction Action,
310 llvm::StringRef StackSlotLabel,
312 if (Action == PSK_Reset) {
313 CurrentValue = DefaultValue;
314 CurrentPragmaLocation = PragmaLocation;
317 if (Action & PSK_Push)
318 Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
320 else if (Action & PSK_Pop) {
321 if (!StackSlotLabel.empty()) {
322 // If we've got a label, try to find it and jump there.
323 auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
324 return x.StackSlotLabel == StackSlotLabel;
326 // If we found the label so pop from there.
327 if (I != Stack.rend()) {
328 CurrentValue = I->Value;
329 CurrentPragmaLocation = I->PragmaLocation;
330 Stack.erase(std::prev(I.base()), Stack.end());
332 } else if (!Stack.empty()) {
333 // We don't have a label, just pop the last entry.
334 CurrentValue = Stack.back().Value;
335 CurrentPragmaLocation = Stack.back().PragmaLocation;
339 if (Action & PSK_Set) {
340 CurrentValue = Value;
341 CurrentPragmaLocation = PragmaLocation;
345 bool Sema::UnifySection(StringRef SectionName,
347 DeclaratorDecl *Decl) {
348 auto Section = Context.SectionInfos.find(SectionName);
349 if (Section == Context.SectionInfos.end()) {
350 Context.SectionInfos[SectionName] =
351 ASTContext::SectionInfo(Decl, SourceLocation(), SectionFlags);
354 // A pre-declared section takes precedence w/o diagnostic.
355 if (Section->second.SectionFlags == SectionFlags ||
356 !(Section->second.SectionFlags & ASTContext::PSF_Implicit))
358 auto OtherDecl = Section->second.Decl;
359 Diag(Decl->getLocation(), diag::err_section_conflict)
360 << Decl << OtherDecl;
361 Diag(OtherDecl->getLocation(), diag::note_declared_at)
362 << OtherDecl->getName();
363 if (auto A = Decl->getAttr<SectionAttr>())
365 Diag(A->getLocation(), diag::note_pragma_entered_here);
366 if (auto A = OtherDecl->getAttr<SectionAttr>())
368 Diag(A->getLocation(), diag::note_pragma_entered_here);
372 bool Sema::UnifySection(StringRef SectionName,
374 SourceLocation PragmaSectionLocation) {
375 auto Section = Context.SectionInfos.find(SectionName);
376 if (Section != Context.SectionInfos.end()) {
377 if (Section->second.SectionFlags == SectionFlags)
379 if (!(Section->second.SectionFlags & ASTContext::PSF_Implicit)) {
380 Diag(PragmaSectionLocation, diag::err_section_conflict)
381 << "this" << "a prior #pragma section";
382 Diag(Section->second.PragmaSectionLocation,
383 diag::note_pragma_entered_here);
387 Context.SectionInfos[SectionName] =
388 ASTContext::SectionInfo(nullptr, PragmaSectionLocation, SectionFlags);
392 /// \brief Called on well formed \#pragma bss_seg().
393 void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation,
394 PragmaMsStackAction Action,
395 llvm::StringRef StackSlotLabel,
396 StringLiteral *SegmentName,
397 llvm::StringRef PragmaName) {
398 PragmaStack<StringLiteral *> *Stack =
399 llvm::StringSwitch<PragmaStack<StringLiteral *> *>(PragmaName)
400 .Case("data_seg", &DataSegStack)
401 .Case("bss_seg", &BSSSegStack)
402 .Case("const_seg", &ConstSegStack)
403 .Case("code_seg", &CodeSegStack);
404 if (Action & PSK_Pop && Stack->Stack.empty())
405 Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName
408 !checkSectionName(SegmentName->getLocStart(), SegmentName->getString()))
410 Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName);
413 /// \brief Called on well formed \#pragma bss_seg().
414 void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation,
415 int SectionFlags, StringLiteral *SegmentName) {
416 UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation);
419 void Sema::ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
420 StringLiteral *SegmentName) {
421 // There's no stack to maintain, so we just have a current section. When we
422 // see the default section, reset our current section back to null so we stop
423 // tacking on unnecessary attributes.
424 CurInitSeg = SegmentName->getString() == ".CRT$XCU" ? nullptr : SegmentName;
425 CurInitSegLoc = PragmaLocation;
428 void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope,
429 SourceLocation PragmaLoc) {
431 IdentifierInfo *Name = IdTok.getIdentifierInfo();
432 LookupResult Lookup(*this, Name, IdTok.getLocation(), LookupOrdinaryName);
433 LookupParsedName(Lookup, curScope, nullptr, true);
435 if (Lookup.empty()) {
436 Diag(PragmaLoc, diag::warn_pragma_unused_undeclared_var)
437 << Name << SourceRange(IdTok.getLocation());
441 VarDecl *VD = Lookup.getAsSingle<VarDecl>();
443 Diag(PragmaLoc, diag::warn_pragma_unused_expected_var_arg)
444 << Name << SourceRange(IdTok.getLocation());
448 // Warn if this was used before being marked unused.
450 Diag(PragmaLoc, diag::warn_used_but_marked_unused) << Name;
452 VD->addAttr(UnusedAttr::CreateImplicit(Context, UnusedAttr::GNU_unused,
453 IdTok.getLocation()));
456 void Sema::AddCFAuditedAttribute(Decl *D) {
457 SourceLocation Loc = PP.getPragmaARCCFCodeAuditedLoc();
458 if (!Loc.isValid()) return;
460 // Don't add a redundant or conflicting attribute.
461 if (D->hasAttr<CFAuditedTransferAttr>() ||
462 D->hasAttr<CFUnknownTransferAttr>())
465 D->addAttr(CFAuditedTransferAttr::CreateImplicit(Context, Loc));
470 Optional<attr::SubjectMatchRule>
471 getParentAttrMatcherRule(attr::SubjectMatchRule Rule) {
472 using namespace attr;
476 #define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)
477 #define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated) \
480 #include "clang/Basic/AttrSubMatchRulesList.inc"
484 bool isNegatedAttrMatcherSubRule(attr::SubjectMatchRule Rule) {
485 using namespace attr;
489 #define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)
490 #define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated) \
493 #include "clang/Basic/AttrSubMatchRulesList.inc"
497 CharSourceRange replacementRangeForListElement(const Sema &S,
499 // Make sure that the ',' is removed as well.
500 SourceLocation AfterCommaLoc = Lexer::findLocationAfterToken(
501 Range.getEnd(), tok::comma, S.getSourceManager(), S.getLangOpts(),
502 /*SkipTrailingWhitespaceAndNewLine=*/false);
503 if (AfterCommaLoc.isValid())
504 return CharSourceRange::getCharRange(Range.getBegin(), AfterCommaLoc);
506 return CharSourceRange::getTokenRange(Range);
510 attrMatcherRuleListToString(ArrayRef<attr::SubjectMatchRule> Rules) {
512 llvm::raw_string_ostream OS(Result);
513 for (const auto &I : llvm::enumerate(Rules)) {
515 OS << (I.index() == Rules.size() - 1 ? ", and " : ", ");
516 OS << "'" << attr::getSubjectMatchRuleSpelling(I.value()) << "'";
521 } // end anonymous namespace
523 void Sema::ActOnPragmaAttributePush(AttributeList &Attribute,
524 SourceLocation PragmaLoc,
525 attr::ParsedSubjectMatchRuleSet Rules) {
526 SmallVector<attr::SubjectMatchRule, 4> SubjectMatchRules;
527 // Gather the subject match rules that are supported by the attribute.
528 SmallVector<std::pair<attr::SubjectMatchRule, bool>, 4>
529 StrictSubjectMatchRuleSet;
530 Attribute.getMatchRules(LangOpts, StrictSubjectMatchRuleSet);
532 // Figure out which subject matching rules are valid.
533 if (StrictSubjectMatchRuleSet.empty()) {
534 // Check for contradicting match rules. Contradicting match rules are
536 // - a top-level rule and one of its sub-rules. E.g. variable and
537 // variable(is_parameter).
538 // - a sub-rule and a sibling that's negated. E.g.
539 // variable(is_thread_local) and variable(unless(is_parameter))
540 llvm::SmallDenseMap<int, std::pair<int, SourceRange>, 2>
541 RulesToFirstSpecifiedNegatedSubRule;
542 for (const auto &Rule : Rules) {
543 attr::SubjectMatchRule MatchRule = attr::SubjectMatchRule(Rule.first);
544 Optional<attr::SubjectMatchRule> ParentRule =
545 getParentAttrMatcherRule(MatchRule);
548 auto It = Rules.find(*ParentRule);
549 if (It != Rules.end()) {
550 // A sub-rule contradicts a parent rule.
551 Diag(Rule.second.getBegin(),
552 diag::err_pragma_attribute_matcher_subrule_contradicts_rule)
553 << attr::getSubjectMatchRuleSpelling(MatchRule)
554 << attr::getSubjectMatchRuleSpelling(*ParentRule) << It->second
555 << FixItHint::CreateRemoval(
556 replacementRangeForListElement(*this, Rule.second));
557 // Keep going without removing this rule as it won't change the set of
558 // declarations that receive the attribute.
561 if (isNegatedAttrMatcherSubRule(MatchRule))
562 RulesToFirstSpecifiedNegatedSubRule.insert(
563 std::make_pair(*ParentRule, Rule));
565 bool IgnoreNegatedSubRules = false;
566 for (const auto &Rule : Rules) {
567 attr::SubjectMatchRule MatchRule = attr::SubjectMatchRule(Rule.first);
568 Optional<attr::SubjectMatchRule> ParentRule =
569 getParentAttrMatcherRule(MatchRule);
572 auto It = RulesToFirstSpecifiedNegatedSubRule.find(*ParentRule);
573 if (It != RulesToFirstSpecifiedNegatedSubRule.end() &&
574 It->second != Rule) {
575 // Negated sub-rule contradicts another sub-rule.
577 It->second.second.getBegin(),
579 err_pragma_attribute_matcher_negated_subrule_contradicts_subrule)
580 << attr::getSubjectMatchRuleSpelling(
581 attr::SubjectMatchRule(It->second.first))
582 << attr::getSubjectMatchRuleSpelling(MatchRule) << Rule.second
583 << FixItHint::CreateRemoval(
584 replacementRangeForListElement(*this, It->second.second));
585 // Keep going but ignore all of the negated sub-rules.
586 IgnoreNegatedSubRules = true;
587 RulesToFirstSpecifiedNegatedSubRule.erase(It);
591 if (!IgnoreNegatedSubRules) {
592 for (const auto &Rule : Rules)
593 SubjectMatchRules.push_back(attr::SubjectMatchRule(Rule.first));
595 for (const auto &Rule : Rules) {
596 if (!isNegatedAttrMatcherSubRule(attr::SubjectMatchRule(Rule.first)))
597 SubjectMatchRules.push_back(attr::SubjectMatchRule(Rule.first));
602 for (const auto &Rule : StrictSubjectMatchRuleSet) {
603 if (Rules.erase(Rule.first)) {
604 // Add the rule to the set of attribute receivers only if it's supported
605 // in the current language mode.
607 SubjectMatchRules.push_back(Rule.first);
612 if (!Rules.empty()) {
614 Diag(PragmaLoc, diag::err_pragma_attribute_invalid_matchers)
615 << Attribute.getName();
616 SmallVector<attr::SubjectMatchRule, 2> ExtraRules;
617 for (const auto &Rule : Rules) {
618 ExtraRules.push_back(attr::SubjectMatchRule(Rule.first));
619 Diagnostic << FixItHint::CreateRemoval(
620 replacementRangeForListElement(*this, Rule.second));
622 Diagnostic << attrMatcherRuleListToString(ExtraRules);
625 PragmaAttributeStack.push_back(
626 {PragmaLoc, &Attribute, std::move(SubjectMatchRules), /*IsUsed=*/false});
629 void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc) {
630 if (PragmaAttributeStack.empty()) {
631 Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch);
634 const PragmaAttributeEntry &Entry = PragmaAttributeStack.back();
636 assert(Entry.Attribute && "Expected an attribute");
637 Diag(Entry.Attribute->getLoc(), diag::warn_pragma_attribute_unused)
638 << Entry.Attribute->getName();
639 Diag(PragmaLoc, diag::note_pragma_attribute_region_ends_here);
641 PragmaAttributeStack.pop_back();
644 void Sema::AddPragmaAttributes(Scope *S, Decl *D) {
645 if (PragmaAttributeStack.empty())
647 for (auto &Entry : PragmaAttributeStack) {
648 const AttributeList *Attribute = Entry.Attribute;
649 assert(Attribute && "Expected an attribute");
651 // Ensure that the attribute can be applied to the given declaration.
652 bool Applies = false;
653 for (const auto &Rule : Entry.MatchRules) {
654 if (Attribute->appliesToDecl(D, Rule)) {
662 assert(!Attribute->getNext() && "Expected just one attribute");
663 PragmaAttributeCurrentTargetDecl = D;
664 ProcessDeclAttributeList(S, D, Attribute);
665 PragmaAttributeCurrentTargetDecl = nullptr;
669 void Sema::PrintPragmaAttributeInstantiationPoint() {
670 assert(PragmaAttributeCurrentTargetDecl && "Expected an active declaration");
671 Diags.Report(PragmaAttributeCurrentTargetDecl->getLocStart(),
672 diag::note_pragma_attribute_applied_decl_here);
675 void Sema::DiagnoseUnterminatedPragmaAttribute() {
676 if (PragmaAttributeStack.empty())
678 Diag(PragmaAttributeStack.back().Loc, diag::err_pragma_attribute_no_pop_eof);
681 void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) {
683 OptimizeOffPragmaLocation = SourceLocation();
685 OptimizeOffPragmaLocation = PragmaLoc;
688 void Sema::AddRangeBasedOptnone(FunctionDecl *FD) {
689 // In the future, check other pragmas if they're implemented (e.g. pragma
690 // optimize 0 will probably map to this functionality too).
691 if(OptimizeOffPragmaLocation.isValid())
692 AddOptnoneAttributeIfNoConflicts(FD, OptimizeOffPragmaLocation);
695 void Sema::AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD,
696 SourceLocation Loc) {
697 // Don't add a conflicting attribute. No diagnostic is needed.
698 if (FD->hasAttr<MinSizeAttr>() || FD->hasAttr<AlwaysInlineAttr>())
701 // Add attributes only if required. Optnone requires noinline as well, but if
702 // either is already present then don't bother adding them.
703 if (!FD->hasAttr<OptimizeNoneAttr>())
704 FD->addAttr(OptimizeNoneAttr::CreateImplicit(Context, Loc));
705 if (!FD->hasAttr<NoInlineAttr>())
706 FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc));
709 typedef std::vector<std::pair<unsigned, SourceLocation> > VisStack;
710 enum : unsigned { NoVisibility = ~0U };
712 void Sema::AddPushedVisibilityAttribute(Decl *D) {
716 NamedDecl *ND = dyn_cast<NamedDecl>(D);
717 if (ND && ND->getExplicitVisibility(NamedDecl::VisibilityForValue))
720 VisStack *Stack = static_cast<VisStack*>(VisContext);
721 unsigned rawType = Stack->back().first;
722 if (rawType == NoVisibility) return;
724 VisibilityAttr::VisibilityType type
725 = (VisibilityAttr::VisibilityType) rawType;
726 SourceLocation loc = Stack->back().second;
728 D->addAttr(VisibilityAttr::CreateImplicit(Context, type, loc));
731 /// FreeVisContext - Deallocate and null out VisContext.
732 void Sema::FreeVisContext() {
733 delete static_cast<VisStack*>(VisContext);
734 VisContext = nullptr;
737 static void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc) {
738 // Put visibility on stack.
740 S.VisContext = new VisStack;
742 VisStack *Stack = static_cast<VisStack*>(S.VisContext);
743 Stack->push_back(std::make_pair(type, loc));
746 void Sema::ActOnPragmaVisibility(const IdentifierInfo* VisType,
747 SourceLocation PragmaLoc) {
749 // Compute visibility to use.
750 VisibilityAttr::VisibilityType T;
751 if (!VisibilityAttr::ConvertStrToVisibilityType(VisType->getName(), T)) {
752 Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType;
755 PushPragmaVisibility(*this, T, PragmaLoc);
757 PopPragmaVisibility(false, PragmaLoc);
761 void Sema::ActOnPragmaFPContract(LangOptions::FPContractModeKind FPC) {
763 case LangOptions::FPC_On:
764 FPFeatures.setAllowFPContractWithinStatement();
766 case LangOptions::FPC_Fast:
767 FPFeatures.setAllowFPContractAcrossStatement();
769 case LangOptions::FPC_Off:
770 FPFeatures.setDisallowFPContract();
775 void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
776 SourceLocation Loc) {
777 // Visibility calculations will consider the namespace's visibility.
778 // Here we just want to note that we're in a visibility context
779 // which overrides any enclosing #pragma context, but doesn't itself
780 // contribute visibility.
781 PushPragmaVisibility(*this, NoVisibility, Loc);
784 void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) {
786 Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
790 // Pop visibility from stack
791 VisStack *Stack = static_cast<VisStack*>(VisContext);
793 const std::pair<unsigned, SourceLocation> *Back = &Stack->back();
794 bool StartsWithPragma = Back->first != NoVisibility;
795 if (StartsWithPragma && IsNamespaceEnd) {
796 Diag(Back->second, diag::err_pragma_push_visibility_mismatch);
797 Diag(EndLoc, diag::note_surrounding_namespace_ends_here);
799 // For better error recovery, eat all pushes inside the namespace.
802 Back = &Stack->back();
803 StartsWithPragma = Back->first != NoVisibility;
804 } while (StartsWithPragma);
805 } else if (!StartsWithPragma && !IsNamespaceEnd) {
806 Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
807 Diag(Back->second, diag::note_surrounding_namespace_starts_here);
812 // To simplify the implementation, never keep around an empty stack.