gcc/hsa-dump.c

   1 /* Infrastructure to dump our HSAIL IL
   2    Copyright (C) 2013-2019 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 "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   char buf[64];
 780   if (symbol->m_name)
 781     name = symbol->m_name;
 782   else
 783     {
 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 }