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