1 /* Infrastructure to dump our HSAIL IL 2 Copyright (C) 2013-2018 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 } 1278