clang 19.0.0git
SemaAttr.cpp
Go to the documentation of this file.
1//===--- SemaAttr.cpp - Semantic Analysis for Attributes ------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements semantic analysis for non-trivial attributes and
10// pragmas.
11//
12//===----------------------------------------------------------------------===//
13
15#include "clang/AST/Attr.h"
16#include "clang/AST/Expr.h"
19#include "clang/Sema/Lookup.h"
21#include <optional>
22using namespace clang;
23
24//===----------------------------------------------------------------------===//
25// Pragma 'pack' and 'options align'
26//===----------------------------------------------------------------------===//
27
29 StringRef SlotLabel,
30 bool ShouldAct)
31 : S(S), SlotLabel(SlotLabel), ShouldAct(ShouldAct) {
32 if (ShouldAct) {
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);
39 }
40}
41
43 if (ShouldAct) {
45 S.DataSegStack.SentinelAction(PSK_Pop, SlotLabel);
46 S.BSSSegStack.SentinelAction(PSK_Pop, SlotLabel);
47 S.ConstSegStack.SentinelAction(PSK_Pop, SlotLabel);
48 S.CodeSegStack.SentinelAction(PSK_Pop, SlotLabel);
50 }
51}
52
54 AlignPackInfo InfoVal = AlignPackStack.CurrentValue;
56 bool IsPackSet = InfoVal.IsPackSet();
57 bool IsXLPragma = getLangOpts().XLPragmaPack;
58
59 // If we are not under mac68k/natural alignment mode and also there is no pack
60 // value, we don't need any attributes.
61 if (!IsPackSet && M != AlignPackInfo::Mac68k && M != AlignPackInfo::Natural)
62 return;
63
64 if (M == AlignPackInfo::Mac68k && (IsXLPragma || InfoVal.IsAlignAttr())) {
65 RD->addAttr(AlignMac68kAttr::CreateImplicit(Context));
66 } else if (IsPackSet) {
67 // Check to see if we need a max field alignment attribute.
68 RD->addAttr(MaxFieldAlignmentAttr::CreateImplicit(
69 Context, InfoVal.getPackNumber() * 8));
70 }
71
72 if (IsXLPragma && M == AlignPackInfo::Natural)
73 RD->addAttr(AlignNaturalAttr::CreateImplicit(Context));
74
75 if (AlignPackIncludeStack.empty())
76 return;
77 // The #pragma align/pack affected a record in an included file, so Clang
78 // should warn when that pragma was written in a file that included the
79 // included file.
80 for (auto &AlignPackedInclude : llvm::reverse(AlignPackIncludeStack)) {
81 if (AlignPackedInclude.CurrentPragmaLocation !=
82 AlignPackStack.CurrentPragmaLocation)
83 break;
84 if (AlignPackedInclude.HasNonDefaultValue)
85 AlignPackedInclude.ShouldWarnOnInclude = true;
86 }
87}
88
91 RD->addAttr(MSStructAttr::CreateImplicit(Context));
92
93 // FIXME: We should merge AddAlignmentAttributesForRecord with
94 // AddMsStructLayoutForRecord into AddPragmaAttributesForRecord, which takes
95 // all active pragmas and applies them as attributes to class definitions.
96 if (VtorDispStack.CurrentValue != getLangOpts().getVtorDispMode())
97 RD->addAttr(MSVtorDispAttr::CreateImplicit(
99}
100
101template <typename Attribute>
104 if (Record->hasAttr<OwnerAttr>() || Record->hasAttr<PointerAttr>())
105 return;
106
107 for (Decl *Redecl : Record->redecls())
108 Redecl->addAttr(Attribute::CreateImplicit(Context, /*DerefType=*/nullptr));
109}
110
112 CXXRecordDecl *UnderlyingRecord) {
113 if (!UnderlyingRecord)
114 return;
115
116 const auto *Parent = dyn_cast<CXXRecordDecl>(ND->getDeclContext());
117 if (!Parent)
118 return;
119
120 static llvm::StringSet<> Containers{
121 "array",
122 "basic_string",
123 "deque",
124 "forward_list",
125 "vector",
126 "list",
127 "map",
128 "multiset",
129 "multimap",
130 "priority_queue",
131 "queue",
132 "set",
133 "stack",
134 "unordered_set",
135 "unordered_map",
136 "unordered_multiset",
137 "unordered_multimap",
138 };
139
140 static llvm::StringSet<> Iterators{"iterator", "const_iterator",
141 "reverse_iterator",
142 "const_reverse_iterator"};
143
144 if (Parent->isInStdNamespace() && Iterators.count(ND->getName()) &&
145 Containers.count(Parent->getName()))
146 addGslOwnerPointerAttributeIfNotExisting<PointerAttr>(Context,
147 UnderlyingRecord);
148}
149
151
152 QualType Canonical = TD->getUnderlyingType().getCanonicalType();
153
154 CXXRecordDecl *RD = Canonical->getAsCXXRecordDecl();
155 if (!RD) {
156 if (auto *TST =
157 dyn_cast<TemplateSpecializationType>(Canonical.getTypePtr())) {
158
159 RD = dyn_cast_or_null<CXXRecordDecl>(
160 TST->getTemplateName().getAsTemplateDecl()->getTemplatedDecl());
161 }
162 }
163
165}
166
168 static llvm::StringSet<> StdOwners{
169 "any",
170 "array",
171 "basic_regex",
172 "basic_string",
173 "deque",
174 "forward_list",
175 "vector",
176 "list",
177 "map",
178 "multiset",
179 "multimap",
180 "optional",
181 "priority_queue",
182 "queue",
183 "set",
184 "stack",
185 "unique_ptr",
186 "unordered_set",
187 "unordered_map",
188 "unordered_multiset",
189 "unordered_multimap",
190 "variant",
191 };
192 static llvm::StringSet<> StdPointers{
193 "basic_string_view",
194 "reference_wrapper",
195 "regex_iterator",
196 };
197
198 if (!Record->getIdentifier())
199 return;
200
201 // Handle classes that directly appear in std namespace.
202 if (Record->isInStdNamespace()) {
203 if (Record->hasAttr<OwnerAttr>() || Record->hasAttr<PointerAttr>())
204 return;
205
206 if (StdOwners.count(Record->getName()))
207 addGslOwnerPointerAttributeIfNotExisting<OwnerAttr>(Context, Record);
208 else if (StdPointers.count(Record->getName()))
209 addGslOwnerPointerAttributeIfNotExisting<PointerAttr>(Context, Record);
210
211 return;
212 }
213
214 // Handle nested classes that could be a gsl::Pointer.
216}
217
219 SourceLocation PragmaLoc) {
222
223 switch (Kind) {
224 // For most of the platforms we support, native and natural are the same.
225 // With XL, native is the same as power, natural means something else.
226 case POAK_Native:
227 case POAK_Power:
228 Action = Sema::PSK_Push_Set;
229 break;
230 case POAK_Natural:
231 Action = Sema::PSK_Push_Set;
232 ModeVal = AlignPackInfo::Natural;
233 break;
234
235 // Note that '#pragma options align=packed' is not equivalent to attribute
236 // packed, it has a different precedence relative to attribute aligned.
237 case POAK_Packed:
238 Action = Sema::PSK_Push_Set;
239 ModeVal = AlignPackInfo::Packed;
240 break;
241
242 case POAK_Mac68k:
243 // Check if the target supports this.
245 Diag(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported);
246 return;
247 }
248 Action = Sema::PSK_Push_Set;
249 ModeVal = AlignPackInfo::Mac68k;
250 break;
251 case POAK_Reset:
252 // Reset just pops the top of the stack, or resets the current alignment to
253 // default.
254 Action = Sema::PSK_Pop;
255 if (AlignPackStack.Stack.empty()) {
256 if (AlignPackStack.CurrentValue.getAlignMode() != AlignPackInfo::Native ||
257 AlignPackStack.CurrentValue.IsPackAttr()) {
258 Action = Sema::PSK_Reset;
259 } else {
260 Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed)
261 << "stack empty";
262 return;
263 }
264 }
265 break;
266 }
267
268 AlignPackInfo Info(ModeVal, getLangOpts().XLPragmaPack);
269
270 AlignPackStack.Act(PragmaLoc, Action, StringRef(), Info);
271}
272
276 StringRef SecName) {
277 PragmaClangSection *CSec;
278 int SectionFlags = ASTContext::PSF_Read;
279 switch (SecKind) {
281 CSec = &PragmaClangBSSSection;
283 break;
286 SectionFlags |= ASTContext::PSF_Write;
287 break;
290 break;
293 break;
296 SectionFlags |= ASTContext::PSF_Execute;
297 break;
298 default:
299 llvm_unreachable("invalid clang section kind");
300 }
301
303 CSec->Valid = false;
304 return;
305 }
306
307 if (llvm::Error E = isValidSectionSpecifier(SecName)) {
308 Diag(PragmaLoc, diag::err_pragma_section_invalid_for_target)
309 << toString(std::move(E));
310 CSec->Valid = false;
311 return;
312 }
313
314 if (UnifySection(SecName, SectionFlags, PragmaLoc))
315 return;
316
317 CSec->Valid = true;
318 CSec->SectionName = std::string(SecName);
319 CSec->PragmaLocation = PragmaLoc;
320}
321
323 StringRef SlotLabel, Expr *alignment) {
324 bool IsXLPragma = getLangOpts().XLPragmaPack;
325 // XL pragma pack does not support identifier syntax.
326 if (IsXLPragma && !SlotLabel.empty()) {
327 Diag(PragmaLoc, diag::err_pragma_pack_identifer_not_supported);
328 return;
329 }
330
331 const AlignPackInfo CurVal = AlignPackStack.CurrentValue;
332 Expr *Alignment = static_cast<Expr *>(alignment);
333
334 // If specified then alignment must be a "small" power of two.
335 unsigned AlignmentVal = 0;
336 AlignPackInfo::Mode ModeVal = CurVal.getAlignMode();
337
338 if (Alignment) {
339 std::optional<llvm::APSInt> Val;
340 Val = Alignment->getIntegerConstantExpr(Context);
341
342 // pack(0) is like pack(), which just works out since that is what
343 // we use 0 for in PackAttr.
344 if (Alignment->isTypeDependent() || !Val ||
345 !(*Val == 0 || Val->isPowerOf2()) || Val->getZExtValue() > 16) {
346 Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment);
347 return; // Ignore
348 }
349
350 if (IsXLPragma && *Val == 0) {
351 // pack(0) does not work out with XL.
352 Diag(PragmaLoc, diag::err_pragma_pack_invalid_alignment);
353 return; // Ignore
354 }
355
356 AlignmentVal = (unsigned)Val->getZExtValue();
357 }
358
359 if (Action == Sema::PSK_Show) {
360 // Show the current alignment, making sure to show the right value
361 // for the default.
362 // FIXME: This should come from the target.
363 AlignmentVal = CurVal.IsPackSet() ? CurVal.getPackNumber() : 8;
364 if (ModeVal == AlignPackInfo::Mac68k &&
365 (IsXLPragma || CurVal.IsAlignAttr()))
366 Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k";
367 else
368 Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;
369 }
370
371 // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack:
372 // "#pragma pack(pop, identifier, n) is undefined"
373 if (Action & Sema::PSK_Pop) {
374 if (Alignment && !SlotLabel.empty())
375 Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifier_and_alignment);
376 if (AlignPackStack.Stack.empty()) {
377 assert(CurVal.getAlignMode() == AlignPackInfo::Native &&
378 "Empty pack stack can only be at Native alignment mode.");
379 Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << "stack empty";
380 }
381 }
382
383 AlignPackInfo Info(ModeVal, AlignmentVal, IsXLPragma);
384
385 AlignPackStack.Act(PragmaLoc, Action, SlotLabel, Info);
386}
387
391 for (unsigned Idx = 0; Idx < Args.size(); Idx++) {
392 Expr *&E = Args.begin()[Idx];
393 assert(E && "error are handled before");
394 if (E->isValueDependent() || E->isTypeDependent())
395 continue;
396
397 // FIXME: Use DefaultFunctionArrayLValueConversion() in place of the logic
398 // that adds implicit casts here.
399 if (E->getType()->isArrayType())
401 clang::CK_ArrayToPointerDecay)
402 .get();
403 if (E->getType()->isFunctionType())
406 clang::CK_FunctionToPointerDecay, E, nullptr,
408 if (E->isLValue())
410 clang::CK_LValueToRValue, E, nullptr,
412
413 Expr::EvalResult Eval;
414 Notes.clear();
415 Eval.Diag = &Notes;
416
417 bool Result = E->EvaluateAsConstantExpr(Eval, Context);
418
419 /// Result means the expression can be folded to a constant.
420 /// Note.empty() means the expression is a valid constant expression in the
421 /// current language mode.
422 if (!Result || !Notes.empty()) {
423 Diag(E->getBeginLoc(), diag::err_attribute_argument_n_type)
424 << CI << (Idx + 1) << AANT_ArgumentConstantExpr;
425 for (auto &Note : Notes)
426 Diag(Note.first, Note.second);
427 return false;
428 }
429 assert(Eval.Val.hasValue());
430 E = ConstantExpr::Create(Context, E, Eval.Val);
431 }
432
433 return true;
434}
435
437 SourceLocation IncludeLoc) {
439 SourceLocation PrevLocation = AlignPackStack.CurrentPragmaLocation;
440 // Warn about non-default alignment at #includes (without redundant
441 // warnings for the same directive in nested includes).
442 // The warning is delayed until the end of the file to avoid warnings
443 // for files that don't have any records that are affected by the modified
444 // alignment.
445 bool HasNonDefaultValue =
446 AlignPackStack.hasValue() &&
447 (AlignPackIncludeStack.empty() ||
448 AlignPackIncludeStack.back().CurrentPragmaLocation != PrevLocation);
449 AlignPackIncludeStack.push_back(
450 {AlignPackStack.CurrentValue,
451 AlignPackStack.hasValue() ? PrevLocation : SourceLocation(),
452 HasNonDefaultValue, /*ShouldWarnOnInclude*/ false});
453 return;
454 }
455
457 "invalid kind");
458 AlignPackIncludeState PrevAlignPackState =
459 AlignPackIncludeStack.pop_back_val();
460 // FIXME: AlignPackStack may contain both #pragma align and #pragma pack
461 // information, diagnostics below might not be accurate if we have mixed
462 // pragmas.
463 if (PrevAlignPackState.ShouldWarnOnInclude) {
464 // Emit the delayed non-default alignment at #include warning.
465 Diag(IncludeLoc, diag::warn_pragma_pack_non_default_at_include);
466 Diag(PrevAlignPackState.CurrentPragmaLocation, diag::note_pragma_pack_here);
467 }
468 // Warn about modified alignment after #includes.
469 if (PrevAlignPackState.CurrentValue != AlignPackStack.CurrentValue) {
470 Diag(IncludeLoc, diag::warn_pragma_pack_modified_after_include);
471 Diag(AlignPackStack.CurrentPragmaLocation, diag::note_pragma_pack_here);
472 }
473}
474
476 if (AlignPackStack.Stack.empty())
477 return;
478 bool IsInnermost = true;
479
480 // FIXME: AlignPackStack may contain both #pragma align and #pragma pack
481 // information, diagnostics below might not be accurate if we have mixed
482 // pragmas.
483 for (const auto &StackSlot : llvm::reverse(AlignPackStack.Stack)) {
484 Diag(StackSlot.PragmaPushLocation, diag::warn_pragma_pack_no_pop_eof);
485 // The user might have already reset the alignment, so suggest replacing
486 // the reset with a pop.
487 if (IsInnermost &&
488 AlignPackStack.CurrentValue == AlignPackStack.DefaultValue) {
489 auto DB = Diag(AlignPackStack.CurrentPragmaLocation,
490 diag::note_pragma_pack_pop_instead_reset);
491 SourceLocation FixItLoc =
492 Lexer::findLocationAfterToken(AlignPackStack.CurrentPragmaLocation,
493 tok::l_paren, SourceMgr, LangOpts,
494 /*SkipTrailing=*/false);
495 if (FixItLoc.isValid())
496 DB << FixItHint::CreateInsertion(FixItLoc, "pop");
497 }
498 IsInnermost = false;
499 }
500}
501
503 MSStructPragmaOn = (Kind == PMSST_ON);
504}
505
507 PragmaMSCommentKind Kind, StringRef Arg) {
508 auto *PCD = PragmaCommentDecl::Create(
509 Context, Context.getTranslationUnitDecl(), CommentLoc, Kind, Arg);
512}
513
515 StringRef Value) {
520}
521
525 switch (Value) {
526 default:
527 llvm_unreachable("invalid pragma eval_method kind");
529 NewFPFeatures.setFPEvalMethodOverride(LangOptions::FEM_Source);
530 break;
532 NewFPFeatures.setFPEvalMethodOverride(LangOptions::FEM_Double);
533 break;
535 NewFPFeatures.setFPEvalMethodOverride(LangOptions::FEM_Extended);
536 break;
537 }
538 if (getLangOpts().ApproxFunc)
539 Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 0;
540 if (getLangOpts().AllowFPReassoc)
541 Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 1;
542 if (getLangOpts().AllowRecip)
543 Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 2;
544 FpPragmaStack.Act(Loc, PSK_Set, StringRef(), NewFPFeatures);
545 CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts());
547}
548
550 PragmaMsStackAction Action,
553 if ((Action == PSK_Push_Set || Action == PSK_Push || Action == PSK_Pop) &&
555 // Push and pop can only occur at file or namespace scope, or within a
556 // language linkage declaration.
557 Diag(Loc, diag::err_pragma_fc_pp_scope);
558 return;
559 }
560 switch (Value) {
561 default:
562 llvm_unreachable("invalid pragma float_control kind");
563 case PFC_Precise:
564 NewFPFeatures.setFPPreciseEnabled(true);
565 FpPragmaStack.Act(Loc, Action, StringRef(), NewFPFeatures);
566 break;
567 case PFC_NoPrecise:
569 Diag(Loc, diag::err_pragma_fc_noprecise_requires_noexcept);
570 else if (CurFPFeatures.getAllowFEnvAccess())
571 Diag(Loc, diag::err_pragma_fc_noprecise_requires_nofenv);
572 else
573 NewFPFeatures.setFPPreciseEnabled(false);
574 FpPragmaStack.Act(Loc, Action, StringRef(), NewFPFeatures);
575 break;
576 case PFC_Except:
577 if (!isPreciseFPEnabled())
578 Diag(Loc, diag::err_pragma_fc_except_requires_precise);
579 else
580 NewFPFeatures.setSpecifiedExceptionModeOverride(LangOptions::FPE_Strict);
581 FpPragmaStack.Act(Loc, Action, StringRef(), NewFPFeatures);
582 break;
583 case PFC_NoExcept:
584 NewFPFeatures.setSpecifiedExceptionModeOverride(LangOptions::FPE_Ignore);
585 FpPragmaStack.Act(Loc, Action, StringRef(), NewFPFeatures);
586 break;
587 case PFC_Push:
588 FpPragmaStack.Act(Loc, Sema::PSK_Push_Set, StringRef(), NewFPFeatures);
589 break;
590 case PFC_Pop:
591 if (FpPragmaStack.Stack.empty()) {
592 Diag(Loc, diag::warn_pragma_pop_failed) << "float_control"
593 << "stack empty";
594 return;
595 }
596 FpPragmaStack.Act(Loc, Action, StringRef(), NewFPFeatures);
597 NewFPFeatures = FpPragmaStack.CurrentValue;
598 break;
599 }
600 CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts());
601}
602
605 SourceLocation PragmaLoc) {
606 MSPointerToMemberRepresentationMethod = RepresentationMethod;
608}
609
611 SourceLocation PragmaLoc,
612 MSVtorDispMode Mode) {
613 if (Action & PSK_Pop && VtorDispStack.Stack.empty())
614 Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "vtordisp"
615 << "stack empty";
616 VtorDispStack.Act(PragmaLoc, Action, StringRef(), Mode);
617}
618
619template <>
621 PragmaMsStackAction Action,
622 llvm::StringRef StackSlotLabel,
623 AlignPackInfo Value) {
624 if (Action == PSK_Reset) {
625 CurrentValue = DefaultValue;
626 CurrentPragmaLocation = PragmaLocation;
627 return;
628 }
629 if (Action & PSK_Push)
630 Stack.emplace_back(Slot(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
631 PragmaLocation));
632 else if (Action & PSK_Pop) {
633 if (!StackSlotLabel.empty()) {
634 // If we've got a label, try to find it and jump there.
635 auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
636 return x.StackSlotLabel == StackSlotLabel;
637 });
638 // We found the label, so pop from there.
639 if (I != Stack.rend()) {
640 CurrentValue = I->Value;
641 CurrentPragmaLocation = I->PragmaLocation;
642 Stack.erase(std::prev(I.base()), Stack.end());
643 }
644 } else if (Value.IsXLStack() && Value.IsAlignAttr() &&
645 CurrentValue.IsPackAttr()) {
646 // XL '#pragma align(reset)' would pop the stack until
647 // a current in effect pragma align is popped.
648 auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
649 return x.Value.IsAlignAttr();
650 });
651 // If we found pragma align so pop from there.
652 if (I != Stack.rend()) {
653 Stack.erase(std::prev(I.base()), Stack.end());
654 if (Stack.empty()) {
655 CurrentValue = DefaultValue;
656 CurrentPragmaLocation = PragmaLocation;
657 } else {
658 CurrentValue = Stack.back().Value;
659 CurrentPragmaLocation = Stack.back().PragmaLocation;
660 Stack.pop_back();
661 }
662 }
663 } else if (!Stack.empty()) {
664 // xl '#pragma align' sets the baseline, and `#pragma pack` cannot pop
665 // over the baseline.
666 if (Value.IsXLStack() && Value.IsPackAttr() && CurrentValue.IsAlignAttr())
667 return;
668
669 // We don't have a label, just pop the last entry.
670 CurrentValue = Stack.back().Value;
671 CurrentPragmaLocation = Stack.back().PragmaLocation;
672 Stack.pop_back();
673 }
674 }
675 if (Action & PSK_Set) {
676 CurrentValue = Value;
677 CurrentPragmaLocation = PragmaLocation;
678 }
679}
680
681bool Sema::UnifySection(StringRef SectionName, int SectionFlags,
682 NamedDecl *Decl) {
683 SourceLocation PragmaLocation;
684 if (auto A = Decl->getAttr<SectionAttr>())
685 if (A->isImplicit())
686 PragmaLocation = A->getLocation();
687 auto SectionIt = Context.SectionInfos.find(SectionName);
688 if (SectionIt == Context.SectionInfos.end()) {
689 Context.SectionInfos[SectionName] =
690 ASTContext::SectionInfo(Decl, PragmaLocation, SectionFlags);
691 return false;
692 }
693 // A pre-declared section takes precedence w/o diagnostic.
694 const auto &Section = SectionIt->second;
695 if (Section.SectionFlags == SectionFlags ||
696 ((SectionFlags & ASTContext::PSF_Implicit) &&
697 !(Section.SectionFlags & ASTContext::PSF_Implicit)))
698 return false;
699 Diag(Decl->getLocation(), diag::err_section_conflict) << Decl << Section;
700 if (Section.Decl)
701 Diag(Section.Decl->getLocation(), diag::note_declared_at)
702 << Section.Decl->getName();
703 if (PragmaLocation.isValid())
704 Diag(PragmaLocation, diag::note_pragma_entered_here);
705 if (Section.PragmaSectionLocation.isValid())
706 Diag(Section.PragmaSectionLocation, diag::note_pragma_entered_here);
707 return true;
708}
709
710bool Sema::UnifySection(StringRef SectionName,
711 int SectionFlags,
712 SourceLocation PragmaSectionLocation) {
713 auto SectionIt = Context.SectionInfos.find(SectionName);
714 if (SectionIt != Context.SectionInfos.end()) {
715 const auto &Section = SectionIt->second;
716 if (Section.SectionFlags == SectionFlags)
717 return false;
718 if (!(Section.SectionFlags & ASTContext::PSF_Implicit)) {
719 Diag(PragmaSectionLocation, diag::err_section_conflict)
720 << "this" << Section;
721 if (Section.Decl)
722 Diag(Section.Decl->getLocation(), diag::note_declared_at)
723 << Section.Decl->getName();
724 if (Section.PragmaSectionLocation.isValid())
725 Diag(Section.PragmaSectionLocation, diag::note_pragma_entered_here);
726 return true;
727 }
728 }
729 Context.SectionInfos[SectionName] =
730 ASTContext::SectionInfo(nullptr, PragmaSectionLocation, SectionFlags);
731 return false;
732}
733
734/// Called on well formed \#pragma bss_seg().
736 PragmaMsStackAction Action,
737 llvm::StringRef StackSlotLabel,
738 StringLiteral *SegmentName,
739 llvm::StringRef PragmaName) {
741 llvm::StringSwitch<PragmaStack<StringLiteral *> *>(PragmaName)
742 .Case("data_seg", &DataSegStack)
743 .Case("bss_seg", &BSSSegStack)
744 .Case("const_seg", &ConstSegStack)
745 .Case("code_seg", &CodeSegStack);
746 if (Action & PSK_Pop && Stack->Stack.empty())
747 Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName
748 << "stack empty";
749 if (SegmentName) {
750 if (!checkSectionName(SegmentName->getBeginLoc(), SegmentName->getString()))
751 return;
752
753 if (SegmentName->getString() == ".drectve" &&
755 Diag(PragmaLocation, diag::warn_attribute_section_drectve) << PragmaName;
756 }
757
758 Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName);
759}
760
761/// Called on well formed \#pragma strict_gs_check().
763 PragmaMsStackAction Action,
764 bool Value) {
765 if (Action & PSK_Pop && StrictGuardStackCheckStack.Stack.empty())
766 Diag(PragmaLocation, diag::warn_pragma_pop_failed) << "strict_gs_check"
767 << "stack empty";
768
769 StrictGuardStackCheckStack.Act(PragmaLocation, Action, StringRef(), Value);
770}
771
772/// Called on well formed \#pragma bss_seg().
774 int SectionFlags, StringLiteral *SegmentName) {
775 UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation);
776}
777
779 StringLiteral *SegmentName) {
780 // There's no stack to maintain, so we just have a current section. When we
781 // see the default section, reset our current section back to null so we stop
782 // tacking on unnecessary attributes.
783 CurInitSeg = SegmentName->getString() == ".CRT$XCU" ? nullptr : SegmentName;
784 CurInitSegLoc = PragmaLocation;
785}
786
788 SourceLocation PragmaLocation, StringRef Section,
789 const SmallVector<std::tuple<IdentifierInfo *, SourceLocation>>
790 &Functions) {
792 Diag(PragmaLocation, diag::err_pragma_expected_file_scope) << "alloc_text";
793 return;
794 }
795
796 for (auto &Function : Functions) {
797 IdentifierInfo *II;
798 SourceLocation Loc;
799 std::tie(II, Loc) = Function;
800
801 DeclarationName DN(II);
803 if (!ND) {
804 Diag(Loc, diag::err_undeclared_use) << II->getName();
805 return;
806 }
807
808 auto *FD = dyn_cast<FunctionDecl>(ND->getCanonicalDecl());
809 if (!FD) {
810 Diag(Loc, diag::err_pragma_alloc_text_not_function);
811 return;
812 }
813
814 if (getLangOpts().CPlusPlus && !FD->isInExternCContext()) {
815 Diag(Loc, diag::err_pragma_alloc_text_c_linkage);
816 return;
817 }
818
819 FunctionToSectionMap[II->getName()] = std::make_tuple(Section, Loc);
820 }
821}
822
823void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope,
824 SourceLocation PragmaLoc) {
825
826 IdentifierInfo *Name = IdTok.getIdentifierInfo();
827 LookupResult Lookup(*this, Name, IdTok.getLocation(), LookupOrdinaryName);
828 LookupParsedName(Lookup, curScope, nullptr, true);
829
830 if (Lookup.empty()) {
831 Diag(PragmaLoc, diag::warn_pragma_unused_undeclared_var)
832 << Name << SourceRange(IdTok.getLocation());
833 return;
834 }
835
836 VarDecl *VD = Lookup.getAsSingle<VarDecl>();
837 if (!VD) {
838 Diag(PragmaLoc, diag::warn_pragma_unused_expected_var_arg)
839 << Name << SourceRange(IdTok.getLocation());
840 return;
841 }
842
843 // Warn if this was used before being marked unused.
844 if (VD->isUsed())
845 Diag(PragmaLoc, diag::warn_used_but_marked_unused) << Name;
846
847 VD->addAttr(UnusedAttr::CreateImplicit(Context, IdTok.getLocation(),
848 UnusedAttr::GNU_unused));
849}
850
852 IdentifierInfo *Ident;
853 SourceLocation Loc;
854 std::tie(Ident, Loc) = PP.getPragmaARCCFCodeAuditedInfo();
855 if (!Loc.isValid()) return;
856
857 // Don't add a redundant or conflicting attribute.
858 if (D->hasAttr<CFAuditedTransferAttr>() ||
859 D->hasAttr<CFUnknownTransferAttr>())
860 return;
861
862 AttributeCommonInfo Info(Ident, SourceRange(Loc),
864 D->addAttr(CFAuditedTransferAttr::CreateImplicit(Context, Info));
865}
866
867namespace {
868
869std::optional<attr::SubjectMatchRule>
870getParentAttrMatcherRule(attr::SubjectMatchRule Rule) {
871 using namespace attr;
872 switch (Rule) {
873 default:
874 return std::nullopt;
875#define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)
876#define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated) \
877 case Value: \
878 return Parent;
879#include "clang/Basic/AttrSubMatchRulesList.inc"
880 }
881}
882
883bool isNegatedAttrMatcherSubRule(attr::SubjectMatchRule Rule) {
884 using namespace attr;
885 switch (Rule) {
886 default:
887 return false;
888#define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)
889#define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated) \
890 case Value: \
891 return IsNegated;
892#include "clang/Basic/AttrSubMatchRulesList.inc"
893 }
894}
895
896CharSourceRange replacementRangeForListElement(const Sema &S,
897 SourceRange Range) {
898 // Make sure that the ',' is removed as well.
900 Range.getEnd(), tok::comma, S.getSourceManager(), S.getLangOpts(),
901 /*SkipTrailingWhitespaceAndNewLine=*/false);
902 if (AfterCommaLoc.isValid())
903 return CharSourceRange::getCharRange(Range.getBegin(), AfterCommaLoc);
904 else
905 return CharSourceRange::getTokenRange(Range);
906}
907
908std::string
909attrMatcherRuleListToString(ArrayRef<attr::SubjectMatchRule> Rules) {
910 std::string Result;
911 llvm::raw_string_ostream OS(Result);
912 for (const auto &I : llvm::enumerate(Rules)) {
913 if (I.index())
914 OS << (I.index() == Rules.size() - 1 ? ", and " : ", ");
915 OS << "'" << attr::getSubjectMatchRuleSpelling(I.value()) << "'";
916 }
917 return Result;
918}
919
920} // end anonymous namespace
921
925 Attribute.setIsPragmaClangAttribute();
927 // Gather the subject match rules that are supported by the attribute.
929 StrictSubjectMatchRuleSet;
930 Attribute.getMatchRules(LangOpts, StrictSubjectMatchRuleSet);
931
932 // Figure out which subject matching rules are valid.
933 if (StrictSubjectMatchRuleSet.empty()) {
934 // Check for contradicting match rules. Contradicting match rules are
935 // either:
936 // - a top-level rule and one of its sub-rules. E.g. variable and
937 // variable(is_parameter).
938 // - a sub-rule and a sibling that's negated. E.g.
939 // variable(is_thread_local) and variable(unless(is_parameter))
940 llvm::SmallDenseMap<int, std::pair<int, SourceRange>, 2>
941 RulesToFirstSpecifiedNegatedSubRule;
942 for (const auto &Rule : Rules) {
943 attr::SubjectMatchRule MatchRule = attr::SubjectMatchRule(Rule.first);
944 std::optional<attr::SubjectMatchRule> ParentRule =
945 getParentAttrMatcherRule(MatchRule);
946 if (!ParentRule)
947 continue;
948 auto It = Rules.find(*ParentRule);
949 if (It != Rules.end()) {
950 // A sub-rule contradicts a parent rule.
951 Diag(Rule.second.getBegin(),
952 diag::err_pragma_attribute_matcher_subrule_contradicts_rule)
954 << attr::getSubjectMatchRuleSpelling(*ParentRule) << It->second
956 replacementRangeForListElement(*this, Rule.second));
957 // Keep going without removing this rule as it won't change the set of
958 // declarations that receive the attribute.
959 continue;
960 }
961 if (isNegatedAttrMatcherSubRule(MatchRule))
962 RulesToFirstSpecifiedNegatedSubRule.insert(
963 std::make_pair(*ParentRule, Rule));
964 }
965 bool IgnoreNegatedSubRules = false;
966 for (const auto &Rule : Rules) {
967 attr::SubjectMatchRule MatchRule = attr::SubjectMatchRule(Rule.first);
968 std::optional<attr::SubjectMatchRule> ParentRule =
969 getParentAttrMatcherRule(MatchRule);
970 if (!ParentRule)
971 continue;
972 auto It = RulesToFirstSpecifiedNegatedSubRule.find(*ParentRule);
973 if (It != RulesToFirstSpecifiedNegatedSubRule.end() &&
974 It->second != Rule) {
975 // Negated sub-rule contradicts another sub-rule.
976 Diag(
977 It->second.second.getBegin(),
978 diag::
979 err_pragma_attribute_matcher_negated_subrule_contradicts_subrule)
981 attr::SubjectMatchRule(It->second.first))
982 << attr::getSubjectMatchRuleSpelling(MatchRule) << Rule.second
984 replacementRangeForListElement(*this, It->second.second));
985 // Keep going but ignore all of the negated sub-rules.
986 IgnoreNegatedSubRules = true;
987 RulesToFirstSpecifiedNegatedSubRule.erase(It);
988 }
989 }
990
991 if (!IgnoreNegatedSubRules) {
992 for (const auto &Rule : Rules)
993 SubjectMatchRules.push_back(attr::SubjectMatchRule(Rule.first));
994 } else {
995 for (const auto &Rule : Rules) {
996 if (!isNegatedAttrMatcherSubRule(attr::SubjectMatchRule(Rule.first)))
997 SubjectMatchRules.push_back(attr::SubjectMatchRule(Rule.first));
998 }
999 }
1000 Rules.clear();
1001 } else {
1002 // Each rule in Rules must be a strict subset of the attribute's
1003 // SubjectMatch rules. I.e. we're allowed to use
1004 // `apply_to=variables(is_global)` on an attrubute with SubjectList<[Var]>,
1005 // but should not allow `apply_to=variables` on an attribute which has
1006 // `SubjectList<[GlobalVar]>`.
1007 for (const auto &StrictRule : StrictSubjectMatchRuleSet) {
1008 // First, check for exact match.
1009 if (Rules.erase(StrictRule.first)) {
1010 // Add the rule to the set of attribute receivers only if it's supported
1011 // in the current language mode.
1012 if (StrictRule.second)
1013 SubjectMatchRules.push_back(StrictRule.first);
1014 }
1015 }
1016 // Check remaining rules for subset matches.
1017 auto RulesToCheck = Rules;
1018 for (const auto &Rule : RulesToCheck) {
1019 attr::SubjectMatchRule MatchRule = attr::SubjectMatchRule(Rule.first);
1020 if (auto ParentRule = getParentAttrMatcherRule(MatchRule)) {
1021 if (llvm::any_of(StrictSubjectMatchRuleSet,
1022 [ParentRule](const auto &StrictRule) {
1023 return StrictRule.first == *ParentRule &&
1024 StrictRule.second; // IsEnabled
1025 })) {
1026 SubjectMatchRules.push_back(MatchRule);
1027 Rules.erase(MatchRule);
1028 }
1029 }
1030 }
1031 }
1032
1033 if (!Rules.empty()) {
1034 auto Diagnostic =
1035 Diag(PragmaLoc, diag::err_pragma_attribute_invalid_matchers)
1036 << Attribute;
1038 for (const auto &Rule : Rules) {
1039 ExtraRules.push_back(attr::SubjectMatchRule(Rule.first));
1041 replacementRangeForListElement(*this, Rule.second));
1042 }
1043 Diagnostic << attrMatcherRuleListToString(ExtraRules);
1044 }
1045
1046 if (PragmaAttributeStack.empty()) {
1047 Diag(PragmaLoc, diag::err_pragma_attr_attr_no_push);
1048 return;
1049 }
1050
1051 PragmaAttributeStack.back().Entries.push_back(
1052 {PragmaLoc, &Attribute, std::move(SubjectMatchRules), /*IsUsed=*/false});
1053}
1054
1056 const IdentifierInfo *Namespace) {
1057 PragmaAttributeStack.emplace_back();
1058 PragmaAttributeStack.back().Loc = PragmaLoc;
1059 PragmaAttributeStack.back().Namespace = Namespace;
1060}
1061
1063 const IdentifierInfo *Namespace) {
1064 if (PragmaAttributeStack.empty()) {
1065 Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;
1066 return;
1067 }
1068
1069 // Dig back through the stack trying to find the most recently pushed group
1070 // that in Namespace. Note that this works fine if no namespace is present,
1071 // think of push/pops without namespaces as having an implicit "nullptr"
1072 // namespace.
1073 for (size_t Index = PragmaAttributeStack.size(); Index;) {
1074 --Index;
1075 if (PragmaAttributeStack[Index].Namespace == Namespace) {
1076 for (const PragmaAttributeEntry &Entry :
1077 PragmaAttributeStack[Index].Entries) {
1078 if (!Entry.IsUsed) {
1079 assert(Entry.Attribute && "Expected an attribute");
1080 Diag(Entry.Attribute->getLoc(), diag::warn_pragma_attribute_unused)
1081 << *Entry.Attribute;
1082 Diag(PragmaLoc, diag::note_pragma_attribute_region_ends_here);
1083 }
1084 }
1085 PragmaAttributeStack.erase(PragmaAttributeStack.begin() + Index);
1086 return;
1087 }
1088 }
1089
1090 if (Namespace)
1091 Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch)
1092 << 0 << Namespace->getName();
1093 else
1094 Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;
1095}
1096
1098 if (PragmaAttributeStack.empty())
1099 return;
1100 for (auto &Group : PragmaAttributeStack) {
1101 for (auto &Entry : Group.Entries) {
1102 ParsedAttr *Attribute = Entry.Attribute;
1103 assert(Attribute && "Expected an attribute");
1104 assert(Attribute->isPragmaClangAttribute() &&
1105 "expected #pragma clang attribute");
1106
1107 // Ensure that the attribute can be applied to the given declaration.
1108 bool Applies = false;
1109 for (const auto &Rule : Entry.MatchRules) {
1110 if (Attribute->appliesToDecl(D, Rule)) {
1111 Applies = true;
1112 break;
1113 }
1114 }
1115 if (!Applies)
1116 continue;
1117 Entry.IsUsed = true;
1120 Attrs.addAtEnd(Attribute);
1121 ProcessDeclAttributeList(S, D, Attrs);
1123 }
1124 }
1125}
1126
1128 assert(PragmaAttributeCurrentTargetDecl && "Expected an active declaration");
1130 diag::note_pragma_attribute_applied_decl_here);
1131}
1132
1134 if (PragmaAttributeStack.empty())
1135 return;
1136 Diag(PragmaAttributeStack.back().Loc, diag::err_pragma_attribute_no_pop_eof);
1137}
1138
1140 if(On)
1142 else
1143 OptimizeOffPragmaLocation = PragmaLoc;
1144}
1145
1148 Diag(Loc, diag::err_pragma_expected_file_scope) << "optimize";
1149 return;
1150 }
1151
1152 MSPragmaOptimizeIsOn = IsOn;
1153}
1154
1156 SourceLocation Loc, const llvm::SmallVectorImpl<StringRef> &NoBuiltins) {
1158 Diag(Loc, diag::err_pragma_expected_file_scope) << "function";
1159 return;
1160 }
1161
1162 MSFunctionNoBuiltins.insert(NoBuiltins.begin(), NoBuiltins.end());
1163}
1164
1166 // In the future, check other pragmas if they're implemented (e.g. pragma
1167 // optimize 0 will probably map to this functionality too).
1170}
1171
1173 if (!FD->getIdentifier())
1174 return;
1175
1176 StringRef Name = FD->getName();
1177 auto It = FunctionToSectionMap.find(Name);
1178 if (It != FunctionToSectionMap.end()) {
1179 StringRef Section;
1180 SourceLocation Loc;
1181 std::tie(Section, Loc) = It->second;
1182
1183 if (!FD->hasAttr<SectionAttr>())
1184 FD->addAttr(SectionAttr::CreateImplicit(Context, Section));
1185 }
1186}
1187
1189 // Don't modify the function attributes if it's "on". "on" resets the
1190 // optimizations to the ones listed on the command line
1193}
1194
1196 SourceLocation Loc) {
1197 // Don't add a conflicting attribute. No diagnostic is needed.
1198 if (FD->hasAttr<MinSizeAttr>() || FD->hasAttr<AlwaysInlineAttr>())
1199 return;
1200
1201 // Add attributes only if required. Optnone requires noinline as well, but if
1202 // either is already present then don't bother adding them.
1203 if (!FD->hasAttr<OptimizeNoneAttr>())
1204 FD->addAttr(OptimizeNoneAttr::CreateImplicit(Context, Loc));
1205 if (!FD->hasAttr<NoInlineAttr>())
1206 FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc));
1207}
1208
1211 MSFunctionNoBuiltins.end());
1212 if (!MSFunctionNoBuiltins.empty())
1213 FD->addAttr(NoBuiltinAttr::CreateImplicit(Context, V.data(), V.size()));
1214}
1215
1216typedef std::vector<std::pair<unsigned, SourceLocation> > VisStack;
1217enum : unsigned { NoVisibility = ~0U };
1218
1220 if (!VisContext)
1221 return;
1222
1223 NamedDecl *ND = dyn_cast<NamedDecl>(D);
1225 return;
1226
1227 VisStack *Stack = static_cast<VisStack*>(VisContext);
1228 unsigned rawType = Stack->back().first;
1229 if (rawType == NoVisibility) return;
1230
1231 VisibilityAttr::VisibilityType type
1232 = (VisibilityAttr::VisibilityType) rawType;
1233 SourceLocation loc = Stack->back().second;
1234
1235 D->addAttr(VisibilityAttr::CreateImplicit(Context, type, loc));
1236}
1237
1238/// FreeVisContext - Deallocate and null out VisContext.
1240 delete static_cast<VisStack*>(VisContext);
1241 VisContext = nullptr;
1242}
1243
1244static void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc) {
1245 // Put visibility on stack.
1246 if (!S.VisContext)
1247 S.VisContext = new VisStack;
1248
1249 VisStack *Stack = static_cast<VisStack*>(S.VisContext);
1250 Stack->push_back(std::make_pair(type, loc));
1251}
1252
1254 SourceLocation PragmaLoc) {
1255 if (VisType) {
1256 // Compute visibility to use.
1257 VisibilityAttr::VisibilityType T;
1258 if (!VisibilityAttr::ConvertStrToVisibilityType(VisType->getName(), T)) {
1259 Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType;
1260 return;
1261 }
1262 PushPragmaVisibility(*this, T, PragmaLoc);
1263 } else {
1264 PopPragmaVisibility(false, PragmaLoc);
1265 }
1266}
1267
1270 FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides();
1271 switch (FPC) {
1273 NewFPFeatures.setAllowFPContractWithinStatement();
1274 break;
1276 NewFPFeatures.setAllowFPContractAcrossStatement();
1277 break;
1279 NewFPFeatures.setDisallowFPContract();
1280 break;
1282 llvm_unreachable("Should not happen");
1283 }
1284 FpPragmaStack.Act(Loc, Sema::PSK_Set, StringRef(), NewFPFeatures);
1285 CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts());
1286}
1287
1289 PragmaFPKind Kind, bool IsEnabled) {
1290 if (IsEnabled) {
1291 // For value unsafe context, combining this pragma with eval method
1292 // setting is not recommended. See comment in function FixupInvocation#506.
1293 int Reason = -1;
1294 if (getLangOpts().getFPEvalMethod() != LangOptions::FEM_UnsetOnCommandLine)
1295 // Eval method set using the option 'ffp-eval-method'.
1296 Reason = 1;
1298 // Eval method set using the '#pragma clang fp eval_method'.
1299 // We could have both an option and a pragma used to the set the eval
1300 // method. The pragma overrides the option in the command line. The Reason
1301 // of the diagnostic is overriden too.
1302 Reason = 0;
1303 if (Reason != -1)
1304 Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context)
1305 << Reason << (Kind == PFK_Reassociate ? 4 : 5);
1306 }
1307
1308 FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides();
1309 switch (Kind) {
1310 case PFK_Reassociate:
1311 NewFPFeatures.setAllowFPReassociateOverride(IsEnabled);
1312 break;
1313 case PFK_Reciprocal:
1314 NewFPFeatures.setAllowReciprocalOverride(IsEnabled);
1315 break;
1316 default:
1317 llvm_unreachable("unhandled value changing pragma fp");
1318 }
1319
1320 FpPragmaStack.Act(Loc, PSK_Set, StringRef(), NewFPFeatures);
1321 CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts());
1322}
1323
1324void Sema::ActOnPragmaFEnvRound(SourceLocation Loc, llvm::RoundingMode FPR) {
1325 FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides();
1326 NewFPFeatures.setConstRoundingModeOverride(FPR);
1327 FpPragmaStack.Act(Loc, PSK_Set, StringRef(), NewFPFeatures);
1328 CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts());
1329}
1330
1333 FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides();
1334 NewFPFeatures.setSpecifiedExceptionModeOverride(FPE);
1335 FpPragmaStack.Act(Loc, PSK_Set, StringRef(), NewFPFeatures);
1336 CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts());
1337}
1338
1340 FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides();
1341 if (IsEnabled) {
1342 // Verify Microsoft restriction:
1343 // You can't enable fenv_access unless precise semantics are enabled.
1344 // Precise semantics can be enabled either by the float_control
1345 // pragma, or by using the /fp:precise or /fp:strict compiler options
1346 if (!isPreciseFPEnabled())
1347 Diag(Loc, diag::err_pragma_fenv_requires_precise);
1348 }
1349 NewFPFeatures.setAllowFEnvAccessOverride(IsEnabled);
1350 NewFPFeatures.setRoundingMathOverride(IsEnabled);
1351 FpPragmaStack.Act(Loc, PSK_Set, StringRef(), NewFPFeatures);
1352 CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts());
1353}
1354
1357 FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides();
1358 NewFPFeatures.setComplexRangeOverride(Range);
1359 FpPragmaStack.Act(Loc, PSK_Set, StringRef(), NewFPFeatures);
1360 CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts());
1361}
1362
1365 setExceptionMode(Loc, FPE);
1366}
1367
1368void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
1369 SourceLocation Loc) {
1370 // Visibility calculations will consider the namespace's visibility.
1371 // Here we just want to note that we're in a visibility context
1372 // which overrides any enclosing #pragma context, but doesn't itself
1373 // contribute visibility.
1375}
1376
1377void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) {
1378 if (!VisContext) {
1379 Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
1380 return;
1381 }
1382
1383 // Pop visibility from stack
1384 VisStack *Stack = static_cast<VisStack*>(VisContext);
1385
1386 const std::pair<unsigned, SourceLocation> *Back = &Stack->back();
1387 bool StartsWithPragma = Back->first != NoVisibility;
1388 if (StartsWithPragma && IsNamespaceEnd) {
1389 Diag(Back->second, diag::err_pragma_push_visibility_mismatch);
1390 Diag(EndLoc, diag::note_surrounding_namespace_ends_here);
1391
1392 // For better error recovery, eat all pushes inside the namespace.
1393 do {
1394 Stack->pop_back();
1395 Back = &Stack->back();
1396 StartsWithPragma = Back->first != NoVisibility;
1397 } while (StartsWithPragma);
1398 } else if (!StartsWithPragma && !IsNamespaceEnd) {
1399 Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
1400 Diag(Back->second, diag::note_surrounding_namespace_starts_here);
1401 return;
1402 }
1403
1404 Stack->pop_back();
1405 // To simplify the implementation, never keep around an empty stack.
1406 if (Stack->empty())
1408}
1409
1410template <typename Ty>
1411static bool checkCommonAttributeFeatures(Sema &S, const Ty *Node,
1412 const ParsedAttr &A,
1413 bool SkipArgCountCheck) {
1414 // Several attributes carry different semantics than the parsing requires, so
1415 // those are opted out of the common argument checks.
1416 //
1417 // We also bail on unknown and ignored attributes because those are handled
1418 // as part of the target-specific handling logic.
1420 return false;
1421 // Check whether the attribute requires specific language extensions to be
1422 // enabled.
1423 if (!A.diagnoseLangOpts(S))
1424 return true;
1425 // Check whether the attribute appertains to the given subject.
1426 if (!A.diagnoseAppertainsTo(S, Node))
1427 return true;
1428 // Check whether the attribute is mutually exclusive with other attributes
1429 // that have already been applied to the declaration.
1430 if (!A.diagnoseMutualExclusion(S, Node))
1431 return true;
1432 // Check whether the attribute exists in the target architecture.
1433 if (S.CheckAttrTarget(A))
1434 return true;
1435
1436 if (A.hasCustomParsing())
1437 return false;
1438
1439 if (!SkipArgCountCheck) {
1440 if (A.getMinArgs() == A.getMaxArgs()) {
1441 // If there are no optional arguments, then checking for the argument
1442 // count is trivial.
1443 if (!A.checkExactlyNumArgs(S, A.getMinArgs()))
1444 return true;
1445 } else {
1446 // There are optional arguments, so checking is slightly more involved.
1447 if (A.getMinArgs() && !A.checkAtLeastNumArgs(S, A.getMinArgs()))
1448 return true;
1449 else if (!A.hasVariadicArg() && A.getMaxArgs() &&
1450 !A.checkAtMostNumArgs(S, A.getMaxArgs()))
1451 return true;
1452 }
1453 }
1454
1455 return false;
1456}
1457
1459 bool SkipArgCountCheck) {
1460 return ::checkCommonAttributeFeatures(*this, D, A, SkipArgCountCheck);
1461}
1463 bool SkipArgCountCheck) {
1464 return ::checkCommonAttributeFeatures(*this, S, A, SkipArgCountCheck);
1465}
#define V(N, I)
Definition: ASTContext.h:3259
NodeId Parent
Definition: ASTDiff.cpp:191
DynTypedNode Node
llvm::MachO::Record Record
Definition: MachO.h:28
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.
@ NoVisibility
Definition: SemaAttr.cpp:1217
std::vector< std::pair< unsigned, SourceLocation > > VisStack
Definition: SemaAttr.cpp:1216
static void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc)
Definition: SemaAttr.cpp:1244
static void addGslOwnerPointerAttributeIfNotExisting(ASTContext &Context, CXXRecordDecl *Record)
Definition: SemaAttr.cpp:102
bool hasValue() const
Definition: APValue.h:399
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
Definition: ASTConsumer.cpp:18
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1068
llvm::StringMap< SectionInfo > SectionInfos
Definition: ASTContext.h:3375
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:752
PtrTy get() const
Definition: Ownership.h:170
Attr - This represents one attribute.
Definition: Attr.h:42
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
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)
Definition: Expr.cpp:350
bool isFileContext() const
Definition: DeclBase.h:2147
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1921
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1699
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:85
Decl()=delete
T * getAttr() const
Definition: DeclBase.h:578
void addAttr(Attr *A)
Definition: DeclBase.cpp:975
SourceLocation getLocation() const
Definition: DeclBase.h:444
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: DeclBase.h:1049
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
Definition: DeclBase.cpp:530
DeclContext * getDeclContext()
Definition: DeclBase.h:453
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclBase.h:436
bool hasAttr() const
Definition: DeclBase.h:582
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:978
The name of a declaration.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:822
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1571
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1547
This represents one expression.
Definition: Expr.h:110
bool isValueDependent() const
Determines whether the value of this expression depends on.
Definition: Expr.h:175
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Definition: Expr.h:192
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
Definition: Expr.h:277
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.
QualType getType() const
Definition: Expr.h:142
Represents difference between two FPOptions values.
Definition: LangOptions.h:870
void setAllowFPContractAcrossStatement()
Definition: LangOptions.h:902
void setFPPreciseEnabled(bool Value)
Definition: LangOptions.h:910
void setAllowFPContractWithinStatement()
Definition: LangOptions.h:898
FPOptions applyOverrides(FPOptions Base)
Definition: LangOptions.h:938
LangOptions::FPExceptionModeKind getExceptionMode() const
Definition: LangOptions.h:818
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:123
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.
Definition: Diagnostic.h:97
Represents a function declaration or definition.
Definition: Decl.h:1959
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)
Definition: Expr.cpp:2060
FPEvalMethodKind
Possible float expression evaluation method choices.
Definition: LangOptions.h:276
@ FEM_Extended
Use extended type for fp arithmetic.
Definition: LangOptions.h:285
@ FEM_Double
Use the type double for fp arithmetic.
Definition: LangOptions.h:283
@ FEM_UnsetOnCommandLine
Used only for FE option processing; this is only used to indicate that the user did not specify an ex...
Definition: LangOptions.h:290
@ FEM_Source
Use the declared type for fp arithmetic.
Definition: LangOptions.h:281
FPExceptionModeKind
Possible floating point exception behavior.
Definition: LangOptions.h:264
@ FPE_Strict
Strictly preserve the floating-point exception semantics.
Definition: LangOptions.h:270
@ FPE_Ignore
Assume that floating-point exceptions are masked.
Definition: LangOptions.h:266
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...
Definition: Lexer.cpp:1358
Represents the results of name lookup.
Definition: Lookup.h:46
DeclClass * getAsSingle() const
Definition: Lookup.h:553
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:359
This represents a decl that may have a name.
Definition: Decl.h:249
@ VisibilityForValue
Do an LV computation for, ultimately, a non-type declaration.
Definition: Decl.h:436
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:270
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:276
std::optional< Visibility > getExplicitVisibility(ExplicitVisibilityKind kind) const
If visibility was explicitly specified for this declaration, return that visibility.
Definition: Decl.cpp:1304
ParsedAttr - Represents a syntactic attribute.
Definition: ParsedAttr.h:126
bool hasCustomParsing() const
Definition: ParsedAttr.cpp:158
unsigned getMinArgs() const
Definition: ParsedAttr.cpp:148
bool checkExactlyNumArgs(class Sema &S, unsigned Num) const
Check if the attribute has exactly as many args as Num.
Definition: ParsedAttr.cpp:298
bool hasVariadicArg() const
Definition: ParsedAttr.cpp:266
bool diagnoseMutualExclusion(class Sema &S, const Decl *D) const
Definition: ParsedAttr.cpp:170
bool diagnoseAppertainsTo(class Sema &S, const Decl *D) const
Definition: ParsedAttr.cpp:162
bool checkAtLeastNumArgs(class Sema &S, unsigned Num) const
Check if the attribute has at least as many args as Num.
Definition: ParsedAttr.cpp:303
unsigned getMaxArgs() const
Definition: ParsedAttr.cpp:150
AttributeCommonInfo::Kind getKind() const
Definition: ParsedAttr.h:617
bool diagnoseLangOpts(class Sema &S) const
Definition: ParsedAttr.cpp:186
bool checkAtMostNumArgs(class Sema &S, unsigned Num) const
Check if the attribute has at most as many args as Num.
Definition: ParsedAttr.cpp:308
void addAtEnd(ParsedAttr *newAttr)
Definition: ParsedAttr.h:841
static PragmaCommentDecl * Create(const ASTContext &C, TranslationUnitDecl *DC, SourceLocation CommentLoc, PragmaMSCommentKind CommentKind, StringRef Arg)
Definition: Decl.cpp:5244
static PragmaDetectMismatchDecl * Create(const ASTContext &C, TranslationUnitDecl *DC, SourceLocation Loc, StringRef Name, StringRef Value)
Definition: Decl.cpp:5267
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.
Definition: Type.h:737
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6902
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:7102
QualType getCanonicalType() const
Definition: Type.h:6954
Represents a struct/union/class.
Definition: Decl.h:4133
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:41
unsigned getPackNumber() const
Definition: Sema.h:1402
bool IsPackSet() const
Definition: Sema.h:1404
bool IsAlignAttr() const
Definition: Sema.h:1398
Mode getAlignMode() const
Definition: Sema.h:1400
PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct)
Definition: SemaAttr.cpp:28
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:426
void ActOnPragmaMSOptimize(SourceLocation Loc, bool IsOn)
#pragma optimize("[optimization-list]", on | off).
Definition: SemaAttr.cpp:1146
bool ConstantFoldAttrArgs(const AttributeCommonInfo &CI, MutableArrayRef< Expr * > Args)
ConstantFoldAttrArgs - Folds attribute arguments into ConstantExprs (unless they are value dependent ...
Definition: SemaAttr.cpp:388
void ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc, const IdentifierInfo *Namespace)
Definition: SemaAttr.cpp:1055
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
Definition: Sema.h:7607
void ActOnPragmaAttributePop(SourceLocation PragmaLoc, const IdentifierInfo *Namespace)
Called on well-formed '#pragma clang attribute pop'.
Definition: SemaAttr.cpp:1062
void ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name, StringRef Value)
ActOnPragmaDetectMismatch - Call on well-formed #pragma detect_mismatch.
Definition: SemaAttr.cpp:514
const Decl * PragmaAttributeCurrentTargetDecl
The declaration that is currently receiving an attribute from the #pragma attribute stack.
Definition: Sema.h:1617
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
Definition: Sema.cpp:1911
void ActOnPragmaFEnvRound(SourceLocation Loc, llvm::RoundingMode)
Called to set constant rounding mode for floating point operations.
Definition: SemaAttr.cpp:1324
PragmaClangSection PragmaClangRodataSection
Definition: Sema.h:1324
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...
Definition: SemaAttr.cpp:1097
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 ...
Definition: SemaAttr.cpp:1458
PragmaClangSectionAction
Definition: Sema.h:1314
@ PCSA_Clear
Definition: Sema.h:1314
void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc)
Adds the 'optnone' attribute to the function declaration if there are no conflicts; Loc represents th...
Definition: SemaAttr.cpp:1195
PragmaStack< FPOptionsOverride > FpPragmaStack
Definition: Sema.h:1555
PragmaStack< StringLiteral * > CodeSegStack
Definition: Sema.h:1549
void AddRangeBasedOptnone(FunctionDecl *FD)
Only called on function definitions; if there is a pragma in scope with the effect of a range-based o...
Definition: SemaAttr.cpp:1165
void ActOnPragmaMSComment(SourceLocation CommentLoc, PragmaMSCommentKind Kind, StringRef Arg)
ActOnPragmaMSComment - Called on well formed #pragma comment(kind, "arg").
Definition: SemaAttr.cpp:506
SmallVector< AlignPackIncludeState, 8 > AlignPackIncludeStack
Definition: Sema.h:1544
void AddAlignmentAttributesForRecord(RecordDecl *RD)
AddAlignmentAttributesForRecord - Adds any needed alignment attributes to a the record decl,...
Definition: SemaAttr.cpp:53
FPOptionsOverride CurFPFeatureOverrides()
Definition: Sema.h:1556
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.
Definition: SemaAttr.cpp:735
void ActOnPragmaFloatControl(SourceLocation Loc, PragmaMsStackAction Action, PragmaFloatControlKind Value)
ActOnPragmaFloatControl - Call on well-formed #pragma float_control.
Definition: SemaAttr.cpp:549
void ActOnPragmaMSPointersToMembers(LangOptions::PragmaMSPointersToMembersKind Kind, SourceLocation PragmaLoc)
ActOnPragmaMSPointersToMembers - called on well formed #pragma pointers_to_members(representation met...
Definition: SemaAttr.cpp:603
ASTContext & Context
Definition: Sema.h:1030
void ActOnPragmaUnused(const Token &Identifier, Scope *curScope, SourceLocation PragmaLoc)
ActOnPragmaUnused - Called on well-formed '#pragma unused'.
Definition: SemaAttr.cpp:823
void ActOnPragmaMSAllocText(SourceLocation PragmaLocation, StringRef Section, const SmallVector< std::tuple< IdentifierInfo *, SourceLocation > > &Functions)
Called on well-formed #pragma alloc_text().
Definition: SemaAttr.cpp:787
PragmaStack< bool > StrictGuardStackCheckStack
Definition: Sema.h:1552
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)
Definition: SemaAttr.cpp:922
PragmaStack< StringLiteral * > ConstSegStack
Definition: Sema.h:1548
void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind, SourceLocation PragmaLoc)
ActOnPragmaOptionsAlign - Called on well formed #pragma options align.
Definition: SemaAttr.cpp:218
void ActOnPragmaCXLimitedRange(SourceLocation Loc, LangOptions::ComplexRangeKind Range)
ActOnPragmaCXLimitedRange - Called on well formed #pragma STDC CX_LIMITED_RANGE.
Definition: SemaAttr.cpp:1355
void ActOnPragmaFPExceptions(SourceLocation Loc, LangOptions::FPExceptionModeKind)
Called on well formed '#pragma clang fp' that has option 'exceptions'.
Definition: SemaAttr.cpp:1363
void inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord)
Add gsl::Pointer attribute to std::container::iterator.
Definition: SemaAttr.cpp:111
void ActOnPragmaFPEvalMethod(SourceLocation Loc, LangOptions::FPEvalMethodKind Value)
Definition: SemaAttr.cpp:522
void ActOnPragmaClangSection(SourceLocation PragmaLoc, PragmaClangSectionAction Action, PragmaClangSectionKind SecKind, StringRef SecName)
ActOnPragmaClangSection - Called on well formed #pragma clang section.
Definition: SemaAttr.cpp:273
bool UnifySection(StringRef SectionName, int SectionFlags, NamedDecl *TheDecl)
Definition: SemaAttr.cpp:681
void setExceptionMode(SourceLocation Loc, LangOptions::FPExceptionModeKind)
Called to set exception behavior for floating point operations.
Definition: SemaAttr.cpp:1331
void PrintPragmaAttributeInstantiationPoint()
Definition: SemaAttr.cpp:1127
void inferGslOwnerPointerAttribute(CXXRecordDecl *Record)
Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.
Definition: SemaAttr.cpp:167
const LangOptions & getLangOpts() const
Definition: Sema.h:494
SourceLocation CurInitSegLoc
Definition: Sema.h:1588
void ActOnPragmaMSVtorDisp(PragmaMsStackAction Action, SourceLocation PragmaLoc, MSVtorDispMode Value)
Called on well formed #pragma vtordisp().
Definition: SemaAttr.cpp:610
Preprocessor & PP
Definition: Sema.h:1029
bool MSPragmaOptimizeIsOn
The "on" or "off" argument passed by #pragma optimize, that denotes whether the optimizations in the ...
Definition: Sema.h:1635
SmallVector< PragmaAttributeGroup, 2 > PragmaAttributeStack
Definition: Sema.h:1613
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.
Definition: Sema.cpp:636
const LangOptions & LangOpts
Definition: Sema.h:1028
PragmaClangSection PragmaClangRelroSection
Definition: Sema.h:1325
SourceLocation ImplicitMSInheritanceAttrLoc
Source location for newly created implicit MSInheritanceAttrs.
Definition: Sema.h:1302
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...
Definition: SemaAttr.cpp:1209
PragmaStack< AlignPackInfo > AlignPackStack
Definition: Sema.h:1537
PragmaStack< StringLiteral * > BSSSegStack
Definition: Sema.h:1547
llvm::StringMap< std::tuple< StringRef, SourceLocation > > FunctionToSectionMap
Sections used with #pragma alloc_text.
Definition: Sema.h:1591
llvm::SmallSetVector< StringRef, 4 > MSFunctionNoBuiltins
Set of no-builtin functions listed by #pragma function.
Definition: Sema.h:1638
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,...
Definition: SemaAttr.cpp:851
void AddPushedVisibilityAttribute(Decl *RD)
AddPushedVisibilityAttribute - If '#pragma GCC visibility' was used, add an appropriate visibility at...
Definition: SemaAttr.cpp:1219
StringLiteral * CurInitSeg
Last section used with #pragma init_seg.
Definition: Sema.h:1587
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:1163
void ActOnPragmaMSFunction(SourceLocation Loc, const llvm::SmallVectorImpl< StringRef > &NoBuiltins)
Call on well formed #pragma function.
Definition: SemaAttr.cpp:1155
void ActOnPragmaMSStruct(PragmaMSStructKind Kind)
ActOnPragmaMSStruct - Called on well formed #pragma ms_struct [on|off].
Definition: SemaAttr.cpp:502
bool isPreciseFPEnabled()
Are precise floating point semantics currently enabled?
Definition: Sema.h:1710
void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation, StringLiteral *SegmentName)
Called on well-formed #pragma init_seg().
Definition: SemaAttr.cpp:778
bool MSStructPragmaOn
Definition: Sema.h:1299
SourceManager & getSourceManager() const
Definition: Sema.h:499
void DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind, SourceLocation IncludeLoc)
Definition: SemaAttr.cpp:436
PragmaClangSection PragmaClangTextSection
Definition: Sema.h:1326
void ActOnPragmaFPValueChangingOption(SourceLocation Loc, PragmaFPKind Kind, bool IsEnabled)
Called on well formed #pragma clang fp reassociate or #pragma clang fp reciprocal.
Definition: SemaAttr.cpp:1288
PragmaClangSection PragmaClangDataSection
Definition: Sema.h:1323
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.
Definition: SemaAttr.cpp:1368
PragmaStack< MSVtorDispMode > VtorDispStack
Whether to insert vtordisps prior to virtual bases in the Microsoft C++ ABI.
Definition: Sema.h:1536
void AddMsStructLayoutForRecord(RecordDecl *RD)
AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.
Definition: SemaAttr.cpp:89
void * VisContext
VisContext - Manages the stack for #pragma GCC visibility.
Definition: Sema.h:1594
bool CheckAttrTarget(const ParsedAttr &CurrAttr)
ASTConsumer & Consumer
Definition: Sema.h:1031
PragmaAlignPackDiagnoseKind
Definition: Sema.h:1688
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:1002
void DiagnoseUnterminatedPragmaAttribute()
Definition: SemaAttr.cpp:1133
void FreeVisContext()
FreeVisContext - Deallocate and null out VisContext.
Definition: SemaAttr.cpp:1239
void ModifyFnAttributesMSPragmaOptimize(FunctionDecl *FD)
Only called on function definitions; if there is a MSVC #pragma optimize in scope,...
Definition: SemaAttr.cpp:1188
void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc)
PopPragmaVisibility - Pop the top element of the visibility stack; used for '#pragma GCC visibility' ...
Definition: SemaAttr.cpp:1377
SourceManager & SourceMgr
Definition: Sema.h:1033
void ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action, StringRef SlotLabel, Expr *Alignment)
ActOnPragmaPack - Called on well formed #pragma pack(...).
Definition: SemaAttr.cpp:322
DiagnosticsEngine & Diags
Definition: Sema.h:1032
void DiagnoseUnterminatedPragmaAlignPack()
Definition: SemaAttr.cpp:475
FPOptions CurFPFeatures
Definition: Sema.h:1026
PragmaStack< StringLiteral * > DataSegStack
Definition: Sema.h:1546
void ActOnPragmaVisibility(const IdentifierInfo *VisType, SourceLocation PragmaLoc)
ActOnPragmaVisibility - Called on well formed #pragma GCC visibility... .
Definition: SemaAttr.cpp:1253
SourceLocation OptimizeOffPragmaLocation
This represents the last location of a "#pragma clang optimize off" directive if such a directive has...
Definition: Sema.h:1622
LangOptions::PragmaMSPointersToMembersKind MSPointerToMemberRepresentationMethod
Controls member pointer representation format under the MS ABI.
Definition: Sema.h:1297
void ActOnPragmaMSStrictGuardStackCheck(SourceLocation PragmaLocation, PragmaMsStackAction Action, bool Value)
ActOnPragmaMSStrictGuardStackCheck - Called on well formed #pragma strict_gs_check.
Definition: SemaAttr.cpp:762
PragmaClangSection PragmaClangBSSSection
Definition: Sema.h:1322
PragmaOptionsAlignKind
Definition: Sema.h:1658
@ POAK_Power
Definition: Sema.h:1662
@ POAK_Reset
Definition: Sema.h:1664
@ POAK_Packed
Definition: Sema.h:1661
@ POAK_Mac68k
Definition: Sema.h:1663
@ POAK_Natural
Definition: Sema.h:1660
@ POAK_Native
Definition: Sema.h:1659
void ActOnPragmaFPContract(SourceLocation Loc, LangOptions::FPModeKind FPC)
ActOnPragmaFPContract - Called on well formed #pragma {STDC,OPENCL} FP_CONTRACT and #pragma clang fp ...
Definition: SemaAttr.cpp:1268
void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc)
Called on well formed #pragma clang optimize.
Definition: SemaAttr.cpp:1139
void ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled)
ActOnPragmaFenvAccess - Called on well formed #pragma STDC FENV_ACCESS.
Definition: SemaAttr.cpp:1339
void AddSectionMSAllocText(FunctionDecl *FD)
Only called on function definitions; if there is a #pragma alloc_text that decides which code section...
Definition: SemaAttr.cpp:1172
void ActOnPragmaMSSection(SourceLocation PragmaLocation, int SectionFlags, StringLiteral *SegmentName)
Called on well formed #pragma section().
Definition: SemaAttr.cpp:773
PragmaClangSectionKind
pragma clang section kind
Definition: Sema.h:1305
@ PCSK_BSS
Definition: Sema.h:1307
@ PCSK_Data
Definition: Sema.h:1308
@ PCSK_Text
Definition: Sema.h:1310
@ PCSK_Relro
Definition: Sema.h:1311
@ PCSK_Rodata
Definition: Sema.h:1309
PragmaMsStackAction
Definition: Sema.h:1328
@ PSK_Push_Set
Definition: Sema.h:1334
@ PSK_Reset
Definition: Sema.h:1329
@ PSK_Show
Definition: Sema.h:1333
@ PSK_Pop
Definition: Sema.h:1332
@ PSK_Set
Definition: Sema.h:1330
@ PSK_Push
Definition: Sema.h:1331
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.
Definition: Stmt.h:84
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:338
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1773
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.h:1954
StringRef getString() const
Definition: Expr.h:1850
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:136
bool hasAlignMac68kSupport() const
Check whether this target support '#pragma options align=mac68k'.
Definition: TargetInfo.h:920
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1291
Token - This structure provides full information about a lexed token.
Definition: Token.h:36
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:187
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file.
Definition: Token.h:132
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1819
bool isArrayType() const
Definition: Type.h:7220
bool isFunctionType() const
Definition: Type.h:7150
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3399
QualType getUnderlyingType() const
Definition: Decl.h:3454
Represents a variable declaration or definition.
Definition: Decl.h:918
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)
Definition: Attributes.cpp:69
The JSON file list parser is used to communicate input to InstallAPI.
PragmaFPKind
Definition: PragmaKinds.h:38
@ PFK_Reassociate
Definition: PragmaKinds.h:40
@ PFK_Reciprocal
Definition: PragmaKinds.h:41
@ CPlusPlus
Definition: LangStandard.h:54
PragmaMSCommentKind
Definition: PragmaKinds.h:14
@ AANT_ArgumentConstantExpr
Definition: ParsedAttr.h:1074
@ 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...
Definition: LangOptions.h:35
PragmaMSStructKind
Definition: PragmaKinds.h:23
@ PMSST_ON
Definition: PragmaKinds.h:25
PragmaFloatControlKind
Definition: PragmaKinds.h:28
@ PFC_NoExcept
Definition: PragmaKinds.h:33
@ PFC_NoPrecise
Definition: PragmaKinds.h:31
@ PFC_Pop
Definition: PragmaKinds.h:35
@ PFC_Precise
Definition: PragmaKinds.h:30
@ PFC_Except
Definition: PragmaKinds.h:32
@ PFC_Push
Definition: PragmaKinds.h:34
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:132
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:642
APValue Val
Val - This is the value the expression can be folded to.
Definition: Expr.h:644
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
Definition: Expr.h:630
SourceLocation CurrentPragmaLocation
Definition: Sema.h:1541
This an attribute introduced by #pragma clang attribute.
Definition: Sema.h:1597
SourceLocation PragmaLocation
Definition: Sema.h:1319
ValueType CurrentValue
Definition: Sema.h:1522
void SentinelAction(PragmaMsStackAction Action, StringRef Label)
Definition: Sema.h:1508
SmallVector< Slot, 2 > Stack
Definition: Sema.h:1520
void Act(SourceLocation PragmaLocation, PragmaMsStackAction Action, llvm::StringRef StackSlotLabel, ValueType Value)
Definition: Sema.h:1459