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::ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
 130                            StringRef SlotLabel, Expr *alignment) {
 131   Expr *Alignment = static_cast<Expr *>(alignment);
 132
 133   // If specified then alignment must be a "small" power of two.
 134   unsigned AlignmentVal = 0;
 135   if (Alignment) {
 136     llvm::APSInt Val;
 137
 138     // pack(0) is like pack(), which just works out since that is what
 139     // we use 0 for in PackAttr.
 140     if (Alignment->isTypeDependent() ||
 141         Alignment->isValueDependent() ||
 142         !Alignment->isIntegerConstantExpr(Val, Context) ||
 143         !(Val == 0 || Val.isPowerOf2()) ||
 144         Val.getZExtValue() > 16) {
 145       Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment);
 146       return; // Ignore
 147     }
 148
 149     AlignmentVal = (unsigned) Val.getZExtValue();
 150   }
 151   if (Action == Sema::PSK_Show) {
 152     // Show the current alignment, making sure to show the right value
 153     // for the default.
 154     // FIXME: This should come from the target.
 155     AlignmentVal = PackStack.CurrentValue;
 156     if (AlignmentVal == 0)
 157       AlignmentVal = 8;
 158     if (AlignmentVal == Sema::kMac68kAlignmentSentinel)
 159       Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k";
 160     else
 161       Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;
 162   }
 163   // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack:
 164   // "#pragma pack(pop, identifier, n) is undefined"
 165   if (Action & Sema::PSK_Pop) {
 166     if (Alignment && !SlotLabel.empty())
 167       Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifer_and_alignment);
 168     if (PackStack.Stack.empty())
 169       Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << "stack empty";
 170   }
 171
 172   PackStack.Act(PragmaLoc, Action, SlotLabel, AlignmentVal);
 173 }
 174
 175 void Sema::ActOnPragmaMSStruct(PragmaMSStructKind Kind) {
 176   MSStructPragmaOn = (Kind == PMSST_ON);
 177 }
 178
 179 void Sema::ActOnPragmaMSComment(SourceLocation CommentLoc,
 180                                 PragmaMSCommentKind Kind, StringRef Arg) {
 181   auto *PCD = PragmaCommentDecl::Create(
 182       Context, Context.getTranslationUnitDecl(), CommentLoc, Kind, Arg);
 183   Context.getTranslationUnitDecl()->addDecl(PCD);
 184   Consumer.HandleTopLevelDecl(DeclGroupRef(PCD));
 185 }
 186
 187 void Sema::ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
 188                                      StringRef Value) {
 189   auto *PDMD = PragmaDetectMismatchDecl::Create(
 190       Context, Context.getTranslationUnitDecl(), Loc, Name, Value);
 191   Context.getTranslationUnitDecl()->addDecl(PDMD);
 192   Consumer.HandleTopLevelDecl(DeclGroupRef(PDMD));
 193 }
 194
 195 void Sema::ActOnPragmaMSPointersToMembers(
 196     LangOptions::PragmaMSPointersToMembersKind RepresentationMethod,
 197     SourceLocation PragmaLoc) {
 198   MSPointerToMemberRepresentationMethod = RepresentationMethod;
 199   ImplicitMSInheritanceAttrLoc = PragmaLoc;
 200 }
 201
 202 void Sema::ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,
 203                                  SourceLocation PragmaLoc,
 204                                  MSVtorDispAttr::Mode Mode) {
 205   if (Action & PSK_Pop && VtorDispStack.Stack.empty())
 206     Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "vtordisp"
 207                                                   << "stack empty";
 208   VtorDispStack.Act(PragmaLoc, Action, StringRef(), Mode);
 209 }
 210
 211 template<typename ValueType>
 212 void Sema::PragmaStack<ValueType>::Act(SourceLocation PragmaLocation,
 213                                        PragmaMsStackAction Action,
 214                                        llvm::StringRef StackSlotLabel,
 215                                        ValueType Value) {
 216   if (Action == PSK_Reset) {
 217     CurrentValue = DefaultValue;
 218     return;
 219   }
 220   if (Action & PSK_Push)
 221     Stack.push_back(Slot(StackSlotLabel, CurrentValue, CurrentPragmaLocation));
 222   else if (Action & PSK_Pop) {
 223     if (!StackSlotLabel.empty()) {
 224       // If we've got a label, try to find it and jump there.
 225       auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
 226         return x.StackSlotLabel == StackSlotLabel;
 227       });
 228       // If we found the label so pop from there.
 229       if (I != Stack.rend()) {
 230         CurrentValue = I->Value;
 231         CurrentPragmaLocation = I->PragmaLocation;
 232         Stack.erase(std::prev(I.base()), Stack.end());
 233       }
 234     } else if (!Stack.empty()) {
 235       // We don't have a label, just pop the last entry.
 236       CurrentValue = Stack.back().Value;
 237       CurrentPragmaLocation = Stack.back().PragmaLocation;
 238       Stack.pop_back();
 239     }
 240   }
 241   if (Action & PSK_Set) {
 242     CurrentValue = Value;
 243     CurrentPragmaLocation = PragmaLocation;
 244   }
 245 }
 246
 247 bool Sema::UnifySection(StringRef SectionName,
 248                         int SectionFlags,
 249                         DeclaratorDecl *Decl) {
 250   auto Section = Context.SectionInfos.find(SectionName);
 251   if (Section == Context.SectionInfos.end()) {
 252     Context.SectionInfos[SectionName] =
 253         ASTContext::SectionInfo(Decl, SourceLocation(), SectionFlags);
 254     return false;
 255   }
 256   // A pre-declared section takes precedence w/o diagnostic.
 257   if (Section->second.SectionFlags == SectionFlags ||
 258       !(Section->second.SectionFlags & ASTContext::PSF_Implicit))
 259     return false;
 260   auto OtherDecl = Section->second.Decl;
 261   Diag(Decl->getLocation(), diag::err_section_conflict)
 262       << Decl << OtherDecl;
 263   Diag(OtherDecl->getLocation(), diag::note_declared_at)
 264       << OtherDecl->getName();
 265   if (auto A = Decl->getAttr<SectionAttr>())
 266     if (A->isImplicit())
 267       Diag(A->getLocation(), diag::note_pragma_entered_here);
 268   if (auto A = OtherDecl->getAttr<SectionAttr>())
 269     if (A->isImplicit())
 270       Diag(A->getLocation(), diag::note_pragma_entered_here);
 271   return true;
 272 }
 273
 274 bool Sema::UnifySection(StringRef SectionName,
 275                         int SectionFlags,
 276                         SourceLocation PragmaSectionLocation) {
 277   auto Section = Context.SectionInfos.find(SectionName);
 278   if (Section != Context.SectionInfos.end()) {
 279     if (Section->second.SectionFlags == SectionFlags)
 280       return false;
 281     if (!(Section->second.SectionFlags & ASTContext::PSF_Implicit)) {
 282       Diag(PragmaSectionLocation, diag::err_section_conflict)
 283           << "this" << "a prior #pragma section";
 284       Diag(Section->second.PragmaSectionLocation,
 285            diag::note_pragma_entered_here);
 286       return true;
 287     }
 288   }
 289   Context.SectionInfos[SectionName] =
 290       ASTContext::SectionInfo(nullptr, PragmaSectionLocation, SectionFlags);
 291   return false;
 292 }
 293
 294 /// \brief Called on well formed \#pragma bss_seg().
 295 void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation,
 296                             PragmaMsStackAction Action,
 297                             llvm::StringRef StackSlotLabel,
 298                             StringLiteral *SegmentName,
 299                             llvm::StringRef PragmaName) {
 300   PragmaStack<StringLiteral *> *Stack =
 301     llvm::StringSwitch<PragmaStack<StringLiteral *> *>(PragmaName)
 302         .Case("data_seg", &DataSegStack)
 303         .Case("bss_seg", &BSSSegStack)
 304         .Case("const_seg", &ConstSegStack)
 305         .Case("code_seg", &CodeSegStack);
 306   if (Action & PSK_Pop && Stack->Stack.empty())
 307     Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName
 308         << "stack empty";
 309   if (SegmentName &&
 310       !checkSectionName(SegmentName->getLocStart(), SegmentName->getString()))
 311     return;
 312   Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName);
 313 }
 314
 315 /// \brief Called on well formed \#pragma bss_seg().
 316 void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation,
 317                                 int SectionFlags, StringLiteral *SegmentName) {
 318   UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation);
 319 }
 320
 321 void Sema::ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
 322                                 StringLiteral *SegmentName) {
 323   // There's no stack to maintain, so we just have a current section.  When we
 324   // see the default section, reset our current section back to null so we stop
 325   // tacking on unnecessary attributes.
 326   CurInitSeg = SegmentName->getString() == ".CRT$XCU" ? nullptr : SegmentName;
 327   CurInitSegLoc = PragmaLocation;
 328 }
 329
 330 void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope,
 331                              SourceLocation PragmaLoc) {
 332
 333   IdentifierInfo *Name = IdTok.getIdentifierInfo();
 334   LookupResult Lookup(*this, Name, IdTok.getLocation(), LookupOrdinaryName);
 335   LookupParsedName(Lookup, curScope, nullptr, true);
 336
 337   if (Lookup.empty()) {
 338     Diag(PragmaLoc, diag::warn_pragma_unused_undeclared_var)
 339       << Name << SourceRange(IdTok.getLocation());
 340     return;
 341   }
 342
 343   VarDecl *VD = Lookup.getAsSingle<VarDecl>();
 344   if (!VD) {
 345     Diag(PragmaLoc, diag::warn_pragma_unused_expected_var_arg)
 346       << Name << SourceRange(IdTok.getLocation());
 347     return;
 348   }
 349
 350   // Warn if this was used before being marked unused.
 351   if (VD->isUsed())
 352     Diag(PragmaLoc, diag::warn_used_but_marked_unused) << Name;
 353
 354   VD->addAttr(UnusedAttr::CreateImplicit(Context, UnusedAttr::GNU_unused,
 355                                          IdTok.getLocation()));
 356 }
 357
 358 void Sema::AddCFAuditedAttribute(Decl *D) {
 359   SourceLocation Loc = PP.getPragmaARCCFCodeAuditedLoc();
 360   if (!Loc.isValid()) return;
 361
 362   // Don't add a redundant or conflicting attribute.
 363   if (D->hasAttr<CFAuditedTransferAttr>() ||
 364       D->hasAttr<CFUnknownTransferAttr>())
 365     return;
 366
 367   D->addAttr(CFAuditedTransferAttr::CreateImplicit(Context, Loc));
 368 }
 369
 370 void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) {
 371   if(On)
 372     OptimizeOffPragmaLocation = SourceLocation();
 373   else
 374     OptimizeOffPragmaLocation = PragmaLoc;
 375 }
 376
 377 void Sema::AddRangeBasedOptnone(FunctionDecl *FD) {
 378   // In the future, check other pragmas if they're implemented (e.g. pragma
 379   // optimize 0 will probably map to this functionality too).
 380   if(OptimizeOffPragmaLocation.isValid())
 381     AddOptnoneAttributeIfNoConflicts(FD, OptimizeOffPragmaLocation);
 382 }
 383
 384 void Sema::AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD,
 385                                             SourceLocation Loc) {
 386   // Don't add a conflicting attribute. No diagnostic is needed.
 387   if (FD->hasAttr<MinSizeAttr>() || FD->hasAttr<AlwaysInlineAttr>())
 388     return;
 389
 390   // Add attributes only if required. Optnone requires noinline as well, but if
 391   // either is already present then don't bother adding them.
 392   if (!FD->hasAttr<OptimizeNoneAttr>())
 393     FD->addAttr(OptimizeNoneAttr::CreateImplicit(Context, Loc));
 394   if (!FD->hasAttr<NoInlineAttr>())
 395     FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc));
 396 }
 397
 398 typedef std::vector<std::pair<unsigned, SourceLocation> > VisStack;
 399 enum : unsigned { NoVisibility = ~0U };
 400
 401 void Sema::AddPushedVisibilityAttribute(Decl *D) {
 402   if (!VisContext)
 403     return;
 404
 405   NamedDecl *ND = dyn_cast<NamedDecl>(D);
 406   if (ND && ND->getExplicitVisibility(NamedDecl::VisibilityForValue))
 407     return;
 408
 409   VisStack *Stack = static_cast<VisStack*>(VisContext);
 410   unsigned rawType = Stack->back().first;
 411   if (rawType == NoVisibility) return;
 412
 413   VisibilityAttr::VisibilityType type
 414     = (VisibilityAttr::VisibilityType) rawType;
 415   SourceLocation loc = Stack->back().second;
 416
 417   D->addAttr(VisibilityAttr::CreateImplicit(Context, type, loc));
 418 }
 419
 420 /// FreeVisContext - Deallocate and null out VisContext.
 421 void Sema::FreeVisContext() {
 422   delete static_cast<VisStack*>(VisContext);
 423   VisContext = nullptr;
 424 }
 425
 426 static void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc) {
 427   // Put visibility on stack.
 428   if (!S.VisContext)
 429     S.VisContext = new VisStack;
 430
 431   VisStack *Stack = static_cast<VisStack*>(S.VisContext);
 432   Stack->push_back(std::make_pair(type, loc));
 433 }
 434
 435 void Sema::ActOnPragmaVisibility(const IdentifierInfo* VisType,
 436                                  SourceLocation PragmaLoc) {
 437   if (VisType) {
 438     // Compute visibility to use.
 439     VisibilityAttr::VisibilityType T;
 440     if (!VisibilityAttr::ConvertStrToVisibilityType(VisType->getName(), T)) {
 441       Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType;
 442       return;
 443     }
 444     PushPragmaVisibility(*this, T, PragmaLoc);
 445   } else {
 446     PopPragmaVisibility(false, PragmaLoc);
 447   }
 448 }
 449
 450 void Sema::ActOnPragmaFPContract(tok::OnOffSwitch OOS) {
 451   switch (OOS) {
 452   case tok::OOS_ON:
 453     FPFeatures.fp_contract = 1;
 454     break;
 455   case tok::OOS_OFF:
 456     FPFeatures.fp_contract = 0;
 457     break;
 458   case tok::OOS_DEFAULT:
 459     FPFeatures.fp_contract = getLangOpts().DefaultFPContract;
 460     break;
 461   }
 462 }
 463
 464 void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
 465                                        SourceLocation Loc) {
 466   // Visibility calculations will consider the namespace's visibility.
 467   // Here we just want to note that we're in a visibility context
 468   // which overrides any enclosing #pragma context, but doesn't itself
 469   // contribute visibility.
 470   PushPragmaVisibility(*this, NoVisibility, Loc);
 471 }
 472
 473 void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) {
 474   if (!VisContext) {
 475     Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
 476     return;
 477   }
 478
 479   // Pop visibility from stack
 480   VisStack *Stack = static_cast<VisStack*>(VisContext);
 481
 482   const std::pair<unsigned, SourceLocation> *Back = &Stack->back();
 483   bool StartsWithPragma = Back->first != NoVisibility;
 484   if (StartsWithPragma && IsNamespaceEnd) {
 485     Diag(Back->second, diag::err_pragma_push_visibility_mismatch);
 486     Diag(EndLoc, diag::note_surrounding_namespace_ends_here);
 487
 488     // For better error recovery, eat all pushes inside the namespace.
 489     do {
 490       Stack->pop_back();
 491       Back = &Stack->back();
 492       StartsWithPragma = Back->first != NoVisibility;
 493     } while (StartsWithPragma);
 494   } else if (!StartsWithPragma && !IsNamespaceEnd) {
 495     Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
 496     Diag(Back->second, diag::note_surrounding_namespace_starts_here);
 497     return;
 498   }
 499
 500   Stack->pop_back();
 501   // To simplify the implementation, never keep around an empty stack.
 502   if (Stack->empty())
 503     FreeVisContext();
 504 }