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
14#include "clang/AST/ASTConsumer.h"
15#include "clang/AST/Attr.h"
16#include "clang/AST/Expr.h"
17#include "clang/Basic/TargetInfo.h"
18#include "clang/Lex/Preprocessor.h"
19#include "clang/Sema/Lookup.h"
20#include "clang/Sema/SemaInternal.h"
21#include <optional>
22using namespace clang;
23
24//===----------------------------------------------------------------------===//
25// Pragma 'pack' and 'options align'
26//===----------------------------------------------------------------------===//
27
28Sema::PragmaStackSentinelRAII::PragmaStackSentinelRAII(Sema &S,
29 StringRef SlotLabel,
30 bool ShouldAct)
31 : S(S), SlotLabel(SlotLabel), ShouldAct(ShouldAct) {
32 if (ShouldAct) {
33 S.VtorDispStack.SentinelAction(Action: PSK_Push, Label: SlotLabel);
34 S.DataSegStack.SentinelAction(Action: PSK_Push, Label: SlotLabel);
35 S.BSSSegStack.SentinelAction(Action: PSK_Push, Label: SlotLabel);
36 S.ConstSegStack.SentinelAction(Action: PSK_Push, Label: SlotLabel);
37 S.CodeSegStack.SentinelAction(Action: PSK_Push, Label: SlotLabel);
38 S.StrictGuardStackCheckStack.SentinelAction(Action: PSK_Push, Label: SlotLabel);
39 }
40}
41
42Sema::PragmaStackSentinelRAII::~PragmaStackSentinelRAII() {
43 if (ShouldAct) {
44 S.VtorDispStack.SentinelAction(Action: PSK_Pop, Label: SlotLabel);
45 S.DataSegStack.SentinelAction(Action: PSK_Pop, Label: SlotLabel);
46 S.BSSSegStack.SentinelAction(Action: PSK_Pop, Label: SlotLabel);
47 S.ConstSegStack.SentinelAction(Action: PSK_Pop, Label: SlotLabel);
48 S.CodeSegStack.SentinelAction(Action: PSK_Pop, Label: SlotLabel);
49 S.StrictGuardStackCheckStack.SentinelAction(Action: PSK_Pop, Label: SlotLabel);
50 }
51}
52
53void Sema::AddAlignmentAttributesForRecord(RecordDecl *RD) {
54 AlignPackInfo InfoVal = AlignPackStack.CurrentValue;
55 AlignPackInfo::Mode M = InfoVal.getAlignMode();
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(C&: AlignPackIncludeStack)) {
81 if (AlignPackedInclude.CurrentPragmaLocation !=
82 AlignPackStack.CurrentPragmaLocation)
83 break;
84 if (AlignPackedInclude.HasNonDefaultValue)
85 AlignPackedInclude.ShouldWarnOnInclude = true;
86 }
87}
88
89void Sema::AddMsStructLayoutForRecord(RecordDecl *RD) {
90 if (MSStructPragmaOn)
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(
98 Context, unsigned(VtorDispStack.CurrentValue)));
99}
100
101template <typename Attribute>
102static void addGslOwnerPointerAttributeIfNotExisting(ASTContext &Context,
103 CXXRecordDecl *Record) {
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
111void Sema::inferGslPointerAttribute(NamedDecl *ND,
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
150void Sema::inferGslPointerAttribute(TypedefNameDecl *TD) {
151
152 QualType Canonical = TD->getUnderlyingType().getCanonicalType();
153
154 CXXRecordDecl *RD = Canonical->getAsCXXRecordDecl();
155 if (!RD) {
156 if (auto *TST =
157 dyn_cast<TemplateSpecializationType>(Val: Canonical.getTypePtr())) {
158
159 RD = dyn_cast_or_null<CXXRecordDecl>(
160 Val: TST->getTemplateName().getAsTemplateDecl()->getTemplatedDecl());
161 }
162 }
163
164 inferGslPointerAttribute(TD, RD);
165}
166
167void Sema::inferGslOwnerPointerAttribute(CXXRecordDecl *Record) {
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.
215 inferGslPointerAttribute(Record, Record);
216}
217
218void Sema::ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
219 SourceLocation PragmaLoc) {
220 PragmaMsStackAction Action = Sema::PSK_Reset;
221 AlignPackInfo::Mode ModeVal = AlignPackInfo::Native;
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.
244 if (!this->Context.getTargetInfo().hasAlignMac68kSupport()) {
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(PragmaLocation: PragmaLoc, Action, StackSlotLabel: StringRef(), Value: Info);
271}
272
273void Sema::ActOnPragmaClangSection(SourceLocation PragmaLoc,
274 PragmaClangSectionAction Action,
275 PragmaClangSectionKind SecKind,
276 StringRef SecName) {
277 PragmaClangSection *CSec;
278 int SectionFlags = ASTContext::PSF_Read;
279 switch (SecKind) {
280 case PragmaClangSectionKind::PCSK_BSS:
281 CSec = &PragmaClangBSSSection;
282 SectionFlags |= ASTContext::PSF_Write | ASTContext::PSF_ZeroInit;
283 break;
284 case PragmaClangSectionKind::PCSK_Data:
285 CSec = &PragmaClangDataSection;
286 SectionFlags |= ASTContext::PSF_Write;
287 break;
288 case PragmaClangSectionKind::PCSK_Rodata:
289 CSec = &PragmaClangRodataSection;
290 break;
291 case PragmaClangSectionKind::PCSK_Relro:
292 CSec = &PragmaClangRelroSection;
293 break;
294 case PragmaClangSectionKind::PCSK_Text:
295 CSec = &PragmaClangTextSection;
296 SectionFlags |= ASTContext::PSF_Execute;
297 break;
298 default:
299 llvm_unreachable("invalid clang section kind");
300 }
301
302 if (Action == PragmaClangSectionAction::PCSA_Clear) {
303 CSec->Valid = false;
304 return;
305 }
306
307 if (llvm::Error E = isValidSectionSpecifier(Str: 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(SectionName: SecName, SectionFlags, PragmaSectionLocation: PragmaLoc))
315 return;
316
317 CSec->Valid = true;
318 CSec->SectionName = std::string(SecName);
319 CSec->PragmaLocation = PragmaLoc;
320}
321
322void Sema::ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
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(Ctx: 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(PragmaLocation: PragmaLoc, Action, StackSlotLabel: SlotLabel, Value: Info);
386}
387
388bool Sema::ConstantFoldAttrArgs(const AttributeCommonInfo &CI,
389 MutableArrayRef<Expr *> Args) {
390 llvm::SmallVector<PartialDiagnosticAt, 8> Notes;
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())
400 E = ImpCastExprToType(E, Type: Context.getPointerType(T: E->getType()),
401 CK: clang::CK_ArrayToPointerDecay)
402 .get();
403 if (E->getType()->isFunctionType())
404 E = ImplicitCastExpr::Create(Context,
405 T: Context.getPointerType(T: E->getType()),
406 Kind: clang::CK_FunctionToPointerDecay, Operand: E, BasePath: nullptr,
407 Cat: VK_PRValue, FPO: FPOptionsOverride());
408 if (E->isLValue())
409 E = ImplicitCastExpr::Create(Context, T: E->getType().getNonReferenceType(),
410 Kind: clang::CK_LValueToRValue, Operand: E, BasePath: nullptr,
411 Cat: VK_PRValue, FPO: FPOptionsOverride());
412
413 Expr::EvalResult Eval;
414 Notes.clear();
415 Eval.Diag = &Notes;
416
417 bool Result = E->EvaluateAsConstantExpr(Result&: Eval, Ctx: 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(Loc: Note.first, PD: Note.second);
427 return false;
428 }
429 assert(Eval.Val.hasValue());
430 E = ConstantExpr::Create(Context, E, Result: Eval.Val);
431 }
432
433 return true;
434}
435
436void Sema::DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind,
437 SourceLocation IncludeLoc) {
438 if (Kind == PragmaAlignPackDiagnoseKind::NonDefaultStateAtInclude) {
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 Elt: {.CurrentValue: AlignPackStack.CurrentValue,
451 .CurrentPragmaLocation: AlignPackStack.hasValue() ? PrevLocation : SourceLocation(),
452 .HasNonDefaultValue: HasNonDefaultValue, /*ShouldWarnOnInclude*/ false});
453 return;
454 }
455
456 assert(Kind == PragmaAlignPackDiagnoseKind::ChangedStateAtExit &&
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
475void Sema::DiagnoseUnterminatedPragmaAlignPack() {
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(C&: 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(loc: AlignPackStack.CurrentPragmaLocation,
493 TKind: tok::l_paren, SM: SourceMgr, LangOpts,
494 /*SkipTrailing=*/SkipTrailingWhitespaceAndNewLine: false);
495 if (FixItLoc.isValid())
496 DB << FixItHint::CreateInsertion(InsertionLoc: FixItLoc, Code: "pop");
497 }
498 IsInnermost = false;
499 }
500}
501
502void Sema::ActOnPragmaMSStruct(PragmaMSStructKind Kind) {
503 MSStructPragmaOn = (Kind == PMSST_ON);
504}
505
506void Sema::ActOnPragmaMSComment(SourceLocation CommentLoc,
507 PragmaMSCommentKind Kind, StringRef Arg) {
508 auto *PCD = PragmaCommentDecl::Create(
509 C: Context, DC: Context.getTranslationUnitDecl(), CommentLoc, CommentKind: Kind, Arg);
510 Context.getTranslationUnitDecl()->addDecl(PCD);
511 Consumer.HandleTopLevelDecl(D: DeclGroupRef(PCD));
512}
513
514void Sema::ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
515 StringRef Value) {
516 auto *PDMD = PragmaDetectMismatchDecl::Create(
517 C: Context, DC: Context.getTranslationUnitDecl(), Loc, Name, Value);
518 Context.getTranslationUnitDecl()->addDecl(PDMD);
519 Consumer.HandleTopLevelDecl(D: DeclGroupRef(PDMD));
520}
521
522void Sema::ActOnPragmaFPEvalMethod(SourceLocation Loc,
523 LangOptions::FPEvalMethodKind Value) {
524 FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides();
525 switch (Value) {
526 default:
527 llvm_unreachable("invalid pragma eval_method kind");
528 case LangOptions::FEM_Source:
529 NewFPFeatures.setFPEvalMethodOverride(LangOptions::FEM_Source);
530 break;
531 case LangOptions::FEM_Double:
532 NewFPFeatures.setFPEvalMethodOverride(LangOptions::FEM_Double);
533 break;
534 case LangOptions::FEM_Extended:
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(PragmaLocation: Loc, Action: PSK_Set, StackSlotLabel: StringRef(), Value: NewFPFeatures);
545 CurFPFeatures = NewFPFeatures.applyOverrides(LO: getLangOpts());
546 PP.setCurrentFPEvalMethod(PragmaLoc: Loc, Val: Value);
547}
548
549void Sema::ActOnPragmaFloatControl(SourceLocation Loc,
550 PragmaMsStackAction Action,
551 PragmaFloatControlKind Value) {
552 FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides();
553 if ((Action == PSK_Push_Set || Action == PSK_Push || Action == PSK_Pop) &&
554 !CurContext->getRedeclContext()->isFileContext()) {
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(PragmaLocation: Loc, Action, StackSlotLabel: StringRef(), Value: NewFPFeatures);
566 break;
567 case PFC_NoPrecise:
568 if (CurFPFeatures.getExceptionMode() == LangOptions::FPE_Strict)
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(PragmaLocation: Loc, Action, StackSlotLabel: StringRef(), Value: 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(PragmaLocation: Loc, Action, StackSlotLabel: StringRef(), Value: NewFPFeatures);
582 break;
583 case PFC_NoExcept:
584 NewFPFeatures.setSpecifiedExceptionModeOverride(LangOptions::FPE_Ignore);
585 FpPragmaStack.Act(PragmaLocation: Loc, Action, StackSlotLabel: StringRef(), Value: NewFPFeatures);
586 break;
587 case PFC_Push:
588 FpPragmaStack.Act(PragmaLocation: Loc, Action: Sema::PSK_Push_Set, StackSlotLabel: StringRef(), Value: 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(PragmaLocation: Loc, Action, StackSlotLabel: StringRef(), Value: NewFPFeatures);
597 NewFPFeatures = FpPragmaStack.CurrentValue;
598 break;
599 }
600 CurFPFeatures = NewFPFeatures.applyOverrides(LO: getLangOpts());
601}
602
603void Sema::ActOnPragmaMSPointersToMembers(
604 LangOptions::PragmaMSPointersToMembersKind RepresentationMethod,
605 SourceLocation PragmaLoc) {
606 MSPointerToMemberRepresentationMethod = RepresentationMethod;
607 ImplicitMSInheritanceAttrLoc = PragmaLoc;
608}
609
610void Sema::ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,
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(PragmaLocation: PragmaLoc, Action, StackSlotLabel: StringRef(), Value: Mode);
617}
618
619template <>
620void Sema::PragmaStack<Sema::AlignPackInfo>::Act(SourceLocation PragmaLocation,
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(Args: 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(Range: llvm::reverse(C&: Stack), P: [&](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(CS: std::prev(x: I.base()), CE: 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(Range: llvm::reverse(C&: Stack), P: [&](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(CS: std::prev(x: I.base()), CE: 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(Key: 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(Key: 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().
735void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation,
736 PragmaMsStackAction Action,
737 llvm::StringRef StackSlotLabel,
738 StringLiteral *SegmentName,
739 llvm::StringRef PragmaName) {
740 PragmaStack<StringLiteral *> *Stack =
741 llvm::StringSwitch<PragmaStack<StringLiteral *> *>(PragmaName)
742 .Case(S: "data_seg", Value: &DataSegStack)
743 .Case(S: "bss_seg", Value: &BSSSegStack)
744 .Case(S: "const_seg", Value: &ConstSegStack)
745 .Case(S: "code_seg", Value: &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(LiteralLoc: SegmentName->getBeginLoc(), Str: SegmentName->getString()))
751 return;
752
753 if (SegmentName->getString() == ".drectve" &&
754 Context.getTargetInfo().getCXXABI().isMicrosoft())
755 Diag(PragmaLocation, diag::warn_attribute_section_drectve) << PragmaName;
756 }
757
758 Stack->Act(PragmaLocation, Action, StackSlotLabel, Value: SegmentName);
759}
760
761/// Called on well formed \#pragma strict_gs_check().
762void Sema::ActOnPragmaMSStrictGuardStackCheck(SourceLocation PragmaLocation,
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, StackSlotLabel: StringRef(), Value);
770}
771
772/// Called on well formed \#pragma bss_seg().
773void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation,
774 int SectionFlags, StringLiteral *SegmentName) {
775 UnifySection(SectionName: SegmentName->getString(), SectionFlags, PragmaSectionLocation: PragmaLocation);
776}
777
778void Sema::ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
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
787void Sema::ActOnPragmaMSAllocText(
788 SourceLocation PragmaLocation, StringRef Section,
789 const SmallVector<std::tuple<IdentifierInfo *, SourceLocation>>
790 &Functions) {
791 if (!CurContext->getRedeclContext()->isFileContext()) {
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(args&: II, args&: Loc) = Function;
800
801 DeclarationName DN(II);
802 NamedDecl *ND = LookupSingleName(S: TUScope, Name: DN, Loc, NameKind: LookupOrdinaryName);
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(args&: Section, args&: 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(R&: Lookup, S: curScope, SS: nullptr, AllowBuiltinCreation: 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
851void Sema::AddCFAuditedAttribute(Decl *D) {
852 IdentifierInfo *Ident;
853 SourceLocation Loc;
854 std::tie(args&: Ident, args&: 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),
863 AttributeCommonInfo::Form::Pragma());
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.
899 SourceLocation AfterCommaLoc = Lexer::findLocationAfterToken(
900 loc: Range.getEnd(), TKind: tok::comma, SM: S.getSourceManager(), LangOpts: S.getLangOpts(),
901 /*SkipTrailingWhitespaceAndNewLine=*/false);
902 if (AfterCommaLoc.isValid())
903 return CharSourceRange::getCharRange(B: Range.getBegin(), E: AfterCommaLoc);
904 else
905 return CharSourceRange::getTokenRange(R: 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
922void Sema::ActOnPragmaAttributeAttribute(
923 ParsedAttr &Attribute, SourceLocation PragmaLoc,
924 attr::ParsedSubjectMatchRuleSet Rules) {
925 Attribute.setIsPragmaClangAttribute();
926 SmallVector<attr::SubjectMatchRule, 4> SubjectMatchRules;
927 // Gather the subject match rules that are supported by the attribute.
928 SmallVector<std::pair<attr::SubjectMatchRule, bool>, 4>
929 StrictSubjectMatchRuleSet;
930 Attribute.getMatchRules(LangOpts, MatchRules&: 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)
953 << attr::getSubjectMatchRuleSpelling(MatchRule)
954 << attr::getSubjectMatchRuleSpelling(*ParentRule) << It->second
955 << FixItHint::CreateRemoval(
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)
980 << attr::getSubjectMatchRuleSpelling(
981 attr::SubjectMatchRule(It->second.first))
982 << attr::getSubjectMatchRuleSpelling(MatchRule) << Rule.second
983 << FixItHint::CreateRemoval(
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(Elt: 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;
1037 SmallVector<attr::SubjectMatchRule, 2> ExtraRules;
1038 for (const auto &Rule : Rules) {
1039 ExtraRules.push_back(attr::SubjectMatchRule(Rule.first));
1040 Diagnostic << FixItHint::CreateRemoval(
1041 replacementRangeForListElement(*this, Rule.second));
1042 }
1043 Diagnostic << attrMatcherRuleListToString(Rules: 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 Elt: {.Loc: PragmaLoc, .Attribute: &Attribute, .MatchRules: std::move(SubjectMatchRules), /*IsUsed=*/false});
1053}
1054
1055void Sema::ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc,
1056 const IdentifierInfo *Namespace) {
1057 PragmaAttributeStack.emplace_back();
1058 PragmaAttributeStack.back().Loc = PragmaLoc;
1059 PragmaAttributeStack.back().Namespace = Namespace;
1060}
1061
1062void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc,
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(CI: 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
1097void Sema::AddPragmaAttributes(Scope *S, Decl *D) {
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, MatchRule: Rule)) {
1111 Applies = true;
1112 break;
1113 }
1114 }
1115 if (!Applies)
1116 continue;
1117 Entry.IsUsed = true;
1118 PragmaAttributeCurrentTargetDecl = D;
1119 ParsedAttributesView Attrs;
1120 Attrs.addAtEnd(newAttr: Attribute);
1121 ProcessDeclAttributeList(S, D, AttrList: Attrs);
1122 PragmaAttributeCurrentTargetDecl = nullptr;
1123 }
1124 }
1125}
1126
1127void Sema::PrintPragmaAttributeInstantiationPoint() {
1128 assert(PragmaAttributeCurrentTargetDecl && "Expected an active declaration");
1129 Diags.Report(PragmaAttributeCurrentTargetDecl->getBeginLoc(),
1130 diag::note_pragma_attribute_applied_decl_here);
1131}
1132
1133void Sema::DiagnoseUnterminatedPragmaAttribute() {
1134 if (PragmaAttributeStack.empty())
1135 return;
1136 Diag(PragmaAttributeStack.back().Loc, diag::err_pragma_attribute_no_pop_eof);
1137}
1138
1139void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) {
1140 if(On)
1141 OptimizeOffPragmaLocation = SourceLocation();
1142 else
1143 OptimizeOffPragmaLocation = PragmaLoc;
1144}
1145
1146void Sema::ActOnPragmaMSOptimize(SourceLocation Loc, bool IsOn) {
1147 if (!CurContext->getRedeclContext()->isFileContext()) {
1148 Diag(Loc, diag::err_pragma_expected_file_scope) << "optimize";
1149 return;
1150 }
1151
1152 MSPragmaOptimizeIsOn = IsOn;
1153}
1154
1155void Sema::ActOnPragmaMSFunction(
1156 SourceLocation Loc, const llvm::SmallVectorImpl<StringRef> &NoBuiltins) {
1157 if (!CurContext->getRedeclContext()->isFileContext()) {
1158 Diag(Loc, diag::err_pragma_expected_file_scope) << "function";
1159 return;
1160 }
1161
1162 MSFunctionNoBuiltins.insert(Start: NoBuiltins.begin(), End: NoBuiltins.end());
1163}
1164
1165void Sema::AddRangeBasedOptnone(FunctionDecl *FD) {
1166 // In the future, check other pragmas if they're implemented (e.g. pragma
1167 // optimize 0 will probably map to this functionality too).
1168 if(OptimizeOffPragmaLocation.isValid())
1169 AddOptnoneAttributeIfNoConflicts(FD, Loc: OptimizeOffPragmaLocation);
1170}
1171
1172void Sema::AddSectionMSAllocText(FunctionDecl *FD) {
1173 if (!FD->getIdentifier())
1174 return;
1175
1176 StringRef Name = FD->getName();
1177 auto It = FunctionToSectionMap.find(Key: Name);
1178 if (It != FunctionToSectionMap.end()) {
1179 StringRef Section;
1180 SourceLocation Loc;
1181 std::tie(args&: Section, args&: Loc) = It->second;
1182
1183 if (!FD->hasAttr<SectionAttr>())
1184 FD->addAttr(SectionAttr::CreateImplicit(Context, Section));
1185 }
1186}
1187
1188void Sema::ModifyFnAttributesMSPragmaOptimize(FunctionDecl *FD) {
1189 // Don't modify the function attributes if it's "on". "on" resets the
1190 // optimizations to the ones listed on the command line
1191 if (!MSPragmaOptimizeIsOn)
1192 AddOptnoneAttributeIfNoConflicts(FD, Loc: FD->getBeginLoc());
1193}
1194
1195void Sema::AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD,
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
1209void Sema::AddImplicitMSFunctionNoBuiltinAttr(FunctionDecl *FD) {
1210 SmallVector<StringRef> V(MSFunctionNoBuiltins.begin(),
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
1219void Sema::AddPushedVisibilityAttribute(Decl *D) {
1220 if (!VisContext)
1221 return;
1222
1223 NamedDecl *ND = dyn_cast<NamedDecl>(Val: D);
1224 if (ND && ND->getExplicitVisibility(kind: NamedDecl::VisibilityForValue))
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.
1239void Sema::FreeVisContext() {
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(x: std::make_pair(x&: type, y&: loc));
1251}
1252
1253void Sema::ActOnPragmaVisibility(const IdentifierInfo* VisType,
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(IsNamespaceEnd: false, EndLoc: PragmaLoc);
1265 }
1266}
1267
1268void Sema::ActOnPragmaFPContract(SourceLocation Loc,
1269 LangOptions::FPModeKind FPC) {
1270 FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides();
1271 switch (FPC) {
1272 case LangOptions::FPM_On:
1273 NewFPFeatures.setAllowFPContractWithinStatement();
1274 break;
1275 case LangOptions::FPM_Fast:
1276 NewFPFeatures.setAllowFPContractAcrossStatement();
1277 break;
1278 case LangOptions::FPM_Off:
1279 NewFPFeatures.setDisallowFPContract();
1280 break;
1281 case LangOptions::FPM_FastHonorPragmas:
1282 llvm_unreachable("Should not happen");
1283 }
1284 FpPragmaStack.Act(PragmaLocation: Loc, Action: Sema::PSK_Set, StackSlotLabel: StringRef(), Value: NewFPFeatures);
1285 CurFPFeatures = NewFPFeatures.applyOverrides(LO: getLangOpts());
1286}
1287
1288void Sema::ActOnPragmaFPValueChangingOption(SourceLocation Loc,
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;
1297 if (PP.getLastFPEvalPragmaLocation().isValid())
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(PragmaLocation: Loc, Action: PSK_Set, StackSlotLabel: StringRef(), Value: NewFPFeatures);
1321 CurFPFeatures = NewFPFeatures.applyOverrides(LO: getLangOpts());
1322}
1323
1324void Sema::ActOnPragmaFEnvRound(SourceLocation Loc, llvm::RoundingMode FPR) {
1325 FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides();
1326 NewFPFeatures.setConstRoundingModeOverride(FPR);
1327 FpPragmaStack.Act(PragmaLocation: Loc, Action: PSK_Set, StackSlotLabel: StringRef(), Value: NewFPFeatures);
1328 CurFPFeatures = NewFPFeatures.applyOverrides(LO: getLangOpts());
1329}
1330
1331void Sema::setExceptionMode(SourceLocation Loc,
1332 LangOptions::FPExceptionModeKind FPE) {
1333 FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides();
1334 NewFPFeatures.setSpecifiedExceptionModeOverride(FPE);
1335 FpPragmaStack.Act(PragmaLocation: Loc, Action: PSK_Set, StackSlotLabel: StringRef(), Value: NewFPFeatures);
1336 CurFPFeatures = NewFPFeatures.applyOverrides(LO: getLangOpts());
1337}
1338
1339void Sema::ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled) {
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(PragmaLocation: Loc, Action: PSK_Set, StackSlotLabel: StringRef(), Value: NewFPFeatures);
1352 CurFPFeatures = NewFPFeatures.applyOverrides(LO: getLangOpts());
1353}
1354
1355void Sema::ActOnPragmaCXLimitedRange(SourceLocation Loc,
1356 LangOptions::ComplexRangeKind Range) {
1357 FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides();
1358 NewFPFeatures.setComplexRangeOverride(Range);
1359 FpPragmaStack.Act(PragmaLocation: Loc, Action: PSK_Set, StackSlotLabel: StringRef(), Value: NewFPFeatures);
1360 CurFPFeatures = NewFPFeatures.applyOverrides(LO: getLangOpts());
1361}
1362
1363void Sema::ActOnPragmaFPExceptions(SourceLocation Loc,
1364 LangOptions::FPExceptionModeKind FPE) {
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.
1374 PushPragmaVisibility(S&: *this, type: NoVisibility, loc: Loc);
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())
1407 FreeVisContext();
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.
1419 if (A.getKind() == ParsedAttr::UnknownAttribute)
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(CurrAttr: 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, Num: 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, Num: A.getMinArgs()))
1448 return true;
1449 else if (!A.hasVariadicArg() && A.getMaxArgs() &&
1450 !A.checkAtMostNumArgs(S, Num: A.getMaxArgs()))
1451 return true;
1452 }
1453 }
1454
1455 return false;
1456}
1457
1458bool Sema::checkCommonAttributeFeatures(const Decl *D, const ParsedAttr &A,
1459 bool SkipArgCountCheck) {
1460 return ::checkCommonAttributeFeatures(S&: *this, Node: D, A, SkipArgCountCheck);
1461}
1462bool Sema::checkCommonAttributeFeatures(const Stmt *S, const ParsedAttr &A,
1463 bool SkipArgCountCheck) {
1464 return ::checkCommonAttributeFeatures(S&: *this, Node: S, A, SkipArgCountCheck);
1465}
1466

source code of clang/lib/Sema/SemaAttr.cpp