[clang][OpenMP] Initial parsing/sema for 'align' clause

[ddpagan]

Summary

[OPENMP51] Added basic parsing/sema/serialization support for 'align' clause for use with 'allocate' directive.

[ABataev]

clang/include/clang/AST/OpenMPClause.h

334

final

362–364

Also worth to make it private

377–382

IIRC, must return same as children here

[ddpagan]

Thanks for the review, Alexey.

Made the requested changes except for modifying "used_children". After looking over other clause classes, for example, OMPNumThreadsClause, we're being consistent in how we're declaring these. Let me know if I'm missing something there.

[ABataev]

LG

[aaron.ballman]

clang/include/clang/AST/OpenMPClause.h

362–364

I agree, I think these constructors should have their access reduced to at least protected.

369

I have a preference for improved const-correctness with this sort of thing, where I'd rather see an overloaded pair of functions:

const Expr *getAlignment() const { return cast_or_null<Expr>(Alignment); }
Expr *getAlignment() { return cast_or_null<Expr>(Alignment); }

clang/lib/AST/OpenMPClause.cpp

1615

getAlignment() can return nullptr and it looks like the vast majority of the calls to it are unprotected like this. Would it make sense to ensure that OMPAlignClause can never have a nonnull alignment expression?

[ddpagan]

Thanks for the review, Aaron! I neglected to submit my responses that I made inline, but you can still see them.

[ddpagan]

clang/include/clang/AST/OpenMPClause.h

362–364

Agreed. I made them private, then created a function to build the clause rather than reference the constructor directly. This is similar to what we do for some other clauses.

369

Agreed. Unfortunately, OpenMP code isn't set up well for this. A few clauses are, but not this one. So, trying to make this change led to an ugly rat's nest of other changes outside the scope of this fix. I'd like to see new clauses follow this pattern, though.

clang/lib/AST/OpenMPClause.cpp

1615

This particular code is only called when a legitimate align clause has been used, so we are guaranteed a non-nullptr. I looked over other references to getAlignment (most from other classes) and it didn't appear that any of them were unsafe.

[aaron.ballman]

LGTM aside from some possible nits.

clang/lib/Serialization/ASTWriter.cpp

5018

This can potentially add a null statement to emit to the serialized form.

6224

Same for this one, maybe?

[ddpagan]

Thanks for reviewing the code, Aaron.

clang/lib/Serialization/ASTWriter.cpp

5018

The same thing can occur with A->getAllocator(). However, it's expected behavior. When these values are read in later, the allocator and alignment values are use to set the appropriate fields in the allocate directive. Null values are okay as they indicate whether or not a field has been specified (via an align or allocator clause).

6224

This is called only when an align clause has been specified, so it's guaranteed to not be null.

[aaron.ballman]

Ah, thank you for the explanations! Then this continues to LGTM. Do you need someone to commit on your behalf? If so, what name and email address would you like me to use for patch attribution in git?

[ddpagan]

Successfully rebased, built, and tested.

[aaron.ballman]

Before I land this, it looks like precommit CI is failing with what possibly is a related failure:

[9094/9117] Linking CXX executable tools/flang/unittests/Frontend/FlangFrontendTests
FAILED: tools/flang/unittests/Frontend/FlangFrontendTests
: && /usr/bin/clang++ -gmlt -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wc++98-compat-extra-semi -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wsuggest-override -Wstring-conversion -Wmisleading-indentation -fdiagnostics-color -ffunction-sections -fdata-sections -Wno-deprecated-copy -Wno-string-conversion -Wno-unused-command-line-argument -Wstring-conversion           -Wcovered-switch-default -Wno-nested-anon-types -O3 -DNDEBUG -fuse-ld=lld -Wl,--color-diagnostics    -Wl,-O3 -Wl,--gc-sections tools/flang/unittests/Frontend/CMakeFiles/FlangFrontendTests.dir/CompilerInstanceTest.cpp.o tools/flang/unittests/Frontend/CMakeFiles/FlangFrontendTests.dir/FrontendActionTest.cpp.o -o tools/flang/unittests/Frontend/FlangFrontendTests  lib/libLLVMSupport.a  -lpthread  lib/libgtest_main.a  lib/libgtest.a  -lpthread  lib/libclangBasic.a  lib/libflangFrontend.a  lib/libflangFrontendTool.a  lib/libFortranParser.a  lib/libFortranSemantics.a  lib/libFortranCommon.a  lib/libFortranEvaluate.a  -lpthread  lib/libflangFrontend.a  lib/libFortranLower.a  lib/libFortranSemantics.a  lib/libFortranEvaluate.a  lib/libFortranParser.a  lib/libFortranCommon.a  lib/libFortranDecimal.a  lib/libFIRTransforms.a  lib/libFIRDialect.a  lib/libMLIROpenMPToLLVM.a  lib/libMLIRMemRefToLLVM.a  lib/libFIRSupport.a  lib/libMLIROpenMPToLLVMIRTranslation.a  lib/libMLIRAffineTransforms.a  lib/libMLIRAsyncTransforms.a  lib/libMLIREmitC.a  lib/libMLIRGPUTransforms.a  lib/libMLIRAsync.a  lib/libMLIRGPUOps.a  lib/libMLIRDLTI.a  lib/libMLIRLLVMToLLVMIRTranslation.a  lib/libLLVMNVPTXCodeGen.a  lib/libLLVMNVPTXDesc.a  lib/libLLVMNVPTXInfo.a  lib/libLLVMAMDGPUAsmParser.a  lib/libLLVMAMDGPUCodeGen.a  lib/libLLVMAsmPrinter.a  lib/libLLVMDebugInfoDWARF.a  lib/libLLVMDebugInfoMSF.a  lib/libLLVMPasses.a  lib/libLLVMCoroutines.a  lib/libLLVMipo.a  lib/libLLVMVectorize.a  lib/libLLVMIRReader.a  lib/libLLVMLinker.a  lib/libLLVMInstrumentation.a  lib/libLLVMObjCARCOpts.a  lib/libLLVMGlobalISel.a  lib/libLLVMSelectionDAG.a  lib/libLLVMMIRParser.a  lib/libLLVMCodeGen.a  lib/libLLVMTarget.a  lib/libLLVMAMDGPUDesc.a  lib/libLLVMAMDGPUUtils.a  lib/libLLVMAMDGPUInfo.a  lib/libMLIRNVVMIR.a  lib/libMLIRROCDLIR.a  lib/libMLIRVectorToLLVM.a  lib/libMLIRArmNeon.a  lib/libMLIRArmSVETransforms.a  lib/libMLIRArmSVE.a  lib/libMLIRAMXTransforms.a  lib/libMLIRAMX.a  lib/libMLIRTargetLLVMIRExport.a  lib/libMLIRLLVMIRTransforms.a  lib/libMLIRTranslation.a  lib/libMLIRMathTransforms.a  lib/libMLIRMemRefTransforms.a  lib/libMLIROpenACC.a  lib/libMLIROpenMP.a  lib/libMLIRShapeOpsTransforms.a  lib/libMLIRShape.a  lib/libMLIRSparseTensorTransforms.a  lib/libMLIRLinalgTransforms.a  lib/libMLIRComplex.a  lib/libMLIRLinalgAnalysis.a  lib/libMLIRComprehensiveBufferize.a  lib/libMLIRBufferizableOpInterface.a  lib/libMLIRLinalgUtils.a  lib/libMLIRSCFTransforms.a  lib/libMLIRStandardToLLVM.a  lib/libMLIRArithmeticToLLVM.a  lib/libMLIRVectorToSCF.a  lib/libMLIRSparseTensor.a  lib/libMLIRSparseTensorUtils.a  lib/libMLIRSPIRVModuleCombiner.a  lib/libMLIRSPIRVTransforms.a  lib/libMLIRSPIRVConversion.a  lib/libMLIRSPIRVUtils.a  lib/libMLIRSPIRV.a  lib/libMLIRStandardOpsTransforms.a  lib/libMLIRArithmeticTransforms.a  lib/libMLIRTensorTransforms.a  lib/libMLIRTosaTransforms.a  lib/libMLIRX86VectorTransforms.a  lib/libMLIRX86Vector.a  lib/libMLIRLLVMCommonConversion.a  lib/libMLIRLLVMIR.a  lib/libLLVMAsmParser.a  lib/libLLVMBitWriter.a  lib/libMLIRTosaTestPasses.a  lib/libMLIRTosa.a  lib/libMLIRQuant.a  lib/libMLIRAffineToStandard.a  lib/libMLIRSCFToStandard.a  lib/libMLIRTransforms.a  lib/libMLIRVector.a  lib/libMLIRAffineUtils.a  lib/libMLIRLinalg.a  lib/libMLIRMath.a  lib/libMLIRParser.a  lib/libMLIRTilingInterface.a  lib/libMLIRTransformUtils.a  lib/libMLIRLoopAnalysis.a  lib/libMLIRAffine.a  lib/libMLIRSCF.a  lib/libMLIRMemRef.a  lib/libMLIRMemRefUtils.a  lib/libMLIRTensor.a  lib/libMLIRDialectUtils.a  lib/libMLIRStandard.a  lib/libMLIRArithmetic.a  lib/libMLIRDialect.a  lib/libMLIRCastInterfaces.a  lib/libMLIRVectorInterfaces.a  lib/libMLIRLoopLikeInterface.a  lib/libMLIRPresburger.a  lib/libMLIRRewrite.a  lib/libMLIRPDLToPDLInterp.a  lib/libMLIRPDLInterp.a  lib/libMLIRPDL.a  lib/libMLIRPass.a  lib/libMLIRAnalysis.a  lib/libMLIRSideEffectInterfaces.a  lib/libMLIRDataLayoutInterfaces.a  lib/libMLIRInferTypeOpInterface.a  lib/libMLIRViewLikeInterface.a  lib/libMLIRCallInterfaces.a  lib/libMLIRControlFlowInterfaces.a  lib/libMLIRCopyOpInterface.a  lib/libMLIRIR.a  lib/libMLIRSupport.a  lib/libLLVMFrontendOpenACC.a  lib/libLLVMFrontendOpenMP.a  lib/libLLVMScalarOpts.a  lib/libLLVMAggressiveInstCombine.a  lib/libLLVMInstCombine.a  lib/libLLVMTransformUtils.a  lib/libLLVMAnalysis.a  lib/libLLVMObject.a  lib/libLLVMMCParser.a  lib/libLLVMBitReader.a  lib/libLLVMTextAPI.a  lib/libclangDriver.a  lib/libclangBasic.a  lib/libLLVMMC.a  lib/libLLVMDebugInfoCodeView.a  lib/libLLVMProfileData.a  lib/libLLVMCore.a  lib/libLLVMBinaryFormat.a  lib/libLLVMRemarks.a  lib/libLLVMBitstreamReader.a  lib/libLLVMOption.a  lib/libLLVMSupport.a  -lrt  -ldl  -lpthread  -lm  /usr/lib/x86_64-linux-gnu/libz.so  /usr/lib/x86_64-linux-gnu/libtinfo.so  lib/libLLVMDemangle.a && :
ld.lld: error: undefined symbol: Fortran::semantics::OmpStructureChecker::Enter(Fortran::parser::OmpClause::Align const&)
>>> referenced by semantics.cpp:83 (/var/lib/buildkite-agent/builds/llvm-project/flang/lib/Semantics/semantics.cpp:83)
>>>               semantics.cpp.o:(std::__detail::__variant::__gen_vtable_impl<std::__detail::__variant::_Multi_array<std::__detail::__variant::__deduce_visit_result<void> (*)(void Fortran::parser::Walk<Fortran::semantics::SemanticsVisitor<Fortran::semantics::AccStructureChecker, Fortran::semantics::AllocateChecker, Fortran::semantics::ArithmeticIfStmtChecker, Fortran::semantics::AssignmentChecker, Fortran::semantics::CaseChecker, Fortran::semantics::CoarrayChecker, Fortran::semantics::DataChecker, Fortran::semantics::DeallocateChecker, Fortran::semantics::DoForallChecker, Fortran::semantics::IfStmtChecker, Fortran::semantics::IoChecker, Fortran::semantics::MiscChecker, Fortran::semantics::NamelistChecker, Fortran::semantics::NullifyChecker, Fortran::semantics::OmpStructureChecker, Fortran::semantics::PurityChecker, Fortran::semantics::ReturnStmtChecker, Fortran::semantics::SelectRankConstructChecker, Fortran::semantics::SelectTypeChecker, Fortran::semantics::StopChecker>, Fortran::parser::OmpClause::AcqRel, Fortran::parser::OmpClause::Acquire, Fortran::parser::OmpClause::AdjustArgs, Fortran::parser::OmpClause::Affinity, Fortran::parser::OmpClause::Align, Fortran::parser::OmpClause::Aligned, Fortran::parser::OmpClause::Allocate, Fortran::parser::OmpClause::Allocator, Fortran::parser::OmpClause::AppendArgs, Fortran::parser::OmpClause::AtomicDefaultMemOrder, Fortran::parser::OmpClause::Bind, Fortran::parser::OmpClause::Capture, Fortran::parser::OmpClause::Collapse, Fortran::parser::OmpClause::Copyprivate, Fortran::parser::OmpClause::Copyin, Fortran::parser::OmpClause::Default, Fortran::parser::OmpClause::Defaultmap, Fortran::parser::OmpClause::Depend, Fortran::parser::OmpClause::Depobj, Fortran::parser::OmpClause::Destroy, Fortran::parser::OmpClause::Detach, Fortran::parser::OmpClause::Device, Fortran::parser::OmpClause::DeviceType, Fortran::parser::OmpClause::DistSchedule, Fortran::parser::OmpClause::DynamicAllocators, Fortran::parser::OmpClause::Exclusive, Fortran::parser::OmpClause::Filter, Fortran::parser::OmpClause::Final, Fortran::parser::OmpClause::Firstprivate, Fortran::parser::OmpClause::Flush, Fortran::parser::OmpClause::From, Fortran::parser::OmpClause::Full, Fortran::parser::OmpClause::Grainsize, Fortran::parser::OmpClause::Hint, Fortran::parser::OmpClause::If, Fortran::parser::OmpClause::InReduction, Fortran::parser::OmpClause::Inbranch, Fortran::parser::OmpClause::Inclusive, Fortran::parser::OmpClause::Init, Fortran::parser::OmpClause::IsDevicePtr, Fortran::parser::OmpClause::Lastprivate, Fortran::parser::OmpClause::Linear, Fortran::parser::OmpClause::Link, Fortran::parser::OmpClause::Map, Fortran::parser::OmpClause::Match, Fortran::parser::OmpClause::MemoryOrder, Fortran::parser::OmpClause::Mergeable, Fortran::parser::OmpClause::Nogroup, Fortran::parser::OmpClause::Nowait, Fortran::parser::OmpClause::Nocontext, Fortran::parser::OmpClause::Nontemporal, Fortran::parser::OmpClause::Notinbranch, Fortran::parser::OmpClause::Novariants, Fortran::parser::OmpClause::NumTasks, Fortran::parser::OmpClause::NumTeams, Fortran::parser::OmpClause::NumThreads, Fortran::parser::OmpClause::Order, Fortran::parser::OmpClause::Ordered, Fortran::parser::OmpClause::Partial, Fortran::parser::OmpClause::Priority, Fortran::parser::OmpClause::Private, Fortran::parser::OmpClause::ProcBind, Fortran::parser::OmpClause::Read, Fortran::parser::OmpClause::Reduction, Fortran::parser::OmpClause::Relaxed, Fortran::parser::OmpClause::Release, Fortran::parser::OmpClause::ReverseOffload, Fortran::parser::OmpClause::Safelen, Fortran::parser::OmpClause::Schedule, Fortran::parser::OmpClause::SeqCst, Fortran::parser::OmpClause::Shared, Fortran::parser::OmpClause::Simd, Fortran::parser::OmpClause::Simdlen, Fortran::parser::OmpClause::Sizes, Fortran::parser::OmpClause::TaskReduction, Fortran::parser::OmpClause::ThreadLimit, Fortran::parser::OmpClause::Threadprivate, Fortran::parser::OmpClause::Threads, Fortran::parser::OmpClause::To, Fortran::parser::OmpClause::UnifiedAddress, Fortran::parser::OmpClause::UnifiedSharedMemory, Fortran::parser::OmpClause::Uniform, Fortran::parser::OmpClause::Unknown, Fortran::parser::OmpClause::Untied, Fortran::parser::OmpClause::Update, Fortran::parser::OmpClause::Use, Fortran::parser::OmpClause::UseDeviceAddr, Fortran::parser::OmpClause::UseDevicePtr, Fortran::parser::OmpClause::UsesAllocators, Fortran::parser::OmpClause::When, Fortran::parser::OmpClause::Write>(std::variant<Fortran::parser::OmpClause::AcqRel, Fortran::parser::OmpClause::Acquire, Fortran::parser::OmpClause::AdjustArgs, Fortran::parser::OmpClause::Affinity, Fortran::parser::OmpClause::Align, Fortran::parser::OmpClause::Aligned, Fortran::parser::OmpClause::Allocate, Fortran::parser::OmpClause::Allocator, Fortran::parser::OmpClause::AppendArgs, Fortran::parser::OmpClause::AtomicDefaultMemOrder, Fortran::parser::OmpClause::Bind, Fortran::parser::OmpClause::Capture, Fortran::parser::OmpClause::Collapse, Fortran::parser::OmpClause::Copyprivate, Fortran::parser::OmpClause::Copyin, Fortran::parser::OmpClause::Default, Fortran::parser::OmpClause::Defaultmap, Fortran::parser::OmpClause::Depend, Fortran::parser::OmpClause::Depobj, Fortran::parser::OmpClause::Destroy, Fortran::parser::OmpClause::Detach, Fortran::parser::OmpClause::Device, Fortran::parser::OmpClause::DeviceType, Fortran::parser::OmpClause::DistSchedule, Fortran::parser::OmpClause::DynamicAllocators, Fortran::parser::OmpClause::Exclusive, Fortran::parser::OmpClause::Filter, Fortran::parser::OmpClause::Final, Fortran::parser::OmpClause::Firstprivate, Fortran::parser::OmpClause::Flush, Fortran::parser::OmpClause::From, Fortran::parser::OmpClause::Full, Fortran::parser::OmpClause::Grainsize, Fortran::parser::OmpClause::Hint, Fortran::parser::OmpClause::If, Fortran::parser::OmpClause::InReduction, Fortran::parser::OmpClause::Inbranch, Fortran::parser::OmpClause::Inclusive, Fortran::parser::OmpClause::Init, Fortran::parser::OmpClause::IsDevicePtr, Fortran::parser::OmpClause::Lastprivate, Fortran::parser::OmpClause::Linear, Fortran::parser::OmpClause::Link, Fortran::parser::OmpClause::Map, Fortran::parser::OmpClause::Match, Fortran::parser::OmpClause::MemoryOrder, Fortran::parser::OmpClause::Mergeable, Fortran::parser::OmpClause::Nogroup, Fortran::parser::OmpClause::Nowait, Fortran::parser::OmpClause::Nocontext, Fortran::parser::OmpClause::Nontemporal, Fortran::parser::OmpClause::Notinbranch, Fortran::parser::OmpClause::Novariants, Fortran::parser::OmpClause::NumTasks, Fortran::parser::OmpClause::NumTeams, Fortran::parser::OmpClause::NumThreads, Fortran::parser::OmpClause::Order, Fortran::parser::OmpClause::Ordered, Fortran::parser::OmpClause::Partial, Fortran::parser::OmpClause::Priority, Fortran::parser::OmpClause::Private, Fortran::parser::OmpClause::ProcBind, Fortran::parser::OmpClause::Read, Fortran::parser::OmpClause::Reduction, Fortran::parser::OmpClause::Relaxed, Fortran::parser::OmpClause::Release, Fortran::parser::OmpClause::ReverseOffload, Fortran::parser::OmpClause::Safelen, Fortran::parser::OmpClause::Schedule, Fortran::parser::OmpClause::SeqCst, Fortran::parser::OmpClause::Shared, Fortran::parser::OmpClause::Simd, Fortran::parser::OmpClause::Simdlen, Fortran::parser::OmpClause::Sizes, Fortran::parser::OmpClause::TaskReduction, Fortran::parser::OmpClause::ThreadLimit, Fortran::parser::OmpClause::Threadprivate, Fortran::parser::OmpClause::Threads, Fortran::parser::OmpClause::To, Fortran::parser::OmpClause::UnifiedAddress, Fortran::parser::OmpClause::UnifiedSharedMemory, Fortran::parser::OmpClause::Uniform, Fortran::parser::OmpClause::Unknown, Fortran::parser::OmpClause::Untied, Fortran::parser::OmpClause::Update, Fortran::parser::OmpClause::Use, Fortran::parser::OmpClause::UseDeviceAddr, Fortran::parser::OmpClause::UseDevicePtr, Fortran::parser::OmpClause::UsesAllocators, Fortran::parser::OmpClause::When, Fortran::parser::OmpClause::Write> const&, Fortran::semantics::SemanticsVisitor<Fortran::semantics::AccStructureChecker, Fortran::semantics::AllocateChecker, Fortran::semantics::ArithmeticIfStmtChecker, Fortran::semantics::AssignmentChecker, Fortran::semantics::CaseChecker, Fortran::semantics::CoarrayChecker, Fortran::semantics::DataChecker, Fortran::semantics::DeallocateChecker, Fortran::semantics::DoForallChecker, Fortran::semantics::IfStmtChecker, Fortran::semantics::IoChecker, Fortran::semantics::MiscChecker, Fortran::semantics::NamelistChecker, Fortran::semantics::NullifyChecker, Fortran::semantics::OmpStructureChecker, Fortran::semantics::PurityChecker, Fortran::semantics::ReturnStmtChecker, Fortran::semantics::SelectRankConstructChecker, Fortran::semantics::SelectTypeChecker, Fortran::semantics::StopChecker>&)::'lambda'(Fortran::semantics::SemanticsVisitor<Fortran::semantics::AccStructureChecker, Fortran::semantics::AllocateChecker, Fortran::semantics::ArithmeticIfStmtChecker, Fortran::semantics::AssignmentChecker, Fortran::semantics::CaseChecker, Fortran::semantics::CoarrayChecker, Fortran::semantics::DataChecker, Fortran::semantics::DeallocateChecker, Fortran::semantics::DoForallChecker, Fortran::semantics::IfStmtChecker, Fortran::semantics::IoChecker, Fortran::semantics::MiscChecker, Fortran::semantics::NamelistChecker, Fortran::semantics::NullifyChecker, Fortran::semantics::OmpStructureChecker, Fortran::semantics::PurityChecker, Fortran::semantics::ReturnStmtChecker, Fortran::semantics::SelectRankConstructChecker, Fortran::semantics::SelectTypeChecker, Fortran::semantics::StopChecker> const&)&&, std::variant<Fortran::parser::OmpClause::AcqRel, Fortran::parser::OmpClause::Acquire, Fortran::parser::OmpClause::AdjustArgs, Fortran::parser::OmpClause::Affinity, Fortran::parser::OmpClause::Align, Fortran::parser::OmpClause::Aligned, Fortran::parser::OmpClause::Allocate, Fortran::parser::OmpClause::Allocator, Fortran::parser::OmpClause::AppendArgs, Fortran::parser::OmpClause::AtomicDefaultMemOrder, Fortran::parser::OmpClause::Bind, Fortran::parser::OmpClause::Capture, Fortran::parser::OmpClause::Collapse, Fortran::parser::OmpClause::Copyprivate, Fortran::parser::OmpClause::Copyin, Fortran::parser::OmpClause::Default, Fortran::parser::OmpClause::Defaultmap, Fortran::parser::OmpClause::Depend, Fortran::parser::OmpClause::Depobj, Fortran::parser::OmpClause::Destroy, Fortran::parser::OmpClause::Detach, Fortran::parser::OmpClause::Device, Fortran::parser::OmpClause::DeviceType, Fortran::parser::OmpClause::DistSchedule, Fortran::parser::OmpClause::DynamicAllocators, Fortran::parser::OmpClause::Exclusive, Fortran::parser::OmpClause::Filter, Fortran::parser::OmpClause::Final, Fortran::parser::OmpClause::Firstprivate, Fortran::parser::OmpClause::Flush, Fortran::parser::OmpClause::From, Fortran::parser::OmpClause::Full, Fortran::parser::OmpClause::Grainsize, Fortran::parser::OmpClause::Hint, Fortran::parser::OmpClause::If, Fortran::parser::OmpClause::InReduction, Fortran::parser::OmpClause::Inbranch, Fortran::parser::OmpClause::Inclusive, Fortran::parser::OmpClause::Init, Fortran::parser::OmpClause::IsDevicePtr, Fortran::parser::OmpClause::Lastprivate, Fortran::parser::OmpClause::Linear, Fortran::parser::OmpClause::Link, Fortran::parser::OmpClause::Map, Fortran::parser::OmpClause::Match, Fortran::parser::OmpClause::MemoryOrder, Fortran::parser::OmpClause::Mergeable, Fortran::parser::OmpClause::Nogroup, Fortran::parser::OmpClause::Nowait, Fortran::parser::OmpClause::Nocontext, Fortran::parser::OmpClause::Nontemporal, Fortran::parser::OmpClause::Notinbranch, Fortran::parser::OmpClause::Novariants, Fortran::parser::OmpClause::NumTasks, Fortran::parser::OmpClause::NumTeams, Fortran::parser::OmpClause::NumThreads, Fortran::parser::OmpClause::Order, Fortran::parser::OmpClause::Ordered, Fortran::parser::OmpClause::Partial, Fortran::parser::OmpClause::Priority, Fortran::parser::OmpClause::Private, Fortran::parser::OmpClause::ProcBind, Fortran::parser::OmpClause::Read, Fortran::parser::OmpClause::Reduction, Fortran::parser::OmpClause::Relaxed, Fortran::parser::OmpClause::Release, Fortran::parser::OmpClause::ReverseOffload, Fortran::parser::OmpClause::Safelen, Fortran::parser::OmpClause::Schedule, Fortran::parser::OmpClause::SeqCst, Fortran::parser::OmpClause::Shared, Fortran::parser::OmpClause::Simd, Fortran::parser::OmpClause::Simdlen, Fortran::parser::OmpClause::Sizes, Fortran::parser::OmpClause::TaskReduction, Fortran::parser::OmpClause::ThreadLimit, Fortran::parser::OmpClause::Threadprivate, Fortran::parser::OmpClause::Threads, Fortran::parser::OmpClause::To, Fortran::parser::OmpClause::UnifiedAddress, Fortran::parser::OmpClause::UnifiedSharedMemory, Fortran::parser::OmpClause::Uniform, Fortran::parser::OmpClause::Unknown, Fortran::parser::OmpClause::Untied, Fortran::parser::OmpClause::Update, Fortran::parser::OmpClause::Use, Fortran::parser::OmpClause::UseDeviceAddr, Fortran::parser::OmpClause::UseDevicePtr, Fortran::parser::OmpClause::UsesAllocators, Fortran::parser::OmpClause::When, Fortran::parser::OmpClause::Write> const&)>, std::integer_sequence<unsigned long, 4ul> >::__visit_invoke(void Fortran::parser::Walk<Fortran::semantics::SemanticsVisitor<Fortran::semantics::AccStructureChecker, Fortran::semantics::AllocateChecker, Fortran::semantics::ArithmeticIfStmtChecker, Fortran::semantics::AssignmentChecker, Fortran::semantics::CaseChecker, Fortran::semantics::CoarrayChecker, Fortran::semantics::DataChecker, Fortran::semantics::DeallocateChecker, Fortran::semantics::DoForallChecker, Fortran::semantics::IfStmtChecker, Fortran::semantics::IoChecker, Fortran::semantics::MiscChecker, Fortran::semantics::NamelistChecker, Fortran::semantics::NullifyChecker, Fortran::semantics::OmpStructureChecker, Fortran::semantics::PurityChecker, Fortran::semantics::ReturnStmtChecker, Fortran::semantics::SelectRankConstructChecker, Fortran::semantics::SelectTypeChecker, Fortran::semantics::StopChecker>, Fortran::parser::OmpClause::AcqRel, Fortran::parser::OmpClause::Acquire, Fortran::parser::OmpClause::AdjustArgs, Fortran::parser::OmpClause::Affinity, Fortran::parser::OmpClause::Align, Fortran::parser::OmpClause::Aligned, Fortran::parser::OmpClause::Allocate, Fortran::parser::OmpClause::Allocator, Fortran::parser::OmpClause::AppendArgs, Fortran::parser::OmpClause::AtomicDefaultMemOrder, Fortran::parser::OmpClause::Bind, Fortran::parser::OmpClause::Capture, Fortran::parser::OmpClause::Collapse, Fortran::parser::OmpClause::Copyprivate, Fortran::parser::OmpClause::Copyin, Fortran::parser::OmpClause::Default, Fortran::parser::OmpClause::Defaultmap, Fortran::parser::OmpClause::Depend, Fortran::parser::OmpClause::Depobj, Fortran::parser::OmpClause::Destroy, Fortran::parser::OmpClause::Detach, Fortran::parser::OmpClause::Device, Fortran::parser::OmpClause::DeviceType, Fortran::parser::OmpClause::DistSchedule, Fortran::parser::OmpClause::DynamicAllocators, Fortran::parser::OmpClause::Exclusive, Fortran::parser::OmpClause::Filter, Fortran::parser::OmpClause::Final, Fortran::parser::OmpClause::Firstprivate, Fortran::parser::OmpClause::Flush, Fortran::parser::OmpClause::From, Fortran::parser::OmpClause::Full, Fortran::parser::OmpClause::Grainsize, Fortran::parser::OmpClause::Hint, Fortran::parser::OmpClause::If, Fortran::parser::OmpClause::InReduction, Fortran::parser::OmpClause::Inbranch, Fortran::parser::OmpClause::Inclusive, Fortran::parser::OmpClause::Init, Fortran::parser::OmpClause::IsDevicePtr, Fortran::parser::OmpClause::Lastprivate, Fortran::parser::OmpClause::Linear, Fortran::parser::OmpClause::Link, Fortran::parser::OmpClause::Map, Fortran::parser::OmpClause::Match, Fortran::parser::OmpClause::MemoryOrder, Fortran::parser::OmpClause::Mergeable, Fortran::parser::OmpClause::Nogroup, Fortran::parser::OmpClause::Nowait, Fortran::parser::OmpClause::Nocontext, Fortran::parser::OmpClause::Nontemporal, Fortran::parser::OmpClause::Notinbranch, Fortran::parser::OmpClause::Novariants, Fortran::parser::OmpClause::NumTasks, Fortran::parser::OmpClause::NumTeams, Fortran::parser::OmpClause::NumThreads, Fortran::parser::OmpClause::Order, Fortran::parser::OmpClause::Ordered, Fortran::parser::OmpClause::Partial, Fortran::parser::OmpClause::Priority, Fortran::parser::OmpClause::Private, Fortran::parser::OmpClause::ProcBind, Fortran::parser::OmpClause::Read, Fortran::parser::OmpClause::Reduction, Fortran::parser::OmpClause::Relaxed, Fortran::parser::OmpClause::Release, Fortran::parser::OmpClause::ReverseOffload, Fortran::parser::OmpClause::Safelen, Fortran::parser::OmpClause::Schedule, Fortran::parser::OmpClause::SeqCst, Fortran::parser::OmpClause::Shared, Fortran::parser::OmpClause::Simd, Fortran::parser::OmpClause::Simdlen, Fortran::parser::OmpClause::Sizes, Fortran::parser::OmpClause::TaskReduction, Fortran::parser::OmpClause::ThreadLimit, Fortran::parser::OmpClause::Threadprivate, Fortran::parser::OmpClause::Threads, Fortran::parser::OmpClause::To, Fortran::parser::OmpClause::UnifiedAddress, Fortran::parser::OmpClause::UnifiedSharedMemory, Fortran::parser::OmpClause::Uniform, Fortran::parser::OmpClause::Unknown, Fortran::parser::OmpClause::Untied, Fortran::parser::OmpClause::Update, Fortran::parser::OmpClause::Use, Fortran::parser::OmpClause::UseDeviceAddr, Fortran::parser::OmpClause::UseDevicePtr, Fortran::parser::OmpClause::UsesAllocators, Fortran::parser::OmpClause::When, Fortran::parser::OmpClause::Write>(std::variant<Fortran::parser::OmpClause::AcqRel, Fortran::parser::OmpClause::Acquire, Fortran::parser::OmpClause::AdjustArgs, Fortran::parser::OmpClause::Affinity, Fortran::parser::OmpClause::Align, Fortran::parser::OmpClause::Aligned, Fortran::parser::OmpClause::Allocate, Fortran::parser::OmpClause::Allocator, Fortran::parser::OmpClause::AppendArgs, Fortran::parser::OmpClause::AtomicDefaultMemOrder, Fortran::parser::OmpClause::Bind, Fortran::parser::OmpClause::Capture, Fortran::parser::OmpClause::Collapse, Fortran::parser::OmpClause::Copyprivate, Fortran::parser::OmpClause::Copyin, Fortran::parser::OmpClause::Default, Fortran::parser::OmpClause::Defaultmap, Fortran::parser::OmpClause::Depend, Fortran::parser::OmpClause::Depobj, Fortran::parser::OmpClause::Destroy, Fortran::parser::OmpClause::Detach, Fortran::parser::OmpClause::Device, Fortran::parser::OmpClause::DeviceType, Fortran::parser::OmpClause::DistSchedule, Fortran::parser::OmpClause::DynamicAllocators, Fortran::parser::OmpClause::Exclusive, Fortran::parser::OmpClause::Filter, Fortran::parser::OmpClause::Final, Fortran::parser::OmpClause::Firstprivate, Fortran::parser::OmpClause::Flush, Fortran::parser::OmpClause::From, Fortran::parser::OmpClause::Full, Fortran::parser::OmpClause::Grainsize, Fortran::parser::OmpClause::Hint, Fortran::parser::OmpClause::If, Fortran::parser::OmpClause::InReduction, Fortran::parser::OmpClause::Inbranch, Fortran::parser::OmpClause::Inclusive, Fortran::parser::OmpClause::Init, Fortran::parser::OmpClause::IsDevicePtr, Fortran::parser::OmpClause::Lastprivate, Fortran::parser::OmpClause::Linear, Fortran::parser::OmpClause::Link, Fortran::parser::OmpClause::Map, Fortran::parser::OmpClause::Match, Fortran::parser::OmpClause::MemoryOrder, Fortran::parser::OmpClause::Mergeable, Fortran::parser::OmpClause::Nogroup, Fortran::parser::OmpClause::Nowait, Fortran::parser::OmpClause::Nocontext, Fortran::parser::OmpClause::Nontemporal, Fortran::parser::OmpClause::Notinbranch, Fortran::parser::OmpClause::Novariants, Fortran::parser::OmpClause::NumTasks, Fortran::parser::OmpClause::NumTeams, Fortran::parser::OmpClause::NumThreads, Fortran::parser::OmpClause::Order, Fortran::parser::OmpClause::Ordered, Fortran::parser::OmpClause::Partial, Fortran::parser::OmpClause::Priority, Fortran::parser::OmpClause::Private, Fortran::parser::OmpClause::ProcBind, Fortran::parser::OmpClause::Read, Fortran::parser::OmpClause::Reduction, Fortran::parser::OmpClause::Relaxed, Fortran::parser::OmpClause::Release, Fortran::parser::OmpClause::ReverseOffload, Fortran::parser::OmpClause::Safelen, Fortran::parser::OmpClause::Schedule, Fortran::parser::OmpClause::SeqCst, Fortran::parser::OmpClause::Shared, Fortran::parser::OmpClause::Simd, Fortran::parser::OmpClause::Simdlen, Fortran::parser::OmpClause::Sizes, Fortran::parser::OmpClause::TaskReduction, Fortran::parser::OmpClause::ThreadLimit, Fortran::parser::OmpClause::Threadprivate, Fortran::parser::OmpClause::Threads, Fortran::parser::OmpClause::To, Fortran::parser::OmpClause::UnifiedAddress, Fortran::parser::OmpClause::UnifiedSharedMemory, Fortran::parser::OmpClause::Uniform, Fortran::parser::OmpClause::Unknown, Fortran::parser::OmpClause::Untied, Fortran::parser::OmpClause::Update, Fortran::parser::OmpClause::Use, Fortran::parser::OmpClause::UseDeviceAddr, Fortran::parser::OmpClause::UseDevicePtr, Fortran::parser::OmpClause::UsesAllocators, Fortran::parser::OmpClause::When, Fortran::parser::OmpClause::Write> const&, Fortran::semantics::SemanticsVisitor<Fortran::semantics::AccStructureChecker, Fortran::semantics::AllocateChecker, Fortran::semantics::ArithmeticIfStmtChecker, Fortran::semantics::AssignmentChecker, Fortran::semantics::CaseChecker, Fortran::semantics::CoarrayChecker, Fortran::semantics::DataChecker, Fortran::semantics::DeallocateChecker, Fortran::semantics::DoForallChecker, Fortran::semantics::IfStmtChecker, Fortran::semantics::IoChecker, Fortran::semantics::MiscChecker, Fortran::semantics::NamelistChecker, Fortran::semantics::NullifyChecker, Fortran::semantics::OmpStructureChecker, Fortran::semantics::PurityChecker, Fortran::semantics::ReturnStmtChecker, Fortran::semantics::SelectRankConstructChecker, Fortran::semantics::SelectTypeChecker, Fortran::semantics::StopChecker>&)::'lambda'(Fortran::semantics::SemanticsVisitor<Fortran::semantics::AccStructureChecker, Fortran::semantics::AllocateChecker, Fortran::semantics::ArithmeticIfStmtChecker, Fortran::semantics::AssignmentChecker, Fortran::semantics::CaseChecker, Fortran::semantics::CoarrayChecker, Fortran::semantics::DataChecker, Fortran::semantics::DeallocateChecker, Fortran::semantics::DoForallChecker, Fortran::semantics::IfStmtChecker, Fortran::semantics::IoChecker, Fortran::semantics::MiscChecker, Fortran::semantics::NamelistChecker, Fortran::semantics::NullifyChecker, Fortran::semantics::OmpStructureChecker, Fortran::semantics::PurityChecker, Fortran::semantics::ReturnStmtChecker, Fortran::semantics::SelectRankConstructChecker, Fortran::semantics::SelectTypeChecker, Fortran::semantics::StopChecker> const&)&&, std::variant<Fortran::parser::OmpClause::AcqRel, Fortran::parser::OmpClause::Acquire, Fortran::parser::OmpClause::AdjustArgs, Fortran::parser::OmpClause::Affinity, Fortran::parser::OmpClause::Align, Fortran::parser::OmpClause::Aligned, Fortran::parser::OmpClause::Allocate, Fortran::parser::OmpClause::Allocator, Fortran::parser::OmpClause::AppendArgs, Fortran::parser::OmpClause::AtomicDefaultMemOrder, Fortran::parser::OmpClause::Bind, Fortran::parser::OmpClause::Capture, Fortran::parser::OmpClause::Collapse, Fortran::parser::OmpClause::Copyprivate, Fortran::parser::OmpClause::Copyin, Fortran::parser::OmpClause::Default, Fortran::parser::OmpClause::Defaultmap, Fortran::parser::OmpClause::Depend, Fortran::parser::OmpClause::Depobj, Fortran::parser::OmpClause::Destroy, Fortran::parser::OmpClause::Detach, Fortran::parser::OmpClause::Device, Fortran::parser::OmpClause::DeviceType, Fortran::parser::OmpClause::DistSchedule, Fortran::parser::OmpClause::DynamicAllocators, Fortran::parser::OmpClause::Exclusive, Fortran::parser::OmpClause::Filter, Fortran::parser::OmpClause::Final, Fortran::parser::OmpClause::Firstprivate, Fortran::parser::OmpClause::Flush, Fortran::parser::OmpClause::From, Fortran::parser::OmpClause::Full, Fortran::parser::OmpClause::Grainsize, Fortran::parser::OmpClause::Hint, Fortran::parser::OmpClause::If, Fortran::parser::OmpClause::InReduction, Fortran::parser::OmpClause::Inbranch, Fortran::parser::OmpClause::Inclusive, Fortran::parser::OmpClause::Init, Fortran::parser::OmpClause::IsDevicePtr, Fortran::parser::OmpClause::Lastprivate, Fortran::parser::OmpClause::Linear, Fortran::parser::OmpClause::Link, Fortran::parser::OmpClause::Map, Fortran::parser::OmpClause::Match, Fortran::parser::OmpClause::MemoryOrder, Fortran::parser::OmpClause::Mergeable, Fortran::parser::OmpClause::Nogroup, Fortran::parser::OmpClause::Nowait, Fortran::parser::OmpClause::Nocontext, Fortran::parser::OmpClause::Nontemporal, Fortran::parser::OmpClause::Notinbranch, Fortran::parser::OmpClause::Novariants, Fortran::parser::OmpClause::NumTasks, Fortran::parser::OmpClause::NumTeams, Fortran::parser::OmpClause::NumThreads, Fortran::parser::OmpClause::Order, Fortran::parser::OmpClause::Ordered, Fortran::parser::OmpClause::Partial, Fortran::parser::OmpClause::Priority, Fortran::parser::OmpClause::Private, Fortran::parser::OmpClause::ProcBind, Fortran::parser::OmpClause::Read, Fortran::parser::OmpClause::Reduction, Fortran::parser::OmpClause::Relaxed, Fortran::parser::OmpClause::Release, Fortran::parser::OmpClause::ReverseOffload, Fortran::parser::OmpClause::Safelen, Fortran::parser::OmpClause::Schedule, Fortran::parser::OmpClause::SeqCst, Fortran::parser::OmpClause::Shared, Fortran::parser::OmpClause::Simd, Fortran::parser::OmpClause::Simdlen, Fortran::parser::OmpClause::Sizes, Fortran::parser::OmpClause::TaskReduction, Fortran::parser::OmpClause::ThreadLimit, Fortran::parser::OmpClause::Threadprivate, Fortran::parser::OmpClause::Threads, Fortran::parser::OmpClause::To, Fortran::parser::OmpClause::UnifiedAddress, Fortran::parser::OmpClause::UnifiedSharedMemory, Fortran::parser::OmpClause::Uniform, Fortran::parser::OmpClause::Unknown, Fortran::parser::OmpClause::Untied, Fortran::parser::OmpClause::Update, Fortran::parser::OmpClause::Use, Fortran::parser::OmpClause::UseDeviceAddr, Fortran::parser::OmpClause::UseDevicePtr, Fortran::parser::OmpClause::UsesAllocators, Fortran::parser::OmpClause::When, Fortran::parser::OmpClause::Write> const&)) in archive lib/libFortranSemantics.a
clang: error: linker command failed with exit code 1 (use -v to see invocation)

Can you investigate to make sure this change isn't accidentally breaking flang?

[cfe-commits]

Thanks, Aaron. I'll check this out.

[ddpagan]

Fixed build problem (found during build of flang). Added align clause to simple clause check.

[aaron.ballman]

I've commit on your behalf in b0de656bdf0ee3f4e51d04ae29160dab99819e8e (clang), b0de656bdf0ee3f4e51d04ae29160dab99819e8e (llvm), and b0de656bdf0ee3f4e51d04ae29160dab99819e8e (flang). Thanks!

clang/include/clang/AST/OpenMPClause.h

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_allocator;
   }
 };
 
+/// This represents the 'align' clause in the '#pragma omp allocate'
+/// directive.
+///
+/// \code
+/// #pragma omp allocate(a) allocator(omp_default_mem_alloc) align(8)
+/// \endcode
+/// In this example directive '#pragma omp allocate' has simple 'allocator'
+/// clause with the allocator 'omp_default_mem_alloc' and align clause with
+/// value of 8.
+class OMPAlignClause : public OMPClause {
+  friend class OMPClauseReader;
+
+  /// Location of '('.
+  SourceLocation LParenLoc;
+
+  /// Alignment specified with align clause.
+  Stmt *Alignment = nullptr;
+
+  /// Set alignment value.
+  void setAlignment(Expr *A) { Alignment = A; }
+
+public:
+  /// Build 'align' clause with the given alignment
+  ///
+  /// \param A Alignment value
+  /// \param StartLoc Starting location of the clause.
+  /// \param LParenLoc Location of '('.
+  /// \param EndLoc Ending location of the clause.
+  OMPAlignClause(Expr *A, SourceLocation StartLoc, SourceLocation LParenLoc,
+                 SourceLocation EndLoc)
+      : OMPClause(llvm::omp::OMPC_align, StartLoc, EndLoc),
+        LParenLoc(LParenLoc), Alignment(A) {}
+
+  /// Build an empty clause.
+  OMPAlignClause()
+      : OMPClause(llvm::omp::OMPC_align, SourceLocation(), SourceLocation()) {}
+
+  /// Sets the location of '('.
+  void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
+
+  /// Returns the location of '('.
+  SourceLocation getLParenLoc() const { return LParenLoc; }
+
+  /// Returns alignment
+  Expr *getAlignment() const { return cast_or_null<Expr>(Alignment); }
+
+  child_range children() { return child_range(&Alignment, &Alignment + 1); }
+
+  const_child_range children() const {
+    return const_child_range(&Alignment, &Alignment + 1);
+  }
+
+  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_align;
+  }
+};
+
 /// This represents clause 'allocate' in the '#pragma omp ...' directives.
 ///
 /// \code
 /// #pragma omp parallel private(a) allocate(omp_default_mem_alloc :a)
 /// \endcode
 /// In this example directive '#pragma omp parallel' has clause 'private'
 /// and clause 'allocate' for the variable 'a'.
 class OMPAllocateClause final

clang/include/clang/AST/RecursiveASTVisitor.h

 bool
 RecursiveASTVisitor<Derived>::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
   TRY_TO(VisitOMPClauseWithPreInit(C));
   TRY_TO(TraverseStmt(C->getNumThreads()));
   return true;
 }
 
 template <typename Derived>
+bool RecursiveASTVisitor<Derived>::VisitOMPAlignClause(OMPAlignClause *C) {
+  TRY_TO(TraverseStmt(C->getAlignment()));
+  return true;
+}
+
+template <typename Derived>
 bool RecursiveASTVisitor<Derived>::VisitOMPSafelenClause(OMPSafelenClause *C) {
   TRY_TO(TraverseStmt(C->getSafelen()));
   return true;
 }
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
   TRY_TO(TraverseStmt(C->getSimdlen()));

clang/include/clang/Basic/Attr.td

EnumArgument<"AllocatorType", "AllocatorTypeTy",
                  ],
                  [
                    "OMPNullMemAlloc", "OMPDefaultMemAlloc",
                    "OMPLargeCapMemAlloc", "OMPConstMemAlloc",
                    "OMPHighBWMemAlloc", "OMPLowLatMemAlloc",
                    "OMPCGroupMemAlloc", "OMPPTeamMemAlloc", "OMPThreadMemAlloc",
                    "OMPUserDefinedMemAlloc"
                  ]>,
-    ExprArgument<"Allocator">
+    ExprArgument<"Allocator">,
+    ExprArgument<"Alignment">
   ];
   let Documentation = [Undocumented];
 }
 
 def OMPDeclareVariant : InheritableAttr {
   let Spellings = [Pragma<"omp", "declare variant">];
   let Subjects = SubjectList<[Function]>;
   let SemaHandler = 0;

clang/include/clang/Sema/Sema.h

public:
   OMPClause *ActOnOpenMPFinalClause(Expr *Condition, SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation EndLoc);
   /// Called on well-formed 'num_threads' clause.
   OMPClause *ActOnOpenMPNumThreadsClause(Expr *NumThreads,
                                          SourceLocation StartLoc,
                                          SourceLocation LParenLoc,
                                          SourceLocation EndLoc);
+  /// Called on well-formed 'align' clause.
+  OMPClause *ActOnOpenMPAlignClause(Expr *Alignment, SourceLocation StartLoc,
+                                    SourceLocation LParenLoc,
+                                    SourceLocation EndLoc);
   /// Called on well-formed 'safelen' clause.
   OMPClause *ActOnOpenMPSafelenClause(Expr *Length,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc);
   /// Called on well-formed 'simdlen' clause.
   OMPClause *ActOnOpenMPSimdlenClause(Expr *Length, SourceLocation StartLoc,
                                       SourceLocation LParenLoc,

clang/lib/AST/DeclPrinter.cpp

for (OMPAllocateDecl::varlist_iterator I = D->varlist_begin(),
          I != E; ++I) {
       Out << (I == D->varlist_begin() ? '(' : ',');
       NamedDecl *ND = cast<DeclRefExpr>(*I)->getDecl();
       ND->printQualifiedName(Out);
     }
     Out << ")";
   }
   if (!D->clauselist_empty()) {
-    Out << " ";
     OMPClausePrinter Printer(Out, Policy);
-    for (OMPClause *C : D->clauselists())
+    for (OMPClause *C : D->clauselists()) {
+      Out << " ";
       Printer.Visit(C);
     }
   }
+}
 
 void DeclPrinter::VisitOMPRequiresDecl(OMPRequiresDecl *D) {
   Out << "#pragma omp requires ";
   if (!D->clauselist_empty()) {
     OMPClausePrinter Printer(Out, Policy);
     for (auto I = D->clauselist_begin(), E = D->clauselist_end(); I != E; ++I)
       Printer.Visit(*I);
   }

clang/lib/AST/OpenMPClause.cpp

 }
 
 void OMPClausePrinter::VisitOMPNumThreadsClause(OMPNumThreadsClause *Node) {
   OS << "num_threads(";
   Node->getNumThreads()->printPretty(OS, nullptr, Policy, 0);
   OS << ")";
 }
 
+void OMPClausePrinter::VisitOMPAlignClause(OMPAlignClause *Node) {
+  OS << "align(";
+  Node->getAlignment()->printPretty(OS, nullptr, Policy, 0);
+  OS << ")";
+}
+
 void OMPClausePrinter::VisitOMPSafelenClause(OMPSafelenClause *Node) {
   OS << "safelen(";
   Node->getSafelen()->printPretty(OS, nullptr, Policy, 0);
   OS << ")";
 }
 
 void OMPClausePrinter::VisitOMPSimdlenClause(OMPSimdlenClause *Node) {
   OS << "simdlen(";

clang/lib/AST/StmtProfile.cpp

 }
 
 void OMPClauseProfiler::VisitOMPNumThreadsClause(const OMPNumThreadsClause *C) {
   VistOMPClauseWithPreInit(C);
   if (C->getNumThreads())
     Profiler->VisitStmt(C->getNumThreads());
 }
 
+void OMPClauseProfiler::VisitOMPAlignClause(const OMPAlignClause *C) {
+  if (C->getAlignment())
+    Profiler->VisitStmt(C->getAlignment());
+}
+
 void OMPClauseProfiler::VisitOMPSafelenClause(const OMPSafelenClause *C) {
   if (C->getSafelen())
     Profiler->VisitStmt(C->getSafelen());
 }
 
 void OMPClauseProfiler::VisitOMPSimdlenClause(const OMPSimdlenClause *C) {
   if (C->getSimdlen())
     Profiler->VisitStmt(C->getSimdlen());

clang/lib/CodeGen/CGStmtOpenMP.cpp

static void emitOMPAtomicExpr(CodeGenFunction &CGF, OpenMPClauseKind Kind,
   case OMPC_link:
   case OMPC_use:
   case OMPC_novariants:
   case OMPC_nocontext:
   case OMPC_filter:
   case OMPC_when:
   case OMPC_adjust_args:
   case OMPC_append_args:
+  case OMPC_align:
     llvm_unreachable("Clause is not allowed in 'omp atomic'.");
   }
 }
 
 void CodeGenFunction::EmitOMPAtomicDirective(const OMPAtomicDirective &S) {
   llvm::AtomicOrdering AO = llvm::AtomicOrdering::Monotonic;
   bool MemOrderingSpecified = false;
   if (S.getSingleClause<OMPSeqCstClause>()) {

clang/lib/Parse/ParseOpenMP.cpp

OMPClause *Parser::ParseOpenMPClause(OpenMPDirectiveKind DKind,
   case OMPC_hint:
   case OMPC_allocator:
   case OMPC_depobj:
   case OMPC_detach:
   case OMPC_novariants:
   case OMPC_nocontext:
   case OMPC_filter:
   case OMPC_partial:
+  case OMPC_align:
     // OpenMP [2.5, Restrictions]
     //  At most one num_threads clause can appear on the directive.
     // OpenMP [2.8.1, simd construct, Restrictions]
     //  Only one safelen  clause can appear on a simd directive.
     //  Only one simdlen  clause can appear on a simd directive.
     //  Only one collapse clause can appear on a simd directive.
     // OpenMP [2.11.1, task Construct, Restrictions]
     //  At most one if clause can appear on the directive.

 ///      'hint' '(' expression ')'
 ///
 ///    allocator-clause:
 ///      'allocator' '(' expression ')'
 ///
 ///    detach-clause:
 ///      'detach' '(' event-handler-expression ')'
 ///
+///    align-clause
+///      'align' '(' positive-integer-constant ')'
+///
 OMPClause *Parser::ParseOpenMPSingleExprClause(OpenMPClauseKind Kind,
                                                bool ParseOnly) {
   SourceLocation Loc = ConsumeToken();
   SourceLocation LLoc = Tok.getLocation();
   SourceLocation RLoc;
 
   ExprResult Val = ParseOpenMPParensExpr(getOpenMPClauseName(Kind), RLoc);
 

clang/lib/Sema/SemaOpenMP.cpp

if (!AllocatorsMatch) {
     return true;
   }
   return false;
 }
 
 static void
 applyOMPAllocateAttribute(Sema &S, VarDecl *VD,
                           OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind,
-                          Expr *Allocator, SourceRange SR) {
+                          Expr *Allocator, Expr *Alignment, SourceRange SR) {
   if (VD->hasAttr<OMPAllocateDeclAttr>())
     return;
+  if (Alignment &&
+      (Alignment->isTypeDependent() || Alignment->isValueDependent() ||
+       Alignment->isInstantiationDependent() ||
+       Alignment->containsUnexpandedParameterPack()))
+    // Apply later when we have a usable value.
+    return;
   if (Allocator &&
       (Allocator->isTypeDependent() || Allocator->isValueDependent() ||
        Allocator->isInstantiationDependent() ||
        Allocator->containsUnexpandedParameterPack()))
     return;
   auto *A = OMPAllocateDeclAttr::CreateImplicit(S.Context, AllocatorKind,
-                                                Allocator, SR);
+                                                Allocator, Alignment, SR);
   VD->addAttr(A);
   if (ASTMutationListener *ML = S.Context.getASTMutationListener())
     ML->DeclarationMarkedOpenMPAllocate(VD, A);
 }
 
 Sema::DeclGroupPtrTy Sema::ActOnOpenMPAllocateDirective(
     SourceLocation Loc, ArrayRef<Expr *> VarList,
     ArrayRef<OMPClause *> Clauses, DeclContext *Owner) {
-  assert(Clauses.size() <= 1 && "Expected at most one clause.");
+  assert(Clauses.size() <= 2 && "Expected at most two clauses.");
+  Expr *Alignment = nullptr;
   Expr *Allocator = nullptr;
   if (Clauses.empty()) {
     // OpenMP 5.0, 2.11.3 allocate Directive, Restrictions.
     // allocate directives that appear in a target region must specify an
     // allocator clause unless a requires directive with the dynamic_allocators
     // clause is present in the same compilation unit.
     if (LangOpts.OpenMPIsDevice &&
         !DSAStack->hasRequiresDeclWithClause<OMPDynamicAllocatorsClause>())
       targetDiag(Loc, diag::err_expected_allocator_clause);
   } else {
-    Allocator = cast<OMPAllocatorClause>(Clauses.back())->getAllocator();
+    for (const OMPClause *C : Clauses)
+      if (const auto *AC = dyn_cast<OMPAllocatorClause>(C))
+        Allocator = AC->getAllocator();
+      else if (const auto *AC = dyn_cast<OMPAlignClause>(C))
+        Alignment = AC->getAlignment();
+      else
+        llvm_unreachable("Unexpected clause on allocate directive");
   }
   OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind =
       getAllocatorKind(*this, DSAStack, Allocator);
   SmallVector<Expr *, 8> Vars;
   for (Expr *RefExpr : VarList) {
     auto *DE = cast<DeclRefExpr>(RefExpr);
     auto *VD = cast<VarDecl>(DE->getDecl());
 
if (Allocator && VD->hasGlobalStorage()) {
         Diag(VD->getLocation(),
              IsDecl ? diag::note_previous_decl : diag::note_defined_here)
             << VD;
         continue;
       }
     }
 
     Vars.push_back(RefExpr);
-    applyOMPAllocateAttribute(*this, VD, AllocatorKind, Allocator,
+    applyOMPAllocateAttribute(*this, VD, AllocatorKind, Allocator, Alignment,
                               DE->getSourceRange());
   }
   if (Vars.empty())
     return nullptr;
   if (!Owner)
     Owner = getCurLexicalContext();
   auto *D = OMPAllocateDecl::Create(Context, Owner, Loc, Vars, Clauses);
   D->setAccess(AS_public);
for (Expr *E : AC->varlists()) {
         S.Diag(E->getExprLoc(),
                diag::err_omp_expected_private_copy_for_allocate);
         continue;
       }
       VarDecl *PrivateVD = DeclToCopy[VD];
       if (checkPreviousOMPAllocateAttribute(S, Stack, E, PrivateVD,
                                             AllocatorKind, AC->getAllocator()))
         continue;
+      // Placeholder until allocate clause supports align modifier.
+      Expr *Alignment = nullptr;
       applyOMPAllocateAttribute(S, PrivateVD, AllocatorKind, AC->getAllocator(),
-                                E->getSourceRange());
+                                Alignment, E->getSourceRange());
     }
   }
 }
 
 namespace {
 /// Rewrite statements and expressions for Sema \p Actions CurContext.
 ///
 /// Used to wrap already parsed statements/expressions into a new CapturedStmt
case OMPC_nocontext:
     Res = ActOnOpenMPNocontextClause(Expr, StartLoc, LParenLoc, EndLoc);
     break;
   case OMPC_filter:
     Res = ActOnOpenMPFilterClause(Expr, StartLoc, LParenLoc, EndLoc);
     break;
   case OMPC_partial:
     Res = ActOnOpenMPPartialClause(Expr, StartLoc, LParenLoc, EndLoc);
     break;
+  case OMPC_align:
+    Res = ActOnOpenMPAlignClause(Expr, StartLoc, LParenLoc, EndLoc);
+    break;
   case OMPC_device:
   case OMPC_if:
   case OMPC_default:
   case OMPC_proc_bind:
   case OMPC_schedule:
   case OMPC_private:
   case OMPC_firstprivate:
   case OMPC_lastprivate:
ExprResult Sema::VerifyPositiveIntegerConstantInClause(Expr *E,
 
   if ((StrictlyPositive && !Result.isStrictlyPositive()) ||
       (!StrictlyPositive && !Result.isNonNegative())) {
     Diag(E->getExprLoc(), diag::err_omp_negative_expression_in_clause)
         << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0)
         << E->getSourceRange();
     return ExprError();
   }
-  if (CKind == OMPC_aligned && !Result.isPowerOf2()) {
+  if ((CKind == OMPC_aligned || CKind == OMPC_align) && !Result.isPowerOf2()) {
     Diag(E->getExprLoc(), diag::warn_omp_alignment_not_power_of_two)
         << E->getSourceRange();
     return ExprError();
   }
   if (CKind == OMPC_collapse && DSAStack->getAssociatedLoops() == 1)
     DSAStack->setAssociatedLoops(Result.getExtValue());
   else if (CKind == OMPC_ordered)
     DSAStack->setAssociatedLoops(Result.getExtValue());
if (FactorResult.isInvalid())
       return nullptr;
     FactorExpr = FactorResult.get();
   }
 
   return OMPPartialClause::Create(Context, StartLoc, LParenLoc, EndLoc,
                                   FactorExpr);
 }
 
+OMPClause *Sema::ActOnOpenMPAlignClause(Expr *A, SourceLocation StartLoc,
+                                        SourceLocation LParenLoc,
+                                        SourceLocation EndLoc) {
+  ExprResult AlignVal;
+  AlignVal = VerifyPositiveIntegerConstantInClause(A, OMPC_align);
+  if (AlignVal.isInvalid())
+    return nullptr;
+  return new (Context)
+      OMPAlignClause(AlignVal.get(), StartLoc, LParenLoc, EndLoc);
+}
+
 OMPClause *Sema::ActOnOpenMPSingleExprWithArgClause(
     OpenMPClauseKind Kind, ArrayRef<unsigned> Argument, Expr *Expr,
     SourceLocation StartLoc, SourceLocation LParenLoc,
     ArrayRef<SourceLocation> ArgumentLoc, SourceLocation DelimLoc,
     SourceLocation EndLoc) {
   OMPClause *Res = nullptr;
   switch (Kind) {
   case OMPC_schedule:

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

Decl *TemplateDeclInstantiator::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
   for (auto *I : D->varlists()) {
     Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
     assert(isa<DeclRefExpr>(Var) && "allocate arg is not a DeclRefExpr");
     Vars.push_back(Var);
   }
   SmallVector<OMPClause *, 4> Clauses;
   // Copy map clauses from the original mapper.
   for (OMPClause *C : D->clauselists()) {
-    auto *AC = cast<OMPAllocatorClause>(C);
+    OMPClause *IC = nullptr;
+    if (auto *AC = dyn_cast<OMPAllocatorClause>(C)) {
       ExprResult NewE = SemaRef.SubstExpr(AC->getAllocator(), TemplateArgs);
       if (!NewE.isUsable())
         continue;
-    OMPClause *IC = SemaRef.ActOnOpenMPAllocatorClause(
+      IC = SemaRef.ActOnOpenMPAllocatorClause(
           NewE.get(), AC->getBeginLoc(), AC->getLParenLoc(), AC->getEndLoc());
+    } else if (auto *AC = dyn_cast<OMPAlignClause>(C)) {
+      ExprResult NewE = SemaRef.SubstExpr(AC->getAlignment(), TemplateArgs);
+      if (!NewE.isUsable())
+        continue;
+      IC = SemaRef.ActOnOpenMPAlignClause(NewE.get(), AC->getBeginLoc(),
+                                          AC->getLParenLoc(), AC->getEndLoc());
+      // If align clause value ends up being invalid, this can end up null.
+      if (!IC)
+        continue;
+    }
     Clauses.push_back(IC);
   }
 
   Sema::DeclGroupPtrTy Res = SemaRef.ActOnOpenMPAllocateDirective(
       D->getLocation(), Vars, Clauses, Owner);
   if (Res.get().isNull())
     return nullptr;
   return Res.get().getSingleDecl();

clang/lib/Sema/TreeTransform.h

   /// Subclasses may override this routine to provide different behavior.
   OMPClause *RebuildOMPFilterClause(Expr *ThreadID, SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation EndLoc) {
     return getSema().ActOnOpenMPFilterClause(ThreadID, StartLoc, LParenLoc,
                                              EndLoc);
   }
 
+  /// Build a new OpenMP 'align' clause.
+  ///
+  /// By default, performs semantic analysis to build the new OpenMP clause.
+  /// Subclasses may override this routine to provide different behavior.
+  OMPClause *RebuildOMPAlignClause(Expr *A, SourceLocation StartLoc,
+                                   SourceLocation LParenLoc,
+                                   SourceLocation EndLoc) {
+    return getSema().ActOnOpenMPAlignClause(A, StartLoc, LParenLoc, EndLoc);
+  }
+
   /// Rebuild the operand to an Objective-C \@synchronized statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc,
                                               Expr *object) {
     return getSema().ActOnObjCAtSynchronizedOperand(atLoc, object);
   }
TreeTransform<Derived>::TransformOMPFilterClause(OMPFilterClause *C) {
   ExprResult ThreadID = getDerived().TransformExpr(C->getThreadID());
   if (ThreadID.isInvalid())
     return nullptr;
   return getDerived().RebuildOMPFilterClause(ThreadID.get(), C->getBeginLoc(),
                                              C->getLParenLoc(), C->getEndLoc());
 }
 
 template <typename Derived>
+OMPClause *TreeTransform<Derived>::TransformOMPAlignClause(OMPAlignClause *C) {
+  ExprResult E = getDerived().TransformExpr(C->getAlignment());
+  if (E.isInvalid())
+    return nullptr;
+  return getDerived().RebuildOMPAlignClause(E.get(), C->getBeginLoc(),
+                                            C->getLParenLoc(), C->getEndLoc());
+}
+
+template <typename Derived>
 OMPClause *TreeTransform<Derived>::TransformOMPUnifiedAddressClause(
     OMPUnifiedAddressClause *C) {
   llvm_unreachable("unified_address clause cannot appear in dependent context");
 }
 
 template <typename Derived>
 OMPClause *TreeTransform<Derived>::TransformOMPUnifiedSharedMemoryClause(
     OMPUnifiedSharedMemoryClause *C) {

clang/lib/Serialization/ASTReader.cpp

case llvm::omp::OMPC_uses_allocators:
     C = OMPUsesAllocatorsClause::CreateEmpty(Context, Record.readInt());
     break;
   case llvm::omp::OMPC_affinity:
     C = OMPAffinityClause::CreateEmpty(Context, Record.readInt());
     break;
   case llvm::omp::OMPC_filter:
     C = new (Context) OMPFilterClause();
     break;
+  case llvm::omp::OMPC_align:
+    C = new (Context) OMPAlignClause();
+    break;
 #define OMP_CLAUSE_NO_CLASS(Enum, Str)                                         \
   case llvm::omp::Enum:                                                        \
     break;
 #include "llvm/Frontend/OpenMP/OMPKinds.def"
   default:
     break;
   }
   assert(C && "Unknown OMPClause type");

 }
 
 void OMPClauseReader::VisitOMPFilterClause(OMPFilterClause *C) {
   VisitOMPClauseWithPreInit(C);
   C->setThreadID(Record.readSubExpr());
   C->setLParenLoc(Record.readSourceLocation());
 }
 
+void OMPClauseReader::VisitOMPAlignClause(OMPAlignClause *C) {
+  C->setAlignment(Record.readExpr());
+  C->setLParenLoc(Record.readSourceLocation());
+}
+
 OMPTraitInfo *ASTRecordReader::readOMPTraitInfo() {
   OMPTraitInfo &TI = getContext().getNewOMPTraitInfo();
   TI.Sets.resize(readUInt32());
   for (auto &Set : TI.Sets) {
     Set.Kind = readEnum<llvm::omp::TraitSet>();
     Set.Selectors.resize(readUInt32());
     for (auto &Selector : Set.Selectors) {
       Selector.Kind = readEnum<llvm::omp::TraitSelector>();

clang/lib/Serialization/ASTReaderDecl.cpp

case UPD_DECL_MARKED_OPENMP_THREADPRIVATE:
           Reader.getContext(), readSourceRange(),
           AttributeCommonInfo::AS_Pragma));
       break;
 
     case UPD_DECL_MARKED_OPENMP_ALLOCATE: {
       auto AllocatorKind =
           static_cast<OMPAllocateDeclAttr::AllocatorTypeTy>(Record.readInt());
       Expr *Allocator = Record.readExpr();
+      Expr *Alignment = Record.readExpr();
       SourceRange SR = readSourceRange();
       D->addAttr(OMPAllocateDeclAttr::CreateImplicit(
-          Reader.getContext(), AllocatorKind, Allocator, SR,
+          Reader.getContext(), AllocatorKind, Allocator, Alignment, SR,
           AttributeCommonInfo::AS_Pragma));
       break;
     }
 
     case UPD_DECL_EXPORTED: {
       unsigned SubmoduleID = readSubmoduleID();
       auto *Exported = cast<NamedDecl>(D);
       Module *Owner = SubmoduleID ? Reader.getSubmodule(SubmoduleID) : nullptr;

clang/lib/Serialization/ASTWriter.cpp

for (auto &Update : DeclUpdate.second) {
         Record.AddSourceRange(
             D->getAttr<OMPThreadPrivateDeclAttr>()->getRange());
         break;
 
       case UPD_DECL_MARKED_OPENMP_ALLOCATE: {
         auto *A = D->getAttr<OMPAllocateDeclAttr>();
         Record.push_back(A->getAllocatorType());
         Record.AddStmt(A->getAllocator());
+        Record.AddStmt(A->getAlignment());
         Record.AddSourceRange(A->getRange());
         break;
       }
 
       case UPD_DECL_MARKED_OPENMP_DECLARETARGET:
         Record.push_back(D->getAttr<OMPDeclareTargetDeclAttr>()->getMapType());
         Record.AddSourceRange(
             D->getAttr<OMPDeclareTargetDeclAttr>()->getRange());

 }
 
 void OMPClauseWriter::VisitOMPFilterClause(OMPFilterClause *C) {
   VisitOMPClauseWithPreInit(C);
   Record.AddStmt(C->getThreadID());
   Record.AddSourceLocation(C->getLParenLoc());
 }
 
+void OMPClauseWriter::VisitOMPAlignClause(OMPAlignClause *C) {
+  Record.AddStmt(C->getAlignment());
+  Record.AddSourceLocation(C->getLParenLoc());
+}
+
 void OMPClauseWriter::VisitOMPPrivateClause(OMPPrivateClause *C) {
   Record.push_back(C->varlist_size());
   Record.AddSourceLocation(C->getLParenLoc());
   for (auto *VE : C->varlists()) {
     Record.AddStmt(VE);
   }
   for (auto *VE : C->private_copies()) {
     Record.AddStmt(VE);

clang/test/OpenMP/align_clause_ast_print.cpp

+// expected-no-diagnostics
+
+//RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \
+//RUN:   -x c++ -std=c++14 -fexceptions -fcxx-exceptions                   \
+//RUN:   -Wno-source-uses-openmp -Wno-openmp-clauses                       \
+//RUN:   -ast-print %s | FileCheck %s --check-prefix=PRINT
+
+//RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \
+//RUN:   -x c++ -std=c++14 -fexceptions -fcxx-exceptions                   \
+//RUN:   -Wno-source-uses-openmp -Wno-openmp-clauses                       \
+//RUN:   -ast-dump %s | FileCheck %s --check-prefix=DUMP
+
+//RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \
+//RUN:   -x c++ -std=c++14 -fexceptions -fcxx-exceptions                   \
+//RUN:   -Wno-source-uses-openmp -Wno-openmp-clauses                       \
+//RUN:   -emit-pch -o %t %s
+
+//RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \
+//RUN:   -x c++ -std=c++14 -fexceptions -fcxx-exceptions                   \
+//RUN:   -Wno-source-uses-openmp -Wno-openmp-clauses                       \
+//RUN:   -include-pch %t -ast-print %s | FileCheck %s --check-prefix=PRINT
+
+//RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \
+//RUN:   -x c++ -std=c++14 -fexceptions -fcxx-exceptions                   \
+//RUN:   -Wno-source-uses-openmp -Wno-openmp-clauses                       \
+//RUN:   -include-pch %t -ast-dump-all %s | FileCheck %s --check-prefix=DUMP
+
+#ifndef HEADER
+#define HEADER
+
+typedef enum omp_allocator_handle_t {
+  omp_null_allocator = 0,
+  omp_default_mem_alloc = 1,
+  omp_large_cap_mem_alloc = 2,
+  omp_const_mem_alloc = 3,
+  omp_high_bw_mem_alloc = 4,
+  omp_low_lat_mem_alloc = 5,
+  omp_cgroup_mem_alloc = 6,
+  omp_pteam_mem_alloc = 7,
+  omp_thread_mem_alloc = 8,
+  KMP_ALLOCATOR_MAX_HANDLE = __UINTPTR_MAX__
+} omp_allocator_handle_t;
+
+int foo1() {
+  char a;
+#pragma omp allocate(a) align(4) allocator(omp_pteam_mem_alloc)
+  return a;
+}
+// DUMP: FunctionDecl {{.*}}
+// DUMP: DeclStmt {{.*}}
+// DUMP: VarDecl {{.*}}a 'char'
+// DUMP: OMPAllocateDeclAttr {{.*}}OMPPTeamMemAlloc
+// DUMP: DeclRefExpr {{.*}}'omp_allocator_handle_t' EnumConstant {{.*}} 'omp_pteam_mem_alloc' 'omp_allocator_handle_t'
+// DUMP: ConstantExpr {{.*}}'int'
+// DUMP: value: Int 4
+// DUMP: IntegerLiteral {{.*}}'int' 4
+// DUMP: DeclStmt {{.*}}
+// DUMP: OMPAllocateDecl {{.*}}
+// DUMP: DeclRefExpr {{.*}}'char' lvalue Var {{.*}} 'a' 'char'
+// DUMP: OMPAlignClause {{.*}}
+// DUMP: ConstantExpr {{.*}}'int'
+// DUMP: value: Int 4
+// DUMP: IntegerLiteral {{.*}}'int' 4
+// DUMP: OMPAllocatorClause {{.*}}
+// DUMP: DeclRefExpr {{.*}}'omp_allocator_handle_t' EnumConstant {{.*}}'omp_pteam_mem_alloc' 'omp_allocator_handle_t'
+// PRINT: #pragma omp allocate(a) align(4) allocator(omp_pteam_mem_alloc)
+
+int foo2() {
+  char b;
+#pragma omp allocate(b) allocator(omp_low_lat_mem_alloc) align(2)
+  return b;
+}
+// DUMP: FunctionDecl {{.*}}
+// DUMP: DeclStmt {{.*}}
+// DUMP: VarDecl {{.*}}b 'char'
+// DUMP: OMPAllocateDeclAttr {{.*}}Implicit OMPLowLatMemAlloc
+// DUMP: DeclRefExpr {{.*}}'omp_allocator_handle_t' EnumConstant {{.*}} 'omp_low_lat_mem_alloc' 'omp_allocator_handle_t'
+// DUMP: ConstantExpr {{.*}}'int'
+// DUMP: value: Int 2
+// DUMP: IntegerLiteral {{.*}}'int' 2
+// DUMP: DeclStmt {{.*}}
+// DUMP: OMPAllocateDecl {{.*}}
+// DUMP: DeclRefExpr {{.*}}'char' lvalue Var {{.*}} 'b' 'char'
+// DUMP: OMPAllocatorClause {{.*}}
+// DUMP: DeclRefExpr {{.*}}'omp_allocator_handle_t' EnumConstant {{.*}} 'omp_low_lat_mem_alloc' 'omp_allocator_handle_t'
+// DUMP: OMPAlignClause {{.*}}
+// DUMP:  ConstantExpr {{.*}}'int'
+// DUMP: value: Int 2
+// DUMP: IntegerLiteral {{.*}}'int' 2
+// PRINT: #pragma omp allocate(b) allocator(omp_low_lat_mem_alloc) align(2)
+
+template <typename T, unsigned size>
+T run() {
+  T foo;
+#pragma omp allocate(foo) align(size)
+  return size;
+}
+
+int template_test() {
+  double d;
+  d = run<double, 1>();
+  return 0;
+}
+
+// DUMP: FunctionTemplateDecl {{.*}}
+// DUMP: TemplateTypeParmDecl {{.*}}
+// DUMP: NonTypeTemplateParmDecl {{.*}}'unsigned int' depth 0 index 1 size
+// DUMP: FunctionDecl {{.*}}'T ()'
+// DUMP: DeclStmt {{.*}}
+// DUMP: OMPAllocateDecl {{.*}}
+// DUMP: DeclRefExpr {{.*}}'T' lvalue Var {{.*}} 'foo' 'T'
+// DUMP: OMPAlignClause {{.*}}
+// DUMP: DeclRefExpr {{.*}}'unsigned int' NonTypeTemplateParm {{.*}} 'size' 'unsigned int'
+// DUMP: FunctionDecl {{.*}}run 'double ()'
+// DUMP: TemplateArgument type 'double'
+// DUMP: BuiltinType {{.*}}'double'
+// DUMP: TemplateArgument integral 1
+// DUMP: OMPAllocateDeclAttr {{.*}}Implicit OMPNullMemAlloc
+// DUMP: ConstantExpr {{.*}}'unsigned int'
+// DUMP: value: Int 1
+// DUMP: SubstNonTypeTemplateParmExpr {{.*}}'unsigned int'
+// DUMP: NonTypeTemplateParmDecl {{.*}}'unsigned int' depth 0 index 1 size
+// DUMP: IntegerLiteral {{.*}}'unsigned int' 1
+// DUMP: OMPAllocateDecl {{.*}}
+// DUMP: DeclRefExpr {{.*}}'double':'double' lvalue Var {{.*}} 'foo' 'double':'double'
+// DUMP: OMPAlignClause {{.*}}
+// DUMP: ConstantExpr {{.*}}'unsigned int'
+// DUMP: value: Int 1
+// DUMP: SubstNonTypeTemplateParmExpr {{.*}}'unsigned int'
+// DUMP: NonTypeTemplateParmDecl {{.*}}'unsigned int' depth 0 index 1 size
+// DUMP: IntegerLiteral {{.*}}'unsigned int' 1
+// PRINT: #pragma omp allocate(foo) align(size)
+// PRINT: #pragma omp allocate(foo) align(1U)
+#endif // HEADER

clang/test/OpenMP/align_clause_messages.cpp

+// RUN: %clang_cc1 -fopenmp -fopenmp-version=51 %s -verify
+
+int foobar() {
+  return 1;
+}
+
+int main(int argc, char *argv[]) {
+  // expected-note@+1 {{declared here}}
+  int a;
+  // expected-note@+1 {{declared here}}
+  int b;
+  // expected-note@+1 {{declared here}}
+  int c;
+  double f;
+  int foo2[10];
+
+// expected-error@+1 {{expected '(' after 'align'}}
+#pragma omp allocate(a) align
+// expected-error@+3 {{expected expression}}
+// expected-error@+2 {{expected ')'}}
+// expected-note@+1 {{to match this '('}}
+#pragma omp allocate(a) align(
+// expected-error@+1 {{expected expression}}
+#pragma omp allocate(a) align()
+// expected-error@+4 {{expected ')'}}
+// expected-note@+3 {{to match this '('}}
+// expected-error@+2 {{expression is not an integral constant expression}}
+// expected-note@+1 {{read of non-const variable 'a' is not allowed in a constant expression}}
+#pragma omp allocate(a) align(a
+// expected-error@+2 {{expression is not an integral constant expression}}
+// expected-note@+1 {{read of non-const variable 'b' is not allowed in a constant expression}}
+#pragma omp allocate(a) align(b)
+// expected-error@+2 {{expression is not an integral constant expression}}
+// expected-note@+1 {{read of non-const variable 'c' is not allowed in a constant expression}}
+#pragma omp allocate(a) align(c + 1)
+// expected-error@+1 {{expected an OpenMP directive}}
+#pragma omp align(2) allocate(a)
+// expected-error@+1 {{directive '#pragma omp allocate' cannot contain more than one 'align' clause}}
+#pragma omp allocate(a) align(2) align(4)
+// expected-warning@+1 {{aligned clause will be ignored because the requested alignment is not a power of 2}}
+#pragma omp allocate(a) align(9)
+// expected-error@+1 {{integral constant expression must have integral or unscoped enumeration type, not 'double'}}
+#pragma omp allocate(a) align(f)
+}
+
+// Verify appropriate errors when using templates.
+template <typename T, unsigned size, unsigned align>
+T run() {
+  T foo[size];
+// expected-warning@+1 {{aligned clause will be ignored because the requested alignment is not a power of 2}}
+#pragma omp allocate(foo) align(align)
+  return foo[0];
+}
+
+int template_test() {
+  double d;
+  // expected-note@+1 {{in instantiation of function template specialization 'run<double, 10U, 3U>' requested here}}
+  d = run<double, 10, 3>();
+  return 0;
+}

clang/tools/libclang/CIndex.cpp

void OMPClauseEnqueue::VisitOMPNocontextClause(const OMPNocontextClause *C) {
   Visitor->AddStmt(C->getCondition());
 }
 
 void OMPClauseEnqueue::VisitOMPFilterClause(const OMPFilterClause *C) {
   VisitOMPClauseWithPreInit(C);
   Visitor->AddStmt(C->getThreadID());
 }
 
+void OMPClauseEnqueue::VisitOMPAlignClause(const OMPAlignClause *C) {
+  Visitor->AddStmt(C->getAlignment());
+}
+
 void OMPClauseEnqueue::VisitOMPUnifiedAddressClause(
     const OMPUnifiedAddressClause *) {}
 
 void OMPClauseEnqueue::VisitOMPUnifiedSharedMemoryClause(
     const OMPUnifiedSharedMemoryClause *) {}
 
 void OMPClauseEnqueue::VisitOMPReverseOffloadClause(
     const OMPReverseOffloadClause *) {}

llvm/include/llvm/Frontend/OpenMP/OMP.td

def OMPC_Link : Clause<"link"> {
   let flangClass = "OmpObjectList";
 }
 def OMPC_Inbranch : Clause<"inbranch"> {}
 def OMPC_Notinbranch : Clause<"notinbranch"> {}
 def OMPC_Filter : Clause<"filter"> {
   let clangClass = "OMPFilterClause";
   let flangClass = "ScalarIntExpr";
 }
+def OMPC_Align : Clause<"align"> {
+  let clangClass = "OMPAlignClause";
+}
 def OMPC_When: Clause<"when"> {}
 
 //===----------------------------------------------------------------------===//
 // Definition of OpenMP directives
 //===----------------------------------------------------------------------===//
 
 def OMP_ThreadPrivate : Directive<"threadprivate"> {}
 def OMP_Parallel : Directive<"parallel"> {
let allowedOnceClauses = [
     VersionedClause<OMPC_Collapse>,
     VersionedClause<OMPC_DistSchedule>,
     VersionedClause<OMPC_SafeLen>,
     VersionedClause<OMPC_SimdLen>,
   ];
 }
 def OMP_Allocate : Directive<"allocate"> {
   let allowedOnceClauses = [
-    VersionedClause<OMPC_Allocator>
+    VersionedClause<OMPC_Allocator>,
+    VersionedClause<OMPC_Align, 51>
   ];
 }
 def OMP_DeclareVariant : Directive<"declare variant"> {
   let allowedClauses = [
     VersionedClause<OMPC_Match>
   ];
   let allowedExclusiveClauses = [
     VersionedClause<OMPC_AdjustArgs, 51>,