gcc/hsa-dump.c

   1 /* Infrastructure to dump our HSAIL IL
   2    Copyright (C) 2013-2017 Free Software Foundation, Inc.
   3    Contributed by Martin Jambor <mjambor@suse.cz> and
   4    Martin Liska <mliska@suse.cz>.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "is-a.h"
  27 #include "vec.h"
  28 #include "tree.h"
  29 #include "cfg.h"
  30 #include "function.h"
  31 #include "dumpfile.h"
  32 #include "gimple-pretty-print.h"
  33 #include "cgraph.h"
  34 #include "print-tree.h"
  35 #include "symbol-summary.h"
  36 #include "hsa-common.h"
  37
  38 /* Return textual name of TYPE.  */
  39
  40 static const char *
  41 hsa_type_name (BrigType16_t type)
  42 {
  43   switch (type)
  44     {
  45     case BRIG_TYPE_NONE:
  46       return "none";
  47     case BRIG_TYPE_U8:
  48       return "u8";
  49     case BRIG_TYPE_U16:
  50       return "u16";
  51     case BRIG_TYPE_U32:
  52       return "u32";
  53     case BRIG_TYPE_U64:
  54       return "u64";
  55     case BRIG_TYPE_S8:
  56       return "s8";
  57     case BRIG_TYPE_S16:
  58       return "s16";
  59     case BRIG_TYPE_S32:
  60       return "s32";
  61     case BRIG_TYPE_S64:
  62       return "s64";
  63     case BRIG_TYPE_F16:
  64       return "f16";
  65     case BRIG_TYPE_F32:
  66       return "f32";
  67     case BRIG_TYPE_F64:
  68       return "f64";
  69     case BRIG_TYPE_B1:
  70       return "b1";
  71     case BRIG_TYPE_B8:
  72       return "b8";
  73     case BRIG_TYPE_B16:
  74       return "b16";
  75     case BRIG_TYPE_B32:
  76       return "b32";
  77     case BRIG_TYPE_B64:
  78       return "b64";
  79     case BRIG_TYPE_B128:
  80       return "b128";
  81     case BRIG_TYPE_SAMP:
  82       return "samp";
  83     case BRIG_TYPE_ROIMG:
  84       return "roimg";
  85     case BRIG_TYPE_WOIMG:
  86       return "woimg";
  87     case BRIG_TYPE_RWIMG:
  88       return "rwimg";
  89     case BRIG_TYPE_SIG32:
  90       return "sig32";
  91     case BRIG_TYPE_SIG64:
  92       return "sig64";
  93     case BRIG_TYPE_U8X4:
  94       return "u8x4";
  95     case BRIG_TYPE_U8X8:
  96       return "u8x8";
  97     case BRIG_TYPE_U8X16:
  98       return "u8x16";
  99     case BRIG_TYPE_U16X2:
 100       return "u16x2";
 101     case BRIG_TYPE_U16X4:
 102       return "u16x4";
 103     case BRIG_TYPE_U16X8:
 104       return "u16x8";
 105     case BRIG_TYPE_U32X2:
 106       return "u32x2";
 107     case BRIG_TYPE_U32X4:
 108       return "u32x4";
 109     case BRIG_TYPE_U64X2:
 110       return "u64x2";
 111     case BRIG_TYPE_S8X4:
 112       return "s8x4";
 113     case BRIG_TYPE_S8X8:
 114       return "s8x8";
 115     case BRIG_TYPE_S8X16:
 116       return "s8x16";
 117     case BRIG_TYPE_S16X2:
 118       return "s16x2";
 119     case BRIG_TYPE_S16X4:
 120       return "s16x4";
 121     case BRIG_TYPE_S16X8:
 122       return "s16x8";
 123     case BRIG_TYPE_S32X2:
 124       return "s32x2";
 125     case BRIG_TYPE_S32X4:
 126       return "s32x4";
 127     case BRIG_TYPE_S64X2:
 128       return "s64x2";
 129     case BRIG_TYPE_F16X2:
 130       return "f16x2";
 131     case BRIG_TYPE_F16X4:
 132       return "f16x4";
 133     case BRIG_TYPE_F16X8:
 134       return "f16x8";
 135     case BRIG_TYPE_F32X2:
 136       return "f32x2";
 137     case BRIG_TYPE_F32X4:
 138       return "f32x4";
 139     case BRIG_TYPE_F64X2:
 140       return "f64x2";
 141     default:
 142       return "UNKNOWN_TYPE";
 143     }
 144 }
 145
 146 /* Return textual name of OPCODE.  */
 147
 148 static const char *
 149 hsa_opcode_name (BrigOpcode16_t opcode)
 150 {
 151   switch (opcode)
 152     {
 153     case BRIG_OPCODE_NOP:
 154       return "nop";
 155     case BRIG_OPCODE_ABS:
 156       return "abs";
 157     case BRIG_OPCODE_ADD:
 158       return "add";
 159     case BRIG_OPCODE_BORROW:
 160       return "borrow";
 161     case BRIG_OPCODE_CARRY:
 162       return "carry";
 163     case BRIG_OPCODE_CEIL:
 164       return "ceil";
 165     case BRIG_OPCODE_COPYSIGN:
 166       return "copysign";
 167     case BRIG_OPCODE_DIV:
 168       return "div";
 169     case BRIG_OPCODE_FLOOR:
 170       return "floor";
 171     case BRIG_OPCODE_FMA:
 172       return "fma";
 173     case BRIG_OPCODE_FRACT:
 174       return "fract";
 175     case BRIG_OPCODE_MAD:
 176       return "mad";
 177     case BRIG_OPCODE_MAX:
 178       return "max";
 179     case BRIG_OPCODE_MIN:
 180       return "min";
 181     case BRIG_OPCODE_MUL:
 182       return "mul";
 183     case BRIG_OPCODE_MULHI:
 184       return "mulhi";
 185     case BRIG_OPCODE_NEG:
 186       return "neg";
 187     case BRIG_OPCODE_REM:
 188       return "rem";
 189     case BRIG_OPCODE_RINT:
 190       return "rint";
 191     case BRIG_OPCODE_SQRT:
 192       return "sqrt";
 193     case BRIG_OPCODE_SUB:
 194       return "sub";
 195     case BRIG_OPCODE_TRUNC:
 196       return "trunc";
 197     case BRIG_OPCODE_MAD24:
 198       return "mad24";
 199     case BRIG_OPCODE_MAD24HI:
 200       return "mad24hi";
 201     case BRIG_OPCODE_MUL24:
 202       return "mul24";
 203     case BRIG_OPCODE_MUL24HI:
 204       return "mul24hi";
 205     case BRIG_OPCODE_SHL:
 206       return "shl";
 207     case BRIG_OPCODE_SHR:
 208       return "shr";
 209     case BRIG_OPCODE_AND:
 210       return "and";
 211     case BRIG_OPCODE_NOT:
 212       return "not";
 213     case BRIG_OPCODE_OR:
 214       return "or";
 215     case BRIG_OPCODE_POPCOUNT:
 216       return "popcount";
 217     case BRIG_OPCODE_XOR:
 218       return "xor";
 219     case BRIG_OPCODE_BITEXTRACT:
 220       return "bitextract";
 221     case BRIG_OPCODE_BITINSERT:
 222       return "bitinsert";
 223     case BRIG_OPCODE_BITMASK:
 224       return "bitmask";
 225     case BRIG_OPCODE_BITREV:
 226       return "bitrev";
 227     case BRIG_OPCODE_BITSELECT:
 228       return "bitselect";
 229     case BRIG_OPCODE_FIRSTBIT:
 230       return "firstbit";
 231     case BRIG_OPCODE_LASTBIT:
 232       return "lastbit";
 233     case BRIG_OPCODE_COMBINE:
 234       return "combine";
 235     case BRIG_OPCODE_EXPAND:
 236       return "expand";
 237     case BRIG_OPCODE_LDA:
 238       return "lda";
 239     case BRIG_OPCODE_MOV:
 240       return "mov";
 241     case BRIG_OPCODE_SHUFFLE:
 242       return "shuffle";
 243     case BRIG_OPCODE_UNPACKHI:
 244       return "unpackhi";
 245     case BRIG_OPCODE_UNPACKLO:
 246       return "unpacklo";
 247     case BRIG_OPCODE_PACK:
 248       return "pack";
 249     case BRIG_OPCODE_UNPACK:
 250       return "unpack";
 251     case BRIG_OPCODE_CMOV:
 252       return "cmov";
 253     case BRIG_OPCODE_CLASS:
 254       return "class";
 255     case BRIG_OPCODE_NCOS:
 256       return "ncos";
 257     case BRIG_OPCODE_NEXP2:
 258       return "nexp2";
 259     case BRIG_OPCODE_NFMA:
 260       return "nfma";
 261     case BRIG_OPCODE_NLOG2:
 262       return "nlog2";
 263     case BRIG_OPCODE_NRCP:
 264       return "nrcp";
 265     case BRIG_OPCODE_NRSQRT:
 266       return "nrsqrt";
 267     case BRIG_OPCODE_NSIN:
 268       return "nsin";
 269     case BRIG_OPCODE_NSQRT:
 270       return "nsqrt";
 271     case BRIG_OPCODE_BITALIGN:
 272       return "bitalign";
 273     case BRIG_OPCODE_BYTEALIGN:
 274       return "bytealign";
 275     case BRIG_OPCODE_PACKCVT:
 276       return "packcvt";
 277     case BRIG_OPCODE_UNPACKCVT:
 278       return "unpackcvt";
 279     case BRIG_OPCODE_LERP:
 280       return "lerp";
 281     case BRIG_OPCODE_SAD:
 282       return "sad";
 283     case BRIG_OPCODE_SADHI:
 284       return "sadhi";
 285     case BRIG_OPCODE_SEGMENTP:
 286       return "segmentp";
 287     case BRIG_OPCODE_FTOS:
 288       return "ftos";
 289     case BRIG_OPCODE_STOF:
 290       return "stof";
 291     case BRIG_OPCODE_CMP:
 292       return "cmp";
 293     case BRIG_OPCODE_CVT:
 294       return "cvt";
 295     case BRIG_OPCODE_LD:
 296       return "ld";
 297     case BRIG_OPCODE_ST:
 298       return "st";
 299     case BRIG_OPCODE_ATOMIC:
 300       return "atomic";
 301     case BRIG_OPCODE_ATOMICNORET:
 302       return "atomicnoret";
 303     case BRIG_OPCODE_SIGNAL:
 304       return "signal";
 305     case BRIG_OPCODE_SIGNALNORET:
 306       return "signalnoret";
 307     case BRIG_OPCODE_MEMFENCE:
 308       return "memfence";
 309     case BRIG_OPCODE_RDIMAGE:
 310       return "rdimage";
 311     case BRIG_OPCODE_LDIMAGE:
 312       return "ldimage";
 313     case BRIG_OPCODE_STIMAGE:
 314       return "stimage";
 315     case BRIG_OPCODE_QUERYIMAGE:
 316       return "queryimage";
 317     case BRIG_OPCODE_QUERYSAMPLER:
 318       return "querysampler";
 319     case BRIG_OPCODE_CBR:
 320       return "cbr";
 321     case BRIG_OPCODE_BR:
 322       return "br";
 323     case BRIG_OPCODE_SBR:
 324       return "sbr";
 325     case BRIG_OPCODE_BARRIER:
 326       return "barrier";
 327     case BRIG_OPCODE_WAVEBARRIER:
 328       return "wavebarrier";
 329     case BRIG_OPCODE_ARRIVEFBAR:
 330       return "arrivefbar";
 331     case BRIG_OPCODE_INITFBAR:
 332       return "initfbar";
 333     case BRIG_OPCODE_JOINFBAR:
 334       return "joinfbar";
 335     case BRIG_OPCODE_LEAVEFBAR:
 336       return "leavefbar";
 337     case BRIG_OPCODE_RELEASEFBAR:
 338       return "releasefbar";
 339     case BRIG_OPCODE_WAITFBAR:
 340       return "waitfbar";
 341     case BRIG_OPCODE_LDF:
 342       return "ldf";
 343     case BRIG_OPCODE_ACTIVELANECOUNT:
 344       return "activelanecount";
 345     case BRIG_OPCODE_ACTIVELANEID:
 346       return "activelaneid";
 347     case BRIG_OPCODE_ACTIVELANEMASK:
 348       return "activelanemask";
 349     case BRIG_OPCODE_CALL:
 350       return "call";
 351     case BRIG_OPCODE_SCALL:
 352       return "scall";
 353     case BRIG_OPCODE_ICALL:
 354       return "icall";
 355     case BRIG_OPCODE_RET:
 356       return "ret";
 357     case BRIG_OPCODE_ALLOCA:
 358       return "alloca";
 359     case BRIG_OPCODE_CURRENTWORKGROUPSIZE:
 360       return "currentworkgroupsize";
 361     case BRIG_OPCODE_DIM:
 362       return "dim";
 363     case BRIG_OPCODE_GRIDGROUPS:
 364       return "gridgroups";
 365     case BRIG_OPCODE_GRIDSIZE:
 366       return "gridsize";
 367     case BRIG_OPCODE_PACKETCOMPLETIONSIG:
 368       return "packetcompletionsig";
 369     case BRIG_OPCODE_PACKETID:
 370       return "packetid";
 371     case BRIG_OPCODE_WORKGROUPID:
 372       return "workgroupid";
 373     case BRIG_OPCODE_WORKGROUPSIZE:
 374       return "workgroupsize";
 375     case BRIG_OPCODE_WORKITEMABSID:
 376       return "workitemabsid";
 377     case BRIG_OPCODE_WORKITEMFLATABSID:
 378       return "workitemflatabsid";
 379     case BRIG_OPCODE_WORKITEMFLATID:
 380       return "workitemflatid";
 381     case BRIG_OPCODE_WORKITEMID:
 382       return "workitemid";
 383     case BRIG_OPCODE_CLEARDETECTEXCEPT:
 384       return "cleardetectexcept";
 385     case BRIG_OPCODE_GETDETECTEXCEPT:
 386       return "getdetectexcept";
 387     case BRIG_OPCODE_SETDETECTEXCEPT:
 388       return "setdetectexcept";
 389     case BRIG_OPCODE_ADDQUEUEWRITEINDEX:
 390       return "addqueuewriteindex";
 391     case BRIG_OPCODE_CASQUEUEWRITEINDEX:
 392       return "casqueuewriteindex";
 393     case BRIG_OPCODE_LDQUEUEREADINDEX:
 394       return "ldqueuereadindex";
 395     case BRIG_OPCODE_LDQUEUEWRITEINDEX:
 396       return "ldqueuewriteindex";
 397     case BRIG_OPCODE_STQUEUEREADINDEX:
 398       return "stqueuereadindex";
 399     case BRIG_OPCODE_STQUEUEWRITEINDEX:
 400       return "stqueuewriteindex";
 401     case BRIG_OPCODE_CLOCK:
 402       return "clock";
 403     case BRIG_OPCODE_CUID:
 404       return "cuid";
 405     case BRIG_OPCODE_DEBUGTRAP:
 406       return "debugtrap";
 407     case BRIG_OPCODE_GROUPBASEPTR:
 408       return "groupbaseptr";
 409     case BRIG_OPCODE_KERNARGBASEPTR:
 410       return "kernargbaseptr";
 411     case BRIG_OPCODE_LANEID:
 412       return "laneid";
 413     case BRIG_OPCODE_MAXCUID:
 414       return "maxcuid";
 415     case BRIG_OPCODE_MAXWAVEID:
 416       return "maxwaveid";
 417     case BRIG_OPCODE_NULLPTR:
 418       return "nullptr";
 419     case BRIG_OPCODE_WAVEID:
 420       return "waveid";
 421     default:
 422       return "UNKNOWN_OPCODE";
 423     }
 424 }
 425
 426 /* Return textual name of SEG.  */
 427
 428 const char *
 429 hsa_seg_name (BrigSegment8_t seg)
 430 {
 431   switch (seg)
 432     {
 433     case BRIG_SEGMENT_NONE:
 434       return "none";
 435     case BRIG_SEGMENT_FLAT:
 436       return "flat";
 437     case BRIG_SEGMENT_GLOBAL:
 438       return "global";
 439     case BRIG_SEGMENT_READONLY:
 440       return "readonly";
 441     case BRIG_SEGMENT_KERNARG:
 442       return "kernarg";
 443     case BRIG_SEGMENT_GROUP:
 444       return "group";
 445     case BRIG_SEGMENT_PRIVATE:
 446       return "private";
 447     case BRIG_SEGMENT_SPILL:
 448       return "spill";
 449     case BRIG_SEGMENT_ARG:
 450       return "arg";
 451     default:
 452       return "UNKNOWN_SEGMENT";
 453     }
 454 }
 455
 456 /* Return textual name of CMPOP.  */
 457
 458 static const char *
 459 hsa_cmpop_name (BrigCompareOperation8_t cmpop)
 460 {
 461   switch (cmpop)
 462     {
 463     case BRIG_COMPARE_EQ:
 464       return "eq";
 465     case BRIG_COMPARE_NE:
 466       return "ne";
 467     case BRIG_COMPARE_LT:
 468       return "lt";
 469     case BRIG_COMPARE_LE:
 470       return "le";
 471     case BRIG_COMPARE_GT:
 472       return "gt";
 473     case BRIG_COMPARE_GE:
 474       return "ge";
 475     case BRIG_COMPARE_EQU:
 476       return "equ";
 477     case BRIG_COMPARE_NEU:
 478       return "neu";
 479     case BRIG_COMPARE_LTU:
 480       return "ltu";
 481     case BRIG_COMPARE_LEU:
 482       return "leu";
 483     case BRIG_COMPARE_GTU:
 484       return "gtu";
 485     case BRIG_COMPARE_GEU:
 486       return "geu";
 487     case BRIG_COMPARE_NUM:
 488       return "num";
 489     case BRIG_COMPARE_NAN:
 490       return "nan";
 491     case BRIG_COMPARE_SEQ:
 492       return "seq";
 493     case BRIG_COMPARE_SNE:
 494       return "sne";
 495     case BRIG_COMPARE_SLT:
 496       return "slt";
 497     case BRIG_COMPARE_SLE:
 498       return "sle";
 499     case BRIG_COMPARE_SGT:
 500       return "sgt";
 501     case BRIG_COMPARE_SGE:
 502       return "sge";
 503     case BRIG_COMPARE_SGEU:
 504       return "sgeu";
 505     case BRIG_COMPARE_SEQU:
 506       return "sequ";
 507     case BRIG_COMPARE_SNEU:
 508       return "sneu";
 509     case BRIG_COMPARE_SLTU:
 510       return "sltu";
 511     case BRIG_COMPARE_SLEU:
 512       return "sleu";
 513     case BRIG_COMPARE_SNUM:
 514       return "snum";
 515     case BRIG_COMPARE_SNAN:
 516       return "snan";
 517     case BRIG_COMPARE_SGTU:
 518       return "sgtu";
 519     default:
 520       return "UNKNOWN_COMPARISON";
 521     }
 522 }
 523
 524 /* Return textual name for memory order.  */
 525
 526 static const char *
 527 hsa_memsem_name (enum BrigMemoryOrder mo)
 528 {
 529   switch (mo)
 530     {
 531     case BRIG_MEMORY_ORDER_NONE:
 532       return "";
 533     case BRIG_MEMORY_ORDER_RELAXED:
 534       return "rlx";
 535     case BRIG_MEMORY_ORDER_SC_ACQUIRE:
 536       return "scacq";
 537     case BRIG_MEMORY_ORDER_SC_RELEASE:
 538       return "screl";
 539     case BRIG_MEMORY_ORDER_SC_ACQUIRE_RELEASE:
 540       return "scar";
 541     default:
 542       return "UNKNOWN_MEMORY_ORDER";
 543     }
 544 }
 545
 546 /* Return textual name for memory scope.  */
 547
 548 static const char *
 549 hsa_memscope_name (enum BrigMemoryScope scope)
 550 {
 551   switch (scope)
 552     {
 553     case BRIG_MEMORY_SCOPE_NONE:
 554       return "";
 555     case BRIG_MEMORY_SCOPE_WORKITEM:
 556       return "wi";
 557     case BRIG_MEMORY_SCOPE_WAVEFRONT:
 558       return "wave";
 559     case BRIG_MEMORY_SCOPE_WORKGROUP:
 560       return "wg";
 561     case BRIG_MEMORY_SCOPE_AGENT:
 562       return "agent";
 563     case BRIG_MEMORY_SCOPE_SYSTEM:
 564       return "sys";
 565     default:
 566       return "UNKNOWN_SCOPE";
 567     }
 568 }
 569
 570 /* Return textual name for atomic operation.  */
 571
 572 static const char *
 573 hsa_m_atomicop_name (enum BrigAtomicOperation op)
 574 {
 575   switch (op)
 576     {
 577     case BRIG_ATOMIC_ADD:
 578       return "add";
 579     case BRIG_ATOMIC_AND:
 580       return "and";
 581     case BRIG_ATOMIC_CAS:
 582       return "cas";
 583     case BRIG_ATOMIC_EXCH:
 584       return "exch";
 585     case BRIG_ATOMIC_LD:
 586       return "ld";
 587     case BRIG_ATOMIC_MAX:
 588       return "max";
 589     case BRIG_ATOMIC_MIN:
 590       return "min";
 591     case BRIG_ATOMIC_OR:
 592       return "or";
 593     case BRIG_ATOMIC_ST:
 594       return "st";
 595     case BRIG_ATOMIC_SUB:
 596       return "sub";
 597     case BRIG_ATOMIC_WRAPDEC:
 598       return "wrapdec";
 599     case BRIG_ATOMIC_WRAPINC:
 600       return "wrapinc";
 601     case BRIG_ATOMIC_XOR:
 602       return "xor";
 603     case BRIG_ATOMIC_WAIT_EQ:
 604       return "wait_eq";
 605     case BRIG_ATOMIC_WAIT_NE:
 606       return "wait_ne";
 607     case BRIG_ATOMIC_WAIT_LT:
 608       return "wait_lt";
 609     case BRIG_ATOMIC_WAIT_GTE:
 610       return "wait_gte";
 611     case BRIG_ATOMIC_WAITTIMEOUT_EQ:
 612       return "waittimeout_eq";
 613     case BRIG_ATOMIC_WAITTIMEOUT_NE:
 614       return "waittimeout_ne";
 615     case BRIG_ATOMIC_WAITTIMEOUT_LT:
 616       return "waittimeout_lt";
 617     case BRIG_ATOMIC_WAITTIMEOUT_GTE:
 618       return "waittimeout_gte";
 619     default:
 620       return "UNKNOWN_ATOMIC_OP";
 621     }
 622 }
 623
 624 /* Return textual name for atomic operation.  */
 625
 626 static const char *
 627 hsa_width_specifier_name (BrigWidth8_t width)
 628 {
 629   switch (width)
 630     {
 631     case BRIG_WIDTH_NONE:
 632       return "none";
 633     case BRIG_WIDTH_1:
 634       return "1";
 635     case BRIG_WIDTH_2:
 636       return "2";
 637     case BRIG_WIDTH_4:
 638       return "4";
 639     case BRIG_WIDTH_8:
 640       return "8";
 641     case BRIG_WIDTH_16:
 642       return "16";
 643     case BRIG_WIDTH_32:
 644       return "32";
 645     case BRIG_WIDTH_64:
 646       return "64";
 647     case BRIG_WIDTH_128:
 648       return "128";
 649     case BRIG_WIDTH_256:
 650       return "256";
 651     case BRIG_WIDTH_512:
 652       return "512";
 653     case BRIG_WIDTH_1024:
 654       return "1024";
 655     case BRIG_WIDTH_2048:
 656       return "2048";
 657     case BRIG_WIDTH_4096:
 658       return "4096";
 659     case BRIG_WIDTH_8192:
 660       return "8192";
 661     case BRIG_WIDTH_16384:
 662       return "16384";
 663     case BRIG_WIDTH_32768:
 664       return "32768";
 665     case BRIG_WIDTH_65536:
 666       return "65536";
 667     case BRIG_WIDTH_131072:
 668       return "131072";
 669     case BRIG_WIDTH_262144:
 670       return "262144";
 671     case BRIG_WIDTH_524288:
 672       return "524288";
 673     case BRIG_WIDTH_1048576:
 674       return "1048576";
 675     case BRIG_WIDTH_2097152:
 676       return "2097152";
 677     case BRIG_WIDTH_4194304:
 678       return "4194304";
 679     case BRIG_WIDTH_8388608:
 680       return "8388608";
 681     case BRIG_WIDTH_16777216:
 682       return "16777216";
 683     case BRIG_WIDTH_33554432:
 684       return "33554432";
 685     case BRIG_WIDTH_67108864:
 686       return "67108864";
 687     case BRIG_WIDTH_134217728:
 688       return "134217728";
 689     case BRIG_WIDTH_268435456:
 690       return "268435456";
 691     case BRIG_WIDTH_536870912:
 692       return "536870912";
 693     case BRIG_WIDTH_1073741824:
 694       return "1073741824";
 695     case BRIG_WIDTH_2147483648:
 696       return "2147483648";
 697     case BRIG_WIDTH_WAVESIZE:
 698       return "wavesize";
 699     case BRIG_WIDTH_ALL:
 700       return "all";
 701     default:
 702       return "UNKNOWN_WIDTH";
 703     }
 704 }
 705
 706 /* Dump textual representation of HSA IL register REG to file F.  */
 707
 708 static void
 709 dump_hsa_reg (FILE *f, hsa_op_reg *reg, bool dump_type = false)
 710 {
 711   if (reg->m_reg_class)
 712     fprintf (f, "$%c%i", reg->m_reg_class, reg->m_hard_num);
 713   else
 714     fprintf (f, "$_%i", reg->m_order);
 715   if (dump_type)
 716     fprintf (f, " (%s)", hsa_type_name (reg->m_type));
 717 }
 718
 719 /* Dump textual representation of HSA IL immediate operand IMM to file F.  */
 720
 721 static void
 722 dump_hsa_immed (FILE *f, hsa_op_immed *imm)
 723 {
 724   bool unsigned_int_type
 725     = (BRIG_TYPE_U8 | BRIG_TYPE_U16 | BRIG_TYPE_U32 | BRIG_TYPE_U64)
 726     & imm->m_type;
 727
 728   if (imm->m_tree_value)
 729     print_generic_expr (f, imm->m_tree_value, 0);
 730   else
 731     {
 732       if (unsigned_int_type)
 733         fprintf (f, HOST_WIDE_INT_PRINT_DEC, imm->m_int_value);
 734       else
 735         fprintf (f, HOST_WIDE_INT_PRINT_UNSIGNED,
 736                  (unsigned HOST_WIDE_INT) imm->m_int_value);
 737     }
 738
 739   fprintf (f, " (%s)", hsa_type_name (imm->m_type));
 740 }
 741
 742 /* Dump textual representation of HSA IL address operand ADDR to file F.  */
 743
 744 static void
 745 dump_hsa_address (FILE *f, hsa_op_address *addr)
 746 {
 747   bool sth = false;
 748
 749   if (addr->m_symbol)
 750     {
 751       sth = true;
 752       if (addr->m_symbol->m_name)
 753         fprintf (f, "[%%%s]", addr->m_symbol->m_name);
 754       else
 755         fprintf (f, "[%%__%s_%i]", hsa_seg_name (addr->m_symbol->m_segment),
 756                  addr->m_symbol->m_name_number);
 757     }
 758
 759   if (addr->m_reg)
 760     {
 761       fprintf (f, "[");
 762       dump_hsa_reg (f, addr->m_reg);
 763       if (addr->m_imm_offset != 0)
 764         fprintf (f, " + " HOST_WIDE_INT_PRINT_DEC "]", addr->m_imm_offset);
 765       else
 766         fprintf (f, "]");
 767     }
 768   else if (!sth || addr->m_imm_offset != 0)
 769     fprintf (f, "[" HOST_WIDE_INT_PRINT_DEC "]", addr->m_imm_offset);
 770 }
 771
 772 /* Dump textual representation of HSA IL symbol SYMBOL to file F.  */
 773
 774 static void
 775 dump_hsa_symbol (FILE *f, hsa_symbol *symbol)
 776 {
 777   const char *name;
 778   if (symbol->m_name)
 779     name = symbol->m_name;
 780   else
 781     {
 782       char buf[64];
 783       sprintf (buf, "__%s_%i", hsa_seg_name (symbol->m_segment),
 784                symbol->m_name_number);
 785
 786       name = buf;
 787     }
 788
 789   fprintf (f, "align(%u) %s_%s %s", hsa_byte_alignment (symbol->m_align),
 790            hsa_seg_name (symbol->m_segment),
 791            hsa_type_name (symbol->m_type & ~BRIG_TYPE_ARRAY_MASK), name);
 792
 793   if (symbol->m_type & BRIG_TYPE_ARRAY_MASK)
 794     fprintf (f, "[%lu]", (unsigned long) symbol->m_dim);
 795
 796   if (symbol->m_directive_offset)
 797     fprintf (f, "             /* BRIG offset: %u */", symbol->m_directive_offset);
 798 }
 799
 800 /* Dump textual representation of HSA IL operand OP to file F.  */
 801
 802 static void
 803 dump_hsa_operand (FILE *f, hsa_op_base *op, bool dump_reg_type = false)
 804 {
 805   if (is_a <hsa_op_immed *> (op))
 806     dump_hsa_immed (f, as_a <hsa_op_immed *> (op));
 807   else if (is_a <hsa_op_reg *> (op))
 808     dump_hsa_reg (f, as_a <hsa_op_reg *> (op), dump_reg_type);
 809   else if (is_a <hsa_op_address *> (op))
 810     dump_hsa_address (f, as_a <hsa_op_address *> (op));
 811   else
 812     fprintf (f, "UNKNOWN_OP_KIND");
 813 }
 814
 815 /* Dump textual representation of HSA IL operands in VEC to file F.  */
 816
 817 static void
 818 dump_hsa_operands (FILE *f, hsa_insn_basic *insn, int start = 0,
 819                    int end = -1, bool dump_reg_type = false)
 820 {
 821   if (end == -1)
 822     end = insn->operand_count ();
 823
 824   for (int i = start; i < end; i++)
 825     {
 826       dump_hsa_operand (f, insn->get_op (i), dump_reg_type);
 827       if (i != end - 1)
 828         fprintf (f, ", ");
 829     }
 830 }
 831
 832 /* Indent F stream with INDENT spaces.  */
 833
 834 static void indent_stream (FILE *f, int indent)
 835 {
 836   for (int i = 0; i < indent; i++)
 837     fputc (' ', f);
 838 }
 839
 840 /* Dump textual representation of HSA IL instruction INSN to file F.  Prepend
 841    the instruction with *INDENT spaces and adjust the indentation for call
 842    instructions as appropriate.  */
 843
 844 static void
 845 dump_hsa_insn_1 (FILE *f, hsa_insn_basic *insn, int *indent)
 846 {
 847   gcc_checking_assert (insn);
 848
 849   if (insn->m_number)
 850     fprintf (f, "%5d: ", insn->m_number);
 851
 852   indent_stream (f, *indent);
 853
 854   if (is_a <hsa_insn_phi *> (insn))
 855     {
 856       hsa_insn_phi *phi = as_a <hsa_insn_phi *> (insn);
 857       bool first = true;
 858       dump_hsa_reg (f, phi->m_dest, true);
 859       fprintf (f, " = PHI <");
 860       unsigned count = phi->operand_count ();
 861       for (unsigned i = 0; i < count; i++)
 862         {
 863           if (!phi->get_op (i))
 864             break;
 865           if (!first)
 866             fprintf (f, ", ");
 867           else
 868             first = false;
 869           dump_hsa_operand (f, phi->get_op (i), true);
 870         }
 871       fprintf (f, ">");
 872     }
 873   else if (is_a <hsa_insn_signal *> (insn))
 874     {
 875       hsa_insn_signal *mem = as_a <hsa_insn_signal *> (insn);
 876
 877       fprintf (f, "%s", hsa_opcode_name (mem->m_opcode));
 878       fprintf (f, "_%s", hsa_m_atomicop_name (mem->m_signalop));
 879       if (mem->m_memory_order != BRIG_MEMORY_ORDER_NONE)
 880         fprintf (f, "_%s", hsa_memsem_name (mem->m_memory_order));
 881       fprintf (f, "_%s ", hsa_type_name (mem->m_type));
 882
 883       dump_hsa_operands (f, mem);
 884     }
 885
 886   else if (is_a <hsa_insn_atomic *> (insn))
 887     {
 888       hsa_insn_atomic *mem = as_a <hsa_insn_atomic *> (insn);
 889
 890       /* Either operand[0] or operand[1] must be an address operand.  */
 891       hsa_op_address *addr = NULL;
 892       if (is_a <hsa_op_address *> (mem->get_op (0)))
 893         addr = as_a <hsa_op_address *> (mem->get_op (0));
 894       else
 895         addr = as_a <hsa_op_address *> (mem->get_op (1));
 896
 897       fprintf (f, "%s", hsa_opcode_name (mem->m_opcode));
 898       fprintf (f, "_%s", hsa_m_atomicop_name (mem->m_atomicop));
 899       if (addr->m_symbol)
 900         fprintf (f, "_%s", hsa_seg_name (addr->m_symbol->m_segment));
 901       if (mem->m_memoryorder != BRIG_MEMORY_ORDER_NONE)
 902         fprintf (f, "_%s", hsa_memsem_name (mem->m_memoryorder));
 903       if (mem->m_memoryscope != BRIG_MEMORY_SCOPE_NONE)
 904         fprintf (f, "_%s", hsa_memscope_name (mem->m_memoryscope));
 905       fprintf (f, "_%s ", hsa_type_name (mem->m_type));
 906
 907       dump_hsa_operands (f, mem);
 908     }
 909   else if (is_a <hsa_insn_mem *> (insn))
 910     {
 911       hsa_insn_mem *mem = as_a <hsa_insn_mem *> (insn);
 912       hsa_op_address *addr = as_a <hsa_op_address *> (mem->get_op (1));
 913
 914       fprintf (f, "%s", hsa_opcode_name (mem->m_opcode));
 915       if (addr->m_symbol)
 916         fprintf (f, "_%s", hsa_seg_name (addr->m_symbol->m_segment));
 917       if (mem->m_align != BRIG_ALIGNMENT_NONE)
 918         fprintf (f, "_align(%u)", hsa_byte_alignment (mem->m_align));
 919       if (mem->m_equiv_class != 0)
 920         fprintf (f, "_equiv(%i)", mem->m_equiv_class);
 921       fprintf (f, "_%s ", hsa_type_name (mem->m_type));
 922
 923       dump_hsa_operand (f, mem->get_op (0));
 924       fprintf (f, ", ");
 925       dump_hsa_address (f, addr);
 926     }
 927   else if (insn->m_opcode == BRIG_OPCODE_LDA)
 928     {
 929       hsa_op_address *addr = as_a <hsa_op_address *> (insn->get_op (1));
 930
 931       fprintf (f, "%s", hsa_opcode_name (insn->m_opcode));
 932       if (addr->m_symbol)
 933         fprintf (f, "_%s", hsa_seg_name (addr->m_symbol->m_segment));
 934       fprintf (f, "_%s ", hsa_type_name (insn->m_type));
 935
 936       dump_hsa_operand (f, insn->get_op (0));
 937       fprintf (f, ", ");
 938       dump_hsa_address (f, addr);
 939     }
 940   else if (is_a <hsa_insn_seg *> (insn))
 941     {
 942       hsa_insn_seg *seg = as_a <hsa_insn_seg *> (insn);
 943       fprintf (f, "%s_%s_%s_%s ", hsa_opcode_name (seg->m_opcode),
 944                hsa_seg_name (seg->m_segment),
 945                hsa_type_name (seg->m_type), hsa_type_name (seg->m_src_type));
 946       dump_hsa_reg (f, as_a <hsa_op_reg *> (seg->get_op (0)));
 947       fprintf (f, ", ");
 948       dump_hsa_operand (f, seg->get_op (1));
 949     }
 950   else if (is_a <hsa_insn_cmp *> (insn))
 951     {
 952       hsa_insn_cmp *cmp = as_a <hsa_insn_cmp *> (insn);
 953       BrigType16_t src_type;
 954
 955       if (is_a <hsa_op_reg *> (cmp->get_op (1)))
 956         src_type = as_a <hsa_op_reg *> (cmp->get_op (1))->m_type;
 957       else
 958         src_type = as_a <hsa_op_immed *> (cmp->get_op (1))->m_type;
 959
 960       fprintf (f, "%s_%s_%s_%s ", hsa_opcode_name (cmp->m_opcode),
 961                hsa_cmpop_name (cmp->m_compare),
 962                hsa_type_name (cmp->m_type), hsa_type_name (src_type));
 963       dump_hsa_reg (f, as_a <hsa_op_reg *> (cmp->get_op (0)));
 964       fprintf (f, ", ");
 965       dump_hsa_operand (f, cmp->get_op (1));
 966       fprintf (f, ", ");
 967       dump_hsa_operand (f, cmp->get_op (2));
 968     }
 969   else if (is_a <hsa_insn_cbr *> (insn))
 970     {
 971       hsa_insn_cbr *br = as_a <hsa_insn_cbr *> (insn);
 972       basic_block target = NULL;
 973       edge_iterator ei;
 974       edge e;
 975
 976       fprintf (f, "%s ", hsa_opcode_name (br->m_opcode));
 977       if (br->m_opcode == BRIG_OPCODE_CBR)
 978         {
 979           dump_hsa_reg (f, as_a <hsa_op_reg *> (br->get_op (0)));
 980           fprintf (f, ", ");
 981         }
 982
 983       FOR_EACH_EDGE (e, ei, br->m_bb->succs)
 984         if (e->flags & EDGE_TRUE_VALUE)
 985           {
 986             target = e->dest;
 987             break;
 988           }
 989       fprintf (f, "BB %i", hsa_bb_for_bb (target)->m_index);
 990     }
 991   else if (is_a <hsa_insn_sbr *> (insn))
 992     {
 993       hsa_insn_sbr *sbr = as_a <hsa_insn_sbr *> (insn);
 994
 995       fprintf (f, "%s ", hsa_opcode_name (sbr->m_opcode));
 996       dump_hsa_reg (f, as_a <hsa_op_reg *> (sbr->get_op (0)));
 997       fprintf (f, ", [");
 998
 999       for (unsigned i = 0; i < sbr->m_jump_table.length (); i++)
1000         {
1001           fprintf (f, "BB %i", hsa_bb_for_bb (sbr->m_jump_table[i])->m_index);
1002           if (i != sbr->m_jump_table.length () - 1)
1003             fprintf (f, ", ");
1004         }
1005     }
1006   else if (is_a <hsa_insn_br *> (insn))
1007     {
1008       hsa_insn_br *br = as_a <hsa_insn_br *> (insn);
1009       fprintf (f, "%s_width(%s) ", hsa_opcode_name (br->m_opcode),
1010                hsa_width_specifier_name (br->m_width));
1011     }
1012   else if (is_a <hsa_insn_arg_block *> (insn))
1013     {
1014       hsa_insn_arg_block *arg_block = as_a <hsa_insn_arg_block *> (insn);
1015       bool start_p = arg_block->m_kind == BRIG_KIND_DIRECTIVE_ARG_BLOCK_START;
1016       char c = start_p ? '{' : '}';
1017
1018       if (start_p)
1019         {
1020           *indent += 2;
1021           indent_stream (f, 2);
1022         }
1023
1024       if (!start_p)
1025         *indent -= 2;
1026
1027       fprintf (f, "%c", c);
1028     }
1029   else if (is_a <hsa_insn_call *> (insn))
1030     {
1031       hsa_insn_call *call = as_a <hsa_insn_call *> (insn);
1032       if (call->m_called_function)
1033         {
1034           const char *name = hsa_get_declaration_name (call->m_called_function);
1035           fprintf (f, "call &%s", name);
1036         }
1037       else
1038         {
1039           char *name = call->m_called_internal_fn->name ();
1040           fprintf (f, "call &%s", name);
1041           free (name);
1042         }
1043
1044       if (call->m_output_arg)
1045         fprintf (f, "(%%res) ");
1046
1047       fprintf (f, "(");
1048       for (unsigned i = 0; i < call->m_input_args.length (); i++)
1049         {
1050           fprintf (f, "%%__arg_%u", i);
1051
1052           if (i != call->m_input_args.length () - 1)
1053             fprintf (f, ", ");
1054         }
1055       fprintf (f, ")");
1056     }
1057   else if (is_a <hsa_insn_comment *> (insn))
1058     {
1059       hsa_insn_comment *c = as_a <hsa_insn_comment *> (insn);
1060       fprintf (f, "%s", c->m_comment);
1061     }
1062   else if (is_a <hsa_insn_srctype *> (insn))
1063     {
1064       hsa_insn_srctype *srctype = as_a <hsa_insn_srctype *> (insn);
1065
1066       fprintf (f, "%s_%s_%s ", hsa_opcode_name (srctype->m_opcode),
1067                hsa_type_name (srctype->m_type),
1068                hsa_type_name (srctype->m_source_type));
1069
1070       dump_hsa_operands (f, insn);
1071     }
1072   else if (is_a <hsa_insn_packed *> (insn))
1073     {
1074       hsa_insn_packed *packed = as_a <hsa_insn_packed *> (insn);
1075
1076       fprintf (f, "%s_v%u_%s_%s ", hsa_opcode_name (packed->m_opcode),
1077                packed->operand_count () - 1,
1078                hsa_type_name (packed->m_type),
1079                hsa_type_name (packed->m_source_type));
1080
1081       if (packed->m_opcode == BRIG_OPCODE_COMBINE)
1082         {
1083           dump_hsa_operand (f, insn->get_op (0));
1084           fprintf (f, ", (");
1085           dump_hsa_operands (f, insn, 1);
1086           fprintf (f, ")");
1087         }
1088       else if (packed->m_opcode == BRIG_OPCODE_EXPAND)
1089         {
1090           fprintf (f, "(");
1091           dump_hsa_operands (f, insn, 0, insn->operand_count () - 1);
1092           fprintf (f, "), ");
1093           dump_hsa_operand (f, insn->get_op (insn->operand_count () - 1));
1094
1095         }
1096       else
1097         gcc_unreachable ();
1098     }
1099   else if (is_a <hsa_insn_alloca *> (insn))
1100     {
1101       hsa_insn_alloca *alloca = as_a <hsa_insn_alloca *> (insn);
1102
1103       fprintf (f, "%s_align(%u)_%s ", hsa_opcode_name (insn->m_opcode),
1104                hsa_byte_alignment (alloca->m_align),
1105                hsa_type_name (insn->m_type));
1106
1107       dump_hsa_operands (f, insn);
1108     }
1109   else if (hsa_insn_queue *qi = dyn_cast <hsa_insn_queue *> (insn))
1110     {
1111       fprintf (f, "%s_%s_%s_%s ", hsa_opcode_name (qi->m_opcode),
1112                hsa_seg_name (qi->m_segment),
1113                hsa_memsem_name (qi->m_memory_order),
1114                hsa_type_name (qi->m_type));
1115
1116       dump_hsa_operands (f, qi);
1117     }
1118   else
1119     {
1120       fprintf (f, "%s_%s ", hsa_opcode_name (insn->m_opcode),
1121                hsa_type_name (insn->m_type));
1122
1123       dump_hsa_operands (f, insn);
1124     }
1125
1126   if (insn->m_brig_offset)
1127     {
1128       fprintf (f, "             /* BRIG offset: %u", insn->m_brig_offset);
1129
1130       for (unsigned i = 0; i < insn->operand_count (); i++)
1131         fprintf (f, ", op%u: %u", i, insn->get_op (i)->m_brig_op_offset);
1132
1133       fprintf (f, " */");
1134     }
1135
1136   fprintf (f, "\n");
1137 }
1138
1139 /* Dump textual representation of HSA IL instruction INSN to file F.  */
1140
1141 void
1142 dump_hsa_insn (FILE *f, hsa_insn_basic *insn)
1143 {
1144   int indent = 0;
1145   dump_hsa_insn_1 (f, insn, &indent);
1146 }
1147
1148 /* Dump textual representation of HSA IL in HBB to file F.  */
1149
1150 void
1151 dump_hsa_bb (FILE *f, hsa_bb *hbb)
1152 {
1153   hsa_insn_basic *insn;
1154   edge_iterator ei;
1155   edge e;
1156   basic_block true_bb = NULL, other = NULL;
1157
1158   fprintf (f, "BB %i:\n", hbb->m_index);
1159
1160   int indent = 2;
1161   for (insn = hbb->m_first_phi; insn; insn = insn->m_next)
1162     dump_hsa_insn_1 (f, insn, &indent);
1163
1164   for (insn = hbb->m_first_insn; insn; insn = insn->m_next)
1165     dump_hsa_insn_1 (f, insn, &indent);
1166
1167   if (hbb->m_last_insn && is_a <hsa_insn_sbr *> (hbb->m_last_insn))
1168     goto exit;
1169
1170   FOR_EACH_EDGE (e, ei, hbb->m_bb->succs)
1171     if (e->flags & EDGE_TRUE_VALUE)
1172       {
1173         gcc_assert (!true_bb);
1174         true_bb = e->dest;
1175       }
1176     else
1177       {
1178         gcc_assert (!other);
1179         other = e->dest;
1180       }
1181
1182   if (true_bb)
1183     {
1184       if (!hbb->m_last_insn
1185           || hbb->m_last_insn->m_opcode != BRIG_OPCODE_CBR)
1186         fprintf (f, "WARNING: No branch insn for a true edge. \n");
1187     }
1188   else if (hbb->m_last_insn
1189            && hbb->m_last_insn->m_opcode == BRIG_OPCODE_CBR)
1190     fprintf (f, "WARNING: No true edge for a cbr statement\n");
1191
1192   if (other && other->aux)
1193     fprintf (f, "  Fall-through to BB %i\n",
1194              hsa_bb_for_bb (other)->m_index);
1195   else if (hbb->m_last_insn
1196            && hbb->m_last_insn->m_opcode != BRIG_OPCODE_RET)
1197     fprintf (f, "  WARNING: Fall through to a BB with no aux!\n");
1198
1199 exit:
1200   fprintf (f, "\n");
1201 }
1202
1203 /* Dump textual representation of HSA IL of the current function to file F.  */
1204
1205 void
1206 dump_hsa_cfun (FILE *f)
1207 {
1208   basic_block bb;
1209
1210   if (hsa_cfun->m_global_symbols.length () > 0)
1211     fprintf (f, "\nHSAIL in global scope\n");
1212
1213   for (unsigned i = 0; i < hsa_cfun->m_global_symbols.length (); i++)
1214     {
1215       fprintf (f, "  ");
1216       dump_hsa_symbol (f, hsa_cfun->m_global_symbols[i]);
1217       fprintf (f, "\n");
1218     }
1219
1220   fprintf (f, "\nHSAIL IL for %s\n", hsa_cfun->m_name);
1221
1222   for (unsigned i = 0; i < hsa_cfun->m_private_variables.length (); i++)
1223     {
1224       fprintf (f, "  ");
1225       dump_hsa_symbol (f, hsa_cfun->m_private_variables[i]);
1226       fprintf (f, "\n");
1227     }
1228
1229   FOR_ALL_BB_FN (bb, cfun)
1230     {
1231       hsa_bb *hbb = (struct hsa_bb *) bb->aux;
1232       dump_hsa_bb (f, hbb);
1233     }
1234 }
1235
1236 /* Dump textual representation of HSA IL instruction INSN to stderr.  */
1237
1238 DEBUG_FUNCTION void
1239 debug_hsa_insn (hsa_insn_basic *insn)
1240 {
1241   dump_hsa_insn (stderr, insn);
1242 }
1243
1244 /* Dump textual representation of HSA IL in HBB to stderr.  */
1245
1246 DEBUG_FUNCTION void
1247 debug_hsa_bb (hsa_bb *hbb)
1248 {
1249   dump_hsa_bb (stderr, hbb);
1250 }
1251
1252 /* Dump textual representation of HSA IL of the current function to stderr.  */
1253
1254 DEBUG_FUNCTION void
1255 debug_hsa_cfun (void)
1256 {
1257   dump_hsa_cfun (stderr);
1258 }
1259
1260 /* Dump textual representation of an HSA operand to stderr.  */
1261
1262 DEBUG_FUNCTION void
1263 debug_hsa_operand (hsa_op_base *opc)
1264 {
1265   dump_hsa_operand (stderr, opc, true);
1266   fprintf (stderr, "\n");
1267 }
1268
1269 /* Dump textual representation of as HSA symbol.  */
1270
1271 DEBUG_FUNCTION void
1272 debug_hsa_symbol (hsa_symbol *symbol)
1273 {
1274   dump_hsa_symbol (stderr, symbol);
1275   fprintf (stderr, "\n");
1276 }