LCOV - code coverage report
Current view: top level - gcc - hsa-dump.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 0 916 0.0 %
Date: 2020-04-04 11:58:09 Functions: 0 24 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

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

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.