llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang Author: Erich Keane (erichkeane) <details> <summary>Changes</summary> This patch adds the basic infrastructure for lowering an OpenMP directive, which should enable someone to take over the OpenMP lowering in the future. It adds the lowering entry points to CIR in the same way as OpenACC. Note that this does nothing with any of the directives, which will happen in a followup patch. No infrastructure for clauses is added either, but that will come in a followup patch as well. --- Patch is 52.89 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/171902.diff 11 Files Affected: - (modified) clang/lib/CIR/CodeGen/CIRGenDecl.cpp (+21-7) - (added) clang/lib/CIR/CodeGen/CIRGenDeclOpenMP.cpp (+129) - (modified) clang/lib/CIR/CodeGen/CIRGenFunction.h (+133) - (modified) clang/lib/CIR/CodeGen/CIRGenModule.cpp (+27) - (modified) clang/lib/CIR/CodeGen/CIRGenModule.h (+8) - (modified) clang/lib/CIR/CodeGen/CIRGenStmt.cpp (+120-15) - (added) clang/lib/CIR/CodeGen/CIRGenStmtOpenMP.cpp (+460) - (modified) clang/lib/CIR/CodeGen/CIRGenerator.cpp (+2) - (modified) clang/lib/CIR/CodeGen/CMakeLists.txt (+2) - (added) clang/test/CIR/CodeGenOpenMP/decl-not-yet-implemented.c (+5) - (added) clang/test/CIR/CodeGenOpenMP/not-yet-implemented.c (+16) ``````````diff diff --git a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp index 12b153af36c3e..393633f686917 100644 --- a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp @@ -744,11 +744,6 @@ void CIRGenFunction::emitDecl(const Decl &d, bool evaluateConditionDecl) { case Decl::Import: case Decl::MSGuid: // __declspec(uuid("...")) case Decl::TemplateParamObject: - case Decl::OMPThreadPrivate: - case Decl::OMPGroupPrivate: - case Decl::OMPAllocate: - case Decl::OMPCapturedExpr: - case Decl::OMPRequires: case Decl::Empty: case Decl::Concept: case Decl::LifetimeExtendedTemporary: @@ -782,6 +777,27 @@ void CIRGenFunction::emitDecl(const Decl &d, bool evaluateConditionDecl) { case Decl::OpenACCRoutine: emitOpenACCRoutine(cast<OpenACCRoutineDecl>(d)); return; + case Decl::OMPThreadPrivate: + emitOMPThreadPrivateDecl(cast<OMPThreadPrivateDecl>(d)); + return; + case Decl::OMPGroupPrivate: + emitOMPGroupPrivateDecl(cast<OMPGroupPrivateDecl>(d)); + return; + case Decl::OMPAllocate: + emitOMPAllocateDecl(cast<OMPAllocateDecl>(d)); + return; + case Decl::OMPCapturedExpr: + emitOMPCapturedExpr(cast<OMPCapturedExprDecl>(d)); + return; + case Decl::OMPRequires: + emitOMPRequiresDecl(cast<OMPRequiresDecl>(d)); + return; + case Decl::OMPDeclareMapper: + emitOMPDeclareMapper(cast<OMPDeclareMapperDecl>(d)); + return; + case Decl::OMPDeclareReduction: + emitOMPDeclareReduction(cast<OMPDeclareReductionDecl>(d)); + return; case Decl::Typedef: // typedef int X; case Decl::TypeAlias: { // using X = int; [C++0x] QualType ty = cast<TypedefNameDecl>(d).getUnderlyingType(); @@ -793,8 +809,6 @@ void CIRGenFunction::emitDecl(const Decl &d, bool evaluateConditionDecl) { case Decl::ImplicitConceptSpecialization: case Decl::TopLevelStmt: case Decl::UsingPack: - case Decl::OMPDeclareMapper: - case Decl::OMPDeclareReduction: cgm.errorNYI(d.getSourceRange(), std::string("emitDecl: unhandled decl type: ") + d.getDeclKindName()); diff --git a/clang/lib/CIR/CodeGen/CIRGenDeclOpenMP.cpp b/clang/lib/CIR/CodeGen/CIRGenDeclOpenMP.cpp new file mode 100644 index 0000000000000..e377bb6172a29 --- /dev/null +++ b/clang/lib/CIR/CodeGen/CIRGenDeclOpenMP.cpp @@ -0,0 +1,129 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This contains code to emit Decl nodes as CIR code. +// +//===----------------------------------------------------------------------===// + +#include "CIRGenFunction.h" +#include "clang/AST/DeclOpenMP.h" + +using namespace clang; +using namespace clang::CIRGen; + +void CIRGenModule::emitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *d) { + // TODO(OpenMP): We don't properly differentiate between 'emitDecl' and + // 'emitGlobal' and 'emitTopLevelDecl' in CIRGenDecl.cpp/CIRGenModule.cpp, so + // if this decl requires we differentiate those, we probably need to split + // this function into multiples. + errorNYI(d->getSourceRange(), "OpenMP OMPThreadPrivateDecl"); +} + +void CIRGenFunction::emitOMPThreadPrivateDecl(const OMPThreadPrivateDecl &d) { + // TODO(OpenMP): We don't properly differentiate between 'emitDecl' and + // 'emitGlobal' and 'emitTopLevelDecl' in CIRGenDecl.cpp/CIRGenModule.cpp, so + // if this decl requires we differentiate those, we probably need to split + // this function into multiples. + getCIRGenModule().errorNYI(d.getSourceRange(), "OpenMP OMPThreadPrivateDecl"); +} + +void CIRGenModule::emitOMPGroupPrivateDecl(const OMPGroupPrivateDecl *d) { + // TODO(OpenMP): We don't properly differentiate between 'emitDecl' and + // 'emitGlobal' and 'emitTopLevelDecl' in CIRGenDecl.cpp/CIRGenModule.cpp, so + // if this decl requires we differentiate those, we probably need to split + // this function into multiples. + errorNYI(d->getSourceRange(), "OpenMP OMPGroupPrivateDecl"); +} + +void CIRGenFunction::emitOMPGroupPrivateDecl(const OMPGroupPrivateDecl &d) { + // TODO(OpenMP): We don't properly differentiate between 'emitDecl' and + // 'emitGlobal' and 'emitTopLevelDecl' in CIRGenDecl.cpp/CIRGenModule.cpp, so + // if this decl requires we differentiate those, we probably need to split + // this function into multiples. + getCIRGenModule().errorNYI(d.getSourceRange(), "OpenMP OMPGroupPrivateDecl"); +} + +void CIRGenModule::emitOMPCapturedExpr(const OMPCapturedExprDecl *d) { + // TODO(OpenMP): We don't properly differentiate between 'emitDecl' and + // 'emitGlobal' and 'emitTopLevelDecl' in CIRGenDecl.cpp/CIRGenModule.cpp, so + // if this decl requires we differentiate those, we probably need to split + // this function into multiples. + errorNYI(d->getSourceRange(), "OpenMP OMPCapturedExpr"); +} + +void CIRGenFunction::emitOMPCapturedExpr(const OMPCapturedExprDecl &d) { + // TODO(OpenMP): We don't properly differentiate between 'emitDecl' and + // 'emitGlobal' and 'emitTopLevelDecl' in CIRGenDecl.cpp/CIRGenModule.cpp, so + // if this decl requires we differentiate those, we probably need to split + // this function into multiples. + getCIRGenModule().errorNYI(d.getSourceRange(), "OpenMP OMPCapturedExpr"); +} + +void CIRGenModule::emitOMPAllocateDecl(const OMPAllocateDecl *d) { + // TODO(OpenMP): We don't properly differentiate between 'emitDecl' and + // 'emitGlobal' and 'emitTopLevelDecl' in CIRGenDecl.cpp/CIRGenModule.cpp, so + // if this decl requires we differentiate those, we probably need to split + // this function into multiples. + errorNYI(d->getSourceRange(), "OpenMP OMPAllocateDecl"); +} + +void CIRGenFunction::emitOMPAllocateDecl(const OMPAllocateDecl &d) { + // TODO(OpenMP): We don't properly differentiate between 'emitDecl' and + // 'emitGlobal' and 'emitTopLevelDecl' in CIRGenDecl.cpp/CIRGenModule.cpp, so + // if this decl requires we differentiate those, we probably need to split + // this function into multiples. + getCIRGenModule().errorNYI(d.getSourceRange(), "OpenMP OMPAllocateDecl"); +} + +void CIRGenModule::emitOMPDeclareReduction(const OMPDeclareReductionDecl *d) { + // TODO(OpenMP): We don't properly differentiate between 'emitDecl' and + // 'emitGlobal' and 'emitTopLevelDecl' in CIRGenDecl.cpp/CIRGenModule.cpp, so + // if this decl requires we differentiate those, we probably need to split + // this function into multiples. + errorNYI(d->getSourceRange(), "OpenMP OMPDeclareReduction"); +} + +void CIRGenFunction::emitOMPDeclareReduction(const OMPDeclareReductionDecl &d) { + // TODO(OpenMP): We don't properly differentiate between 'emitDecl' and + // 'emitGlobal' and 'emitTopLevelDecl' in CIRGenDecl.cpp/CIRGenModule.cpp, so + // if this decl requires we differentiate those, we probably need to split + // this function into multiples. + getCIRGenModule().errorNYI(d.getSourceRange(), "OpenMP OMPDeclareReduction"); +} + +void CIRGenModule::emitOMPDeclareMapper(const OMPDeclareMapperDecl *d) { + // TODO(OpenMP): We don't properly differentiate between 'emitDecl' and + // 'emitGlobal' and 'emitTopLevelDecl' in CIRGenDecl.cpp/CIRGenModule.cpp, so + // if this decl requires we differentiate those, we probably need to split + // this function into multiples. + errorNYI(d->getSourceRange(), "OpenMP OMPDeclareMapper"); +} + +void CIRGenFunction::emitOMPDeclareMapper(const OMPDeclareMapperDecl &d) { + // TODO(OpenMP): We don't properly differentiate between 'emitDecl' and + // 'emitGlobal' and 'emitTopLevelDecl' in CIRGenDecl.cpp/CIRGenModule.cpp, so + // if this decl requires we differentiate those, we probably need to split + // this function into multiples. + getCIRGenModule().errorNYI(d.getSourceRange(), "OpenMP OMPDeclareMapper"); +} + +void CIRGenModule::emitOMPRequiresDecl(const OMPRequiresDecl *d) { + // TODO(OpenMP): We don't properly differentiate between 'emitDecl' and + // 'emitGlobal' and 'emitTopLevelDecl' in CIRGenDecl.cpp/CIRGenModule.cpp, so + // if this decl requires we differentiate those, we probably need to split + // this function into multiples. + errorNYI(d->getSourceRange(), "OpenMP OMPRequiresDecl"); +} + +void CIRGenFunction::emitOMPRequiresDecl(const OMPRequiresDecl &d) { + // TODO(OpenMP): We don't properly differentiate between 'emitDecl' and + // 'emitGlobal' and 'emitTopLevelDecl' in CIRGenDecl.cpp/CIRGenModule.cpp, so + // if this decl requires we differentiate those, we probably need to split + // this function into multiples. + getCIRGenModule().errorNYI(d.getSourceRange(), "OpenMP OMPRequiresDecl"); +} diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.h b/clang/lib/CIR/CodeGen/CIRGenFunction.h index 90a3c6233d892..cfe9b37c2c725 100644 --- a/clang/lib/CIR/CodeGen/CIRGenFunction.h +++ b/clang/lib/CIR/CodeGen/CIRGenFunction.h @@ -2022,6 +2022,139 @@ class CIRGenFunction : public CIRGenTypeCache { const Twine &name = "tmp", Address *alloca = nullptr, mlir::OpBuilder::InsertPoint ip = {}); + //===--------------------------------------------------------------------===// + // OpenMP Emission + //===--------------------------------------------------------------------===// +public: + mlir::LogicalResult emitOMPScopeDirective(const OMPScopeDirective &s); + mlir::LogicalResult emitOMPErrorDirective(const OMPErrorDirective &s); + mlir::LogicalResult emitOMPParallelDirective(const OMPParallelDirective &s); + mlir::LogicalResult emitOMPTaskwaitDirective(const OMPTaskwaitDirective &s); + mlir::LogicalResult emitOMPTaskyieldDirective(const OMPTaskyieldDirective &s); + mlir::LogicalResult emitOMPBarrierDirective(const OMPBarrierDirective &s); + mlir::LogicalResult emitOMPMetaDirective(const OMPMetaDirective &s); + mlir::LogicalResult emitOMPCanonicalLoop(const OMPCanonicalLoop &s); + mlir::LogicalResult emitOMPSimdDirective(const OMPSimdDirective &s); + mlir::LogicalResult emitOMPTileDirective(const OMPTileDirective &s); + mlir::LogicalResult emitOMPUnrollDirective(const OMPUnrollDirective &s); + mlir::LogicalResult emitOMPFuseDirective(const OMPFuseDirective &s); + mlir::LogicalResult emitOMPForDirective(const OMPForDirective &s); + mlir::LogicalResult emitOMPForSimdDirective(const OMPForSimdDirective &s); + mlir::LogicalResult emitOMPSectionsDirective(const OMPSectionsDirective &s); + mlir::LogicalResult emitOMPSectionDirective(const OMPSectionDirective &s); + mlir::LogicalResult emitOMPSingleDirective(const OMPSingleDirective &s); + mlir::LogicalResult emitOMPMasterDirective(const OMPMasterDirective &s); + mlir::LogicalResult emitOMPCriticalDirective(const OMPCriticalDirective &s); + mlir::LogicalResult + emitOMPParallelForDirective(const OMPParallelForDirective &s); + mlir::LogicalResult + emitOMPParallelForSimdDirective(const OMPParallelForSimdDirective &s); + mlir::LogicalResult + emitOMPParallelMasterDirective(const OMPParallelMasterDirective &s); + mlir::LogicalResult + emitOMPParallelSectionsDirective(const OMPParallelSectionsDirective &s); + mlir::LogicalResult emitOMPTaskDirective(const OMPTaskDirective &s); + mlir::LogicalResult emitOMPTaskgroupDirective(const OMPTaskgroupDirective &s); + mlir::LogicalResult emitOMPFlushDirective(const OMPFlushDirective &s); + mlir::LogicalResult emitOMPDepobjDirective(const OMPDepobjDirective &s); + mlir::LogicalResult emitOMPScanDirective(const OMPScanDirective &s); + mlir::LogicalResult emitOMPOrderedDirective(const OMPOrderedDirective &s); + mlir::LogicalResult emitOMPAtomicDirective(const OMPAtomicDirective &s); + mlir::LogicalResult emitOMPTargetDirective(const OMPTargetDirective &s); + mlir::LogicalResult emitOMPTeamsDirective(const OMPTeamsDirective &s); + mlir::LogicalResult + emitOMPCancellationPointDirective(const OMPCancellationPointDirective &s); + mlir::LogicalResult emitOMPCancelDirective(const OMPCancelDirective &s); + mlir::LogicalResult + emitOMPTargetDataDirective(const OMPTargetDataDirective &s); + mlir::LogicalResult + emitOMPTargetEnterDataDirective(const OMPTargetEnterDataDirective &s); + mlir::LogicalResult + emitOMPTargetExitDataDirective(const OMPTargetExitDataDirective &s); + mlir::LogicalResult + emitOMPTargetParallelDirective(const OMPTargetParallelDirective &s); + mlir::LogicalResult + emitOMPTargetParallelForDirective(const OMPTargetParallelForDirective &s); + mlir::LogicalResult emitOMPTaskLoopDirective(const OMPTaskLoopDirective &s); + mlir::LogicalResult + emitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective &s); + mlir::LogicalResult + emitOMPMaskedTaskLoopDirective(const OMPMaskedTaskLoopDirective &s); + mlir::LogicalResult + emitOMPMaskedTaskLoopSimdDirective(const OMPMaskedTaskLoopSimdDirective &s); + mlir::LogicalResult + emitOMPMasterTaskLoopDirective(const OMPMasterTaskLoopDirective &s); + mlir::LogicalResult + emitOMPMasterTaskLoopSimdDirective(const OMPMasterTaskLoopSimdDirective &s); + mlir::LogicalResult + emitOMPParallelGenericLoopDirective(const OMPParallelGenericLoopDirective &s); + mlir::LogicalResult + emitOMPParallelMaskedDirective(const OMPParallelMaskedDirective &s); + mlir::LogicalResult emitOMPParallelMaskedTaskLoopDirective( + const OMPParallelMaskedTaskLoopDirective &s); + mlir::LogicalResult emitOMPParallelMaskedTaskLoopSimdDirective( + const OMPParallelMaskedTaskLoopSimdDirective &s); + mlir::LogicalResult emitOMPParallelMasterTaskLoopDirective( + const OMPParallelMasterTaskLoopDirective &s); + mlir::LogicalResult emitOMPParallelMasterTaskLoopSimdDirective( + const OMPParallelMasterTaskLoopSimdDirective &s); + mlir::LogicalResult + emitOMPDistributeDirective(const OMPDistributeDirective &s); + mlir::LogicalResult emitOMPDistributeParallelForDirective( + const OMPDistributeParallelForDirective &s); + mlir::LogicalResult emitOMPDistributeParallelForSimdDirective( + const OMPDistributeParallelForSimdDirective &s); + mlir::LogicalResult + emitOMPDistributeSimdDirective(const OMPDistributeSimdDirective &s); + mlir::LogicalResult emitOMPTargetParallelGenericLoopDirective( + const OMPTargetParallelGenericLoopDirective &s); + mlir::LogicalResult emitOMPTargetParallelForSimdDirective( + const OMPTargetParallelForSimdDirective &s); + mlir::LogicalResult + emitOMPTargetSimdDirective(const OMPTargetSimdDirective &s); + mlir::LogicalResult emitOMPTargetTeamsGenericLoopDirective( + const OMPTargetTeamsGenericLoopDirective &s); + mlir::LogicalResult + emitOMPTargetUpdateDirective(const OMPTargetUpdateDirective &s); + mlir::LogicalResult + emitOMPTeamsDistributeDirective(const OMPTeamsDistributeDirective &s); + mlir::LogicalResult + emitOMPTeamsDistributeSimdDirective(const OMPTeamsDistributeSimdDirective &s); + mlir::LogicalResult emitOMPTeamsDistributeParallelForSimdDirective( + const OMPTeamsDistributeParallelForSimdDirective &s); + mlir::LogicalResult emitOMPTeamsDistributeParallelForDirective( + const OMPTeamsDistributeParallelForDirective &s); + mlir::LogicalResult + emitOMPTeamsGenericLoopDirective(const OMPTeamsGenericLoopDirective &s); + mlir::LogicalResult + emitOMPTargetTeamsDirective(const OMPTargetTeamsDirective &s); + mlir::LogicalResult emitOMPTargetTeamsDistributeDirective( + const OMPTargetTeamsDistributeDirective &s); + mlir::LogicalResult emitOMPTargetTeamsDistributeParallelForDirective( + const OMPTargetTeamsDistributeParallelForDirective &s); + mlir::LogicalResult emitOMPTargetTeamsDistributeParallelForSimdDirective( + const OMPTargetTeamsDistributeParallelForSimdDirective &s); + mlir::LogicalResult emitOMPTargetTeamsDistributeSimdDirective( + const OMPTargetTeamsDistributeSimdDirective &s); + mlir::LogicalResult emitOMPInteropDirective(const OMPInteropDirective &s); + mlir::LogicalResult emitOMPDispatchDirective(const OMPDispatchDirective &s); + mlir::LogicalResult + emitOMPGenericLoopDirective(const OMPGenericLoopDirective &s); + mlir::LogicalResult emitOMPReverseDirective(const OMPReverseDirective &s); + mlir::LogicalResult + emitOMPInterchangeDirective(const OMPInterchangeDirective &s); + mlir::LogicalResult emitOMPAssumeDirective(const OMPAssumeDirective &s); + mlir::LogicalResult emitOMPMaskedDirective(const OMPMaskedDirective &s); + mlir::LogicalResult emitOMPStripeDirective(const OMPStripeDirective &s); + + void emitOMPThreadPrivateDecl(const OMPThreadPrivateDecl &d); + void emitOMPGroupPrivateDecl(const OMPGroupPrivateDecl &d); + void emitOMPCapturedExpr(const OMPCapturedExprDecl &d); + void emitOMPAllocateDecl(const OMPAllocateDecl &d); + void emitOMPDeclareReduction(const OMPDeclareReductionDecl &d); + void emitOMPDeclareMapper(const OMPDeclareMapperDecl &d); + void emitOMPRequiresDecl(const OMPRequiresDecl &d); + //===--------------------------------------------------------------------===// // OpenACC Emission //===--------------------------------------------------------------------===// diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp index 1ad1c2fa41aa1..623d9a13eb131 100644 --- a/clang/lib/CIR/CodeGen/CIRGenModule.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenModule.cpp @@ -360,6 +360,12 @@ void CIRGenModule::emitGlobal(clang::GlobalDecl gd) { return; } + // TODO(OMP): The logic in this function for the 'rest' of the OpenMP + // declarative declarations is complicated and needs to be done on a per-kind + // basis, so all of that needs to be added when we implement the individual + // global-allowed declarations. See uses of `cir::MissingFeatures::openMP + // throughout this function. + const auto *global = cast<ValueDecl>(gd.getDecl()); if (const auto *fd = dyn_cast<FunctionDecl>(global)) { @@ -1544,6 +1550,27 @@ void CIRGenModule::emitTopLevelDecl(Decl *decl) { case Decl::OpenACCDeclare: emitGlobalOpenACCDeclareDecl(cast<OpenACCDeclareDecl>(decl)); break; + case Decl::OMPThreadPrivate: + emitOMPThreadPrivateDecl(cast<OMPThreadPrivateDecl>(decl)); + break; + case Decl::OMPGroupPrivate: + emitOMPGroupPrivateDecl(cast<OMPGroupPrivateDecl>(decl)); + break; + case Decl::OMPAllocate: + emitOMPAllocateDecl(cast<OMPAllocateDecl>(decl)); + break; + case Decl::OMPCapturedExpr: + emitOMPCapturedExpr(cast<OMPCapturedExprDecl>(decl)); + break; + case Decl::OMPDeclareReduction: + emitOMPDeclareReduction(cast<OMPDeclareReductionDecl>(decl)); + break; + case Decl::OMPDeclareMapper: + emitOMPDeclareMapper(cast<OMPDeclareMapperDecl>(decl)); + break; + case Decl::OMPRequires: + emitOMPRequiresDecl(cast<OMPRequiresDecl>(decl)); + break; case Decl::Enum: case Decl::Using: // using X; [C++] case Decl::UsingDirective: // using namespace X; [C++] diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.h b/clang/lib/CIR/CodeGen/CIRGenModule.h index de263f4868507..edd49e24a326f 100644 --- a/clang/lib/CIR/CodeGen/CIRGenModule.h +++ b/clang/lib/CIR/CodeGen/CIRGenModule.h @@ -491,6 +491,14 @@ class CIRGenModule : public CIRGenTypeCache { cir::FuncOp func, SourceLocation pragmaLoc, ArrayRef<const OpenACCClause *> clauses); + void emitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *d); + void emitOMPGroupPrivateDecl(const OMPGroupPrivateDecl *d); + void emitOMPCapturedExpr(const OMPCapturedExprDecl *d); + void emitOMPAllocateDecl(const OMPAllocateDecl *d); + void emitOMPDeclareReduction(const OMPDeclareReductionDecl *d); + void emitOMPDeclareMapper(const OMPDeclareMapperDecl *d); + void emitOMPRequiresDecl(const OMPRequiresDecl *d); + // C++ related functions. void emitDeclContext(const DeclContext *dc); diff --git a/clang/lib/CIR/CodeGen/CIRGenStmt.cpp b/clang/lib/CIR/CodeGen/CIRGenStmt.cpp index c7a95b34a0d6b..fdb1d1c5fcc7d 100644 --- a/clang/lib/CIR/CodeGen/CIRGenStmt.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenStmt.cpp @@ -19,6 +19,7 @@ #include "clang/AST/ExprCXX.h" #include "clang/AST/Stmt.h" #include "clang/AST/StmtOpenACC.h" +#include "clang/AST/StmtOpenMP.h" #include "clan... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/171902 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
