SemaAttr.cpp revision 234353
1193326Sed//===--- SemaAttr.cpp - Semantic Analysis for Attributes ------------------===// 2193326Sed// 3193326Sed// The LLVM Compiler Infrastructure 4193326Sed// 5193326Sed// This file is distributed under the University of Illinois Open Source 6193326Sed// License. See LICENSE.TXT for details. 7193326Sed// 8193326Sed//===----------------------------------------------------------------------===// 9193326Sed// 10193326Sed// This file implements semantic analysis for non-trivial attributes and 11193326Sed// pragmas. 12193326Sed// 13193326Sed//===----------------------------------------------------------------------===// 14193326Sed 15212904Sdim#include "clang/Sema/SemaInternal.h" 16212904Sdim#include "clang/Sema/Lookup.h" 17212904Sdim#include "clang/AST/Attr.h" 18193326Sed#include "clang/AST/Expr.h" 19208600Srdivacky#include "clang/Basic/TargetInfo.h" 20208600Srdivacky#include "clang/Lex/Preprocessor.h" 21193326Sedusing namespace clang; 22193326Sed 23193326Sed//===----------------------------------------------------------------------===// 24208600Srdivacky// Pragma 'pack' and 'options align' 25193326Sed//===----------------------------------------------------------------------===// 26193326Sed 27193326Sednamespace { 28208600Srdivacky struct PackStackEntry { 29208600Srdivacky // We just use a sentinel to represent when the stack is set to mac68k 30208600Srdivacky // alignment. 31208600Srdivacky static const unsigned kMac68kAlignmentSentinel = ~0U; 32208600Srdivacky 33208600Srdivacky unsigned Alignment; 34208600Srdivacky IdentifierInfo *Name; 35208600Srdivacky }; 36208600Srdivacky 37193326Sed /// PragmaPackStack - Simple class to wrap the stack used by #pragma 38193326Sed /// pack. 39193326Sed class PragmaPackStack { 40208600Srdivacky typedef std::vector<PackStackEntry> stack_ty; 41193326Sed 42193326Sed /// Alignment - The current user specified alignment. 43193326Sed unsigned Alignment; 44193326Sed 45193326Sed /// Stack - Entries in the #pragma pack stack, consisting of saved 46193326Sed /// alignments and optional names. 47193326Sed stack_ty Stack; 48198092Srdivacky 49198092Srdivacky public: 50193326Sed PragmaPackStack() : Alignment(0) {} 51193326Sed 52193326Sed void setAlignment(unsigned A) { Alignment = A; } 53193326Sed unsigned getAlignment() { return Alignment; } 54193326Sed 55193326Sed /// push - Push the current alignment onto the stack, optionally 56193326Sed /// using the given \arg Name for the record, if non-zero. 57193326Sed void push(IdentifierInfo *Name) { 58208600Srdivacky PackStackEntry PSE = { Alignment, Name }; 59208600Srdivacky Stack.push_back(PSE); 60193326Sed } 61193326Sed 62193326Sed /// pop - Pop a record from the stack and restore the current 63193326Sed /// alignment to the previous value. If \arg Name is non-zero then 64193326Sed /// the first such named record is popped, otherwise the top record 65193326Sed /// is popped. Returns true if the pop succeeded. 66212904Sdim bool pop(IdentifierInfo *Name, bool IsReset); 67193326Sed }; 68193326Sed} // end anonymous namespace. 69193326Sed 70212904Sdimbool PragmaPackStack::pop(IdentifierInfo *Name, bool IsReset) { 71193326Sed // If name is empty just pop top. 72193326Sed if (!Name) { 73212904Sdim // An empty stack is a special case... 74212904Sdim if (Stack.empty()) { 75212904Sdim // If this isn't a reset, it is always an error. 76212904Sdim if (!IsReset) 77212904Sdim return false; 78212904Sdim 79212904Sdim // Otherwise, it is an error only if some alignment has been set. 80212904Sdim if (!Alignment) 81212904Sdim return false; 82212904Sdim 83212904Sdim // Otherwise, reset to the default alignment. 84212904Sdim Alignment = 0; 85212904Sdim } else { 86212904Sdim Alignment = Stack.back().Alignment; 87212904Sdim Stack.pop_back(); 88212904Sdim } 89212904Sdim 90193326Sed return true; 91198092Srdivacky } 92198092Srdivacky 93193326Sed // Otherwise, find the named record. 94193326Sed for (unsigned i = Stack.size(); i != 0; ) { 95193326Sed --i; 96208600Srdivacky if (Stack[i].Name == Name) { 97193326Sed // Found it, pop up to and including this record. 98208600Srdivacky Alignment = Stack[i].Alignment; 99193326Sed Stack.erase(Stack.begin() + i, Stack.end()); 100193326Sed return true; 101193326Sed } 102193326Sed } 103198092Srdivacky 104193326Sed return false; 105193326Sed} 106193326Sed 107193326Sed 108193326Sed/// FreePackedContext - Deallocate and null out PackContext. 109193326Sedvoid Sema::FreePackedContext() { 110193326Sed delete static_cast<PragmaPackStack*>(PackContext); 111193326Sed PackContext = 0; 112193326Sed} 113193326Sed 114208600Srdivackyvoid Sema::AddAlignmentAttributesForRecord(RecordDecl *RD) { 115208600Srdivacky // If there is no pack context, we don't need any attributes. 116208600Srdivacky if (!PackContext) 117208600Srdivacky return; 118208600Srdivacky 119208600Srdivacky PragmaPackStack *Stack = static_cast<PragmaPackStack*>(PackContext); 120208600Srdivacky 121208600Srdivacky // Otherwise, check to see if we need a max field alignment attribute. 122208600Srdivacky if (unsigned Alignment = Stack->getAlignment()) { 123208600Srdivacky if (Alignment == PackStackEntry::kMac68kAlignmentSentinel) 124212904Sdim RD->addAttr(::new (Context) AlignMac68kAttr(SourceLocation(), Context)); 125208600Srdivacky else 126212904Sdim RD->addAttr(::new (Context) MaxFieldAlignmentAttr(SourceLocation(), 127212904Sdim Context, 128212904Sdim Alignment * 8)); 129208600Srdivacky } 130193326Sed} 131193326Sed 132221345Sdimvoid Sema::AddMsStructLayoutForRecord(RecordDecl *RD) { 133221345Sdim if (!MSStructPragmaOn) 134221345Sdim return; 135221345Sdim RD->addAttr(::new (Context) MsStructAttr(SourceLocation(), Context)); 136221345Sdim} 137221345Sdim 138208600Srdivackyvoid Sema::ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind, 139208600Srdivacky SourceLocation PragmaLoc, 140208600Srdivacky SourceLocation KindLoc) { 141208600Srdivacky if (PackContext == 0) 142208600Srdivacky PackContext = new PragmaPackStack(); 143208600Srdivacky 144208600Srdivacky PragmaPackStack *Context = static_cast<PragmaPackStack*>(PackContext); 145208600Srdivacky 146212904Sdim // Reset just pops the top of the stack, or resets the current alignment to 147212904Sdim // default. 148212904Sdim if (Kind == Sema::POAK_Reset) { 149212904Sdim if (!Context->pop(0, /*IsReset=*/true)) { 150208600Srdivacky Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed) 151208600Srdivacky << "stack empty"; 152208600Srdivacky } 153208600Srdivacky return; 154208600Srdivacky } 155208600Srdivacky 156208600Srdivacky switch (Kind) { 157210299Sed // For all targets we support native and natural are the same. 158210299Sed // 159210299Sed // FIXME: This is not true on Darwin/PPC. 160210299Sed case POAK_Native: 161210299Sed case POAK_Power: 162208600Srdivacky case POAK_Natural: 163208600Srdivacky Context->push(0); 164208600Srdivacky Context->setAlignment(0); 165208600Srdivacky break; 166208600Srdivacky 167210299Sed // Note that '#pragma options align=packed' is not equivalent to attribute 168210299Sed // packed, it has a different precedence relative to attribute aligned. 169210299Sed case POAK_Packed: 170210299Sed Context->push(0); 171210299Sed Context->setAlignment(1); 172210299Sed break; 173210299Sed 174208600Srdivacky case POAK_Mac68k: 175208600Srdivacky // Check if the target supports this. 176208600Srdivacky if (!PP.getTargetInfo().hasAlignMac68kSupport()) { 177208600Srdivacky Diag(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported); 178208600Srdivacky return; 179208600Srdivacky } 180208600Srdivacky Context->push(0); 181208600Srdivacky Context->setAlignment(PackStackEntry::kMac68kAlignmentSentinel); 182208600Srdivacky break; 183208600Srdivacky 184208600Srdivacky default: 185208600Srdivacky Diag(PragmaLoc, diag::warn_pragma_options_align_unsupported_option) 186208600Srdivacky << KindLoc; 187208600Srdivacky break; 188208600Srdivacky } 189208600Srdivacky} 190208600Srdivacky 191198092Srdivackyvoid Sema::ActOnPragmaPack(PragmaPackKind Kind, IdentifierInfo *Name, 192226633Sdim Expr *alignment, SourceLocation PragmaLoc, 193193326Sed SourceLocation LParenLoc, SourceLocation RParenLoc) { 194193326Sed Expr *Alignment = static_cast<Expr *>(alignment); 195193326Sed 196193326Sed // If specified then alignment must be a "small" power of two. 197193326Sed unsigned AlignmentVal = 0; 198193326Sed if (Alignment) { 199193326Sed llvm::APSInt Val; 200198092Srdivacky 201193326Sed // pack(0) is like pack(), which just works out since that is what 202193326Sed // we use 0 for in PackAttr. 203208600Srdivacky if (Alignment->isTypeDependent() || 204208600Srdivacky Alignment->isValueDependent() || 205208600Srdivacky !Alignment->isIntegerConstantExpr(Val, Context) || 206193326Sed !(Val == 0 || Val.isPowerOf2()) || 207193326Sed Val.getZExtValue() > 16) { 208193326Sed Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment); 209193326Sed return; // Ignore 210193326Sed } 211193326Sed 212193326Sed AlignmentVal = (unsigned) Val.getZExtValue(); 213193326Sed } 214198092Srdivacky 215193326Sed if (PackContext == 0) 216193326Sed PackContext = new PragmaPackStack(); 217198092Srdivacky 218193326Sed PragmaPackStack *Context = static_cast<PragmaPackStack*>(PackContext); 219198092Srdivacky 220193326Sed switch (Kind) { 221212904Sdim case Sema::PPK_Default: // pack([n]) 222193326Sed Context->setAlignment(AlignmentVal); 223193326Sed break; 224193326Sed 225212904Sdim case Sema::PPK_Show: // pack(show) 226193326Sed // Show the current alignment, making sure to show the right value 227193326Sed // for the default. 228193326Sed AlignmentVal = Context->getAlignment(); 229193326Sed // FIXME: This should come from the target. 230193326Sed if (AlignmentVal == 0) 231193326Sed AlignmentVal = 8; 232208600Srdivacky if (AlignmentVal == PackStackEntry::kMac68kAlignmentSentinel) 233208600Srdivacky Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k"; 234208600Srdivacky else 235208600Srdivacky Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal; 236193326Sed break; 237193326Sed 238212904Sdim case Sema::PPK_Push: // pack(push [, id] [, [n]) 239193326Sed Context->push(Name); 240193326Sed // Set the new alignment if specified. 241193326Sed if (Alignment) 242198092Srdivacky Context->setAlignment(AlignmentVal); 243193326Sed break; 244193326Sed 245212904Sdim case Sema::PPK_Pop: // pack(pop [, id] [, n]) 246193326Sed // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack: 247193326Sed // "#pragma pack(pop, identifier, n) is undefined" 248193326Sed if (Alignment && Name) 249198092Srdivacky Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifer_and_alignment); 250198092Srdivacky 251193326Sed // Do the pop. 252212904Sdim if (!Context->pop(Name, /*IsReset=*/false)) { 253193326Sed // If a name was specified then failure indicates the name 254193326Sed // wasn't found. Otherwise failure indicates the stack was 255193326Sed // empty. 256193326Sed Diag(PragmaLoc, diag::warn_pragma_pack_pop_failed) 257193326Sed << (Name ? "no record matching name" : "stack empty"); 258193326Sed 259193326Sed // FIXME: Warn about popping named records as MSVC does. 260193326Sed } else { 261193326Sed // Pop succeeded, set the new alignment if specified. 262193326Sed if (Alignment) 263193326Sed Context->setAlignment(AlignmentVal); 264193326Sed } 265193326Sed break; 266193326Sed } 267193326Sed} 268193326Sed 269221345Sdimvoid Sema::ActOnPragmaMSStruct(PragmaMSStructKind Kind) { 270221345Sdim MSStructPragmaOn = (Kind == PMSST_ON); 271221345Sdim} 272221345Sdim 273218893Sdimvoid Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope, 274218893Sdim SourceLocation PragmaLoc) { 275198092Srdivacky 276218893Sdim IdentifierInfo *Name = IdTok.getIdentifierInfo(); 277218893Sdim LookupResult Lookup(*this, Name, IdTok.getLocation(), LookupOrdinaryName); 278218893Sdim LookupParsedName(Lookup, curScope, NULL, true); 279198092Srdivacky 280218893Sdim if (Lookup.empty()) { 281218893Sdim Diag(PragmaLoc, diag::warn_pragma_unused_undeclared_var) 282218893Sdim << Name << SourceRange(IdTok.getLocation()); 283218893Sdim return; 284218893Sdim } 285193326Sed 286218893Sdim VarDecl *VD = Lookup.getAsSingle<VarDecl>(); 287218893Sdim if (!VD) { 288218893Sdim Diag(PragmaLoc, diag::warn_pragma_unused_expected_var_arg) 289218893Sdim << Name << SourceRange(IdTok.getLocation()); 290218893Sdim return; 291218893Sdim } 292193326Sed 293218893Sdim // Warn if this was used before being marked unused. 294218893Sdim if (VD->isUsed()) 295218893Sdim Diag(PragmaLoc, diag::warn_used_but_marked_unused) << Name; 296218893Sdim 297218893Sdim VD->addAttr(::new (Context) UnusedAttr(IdTok.getLocation(), Context)); 298193326Sed} 299212904Sdim 300226633Sdimvoid Sema::AddCFAuditedAttribute(Decl *D) { 301226633Sdim SourceLocation Loc = PP.getPragmaARCCFCodeAuditedLoc(); 302226633Sdim if (!Loc.isValid()) return; 303226633Sdim 304226633Sdim // Don't add a redundant or conflicting attribute. 305226633Sdim if (D->hasAttr<CFAuditedTransferAttr>() || 306226633Sdim D->hasAttr<CFUnknownTransferAttr>()) 307226633Sdim return; 308226633Sdim 309226633Sdim D->addAttr(::new (Context) CFAuditedTransferAttr(Loc, Context)); 310226633Sdim} 311226633Sdim 312218893Sdimtypedef std::vector<std::pair<unsigned, SourceLocation> > VisStack; 313218893Sdimenum { NoVisibility = (unsigned) -1 }; 314212904Sdim 315212904Sdimvoid Sema::AddPushedVisibilityAttribute(Decl *D) { 316212904Sdim if (!VisContext) 317212904Sdim return; 318212904Sdim 319221345Sdim if (isa<NamedDecl>(D) && cast<NamedDecl>(D)->getExplicitVisibility()) 320212904Sdim return; 321212904Sdim 322212904Sdim VisStack *Stack = static_cast<VisStack*>(VisContext); 323218893Sdim unsigned rawType = Stack->back().first; 324218893Sdim if (rawType == NoVisibility) return; 325218893Sdim 326218893Sdim VisibilityAttr::VisibilityType type 327218893Sdim = (VisibilityAttr::VisibilityType) rawType; 328212904Sdim SourceLocation loc = Stack->back().second; 329212904Sdim 330212904Sdim D->addAttr(::new (Context) VisibilityAttr(loc, Context, type)); 331212904Sdim} 332212904Sdim 333212904Sdim/// FreeVisContext - Deallocate and null out VisContext. 334212904Sdimvoid Sema::FreeVisContext() { 335212904Sdim delete static_cast<VisStack*>(VisContext); 336212904Sdim VisContext = 0; 337212904Sdim} 338212904Sdim 339218893Sdimstatic void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc) { 340212904Sdim // Put visibility on stack. 341212904Sdim if (!S.VisContext) 342212904Sdim S.VisContext = new VisStack; 343212904Sdim 344212904Sdim VisStack *Stack = static_cast<VisStack*>(S.VisContext); 345212904Sdim Stack->push_back(std::make_pair(type, loc)); 346212904Sdim} 347212904Sdim 348234353Sdimvoid Sema::ActOnPragmaVisibility(const IdentifierInfo* VisType, 349212904Sdim SourceLocation PragmaLoc) { 350234353Sdim if (VisType) { 351212904Sdim // Compute visibility to use. 352212904Sdim VisibilityAttr::VisibilityType type; 353212904Sdim if (VisType->isStr("default")) 354212904Sdim type = VisibilityAttr::Default; 355212904Sdim else if (VisType->isStr("hidden")) 356212904Sdim type = VisibilityAttr::Hidden; 357212904Sdim else if (VisType->isStr("internal")) 358212904Sdim type = VisibilityAttr::Hidden; // FIXME 359212904Sdim else if (VisType->isStr("protected")) 360212904Sdim type = VisibilityAttr::Protected; 361212904Sdim else { 362212904Sdim Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << 363212904Sdim VisType->getName(); 364212904Sdim return; 365212904Sdim } 366212904Sdim PushPragmaVisibility(*this, type, PragmaLoc); 367212904Sdim } else { 368234353Sdim PopPragmaVisibility(false, PragmaLoc); 369212904Sdim } 370212904Sdim} 371212904Sdim 372218893Sdimvoid Sema::ActOnPragmaFPContract(tok::OnOffSwitch OOS) { 373218893Sdim switch (OOS) { 374218893Sdim case tok::OOS_ON: 375218893Sdim FPFeatures.fp_contract = 1; 376218893Sdim break; 377218893Sdim case tok::OOS_OFF: 378218893Sdim FPFeatures.fp_contract = 0; 379218893Sdim break; 380218893Sdim case tok::OOS_DEFAULT: 381234353Sdim FPFeatures.fp_contract = getLangOpts().DefaultFPContract; 382218893Sdim break; 383218893Sdim } 384212904Sdim} 385212904Sdim 386234353Sdimvoid Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr, 387234353Sdim SourceLocation Loc) { 388218893Sdim // Visibility calculations will consider the namespace's visibility. 389218893Sdim // Here we just want to note that we're in a visibility context 390218893Sdim // which overrides any enclosing #pragma context, but doesn't itself 391218893Sdim // contribute visibility. 392234353Sdim PushPragmaVisibility(*this, NoVisibility, Loc); 393218893Sdim} 394218893Sdim 395234353Sdimvoid Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) { 396234353Sdim if (!VisContext) { 397234353Sdim Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch); 398234353Sdim return; 399234353Sdim } 400212904Sdim 401234353Sdim // Pop visibility from stack 402234353Sdim VisStack *Stack = static_cast<VisStack*>(VisContext); 403234353Sdim 404234353Sdim const std::pair<unsigned, SourceLocation> *Back = &Stack->back(); 405234353Sdim bool StartsWithPragma = Back->first != NoVisibility; 406234353Sdim if (StartsWithPragma && IsNamespaceEnd) { 407234353Sdim Diag(Back->second, diag::err_pragma_push_visibility_mismatch); 408234353Sdim Diag(EndLoc, diag::note_surrounding_namespace_ends_here); 409234353Sdim 410234353Sdim // For better error recovery, eat all pushes inside the namespace. 411234353Sdim do { 412234353Sdim Stack->pop_back(); 413234353Sdim Back = &Stack->back(); 414234353Sdim StartsWithPragma = Back->first != NoVisibility; 415234353Sdim } while (StartsWithPragma); 416234353Sdim } else if (!StartsWithPragma && !IsNamespaceEnd) { 417234353Sdim Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch); 418234353Sdim Diag(Back->second, diag::note_surrounding_namespace_starts_here); 419234353Sdim return; 420212904Sdim } 421234353Sdim 422234353Sdim Stack->pop_back(); 423234353Sdim // To simplify the implementation, never keep around an empty stack. 424234353Sdim if (Stack->empty()) 425234353Sdim FreeVisContext(); 426212904Sdim} 427