]>
Commit | Line | Data |
---|---|---|
b2b40051 | 1 | /* Infrastructure to dump our HSAIL IL |
8d9254fc | 2 | Copyright (C) 2013-2020 Free Software Foundation, Inc. |
b2b40051 MJ |
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" | |
3995f3a2 | 29 | #include "basic-block.h" |
b2b40051 | 30 | #include "function.h" |
e144a2b3 | 31 | #include "cfg.h" |
b2b40051 MJ |
32 | #include "dumpfile.h" |
33 | #include "gimple-pretty-print.h" | |
34 | #include "cgraph.h" | |
35 | #include "print-tree.h" | |
a895e6d7 | 36 | #include "alloc-pool.h" |
b2b40051 | 37 | #include "symbol-summary.h" |
13293add | 38 | #include "hsa-common.h" |
b2b40051 MJ |
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 | ||
56b1c60e MJ |
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 | ||
b2b40051 MJ |
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) | |
ef6cb4c7 | 731 | print_generic_expr (f, imm->m_tree_value); |
b2b40051 MJ |
732 | else |
733 | { | |
b2b40051 MJ |
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; | |
723f415e | 780 | char buf[64]; |
b2b40051 MJ |
781 | if (symbol->m_name) |
782 | name = symbol->m_name; | |
783 | else | |
784 | { | |
b2b40051 MJ |
785 | sprintf (buf, "__%s_%i", hsa_seg_name (symbol->m_segment), |
786 | symbol->m_name_number); | |
787 | ||
788 | name = buf; | |
789 | } | |
790 | ||
320c1a36 ML |
791 | fprintf (f, "align(%u) %s_%s %s", hsa_byte_alignment (symbol->m_align), |
792 | hsa_seg_name (symbol->m_segment), | |
b2b40051 MJ |
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); | |
60d15bae ML |
797 | |
798 | if (symbol->m_directive_offset) | |
799 | fprintf (f, " /* BRIG offset: %u */", symbol->m_directive_offset); | |
b2b40051 MJ |
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)); | |
56b1c60e MJ |
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)); | |
b2b40051 MJ |
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 | } | |
56b1c60e | 971 | else if (is_a <hsa_insn_cbr *> (insn)) |
b2b40051 | 972 | { |
56b1c60e | 973 | hsa_insn_cbr *br = as_a <hsa_insn_cbr *> (insn); |
b2b40051 MJ |
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 | } | |
b2b40051 | 1007 | } |
56b1c60e MJ |
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 | } | |
b2b40051 MJ |
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 | } | |
56b1c60e MJ |
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 | } | |
b2b40051 MJ |
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) | |
730c9e75 | 1232 | { |
99b1c316 | 1233 | hsa_bb *hbb = (class hsa_bb *) bb->aux; |
730c9e75 NS |
1234 | dump_hsa_bb (f, hbb); |
1235 | } | |
b2b40051 MJ |
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 | } |