1 /*
2 * Copyright (c) 2025-2026, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package hat.dialect;
26
27 import jdk.incubator.code.CodeContext;
28 import jdk.incubator.code.CodeTransformer;
29 import jdk.incubator.code.Op;
30 import jdk.incubator.code.TypeElement;
31 import jdk.incubator.code.Value;
32 import jdk.incubator.code.dialect.java.JavaType;
33 import optkl.util.ops.Precedence.LoadOrConv;
34
35 import java.util.List;
36
37 public abstract sealed class HATThreadOp extends HATOp implements Dim, LoadOrConv {
38
39 protected HATThreadOp(List<Value> operands) {
40 super(operands);
41 }
42
43 protected HATThreadOp(HATThreadOp that, CodeContext cc) {
44 super(that, cc);
45 }
46
47 @Override
48 public final TypeElement resultType() {
49 return JavaType.INT;
50 }
51
52 public static HATThreadOp create(String name) {
53 return switch (name) {
54 case "gix" -> new HATThreadOp.HAT_GI.HAT_GIX();
55 case "giy" -> new HATThreadOp.HAT_GI.HAT_GIY();
56 case "giz" -> new HATThreadOp.HAT_GI.HAT_GIZ();
57 case "gsx" -> new HATThreadOp.HAT_GS.HAT_GSX();
58 case "gsy" -> new HATThreadOp.HAT_GS.HAT_GSY();
59 case "gsz" -> new HATThreadOp.HAT_GS.HAT_GSZ();
60 case "lix" -> new HATThreadOp.HAT_LI.HAT_LIX();
61 case "liy" -> new HATThreadOp.HAT_LI.HAT_LIY();
62 case "liz" -> new HATThreadOp.HAT_LI.HAT_LIZ();
63 case "lsx" -> new HATThreadOp.HAT_LS.HAT_LSX();
64 case "lsy" -> new HATThreadOp.HAT_LS.HAT_LSY();
65 case "lsz" -> new HATThreadOp.HAT_LS.HAT_LSZ();
66 case "bix" -> new HATThreadOp.HAT_BI.HAT_BIX();
67 case "biy" -> new HATThreadOp.HAT_BI.HAT_BIY();
68 case "biz" -> new HATThreadOp.HAT_BI.HAT_BIZ();
69 case "bsx" -> new HATThreadOp.HAT_BS.HAT_BSX();
70 case "bsy" -> new HATThreadOp.HAT_BS.HAT_BSY();
71 case "bsz" -> new HATThreadOp.HAT_BS.HAT_BSZ();
72 default -> throw new RuntimeException("[ERROR] Illegal/unsupported parallel construct: " + name);
73 };
74 }
75
76 public abstract static sealed class HAT_LI extends HATThreadOp {
77
78 protected HAT_LI() {
79 super(List.of());
80 }
81
82 protected HAT_LI(HAT_LI op, CodeContext copyContext) {
83 super(op, copyContext);
84 }
85
86 public static final class HAT_LIX extends HAT_LI implements Dim.X {
87 public HAT_LIX(HAT_LIX op, CodeContext copyContext) {
88 super(op, copyContext);
89 }
90
91 public HAT_LIX() {
92 super();
93 }
94
95 @Override
96 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
97 return new HAT_LIX(this, copyContext);
98 }
99 }
100
101 public static final class HAT_LIY extends HAT_LI implements Dim.Y {
102 public HAT_LIY(HAT_LIY op, CodeContext copyContext) {
103 super(op, copyContext);
104 }
105
106 public HAT_LIY() {
107 super();
108 }
109
110 @Override
111 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
112 return new HAT_LIY(this, copyContext);
113 }
114 }
115
116 public static final class HAT_LIZ extends HAT_LI implements Dim.Z {
117 public HAT_LIZ(HAT_LI op, CodeContext copyContext) {
118 super(op, copyContext);
119 }
120
121 public HAT_LIZ() {
122 super();
123 }
124
125 @Override
126 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
127 return new HAT_LIZ(this, copyContext);
128 }
129 }
130 }
131
132 public abstract static sealed class HAT_BI extends HATThreadOp {
133 protected HAT_BI() {
134 super(List.of());
135 }
136
137 protected HAT_BI(HAT_BI op, CodeContext copyContext) {
138 super(op, copyContext);
139 }
140
141 public static final class HAT_BIX extends HAT_BI implements Dim.X {
142 public HAT_BIX(HAT_BI op, CodeContext copyContext) {
143 super(op, copyContext);
144 }
145
146 public HAT_BIX() {
147 super();
148 }
149
150 @Override
151 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
152 return new HAT_BIX(this, copyContext);
153 }
154 }
155
156 public static final class HAT_BIY extends HAT_BI implements Dim.Y {
157 public HAT_BIY(HAT_BI op, CodeContext copyContext) {
158 super(op, copyContext);
159 }
160
161 public HAT_BIY() {
162 super();
163 }
164
165 @Override
166 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
167 return new HAT_BIY(this, copyContext);
168 }
169 }
170
171 public static final class HAT_BIZ extends HAT_BI implements Dim.Z {
172 public HAT_BIZ(HAT_BI op, CodeContext copyContext) {
173 super(op, copyContext);
174 }
175
176 public HAT_BIZ() {
177 super();
178 }
179
180 @Override
181 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
182 return new HAT_BIZ(this, copyContext);
183 }
184 }
185 }
186
187 public abstract static sealed class HAT_BS extends HATThreadOp {
188
189 protected HAT_BS() {
190 super(List.of());
191 }
192
193 protected HAT_BS(HAT_BS op, CodeContext copyContext) {
194 super(op, copyContext);
195 }
196
197 public static final class HAT_BSX extends HAT_BS implements Dim.X {
198
199 public HAT_BSX(HAT_BS op, CodeContext copyContext) {
200 super(op, copyContext);
201 }
202
203 public HAT_BSX() {
204 super();
205 }
206
207 @Override
208 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
209 return new HAT_BSX(this, copyContext);
210 }
211 }
212
213 public static final class HAT_BSY extends HAT_BS implements Dim.Y {
214
215 public HAT_BSY(HAT_BS op, CodeContext copyContext) {
216 super(op, copyContext);
217 }
218
219 public HAT_BSY() {
220 super();
221 }
222
223 @Override
224 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
225 return new HAT_BSY(this, copyContext);
226 }
227
228 }
229
230 public static final class HAT_BSZ extends HAT_BS implements Dim.Z {
231
232 public HAT_BSZ(HAT_BS op, CodeContext copyContext) {
233 super(op, copyContext);
234 }
235
236 public HAT_BSZ() {
237 super();
238 }
239
240 @Override
241 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
242 return new HAT_BSZ(this, copyContext);
243 }
244 }
245 }
246
247 public abstract static sealed class HAT_LS extends HATThreadOp {
248
249 protected HAT_LS() {
250 super(List.of());
251 }
252
253 protected HAT_LS(HAT_LS op, CodeContext copyContext) {
254 super(op, copyContext);
255 }
256
257 public static final class HAT_LSX extends HAT_LS implements Dim.X {
258 public HAT_LSX(HAT_LS op, CodeContext copyContext) {
259 super(op, copyContext);
260 }
261
262 public HAT_LSX() {
263 super();
264 }
265
266 @Override
267 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
268 return new HAT_LSX(this, copyContext);
269 }
270 }
271
272 public static final class HAT_LSY extends HAT_LS implements Dim.Y {
273 public HAT_LSY(HAT_LS op, CodeContext copyContext) {
274 super(op, copyContext);
275 }
276
277 public HAT_LSY() {
278 super();
279 }
280
281 @Override
282 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
283 return new HAT_LSY(this, copyContext);
284 }
285 }
286
287 public static final class HAT_LSZ extends HAT_LS implements Dim.Z {
288 public HAT_LSZ(HAT_LS op, CodeContext copyContext) {
289 super(op, copyContext);
290 }
291
292 public HAT_LSZ() {
293 super();
294 }
295
296 @Override
297 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
298 return new HAT_LSZ(this, copyContext);
299 }
300 }
301 }
302
303 public abstract static sealed class HAT_GI extends HATThreadOp {
304
305 protected HAT_GI() {
306 super(List.of());
307 }
308
309 protected HAT_GI(HAT_GI op, CodeContext copyContext) {
310 super(op, copyContext);
311 }
312
313 public static final class HAT_GIX extends HAT_GI implements Dim.X {
314 public HAT_GIX(HAT_GI op, CodeContext copyContext) {
315 super(op, copyContext);
316 }
317
318 public HAT_GIX() {
319 super();
320 }
321
322 @Override
323 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
324 return new HAT_GIX(this, copyContext);
325 }
326 }
327
328 public static final class HAT_GIY extends HAT_GI implements Dim.Y {
329 public HAT_GIY(HAT_GI op, CodeContext copyContext) {
330 super(op, copyContext);
331 }
332
333 public HAT_GIY() {
334 super();
335 }
336
337 @Override
338 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
339 return new HAT_GIY(this, copyContext);
340 }
341 }
342
343 public static final class HAT_GIZ extends HAT_GI implements Dim.Z {
344 public HAT_GIZ(HAT_GI op, CodeContext copyContext) {
345 super(op, copyContext);
346 }
347
348 public HAT_GIZ() {
349 super();
350 }
351
352 @Override
353 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
354 return new HAT_GIZ(this, copyContext);
355 }
356 }
357 }
358
359 public abstract static sealed class HAT_GS extends HATThreadOp {
360
361 protected HAT_GS() {
362 super(List.of());
363 }
364
365 protected HAT_GS(HAT_GS op, CodeContext copyContext) {
366 super(op, copyContext);
367 }
368
369 public static final class HAT_GSX extends HAT_GS implements Dim.X {
370 public HAT_GSX(HAT_GS op, CodeContext copyContext) {
371 super(op, copyContext);
372 }
373
374 public HAT_GSX() {
375 super();
376 }
377
378 @Override
379 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
380 return new HAT_GSX(this, copyContext);
381 }
382 }
383
384 public static final class HAT_GSY extends HAT_GS implements Dim.Y {
385 public HAT_GSY(HAT_GS op, CodeContext copyContext) {
386 super(op, copyContext);
387 }
388
389 public HAT_GSY() {
390 super();
391 }
392
393 @Override
394 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
395 return new HAT_GSY(this, copyContext);
396 }
397 }
398
399 public static final class HAT_GSZ extends HAT_GS implements Dim.Z {
400 public HAT_GSZ(HAT_GS op, CodeContext copyContext) {
401 super(op, copyContext);
402 }
403
404 public HAT_GSZ() {
405 super();
406 }
407
408 @Override
409 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
410 return new HAT_GSZ(this, copyContext);
411 }
412 }
413 }
414 }