Skip to content

Commit 82cb486

Browse files
erichkeaneerichkeane
committed
Starting effort to make tablegen specifically for clang.x
1 parent 2b05c62 commit 82cb486

File tree

3 files changed

+40
-158
lines changed

3 files changed

+40
-158
lines changed

‎clang/include/clang/Basic/OpenACCKinds.h

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -328,7 +328,8 @@ enum class OpenACCClauseKind : uint8_t {
328328
/// constructs.
329329
Wait,
330330

331-
/// Represents an invalid clause, for the purposes of parsing.
331+
/// Represents an invalid clause, for the purposes of parsing. Should be
332+
/// 'last'.
332333
Invalid,
333334
};
334335

‎clang/lib/Sema/SemaOpenACCClauseAppertainment.cpp

Lines changed: 28 additions & 157 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,8 @@
1616

1717
#include "llvm/ADT/STLExtras.h"
1818
#include "llvm/ADT/bit.h"
19-
#include "llvm/Frontend/OpenACC/ACC.h.inc"
19+
20+
using namespace clang;
2021

2122
namespace {
2223
// Implements a simple 'enum-set' which stores enum values in a single 64 bit
@@ -25,41 +26,34 @@ namespace {
2526
class AccClauseSet {
2627
// We're just using a uint64_t as our underlying rep, so if this size ever
2728
// gets bigger than 64, we probably need a pair of uint64_ts.
28-
static_assert(llvm::acc::Clause_enumSize <= 64);
29+
static_assert(static_assert<unsigned>(OpenACCClauseKind::Invalid) < 64);
2930
uint64_t Data;
3031

31-
void setBit(llvm::acc::Clause C) {
32+
void setBit(OpenACCClauseKind C) {
3233
Data |= static_cast<uint64_t>(1) << static_cast<uint64_t>(C);
3334
}
3435

3536
public:
3637
constexpr AccClauseSet(
37-
const std::initializer_list<llvm::acc::Clause> &Clauses)
38+
const std::initializer_list<OpenACCClauseKind> &Clauses)
3839
: Data(0) {
39-
for (llvm::acc::Clause C : Clauses)
40+
for (OpenACCClauseKind C : Clauses)
4041
setBit(C);
4142
}
4243

43-
constexpr bool isSet(llvm::acc::Clause C) const {
44+
constexpr bool isSet(OpenACCClauseKind C) const {
4445
return ((Data >> static_cast<uint64_t>(C)) & 1) != 0;
4546
}
4647

47-
void clearBit(llvm::acc::Clause C) {
48+
void clearBit(OpenACCClauseKind C) {
4849
Data &= ~(static_cast<uint64_t>(1) << static_cast<uint64_t>(C));
4950
}
5051

5152
constexpr bool isEmpty() const { return Data == 0; }
5253

5354
unsigned popcount() const { return llvm::popcount<uint64_t>(Data); }
5455
};
55-
} // namespace
56-
57-
#define GEN_FLANG_DIRECTIVE_CLAUSE_SETS
58-
#include "llvm/Frontend/OpenACC/ACC.inc"
59-
60-
using namespace clang;
6156

62-
namespace {
6357
struct LLVMClauseLists {
6458
AccClauseSet Allowed;
6559
AccClauseSet AllowedOnce;
@@ -71,136 +65,19 @@ struct LLVMDirectiveClauseRelationships {
7165
LLVMClauseLists Lists;
7266
};
7367

74-
LLVMDirectiveClauseRelationships Relations[] =
75-
#define GEN_FLANG_DIRECTIVE_CLAUSE_MAP
76-
#include "llvm/Frontend/OpenACC/ACC.inc"
77-
;
78-
79-
llvm::acc::Directive
80-
getLLVMDirectiveFromClangDirective(OpenACCDirectiveKind DK) {
81-
// FIXME: There isn't any obvious way to do this automatically, but perhaps we
82-
// could figure out one?
83-
switch (DK) {
84-
case OpenACCDirectiveKind::Parallel:
85-
return llvm::acc::Directive::ACCD_parallel;
86-
case OpenACCDirectiveKind::Serial:
87-
return llvm::acc::Directive::ACCD_serial;
88-
case OpenACCDirectiveKind::Kernels:
89-
return llvm::acc::Directive::ACCD_kernels;
90-
case OpenACCDirectiveKind::Data:
91-
return llvm::acc::Directive::ACCD_data;
92-
case OpenACCDirectiveKind::EnterData:
93-
return llvm::acc::Directive::ACCD_enter_data;
94-
case OpenACCDirectiveKind::ExitData:
95-
return llvm::acc::Directive::ACCD_exit_data;
96-
case OpenACCDirectiveKind::HostData:
97-
return llvm::acc::Directive::ACCD_host_data;
98-
case OpenACCDirectiveKind::Loop:
99-
return llvm::acc::Directive::ACCD_loop;
100-
case OpenACCDirectiveKind::Cache:
101-
return llvm::acc::Directive::ACCD_cache;
102-
case OpenACCDirectiveKind::ParallelLoop:
103-
return llvm::acc::Directive::ACCD_parallel_loop;
104-
case OpenACCDirectiveKind::SerialLoop:
105-
return llvm::acc::Directive::ACCD_serial_loop;
106-
case OpenACCDirectiveKind::KernelsLoop:
107-
return llvm::acc::Directive::ACCD_kernels_loop;
108-
case OpenACCDirectiveKind::Atomic:
109-
return llvm::acc::Directive::ACCD_atomic;
110-
case OpenACCDirectiveKind::Declare:
111-
return llvm::acc::Directive::ACCD_declare;
112-
case OpenACCDirectiveKind::Init:
113-
return llvm::acc::Directive::ACCD_init;
114-
case OpenACCDirectiveKind::Shutdown:
115-
return llvm::acc::Directive::ACCD_shutdown;
116-
case OpenACCDirectiveKind::Set:
117-
return llvm::acc::Directive::ACCD_set;
118-
case OpenACCDirectiveKind::Update:
119-
return llvm::acc::Directive::ACCD_update;
120-
case OpenACCDirectiveKind::Wait:
121-
return llvm::acc::Directive::ACCD_wait;
122-
case OpenACCDirectiveKind::Routine:
123-
return llvm::acc::Directive::ACCD_routine;
124-
case OpenACCDirectiveKind::Invalid:
125-
llvm_unreachable("Shouldn't get here with an invalid directive");
126-
}
127-
128-
llvm_unreachable("unhandled directive kind");
129-
}
130-
131-
// FIXME: There isn't any obvious way to do this automatically, but perhaps we
132-
// could figure out one?
133-
std::pair<OpenACCClauseKind, llvm::acc::Clause> ClauseEquivs[]{
134-
{OpenACCClauseKind::Finalize, llvm::acc::Clause::ACCC_finalize},
135-
{OpenACCClauseKind::IfPresent, llvm::acc::Clause::ACCC_if_present},
136-
{OpenACCClauseKind::Seq, llvm::acc::Clause::ACCC_seq},
137-
{OpenACCClauseKind::Independent, llvm::acc::Clause::ACCC_independent},
138-
{OpenACCClauseKind::Auto, llvm::acc::Clause::ACCC_auto},
139-
{OpenACCClauseKind::Worker, llvm::acc::Clause::ACCC_worker},
140-
{OpenACCClauseKind::Vector, llvm::acc::Clause::ACCC_vector},
141-
{OpenACCClauseKind::NoHost, llvm::acc::Clause::ACCC_nohost},
142-
{OpenACCClauseKind::Default, llvm::acc::Clause::ACCC_default},
143-
{OpenACCClauseKind::If, llvm::acc::Clause::ACCC_if},
144-
{OpenACCClauseKind::Self, llvm::acc::Clause::ACCC_self},
145-
{OpenACCClauseKind::Copy, llvm::acc::Clause::ACCC_copy},
146-
{OpenACCClauseKind::PCopy, llvm::acc::Clause::ACCC_copy},
147-
{OpenACCClauseKind::PresentOrCopy, llvm::acc::Clause::ACCC_copy},
148-
{OpenACCClauseKind::UseDevice, llvm::acc::Clause::ACCC_use_device},
149-
{OpenACCClauseKind::Attach, llvm::acc::Clause::ACCC_attach},
150-
{OpenACCClauseKind::Delete, llvm::acc::Clause::ACCC_delete},
151-
{OpenACCClauseKind::Detach, llvm::acc::Clause::ACCC_detach},
152-
{OpenACCClauseKind::Device, llvm::acc::Clause::ACCC_device},
153-
{OpenACCClauseKind::DevicePtr, llvm::acc::Clause::ACCC_deviceptr},
154-
{OpenACCClauseKind::DeviceResident,
155-
llvm::acc::Clause::ACCC_device_resident},
156-
{OpenACCClauseKind::FirstPrivate, llvm::acc::Clause::ACCC_firstprivate},
157-
{OpenACCClauseKind::Host, llvm::acc::Clause::ACCC_host},
158-
{OpenACCClauseKind::Link, llvm::acc::Clause::ACCC_link},
159-
{OpenACCClauseKind::NoCreate, llvm::acc::Clause::ACCC_no_create},
160-
{OpenACCClauseKind::Present, llvm::acc::Clause::ACCC_present},
161-
{OpenACCClauseKind::Private, llvm::acc::Clause::ACCC_private},
162-
{OpenACCClauseKind::CopyOut, llvm::acc::Clause::ACCC_copyout},
163-
{OpenACCClauseKind::PCopyOut, llvm::acc::Clause::ACCC_copyout},
164-
{OpenACCClauseKind::PresentOrCopyOut, llvm::acc::Clause::ACCC_copyout},
165-
{OpenACCClauseKind::CopyIn, llvm::acc::Clause::ACCC_copyin},
166-
{OpenACCClauseKind::PCopyIn, llvm::acc::Clause::ACCC_copyin},
167-
{OpenACCClauseKind::PresentOrCopyIn, llvm::acc::Clause::ACCC_copyin},
168-
{OpenACCClauseKind::Create, llvm::acc::Clause::ACCC_create},
169-
{OpenACCClauseKind::PCreate, llvm::acc::Clause::ACCC_create},
170-
{OpenACCClauseKind::PresentOrCreate, llvm::acc::Clause::ACCC_create},
171-
{OpenACCClauseKind::Reduction, llvm::acc::Clause::ACCC_reduction},
172-
{OpenACCClauseKind::Collapse, llvm::acc::Clause::ACCC_collapse},
173-
{OpenACCClauseKind::Bind, llvm::acc::Clause::ACCC_bind},
174-
{OpenACCClauseKind::VectorLength, llvm::acc::Clause::ACCC_vector_length},
175-
{OpenACCClauseKind::NumGangs, llvm::acc::Clause::ACCC_num_gangs},
176-
{OpenACCClauseKind::NumWorkers, llvm::acc::Clause::ACCC_num_workers},
177-
{OpenACCClauseKind::DeviceNum, llvm::acc::Clause::ACCC_device_num},
178-
{OpenACCClauseKind::DefaultAsync, llvm::acc::Clause::ACCC_default_async},
179-
{OpenACCClauseKind::DeviceType, llvm::acc::Clause::ACCC_device_type},
180-
{OpenACCClauseKind::DType, llvm::acc::Clause::ACCC_device_type},
181-
{OpenACCClauseKind::Async, llvm::acc::Clause::ACCC_async},
182-
{OpenACCClauseKind::Tile, llvm::acc::Clause::ACCC_tile},
183-
{OpenACCClauseKind::Gang, llvm::acc::Clause::ACCC_gang},
184-
{OpenACCClauseKind::Wait, llvm::acc::Clause::ACCC_wait}};
185-
186-
llvm::acc::Clause getLLVMClauseFromClangClause(OpenACCClauseKind CK) {
187-
assert(CK != OpenACCClauseKind::Invalid);
188-
189-
auto *Res =
190-
llvm::find_if(ClauseEquivs, [=](auto Ref) { return CK == Ref.first; });
191-
assert(Res && "Unhandled clause kind");
192-
193-
return Res->second;
194-
}
68+
} // namespace
19569

196-
OpenACCClauseKind getClangClauseFromLLVMClause(llvm::acc::Clause CK) {
70+
// TODO: ERICH: WOULD NEED Own DIRECTIVE_CLAUSE_SETS
71+
#define GEN_CLANG_DIRECTIVE_CLAUSE_SETS
72+
#include "llvm/Frontend/OpenACC/ACC.inc"
19773

198-
auto *Res =
199-
llvm::find_if(ClauseEquivs, [=](auto Ref) { return CK == Ref.second; });
200-
assert(Res && "Unhandled clause kind");
74+
namespace {
20175

202-
return Res->first;
203-
}
76+
// TODO: ERIHC: WOULD NEED ON DIRECTIVE_CLAUSE_MAP
77+
LLVMDirectiveClauseRelationships Relations[] =
78+
#define GEN_CLANG_DIRECTIVE_CLAUSE_MAP
79+
#include "llvm/Frontend/OpenACC/ACC.inc"
80+
;
20481

20582
const LLVMClauseLists &getListsForDirective(OpenACCDirectiveKind DK) {
20683

@@ -220,13 +97,13 @@ std::string getListOfClauses(AccClauseSet Set) {
22097
std::string Output;
22198
llvm::raw_string_ostream OS{Output};
22299

223-
for (unsigned I = 0; I < llvm::acc::Clause_enumSize; ++I) {
224-
llvm::acc::Clause CurClause = static_cast<llvm::acc::Clause>(I);
100+
for (unsigned I = 0; I < static_cast<unsigned>(OpenACCClauseKind::Invalid);
101+
++I) {
102+
OpenACCClauseKind CurClause = static_cast<OpenACCClauseKind>(I);
225103
if (!Set.isSet(CurClause))
226104
continue;
227105

228-
OpenACCClauseKind NewCK = getClangClauseFromLLVMClause(CurClause);
229-
OS << '\'' << NewCK << '\'';
106+
OS << '\'' << CurClause << '\'';
230107

231108
Set.clearBit(CurClause);
232109

@@ -259,7 +136,7 @@ bool SemaOpenACC::DiagnoseRequiredClauses(
259136
return false;
260137

261138
for (auto *C : Clauses) {
262-
if (Lists.Required.isSet(getLLVMClauseFromClangClause(C->getClauseKind())))
139+
if (Lists.Required.isSet(C->getClauseKind()))
263140
return false;
264141
}
265142

@@ -277,9 +154,7 @@ bool SemaOpenACC::DiagnoseAllowedOnceClauses(
277154
return false;
278155

279156
const LLVMClauseLists &Lists = getListsForDirective(DK);
280-
llvm::acc::Clause LLVMClause = getLLVMClauseFromClangClause(CK);
281-
282-
if (!Lists.AllowedOnce.isSet(LLVMClause))
157+
if (!Lists.AllowedOnce.isSet(CK))
283158
return false;
284159

285160
auto Res = llvm::find_if(Clauses, [=](const OpenACCClause *C) {
@@ -302,17 +177,14 @@ bool SemaOpenACC::DiagnoseExclusiveClauses(
302177
if (DK == OpenACCDirectiveKind::Invalid || CK == OpenACCClauseKind::Invalid)
303178
return false;
304179

305-
llvm::acc::Clause LLVMClause = getLLVMClauseFromClangClause(CK);
306180
const LLVMClauseLists &Lists = getListsForDirective(DK);
307181

308182
// If this isn't on the list, this is fine.
309-
if (!Lists.AllowedExclusive.isSet(LLVMClause))
183+
if (!Lists.AllowedExclusive.isSet(CK))
310184
return false;
311185

312186
for (const OpenACCClause *C : Clauses) {
313-
llvm::acc::Clause ExistingLLVMClause =
314-
getLLVMClauseFromClangClause(C->getClauseKind());
315-
if (Lists.AllowedExclusive.isSet(ExistingLLVMClause)) {
187+
if (Lists.AllowedExclusive.isSet(C->getClauseKind())) {
316188
Diag(ClauseLoc, diag::err_acc_clause_cannot_combine)
317189
<< CK << C->getClauseKind() << DK;
318190
Diag(C->getBeginLoc(), diag::note_acc_previous_clause_here);
@@ -331,10 +203,9 @@ bool SemaOpenACC::DiagnoseAllowedClauses(OpenACCDirectiveKind DK,
331203
if (DK == OpenACCDirectiveKind::Invalid || CK == OpenACCClauseKind::Invalid)
332204
return false;
333205
const LLVMClauseLists &Lists = getListsForDirective(DK);
334-
llvm::acc::Clause Clause = getLLVMClauseFromClangClause(CK);
335206

336-
if (!Lists.Allowed.isSet(Clause) && !Lists.AllowedOnce.isSet(Clause) &&
337-
!Lists.AllowedExclusive.isSet(Clause) && !Lists.Required.isSet(Clause))
207+
if (!Lists.Allowed.isSet(CK) && !Lists.AllowedOnce.isSet(CK) &&
208+
!Lists.AllowedExclusive.isSet(CK) && !Lists.Required.isSet(CK))
338209
return Diag(ClauseLoc, diag::err_acc_clause_appertainment) << DK << CK;
339210

340211
return false;

‎llvm/utils/TableGen/Basic/DirectiveEmitter.cpp

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1072,6 +1072,14 @@ static void generateFlangClausesParser(const DirectiveLanguage &DirLang,
10721072
OS << ")\n";
10731073
}
10741074

1075+
// Generate the implementation section for the enumeration in the directive
1076+
// language
1077+
static void emitDirectivesClangImpl(const DirectiveLanguage &DirLang,
1078+
raw_ostream &OS) {
1079+
// Currently we only have work to do for OpenACC, so skip.
1080+
if (DirLang.getName() != "OpenACC")
1081+
return;
1082+
}
10751083
// Generate the implementation section for the enumeration in the directive
10761084
// language
10771085
static void emitDirectivesFlangImpl(const DirectiveLanguage &DirLang,
@@ -1211,6 +1219,8 @@ static void emitDirectivesImpl(const RecordKeeper &Records, raw_ostream &OS) {
12111219

12121220
emitDirectivesFlangImpl(DirLang, OS);
12131221

1222+
emitDirectivesClangImpl(DirLang, OS);
1223+
12141224
generateClauseClassMacro(DirLang, OS);
12151225

12161226
emitDirectivesBasicImpl(DirLang, OS);

0 commit comments

Comments
 (0)