head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.11 netbsd-11-0-RC3:1.1.1.11 netbsd-11-0-RC2:1.1.1.11 netbsd-11-0-RC1:1.1.1.11 perseant-exfatfs-base-20250801:1.1.1.11 netbsd-11:1.1.1.11.0.10 netbsd-11-base:1.1.1.11 netbsd-10-1-RELEASE:1.1.1.11 perseant-exfatfs-base-20240630:1.1.1.11 perseant-exfatfs:1.1.1.11.0.8 perseant-exfatfs-base:1.1.1.11 netbsd-8-3-RELEASE:1.1.1.8 netbsd-9-4-RELEASE:1.1.1.10 netbsd-10-0-RELEASE:1.1.1.11 netbsd-10-0-RC6:1.1.1.11 netbsd-10-0-RC5:1.1.1.11 netbsd-10-0-RC4:1.1.1.11 netbsd-10-0-RC3:1.1.1.11 netbsd-10-0-RC2:1.1.1.11 netbsd-10-0-RC1:1.1.1.11 netbsd-10:1.1.1.11.0.6 netbsd-10-base:1.1.1.11 netbsd-9-3-RELEASE:1.1.1.10 cjep_sun2x:1.1.1.11.0.4 cjep_sun2x-base:1.1.1.11 cjep_staticlib_x-base1:1.1.1.11 netbsd-9-2-RELEASE:1.1.1.10 cjep_staticlib_x:1.1.1.11.0.2 cjep_staticlib_x-base:1.1.1.11 netbsd-9-1-RELEASE:1.1.1.10 phil-wifi-20200421:1.1.1.11 phil-wifi-20200411:1.1.1.11 phil-wifi-20200406:1.1.1.11 netbsd-8-2-RELEASE:1.1.1.8 netbsd-9-0-RELEASE:1.1.1.10 netbsd-9-0-RC2:1.1.1.10 netbsd-9-0-RC1:1.1.1.10 netbsd-9:1.1.1.10.0.2 netbsd-9-base:1.1.1.10 phil-wifi-20190609:1.1.1.10 netbsd-8-1-RELEASE:1.1.1.8 netbsd-8-1-RC1:1.1.1.8 pgoyette-compat-merge-20190127:1.1.1.9.2.1 pgoyette-compat-20190127:1.1.1.10 pgoyette-compat-20190118:1.1.1.10 pgoyette-compat-1226:1.1.1.10 pgoyette-compat-1126:1.1.1.10 pgoyette-compat-1020:1.1.1.10 pgoyette-compat-0930:1.1.1.10 pgoyette-compat-0906:1.1.1.10 netbsd-7-2-RELEASE:1.1.1.5.2.1 pgoyette-compat-0728:1.1.1.10 clang-337282:1.1.1.10 netbsd-8-0-RELEASE:1.1.1.8 phil-wifi:1.1.1.9.0.4 phil-wifi-base:1.1.1.9 pgoyette-compat-0625:1.1.1.9 netbsd-8-0-RC2:1.1.1.8 pgoyette-compat-0521:1.1.1.9 pgoyette-compat-0502:1.1.1.9 pgoyette-compat-0422:1.1.1.9 netbsd-8-0-RC1:1.1.1.8 pgoyette-compat-0415:1.1.1.9 pgoyette-compat-0407:1.1.1.9 pgoyette-compat-0330:1.1.1.9 pgoyette-compat-0322:1.1.1.9 pgoyette-compat-0315:1.1.1.9 netbsd-7-1-2-RELEASE:1.1.1.5.2.1 pgoyette-compat:1.1.1.9.0.2 pgoyette-compat-base:1.1.1.9 netbsd-7-1-1-RELEASE:1.1.1.5.2.1 clang-319952:1.1.1.9 matt-nb8-mediatek:1.1.1.8.0.10 matt-nb8-mediatek-base:1.1.1.8 clang-309604:1.1.1.9 perseant-stdc-iso10646:1.1.1.8.0.8 perseant-stdc-iso10646-base:1.1.1.8 netbsd-8:1.1.1.8.0.6 netbsd-8-base:1.1.1.8 prg-localcount2-base3:1.1.1.8 prg-localcount2-base2:1.1.1.8 prg-localcount2-base1:1.1.1.8 prg-localcount2:1.1.1.8.0.4 prg-localcount2-base:1.1.1.8 pgoyette-localcount-20170426:1.1.1.8 bouyer-socketcan-base1:1.1.1.8 pgoyette-localcount-20170320:1.1.1.8 netbsd-7-1:1.1.1.5.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.5.2.1 netbsd-7-1-RC2:1.1.1.5.2.1 clang-294123:1.1.1.8 netbsd-7-nhusb-base-20170116:1.1.1.5.2.1 bouyer-socketcan:1.1.1.8.0.2 bouyer-socketcan-base:1.1.1.8 clang-291444:1.1.1.8 pgoyette-localcount-20170107:1.1.1.7 netbsd-7-1-RC1:1.1.1.5.2.1 pgoyette-localcount-20161104:1.1.1.7 netbsd-7-0-2-RELEASE:1.1.1.5.2.1 localcount-20160914:1.1.1.7 netbsd-7-nhusb:1.1.1.5.2.1.0.4 netbsd-7-nhusb-base:1.1.1.5.2.1 clang-280599:1.1.1.7 pgoyette-localcount-20160806:1.1.1.7 pgoyette-localcount-20160726:1.1.1.7 pgoyette-localcount:1.1.1.7.0.2 pgoyette-localcount-base:1.1.1.7 netbsd-7-0-1-RELEASE:1.1.1.5.2.1 clang-261930:1.1.1.7 netbsd-7-0:1.1.1.5.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.5.2.1 netbsd-7-0-RC3:1.1.1.5.2.1 netbsd-7-0-RC2:1.1.1.5.2.1 netbsd-7-0-RC1:1.1.1.5.2.1 clang-237755:1.1.1.6 clang-232565:1.1.1.6 clang-227398:1.1.1.6 tls-maxphys-base:1.1.1.5 tls-maxphys:1.1.1.5.0.4 netbsd-7:1.1.1.5.0.2 netbsd-7-base:1.1.1.5 clang-215315:1.1.1.5 clang-209886:1.1.1.4 yamt-pagecache:1.1.1.3.0.4 yamt-pagecache-base9:1.1.1.3 tls-earlyentropy:1.1.1.3.0.2 tls-earlyentropy-base:1.1.1.4 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.3 riastradh-drm2-base3:1.1.1.3 clang-202566:1.1.1.3 clang-201163:1.1.1.2 clang-199312:1.1.1.1 clang-198450:1.1.1.1 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.49; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.02.14.20.07.19; author joerg; state Exp; branches; next 1.1.1.3; commitid annVkZ1sc17rF6px; 1.1.1.3 date 2014.03.04.19.54.10; author joerg; state Exp; branches 1.1.1.3.2.1 1.1.1.3.4.1; next 1.1.1.4; commitid 29z1hJonZISIXprx; 1.1.1.4 date 2014.05.30.18.14.42; author joerg; state Exp; branches; next 1.1.1.5; commitid 8q0kdlBlCn09GACx; 1.1.1.5 date 2014.08.10.17.08.28; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid N85tXAN6Ex9VZPLx; 1.1.1.6 date 2015.01.29.19.57.29; author joerg; state Exp; branches; next 1.1.1.7; commitid mlISSizlPKvepX7y; 1.1.1.7 date 2016.02.27.22.11.56; author joerg; state Exp; branches 1.1.1.7.2.1; next 1.1.1.8; commitid tIimz3oDlh1NpBWy; 1.1.1.8 date 2017.01.11.10.34.07; author joerg; state Exp; branches; next 1.1.1.9; commitid CNnUNfII1jgNmxBz; 1.1.1.9 date 2017.08.01.19.35.02; author joerg; state Exp; branches 1.1.1.9.2.1 1.1.1.9.4.1; next 1.1.1.10; commitid pMuDy65V0VicSx1A; 1.1.1.10 date 2018.07.17.18.31.20; author joerg; state Exp; branches; next 1.1.1.11; commitid wDzL46ALjrCZgwKA; 1.1.1.11 date 2019.11.13.22.19.26; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.3.2.1 date 2014.08.10.07.08.09; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.3.4.1 date 2014.03.04.19.54.10; author yamt; state dead; branches; next 1.1.1.3.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.3.4.2 date 2014.05.22.16.18.29; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.2.1 date 2015.06.04.20.04.29; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.5.4.1 date 2014.08.10.17.08.28; author tls; state dead; branches; next 1.1.1.5.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.5.4.2 date 2014.08.19.23.47.30; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.2.1 date 2017.03.20.06.52.40; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.9.2.1 date 2018.07.28.04.33.21; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.9.4.1 date 2019.06.10.21.45.26; author christos; state Exp; branches; next 1.1.1.9.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.9.4.2 date 2020.04.13.07.46.36; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- SemaAttr.cpp - Semantic Analysis for Attributes ------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements semantic analysis for non-trivial attributes and // pragmas. // //===----------------------------------------------------------------------===// #include "clang/Sema/SemaInternal.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/Attr.h" #include "clang/AST/Expr.h" #include "clang/Basic/TargetInfo.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/Lookup.h" using namespace clang; //===----------------------------------------------------------------------===// // Pragma 'pack' and 'options align' //===----------------------------------------------------------------------===// namespace { struct PackStackEntry { // We just use a sentinel to represent when the stack is set to mac68k // alignment. static const unsigned kMac68kAlignmentSentinel = ~0U; unsigned Alignment; IdentifierInfo *Name; }; /// PragmaPackStack - Simple class to wrap the stack used by #pragma /// pack. class PragmaPackStack { typedef std::vector stack_ty; /// Alignment - The current user specified alignment. unsigned Alignment; /// Stack - Entries in the #pragma pack stack, consisting of saved /// alignments and optional names. stack_ty Stack; public: PragmaPackStack() : Alignment(0) {} void setAlignment(unsigned A) { Alignment = A; } unsigned getAlignment() { return Alignment; } /// push - Push the current alignment onto the stack, optionally /// using the given \arg Name for the record, if non-zero. void push(IdentifierInfo *Name) { PackStackEntry PSE = { Alignment, Name }; Stack.push_back(PSE); } /// pop - Pop a record from the stack and restore the current /// alignment to the previous value. If \arg Name is non-zero then /// the first such named record is popped, otherwise the top record /// is popped. Returns true if the pop succeeded. bool pop(IdentifierInfo *Name, bool IsReset); }; } // end anonymous namespace. bool PragmaPackStack::pop(IdentifierInfo *Name, bool IsReset) { // If name is empty just pop top. if (!Name) { // An empty stack is a special case... if (Stack.empty()) { // If this isn't a reset, it is always an error. if (!IsReset) return false; // Otherwise, it is an error only if some alignment has been set. if (!Alignment) return false; // Otherwise, reset to the default alignment. Alignment = 0; } else { Alignment = Stack.back().Alignment; Stack.pop_back(); } return true; } // Otherwise, find the named record. for (unsigned i = Stack.size(); i != 0; ) { --i; if (Stack[i].Name == Name) { // Found it, pop up to and including this record. Alignment = Stack[i].Alignment; Stack.erase(Stack.begin() + i, Stack.end()); return true; } } return false; } /// FreePackedContext - Deallocate and null out PackContext. void Sema::FreePackedContext() { delete static_cast(PackContext); PackContext = 0; } void Sema::AddAlignmentAttributesForRecord(RecordDecl *RD) { // If there is no pack context, we don't need any attributes. if (!PackContext) return; PragmaPackStack *Stack = static_cast(PackContext); // Otherwise, check to see if we need a max field alignment attribute. if (unsigned Alignment = Stack->getAlignment()) { if (Alignment == PackStackEntry::kMac68kAlignmentSentinel) RD->addAttr(::new (Context) AlignMac68kAttr(SourceLocation(), Context)); else RD->addAttr(::new (Context) MaxFieldAlignmentAttr(SourceLocation(), Context, Alignment * 8)); } } void Sema::AddMsStructLayoutForRecord(RecordDecl *RD) { if (!MSStructPragmaOn) return; RD->addAttr(::new (Context) MsStructAttr(SourceLocation(), Context)); } void Sema::ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind, SourceLocation PragmaLoc) { if (PackContext == 0) PackContext = new PragmaPackStack(); PragmaPackStack *Context = static_cast(PackContext); switch (Kind) { // For all targets we support native and natural are the same. // // FIXME: This is not true on Darwin/PPC. case POAK_Native: case POAK_Power: case POAK_Natural: Context->push(0); Context->setAlignment(0); break; // Note that '#pragma options align=packed' is not equivalent to attribute // packed, it has a different precedence relative to attribute aligned. case POAK_Packed: Context->push(0); Context->setAlignment(1); break; case POAK_Mac68k: // Check if the target supports this. if (!PP.getTargetInfo().hasAlignMac68kSupport()) { Diag(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported); return; } Context->push(0); Context->setAlignment(PackStackEntry::kMac68kAlignmentSentinel); break; case POAK_Reset: // Reset just pops the top of the stack, or resets the current alignment to // default. if (!Context->pop(0, /*IsReset=*/true)) { Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed) << "stack empty"; } break; } } void Sema::ActOnPragmaPack(PragmaPackKind Kind, IdentifierInfo *Name, Expr *alignment, SourceLocation PragmaLoc, SourceLocation LParenLoc, SourceLocation RParenLoc) { Expr *Alignment = static_cast(alignment); // If specified then alignment must be a "small" power of two. unsigned AlignmentVal = 0; if (Alignment) { llvm::APSInt Val; // pack(0) is like pack(), which just works out since that is what // we use 0 for in PackAttr. if (Alignment->isTypeDependent() || Alignment->isValueDependent() || !Alignment->isIntegerConstantExpr(Val, Context) || !(Val == 0 || Val.isPowerOf2()) || Val.getZExtValue() > 16) { Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment); return; // Ignore } AlignmentVal = (unsigned) Val.getZExtValue(); } if (PackContext == 0) PackContext = new PragmaPackStack(); PragmaPackStack *Context = static_cast(PackContext); switch (Kind) { case Sema::PPK_Default: // pack([n]) Context->setAlignment(AlignmentVal); break; case Sema::PPK_Show: // pack(show) // Show the current alignment, making sure to show the right value // for the default. AlignmentVal = Context->getAlignment(); // FIXME: This should come from the target. if (AlignmentVal == 0) AlignmentVal = 8; if (AlignmentVal == PackStackEntry::kMac68kAlignmentSentinel) Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k"; else Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal; break; case Sema::PPK_Push: // pack(push [, id] [, [n]) Context->push(Name); // Set the new alignment if specified. if (Alignment) Context->setAlignment(AlignmentVal); break; case Sema::PPK_Pop: // pack(pop [, id] [, n]) // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack: // "#pragma pack(pop, identifier, n) is undefined" if (Alignment && Name) Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifer_and_alignment); // Do the pop. if (!Context->pop(Name, /*IsReset=*/false)) { // If a name was specified then failure indicates the name // wasn't found. Otherwise failure indicates the stack was // empty. Diag(PragmaLoc, diag::warn_pragma_pack_pop_failed) << (Name ? "no record matching name" : "stack empty"); // FIXME: Warn about popping named records as MSVC does. } else { // Pop succeeded, set the new alignment if specified. if (Alignment) Context->setAlignment(AlignmentVal); } break; } } void Sema::ActOnPragmaMSStruct(PragmaMSStructKind Kind) { MSStructPragmaOn = (Kind == PMSST_ON); } void Sema::ActOnPragmaMSComment(PragmaMSCommentKind Kind, StringRef Arg) { // FIXME: Serialize this. switch (Kind) { case PCK_Unknown: llvm_unreachable("unexpected pragma comment kind"); case PCK_Linker: Consumer.HandleLinkerOptionPragma(Arg); return; case PCK_Lib: Consumer.HandleDependentLibrary(Arg); return; case PCK_Compiler: case PCK_ExeStr: case PCK_User: return; // We ignore all of these. } llvm_unreachable("invalid pragma comment kind"); } void Sema::ActOnPragmaDetectMismatch(StringRef Name, StringRef Value) { // FIXME: Serialize this. Consumer.HandleDetectMismatch(Name, Value); } void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope, SourceLocation PragmaLoc) { IdentifierInfo *Name = IdTok.getIdentifierInfo(); LookupResult Lookup(*this, Name, IdTok.getLocation(), LookupOrdinaryName); LookupParsedName(Lookup, curScope, NULL, true); if (Lookup.empty()) { Diag(PragmaLoc, diag::warn_pragma_unused_undeclared_var) << Name << SourceRange(IdTok.getLocation()); return; } VarDecl *VD = Lookup.getAsSingle(); if (!VD) { Diag(PragmaLoc, diag::warn_pragma_unused_expected_var_arg) << Name << SourceRange(IdTok.getLocation()); return; } // Warn if this was used before being marked unused. if (VD->isUsed()) Diag(PragmaLoc, diag::warn_used_but_marked_unused) << Name; VD->addAttr(::new (Context) UnusedAttr(IdTok.getLocation(), Context)); } void Sema::AddCFAuditedAttribute(Decl *D) { SourceLocation Loc = PP.getPragmaARCCFCodeAuditedLoc(); if (!Loc.isValid()) return; // Don't add a redundant or conflicting attribute. if (D->hasAttr() || D->hasAttr()) return; D->addAttr(::new (Context) CFAuditedTransferAttr(Loc, Context)); } typedef std::vector > VisStack; enum { NoVisibility = (unsigned) -1 }; void Sema::AddPushedVisibilityAttribute(Decl *D) { if (!VisContext) return; NamedDecl *ND = dyn_cast(D); if (ND && ND->getExplicitVisibility(NamedDecl::VisibilityForValue)) return; VisStack *Stack = static_cast(VisContext); unsigned rawType = Stack->back().first; if (rawType == NoVisibility) return; VisibilityAttr::VisibilityType type = (VisibilityAttr::VisibilityType) rawType; SourceLocation loc = Stack->back().second; D->addAttr(::new (Context) VisibilityAttr(loc, Context, type)); } /// FreeVisContext - Deallocate and null out VisContext. void Sema::FreeVisContext() { delete static_cast(VisContext); VisContext = 0; } static void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc) { // Put visibility on stack. if (!S.VisContext) S.VisContext = new VisStack; VisStack *Stack = static_cast(S.VisContext); Stack->push_back(std::make_pair(type, loc)); } void Sema::ActOnPragmaVisibility(const IdentifierInfo* VisType, SourceLocation PragmaLoc) { if (VisType) { // Compute visibility to use. VisibilityAttr::VisibilityType T; if (!VisibilityAttr::ConvertStrToVisibilityType(VisType->getName(), T)) { Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType; return; } PushPragmaVisibility(*this, T, PragmaLoc); } else { PopPragmaVisibility(false, PragmaLoc); } } void Sema::ActOnPragmaFPContract(tok::OnOffSwitch OOS) { switch (OOS) { case tok::OOS_ON: FPFeatures.fp_contract = 1; break; case tok::OOS_OFF: FPFeatures.fp_contract = 0; break; case tok::OOS_DEFAULT: FPFeatures.fp_contract = getLangOpts().DefaultFPContract; break; } } void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr, SourceLocation Loc) { // Visibility calculations will consider the namespace's visibility. // Here we just want to note that we're in a visibility context // which overrides any enclosing #pragma context, but doesn't itself // contribute visibility. PushPragmaVisibility(*this, NoVisibility, Loc); } void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) { if (!VisContext) { Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch); return; } // Pop visibility from stack VisStack *Stack = static_cast(VisContext); const std::pair *Back = &Stack->back(); bool StartsWithPragma = Back->first != NoVisibility; if (StartsWithPragma && IsNamespaceEnd) { Diag(Back->second, diag::err_pragma_push_visibility_mismatch); Diag(EndLoc, diag::note_surrounding_namespace_ends_here); // For better error recovery, eat all pushes inside the namespace. do { Stack->pop_back(); Back = &Stack->back(); StartsWithPragma = Back->first != NoVisibility; } while (StartsWithPragma); } else if (!StartsWithPragma && !IsNamespaceEnd) { Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch); Diag(Back->second, diag::note_surrounding_namespace_starts_here); return; } Stack->pop_back(); // To simplify the implementation, never keep around an empty stack. if (Stack->empty()) FreeVisContext(); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import Clang 3.5svn r201163. @ text @d125 1 a125 1 RD->addAttr(AlignMac68kAttr::CreateImplicit(Context)); d127 2 a128 1 RD->addAttr(MaxFieldAlignmentAttr::CreateImplicit(Context, d136 1 a136 1 RD->addAttr(MsStructAttr::CreateImplicit(Context)); a290 7 void Sema::ActOnPragmaMSPointersToMembers( PragmaMSPointersToMembersKind RepresentationMethod, SourceLocation PragmaLoc) { MSPointerToMemberRepresentationMethod = RepresentationMethod; ImplicitMSInheritanceAttrLoc = PragmaLoc; } d315 1 a315 1 VD->addAttr(UnusedAttr::CreateImplicit(Context, IdTok.getLocation())); d327 1 a327 1 D->addAttr(CFAuditedTransferAttr::CreateImplicit(Context, Loc)); d331 1 a331 1 enum LLVM_ENUM_INT_TYPE(unsigned) { NoVisibility = ~0U }; d349 1 a349 1 D->addAttr(VisibilityAttr::CreateImplicit(Context, type, loc)); @ 1.1.1.3 log @Import Clang 3.5svn r202566. @ text @d133 3 a135 9 if (MSStructPragmaOn) RD->addAttr(MsStructAttr::CreateImplicit(Context)); // FIXME: We should merge AddAlignmentAttributesForRecord with // AddMsStructLayoutForRecord into AddPragmaAttributesForRecord, which takes // all active pragmas and applies them as attributes to class definitions. if (VtorDispModeStack.back() != getLangOpts().VtorDispMode) RD->addAttr( MSVtorDispAttr::CreateImplicit(Context, VtorDispModeStack.back())); d249 2 a250 2 Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << (Name ? "no record matching name" : "stack empty"); d291 1 a291 1 LangOptions::PragmaMSPointersToMembersKind RepresentationMethod, a296 25 void Sema::ActOnPragmaMSVtorDisp(PragmaVtorDispKind Kind, SourceLocation PragmaLoc, MSVtorDispAttr::Mode Mode) { switch (Kind) { case PVDK_Set: VtorDispModeStack.back() = Mode; break; case PVDK_Push: VtorDispModeStack.push_back(Mode); break; case PVDK_Reset: VtorDispModeStack.clear(); VtorDispModeStack.push_back(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)); break; case PVDK_Pop: VtorDispModeStack.pop_back(); if (VtorDispModeStack.empty()) { Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "vtordisp" << "stack empty"; VtorDispModeStack.push_back(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)); } break; } } @ 1.1.1.3.2.1 log @Rebase. @ text @d112 1 a112 1 PackContext = nullptr; d146 1 a146 1 if (!PackContext) d158 1 a158 1 Context->push(nullptr); d165 1 a165 1 Context->push(nullptr); d171 1 a171 1 if (!this->Context.getTargetInfo().hasAlignMac68kSupport()) { d175 1 a175 1 Context->push(nullptr); d182 1 a182 1 if (!Context->pop(nullptr, /*IsReset=*/true)) { d214 1 a214 1 if (!PackContext) a327 106 template void Sema::PragmaStack::Act(SourceLocation PragmaLocation, PragmaMsStackAction Action, llvm::StringRef StackSlotLabel, ValueType Value) { if (Action == PSK_Reset) { CurrentValue = nullptr; return; } if (Action & PSK_Push) Stack.push_back(Slot(StackSlotLabel, CurrentValue, CurrentPragmaLocation)); else if (Action & PSK_Pop) { if (!StackSlotLabel.empty()) { // If we've got a label, try to find it and jump there. auto I = std::find_if(Stack.rbegin(), Stack.rend(), [&](const Slot &x) { return x.StackSlotLabel == StackSlotLabel; }); // If we found the label so pop from there. if (I != Stack.rend()) { CurrentValue = I->Value; CurrentPragmaLocation = I->PragmaLocation; Stack.erase(std::prev(I.base()), Stack.end()); } } else if (!Stack.empty()) { // We don't have a label, just pop the last entry. CurrentValue = Stack.back().Value; CurrentPragmaLocation = Stack.back().PragmaLocation; Stack.pop_back(); } } if (Action & PSK_Set) { CurrentValue = Value; CurrentPragmaLocation = PragmaLocation; } } bool Sema::UnifySection(const StringRef &SectionName, int SectionFlags, DeclaratorDecl *Decl) { auto Section = SectionInfos.find(SectionName); if (Section == SectionInfos.end()) { SectionInfos[SectionName] = SectionInfo(Decl, SourceLocation(), SectionFlags); return false; } // A pre-declared section takes precedence w/o diagnostic. if (Section->second.SectionFlags == SectionFlags || !(Section->second.SectionFlags & PSF_Implicit)) return false; auto OtherDecl = Section->second.Decl; Diag(Decl->getLocation(), diag::err_section_conflict) << Decl << OtherDecl; Diag(OtherDecl->getLocation(), diag::note_declared_at) << OtherDecl->getName(); if (auto A = Decl->getAttr()) if (A->isImplicit()) Diag(A->getLocation(), diag::note_pragma_entered_here); if (auto A = OtherDecl->getAttr()) if (A->isImplicit()) Diag(A->getLocation(), diag::note_pragma_entered_here); return false; } bool Sema::UnifySection(const StringRef &SectionName, int SectionFlags, SourceLocation PragmaSectionLocation) { auto Section = SectionInfos.find(SectionName); if (Section != SectionInfos.end()) { if (Section->second.SectionFlags == SectionFlags) return false; if (!(Section->second.SectionFlags & PSF_Implicit)) { Diag(PragmaSectionLocation, diag::err_section_conflict) << "this" << "a prior #pragma section"; Diag(Section->second.PragmaSectionLocation, diag::note_pragma_entered_here); return true; } } SectionInfos[SectionName] = SectionInfo(nullptr, PragmaSectionLocation, SectionFlags); return false; } /// \brief Called on well formed \#pragma bss_seg(). void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation, PragmaMsStackAction Action, llvm::StringRef StackSlotLabel, StringLiteral *SegmentName, llvm::StringRef PragmaName) { PragmaStack *Stack = llvm::StringSwitch *>(PragmaName) .Case("data_seg", &DataSegStack) .Case("bss_seg", &BSSSegStack) .Case("const_seg", &ConstSegStack) .Case("code_seg", &CodeSegStack); if (Action & PSK_Pop && Stack->Stack.empty()) Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName << "stack empty"; Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName); } /// \brief Called on well formed \#pragma bss_seg(). void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation, int SectionFlags, StringLiteral *SegmentName) { UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation); } d333 1 a333 1 LookupParsedName(Lookup, curScope, nullptr, true); a366 28 void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) { if(On) OptimizeOffPragmaLocation = SourceLocation(); else OptimizeOffPragmaLocation = PragmaLoc; } void Sema::AddRangeBasedOptnone(FunctionDecl *FD) { // In the future, check other pragmas if they're implemented (e.g. pragma // optimize 0 will probably map to this functionality too). if(OptimizeOffPragmaLocation.isValid()) AddOptnoneAttributeIfNoConflicts(FD, OptimizeOffPragmaLocation); } void Sema::AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc) { // Don't add a conflicting attribute. No diagnostic is needed. if (FD->hasAttr() || FD->hasAttr()) return; // Add attributes only if required. Optnone requires noinline as well, but if // either is already present then don't bother adding them. if (!FD->hasAttr()) FD->addAttr(OptimizeNoneAttr::CreateImplicit(Context, Loc)); if (!FD->hasAttr()) FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc)); } d368 1 a368 1 enum : unsigned { NoVisibility = ~0U }; d392 1 a392 1 VisContext = nullptr; @ 1.1.1.4 log @Import Clang 3.5svn r209886. @ text @d112 1 a112 1 PackContext = nullptr; d146 1 a146 1 if (!PackContext) d158 1 a158 1 Context->push(nullptr); d165 1 a165 1 Context->push(nullptr); d171 1 a171 1 if (!this->Context.getTargetInfo().hasAlignMac68kSupport()) { d175 1 a175 1 Context->push(nullptr); d182 1 a182 1 if (!Context->pop(nullptr, /*IsReset=*/true)) { d214 1 a214 1 if (!PackContext) a327 106 template void Sema::PragmaStack::Act(SourceLocation PragmaLocation, PragmaMsStackAction Action, llvm::StringRef StackSlotLabel, ValueType Value) { if (Action == PSK_Reset) { CurrentValue = nullptr; return; } if (Action & PSK_Push) Stack.push_back(Slot(StackSlotLabel, CurrentValue, CurrentPragmaLocation)); else if (Action & PSK_Pop) { if (!StackSlotLabel.empty()) { // If we've got a label, try to find it and jump there. auto I = std::find_if(Stack.rbegin(), Stack.rend(), [&](const Slot &x) { return x.StackSlotLabel == StackSlotLabel; }); // If we found the label so pop from there. if (I != Stack.rend()) { CurrentValue = I->Value; CurrentPragmaLocation = I->PragmaLocation; Stack.erase(std::prev(I.base()), Stack.end()); } } else if (!Stack.empty()) { // We don't have a label, just pop the last entry. CurrentValue = Stack.back().Value; CurrentPragmaLocation = Stack.back().PragmaLocation; Stack.pop_back(); } } if (Action & PSK_Set) { CurrentValue = Value; CurrentPragmaLocation = PragmaLocation; } } bool Sema::UnifySection(const StringRef &SectionName, int SectionFlags, DeclaratorDecl *Decl) { auto Section = SectionInfos.find(SectionName); if (Section == SectionInfos.end()) { SectionInfos[SectionName] = SectionInfo(Decl, SourceLocation(), SectionFlags); return false; } // A pre-declared section takes precedence w/o diagnostic. if (Section->second.SectionFlags == SectionFlags || !(Section->second.SectionFlags & PSF_Implicit)) return false; auto OtherDecl = Section->second.Decl; Diag(Decl->getLocation(), diag::err_section_conflict) << Decl << OtherDecl; Diag(OtherDecl->getLocation(), diag::note_declared_at) << OtherDecl->getName(); if (auto A = Decl->getAttr()) if (A->isImplicit()) Diag(A->getLocation(), diag::note_pragma_entered_here); if (auto A = OtherDecl->getAttr()) if (A->isImplicit()) Diag(A->getLocation(), diag::note_pragma_entered_here); return false; } bool Sema::UnifySection(const StringRef &SectionName, int SectionFlags, SourceLocation PragmaSectionLocation) { auto Section = SectionInfos.find(SectionName); if (Section != SectionInfos.end()) { if (Section->second.SectionFlags == SectionFlags) return false; if (!(Section->second.SectionFlags & PSF_Implicit)) { Diag(PragmaSectionLocation, diag::err_section_conflict) << "this" << "a prior #pragma section"; Diag(Section->second.PragmaSectionLocation, diag::note_pragma_entered_here); return true; } } SectionInfos[SectionName] = SectionInfo(nullptr, PragmaSectionLocation, SectionFlags); return false; } /// \brief Called on well formed \#pragma bss_seg(). void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation, PragmaMsStackAction Action, llvm::StringRef StackSlotLabel, StringLiteral *SegmentName, llvm::StringRef PragmaName) { PragmaStack *Stack = llvm::StringSwitch *>(PragmaName) .Case("data_seg", &DataSegStack) .Case("bss_seg", &BSSSegStack) .Case("const_seg", &ConstSegStack) .Case("code_seg", &CodeSegStack); if (Action & PSK_Pop && Stack->Stack.empty()) Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName << "stack empty"; Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName); } /// \brief Called on well formed \#pragma bss_seg(). void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation, int SectionFlags, StringLiteral *SegmentName) { UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation); } d333 1 a333 1 LookupParsedName(Lookup, curScope, nullptr, true); a366 28 void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) { if(On) OptimizeOffPragmaLocation = SourceLocation(); else OptimizeOffPragmaLocation = PragmaLoc; } void Sema::AddRangeBasedOptnone(FunctionDecl *FD) { // In the future, check other pragmas if they're implemented (e.g. pragma // optimize 0 will probably map to this functionality too). if(OptimizeOffPragmaLocation.isValid()) AddOptnoneAttributeIfNoConflicts(FD, OptimizeOffPragmaLocation); } void Sema::AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc) { // Don't add a conflicting attribute. No diagnostic is needed. if (FD->hasAttr() || FD->hasAttr()) return; // Add attributes only if required. Optnone requires noinline as well, but if // either is already present then don't bother adding them. if (!FD->hasAttr()) FD->addAttr(OptimizeNoneAttr::CreateImplicit(Context, Loc)); if (!FD->hasAttr()) FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc)); } d368 1 a368 1 enum : unsigned { NoVisibility = ~0U }; d392 1 a392 1 VisContext = nullptr; @ 1.1.1.5 log @Import clang 3.6svn r215315. @ text @a433 9 void Sema::ActOnPragmaMSInitSeg(SourceLocation PragmaLocation, StringLiteral *SegmentName) { // There's no stack to maintain, so we just have a current section. When we // see the default section, reset our current section back to null so we stop // tacking on unnecessary attributes. CurInitSeg = SegmentName->getString() == ".CRT$XCU" ? nullptr : SegmentName; CurInitSegLoc = PragmaLocation; } @ 1.1.1.5.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d363 1 a363 1 bool Sema::UnifySection(StringRef SectionName, d366 4 a369 4 auto Section = Context.SectionInfos.find(SectionName); if (Section == Context.SectionInfos.end()) { Context.SectionInfos[SectionName] = ASTContext::SectionInfo(Decl, SourceLocation(), SectionFlags); d374 1 a374 1 !(Section->second.SectionFlags & ASTContext::PSF_Implicit)) d387 1 a387 1 return true; d390 1 a390 1 bool Sema::UnifySection(StringRef SectionName, d393 2 a394 2 auto Section = Context.SectionInfos.find(SectionName); if (Section != Context.SectionInfos.end()) { d397 1 a397 1 if (!(Section->second.SectionFlags & ASTContext::PSF_Implicit)) { d405 2 a406 2 Context.SectionInfos[SectionName] = ASTContext::SectionInfo(nullptr, PragmaSectionLocation, SectionFlags); @ 1.1.1.6 log @Import Clang 3.6RC1 r227398. @ text @d363 1 a363 1 bool Sema::UnifySection(StringRef SectionName, d366 4 a369 4 auto Section = Context.SectionInfos.find(SectionName); if (Section == Context.SectionInfos.end()) { Context.SectionInfos[SectionName] = ASTContext::SectionInfo(Decl, SourceLocation(), SectionFlags); d374 1 a374 1 !(Section->second.SectionFlags & ASTContext::PSF_Implicit)) d387 1 a387 1 return true; d390 1 a390 1 bool Sema::UnifySection(StringRef SectionName, d393 2 a394 2 auto Section = Context.SectionInfos.find(SectionName); if (Section != Context.SectionInfos.end()) { d397 1 a397 1 if (!(Section->second.SectionFlags & ASTContext::PSF_Implicit)) { d405 2 a406 2 Context.SectionInfos[SectionName] = ASTContext::SectionInfo(nullptr, PragmaSectionLocation, SectionFlags); @ 1.1.1.7 log @Import Clang 3.8.0rc3 r261930. @ text @d134 1 a134 1 RD->addAttr(MSStructAttr::CreateImplicit(Context)); a424 3 if (SegmentName && !checkSectionName(SegmentName->getLocStart(), SegmentName->getString())) return; @ 1.1.1.7.2.1 log @Sync with HEAD @ text @d15 1 a21 1 #include "clang/Sema/SemaInternal.h" d28 75 a102 10 Sema::PragmaStackSentinelRAII::PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct) : S(S), SlotLabel(SlotLabel), ShouldAct(ShouldAct) { if (ShouldAct) { S.VtorDispStack.SentinelAction(PSK_Push, SlotLabel); S.DataSegStack.SentinelAction(PSK_Push, SlotLabel); S.BSSSegStack.SentinelAction(PSK_Push, SlotLabel); S.ConstSegStack.SentinelAction(PSK_Push, SlotLabel); S.CodeSegStack.SentinelAction(PSK_Push, SlotLabel); d104 2 d108 5 a112 8 Sema::PragmaStackSentinelRAII::~PragmaStackSentinelRAII() { if (ShouldAct) { S.VtorDispStack.SentinelAction(PSK_Pop, SlotLabel); S.DataSegStack.SentinelAction(PSK_Pop, SlotLabel); S.BSSSegStack.SentinelAction(PSK_Pop, SlotLabel); S.ConstSegStack.SentinelAction(PSK_Pop, SlotLabel); S.CodeSegStack.SentinelAction(PSK_Pop, SlotLabel); } d116 2 a117 2 // If there is no pack value, we don't need any attributes. if (!PackStack.CurrentValue) d120 2 d123 2 a124 2 if (unsigned Alignment = PackStack.CurrentValue) { if (Alignment == Sema::kMac68kAlignmentSentinel) d139 1 a139 1 if (VtorDispStack.CurrentValue != getLangOpts().VtorDispMode) d141 1 a141 1 MSVtorDispAttr::CreateImplicit(Context, VtorDispStack.CurrentValue)); d146 5 a150 2 PragmaMsStackAction Action = Sema::PSK_Reset; unsigned Alignment = 0; d158 2 a159 2 Action = Sema::PSK_Push_Set; Alignment = 0; d165 2 a166 2 Action = Sema::PSK_Push_Set; Alignment = 1; d175 2 a176 2 Action = Sema::PSK_Push_Set; Alignment = Sema::kMac68kAlignmentSentinel; d182 3 a184 9 Action = Sema::PSK_Pop; if (PackStack.Stack.empty()) { if (PackStack.CurrentValue) { Action = Sema::PSK_Reset; } else { Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed) << "stack empty"; return; } a187 2 PackStack.Act(PragmaLoc, Action, StringRef(), Alignment); d190 3 a192 2 void Sema::ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action, StringRef SlotLabel, Expr *alignment) { d213 12 a224 1 if (Action == Sema::PSK_Show) { d227 1 a228 1 AlignmentVal = PackStack.CurrentValue; d231 1 a231 1 if (AlignmentVal == Sema::kMac68kAlignmentSentinel) d235 13 a247 5 } // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack: // "#pragma pack(pop, identifier, n) is undefined" if (Action & Sema::PSK_Pop) { if (Alignment && !SlotLabel.empty()) d249 16 a264 2 if (PackStack.Stack.empty()) Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << "stack empty"; a265 2 PackStack.Act(PragmaLoc, Action, SlotLabel, AlignmentVal); d272 17 a288 6 void Sema::ActOnPragmaMSComment(SourceLocation CommentLoc, PragmaMSCommentKind Kind, StringRef Arg) { auto *PCD = PragmaCommentDecl::Create( Context, Context.getTranslationUnitDecl(), CommentLoc, Kind, Arg); Context.getTranslationUnitDecl()->addDecl(PCD); Consumer.HandleTopLevelDecl(DeclGroupRef(PCD)); d291 3 a293 6 void Sema::ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name, StringRef Value) { auto *PDMD = PragmaDetectMismatchDecl::Create( Context, Context.getTranslationUnitDecl(), Loc, Name, Value); Context.getTranslationUnitDecl()->addDecl(PDMD); Consumer.HandleTopLevelDecl(DeclGroupRef(PDMD)); d303 1 a303 1 void Sema::ActOnPragmaMSVtorDisp(PragmaMsStackAction Action, d306 20 a325 4 if (Action & PSK_Pop && VtorDispStack.Stack.empty()) Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "vtordisp" << "stack empty"; VtorDispStack.Act(PragmaLoc, Action, StringRef(), Mode); d334 1 a334 1 CurrentValue = DefaultValue; d342 2 a343 3 auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) { return x.StackSlotLabel == StackSlotLabel; }); d470 1 a470 2 VD->addAttr(UnusedAttr::CreateImplicit(Context, UnusedAttr::GNU_unused, IdTok.getLocation())); @ 1.1.1.8 log @Import Clang pre-4.0.0 r291444. @ text @d15 1 a21 1 #include "clang/Sema/SemaInternal.h" d28 75 a102 10 Sema::PragmaStackSentinelRAII::PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct) : S(S), SlotLabel(SlotLabel), ShouldAct(ShouldAct) { if (ShouldAct) { S.VtorDispStack.SentinelAction(PSK_Push, SlotLabel); S.DataSegStack.SentinelAction(PSK_Push, SlotLabel); S.BSSSegStack.SentinelAction(PSK_Push, SlotLabel); S.ConstSegStack.SentinelAction(PSK_Push, SlotLabel); S.CodeSegStack.SentinelAction(PSK_Push, SlotLabel); d104 2 d108 5 a112 8 Sema::PragmaStackSentinelRAII::~PragmaStackSentinelRAII() { if (ShouldAct) { S.VtorDispStack.SentinelAction(PSK_Pop, SlotLabel); S.DataSegStack.SentinelAction(PSK_Pop, SlotLabel); S.BSSSegStack.SentinelAction(PSK_Pop, SlotLabel); S.ConstSegStack.SentinelAction(PSK_Pop, SlotLabel); S.CodeSegStack.SentinelAction(PSK_Pop, SlotLabel); } d116 2 a117 2 // If there is no pack value, we don't need any attributes. if (!PackStack.CurrentValue) d120 2 d123 2 a124 2 if (unsigned Alignment = PackStack.CurrentValue) { if (Alignment == Sema::kMac68kAlignmentSentinel) d139 1 a139 1 if (VtorDispStack.CurrentValue != getLangOpts().VtorDispMode) d141 1 a141 1 MSVtorDispAttr::CreateImplicit(Context, VtorDispStack.CurrentValue)); d146 5 a150 2 PragmaMsStackAction Action = Sema::PSK_Reset; unsigned Alignment = 0; d158 2 a159 2 Action = Sema::PSK_Push_Set; Alignment = 0; d165 2 a166 2 Action = Sema::PSK_Push_Set; Alignment = 1; d175 2 a176 2 Action = Sema::PSK_Push_Set; Alignment = Sema::kMac68kAlignmentSentinel; d182 3 a184 9 Action = Sema::PSK_Pop; if (PackStack.Stack.empty()) { if (PackStack.CurrentValue) { Action = Sema::PSK_Reset; } else { Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed) << "stack empty"; return; } a187 2 PackStack.Act(PragmaLoc, Action, StringRef(), Alignment); d190 3 a192 2 void Sema::ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action, StringRef SlotLabel, Expr *alignment) { d213 12 a224 1 if (Action == Sema::PSK_Show) { d227 1 a228 1 AlignmentVal = PackStack.CurrentValue; d231 1 a231 1 if (AlignmentVal == Sema::kMac68kAlignmentSentinel) d235 13 a247 5 } // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack: // "#pragma pack(pop, identifier, n) is undefined" if (Action & Sema::PSK_Pop) { if (Alignment && !SlotLabel.empty()) d249 16 a264 2 if (PackStack.Stack.empty()) Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << "stack empty"; a265 2 PackStack.Act(PragmaLoc, Action, SlotLabel, AlignmentVal); d272 17 a288 6 void Sema::ActOnPragmaMSComment(SourceLocation CommentLoc, PragmaMSCommentKind Kind, StringRef Arg) { auto *PCD = PragmaCommentDecl::Create( Context, Context.getTranslationUnitDecl(), CommentLoc, Kind, Arg); Context.getTranslationUnitDecl()->addDecl(PCD); Consumer.HandleTopLevelDecl(DeclGroupRef(PCD)); d291 3 a293 6 void Sema::ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name, StringRef Value) { auto *PDMD = PragmaDetectMismatchDecl::Create( Context, Context.getTranslationUnitDecl(), Loc, Name, Value); Context.getTranslationUnitDecl()->addDecl(PDMD); Consumer.HandleTopLevelDecl(DeclGroupRef(PDMD)); d303 1 a303 1 void Sema::ActOnPragmaMSVtorDisp(PragmaMsStackAction Action, d306 20 a325 4 if (Action & PSK_Pop && VtorDispStack.Stack.empty()) Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "vtordisp" << "stack empty"; VtorDispStack.Act(PragmaLoc, Action, StringRef(), Mode); d334 1 a334 1 CurrentValue = DefaultValue; d342 2 a343 3 auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) { return x.StackSlotLabel == StackSlotLabel; }); d470 1 a470 2 VD->addAttr(UnusedAttr::CreateImplicit(Context, UnusedAttr::GNU_unused, IdTok.getLocation())); @ 1.1.1.9 log @Import clang r309604 from branches/release_50 @ text @a128 30 void Sema::ActOnPragmaClangSection(SourceLocation PragmaLoc, PragmaClangSectionAction Action, PragmaClangSectionKind SecKind, StringRef SecName) { PragmaClangSection *CSec; switch (SecKind) { case PragmaClangSectionKind::PCSK_BSS: CSec = &PragmaClangBSSSection; break; case PragmaClangSectionKind::PCSK_Data: CSec = &PragmaClangDataSection; break; case PragmaClangSectionKind::PCSK_Rodata: CSec = &PragmaClangRodataSection; break; case PragmaClangSectionKind::PCSK_Text: CSec = &PragmaClangTextSection; break; default: llvm_unreachable("invalid clang section kind"); } if (Action == PragmaClangSectionAction::PCSA_Clear) { CSec->Valid = false; return; } CSec->Valid = true; CSec->SectionName = SecName; CSec->PragmaLocation = PragmaLoc; } a217 1 CurrentPragmaLocation = PragmaLocation; a369 213 namespace { Optional getParentAttrMatcherRule(attr::SubjectMatchRule Rule) { using namespace attr; switch (Rule) { default: return None; #define ATTR_MATCH_RULE(Value, Spelling, IsAbstract) #define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated) \ case Value: \ return Parent; #include "clang/Basic/AttrSubMatchRulesList.inc" } } bool isNegatedAttrMatcherSubRule(attr::SubjectMatchRule Rule) { using namespace attr; switch (Rule) { default: return false; #define ATTR_MATCH_RULE(Value, Spelling, IsAbstract) #define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated) \ case Value: \ return IsNegated; #include "clang/Basic/AttrSubMatchRulesList.inc" } } CharSourceRange replacementRangeForListElement(const Sema &S, SourceRange Range) { // Make sure that the ',' is removed as well. SourceLocation AfterCommaLoc = Lexer::findLocationAfterToken( Range.getEnd(), tok::comma, S.getSourceManager(), S.getLangOpts(), /*SkipTrailingWhitespaceAndNewLine=*/false); if (AfterCommaLoc.isValid()) return CharSourceRange::getCharRange(Range.getBegin(), AfterCommaLoc); else return CharSourceRange::getTokenRange(Range); } std::string attrMatcherRuleListToString(ArrayRef Rules) { std::string Result; llvm::raw_string_ostream OS(Result); for (const auto &I : llvm::enumerate(Rules)) { if (I.index()) OS << (I.index() == Rules.size() - 1 ? ", and " : ", "); OS << "'" << attr::getSubjectMatchRuleSpelling(I.value()) << "'"; } return OS.str(); } } // end anonymous namespace void Sema::ActOnPragmaAttributePush(AttributeList &Attribute, SourceLocation PragmaLoc, attr::ParsedSubjectMatchRuleSet Rules) { SmallVector SubjectMatchRules; // Gather the subject match rules that are supported by the attribute. SmallVector, 4> StrictSubjectMatchRuleSet; Attribute.getMatchRules(LangOpts, StrictSubjectMatchRuleSet); // Figure out which subject matching rules are valid. if (StrictSubjectMatchRuleSet.empty()) { // Check for contradicting match rules. Contradicting match rules are // either: // - a top-level rule and one of its sub-rules. E.g. variable and // variable(is_parameter). // - a sub-rule and a sibling that's negated. E.g. // variable(is_thread_local) and variable(unless(is_parameter)) llvm::SmallDenseMap, 2> RulesToFirstSpecifiedNegatedSubRule; for (const auto &Rule : Rules) { attr::SubjectMatchRule MatchRule = attr::SubjectMatchRule(Rule.first); Optional ParentRule = getParentAttrMatcherRule(MatchRule); if (!ParentRule) continue; auto It = Rules.find(*ParentRule); if (It != Rules.end()) { // A sub-rule contradicts a parent rule. Diag(Rule.second.getBegin(), diag::err_pragma_attribute_matcher_subrule_contradicts_rule) << attr::getSubjectMatchRuleSpelling(MatchRule) << attr::getSubjectMatchRuleSpelling(*ParentRule) << It->second << FixItHint::CreateRemoval( replacementRangeForListElement(*this, Rule.second)); // Keep going without removing this rule as it won't change the set of // declarations that receive the attribute. continue; } if (isNegatedAttrMatcherSubRule(MatchRule)) RulesToFirstSpecifiedNegatedSubRule.insert( std::make_pair(*ParentRule, Rule)); } bool IgnoreNegatedSubRules = false; for (const auto &Rule : Rules) { attr::SubjectMatchRule MatchRule = attr::SubjectMatchRule(Rule.first); Optional ParentRule = getParentAttrMatcherRule(MatchRule); if (!ParentRule) continue; auto It = RulesToFirstSpecifiedNegatedSubRule.find(*ParentRule); if (It != RulesToFirstSpecifiedNegatedSubRule.end() && It->second != Rule) { // Negated sub-rule contradicts another sub-rule. Diag( It->second.second.getBegin(), diag:: err_pragma_attribute_matcher_negated_subrule_contradicts_subrule) << attr::getSubjectMatchRuleSpelling( attr::SubjectMatchRule(It->second.first)) << attr::getSubjectMatchRuleSpelling(MatchRule) << Rule.second << FixItHint::CreateRemoval( replacementRangeForListElement(*this, It->second.second)); // Keep going but ignore all of the negated sub-rules. IgnoreNegatedSubRules = true; RulesToFirstSpecifiedNegatedSubRule.erase(It); } } if (!IgnoreNegatedSubRules) { for (const auto &Rule : Rules) SubjectMatchRules.push_back(attr::SubjectMatchRule(Rule.first)); } else { for (const auto &Rule : Rules) { if (!isNegatedAttrMatcherSubRule(attr::SubjectMatchRule(Rule.first))) SubjectMatchRules.push_back(attr::SubjectMatchRule(Rule.first)); } } Rules.clear(); } else { for (const auto &Rule : StrictSubjectMatchRuleSet) { if (Rules.erase(Rule.first)) { // Add the rule to the set of attribute receivers only if it's supported // in the current language mode. if (Rule.second) SubjectMatchRules.push_back(Rule.first); } } } if (!Rules.empty()) { auto Diagnostic = Diag(PragmaLoc, diag::err_pragma_attribute_invalid_matchers) << Attribute.getName(); SmallVector ExtraRules; for (const auto &Rule : Rules) { ExtraRules.push_back(attr::SubjectMatchRule(Rule.first)); Diagnostic << FixItHint::CreateRemoval( replacementRangeForListElement(*this, Rule.second)); } Diagnostic << attrMatcherRuleListToString(ExtraRules); } PragmaAttributeStack.push_back( {PragmaLoc, &Attribute, std::move(SubjectMatchRules), /*IsUsed=*/false}); } void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc) { if (PragmaAttributeStack.empty()) { Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch); return; } const PragmaAttributeEntry &Entry = PragmaAttributeStack.back(); if (!Entry.IsUsed) { assert(Entry.Attribute && "Expected an attribute"); Diag(Entry.Attribute->getLoc(), diag::warn_pragma_attribute_unused) << Entry.Attribute->getName(); Diag(PragmaLoc, diag::note_pragma_attribute_region_ends_here); } PragmaAttributeStack.pop_back(); } void Sema::AddPragmaAttributes(Scope *S, Decl *D) { if (PragmaAttributeStack.empty()) return; for (auto &Entry : PragmaAttributeStack) { const AttributeList *Attribute = Entry.Attribute; assert(Attribute && "Expected an attribute"); // Ensure that the attribute can be applied to the given declaration. bool Applies = false; for (const auto &Rule : Entry.MatchRules) { if (Attribute->appliesToDecl(D, Rule)) { Applies = true; break; } } if (!Applies) continue; Entry.IsUsed = true; assert(!Attribute->getNext() && "Expected just one attribute"); PragmaAttributeCurrentTargetDecl = D; ProcessDeclAttributeList(S, D, Attribute); PragmaAttributeCurrentTargetDecl = nullptr; } } void Sema::PrintPragmaAttributeInstantiationPoint() { assert(PragmaAttributeCurrentTargetDecl && "Expected an active declaration"); Diags.Report(PragmaAttributeCurrentTargetDecl->getLocStart(), diag::note_pragma_attribute_applied_decl_here); } void Sema::DiagnoseUnterminatedPragmaAttribute() { if (PragmaAttributeStack.empty()) return; Diag(PragmaAttributeStack.back().Loc, diag::err_pragma_attribute_no_pop_eof); } d450 4 a453 4 void Sema::ActOnPragmaFPContract(LangOptions::FPContractModeKind FPC) { switch (FPC) { case LangOptions::FPC_On: FPFeatures.setAllowFPContractWithinStatement(); d455 2 a456 2 case LangOptions::FPC_Fast: FPFeatures.setAllowFPContractAcrossStatement(); d458 2 a459 2 case LangOptions::FPC_Off: FPFeatures.setDisallowFPContract(); @ 1.1.1.9.4.1 log @Sync with HEAD @ text @a63 11 if (PackIncludeStack.empty()) return; // The #pragma pack affected a record in an included file, so Clang should // warn when that pragma was written in a file that included the included // file. for (auto &PackedInclude : llvm::reverse(PackIncludeStack)) { if (PackedInclude.CurrentPragmaLocation != PackStack.CurrentPragmaLocation) break; if (PackedInclude.HasNonDefaultValue) PackedInclude.ShouldWarnOnInclude = true; } d197 1 a197 1 Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifier_and_alignment); a204 55 void Sema::DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind, SourceLocation IncludeLoc) { if (Kind == PragmaPackDiagnoseKind::NonDefaultStateAtInclude) { SourceLocation PrevLocation = PackStack.CurrentPragmaLocation; // Warn about non-default alignment at #includes (without redundant // warnings for the same directive in nested includes). // The warning is delayed until the end of the file to avoid warnings // for files that don't have any records that are affected by the modified // alignment. bool HasNonDefaultValue = PackStack.hasValue() && (PackIncludeStack.empty() || PackIncludeStack.back().CurrentPragmaLocation != PrevLocation); PackIncludeStack.push_back( {PackStack.CurrentValue, PackStack.hasValue() ? PrevLocation : SourceLocation(), HasNonDefaultValue, /*ShouldWarnOnInclude*/ false}); return; } assert(Kind == PragmaPackDiagnoseKind::ChangedStateAtExit && "invalid kind"); PackIncludeState PrevPackState = PackIncludeStack.pop_back_val(); if (PrevPackState.ShouldWarnOnInclude) { // Emit the delayed non-default alignment at #include warning. Diag(IncludeLoc, diag::warn_pragma_pack_non_default_at_include); Diag(PrevPackState.CurrentPragmaLocation, diag::note_pragma_pack_here); } // Warn about modified alignment after #includes. if (PrevPackState.CurrentValue != PackStack.CurrentValue) { Diag(IncludeLoc, diag::warn_pragma_pack_modified_after_include); Diag(PackStack.CurrentPragmaLocation, diag::note_pragma_pack_here); } } void Sema::DiagnoseUnterminatedPragmaPack() { if (PackStack.Stack.empty()) return; bool IsInnermost = true; for (const auto &StackSlot : llvm::reverse(PackStack.Stack)) { Diag(StackSlot.PragmaPushLocation, diag::warn_pragma_pack_no_pop_eof); // The user might have already reset the alignment, so suggest replacing // the reset with a pop. if (IsInnermost && PackStack.CurrentValue == PackStack.DefaultValue) { DiagnosticBuilder DB = Diag(PackStack.CurrentPragmaLocation, diag::note_pragma_pack_pop_instead_reset); SourceLocation FixItLoc = Lexer::findLocationAfterToken( PackStack.CurrentPragmaLocation, tok::l_paren, SourceMgr, LangOpts, /*SkipTrailing=*/false); if (FixItLoc.isValid()) DB << FixItHint::CreateInsertion(FixItLoc, "pop"); } IsInnermost = false; } } d252 1 a252 2 Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation, PragmaLocation); d266 1 a266 1 // We do not have a label, just pop the last entry. d325 1 a325 1 /// Called on well formed \#pragma bss_seg(). d346 1 a346 1 /// Called on well formed \#pragma bss_seg(). d456 1 a456 1 void Sema::ActOnPragmaAttributePush(ParsedAttr &Attribute, d581 1 a581 1 ParsedAttr *Attribute = Entry.Attribute; d595 1 d597 1 a597 3 ParsedAttributesView Attrs; Attrs.addAtStart(Attribute); ProcessDeclAttributeList(S, D, Attrs); @ 1.1.1.9.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.9.2.1 log @Sync with HEAD @ text @a63 11 if (PackIncludeStack.empty()) return; // The #pragma pack affected a record in an included file, so Clang should // warn when that pragma was written in a file that included the included // file. for (auto &PackedInclude : llvm::reverse(PackIncludeStack)) { if (PackedInclude.CurrentPragmaLocation != PackStack.CurrentPragmaLocation) break; if (PackedInclude.HasNonDefaultValue) PackedInclude.ShouldWarnOnInclude = true; } d197 1 a197 1 Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifier_and_alignment); a204 55 void Sema::DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind, SourceLocation IncludeLoc) { if (Kind == PragmaPackDiagnoseKind::NonDefaultStateAtInclude) { SourceLocation PrevLocation = PackStack.CurrentPragmaLocation; // Warn about non-default alignment at #includes (without redundant // warnings for the same directive in nested includes). // The warning is delayed until the end of the file to avoid warnings // for files that don't have any records that are affected by the modified // alignment. bool HasNonDefaultValue = PackStack.hasValue() && (PackIncludeStack.empty() || PackIncludeStack.back().CurrentPragmaLocation != PrevLocation); PackIncludeStack.push_back( {PackStack.CurrentValue, PackStack.hasValue() ? PrevLocation : SourceLocation(), HasNonDefaultValue, /*ShouldWarnOnInclude*/ false}); return; } assert(Kind == PragmaPackDiagnoseKind::ChangedStateAtExit && "invalid kind"); PackIncludeState PrevPackState = PackIncludeStack.pop_back_val(); if (PrevPackState.ShouldWarnOnInclude) { // Emit the delayed non-default alignment at #include warning. Diag(IncludeLoc, diag::warn_pragma_pack_non_default_at_include); Diag(PrevPackState.CurrentPragmaLocation, diag::note_pragma_pack_here); } // Warn about modified alignment after #includes. if (PrevPackState.CurrentValue != PackStack.CurrentValue) { Diag(IncludeLoc, diag::warn_pragma_pack_modified_after_include); Diag(PackStack.CurrentPragmaLocation, diag::note_pragma_pack_here); } } void Sema::DiagnoseUnterminatedPragmaPack() { if (PackStack.Stack.empty()) return; bool IsInnermost = true; for (const auto &StackSlot : llvm::reverse(PackStack.Stack)) { Diag(StackSlot.PragmaPushLocation, diag::warn_pragma_pack_no_pop_eof); // The user might have already reset the alignment, so suggest replacing // the reset with a pop. if (IsInnermost && PackStack.CurrentValue == PackStack.DefaultValue) { DiagnosticBuilder DB = Diag(PackStack.CurrentPragmaLocation, diag::note_pragma_pack_pop_instead_reset); SourceLocation FixItLoc = Lexer::findLocationAfterToken( PackStack.CurrentPragmaLocation, tok::l_paren, SourceMgr, LangOpts, /*SkipTrailing=*/false); if (FixItLoc.isValid()) DB << FixItHint::CreateInsertion(FixItLoc, "pop"); } IsInnermost = false; } } d252 1 a252 2 Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation, PragmaLocation); d266 1 a266 1 // We do not have a label, just pop the last entry. d325 1 a325 1 /// Called on well formed \#pragma bss_seg(). d346 1 a346 1 /// Called on well formed \#pragma bss_seg(). d456 1 a456 1 void Sema::ActOnPragmaAttributePush(ParsedAttr &Attribute, d581 1 a581 1 ParsedAttr *Attribute = Entry.Attribute; d595 1 d597 1 a597 3 ParsedAttributesView Attrs; Attrs.addAtStart(Attribute); ProcessDeclAttributeList(S, D, Attrs); @ 1.1.1.10 log @Import clang r337282 from trunk @ text @a63 11 if (PackIncludeStack.empty()) return; // The #pragma pack affected a record in an included file, so Clang should // warn when that pragma was written in a file that included the included // file. for (auto &PackedInclude : llvm::reverse(PackIncludeStack)) { if (PackedInclude.CurrentPragmaLocation != PackStack.CurrentPragmaLocation) break; if (PackedInclude.HasNonDefaultValue) PackedInclude.ShouldWarnOnInclude = true; } d197 1 a197 1 Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifier_and_alignment); a204 55 void Sema::DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind, SourceLocation IncludeLoc) { if (Kind == PragmaPackDiagnoseKind::NonDefaultStateAtInclude) { SourceLocation PrevLocation = PackStack.CurrentPragmaLocation; // Warn about non-default alignment at #includes (without redundant // warnings for the same directive in nested includes). // The warning is delayed until the end of the file to avoid warnings // for files that don't have any records that are affected by the modified // alignment. bool HasNonDefaultValue = PackStack.hasValue() && (PackIncludeStack.empty() || PackIncludeStack.back().CurrentPragmaLocation != PrevLocation); PackIncludeStack.push_back( {PackStack.CurrentValue, PackStack.hasValue() ? PrevLocation : SourceLocation(), HasNonDefaultValue, /*ShouldWarnOnInclude*/ false}); return; } assert(Kind == PragmaPackDiagnoseKind::ChangedStateAtExit && "invalid kind"); PackIncludeState PrevPackState = PackIncludeStack.pop_back_val(); if (PrevPackState.ShouldWarnOnInclude) { // Emit the delayed non-default alignment at #include warning. Diag(IncludeLoc, diag::warn_pragma_pack_non_default_at_include); Diag(PrevPackState.CurrentPragmaLocation, diag::note_pragma_pack_here); } // Warn about modified alignment after #includes. if (PrevPackState.CurrentValue != PackStack.CurrentValue) { Diag(IncludeLoc, diag::warn_pragma_pack_modified_after_include); Diag(PackStack.CurrentPragmaLocation, diag::note_pragma_pack_here); } } void Sema::DiagnoseUnterminatedPragmaPack() { if (PackStack.Stack.empty()) return; bool IsInnermost = true; for (const auto &StackSlot : llvm::reverse(PackStack.Stack)) { Diag(StackSlot.PragmaPushLocation, diag::warn_pragma_pack_no_pop_eof); // The user might have already reset the alignment, so suggest replacing // the reset with a pop. if (IsInnermost && PackStack.CurrentValue == PackStack.DefaultValue) { DiagnosticBuilder DB = Diag(PackStack.CurrentPragmaLocation, diag::note_pragma_pack_pop_instead_reset); SourceLocation FixItLoc = Lexer::findLocationAfterToken( PackStack.CurrentPragmaLocation, tok::l_paren, SourceMgr, LangOpts, /*SkipTrailing=*/false); if (FixItLoc.isValid()) DB << FixItHint::CreateInsertion(FixItLoc, "pop"); } IsInnermost = false; } } d252 1 a252 2 Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation, PragmaLocation); d266 1 a266 1 // We do not have a label, just pop the last entry. d325 1 a325 1 /// Called on well formed \#pragma bss_seg(). d346 1 a346 1 /// Called on well formed \#pragma bss_seg(). d456 1 a456 1 void Sema::ActOnPragmaAttributePush(ParsedAttr &Attribute, d581 1 a581 1 ParsedAttr *Attribute = Entry.Attribute; d595 1 d597 1 a597 3 ParsedAttributesView Attrs; Attrs.addAtStart(Attribute); ProcessDeclAttributeList(S, D, Attrs); @ 1.1.1.11 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.5.4.1 log @file SemaAttr.cpp was added on branch tls-maxphys on 2014-08-19 23:47:30 +0000 @ text @d1 616 @ 1.1.1.5.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 616 //===--- SemaAttr.cpp - Semantic Analysis for Attributes ------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements semantic analysis for non-trivial attributes and // pragmas. // //===----------------------------------------------------------------------===// #include "clang/Sema/SemaInternal.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/Attr.h" #include "clang/AST/Expr.h" #include "clang/Basic/TargetInfo.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/Lookup.h" using namespace clang; //===----------------------------------------------------------------------===// // Pragma 'pack' and 'options align' //===----------------------------------------------------------------------===// namespace { struct PackStackEntry { // We just use a sentinel to represent when the stack is set to mac68k // alignment. static const unsigned kMac68kAlignmentSentinel = ~0U; unsigned Alignment; IdentifierInfo *Name; }; /// PragmaPackStack - Simple class to wrap the stack used by #pragma /// pack. class PragmaPackStack { typedef std::vector stack_ty; /// Alignment - The current user specified alignment. unsigned Alignment; /// Stack - Entries in the #pragma pack stack, consisting of saved /// alignments and optional names. stack_ty Stack; public: PragmaPackStack() : Alignment(0) {} void setAlignment(unsigned A) { Alignment = A; } unsigned getAlignment() { return Alignment; } /// push - Push the current alignment onto the stack, optionally /// using the given \arg Name for the record, if non-zero. void push(IdentifierInfo *Name) { PackStackEntry PSE = { Alignment, Name }; Stack.push_back(PSE); } /// pop - Pop a record from the stack and restore the current /// alignment to the previous value. If \arg Name is non-zero then /// the first such named record is popped, otherwise the top record /// is popped. Returns true if the pop succeeded. bool pop(IdentifierInfo *Name, bool IsReset); }; } // end anonymous namespace. bool PragmaPackStack::pop(IdentifierInfo *Name, bool IsReset) { // If name is empty just pop top. if (!Name) { // An empty stack is a special case... if (Stack.empty()) { // If this isn't a reset, it is always an error. if (!IsReset) return false; // Otherwise, it is an error only if some alignment has been set. if (!Alignment) return false; // Otherwise, reset to the default alignment. Alignment = 0; } else { Alignment = Stack.back().Alignment; Stack.pop_back(); } return true; } // Otherwise, find the named record. for (unsigned i = Stack.size(); i != 0; ) { --i; if (Stack[i].Name == Name) { // Found it, pop up to and including this record. Alignment = Stack[i].Alignment; Stack.erase(Stack.begin() + i, Stack.end()); return true; } } return false; } /// FreePackedContext - Deallocate and null out PackContext. void Sema::FreePackedContext() { delete static_cast(PackContext); PackContext = nullptr; } void Sema::AddAlignmentAttributesForRecord(RecordDecl *RD) { // If there is no pack context, we don't need any attributes. if (!PackContext) return; PragmaPackStack *Stack = static_cast(PackContext); // Otherwise, check to see if we need a max field alignment attribute. if (unsigned Alignment = Stack->getAlignment()) { if (Alignment == PackStackEntry::kMac68kAlignmentSentinel) RD->addAttr(AlignMac68kAttr::CreateImplicit(Context)); else RD->addAttr(MaxFieldAlignmentAttr::CreateImplicit(Context, Alignment * 8)); } } void Sema::AddMsStructLayoutForRecord(RecordDecl *RD) { if (MSStructPragmaOn) RD->addAttr(MsStructAttr::CreateImplicit(Context)); // FIXME: We should merge AddAlignmentAttributesForRecord with // AddMsStructLayoutForRecord into AddPragmaAttributesForRecord, which takes // all active pragmas and applies them as attributes to class definitions. if (VtorDispModeStack.back() != getLangOpts().VtorDispMode) RD->addAttr( MSVtorDispAttr::CreateImplicit(Context, VtorDispModeStack.back())); } void Sema::ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind, SourceLocation PragmaLoc) { if (!PackContext) PackContext = new PragmaPackStack(); PragmaPackStack *Context = static_cast(PackContext); switch (Kind) { // For all targets we support native and natural are the same. // // FIXME: This is not true on Darwin/PPC. case POAK_Native: case POAK_Power: case POAK_Natural: Context->push(nullptr); Context->setAlignment(0); break; // Note that '#pragma options align=packed' is not equivalent to attribute // packed, it has a different precedence relative to attribute aligned. case POAK_Packed: Context->push(nullptr); Context->setAlignment(1); break; case POAK_Mac68k: // Check if the target supports this. if (!this->Context.getTargetInfo().hasAlignMac68kSupport()) { Diag(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported); return; } Context->push(nullptr); Context->setAlignment(PackStackEntry::kMac68kAlignmentSentinel); break; case POAK_Reset: // Reset just pops the top of the stack, or resets the current alignment to // default. if (!Context->pop(nullptr, /*IsReset=*/true)) { Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed) << "stack empty"; } break; } } void Sema::ActOnPragmaPack(PragmaPackKind Kind, IdentifierInfo *Name, Expr *alignment, SourceLocation PragmaLoc, SourceLocation LParenLoc, SourceLocation RParenLoc) { Expr *Alignment = static_cast(alignment); // If specified then alignment must be a "small" power of two. unsigned AlignmentVal = 0; if (Alignment) { llvm::APSInt Val; // pack(0) is like pack(), which just works out since that is what // we use 0 for in PackAttr. if (Alignment->isTypeDependent() || Alignment->isValueDependent() || !Alignment->isIntegerConstantExpr(Val, Context) || !(Val == 0 || Val.isPowerOf2()) || Val.getZExtValue() > 16) { Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment); return; // Ignore } AlignmentVal = (unsigned) Val.getZExtValue(); } if (!PackContext) PackContext = new PragmaPackStack(); PragmaPackStack *Context = static_cast(PackContext); switch (Kind) { case Sema::PPK_Default: // pack([n]) Context->setAlignment(AlignmentVal); break; case Sema::PPK_Show: // pack(show) // Show the current alignment, making sure to show the right value // for the default. AlignmentVal = Context->getAlignment(); // FIXME: This should come from the target. if (AlignmentVal == 0) AlignmentVal = 8; if (AlignmentVal == PackStackEntry::kMac68kAlignmentSentinel) Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k"; else Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal; break; case Sema::PPK_Push: // pack(push [, id] [, [n]) Context->push(Name); // Set the new alignment if specified. if (Alignment) Context->setAlignment(AlignmentVal); break; case Sema::PPK_Pop: // pack(pop [, id] [, n]) // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack: // "#pragma pack(pop, identifier, n) is undefined" if (Alignment && Name) Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifer_and_alignment); // Do the pop. if (!Context->pop(Name, /*IsReset=*/false)) { // If a name was specified then failure indicates the name // wasn't found. Otherwise failure indicates the stack was // empty. Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << (Name ? "no record matching name" : "stack empty"); // FIXME: Warn about popping named records as MSVC does. } else { // Pop succeeded, set the new alignment if specified. if (Alignment) Context->setAlignment(AlignmentVal); } break; } } void Sema::ActOnPragmaMSStruct(PragmaMSStructKind Kind) { MSStructPragmaOn = (Kind == PMSST_ON); } void Sema::ActOnPragmaMSComment(PragmaMSCommentKind Kind, StringRef Arg) { // FIXME: Serialize this. switch (Kind) { case PCK_Unknown: llvm_unreachable("unexpected pragma comment kind"); case PCK_Linker: Consumer.HandleLinkerOptionPragma(Arg); return; case PCK_Lib: Consumer.HandleDependentLibrary(Arg); return; case PCK_Compiler: case PCK_ExeStr: case PCK_User: return; // We ignore all of these. } llvm_unreachable("invalid pragma comment kind"); } void Sema::ActOnPragmaDetectMismatch(StringRef Name, StringRef Value) { // FIXME: Serialize this. Consumer.HandleDetectMismatch(Name, Value); } void Sema::ActOnPragmaMSPointersToMembers( LangOptions::PragmaMSPointersToMembersKind RepresentationMethod, SourceLocation PragmaLoc) { MSPointerToMemberRepresentationMethod = RepresentationMethod; ImplicitMSInheritanceAttrLoc = PragmaLoc; } void Sema::ActOnPragmaMSVtorDisp(PragmaVtorDispKind Kind, SourceLocation PragmaLoc, MSVtorDispAttr::Mode Mode) { switch (Kind) { case PVDK_Set: VtorDispModeStack.back() = Mode; break; case PVDK_Push: VtorDispModeStack.push_back(Mode); break; case PVDK_Reset: VtorDispModeStack.clear(); VtorDispModeStack.push_back(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)); break; case PVDK_Pop: VtorDispModeStack.pop_back(); if (VtorDispModeStack.empty()) { Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "vtordisp" << "stack empty"; VtorDispModeStack.push_back(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)); } break; } } template void Sema::PragmaStack::Act(SourceLocation PragmaLocation, PragmaMsStackAction Action, llvm::StringRef StackSlotLabel, ValueType Value) { if (Action == PSK_Reset) { CurrentValue = nullptr; return; } if (Action & PSK_Push) Stack.push_back(Slot(StackSlotLabel, CurrentValue, CurrentPragmaLocation)); else if (Action & PSK_Pop) { if (!StackSlotLabel.empty()) { // If we've got a label, try to find it and jump there. auto I = std::find_if(Stack.rbegin(), Stack.rend(), [&](const Slot &x) { return x.StackSlotLabel == StackSlotLabel; }); // If we found the label so pop from there. if (I != Stack.rend()) { CurrentValue = I->Value; CurrentPragmaLocation = I->PragmaLocation; Stack.erase(std::prev(I.base()), Stack.end()); } } else if (!Stack.empty()) { // We don't have a label, just pop the last entry. CurrentValue = Stack.back().Value; CurrentPragmaLocation = Stack.back().PragmaLocation; Stack.pop_back(); } } if (Action & PSK_Set) { CurrentValue = Value; CurrentPragmaLocation = PragmaLocation; } } bool Sema::UnifySection(const StringRef &SectionName, int SectionFlags, DeclaratorDecl *Decl) { auto Section = SectionInfos.find(SectionName); if (Section == SectionInfos.end()) { SectionInfos[SectionName] = SectionInfo(Decl, SourceLocation(), SectionFlags); return false; } // A pre-declared section takes precedence w/o diagnostic. if (Section->second.SectionFlags == SectionFlags || !(Section->second.SectionFlags & PSF_Implicit)) return false; auto OtherDecl = Section->second.Decl; Diag(Decl->getLocation(), diag::err_section_conflict) << Decl << OtherDecl; Diag(OtherDecl->getLocation(), diag::note_declared_at) << OtherDecl->getName(); if (auto A = Decl->getAttr()) if (A->isImplicit()) Diag(A->getLocation(), diag::note_pragma_entered_here); if (auto A = OtherDecl->getAttr()) if (A->isImplicit()) Diag(A->getLocation(), diag::note_pragma_entered_here); return false; } bool Sema::UnifySection(const StringRef &SectionName, int SectionFlags, SourceLocation PragmaSectionLocation) { auto Section = SectionInfos.find(SectionName); if (Section != SectionInfos.end()) { if (Section->second.SectionFlags == SectionFlags) return false; if (!(Section->second.SectionFlags & PSF_Implicit)) { Diag(PragmaSectionLocation, diag::err_section_conflict) << "this" << "a prior #pragma section"; Diag(Section->second.PragmaSectionLocation, diag::note_pragma_entered_here); return true; } } SectionInfos[SectionName] = SectionInfo(nullptr, PragmaSectionLocation, SectionFlags); return false; } /// \brief Called on well formed \#pragma bss_seg(). void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation, PragmaMsStackAction Action, llvm::StringRef StackSlotLabel, StringLiteral *SegmentName, llvm::StringRef PragmaName) { PragmaStack *Stack = llvm::StringSwitch *>(PragmaName) .Case("data_seg", &DataSegStack) .Case("bss_seg", &BSSSegStack) .Case("const_seg", &ConstSegStack) .Case("code_seg", &CodeSegStack); if (Action & PSK_Pop && Stack->Stack.empty()) Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName << "stack empty"; Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName); } /// \brief Called on well formed \#pragma bss_seg(). void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation, int SectionFlags, StringLiteral *SegmentName) { UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation); } void Sema::ActOnPragmaMSInitSeg(SourceLocation PragmaLocation, StringLiteral *SegmentName) { // There's no stack to maintain, so we just have a current section. When we // see the default section, reset our current section back to null so we stop // tacking on unnecessary attributes. CurInitSeg = SegmentName->getString() == ".CRT$XCU" ? nullptr : SegmentName; CurInitSegLoc = PragmaLocation; } void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope, SourceLocation PragmaLoc) { IdentifierInfo *Name = IdTok.getIdentifierInfo(); LookupResult Lookup(*this, Name, IdTok.getLocation(), LookupOrdinaryName); LookupParsedName(Lookup, curScope, nullptr, true); if (Lookup.empty()) { Diag(PragmaLoc, diag::warn_pragma_unused_undeclared_var) << Name << SourceRange(IdTok.getLocation()); return; } VarDecl *VD = Lookup.getAsSingle(); if (!VD) { Diag(PragmaLoc, diag::warn_pragma_unused_expected_var_arg) << Name << SourceRange(IdTok.getLocation()); return; } // Warn if this was used before being marked unused. if (VD->isUsed()) Diag(PragmaLoc, diag::warn_used_but_marked_unused) << Name; VD->addAttr(UnusedAttr::CreateImplicit(Context, IdTok.getLocation())); } void Sema::AddCFAuditedAttribute(Decl *D) { SourceLocation Loc = PP.getPragmaARCCFCodeAuditedLoc(); if (!Loc.isValid()) return; // Don't add a redundant or conflicting attribute. if (D->hasAttr() || D->hasAttr()) return; D->addAttr(CFAuditedTransferAttr::CreateImplicit(Context, Loc)); } void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) { if(On) OptimizeOffPragmaLocation = SourceLocation(); else OptimizeOffPragmaLocation = PragmaLoc; } void Sema::AddRangeBasedOptnone(FunctionDecl *FD) { // In the future, check other pragmas if they're implemented (e.g. pragma // optimize 0 will probably map to this functionality too). if(OptimizeOffPragmaLocation.isValid()) AddOptnoneAttributeIfNoConflicts(FD, OptimizeOffPragmaLocation); } void Sema::AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc) { // Don't add a conflicting attribute. No diagnostic is needed. if (FD->hasAttr() || FD->hasAttr()) return; // Add attributes only if required. Optnone requires noinline as well, but if // either is already present then don't bother adding them. if (!FD->hasAttr()) FD->addAttr(OptimizeNoneAttr::CreateImplicit(Context, Loc)); if (!FD->hasAttr()) FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc)); } typedef std::vector > VisStack; enum : unsigned { NoVisibility = ~0U }; void Sema::AddPushedVisibilityAttribute(Decl *D) { if (!VisContext) return; NamedDecl *ND = dyn_cast(D); if (ND && ND->getExplicitVisibility(NamedDecl::VisibilityForValue)) return; VisStack *Stack = static_cast(VisContext); unsigned rawType = Stack->back().first; if (rawType == NoVisibility) return; VisibilityAttr::VisibilityType type = (VisibilityAttr::VisibilityType) rawType; SourceLocation loc = Stack->back().second; D->addAttr(VisibilityAttr::CreateImplicit(Context, type, loc)); } /// FreeVisContext - Deallocate and null out VisContext. void Sema::FreeVisContext() { delete static_cast(VisContext); VisContext = nullptr; } static void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc) { // Put visibility on stack. if (!S.VisContext) S.VisContext = new VisStack; VisStack *Stack = static_cast(S.VisContext); Stack->push_back(std::make_pair(type, loc)); } void Sema::ActOnPragmaVisibility(const IdentifierInfo* VisType, SourceLocation PragmaLoc) { if (VisType) { // Compute visibility to use. VisibilityAttr::VisibilityType T; if (!VisibilityAttr::ConvertStrToVisibilityType(VisType->getName(), T)) { Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType; return; } PushPragmaVisibility(*this, T, PragmaLoc); } else { PopPragmaVisibility(false, PragmaLoc); } } void Sema::ActOnPragmaFPContract(tok::OnOffSwitch OOS) { switch (OOS) { case tok::OOS_ON: FPFeatures.fp_contract = 1; break; case tok::OOS_OFF: FPFeatures.fp_contract = 0; break; case tok::OOS_DEFAULT: FPFeatures.fp_contract = getLangOpts().DefaultFPContract; break; } } void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr, SourceLocation Loc) { // Visibility calculations will consider the namespace's visibility. // Here we just want to note that we're in a visibility context // which overrides any enclosing #pragma context, but doesn't itself // contribute visibility. PushPragmaVisibility(*this, NoVisibility, Loc); } void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) { if (!VisContext) { Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch); return; } // Pop visibility from stack VisStack *Stack = static_cast(VisContext); const std::pair *Back = &Stack->back(); bool StartsWithPragma = Back->first != NoVisibility; if (StartsWithPragma && IsNamespaceEnd) { Diag(Back->second, diag::err_pragma_push_visibility_mismatch); Diag(EndLoc, diag::note_surrounding_namespace_ends_here); // For better error recovery, eat all pushes inside the namespace. do { Stack->pop_back(); Back = &Stack->back(); StartsWithPragma = Back->first != NoVisibility; } while (StartsWithPragma); } else if (!StartsWithPragma && !IsNamespaceEnd) { Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch); Diag(Back->second, diag::note_surrounding_namespace_starts_here); return; } Stack->pop_back(); // To simplify the implementation, never keep around an empty stack. if (Stack->empty()) FreeVisContext(); } @ 1.1.1.3.4.1 log @file SemaAttr.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:29 +0000 @ text @d1 473 @ 1.1.1.3.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 473 //===--- SemaAttr.cpp - Semantic Analysis for Attributes ------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements semantic analysis for non-trivial attributes and // pragmas. // //===----------------------------------------------------------------------===// #include "clang/Sema/SemaInternal.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/Attr.h" #include "clang/AST/Expr.h" #include "clang/Basic/TargetInfo.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/Lookup.h" using namespace clang; //===----------------------------------------------------------------------===// // Pragma 'pack' and 'options align' //===----------------------------------------------------------------------===// namespace { struct PackStackEntry { // We just use a sentinel to represent when the stack is set to mac68k // alignment. static const unsigned kMac68kAlignmentSentinel = ~0U; unsigned Alignment; IdentifierInfo *Name; }; /// PragmaPackStack - Simple class to wrap the stack used by #pragma /// pack. class PragmaPackStack { typedef std::vector stack_ty; /// Alignment - The current user specified alignment. unsigned Alignment; /// Stack - Entries in the #pragma pack stack, consisting of saved /// alignments and optional names. stack_ty Stack; public: PragmaPackStack() : Alignment(0) {} void setAlignment(unsigned A) { Alignment = A; } unsigned getAlignment() { return Alignment; } /// push - Push the current alignment onto the stack, optionally /// using the given \arg Name for the record, if non-zero. void push(IdentifierInfo *Name) { PackStackEntry PSE = { Alignment, Name }; Stack.push_back(PSE); } /// pop - Pop a record from the stack and restore the current /// alignment to the previous value. If \arg Name is non-zero then /// the first such named record is popped, otherwise the top record /// is popped. Returns true if the pop succeeded. bool pop(IdentifierInfo *Name, bool IsReset); }; } // end anonymous namespace. bool PragmaPackStack::pop(IdentifierInfo *Name, bool IsReset) { // If name is empty just pop top. if (!Name) { // An empty stack is a special case... if (Stack.empty()) { // If this isn't a reset, it is always an error. if (!IsReset) return false; // Otherwise, it is an error only if some alignment has been set. if (!Alignment) return false; // Otherwise, reset to the default alignment. Alignment = 0; } else { Alignment = Stack.back().Alignment; Stack.pop_back(); } return true; } // Otherwise, find the named record. for (unsigned i = Stack.size(); i != 0; ) { --i; if (Stack[i].Name == Name) { // Found it, pop up to and including this record. Alignment = Stack[i].Alignment; Stack.erase(Stack.begin() + i, Stack.end()); return true; } } return false; } /// FreePackedContext - Deallocate and null out PackContext. void Sema::FreePackedContext() { delete static_cast(PackContext); PackContext = 0; } void Sema::AddAlignmentAttributesForRecord(RecordDecl *RD) { // If there is no pack context, we don't need any attributes. if (!PackContext) return; PragmaPackStack *Stack = static_cast(PackContext); // Otherwise, check to see if we need a max field alignment attribute. if (unsigned Alignment = Stack->getAlignment()) { if (Alignment == PackStackEntry::kMac68kAlignmentSentinel) RD->addAttr(AlignMac68kAttr::CreateImplicit(Context)); else RD->addAttr(MaxFieldAlignmentAttr::CreateImplicit(Context, Alignment * 8)); } } void Sema::AddMsStructLayoutForRecord(RecordDecl *RD) { if (MSStructPragmaOn) RD->addAttr(MsStructAttr::CreateImplicit(Context)); // FIXME: We should merge AddAlignmentAttributesForRecord with // AddMsStructLayoutForRecord into AddPragmaAttributesForRecord, which takes // all active pragmas and applies them as attributes to class definitions. if (VtorDispModeStack.back() != getLangOpts().VtorDispMode) RD->addAttr( MSVtorDispAttr::CreateImplicit(Context, VtorDispModeStack.back())); } void Sema::ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind, SourceLocation PragmaLoc) { if (PackContext == 0) PackContext = new PragmaPackStack(); PragmaPackStack *Context = static_cast(PackContext); switch (Kind) { // For all targets we support native and natural are the same. // // FIXME: This is not true on Darwin/PPC. case POAK_Native: case POAK_Power: case POAK_Natural: Context->push(0); Context->setAlignment(0); break; // Note that '#pragma options align=packed' is not equivalent to attribute // packed, it has a different precedence relative to attribute aligned. case POAK_Packed: Context->push(0); Context->setAlignment(1); break; case POAK_Mac68k: // Check if the target supports this. if (!PP.getTargetInfo().hasAlignMac68kSupport()) { Diag(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported); return; } Context->push(0); Context->setAlignment(PackStackEntry::kMac68kAlignmentSentinel); break; case POAK_Reset: // Reset just pops the top of the stack, or resets the current alignment to // default. if (!Context->pop(0, /*IsReset=*/true)) { Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed) << "stack empty"; } break; } } void Sema::ActOnPragmaPack(PragmaPackKind Kind, IdentifierInfo *Name, Expr *alignment, SourceLocation PragmaLoc, SourceLocation LParenLoc, SourceLocation RParenLoc) { Expr *Alignment = static_cast(alignment); // If specified then alignment must be a "small" power of two. unsigned AlignmentVal = 0; if (Alignment) { llvm::APSInt Val; // pack(0) is like pack(), which just works out since that is what // we use 0 for in PackAttr. if (Alignment->isTypeDependent() || Alignment->isValueDependent() || !Alignment->isIntegerConstantExpr(Val, Context) || !(Val == 0 || Val.isPowerOf2()) || Val.getZExtValue() > 16) { Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment); return; // Ignore } AlignmentVal = (unsigned) Val.getZExtValue(); } if (PackContext == 0) PackContext = new PragmaPackStack(); PragmaPackStack *Context = static_cast(PackContext); switch (Kind) { case Sema::PPK_Default: // pack([n]) Context->setAlignment(AlignmentVal); break; case Sema::PPK_Show: // pack(show) // Show the current alignment, making sure to show the right value // for the default. AlignmentVal = Context->getAlignment(); // FIXME: This should come from the target. if (AlignmentVal == 0) AlignmentVal = 8; if (AlignmentVal == PackStackEntry::kMac68kAlignmentSentinel) Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k"; else Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal; break; case Sema::PPK_Push: // pack(push [, id] [, [n]) Context->push(Name); // Set the new alignment if specified. if (Alignment) Context->setAlignment(AlignmentVal); break; case Sema::PPK_Pop: // pack(pop [, id] [, n]) // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack: // "#pragma pack(pop, identifier, n) is undefined" if (Alignment && Name) Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifer_and_alignment); // Do the pop. if (!Context->pop(Name, /*IsReset=*/false)) { // If a name was specified then failure indicates the name // wasn't found. Otherwise failure indicates the stack was // empty. Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << (Name ? "no record matching name" : "stack empty"); // FIXME: Warn about popping named records as MSVC does. } else { // Pop succeeded, set the new alignment if specified. if (Alignment) Context->setAlignment(AlignmentVal); } break; } } void Sema::ActOnPragmaMSStruct(PragmaMSStructKind Kind) { MSStructPragmaOn = (Kind == PMSST_ON); } void Sema::ActOnPragmaMSComment(PragmaMSCommentKind Kind, StringRef Arg) { // FIXME: Serialize this. switch (Kind) { case PCK_Unknown: llvm_unreachable("unexpected pragma comment kind"); case PCK_Linker: Consumer.HandleLinkerOptionPragma(Arg); return; case PCK_Lib: Consumer.HandleDependentLibrary(Arg); return; case PCK_Compiler: case PCK_ExeStr: case PCK_User: return; // We ignore all of these. } llvm_unreachable("invalid pragma comment kind"); } void Sema::ActOnPragmaDetectMismatch(StringRef Name, StringRef Value) { // FIXME: Serialize this. Consumer.HandleDetectMismatch(Name, Value); } void Sema::ActOnPragmaMSPointersToMembers( LangOptions::PragmaMSPointersToMembersKind RepresentationMethod, SourceLocation PragmaLoc) { MSPointerToMemberRepresentationMethod = RepresentationMethod; ImplicitMSInheritanceAttrLoc = PragmaLoc; } void Sema::ActOnPragmaMSVtorDisp(PragmaVtorDispKind Kind, SourceLocation PragmaLoc, MSVtorDispAttr::Mode Mode) { switch (Kind) { case PVDK_Set: VtorDispModeStack.back() = Mode; break; case PVDK_Push: VtorDispModeStack.push_back(Mode); break; case PVDK_Reset: VtorDispModeStack.clear(); VtorDispModeStack.push_back(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)); break; case PVDK_Pop: VtorDispModeStack.pop_back(); if (VtorDispModeStack.empty()) { Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "vtordisp" << "stack empty"; VtorDispModeStack.push_back(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)); } break; } } void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope, SourceLocation PragmaLoc) { IdentifierInfo *Name = IdTok.getIdentifierInfo(); LookupResult Lookup(*this, Name, IdTok.getLocation(), LookupOrdinaryName); LookupParsedName(Lookup, curScope, NULL, true); if (Lookup.empty()) { Diag(PragmaLoc, diag::warn_pragma_unused_undeclared_var) << Name << SourceRange(IdTok.getLocation()); return; } VarDecl *VD = Lookup.getAsSingle(); if (!VD) { Diag(PragmaLoc, diag::warn_pragma_unused_expected_var_arg) << Name << SourceRange(IdTok.getLocation()); return; } // Warn if this was used before being marked unused. if (VD->isUsed()) Diag(PragmaLoc, diag::warn_used_but_marked_unused) << Name; VD->addAttr(UnusedAttr::CreateImplicit(Context, IdTok.getLocation())); } void Sema::AddCFAuditedAttribute(Decl *D) { SourceLocation Loc = PP.getPragmaARCCFCodeAuditedLoc(); if (!Loc.isValid()) return; // Don't add a redundant or conflicting attribute. if (D->hasAttr() || D->hasAttr()) return; D->addAttr(CFAuditedTransferAttr::CreateImplicit(Context, Loc)); } typedef std::vector > VisStack; enum LLVM_ENUM_INT_TYPE(unsigned) { NoVisibility = ~0U }; void Sema::AddPushedVisibilityAttribute(Decl *D) { if (!VisContext) return; NamedDecl *ND = dyn_cast(D); if (ND && ND->getExplicitVisibility(NamedDecl::VisibilityForValue)) return; VisStack *Stack = static_cast(VisContext); unsigned rawType = Stack->back().first; if (rawType == NoVisibility) return; VisibilityAttr::VisibilityType type = (VisibilityAttr::VisibilityType) rawType; SourceLocation loc = Stack->back().second; D->addAttr(VisibilityAttr::CreateImplicit(Context, type, loc)); } /// FreeVisContext - Deallocate and null out VisContext. void Sema::FreeVisContext() { delete static_cast(VisContext); VisContext = 0; } static void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc) { // Put visibility on stack. if (!S.VisContext) S.VisContext = new VisStack; VisStack *Stack = static_cast(S.VisContext); Stack->push_back(std::make_pair(type, loc)); } void Sema::ActOnPragmaVisibility(const IdentifierInfo* VisType, SourceLocation PragmaLoc) { if (VisType) { // Compute visibility to use. VisibilityAttr::VisibilityType T; if (!VisibilityAttr::ConvertStrToVisibilityType(VisType->getName(), T)) { Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType; return; } PushPragmaVisibility(*this, T, PragmaLoc); } else { PopPragmaVisibility(false, PragmaLoc); } } void Sema::ActOnPragmaFPContract(tok::OnOffSwitch OOS) { switch (OOS) { case tok::OOS_ON: FPFeatures.fp_contract = 1; break; case tok::OOS_OFF: FPFeatures.fp_contract = 0; break; case tok::OOS_DEFAULT: FPFeatures.fp_contract = getLangOpts().DefaultFPContract; break; } } void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr, SourceLocation Loc) { // Visibility calculations will consider the namespace's visibility. // Here we just want to note that we're in a visibility context // which overrides any enclosing #pragma context, but doesn't itself // contribute visibility. PushPragmaVisibility(*this, NoVisibility, Loc); } void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) { if (!VisContext) { Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch); return; } // Pop visibility from stack VisStack *Stack = static_cast(VisContext); const std::pair *Back = &Stack->back(); bool StartsWithPragma = Back->first != NoVisibility; if (StartsWithPragma && IsNamespaceEnd) { Diag(Back->second, diag::err_pragma_push_visibility_mismatch); Diag(EndLoc, diag::note_surrounding_namespace_ends_here); // For better error recovery, eat all pushes inside the namespace. do { Stack->pop_back(); Back = &Stack->back(); StartsWithPragma = Back->first != NoVisibility; } while (StartsWithPragma); } else if (!StartsWithPragma && !IsNamespaceEnd) { Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch); Diag(Back->second, diag::note_surrounding_namespace_starts_here); return; } Stack->pop_back(); // To simplify the implementation, never keep around an empty stack. if (Stack->empty()) FreeVisContext(); } @