|
111
|
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 }
|
