ae2f_docs
Loading...
Searching...
No Matches
expr.h
Go to the documentation of this file.
1/** @file expr.h */
2
3#ifndef lib_emit_expr_h
4#define lib_emit_expr_h
5
6#include <complex.h>
7#include <assert.h>
8
9#include <aclspv.h>
10
11#include <ae2f/Keys.h>
12#include <ae2f/c90/StdInt.h>
13#include <ae2f/c90/StdBool.h>
14
15#include <clang-c/Index.h>
16#include <clang-c/CXString.h>
17
18#include <util/ctx.h>
19#include <util/emitx.h>
20#include <util/iddef.h>
21#include <util/constant.h>
22#include <util/cursor.h>
23#include <util/fn.h>
24#include <util/scale.h>
25
26#include <spirv/unified1/spirv.h>
27
28
29static enum CXChildVisitResult emit_expr(
30 CXCursor h_cur,
31 CXCursor h_parent,
32 CXClientData h_ctx
33 );
34
35typedef enum EMIT_EXPR_BIN_1_ {
36
37 EMIT_EXPR_BIN_1_FAILURE,
38
39 /** succeed, value was not constant */
40 EMIT_EXPR_BIN_1_SUCCESS,
41
42 /** succeed, value was constant. */
43 EMIT_EXPR_BIN_1_SUCCESS_CONSTANT,
44 EMIT_EXPR_BIN_1_NOT_THE_CASE
45} e_emit_expr_bin_1_t;
46
47/**
48 * binary expression with 1 operators.
49 *
50 * @param c_id_scalar_for_cast
51 * if casting is needed, specify the type via here
52 * 0 for no casting
53 *
54 * */
55ae2f_inline static enum EMIT_EXPR_BIN_1_ emit_expr_bin_1(
56 const CXCursor c_cur,
57 const h_util_ctx_t h_ctx,
58 const aclspv_id_t c_newid,
59 e_id_default* ae2f_restrict const rdwr_type_req
60 ) {
61 union {
62 uintmax_t m_ull;
63 intmax_t m_ll;
64 double m_dbl;
65 float m_flt;
66 } EVRES;
67#define TYPE_NEW_REQ ((*rdwr_type_req))
68
69 struct {
70 unsigned m_is_constant : 1;
71 unsigned m_is_int : 1;
72 unsigned m_need_cast : 1;
73 } FLAGS;
74
75 FLAGS.m_is_constant = 0;
76 FLAGS.m_is_int = 0;
77
78 ae2f_expected_but_else(h_ctx)
79 return EMIT_EXPR_BIN_1_FAILURE;
80
81 switch((uintmax_t)c_cur.kind) {
82 /** unknown */
83 default:
84 return EMIT_EXPR_BIN_1_NOT_THE_CASE;
85
86 /** literals */
87
88 case CXCursor_IntegerLiteral:
89 case CXCursor_FloatingLiteral:
90 {
91 CXEvalResult EVAL = clang_Cursor_Evaluate(c_cur);
92 enum EMIT_EXPR_BIN_1_ RES = EMIT_EXPR_BIN_1_FAILURE;
93
94 /** no cleanup needed. init already fucked. */
95 ae2f_expected_but_else (EVAL) {
96 assert(0 && "EVAL is not running");
97 return EMIT_EXPR_BIN_1_FAILURE;
98 }
99
100 switch((uintmax_t)clang_EvalResult_getKind(EVAL)) {
101 case CXEval_Int:
102 EVRES.m_ull = clang_EvalResult_getAsUnsigned(EVAL);
103 if(TYPE_NEW_REQ && TYPE_NEW_REQ != ID_DEFAULT_U64) {
104 FLAGS.m_is_constant = 1;
105 FLAGS.m_is_int = 1;
106 FLAGS.m_need_cast = 1;
107 RES = EMIT_EXPR_BIN_1_SUCCESS_CONSTANT;
108 break;
109 } else {
110 TYPE_NEW_REQ = ID_DEFAULT_U64;
111 }
112
113
114
115 if(EVRES.m_ull <= UINT32_MAX) {
116 ae2f_expected_but_else(h_ctx->m_count.m_types = util_emitx_4(
117 &h_ctx->m_section.m_types
118 , h_ctx->m_count.m_types
119 , SpvOpConstant
120 , ID_DEFAULT_U32
121 , c_newid
122 , (aclspv_wrd_t)EVRES.m_ull
123 )) { assert(0); break; }
124
125 RES = EMIT_EXPR_BIN_1_SUCCESS_CONSTANT;
126 break;
127 }
128
129 ae2f_expected_but_else(util_get_default_id(ID_DEFAULT_U64, h_ctx)) {
130 assert(0);
131 break;
132 }
133
134 ae2f_expected_but_else(h_ctx->m_count.m_types = util_emitx_5(
135 &h_ctx->m_section.m_types
136 , h_ctx->m_count.m_types
137 , SpvOpConstant
138 , ID_DEFAULT_U64
139 , c_newid
140 , (aclspv_wrd_t)(EVRES.m_ull & 0xFFFFFFFF)
141 , (aclspv_wrd_t)((EVRES.m_ull >> 32) & 0xFFFFFFFF)
142 ))
143 {
144 assert(0);
145 break;
146 }
147
148 RES = EMIT_EXPR_BIN_1_SUCCESS_CONSTANT;
149 break;
150
151 case CXEval_Float:
152 EVRES.m_dbl = clang_EvalResult_getAsDouble(EVAL);
153 if(TYPE_NEW_REQ && TYPE_NEW_REQ != ID_DEFAULT_F64) {
154 FLAGS.m_is_constant = 1;
155 FLAGS.m_need_cast = 1;
156 RES = EMIT_EXPR_BIN_1_SUCCESS_CONSTANT;
157 break;
158 } else {
159 TYPE_NEW_REQ = ID_DEFAULT_F64;
160 }
161
162
163 ae2f_expected_but_else(util_get_default_id(ID_DEFAULT_F64, h_ctx)) {
164 RES = EMIT_EXPR_BIN_1_FAILURE;
165 break;
166 }
167
168 ae2f_expected_but_else(h_ctx->m_count.m_types = util_emitx_5(
169 &h_ctx->m_section.m_types
170 , h_ctx->m_count.m_types
171 , SpvOpConstant
172 , ID_DEFAULT_F64
173 , c_newid
174 , (aclspv_wrd_t)(EVRES.m_ull & 0xFFFFFFFF)
175 , (aclspv_wrd_t)((EVRES.m_ull >> 32) & 0xFFFFFFFF)
176 )) {
177 break;
178 }
179
180 RES = EMIT_EXPR_BIN_1_SUCCESS_CONSTANT;
181 break;
182 default:
183 assert(0 && "unknown evaluation");
184 break;
185 }
186
187 clang_EvalResult_dispose(EVAL);
188
189 if(FLAGS.m_need_cast && RES != EMIT_EXPR_BIN_1_FAILURE) {
190 break;
191 }
192 return RES;
193 }
194
195 case CXCursor_DeclRefExpr:
196 {
197 const CXCursor DECL = clang_getCursorReferenced(c_cur);
198 const aclspv_wrd_t DECL_IDX = util_find_cursor(
199 h_ctx->m_num_cursor
200 , h_ctx->m_cursors.m_p
201 , DECL
202 );
203
204 ae2f_expected_but_else(DECL_IDX < h_ctx->m_num_cursor)
205 return EMIT_EXPR_BIN_1_FAILURE;
206
207#define DECL_INFO DECL_IDX[((util_cursor* ae2f_restrict)h_ctx->m_cursors.m_p)]
208
209 /** NaN is undefined behaviour here */
210 unless(util_default_is_number(DECL_INFO.m_data.m_var_simple.m_type_id))
211 return EMIT_EXPR_BIN_1_FAILURE;
212
213 if(!TYPE_NEW_REQ || TYPE_NEW_REQ == DECL_INFO.m_data.m_var_simple.m_type_id) {
214 TYPE_NEW_REQ = DECL_INFO.m_data.m_var_simple.m_type_id;
215 ae2f_expected_but_else(h_ctx->m_count.m_fnimpl = util_emitx_4(
216 &h_ctx->m_section.m_fnimpl
217 , h_ctx->m_count.m_fnimpl
218 , SpvOpLoad
219 , DECL_INFO.m_data.m_var_simple.m_type_id
220 , c_newid
221 , DECL_INFO.m_data.m_var_simple.m_id
222 )) return EMIT_EXPR_BIN_1_FAILURE;
223 } else {
224 ae2f_expected_but_else(h_ctx->m_count.m_fnimpl = util_emitx_4(
225 &h_ctx->m_section.m_fnimpl
226 , h_ctx->m_count.m_fnimpl
227 , SpvOpLoad
228 , DECL_INFO.m_data.m_var_simple.m_type_id
229 , h_ctx->m_id++
230 , DECL_INFO.m_data.m_var_simple.m_id
231 )) return EMIT_EXPR_BIN_1_FAILURE;
232
233 if(
234 util_default_bit_width(TYPE_NEW_REQ)
235 != util_default_bit_width(DECL_INFO.m_data.m_var_simple.m_type_id))
236 {
237#define IS_FLT util_default_is_float(DECL_INFO.m_data.m_var_simple.m_type_id)
238#define BWIDTH util_default_bit_width(TYPE_NEW_REQ)
239#define OPCODE IS_FLT ? SpvOpFConvert : SpvOpUConvert
240#define NEWTYPEGEN (IS_FLT ? util_default_float : util_default_unsigned)(BWIDTH)
241
242 ae2f_expected_but_else(h_ctx->m_count.m_fnimpl = util_emitx_4(
243 &h_ctx->m_section.m_fnimpl
244 , h_ctx->m_count.m_fnimpl
245 , OPCODE
246 , NEWTYPEGEN
247 , h_ctx->m_id
248 , h_ctx->m_id - 1
249 )) return EMIT_EXPR_BIN_1_FAILURE;
250 ++h_ctx->m_id;
251#undef NEWTYPEGEN
252#undef BWIDTH
253#undef IS_FLT
254#undef OPCODE
255 }
256
257#define IS_FLT util_default_is_float(TYPE_NEW_REQ)
258#define OPCODE IS_FLT ? SpvOpConvertSToF : SpvOpConvertFToS
259 ae2f_expected_but_else(h_ctx->m_count.m_fnimpl = util_emitx_4(
260 &h_ctx->m_section.m_fnimpl
261 , h_ctx->m_count.m_fnimpl
262 , OPCODE
263 , TYPE_NEW_REQ
264 , c_newid
265 , h_ctx->m_id - 1
266 )) return EMIT_EXPR_BIN_1_FAILURE;
267#undef OPCODE
268#undef IS_FLT
269
270 }
271#undef DECL_INFO
272 }
273
274 return EMIT_EXPR_BIN_1_SUCCESS;
275 }
276
277 /** casting logic */
278 unless(FLAGS.m_is_constant) {
279 assert(0 && "not constant");
280 return EMIT_EXPR_BIN_1_FAILURE;
281 }
282
283 unless(util_get_default_id(TYPE_NEW_REQ, h_ctx)) {
284 assert(0 && "requested type is not default maybe");
285 return EMIT_EXPR_BIN_1_FAILURE;
286 }
287
288 switch(TYPE_NEW_REQ) {
289 {
290 aclspv_wrd_t MASK;
291
292 ae2f_unexpected_but_if(0) {
293 ae2f_unreachable();
294 case ID_DEFAULT_U8:
295 MASK = 0xFF;
296 unless(FLAGS.m_is_int)
297 EVRES.m_ll = (intmax_t)EVRES.m_dbl;
298
299 EVRES.m_ll = (char)EVRES.m_ll;
300 }
301
302 ae2f_unexpected_but_if(0) {
303 ae2f_unreachable();
304 case ID_DEFAULT_U16:
305 MASK = 0xFFFF;
306 unless(FLAGS.m_is_int)
307 EVRES.m_ll = (intmax_t)EVRES.m_dbl;
308
309 EVRES.m_ll = (short)EVRES.m_ll;
310 }
311
312 ae2f_unexpected_but_if(0) {
313 ae2f_unreachable();
314 case ID_DEFAULT_U32:
315 case ID_DEFAULT_I32:
316 MASK = 0xFFFFFFFF;
317 unless(FLAGS.m_is_int)
318 EVRES.m_ll = (intmax_t)EVRES.m_dbl;
319
320 EVRES.m_ll = (int)EVRES.m_ll;
321 }
322
323 ae2f_unexpected_but_if(0) {
324 ae2f_unreachable();
325 case ID_DEFAULT_F32:
326 MASK = 0xFFFFFFFF;
327 if(FLAGS.m_is_int)
328 EVRES.m_flt = (float)EVRES.m_ll;
329 else
330 EVRES.m_flt = (float)EVRES.m_dbl;
331 }
332
333 ae2f_expected_but_else(h_ctx->m_count.m_types = util_emitx_4(
334 &h_ctx->m_section.m_types
335 , h_ctx->m_count.m_types
336 , SpvOpConstant
337 , TYPE_NEW_REQ
338 , c_newid
339 , (aclspv_wrd_t)EVRES.m_ull & MASK
340 )) { return EMIT_EXPR_BIN_1_FAILURE; }
341 } return EMIT_EXPR_BIN_1_SUCCESS_CONSTANT;
342
343 ae2f_unexpected_but_if(0) {
344 ae2f_unreachable();
345 case ID_DEFAULT_F64:
346 if(FLAGS.m_is_int)
347 EVRES.m_dbl = (double)EVRES.m_ull;
348 }
349
350 ae2f_unexpected_but_if(0) {
351 ae2f_unreachable();
352 case ID_DEFAULT_U64:
353 unless(FLAGS.m_is_int)
354 EVRES.m_ll = (intmax_t)EVRES.m_dbl;
355 }
356
357 ae2f_expected_but_else(h_ctx->m_count.m_types = util_emitx_5(
358 &h_ctx->m_section.m_types
359 , h_ctx->m_count.m_types
360 , SpvOpConstant
361 , ID_DEFAULT_F64
362 , c_newid
363 , (aclspv_wrd_t)(EVRES.m_ull & 0xFFFFFFFF)
364 , (aclspv_wrd_t)((EVRES.m_ull >> 32) & 0xFFFFFFFF)
365 )) return EMIT_EXPR_BIN_1_FAILURE;
366 return EMIT_EXPR_BIN_1_SUCCESS_CONSTANT;
367
368 case ID_DEFAULT_F16:
369 unless(util_get_default_id(ID_DEFAULT_F32, h_ctx)) {
370 assert(0);
371 return EMIT_EXPR_BIN_1_FAILURE;
372 }
373
374 if(FLAGS.m_is_int)
375 EVRES.m_flt = (float)EVRES.m_ull;
376 else
377 EVRES.m_flt = (float)EVRES.m_dbl;
378
379 ae2f_expected_but_else(h_ctx->m_count.m_types = util_emitx_4(
380 &h_ctx->m_section.m_types
381 , h_ctx->m_count.m_types
382 , SpvOpConstant
383 , ID_DEFAULT_F32
384 , h_ctx->m_id
385 , (aclspv_wrd_t)EVRES.m_ull & 0xFFFFFFFF
386 )) { assert(0); return EMIT_EXPR_BIN_1_FAILURE; }
387
388 ae2f_expected_but_else(h_ctx->m_count.m_types = util_emitx_4(
389 &h_ctx->m_section.m_types
390 , h_ctx->m_count.m_types
391 , SpvOpSpecConstantOp
392 , ID_DEFAULT_F16
393 , c_newid
394 , h_ctx->m_id
395 )) { assert(0); return EMIT_EXPR_BIN_1_FAILURE; }
396
397 ++h_ctx->m_id;
398 return EMIT_EXPR_BIN_1_SUCCESS_CONSTANT;
399
400 /** literals? for these? seriously? */
401 case ID_DEFAULT_I32_PTR_FUNC:
402 case ID_DEFAULT_U8_PTR_FUNC:
403 case ID_DEFAULT_U16_PTR_FUNC:
404 case ID_DEFAULT_U32_PTR_FUNC:
405 case ID_DEFAULT_U64_PTR_FUNC:
406 case ID_DEFAULT_U32V4_PTR_INP:
407 case ID_DEFAULT_U32V4_PTR_OUT:
408 case ID_DEFAULT_END:
409 case ID_DEFAULT_FN_VOID:
410 case ID_DEFAULT_VOID:
411 case ID_DEFAULT_F16_PTR_FUNC:
412 case ID_DEFAULT_F32_PTR_FUNC:
413 case ID_DEFAULT_F64_PTR_FUNC:
414 default:
415 assert(0 && "unsuppported");
416 return EMIT_EXPR_BIN_1_FAILURE;
417 }
418}
419
420
421#if 1
422ae2f_inline static enum EMIT_EXPR_BIN_1_ emit_expr_bin_2(
423 const CXCursor c_cur,
424 const h_util_ctx_t h_ctx,
425 const aclspv_id_t c_newid,
426 const aclspv_id_t c_result_type_id,
427 x_aclspv_vec* ae2f_restrict const h_cmdscale,
428 aclspv_id_t wr_operands[2]
429 )
430{
431
432 x_scale* ae2f_restrict NEW_SCALE;
433 aclspv_wrd_t OPCODE;
434 ae2f_expected_but_else(h_ctx) {
435 assert(0 && "emit_expr_bin_2::h_ctx is null");
436 return EMIT_EXPR_BIN_1_FAILURE;
437 }
438
439 switch((umax)c_cur.kind) {
440 default:
441 return EMIT_EXPR_BIN_1_NOT_THE_CASE;
442
443 case CXCursor_BinaryOperator:
444 case CXCursor_CompoundAssignOperator:
445 break;
446 }
447
448 switch((uintmax_t)clang_getCursorBinaryOperatorKind(c_cur)) {
449 default:
450 return EMIT_EXPR_BIN_1_NOT_THE_CASE;
451
452 case CXBinaryOperator_Add:
453 switch(c_result_type_id) {
454 case 0:
455 case ID_DEFAULT_U8:
456 case ID_DEFAULT_U16:
457 case ID_DEFAULT_U32:
458 case ID_DEFAULT_U64:
459 case ID_DEFAULT_I32:
460 OPCODE = SpvOpIAdd;
461 break;
462
463 case ID_DEFAULT_F16:
464 case ID_DEFAULT_F32:
465 case ID_DEFAULT_F64:
466 OPCODE = SpvOpFAdd;
467 break;
468
469 default:
470 /** not supported */
471 assert(0 && "no support::add");
472 return EMIT_EXPR_BIN_1_FAILURE;
473 } break;
474
475 case CXBinaryOperator_Sub:
476 switch(c_result_type_id) {
477 case ID_DEFAULT_U8:
478 case ID_DEFAULT_U16:
479 case ID_DEFAULT_U32:
480 case ID_DEFAULT_U64:
481 case ID_DEFAULT_I32:
482 OPCODE = SpvOpISub;
483 break;
484
485 case ID_DEFAULT_F16:
486 case ID_DEFAULT_F32:
487 case ID_DEFAULT_F64:
488 OPCODE = SpvOpFSub;
489 break;
490
491 default:
492 /** not supported */
493 assert(0 && "no support::sub");
494 return EMIT_EXPR_BIN_1_FAILURE;
495 } break;
496
497 case CXBinaryOperator_Mul:
498 switch(c_result_type_id) {
499 case ID_DEFAULT_U8:
500 case ID_DEFAULT_U16:
501 case ID_DEFAULT_U32:
502 case ID_DEFAULT_U64:
503 case ID_DEFAULT_I32:
504 OPCODE = SpvOpIMul;
505 break;
506
507 case ID_DEFAULT_F16:
508 case ID_DEFAULT_F32:
509 case ID_DEFAULT_F64:
510 OPCODE = SpvOpFMul;
511 break;
512
513 default:
514 /** not supported */
515 assert(0 && "no support::mul");
516 return EMIT_EXPR_BIN_1_FAILURE;
517 } break;
518
519 case CXBinaryOperator_Div:
520 switch(c_result_type_id) {
521 case ID_DEFAULT_U8:
522 case ID_DEFAULT_U16:
523 case ID_DEFAULT_U32:
524 case ID_DEFAULT_U64:
525 OPCODE = SpvOpUDiv;
526 break;
527
528 case ID_DEFAULT_I32:
529 OPCODE = SpvOpSDiv;
530 break;
531
532 case ID_DEFAULT_F16:
533 case ID_DEFAULT_F32:
534 case ID_DEFAULT_F64:
535 OPCODE = SpvOpFDiv;
536 break;
537
538 default:
539 /** not supported */
540 assert(0 && "no support::div");
541 return EMIT_EXPR_BIN_1_FAILURE;
542 } break;
543
544 case CXBinaryOperator_Rem:
545 switch(c_result_type_id) {
546 case ID_DEFAULT_U8:
547 case ID_DEFAULT_U16:
548 case ID_DEFAULT_U32:
549 case ID_DEFAULT_U64:
550 OPCODE = SpvOpUMod;
551 break;
552
553 case ID_DEFAULT_I32:
554 OPCODE = SpvOpSRem;
555 break;
556
557 default:
558 /** not supported */
559 assert(0 && "no support::rem");
560 return EMIT_EXPR_BIN_1_FAILURE;
561 } break;
562 }
563
564
565 {
566 aclspv_wrd_t* ae2f_restrict VEC;
567 NEW_SCALE = mk_scale_from_vec(h_cmdscale, count_to_sz(8));
568 ae2f_expected_but_else(NEW_SCALE)
569 return EMIT_EXPR_BIN_1_FAILURE;
570
571 VEC = get_buf_from_scale2(aclspv_wrd_t, h_cmdscale, *NEW_SCALE);
572
573 ae2f_expected_but_else(VEC)
574 return EMIT_EXPR_BIN_1_FAILURE;
575
576 if(c_newid == h_ctx->m_id)
577 ++h_ctx->m_id;
578
579 VEC[0] = 2; /** number of operands */
580 VEC[1] = 0; /** is not constant? */
581 VEC[2] = opcode_to_wrd(SpvOpSpecConstantOp, 5);
582 VEC[3] = c_result_type_id;
583 VEC[4] = c_newid;
584 VEC[5] = OPCODE;
585 VEC[6] = h_ctx->m_id++;
586 VEC[7] = h_ctx->m_id++;
587
588 if(wr_operands) {
589 wr_operands[0] = VEC[6];
590 wr_operands[1] = VEC[7];
591 }
592 }
593
594 return EMIT_EXPR_BIN_1_SUCCESS_CONSTANT;
595}
596
597ae2f_inline static aclspv_id_t emit_expr_type(const CXType type, const h_util_ctx_t CTX)
598{
599 aclspv_id_t TYPE_ID = 0;
600
601 switch((uintmax_t)type.kind) {
602 case CXType_Int:
603 case CXType_UInt:
604 TYPE_ID = util_get_default_id(ID_DEFAULT_U32, CTX);
605 break;
606
607 case CXType_Short:
608 case CXType_UShort:
609 TYPE_ID = util_get_default_id(ID_DEFAULT_U16, CTX);
610 break;
611
612 case CXType_SChar:
613 case CXType_UChar:
614 TYPE_ID = util_get_default_id(ID_DEFAULT_U8, CTX);
615 break;
616
617 case CXType_Float:
618 TYPE_ID = util_get_default_id(ID_DEFAULT_F32, CTX);
619 break;
620
621 case CXType_Double:
622 TYPE_ID = util_get_default_id(ID_DEFAULT_F64, CTX);
623 break;
624
625 case CXType_Long:
626 case CXType_ULong:
627 case CXType_LongLong:
628 case CXType_ULongLong:
629 TYPE_ID = util_get_default_id(ID_DEFAULT_U64, CTX);
630 break;
631
632 default:
633 TYPE_ID = 0;
634 break;
635 }
636
637 return TYPE_ID;
638}
639#endif
640
641static enum CXChildVisitResult emit_expr(
642 CXCursor h_cur,
643 CXCursor h_parent,
644 CXClientData rdwr_data
645 )
646{
647#define CTX ((h_util_ctx_t)(((uptr* ae2f_restrict)rdwr_data)[0]))
648#define STCK_COUNT ((uptr* ae2f_restrict)(rdwr_data))[1]
649#define ID_REQ ((aclspv_wrd_t)(((uptr* ae2f_restrict)(rdwr_data))[2]))
650#define IS_NOT_CONSTANT ((uptr* ae2f_restrict)(rdwr_data))[3]
651#define TYPE_REQUIRED (((uptr* ae2f_restrict)(rdwr_data))[4])
652#define COUNTER_OPRND (((uptr* ae2f_restrict)(rdwr_data))[5])
653
654 /** for stack tmp.m_v0 will be used. */
655#define STCK CTX->m_tmp.m_v0
656#define CMDSTCK_SCALE CTX->m_tmp.m_v1
657 h_scale_t LST_SCALE = get_last_scale_from_vec(&CMDSTCK_SCALE);
658 aclspv_wrd_t* ae2f_restrict LST_SCALE_BUF = get_buf_from_scale2(aclspv_wrd_t, &CMDSTCK_SCALE, *LST_SCALE);
659 aclspv_id_t ID_REQ_CURRENT = ID_REQ;
660
661 if(STCK_COUNT) {
662 ae2f_expected_but_else(STCK.m_p) {
663 CTX->m_err = ACLSPV_COMPILE_ALLOC_FAILED;
664 assert(0 && "stack is acting funny");
665 return CXChildVisit_Break;
666 }
667
668 ID_REQ_CURRENT = get_wrd_of_vec(&STCK)[STCK_COUNT - 1];
669 }
670
671 ae2f_expected_but_else(LST_SCALE_BUF) {
672 CTX->m_err = ACLSPV_COMPILE_ALLOC_FAILED;
673 return CXChildVisit_Break;
674 }
675
676 {
677 const CXString SPELL = clang_getCursorSpelling(h_cur);
678 const CXString KINDSPELL = clang_getCursorKindSpelling(h_cur.kind);
679 printf("EMITEXPR(%u) STACK(%lu) LST_SCALE_BUF(%lu %u): ", ID_REQ_CURRENT, STCK_COUNT, LST_SCALE->m_id, LST_SCALE_BUF[0]);
680 puts(SPELL.data);
681 puts(KINDSPELL.data);
682 clang_disposeString(SPELL);
683 clang_disposeString(KINDSPELL);
684
685#if 0
686 return CXChildVisit_Recurse;
687#endif
688 }
689
690 (void)h_parent;
691
692 switch(emit_expr_bin_1(h_cur, CTX, ID_REQ_CURRENT, (e_id_default* ae2f_restrict)&TYPE_REQUIRED)) {
693 case EMIT_EXPR_BIN_1_FAILURE:
694 assert(0 && "bin_1 is fishy");
695 return CXChildVisit_Break;
696
697 case EMIT_EXPR_BIN_1_SUCCESS:
698 IS_NOT_CONSTANT = 1;
699 LST_SCALE_BUF[1] = 1;
700 ae2f_fallthrough;
701
702 case EMIT_EXPR_BIN_1_SUCCESS_CONSTANT:
703 (void)(STCK_COUNT && --STCK_COUNT);
704 ++COUNTER_OPRND;
705 while(LST_SCALE->m_id && COUNTER_OPRND == LST_SCALE_BUF[0]) {
706 puts("SPOTTED!!");
707 get_buf_from_scale2(aclspv_wrd_t, &CMDSTCK_SCALE, *get_prv_from_scale(&CMDSTCK_SCALE, *LST_SCALE))[1]
708 |= LST_SCALE_BUF[1];
709
710 if(LST_SCALE_BUF[1]) {
711#define XORSWAP(a, b) (a) ^= (b); (b) ^= (a); (a) ^= (b);
712 /**
713 * here, operation is not constant.
714 *
715 * current
716 * [2] OpSpecConstant opcode (ignorance required)
717 * [3] result type
718 * [4] result id
719 * [5] literal opcode (opspecconstant evaluation)
720 * ...
721 *
722 *
723 * we want
724 * [3] opcode with operand count
725 * [4] result type
726 * [5] result id
727 * */
728 (void)LST_SCALE_BUF[2];
729
730 /**
731 * swap [3] and [5]
732 *
733 * after this will
734 * [3] literal opcode (without operand)
735 * [4] result id
736 * [5] result type
737 * * */
738 XORSWAP(LST_SCALE_BUF[3], LST_SCALE_BUF[5]);
739
740 /** we have four operands (including opcode) */
741 LST_SCALE_BUF[3] |= mk_noprnds(4);
742
743 /**
744 * swap [4] and [5].
745 *
746 * after this will
747 * [3] opcode
748 * [4] result type
749 * [5] result id
750 *
751 * that matches what we want.
752 * */
753 XORSWAP(LST_SCALE_BUF[4], LST_SCALE_BUF[5]);
754#undef XORSWAP
755 }
756
757#define TMPL_SECTION (*(IS_NOT_CONSTANT ? &CTX->m_section.m_fnimpl : &CTX->m_section.m_types))
758#define TMPL_COUNT (*(IS_NOT_CONSTANT ? &CTX->m_count.m_fnimpl : &CTX->m_count.m_types))
759
760 _aclspv_grow_vec_with_copy(
761 _aclspv_malloc
762 , _aclspv_free
763 , memcpy
764 , L_new
765 , TMPL_SECTION
766 , count_to_sz(TMPL_COUNT + sz_to_count(LST_SCALE->m_sz) - 2 - LST_SCALE_BUF[1])
767 );
768
769 ae2f_expected_but_else(TMPL_SECTION.m_p) {
770 CTX->m_err = ACLSPV_COMPILE_ALLOC_FAILED;
771 return CXChildVisit_Break;
772 }
773
774 memcpy(
775 get_wrd_of_vec(&TMPL_SECTION) + TMPL_COUNT
776 , LST_SCALE_BUF + 2 + LST_SCALE_BUF[1]
777 , LST_SCALE->m_sz - count_to_sz(2 + (aclspv_wrd_t)LST_SCALE_BUF[1])
778 );
779
780 TMPL_COUNT += sz_to_count(LST_SCALE->m_sz) - 2 - LST_SCALE_BUF[1];
781#undef TMPL_SECTION
782#undef TMPL_COUNT
783
784 del_scale_from_vec_last(&CMDSTCK_SCALE);
785 LST_SCALE = get_last_scale_from_vec(&CMDSTCK_SCALE);
786 LST_SCALE_BUF = get_buf_from_scale2(aclspv_wrd_t, &CMDSTCK_SCALE, *LST_SCALE);
787
788 COUNTER_OPRND = 1;
789 STCK_COUNT -= LST_SCALE_BUF[0] - 1;
790 } return CXChildVisit_Recurse;
791 case EMIT_EXPR_BIN_1_NOT_THE_CASE:
792 break;
793 default:
794 ae2f_unreachable();
795 }
796
797 {
798 aclspv_wrd_t OPRNDS[2];
799 switch(emit_expr_bin_2(
800 h_cur
801 , CTX
802 , ID_REQ_CURRENT
803 , (aclspv_wrd_t)TYPE_REQUIRED
804 , &CMDSTCK_SCALE, OPRNDS))
805 {
806 case EMIT_EXPR_BIN_1_FAILURE:
807 assert(0 && "FAILURE_expr_bin2");
808 return CXChildVisit_Break;
809
810 case EMIT_EXPR_BIN_1_SUCCESS:
811 case EMIT_EXPR_BIN_1_SUCCESS_CONSTANT:
812 printf("OPERANDS %u %u\n", OPRNDS[0], OPRNDS[1]);
813
814 ae2f_expected_but_else(STCK_COUNT = util_emit_wrd(
815 &STCK, (aclspv_wrd_t)STCK_COUNT + 1
816 , OPRNDS[0])) {
817 CTX->m_err = ACLSPV_COMPILE_ALLOC_FAILED;
818 return CXChildVisit_Break;
819 }
820
821 get_wrd_of_vec(&STCK)[STCK_COUNT - 2] = OPRNDS[1];
822
823
824 ae2f_fallthrough;
825 case EMIT_EXPR_BIN_1_NOT_THE_CASE:
826 break;
827 default:
828 ae2f_unreachable();
829 }
830 }
831
832 CTX->m_err = ACLSPV_COMPILE_OK;
833 return CXChildVisit_Recurse;
834
835#undef CTX
836#undef STCK_COUNT
837#undef STCK
838#undef CMDSTCK_SCALE
839#undef ID_REQ
840}
841
842ae2f_inline static int emit_get_expr(const aclspv_id_t c_id_req, const aclspv_id_t c_type_req, const CXCursor c_cur, h_util_ctx_t h_ctx) {
843 uptr BUF[6];
844 aclspv_wrd_t* ae2f_restrict SCALE_BOOT;
845
846 BUF[0] = (uptr)h_ctx; /* context. must be pointer to context. */
847 BUF[1] = 0; /* stack count. must be 0. */
848 BUF[2] = c_id_req; /* result value id requested */
849 BUF[3] = 0; /* is-not-constant. must be 0. */
850 BUF[4] = c_type_req ? c_type_req : ID_DEFAULT_U32; /* type required */
851 BUF[5] = 0; /* count for operand */
852
853 puts("HERE IS YOUR CALL");
854
855 _aclspv_grow_vec(_aclspv_malloc, _aclspv_free, h_ctx->m_tmp.m_v0, 100);
856 ae2f_expected_but_else(h_ctx->m_tmp.m_v0.m_p)
857 return 1;
858
859 ae2f_expected_but_else(init_scale(&h_ctx->m_tmp.m_v1, 2))
860 return 1;
861
862 SCALE_BOOT = get_buf_from_scale2(aclspv_wrd_t, &h_ctx->m_tmp.m_v1, *get_last_scale_from_vec(&h_ctx->m_tmp.m_v1));
863 assert(SCALE_BOOT);
864 SCALE_BOOT[0] = 0;
865 SCALE_BOOT[1] = 0;
866
867 if(emit_expr(c_cur, c_cur, BUF) == CXChildVisit_Break)
868 return 1;
869
870 ae2f_expected_but_else(h_ctx->m_tmp.m_v0.m_p)
871 return 1;
872
873 ae2f_expected_but_else(h_ctx->m_tmp.m_v1.m_p)
874 return 1;
875
876 clang_visitChildren(c_cur, emit_expr, BUF);
877
878 return (int)h_ctx->m_err;
879}
880
881#endif
ae2f_IS_SHARED
#define ae2f_IS_SHARED
Definition Call.auto.h:12
ae2f_OFF
#define ae2f_OFF
Definition Call.auto.h:3
ae2f_WhenCXX
#define ae2f_WhenCXX(a)
Appears when the current language is C.
Definition Cxx.h:44
ae2f_WhenC
#define ae2f_WhenC(a)
Appears when the current language is C++.
Definition Cxx.h:38
unless
#define unless(a)
Invokes when condition is false.
Definition Keys.h:34
ae2f_extern
#define ae2f_extern
Suggests the existence of external variable or function, in naming of C. [non-mangling].
Definition Keys.h:25
ae2f_NIL
#define ae2f_NIL
Definition Nil.h:13
uptr
#define uptr
Definition StdInt.h:332
umax
#define umax
Definition StdInt.h:324
ACLSPV_ABI_DECL
#define ACLSPV_ABI_DECL
Declaration as ABI.
Definition abi.h:23
STATE_VAL
#define STATE_VAL
FNINFO
#define FNINFO
cpysz
#define cpysz
cpypad
#define cpypad
ae2f_retnew
#define ae2f_retnew
The returning pointer does not alias to existing object.
Definition cc.h:94
ae2f_assume
#define ae2f_assume(a)
tells the compiler that value if a is false, below this keyword is not expected to be reached.
Definition cc.h:228
ae2f_unexpected_but_if
#define ae2f_unexpected_but_if(a)
Definition cc.h:192
ae2f_ccpure
#define ae2f_ccpure
Keyword as [[pure]] on C23.
Definition cc.h:52
ae2f_expected_but_else
#define ae2f_expected_but_else(a)
Definition cc.h:201
ae2f_expected_if
#define ae2f_expected_if(a)
Definition cc.h:195
ae2f_ccconst
#define ae2f_ccconst
Keyword as [[const]] on C23..
Definition cc.h:66
ae2f_noexcept
#define ae2f_noexcept
marker that this function does not throw something.
Definition cc.h:133
ae2f_restrict
#define ae2f_restrict
Keyword as restrict on C99.
Definition cc.h:81
ae2f_expected_not
#define ae2f_expected_not(a)
expectes a as false.
Definition cc.h:185
ae2f_unreachable
#define ae2f_unreachable()
tells the compiler that below this keyword is not expected to be reached.
Definition cc.h:213
ae2f_fallthrough
#define ae2f_fallthrough
explicitly tells compiler that fallthrough on switch is expected.
Definition cc.h:164
ae2f_inline
#define ae2f_inline
inline
Definition cc.h:149
ae2f_expected
#define ae2f_expected(a)
expectes a as true.
Definition cc.h:184
wrd_caps
#define wrd_caps
Definition conf.h:11
wrd_caps_count
#define wrd_caps_count
Definition conf.h:12
wrd_ext
#define wrd_ext
Definition conf.h:14
wrd_ext_count
#define wrd_ext_count
Definition conf.h:15
THIS_FUNCTION
#define THIS_FUNCTION
CTX
#define CTX
THIS_ENTRY_POINT
#define THIS_ENTRY_POINT
CURSORDATA
#define CURSORDATA
ARG_IDX
#define ARG_IDX
INTERFACES_MGR
#define INTERFACES_MGR
EMIT_POS
#define EMIT_POS
IO_ARG_IDX
#define IO_ARG_IDX
INTERFACE_COUNT
#define INTERFACE_COUNT
PUSH_SIZE
#define PUSH_SIZE
PSH_CONSTANT_ID
#define PSH_CONSTANT_ID
THIS_ENTP
#define THIS_ENTP
INFO
#define INFO
BIND_IDX
#define BIND_IDX
util_emitx_spec_constant
#define util_emitx_spec_constant(h_wrds, c_wrdcount, c_ty, c_retid, c_val)
Definition emitx.h:140
util_emitx_variable
#define util_emitx_variable(h_wrds, c_wrdcount, c_type, c_retid, c_storage_class)
Definition emitx.h:131
util_emitx_spec_constant_op2
#define util_emitx_spec_constant_op2(h_wrds, c_wrdcount, c_retid, c_ty, c_operator, c_opr_0, c_opr_1)
Definition emitx.h:146
util_emitx_type_array
#define util_emitx_type_array(h_wrds, c_wrdcount, c_retid, c_elm_type_id, c_arrcount_id)
Definition emitx.h:137
util_emitx_type_pointer
#define util_emitx_type_pointer(h_wrds, c_wrdcount, c_retid, c_storage_class, c_elm_type_id)
Definition emitx.h:134
___mkname_on_dbg
#define ___mkname_on_dbg(c_ID)
Definition entp_body.h:33
jmpfail
#define jmpfail(c_why)
CURSOR
#define CURSOR
DECL_INFO
#define DECL_INFO
STCK
#define STCK
CMDSTCK_SCALE
#define CMDSTCK_SCALE
STCK_COUNT
#define STCK_COUNT
COUNTER_OPRND
#define COUNTER_OPRND
XORSWAP
#define XORSWAP(a, b)
IS_NOT_CONSTANT
#define IS_NOT_CONSTANT
TMPL_SECTION
#define TMPL_SECTION
OPCODE
#define OPCODE
TYPE_REQUIRED
#define TYPE_REQUIRED
TMPL_COUNT
#define TMPL_COUNT
EMIT_EXPR_BIN_1_
EMIT_EXPR_BIN_1_
Definition expr.h:35
EMIT_EXPR_BIN_1_SUCCESS_CONSTANT
@ EMIT_EXPR_BIN_1_SUCCESS_CONSTANT
Definition expr.h:43
EMIT_EXPR_BIN_1_SUCCESS
@ EMIT_EXPR_BIN_1_SUCCESS
Definition expr.h:40
ID_REQ
#define ID_REQ
TYPE_NEW_REQ
#define TYPE_NEW_REQ
NEWTYPEGEN
#define NEWTYPEGEN
ret_count
#define ret_count
get_buf_from_scale
#define get_buf_from_scale(h_alloc, c_scale)
Definition scale.h:34
get_last_scale_from_vec
#define get_last_scale_from_vec(h_alloc)
Definition scale.h:31
get_prv_from_scale
#define get_prv_from_scale(h_alloc, c_scale)
Definition scale.h:45
SCALE_HEADER_SIZE
#define SCALE_HEADER_SIZE
Definition scale.h:25
get_first_scale_from_vec
#define get_first_scale_from_vec(h_alloc)
Definition scale.h:29
get_nxt_from_scale
#define get_nxt_from_scale(h_alloc, c_scale)
Definition scale.h:42
get_scale_header_from_vec
#define get_scale_header_from_vec(h_alloc)
Definition scale.h:28
get_buf_from_scale2
#define get_buf_from_scale2(buf_T, h_alloc, c_scale)
Definition scale.h:39
aclspv_opcode_t
#define aclspv_opcode_t
integer as operation code
Definition spvty.h:27
aclspv_wrdcount_t
aclspv_wrd_t aclspv_wrdcount_t
the integer type represents the number of word.
Definition spvty.h:61
ACLSPV_MASK_OPCODE
#define ACLSPV_MASK_OPCODE
mask for opcode
Definition spvty.h:37
aclspv_wrd_t
#define aclspv_wrd_t
integer as word
Definition spvty.h:16
ACLSPV_MASK_NOPRNDS
#define ACLSPV_MASK_NOPRNDS
mask for number of operands
Definition spvty.h:42
a_aclspv_ctx
Definition ctx.h:14
a_aclspv_ctx::m_scale_vars
x_aclspv_vec m_scale_vars
Definition ctx.h:62
a_aclspv_ctx::m_num_type_uniques
aclspv_wrdcount_t m_num_type_uniques
Definition ctx.h:44
a_aclspv_ctx::m_cursors
x_aclspv_vec m_cursors
cache for cursors for parsing one function for its use see util/cursor.h
Definition ctx.h:77
a_aclspv_ctx::m_constant_cache
x_aclspv_vec m_constant_cache
Definition ctx.h:65
a_aclspv_ctx::m_id
aclspv_id_t m_id
id
Definition ctx.h:50
a_aclspv_ctx::m_ret
x_aclspv_vec m_ret
word count for m_ret
Definition ctx.h:56
a_aclspv_ctx::m_is_logical
aclspv_wrd_t m_is_logical
when on, ignores m_is_buffer_64.
Definition ctx.h:23
a_aclspv_ctx::m_num_cursor
aclspv_wrdcount_t m_num_cursor
number of m_cursors. for its use see util/cursor.h
Definition ctx.h:41
a_aclspv_ctx::m_type_uniques
x_aclspv_vec m_type_uniques
cache for complex types which needs to be stored somewhere for its use see util/type_unique....
Definition ctx.h:86
util_cursor::m_cursor
CXCursor m_cursor
CXCursorKind could be retrieved here
Definition cursor.h:21
util_cursor::m_id
aclspv_id_t m_id
label id for goto
Definition cursor.h:35
util_cursor::m_is_allocated
aclspv_wrd_t m_is_allocated
Definition cursor.h:88
util_cursor::m_met_branch
aclspv_wrd_t m_met_branch
Definition cursor.h:85
util_entp_t::m_nprm
aclspv_wrd_t m_nprm
Definition entp.h:13
x_scale
Definition scale.h:17
util_bind::m_arr_count_id
aclspv_wrdcount_t m_arr_count_id
Definition bind.h:34
util_bind::m_size
aclspv_wrd_t m_size
Definition bind.h:47
util_bind::m_unified
util_bind_unified m_unified
Definition bind.h:20
util_bind::m_set
aclspv_wrd_t m_set
Definition bind.h:26
util_bind::m_pad
aclspv_wrd_t m_pad
Definition bind.h:49
mk_noprnds
#define mk_noprnds(c_num_opprm)
Definition wrdemit.h:66
emit_opcode
#define emit_opcode(h_wrds, c_wrdcount, c_opcode, c_num_opprm_opt)
try emit opcode with num_opprm
Definition wrdemit.h:75
sz_to_count
#define sz_to_count(c_sz)
byte size to word count
Definition wrdemit.h:24
get_wrd_of_vec
#define get_wrd_of_vec(vec)
get word buffer from vector
Definition wrdemit.h:38
spvsz_t
aclspv_wrdcount_t spvsz_t
Definition wrdemit.h:18
count_to_sz
#define count_to_sz(c_count)
word count to byte size
Definition wrdemit.h:32
set_oprnd_count_for_opcode
#define set_oprnd_count_for_opcode(cr_wrd, c_num_opprm)
Definition wrdemit.h:78
opcode_to_wrd
#define opcode_to_wrd(c_opcode, c_num_opprm)
Definition wrdemit.h:69