OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 2
Code Issues Packages Projects Releases Wiki Activity

[OpenMP][NFCI] Introduce llvm/IR/OpenMPConstants.h 

Summary:
The new OpenMPConstants.h is a location for all OpenMP related constants
(and helpers) to live.

This patch moves the directives there (the enum OpenMPDirectiveKind) and
rewires Clang to use the new location.

Initially part of D69785.

Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim

Subscribers: jholewinski, ppenzin, penzn, llvm-commits, cfe-commits, jfb, guansong, bollu, hiraditya, mgorny

Tags: #clang, #llvm

Differential Revision: https://reviews.llvm.org/D69853
This commit is contained in:
Johannes Doerfert 2019-11-04 22:00:49 -06:00
parent 4448125007
commit eb3e81f43f
29 changed files with 561 additions and 352 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -111,7 +111,7 @@ class OMPClauseWithPreInit {
Stmt *PreInit = nullptr;
/// Region that captures the associated stmt.
OpenMPDirectiveKind CaptureRegion = OMPD_unknown;
OpenMPDirectiveKind CaptureRegion = llvm::omp::OMPD_unknown;
protected:
OMPClauseWithPreInit(const OMPClause *This) {
@ -119,7 +119,9 @@ protected:
}
/// Set pre-initialization statement for the clause.
void setPreInitStmt(Stmt *S, OpenMPDirectiveKind ThisRegion = OMPD_unknown) {
void
setPreInitStmt(Stmt *S,
OpenMPDirectiveKind ThisRegion = llvm::omp::OMPD_unknown) {
PreInit = S;
CaptureRegion = ThisRegion;
}
@ -432,7 +434,7 @@ class OMPIfClause : public OMPClause, public OMPClauseWithPreInit {
SourceLocation ColonLoc;
/// Directive name modifier for the clause.
OpenMPDirectiveKind NameModifier = OMPD_unknown;
OpenMPDirectiveKind NameModifier = llvm::omp::OMPD_unknown;
/// Name modifier location.
SourceLocation NameModifierLoc;

474
clang/include/clang/AST/StmtOpenMP.h
View File

File diff suppressed because it is too large Load Diff

71
clang/include/clang/Basic/OpenMPKinds.def
View File

@ -11,12 +11,6 @@
///
//===----------------------------------------------------------------------===//
#ifndef OPENMP_DIRECTIVE
# define OPENMP_DIRECTIVE(Name)
#endif
#ifndef OPENMP_DIRECTIVE_EXT
#define OPENMP_DIRECTIVE_EXT(Name, Str)
#endif
#ifndef OPENMP_CLAUSE
# define OPENMP_CLAUSE(Name, Class)
#endif
@ -230,69 +224,6 @@ OPENMP_CONTEXT_SELECTOR_SET(device)
OPENMP_CONTEXT_SELECTOR(vendor)
OPENMP_CONTEXT_SELECTOR(kind)
// OpenMP directives.
OPENMP_DIRECTIVE(threadprivate)
OPENMP_DIRECTIVE(parallel)
OPENMP_DIRECTIVE(task)
OPENMP_DIRECTIVE(simd)
OPENMP_DIRECTIVE(for)
OPENMP_DIRECTIVE(sections)
OPENMP_DIRECTIVE(section)
OPENMP_DIRECTIVE(single)
OPENMP_DIRECTIVE(master)
OPENMP_DIRECTIVE(critical)
OPENMP_DIRECTIVE(taskyield)
OPENMP_DIRECTIVE(barrier)
OPENMP_DIRECTIVE(taskwait)
OPENMP_DIRECTIVE(taskgroup)
OPENMP_DIRECTIVE(flush)
OPENMP_DIRECTIVE(ordered)
OPENMP_DIRECTIVE(atomic)
OPENMP_DIRECTIVE(target)
OPENMP_DIRECTIVE(teams)
OPENMP_DIRECTIVE(cancel)
OPENMP_DIRECTIVE(requires)
OPENMP_DIRECTIVE_EXT(target_data, "target data")
OPENMP_DIRECTIVE_EXT(target_enter_data, "target enter data")
OPENMP_DIRECTIVE_EXT(target_exit_data, "target exit data")
OPENMP_DIRECTIVE_EXT(target_parallel, "target parallel")
OPENMP_DIRECTIVE_EXT(target_parallel_for, "target parallel for")
OPENMP_DIRECTIVE_EXT(target_update, "target update")
OPENMP_DIRECTIVE_EXT(parallel_for, "parallel for")
OPENMP_DIRECTIVE_EXT(parallel_for_simd, "parallel for simd")
OPENMP_DIRECTIVE_EXT(parallel_master, "parallel master")
OPENMP_DIRECTIVE_EXT(parallel_sections, "parallel sections")
OPENMP_DIRECTIVE_EXT(for_simd, "for simd")
OPENMP_DIRECTIVE_EXT(cancellation_point, "cancellation point")
OPENMP_DIRECTIVE_EXT(declare_reduction, "declare reduction")
OPENMP_DIRECTIVE_EXT(declare_mapper, "declare mapper")
OPENMP_DIRECTIVE_EXT(declare_simd, "declare simd")
OPENMP_DIRECTIVE(taskloop)
OPENMP_DIRECTIVE_EXT(taskloop_simd, "taskloop simd")
OPENMP_DIRECTIVE(distribute)
OPENMP_DIRECTIVE_EXT(declare_target, "declare target")
OPENMP_DIRECTIVE_EXT(end_declare_target, "end declare target")
OPENMP_DIRECTIVE_EXT(distribute_parallel_for, "distribute parallel for")
OPENMP_DIRECTIVE_EXT(distribute_parallel_for_simd, "distribute parallel for simd")
OPENMP_DIRECTIVE_EXT(distribute_simd, "distribute simd")
OPENMP_DIRECTIVE_EXT(target_parallel_for_simd, "target parallel for simd")
OPENMP_DIRECTIVE_EXT(target_simd, "target simd")
OPENMP_DIRECTIVE_EXT(teams_distribute, "teams distribute")
OPENMP_DIRECTIVE_EXT(teams_distribute_simd, "teams distribute simd")
OPENMP_DIRECTIVE_EXT(teams_distribute_parallel_for_simd, "teams distribute parallel for simd")
OPENMP_DIRECTIVE_EXT(teams_distribute_parallel_for, "teams distribute parallel for")
OPENMP_DIRECTIVE_EXT(target_teams, "target teams")
OPENMP_DIRECTIVE_EXT(target_teams_distribute, "target teams distribute")
OPENMP_DIRECTIVE_EXT(target_teams_distribute_parallel_for, "target teams distribute parallel for")
OPENMP_DIRECTIVE_EXT(target_teams_distribute_parallel_for_simd, "target teams distribute parallel for simd")
OPENMP_DIRECTIVE_EXT(target_teams_distribute_simd, "target teams distribute simd")
OPENMP_DIRECTIVE(allocate)
OPENMP_DIRECTIVE_EXT(declare_variant, "declare variant")
OPENMP_DIRECTIVE_EXT(master_taskloop, "master taskloop")
OPENMP_DIRECTIVE_EXT(parallel_master_taskloop, "parallel master taskloop")
OPENMP_DIRECTIVE_EXT(master_taskloop_simd, "master taskloop simd")
OPENMP_DIRECTIVE_EXT(parallel_master_taskloop_simd, "parallel master taskloop simd")
// OpenMP clauses.
OPENMP_CLAUSE(allocator, OMPAllocatorClause)
OPENMP_CLAUSE(if, OMPIfClause)
@ -1137,8 +1068,6 @@ OPENMP_MATCH_KIND(implementation)
#undef OPENMP_SCHEDULE_KIND
#undef OPENMP_PROC_BIND_KIND
#undef OPENMP_DEFAULT_KIND
#undef OPENMP_DIRECTIVE
#undef OPENMP_DIRECTIVE_EXT
#undef OPENMP_CLAUSE
#undef OPENMP_CRITICAL_CLAUSE
#undef OPENMP_ORDERED_CLAUSE

13
clang/include/clang/Basic/OpenMPKinds.h
View File

@ -15,6 +15,7 @@
#define LLVM_CLANG_BASIC_OPENMPKINDS_H
#include "llvm/ADT/StringRef.h"
#include "llvm/Frontend/OpenMP/OMPConstants.h"
namespace clang {
@ -58,14 +59,7 @@ template <typename VectorType, typename ScoreT> struct OpenMPCtxSelectorData {
};
/// OpenMP directives.
enum OpenMPDirectiveKind {
#define OPENMP_DIRECTIVE(Name) \
OMPD_##Name,
#define OPENMP_DIRECTIVE_EXT(Name, Str) \
OMPD_##Name,
#include "clang/Basic/OpenMPKinds.def"
OMPD_unknown
};
using OpenMPDirectiveKind = llvm::omp::Directive;
/// OpenMP clauses.
enum OpenMPClauseKind {
@ -208,9 +202,6 @@ struct OpenMPScheduleTy final {
OpenMPScheduleClauseModifier M2 = OMPC_SCHEDULE_MODIFIER_unknown;
};
OpenMPDirectiveKind getOpenMPDirectiveKind(llvm::StringRef Str);
const char *getOpenMPDirectiveName(OpenMPDirectiveKind Kind);
OpenMPClauseKind getOpenMPClauseKind(llvm::StringRef Str);
const char *getOpenMPClauseName(OpenMPClauseKind Kind);

1
clang/lib/AST/CMakeLists.txt
View File

@ -1,6 +1,7 @@
set(LLVM_LINK_COMPONENTS
BinaryFormat
Core
FrontendOpenMP
Support
)

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

@ -1161,7 +1161,7 @@ OMPIsDevicePtrClause::CreateEmpty(const ASTContext &C,
void OMPClausePrinter::VisitOMPIfClause(OMPIfClause *Node) {
OS << "if(";
if (Node->getNameModifier() != OMPD_unknown)
if (Node->getNameModifier() != llvm::omp::OMPD_unknown)
OS << getOpenMPDirectiveName(Node->getNameModifier()) << ": ";
Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
OS << ")";

1
clang/lib/AST/StmtOpenMP.cpp
View File

@ -15,6 +15,7 @@
#include "clang/AST/ASTContext.h"
using namespace clang;
using namespace llvm::omp;
void OMPExecutableDirective::setClauses(ArrayRef<OMPClause *> Clauses) {
assert(Clauses.size() == getNumClauses() &&

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

@ -18,6 +18,7 @@
#include <cassert>
using namespace clang;
using namespace llvm::omp;
OpenMPContextSelectorSetKind
clang::getOpenMPContextSelectorSet(llvm::StringRef Str) {
@ -62,31 +63,6 @@ clang::getOpenMPContextSelectorName(OpenMPContextSelectorKind Kind) {
llvm_unreachable("Invalid OpenMP context selector kind");
}
OpenMPDirectiveKind clang::getOpenMPDirectiveKind(StringRef Str) {
return llvm::StringSwitch<OpenMPDirectiveKind>(Str)
#define OPENMP_DIRECTIVE(Name) .Case(#Name, OMPD_##Name)
#define OPENMP_DIRECTIVE_EXT(Name, Str) .Case(Str, OMPD_##Name)
#include "clang/Basic/OpenMPKinds.def"
.Default(OMPD_unknown);
}
const char *clang::getOpenMPDirectiveName(OpenMPDirectiveKind Kind) {
assert(Kind <= OMPD_unknown);
switch (Kind) {
case OMPD_unknown:
return "unknown";
#define OPENMP_DIRECTIVE(Name) \
case OMPD_##Name: \
return #Name;
#define OPENMP_DIRECTIVE_EXT(Name, Str) \
case OMPD_##Name: \
return Str;
#include "clang/Basic/OpenMPKinds.def"
break;
}
llvm_unreachable("Invalid OpenMP directive kind");
}
OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) {
// 'flush' clause cannot be specified explicitly, because this is an implicit
// clause for 'flush' directive. If the 'flush' clause is explicitly specified
@ -449,7 +425,7 @@ const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
OpenMPClauseKind CKind,
unsigned OpenMPVersion) {
assert(DKind <= OMPD_unknown);
assert(unsigned(DKind) <= unsigned(OMPD_unknown));
assert(CKind <= OMPC_unknown);
switch (DKind) {
case OMPD_parallel:

1
clang/lib/CodeGen/CGOpenMPRuntime.cpp
View File

@ -32,6 +32,7 @@
using namespace clang;
using namespace CodeGen;
using namespace llvm::omp;
namespace {
/// Base class for handling code generation inside OpenMP regions.

1
clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp
View File

@ -22,6 +22,7 @@
using namespace clang;
using namespace CodeGen;
using namespace llvm::omp;
namespace {
enum OpenMPRTLFunctionNVPTX {

1
clang/lib/CodeGen/CGStmtOpenMP.cpp
View File

@ -23,6 +23,7 @@
#include "clang/Basic/PrettyStackTrace.h"
using namespace clang;
using namespace CodeGen;
using namespace llvm::omp;
namespace {
/// Lexical scope for OpenMP executable constructs, that handles correct codegen

2
clang/lib/CodeGen/CodeGenFunction.h
View File

@ -1276,7 +1276,7 @@ private:
CancelExit(OpenMPDirectiveKind Kind, JumpDest ExitBlock,
JumpDest ContBlock)
: Kind(Kind), ExitBlock(ExitBlock), ContBlock(ContBlock) {}
OpenMPDirectiveKind Kind = OMPD_unknown;
OpenMPDirectiveKind Kind = llvm::omp::OMPD_unknown;
/// true if the exit block has been emitted already by the special
/// emitExit() call, false if the default codegen is used.
bool HasBeenEmitted = false;

1
clang/lib/Parse/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LLVM_LINK_COMPONENTS
FrontendOpenMP
MC
MCParser
Support

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

@ -20,6 +20,7 @@
#include "llvm/ADT/UniqueVector.h"
using namespace clang;
using namespace llvm::omp;
//===----------------------------------------------------------------------===//
// OpenMP declarative directives.
@ -27,7 +28,7 @@ using namespace clang;
namespace {
enum OpenMPDirectiveKindEx {
OMPD_cancellation = OMPD_unknown + 1,
OMPD_cancellation = unsigned(OMPD_unknown) + 1,
OMPD_data,
OMPD_declare,
OMPD_end,
@ -46,6 +47,20 @@ enum OpenMPDirectiveKindEx {
OMPD_variant,
};
// Helper to unify the enum class OpenMPDirectiveKind with its extension
// the OpenMPDirectiveKindEx enum which allows to use them together as if they
// are unsigned values.
struct OpenMPDirectiveKindExWrapper {
OpenMPDirectiveKindExWrapper(unsigned Value) : Value(Value) {}
OpenMPDirectiveKindExWrapper(OpenMPDirectiveKind DK) : Value(unsigned(DK)) {}
bool operator==(OpenMPDirectiveKind V) const { return Value == unsigned(V); }
bool operator!=(OpenMPDirectiveKind V) const { return Value != unsigned(V); }
bool operator<(OpenMPDirectiveKind V) const { return Value < unsigned(V); }
operator unsigned() const { return Value; }
operator OpenMPDirectiveKind() const { return OpenMPDirectiveKind(Value); }
unsigned Value;
};
class DeclDirectiveListParserHelper final {
SmallVector<Expr *, 4> Identifiers;
Parser *P;
@ -67,11 +82,11 @@ public:
// Map token string to extended OMP token kind that are
// OpenMPDirectiveKind + OpenMPDirectiveKindEx.
static unsigned getOpenMPDirectiveKindEx(StringRef S) {
auto DKind = getOpenMPDirectiveKind(S);
OpenMPDirectiveKindExWrapper DKind = getOpenMPDirectiveKind(S);
if (DKind != OMPD_unknown)
return DKind;
return llvm::StringSwitch<unsigned>(S)
return llvm::StringSwitch<OpenMPDirectiveKindExWrapper>(S)
.Case("cancellation", OMPD_cancellation)
.Case("data", OMPD_data)
.Case("declare", OMPD_declare)
@ -86,11 +101,11 @@ static unsigned getOpenMPDirectiveKindEx(StringRef S) {
.Default(OMPD_unknown);
}
static OpenMPDirectiveKind parseOpenMPDirectiveKind(Parser &P) {
static OpenMPDirectiveKindExWrapper parseOpenMPDirectiveKind(Parser &P) {
// Array of foldings: F[i][0] F[i][1] ===> F[i][2].
// E.g.: OMPD_for OMPD_simd ===> OMPD_for_simd
// TODO: add other combined directives in topological order.
static const unsigned F[][3] = {
static const OpenMPDirectiveKindExWrapper F[][3] = {
{OMPD_cancellation, OMPD_point, OMPD_cancellation_point},
{OMPD_declare, OMPD_reduction, OMPD_declare_reduction},
{OMPD_declare, OMPD_mapper, OMPD_declare_mapper},
@ -144,7 +159,7 @@ static OpenMPDirectiveKind parseOpenMPDirectiveKind(Parser &P) {
OMPD_parallel_master_taskloop_simd}};
enum { CancellationPoint = 0, DeclareReduction = 1, TargetData = 2 };
Token Tok = P.getCurToken();
unsigned DKind =
OpenMPDirectiveKindExWrapper DKind =
Tok.isAnnotation()
? static_cast<unsigned>(OMPD_unknown)
: getOpenMPDirectiveKindEx(P.getPreprocessor().getSpelling(Tok));
@ -156,7 +171,7 @@ static OpenMPDirectiveKind parseOpenMPDirectiveKind(Parser &P) {
continue;
Tok = P.getPreprocessor().LookAhead(0);
unsigned SDKind =
OpenMPDirectiveKindExWrapper SDKind =
Tok.isAnnotation()
? static_cast<unsigned>(OMPD_unknown)
: getOpenMPDirectiveKindEx(P.getPreprocessor().getSpelling(Tok));
@ -238,8 +253,9 @@ Parser::DeclGroupPtrTy
Parser::ParseOpenMPDeclareReductionDirective(AccessSpecifier AS) {
// Parse '('.
BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
if (T.expectAndConsume(diag::err_expected_lparen_after,
getOpenMPDirectiveName(OMPD_declare_reduction))) {
if (T.expectAndConsume(
diag::err_expected_lparen_after,
getOpenMPDirectiveName(OMPD_declare_reduction).data())) {
SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
return DeclGroupPtrTy();
}
@ -491,7 +507,7 @@ Parser::ParseOpenMPDeclareMapperDirective(AccessSpecifier AS) {
// Parse '('
BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
if (T.expectAndConsume(diag::err_expected_lparen_after,
getOpenMPDirectiveName(OMPD_declare_mapper))) {
getOpenMPDirectiveName(OMPD_declare_mapper).data())) {
SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
return DeclGroupPtrTy();
}
@ -1956,7 +1972,7 @@ bool Parser::ParseOpenMPSimpleVarList(
// Parse '('.
BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
if (T.expectAndConsume(diag::err_expected_lparen_after,
getOpenMPDirectiveName(Kind)))
getOpenMPDirectiveName(Kind).data()))
return true;
bool IsCorrect = true;
bool NoIdentIsFound = true;
@ -2428,15 +2444,16 @@ OMPClause *Parser::ParseOpenMPSingleExprWithArgClause(OpenMPClauseKind Kind,
assert(Kind == OMPC_if);
KLoc.push_back(Tok.getLocation());
TentativeParsingAction TPA(*this);
Arg.push_back(parseOpenMPDirectiveKind(*this));
if (Arg.back() != OMPD_unknown) {
auto DK = parseOpenMPDirectiveKind(*this);
Arg.push_back(DK);
if (DK != OMPD_unknown) {
ConsumeToken();
if (Tok.is(tok::colon) && getLangOpts().OpenMP > 40) {
TPA.Commit();
DelimLoc = ConsumeToken();
} else {
TPA.Revert();
Arg.back() = OMPD_unknown;
Arg.back() = unsigned(OMPD_unknown);
}
} else {
TPA.Revert();

1
clang/lib/Sema/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LLVM_LINK_COMPONENTS
FrontendOpenMP
Support
)

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

@ -28,8 +28,11 @@
#include "clang/Sema/Scope.h"
#include "clang/Sema/ScopeInfo.h"
#include "clang/Sema/SemaInternal.h"
#include "llvm/ADT/IndexedMap.h"
#include "llvm/ADT/PointerEmbeddedInt.h"
#include "llvm/Frontend/OpenMP/OMPConstants.h"
using namespace clang;
using namespace llvm::omp;
//===----------------------------------------------------------------------===//
// Stack of data-sharing attributes for variables
@ -4152,13 +4155,17 @@ static bool checkNestingOfRegions(Sema &SemaRef, const DSAStackTy *Stack,
return false;
}
struct Kind2Unsigned {
using argument_type = OpenMPDirectiveKind;
unsigned operator()(argument_type DK) { return unsigned(DK); }
};
static bool checkIfClauses(Sema &S, OpenMPDirectiveKind Kind,
ArrayRef<OMPClause *> Clauses,
ArrayRef<OpenMPDirectiveKind> AllowedNameModifiers) {
bool ErrorFound = false;
unsigned NamedModifiersNumber = 0;
SmallVector<const OMPIfClause *, OMPC_unknown + 1> FoundNameModifiers(
OMPD_unknown + 1);
llvm::IndexedMap<const OMPIfClause *, Kind2Unsigned> FoundNameModifiers;
FoundNameModifiers.resize(unsigned(OMPD_unknown) + 1);
SmallVector<SourceLocation, 4> NameModifierLoc;
for (const OMPClause *C : Clauses) {
if (const auto *IC = dyn_cast_or_null<OMPIfClause>(C)) {

3
clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
View File

@ -3188,7 +3188,8 @@ TemplateDeclInstantiator::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
} else {
// Instantiate the mapper variable.
DeclarationNameInfo DirName;
SemaRef.StartOpenMPDSABlock(OMPD_declare_mapper, DirName, /*S=*/nullptr,
SemaRef.StartOpenMPDSABlock(llvm::omp::OMPD_declare_mapper, DirName,
/*S=*/nullptr,
(*D->clauselist_begin())->getBeginLoc());
SemaRef.ActOnOpenMPDeclareMapperDirectiveVarDecl(
NewDMD, /*S=*/nullptr, SubstMapperTy, D->getLocation(), VN);

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

@ -37,6 +37,8 @@
#include "llvm/Support/ErrorHandling.h"
#include <algorithm>
using namespace llvm::omp;
namespace clang {
using namespace sema;

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

@ -6622,7 +6622,7 @@ void OMPClauseWriter::writeClause(OMPClause *C) {
}
void OMPClauseWriter::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
Record.push_back(C->getCaptureRegion());
Record.push_back(uint64_t(C->getCaptureRegion()));
Record.AddStmt(C->getPreInitStmt());
}
@ -6633,7 +6633,7 @@ void OMPClauseWriter::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) {
void OMPClauseWriter::VisitOMPIfClause(OMPIfClause *C) {
VisitOMPClauseWithPreInit(C);
Record.push_back(C->getNameModifier());
Record.push_back(uint64_t(C->getNameModifier()));
Record.AddSourceLocation(C->getNameModifierLoc());
Record.AddSourceLocation(C->getColonLoc());
Record.AddStmt(C->getCondition());

4
clang/lib/Serialization/ASTWriterStmt.cpp
View File

@ -2255,7 +2255,7 @@ void ASTStmtWriter::VisitOMPCancellationPointDirective(
OMPCancellationPointDirective *D) {
VisitStmt(D);
VisitOMPExecutableDirective(D);
Record.push_back(D->getCancelRegion());
Record.push_back(uint64_t(D->getCancelRegion()));
Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE;
}
@ -2263,7 +2263,7 @@ void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Record.push_back(D->getCancelRegion());
Record.push_back(uint64_t(D->getCancelRegion()));
Code = serialization::STMT_OMP_CANCEL_DIRECTIVE;
}

46
llvm/include/llvm/Frontend/OpenMP/OMPConstants.h Normal file
View File

@ -0,0 +1,46 @@
//===- OMPConstants.h - OpenMP related constants and helpers ------ C++ -*-===//
//
// 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 defines constans and helpers used when dealing with OpenMP.
///
//===----------------------------------------------------------------------===//
#ifndef LLVM_OPENMP_CONSTANTS_H
#define LLVM_OPENMP_CONSTANTS_H
#include "llvm/ADT/StringRef.h"
namespace llvm {
namespace omp {
/// IDs for all OpenMP directives.
enum class Directive {
#define OMP_DIRECTIVE(Enum, ...) Enum,
#include "llvm/Frontend/OpenMP/OMPKinds.def"
};
/// Make the enum values available in the llvm::omp namespace. This allows us to
/// write something like OMPD_parallel if we have a `using namespace omp`. At
/// the same time we do not loose the strong type guarantees of the enum class,
/// that is we cannot pass an unsigned as Directive without an explicit cast.
#define OMP_DIRECTIVE(Enum, ...) constexpr auto Enum = omp::Directive::Enum;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
/// Parse \p Str and return the directive it matches or OMPD_unknown if none.
Directive getOpenMPDirectiveKind(StringRef Str);
/// Return a textual representation of the directive \p D.
StringRef getOpenMPDirectiveName(Directive D);
} // end namespace omp
} // end namespace llvm
#endif // LLVM_OPENMP_CONSTANTS_H

102
llvm/include/llvm/Frontend/OpenMP/OMPKinds.def Normal file
View File

@ -0,0 +1,102 @@
//===--- OMPKinds.def - OpenMP directives, clauses, rt-calls -*- C++ -*-===//
//
// 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 defines the list of supported OpenMP directives, clauses, runtime
/// calls, and other things that need to be listed in enums.
///
//===----------------------------------------------------------------------===//
/// OpenMP Directives and combined directives
///
///{
#ifndef OMP_DIRECTIVE
#define OMP_DIRECTIVE(Enum, Str)
#endif
#define __OMP_DIRECTIVE_EXT(Name, Str) OMP_DIRECTIVE(OMPD_##Name, Str)
#define __OMP_DIRECTIVE(Name) __OMP_DIRECTIVE_EXT(Name, #Name)
__OMP_DIRECTIVE(threadprivate)
__OMP_DIRECTIVE(parallel)
__OMP_DIRECTIVE(task)
__OMP_DIRECTIVE(simd)
__OMP_DIRECTIVE(for)
__OMP_DIRECTIVE(sections)
__OMP_DIRECTIVE(section)
__OMP_DIRECTIVE(single)
__OMP_DIRECTIVE(master)
__OMP_DIRECTIVE(critical)
__OMP_DIRECTIVE(taskyield)
__OMP_DIRECTIVE(barrier)
__OMP_DIRECTIVE(taskwait)
__OMP_DIRECTIVE(taskgroup)
__OMP_DIRECTIVE(flush)
__OMP_DIRECTIVE(ordered)
__OMP_DIRECTIVE(atomic)
__OMP_DIRECTIVE(target)
__OMP_DIRECTIVE(teams)
__OMP_DIRECTIVE(cancel)
__OMP_DIRECTIVE(requires)
__OMP_DIRECTIVE_EXT(target_data, "target data")
__OMP_DIRECTIVE_EXT(target_enter_data, "target enter data")
__OMP_DIRECTIVE_EXT(target_exit_data, "target exit data")
__OMP_DIRECTIVE_EXT(target_parallel, "target parallel")
__OMP_DIRECTIVE_EXT(target_parallel_for, "target parallel for")
__OMP_DIRECTIVE_EXT(target_update, "target update")
__OMP_DIRECTIVE_EXT(parallel_for, "parallel for")
__OMP_DIRECTIVE_EXT(parallel_for_simd, "parallel for simd")
__OMP_DIRECTIVE_EXT(parallel_master, "parallel master")
__OMP_DIRECTIVE_EXT(parallel_sections, "parallel sections")
__OMP_DIRECTIVE_EXT(for_simd, "for simd")
__OMP_DIRECTIVE_EXT(cancellation_point, "cancellation point")
__OMP_DIRECTIVE_EXT(declare_reduction, "declare reduction")
__OMP_DIRECTIVE_EXT(declare_mapper, "declare mapper")
__OMP_DIRECTIVE_EXT(declare_simd, "declare simd")
__OMP_DIRECTIVE(taskloop)
__OMP_DIRECTIVE_EXT(taskloop_simd, "taskloop simd")
__OMP_DIRECTIVE(distribute)
__OMP_DIRECTIVE_EXT(declare_target, "declare target")
__OMP_DIRECTIVE_EXT(end_declare_target, "end declare target")
__OMP_DIRECTIVE_EXT(distribute_parallel_for, "distribute parallel for")
__OMP_DIRECTIVE_EXT(distribute_parallel_for_simd,
"distribute parallel for simd")
__OMP_DIRECTIVE_EXT(distribute_simd, "distribute simd")
__OMP_DIRECTIVE_EXT(target_parallel_for_simd, "target parallel for simd")
__OMP_DIRECTIVE_EXT(target_simd, "target simd")
__OMP_DIRECTIVE_EXT(teams_distribute, "teams distribute")
__OMP_DIRECTIVE_EXT(teams_distribute_simd, "teams distribute simd")
__OMP_DIRECTIVE_EXT(teams_distribute_parallel_for_simd,
"teams distribute parallel for simd")
__OMP_DIRECTIVE_EXT(teams_distribute_parallel_for,
"teams distribute parallel for")
__OMP_DIRECTIVE_EXT(target_teams, "target teams")
__OMP_DIRECTIVE_EXT(target_teams_distribute, "target teams distribute")
__OMP_DIRECTIVE_EXT(target_teams_distribute_parallel_for,
"target teams distribute parallel for")
__OMP_DIRECTIVE_EXT(target_teams_distribute_parallel_for_simd,
"target teams distribute parallel for simd")
__OMP_DIRECTIVE_EXT(target_teams_distribute_simd,
"target teams distribute simd")
__OMP_DIRECTIVE(allocate)
__OMP_DIRECTIVE_EXT(declare_variant, "declare variant")
__OMP_DIRECTIVE_EXT(master_taskloop, "master taskloop")
__OMP_DIRECTIVE_EXT(parallel_master_taskloop, "parallel master taskloop")
__OMP_DIRECTIVE_EXT(master_taskloop_simd, "master taskloop simd")
__OMP_DIRECTIVE_EXT(parallel_master_taskloop_simd,
"parallel master taskloop simd")
// Has to be the last because Clang implicitly expects it to be.
__OMP_DIRECTIVE(unknown)
#undef __OMP_DIRECTIVE_EXT
#undef __OMP_DIRECTIVE
#undef OMP_DIRECTIVE
///}

1
llvm/lib/CMakeLists.txt
View File

@ -8,6 +8,7 @@ add_subdirectory(CodeGen)
add_subdirectory(BinaryFormat)
add_subdirectory(Bitcode)
add_subdirectory(Bitstream)
add_subdirectory(Frontend)
add_subdirectory(Transforms)
add_subdirectory(Linker)
add_subdirectory(Analysis)

1
llvm/lib/Frontend/CMakeLists.txt Normal file
View File

@ -0,0 +1 @@
add_subdirectory(OpenMP)

23
llvm/lib/Frontend/LLVMBuild.txt Normal file
View File

@ -0,0 +1,23 @@
;===- ./lib/Frontend/LLVMBuild.txt -----------------------------*- Conf -*--===;
;
; 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 is an LLVMBuild description file for the components in this subdirectory.
;
; For more information on the LLVMBuild system, please see:
;
; http://llvm.org/docs/LLVMBuild.html
;
;===------------------------------------------------------------------------===;
[common]
subdirectories = OpenMP
[component_0]
type = Group
name = Frontend
parent = Libraries

10
llvm/lib/Frontend/OpenMP/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
add_llvm_component_library(LLVMFrontendOpenMP
OMPConstants.cpp
ADDITIONAL_HEADER_DIRS
${LLVM_MAIN_INCLUDE_DIR}/llvm/Frontend
${LLVM_MAIN_INCLUDE_DIR}/llvm/Frontend/OpenMP
DEPENDS
intrinsics_gen
)

21
llvm/lib/Frontend/OpenMP/LLVMBuild.txt Normal file
View File

@ -0,0 +1,21 @@
;===- ./lib/Frontend/OpenMP/LLVMBuild.txt ----------------------*- Conf -*--===;
;
; 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 is an LLVMBuild description file for the components in this subdirectory.
;
; For more information on the LLVMBuild system, please see:
;
; http://llvm.org/docs/LLVMBuild.html
;
;===------------------------------------------------------------------------===;
[component_0]
type = Library
name = FrontendOpenMP
parent = Frontend
required_libraries = Core Support TransformUtils

34
llvm/lib/Frontend/OpenMP/OMPConstants.cpp Normal file
View File

@ -0,0 +1,34 @@
//===- OMPConstants.cpp - Helpers related to OpenMP code generation ---===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
//===----------------------------------------------------------------------===//
#include "llvm/Frontend/OpenMP/OMPConstants.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
using namespace llvm;
using namespace omp;
Directive llvm::omp::getOpenMPDirectiveKind(StringRef Str) {
return llvm::StringSwitch<Directive>(Str)
#define OMP_DIRECTIVE(Enum, Str) .Case(Str, Enum)
#include "llvm/Frontend/OpenMP/OMPKinds.def"
.Default(OMPD_unknown);
}
StringRef llvm::omp::getOpenMPDirectiveName(Directive Kind) {
switch (Kind) {
#define OMP_DIRECTIVE(Enum, Str) \
case Enum: \
return Str;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
}
llvm_unreachable("Invalid OpenMP directive kind");
}

1
llvm/lib/LLVMBuild.txt
View File

@ -24,6 +24,7 @@ subdirectories =
DebugInfo
Demangle
ExecutionEngine
Frontend
FuzzMutate
LineEditor
Linker