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"
22using namespace clang;
23
24//===----------------------------------------------------------------------===//
25// Pragma 'pack' and 'options align'
26//===----------------------------------------------------------------------===//
27
28namespace {
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
71bool 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.
110void Sema::FreePackedContext() {
111  delete static_cast<PragmaPackStack*>(PackContext);
112  PackContext = nullptr;
113}
114
115void 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
132void 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
144void 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
190void 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
268void Sema::ActOnPragmaMSStruct(PragmaMSStructKind Kind) {
269  MSStructPragmaOn = (Kind == PMSST_ON);
270}
271
272void 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
291void Sema::ActOnPragmaDetectMismatch(StringRef Name, StringRef Value) {
292  // FIXME: Serialize this.
293  Consumer.HandleDetectMismatch(Name, Value);
294}
295
296void Sema::ActOnPragmaMSPointersToMembers(
297    LangOptions::PragmaMSPointersToMembersKind RepresentationMethod,
298    SourceLocation PragmaLoc) {
299  MSPointerToMemberRepresentationMethod = RepresentationMethod;
300  ImplicitMSInheritanceAttrLoc = PragmaLoc;
301}
302
303void 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
328template<typename ValueType>
329void 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
363bool 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
390bool 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().
411void 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().
429void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation,
430                                int SectionFlags, StringLiteral *SegmentName) {
431  UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation);
432}
433
434void 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
461void 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
473void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) {
474  if(On)
475    OptimizeOffPragmaLocation = SourceLocation();
476  else
477    OptimizeOffPragmaLocation = PragmaLoc;
478}
479
480void 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
487void 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
501typedef std::vector<std::pair<unsigned, SourceLocation> > VisStack;
502enum : unsigned { NoVisibility = ~0U };
503
504void 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.
524void Sema::FreeVisContext() {
525  delete static_cast<VisStack*>(VisContext);
526  VisContext = nullptr;
527}
528
529static 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
538void 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
553void 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
567void 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
576void 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