contrib/llvm/tools/clang/lib/Sema/SemaAttr.cpp

   1 //===--- SemaAttr.cpp - Semantic Analysis for Attributes ------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements semantic analysis for non-trivial attributes and
  11 // pragmas.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/AST/ASTConsumer.h"
  16 #include "clang/AST/Attr.h"
  17 #include "clang/AST/Expr.h"
  18 #include "clang/Basic/TargetInfo.h"
  19 #include "clang/Lex/Preprocessor.h"
  20 #include "clang/Sema/Lookup.h"
  21 #include "clang/Sema/SemaInternal.h"
  22 using namespace clang;
  23
  24 //===----------------------------------------------------------------------===//
  25 // Pragma 'pack' and 'options align'
  26 //===----------------------------------------------------------------------===//
  27
  28 Sema::PragmaStackSentinelRAII::PragmaStackSentinelRAII(Sema &S,
  29                                                        StringRef SlotLabel,
  30                                                        bool ShouldAct)
  31     : S(S), SlotLabel(SlotLabel), ShouldAct(ShouldAct) {
  32   if (ShouldAct) {
  33     S.VtorDispStack.SentinelAction(PSK_Push, SlotLabel);
  34     S.DataSegStack.SentinelAction(PSK_Push, SlotLabel);
  35     S.BSSSegStack.SentinelAction(PSK_Push, SlotLabel);
  36     S.ConstSegStack.SentinelAction(PSK_Push, SlotLabel);
  37     S.CodeSegStack.SentinelAction(PSK_Push, SlotLabel);
  38   }
  39 }
  40
  41 Sema::PragmaStackSentinelRAII::~PragmaStackSentinelRAII() {
  42   if (ShouldAct) {
  43     S.VtorDispStack.SentinelAction(PSK_Pop, SlotLabel);
  44     S.DataSegStack.SentinelAction(PSK_Pop, SlotLabel);
  45     S.BSSSegStack.SentinelAction(PSK_Pop, SlotLabel);
  46     S.ConstSegStack.SentinelAction(PSK_Pop, SlotLabel);
  47     S.CodeSegStack.SentinelAction(PSK_Pop, SlotLabel);
  48   }
  49 }
  50
  51 void Sema::AddAlignmentAttributesForRecord(RecordDecl *RD) {
  52   // If there is no pack value, we don't need any attributes.
  53   if (!PackStack.CurrentValue)
  54     return;
  55
  56   // Otherwise, check to see if we need a max field alignment attribute.
  57   if (unsigned Alignment = PackStack.CurrentValue) {
  58     if (Alignment == Sema::kMac68kAlignmentSentinel)
  59       RD->addAttr(AlignMac68kAttr::CreateImplicit(Context));
  60     else
  61       RD->addAttr(MaxFieldAlignmentAttr::CreateImplicit(Context,
  62                                                         Alignment * 8));
  63   }
  64   if (PackIncludeStack.empty())
  65     return;
  66   // The #pragma pack affected a record in an included file,  so Clang should
  67   // warn when that pragma was written in a file that included the included
  68   // file.
  69   for (auto &PackedInclude : llvm::reverse(PackIncludeStack)) {
  70     if (PackedInclude.CurrentPragmaLocation != PackStack.CurrentPragmaLocation)
  71       break;
  72     if (PackedInclude.HasNonDefaultValue)
  73       PackedInclude.ShouldWarnOnInclude = true;
  74   }
  75 }
  76
  77 void Sema::AddMsStructLayoutForRecord(RecordDecl *RD) {
  78   if (MSStructPragmaOn)
  79     RD->addAttr(MSStructAttr::CreateImplicit(Context));
  80
  81   // FIXME: We should merge AddAlignmentAttributesForRecord with
  82   // AddMsStructLayoutForRecord into AddPragmaAttributesForRecord, which takes
  83   // all active pragmas and applies them as attributes to class definitions.
  84   if (VtorDispStack.CurrentValue != getLangOpts().VtorDispMode)
  85     RD->addAttr(
  86         MSVtorDispAttr::CreateImplicit(Context, VtorDispStack.CurrentValue));
  87 }
  88
  89 void Sema::ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
  90                                    SourceLocation PragmaLoc) {
  91   PragmaMsStackAction Action = Sema::PSK_Reset;
  92   unsigned Alignment = 0;
  93   switch (Kind) {
  94     // For all targets we support native and natural are the same.
  95     //
  96     // FIXME: This is not true on Darwin/PPC.
  97   case POAK_Native:
  98   case POAK_Power:
  99   case POAK_Natural:
 100     Action = Sema::PSK_Push_Set;
 101     Alignment = 0;
 102     break;
 103
 104     // Note that '#pragma options align=packed' is not equivalent to attribute
 105     // packed, it has a different precedence relative to attribute aligned.
 106   case POAK_Packed:
 107     Action = Sema::PSK_Push_Set;
 108     Alignment = 1;
 109     break;
 110
 111   case POAK_Mac68k:
 112     // Check if the target supports this.
 113     if (!this->Context.getTargetInfo().hasAlignMac68kSupport()) {
 114       Diag(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported);
 115       return;
 116     }
 117     Action = Sema::PSK_Push_Set;
 118     Alignment = Sema::kMac68kAlignmentSentinel;
 119     break;
 120
 121   case POAK_Reset:
 122     // Reset just pops the top of the stack, or resets the current alignment to
 123     // default.
 124     Action = Sema::PSK_Pop;
 125     if (PackStack.Stack.empty()) {
 126       if (PackStack.CurrentValue) {
 127         Action = Sema::PSK_Reset;
 128       } else {
 129         Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed)
 130             << "stack empty";
 131         return;
 132       }
 133     }
 134     break;
 135   }
 136
 137   PackStack.Act(PragmaLoc, Action, StringRef(), Alignment);
 138 }
 139
 140 void Sema::ActOnPragmaClangSection(SourceLocation PragmaLoc, PragmaClangSectionAction Action,
 141                                    PragmaClangSectionKind SecKind, StringRef SecName) {
 142   PragmaClangSection *CSec;
 143   switch (SecKind) {
 144     case PragmaClangSectionKind::PCSK_BSS:
 145       CSec = &PragmaClangBSSSection;
 146       break;
 147     case PragmaClangSectionKind::PCSK_Data:
 148       CSec = &PragmaClangDataSection;
 149       break;
 150     case PragmaClangSectionKind::PCSK_Rodata:
 151       CSec = &PragmaClangRodataSection;
 152       break;
 153     case PragmaClangSectionKind::PCSK_Text:
 154       CSec = &PragmaClangTextSection;
 155       break;
 156     default:
 157       llvm_unreachable("invalid clang section kind");
 158   }
 159
 160   if (Action == PragmaClangSectionAction::PCSA_Clear) {
 161     CSec->Valid = false;
 162     return;
 163   }
 164
 165   CSec->Valid = true;
 166   CSec->SectionName = SecName;
 167   CSec->PragmaLocation = PragmaLoc;
 168 }
 169
 170 void Sema::ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
 171                            StringRef SlotLabel, Expr *alignment) {
 172   Expr *Alignment = static_cast<Expr *>(alignment);
 173
 174   // If specified then alignment must be a "small" power of two.
 175   unsigned AlignmentVal = 0;
 176   if (Alignment) {
 177     llvm::APSInt Val;
 178
 179     // pack(0) is like pack(), which just works out since that is what
 180     // we use 0 for in PackAttr.
 181     if (Alignment->isTypeDependent() ||
 182         Alignment->isValueDependent() ||
 183         !Alignment->isIntegerConstantExpr(Val, Context) ||
 184         !(Val == 0 || Val.isPowerOf2()) ||
 185         Val.getZExtValue() > 16) {
 186       Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment);
 187       return; // Ignore
 188     }
 189
 190     AlignmentVal = (unsigned) Val.getZExtValue();
 191   }
 192   if (Action == Sema::PSK_Show) {
 193     // Show the current alignment, making sure to show the right value
 194     // for the default.
 195     // FIXME: This should come from the target.
 196     AlignmentVal = PackStack.CurrentValue;
 197     if (AlignmentVal == 0)
 198       AlignmentVal = 8;
 199     if (AlignmentVal == Sema::kMac68kAlignmentSentinel)
 200       Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k";
 201     else
 202       Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;
 203   }
 204   // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack:
 205   // "#pragma pack(pop, identifier, n) is undefined"
 206   if (Action & Sema::PSK_Pop) {
 207     if (Alignment && !SlotLabel.empty())
 208       Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifier_and_alignment);
 209     if (PackStack.Stack.empty())
 210       Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << "stack empty";
 211   }
 212
 213   PackStack.Act(PragmaLoc, Action, SlotLabel, AlignmentVal);
 214 }
 215
 216 void Sema::DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind,
 217                                         SourceLocation IncludeLoc) {
 218   if (Kind == PragmaPackDiagnoseKind::NonDefaultStateAtInclude) {
 219     SourceLocation PrevLocation = PackStack.CurrentPragmaLocation;
 220     // Warn about non-default alignment at #includes (without redundant
 221     // warnings for the same directive in nested includes).
 222     // The warning is delayed until the end of the file to avoid warnings
 223     // for files that don't have any records that are affected by the modified
 224     // alignment.
 225     bool HasNonDefaultValue =
 226         PackStack.hasValue() &&
 227         (PackIncludeStack.empty() ||
 228          PackIncludeStack.back().CurrentPragmaLocation != PrevLocation);
 229     PackIncludeStack.push_back(
 230         {PackStack.CurrentValue,
 231          PackStack.hasValue() ? PrevLocation : SourceLocation(),
 232          HasNonDefaultValue, /*ShouldWarnOnInclude*/ false});
 233     return;
 234   }
 235
 236   assert(Kind == PragmaPackDiagnoseKind::ChangedStateAtExit && "invalid kind");
 237   PackIncludeState PrevPackState = PackIncludeStack.pop_back_val();
 238   if (PrevPackState.ShouldWarnOnInclude) {
 239     // Emit the delayed non-default alignment at #include warning.
 240     Diag(IncludeLoc, diag::warn_pragma_pack_non_default_at_include);
 241     Diag(PrevPackState.CurrentPragmaLocation, diag::note_pragma_pack_here);
 242   }
 243   // Warn about modified alignment after #includes.
 244   if (PrevPackState.CurrentValue != PackStack.CurrentValue) {
 245     Diag(IncludeLoc, diag::warn_pragma_pack_modified_after_include);
 246     Diag(PackStack.CurrentPragmaLocation, diag::note_pragma_pack_here);
 247   }
 248 }
 249
 250 void Sema::DiagnoseUnterminatedPragmaPack() {
 251   if (PackStack.Stack.empty())
 252     return;
 253   bool IsInnermost = true;
 254   for (const auto &StackSlot : llvm::reverse(PackStack.Stack)) {
 255     Diag(StackSlot.PragmaPushLocation, diag::warn_pragma_pack_no_pop_eof);
 256     // The user might have already reset the alignment, so suggest replacing
 257     // the reset with a pop.
 258     if (IsInnermost && PackStack.CurrentValue == PackStack.DefaultValue) {
 259       DiagnosticBuilder DB = Diag(PackStack.CurrentPragmaLocation,
 260                                   diag::note_pragma_pack_pop_instead_reset);
 261       SourceLocation FixItLoc = Lexer::findLocationAfterToken(
 262           PackStack.CurrentPragmaLocation, tok::l_paren, SourceMgr, LangOpts,
 263           /*SkipTrailing=*/false);
 264       if (FixItLoc.isValid())
 265         DB << FixItHint::CreateInsertion(FixItLoc, "pop");
 266     }
 267     IsInnermost = false;
 268   }
 269 }
 270
 271 void Sema::ActOnPragmaMSStruct(PragmaMSStructKind Kind) {
 272   MSStructPragmaOn = (Kind == PMSST_ON);
 273 }
 274
 275 void Sema::ActOnPragmaMSComment(SourceLocation CommentLoc,
 276                                 PragmaMSCommentKind Kind, StringRef Arg) {
 277   auto *PCD = PragmaCommentDecl::Create(
 278       Context, Context.getTranslationUnitDecl(), CommentLoc, Kind, Arg);
 279   Context.getTranslationUnitDecl()->addDecl(PCD);
 280   Consumer.HandleTopLevelDecl(DeclGroupRef(PCD));
 281 }
 282
 283 void Sema::ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
 284                                      StringRef Value) {
 285   auto *PDMD = PragmaDetectMismatchDecl::Create(
 286       Context, Context.getTranslationUnitDecl(), Loc, Name, Value);
 287   Context.getTranslationUnitDecl()->addDecl(PDMD);
 288   Consumer.HandleTopLevelDecl(DeclGroupRef(PDMD));
 289 }
 290
 291 void Sema::ActOnPragmaMSPointersToMembers(
 292     LangOptions::PragmaMSPointersToMembersKind RepresentationMethod,
 293     SourceLocation PragmaLoc) {
 294   MSPointerToMemberRepresentationMethod = RepresentationMethod;
 295   ImplicitMSInheritanceAttrLoc = PragmaLoc;
 296 }
 297
 298 void Sema::ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,
 299                                  SourceLocation PragmaLoc,
 300                                  MSVtorDispAttr::Mode Mode) {
 301   if (Action & PSK_Pop && VtorDispStack.Stack.empty())
 302     Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "vtordisp"
 303                                                   << "stack empty";
 304   VtorDispStack.Act(PragmaLoc, Action, StringRef(), Mode);
 305 }
 306
 307 template<typename ValueType>
 308 void Sema::PragmaStack<ValueType>::Act(SourceLocation PragmaLocation,
 309                                        PragmaMsStackAction Action,
 310                                        llvm::StringRef StackSlotLabel,
 311                                        ValueType Value) {
 312   if (Action == PSK_Reset) {
 313     CurrentValue = DefaultValue;
 314     CurrentPragmaLocation = PragmaLocation;
 315     return;
 316   }
 317   if (Action & PSK_Push)
 318     Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
 319                        PragmaLocation);
 320   else if (Action & PSK_Pop) {
 321     if (!StackSlotLabel.empty()) {
 322       // If we've got a label, try to find it and jump there.
 323       auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
 324         return x.StackSlotLabel == StackSlotLabel;
 325       });
 326       // If we found the label so pop from there.
 327       if (I != Stack.rend()) {
 328         CurrentValue = I->Value;
 329         CurrentPragmaLocation = I->PragmaLocation;
 330         Stack.erase(std::prev(I.base()), Stack.end());
 331       }
 332     } else if (!Stack.empty()) {
 333       // We do not have a label, just pop the last entry.
 334       CurrentValue = Stack.back().Value;
 335       CurrentPragmaLocation = Stack.back().PragmaLocation;
 336       Stack.pop_back();
 337     }
 338   }
 339   if (Action & PSK_Set) {
 340     CurrentValue = Value;
 341     CurrentPragmaLocation = PragmaLocation;
 342   }
 343 }
 344
 345 bool Sema::UnifySection(StringRef SectionName,
 346                         int SectionFlags,
 347                         DeclaratorDecl *Decl) {
 348   auto Section = Context.SectionInfos.find(SectionName);
 349   if (Section == Context.SectionInfos.end()) {
 350     Context.SectionInfos[SectionName] =
 351         ASTContext::SectionInfo(Decl, SourceLocation(), SectionFlags);
 352     return false;
 353   }
 354   // A pre-declared section takes precedence w/o diagnostic.
 355   if (Section->second.SectionFlags == SectionFlags ||
 356       !(Section->second.SectionFlags & ASTContext::PSF_Implicit))
 357     return false;
 358   auto OtherDecl = Section->second.Decl;
 359   Diag(Decl->getLocation(), diag::err_section_conflict)
 360       << Decl << OtherDecl;
 361   Diag(OtherDecl->getLocation(), diag::note_declared_at)
 362       << OtherDecl->getName();
 363   if (auto A = Decl->getAttr<SectionAttr>())
 364     if (A->isImplicit())
 365       Diag(A->getLocation(), diag::note_pragma_entered_here);
 366   if (auto A = OtherDecl->getAttr<SectionAttr>())
 367     if (A->isImplicit())
 368       Diag(A->getLocation(), diag::note_pragma_entered_here);
 369   return true;
 370 }
 371
 372 bool Sema::UnifySection(StringRef SectionName,
 373                         int SectionFlags,
 374                         SourceLocation PragmaSectionLocation) {
 375   auto Section = Context.SectionInfos.find(SectionName);
 376   if (Section != Context.SectionInfos.end()) {
 377     if (Section->second.SectionFlags == SectionFlags)
 378       return false;
 379     if (!(Section->second.SectionFlags & ASTContext::PSF_Implicit)) {
 380       Diag(PragmaSectionLocation, diag::err_section_conflict)
 381           << "this" << "a prior #pragma section";
 382       Diag(Section->second.PragmaSectionLocation,
 383            diag::note_pragma_entered_here);
 384       return true;
 385     }
 386   }
 387   Context.SectionInfos[SectionName] =
 388       ASTContext::SectionInfo(nullptr, PragmaSectionLocation, SectionFlags);
 389   return false;
 390 }
 391
 392 /// Called on well formed \#pragma bss_seg().
 393 void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation,
 394                             PragmaMsStackAction Action,
 395                             llvm::StringRef StackSlotLabel,
 396                             StringLiteral *SegmentName,
 397                             llvm::StringRef PragmaName) {
 398   PragmaStack<StringLiteral *> *Stack =
 399     llvm::StringSwitch<PragmaStack<StringLiteral *> *>(PragmaName)
 400         .Case("data_seg", &DataSegStack)
 401         .Case("bss_seg", &BSSSegStack)
 402         .Case("const_seg", &ConstSegStack)
 403         .Case("code_seg", &CodeSegStack);
 404   if (Action & PSK_Pop && Stack->Stack.empty())
 405     Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName
 406         << "stack empty";
 407   if (SegmentName &&
 408       !checkSectionName(SegmentName->getLocStart(), SegmentName->getString()))
 409     return;
 410   Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName);
 411 }
 412
 413 /// Called on well formed \#pragma bss_seg().
 414 void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation,
 415                                 int SectionFlags, StringLiteral *SegmentName) {
 416   UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation);
 417 }
 418
 419 void Sema::ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
 420                                 StringLiteral *SegmentName) {
 421   // There's no stack to maintain, so we just have a current section.  When we
 422   // see the default section, reset our current section back to null so we stop
 423   // tacking on unnecessary attributes.
 424   CurInitSeg = SegmentName->getString() == ".CRT$XCU" ? nullptr : SegmentName;
 425   CurInitSegLoc = PragmaLocation;
 426 }
 427
 428 void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope,
 429                              SourceLocation PragmaLoc) {
 430
 431   IdentifierInfo *Name = IdTok.getIdentifierInfo();
 432   LookupResult Lookup(*this, Name, IdTok.getLocation(), LookupOrdinaryName);
 433   LookupParsedName(Lookup, curScope, nullptr, true);
 434
 435   if (Lookup.empty()) {
 436     Diag(PragmaLoc, diag::warn_pragma_unused_undeclared_var)
 437       << Name << SourceRange(IdTok.getLocation());
 438     return;
 439   }
 440
 441   VarDecl *VD = Lookup.getAsSingle<VarDecl>();
 442   if (!VD) {
 443     Diag(PragmaLoc, diag::warn_pragma_unused_expected_var_arg)
 444       << Name << SourceRange(IdTok.getLocation());
 445     return;
 446   }
 447
 448   // Warn if this was used before being marked unused.
 449   if (VD->isUsed())
 450     Diag(PragmaLoc, diag::warn_used_but_marked_unused) << Name;
 451
 452   VD->addAttr(UnusedAttr::CreateImplicit(Context, UnusedAttr::GNU_unused,
 453                                          IdTok.getLocation()));
 454 }
 455
 456 void Sema::AddCFAuditedAttribute(Decl *D) {
 457   SourceLocation Loc = PP.getPragmaARCCFCodeAuditedLoc();
 458   if (!Loc.isValid()) return;
 459
 460   // Don't add a redundant or conflicting attribute.
 461   if (D->hasAttr<CFAuditedTransferAttr>() ||
 462       D->hasAttr<CFUnknownTransferAttr>())
 463     return;
 464
 465   D->addAttr(CFAuditedTransferAttr::CreateImplicit(Context, Loc));
 466 }
 467
 468 namespace {
 469
 470 Optional<attr::SubjectMatchRule>
 471 getParentAttrMatcherRule(attr::SubjectMatchRule Rule) {
 472   using namespace attr;
 473   switch (Rule) {
 474   default:
 475     return None;
 476 #define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)
 477 #define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated)    \
 478   case Value:                                                                  \
 479     return Parent;
 480 #include "clang/Basic/AttrSubMatchRulesList.inc"
 481   }
 482 }
 483
 484 bool isNegatedAttrMatcherSubRule(attr::SubjectMatchRule Rule) {
 485   using namespace attr;
 486   switch (Rule) {
 487   default:
 488     return false;
 489 #define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)
 490 #define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated)    \
 491   case Value:                                                                  \
 492     return IsNegated;
 493 #include "clang/Basic/AttrSubMatchRulesList.inc"
 494   }
 495 }
 496
 497 CharSourceRange replacementRangeForListElement(const Sema &S,
 498                                                SourceRange Range) {
 499   // Make sure that the ',' is removed as well.
 500   SourceLocation AfterCommaLoc = Lexer::findLocationAfterToken(
 501       Range.getEnd(), tok::comma, S.getSourceManager(), S.getLangOpts(),
 502       /*SkipTrailingWhitespaceAndNewLine=*/false);
 503   if (AfterCommaLoc.isValid())
 504     return CharSourceRange::getCharRange(Range.getBegin(), AfterCommaLoc);
 505   else
 506     return CharSourceRange::getTokenRange(Range);
 507 }
 508
 509 std::string
 510 attrMatcherRuleListToString(ArrayRef<attr::SubjectMatchRule> Rules) {
 511   std::string Result;
 512   llvm::raw_string_ostream OS(Result);
 513   for (const auto &I : llvm::enumerate(Rules)) {
 514     if (I.index())
 515       OS << (I.index() == Rules.size() - 1 ? ", and " : ", ");
 516     OS << "'" << attr::getSubjectMatchRuleSpelling(I.value()) << "'";
 517   }
 518   return OS.str();
 519 }
 520
 521 } // end anonymous namespace
 522
 523 void Sema::ActOnPragmaAttributePush(ParsedAttr &Attribute,
 524                                     SourceLocation PragmaLoc,
 525                                     attr::ParsedSubjectMatchRuleSet Rules) {
 526   SmallVector<attr::SubjectMatchRule, 4> SubjectMatchRules;
 527   // Gather the subject match rules that are supported by the attribute.
 528   SmallVector<std::pair<attr::SubjectMatchRule, bool>, 4>
 529       StrictSubjectMatchRuleSet;
 530   Attribute.getMatchRules(LangOpts, StrictSubjectMatchRuleSet);
 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   PragmaAttributeStack.push_back(
 626       {PragmaLoc, &Attribute, std::move(SubjectMatchRules), /*IsUsed=*/false});
 627 }
 628
 629 void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc) {
 630   if (PragmaAttributeStack.empty()) {
 631     Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch);
 632     return;
 633   }
 634   const PragmaAttributeEntry &Entry = PragmaAttributeStack.back();
 635   if (!Entry.IsUsed) {
 636     assert(Entry.Attribute && "Expected an attribute");
 637     Diag(Entry.Attribute->getLoc(), diag::warn_pragma_attribute_unused)
 638         << Entry.Attribute->getName();
 639     Diag(PragmaLoc, diag::note_pragma_attribute_region_ends_here);
 640   }
 641   PragmaAttributeStack.pop_back();
 642 }
 643
 644 void Sema::AddPragmaAttributes(Scope *S, Decl *D) {
 645   if (PragmaAttributeStack.empty())
 646     return;
 647   for (auto &Entry : PragmaAttributeStack) {
 648     ParsedAttr *Attribute = Entry.Attribute;
 649     assert(Attribute && "Expected an attribute");
 650
 651     // Ensure that the attribute can be applied to the given declaration.
 652     bool Applies = false;
 653     for (const auto &Rule : Entry.MatchRules) {
 654       if (Attribute->appliesToDecl(D, Rule)) {
 655         Applies = true;
 656         break;
 657       }
 658     }
 659     if (!Applies)
 660       continue;
 661     Entry.IsUsed = true;
 662     PragmaAttributeCurrentTargetDecl = D;
 663     ParsedAttributesView Attrs;
 664     Attrs.addAtStart(Attribute);
 665     ProcessDeclAttributeList(S, D, Attrs);
 666     PragmaAttributeCurrentTargetDecl = nullptr;
 667   }
 668 }
 669
 670 void Sema::PrintPragmaAttributeInstantiationPoint() {
 671   assert(PragmaAttributeCurrentTargetDecl && "Expected an active declaration");
 672   Diags.Report(PragmaAttributeCurrentTargetDecl->getLocStart(),
 673                diag::note_pragma_attribute_applied_decl_here);
 674 }
 675
 676 void Sema::DiagnoseUnterminatedPragmaAttribute() {
 677   if (PragmaAttributeStack.empty())
 678     return;
 679   Diag(PragmaAttributeStack.back().Loc, diag::err_pragma_attribute_no_pop_eof);
 680 }
 681
 682 void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) {
 683   if(On)
 684     OptimizeOffPragmaLocation = SourceLocation();
 685   else
 686     OptimizeOffPragmaLocation = PragmaLoc;
 687 }
 688
 689 void Sema::AddRangeBasedOptnone(FunctionDecl *FD) {
 690   // In the future, check other pragmas if they're implemented (e.g. pragma
 691   // optimize 0 will probably map to this functionality too).
 692   if(OptimizeOffPragmaLocation.isValid())
 693     AddOptnoneAttributeIfNoConflicts(FD, OptimizeOffPragmaLocation);
 694 }
 695
 696 void Sema::AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD,
 697                                             SourceLocation Loc) {
 698   // Don't add a conflicting attribute. No diagnostic is needed.
 699   if (FD->hasAttr<MinSizeAttr>() || FD->hasAttr<AlwaysInlineAttr>())
 700     return;
 701
 702   // Add attributes only if required. Optnone requires noinline as well, but if
 703   // either is already present then don't bother adding them.
 704   if (!FD->hasAttr<OptimizeNoneAttr>())
 705     FD->addAttr(OptimizeNoneAttr::CreateImplicit(Context, Loc));
 706   if (!FD->hasAttr<NoInlineAttr>())
 707     FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc));
 708 }
 709
 710 typedef std::vector<std::pair<unsigned, SourceLocation> > VisStack;
 711 enum : unsigned { NoVisibility = ~0U };
 712
 713 void Sema::AddPushedVisibilityAttribute(Decl *D) {
 714   if (!VisContext)
 715     return;
 716
 717   NamedDecl *ND = dyn_cast<NamedDecl>(D);
 718   if (ND && ND->getExplicitVisibility(NamedDecl::VisibilityForValue))
 719     return;
 720
 721   VisStack *Stack = static_cast<VisStack*>(VisContext);
 722   unsigned rawType = Stack->back().first;
 723   if (rawType == NoVisibility) return;
 724
 725   VisibilityAttr::VisibilityType type
 726     = (VisibilityAttr::VisibilityType) rawType;
 727   SourceLocation loc = Stack->back().second;
 728
 729   D->addAttr(VisibilityAttr::CreateImplicit(Context, type, loc));
 730 }
 731
 732 /// FreeVisContext - Deallocate and null out VisContext.
 733 void Sema::FreeVisContext() {
 734   delete static_cast<VisStack*>(VisContext);
 735   VisContext = nullptr;
 736 }
 737
 738 static void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc) {
 739   // Put visibility on stack.
 740   if (!S.VisContext)
 741     S.VisContext = new VisStack;
 742
 743   VisStack *Stack = static_cast<VisStack*>(S.VisContext);
 744   Stack->push_back(std::make_pair(type, loc));
 745 }
 746
 747 void Sema::ActOnPragmaVisibility(const IdentifierInfo* VisType,
 748                                  SourceLocation PragmaLoc) {
 749   if (VisType) {
 750     // Compute visibility to use.
 751     VisibilityAttr::VisibilityType T;
 752     if (!VisibilityAttr::ConvertStrToVisibilityType(VisType->getName(), T)) {
 753       Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType;
 754       return;
 755     }
 756     PushPragmaVisibility(*this, T, PragmaLoc);
 757   } else {
 758     PopPragmaVisibility(false, PragmaLoc);
 759   }
 760 }
 761
 762 void Sema::ActOnPragmaFPContract(LangOptions::FPContractModeKind FPC) {
 763   switch (FPC) {
 764   case LangOptions::FPC_On:
 765     FPFeatures.setAllowFPContractWithinStatement();
 766     break;
 767   case LangOptions::FPC_Fast:
 768     FPFeatures.setAllowFPContractAcrossStatement();
 769     break;
 770   case LangOptions::FPC_Off:
 771     FPFeatures.setDisallowFPContract();
 772     break;
 773   }
 774 }
 775
 776 void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
 777                                        SourceLocation Loc) {
 778   // Visibility calculations will consider the namespace's visibility.
 779   // Here we just want to note that we're in a visibility context
 780   // which overrides any enclosing #pragma context, but doesn't itself
 781   // contribute visibility.
 782   PushPragmaVisibility(*this, NoVisibility, Loc);
 783 }
 784
 785 void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) {
 786   if (!VisContext) {
 787     Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
 788     return;
 789   }
 790
 791   // Pop visibility from stack
 792   VisStack *Stack = static_cast<VisStack*>(VisContext);
 793
 794   const std::pair<unsigned, SourceLocation> *Back = &Stack->back();
 795   bool StartsWithPragma = Back->first != NoVisibility;
 796   if (StartsWithPragma && IsNamespaceEnd) {
 797     Diag(Back->second, diag::err_pragma_push_visibility_mismatch);
 798     Diag(EndLoc, diag::note_surrounding_namespace_ends_here);
 799
 800     // For better error recovery, eat all pushes inside the namespace.
 801     do {
 802       Stack->pop_back();
 803       Back = &Stack->back();
 804       StartsWithPragma = Back->first != NoVisibility;
 805     } while (StartsWithPragma);
 806   } else if (!StartsWithPragma && !IsNamespaceEnd) {
 807     Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
 808     Diag(Back->second, diag::note_surrounding_namespace_starts_here);
 809     return;
 810   }
 811
 812   Stack->pop_back();
 813   // To simplify the implementation, never keep around an empty stack.
 814   if (Stack->empty())
 815     FreeVisContext();
 816 }