maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revert "[OpenMP] atomic compare fail : Parser & AST support" 

This reverts commit 232bf8189e.

It broke the sanitize buildbot: https://lab.llvm.org/buildbot/#/builders/5/builds/24074

It also reproduces on Windows debug builds as a crash.
This commit is contained in:
Aaron Ballman 2022-05-25 13:33:30 -04:00
parent ba3f85390b
commit 69da3b6aea
19 changed files with 2 additions and 444 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
clang/include/clang/AST/ASTNodeTraverser.h
View File

@ -214,10 +214,6 @@ public:
}
void Visit(const OMPClause *C) {
if (OMPFailClause::classof(C)) {
Visit(static_cast<const OMPFailClause *>(C));
return;
}
getNodeDelegate().AddChild([=] {
getNodeDelegate().Visit(C);
for (const auto *S : C->children())
@ -225,13 +221,6 @@ public:
});
}
void Visit(const OMPFailClause *C) {
getNodeDelegate().AddChild([=] {
getNodeDelegate().Visit(C);
const OMPClause *MOC = C->const_getMemoryOrderClause();
Visit(MOC);
});
}
void Visit(const GenericSelectionExpr::ConstAssociation &A) {
getNodeDelegate().AddChild([=] {
getNodeDelegate().Visit(A);

127
clang/include/clang/AST/OpenMPClause.h
View File

@ -2266,133 +2266,6 @@ public:
}
};
/// This represents 'fail' clause in the '#pragma omp atomic'
/// directive.
///
/// \code
/// #pragma omp atomic compare fail
/// \endcode
/// In this example directive '#pragma omp atomic compare' has 'fail' clause.
class OMPFailClause final
: public OMPClause,
private llvm::TrailingObjects<OMPFailClause, SourceLocation,
OpenMPClauseKind> {
OMPClause *MemoryOrderClause;
friend class OMPClauseReader;
friend TrailingObjects;
/// Define the sizes of each trailing object array except the last one. This
/// is required for TrailingObjects to work properly.
size_t numTrailingObjects(OverloadToken<SourceLocation>) const {
// 2 locations: for '(' and argument location.
return 2;
}
/// Sets the location of '(' in fail clause.
void setLParenLoc(SourceLocation Loc) {
*getTrailingObjects<SourceLocation>() = Loc;
}
/// Sets the location of memoryOrder clause argument in fail clause.
void setArgumentLoc(SourceLocation Loc) {
*std::next(getTrailingObjects<SourceLocation>(), 1) = Loc;
}
/// Sets the mem_order clause for 'atomic compare fail' directive.
void setMemOrderClauseKind(OpenMPClauseKind MemOrder) {
OpenMPClauseKind *MOCK = getTrailingObjects<OpenMPClauseKind>();
*MOCK = MemOrder;
}
/// Sets the mem_order clause for 'atomic compare fail' directive.
void setMemOrderClause(OMPClause *MemoryOrderClauseParam) {
MemoryOrderClause = MemoryOrderClauseParam;
}
public:
/// Build 'fail' clause.
///
/// \param StartLoc Starting location of the clause.
/// \param EndLoc Ending location of the clause.
OMPFailClause(SourceLocation StartLoc, SourceLocation EndLoc)
: OMPClause(llvm::omp::OMPC_fail, StartLoc, EndLoc) {}
/// Build an empty clause.
OMPFailClause()
: OMPClause(llvm::omp::OMPC_fail, SourceLocation(), SourceLocation()) {}
static OMPFailClause *CreateEmpty(const ASTContext &C);
static OMPFailClause *Create(const ASTContext &C, SourceLocation StartLoc,
SourceLocation EndLoc);
child_range children() {
return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
return const_child_range(const_child_iterator(), const_child_iterator());
}
child_range used_children() {
return child_range(child_iterator(), child_iterator());
}
const_child_range used_children() const {
return const_child_range(const_child_iterator(), const_child_iterator());
}
static bool classof(const OMPClause *T) {
return T->getClauseKind() == llvm::omp::OMPC_fail;
}
void initFailClause(SourceLocation LParenLoc, OMPClause *MemOClause,
SourceLocation MemOrderLoc) {
setLParenLoc(LParenLoc);
MemoryOrderClause = MemOClause;
setArgumentLoc(MemOrderLoc);
OpenMPClauseKind ClauseKind = MemoryOrderClause->getClauseKind();
OpenMPClauseKind MemClauseKind = llvm::omp::OMPC_unknown;
switch(ClauseKind) {
case llvm::omp::OMPC_acq_rel:
case llvm::omp::OMPC_acquire:
MemClauseKind = llvm::omp::OMPC_acquire;
break;
case llvm::omp::OMPC_relaxed:
case llvm::omp::OMPC_release:
MemClauseKind = llvm::omp::OMPC_relaxed;
break;
case llvm::omp::OMPC_seq_cst:
MemClauseKind = llvm::omp::OMPC_seq_cst;
break;
default : break;
}
setMemOrderClauseKind(MemClauseKind);
}
/// Gets the location of '(' in fail clause.
SourceLocation getLParenLoc() const {
return *getTrailingObjects<SourceLocation>();
}
OMPClause *getMemoryOrderClause() { return MemoryOrderClause; }
const OMPClause *const_getMemoryOrderClause() const {
return static_cast<const OMPClause *>(MemoryOrderClause);
}
/// Gets the location of memoryOrder clause argument in fail clause.
SourceLocation getArgumentLoc() const {
return *std::next(getTrailingObjects<SourceLocation>(), 1);
}
/// Gets the dependence kind in clause for 'depobj' directive.
OpenMPClauseKind getMemOrderClauseKind() const {
return *getTrailingObjects<OpenMPClauseKind>();
}
};
/// This represents 'seq_cst' clause in the '#pragma omp atomic'
/// directive.
///

5
clang/include/clang/AST/RecursiveASTVisitor.h
View File

@ -3346,11 +3346,6 @@ bool RecursiveASTVisitor<Derived>::VisitOMPCompareClause(OMPCompareClause *) {
return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::VisitOMPFailClause(OMPFailClause *) {
return true;
}
template <typename Derived>
bool RecursiveASTVisitor<Derived>::VisitOMPSeqCstClause(OMPSeqCstClause *) {
return true;

4
clang/include/clang/Basic/DiagnosticSemaKinds.td
View File

@ -10633,10 +10633,6 @@ def note_omp_atomic_compare: Note<
"expect binary operator in conditional expression|expect '<', '>' or '==' as order operator|expect comparison in a form of 'x == e', 'e == x', 'x ordop expr', or 'expr ordop x'|"
"expect lvalue for result value|expect scalar value|expect integer value|unexpected 'else' statement|expect '==' operator|expect an assignment statement 'v = x'|"
"expect a 'if' statement|expect no more than two statements|expect a compound statement|expect 'else' statement|expect a form 'r = x == e; if (r) ...'}0">;
def err_omp_atomic_fail_wrong_or_no_clauses : Error<"expected a memory order clause">;
def err_omp_atomic_fail_extra_mem_order_clauses : Error<"directive '#pragma omp atomic compare fail' cannot contain more than one memory order clause">;
def err_omp_atomic_fail_extra_clauses : Error<"directive '#pragma omp atomic compare' cannot contain more than one fail clause">;
def err_omp_atomic_fail_no_compare : Error<"expected 'compare' clause with the 'fail' modifier">;
def err_omp_atomic_several_clauses : Error<
"directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause">;
def err_omp_several_mem_order_clauses : Error<

2
clang/include/clang/Parse/Parser.h
View File

@ -433,8 +433,6 @@ class Parser : public CodeCompletionHandler {
/// a statement expression and builds a suitable expression statement.
StmtResult handleExprStmt(ExprResult E, ParsedStmtContext StmtCtx);
OMPClause *ParseOpenMPFailClause(OMPClause *Clause);
public:
Parser(Preprocessor &PP, Sema &Actions, bool SkipFunctionBodies);
~Parser() override;

3
clang/include/clang/Sema/Sema.h
View File

@ -11361,9 +11361,6 @@ public:
/// Called on well-formed 'compare' clause.
OMPClause *ActOnOpenMPCompareClause(SourceLocation StartLoc,
SourceLocation EndLoc);
/// Called on well-formed 'fail' clause.
OMPClause *ActOnOpenMPFailClause(SourceLocation StartLoc,
SourceLocation EndLoc);
/// Called on well-formed 'seq_cst' clause.
OMPClause *ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
SourceLocation EndLoc);

31
clang/lib/AST/OpenMPClause.cpp
View File

@ -127,7 +127,6 @@ const OMPClauseWithPreInit *OMPClauseWithPreInit::get(const OMPClause *C) {
case OMPC_update:
case OMPC_capture:
case OMPC_compare:
case OMPC_fail:
case OMPC_seq_cst:
case OMPC_acq_rel:
case OMPC_acquire:
@ -221,7 +220,6 @@ const OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(const OMPClause *C)
case OMPC_update:
case OMPC_capture:
case OMPC_compare:
case OMPC_fail:
case OMPC_seq_cst:
case OMPC_acq_rel:
case OMPC_acquire:
@ -414,25 +412,6 @@ OMPUpdateClause *OMPUpdateClause::CreateEmpty(const ASTContext &C,
return Clause;
}
OMPFailClause *OMPFailClause::Create(const ASTContext &C,
SourceLocation StartLoc,
SourceLocation EndLoc) {
void *Mem =
C.Allocate(totalSizeToAlloc<SourceLocation, OpenMPClauseKind>(2, 1),
alignof(OMPFailClause));
auto *Clause =
new (Mem) OMPFailClause(StartLoc, EndLoc);
return Clause;
}
OMPFailClause *OMPFailClause::CreateEmpty(const ASTContext &C) {
void *Mem =
C.Allocate(totalSizeToAlloc<SourceLocation, OpenMPClauseKind>(2, 1),
alignof(OMPFailClause));
auto *Clause = new (Mem) OMPFailClause();
return Clause;
}
void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
assert(VL.size() == varlist_size() &&
"Number of private copies is not the same as the preallocated buffer");
@ -1868,16 +1847,6 @@ void OMPClausePrinter::VisitOMPCompareClause(OMPCompareClause *) {
OS << "compare";
}
void OMPClausePrinter::VisitOMPFailClause(OMPFailClause *Node) {
OS << "fail";
if(Node) {
OS << "(";
OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(),
static_cast<int>(Node->getMemOrderClauseKind()));
OS << ")";
}
}
void OMPClausePrinter::VisitOMPSeqCstClause(OMPSeqCstClause *) {
OS << "seq_cst";
}

2
clang/lib/AST/StmtProfile.cpp
View File

@ -557,8 +557,6 @@ void OMPClauseProfiler::VisitOMPCaptureClause(const OMPCaptureClause *) {}
void OMPClauseProfiler::VisitOMPCompareClause(const OMPCompareClause *) {}
void OMPClauseProfiler::VisitOMPFailClause(const OMPFailClause *) {}
void OMPClauseProfiler::VisitOMPSeqCstClause(const OMPSeqCstClause *) {}
void OMPClauseProfiler::VisitOMPAcqRelClause(const OMPAcqRelClause *) {}

14
clang/lib/Basic/OpenMPKinds.cpp
View File

@ -366,20 +366,6 @@ const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
#include "clang/Basic/OpenMPKinds.def"
}
llvm_unreachable("Invalid OpenMP 'depend' clause type");
case OMPC_fail: {
OpenMPClauseKind CK = static_cast<OpenMPClauseKind>(Type);
switch (CK) {
case OMPC_acquire:
return "acquire";
case OMPC_relaxed:
return "relaxed";
case OMPC_seq_cst:
return "seq_cst";
default:
return "unknown";
}
llvm_unreachable("Invalid OpenMP 'fail' clause modifier");
}
case OMPC_device:
switch (Type) {
case OMPC_DEVICE_unknown:

46
clang/lib/Parse/ParseOpenMP.cpp
View File

@ -3244,7 +3244,6 @@ OMPClause *Parser::ParseOpenMPClause(OpenMPDirectiveKind DKind,
case OMPC_write:
case OMPC_capture:
case OMPC_compare:
case OMPC_fail:
case OMPC_seq_cst:
case OMPC_acq_rel:
case OMPC_acquire:
@ -3631,45 +3630,6 @@ OMPClause *Parser::ParseOpenMPSimpleClause(OpenMPClauseKind Kind,
Val.getValue().Loc, Val.getValue().RLoc);
}
OMPClause *Parser::ParseOpenMPFailClause(OMPClause *Clause) {
OMPFailClause *FailClause = static_cast<OMPFailClause *>(Clause);
SourceLocation LParenLoc;
if (Tok.is(tok::l_paren)) {
LParenLoc = Tok.getLocation();
ConsumeAnyToken();
} else {
Diag(diag::err_expected_lparen_after) << getOpenMPClauseName(OMPC_fail);
return Clause;
}
OpenMPClauseKind CKind = Tok.isAnnotation()
? OMPC_unknown
: getOpenMPClauseKind(PP.getSpelling(Tok));
if (CKind == OMPC_unknown) {
Diag(diag::err_omp_expected_clause) << ("atomic compare fail");
return Clause;
}
OMPClause *MemoryOrderClause = ParseOpenMPClause(CKind, false);
SourceLocation MemOrderLoc;
// Store Memory Order SubClause for Sema.
if (MemoryOrderClause) {
MemOrderLoc = Tok.getLocation();
}
if (Tok.is(tok::r_paren)) {
FailClause->initFailClause(LParenLoc,MemoryOrderClause,MemOrderLoc);
ConsumeAnyToken();
} else {
const IdentifierInfo *Arg = Tok.getIdentifierInfo();
Diag(Tok, diag::err_expected_rparen_after)
<< (Arg ? Arg->getName() : "atomic compare fail");
}
return Clause;
}
/// Parsing of OpenMP clauses like 'ordered'.
///
/// ordered-clause:
@ -3702,11 +3662,7 @@ OMPClause *Parser::ParseOpenMPClause(OpenMPClauseKind Kind, bool ParseOnly) {
if (ParseOnly)
return nullptr;
OMPClause *Clause = Actions.ActOnOpenMPClause(Kind, Loc, Tok.getLocation());
if (Kind == llvm::omp::Clause::OMPC_fail) {
Clause = ParseOpenMPFailClause(Clause);
}
return Clause;
return Actions.ActOnOpenMPClause(Kind, Loc, Tok.getLocation());
}
/// Parsing of OpenMP clauses with single expressions and some additional

93
clang/lib/Sema/SemaOpenMP.cpp
View File

@ -12026,68 +12026,6 @@ bool OpenMPAtomicCompareCaptureChecker::checkStmt(Stmt *S,
return checkType(ErrorInfo);
}
class OpenMPAtomicFailChecker {
protected:
Sema &SemaRef;
ASTContext &Context;
public:
// Error descriptor type which will be returned to Sema
unsigned int ErrorNo;
OpenMPAtomicFailChecker(Sema &S) : SemaRef(S), Context(S.getASTContext()) {}
/// Check if all results conform with spec in terms of lvalue/rvalue
/// and scalar type.
bool checkSubClause(ArrayRef<OMPClause *> Clauses, SourceLocation *ErrorLoc);
/// Return the error descriptor that will guide the error message emission.
unsigned getErrorDesc() const { return ErrorNo; }
};
bool OpenMPAtomicFailChecker::checkSubClause(ArrayRef<OMPClause *> Clauses,
SourceLocation *ErrorLoc) {
int NoOfFails = 0;
ErrorNo = 0;
SourceLocation ClauseLoc;
for (const OMPClause *C : Clauses) {
if (C->getClauseKind() == OMPC_fail) {
NoOfFails++;
const OMPFailClause *FC = static_cast<const OMPFailClause *>(C);
const OMPClause *MemOrderC = FC->const_getMemoryOrderClause();
/* Clauses contains OMPC_fail and the subclause */
if (MemOrderC) {
OpenMPClauseKind ClauseKind = MemOrderC->getClauseKind();
if ((ClauseKind == OMPC_acq_rel) || (ClauseKind == OMPC_acquire) ||
(ClauseKind == OMPC_relaxed) || (ClauseKind == OMPC_release) ||
(ClauseKind == OMPC_seq_cst)) {
switch(ClauseKind) {
case OMPC_acq_rel :
ClauseKind = OMPC_acquire;
break;
case OMPC_release :
ClauseKind = OMPC_relaxed;
break;
default : break;
}
continue;
} else {
ErrorNo = diag::err_omp_atomic_fail_wrong_or_no_clauses;
*ErrorLoc = MemOrderC->getBeginLoc();
continue;
}
}
}
}
if (NoOfFails > 1) {
ErrorNo = diag::err_omp_atomic_fail_extra_clauses;
*ErrorLoc = ClauseLoc;
}
return !ErrorNo;
}
} // namespace
StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
@ -12108,8 +12046,6 @@ StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
SourceLocation AtomicKindLoc;
OpenMPClauseKind MemOrderKind = OMPC_unknown;
SourceLocation MemOrderLoc;
llvm::omp::Clause SubClause = OMPC_unknown;
SourceLocation SubClauseLoc;
bool MutexClauseEncountered = false;
llvm::SmallSet<OpenMPClauseKind, 2> EncounteredAtomicKinds;
for (const OMPClause *C : Clauses) {
@ -12138,16 +12074,6 @@ StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
}
break;
}
case OMPC_fail: {
if (AtomicKind != OMPC_compare) {
Diag(C->getBeginLoc(), diag::err_omp_atomic_fail_no_compare)
<< SourceRange(C->getBeginLoc(), C->getEndLoc());
return StmtError();
}
SubClause = OMPC_fail;
SubClauseLoc = C->getBeginLoc();
break;
}
case OMPC_seq_cst:
case OMPC_acq_rel:
case OMPC_acquire:
@ -12626,17 +12552,6 @@ StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
CE = Checker.getCond();
// We reuse IsXLHSInRHSPart to tell if it is in the form 'x ordop expr'.
IsXLHSInRHSPart = Checker.isXBinopExpr();
if (SubClause == OMPC_fail) {
OpenMPAtomicFailChecker Checker(*this);
SourceLocation ErrorLoc, NoteLoc;
NoteLoc = ErrorLoc = Body->getBeginLoc();
ErrorLoc = SubClauseLoc;
if (!Checker.checkSubClause(Clauses,&ErrorLoc)) {
unsigned ErrorNo = Checker.getErrorDesc();
Diag(ErrorLoc, ErrorNo);
return StmtError();
}
}
}
}
@ -16576,9 +16491,6 @@ OMPClause *Sema::ActOnOpenMPClause(OpenMPClauseKind Kind,
case OMPC_compare:
Res = ActOnOpenMPCompareClause(StartLoc, EndLoc);
break;
case OMPC_fail:
Res = ActOnOpenMPFailClause(StartLoc, EndLoc);
break;
case OMPC_seq_cst:
Res = ActOnOpenMPSeqCstClause(StartLoc, EndLoc);
break;
@ -16732,11 +16644,6 @@ OMPClause *Sema::ActOnOpenMPCompareClause(SourceLocation StartLoc,
return new (Context) OMPCompareClause(StartLoc, EndLoc);
}
OMPClause *Sema::ActOnOpenMPFailClause(SourceLocation StartLoc,
SourceLocation EndLoc) {
return OMPFailClause::Create(Context, StartLoc, EndLoc);
}
OMPClause *Sema::ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
SourceLocation EndLoc) {
return new (Context) OMPSeqCstClause(StartLoc, EndLoc);

7
clang/lib/Sema/TreeTransform.h
View File

@ -9559,13 +9559,6 @@ TreeTransform<Derived>::TransformOMPCompareClause(OMPCompareClause *C) {
return C;
}
template <typename Derived>
OMPClause *
TreeTransform<Derived>::TransformOMPFailClause(OMPFailClause *C) {
// No need to rebuild this clause, no template-dependent parameters.
return C;
}
template <typename Derived>
OMPClause *
TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) {

28
clang/lib/Serialization/ASTReader.cpp
View File

@ -11744,9 +11744,6 @@ OMPClause *OMPClauseReader::readClause() {
case llvm::omp::OMPC_compare:
C = new (Context) OMPCompareClause();
break;
case llvm::omp::OMPC_fail:
C = OMPFailClause::CreateEmpty(Context);
break;
case llvm::omp::OMPC_seq_cst:
C = new (Context) OMPSeqCstClause();
break;
@ -12116,31 +12113,6 @@ void OMPClauseReader::VisitOMPCaptureClause(OMPCaptureClause *) {}
void OMPClauseReader::VisitOMPCompareClause(OMPCompareClause *) {}
void OMPClauseReader::VisitOMPFailClause(OMPFailClause *C) {
C->setLParenLoc(Record.readSourceLocation());
SourceLocation SourceLoc = Record.readSourceLocation();
C->setArgumentLoc(SourceLoc);
OpenMPClauseKind CKind = Record.readEnum<OpenMPClauseKind>();
C->setMemOrderClauseKind(CKind);
SourceLocation EndLoc;
OMPClause *MemoryOrderClause = NULL;
switch(CKind) {
case llvm::omp::OMPC_acquire:
MemoryOrderClause = new (Context) OMPAcquireClause(SourceLoc, EndLoc);
break;
case llvm::omp::OMPC_relaxed:
MemoryOrderClause = new (Context) OMPRelaxedClause(SourceLoc, EndLoc);
break;
case llvm::omp::OMPC_seq_cst:
MemoryOrderClause = new (Context) OMPSeqCstClause(SourceLoc, EndLoc);
break;
default:
break;
}
C->setMemOrderClause(MemoryOrderClause);
}
void OMPClauseReader::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
void OMPClauseReader::VisitOMPAcqRelClause(OMPAcqRelClause *) {}

8
clang/lib/Serialization/ASTWriter.cpp
View File

@ -6327,14 +6327,6 @@ void OMPClauseWriter::VisitOMPCaptureClause(OMPCaptureClause *) {}
void OMPClauseWriter::VisitOMPCompareClause(OMPCompareClause *) {}
void OMPClauseWriter::VisitOMPFailClause(OMPFailClause *C) {
// Record.AddSourceLocation(C->getLParenLoc());
// Copied from VisitOMPUpdateClause
Record.AddSourceLocation(C->getLParenLoc());
Record.AddSourceLocation(C->getArgumentLoc());
Record.writeEnum(C->getMemOrderClauseKind());
}
void OMPClauseWriter::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
void OMPClauseWriter::VisitOMPAcqRelClause(OMPAcqRelClause *) {}

40
clang/test/OpenMP/atomic_ast_print.cpp
View File

@ -226,16 +226,6 @@ T foo(T argc) {
{ v = a; if (a < b) { a = b; } }
#pragma omp atomic compare capture hint(6)
{ v = a == b; if (v) a = c; }
#pragma omp atomic compare fail(acq_rel)
{ if (a < c) { a = c; } }
#pragma omp atomic compare fail(acquire)
{ if (a < c) { a = c; } }
#pragma omp atomic compare fail(release)
{ if (a < c) { a = c; } }
#pragma omp atomic compare fail(relaxed)
{ if (a < c) { a = c; } }
#pragma omp atomic compare fail(seq_cst)
{ if (a < c) { a = c; } }
#endif
return T();
}
@ -1109,16 +1099,6 @@ int main(int argc, char **argv) {
{ v = a; if (a < b) { a = b; } }
#pragma omp atomic compare capture hint(6)
{ v = a == b; if (v) a = c; }
#pragma omp atomic compare fail(acq_rel)
if(a < b) { a = b; }
#pragma omp atomic compare fail(acquire)
if(a < b) { a = b; }
#pragma omp atomic compare fail(release)
if(a < b) { a = b; }
#pragma omp atomic compare fail(relaxed)
if(a < b) { a = b; }
#pragma omp atomic compare fail(seq_cst)
if(a < b) { a = b; }
#endif
// CHECK-NEXT: #pragma omp atomic
// CHECK-NEXT: a++;
@ -1449,26 +1429,6 @@ int main(int argc, char **argv) {
// CHECK-51-NEXT: if (v)
// CHECK-51-NEXT: a = c;
// CHECK-51-NEXT: }
// CHECK-51-NEXT: #pragma omp atomic compare fail(acquire)
// CHECK-51-NEXT: if (a < b) {
// CHECK-51-NEXT: a = b;
// CHECK-51-NEXT: }
// CHECK-51-NEXT: #pragma omp atomic compare fail(acquire)
// CHECK-51-NEXT: if (a < b) {
// CHECK-51-NEXT: a = b;
// CHECK-51-NEXT: }
// CHECK-51-NEXT: #pragma omp atomic compare fail(relaxed)
// CHECK-51-NEXT: if (a < b) {
// CHECK-51-NEXT: a = b;
// CHECK-51-NEXT: }
// CHECK-51-NEXT: #pragma omp atomic compare fail(relaxed)
// CHECK-51-NEXT: if (a < b) {
// CHECK-51-NEXT: a = b;
// CHECK-51-NEXT: }
// CHECK-51-NEXT: #pragma omp atomic compare fail(seq_cst)
// CHECK-51-NEXT: if (a < b) {
// CHECK-51-NEXT: a = b;
// CHECK-51-NEXT: }
// expect-note@+1 {{in instantiation of function template specialization 'foo<int>' requested here}}
return foo(a);
}

18
clang/test/OpenMP/atomic_messages.cpp
View File

@ -958,24 +958,6 @@ int mixed() {
// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'capture' clause}}
#pragma omp atomic compare compare capture capture
{ v = a; if (a > b) a = b; }
// expected-error@+1 {{expected 'compare' clause with the 'fail' modifier}}
#pragma omp atomic fail(seq_cst)
if(v == a) { v = a; }
// expected-error@+1 {{expected '(' after 'fail'}}
#pragma omp atomic compare fail
if(v < a) { v = a; }
// expected-error@+1 {{expected a memory order clause}}
#pragma omp atomic compare fail(capture)
if(v < a) { v = a; }
// expected-error@+2 {{expected ')' after 'atomic compare fail'}}
// expected-warning@+1 {{extra tokens at the end of '#pragma omp atomic' are ignored}}
#pragma omp atomic compare fail(seq_cst | acquire)
if(v < a) { v = a; }
// expected-error@+1 {{directive '#pragma omp atomic' cannot contain more than one 'fail' clause}}
#pragma omp atomic compare fail(relaxed) fail(seq_cst)
if(v < a) { v = a; }
#endif
// expected-note@+1 {{in instantiation of function template specialization 'mixed<int>' requested here}}
return mixed<int>();

2
clang/tools/libclang/CIndex.cpp
View File

@ -2367,8 +2367,6 @@ void OMPClauseEnqueue::VisitOMPCaptureClause(const OMPCaptureClause *) {}
void OMPClauseEnqueue::VisitOMPCompareClause(const OMPCompareClause *) {}
void OMPClauseEnqueue::VisitOMPFailClause(const OMPFailClause *) {}
void OMPClauseEnqueue::VisitOMPSeqCstClause(const OMPSeqCstClause *) {}
void OMPClauseEnqueue::VisitOMPAcqRelClause(const OMPAcqRelClause *) {}

1
flang/lib/Semantics/check-omp-structure.cpp
View File

@ -1807,7 +1807,6 @@ CHECK_SIMPLE_CLAUSE(Bind, OMPC_bind)
CHECK_SIMPLE_CLAUSE(Align, OMPC_align)
CHECK_SIMPLE_CLAUSE(Compare, OMPC_compare)
CHECK_SIMPLE_CLAUSE(CancellationConstructType, OMPC_cancellation_construct_type)
CHECK_SIMPLE_CLAUSE(Fail, OMPC_fail)
CHECK_REQ_SCALAR_INT_CLAUSE(Grainsize, OMPC_grainsize)
CHECK_REQ_SCALAR_INT_CLAUSE(NumTasks, OMPC_num_tasks)

4
llvm/include/llvm/Frontend/OpenMP/OMP.td
View File

@ -199,7 +199,6 @@ def OMPC_Write : Clause<"write"> { let clangClass = "OMPWriteClause"; }
def OMPC_Update : Clause<"update"> { let clangClass = "OMPUpdateClause"; }
def OMPC_Capture : Clause<"capture"> { let clangClass = "OMPCaptureClause"; }
def OMPC_Compare : Clause<"compare"> { let clangClass = "OMPCompareClause"; }
def OMPC_Fail : Clause<"fail"> { let clangClass = "OMPFailClause"; }
def OMPC_SeqCst : Clause<"seq_cst"> { let clangClass = "OMPSeqCstClause"; }
def OMPC_AcqRel : Clause<"acq_rel"> { let clangClass = "OMPAcqRelClause"; }
def OMPC_Acquire : Clause<"acquire"> { let clangClass = "OMPAcquireClause"; }
@ -570,8 +569,7 @@ def OMP_Atomic : Directive<"atomic"> {
VersionedClause<OMPC_Acquire, 50>,
VersionedClause<OMPC_Release, 50>,
VersionedClause<OMPC_Relaxed, 50>,
VersionedClause<OMPC_Hint, 50>,
VersionedClause<OMPC_Fail, 51>
VersionedClause<OMPC_Hint, 50>
];
}
def OMP_Target : Directive<"target"> {