mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-25 07:56:06 +00:00
240f2269ff
Add option and statement attribute for controlling emitting of target-specific metadata to atomicrmw instructions in IR. The RFC for this attribute and option is https://discourse.llvm.org/t/rfc-add-clang-atomic-control-options-and-pragmas/80641, Originally a pragma was proposed, then it was changed to clang attribute. This attribute allows users to specify one, two, or all three options and must be applied to a compound statement. The attribute can also be nested, with inner attributes overriding the options specified by outer attributes or the target's default options. These options will then determine the target-specific metadata added to atomic instructions in the IR. In addition to the attribute, three new compiler options are introduced: `-f[no-]atomic-remote-memory`, `-f[no-]atomic-fine-grained-memory`, `-f[no-]atomic-ignore-denormal-mode`. These compiler options allow users to override the default options through the Clang driver and front end. `-m[no-]unsafe-fp-atomics` is aliased to `-f[no-]ignore-denormal-mode`. In terms of implementation, the atomic attribute is represented in the AST by the existing AttributedStmt, with minimal changes to AST and Sema. During code generation in Clang, the CodeGenModule maintains the current atomic options, which are used to emit the relevant metadata for atomic instructions. RAII is used to manage the saving and restoring of atomic options when entering and exiting nested AttributedStmt.
802 lines
30 KiB
C++
802 lines
30 KiB
C++
//===--- SemaStmtAttr.cpp - Statement Attribute Handling ------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements stmt-related attribute processing.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/EvaluatedExprVisitor.h"
|
|
#include "clang/Basic/TargetInfo.h"
|
|
#include "clang/Sema/DelayedDiagnostic.h"
|
|
#include "clang/Sema/ParsedAttr.h"
|
|
#include "clang/Sema/ScopeInfo.h"
|
|
#include <optional>
|
|
|
|
using namespace clang;
|
|
using namespace sema;
|
|
|
|
static Attr *handleFallThroughAttr(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
FallThroughAttr Attr(S.Context, A);
|
|
if (isa<SwitchCase>(St)) {
|
|
S.Diag(A.getRange().getBegin(), diag::err_fallthrough_attr_wrong_target)
|
|
<< A << St->getBeginLoc();
|
|
SourceLocation L = S.getLocForEndOfToken(Range.getEnd());
|
|
S.Diag(L, diag::note_fallthrough_insert_semi_fixit)
|
|
<< FixItHint::CreateInsertion(L, ";");
|
|
return nullptr;
|
|
}
|
|
auto *FnScope = S.getCurFunction();
|
|
if (FnScope->SwitchStack.empty()) {
|
|
S.Diag(A.getRange().getBegin(), diag::err_fallthrough_attr_outside_switch);
|
|
return nullptr;
|
|
}
|
|
|
|
// If this is spelled as the standard C++17 attribute, but not in C++17, warn
|
|
// about using it as an extension.
|
|
if (!S.getLangOpts().CPlusPlus17 && A.isCXX11Attribute() &&
|
|
!A.getScopeName())
|
|
S.Diag(A.getLoc(), diag::ext_cxx17_attr) << A;
|
|
|
|
FnScope->setHasFallthroughStmt();
|
|
return ::new (S.Context) FallThroughAttr(S.Context, A);
|
|
}
|
|
|
|
static Attr *handleSuppressAttr(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
if (A.getAttributeSpellingListIndex() == SuppressAttr::CXX11_gsl_suppress &&
|
|
A.getNumArgs() < 1) {
|
|
// Suppression attribute with GSL spelling requires at least 1 argument.
|
|
S.Diag(A.getLoc(), diag::err_attribute_too_few_arguments) << A << 1;
|
|
return nullptr;
|
|
}
|
|
|
|
std::vector<StringRef> DiagnosticIdentifiers;
|
|
for (unsigned I = 0, E = A.getNumArgs(); I != E; ++I) {
|
|
StringRef RuleName;
|
|
|
|
if (!S.checkStringLiteralArgumentAttr(A, I, RuleName, nullptr))
|
|
return nullptr;
|
|
|
|
DiagnosticIdentifiers.push_back(RuleName);
|
|
}
|
|
|
|
return ::new (S.Context) SuppressAttr(
|
|
S.Context, A, DiagnosticIdentifiers.data(), DiagnosticIdentifiers.size());
|
|
}
|
|
|
|
static Attr *handleLoopHintAttr(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange) {
|
|
IdentifierLoc *PragmaNameLoc = A.getArgAsIdent(0);
|
|
IdentifierLoc *OptionLoc = A.getArgAsIdent(1);
|
|
IdentifierLoc *StateLoc = A.getArgAsIdent(2);
|
|
Expr *ValueExpr = A.getArgAsExpr(3);
|
|
|
|
StringRef PragmaName =
|
|
llvm::StringSwitch<StringRef>(PragmaNameLoc->Ident->getName())
|
|
.Cases("unroll", "nounroll", "unroll_and_jam", "nounroll_and_jam",
|
|
PragmaNameLoc->Ident->getName())
|
|
.Default("clang loop");
|
|
|
|
// This could be handled automatically by adding a Subjects definition in
|
|
// Attr.td, but that would make the diagnostic behavior worse in this case
|
|
// because the user spells this attribute as a pragma.
|
|
if (!isa<DoStmt, ForStmt, CXXForRangeStmt, WhileStmt>(St)) {
|
|
std::string Pragma = "#pragma " + std::string(PragmaName);
|
|
S.Diag(St->getBeginLoc(), diag::err_pragma_loop_precedes_nonloop) << Pragma;
|
|
return nullptr;
|
|
}
|
|
|
|
LoopHintAttr::OptionType Option;
|
|
LoopHintAttr::LoopHintState State;
|
|
|
|
auto SetHints = [&Option, &State](LoopHintAttr::OptionType O,
|
|
LoopHintAttr::LoopHintState S) {
|
|
Option = O;
|
|
State = S;
|
|
};
|
|
|
|
if (PragmaName == "nounroll") {
|
|
SetHints(LoopHintAttr::Unroll, LoopHintAttr::Disable);
|
|
} else if (PragmaName == "unroll") {
|
|
// #pragma unroll N
|
|
if (ValueExpr) {
|
|
if (!ValueExpr->isValueDependent()) {
|
|
auto Value = ValueExpr->EvaluateKnownConstInt(S.getASTContext());
|
|
if (Value.isZero() || Value.isOne())
|
|
SetHints(LoopHintAttr::Unroll, LoopHintAttr::Disable);
|
|
else
|
|
SetHints(LoopHintAttr::UnrollCount, LoopHintAttr::Numeric);
|
|
} else
|
|
SetHints(LoopHintAttr::UnrollCount, LoopHintAttr::Numeric);
|
|
} else
|
|
SetHints(LoopHintAttr::Unroll, LoopHintAttr::Enable);
|
|
} else if (PragmaName == "nounroll_and_jam") {
|
|
SetHints(LoopHintAttr::UnrollAndJam, LoopHintAttr::Disable);
|
|
} else if (PragmaName == "unroll_and_jam") {
|
|
// #pragma unroll_and_jam N
|
|
if (ValueExpr)
|
|
SetHints(LoopHintAttr::UnrollAndJamCount, LoopHintAttr::Numeric);
|
|
else
|
|
SetHints(LoopHintAttr::UnrollAndJam, LoopHintAttr::Enable);
|
|
} else {
|
|
// #pragma clang loop ...
|
|
assert(OptionLoc && OptionLoc->Ident &&
|
|
"Attribute must have valid option info.");
|
|
Option = llvm::StringSwitch<LoopHintAttr::OptionType>(
|
|
OptionLoc->Ident->getName())
|
|
.Case("vectorize", LoopHintAttr::Vectorize)
|
|
.Case("vectorize_width", LoopHintAttr::VectorizeWidth)
|
|
.Case("interleave", LoopHintAttr::Interleave)
|
|
.Case("vectorize_predicate", LoopHintAttr::VectorizePredicate)
|
|
.Case("interleave_count", LoopHintAttr::InterleaveCount)
|
|
.Case("unroll", LoopHintAttr::Unroll)
|
|
.Case("unroll_count", LoopHintAttr::UnrollCount)
|
|
.Case("pipeline", LoopHintAttr::PipelineDisabled)
|
|
.Case("pipeline_initiation_interval",
|
|
LoopHintAttr::PipelineInitiationInterval)
|
|
.Case("distribute", LoopHintAttr::Distribute)
|
|
.Default(LoopHintAttr::Vectorize);
|
|
if (Option == LoopHintAttr::VectorizeWidth) {
|
|
assert((ValueExpr || (StateLoc && StateLoc->Ident)) &&
|
|
"Attribute must have a valid value expression or argument.");
|
|
if (ValueExpr && S.CheckLoopHintExpr(ValueExpr, St->getBeginLoc(),
|
|
/*AllowZero=*/false))
|
|
return nullptr;
|
|
if (StateLoc && StateLoc->Ident && StateLoc->Ident->isStr("scalable"))
|
|
State = LoopHintAttr::ScalableWidth;
|
|
else
|
|
State = LoopHintAttr::FixedWidth;
|
|
} else if (Option == LoopHintAttr::InterleaveCount ||
|
|
Option == LoopHintAttr::UnrollCount ||
|
|
Option == LoopHintAttr::PipelineInitiationInterval) {
|
|
assert(ValueExpr && "Attribute must have a valid value expression.");
|
|
if (S.CheckLoopHintExpr(ValueExpr, St->getBeginLoc(),
|
|
/*AllowZero=*/false))
|
|
return nullptr;
|
|
State = LoopHintAttr::Numeric;
|
|
} else if (Option == LoopHintAttr::Vectorize ||
|
|
Option == LoopHintAttr::Interleave ||
|
|
Option == LoopHintAttr::VectorizePredicate ||
|
|
Option == LoopHintAttr::Unroll ||
|
|
Option == LoopHintAttr::Distribute ||
|
|
Option == LoopHintAttr::PipelineDisabled) {
|
|
assert(StateLoc && StateLoc->Ident && "Loop hint must have an argument");
|
|
if (StateLoc->Ident->isStr("disable"))
|
|
State = LoopHintAttr::Disable;
|
|
else if (StateLoc->Ident->isStr("assume_safety"))
|
|
State = LoopHintAttr::AssumeSafety;
|
|
else if (StateLoc->Ident->isStr("full"))
|
|
State = LoopHintAttr::Full;
|
|
else if (StateLoc->Ident->isStr("enable"))
|
|
State = LoopHintAttr::Enable;
|
|
else
|
|
llvm_unreachable("bad loop hint argument");
|
|
} else
|
|
llvm_unreachable("bad loop hint");
|
|
}
|
|
|
|
return LoopHintAttr::CreateImplicit(S.Context, Option, State, ValueExpr, A);
|
|
}
|
|
|
|
namespace {
|
|
class CallExprFinder : public ConstEvaluatedExprVisitor<CallExprFinder> {
|
|
bool FoundAsmStmt = false;
|
|
std::vector<const CallExpr *> CallExprs;
|
|
|
|
public:
|
|
typedef ConstEvaluatedExprVisitor<CallExprFinder> Inherited;
|
|
|
|
CallExprFinder(Sema &S, const Stmt *St) : Inherited(S.Context) { Visit(St); }
|
|
|
|
bool foundCallExpr() { return !CallExprs.empty(); }
|
|
const std::vector<const CallExpr *> &getCallExprs() { return CallExprs; }
|
|
|
|
bool foundAsmStmt() { return FoundAsmStmt; }
|
|
|
|
void VisitCallExpr(const CallExpr *E) { CallExprs.push_back(E); }
|
|
|
|
void VisitAsmStmt(const AsmStmt *S) { FoundAsmStmt = true; }
|
|
|
|
void Visit(const Stmt *St) {
|
|
if (!St)
|
|
return;
|
|
ConstEvaluatedExprVisitor<CallExprFinder>::Visit(St);
|
|
}
|
|
};
|
|
} // namespace
|
|
|
|
static Attr *handleNoMergeAttr(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
CallExprFinder CEF(S, St);
|
|
|
|
if (!CEF.foundCallExpr() && !CEF.foundAsmStmt()) {
|
|
S.Diag(St->getBeginLoc(), diag::warn_attribute_ignored_no_calls_in_stmt)
|
|
<< A;
|
|
return nullptr;
|
|
}
|
|
|
|
return ::new (S.Context) NoMergeAttr(S.Context, A);
|
|
}
|
|
|
|
static Attr *handleNoConvergentAttr(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
CallExprFinder CEF(S, St);
|
|
|
|
if (!CEF.foundCallExpr() && !CEF.foundAsmStmt()) {
|
|
S.Diag(St->getBeginLoc(), diag::warn_attribute_ignored_no_calls_in_stmt)
|
|
<< A;
|
|
return nullptr;
|
|
}
|
|
|
|
return ::new (S.Context) NoConvergentAttr(S.Context, A);
|
|
}
|
|
|
|
template <typename OtherAttr, int DiagIdx>
|
|
static bool CheckStmtInlineAttr(Sema &SemaRef, const Stmt *OrigSt,
|
|
const Stmt *CurSt,
|
|
const AttributeCommonInfo &A) {
|
|
CallExprFinder OrigCEF(SemaRef, OrigSt);
|
|
CallExprFinder CEF(SemaRef, CurSt);
|
|
|
|
// If the call expressions lists are equal in size, we can skip
|
|
// previously emitted diagnostics. However, if the statement has a pack
|
|
// expansion, we have no way of telling which CallExpr is the instantiated
|
|
// version of the other. In this case, we will end up re-diagnosing in the
|
|
// instantiation.
|
|
// ie: [[clang::always_inline]] non_dependent(), (other_call<Pack>()...)
|
|
// will diagnose nondependent again.
|
|
bool CanSuppressDiag =
|
|
OrigSt && CEF.getCallExprs().size() == OrigCEF.getCallExprs().size();
|
|
|
|
if (!CEF.foundCallExpr()) {
|
|
return SemaRef.Diag(CurSt->getBeginLoc(),
|
|
diag::warn_attribute_ignored_no_calls_in_stmt)
|
|
<< A;
|
|
}
|
|
|
|
for (const auto &Tup :
|
|
llvm::zip_longest(OrigCEF.getCallExprs(), CEF.getCallExprs())) {
|
|
// If the original call expression already had a callee, we already
|
|
// diagnosed this, so skip it here. We can't skip if there isn't a 1:1
|
|
// relationship between the two lists of call expressions.
|
|
if (!CanSuppressDiag || !(*std::get<0>(Tup))->getCalleeDecl()) {
|
|
const Decl *Callee = (*std::get<1>(Tup))->getCalleeDecl();
|
|
if (Callee &&
|
|
(Callee->hasAttr<OtherAttr>() || Callee->hasAttr<FlattenAttr>())) {
|
|
SemaRef.Diag(CurSt->getBeginLoc(),
|
|
diag::warn_function_stmt_attribute_precedence)
|
|
<< A << (Callee->hasAttr<OtherAttr>() ? DiagIdx : 1);
|
|
SemaRef.Diag(Callee->getBeginLoc(), diag::note_conflicting_attribute);
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool Sema::CheckNoInlineAttr(const Stmt *OrigSt, const Stmt *CurSt,
|
|
const AttributeCommonInfo &A) {
|
|
return CheckStmtInlineAttr<AlwaysInlineAttr, 0>(*this, OrigSt, CurSt, A);
|
|
}
|
|
|
|
bool Sema::CheckAlwaysInlineAttr(const Stmt *OrigSt, const Stmt *CurSt,
|
|
const AttributeCommonInfo &A) {
|
|
return CheckStmtInlineAttr<NoInlineAttr, 2>(*this, OrigSt, CurSt, A);
|
|
}
|
|
|
|
static Attr *handleNoInlineAttr(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
NoInlineAttr NIA(S.Context, A);
|
|
if (!NIA.isStmtNoInline()) {
|
|
S.Diag(St->getBeginLoc(), diag::warn_function_attribute_ignored_in_stmt)
|
|
<< "[[clang::noinline]]";
|
|
return nullptr;
|
|
}
|
|
|
|
if (S.CheckNoInlineAttr(/*OrigSt=*/nullptr, St, A))
|
|
return nullptr;
|
|
|
|
return ::new (S.Context) NoInlineAttr(S.Context, A);
|
|
}
|
|
|
|
static Attr *handleAlwaysInlineAttr(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
AlwaysInlineAttr AIA(S.Context, A);
|
|
if (!AIA.isClangAlwaysInline()) {
|
|
S.Diag(St->getBeginLoc(), diag::warn_function_attribute_ignored_in_stmt)
|
|
<< "[[clang::always_inline]]";
|
|
return nullptr;
|
|
}
|
|
|
|
if (S.CheckAlwaysInlineAttr(/*OrigSt=*/nullptr, St, A))
|
|
return nullptr;
|
|
|
|
return ::new (S.Context) AlwaysInlineAttr(S.Context, A);
|
|
}
|
|
|
|
static Attr *handleCXXAssumeAttr(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
ExprResult Res = S.ActOnCXXAssumeAttr(St, A, Range);
|
|
if (!Res.isUsable())
|
|
return nullptr;
|
|
|
|
return ::new (S.Context) CXXAssumeAttr(S.Context, A, Res.get());
|
|
}
|
|
|
|
static Attr *handleMustTailAttr(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
// Validation is in Sema::ActOnAttributedStmt().
|
|
return ::new (S.Context) MustTailAttr(S.Context, A);
|
|
}
|
|
|
|
static Attr *handleLikely(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
|
|
if (!S.getLangOpts().CPlusPlus20 && A.isCXX11Attribute() && !A.getScopeName())
|
|
S.Diag(A.getLoc(), diag::ext_cxx20_attr) << A << Range;
|
|
|
|
return ::new (S.Context) LikelyAttr(S.Context, A);
|
|
}
|
|
|
|
static Attr *handleUnlikely(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
|
|
if (!S.getLangOpts().CPlusPlus20 && A.isCXX11Attribute() && !A.getScopeName())
|
|
S.Diag(A.getLoc(), diag::ext_cxx20_attr) << A << Range;
|
|
|
|
return ::new (S.Context) UnlikelyAttr(S.Context, A);
|
|
}
|
|
|
|
CodeAlignAttr *Sema::BuildCodeAlignAttr(const AttributeCommonInfo &CI,
|
|
Expr *E) {
|
|
if (!E->isValueDependent()) {
|
|
llvm::APSInt ArgVal;
|
|
ExprResult Res = VerifyIntegerConstantExpression(E, &ArgVal);
|
|
if (Res.isInvalid())
|
|
return nullptr;
|
|
E = Res.get();
|
|
|
|
// This attribute requires an integer argument which is a constant power of
|
|
// two between 1 and 4096 inclusive.
|
|
if (ArgVal < CodeAlignAttr::MinimumAlignment ||
|
|
ArgVal > CodeAlignAttr::MaximumAlignment || !ArgVal.isPowerOf2()) {
|
|
if (std::optional<int64_t> Value = ArgVal.trySExtValue())
|
|
Diag(CI.getLoc(), diag::err_attribute_power_of_two_in_range)
|
|
<< CI << CodeAlignAttr::MinimumAlignment
|
|
<< CodeAlignAttr::MaximumAlignment << Value.value();
|
|
else
|
|
Diag(CI.getLoc(), diag::err_attribute_power_of_two_in_range)
|
|
<< CI << CodeAlignAttr::MinimumAlignment
|
|
<< CodeAlignAttr::MaximumAlignment << E;
|
|
return nullptr;
|
|
}
|
|
}
|
|
return new (Context) CodeAlignAttr(Context, CI, E);
|
|
}
|
|
|
|
static Attr *handleCodeAlignAttr(Sema &S, Stmt *St, const ParsedAttr &A) {
|
|
|
|
Expr *E = A.getArgAsExpr(0);
|
|
return S.BuildCodeAlignAttr(A, E);
|
|
}
|
|
|
|
// Diagnose non-identical duplicates as a 'conflicting' loop attributes
|
|
// and suppress duplicate errors in cases where the two match.
|
|
template <typename LoopAttrT>
|
|
static void CheckForDuplicateLoopAttrs(Sema &S, ArrayRef<const Attr *> Attrs) {
|
|
auto FindFunc = [](const Attr *A) { return isa<const LoopAttrT>(A); };
|
|
const auto *FirstItr = std::find_if(Attrs.begin(), Attrs.end(), FindFunc);
|
|
|
|
if (FirstItr == Attrs.end()) // no attributes found
|
|
return;
|
|
|
|
const auto *LastFoundItr = FirstItr;
|
|
std::optional<llvm::APSInt> FirstValue;
|
|
|
|
const auto *CAFA =
|
|
dyn_cast<ConstantExpr>(cast<LoopAttrT>(*FirstItr)->getAlignment());
|
|
// Return early if first alignment expression is dependent (since we don't
|
|
// know what the effective size will be), and skip the loop entirely.
|
|
if (!CAFA)
|
|
return;
|
|
|
|
while (Attrs.end() != (LastFoundItr = std::find_if(LastFoundItr + 1,
|
|
Attrs.end(), FindFunc))) {
|
|
const auto *CASA =
|
|
dyn_cast<ConstantExpr>(cast<LoopAttrT>(*LastFoundItr)->getAlignment());
|
|
// If the value is dependent, we can not test anything.
|
|
if (!CASA)
|
|
return;
|
|
// Test the attribute values.
|
|
llvm::APSInt SecondValue = CASA->getResultAsAPSInt();
|
|
if (!FirstValue)
|
|
FirstValue = CAFA->getResultAsAPSInt();
|
|
|
|
if (FirstValue != SecondValue) {
|
|
S.Diag((*LastFoundItr)->getLocation(), diag::err_loop_attr_conflict)
|
|
<< *FirstItr;
|
|
S.Diag((*FirstItr)->getLocation(), diag::note_previous_attribute);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
static Attr *handleMSConstexprAttr(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
if (!S.getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2022_3)) {
|
|
S.Diag(A.getLoc(), diag::warn_unknown_attribute_ignored)
|
|
<< A << A.getRange();
|
|
return nullptr;
|
|
}
|
|
return ::new (S.Context) MSConstexprAttr(S.Context, A);
|
|
}
|
|
|
|
#define WANT_STMT_MERGE_LOGIC
|
|
#include "clang/Sema/AttrParsedAttrImpl.inc"
|
|
#undef WANT_STMT_MERGE_LOGIC
|
|
|
|
static void
|
|
CheckForIncompatibleAttributes(Sema &S,
|
|
const SmallVectorImpl<const Attr *> &Attrs) {
|
|
// The vast majority of attributed statements will only have one attribute
|
|
// on them, so skip all of the checking in the common case.
|
|
if (Attrs.size() < 2)
|
|
return;
|
|
|
|
// First, check for the easy cases that are table-generated for us.
|
|
if (!DiagnoseMutualExclusions(S, Attrs))
|
|
return;
|
|
|
|
enum CategoryType {
|
|
// For the following categories, they come in two variants: a state form and
|
|
// a numeric form. The state form may be one of default, enable, and
|
|
// disable. The numeric form provides an integer hint (for example, unroll
|
|
// count) to the transformer.
|
|
Vectorize,
|
|
Interleave,
|
|
UnrollAndJam,
|
|
Pipeline,
|
|
// For unroll, default indicates full unrolling rather than enabling the
|
|
// transformation.
|
|
Unroll,
|
|
// The loop distribution transformation only has a state form that is
|
|
// exposed by #pragma clang loop distribute (enable | disable).
|
|
Distribute,
|
|
// The vector predication only has a state form that is exposed by
|
|
// #pragma clang loop vectorize_predicate (enable | disable).
|
|
VectorizePredicate,
|
|
// This serves as a indicator to how many category are listed in this enum.
|
|
NumberOfCategories
|
|
};
|
|
// The following array accumulates the hints encountered while iterating
|
|
// through the attributes to check for compatibility.
|
|
struct {
|
|
const LoopHintAttr *StateAttr;
|
|
const LoopHintAttr *NumericAttr;
|
|
} HintAttrs[CategoryType::NumberOfCategories] = {};
|
|
|
|
for (const auto *I : Attrs) {
|
|
const LoopHintAttr *LH = dyn_cast<LoopHintAttr>(I);
|
|
|
|
// Skip non loop hint attributes
|
|
if (!LH)
|
|
continue;
|
|
|
|
CategoryType Category = CategoryType::NumberOfCategories;
|
|
LoopHintAttr::OptionType Option = LH->getOption();
|
|
switch (Option) {
|
|
case LoopHintAttr::Vectorize:
|
|
case LoopHintAttr::VectorizeWidth:
|
|
Category = Vectorize;
|
|
break;
|
|
case LoopHintAttr::Interleave:
|
|
case LoopHintAttr::InterleaveCount:
|
|
Category = Interleave;
|
|
break;
|
|
case LoopHintAttr::Unroll:
|
|
case LoopHintAttr::UnrollCount:
|
|
Category = Unroll;
|
|
break;
|
|
case LoopHintAttr::UnrollAndJam:
|
|
case LoopHintAttr::UnrollAndJamCount:
|
|
Category = UnrollAndJam;
|
|
break;
|
|
case LoopHintAttr::Distribute:
|
|
// Perform the check for duplicated 'distribute' hints.
|
|
Category = Distribute;
|
|
break;
|
|
case LoopHintAttr::PipelineDisabled:
|
|
case LoopHintAttr::PipelineInitiationInterval:
|
|
Category = Pipeline;
|
|
break;
|
|
case LoopHintAttr::VectorizePredicate:
|
|
Category = VectorizePredicate;
|
|
break;
|
|
};
|
|
|
|
assert(Category != NumberOfCategories && "Unhandled loop hint option");
|
|
auto &CategoryState = HintAttrs[Category];
|
|
const LoopHintAttr *PrevAttr;
|
|
if (Option == LoopHintAttr::Vectorize ||
|
|
Option == LoopHintAttr::Interleave || Option == LoopHintAttr::Unroll ||
|
|
Option == LoopHintAttr::UnrollAndJam ||
|
|
Option == LoopHintAttr::VectorizePredicate ||
|
|
Option == LoopHintAttr::PipelineDisabled ||
|
|
Option == LoopHintAttr::Distribute) {
|
|
// Enable|Disable|AssumeSafety hint. For example, vectorize(enable).
|
|
PrevAttr = CategoryState.StateAttr;
|
|
CategoryState.StateAttr = LH;
|
|
} else {
|
|
// Numeric hint. For example, vectorize_width(8).
|
|
PrevAttr = CategoryState.NumericAttr;
|
|
CategoryState.NumericAttr = LH;
|
|
}
|
|
|
|
PrintingPolicy Policy(S.Context.getLangOpts());
|
|
SourceLocation OptionLoc = LH->getRange().getBegin();
|
|
if (PrevAttr)
|
|
// Cannot specify same type of attribute twice.
|
|
S.Diag(OptionLoc, diag::err_pragma_loop_compatibility)
|
|
<< /*Duplicate=*/true << PrevAttr->getDiagnosticName(Policy)
|
|
<< LH->getDiagnosticName(Policy);
|
|
|
|
if (CategoryState.StateAttr && CategoryState.NumericAttr &&
|
|
(Category == Unroll || Category == UnrollAndJam ||
|
|
CategoryState.StateAttr->getState() == LoopHintAttr::Disable)) {
|
|
// Disable hints are not compatible with numeric hints of the same
|
|
// category. As a special case, numeric unroll hints are also not
|
|
// compatible with enable or full form of the unroll pragma because these
|
|
// directives indicate full unrolling.
|
|
S.Diag(OptionLoc, diag::err_pragma_loop_compatibility)
|
|
<< /*Duplicate=*/false
|
|
<< CategoryState.StateAttr->getDiagnosticName(Policy)
|
|
<< CategoryState.NumericAttr->getDiagnosticName(Policy);
|
|
}
|
|
}
|
|
}
|
|
|
|
static Attr *handleOpenCLUnrollHint(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
// Although the feature was introduced only in OpenCL C v2.0 s6.11.5, it's
|
|
// useful for OpenCL 1.x too and doesn't require HW support.
|
|
// opencl_unroll_hint can have 0 arguments (compiler
|
|
// determines unrolling factor) or 1 argument (the unroll factor provided
|
|
// by the user).
|
|
unsigned UnrollFactor = 0;
|
|
if (A.getNumArgs() == 1) {
|
|
Expr *E = A.getArgAsExpr(0);
|
|
std::optional<llvm::APSInt> ArgVal;
|
|
|
|
if (!(ArgVal = E->getIntegerConstantExpr(S.Context))) {
|
|
S.Diag(A.getLoc(), diag::err_attribute_argument_type)
|
|
<< A << AANT_ArgumentIntegerConstant << E->getSourceRange();
|
|
return nullptr;
|
|
}
|
|
|
|
int Val = ArgVal->getSExtValue();
|
|
if (Val <= 0) {
|
|
S.Diag(A.getRange().getBegin(),
|
|
diag::err_attribute_requires_positive_integer)
|
|
<< A << /* positive */ 0;
|
|
return nullptr;
|
|
}
|
|
UnrollFactor = static_cast<unsigned>(Val);
|
|
}
|
|
|
|
return ::new (S.Context) OpenCLUnrollHintAttr(S.Context, A, UnrollFactor);
|
|
}
|
|
|
|
static Attr *handleHLSLLoopHintAttr(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
|
|
if (A.getSemanticSpelling() == HLSLLoopHintAttr::Spelling::Microsoft_loop &&
|
|
!A.checkAtMostNumArgs(S, 0))
|
|
return nullptr;
|
|
|
|
unsigned UnrollFactor = 0;
|
|
if (A.getNumArgs() == 1) {
|
|
Expr *E = A.getArgAsExpr(0);
|
|
|
|
if (S.CheckLoopHintExpr(E, St->getBeginLoc(),
|
|
/*AllowZero=*/false))
|
|
return nullptr;
|
|
|
|
std::optional<llvm::APSInt> ArgVal = E->getIntegerConstantExpr(S.Context);
|
|
// CheckLoopHintExpr handles non int const cases
|
|
assert(ArgVal != std::nullopt && "ArgVal should be an integer constant.");
|
|
int Val = ArgVal->getSExtValue();
|
|
// CheckLoopHintExpr handles negative and zero cases
|
|
assert(Val > 0 && "Val should be a positive integer greater than zero.");
|
|
UnrollFactor = static_cast<unsigned>(Val);
|
|
}
|
|
return ::new (S.Context) HLSLLoopHintAttr(S.Context, A, UnrollFactor);
|
|
}
|
|
|
|
static Attr *handleHLSLControlFlowHint(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
|
|
return ::new (S.Context) HLSLControlFlowHintAttr(S.Context, A);
|
|
}
|
|
|
|
static Attr *handleAtomicAttr(Sema &S, Stmt *St, const ParsedAttr &AL,
|
|
SourceRange Range) {
|
|
if (!AL.checkAtLeastNumArgs(S, 1))
|
|
return nullptr;
|
|
|
|
SmallVector<AtomicAttr::ConsumedOption, 6> Options;
|
|
for (unsigned ArgIndex = 0; ArgIndex < AL.getNumArgs(); ++ArgIndex) {
|
|
AtomicAttr::ConsumedOption Option;
|
|
StringRef OptionString;
|
|
SourceLocation Loc;
|
|
|
|
if (!AL.isArgIdent(ArgIndex)) {
|
|
S.Diag(AL.getArgAsExpr(ArgIndex)->getBeginLoc(),
|
|
diag::err_attribute_argument_type)
|
|
<< AL << AANT_ArgumentIdentifier;
|
|
return nullptr;
|
|
}
|
|
|
|
IdentifierLoc *Ident = AL.getArgAsIdent(ArgIndex);
|
|
OptionString = Ident->Ident->getName();
|
|
Loc = Ident->Loc;
|
|
if (!AtomicAttr::ConvertStrToConsumedOption(OptionString, Option)) {
|
|
S.Diag(Loc, diag::err_attribute_invalid_atomic_argument) << OptionString;
|
|
return nullptr;
|
|
}
|
|
Options.push_back(Option);
|
|
}
|
|
|
|
return ::new (S.Context)
|
|
AtomicAttr(S.Context, AL, Options.data(), Options.size());
|
|
}
|
|
|
|
static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
if (A.isInvalid() || A.getKind() == ParsedAttr::IgnoredAttribute)
|
|
return nullptr;
|
|
|
|
// Unknown attributes are automatically warned on. Target-specific attributes
|
|
// which do not apply to the current target architecture are treated as
|
|
// though they were unknown attributes.
|
|
const TargetInfo *Aux = S.Context.getAuxTargetInfo();
|
|
if (A.getKind() == ParsedAttr::UnknownAttribute ||
|
|
!(A.existsInTarget(S.Context.getTargetInfo()) ||
|
|
(S.Context.getLangOpts().SYCLIsDevice && Aux &&
|
|
A.existsInTarget(*Aux)))) {
|
|
S.Diag(A.getLoc(), A.isRegularKeywordAttribute()
|
|
? (unsigned)diag::err_keyword_not_supported_on_target
|
|
: A.isDeclspecAttribute()
|
|
? (unsigned)diag::warn_unhandled_ms_attribute_ignored
|
|
: (unsigned)diag::warn_unknown_attribute_ignored)
|
|
<< A << A.getRange();
|
|
return nullptr;
|
|
}
|
|
|
|
if (S.checkCommonAttributeFeatures(St, A))
|
|
return nullptr;
|
|
|
|
switch (A.getKind()) {
|
|
case ParsedAttr::AT_AlwaysInline:
|
|
return handleAlwaysInlineAttr(S, St, A, Range);
|
|
case ParsedAttr::AT_CXXAssume:
|
|
return handleCXXAssumeAttr(S, St, A, Range);
|
|
case ParsedAttr::AT_FallThrough:
|
|
return handleFallThroughAttr(S, St, A, Range);
|
|
case ParsedAttr::AT_LoopHint:
|
|
return handleLoopHintAttr(S, St, A, Range);
|
|
case ParsedAttr::AT_HLSLLoopHint:
|
|
return handleHLSLLoopHintAttr(S, St, A, Range);
|
|
case ParsedAttr::AT_HLSLControlFlowHint:
|
|
return handleHLSLControlFlowHint(S, St, A, Range);
|
|
case ParsedAttr::AT_OpenCLUnrollHint:
|
|
return handleOpenCLUnrollHint(S, St, A, Range);
|
|
case ParsedAttr::AT_Suppress:
|
|
return handleSuppressAttr(S, St, A, Range);
|
|
case ParsedAttr::AT_NoMerge:
|
|
return handleNoMergeAttr(S, St, A, Range);
|
|
case ParsedAttr::AT_NoInline:
|
|
return handleNoInlineAttr(S, St, A, Range);
|
|
case ParsedAttr::AT_MustTail:
|
|
return handleMustTailAttr(S, St, A, Range);
|
|
case ParsedAttr::AT_Likely:
|
|
return handleLikely(S, St, A, Range);
|
|
case ParsedAttr::AT_Unlikely:
|
|
return handleUnlikely(S, St, A, Range);
|
|
case ParsedAttr::AT_CodeAlign:
|
|
return handleCodeAlignAttr(S, St, A);
|
|
case ParsedAttr::AT_MSConstexpr:
|
|
return handleMSConstexprAttr(S, St, A, Range);
|
|
case ParsedAttr::AT_NoConvergent:
|
|
return handleNoConvergentAttr(S, St, A, Range);
|
|
case ParsedAttr::AT_Annotate:
|
|
return S.CreateAnnotationAttr(A);
|
|
case ParsedAttr::AT_Atomic:
|
|
return handleAtomicAttr(S, St, A, Range);
|
|
default:
|
|
if (Attr *AT = nullptr; A.getInfo().handleStmtAttribute(S, St, A, AT) !=
|
|
ParsedAttrInfo::NotHandled) {
|
|
return AT;
|
|
}
|
|
// N.B., ClangAttrEmitter.cpp emits a diagnostic helper that ensures a
|
|
// declaration attribute is not written on a statement, but this code is
|
|
// needed for attributes in Attr.td that do not list any subjects.
|
|
S.Diag(A.getRange().getBegin(), diag::err_decl_attribute_invalid_on_stmt)
|
|
<< A << A.isRegularKeywordAttribute() << St->getBeginLoc();
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
void Sema::ProcessStmtAttributes(Stmt *S, const ParsedAttributes &InAttrs,
|
|
SmallVectorImpl<const Attr *> &OutAttrs) {
|
|
for (const ParsedAttr &AL : InAttrs) {
|
|
if (const Attr *A = ProcessStmtAttribute(*this, S, AL, InAttrs.Range))
|
|
OutAttrs.push_back(A);
|
|
}
|
|
|
|
CheckForIncompatibleAttributes(*this, OutAttrs);
|
|
CheckForDuplicateLoopAttrs<CodeAlignAttr>(*this, OutAttrs);
|
|
}
|
|
|
|
bool Sema::CheckRebuiltStmtAttributes(ArrayRef<const Attr *> Attrs) {
|
|
CheckForDuplicateLoopAttrs<CodeAlignAttr>(*this, Attrs);
|
|
return false;
|
|
}
|
|
|
|
ExprResult Sema::ActOnCXXAssumeAttr(Stmt *St, const ParsedAttr &A,
|
|
SourceRange Range) {
|
|
if (A.getNumArgs() != 1 || !A.getArgAsExpr(0)) {
|
|
Diag(A.getLoc(), diag::err_attribute_wrong_number_arguments)
|
|
<< A.getAttrName() << 1 << Range;
|
|
return ExprError();
|
|
}
|
|
|
|
auto *Assumption = A.getArgAsExpr(0);
|
|
|
|
if (DiagnoseUnexpandedParameterPack(Assumption)) {
|
|
return ExprError();
|
|
}
|
|
|
|
if (Assumption->getDependence() == ExprDependence::None) {
|
|
ExprResult Res = BuildCXXAssumeExpr(Assumption, A.getAttrName(), Range);
|
|
if (Res.isInvalid())
|
|
return ExprError();
|
|
Assumption = Res.get();
|
|
}
|
|
|
|
if (!getLangOpts().CPlusPlus23 &&
|
|
A.getSyntax() == AttributeCommonInfo::AS_CXX11)
|
|
Diag(A.getLoc(), diag::ext_cxx23_attr) << A << Range;
|
|
|
|
return Assumption;
|
|
}
|
|
|
|
ExprResult Sema::BuildCXXAssumeExpr(Expr *Assumption,
|
|
const IdentifierInfo *AttrName,
|
|
SourceRange Range) {
|
|
ExprResult Res = CorrectDelayedTyposInExpr(Assumption);
|
|
if (Res.isInvalid())
|
|
return ExprError();
|
|
|
|
Res = CheckPlaceholderExpr(Res.get());
|
|
if (Res.isInvalid())
|
|
return ExprError();
|
|
|
|
Res = PerformContextuallyConvertToBool(Res.get());
|
|
if (Res.isInvalid())
|
|
return ExprError();
|
|
|
|
Assumption = Res.get();
|
|
if (Assumption->HasSideEffects(Context))
|
|
Diag(Assumption->getBeginLoc(), diag::warn_assume_side_effects)
|
|
<< AttrName << Range;
|
|
|
|
return Assumption;
|
|
}
|