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