| 1 |
//===--- SemaAttr.cpp - Semantic Analysis for Attributes ------------------===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
// |
| 9 |
// This file implements semantic analysis for non-trivial attributes and |
| 10 |
// pragmas. |
| 11 |
// |
| 12 |
//===----------------------------------------------------------------------===// |
| 13 |
|
| 14 |
#include "clang/AST/ASTConsumer.h" |
| 15 |
#include "clang/AST/Attr.h" |
| 16 |
#include "clang/AST/Expr.h" |
| 17 |
#include "clang/Basic/TargetInfo.h" |
| 18 |
#include "clang/Lex/Preprocessor.h" |
| 19 |
#include "clang/Sema/Lookup.h" |
| 20 |
#include "clang/Sema/SemaInternal.h" |
| 21 |
#include <optional> |
| 22 |
using namespace clang; |
| 23 |
|
| 24 |
//===----------------------------------------------------------------------===// |
| 25 |
// Pragma 'pack' and 'options align' |
| 26 |
//===----------------------------------------------------------------------===// |
| 27 |
|
| 28 |
Sema::PragmaStackSentinelRAII::PragmaStackSentinelRAII(Sema &S, |
| 29 |
StringRef SlotLabel, |
| 30 |
bool ShouldAct) |
| 31 |
: S(S), SlotLabel(SlotLabel), ShouldAct(ShouldAct) { |
| 32 |
if (ShouldAct) { |
| 33 |
S.VtorDispStack.SentinelAction(PSK_Push, SlotLabel); |
| 34 |
S.DataSegStack.SentinelAction(PSK_Push, SlotLabel); |
| 35 |
S.BSSSegStack.SentinelAction(PSK_Push, SlotLabel); |
| 36 |
S.ConstSegStack.SentinelAction(PSK_Push, SlotLabel); |
| 37 |
S.CodeSegStack.SentinelAction(PSK_Push, SlotLabel); |
| 38 |
S.StrictGuardStackCheckStack.SentinelAction(PSK_Push, SlotLabel); |
| 39 |
} |
| 40 |
} |
| 41 |
|
| 42 |
Sema::PragmaStackSentinelRAII::~PragmaStackSentinelRAII() { |
| 43 |
if (ShouldAct) { |
| 44 |
S.VtorDispStack.SentinelAction(PSK_Pop, SlotLabel); |
| 45 |
S.DataSegStack.SentinelAction(PSK_Pop, SlotLabel); |
| 46 |
S.BSSSegStack.SentinelAction(PSK_Pop, SlotLabel); |
| 47 |
S.ConstSegStack.SentinelAction(PSK_Pop, SlotLabel); |
| 48 |
S.CodeSegStack.SentinelAction(PSK_Pop, SlotLabel); |
| 49 |
S.StrictGuardStackCheckStack.SentinelAction(PSK_Pop, SlotLabel); |
| 50 |
} |
| 51 |
} |
| 52 |
|
| 53 |
void Sema::AddAlignmentAttributesForRecord(RecordDecl *RD) { |
| 54 |
AlignPackInfo InfoVal = AlignPackStack.CurrentValue; |
| 55 |
AlignPackInfo::Mode M = InfoVal.getAlignMode(); |
| 56 |
bool IsPackSet = InfoVal.IsPackSet(); |
| 57 |
bool IsXLPragma = getLangOpts().XLPragmaPack; |
| 58 |
|
| 59 |
// If we are not under mac68k/natural alignment mode and also there is no pack |
| 60 |
// value, we don't need any attributes. |
| 61 |
if (!IsPackSet && M != AlignPackInfo::Mac68k && M != AlignPackInfo::Natural) |
| 62 |
return; |
| 63 |
|
| 64 |
if (M == AlignPackInfo::Mac68k && (IsXLPragma || InfoVal.IsAlignAttr())) { |
| 65 |
RD->addAttr(AlignMac68kAttr::CreateImplicit(Context)); |
| 66 |
} else if (IsPackSet) { |
| 67 |
// Check to see if we need a max field alignment attribute. |
| 68 |
RD->addAttr(MaxFieldAlignmentAttr::CreateImplicit( |
| 69 |
Context, InfoVal.getPackNumber() * 8)); |
| 70 |
} |
| 71 |
|
| 72 |
if (IsXLPragma && M == AlignPackInfo::Natural) |
| 73 |
RD->addAttr(AlignNaturalAttr::CreateImplicit(Context)); |
| 74 |
|
| 75 |
if (AlignPackIncludeStack.empty()) |
| 76 |
return; |
| 77 |
// The #pragma align/pack affected a record in an included file, so Clang |
| 78 |
// should warn when that pragma was written in a file that included the |
| 79 |
// included file. |
| 80 |
for (auto &AlignPackedInclude : llvm::reverse(AlignPackIncludeStack)) { |
| 81 |
if (AlignPackedInclude.CurrentPragmaLocation != |
| 82 |
AlignPackStack.CurrentPragmaLocation) |
| 83 |
break; |
| 84 |
if (AlignPackedInclude.HasNonDefaultValue) |
| 85 |
AlignPackedInclude.ShouldWarnOnInclude = true; |
| 86 |
} |
| 87 |
} |
| 88 |
|
| 89 |
void Sema::AddMsStructLayoutForRecord(RecordDecl *RD) { |
| 90 |
if (MSStructPragmaOn) |
| 91 |
RD->addAttr(MSStructAttr::CreateImplicit(Context)); |
| 92 |
|
| 93 |
// FIXME: We should merge AddAlignmentAttributesForRecord with |
| 94 |
// AddMsStructLayoutForRecord into AddPragmaAttributesForRecord, which takes |
| 95 |
// all active pragmas and applies them as attributes to class definitions. |
| 96 |
if (VtorDispStack.CurrentValue != getLangOpts().getVtorDispMode()) |
| 97 |
RD->addAttr(MSVtorDispAttr::CreateImplicit( |
| 98 |
Context, unsigned(VtorDispStack.CurrentValue))); |
| 99 |
} |
| 100 |
|
| 101 |
template <typename Attribute> |
| 102 |
static void addGslOwnerPointerAttributeIfNotExisting(ASTContext &Context, |
| 103 |
CXXRecordDecl *Record) { |
| 104 |
if (Record->hasAttr<OwnerAttr>() || Record->hasAttr<PointerAttr>()) |
| 105 |
return; |
| 106 |
|
| 107 |
for (Decl *Redecl : Record->redecls()) |
| 108 |
Redecl->addAttr(Attribute::CreateImplicit(Context, /*DerefType=*/nullptr)); |
| 109 |
} |
| 110 |
|
| 111 |
void Sema::inferGslPointerAttribute(NamedDecl *ND, |
| 112 |
CXXRecordDecl *UnderlyingRecord) { |
| 113 |
if (!UnderlyingRecord) |
| 114 |
return; |
| 115 |
|
| 116 |
const auto *Parent = dyn_cast<CXXRecordDecl>(ND->getDeclContext()); |
| 117 |
if (!Parent) |
| 118 |
return; |
| 119 |
|
| 120 |
static llvm::StringSet<> Containers{ |
| 121 |
"array", |
| 122 |
"basic_string", |
| 123 |
"deque", |
| 124 |
"forward_list", |
| 125 |
"vector", |
| 126 |
"list", |
| 127 |
"map", |
| 128 |
"multiset", |
| 129 |
"multimap", |
| 130 |
"priority_queue", |
| 131 |
"queue", |
| 132 |
"set", |
| 133 |
"stack", |
| 134 |
"unordered_set", |
| 135 |
"unordered_map", |
| 136 |
"unordered_multiset", |
| 137 |
"unordered_multimap", |
| 138 |
}; |
| 139 |
|
| 140 |
static llvm::StringSet<> Iterators{"iterator", "const_iterator", |
| 141 |
"reverse_iterator", |
| 142 |
"const_reverse_iterator"}; |
| 143 |
|
| 144 |
if (Parent->isInStdNamespace() && Iterators.count(ND->getName()) && |
| 145 |
Containers.count(Parent->getName())) |
| 146 |
addGslOwnerPointerAttributeIfNotExisting<PointerAttr>(Context, |
| 147 |
UnderlyingRecord); |
| 148 |
} |
| 149 |
|
| 150 |
void Sema::inferGslPointerAttribute(TypedefNameDecl *TD) { |
| 151 |
|
| 152 |
QualType Canonical = TD->getUnderlyingType().getCanonicalType(); |
| 153 |
|
| 154 |
CXXRecordDecl *RD = Canonical->getAsCXXRecordDecl(); |
| 155 |
if (!RD) { |
| 156 |
if (auto *TST = |
| 157 |
dyn_cast<TemplateSpecializationType>(Canonical.getTypePtr())) { |
| 158 |
|
| 159 |
RD = dyn_cast_or_null<CXXRecordDecl>( |
| 160 |
TST->getTemplateName().getAsTemplateDecl()->getTemplatedDecl()); |
| 161 |
} |
| 162 |
} |
| 163 |
|
| 164 |
inferGslPointerAttribute(TD, RD); |
| 165 |
} |
| 166 |
|
| 167 |
void Sema::inferGslOwnerPointerAttribute(CXXRecordDecl *Record) { |
| 168 |
static llvm::StringSet<> StdOwners{ |
| 169 |
"any", |
| 170 |
"array", |
| 171 |
"basic_regex", |
| 172 |
"basic_string", |
| 173 |
"deque", |
| 174 |
"forward_list", |
| 175 |
"vector", |
| 176 |
"list", |
| 177 |
"map", |
| 178 |
"multiset", |
| 179 |
"multimap", |
| 180 |
"optional", |
| 181 |
"priority_queue", |
| 182 |
"queue", |
| 183 |
"set", |
| 184 |
"stack", |
| 185 |
"unique_ptr", |
| 186 |
"unordered_set", |
| 187 |
"unordered_map", |
| 188 |
"unordered_multiset", |
| 189 |
"unordered_multimap", |
| 190 |
"variant", |
| 191 |
}; |
| 192 |
static llvm::StringSet<> StdPointers{ |
| 193 |
"basic_string_view", |
| 194 |
"reference_wrapper", |
| 195 |
"regex_iterator", |
| 196 |
}; |
| 197 |
|
| 198 |
if (!Record->getIdentifier()) |
| 199 |
return; |
| 200 |
|
| 201 |
// Handle classes that directly appear in std namespace. |
| 202 |
if (Record->isInStdNamespace()) { |
| 203 |
if (Record->hasAttr<OwnerAttr>() || Record->hasAttr<PointerAttr>()) |
| 204 |
return; |
| 205 |
|
| 206 |
if (StdOwners.count(Record->getName())) |
| 207 |
addGslOwnerPointerAttributeIfNotExisting<OwnerAttr>(Context, Record); |
| 208 |
else if (StdPointers.count(Record->getName())) |
| 209 |
addGslOwnerPointerAttributeIfNotExisting<PointerAttr>(Context, Record); |
| 210 |
|
| 211 |
return; |
| 212 |
} |
| 213 |
|
| 214 |
// Handle nested classes that could be a gsl::Pointer. |
| 215 |
inferGslPointerAttribute(Record, Record); |
| 216 |
} |
| 217 |
|
| 218 |
void Sema::ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind, |
| 219 |
SourceLocation PragmaLoc) { |
| 220 |
PragmaMsStackAction Action = Sema::PSK_Reset; |
| 221 |
AlignPackInfo::Mode ModeVal = AlignPackInfo::Native; |
| 222 |
|
| 223 |
switch (Kind) { |
| 224 |
// For most of the platforms we support, native and natural are the same. |
| 225 |
// With XL, native is the same as power, natural means something else. |
| 226 |
// |
| 227 |
// FIXME: This is not true on Darwin/PPC. |
| 228 |
case POAK_Native: |
| 229 |
case POAK_Power: |
| 230 |
Action = Sema::PSK_Push_Set; |
| 231 |
break; |
| 232 |
case POAK_Natural: |
| 233 |
Action = Sema::PSK_Push_Set; |
| 234 |
ModeVal = AlignPackInfo::Natural; |
| 235 |
break; |
| 236 |
|
| 237 |
// Note that '#pragma options align=packed' is not equivalent to attribute |
| 238 |
// packed, it has a different precedence relative to attribute aligned. |
| 239 |
case POAK_Packed: |
| 240 |
Action = Sema::PSK_Push_Set; |
| 241 |
ModeVal = AlignPackInfo::Packed; |
| 242 |
break; |
| 243 |
|
| 244 |
case POAK_Mac68k: |
| 245 |
// Check if the target supports this. |
| 246 |
if (!this->Context.getTargetInfo().hasAlignMac68kSupport()) { |
| 247 |
Diag(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported); |
| 248 |
return; |
| 249 |
} |
| 250 |
Action = Sema::PSK_Push_Set; |
| 251 |
ModeVal = AlignPackInfo::Mac68k; |
| 252 |
break; |
| 253 |
case POAK_Reset: |
| 254 |
// Reset just pops the top of the stack, or resets the current alignment to |
| 255 |
// default. |
| 256 |
Action = Sema::PSK_Pop; |
| 257 |
if (AlignPackStack.Stack.empty()) { |
| 258 |
if (AlignPackStack.CurrentValue.getAlignMode() != AlignPackInfo::Native || |
| 259 |
AlignPackStack.CurrentValue.IsPackAttr()) { |
| 260 |
Action = Sema::PSK_Reset; |
| 261 |
} else { |
| 262 |
Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed) |
| 263 |
<< "stack empty"; |
| 264 |
return; |
| 265 |
} |
| 266 |
} |
| 267 |
break; |
| 268 |
} |
| 269 |
|
| 270 |
AlignPackInfo Info(ModeVal, getLangOpts().XLPragmaPack); |
| 271 |
|
| 272 |
AlignPackStack.Act(PragmaLoc, Action, StringRef(), Info); |
| 273 |
} |
| 274 |
|
| 275 |
void Sema::ActOnPragmaClangSection(SourceLocation PragmaLoc, |
| 276 |
PragmaClangSectionAction Action, |
| 277 |
PragmaClangSectionKind SecKind, |
| 278 |
StringRef SecName) { |
| 279 |
PragmaClangSection *CSec; |
| 280 |
int SectionFlags = ASTContext::PSF_Read; |
| 281 |
switch (SecKind) { |
| 282 |
case PragmaClangSectionKind::PCSK_BSS: |
| 283 |
CSec = &PragmaClangBSSSection; |
| 284 |
SectionFlags |= ASTContext::PSF_Write | ASTContext::PSF_ZeroInit; |
| 285 |
break; |
| 286 |
case PragmaClangSectionKind::PCSK_Data: |
| 287 |
CSec = &PragmaClangDataSection; |
| 288 |
SectionFlags |= ASTContext::PSF_Write; |
| 289 |
break; |
| 290 |
case PragmaClangSectionKind::PCSK_Rodata: |
| 291 |
CSec = &PragmaClangRodataSection; |
| 292 |
break; |
| 293 |
case PragmaClangSectionKind::PCSK_Relro: |
| 294 |
CSec = &PragmaClangRelroSection; |
| 295 |
break; |
| 296 |
case PragmaClangSectionKind::PCSK_Text: |
| 297 |
CSec = &PragmaClangTextSection; |
| 298 |
SectionFlags |= ASTContext::PSF_Execute; |
| 299 |
break; |
| 300 |
default: |
| 301 |
llvm_unreachable("invalid clang section kind"); |
| 302 |
} |
| 303 |
|
| 304 |
if (Action == PragmaClangSectionAction::PCSA_Clear) { |
| 305 |
CSec->Valid = false; |
| 306 |
return; |
| 307 |
} |
| 308 |
|
| 309 |
if (llvm::Error E = isValidSectionSpecifier(SecName)) { |
| 310 |
Diag(PragmaLoc, diag::err_pragma_section_invalid_for_target) |
| 311 |
<< toString(std::move(E)); |
| 312 |
CSec->Valid = false; |
| 313 |
return; |
| 314 |
} |
| 315 |
|
| 316 |
if (UnifySection(SecName, SectionFlags, PragmaLoc)) |
| 317 |
return; |
| 318 |
|
| 319 |
CSec->Valid = true; |
| 320 |
CSec->SectionName = std::string(SecName); |
| 321 |
CSec->PragmaLocation = PragmaLoc; |
| 322 |
} |
| 323 |
|
| 324 |
void Sema::ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action, |
| 325 |
StringRef SlotLabel, Expr *alignment) { |
| 326 |
bool IsXLPragma = getLangOpts().XLPragmaPack; |
| 327 |
// XL pragma pack does not support identifier syntax. |
| 328 |
if (IsXLPragma && !SlotLabel.empty()) { |
| 329 |
Diag(PragmaLoc, diag::err_pragma_pack_identifer_not_supported); |
| 330 |
return; |
| 331 |
} |
| 332 |
|
| 333 |
const AlignPackInfo CurVal = AlignPackStack.CurrentValue; |
| 334 |
Expr *Alignment = static_cast<Expr *>(alignment); |
| 335 |
|
| 336 |
// If specified then alignment must be a "small" power of two. |
| 337 |
unsigned AlignmentVal = 0; |
| 338 |
AlignPackInfo::Mode ModeVal = CurVal.getAlignMode(); |
| 339 |
|
| 340 |
if (Alignment) { |
| 341 |
std::optional<llvm::APSInt> Val; |
| 342 |
Val = Alignment->getIntegerConstantExpr(Context); |
| 343 |
|
| 344 |
// pack(0) is like pack(), which just works out since that is what |
| 345 |
// we use 0 for in PackAttr. |
| 346 |
if (Alignment->isTypeDependent() || !Val || |
| 347 |
!(*Val == 0 || Val->isPowerOf2()) || Val->getZExtValue() > 16) { |
| 348 |
Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment); |
| 349 |
return; // Ignore |
| 350 |
} |
| 351 |
|
| 352 |
if (IsXLPragma && *Val == 0) { |
| 353 |
// pack(0) does not work out with XL. |
| 354 |
Diag(PragmaLoc, diag::err_pragma_pack_invalid_alignment); |
| 355 |
return; // Ignore |
| 356 |
} |
| 357 |
|
| 358 |
AlignmentVal = (unsigned)Val->getZExtValue(); |
| 359 |
} |
| 360 |
|
| 361 |
if (Action == Sema::PSK_Show) { |
| 362 |
// Show the current alignment, making sure to show the right value |
| 363 |
// for the default. |
| 364 |
// FIXME: This should come from the target. |
| 365 |
AlignmentVal = CurVal.IsPackSet() ? CurVal.getPackNumber() : 8; |
| 366 |
if (ModeVal == AlignPackInfo::Mac68k && |
| 367 |
(IsXLPragma || CurVal.IsAlignAttr())) |
| 368 |
Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k"; |
| 369 |
else |
| 370 |
Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal; |
| 371 |
} |
| 372 |
|
| 373 |
// MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack: |
| 374 |
// "#pragma pack(pop, identifier, n) is undefined" |
| 375 |
if (Action & Sema::PSK_Pop) { |
| 376 |
if (Alignment && !SlotLabel.empty()) |
| 377 |
Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifier_and_alignment); |
| 378 |
if (AlignPackStack.Stack.empty()) { |
| 379 |
assert(CurVal.getAlignMode() == AlignPackInfo::Native && |
| 380 |
"Empty pack stack can only be at Native alignment mode."); |
| 381 |
Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << "stack empty"; |
| 382 |
} |
| 383 |
} |
| 384 |
|
| 385 |
AlignPackInfo Info(ModeVal, AlignmentVal, IsXLPragma); |
| 386 |
|
| 387 |
AlignPackStack.Act(PragmaLoc, Action, SlotLabel, Info); |
| 388 |
} |
| 389 |
|
| 390 |
bool Sema::ConstantFoldAttrArgs(const AttributeCommonInfo &CI, |
| 391 |
MutableArrayRef<Expr *> Args) { |
| 392 |
llvm::SmallVector<PartialDiagnosticAt, 8> Notes; |
| 393 |
for (unsigned Idx = 0; Idx < Args.size(); Idx++) { |
| 394 |
Expr *&E = Args.begin()[Idx]; |
| 395 |
assert(E && "error are handled before"); |
| 396 |
if (E->isValueDependent() || E->isTypeDependent()) |
| 397 |
continue; |
| 398 |
|
| 399 |
// FIXME: Use DefaultFunctionArrayLValueConversion() in place of the logic |
| 400 |
// that adds implicit casts here. |
| 401 |
if (E->getType()->isArrayType()) |
| 402 |
E = ImpCastExprToType(E, Context.getPointerType(E->getType()), |
| 403 |
clang::CK_ArrayToPointerDecay) |
| 404 |
.get(); |
| 405 |
if (E->getType()->isFunctionType()) |
| 406 |
E = ImplicitCastExpr::Create(Context, |
| 407 |
Context.getPointerType(E->getType()), |
| 408 |
clang::CK_FunctionToPointerDecay, E, nullptr, |
| 409 |
VK_PRValue, FPOptionsOverride()); |
| 410 |
if (E->isLValue()) |
| 411 |
E = ImplicitCastExpr::Create(Context, E->getType().getNonReferenceType(), |
| 412 |
clang::CK_LValueToRValue, E, nullptr, |
| 413 |
VK_PRValue, FPOptionsOverride()); |
| 414 |
|
| 415 |
Expr::EvalResult Eval; |
| 416 |
Notes.clear(); |
| 417 |
Eval.Diag = &Notes; |
| 418 |
|
| 419 |
bool Result = E->EvaluateAsConstantExpr(Eval, Context); |
| 420 |
|
| 421 |
/// Result means the expression can be folded to a constant. |
| 422 |
/// Note.empty() means the expression is a valid constant expression in the |
| 423 |
/// current language mode. |
| 424 |
if (!Result || !Notes.empty()) { |
| 425 |
Diag(E->getBeginLoc(), diag::err_attribute_argument_n_type) |
| 426 |
<< CI << (Idx + 1) << AANT_ArgumentConstantExpr; |
| 427 |
for (auto &Note : Notes) |
| 428 |
Diag(Note.first, Note.second); |
| 429 |
return false; |
| 430 |
} |
| 431 |
assert(Eval.Val.hasValue()); |
| 432 |
E = ConstantExpr::Create(Context, E, Eval.Val); |
| 433 |
} |
| 434 |
|
| 435 |
return true; |
| 436 |
} |
| 437 |
|
| 438 |
void Sema::DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind, |
| 439 |
SourceLocation IncludeLoc) { |
| 440 |
if (Kind == PragmaAlignPackDiagnoseKind::NonDefaultStateAtInclude) { |
| 441 |
SourceLocation PrevLocation = AlignPackStack.CurrentPragmaLocation; |
| 442 |
// Warn about non-default alignment at #includes (without redundant |
| 443 |
// warnings for the same directive in nested includes). |
| 444 |
// The warning is delayed until the end of the file to avoid warnings |
| 445 |
// for files that don't have any records that are affected by the modified |
| 446 |
// alignment. |
| 447 |
bool HasNonDefaultValue = |
| 448 |
AlignPackStack.hasValue() && |
| 449 |
(AlignPackIncludeStack.empty() || |
| 450 |
AlignPackIncludeStack.back().CurrentPragmaLocation != PrevLocation); |
| 451 |
AlignPackIncludeStack.push_back( |
| 452 |
{AlignPackStack.CurrentValue, |
| 453 |
AlignPackStack.hasValue() ? PrevLocation : SourceLocation(), |
| 454 |
HasNonDefaultValue, /*ShouldWarnOnInclude*/ false}); |
| 455 |
return; |
| 456 |
} |
| 457 |
|
| 458 |
assert(Kind == PragmaAlignPackDiagnoseKind::ChangedStateAtExit && |
| 459 |
"invalid kind"); |
| 460 |
AlignPackIncludeState PrevAlignPackState = |
| 461 |
AlignPackIncludeStack.pop_back_val(); |
| 462 |
// FIXME: AlignPackStack may contain both #pragma align and #pragma pack |
| 463 |
// information, diagnostics below might not be accurate if we have mixed |
| 464 |
// pragmas. |
| 465 |
if (PrevAlignPackState.ShouldWarnOnInclude) { |
| 466 |
// Emit the delayed non-default alignment at #include warning. |
| 467 |
Diag(IncludeLoc, diag::warn_pragma_pack_non_default_at_include); |
| 468 |
Diag(PrevAlignPackState.CurrentPragmaLocation, diag::note_pragma_pack_here); |
| 469 |
} |
| 470 |
// Warn about modified alignment after #includes. |
| 471 |
if (PrevAlignPackState.CurrentValue != AlignPackStack.CurrentValue) { |
| 472 |
Diag(IncludeLoc, diag::warn_pragma_pack_modified_after_include); |
| 473 |
Diag(AlignPackStack.CurrentPragmaLocation, diag::note_pragma_pack_here); |
| 474 |
} |
| 475 |
} |
| 476 |
|
| 477 |
void Sema::DiagnoseUnterminatedPragmaAlignPack() { |
| 478 |
if (AlignPackStack.Stack.empty()) |
| 479 |
return; |
| 480 |
bool IsInnermost = true; |
| 481 |
|
| 482 |
// FIXME: AlignPackStack may contain both #pragma align and #pragma pack |
| 483 |
// information, diagnostics below might not be accurate if we have mixed |
| 484 |
// pragmas. |
| 485 |
for (const auto &StackSlot : llvm::reverse(AlignPackStack.Stack)) { |
| 486 |
Diag(StackSlot.PragmaPushLocation, diag::warn_pragma_pack_no_pop_eof); |
| 487 |
// The user might have already reset the alignment, so suggest replacing |
| 488 |
// the reset with a pop. |
| 489 |
if (IsInnermost && |
| 490 |
AlignPackStack.CurrentValue == AlignPackStack.DefaultValue) { |
| 491 |
auto DB = Diag(AlignPackStack.CurrentPragmaLocation, |
| 492 |
diag::note_pragma_pack_pop_instead_reset); |
| 493 |
SourceLocation FixItLoc = |
| 494 |
Lexer::findLocationAfterToken(AlignPackStack.CurrentPragmaLocation, |
| 495 |
tok::l_paren, SourceMgr, LangOpts, |
| 496 |
/*SkipTrailing=*/false); |
| 497 |
if (FixItLoc.isValid()) |
| 498 |
DB << FixItHint::CreateInsertion(FixItLoc, "pop"); |
| 499 |
} |
| 500 |
IsInnermost = false; |
| 501 |
} |
| 502 |
} |
| 503 |
|
| 504 |
void Sema::ActOnPragmaMSStruct(PragmaMSStructKind Kind) { |
| 505 |
MSStructPragmaOn = (Kind == PMSST_ON); |
| 506 |
} |
| 507 |
|
| 508 |
void Sema::ActOnPragmaMSComment(SourceLocation CommentLoc, |
| 509 |
PragmaMSCommentKind Kind, StringRef Arg) { |
| 510 |
auto *PCD = PragmaCommentDecl::Create( |
| 511 |
Context, Context.getTranslationUnitDecl(), CommentLoc, Kind, Arg); |
| 512 |
Context.getTranslationUnitDecl()->addDecl(PCD); |
| 513 |
Consumer.HandleTopLevelDecl(DeclGroupRef(PCD)); |
| 514 |
} |
| 515 |
|
| 516 |
void Sema::ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name, |
| 517 |
StringRef Value) { |
| 518 |
auto *PDMD = PragmaDetectMismatchDecl::Create( |
| 519 |
Context, Context.getTranslationUnitDecl(), Loc, Name, Value); |
| 520 |
Context.getTranslationUnitDecl()->addDecl(PDMD); |
| 521 |
Consumer.HandleTopLevelDecl(DeclGroupRef(PDMD)); |
| 522 |
} |
| 523 |
|
| 524 |
void Sema::ActOnPragmaFPEvalMethod(SourceLocation Loc, |
| 525 |
LangOptions::FPEvalMethodKind Value) { |
| 526 |
FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides(); |
| 527 |
switch (Value) { |
| 528 |
default: |
| 529 |
llvm_unreachable("invalid pragma eval_method kind"); |
| 530 |
case LangOptions::FEM_Source: |
| 531 |
NewFPFeatures.setFPEvalMethodOverride(LangOptions::FEM_Source); |
| 532 |
break; |
| 533 |
case LangOptions::FEM_Double: |
| 534 |
NewFPFeatures.setFPEvalMethodOverride(LangOptions::FEM_Double); |
| 535 |
break; |
| 536 |
case LangOptions::FEM_Extended: |
| 537 |
NewFPFeatures.setFPEvalMethodOverride(LangOptions::FEM_Extended); |
| 538 |
break; |
| 539 |
} |
| 540 |
if (getLangOpts().ApproxFunc) |
| 541 |
Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 0; |
| 542 |
if (getLangOpts().AllowFPReassoc) |
| 543 |
Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 1; |
| 544 |
if (getLangOpts().AllowRecip) |
| 545 |
Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context) << 0 << 2; |
| 546 |
FpPragmaStack.Act(Loc, PSK_Set, StringRef(), NewFPFeatures); |
| 547 |
CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts()); |
| 548 |
PP.setCurrentFPEvalMethod(Loc, Value); |
| 549 |
} |
| 550 |
|
| 551 |
void Sema::ActOnPragmaFloatControl(SourceLocation Loc, |
| 552 |
PragmaMsStackAction Action, |
| 553 |
PragmaFloatControlKind Value) { |
| 554 |
FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides(); |
| 555 |
if ((Action == PSK_Push_Set || Action == PSK_Push || Action == PSK_Pop) && |
| 556 |
!CurContext->getRedeclContext()->isFileContext()) { |
| 557 |
// Push and pop can only occur at file or namespace scope, or within a |
| 558 |
// language linkage declaration. |
| 559 |
Diag(Loc, diag::err_pragma_fc_pp_scope); |
| 560 |
return; |
| 561 |
} |
| 562 |
switch (Value) { |
| 563 |
default: |
| 564 |
llvm_unreachable("invalid pragma float_control kind"); |
| 565 |
case PFC_Precise: |
| 566 |
NewFPFeatures.setFPPreciseEnabled(true); |
| 567 |
FpPragmaStack.Act(Loc, Action, StringRef(), NewFPFeatures); |
| 568 |
break; |
| 569 |
case PFC_NoPrecise: |
| 570 |
if (CurFPFeatures.getExceptionMode() == LangOptions::FPE_Strict) |
| 571 |
Diag(Loc, diag::err_pragma_fc_noprecise_requires_noexcept); |
| 572 |
else if (CurFPFeatures.getAllowFEnvAccess()) |
| 573 |
Diag(Loc, diag::err_pragma_fc_noprecise_requires_nofenv); |
| 574 |
else |
| 575 |
NewFPFeatures.setFPPreciseEnabled(false); |
| 576 |
FpPragmaStack.Act(Loc, Action, StringRef(), NewFPFeatures); |
| 577 |
break; |
| 578 |
case PFC_Except: |
| 579 |
if (!isPreciseFPEnabled()) |
| 580 |
Diag(Loc, diag::err_pragma_fc_except_requires_precise); |
| 581 |
else |
| 582 |
NewFPFeatures.setSpecifiedExceptionModeOverride(LangOptions::FPE_Strict); |
| 583 |
FpPragmaStack.Act(Loc, Action, StringRef(), NewFPFeatures); |
| 584 |
break; |
| 585 |
case PFC_NoExcept: |
| 586 |
NewFPFeatures.setSpecifiedExceptionModeOverride(LangOptions::FPE_Ignore); |
| 587 |
FpPragmaStack.Act(Loc, Action, StringRef(), NewFPFeatures); |
| 588 |
break; |
| 589 |
case PFC_Push: |
| 590 |
FpPragmaStack.Act(Loc, Sema::PSK_Push_Set, StringRef(), NewFPFeatures); |
| 591 |
break; |
| 592 |
case PFC_Pop: |
| 593 |
if (FpPragmaStack.Stack.empty()) { |
| 594 |
Diag(Loc, diag::warn_pragma_pop_failed) << "float_control" |
| 595 |
<< "stack empty"; |
| 596 |
return; |
| 597 |
} |
| 598 |
FpPragmaStack.Act(Loc, Action, StringRef(), NewFPFeatures); |
| 599 |
NewFPFeatures = FpPragmaStack.CurrentValue; |
| 600 |
break; |
| 601 |
} |
| 602 |
CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts()); |
| 603 |
} |
| 604 |
|
| 605 |
void Sema::ActOnPragmaMSPointersToMembers( |
| 606 |
LangOptions::PragmaMSPointersToMembersKind RepresentationMethod, |
| 607 |
SourceLocation PragmaLoc) { |
| 608 |
MSPointerToMemberRepresentationMethod = RepresentationMethod; |
| 609 |
ImplicitMSInheritanceAttrLoc = PragmaLoc; |
| 610 |
} |
| 611 |
|
| 612 |
void Sema::ActOnPragmaMSVtorDisp(PragmaMsStackAction Action, |
| 613 |
SourceLocation PragmaLoc, |
| 614 |
MSVtorDispMode Mode) { |
| 615 |
if (Action & PSK_Pop && VtorDispStack.Stack.empty()) |
| 616 |
Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "vtordisp" |
| 617 |
<< "stack empty"; |
| 618 |
VtorDispStack.Act(PragmaLoc, Action, StringRef(), Mode); |
| 619 |
} |
| 620 |
|
| 621 |
template <> |
| 622 |
void Sema::PragmaStack<Sema::AlignPackInfo>::Act(SourceLocation PragmaLocation, |
| 623 |
PragmaMsStackAction Action, |
| 624 |
llvm::StringRef StackSlotLabel, |
| 625 |
AlignPackInfo Value) { |
| 626 |
if (Action == PSK_Reset) { |
| 627 |
CurrentValue = DefaultValue; |
| 628 |
CurrentPragmaLocation = PragmaLocation; |
| 629 |
return; |
| 630 |
} |
| 631 |
if (Action & PSK_Push) |
| 632 |
Stack.emplace_back(Slot(StackSlotLabel, CurrentValue, CurrentPragmaLocation, |
| 633 |
PragmaLocation)); |
| 634 |
else if (Action & PSK_Pop) { |
| 635 |
if (!StackSlotLabel.empty()) { |
| 636 |
// If we've got a label, try to find it and jump there. |
| 637 |
auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) { |
| 638 |
return x.StackSlotLabel == StackSlotLabel; |
| 639 |
}); |
| 640 |
// We found the label, so pop from there. |
| 641 |
if (I != Stack.rend()) { |
| 642 |
CurrentValue = I->Value; |
| 643 |
CurrentPragmaLocation = I->PragmaLocation; |
| 644 |
Stack.erase(std::prev(I.base()), Stack.end()); |
| 645 |
} |
| 646 |
} else if (Value.IsXLStack() && Value.IsAlignAttr() && |
| 647 |
CurrentValue.IsPackAttr()) { |
| 648 |
// XL '#pragma align(reset)' would pop the stack until |
| 649 |
// a current in effect pragma align is popped. |
| 650 |
auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) { |
| 651 |
return x.Value.IsAlignAttr(); |
| 652 |
}); |
| 653 |
// If we found pragma align so pop from there. |
| 654 |
if (I != Stack.rend()) { |
| 655 |
Stack.erase(std::prev(I.base()), Stack.end()); |
| 656 |
if (Stack.empty()) { |
| 657 |
CurrentValue = DefaultValue; |
| 658 |
CurrentPragmaLocation = PragmaLocation; |
| 659 |
} else { |
| 660 |
CurrentValue = Stack.back().Value; |
| 661 |
CurrentPragmaLocation = Stack.back().PragmaLocation; |
| 662 |
Stack.pop_back(); |
| 663 |
} |
| 664 |
} |
| 665 |
} else if (!Stack.empty()) { |
| 666 |
// xl '#pragma align' sets the baseline, and `#pragma pack` cannot pop |
| 667 |
// over the baseline. |
| 668 |
if (Value.IsXLStack() && Value.IsPackAttr() && CurrentValue.IsAlignAttr()) |
| 669 |
return; |
| 670 |
|
| 671 |
// We don't have a label, just pop the last entry. |
| 672 |
CurrentValue = Stack.back().Value; |
| 673 |
CurrentPragmaLocation = Stack.back().PragmaLocation; |
| 674 |
Stack.pop_back(); |
| 675 |
} |
| 676 |
} |
| 677 |
if (Action & PSK_Set) { |
| 678 |
CurrentValue = Value; |
| 679 |
CurrentPragmaLocation = PragmaLocation; |
| 680 |
} |
| 681 |
} |
| 682 |
|
| 683 |
bool Sema::UnifySection(StringRef SectionName, int SectionFlags, |
| 684 |
NamedDecl *Decl) { |
| 685 |
SourceLocation PragmaLocation; |
| 686 |
if (auto A = Decl->getAttr<SectionAttr>()) |
| 687 |
if (A->isImplicit()) |
| 688 |
PragmaLocation = A->getLocation(); |
| 689 |
auto SectionIt = Context.SectionInfos.find(SectionName); |
| 690 |
if (SectionIt == Context.SectionInfos.end()) { |
| 691 |
Context.SectionInfos[SectionName] = |
| 692 |
ASTContext::SectionInfo(Decl, PragmaLocation, SectionFlags); |
| 693 |
return false; |
| 694 |
} |
| 695 |
// A pre-declared section takes precedence w/o diagnostic. |
| 696 |
const auto &Section = SectionIt->second; |
| 697 |
if (Section.SectionFlags == SectionFlags || |
| 698 |
((SectionFlags & ASTContext::PSF_Implicit) && |
| 699 |
!(Section.SectionFlags & ASTContext::PSF_Implicit))) |
| 700 |
return false; |
| 701 |
Diag(Decl->getLocation(), diag::err_section_conflict) << Decl << Section; |
| 702 |
if (Section.Decl) |
| 703 |
Diag(Section.Decl->getLocation(), diag::note_declared_at) |
| 704 |
<< Section.Decl->getName(); |
| 705 |
if (PragmaLocation.isValid()) |
| 706 |
Diag(PragmaLocation, diag::note_pragma_entered_here); |
| 707 |
if (Section.PragmaSectionLocation.isValid()) |
| 708 |
Diag(Section.PragmaSectionLocation, diag::note_pragma_entered_here); |
| 709 |
return true; |
| 710 |
} |
| 711 |
|
| 712 |
bool Sema::UnifySection(StringRef SectionName, |
| 713 |
int SectionFlags, |
| 714 |
SourceLocation PragmaSectionLocation) { |
| 715 |
auto SectionIt = Context.SectionInfos.find(SectionName); |
| 716 |
if (SectionIt != Context.SectionInfos.end()) { |
| 717 |
const auto &Section = SectionIt->second; |
| 718 |
if (Section.SectionFlags == SectionFlags) |
| 719 |
return false; |
| 720 |
if (!(Section.SectionFlags & ASTContext::PSF_Implicit)) { |
| 721 |
Diag(PragmaSectionLocation, diag::err_section_conflict) |
| 722 |
<< "this" << Section; |
| 723 |
if (Section.Decl) |
| 724 |
Diag(Section.Decl->getLocation(), diag::note_declared_at) |
| 725 |
<< Section.Decl->getName(); |
| 726 |
if (Section.PragmaSectionLocation.isValid()) |
| 727 |
Diag(Section.PragmaSectionLocation, diag::note_pragma_entered_here); |
| 728 |
return true; |
| 729 |
} |
| 730 |
} |
| 731 |
Context.SectionInfos[SectionName] = |
| 732 |
ASTContext::SectionInfo(nullptr, PragmaSectionLocation, SectionFlags); |
| 733 |
return false; |
| 734 |
} |
| 735 |
|
| 736 |
/// Called on well formed \#pragma bss_seg(). |
| 737 |
void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation, |
| 738 |
PragmaMsStackAction Action, |
| 739 |
llvm::StringRef StackSlotLabel, |
| 740 |
StringLiteral *SegmentName, |
| 741 |
llvm::StringRef PragmaName) { |
| 742 |
PragmaStack<StringLiteral *> *Stack = |
| 743 |
llvm::StringSwitch<PragmaStack<StringLiteral *> *>(PragmaName) |
| 744 |
.Case("data_seg", &DataSegStack) |
| 745 |
.Case("bss_seg", &BSSSegStack) |
| 746 |
.Case("const_seg", &ConstSegStack) |
| 747 |
.Case("code_seg", &CodeSegStack); |
| 748 |
if (Action & PSK_Pop && Stack->Stack.empty()) |
| 749 |
Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName |
| 750 |
<< "stack empty"; |
| 751 |
if (SegmentName) { |
| 752 |
if (!checkSectionName(SegmentName->getBeginLoc(), SegmentName->getString())) |
| 753 |
return; |
| 754 |
|
| 755 |
if (SegmentName->getString() == ".drectve" && |
| 756 |
Context.getTargetInfo().getCXXABI().isMicrosoft()) |
| 757 |
Diag(PragmaLocation, diag::warn_attribute_section_drectve) << PragmaName; |
| 758 |
} |
| 759 |
|
| 760 |
Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName); |
| 761 |
} |
| 762 |
|
| 763 |
/// Called on well formed \#pragma strict_gs_check(). |
| 764 |
void Sema::ActOnPragmaMSStrictGuardStackCheck(SourceLocation PragmaLocation, |
| 765 |
PragmaMsStackAction Action, |
| 766 |
bool Value) { |
| 767 |
if (Action & PSK_Pop && StrictGuardStackCheckStack.Stack.empty()) |
| 768 |
Diag(PragmaLocation, diag::warn_pragma_pop_failed) << "strict_gs_check" |
| 769 |
<< "stack empty"; |
| 770 |
|
| 771 |
StrictGuardStackCheckStack.Act(PragmaLocation, Action, StringRef(), Value); |
| 772 |
} |
| 773 |
|
| 774 |
/// Called on well formed \#pragma bss_seg(). |
| 775 |
void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation, |
| 776 |
int SectionFlags, StringLiteral *SegmentName) { |
| 777 |
UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation); |
| 778 |
} |
| 779 |
|
| 780 |
void Sema::ActOnPragmaMSInitSeg(SourceLocation PragmaLocation, |
| 781 |
StringLiteral *SegmentName) { |
| 782 |
// There's no stack to maintain, so we just have a current section. When we |
| 783 |
// see the default section, reset our current section back to null so we stop |
| 784 |
// tacking on unnecessary attributes. |
| 785 |
CurInitSeg = SegmentName->getString() == ".CRT$XCU" ? nullptr : SegmentName; |
| 786 |
CurInitSegLoc = PragmaLocation; |
| 787 |
} |
| 788 |
|
| 789 |
void Sema::ActOnPragmaMSAllocText( |
| 790 |
SourceLocation PragmaLocation, StringRef Section, |
| 791 |
const SmallVector<std::tuple<IdentifierInfo *, SourceLocation>> |
| 792 |
&Functions) { |
| 793 |
if (!CurContext->getRedeclContext()->isFileContext()) { |
| 794 |
Diag(PragmaLocation, diag::err_pragma_expected_file_scope) << "alloc_text"; |
| 795 |
return; |
| 796 |
} |
| 797 |
|
| 798 |
for (auto &Function : Functions) { |
| 799 |
IdentifierInfo *II; |
| 800 |
SourceLocation Loc; |
| 801 |
std::tie(II, Loc) = Function; |
| 802 |
|
| 803 |
DeclarationName DN(II); |
| 804 |
NamedDecl *ND = LookupSingleName(TUScope, DN, Loc, LookupOrdinaryName); |
| 805 |
if (!ND) { |
| 806 |
Diag(Loc, diag::err_undeclared_use) << II->getName(); |
| 807 |
return; |
| 808 |
} |
| 809 |
|
| 810 |
auto *FD = dyn_cast<FunctionDecl>(ND->getCanonicalDecl()); |
| 811 |
if (!FD) { |
| 812 |
Diag(Loc, diag::err_pragma_alloc_text_not_function); |
| 813 |
return; |
| 814 |
} |
| 815 |
|
| 816 |
if (getLangOpts().CPlusPlus && !FD->isInExternCContext()) { |
| 817 |
Diag(Loc, diag::err_pragma_alloc_text_c_linkage); |
| 818 |
return; |
| 819 |
} |
| 820 |
|
| 821 |
FunctionToSectionMap[II->getName()] = std::make_tuple(Section, Loc); |
| 822 |
} |
| 823 |
} |
| 824 |
|
| 825 |
void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope, |
| 826 |
SourceLocation PragmaLoc) { |
| 827 |
|
| 828 |
IdentifierInfo *Name = IdTok.getIdentifierInfo(); |
| 829 |
LookupResult Lookup(*this, Name, IdTok.getLocation(), LookupOrdinaryName); |
| 830 |
LookupParsedName(Lookup, curScope, nullptr, true); |
| 831 |
|
| 832 |
if (Lookup.empty()) { |
| 833 |
Diag(PragmaLoc, diag::warn_pragma_unused_undeclared_var) |
| 834 |
<< Name << SourceRange(IdTok.getLocation()); |
| 835 |
return; |
| 836 |
} |
| 837 |
|
| 838 |
VarDecl *VD = Lookup.getAsSingle<VarDecl>(); |
| 839 |
if (!VD) { |
| 840 |
Diag(PragmaLoc, diag::warn_pragma_unused_expected_var_arg) |
| 841 |
<< Name << SourceRange(IdTok.getLocation()); |
| 842 |
return; |
| 843 |
} |
| 844 |
|
| 845 |
// Warn if this was used before being marked unused. |
| 846 |
if (VD->isUsed()) |
| 847 |
Diag(PragmaLoc, diag::warn_used_but_marked_unused) << Name; |
| 848 |
|
| 849 |
VD->addAttr(UnusedAttr::CreateImplicit(Context, IdTok.getLocation(), |
| 850 |
AttributeCommonInfo::AS_Pragma, |
| 851 |
UnusedAttr::GNU_unused)); |
| 852 |
} |
| 853 |
|
| 854 |
void Sema::AddCFAuditedAttribute(Decl *D) { |
| 855 |
IdentifierInfo *Ident; |
| 856 |
SourceLocation Loc; |
| 857 |
std::tie(Ident, Loc) = PP.getPragmaARCCFCodeAuditedInfo(); |
| 858 |
if (!Loc.isValid()) return; |
| 859 |
|
| 860 |
// Don't add a redundant or conflicting attribute. |
| 861 |
if (D->hasAttr<CFAuditedTransferAttr>() || |
| 862 |
D->hasAttr<CFUnknownTransferAttr>()) |
| 863 |
return; |
| 864 |
|
| 865 |
AttributeCommonInfo Info(Ident, SourceRange(Loc), |
| 866 |
AttributeCommonInfo::AS_Pragma); |
| 867 |
D->addAttr(CFAuditedTransferAttr::CreateImplicit(Context, Info)); |
| 868 |
} |
| 869 |
|
| 870 |
namespace { |
| 871 |
|
| 872 |
std::optional<attr::SubjectMatchRule> |
| 873 |
getParentAttrMatcherRule(attr::SubjectMatchRule Rule) { |
| 874 |
using namespace attr; |
| 875 |
switch (Rule) { |
| 876 |
default: |
| 877 |
return std::nullopt; |
| 878 |
#define ATTR_MATCH_RULE(Value, Spelling, IsAbstract) |
| 879 |
#define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated) \ |
| 880 |
case Value: \ |
| 881 |
return Parent; |
| 882 |
#include "clang/Basic/AttrSubMatchRulesList.inc" |
| 883 |
} |
| 884 |
} |
| 885 |
|
| 886 |
bool isNegatedAttrMatcherSubRule(attr::SubjectMatchRule Rule) { |
| 887 |
using namespace attr; |
| 888 |
switch (Rule) { |
| 889 |
default: |
| 890 |
return false; |
| 891 |
#define ATTR_MATCH_RULE(Value, Spelling, IsAbstract) |
| 892 |
#define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated) \ |
| 893 |
case Value: \ |
| 894 |
return IsNegated; |
| 895 |
#include "clang/Basic/AttrSubMatchRulesList.inc" |
| 896 |
} |
| 897 |
} |
| 898 |
|
| 899 |
CharSourceRange replacementRangeForListElement(const Sema &S, |
| 900 |
SourceRange Range) { |
| 901 |
// Make sure that the ',' is removed as well. |
| 902 |
SourceLocation AfterCommaLoc = Lexer::findLocationAfterToken( |
| 903 |
Range.getEnd(), tok::comma, S.getSourceManager(), S.getLangOpts(), |
| 904 |
/*SkipTrailingWhitespaceAndNewLine=*/false); |
| 905 |
if (AfterCommaLoc.isValid()) |
| 906 |
return CharSourceRange::getCharRange(Range.getBegin(), AfterCommaLoc); |
| 907 |
else |
| 908 |
return CharSourceRange::getTokenRange(Range); |
| 909 |
} |
| 910 |
|
| 911 |
std::string |
| 912 |
attrMatcherRuleListToString(ArrayRef<attr::SubjectMatchRule> Rules) { |
| 913 |
std::string Result; |
| 914 |
llvm::raw_string_ostream OS(Result); |
| 915 |
for (const auto &I : llvm::enumerate(Rules)) { |
| 916 |
if (I.index()) |
| 917 |
OS << (I.index() == Rules.size() - 1 ? ", and " : ", "); |
| 918 |
OS << "'" << attr::getSubjectMatchRuleSpelling(I.value()) << "'"; |
| 919 |
} |
| 920 |
return Result; |
| 921 |
} |
| 922 |
|
| 923 |
} // end anonymous namespace |
| 924 |
|
| 925 |
void Sema::ActOnPragmaAttributeAttribute( |
| 926 |
ParsedAttr &Attribute, SourceLocation PragmaLoc, |
| 927 |
attr::ParsedSubjectMatchRuleSet Rules) { |
| 928 |
Attribute.setIsPragmaClangAttribute(); |
| 929 |
SmallVector<attr::SubjectMatchRule, 4> SubjectMatchRules; |
| 930 |
// Gather the subject match rules that are supported by the attribute. |
| 931 |
SmallVector<std::pair<attr::SubjectMatchRule, bool>, 4> |
| 932 |
StrictSubjectMatchRuleSet; |
| 933 |
Attribute.getMatchRules(LangOpts, StrictSubjectMatchRuleSet); |
| 934 |
|
| 935 |
// Figure out which subject matching rules are valid. |
| 936 |
if (StrictSubjectMatchRuleSet.empty()) { |
| 937 |
// Check for contradicting match rules. Contradicting match rules are |
| 938 |
// either: |
| 939 |
// - a top-level rule and one of its sub-rules. E.g. variable and |
| 940 |
// variable(is_parameter). |
| 941 |
// - a sub-rule and a sibling that's negated. E.g. |
| 942 |
// variable(is_thread_local) and variable(unless(is_parameter)) |
| 943 |
llvm::SmallDenseMap<int, std::pair<int, SourceRange>, 2> |
| 944 |
RulesToFirstSpecifiedNegatedSubRule; |
| 945 |
for (const auto &Rule : Rules) { |
| 946 |
attr::SubjectMatchRule MatchRule = attr::SubjectMatchRule(Rule.first); |
| 947 |
std::optional<attr::SubjectMatchRule> ParentRule = |
| 948 |
getParentAttrMatcherRule(MatchRule); |
| 949 |
if (!ParentRule) |
| 950 |
continue; |
| 951 |
auto It = Rules.find(*ParentRule); |
| 952 |
if (It != Rules.end()) { |
| 953 |
// A sub-rule contradicts a parent rule. |
| 954 |
Diag(Rule.second.getBegin(), |
| 955 |
diag::err_pragma_attribute_matcher_subrule_contradicts_rule) |
| 956 |
<< attr::getSubjectMatchRuleSpelling(MatchRule) |
| 957 |
<< attr::getSubjectMatchRuleSpelling(*ParentRule) << It->second |
| 958 |
<< FixItHint::CreateRemoval( |
| 959 |
replacementRangeForListElement(*this, Rule.second)); |
| 960 |
// Keep going without removing this rule as it won't change the set of |
| 961 |
// declarations that receive the attribute. |
| 962 |
continue; |
| 963 |
} |
| 964 |
if (isNegatedAttrMatcherSubRule(MatchRule)) |
| 965 |
RulesToFirstSpecifiedNegatedSubRule.insert( |
| 966 |
std::make_pair(*ParentRule, Rule)); |
| 967 |
} |
| 968 |
bool IgnoreNegatedSubRules = false; |
| 969 |
for (const auto &Rule : Rules) { |
| 970 |
attr::SubjectMatchRule MatchRule = attr::SubjectMatchRule(Rule.first); |
| 971 |
std::optional<attr::SubjectMatchRule> ParentRule = |
| 972 |
getParentAttrMatcherRule(MatchRule); |
| 973 |
if (!ParentRule) |
| 974 |
continue; |
| 975 |
auto It = RulesToFirstSpecifiedNegatedSubRule.find(*ParentRule); |
| 976 |
if (It != RulesToFirstSpecifiedNegatedSubRule.end() && |
| 977 |
It->second != Rule) { |
| 978 |
// Negated sub-rule contradicts another sub-rule. |
| 979 |
Diag( |
| 980 |
It->second.second.getBegin(), |
| 981 |
diag:: |
| 982 |
err_pragma_attribute_matcher_negated_subrule_contradicts_subrule) |
| 983 |
<< attr::getSubjectMatchRuleSpelling( |
| 984 |
attr::SubjectMatchRule(It->second.first)) |
| 985 |
<< attr::getSubjectMatchRuleSpelling(MatchRule) << Rule.second |
| 986 |
<< FixItHint::CreateRemoval( |
| 987 |
replacementRangeForListElement(*this, It->second.second)); |
| 988 |
// Keep going but ignore all of the negated sub-rules. |
| 989 |
IgnoreNegatedSubRules = true; |
| 990 |
RulesToFirstSpecifiedNegatedSubRule.erase(It); |
| 991 |
} |
| 992 |
} |
| 993 |
|
| 994 |
if (!IgnoreNegatedSubRules) { |
| 995 |
for (const auto &Rule : Rules) |
| 996 |
SubjectMatchRules.push_back(attr::SubjectMatchRule(Rule.first)); |
| 997 |
} else { |
| 998 |
for (const auto &Rule : Rules) { |
| 999 |
if (!isNegatedAttrMatcherSubRule(attr::SubjectMatchRule(Rule.first))) |
| 1000 |
SubjectMatchRules.push_back(attr::SubjectMatchRule(Rule.first)); |
| 1001 |
} |
| 1002 |
} |
| 1003 |
Rules.clear(); |
| 1004 |
} else { |
| 1005 |
// Each rule in Rules must be a strict subset of the attribute's |
| 1006 |
// SubjectMatch rules. I.e. we're allowed to use |
| 1007 |
// `apply_to=variables(is_global)` on an attrubute with SubjectList<[Var]>, |
| 1008 |
// but should not allow `apply_to=variables` on an attribute which has |
| 1009 |
// `SubjectList<[GlobalVar]>`. |
| 1010 |
for (const auto &StrictRule : StrictSubjectMatchRuleSet) { |
| 1011 |
// First, check for exact match. |
| 1012 |
if (Rules.erase(StrictRule.first)) { |
| 1013 |
// Add the rule to the set of attribute receivers only if it's supported |
| 1014 |
// in the current language mode. |
| 1015 |
if (StrictRule.second) |
| 1016 |
SubjectMatchRules.push_back(StrictRule.first); |
| 1017 |
} |
| 1018 |
} |
| 1019 |
// Check remaining rules for subset matches. |
| 1020 |
auto RulesToCheck = Rules; |
| 1021 |
for (const auto &Rule : RulesToCheck) { |
| 1022 |
attr::SubjectMatchRule MatchRule = attr::SubjectMatchRule(Rule.first); |
| 1023 |
if (auto ParentRule = getParentAttrMatcherRule(MatchRule)) { |
| 1024 |
if (llvm::any_of(StrictSubjectMatchRuleSet, |
| 1025 |
[ParentRule](const auto &StrictRule) { |
| 1026 |
return StrictRule.first == *ParentRule && |
| 1027 |
StrictRule.second; // IsEnabled |
| 1028 |
})) { |
| 1029 |
SubjectMatchRules.push_back(MatchRule); |
| 1030 |
Rules.erase(MatchRule); |
| 1031 |
} |
| 1032 |
} |
| 1033 |
} |
| 1034 |
} |
| 1035 |
|
| 1036 |
if (!Rules.empty()) { |
| 1037 |
auto Diagnostic = |
| 1038 |
Diag(PragmaLoc, diag::err_pragma_attribute_invalid_matchers) |
| 1039 |
<< Attribute; |
| 1040 |
SmallVector<attr::SubjectMatchRule, 2> ExtraRules; |
| 1041 |
for (const auto &Rule : Rules) { |
| 1042 |
ExtraRules.push_back(attr::SubjectMatchRule(Rule.first)); |
| 1043 |
Diagnostic << FixItHint::CreateRemoval( |
| 1044 |
replacementRangeForListElement(*this, Rule.second)); |
| 1045 |
} |
| 1046 |
Diagnostic << attrMatcherRuleListToString(ExtraRules); |
| 1047 |
} |
| 1048 |
|
| 1049 |
if (PragmaAttributeStack.empty()) { |
| 1050 |
Diag(PragmaLoc, diag::err_pragma_attr_attr_no_push); |
| 1051 |
return; |
| 1052 |
} |
| 1053 |
|
| 1054 |
PragmaAttributeStack.back().Entries.push_back( |
| 1055 |
{PragmaLoc, &Attribute, std::move(SubjectMatchRules), /*IsUsed=*/false}); |
| 1056 |
} |
| 1057 |
|
| 1058 |
void Sema::ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc, |
| 1059 |
const IdentifierInfo *Namespace) { |
| 1060 |
PragmaAttributeStack.emplace_back(); |
| 1061 |
PragmaAttributeStack.back().Loc = PragmaLoc; |
| 1062 |
PragmaAttributeStack.back().Namespace = Namespace; |
| 1063 |
} |
| 1064 |
|
| 1065 |
void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc, |
| 1066 |
const IdentifierInfo *Namespace) { |
| 1067 |
if (PragmaAttributeStack.empty()) { |
| 1068 |
Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1; |
| 1069 |
return; |
| 1070 |
} |
| 1071 |
|
| 1072 |
// Dig back through the stack trying to find the most recently pushed group |
| 1073 |
// that in Namespace. Note that this works fine if no namespace is present, |
| 1074 |
// think of push/pops without namespaces as having an implicit "nullptr" |
| 1075 |
// namespace. |
| 1076 |
for (size_t Index = PragmaAttributeStack.size(); Index;) { |
| 1077 |
--Index; |
| 1078 |
if (PragmaAttributeStack[Index].Namespace == Namespace) { |
| 1079 |
for (const PragmaAttributeEntry &Entry : |
| 1080 |
PragmaAttributeStack[Index].Entries) { |
| 1081 |
if (!Entry.IsUsed) { |
| 1082 |
assert(Entry.Attribute && "Expected an attribute"); |
| 1083 |
Diag(Entry.Attribute->getLoc(), diag::warn_pragma_attribute_unused) |
| 1084 |
<< *Entry.Attribute; |
| 1085 |
Diag(PragmaLoc, diag::note_pragma_attribute_region_ends_here); |
| 1086 |
} |
| 1087 |
} |
| 1088 |
PragmaAttributeStack.erase(PragmaAttributeStack.begin() + Index); |
| 1089 |
return; |
| 1090 |
} |
| 1091 |
} |
| 1092 |
|
| 1093 |
if (Namespace) |
| 1094 |
Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) |
| 1095 |
<< 0 << Namespace->getName(); |
| 1096 |
else |
| 1097 |
Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1; |
| 1098 |
} |
| 1099 |
|
| 1100 |
void Sema::AddPragmaAttributes(Scope *S, Decl *D) { |
| 1101 |
if (PragmaAttributeStack.empty()) |
| 1102 |
return; |
| 1103 |
for (auto &Group : PragmaAttributeStack) { |
| 1104 |
for (auto &Entry : Group.Entries) { |
| 1105 |
ParsedAttr *Attribute = Entry.Attribute; |
| 1106 |
assert(Attribute && "Expected an attribute"); |
| 1107 |
assert(Attribute->isPragmaClangAttribute() && |
| 1108 |
"expected #pragma clang attribute"); |
| 1109 |
|
| 1110 |
// Ensure that the attribute can be applied to the given declaration. |
| 1111 |
bool Applies = false; |
| 1112 |
for (const auto &Rule : Entry.MatchRules) { |
| 1113 |
if (Attribute->appliesToDecl(D, Rule)) { |
| 1114 |
Applies = true; |
| 1115 |
break; |
| 1116 |
} |
| 1117 |
} |
| 1118 |
if (!Applies) |
| 1119 |
continue; |
| 1120 |
Entry.IsUsed = true; |
| 1121 |
PragmaAttributeCurrentTargetDecl = D; |
| 1122 |
ParsedAttributesView Attrs; |
| 1123 |
Attrs.addAtEnd(Attribute); |
| 1124 |
ProcessDeclAttributeList(S, D, Attrs); |
| 1125 |
PragmaAttributeCurrentTargetDecl = nullptr; |
| 1126 |
} |
| 1127 |
} |
| 1128 |
} |
| 1129 |
|
| 1130 |
void Sema::PrintPragmaAttributeInstantiationPoint() { |
| 1131 |
assert(PragmaAttributeCurrentTargetDecl && "Expected an active declaration"); |
| 1132 |
Diags.Report(PragmaAttributeCurrentTargetDecl->getBeginLoc(), |
| 1133 |
diag::note_pragma_attribute_applied_decl_here); |
| 1134 |
} |
| 1135 |
|
| 1136 |
void Sema::DiagnoseUnterminatedPragmaAttribute() { |
| 1137 |
if (PragmaAttributeStack.empty()) |
| 1138 |
return; |
| 1139 |
Diag(PragmaAttributeStack.back().Loc, diag::err_pragma_attribute_no_pop_eof); |
| 1140 |
} |
| 1141 |
|
| 1142 |
void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) { |
| 1143 |
if(On) |
| 1144 |
OptimizeOffPragmaLocation = SourceLocation(); |
| 1145 |
else |
| 1146 |
OptimizeOffPragmaLocation = PragmaLoc; |
| 1147 |
} |
| 1148 |
|
| 1149 |
void Sema::ActOnPragmaMSOptimize(SourceLocation Loc, bool IsOn) { |
| 1150 |
if (!CurContext->getRedeclContext()->isFileContext()) { |
| 1151 |
Diag(Loc, diag::err_pragma_expected_file_scope) << "optimize"; |
| 1152 |
return; |
| 1153 |
} |
| 1154 |
|
| 1155 |
MSPragmaOptimizeIsOn = IsOn; |
| 1156 |
} |
| 1157 |
|
| 1158 |
void Sema::ActOnPragmaMSFunction( |
| 1159 |
SourceLocation Loc, const llvm::SmallVectorImpl<StringRef> &NoBuiltins) { |
| 1160 |
if (!CurContext->getRedeclContext()->isFileContext()) { |
| 1161 |
Diag(Loc, diag::err_pragma_expected_file_scope) << "function"; |
| 1162 |
return; |
| 1163 |
} |
| 1164 |
|
| 1165 |
MSFunctionNoBuiltins.insert(NoBuiltins.begin(), NoBuiltins.end()); |
| 1166 |
} |
| 1167 |
|
| 1168 |
void Sema::AddRangeBasedOptnone(FunctionDecl *FD) { |
| 1169 |
// In the future, check other pragmas if they're implemented (e.g. pragma |
| 1170 |
// optimize 0 will probably map to this functionality too). |
| 1171 |
if(OptimizeOffPragmaLocation.isValid()) |
| 1172 |
AddOptnoneAttributeIfNoConflicts(FD, OptimizeOffPragmaLocation); |
| 1173 |
} |
| 1174 |
|
| 1175 |
void Sema::AddSectionMSAllocText(FunctionDecl *FD) { |
| 1176 |
if (!FD->getIdentifier()) |
| 1177 |
return; |
| 1178 |
|
| 1179 |
StringRef Name = FD->getName(); |
| 1180 |
auto It = FunctionToSectionMap.find(Name); |
| 1181 |
if (It != FunctionToSectionMap.end()) { |
| 1182 |
StringRef Section; |
| 1183 |
SourceLocation Loc; |
| 1184 |
std::tie(Section, Loc) = It->second; |
| 1185 |
|
| 1186 |
if (!FD->hasAttr<SectionAttr>()) |
| 1187 |
FD->addAttr(SectionAttr::CreateImplicit(Context, Section)); |
| 1188 |
} |
| 1189 |
} |
| 1190 |
|
| 1191 |
void Sema::ModifyFnAttributesMSPragmaOptimize(FunctionDecl *FD) { |
| 1192 |
// Don't modify the function attributes if it's "on". "on" resets the |
| 1193 |
// optimizations to the ones listed on the command line |
| 1194 |
if (!MSPragmaOptimizeIsOn) |
| 1195 |
AddOptnoneAttributeIfNoConflicts(FD, FD->getBeginLoc()); |
| 1196 |
} |
| 1197 |
|
| 1198 |
void Sema::AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, |
| 1199 |
SourceLocation Loc) { |
| 1200 |
// Don't add a conflicting attribute. No diagnostic is needed. |
| 1201 |
if (FD->hasAttr<MinSizeAttr>() || FD->hasAttr<AlwaysInlineAttr>()) |
| 1202 |
return; |
| 1203 |
|
| 1204 |
// Add attributes only if required. Optnone requires noinline as well, but if |
| 1205 |
// either is already present then don't bother adding them. |
| 1206 |
if (!FD->hasAttr<OptimizeNoneAttr>()) |
| 1207 |
FD->addAttr(OptimizeNoneAttr::CreateImplicit(Context, Loc)); |
| 1208 |
if (!FD->hasAttr<NoInlineAttr>()) |
| 1209 |
FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc)); |
| 1210 |
} |
| 1211 |
|
| 1212 |
void Sema::AddImplicitMSFunctionNoBuiltinAttr(FunctionDecl *FD) { |
| 1213 |
SmallVector<StringRef> V(MSFunctionNoBuiltins.begin(), |
| 1214 |
MSFunctionNoBuiltins.end()); |
| 1215 |
if (!MSFunctionNoBuiltins.empty()) |
| 1216 |
FD->addAttr(NoBuiltinAttr::CreateImplicit(Context, V.data(), V.size())); |
| 1217 |
} |
| 1218 |
|
| 1219 |
typedef std::vector<std::pair<unsigned, SourceLocation> > VisStack; |
| 1220 |
enum : unsigned { NoVisibility = ~0U }; |
| 1221 |
|
| 1222 |
void Sema::AddPushedVisibilityAttribute(Decl *D) { |
| 1223 |
if (!VisContext) |
| 1224 |
return; |
| 1225 |
|
| 1226 |
NamedDecl *ND = dyn_cast<NamedDecl>(D); |
| 1227 |
if (ND && ND->getExplicitVisibility(NamedDecl::VisibilityForValue)) |
| 1228 |
return; |
| 1229 |
|
| 1230 |
VisStack *Stack = static_cast<VisStack*>(VisContext); |
| 1231 |
unsigned rawType = Stack->back().first; |
| 1232 |
if (rawType == NoVisibility) return; |
| 1233 |
|
| 1234 |
VisibilityAttr::VisibilityType type |
| 1235 |
= (VisibilityAttr::VisibilityType) rawType; |
| 1236 |
SourceLocation loc = Stack->back().second; |
| 1237 |
|
| 1238 |
D->addAttr(VisibilityAttr::CreateImplicit(Context, type, loc)); |
| 1239 |
} |
| 1240 |
|
| 1241 |
/// FreeVisContext - Deallocate and null out VisContext. |
| 1242 |
void Sema::FreeVisContext() { |
| 1243 |
delete static_cast<VisStack*>(VisContext); |
| 1244 |
VisContext = nullptr; |
| 1245 |
} |
| 1246 |
|
| 1247 |
static void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc) { |
| 1248 |
// Put visibility on stack. |
| 1249 |
if (!S.VisContext) |
| 1250 |
S.VisContext = new VisStack; |
| 1251 |
|
| 1252 |
VisStack *Stack = static_cast<VisStack*>(S.VisContext); |
| 1253 |
Stack->push_back(std::make_pair(type, loc)); |
| 1254 |
} |
| 1255 |
|
| 1256 |
void Sema::ActOnPragmaVisibility(const IdentifierInfo* VisType, |
| 1257 |
SourceLocation PragmaLoc) { |
| 1258 |
if (VisType) { |
| 1259 |
// Compute visibility to use. |
| 1260 |
VisibilityAttr::VisibilityType T; |
| 1261 |
if (!VisibilityAttr::ConvertStrToVisibilityType(VisType->getName(), T)) { |
| 1262 |
Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType; |
| 1263 |
return; |
| 1264 |
} |
| 1265 |
PushPragmaVisibility(*this, T, PragmaLoc); |
| 1266 |
} else { |
| 1267 |
PopPragmaVisibility(false, PragmaLoc); |
| 1268 |
} |
| 1269 |
} |
| 1270 |
|
| 1271 |
void Sema::ActOnPragmaFPContract(SourceLocation Loc, |
| 1272 |
LangOptions::FPModeKind FPC) { |
| 1273 |
FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides(); |
| 1274 |
switch (FPC) { |
| 1275 |
case LangOptions::FPM_On: |
| 1276 |
NewFPFeatures.setAllowFPContractWithinStatement(); |
| 1277 |
break; |
| 1278 |
case LangOptions::FPM_Fast: |
| 1279 |
NewFPFeatures.setAllowFPContractAcrossStatement(); |
| 1280 |
break; |
| 1281 |
case LangOptions::FPM_Off: |
| 1282 |
NewFPFeatures.setDisallowFPContract(); |
| 1283 |
break; |
| 1284 |
case LangOptions::FPM_FastHonorPragmas: |
| 1285 |
llvm_unreachable("Should not happen"); |
| 1286 |
} |
| 1287 |
FpPragmaStack.Act(Loc, Sema::PSK_Set, StringRef(), NewFPFeatures); |
| 1288 |
CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts()); |
| 1289 |
} |
| 1290 |
|
| 1291 |
void Sema::ActOnPragmaFPReassociate(SourceLocation Loc, bool IsEnabled) { |
| 1292 |
if (IsEnabled) { |
| 1293 |
// For value unsafe context, combining this pragma with eval method |
| 1294 |
// setting is not recommended. See comment in function FixupInvocation#506. |
| 1295 |
int Reason = -1; |
| 1296 |
if (getLangOpts().getFPEvalMethod() != LangOptions::FEM_UnsetOnCommandLine) |
| 1297 |
// Eval method set using the option 'ffp-eval-method'. |
| 1298 |
Reason = 1; |
| 1299 |
if (PP.getLastFPEvalPragmaLocation().isValid()) |
| 1300 |
// Eval method set using the '#pragma clang fp eval_method'. |
| 1301 |
// We could have both an option and a pragma used to the set the eval |
| 1302 |
// method. The pragma overrides the option in the command line. The Reason |
| 1303 |
// of the diagnostic is overriden too. |
| 1304 |
Reason = 0; |
| 1305 |
if (Reason != -1) |
| 1306 |
Diag(Loc, diag::err_setting_eval_method_used_in_unsafe_context) |
| 1307 |
<< Reason << 4; |
| 1308 |
} |
| 1309 |
FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides(); |
| 1310 |
NewFPFeatures.setAllowFPReassociateOverride(IsEnabled); |
| 1311 |
FpPragmaStack.Act(Loc, PSK_Set, StringRef(), NewFPFeatures); |
| 1312 |
CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts()); |
| 1313 |
} |
| 1314 |
|
| 1315 |
void Sema::ActOnPragmaFEnvRound(SourceLocation Loc, llvm::RoundingMode FPR) { |
| 1316 |
FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides(); |
| 1317 |
NewFPFeatures.setConstRoundingModeOverride(FPR); |
| 1318 |
FpPragmaStack.Act(Loc, PSK_Set, StringRef(), NewFPFeatures); |
| 1319 |
CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts()); |
| 1320 |
} |
| 1321 |
|
| 1322 |
void Sema::setExceptionMode(SourceLocation Loc, |
| 1323 |
LangOptions::FPExceptionModeKind FPE) { |
| 1324 |
FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides(); |
| 1325 |
NewFPFeatures.setSpecifiedExceptionModeOverride(FPE); |
| 1326 |
FpPragmaStack.Act(Loc, PSK_Set, StringRef(), NewFPFeatures); |
| 1327 |
CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts()); |
| 1328 |
} |
| 1329 |
|
| 1330 |
void Sema::ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled) { |
| 1331 |
FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides(); |
| 1332 |
if (IsEnabled) { |
| 1333 |
// Verify Microsoft restriction: |
| 1334 |
// You can't enable fenv_access unless precise semantics are enabled. |
| 1335 |
// Precise semantics can be enabled either by the float_control |
| 1336 |
// pragma, or by using the /fp:precise or /fp:strict compiler options |
| 1337 |
if (!isPreciseFPEnabled()) |
| 1338 |
Diag(Loc, diag::err_pragma_fenv_requires_precise); |
| 1339 |
} |
| 1340 |
NewFPFeatures.setAllowFEnvAccessOverride(IsEnabled); |
| 1341 |
FpPragmaStack.Act(Loc, PSK_Set, StringRef(), NewFPFeatures); |
| 1342 |
CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts()); |
| 1343 |
} |
| 1344 |
|
| 1345 |
void Sema::ActOnPragmaFPExceptions(SourceLocation Loc, |
| 1346 |
LangOptions::FPExceptionModeKind FPE) { |
| 1347 |
setExceptionMode(Loc, FPE); |
| 1348 |
} |
| 1349 |
|
| 1350 |
void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr, |
| 1351 |
SourceLocation Loc) { |
| 1352 |
// Visibility calculations will consider the namespace's visibility. |
| 1353 |
// Here we just want to note that we're in a visibility context |
| 1354 |
// which overrides any enclosing #pragma context, but doesn't itself |
| 1355 |
// contribute visibility. |
| 1356 |
PushPragmaVisibility(*this, NoVisibility, Loc); |
| 1357 |
} |
| 1358 |
|
| 1359 |
void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) { |
| 1360 |
if (!VisContext) { |
| 1361 |
Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch); |
| 1362 |
return; |
| 1363 |
} |
| 1364 |
|
| 1365 |
// Pop visibility from stack |
| 1366 |
VisStack *Stack = static_cast<VisStack*>(VisContext); |
| 1367 |
|
| 1368 |
const std::pair<unsigned, SourceLocation> *Back = &Stack->back(); |
| 1369 |
bool StartsWithPragma = Back->first != NoVisibility; |
| 1370 |
if (StartsWithPragma && IsNamespaceEnd) { |
| 1371 |
Diag(Back->second, diag::err_pragma_push_visibility_mismatch); |
| 1372 |
Diag(EndLoc, diag::note_surrounding_namespace_ends_here); |
| 1373 |
|
| 1374 |
// For better error recovery, eat all pushes inside the namespace. |
| 1375 |
do { |
| 1376 |
Stack->pop_back(); |
| 1377 |
Back = &Stack->back(); |
| 1378 |
StartsWithPragma = Back->first != NoVisibility; |
| 1379 |
} while (StartsWithPragma); |
| 1380 |
} else if (!StartsWithPragma && !IsNamespaceEnd) { |
| 1381 |
Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch); |
| 1382 |
Diag(Back->second, diag::note_surrounding_namespace_starts_here); |
| 1383 |
return; |
| 1384 |
} |
| 1385 |
|
| 1386 |
Stack->pop_back(); |
| 1387 |
// To simplify the implementation, never keep around an empty stack. |
| 1388 |
if (Stack->empty()) |
| 1389 |
FreeVisContext(); |
| 1390 |
} |
| 1391 |
|
| 1392 |
template <typename Ty> |
| 1393 |
static bool checkCommonAttributeFeatures(Sema &S, const Ty *Node, |
| 1394 |
const ParsedAttr &A, |
| 1395 |
bool SkipArgCountCheck) { |
| 1396 |
// Several attributes carry different semantics than the parsing requires, so |
| 1397 |
// those are opted out of the common argument checks. |
| 1398 |
// |
| 1399 |
// We also bail on unknown and ignored attributes because those are handled |
| 1400 |
// as part of the target-specific handling logic. |
| 1401 |
if (A.getKind() == ParsedAttr::UnknownAttribute) |
| 1402 |
return false; |
| 1403 |
// Check whether the attribute requires specific language extensions to be |
| 1404 |
// enabled. |
| 1405 |
if (!A.diagnoseLangOpts(S)) |
| 1406 |
return true; |
| 1407 |
// Check whether the attribute appertains to the given subject. |
| 1408 |
if (!A.diagnoseAppertainsTo(S, Node)) |
| 1409 |
return true; |
| 1410 |
// Check whether the attribute is mutually exclusive with other attributes |
| 1411 |
// that have already been applied to the declaration. |
| 1412 |
if (!A.diagnoseMutualExclusion(S, Node)) |
| 1413 |
return true; |
| 1414 |
// Check whether the attribute exists in the target architecture. |
| 1415 |
if (S.CheckAttrTarget(A)) |
| 1416 |
return true; |
| 1417 |
|
| 1418 |
if (A.hasCustomParsing()) |
| 1419 |
return false; |
| 1420 |
|
| 1421 |
if (!SkipArgCountCheck) { |
| 1422 |
if (A.getMinArgs() == A.getMaxArgs()) { |
| 1423 |
// If there are no optional arguments, then checking for the argument |
| 1424 |
// count is trivial. |
| 1425 |
if (!A.checkExactlyNumArgs(S, A.getMinArgs())) |
| 1426 |
return true; |
| 1427 |
} else { |
| 1428 |
// There are optional arguments, so checking is slightly more involved. |
| 1429 |
if (A.getMinArgs() && !A.checkAtLeastNumArgs(S, A.getMinArgs())) |
| 1430 |
return true; |
| 1431 |
else if (!A.hasVariadicArg() && A.getMaxArgs() && |
| 1432 |
!A.checkAtMostNumArgs(S, A.getMaxArgs())) |
| 1433 |
return true; |
| 1434 |
} |
| 1435 |
} |
| 1436 |
|
| 1437 |
return false; |
| 1438 |
} |
| 1439 |
|
| 1440 |
bool Sema::checkCommonAttributeFeatures(const Decl *D, const ParsedAttr &A, |
| 1441 |
bool SkipArgCountCheck) { |
| 1442 |
return ::checkCommonAttributeFeatures(*this, D, A, SkipArgCountCheck); |
| 1443 |
} |
| 1444 |
bool Sema::checkCommonAttributeFeatures(const Stmt *S, const ParsedAttr &A, |
| 1445 |
bool SkipArgCountCheck) { |
| 1446 |
return ::checkCommonAttributeFeatures(*this, S, A, SkipArgCountCheck); |
| 1447 |
} |