xref: /netbsd-src/external/gpl3/gcc.old/dist/gcc/hsa-dump.c (revision d90047b5d07facf36e6c01dcc0bded8997ce9cc2) 
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>.
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 "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"
37 
38 /* Return textual name of TYPE.  */
39 
40 static const char *
41 hsa_type_name (BrigType16_t type)
42 {
43   switch (type)
44     {
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";
143     }
144 }
145 
146 /* Return textual name of OPCODE.  */
147 
148 static const char *
149 hsa_opcode_name (BrigOpcode16_t opcode)
150 {
151   switch (opcode)
152     {
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";
423     }
424 }
425 
426 /* Return textual name of SEG.  */
427 
428 const char *
429 hsa_seg_name (BrigSegment8_t seg)
430 {
431   switch (seg)
432     {
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";
453     }
454 }
455 
456 /* Return textual name of CMPOP.  */
457 
458 static const char *
459 hsa_cmpop_name (BrigCompareOperation8_t cmpop)
460 {
461   switch (cmpop)
462     {
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";
521     }
522 }
523 
524 /* Return textual name for memory order.  */
525 
526 static const char *
527 hsa_memsem_name (enum BrigMemoryOrder mo)
528 {
529   switch (mo)
530     {
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";
543     }
544 }
545 
546 /* Return textual name for memory scope.  */
547 
548 static const char *
549 hsa_memscope_name (enum BrigMemoryScope scope)
550 {
551   switch (scope)
552     {
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";
567     }
568 }
569 
570 /* Return textual name for atomic operation.  */
571 
572 static const char *
573 hsa_m_atomicop_name (enum BrigAtomicOperation op)
574 {
575   switch (op)
576     {
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";
621     }
622 }
623 
624 /* Return textual name for atomic operation.  */
625 
626 static const char *
627 hsa_width_specifier_name (BrigWidth8_t width)
628 {
629   switch (width)
630     {
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";
703     }
704 }
705 
706 /* Dump textual representation of HSA IL register REG to file F.  */
707 
708 static void
709 dump_hsa_reg (FILE *f, hsa_op_reg *reg, bool dump_type = false)
710 {
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));
717 }
718 
719 /* Dump textual representation of HSA IL immediate operand IMM to file F.  */
720 
721 static void
722 dump_hsa_immed (FILE *f, hsa_op_immed *imm)
723 {
724   bool unsigned_int_type
725     = (BRIG_TYPE_U8 | BRIG_TYPE_U16 | BRIG_TYPE_U32 | BRIG_TYPE_U64)
726     & imm->m_type;
727 
728   if (imm->m_tree_value)
729     print_generic_expr (f, imm->m_tree_value, 0);
730   else
731     {
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);
737     }
738 
739   fprintf (f, " (%s)", hsa_type_name (imm->m_type));
740 }
741 
742 /* Dump textual representation of HSA IL address operand ADDR to file F.  */
743 
744 static void
745 dump_hsa_address (FILE *f, hsa_op_address *addr)
746 {
747   bool sth = false;
748 
749   if (addr->m_symbol)
750     {
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);
757     }
758 
759   if (addr->m_reg)
760     {
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, "]");
767     }
768   else if (!sth || addr->m_imm_offset != 0)
769     fprintf (f, "[" HOST_WIDE_INT_PRINT_DEC "]", addr->m_imm_offset);
770 }
771 
772 /* Dump textual representation of HSA IL symbol SYMBOL to file F.  */
773 
774 static void
775 dump_hsa_symbol (FILE *f, hsa_symbol *symbol)
776 {
777   const char *name;
778   if (symbol->m_name)
779     name = symbol->m_name;
780   else
781     {
782       char buf[64];
783       sprintf (buf, "__%s_%i", hsa_seg_name (symbol->m_segment),
784 	       symbol->m_name_number);
785 
786       name = buf;
787     }
788 
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);
792 
793   if (symbol->m_type & BRIG_TYPE_ARRAY_MASK)
794     fprintf (f, "[%lu]", (unsigned long) symbol->m_dim);
795 
796   if (symbol->m_directive_offset)
797     fprintf (f, "             /* BRIG offset: %u */", symbol->m_directive_offset);
798 }
799 
800 /* Dump textual representation of HSA IL operand OP to file F.  */
801 
802 static void
803 dump_hsa_operand (FILE *f, hsa_op_base *op, bool dump_reg_type = false)
804 {
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");
813 }
814 
815 /* Dump textual representation of HSA IL operands in VEC to file F.  */
816 
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)
820 {
821   if (end == -1)
822     end = insn->operand_count ();
823 
824   for (int i = start; i < end; i++)
825     {
826       dump_hsa_operand (f, insn->get_op (i), dump_reg_type);
827       if (i != end - 1)
828 	fprintf (f, ", ");
829     }
830 }
831 
832 /* Indent F stream with INDENT spaces.  */
833 
834 static void indent_stream (FILE *f, int indent)
835 {
836   for (int i = 0; i < indent; i++)
837     fputc (' ', f);
838 }
839 
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.  */
843 
844 static void
845 dump_hsa_insn_1 (FILE *f, hsa_insn_basic *insn, int *indent)
846 {
847   gcc_checking_assert (insn);
848 
849   if (insn->m_number)
850     fprintf (f, "%5d: ", insn->m_number);
851 
852   indent_stream (f, *indent);
853 
854   if (is_a <hsa_insn_phi *> (insn))
855     {
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++)
862 	{
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);
870 	}
871       fprintf (f, ">");
872     }
873   else if (is_a <hsa_insn_signal *> (insn))
874     {
875       hsa_insn_signal *mem = as_a <hsa_insn_signal *> (insn);
876 
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));
882 
883       dump_hsa_operands (f, mem);
884     }
885 
886   else if (is_a <hsa_insn_atomic *> (insn))
887     {
888       hsa_insn_atomic *mem = as_a <hsa_insn_atomic *> (insn);
889 
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));
896 
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));
906 
907       dump_hsa_operands (f, mem);
908     }
909   else if (is_a <hsa_insn_mem *> (insn))
910     {
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));
913 
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));
922 
923       dump_hsa_operand (f, mem->get_op (0));
924       fprintf (f, ", ");
925       dump_hsa_address (f, addr);
926     }
927   else if (insn->m_opcode == BRIG_OPCODE_LDA)
928     {
929       hsa_op_address *addr = as_a <hsa_op_address *> (insn->get_op (1));
930 
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));
935 
936       dump_hsa_operand (f, insn->get_op (0));
937       fprintf (f, ", ");
938       dump_hsa_address (f, addr);
939     }
940   else if (is_a <hsa_insn_seg *> (insn))
941     {
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));
949     }
950   else if (is_a <hsa_insn_cmp *> (insn))
951     {
952       hsa_insn_cmp *cmp = as_a <hsa_insn_cmp *> (insn);
953       BrigType16_t src_type;
954 
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;
959 
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));
968     }
969   else if (is_a <hsa_insn_cbr *> (insn))
970     {
971       hsa_insn_cbr *br = as_a <hsa_insn_cbr *> (insn);
972       basic_block target = NULL;
973       edge_iterator ei;
974       edge e;
975 
976       fprintf (f, "%s ", hsa_opcode_name (br->m_opcode));
977       if (br->m_opcode == BRIG_OPCODE_CBR)
978 	{
979 	  dump_hsa_reg (f, as_a <hsa_op_reg *> (br->get_op (0)));
980 	  fprintf (f, ", ");
981 	}
982 
983       FOR_EACH_EDGE (e, ei, br->m_bb->succs)
984 	if (e->flags & EDGE_TRUE_VALUE)
985 	  {
986 	    target = e->dest;
987 	    break;
988 	  }
989       fprintf (f, "BB %i", hsa_bb_for_bb (target)->m_index);
990     }
991   else if (is_a <hsa_insn_sbr *> (insn))
992     {
993       hsa_insn_sbr *sbr = as_a <hsa_insn_sbr *> (insn);
994 
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, ", [");
998 
999       for (unsigned i = 0; i < sbr->m_jump_table.length (); i++)
1000 	{
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, ", ");
1004 	}
1005     }
1006   else if (is_a <hsa_insn_br *> (insn))
1007     {
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));
1011     }
1012   else if (is_a <hsa_insn_arg_block *> (insn))
1013     {
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 ? '{' : '}';
1017 
1018       if (start_p)
1019 	{
1020 	  *indent += 2;
1021 	  indent_stream (f, 2);
1022 	}
1023 
1024       if (!start_p)
1025 	*indent -= 2;
1026 
1027       fprintf (f, "%c", c);
1028     }
1029   else if (is_a <hsa_insn_call *> (insn))
1030     {
1031       hsa_insn_call *call = as_a <hsa_insn_call *> (insn);
1032       if (call->m_called_function)
1033 	{
1034 	  const char *name = hsa_get_declaration_name (call->m_called_function);
1035 	  fprintf (f, "call &%s", name);
1036 	}
1037       else
1038 	{
1039 	  char *name = call->m_called_internal_fn->name ();
1040 	  fprintf (f, "call &%s", name);
1041 	  free (name);
1042 	}
1043 
1044       if (call->m_output_arg)
1045 	fprintf (f, "(%%res) ");
1046 
1047       fprintf (f, "(");
1048       for (unsigned i = 0; i < call->m_input_args.length (); i++)
1049 	{
1050 	  fprintf (f, "%%__arg_%u", i);
1051 
1052 	  if (i != call->m_input_args.length () - 1)
1053 	    fprintf (f, ", ");
1054 	}
1055       fprintf (f, ")");
1056     }
1057   else if (is_a <hsa_insn_comment *> (insn))
1058     {
1059       hsa_insn_comment *c = as_a <hsa_insn_comment *> (insn);
1060       fprintf (f, "%s", c->m_comment);
1061     }
1062   else if (is_a <hsa_insn_srctype *> (insn))
1063     {
1064       hsa_insn_srctype *srctype = as_a <hsa_insn_srctype *> (insn);
1065 
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));
1069 
1070       dump_hsa_operands (f, insn);
1071     }
1072   else if (is_a <hsa_insn_packed *> (insn))
1073     {
1074       hsa_insn_packed *packed = as_a <hsa_insn_packed *> (insn);
1075 
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));
1080 
1081       if (packed->m_opcode == BRIG_OPCODE_COMBINE)
1082 	{
1083 	  dump_hsa_operand (f, insn->get_op (0));
1084 	  fprintf (f, ", (");
1085 	  dump_hsa_operands (f, insn, 1);
1086 	  fprintf (f, ")");
1087 	}
1088       else if (packed->m_opcode == BRIG_OPCODE_EXPAND)
1089 	{
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));
1094 
1095 	}
1096       else
1097 	gcc_unreachable ();
1098     }
1099   else if (is_a <hsa_insn_alloca *> (insn))
1100     {
1101       hsa_insn_alloca *alloca = as_a <hsa_insn_alloca *> (insn);
1102 
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));
1106 
1107       dump_hsa_operands (f, insn);
1108     }
1109   else if (hsa_insn_queue *qi = dyn_cast <hsa_insn_queue *> (insn))
1110     {
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));
1115 
1116       dump_hsa_operands (f, qi);
1117     }
1118   else
1119     {
1120       fprintf (f, "%s_%s ", hsa_opcode_name (insn->m_opcode),
1121 	       hsa_type_name (insn->m_type));
1122 
1123       dump_hsa_operands (f, insn);
1124     }
1125 
1126   if (insn->m_brig_offset)
1127     {
1128       fprintf (f, "             /* BRIG offset: %u", insn->m_brig_offset);
1129 
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);
1132 
1133       fprintf (f, " */");
1134     }
1135 
1136   fprintf (f, "\n");
1137 }
1138 
1139 /* Dump textual representation of HSA IL instruction INSN to file F.  */
1140 
1141 void
1142 dump_hsa_insn (FILE *f, hsa_insn_basic *insn)
1143 {
1144   int indent = 0;
1145   dump_hsa_insn_1 (f, insn, &indent);
1146 }
1147 
1148 /* Dump textual representation of HSA IL in HBB to file F.  */
1149 
1150 void
1151 dump_hsa_bb (FILE *f, hsa_bb *hbb)
1152 {
1153   hsa_insn_basic *insn;
1154   edge_iterator ei;
1155   edge e;
1156   basic_block true_bb = NULL, other = NULL;
1157 
1158   fprintf (f, "BB %i:\n", hbb->m_index);
1159 
1160   int indent = 2;
1161   for (insn = hbb->m_first_phi; insn; insn = insn->m_next)
1162     dump_hsa_insn_1 (f, insn, &indent);
1163 
1164   for (insn = hbb->m_first_insn; insn; insn = insn->m_next)
1165     dump_hsa_insn_1 (f, insn, &indent);
1166 
1167   if (hbb->m_last_insn && is_a <hsa_insn_sbr *> (hbb->m_last_insn))
1168     goto exit;
1169 
1170   FOR_EACH_EDGE (e, ei, hbb->m_bb->succs)
1171     if (e->flags & EDGE_TRUE_VALUE)
1172       {
1173 	gcc_assert (!true_bb);
1174 	true_bb = e->dest;
1175       }
1176     else
1177       {
1178 	gcc_assert (!other);
1179 	other = e->dest;
1180       }
1181 
1182   if (true_bb)
1183     {
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");
1187     }
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");
1191 
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");
1198 
1199 exit:
1200   fprintf (f, "\n");
1201 }
1202 
1203 /* Dump textual representation of HSA IL of the current function to file F.  */
1204 
1205 void
1206 dump_hsa_cfun (FILE *f)
1207 {
1208   basic_block bb;
1209 
1210   if (hsa_cfun->m_global_symbols.length () > 0)
1211     fprintf (f, "\nHSAIL in global scope\n");
1212 
1213   for (unsigned i = 0; i < hsa_cfun->m_global_symbols.length (); i++)
1214     {
1215       fprintf (f, "  ");
1216       dump_hsa_symbol (f, hsa_cfun->m_global_symbols[i]);
1217       fprintf (f, "\n");
1218     }
1219 
1220   fprintf (f, "\nHSAIL IL for %s\n", hsa_cfun->m_name);
1221 
1222   for (unsigned i = 0; i < hsa_cfun->m_private_variables.length (); i++)
1223     {
1224       fprintf (f, "  ");
1225       dump_hsa_symbol (f, hsa_cfun->m_private_variables[i]);
1226       fprintf (f, "\n");
1227     }
1228 
1229   FOR_ALL_BB_FN (bb, cfun)
1230     {
1231       hsa_bb *hbb = (struct hsa_bb *) bb->aux;
1232       dump_hsa_bb (f, hbb);
1233     }
1234 }
1235 
1236 /* Dump textual representation of HSA IL instruction INSN to stderr.  */
1237 
1238 DEBUG_FUNCTION void
1239 debug_hsa_insn (hsa_insn_basic *insn)
1240 {
1241   dump_hsa_insn (stderr, insn);
1242 }
1243 
1244 /* Dump textual representation of HSA IL in HBB to stderr.  */
1245 
1246 DEBUG_FUNCTION void
1247 debug_hsa_bb (hsa_bb *hbb)
1248 {
1249   dump_hsa_bb (stderr, hbb);
1250 }
1251 
1252 /* Dump textual representation of HSA IL of the current function to stderr.  */
1253 
1254 DEBUG_FUNCTION void
1255 debug_hsa_cfun (void)
1256 {
1257   dump_hsa_cfun (stderr);
1258 }
1259 
1260 /* Dump textual representation of an HSA operand to stderr.  */
1261 
1262 DEBUG_FUNCTION void
1263 debug_hsa_operand (hsa_op_base *opc)
1264 {
1265   dump_hsa_operand (stderr, opc, true);
1266   fprintf (stderr, "\n");
1267 }
1268 
1269 /* Dump textual representation of as HSA symbol.  */
1270 
1271 DEBUG_FUNCTION void
1272 debug_hsa_symbol (hsa_symbol *symbol)
1273 {
1274   dump_hsa_symbol (stderr, symbol);
1275   fprintf (stderr, "\n");
1276 }
1277