gcc/hsa-dump.c

   1 /* Infrastructure to dump our HSAIL IL
   2    Copyright (C) 2013-2020 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 "function.h"
  31 #include "cfg.h"
  32 #include "dumpfile.h"
  33 #include "gimple-pretty-print.h"
  34 #include "cgraph.h"
  35 #include "print-tree.h"
  36 #include "alloc-pool.h"
  37 #include "symbol-summary.h"
  38 #include "hsa-common.h"
  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
 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
 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)
 731     print_generic_expr (f, imm->m_tree_value);
 732   else
 733     {
 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;
 780   char buf[64];
 781   if (symbol->m_name)
 782     name = symbol->m_name;
 783   else
 784     {
 785       sprintf (buf, "__%s_%i", hsa_seg_name (symbol->m_segment),
 786                symbol->m_name_number);
 787
 788       name = buf;
 789     }
 790
 791   fprintf (f, "align(%u) %s_%s %s", hsa_byte_alignment (symbol->m_align),
 792            hsa_seg_name (symbol->m_segment),
 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);
 797
 798   if (symbol->m_directive_offset)
 799     fprintf (f, "             /* BRIG offset: %u */", symbol->m_directive_offset);
 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));
 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));
 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     }
 971   else if (is_a <hsa_insn_cbr *> (insn))
 972     {
 973       hsa_insn_cbr *br = as_a <hsa_insn_cbr *> (insn);
 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         }
1007     }
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     }
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     }
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     }
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)
1232     {
1233       hsa_bb *hbb = (class hsa_bb *) bb->aux;
1234       dump_hsa_bb (f, hbb);
1235     }
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 }