Clang Project

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