blob: 1350934d0e65929e408b8b2c3aa76b822cadc044 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
//===--- OpenMPKinds.cpp - Token Kinds Support ----------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
/// \file
/// \brief This file implements the OpenMP enum and support functions.
///
//===----------------------------------------------------------------------===//
#include "clang/Basic/OpenMPKinds.h"
#include "clang/Basic/IdentifierTable.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/ErrorHandling.h"
#include <cassert>
using namespace clang;
OpenMPDirectiveKind clang::getOpenMPDirectiveKind(StringRef Str) {
return llvm::StringSwitch<OpenMPDirectiveKind>(Str)
#define OPENMP_DIRECTIVE(Name) \
.Case(#Name, OMPD_##Name)
#include "clang/Basic/OpenMPKinds.def"
.Default(OMPD_unknown);
}
const char *clang::getOpenMPDirectiveName(OpenMPDirectiveKind Kind) {
assert(Kind < NUM_OPENMP_DIRECTIVES);
switch (Kind) {
case OMPD_unknown:
return "unknown";
#define OPENMP_DIRECTIVE(Name) \
case OMPD_##Name : return #Name;
#include "clang/Basic/OpenMPKinds.def"
case NUM_OPENMP_DIRECTIVES:
break;
}
llvm_unreachable("Invalid OpenMP directive kind");
}
OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) {
return llvm::StringSwitch<OpenMPClauseKind>(Str)
#define OPENMP_CLAUSE(Name, Class) \
.Case(#Name, OMPC_##Name)
#include "clang/Basic/OpenMPKinds.def"
.Default(OMPC_unknown);
}
const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
assert(Kind < NUM_OPENMP_CLAUSES);
switch (Kind) {
case OMPC_unknown:
return "unknown";
#define OPENMP_CLAUSE(Name, Class) \
case OMPC_##Name : return #Name;
#include "clang/Basic/OpenMPKinds.def"
case OMPC_threadprivate:
return "threadprivate or thread local";
case NUM_OPENMP_CLAUSES:
break;
}
llvm_unreachable("Invalid OpenMP clause kind");
}
unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
StringRef Str) {
switch (Kind) {
case OMPC_default:
return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
#define OPENMP_DEFAULT_KIND(Name) \
.Case(#Name, OMPC_DEFAULT_##Name)
#include "clang/Basic/OpenMPKinds.def"
.Default(OMPC_DEFAULT_unknown);
case OMPC_unknown:
case OMPC_threadprivate:
case OMPC_private:
case OMPC_firstprivate:
case OMPC_shared:
case NUM_OPENMP_CLAUSES:
break;
}
llvm_unreachable("Invalid OpenMP simple clause kind");
}
const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
unsigned Type) {
switch (Kind) {
case OMPC_default:
switch (Type) {
case OMPC_DEFAULT_unknown:
return "unknown";
#define OPENMP_DEFAULT_KIND(Name) \
case OMPC_DEFAULT_##Name : return #Name;
#include "clang/Basic/OpenMPKinds.def"
}
llvm_unreachable("Invalid OpenMP 'default' clause type");
case OMPC_unknown:
case OMPC_threadprivate:
case OMPC_private:
case OMPC_firstprivate:
case OMPC_shared:
case NUM_OPENMP_CLAUSES:
break;
}
llvm_unreachable("Invalid OpenMP simple clause kind");
}
bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
OpenMPClauseKind CKind) {
assert(DKind < NUM_OPENMP_DIRECTIVES);
assert(CKind < NUM_OPENMP_CLAUSES);
switch (DKind) {
case OMPD_parallel:
switch (CKind) {
#define OPENMP_PARALLEL_CLAUSE(Name) \
case OMPC_##Name: return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_unknown:
case OMPD_threadprivate:
case OMPD_task:
case NUM_OPENMP_DIRECTIVES:
break;
}
return false;
}
|
