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