| //== SemaOpenACCAtomic.cpp - Semantic Analysis for OpenACC Atomic Construct===// |
| // |
| // 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 |
| // |
| //===----------------------------------------------------------------------===// |
| /// \file |
| /// This file implements semantic analysis for the OpenACC atomic construct. |
| /// |
| //===----------------------------------------------------------------------===// |
| |
| #include "clang/AST/ExprCXX.h" |
| #include "clang/Basic/DiagnosticSema.h" |
| #include "clang/Sema/SemaOpenACC.h" |
| |
| #include <optional> |
| #include <variant> |
| |
| using namespace clang; |
| |
| namespace { |
| |
| class AtomicOperandChecker { |
| SemaOpenACC &SemaRef; |
| OpenACCAtomicKind AtKind; |
| SourceLocation AtomicDirLoc; |
| StmtResult AssocStmt; |
| |
| // Do a diagnostic, which sets the correct error, then displays passed note. |
| bool DiagnoseInvalidAtomic(SourceLocation Loc, PartialDiagnostic NoteDiag) { |
| SemaRef.Diag(AtomicDirLoc, diag::err_acc_invalid_atomic) |
| << (AtKind != OpenACCAtomicKind::None) << AtKind; |
| SemaRef.Diag(Loc, NoteDiag); |
| return true; |
| } |
| |
| // Create a replacement recovery expr in case we find an error here. This |
| // allows us to ignore this during template instantiation so we only get a |
| // single error. |
| StmtResult getRecoveryExpr() { |
| if (!AssocStmt.isUsable()) |
| return AssocStmt; |
| |
| if (!SemaRef.getASTContext().getLangOpts().RecoveryAST) |
| return StmtError(); |
| |
| Expr *E = dyn_cast<Expr>(AssocStmt.get()); |
| QualType T = E ? E->getType() : SemaRef.getASTContext().DependentTy; |
| |
| return RecoveryExpr::Create(SemaRef.getASTContext(), T, |
| AssocStmt.get()->getBeginLoc(), |
| AssocStmt.get()->getEndLoc(), |
| E ? ArrayRef<Expr *>{E} : ArrayRef<Expr *>{}); |
| } |
| |
| // OpenACC 3.3 2.12: 'expr' is an expression with scalar type. |
| bool CheckOperandExpr(const Expr *E, PartialDiagnostic PD) { |
| QualType ExprTy = E->getType(); |
| |
| // Scalar allowed, plus we allow instantiation dependent to support |
| // templates. |
| if (ExprTy->isInstantiationDependentType() || ExprTy->isScalarType()) |
| return false; |
| |
| return DiagnoseInvalidAtomic(E->getExprLoc(), |
| PD << diag::OACCLValScalar::Scalar << ExprTy); |
| } |
| |
| // OpenACC 3.3 2.12: 'x' and 'v' (as applicable) are boht l-value expressoins |
| // with scalar type. |
| bool CheckOperandVariable(const Expr *E, PartialDiagnostic PD) { |
| if (CheckOperandExpr(E, PD)) |
| return true; |
| |
| if (E->isLValue()) |
| return false; |
| |
| return DiagnoseInvalidAtomic(E->getExprLoc(), |
| PD << diag::OACCLValScalar::LVal); |
| } |
| |
| Expr *RequireExpr(Stmt *Stmt, PartialDiagnostic ExpectedNote) { |
| if (Expr *E = dyn_cast<Expr>(Stmt)) |
| return E->IgnoreImpCasts(); |
| |
| DiagnoseInvalidAtomic(Stmt->getBeginLoc(), ExpectedNote); |
| return nullptr; |
| } |
| |
| // A struct to hold the return the inner components of any operands, which |
| // allows for compound checking. |
| struct BinaryOpInfo { |
| const Expr *FoundExpr = nullptr; |
| const Expr *LHS = nullptr; |
| const Expr *RHS = nullptr; |
| BinaryOperatorKind Operator; |
| }; |
| |
| struct UnaryOpInfo { |
| const Expr *FoundExpr = nullptr; |
| const Expr *SubExpr = nullptr; |
| UnaryOperatorKind Operator; |
| |
| bool IsIncrementOp() { |
| return Operator == UO_PostInc || Operator == UO_PreInc; |
| } |
| }; |
| |
| std::optional<UnaryOpInfo> GetUnaryOperatorInfo(const Expr *E) { |
| // If this is a simple unary operator, just return its details. |
| if (const auto *UO = dyn_cast<UnaryOperator>(E)) |
| return UnaryOpInfo{UO, UO->getSubExpr()->IgnoreImpCasts(), |
| UO->getOpcode()}; |
| |
| // This might be an overloaded operator or a dependent context, so make sure |
| // we can get as many details out of this as we can. |
| if (const auto *OpCall = dyn_cast<CXXOperatorCallExpr>(E)) { |
| UnaryOpInfo Inf; |
| Inf.FoundExpr = OpCall; |
| |
| switch (OpCall->getOperator()) { |
| default: |
| return std::nullopt; |
| case OO_PlusPlus: |
| Inf.Operator = OpCall->getNumArgs() == 1 ? UO_PreInc : UO_PostInc; |
| break; |
| case OO_MinusMinus: |
| Inf.Operator = OpCall->getNumArgs() == 1 ? UO_PreDec : UO_PostDec; |
| break; |
| case OO_Amp: |
| Inf.Operator = UO_AddrOf; |
| break; |
| case OO_Star: |
| Inf.Operator = UO_Deref; |
| break; |
| case OO_Plus: |
| Inf.Operator = UO_Plus; |
| break; |
| case OO_Minus: |
| Inf.Operator = UO_Minus; |
| break; |
| case OO_Tilde: |
| Inf.Operator = UO_Not; |
| break; |
| case OO_Exclaim: |
| Inf.Operator = UO_LNot; |
| break; |
| case OO_Coawait: |
| Inf.Operator = UO_Coawait; |
| break; |
| } |
| |
| // Some of the above can be both binary and unary operations, so make sure |
| // we get the right one. |
| if (Inf.Operator != UO_PostInc && Inf.Operator != UO_PostDec && |
| OpCall->getNumArgs() != 1) |
| return std::nullopt; |
| |
| Inf.SubExpr = OpCall->getArg(0); |
| return Inf; |
| } |
| return std::nullopt; |
| } |
| |
| // Get a normalized version of a binary operator. |
| std::optional<BinaryOpInfo> GetBinaryOperatorInfo(const Expr *E) { |
| if (const auto *BO = dyn_cast<BinaryOperator>(E)) |
| return BinaryOpInfo{BO, BO->getLHS()->IgnoreImpCasts(), |
| BO->getRHS()->IgnoreImpCasts(), BO->getOpcode()}; |
| |
| // In case this is an operator-call, which allows us to support overloaded |
| // operators and dependent expression. |
| if (const auto *OpCall = dyn_cast<CXXOperatorCallExpr>(E)) { |
| BinaryOpInfo Inf; |
| Inf.FoundExpr = OpCall; |
| |
| switch (OpCall->getOperator()) { |
| default: |
| return std::nullopt; |
| case OO_Plus: |
| Inf.Operator = BO_Add; |
| break; |
| case OO_Minus: |
| Inf.Operator = BO_Sub; |
| break; |
| case OO_Star: |
| Inf.Operator = BO_Mul; |
| break; |
| case OO_Slash: |
| Inf.Operator = BO_Div; |
| break; |
| case OO_Percent: |
| Inf.Operator = BO_Rem; |
| break; |
| case OO_Caret: |
| Inf.Operator = BO_Xor; |
| break; |
| case OO_Amp: |
| Inf.Operator = BO_And; |
| break; |
| case OO_Pipe: |
| Inf.Operator = BO_Or; |
| break; |
| case OO_Equal: |
| Inf.Operator = BO_Assign; |
| break; |
| case OO_Spaceship: |
| Inf.Operator = BO_Cmp; |
| break; |
| case OO_Less: |
| Inf.Operator = BO_LT; |
| break; |
| case OO_Greater: |
| Inf.Operator = BO_GT; |
| break; |
| case OO_PlusEqual: |
| Inf.Operator = BO_AddAssign; |
| break; |
| case OO_MinusEqual: |
| Inf.Operator = BO_SubAssign; |
| break; |
| case OO_StarEqual: |
| Inf.Operator = BO_MulAssign; |
| break; |
| case OO_SlashEqual: |
| Inf.Operator = BO_DivAssign; |
| break; |
| case OO_PercentEqual: |
| Inf.Operator = BO_RemAssign; |
| break; |
| case OO_CaretEqual: |
| Inf.Operator = BO_XorAssign; |
| break; |
| case OO_AmpEqual: |
| Inf.Operator = BO_AndAssign; |
| break; |
| case OO_PipeEqual: |
| Inf.Operator = BO_OrAssign; |
| break; |
| case OO_LessLess: |
| Inf.Operator = BO_Shl; |
| break; |
| case OO_GreaterGreater: |
| Inf.Operator = BO_Shr; |
| break; |
| case OO_LessLessEqual: |
| Inf.Operator = BO_ShlAssign; |
| break; |
| case OO_GreaterGreaterEqual: |
| Inf.Operator = BO_ShrAssign; |
| break; |
| case OO_EqualEqual: |
| Inf.Operator = BO_EQ; |
| break; |
| case OO_ExclaimEqual: |
| Inf.Operator = BO_NE; |
| break; |
| case OO_LessEqual: |
| Inf.Operator = BO_LE; |
| break; |
| case OO_GreaterEqual: |
| Inf.Operator = BO_GE; |
| break; |
| case OO_AmpAmp: |
| Inf.Operator = BO_LAnd; |
| break; |
| case OO_PipePipe: |
| Inf.Operator = BO_LOr; |
| break; |
| case OO_Comma: |
| Inf.Operator = BO_Comma; |
| break; |
| case OO_ArrowStar: |
| Inf.Operator = BO_PtrMemI; |
| break; |
| } |
| |
| // This isn't a binary operator unless there are two arguments. |
| if (OpCall->getNumArgs() != 2) |
| return std::nullopt; |
| |
| // Callee is the call-operator, so we only need to extract the two |
| // arguments here. |
| Inf.LHS = OpCall->getArg(0)->IgnoreImpCasts(); |
| Inf.RHS = OpCall->getArg(1)->IgnoreImpCasts(); |
| return Inf; |
| } |
| |
| return std::nullopt; |
| } |
| |
| // Checks a required assignment operation, but don't check the LHS or RHS, |
| // callers have to do that here. |
| std::optional<BinaryOpInfo> CheckAssignment(const Expr *E) { |
| std::optional<BinaryOpInfo> Inf = GetBinaryOperatorInfo(E); |
| |
| if (!Inf) { |
| DiagnoseInvalidAtomic(E->getExprLoc(), |
| SemaRef.PDiag(diag::note_acc_atomic_expr_must_be) |
| << diag::OACCAtomicExpr::Assign); |
| return std::nullopt; |
| } |
| |
| if (Inf->Operator != BO_Assign) { |
| DiagnoseInvalidAtomic(Inf->FoundExpr->getExprLoc(), |
| SemaRef.PDiag(diag::note_acc_atomic_expr_must_be) |
| << diag::OACCAtomicExpr::Assign); |
| return std::nullopt; |
| } |
| |
| // Assignment always requires an lvalue/scalar on the LHS. |
| if (CheckOperandVariable( |
| Inf->LHS, SemaRef.PDiag(diag::note_acc_atomic_operand_lvalue_scalar) |
| << /*left=*/0 << diag::OACCAtomicOpKind::Assign)) |
| return std::nullopt; |
| |
| return Inf; |
| } |
| |
| struct IDACInfo { |
| bool Failed = false; |
| enum ExprKindTy { |
| Invalid, |
| // increment/decrement ops. |
| Unary, |
| // v = x |
| SimpleAssign, |
| // x = expr |
| ExprAssign, |
| // x binop= expr |
| CompoundAssign, |
| // x = x binop expr |
| // x = expr binop x |
| AssignBinOp |
| } ExprKind; |
| |
| // The variable referred to as 'x' in all of the grammar, such that it is |
| // needed in compound statement checking of capture to check between the two |
| // expressions. |
| const Expr *X_Var = nullptr; |
| |
| static IDACInfo Fail() { return IDACInfo{true, Invalid, nullptr}; }; |
| }; |
| |
| // Helper for CheckIncDecAssignCompoundAssign, does checks for inc/dec. |
| IDACInfo CheckIncDec(UnaryOpInfo Inf) { |
| |
| if (!UnaryOperator::isIncrementDecrementOp(Inf.Operator)) { |
| DiagnoseInvalidAtomic( |
| Inf.FoundExpr->getExprLoc(), |
| SemaRef.PDiag(diag::note_acc_atomic_unsupported_unary_operator)); |
| return IDACInfo::Fail(); |
| } |
| bool Failed = CheckOperandVariable( |
| Inf.SubExpr, |
| SemaRef.PDiag(diag::note_acc_atomic_operand_lvalue_scalar) |
| << /*none=*/2 |
| << (Inf.IsIncrementOp() ? diag::OACCAtomicOpKind::Inc |
| : diag::OACCAtomicOpKind::Dec)); |
| // For increment/decrements, the subexpr is the 'x' (x++, ++x, etc). |
| return IDACInfo{Failed, IDACInfo::Unary, Inf.SubExpr}; |
| } |
| |
| enum class SimpleAssignKind { None, Var, Expr }; |
| |
| // Check an assignment, and ensure the RHS is either x binop expr or expr |
| // binop x. |
| // If AllowSimpleAssign, also allows v = x; |
| IDACInfo CheckAssignmentWithBinOpOnRHS(BinaryOpInfo AssignInf, |
| SimpleAssignKind SAK) { |
| PartialDiagnostic PD = |
| SemaRef.PDiag(diag::note_acc_atomic_operand_lvalue_scalar) |
| << /*left=*/0 << diag::OACCAtomicOpKind::Assign; |
| if (CheckOperandVariable(AssignInf.LHS, PD)) |
| return IDACInfo::Fail(); |
| |
| std::optional<BinaryOpInfo> BinInf = GetBinaryOperatorInfo(AssignInf.RHS); |
| |
| if (!BinInf) { |
| |
| // Capture in a compound statement allows v = x assignment. So make sure |
| // we permit that here. |
| if (SAK != SimpleAssignKind::None) { |
| PartialDiagnostic PD = |
| SemaRef.PDiag(diag::note_acc_atomic_operand_lvalue_scalar) |
| << /*right=*/1 << diag::OACCAtomicOpKind::Assign; |
| if (SAK == SimpleAssignKind::Var) { |
| // In the var version, everywhere we allow v = x;, X is the RHS. |
| return IDACInfo{CheckOperandVariable(AssignInf.RHS, PD), |
| IDACInfo::SimpleAssign, AssignInf.RHS}; |
| } |
| assert(SAK == SimpleAssignKind::Expr); |
| // In the expression version, supported by v=x; x = expr;, we need to |
| // set to the LHS here. |
| return IDACInfo{CheckOperandExpr(AssignInf.RHS, PD), |
| IDACInfo::ExprAssign, AssignInf.LHS}; |
| } |
| |
| DiagnoseInvalidAtomic( |
| AssignInf.RHS->getExprLoc(), |
| SemaRef.PDiag(diag::note_acc_atomic_expected_binop)); |
| |
| return IDACInfo::Fail(); |
| } |
| switch (BinInf->Operator) { |
| default: |
| DiagnoseInvalidAtomic( |
| BinInf->FoundExpr->getExprLoc(), |
| SemaRef.PDiag(diag::note_acc_atomic_unsupported_binary_operator)); |
| return IDACInfo::Fail(); |
| // binop is one of +, *, -, /, &, ^, |, <<, or >> |
| case BO_Add: |
| case BO_Mul: |
| case BO_Sub: |
| case BO_Div: |
| case BO_And: |
| case BO_Xor: |
| case BO_Or: |
| case BO_Shl: |
| case BO_Shr: |
| // Handle these outside of the switch. |
| break; |
| } |
| |
| llvm::FoldingSetNodeID LHS_ID, InnerLHS_ID, InnerRHS_ID; |
| AssignInf.LHS->Profile(LHS_ID, SemaRef.getASTContext(), |
| /*Canonical=*/true); |
| BinInf->LHS->Profile(InnerLHS_ID, SemaRef.getASTContext(), |
| /*Canonical=*/true); |
| |
| // This is X = X binop expr; |
| // Check the RHS is an expression. |
| if (LHS_ID == InnerLHS_ID) |
| return IDACInfo{ |
| CheckOperandExpr( |
| BinInf->RHS, |
| SemaRef.PDiag(diag::note_acc_atomic_operand_lvalue_scalar |
| << /*right=*/1 |
| << diag::OACCAtomicOpKind::CompoundAssign)), |
| IDACInfo::AssignBinOp, AssignInf.LHS}; |
| |
| BinInf->RHS->Profile(InnerRHS_ID, SemaRef.getASTContext(), |
| /*Canonical=*/true); |
| // This is X = expr binop X; |
| // Check the LHS is an expression |
| if (LHS_ID == InnerRHS_ID) |
| return IDACInfo{ |
| CheckOperandExpr( |
| BinInf->LHS, |
| SemaRef.PDiag(diag::note_acc_atomic_operand_lvalue_scalar) |
| << /*left=*/0 << diag::OACCAtomicOpKind::CompoundAssign), |
| IDACInfo::AssignBinOp, AssignInf.LHS}; |
| |
| // If nothing matches, error out. |
| DiagnoseInvalidAtomic(BinInf->FoundExpr->getExprLoc(), |
| SemaRef.PDiag(diag::note_acc_atomic_mismatch_operand) |
| << const_cast<Expr *>(AssignInf.LHS) |
| << const_cast<Expr *>(BinInf->LHS) |
| << const_cast<Expr *>(BinInf->RHS)); |
| return IDACInfo::Fail(); |
| } |
| |
| // Ensures that the expression is an increment/decrement, an assignment, or a |
| // compound assignment. If its an assignment, allows the x binop expr/x binop |
| // expr syntax. If it is a compound-assignment, allows any expr on the RHS. |
| IDACInfo CheckIncDecAssignCompoundAssign(const Expr *E, |
| SimpleAssignKind SAK) { |
| std::optional<UnaryOpInfo> UInf = GetUnaryOperatorInfo(E); |
| |
| // If this is a unary operator, only increment/decrement are allowed, so get |
| // unary operator, then check everything we can. |
| if (UInf) |
| return CheckIncDec(*UInf); |
| |
| std::optional<BinaryOpInfo> BinInf = GetBinaryOperatorInfo(E); |
| |
| // Unary or binary operator were the only choices, so error here. |
| if (!BinInf) { |
| DiagnoseInvalidAtomic(E->getExprLoc(), |
| SemaRef.PDiag(diag::note_acc_atomic_expr_must_be) |
| << diag::OACCAtomicExpr::UnaryCompAssign); |
| return IDACInfo::Fail(); |
| } |
| |
| switch (BinInf->Operator) { |
| default: |
| DiagnoseInvalidAtomic( |
| BinInf->FoundExpr->getExprLoc(), |
| SemaRef.PDiag( |
| diag::note_acc_atomic_unsupported_compound_binary_operator)); |
| return IDACInfo::Fail(); |
| case BO_Assign: |
| return CheckAssignmentWithBinOpOnRHS(*BinInf, SAK); |
| case BO_AddAssign: |
| case BO_MulAssign: |
| case BO_SubAssign: |
| case BO_DivAssign: |
| case BO_AndAssign: |
| case BO_XorAssign: |
| case BO_OrAssign: |
| case BO_ShlAssign: |
| case BO_ShrAssign: { |
| PartialDiagnostic LPD = |
| SemaRef.PDiag(diag::note_acc_atomic_operand_lvalue_scalar) |
| << /*left=*/0 << diag::OACCAtomicOpKind::CompoundAssign; |
| PartialDiagnostic RPD = |
| SemaRef.PDiag(diag::note_acc_atomic_operand_lvalue_scalar) |
| << /*right=*/1 << diag::OACCAtomicOpKind::CompoundAssign; |
| // nothing to do other than check the variable expressions. |
| // success or failure |
| bool Failed = CheckOperandVariable(BinInf->LHS, LPD) || |
| CheckOperandExpr(BinInf->RHS, RPD); |
| |
| return IDACInfo{Failed, IDACInfo::CompoundAssign, BinInf->LHS}; |
| } |
| } |
| llvm_unreachable("all binary operator kinds should be checked above"); |
| } |
| |
| StmtResult CheckRead() { |
| Expr *AssocExpr = RequireExpr( |
| AssocStmt.get(), SemaRef.PDiag(diag::note_acc_atomic_expr_must_be) |
| << diag::OACCAtomicExpr::Assign); |
| |
| if (!AssocExpr) |
| return getRecoveryExpr(); |
| |
| std::optional<BinaryOpInfo> AssignRes = CheckAssignment(AssocExpr); |
| if (!AssignRes) |
| return getRecoveryExpr(); |
| |
| PartialDiagnostic PD = |
| SemaRef.PDiag(diag::note_acc_atomic_operand_lvalue_scalar) |
| << /*right=*/1 << diag::OACCAtomicOpKind::Assign; |
| |
| // Finally, check the RHS. |
| if (CheckOperandVariable(AssignRes->RHS, PD)) |
| return getRecoveryExpr(); |
| |
| return AssocStmt; |
| } |
| |
| StmtResult CheckWrite() { |
| Expr *AssocExpr = RequireExpr( |
| AssocStmt.get(), SemaRef.PDiag(diag::note_acc_atomic_expr_must_be) |
| << diag::OACCAtomicExpr::Assign); |
| |
| if (!AssocExpr) |
| return getRecoveryExpr(); |
| |
| std::optional<BinaryOpInfo> AssignRes = CheckAssignment(AssocExpr); |
| if (!AssignRes) |
| return getRecoveryExpr(); |
| |
| PartialDiagnostic PD = |
| SemaRef.PDiag(diag::note_acc_atomic_operand_lvalue_scalar) |
| << /*right=*/1 << diag::OACCAtomicOpKind::Assign; |
| |
| // Finally, check the RHS. |
| if (CheckOperandExpr(AssignRes->RHS, PD)) |
| return getRecoveryExpr(); |
| |
| return AssocStmt; |
| } |
| |
| StmtResult CheckUpdate() { |
| Expr *AssocExpr = RequireExpr( |
| AssocStmt.get(), SemaRef.PDiag(diag::note_acc_atomic_expr_must_be) |
| << diag::OACCAtomicExpr::UnaryCompAssign); |
| |
| if (!AssocExpr || |
| CheckIncDecAssignCompoundAssign(AssocExpr, SimpleAssignKind::None) |
| .Failed) |
| return getRecoveryExpr(); |
| |
| return AssocStmt; |
| } |
| |
| bool CheckVarRefsSame(IDACInfo::ExprKindTy FirstKind, const Expr *FirstX, |
| IDACInfo::ExprKindTy SecondKind, const Expr *SecondX) { |
| llvm::FoldingSetNodeID First_ID, Second_ID; |
| FirstX->Profile(First_ID, SemaRef.getASTContext(), /*Canonical=*/true); |
| SecondX->Profile(Second_ID, SemaRef.getASTContext(), /*Canonical=*/true); |
| |
| if (First_ID == Second_ID) |
| return false; |
| |
| PartialDiagnostic PD = |
| SemaRef.PDiag(diag::note_acc_atomic_mismatch_compound_operand) |
| << FirstKind << const_cast<Expr *>(FirstX) << SecondKind |
| << const_cast<Expr *>(SecondX); |
| |
| return DiagnoseInvalidAtomic(SecondX->getExprLoc(), PD); |
| } |
| |
| StmtResult CheckCapture() { |
| if (const auto *CmpdStmt = dyn_cast<CompoundStmt>(AssocStmt.get())) { |
| auto *const *BodyItr = CmpdStmt->body().begin(); |
| PartialDiagnostic PD = SemaRef.PDiag(diag::note_acc_atomic_expr_must_be) |
| << diag::OACCAtomicExpr::UnaryCompAssign; |
| // If we don't have at least 1 statement, error. |
| if (BodyItr == CmpdStmt->body().end()) { |
| DiagnoseInvalidAtomic(CmpdStmt->getBeginLoc(), PD); |
| return getRecoveryExpr(); |
| } |
| |
| // First Expr can be inc/dec, assign, or compound assign. |
| Expr *FirstExpr = RequireExpr(*BodyItr, PD); |
| if (!FirstExpr) |
| return getRecoveryExpr(); |
| |
| IDACInfo FirstExprResults = |
| CheckIncDecAssignCompoundAssign(FirstExpr, SimpleAssignKind::Var); |
| if (FirstExprResults.Failed) |
| return getRecoveryExpr(); |
| |
| ++BodyItr; |
| |
| // If we don't have second statement, error. |
| if (BodyItr == CmpdStmt->body().end()) { |
| DiagnoseInvalidAtomic(CmpdStmt->getEndLoc(), PD); |
| return getRecoveryExpr(); |
| } |
| |
| Expr *SecondExpr = RequireExpr(*BodyItr, PD); |
| if (!SecondExpr) |
| return getRecoveryExpr(); |
| |
| assert(FirstExprResults.ExprKind != IDACInfo::Invalid); |
| |
| switch (FirstExprResults.ExprKind) { |
| case IDACInfo::Invalid: |
| case IDACInfo::ExprAssign: |
| llvm_unreachable("Should have error'ed out by now"); |
| case IDACInfo::Unary: |
| case IDACInfo::CompoundAssign: |
| case IDACInfo::AssignBinOp: { |
| // Everything but simple-assign can only be followed by a simple |
| // assignment. |
| std::optional<BinaryOpInfo> AssignRes = CheckAssignment(SecondExpr); |
| if (!AssignRes) |
| return getRecoveryExpr(); |
| |
| PartialDiagnostic PD = |
| SemaRef.PDiag(diag::note_acc_atomic_operand_lvalue_scalar) |
| << /*right=*/1 << diag::OACCAtomicOpKind::Assign; |
| |
| if (CheckOperandVariable(AssignRes->RHS, PD)) |
| return getRecoveryExpr(); |
| |
| if (CheckVarRefsSame(FirstExprResults.ExprKind, FirstExprResults.X_Var, |
| IDACInfo::SimpleAssign, AssignRes->RHS)) |
| return getRecoveryExpr(); |
| break; |
| } |
| case IDACInfo::SimpleAssign: { |
| // If the first was v = x, anything but simple expression is allowed. |
| IDACInfo SecondExprResults = |
| CheckIncDecAssignCompoundAssign(SecondExpr, SimpleAssignKind::Expr); |
| if (SecondExprResults.Failed) |
| return getRecoveryExpr(); |
| |
| if (CheckVarRefsSame(FirstExprResults.ExprKind, FirstExprResults.X_Var, |
| SecondExprResults.ExprKind, |
| SecondExprResults.X_Var)) |
| return getRecoveryExpr(); |
| break; |
| } |
| } |
| ++BodyItr; |
| if (BodyItr != CmpdStmt->body().end()) { |
| DiagnoseInvalidAtomic( |
| (*BodyItr)->getBeginLoc(), |
| SemaRef.PDiag(diag::note_acc_atomic_too_many_stmts)); |
| return getRecoveryExpr(); |
| } |
| } else { |
| // This check doesn't need to happen if it is a compound stmt. |
| Expr *AssocExpr = RequireExpr( |
| AssocStmt.get(), SemaRef.PDiag(diag::note_acc_atomic_expr_must_be) |
| << diag::OACCAtomicExpr::Assign); |
| if (!AssocExpr) |
| return getRecoveryExpr(); |
| |
| // First, we require an assignment. |
| std::optional<BinaryOpInfo> AssignRes = CheckAssignment(AssocExpr); |
| |
| if (!AssignRes) |
| return getRecoveryExpr(); |
| |
| if (CheckIncDecAssignCompoundAssign(AssignRes->RHS, |
| SimpleAssignKind::None) |
| .Failed) |
| return getRecoveryExpr(); |
| } |
| |
| return AssocStmt; |
| } |
| |
| public: |
| AtomicOperandChecker(SemaOpenACC &S, OpenACCAtomicKind AtKind, |
| SourceLocation DirLoc, StmtResult AssocStmt) |
| : SemaRef(S), AtKind(AtKind), AtomicDirLoc(DirLoc), AssocStmt(AssocStmt) { |
| } |
| |
| StmtResult Check() { |
| |
| switch (AtKind) { |
| case OpenACCAtomicKind::Read: |
| return CheckRead(); |
| case OpenACCAtomicKind::Write: |
| return CheckWrite(); |
| case OpenACCAtomicKind::None: |
| case OpenACCAtomicKind::Update: |
| return CheckUpdate(); |
| case OpenACCAtomicKind::Capture: |
| return CheckCapture(); |
| } |
| llvm_unreachable("Unhandled atomic kind?"); |
| } |
| }; |
| } // namespace |
| |
| StmtResult SemaOpenACC::CheckAtomicAssociatedStmt(SourceLocation AtomicDirLoc, |
| OpenACCAtomicKind AtKind, |
| StmtResult AssocStmt) { |
| if (!AssocStmt.isUsable()) |
| return AssocStmt; |
| |
| if (isa<RecoveryExpr>(AssocStmt.get())) |
| return AssocStmt; |
| |
| AtomicOperandChecker Checker{*this, AtKind, AtomicDirLoc, AssocStmt}; |
| return Checker.Check(); |
| } |
