Home | History | Annotate | Download | only in Sema 
      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/Sema/SemaInternal.h"
     16 #include "clang/AST/ASTConsumer.h"
     17 #include "clang/AST/Attr.h"
     18 #include "clang/AST/Expr.h"
     19 #include "clang/Basic/TargetInfo.h"
     20 #include "clang/Lex/Preprocessor.h"
     21 #include "clang/Sema/Lookup.h"
     22 using namespace clang;
     23 
     24 //===----------------------------------------------------------------------===//
     25 // Pragma 'pack' and 'options align'
     26 //===----------------------------------------------------------------------===//
     27 
     28 namespace {
     29   struct PackStackEntry {
     30     // We just use a sentinel to represent when the stack is set to mac68k
     31     // alignment.
     32     static const unsigned kMac68kAlignmentSentinel = ~0U;
     33 
     34     unsigned Alignment;
     35     IdentifierInfo *Name;
     36   };
     37 
     38   /// PragmaPackStack - Simple class to wrap the stack used by #pragma
     39   /// pack.
     40   class PragmaPackStack {
     41     typedef std::vector<PackStackEntry> stack_ty;
     42 
     43     /// Alignment - The current user specified alignment.
     44     unsigned Alignment;
     45 
     46     /// Stack - Entries in the #pragma pack stack, consisting of saved
     47     /// alignments and optional names.
     48     stack_ty Stack;
     49 
     50   public:
     51     PragmaPackStack() : Alignment(0) {}
     52 
     53     void setAlignment(unsigned A) { Alignment = A; }
     54     unsigned getAlignment() { return Alignment; }
     55 
     56     /// push - Push the current alignment onto the stack, optionally
     57     /// using the given \arg Name for the record, if non-zero.
     58     void push(IdentifierInfo *Name) {
     59       PackStackEntry PSE = { Alignment, Name };
     60       Stack.push_back(PSE);
     61     }
     62 
     63     /// pop - Pop a record from the stack and restore the current
     64     /// alignment to the previous value. If \arg Name is non-zero then
     65     /// the first such named record is popped, otherwise the top record
     66     /// is popped. Returns true if the pop succeeded.
     67     bool pop(IdentifierInfo *Name, bool IsReset);
     68   };
     69 }  // end anonymous namespace.
     70 
     71 bool PragmaPackStack::pop(IdentifierInfo *Name, bool IsReset) {
     72   // If name is empty just pop top.
     73   if (!Name) {
     74     // An empty stack is a special case...
     75     if (Stack.empty()) {
     76       // If this isn't a reset, it is always an error.
     77       if (!IsReset)
     78         return false;
     79 
     80       // Otherwise, it is an error only if some alignment has been set.
     81       if (!Alignment)
     82         return false;
     83 
     84       // Otherwise, reset to the default alignment.
     85       Alignment = 0;
     86     } else {
     87       Alignment = Stack.back().Alignment;
     88       Stack.pop_back();
     89     }
     90 
     91     return true;
     92   }
     93 
     94   // Otherwise, find the named record.
     95   for (unsigned i = Stack.size(); i != 0; ) {
     96     --i;
     97     if (Stack[i].Name == Name) {
     98       // Found it, pop up to and including this record.
     99       Alignment = Stack[i].Alignment;
    100       Stack.erase(Stack.begin() + i, Stack.end());
    101       return true;
    102     }
    103   }
    104 
    105   return false;
    106 }
    107 
    108 
    109 /// FreePackedContext - Deallocate and null out PackContext.
    110 void Sema::FreePackedContext() {
    111   delete static_cast<PragmaPackStack*>(PackContext);
    112   PackContext = nullptr;
    113 }
    114 
    115 void Sema::AddAlignmentAttributesForRecord(RecordDecl *RD) {
    116   // If there is no pack context, we don't need any attributes.
    117   if (!PackContext)
    118     return;
    119 
    120   PragmaPackStack *Stack = static_cast<PragmaPackStack*>(PackContext);
    121 
    122   // Otherwise, check to see if we need a max field alignment attribute.
    123   if (unsigned Alignment = Stack->getAlignment()) {
    124     if (Alignment == PackStackEntry::kMac68kAlignmentSentinel)
    125       RD->addAttr(AlignMac68kAttr::CreateImplicit(Context));
    126     else
    127       RD->addAttr(MaxFieldAlignmentAttr::CreateImplicit(Context,
    128                                                         Alignment * 8));
    129   }
    130 }
    131 
    132 void Sema::AddMsStructLayoutForRecord(RecordDecl *RD) {
    133   if (MSStructPragmaOn)
    134     RD->addAttr(MsStructAttr::CreateImplicit(Context));
    135 
    136   // FIXME: We should merge AddAlignmentAttributesForRecord with
    137   // AddMsStructLayoutForRecord into AddPragmaAttributesForRecord, which takes
    138   // all active pragmas and applies them as attributes to class definitions.
    139   if (VtorDispModeStack.back() != getLangOpts().VtorDispMode)
    140     RD->addAttr(
    141         MSVtorDispAttr::CreateImplicit(Context, VtorDispModeStack.back()));
    142 }
    143 
    144 void Sema::ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
    145                                    SourceLocation PragmaLoc) {
    146   if (!PackContext)
    147     PackContext = new PragmaPackStack();
    148 
    149   PragmaPackStack *Context = static_cast<PragmaPackStack*>(PackContext);
    150 
    151   switch (Kind) {
    152     // For all targets we support native and natural are the same.
    153     //
    154     // FIXME: This is not true on Darwin/PPC.
    155   case POAK_Native:
    156   case POAK_Power:
    157   case POAK_Natural:
    158     Context->push(nullptr);
    159     Context->setAlignment(0);
    160     break;
    161 
    162     // Note that '#pragma options align=packed' is not equivalent to attribute
    163     // packed, it has a different precedence relative to attribute aligned.
    164   case POAK_Packed:
    165     Context->push(nullptr);
    166     Context->setAlignment(1);
    167     break;
    168 
    169   case POAK_Mac68k:
    170     // Check if the target supports this.
    171     if (!this->Context.getTargetInfo().hasAlignMac68kSupport()) {
    172       Diag(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported);
    173       return;
    174     }
    175     Context->push(nullptr);
    176     Context->setAlignment(PackStackEntry::kMac68kAlignmentSentinel);
    177     break;
    178 
    179   case POAK_Reset:
    180     // Reset just pops the top of the stack, or resets the current alignment to
    181     // default.
    182     if (!Context->pop(nullptr, /*IsReset=*/true)) {
    183       Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed)
    184         << "stack empty";
    185     }
    186     break;
    187   }
    188 }
    189 
    190 void Sema::ActOnPragmaPack(PragmaPackKind Kind, IdentifierInfo *Name,
    191                            Expr *alignment, SourceLocation PragmaLoc,
    192                            SourceLocation LParenLoc, SourceLocation RParenLoc) {
    193   Expr *Alignment = static_cast<Expr *>(alignment);
    194 
    195   // If specified then alignment must be a "small" power of two.
    196   unsigned AlignmentVal = 0;
    197   if (Alignment) {
    198     llvm::APSInt Val;
    199 
    200     // pack(0) is like pack(), which just works out since that is what
    201     // we use 0 for in PackAttr.
    202     if (Alignment->isTypeDependent() ||
    203         Alignment->isValueDependent() ||
    204         !Alignment->isIntegerConstantExpr(Val, Context) ||
    205         !(Val == 0 || Val.isPowerOf2()) ||
    206         Val.getZExtValue() > 16) {
    207       Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment);
    208       return; // Ignore
    209     }
    210 
    211     AlignmentVal = (unsigned) Val.getZExtValue();
    212   }
    213 
    214   if (!PackContext)
    215     PackContext = new PragmaPackStack();
    216 
    217   PragmaPackStack *Context = static_cast<PragmaPackStack*>(PackContext);
    218 
    219   switch (Kind) {
    220   case Sema::PPK_Default: // pack([n])
    221     Context->setAlignment(AlignmentVal);
    222     break;
    223 
    224   case Sema::PPK_Show: // pack(show)
    225     // Show the current alignment, making sure to show the right value
    226     // for the default.
    227     AlignmentVal = Context->getAlignment();
    228     // FIXME: This should come from the target.
    229     if (AlignmentVal == 0)
    230       AlignmentVal = 8;
    231     if (AlignmentVal == PackStackEntry::kMac68kAlignmentSentinel)
    232       Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k";
    233     else
    234       Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;
    235     break;
    236 
    237   case Sema::PPK_Push: // pack(push [, id] [, [n])
    238     Context->push(Name);
    239     // Set the new alignment if specified.
    240     if (Alignment)
    241       Context->setAlignment(AlignmentVal);
    242     break;
    243 
    244   case Sema::PPK_Pop: // pack(pop [, id] [,  n])
    245     // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack:
    246     // "#pragma pack(pop, identifier, n) is undefined"
    247     if (Alignment && Name)
    248       Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifer_and_alignment);
    249 
    250     // Do the pop.
    251     if (!Context->pop(Name, /*IsReset=*/false)) {
    252       // If a name was specified then failure indicates the name
    253       // wasn't found. Otherwise failure indicates the stack was
    254       // empty.
    255       Diag(PragmaLoc, diag::warn_pragma_pop_failed)
    256           << "pack" << (Name ? "no record matching name" : "stack empty");
    257 
    258       // FIXME: Warn about popping named records as MSVC does.
    259     } else {
    260       // Pop succeeded, set the new alignment if specified.
    261       if (Alignment)
    262         Context->setAlignment(AlignmentVal);
    263     }
    264     break;
    265   }
    266 }
    267 
    268 void Sema::ActOnPragmaMSStruct(PragmaMSStructKind Kind) {
    269   MSStructPragmaOn = (Kind == PMSST_ON);
    270 }
    271 
    272 void Sema::ActOnPragmaMSComment(PragmaMSCommentKind Kind, StringRef Arg) {
    273   // FIXME: Serialize this.
    274   switch (Kind) {
    275   case PCK_Unknown:
    276     llvm_unreachable("unexpected pragma comment kind");
    277   case PCK_Linker:
    278     Consumer.HandleLinkerOptionPragma(Arg);
    279     return;
    280   case PCK_Lib:
    281     Consumer.HandleDependentLibrary(Arg);
    282     return;
    283   case PCK_Compiler:
    284   case PCK_ExeStr:
    285   case PCK_User:
    286     return;  // We ignore all of these.
    287   }
    288   llvm_unreachable("invalid pragma comment kind");
    289 }
    290 
    291 void Sema::ActOnPragmaDetectMismatch(StringRef Name, StringRef Value) {
    292   // FIXME: Serialize this.
    293   Consumer.HandleDetectMismatch(Name, Value);
    294 }
    295 
    296 void Sema::ActOnPragmaMSPointersToMembers(
    297     LangOptions::PragmaMSPointersToMembersKind RepresentationMethod,
    298     SourceLocation PragmaLoc) {
    299   MSPointerToMemberRepresentationMethod = RepresentationMethod;
    300   ImplicitMSInheritanceAttrLoc = PragmaLoc;
    301 }
    302 
    303 void Sema::ActOnPragmaMSVtorDisp(PragmaVtorDispKind Kind,
    304                                  SourceLocation PragmaLoc,
    305                                  MSVtorDispAttr::Mode Mode) {
    306   switch (Kind) {
    307   case PVDK_Set:
    308     VtorDispModeStack.back() = Mode;
    309     break;
    310   case PVDK_Push:
    311     VtorDispModeStack.push_back(Mode);
    312     break;
    313   case PVDK_Reset:
    314     VtorDispModeStack.clear();
    315     VtorDispModeStack.push_back(MSVtorDispAttr::Mode(LangOpts.VtorDispMode));
    316     break;
    317   case PVDK_Pop:
    318     VtorDispModeStack.pop_back();
    319     if (VtorDispModeStack.empty()) {
    320       Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "vtordisp"
    321                                                     << "stack empty";
    322       VtorDispModeStack.push_back(MSVtorDispAttr::Mode(LangOpts.VtorDispMode));
    323     }
    324     break;
    325   }
    326 }
    327 
    328 template<typename ValueType>
    329 void Sema::PragmaStack<ValueType>::Act(SourceLocation PragmaLocation,
    330                                        PragmaMsStackAction Action,
    331                                        llvm::StringRef StackSlotLabel,
    332                                        ValueType Value) {
    333   if (Action == PSK_Reset) {
    334     CurrentValue = nullptr;
    335     return;
    336   }
    337   if (Action & PSK_Push)
    338     Stack.push_back(Slot(StackSlotLabel, CurrentValue, CurrentPragmaLocation));
    339   else if (Action & PSK_Pop) {
    340     if (!StackSlotLabel.empty()) {
    341       // If we've got a label, try to find it and jump there.
    342       auto I = std::find_if(Stack.rbegin(), Stack.rend(),
    343         [&](const Slot &x) { return x.StackSlotLabel == StackSlotLabel; });
    344       // If we found the label so pop from there.
    345       if (I != Stack.rend()) {
    346         CurrentValue = I->Value;
    347         CurrentPragmaLocation = I->PragmaLocation;
    348         Stack.erase(std::prev(I.base()), Stack.end());
    349       }
    350     } else if (!Stack.empty()) {
    351       // We don't have a label, just pop the last entry.
    352       CurrentValue = Stack.back().Value;
    353       CurrentPragmaLocation = Stack.back().PragmaLocation;
    354       Stack.pop_back();
    355     }
    356   }
    357   if (Action & PSK_Set) {
    358     CurrentValue = Value;
    359     CurrentPragmaLocation = PragmaLocation;
    360   }
    361 }
    362 
    363 bool Sema::UnifySection(const StringRef &SectionName,
    364                         int SectionFlags,
    365                         DeclaratorDecl *Decl) {
    366   auto Section = SectionInfos.find(SectionName);
    367   if (Section == SectionInfos.end()) {
    368     SectionInfos[SectionName] =
    369         SectionInfo(Decl, SourceLocation(), SectionFlags);
    370     return false;
    371   }
    372   // A pre-declared section takes precedence w/o diagnostic.
    373   if (Section->second.SectionFlags == SectionFlags ||
    374       !(Section->second.SectionFlags & PSF_Implicit))
    375     return false;
    376   auto OtherDecl = Section->second.Decl;
    377   Diag(Decl->getLocation(), diag::err_section_conflict)
    378       << Decl << OtherDecl;
    379   Diag(OtherDecl->getLocation(), diag::note_declared_at)
    380       << OtherDecl->getName();
    381   if (auto A = Decl->getAttr<SectionAttr>())
    382     if (A->isImplicit())
    383       Diag(A->getLocation(), diag::note_pragma_entered_here);
    384   if (auto A = OtherDecl->getAttr<SectionAttr>())
    385     if (A->isImplicit())
    386       Diag(A->getLocation(), diag::note_pragma_entered_here);
    387   return false;
    388 }
    389 
    390 bool Sema::UnifySection(const StringRef &SectionName,
    391                         int SectionFlags,
    392                         SourceLocation PragmaSectionLocation) {
    393   auto Section = SectionInfos.find(SectionName);
    394   if (Section != SectionInfos.end()) {
    395     if (Section->second.SectionFlags == SectionFlags)
    396       return false;
    397     if (!(Section->second.SectionFlags & PSF_Implicit)) {
    398       Diag(PragmaSectionLocation, diag::err_section_conflict)
    399           << "this" << "a prior #pragma section";
    400       Diag(Section->second.PragmaSectionLocation,
    401            diag::note_pragma_entered_here);
    402       return true;
    403     }
    404   }
    405   SectionInfos[SectionName] =
    406       SectionInfo(nullptr, PragmaSectionLocation, SectionFlags);
    407   return false;
    408 }
    409 
    410 /// \brief Called on well formed \#pragma bss_seg().
    411 void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation,
    412                             PragmaMsStackAction Action,
    413                             llvm::StringRef StackSlotLabel,
    414                             StringLiteral *SegmentName,
    415                             llvm::StringRef PragmaName) {
    416   PragmaStack<StringLiteral *> *Stack =
    417     llvm::StringSwitch<PragmaStack<StringLiteral *> *>(PragmaName)
    418         .Case("data_seg", &DataSegStack)
    419         .Case("bss_seg", &BSSSegStack)
    420         .Case("const_seg", &ConstSegStack)
    421         .Case("code_seg", &CodeSegStack);
    422   if (Action & PSK_Pop && Stack->Stack.empty())
    423     Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName
    424         << "stack empty";
    425   Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName);
    426 }
    427 
    428 /// \brief Called on well formed \#pragma bss_seg().
    429 void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation,
    430                                 int SectionFlags, StringLiteral *SegmentName) {
    431   UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation);
    432 }
    433 
    434 void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope,
    435                              SourceLocation PragmaLoc) {
    436 
    437   IdentifierInfo *Name = IdTok.getIdentifierInfo();
    438   LookupResult Lookup(*this, Name, IdTok.getLocation(), LookupOrdinaryName);
    439   LookupParsedName(Lookup, curScope, nullptr, true);
    440 
    441   if (Lookup.empty()) {
    442     Diag(PragmaLoc, diag::warn_pragma_unused_undeclared_var)
    443       << Name << SourceRange(IdTok.getLocation());
    444     return;
    445   }
    446 
    447   VarDecl *VD = Lookup.getAsSingle<VarDecl>();
    448   if (!VD) {
    449     Diag(PragmaLoc, diag::warn_pragma_unused_expected_var_arg)
    450       << Name << SourceRange(IdTok.getLocation());
    451     return;
    452   }
    453 
    454   // Warn if this was used before being marked unused.
    455   if (VD->isUsed())
    456     Diag(PragmaLoc, diag::warn_used_but_marked_unused) << Name;
    457 
    458   VD->addAttr(UnusedAttr::CreateImplicit(Context, IdTok.getLocation()));
    459 }
    460 
    461 void Sema::AddCFAuditedAttribute(Decl *D) {
    462   SourceLocation Loc = PP.getPragmaARCCFCodeAuditedLoc();
    463   if (!Loc.isValid()) return;
    464 
    465   // Don't add a redundant or conflicting attribute.
    466   if (D->hasAttr<CFAuditedTransferAttr>() ||
    467       D->hasAttr<CFUnknownTransferAttr>())
    468     return;
    469 
    470   D->addAttr(CFAuditedTransferAttr::CreateImplicit(Context, Loc));
    471 }
    472 
    473 void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) {
    474   if(On)
    475     OptimizeOffPragmaLocation = SourceLocation();
    476   else
    477     OptimizeOffPragmaLocation = PragmaLoc;
    478 }
    479 
    480 void Sema::AddRangeBasedOptnone(FunctionDecl *FD) {
    481   // In the future, check other pragmas if they're implemented (e.g. pragma
    482   // optimize 0 will probably map to this functionality too).
    483   if(OptimizeOffPragmaLocation.isValid())
    484     AddOptnoneAttributeIfNoConflicts(FD, OptimizeOffPragmaLocation);
    485 }
    486 
    487 void Sema::AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD,
    488                                             SourceLocation Loc) {
    489   // Don't add a conflicting attribute. No diagnostic is needed.
    490   if (FD->hasAttr<MinSizeAttr>() || FD->hasAttr<AlwaysInlineAttr>())
    491     return;
    492 
    493   // Add attributes only if required. Optnone requires noinline as well, but if
    494   // either is already present then don't bother adding them.
    495   if (!FD->hasAttr<OptimizeNoneAttr>())
    496     FD->addAttr(OptimizeNoneAttr::CreateImplicit(Context, Loc));
    497   if (!FD->hasAttr<NoInlineAttr>())
    498     FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc));
    499 }
    500 
    501 typedef std::vector<std::pair<unsigned, SourceLocation> > VisStack;
    502 enum : unsigned { NoVisibility = ~0U };
    503 
    504 void Sema::AddPushedVisibilityAttribute(Decl *D) {
    505   if (!VisContext)
    506     return;
    507 
    508   NamedDecl *ND = dyn_cast<NamedDecl>(D);
    509   if (ND && ND->getExplicitVisibility(NamedDecl::VisibilityForValue))
    510     return;
    511 
    512   VisStack *Stack = static_cast<VisStack*>(VisContext);
    513   unsigned rawType = Stack->back().first;
    514   if (rawType == NoVisibility) return;
    515 
    516   VisibilityAttr::VisibilityType type
    517     = (VisibilityAttr::VisibilityType) rawType;
    518   SourceLocation loc = Stack->back().second;
    519 
    520   D->addAttr(VisibilityAttr::CreateImplicit(Context, type, loc));
    521 }
    522 
    523 /// FreeVisContext - Deallocate and null out VisContext.
    524 void Sema::FreeVisContext() {
    525   delete static_cast<VisStack*>(VisContext);
    526   VisContext = nullptr;
    527 }
    528 
    529 static void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc) {
    530   // Put visibility on stack.
    531   if (!S.VisContext)
    532     S.VisContext = new VisStack;
    533 
    534   VisStack *Stack = static_cast<VisStack*>(S.VisContext);
    535   Stack->push_back(std::make_pair(type, loc));
    536 }
    537 
    538 void Sema::ActOnPragmaVisibility(const IdentifierInfo* VisType,
    539                                  SourceLocation PragmaLoc) {
    540   if (VisType) {
    541     // Compute visibility to use.
    542     VisibilityAttr::VisibilityType T;
    543     if (!VisibilityAttr::ConvertStrToVisibilityType(VisType->getName(), T)) {
    544       Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType;
    545       return;
    546     }
    547     PushPragmaVisibility(*this, T, PragmaLoc);
    548   } else {
    549     PopPragmaVisibility(false, PragmaLoc);
    550   }
    551 }
    552 
    553 void Sema::ActOnPragmaFPContract(tok::OnOffSwitch OOS) {
    554   switch (OOS) {
    555   case tok::OOS_ON:
    556     FPFeatures.fp_contract = 1;
    557     break;
    558   case tok::OOS_OFF:
    559     FPFeatures.fp_contract = 0;
    560     break;
    561   case tok::OOS_DEFAULT:
    562     FPFeatures.fp_contract = getLangOpts().DefaultFPContract;
    563     break;
    564   }
    565 }
    566 
    567 void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
    568                                        SourceLocation Loc) {
    569   // Visibility calculations will consider the namespace's visibility.
    570   // Here we just want to note that we're in a visibility context
    571   // which overrides any enclosing #pragma context, but doesn't itself
    572   // contribute visibility.
    573   PushPragmaVisibility(*this, NoVisibility, Loc);
    574 }
    575 
    576 void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) {
    577   if (!VisContext) {
    578     Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
    579     return;
    580   }
    581 
    582   // Pop visibility from stack
    583   VisStack *Stack = static_cast<VisStack*>(VisContext);
    584 
    585   const std::pair<unsigned, SourceLocation> *Back = &Stack->back();
    586   bool StartsWithPragma = Back->first != NoVisibility;
    587   if (StartsWithPragma && IsNamespaceEnd) {
    588     Diag(Back->second, diag::err_pragma_push_visibility_mismatch);
    589     Diag(EndLoc, diag::note_surrounding_namespace_ends_here);
    590 
    591     // For better error recovery, eat all pushes inside the namespace.
    592     do {
    593       Stack->pop_back();
    594       Back = &Stack->back();
    595       StartsWithPragma = Back->first != NoVisibility;
    596     } while (StartsWithPragma);
    597   } else if (!StartsWithPragma && !IsNamespaceEnd) {
    598     Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
    599     Diag(Back->second, diag::note_surrounding_namespace_starts_here);
    600     return;
    601   }
    602 
    603   Stack->pop_back();
    604   // To simplify the implementation, never keep around an empty stack.
    605   if (Stack->empty())
    606     FreeVisContext();
    607 }
    608