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 using namespace clang;
22 
23 //===----------------------------------------------------------------------===//
24 // Pragma 'pack' and 'options align'
25 //===----------------------------------------------------------------------===//
26 
27 Sema::PragmaStackSentinelRAII::PragmaStackSentinelRAII(Sema &S,
28                                                        StringRef SlotLabel,
29                                                        bool ShouldAct)
30     : S(S), SlotLabel(SlotLabel), ShouldAct(ShouldAct) {
31   if (ShouldAct) {
32     S.VtorDispStack.SentinelAction(PSK_Push, SlotLabel);
33     S.DataSegStack.SentinelAction(PSK_Push, SlotLabel);
34     S.BSSSegStack.SentinelAction(PSK_Push, SlotLabel);
35     S.ConstSegStack.SentinelAction(PSK_Push, SlotLabel);
36     S.CodeSegStack.SentinelAction(PSK_Push, SlotLabel);
37   }
38 }
39 
40 Sema::PragmaStackSentinelRAII::~PragmaStackSentinelRAII() {
41   if (ShouldAct) {
42     S.VtorDispStack.SentinelAction(PSK_Pop, SlotLabel);
43     S.DataSegStack.SentinelAction(PSK_Pop, SlotLabel);
44     S.BSSSegStack.SentinelAction(PSK_Pop, SlotLabel);
45     S.ConstSegStack.SentinelAction(PSK_Pop, SlotLabel);
46     S.CodeSegStack.SentinelAction(PSK_Pop, SlotLabel);
47   }
48 }
49 
50 void Sema::AddAlignmentAttributesForRecord(RecordDecl *RD) {
51   // If there is no pack value, we don't need any attributes.
52   if (!PackStack.CurrentValue)
53     return;
54 
55   // Otherwise, check to see if we need a max field alignment attribute.
56   if (unsigned Alignment = PackStack.CurrentValue) {
57     if (Alignment == Sema::kMac68kAlignmentSentinel)
58       RD->addAttr(AlignMac68kAttr::CreateImplicit(Context));
59     else
60       RD->addAttr(MaxFieldAlignmentAttr::CreateImplicit(Context,
61                                                         Alignment * 8));
62   }
63   if (PackIncludeStack.empty())
64     return;
65   // The #pragma pack affected a record in an included file,  so Clang should
66   // warn when that pragma was written in a file that included the included
67   // file.
68   for (auto &PackedInclude : llvm::reverse(PackIncludeStack)) {
69     if (PackedInclude.CurrentPragmaLocation != PackStack.CurrentPragmaLocation)
70       break;
71     if (PackedInclude.HasNonDefaultValue)
72       PackedInclude.ShouldWarnOnInclude = true;
73   }
74 }
75 
76 void Sema::AddMsStructLayoutForRecord(RecordDecl *RD) {
77   if (MSStructPragmaOn)
78     RD->addAttr(MSStructAttr::CreateImplicit(Context));
79 
80   // FIXME: We should merge AddAlignmentAttributesForRecord with
81   // AddMsStructLayoutForRecord into AddPragmaAttributesForRecord, which takes
82   // all active pragmas and applies them as attributes to class definitions.
83   if (VtorDispStack.CurrentValue != getLangOpts().getVtorDispMode())
84     RD->addAttr(MSVtorDispAttr::CreateImplicit(
85         Context, unsigned(VtorDispStack.CurrentValue)));
86 }
87 
88 template <typename Attribute>
89 static void addGslOwnerPointerAttributeIfNotExisting(ASTContext &Context,
90                                                      CXXRecordDecl *Record) {
91   if (Record->hasAttr<OwnerAttr>() || Record->hasAttr<PointerAttr>())
92     return;
93 
94   for (Decl *Redecl : Record->redecls())
95     Redecl->addAttr(Attribute::CreateImplicit(Context, /*DerefType=*/nullptr));
96 }
97 
98 void Sema::inferGslPointerAttribute(NamedDecl *ND,
99                                     CXXRecordDecl *UnderlyingRecord) {
100   if (!UnderlyingRecord)
101     return;
102 
103   const auto *Parent = dyn_cast<CXXRecordDecl>(ND->getDeclContext());
104   if (!Parent)
105     return;
106 
107   static llvm::StringSet<> Containers{
108       "array",
109       "basic_string",
110       "deque",
111       "forward_list",
112       "vector",
113       "list",
114       "map",
115       "multiset",
116       "multimap",
117       "priority_queue",
118       "queue",
119       "set",
120       "stack",
121       "unordered_set",
122       "unordered_map",
123       "unordered_multiset",
124       "unordered_multimap",
125   };
126 
127   static llvm::StringSet<> Iterators{"iterator", "const_iterator",
128                                      "reverse_iterator",
129                                      "const_reverse_iterator"};
130 
131   if (Parent->isInStdNamespace() && Iterators.count(ND->getName()) &&
132       Containers.count(Parent->getName()))
133     addGslOwnerPointerAttributeIfNotExisting<PointerAttr>(Context,
134                                                           UnderlyingRecord);
135 }
136 
137 void Sema::inferGslPointerAttribute(TypedefNameDecl *TD) {
138 
139   QualType Canonical = TD->getUnderlyingType().getCanonicalType();
140 
141   CXXRecordDecl *RD = Canonical->getAsCXXRecordDecl();
142   if (!RD) {
143     if (auto *TST =
144             dyn_cast<TemplateSpecializationType>(Canonical.getTypePtr())) {
145 
146       RD = dyn_cast_or_null<CXXRecordDecl>(
147           TST->getTemplateName().getAsTemplateDecl()->getTemplatedDecl());
148     }
149   }
150 
151   inferGslPointerAttribute(TD, RD);
152 }
153 
154 void Sema::inferGslOwnerPointerAttribute(CXXRecordDecl *Record) {
155   static llvm::StringSet<> StdOwners{
156       "any",
157       "array",
158       "basic_regex",
159       "basic_string",
160       "deque",
161       "forward_list",
162       "vector",
163       "list",
164       "map",
165       "multiset",
166       "multimap",
167       "optional",
168       "priority_queue",
169       "queue",
170       "set",
171       "stack",
172       "unique_ptr",
173       "unordered_set",
174       "unordered_map",
175       "unordered_multiset",
176       "unordered_multimap",
177       "variant",
178   };
179   static llvm::StringSet<> StdPointers{
180       "basic_string_view",
181       "reference_wrapper",
182       "regex_iterator",
183   };
184 
185   if (!Record->getIdentifier())
186     return;
187 
188   // Handle classes that directly appear in std namespace.
189   if (Record->isInStdNamespace()) {
190     if (Record->hasAttr<OwnerAttr>() || Record->hasAttr<PointerAttr>())
191       return;
192 
193     if (StdOwners.count(Record->getName()))
194       addGslOwnerPointerAttributeIfNotExisting<OwnerAttr>(Context, Record);
195     else if (StdPointers.count(Record->getName()))
196       addGslOwnerPointerAttributeIfNotExisting<PointerAttr>(Context, Record);
197 
198     return;
199   }
200 
201   // Handle nested classes that could be a gsl::Pointer.
202   inferGslPointerAttribute(Record, Record);
203 }
204 
205 void Sema::ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
206                                    SourceLocation PragmaLoc) {
207   PragmaMsStackAction Action = Sema::PSK_Reset;
208   unsigned Alignment = 0;
209   switch (Kind) {
210     // For all targets we support native and natural are the same.
211     //
212     // FIXME: This is not true on Darwin/PPC.
213   case POAK_Native:
214   case POAK_Power:
215   case POAK_Natural:
216     Action = Sema::PSK_Push_Set;
217     Alignment = 0;
218     break;
219 
220     // Note that '#pragma options align=packed' is not equivalent to attribute
221     // packed, it has a different precedence relative to attribute aligned.
222   case POAK_Packed:
223     Action = Sema::PSK_Push_Set;
224     Alignment = 1;
225     break;
226 
227   case POAK_Mac68k:
228     // Check if the target supports this.
229     if (!this->Context.getTargetInfo().hasAlignMac68kSupport()) {
230       Diag(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported);
231       return;
232     }
233     Action = Sema::PSK_Push_Set;
234     Alignment = Sema::kMac68kAlignmentSentinel;
235     break;
236 
237   case POAK_Reset:
238     // Reset just pops the top of the stack, or resets the current alignment to
239     // default.
240     Action = Sema::PSK_Pop;
241     if (PackStack.Stack.empty()) {
242       if (PackStack.CurrentValue) {
243         Action = Sema::PSK_Reset;
244       } else {
245         Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed)
246             << "stack empty";
247         return;
248       }
249     }
250     break;
251   }
252 
253   PackStack.Act(PragmaLoc, Action, StringRef(), Alignment);
254 }
255 
256 void Sema::ActOnPragmaClangSection(SourceLocation PragmaLoc, PragmaClangSectionAction Action,
257                                    PragmaClangSectionKind SecKind, StringRef SecName) {
258   PragmaClangSection *CSec;
259   switch (SecKind) {
260     case PragmaClangSectionKind::PCSK_BSS:
261       CSec = &PragmaClangBSSSection;
262       break;
263     case PragmaClangSectionKind::PCSK_Data:
264       CSec = &PragmaClangDataSection;
265       break;
266     case PragmaClangSectionKind::PCSK_Rodata:
267       CSec = &PragmaClangRodataSection;
268       break;
269     case PragmaClangSectionKind::PCSK_Relro:
270       CSec = &PragmaClangRelroSection;
271       break;
272     case PragmaClangSectionKind::PCSK_Text:
273       CSec = &PragmaClangTextSection;
274       break;
275     default:
276       llvm_unreachable("invalid clang section kind");
277   }
278 
279   if (Action == PragmaClangSectionAction::PCSA_Clear) {
280     CSec->Valid = false;
281     return;
282   }
283 
284   CSec->Valid = true;
285   CSec->SectionName = SecName;
286   CSec->PragmaLocation = PragmaLoc;
287 }
288 
289 void Sema::ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
290                            StringRef SlotLabel, Expr *alignment) {
291   Expr *Alignment = static_cast<Expr *>(alignment);
292 
293   // If specified then alignment must be a "small" power of two.
294   unsigned AlignmentVal = 0;
295   if (Alignment) {
296     llvm::APSInt Val;
297 
298     // pack(0) is like pack(), which just works out since that is what
299     // we use 0 for in PackAttr.
300     if (Alignment->isTypeDependent() ||
301         Alignment->isValueDependent() ||
302         !Alignment->isIntegerConstantExpr(Val, Context) ||
303         !(Val == 0 || Val.isPowerOf2()) ||
304         Val.getZExtValue() > 16) {
305       Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment);
306       return; // Ignore
307     }
308 
309     AlignmentVal = (unsigned) Val.getZExtValue();
310   }
311   if (Action == Sema::PSK_Show) {
312     // Show the current alignment, making sure to show the right value
313     // for the default.
314     // FIXME: This should come from the target.
315     AlignmentVal = PackStack.CurrentValue;
316     if (AlignmentVal == 0)
317       AlignmentVal = 8;
318     if (AlignmentVal == Sema::kMac68kAlignmentSentinel)
319       Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k";
320     else
321       Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;
322   }
323   // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack:
324   // "#pragma pack(pop, identifier, n) is undefined"
325   if (Action & Sema::PSK_Pop) {
326     if (Alignment && !SlotLabel.empty())
327       Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifier_and_alignment);
328     if (PackStack.Stack.empty())
329       Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << "stack empty";
330   }
331 
332   PackStack.Act(PragmaLoc, Action, SlotLabel, AlignmentVal);
333 }
334 
335 void Sema::DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind,
336                                         SourceLocation IncludeLoc) {
337   if (Kind == PragmaPackDiagnoseKind::NonDefaultStateAtInclude) {
338     SourceLocation PrevLocation = PackStack.CurrentPragmaLocation;
339     // Warn about non-default alignment at #includes (without redundant
340     // warnings for the same directive in nested includes).
341     // The warning is delayed until the end of the file to avoid warnings
342     // for files that don't have any records that are affected by the modified
343     // alignment.
344     bool HasNonDefaultValue =
345         PackStack.hasValue() &&
346         (PackIncludeStack.empty() ||
347          PackIncludeStack.back().CurrentPragmaLocation != PrevLocation);
348     PackIncludeStack.push_back(
349         {PackStack.CurrentValue,
350          PackStack.hasValue() ? PrevLocation : SourceLocation(),
351          HasNonDefaultValue, /*ShouldWarnOnInclude*/ false});
352     return;
353   }
354 
355   assert(Kind == PragmaPackDiagnoseKind::ChangedStateAtExit && "invalid kind");
356   PackIncludeState PrevPackState = PackIncludeStack.pop_back_val();
357   if (PrevPackState.ShouldWarnOnInclude) {
358     // Emit the delayed non-default alignment at #include warning.
359     Diag(IncludeLoc, diag::warn_pragma_pack_non_default_at_include);
360     Diag(PrevPackState.CurrentPragmaLocation, diag::note_pragma_pack_here);
361   }
362   // Warn about modified alignment after #includes.
363   if (PrevPackState.CurrentValue != PackStack.CurrentValue) {
364     Diag(IncludeLoc, diag::warn_pragma_pack_modified_after_include);
365     Diag(PackStack.CurrentPragmaLocation, diag::note_pragma_pack_here);
366   }
367 }
368 
369 void Sema::DiagnoseUnterminatedPragmaPack() {
370   if (PackStack.Stack.empty())
371     return;
372   bool IsInnermost = true;
373   for (const auto &StackSlot : llvm::reverse(PackStack.Stack)) {
374     Diag(StackSlot.PragmaPushLocation, diag::warn_pragma_pack_no_pop_eof);
375     // The user might have already reset the alignment, so suggest replacing
376     // the reset with a pop.
377     if (IsInnermost && PackStack.CurrentValue == PackStack.DefaultValue) {
378       DiagnosticBuilder DB = Diag(PackStack.CurrentPragmaLocation,
379                                   diag::note_pragma_pack_pop_instead_reset);
380       SourceLocation FixItLoc = Lexer::findLocationAfterToken(
381           PackStack.CurrentPragmaLocation, tok::l_paren, SourceMgr, LangOpts,
382           /*SkipTrailing=*/false);
383       if (FixItLoc.isValid())
384         DB << FixItHint::CreateInsertion(FixItLoc, "pop");
385     }
386     IsInnermost = false;
387   }
388 }
389 
390 void Sema::ActOnPragmaMSStruct(PragmaMSStructKind Kind) {
391   MSStructPragmaOn = (Kind == PMSST_ON);
392 }
393 
394 void Sema::ActOnPragmaMSComment(SourceLocation CommentLoc,
395                                 PragmaMSCommentKind Kind, StringRef Arg) {
396   auto *PCD = PragmaCommentDecl::Create(
397       Context, Context.getTranslationUnitDecl(), CommentLoc, Kind, Arg);
398   Context.getTranslationUnitDecl()->addDecl(PCD);
399   Consumer.HandleTopLevelDecl(DeclGroupRef(PCD));
400 }
401 
402 void Sema::ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
403                                      StringRef Value) {
404   auto *PDMD = PragmaDetectMismatchDecl::Create(
405       Context, Context.getTranslationUnitDecl(), Loc, Name, Value);
406   Context.getTranslationUnitDecl()->addDecl(PDMD);
407   Consumer.HandleTopLevelDecl(DeclGroupRef(PDMD));
408 }
409 
410 void Sema::ActOnPragmaMSPointersToMembers(
411     LangOptions::PragmaMSPointersToMembersKind RepresentationMethod,
412     SourceLocation PragmaLoc) {
413   MSPointerToMemberRepresentationMethod = RepresentationMethod;
414   ImplicitMSInheritanceAttrLoc = PragmaLoc;
415 }
416 
417 void Sema::ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,
418                                  SourceLocation PragmaLoc,
419                                  MSVtorDispMode Mode) {
420   if (Action & PSK_Pop && VtorDispStack.Stack.empty())
421     Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "vtordisp"
422                                                   << "stack empty";
423   VtorDispStack.Act(PragmaLoc, Action, StringRef(), Mode);
424 }
425 
426 template<typename ValueType>
427 void Sema::PragmaStack<ValueType>::Act(SourceLocation PragmaLocation,
428                                        PragmaMsStackAction Action,
429                                        llvm::StringRef StackSlotLabel,
430                                        ValueType Value) {
431   if (Action == PSK_Reset) {
432     CurrentValue = DefaultValue;
433     CurrentPragmaLocation = PragmaLocation;
434     return;
435   }
436   if (Action & PSK_Push)
437     Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
438                        PragmaLocation);
439   else if (Action & PSK_Pop) {
440     if (!StackSlotLabel.empty()) {
441       // If we've got a label, try to find it and jump there.
442       auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
443         return x.StackSlotLabel == StackSlotLabel;
444       });
445       // If we found the label so pop from there.
446       if (I != Stack.rend()) {
447         CurrentValue = I->Value;
448         CurrentPragmaLocation = I->PragmaLocation;
449         Stack.erase(std::prev(I.base()), Stack.end());
450       }
451     } else if (!Stack.empty()) {
452       // We do not have a label, just pop the last entry.
453       CurrentValue = Stack.back().Value;
454       CurrentPragmaLocation = Stack.back().PragmaLocation;
455       Stack.pop_back();
456     }
457   }
458   if (Action & PSK_Set) {
459     CurrentValue = Value;
460     CurrentPragmaLocation = PragmaLocation;
461   }
462 }
463 
464 bool Sema::UnifySection(StringRef SectionName,
465                         int SectionFlags,
466                         DeclaratorDecl *Decl) {
467   auto Section = Context.SectionInfos.find(SectionName);
468   if (Section == Context.SectionInfos.end()) {
469     Context.SectionInfos[SectionName] =
470         ASTContext::SectionInfo(Decl, SourceLocation(), SectionFlags);
471     return false;
472   }
473   // A pre-declared section takes precedence w/o diagnostic.
474   if (Section->second.SectionFlags == SectionFlags ||
475       !(Section->second.SectionFlags & ASTContext::PSF_Implicit))
476     return false;
477   auto OtherDecl = Section->second.Decl;
478   Diag(Decl->getLocation(), diag::err_section_conflict)
479       << Decl << OtherDecl;
480   Diag(OtherDecl->getLocation(), diag::note_declared_at)
481       << OtherDecl->getName();
482   if (auto A = Decl->getAttr<SectionAttr>())
483     if (A->isImplicit())
484       Diag(A->getLocation(), diag::note_pragma_entered_here);
485   if (auto A = OtherDecl->getAttr<SectionAttr>())
486     if (A->isImplicit())
487       Diag(A->getLocation(), diag::note_pragma_entered_here);
488   return true;
489 }
490 
491 bool Sema::UnifySection(StringRef SectionName,
492                         int SectionFlags,
493                         SourceLocation PragmaSectionLocation) {
494   auto Section = Context.SectionInfos.find(SectionName);
495   if (Section != Context.SectionInfos.end()) {
496     if (Section->second.SectionFlags == SectionFlags)
497       return false;
498     if (!(Section->second.SectionFlags & ASTContext::PSF_Implicit)) {
499       Diag(PragmaSectionLocation, diag::err_section_conflict)
500           << "this" << "a prior #pragma section";
501       Diag(Section->second.PragmaSectionLocation,
502            diag::note_pragma_entered_here);
503       return true;
504     }
505   }
506   Context.SectionInfos[SectionName] =
507       ASTContext::SectionInfo(nullptr, PragmaSectionLocation, SectionFlags);
508   return false;
509 }
510 
511 /// Called on well formed \#pragma bss_seg().
512 void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation,
513                             PragmaMsStackAction Action,
514                             llvm::StringRef StackSlotLabel,
515                             StringLiteral *SegmentName,
516                             llvm::StringRef PragmaName) {
517   PragmaStack<StringLiteral *> *Stack =
518     llvm::StringSwitch<PragmaStack<StringLiteral *> *>(PragmaName)
519         .Case("data_seg", &DataSegStack)
520         .Case("bss_seg", &BSSSegStack)
521         .Case("const_seg", &ConstSegStack)
522         .Case("code_seg", &CodeSegStack);
523   if (Action & PSK_Pop && Stack->Stack.empty())
524     Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName
525         << "stack empty";
526   if (SegmentName) {
527     if (!checkSectionName(SegmentName->getBeginLoc(), SegmentName->getString()))
528       return;
529 
530     if (SegmentName->getString() == ".drectve" &&
531         Context.getTargetInfo().getCXXABI().isMicrosoft())
532       Diag(PragmaLocation, diag::warn_attribute_section_drectve) << PragmaName;
533   }
534 
535   Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName);
536 }
537 
538 /// Called on well formed \#pragma bss_seg().
539 void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation,
540                                 int SectionFlags, StringLiteral *SegmentName) {
541   UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation);
542 }
543 
544 void Sema::ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
545                                 StringLiteral *SegmentName) {
546   // There's no stack to maintain, so we just have a current section.  When we
547   // see the default section, reset our current section back to null so we stop
548   // tacking on unnecessary attributes.
549   CurInitSeg = SegmentName->getString() == ".CRT$XCU" ? nullptr : SegmentName;
550   CurInitSegLoc = PragmaLocation;
551 }
552 
553 void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope,
554                              SourceLocation PragmaLoc) {
555 
556   IdentifierInfo *Name = IdTok.getIdentifierInfo();
557   LookupResult Lookup(*this, Name, IdTok.getLocation(), LookupOrdinaryName);
558   LookupParsedName(Lookup, curScope, nullptr, true);
559 
560   if (Lookup.empty()) {
561     Diag(PragmaLoc, diag::warn_pragma_unused_undeclared_var)
562       << Name << SourceRange(IdTok.getLocation());
563     return;
564   }
565 
566   VarDecl *VD = Lookup.getAsSingle<VarDecl>();
567   if (!VD) {
568     Diag(PragmaLoc, diag::warn_pragma_unused_expected_var_arg)
569       << Name << SourceRange(IdTok.getLocation());
570     return;
571   }
572 
573   // Warn if this was used before being marked unused.
574   if (VD->isUsed())
575     Diag(PragmaLoc, diag::warn_used_but_marked_unused) << Name;
576 
577   VD->addAttr(UnusedAttr::CreateImplicit(Context, IdTok.getLocation(),
578                                          AttributeCommonInfo::AS_Pragma,
579                                          UnusedAttr::GNU_unused));
580 }
581 
582 void Sema::AddCFAuditedAttribute(Decl *D) {
583   IdentifierInfo *Ident;
584   SourceLocation Loc;
585   std::tie(Ident, Loc) = PP.getPragmaARCCFCodeAuditedInfo();
586   if (!Loc.isValid()) return;
587 
588   // Don't add a redundant or conflicting attribute.
589   if (D->hasAttr<CFAuditedTransferAttr>() ||
590       D->hasAttr<CFUnknownTransferAttr>())
591     return;
592 
593   AttributeCommonInfo Info(Ident, SourceRange(Loc),
594                            AttributeCommonInfo::AS_Pragma);
595   D->addAttr(CFAuditedTransferAttr::CreateImplicit(Context, Info));
596 }
597 
598 namespace {
599 
600 Optional<attr::SubjectMatchRule>
601 getParentAttrMatcherRule(attr::SubjectMatchRule Rule) {
602   using namespace attr;
603   switch (Rule) {
604   default:
605     return None;
606 #define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)
607 #define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated)    \
608   case Value:                                                                  \
609     return Parent;
610 #include "clang/Basic/AttrSubMatchRulesList.inc"
611   }
612 }
613 
614 bool isNegatedAttrMatcherSubRule(attr::SubjectMatchRule Rule) {
615   using namespace attr;
616   switch (Rule) {
617   default:
618     return false;
619 #define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)
620 #define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated)    \
621   case Value:                                                                  \
622     return IsNegated;
623 #include "clang/Basic/AttrSubMatchRulesList.inc"
624   }
625 }
626 
627 CharSourceRange replacementRangeForListElement(const Sema &S,
628                                                SourceRange Range) {
629   // Make sure that the ',' is removed as well.
630   SourceLocation AfterCommaLoc = Lexer::findLocationAfterToken(
631       Range.getEnd(), tok::comma, S.getSourceManager(), S.getLangOpts(),
632       /*SkipTrailingWhitespaceAndNewLine=*/false);
633   if (AfterCommaLoc.isValid())
634     return CharSourceRange::getCharRange(Range.getBegin(), AfterCommaLoc);
635   else
636     return CharSourceRange::getTokenRange(Range);
637 }
638 
639 std::string
640 attrMatcherRuleListToString(ArrayRef<attr::SubjectMatchRule> Rules) {
641   std::string Result;
642   llvm::raw_string_ostream OS(Result);
643   for (const auto &I : llvm::enumerate(Rules)) {
644     if (I.index())
645       OS << (I.index() == Rules.size() - 1 ? ", and " : ", ");
646     OS << "'" << attr::getSubjectMatchRuleSpelling(I.value()) << "'";
647   }
648   return OS.str();
649 }
650 
651 } // end anonymous namespace
652 
653 void Sema::ActOnPragmaAttributeAttribute(
654     ParsedAttr &Attribute, SourceLocation PragmaLoc,
655     attr::ParsedSubjectMatchRuleSet Rules) {
656   Attribute.setIsPragmaClangAttribute();
657   SmallVector<attr::SubjectMatchRule, 4> SubjectMatchRules;
658   // Gather the subject match rules that are supported by the attribute.
659   SmallVector<std::pair<attr::SubjectMatchRule, bool>, 4>
660       StrictSubjectMatchRuleSet;
661   Attribute.getMatchRules(LangOpts, StrictSubjectMatchRuleSet);
662 
663   // Figure out which subject matching rules are valid.
664   if (StrictSubjectMatchRuleSet.empty()) {
665     // Check for contradicting match rules. Contradicting match rules are
666     // either:
667     //  - a top-level rule and one of its sub-rules. E.g. variable and
668     //    variable(is_parameter).
669     //  - a sub-rule and a sibling that's negated. E.g.
670     //    variable(is_thread_local) and variable(unless(is_parameter))
671     llvm::SmallDenseMap<int, std::pair<int, SourceRange>, 2>
672         RulesToFirstSpecifiedNegatedSubRule;
673     for (const auto &Rule : Rules) {
674       attr::SubjectMatchRule MatchRule = attr::SubjectMatchRule(Rule.first);
675       Optional<attr::SubjectMatchRule> ParentRule =
676           getParentAttrMatcherRule(MatchRule);
677       if (!ParentRule)
678         continue;
679       auto It = Rules.find(*ParentRule);
680       if (It != Rules.end()) {
681         // A sub-rule contradicts a parent rule.
682         Diag(Rule.second.getBegin(),
683              diag::err_pragma_attribute_matcher_subrule_contradicts_rule)
684             << attr::getSubjectMatchRuleSpelling(MatchRule)
685             << attr::getSubjectMatchRuleSpelling(*ParentRule) << It->second
686             << FixItHint::CreateRemoval(
687                    replacementRangeForListElement(*this, Rule.second));
688         // Keep going without removing this rule as it won't change the set of
689         // declarations that receive the attribute.
690         continue;
691       }
692       if (isNegatedAttrMatcherSubRule(MatchRule))
693         RulesToFirstSpecifiedNegatedSubRule.insert(
694             std::make_pair(*ParentRule, Rule));
695     }
696     bool IgnoreNegatedSubRules = false;
697     for (const auto &Rule : Rules) {
698       attr::SubjectMatchRule MatchRule = attr::SubjectMatchRule(Rule.first);
699       Optional<attr::SubjectMatchRule> ParentRule =
700           getParentAttrMatcherRule(MatchRule);
701       if (!ParentRule)
702         continue;
703       auto It = RulesToFirstSpecifiedNegatedSubRule.find(*ParentRule);
704       if (It != RulesToFirstSpecifiedNegatedSubRule.end() &&
705           It->second != Rule) {
706         // Negated sub-rule contradicts another sub-rule.
707         Diag(
708             It->second.second.getBegin(),
709             diag::
710                 err_pragma_attribute_matcher_negated_subrule_contradicts_subrule)
711             << attr::getSubjectMatchRuleSpelling(
712                    attr::SubjectMatchRule(It->second.first))
713             << attr::getSubjectMatchRuleSpelling(MatchRule) << Rule.second
714             << FixItHint::CreateRemoval(
715                    replacementRangeForListElement(*this, It->second.second));
716         // Keep going but ignore all of the negated sub-rules.
717         IgnoreNegatedSubRules = true;
718         RulesToFirstSpecifiedNegatedSubRule.erase(It);
719       }
720     }
721 
722     if (!IgnoreNegatedSubRules) {
723       for (const auto &Rule : Rules)
724         SubjectMatchRules.push_back(attr::SubjectMatchRule(Rule.first));
725     } else {
726       for (const auto &Rule : Rules) {
727         if (!isNegatedAttrMatcherSubRule(attr::SubjectMatchRule(Rule.first)))
728           SubjectMatchRules.push_back(attr::SubjectMatchRule(Rule.first));
729       }
730     }
731     Rules.clear();
732   } else {
733     for (const auto &Rule : StrictSubjectMatchRuleSet) {
734       if (Rules.erase(Rule.first)) {
735         // Add the rule to the set of attribute receivers only if it's supported
736         // in the current language mode.
737         if (Rule.second)
738           SubjectMatchRules.push_back(Rule.first);
739       }
740     }
741   }
742 
743   if (!Rules.empty()) {
744     auto Diagnostic =
745         Diag(PragmaLoc, diag::err_pragma_attribute_invalid_matchers)
746         << Attribute;
747     SmallVector<attr::SubjectMatchRule, 2> ExtraRules;
748     for (const auto &Rule : Rules) {
749       ExtraRules.push_back(attr::SubjectMatchRule(Rule.first));
750       Diagnostic << FixItHint::CreateRemoval(
751           replacementRangeForListElement(*this, Rule.second));
752     }
753     Diagnostic << attrMatcherRuleListToString(ExtraRules);
754   }
755 
756   if (PragmaAttributeStack.empty()) {
757     Diag(PragmaLoc, diag::err_pragma_attr_attr_no_push);
758     return;
759   }
760 
761   PragmaAttributeStack.back().Entries.push_back(
762       {PragmaLoc, &Attribute, std::move(SubjectMatchRules), /*IsUsed=*/false});
763 }
764 
765 void Sema::ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc,
766                                          const IdentifierInfo *Namespace) {
767   PragmaAttributeStack.emplace_back();
768   PragmaAttributeStack.back().Loc = PragmaLoc;
769   PragmaAttributeStack.back().Namespace = Namespace;
770 }
771 
772 void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc,
773                                    const IdentifierInfo *Namespace) {
774   if (PragmaAttributeStack.empty()) {
775     Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;
776     return;
777   }
778 
779   // Dig back through the stack trying to find the most recently pushed group
780   // that in Namespace. Note that this works fine if no namespace is present,
781   // think of push/pops without namespaces as having an implicit "nullptr"
782   // namespace.
783   for (size_t Index = PragmaAttributeStack.size(); Index;) {
784     --Index;
785     if (PragmaAttributeStack[Index].Namespace == Namespace) {
786       for (const PragmaAttributeEntry &Entry :
787            PragmaAttributeStack[Index].Entries) {
788         if (!Entry.IsUsed) {
789           assert(Entry.Attribute && "Expected an attribute");
790           Diag(Entry.Attribute->getLoc(), diag::warn_pragma_attribute_unused)
791               << *Entry.Attribute;
792           Diag(PragmaLoc, diag::note_pragma_attribute_region_ends_here);
793         }
794       }
795       PragmaAttributeStack.erase(PragmaAttributeStack.begin() + Index);
796       return;
797     }
798   }
799 
800   if (Namespace)
801     Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch)
802         << 0 << Namespace->getName();
803   else
804     Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;
805 }
806 
807 void Sema::AddPragmaAttributes(Scope *S, Decl *D) {
808   if (PragmaAttributeStack.empty())
809     return;
810   for (auto &Group : PragmaAttributeStack) {
811     for (auto &Entry : Group.Entries) {
812       ParsedAttr *Attribute = Entry.Attribute;
813       assert(Attribute && "Expected an attribute");
814       assert(Attribute->isPragmaClangAttribute() &&
815              "expected #pragma clang attribute");
816 
817       // Ensure that the attribute can be applied to the given declaration.
818       bool Applies = false;
819       for (const auto &Rule : Entry.MatchRules) {
820         if (Attribute->appliesToDecl(D, Rule)) {
821           Applies = true;
822           break;
823         }
824       }
825       if (!Applies)
826         continue;
827       Entry.IsUsed = true;
828       PragmaAttributeCurrentTargetDecl = D;
829       ParsedAttributesView Attrs;
830       Attrs.addAtEnd(Attribute);
831       ProcessDeclAttributeList(S, D, Attrs);
832       PragmaAttributeCurrentTargetDecl = nullptr;
833     }
834   }
835 }
836 
837 void Sema::PrintPragmaAttributeInstantiationPoint() {
838   assert(PragmaAttributeCurrentTargetDecl && "Expected an active declaration");
839   Diags.Report(PragmaAttributeCurrentTargetDecl->getBeginLoc(),
840                diag::note_pragma_attribute_applied_decl_here);
841 }
842 
843 void Sema::DiagnoseUnterminatedPragmaAttribute() {
844   if (PragmaAttributeStack.empty())
845     return;
846   Diag(PragmaAttributeStack.back().Loc, diag::err_pragma_attribute_no_pop_eof);
847 }
848 
849 void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) {
850   if(On)
851     OptimizeOffPragmaLocation = SourceLocation();
852   else
853     OptimizeOffPragmaLocation = PragmaLoc;
854 }
855 
856 void Sema::AddRangeBasedOptnone(FunctionDecl *FD) {
857   // In the future, check other pragmas if they're implemented (e.g. pragma
858   // optimize 0 will probably map to this functionality too).
859   if(OptimizeOffPragmaLocation.isValid())
860     AddOptnoneAttributeIfNoConflicts(FD, OptimizeOffPragmaLocation);
861 }
862 
863 void Sema::AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD,
864                                             SourceLocation Loc) {
865   // Don't add a conflicting attribute. No diagnostic is needed.
866   if (FD->hasAttr<MinSizeAttr>() || FD->hasAttr<AlwaysInlineAttr>())
867     return;
868 
869   // Add attributes only if required. Optnone requires noinline as well, but if
870   // either is already present then don't bother adding them.
871   if (!FD->hasAttr<OptimizeNoneAttr>())
872     FD->addAttr(OptimizeNoneAttr::CreateImplicit(Context, Loc));
873   if (!FD->hasAttr<NoInlineAttr>())
874     FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc));
875 }
876 
877 typedef std::vector<std::pair<unsigned, SourceLocation> > VisStack;
878 enum : unsigned { NoVisibility = ~0U };
879 
880 void Sema::AddPushedVisibilityAttribute(Decl *D) {
881   if (!VisContext)
882     return;
883 
884   NamedDecl *ND = dyn_cast<NamedDecl>(D);
885   if (ND && ND->getExplicitVisibility(NamedDecl::VisibilityForValue))
886     return;
887 
888   VisStack *Stack = static_cast<VisStack*>(VisContext);
889   unsigned rawType = Stack->back().first;
890   if (rawType == NoVisibility) return;
891 
892   VisibilityAttr::VisibilityType type
893     = (VisibilityAttr::VisibilityType) rawType;
894   SourceLocation loc = Stack->back().second;
895 
896   D->addAttr(VisibilityAttr::CreateImplicit(Context, type, loc));
897 }
898 
899 /// FreeVisContext - Deallocate and null out VisContext.
900 void Sema::FreeVisContext() {
901   delete static_cast<VisStack*>(VisContext);
902   VisContext = nullptr;
903 }
904 
905 static void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc) {
906   // Put visibility on stack.
907   if (!S.VisContext)
908     S.VisContext = new VisStack;
909 
910   VisStack *Stack = static_cast<VisStack*>(S.VisContext);
911   Stack->push_back(std::make_pair(type, loc));
912 }
913 
914 void Sema::ActOnPragmaVisibility(const IdentifierInfo* VisType,
915                                  SourceLocation PragmaLoc) {
916   if (VisType) {
917     // Compute visibility to use.
918     VisibilityAttr::VisibilityType T;
919     if (!VisibilityAttr::ConvertStrToVisibilityType(VisType->getName(), T)) {
920       Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType;
921       return;
922     }
923     PushPragmaVisibility(*this, T, PragmaLoc);
924   } else {
925     PopPragmaVisibility(false, PragmaLoc);
926   }
927 }
928 
929 void Sema::ActOnPragmaFPContract(LangOptions::FPContractModeKind FPC) {
930   switch (FPC) {
931   case LangOptions::FPC_On:
932     FPFeatures.setAllowFPContractWithinStatement();
933     break;
934   case LangOptions::FPC_Fast:
935     FPFeatures.setAllowFPContractAcrossStatement();
936     break;
937   case LangOptions::FPC_Off:
938     FPFeatures.setDisallowFPContract();
939     break;
940   }
941 }
942 
943 void Sema::ActOnPragmaFEnvAccess(LangOptions::FEnvAccessModeKind FPC) {
944   switch (FPC) {
945   case LangOptions::FEA_On:
946     FPFeatures.setAllowFEnvAccess();
947     break;
948   case LangOptions::FEA_Off:
949     FPFeatures.setDisallowFEnvAccess();
950     break;
951   }
952 }
953 
954 
955 void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
956                                        SourceLocation Loc) {
957   // Visibility calculations will consider the namespace's visibility.
958   // Here we just want to note that we're in a visibility context
959   // which overrides any enclosing #pragma context, but doesn't itself
960   // contribute visibility.
961   PushPragmaVisibility(*this, NoVisibility, Loc);
962 }
963 
964 void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) {
965   if (!VisContext) {
966     Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
967     return;
968   }
969 
970   // Pop visibility from stack
971   VisStack *Stack = static_cast<VisStack*>(VisContext);
972 
973   const std::pair<unsigned, SourceLocation> *Back = &Stack->back();
974   bool StartsWithPragma = Back->first != NoVisibility;
975   if (StartsWithPragma && IsNamespaceEnd) {
976     Diag(Back->second, diag::err_pragma_push_visibility_mismatch);
977     Diag(EndLoc, diag::note_surrounding_namespace_ends_here);
978 
979     // For better error recovery, eat all pushes inside the namespace.
980     do {
981       Stack->pop_back();
982       Back = &Stack->back();
983       StartsWithPragma = Back->first != NoVisibility;
984     } while (StartsWithPragma);
985   } else if (!StartsWithPragma && !IsNamespaceEnd) {
986     Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
987     Diag(Back->second, diag::note_surrounding_namespace_starts_here);
988     return;
989   }
990 
991   Stack->pop_back();
992   // To simplify the implementation, never keep around an empty stack.
993   if (Stack->empty())
994     FreeVisContext();
995 }
996