Daily bump.
[official-gcc.git] / gcc / hsa-dump.c
blobe2ef58693c9601961f4f2a46f74a7fc69e234a31
1 /* Infrastructure to dump our HSAIL IL
2 Copyright (C) 2013-2017 Free Software Foundation, Inc.
3 Contributed by Martin Jambor <mjambor@suse.cz> and
4 Martin Liska <mliska@suse.cz>.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "is-a.h"
27 #include "vec.h"
28 #include "tree.h"
29 #include "cfg.h"
30 #include "function.h"
31 #include "dumpfile.h"
32 #include "gimple-pretty-print.h"
33 #include "cgraph.h"
34 #include "print-tree.h"
35 #include "symbol-summary.h"
36 #include "hsa-common.h"
38 /* Return textual name of TYPE. */
40 static const char *
41 hsa_type_name (BrigType16_t type)
43 switch (type)
45 case BRIG_TYPE_NONE:
46 return "none";
47 case BRIG_TYPE_U8:
48 return "u8";
49 case BRIG_TYPE_U16:
50 return "u16";
51 case BRIG_TYPE_U32:
52 return "u32";
53 case BRIG_TYPE_U64:
54 return "u64";
55 case BRIG_TYPE_S8:
56 return "s8";
57 case BRIG_TYPE_S16:
58 return "s16";
59 case BRIG_TYPE_S32:
60 return "s32";
61 case BRIG_TYPE_S64:
62 return "s64";
63 case BRIG_TYPE_F16:
64 return "f16";
65 case BRIG_TYPE_F32:
66 return "f32";
67 case BRIG_TYPE_F64:
68 return "f64";
69 case BRIG_TYPE_B1:
70 return "b1";
71 case BRIG_TYPE_B8:
72 return "b8";
73 case BRIG_TYPE_B16:
74 return "b16";
75 case BRIG_TYPE_B32:
76 return "b32";
77 case BRIG_TYPE_B64:
78 return "b64";
79 case BRIG_TYPE_B128:
80 return "b128";
81 case BRIG_TYPE_SAMP:
82 return "samp";
83 case BRIG_TYPE_ROIMG:
84 return "roimg";
85 case BRIG_TYPE_WOIMG:
86 return "woimg";
87 case BRIG_TYPE_RWIMG:
88 return "rwimg";
89 case BRIG_TYPE_SIG32:
90 return "sig32";
91 case BRIG_TYPE_SIG64:
92 return "sig64";
93 case BRIG_TYPE_U8X4:
94 return "u8x4";
95 case BRIG_TYPE_U8X8:
96 return "u8x8";
97 case BRIG_TYPE_U8X16:
98 return "u8x16";
99 case BRIG_TYPE_U16X2:
100 return "u16x2";
101 case BRIG_TYPE_U16X4:
102 return "u16x4";
103 case BRIG_TYPE_U16X8:
104 return "u16x8";
105 case BRIG_TYPE_U32X2:
106 return "u32x2";
107 case BRIG_TYPE_U32X4:
108 return "u32x4";
109 case BRIG_TYPE_U64X2:
110 return "u64x2";
111 case BRIG_TYPE_S8X4:
112 return "s8x4";
113 case BRIG_TYPE_S8X8:
114 return "s8x8";
115 case BRIG_TYPE_S8X16:
116 return "s8x16";
117 case BRIG_TYPE_S16X2:
118 return "s16x2";
119 case BRIG_TYPE_S16X4:
120 return "s16x4";
121 case BRIG_TYPE_S16X8:
122 return "s16x8";
123 case BRIG_TYPE_S32X2:
124 return "s32x2";
125 case BRIG_TYPE_S32X4:
126 return "s32x4";
127 case BRIG_TYPE_S64X2:
128 return "s64x2";
129 case BRIG_TYPE_F16X2:
130 return "f16x2";
131 case BRIG_TYPE_F16X4:
132 return "f16x4";
133 case BRIG_TYPE_F16X8:
134 return "f16x8";
135 case BRIG_TYPE_F32X2:
136 return "f32x2";
137 case BRIG_TYPE_F32X4:
138 return "f32x4";
139 case BRIG_TYPE_F64X2:
140 return "f64x2";
141 default:
142 return "UNKNOWN_TYPE";
146 /* Return textual name of OPCODE. */
148 static const char *
149 hsa_opcode_name (BrigOpcode16_t opcode)
151 switch (opcode)
153 case BRIG_OPCODE_NOP:
154 return "nop";
155 case BRIG_OPCODE_ABS:
156 return "abs";
157 case BRIG_OPCODE_ADD:
158 return "add";
159 case BRIG_OPCODE_BORROW:
160 return "borrow";
161 case BRIG_OPCODE_CARRY:
162 return "carry";
163 case BRIG_OPCODE_CEIL:
164 return "ceil";
165 case BRIG_OPCODE_COPYSIGN:
166 return "copysign";
167 case BRIG_OPCODE_DIV:
168 return "div";
169 case BRIG_OPCODE_FLOOR:
170 return "floor";
171 case BRIG_OPCODE_FMA:
172 return "fma";
173 case BRIG_OPCODE_FRACT:
174 return "fract";
175 case BRIG_OPCODE_MAD:
176 return "mad";
177 case BRIG_OPCODE_MAX:
178 return "max";
179 case BRIG_OPCODE_MIN:
180 return "min";
181 case BRIG_OPCODE_MUL:
182 return "mul";
183 case BRIG_OPCODE_MULHI:
184 return "mulhi";
185 case BRIG_OPCODE_NEG:
186 return "neg";
187 case BRIG_OPCODE_REM:
188 return "rem";
189 case BRIG_OPCODE_RINT:
190 return "rint";
191 case BRIG_OPCODE_SQRT:
192 return "sqrt";
193 case BRIG_OPCODE_SUB:
194 return "sub";
195 case BRIG_OPCODE_TRUNC:
196 return "trunc";
197 case BRIG_OPCODE_MAD24:
198 return "mad24";
199 case BRIG_OPCODE_MAD24HI:
200 return "mad24hi";
201 case BRIG_OPCODE_MUL24:
202 return "mul24";
203 case BRIG_OPCODE_MUL24HI:
204 return "mul24hi";
205 case BRIG_OPCODE_SHL:
206 return "shl";
207 case BRIG_OPCODE_SHR:
208 return "shr";
209 case BRIG_OPCODE_AND:
210 return "and";
211 case BRIG_OPCODE_NOT:
212 return "not";
213 case BRIG_OPCODE_OR:
214 return "or";
215 case BRIG_OPCODE_POPCOUNT:
216 return "popcount";
217 case BRIG_OPCODE_XOR:
218 return "xor";
219 case BRIG_OPCODE_BITEXTRACT:
220 return "bitextract";
221 case BRIG_OPCODE_BITINSERT:
222 return "bitinsert";
223 case BRIG_OPCODE_BITMASK:
224 return "bitmask";
225 case BRIG_OPCODE_BITREV:
226 return "bitrev";
227 case BRIG_OPCODE_BITSELECT:
228 return "bitselect";
229 case BRIG_OPCODE_FIRSTBIT:
230 return "firstbit";
231 case BRIG_OPCODE_LASTBIT:
232 return "lastbit";
233 case BRIG_OPCODE_COMBINE:
234 return "combine";
235 case BRIG_OPCODE_EXPAND:
236 return "expand";
237 case BRIG_OPCODE_LDA:
238 return "lda";
239 case BRIG_OPCODE_MOV:
240 return "mov";
241 case BRIG_OPCODE_SHUFFLE:
242 return "shuffle";
243 case BRIG_OPCODE_UNPACKHI:
244 return "unpackhi";
245 case BRIG_OPCODE_UNPACKLO:
246 return "unpacklo";
247 case BRIG_OPCODE_PACK:
248 return "pack";
249 case BRIG_OPCODE_UNPACK:
250 return "unpack";
251 case BRIG_OPCODE_CMOV:
252 return "cmov";
253 case BRIG_OPCODE_CLASS:
254 return "class";
255 case BRIG_OPCODE_NCOS:
256 return "ncos";
257 case BRIG_OPCODE_NEXP2:
258 return "nexp2";
259 case BRIG_OPCODE_NFMA:
260 return "nfma";
261 case BRIG_OPCODE_NLOG2:
262 return "nlog2";
263 case BRIG_OPCODE_NRCP:
264 return "nrcp";
265 case BRIG_OPCODE_NRSQRT:
266 return "nrsqrt";
267 case BRIG_OPCODE_NSIN:
268 return "nsin";
269 case BRIG_OPCODE_NSQRT:
270 return "nsqrt";
271 case BRIG_OPCODE_BITALIGN:
272 return "bitalign";
273 case BRIG_OPCODE_BYTEALIGN:
274 return "bytealign";
275 case BRIG_OPCODE_PACKCVT:
276 return "packcvt";
277 case BRIG_OPCODE_UNPACKCVT:
278 return "unpackcvt";
279 case BRIG_OPCODE_LERP:
280 return "lerp";
281 case BRIG_OPCODE_SAD:
282 return "sad";
283 case BRIG_OPCODE_SADHI:
284 return "sadhi";
285 case BRIG_OPCODE_SEGMENTP:
286 return "segmentp";
287 case BRIG_OPCODE_FTOS:
288 return "ftos";
289 case BRIG_OPCODE_STOF:
290 return "stof";
291 case BRIG_OPCODE_CMP:
292 return "cmp";
293 case BRIG_OPCODE_CVT:
294 return "cvt";
295 case BRIG_OPCODE_LD:
296 return "ld";
297 case BRIG_OPCODE_ST:
298 return "st";
299 case BRIG_OPCODE_ATOMIC:
300 return "atomic";
301 case BRIG_OPCODE_ATOMICNORET:
302 return "atomicnoret";
303 case BRIG_OPCODE_SIGNAL:
304 return "signal";
305 case BRIG_OPCODE_SIGNALNORET:
306 return "signalnoret";
307 case BRIG_OPCODE_MEMFENCE:
308 return "memfence";
309 case BRIG_OPCODE_RDIMAGE:
310 return "rdimage";
311 case BRIG_OPCODE_LDIMAGE:
312 return "ldimage";
313 case BRIG_OPCODE_STIMAGE:
314 return "stimage";
315 case BRIG_OPCODE_QUERYIMAGE:
316 return "queryimage";
317 case BRIG_OPCODE_QUERYSAMPLER:
318 return "querysampler";
319 case BRIG_OPCODE_CBR:
320 return "cbr";
321 case BRIG_OPCODE_BR:
322 return "br";
323 case BRIG_OPCODE_SBR:
324 return "sbr";
325 case BRIG_OPCODE_BARRIER:
326 return "barrier";
327 case BRIG_OPCODE_WAVEBARRIER:
328 return "wavebarrier";
329 case BRIG_OPCODE_ARRIVEFBAR:
330 return "arrivefbar";
331 case BRIG_OPCODE_INITFBAR:
332 return "initfbar";
333 case BRIG_OPCODE_JOINFBAR:
334 return "joinfbar";
335 case BRIG_OPCODE_LEAVEFBAR:
336 return "leavefbar";
337 case BRIG_OPCODE_RELEASEFBAR:
338 return "releasefbar";
339 case BRIG_OPCODE_WAITFBAR:
340 return "waitfbar";
341 case BRIG_OPCODE_LDF:
342 return "ldf";
343 case BRIG_OPCODE_ACTIVELANECOUNT:
344 return "activelanecount";
345 case BRIG_OPCODE_ACTIVELANEID:
346 return "activelaneid";
347 case BRIG_OPCODE_ACTIVELANEMASK:
348 return "activelanemask";
349 case BRIG_OPCODE_CALL:
350 return "call";
351 case BRIG_OPCODE_SCALL:
352 return "scall";
353 case BRIG_OPCODE_ICALL:
354 return "icall";
355 case BRIG_OPCODE_RET:
356 return "ret";
357 case BRIG_OPCODE_ALLOCA:
358 return "alloca";
359 case BRIG_OPCODE_CURRENTWORKGROUPSIZE:
360 return "currentworkgroupsize";
361 case BRIG_OPCODE_DIM:
362 return "dim";
363 case BRIG_OPCODE_GRIDGROUPS:
364 return "gridgroups";
365 case BRIG_OPCODE_GRIDSIZE:
366 return "gridsize";
367 case BRIG_OPCODE_PACKETCOMPLETIONSIG:
368 return "packetcompletionsig";
369 case BRIG_OPCODE_PACKETID:
370 return "packetid";
371 case BRIG_OPCODE_WORKGROUPID:
372 return "workgroupid";
373 case BRIG_OPCODE_WORKGROUPSIZE:
374 return "workgroupsize";
375 case BRIG_OPCODE_WORKITEMABSID:
376 return "workitemabsid";
377 case BRIG_OPCODE_WORKITEMFLATABSID:
378 return "workitemflatabsid";
379 case BRIG_OPCODE_WORKITEMFLATID:
380 return "workitemflatid";
381 case BRIG_OPCODE_WORKITEMID:
382 return "workitemid";
383 case BRIG_OPCODE_CLEARDETECTEXCEPT:
384 return "cleardetectexcept";
385 case BRIG_OPCODE_GETDETECTEXCEPT:
386 return "getdetectexcept";
387 case BRIG_OPCODE_SETDETECTEXCEPT:
388 return "setdetectexcept";
389 case BRIG_OPCODE_ADDQUEUEWRITEINDEX:
390 return "addqueuewriteindex";
391 case BRIG_OPCODE_CASQUEUEWRITEINDEX:
392 return "casqueuewriteindex";
393 case BRIG_OPCODE_LDQUEUEREADINDEX:
394 return "ldqueuereadindex";
395 case BRIG_OPCODE_LDQUEUEWRITEINDEX:
396 return "ldqueuewriteindex";
397 case BRIG_OPCODE_STQUEUEREADINDEX:
398 return "stqueuereadindex";
399 case BRIG_OPCODE_STQUEUEWRITEINDEX:
400 return "stqueuewriteindex";
401 case BRIG_OPCODE_CLOCK:
402 return "clock";
403 case BRIG_OPCODE_CUID:
404 return "cuid";
405 case BRIG_OPCODE_DEBUGTRAP:
406 return "debugtrap";
407 case BRIG_OPCODE_GROUPBASEPTR:
408 return "groupbaseptr";
409 case BRIG_OPCODE_KERNARGBASEPTR:
410 return "kernargbaseptr";
411 case BRIG_OPCODE_LANEID:
412 return "laneid";
413 case BRIG_OPCODE_MAXCUID:
414 return "maxcuid";
415 case BRIG_OPCODE_MAXWAVEID:
416 return "maxwaveid";
417 case BRIG_OPCODE_NULLPTR:
418 return "nullptr";
419 case BRIG_OPCODE_WAVEID:
420 return "waveid";
421 default:
422 return "UNKNOWN_OPCODE";
426 /* Return textual name of SEG. */
428 const char *
429 hsa_seg_name (BrigSegment8_t seg)
431 switch (seg)
433 case BRIG_SEGMENT_NONE:
434 return "none";
435 case BRIG_SEGMENT_FLAT:
436 return "flat";
437 case BRIG_SEGMENT_GLOBAL:
438 return "global";
439 case BRIG_SEGMENT_READONLY:
440 return "readonly";
441 case BRIG_SEGMENT_KERNARG:
442 return "kernarg";
443 case BRIG_SEGMENT_GROUP:
444 return "group";
445 case BRIG_SEGMENT_PRIVATE:
446 return "private";
447 case BRIG_SEGMENT_SPILL:
448 return "spill";
449 case BRIG_SEGMENT_ARG:
450 return "arg";
451 default:
452 return "UNKNOWN_SEGMENT";
456 /* Return textual name of CMPOP. */
458 static const char *
459 hsa_cmpop_name (BrigCompareOperation8_t cmpop)
461 switch (cmpop)
463 case BRIG_COMPARE_EQ:
464 return "eq";
465 case BRIG_COMPARE_NE:
466 return "ne";
467 case BRIG_COMPARE_LT:
468 return "lt";
469 case BRIG_COMPARE_LE:
470 return "le";
471 case BRIG_COMPARE_GT:
472 return "gt";
473 case BRIG_COMPARE_GE:
474 return "ge";
475 case BRIG_COMPARE_EQU:
476 return "equ";
477 case BRIG_COMPARE_NEU:
478 return "neu";
479 case BRIG_COMPARE_LTU:
480 return "ltu";
481 case BRIG_COMPARE_LEU:
482 return "leu";
483 case BRIG_COMPARE_GTU:
484 return "gtu";
485 case BRIG_COMPARE_GEU:
486 return "geu";
487 case BRIG_COMPARE_NUM:
488 return "num";
489 case BRIG_COMPARE_NAN:
490 return "nan";
491 case BRIG_COMPARE_SEQ:
492 return "seq";
493 case BRIG_COMPARE_SNE:
494 return "sne";
495 case BRIG_COMPARE_SLT:
496 return "slt";
497 case BRIG_COMPARE_SLE:
498 return "sle";
499 case BRIG_COMPARE_SGT:
500 return "sgt";
501 case BRIG_COMPARE_SGE:
502 return "sge";
503 case BRIG_COMPARE_SGEU:
504 return "sgeu";
505 case BRIG_COMPARE_SEQU:
506 return "sequ";
507 case BRIG_COMPARE_SNEU:
508 return "sneu";
509 case BRIG_COMPARE_SLTU:
510 return "sltu";
511 case BRIG_COMPARE_SLEU:
512 return "sleu";
513 case BRIG_COMPARE_SNUM:
514 return "snum";
515 case BRIG_COMPARE_SNAN:
516 return "snan";
517 case BRIG_COMPARE_SGTU:
518 return "sgtu";
519 default:
520 return "UNKNOWN_COMPARISON";
524 /* Return textual name for memory order. */
526 static const char *
527 hsa_memsem_name (enum BrigMemoryOrder mo)
529 switch (mo)
531 case BRIG_MEMORY_ORDER_NONE:
532 return "";
533 case BRIG_MEMORY_ORDER_RELAXED:
534 return "rlx";
535 case BRIG_MEMORY_ORDER_SC_ACQUIRE:
536 return "scacq";
537 case BRIG_MEMORY_ORDER_SC_RELEASE:
538 return "screl";
539 case BRIG_MEMORY_ORDER_SC_ACQUIRE_RELEASE:
540 return "scar";
541 default:
542 return "UNKNOWN_MEMORY_ORDER";
546 /* Return textual name for memory scope. */
548 static const char *
549 hsa_memscope_name (enum BrigMemoryScope scope)
551 switch (scope)
553 case BRIG_MEMORY_SCOPE_NONE:
554 return "";
555 case BRIG_MEMORY_SCOPE_WORKITEM:
556 return "wi";
557 case BRIG_MEMORY_SCOPE_WAVEFRONT:
558 return "wave";
559 case BRIG_MEMORY_SCOPE_WORKGROUP:
560 return "wg";
561 case BRIG_MEMORY_SCOPE_AGENT:
562 return "agent";
563 case BRIG_MEMORY_SCOPE_SYSTEM:
564 return "sys";
565 default:
566 return "UNKNOWN_SCOPE";
570 /* Return textual name for atomic operation. */
572 static const char *
573 hsa_m_atomicop_name (enum BrigAtomicOperation op)
575 switch (op)
577 case BRIG_ATOMIC_ADD:
578 return "add";
579 case BRIG_ATOMIC_AND:
580 return "and";
581 case BRIG_ATOMIC_CAS:
582 return "cas";
583 case BRIG_ATOMIC_EXCH:
584 return "exch";
585 case BRIG_ATOMIC_LD:
586 return "ld";
587 case BRIG_ATOMIC_MAX:
588 return "max";
589 case BRIG_ATOMIC_MIN:
590 return "min";
591 case BRIG_ATOMIC_OR:
592 return "or";
593 case BRIG_ATOMIC_ST:
594 return "st";
595 case BRIG_ATOMIC_SUB:
596 return "sub";
597 case BRIG_ATOMIC_WRAPDEC:
598 return "wrapdec";
599 case BRIG_ATOMIC_WRAPINC:
600 return "wrapinc";
601 case BRIG_ATOMIC_XOR:
602 return "xor";
603 case BRIG_ATOMIC_WAIT_EQ:
604 return "wait_eq";
605 case BRIG_ATOMIC_WAIT_NE:
606 return "wait_ne";
607 case BRIG_ATOMIC_WAIT_LT:
608 return "wait_lt";
609 case BRIG_ATOMIC_WAIT_GTE:
610 return "wait_gte";
611 case BRIG_ATOMIC_WAITTIMEOUT_EQ:
612 return "waittimeout_eq";
613 case BRIG_ATOMIC_WAITTIMEOUT_NE:
614 return "waittimeout_ne";
615 case BRIG_ATOMIC_WAITTIMEOUT_LT:
616 return "waittimeout_lt";
617 case BRIG_ATOMIC_WAITTIMEOUT_GTE:
618 return "waittimeout_gte";
619 default:
620 return "UNKNOWN_ATOMIC_OP";
624 /* Return textual name for atomic operation. */
626 static const char *
627 hsa_width_specifier_name (BrigWidth8_t width)
629 switch (width)
631 case BRIG_WIDTH_NONE:
632 return "none";
633 case BRIG_WIDTH_1:
634 return "1";
635 case BRIG_WIDTH_2:
636 return "2";
637 case BRIG_WIDTH_4:
638 return "4";
639 case BRIG_WIDTH_8:
640 return "8";
641 case BRIG_WIDTH_16:
642 return "16";
643 case BRIG_WIDTH_32:
644 return "32";
645 case BRIG_WIDTH_64:
646 return "64";
647 case BRIG_WIDTH_128:
648 return "128";
649 case BRIG_WIDTH_256:
650 return "256";
651 case BRIG_WIDTH_512:
652 return "512";
653 case BRIG_WIDTH_1024:
654 return "1024";
655 case BRIG_WIDTH_2048:
656 return "2048";
657 case BRIG_WIDTH_4096:
658 return "4096";
659 case BRIG_WIDTH_8192:
660 return "8192";
661 case BRIG_WIDTH_16384:
662 return "16384";
663 case BRIG_WIDTH_32768:
664 return "32768";
665 case BRIG_WIDTH_65536:
666 return "65536";
667 case BRIG_WIDTH_131072:
668 return "131072";
669 case BRIG_WIDTH_262144:
670 return "262144";
671 case BRIG_WIDTH_524288:
672 return "524288";
673 case BRIG_WIDTH_1048576:
674 return "1048576";
675 case BRIG_WIDTH_2097152:
676 return "2097152";
677 case BRIG_WIDTH_4194304:
678 return "4194304";
679 case BRIG_WIDTH_8388608:
680 return "8388608";
681 case BRIG_WIDTH_16777216:
682 return "16777216";
683 case BRIG_WIDTH_33554432:
684 return "33554432";
685 case BRIG_WIDTH_67108864:
686 return "67108864";
687 case BRIG_WIDTH_134217728:
688 return "134217728";
689 case BRIG_WIDTH_268435456:
690 return "268435456";
691 case BRIG_WIDTH_536870912:
692 return "536870912";
693 case BRIG_WIDTH_1073741824:
694 return "1073741824";
695 case BRIG_WIDTH_2147483648:
696 return "2147483648";
697 case BRIG_WIDTH_WAVESIZE:
698 return "wavesize";
699 case BRIG_WIDTH_ALL:
700 return "all";
701 default:
702 return "UNKNOWN_WIDTH";
706 /* Dump textual representation of HSA IL register REG to file F. */
708 static void
709 dump_hsa_reg (FILE *f, hsa_op_reg *reg, bool dump_type = false)
711 if (reg->m_reg_class)
712 fprintf (f, "$%c%i", reg->m_reg_class, reg->m_hard_num);
713 else
714 fprintf (f, "$_%i", reg->m_order);
715 if (dump_type)
716 fprintf (f, " (%s)", hsa_type_name (reg->m_type));
719 /* Dump textual representation of HSA IL immediate operand IMM to file F. */
721 static void
722 dump_hsa_immed (FILE *f, hsa_op_immed *imm)
724 bool unsigned_int_type
725 = (BRIG_TYPE_U8 | BRIG_TYPE_U16 | BRIG_TYPE_U32 | BRIG_TYPE_U64)
726 & imm->m_type;
728 if (imm->m_tree_value)
729 print_generic_expr (f, imm->m_tree_value, 0);
730 else
732 if (unsigned_int_type)
733 fprintf (f, HOST_WIDE_INT_PRINT_DEC, imm->m_int_value);
734 else
735 fprintf (f, HOST_WIDE_INT_PRINT_UNSIGNED,
736 (unsigned HOST_WIDE_INT) imm->m_int_value);
739 fprintf (f, " (%s)", hsa_type_name (imm->m_type));
742 /* Dump textual representation of HSA IL address operand ADDR to file F. */
744 static void
745 dump_hsa_address (FILE *f, hsa_op_address *addr)
747 bool sth = false;
749 if (addr->m_symbol)
751 sth = true;
752 if (addr->m_symbol->m_name)
753 fprintf (f, "[%%%s]", addr->m_symbol->m_name);
754 else
755 fprintf (f, "[%%__%s_%i]", hsa_seg_name (addr->m_symbol->m_segment),
756 addr->m_symbol->m_name_number);
759 if (addr->m_reg)
761 fprintf (f, "[");
762 dump_hsa_reg (f, addr->m_reg);
763 if (addr->m_imm_offset != 0)
764 fprintf (f, " + " HOST_WIDE_INT_PRINT_DEC "]", addr->m_imm_offset);
765 else
766 fprintf (f, "]");
768 else if (!sth || addr->m_imm_offset != 0)
769 fprintf (f, "[" HOST_WIDE_INT_PRINT_DEC "]", addr->m_imm_offset);
772 /* Dump textual representation of HSA IL symbol SYMBOL to file F. */
774 static void
775 dump_hsa_symbol (FILE *f, hsa_symbol *symbol)
777 const char *name;
778 if (symbol->m_name)
779 name = symbol->m_name;
780 else
782 char buf[64];
783 sprintf (buf, "__%s_%i", hsa_seg_name (symbol->m_segment),
784 symbol->m_name_number);
786 name = buf;
789 fprintf (f, "align(%u) %s_%s %s", hsa_byte_alignment (symbol->m_align),
790 hsa_seg_name (symbol->m_segment),
791 hsa_type_name (symbol->m_type & ~BRIG_TYPE_ARRAY_MASK), name);
793 if (symbol->m_type & BRIG_TYPE_ARRAY_MASK)
794 fprintf (f, "[%lu]", (unsigned long) symbol->m_dim);
796 if (symbol->m_directive_offset)
797 fprintf (f, " /* BRIG offset: %u */", symbol->m_directive_offset);
800 /* Dump textual representation of HSA IL operand OP to file F. */
802 static void
803 dump_hsa_operand (FILE *f, hsa_op_base *op, bool dump_reg_type = false)
805 if (is_a <hsa_op_immed *> (op))
806 dump_hsa_immed (f, as_a <hsa_op_immed *> (op));
807 else if (is_a <hsa_op_reg *> (op))
808 dump_hsa_reg (f, as_a <hsa_op_reg *> (op), dump_reg_type);
809 else if (is_a <hsa_op_address *> (op))
810 dump_hsa_address (f, as_a <hsa_op_address *> (op));
811 else
812 fprintf (f, "UNKNOWN_OP_KIND");
815 /* Dump textual representation of HSA IL operands in VEC to file F. */
817 static void
818 dump_hsa_operands (FILE *f, hsa_insn_basic *insn, int start = 0,
819 int end = -1, bool dump_reg_type = false)
821 if (end == -1)
822 end = insn->operand_count ();
824 for (int i = start; i < end; i++)
826 dump_hsa_operand (f, insn->get_op (i), dump_reg_type);
827 if (i != end - 1)
828 fprintf (f, ", ");
832 /* Indent F stream with INDENT spaces. */
834 static void indent_stream (FILE *f, int indent)
836 for (int i = 0; i < indent; i++)
837 fputc (' ', f);
840 /* Dump textual representation of HSA IL instruction INSN to file F. Prepend
841 the instruction with *INDENT spaces and adjust the indentation for call
842 instructions as appropriate. */
844 static void
845 dump_hsa_insn_1 (FILE *f, hsa_insn_basic *insn, int *indent)
847 gcc_checking_assert (insn);
849 if (insn->m_number)
850 fprintf (f, "%5d: ", insn->m_number);
852 indent_stream (f, *indent);
854 if (is_a <hsa_insn_phi *> (insn))
856 hsa_insn_phi *phi = as_a <hsa_insn_phi *> (insn);
857 bool first = true;
858 dump_hsa_reg (f, phi->m_dest, true);
859 fprintf (f, " = PHI <");
860 unsigned count = phi->operand_count ();
861 for (unsigned i = 0; i < count; i++)
863 if (!phi->get_op (i))
864 break;
865 if (!first)
866 fprintf (f, ", ");
867 else
868 first = false;
869 dump_hsa_operand (f, phi->get_op (i), true);
871 fprintf (f, ">");
873 else if (is_a <hsa_insn_signal *> (insn))
875 hsa_insn_signal *mem = as_a <hsa_insn_signal *> (insn);
877 fprintf (f, "%s", hsa_opcode_name (mem->m_opcode));
878 fprintf (f, "_%s", hsa_m_atomicop_name (mem->m_signalop));
879 if (mem->m_memory_order != BRIG_MEMORY_ORDER_NONE)
880 fprintf (f, "_%s", hsa_memsem_name (mem->m_memory_order));
881 fprintf (f, "_%s ", hsa_type_name (mem->m_type));
883 dump_hsa_operands (f, mem);
886 else if (is_a <hsa_insn_atomic *> (insn))
888 hsa_insn_atomic *mem = as_a <hsa_insn_atomic *> (insn);
890 /* Either operand[0] or operand[1] must be an address operand. */
891 hsa_op_address *addr = NULL;
892 if (is_a <hsa_op_address *> (mem->get_op (0)))
893 addr = as_a <hsa_op_address *> (mem->get_op (0));
894 else
895 addr = as_a <hsa_op_address *> (mem->get_op (1));
897 fprintf (f, "%s", hsa_opcode_name (mem->m_opcode));
898 fprintf (f, "_%s", hsa_m_atomicop_name (mem->m_atomicop));
899 if (addr->m_symbol)
900 fprintf (f, "_%s", hsa_seg_name (addr->m_symbol->m_segment));
901 if (mem->m_memoryorder != BRIG_MEMORY_ORDER_NONE)
902 fprintf (f, "_%s", hsa_memsem_name (mem->m_memoryorder));
903 if (mem->m_memoryscope != BRIG_MEMORY_SCOPE_NONE)
904 fprintf (f, "_%s", hsa_memscope_name (mem->m_memoryscope));
905 fprintf (f, "_%s ", hsa_type_name (mem->m_type));
907 dump_hsa_operands (f, mem);
909 else if (is_a <hsa_insn_mem *> (insn))
911 hsa_insn_mem *mem = as_a <hsa_insn_mem *> (insn);
912 hsa_op_address *addr = as_a <hsa_op_address *> (mem->get_op (1));
914 fprintf (f, "%s", hsa_opcode_name (mem->m_opcode));
915 if (addr->m_symbol)
916 fprintf (f, "_%s", hsa_seg_name (addr->m_symbol->m_segment));
917 if (mem->m_align != BRIG_ALIGNMENT_NONE)
918 fprintf (f, "_align(%u)", hsa_byte_alignment (mem->m_align));
919 if (mem->m_equiv_class != 0)
920 fprintf (f, "_equiv(%i)", mem->m_equiv_class);
921 fprintf (f, "_%s ", hsa_type_name (mem->m_type));
923 dump_hsa_operand (f, mem->get_op (0));
924 fprintf (f, ", ");
925 dump_hsa_address (f, addr);
927 else if (insn->m_opcode == BRIG_OPCODE_LDA)
929 hsa_op_address *addr = as_a <hsa_op_address *> (insn->get_op (1));
931 fprintf (f, "%s", hsa_opcode_name (insn->m_opcode));
932 if (addr->m_symbol)
933 fprintf (f, "_%s", hsa_seg_name (addr->m_symbol->m_segment));
934 fprintf (f, "_%s ", hsa_type_name (insn->m_type));
936 dump_hsa_operand (f, insn->get_op (0));
937 fprintf (f, ", ");
938 dump_hsa_address (f, addr);
940 else if (is_a <hsa_insn_seg *> (insn))
942 hsa_insn_seg *seg = as_a <hsa_insn_seg *> (insn);
943 fprintf (f, "%s_%s_%s_%s ", hsa_opcode_name (seg->m_opcode),
944 hsa_seg_name (seg->m_segment),
945 hsa_type_name (seg->m_type), hsa_type_name (seg->m_src_type));
946 dump_hsa_reg (f, as_a <hsa_op_reg *> (seg->get_op (0)));
947 fprintf (f, ", ");
948 dump_hsa_operand (f, seg->get_op (1));
950 else if (is_a <hsa_insn_cmp *> (insn))
952 hsa_insn_cmp *cmp = as_a <hsa_insn_cmp *> (insn);
953 BrigType16_t src_type;
955 if (is_a <hsa_op_reg *> (cmp->get_op (1)))
956 src_type = as_a <hsa_op_reg *> (cmp->get_op (1))->m_type;
957 else
958 src_type = as_a <hsa_op_immed *> (cmp->get_op (1))->m_type;
960 fprintf (f, "%s_%s_%s_%s ", hsa_opcode_name (cmp->m_opcode),
961 hsa_cmpop_name (cmp->m_compare),
962 hsa_type_name (cmp->m_type), hsa_type_name (src_type));
963 dump_hsa_reg (f, as_a <hsa_op_reg *> (cmp->get_op (0)));
964 fprintf (f, ", ");
965 dump_hsa_operand (f, cmp->get_op (1));
966 fprintf (f, ", ");
967 dump_hsa_operand (f, cmp->get_op (2));
969 else if (is_a <hsa_insn_cbr *> (insn))
971 hsa_insn_cbr *br = as_a <hsa_insn_cbr *> (insn);
972 basic_block target = NULL;
973 edge_iterator ei;
974 edge e;
976 fprintf (f, "%s ", hsa_opcode_name (br->m_opcode));
977 if (br->m_opcode == BRIG_OPCODE_CBR)
979 dump_hsa_reg (f, as_a <hsa_op_reg *> (br->get_op (0)));
980 fprintf (f, ", ");
983 FOR_EACH_EDGE (e, ei, br->m_bb->succs)
984 if (e->flags & EDGE_TRUE_VALUE)
986 target = e->dest;
987 break;
989 fprintf (f, "BB %i", hsa_bb_for_bb (target)->m_index);
991 else if (is_a <hsa_insn_sbr *> (insn))
993 hsa_insn_sbr *sbr = as_a <hsa_insn_sbr *> (insn);
995 fprintf (f, "%s ", hsa_opcode_name (sbr->m_opcode));
996 dump_hsa_reg (f, as_a <hsa_op_reg *> (sbr->get_op (0)));
997 fprintf (f, ", [");
999 for (unsigned i = 0; i < sbr->m_jump_table.length (); i++)
1001 fprintf (f, "BB %i", hsa_bb_for_bb (sbr->m_jump_table[i])->m_index);
1002 if (i != sbr->m_jump_table.length () - 1)
1003 fprintf (f, ", ");
1006 else if (is_a <hsa_insn_br *> (insn))
1008 hsa_insn_br *br = as_a <hsa_insn_br *> (insn);
1009 fprintf (f, "%s_width(%s) ", hsa_opcode_name (br->m_opcode),
1010 hsa_width_specifier_name (br->m_width));
1012 else if (is_a <hsa_insn_arg_block *> (insn))
1014 hsa_insn_arg_block *arg_block = as_a <hsa_insn_arg_block *> (insn);
1015 bool start_p = arg_block->m_kind == BRIG_KIND_DIRECTIVE_ARG_BLOCK_START;
1016 char c = start_p ? '{' : '}';
1018 if (start_p)
1020 *indent += 2;
1021 indent_stream (f, 2);
1024 if (!start_p)
1025 *indent -= 2;
1027 fprintf (f, "%c", c);
1029 else if (is_a <hsa_insn_call *> (insn))
1031 hsa_insn_call *call = as_a <hsa_insn_call *> (insn);
1032 if (call->m_called_function)
1034 const char *name = hsa_get_declaration_name (call->m_called_function);
1035 fprintf (f, "call &%s", name);
1037 else
1039 char *name = call->m_called_internal_fn->name ();
1040 fprintf (f, "call &%s", name);
1041 free (name);
1044 if (call->m_output_arg)
1045 fprintf (f, "(%%res) ");
1047 fprintf (f, "(");
1048 for (unsigned i = 0; i < call->m_input_args.length (); i++)
1050 fprintf (f, "%%__arg_%u", i);
1052 if (i != call->m_input_args.length () - 1)
1053 fprintf (f, ", ");
1055 fprintf (f, ")");
1057 else if (is_a <hsa_insn_comment *> (insn))
1059 hsa_insn_comment *c = as_a <hsa_insn_comment *> (insn);
1060 fprintf (f, "%s", c->m_comment);
1062 else if (is_a <hsa_insn_srctype *> (insn))
1064 hsa_insn_srctype *srctype = as_a <hsa_insn_srctype *> (insn);
1066 fprintf (f, "%s_%s_%s ", hsa_opcode_name (srctype->m_opcode),
1067 hsa_type_name (srctype->m_type),
1068 hsa_type_name (srctype->m_source_type));
1070 dump_hsa_operands (f, insn);
1072 else if (is_a <hsa_insn_packed *> (insn))
1074 hsa_insn_packed *packed = as_a <hsa_insn_packed *> (insn);
1076 fprintf (f, "%s_v%u_%s_%s ", hsa_opcode_name (packed->m_opcode),
1077 packed->operand_count () - 1,
1078 hsa_type_name (packed->m_type),
1079 hsa_type_name (packed->m_source_type));
1081 if (packed->m_opcode == BRIG_OPCODE_COMBINE)
1083 dump_hsa_operand (f, insn->get_op (0));
1084 fprintf (f, ", (");
1085 dump_hsa_operands (f, insn, 1);
1086 fprintf (f, ")");
1088 else if (packed->m_opcode == BRIG_OPCODE_EXPAND)
1090 fprintf (f, "(");
1091 dump_hsa_operands (f, insn, 0, insn->operand_count () - 1);
1092 fprintf (f, "), ");
1093 dump_hsa_operand (f, insn->get_op (insn->operand_count () - 1));
1096 else
1097 gcc_unreachable ();
1099 else if (is_a <hsa_insn_alloca *> (insn))
1101 hsa_insn_alloca *alloca = as_a <hsa_insn_alloca *> (insn);
1103 fprintf (f, "%s_align(%u)_%s ", hsa_opcode_name (insn->m_opcode),
1104 hsa_byte_alignment (alloca->m_align),
1105 hsa_type_name (insn->m_type));
1107 dump_hsa_operands (f, insn);
1109 else if (hsa_insn_queue *qi = dyn_cast <hsa_insn_queue *> (insn))
1111 fprintf (f, "%s_%s_%s_%s ", hsa_opcode_name (qi->m_opcode),
1112 hsa_seg_name (qi->m_segment),
1113 hsa_memsem_name (qi->m_memory_order),
1114 hsa_type_name (qi->m_type));
1116 dump_hsa_operands (f, qi);
1118 else
1120 fprintf (f, "%s_%s ", hsa_opcode_name (insn->m_opcode),
1121 hsa_type_name (insn->m_type));
1123 dump_hsa_operands (f, insn);
1126 if (insn->m_brig_offset)
1128 fprintf (f, " /* BRIG offset: %u", insn->m_brig_offset);
1130 for (unsigned i = 0; i < insn->operand_count (); i++)
1131 fprintf (f, ", op%u: %u", i, insn->get_op (i)->m_brig_op_offset);
1133 fprintf (f, " */");
1136 fprintf (f, "\n");
1139 /* Dump textual representation of HSA IL instruction INSN to file F. */
1141 void
1142 dump_hsa_insn (FILE *f, hsa_insn_basic *insn)
1144 int indent = 0;
1145 dump_hsa_insn_1 (f, insn, &indent);
1148 /* Dump textual representation of HSA IL in HBB to file F. */
1150 void
1151 dump_hsa_bb (FILE *f, hsa_bb *hbb)
1153 hsa_insn_basic *insn;
1154 edge_iterator ei;
1155 edge e;
1156 basic_block true_bb = NULL, other = NULL;
1158 fprintf (f, "BB %i:\n", hbb->m_index);
1160 int indent = 2;
1161 for (insn = hbb->m_first_phi; insn; insn = insn->m_next)
1162 dump_hsa_insn_1 (f, insn, &indent);
1164 for (insn = hbb->m_first_insn; insn; insn = insn->m_next)
1165 dump_hsa_insn_1 (f, insn, &indent);
1167 if (hbb->m_last_insn && is_a <hsa_insn_sbr *> (hbb->m_last_insn))
1168 goto exit;
1170 FOR_EACH_EDGE (e, ei, hbb->m_bb->succs)
1171 if (e->flags & EDGE_TRUE_VALUE)
1173 gcc_assert (!true_bb);
1174 true_bb = e->dest;
1176 else
1178 gcc_assert (!other);
1179 other = e->dest;
1182 if (true_bb)
1184 if (!hbb->m_last_insn
1185 || hbb->m_last_insn->m_opcode != BRIG_OPCODE_CBR)
1186 fprintf (f, "WARNING: No branch insn for a true edge. \n");
1188 else if (hbb->m_last_insn
1189 && hbb->m_last_insn->m_opcode == BRIG_OPCODE_CBR)
1190 fprintf (f, "WARNING: No true edge for a cbr statement\n");
1192 if (other && other->aux)
1193 fprintf (f, " Fall-through to BB %i\n",
1194 hsa_bb_for_bb (other)->m_index);
1195 else if (hbb->m_last_insn
1196 && hbb->m_last_insn->m_opcode != BRIG_OPCODE_RET)
1197 fprintf (f, " WARNING: Fall through to a BB with no aux!\n");
1199 exit:
1200 fprintf (f, "\n");
1203 /* Dump textual representation of HSA IL of the current function to file F. */
1205 void
1206 dump_hsa_cfun (FILE *f)
1208 basic_block bb;
1210 if (hsa_cfun->m_global_symbols.length () > 0)
1211 fprintf (f, "\nHSAIL in global scope\n");
1213 for (unsigned i = 0; i < hsa_cfun->m_global_symbols.length (); i++)
1215 fprintf (f, " ");
1216 dump_hsa_symbol (f, hsa_cfun->m_global_symbols[i]);
1217 fprintf (f, "\n");
1220 fprintf (f, "\nHSAIL IL for %s\n", hsa_cfun->m_name);
1222 for (unsigned i = 0; i < hsa_cfun->m_private_variables.length (); i++)
1224 fprintf (f, " ");
1225 dump_hsa_symbol (f, hsa_cfun->m_private_variables[i]);
1226 fprintf (f, "\n");
1229 FOR_ALL_BB_FN (bb, cfun)
1231 hsa_bb *hbb = (struct hsa_bb *) bb->aux;
1232 dump_hsa_bb (f, hbb);
1236 /* Dump textual representation of HSA IL instruction INSN to stderr. */
1238 DEBUG_FUNCTION void
1239 debug_hsa_insn (hsa_insn_basic *insn)
1241 dump_hsa_insn (stderr, insn);
1244 /* Dump textual representation of HSA IL in HBB to stderr. */
1246 DEBUG_FUNCTION void
1247 debug_hsa_bb (hsa_bb *hbb)
1249 dump_hsa_bb (stderr, hbb);
1252 /* Dump textual representation of HSA IL of the current function to stderr. */
1254 DEBUG_FUNCTION void
1255 debug_hsa_cfun (void)
1257 dump_hsa_cfun (stderr);
1260 /* Dump textual representation of an HSA operand to stderr. */
1262 DEBUG_FUNCTION void
1263 debug_hsa_operand (hsa_op_base *opc)
1265 dump_hsa_operand (stderr, opc, true);
1266 fprintf (stderr, "\n");
1269 /* Dump textual representation of as HSA symbol. */
1271 DEBUG_FUNCTION void
1272 debug_hsa_symbol (hsa_symbol *symbol)
1274 dump_hsa_symbol (stderr, symbol);
1275 fprintf (stderr, "\n");