| /* Infrastructure to dump our HSAIL IL |
| Copyright (C) 2013-2019 Free Software Foundation, Inc. |
| Contributed by Martin Jambor <mjambor@suse.cz> and |
| Martin Liska <mliska@suse.cz>. |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3, or (at your option) |
| any later version. |
| |
| GCC is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GCC; see the file COPYING3. If not see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include "config.h" |
| #include "system.h" |
| #include "coretypes.h" |
| #include "tm.h" |
| #include "is-a.h" |
| #include "vec.h" |
| #include "tree.h" |
| #include "basic-block.h" |
| #include "function.h" |
| #include "cfg.h" |
| #include "dumpfile.h" |
| #include "gimple-pretty-print.h" |
| #include "cgraph.h" |
| #include "print-tree.h" |
| #include "symbol-summary.h" |
| #include "hsa-common.h" |
| |
| /* Return textual name of TYPE. */ |
| |
| static const char * |
| hsa_type_name (BrigType16_t type) |
| { |
| switch (type) |
| { |
| case BRIG_TYPE_NONE: |
| return "none"; |
| case BRIG_TYPE_U8: |
| return "u8"; |
| case BRIG_TYPE_U16: |
| return "u16"; |
| case BRIG_TYPE_U32: |
| return "u32"; |
| case BRIG_TYPE_U64: |
| return "u64"; |
| case BRIG_TYPE_S8: |
| return "s8"; |
| case BRIG_TYPE_S16: |
| return "s16"; |
| case BRIG_TYPE_S32: |
| return "s32"; |
| case BRIG_TYPE_S64: |
| return "s64"; |
| case BRIG_TYPE_F16: |
| return "f16"; |
| case BRIG_TYPE_F32: |
| return "f32"; |
| case BRIG_TYPE_F64: |
| return "f64"; |
| case BRIG_TYPE_B1: |
| return "b1"; |
| case BRIG_TYPE_B8: |
| return "b8"; |
| case BRIG_TYPE_B16: |
| return "b16"; |
| case BRIG_TYPE_B32: |
| return "b32"; |
| case BRIG_TYPE_B64: |
| return "b64"; |
| case BRIG_TYPE_B128: |
| return "b128"; |
| case BRIG_TYPE_SAMP: |
| return "samp"; |
| case BRIG_TYPE_ROIMG: |
| return "roimg"; |
| case BRIG_TYPE_WOIMG: |
| return "woimg"; |
| case BRIG_TYPE_RWIMG: |
| return "rwimg"; |
| case BRIG_TYPE_SIG32: |
| return "sig32"; |
| case BRIG_TYPE_SIG64: |
| return "sig64"; |
| case BRIG_TYPE_U8X4: |
| return "u8x4"; |
| case BRIG_TYPE_U8X8: |
| return "u8x8"; |
| case BRIG_TYPE_U8X16: |
| return "u8x16"; |
| case BRIG_TYPE_U16X2: |
| return "u16x2"; |
| case BRIG_TYPE_U16X4: |
| return "u16x4"; |
| case BRIG_TYPE_U16X8: |
| return "u16x8"; |
| case BRIG_TYPE_U32X2: |
| return "u32x2"; |
| case BRIG_TYPE_U32X4: |
| return "u32x4"; |
| case BRIG_TYPE_U64X2: |
| return "u64x2"; |
| case BRIG_TYPE_S8X4: |
| return "s8x4"; |
| case BRIG_TYPE_S8X8: |
| return "s8x8"; |
| case BRIG_TYPE_S8X16: |
| return "s8x16"; |
| case BRIG_TYPE_S16X2: |
| return "s16x2"; |
| case BRIG_TYPE_S16X4: |
| return "s16x4"; |
| case BRIG_TYPE_S16X8: |
| return "s16x8"; |
| case BRIG_TYPE_S32X2: |
| return "s32x2"; |
| case BRIG_TYPE_S32X4: |
| return "s32x4"; |
| case BRIG_TYPE_S64X2: |
| return "s64x2"; |
| case BRIG_TYPE_F16X2: |
| return "f16x2"; |
| case BRIG_TYPE_F16X4: |
| return "f16x4"; |
| case BRIG_TYPE_F16X8: |
| return "f16x8"; |
| case BRIG_TYPE_F32X2: |
| return "f32x2"; |
| case BRIG_TYPE_F32X4: |
| return "f32x4"; |
| case BRIG_TYPE_F64X2: |
| return "f64x2"; |
| default: |
| return "UNKNOWN_TYPE"; |
| } |
| } |
| |
| /* Return textual name of OPCODE. */ |
| |
| static const char * |
| hsa_opcode_name (BrigOpcode16_t opcode) |
| { |
| switch (opcode) |
| { |
| case BRIG_OPCODE_NOP: |
| return "nop"; |
| case BRIG_OPCODE_ABS: |
| return "abs"; |
| case BRIG_OPCODE_ADD: |
| return "add"; |
| case BRIG_OPCODE_BORROW: |
| return "borrow"; |
| case BRIG_OPCODE_CARRY: |
| return "carry"; |
| case BRIG_OPCODE_CEIL: |
| return "ceil"; |
| case BRIG_OPCODE_COPYSIGN: |
| return "copysign"; |
| case BRIG_OPCODE_DIV: |
| return "div"; |
| case BRIG_OPCODE_FLOOR: |
| return "floor"; |
| case BRIG_OPCODE_FMA: |
| return "fma"; |
| case BRIG_OPCODE_FRACT: |
| return "fract"; |
| case BRIG_OPCODE_MAD: |
| return "mad"; |
| case BRIG_OPCODE_MAX: |
| return "max"; |
| case BRIG_OPCODE_MIN: |
| return "min"; |
| case BRIG_OPCODE_MUL: |
| return "mul"; |
| case BRIG_OPCODE_MULHI: |
| return "mulhi"; |
| case BRIG_OPCODE_NEG: |
| return "neg"; |
| case BRIG_OPCODE_REM: |
| return "rem"; |
| case BRIG_OPCODE_RINT: |
| return "rint"; |
| case BRIG_OPCODE_SQRT: |
| return "sqrt"; |
| case BRIG_OPCODE_SUB: |
| return "sub"; |
| case BRIG_OPCODE_TRUNC: |
| return "trunc"; |
| case BRIG_OPCODE_MAD24: |
| return "mad24"; |
| case BRIG_OPCODE_MAD24HI: |
| return "mad24hi"; |
| case BRIG_OPCODE_MUL24: |
| return "mul24"; |
| case BRIG_OPCODE_MUL24HI: |
| return "mul24hi"; |
| case BRIG_OPCODE_SHL: |
| return "shl"; |
| case BRIG_OPCODE_SHR: |
| return "shr"; |
| case BRIG_OPCODE_AND: |
| return "and"; |
| case BRIG_OPCODE_NOT: |
| return "not"; |
| case BRIG_OPCODE_OR: |
| return "or"; |
| case BRIG_OPCODE_POPCOUNT: |
| return "popcount"; |
| case BRIG_OPCODE_XOR: |
| return "xor"; |
| case BRIG_OPCODE_BITEXTRACT: |
| return "bitextract"; |
| case BRIG_OPCODE_BITINSERT: |
| return "bitinsert"; |
| case BRIG_OPCODE_BITMASK: |
| return "bitmask"; |
| case BRIG_OPCODE_BITREV: |
| return "bitrev"; |
| case BRIG_OPCODE_BITSELECT: |
| return "bitselect"; |
| case BRIG_OPCODE_FIRSTBIT: |
| return "firstbit"; |
| case BRIG_OPCODE_LASTBIT: |
| return "lastbit"; |
| case BRIG_OPCODE_COMBINE: |
| return "combine"; |
| case BRIG_OPCODE_EXPAND: |
| return "expand"; |
| case BRIG_OPCODE_LDA: |
| return "lda"; |
| case BRIG_OPCODE_MOV: |
| return "mov"; |
| case BRIG_OPCODE_SHUFFLE: |
| return "shuffle"; |
| case BRIG_OPCODE_UNPACKHI: |
| return "unpackhi"; |
| case BRIG_OPCODE_UNPACKLO: |
| return "unpacklo"; |
| case BRIG_OPCODE_PACK: |
| return "pack"; |
| case BRIG_OPCODE_UNPACK: |
| return "unpack"; |
| case BRIG_OPCODE_CMOV: |
| return "cmov"; |
| case BRIG_OPCODE_CLASS: |
| return "class"; |
| case BRIG_OPCODE_NCOS: |
| return "ncos"; |
| case BRIG_OPCODE_NEXP2: |
| return "nexp2"; |
| case BRIG_OPCODE_NFMA: |
| return "nfma"; |
| case BRIG_OPCODE_NLOG2: |
| return "nlog2"; |
| case BRIG_OPCODE_NRCP: |
| return "nrcp"; |
| case BRIG_OPCODE_NRSQRT: |
| return "nrsqrt"; |
| case BRIG_OPCODE_NSIN: |
| return "nsin"; |
| case BRIG_OPCODE_NSQRT: |
| return "nsqrt"; |
| case BRIG_OPCODE_BITALIGN: |
| return "bitalign"; |
| case BRIG_OPCODE_BYTEALIGN: |
| return "bytealign"; |
| case BRIG_OPCODE_PACKCVT: |
| return "packcvt"; |
| case BRIG_OPCODE_UNPACKCVT: |
| return "unpackcvt"; |
| case BRIG_OPCODE_LERP: |
| return "lerp"; |
| case BRIG_OPCODE_SAD: |
| return "sad"; |
| case BRIG_OPCODE_SADHI: |
| return "sadhi"; |
| case BRIG_OPCODE_SEGMENTP: |
| return "segmentp"; |
| case BRIG_OPCODE_FTOS: |
| return "ftos"; |
| case BRIG_OPCODE_STOF: |
| return "stof"; |
| case BRIG_OPCODE_CMP: |
| return "cmp"; |
| case BRIG_OPCODE_CVT: |
| return "cvt"; |
| case BRIG_OPCODE_LD: |
| return "ld"; |
| case BRIG_OPCODE_ST: |
| return "st"; |
| case BRIG_OPCODE_ATOMIC: |
| return "atomic"; |
| case BRIG_OPCODE_ATOMICNORET: |
| return "atomicnoret"; |
| case BRIG_OPCODE_SIGNAL: |
| return "signal"; |
| case BRIG_OPCODE_SIGNALNORET: |
| return "signalnoret"; |
| case BRIG_OPCODE_MEMFENCE: |
| return "memfence"; |
| case BRIG_OPCODE_RDIMAGE: |
| return "rdimage"; |
| case BRIG_OPCODE_LDIMAGE: |
| return "ldimage"; |
| case BRIG_OPCODE_STIMAGE: |
| return "stimage"; |
| case BRIG_OPCODE_QUERYIMAGE: |
| return "queryimage"; |
| case BRIG_OPCODE_QUERYSAMPLER: |
| return "querysampler"; |
| case BRIG_OPCODE_CBR: |
| return "cbr"; |
| case BRIG_OPCODE_BR: |
| return "br"; |
| case BRIG_OPCODE_SBR: |
| return "sbr"; |
| case BRIG_OPCODE_BARRIER: |
| return "barrier"; |
| case BRIG_OPCODE_WAVEBARRIER: |
| return "wavebarrier"; |
| case BRIG_OPCODE_ARRIVEFBAR: |
| return "arrivefbar"; |
| case BRIG_OPCODE_INITFBAR: |
| return "initfbar"; |
| case BRIG_OPCODE_JOINFBAR: |
| return "joinfbar"; |
| case BRIG_OPCODE_LEAVEFBAR: |
| return "leavefbar"; |
| case BRIG_OPCODE_RELEASEFBAR: |
| return "releasefbar"; |
| case BRIG_OPCODE_WAITFBAR: |
| return "waitfbar"; |
| case BRIG_OPCODE_LDF: |
| return "ldf"; |
| case BRIG_OPCODE_ACTIVELANECOUNT: |
| return "activelanecount"; |
| case BRIG_OPCODE_ACTIVELANEID: |
| return "activelaneid"; |
| case BRIG_OPCODE_ACTIVELANEMASK: |
| return "activelanemask"; |
| case BRIG_OPCODE_CALL: |
| return "call"; |
| case BRIG_OPCODE_SCALL: |
| return "scall"; |
| case BRIG_OPCODE_ICALL: |
| return "icall"; |
| case BRIG_OPCODE_RET: |
| return "ret"; |
| case BRIG_OPCODE_ALLOCA: |
| return "alloca"; |
| case BRIG_OPCODE_CURRENTWORKGROUPSIZE: |
| return "currentworkgroupsize"; |
| case BRIG_OPCODE_DIM: |
| return "dim"; |
| case BRIG_OPCODE_GRIDGROUPS: |
| return "gridgroups"; |
| case BRIG_OPCODE_GRIDSIZE: |
| return "gridsize"; |
| case BRIG_OPCODE_PACKETCOMPLETIONSIG: |
| return "packetcompletionsig"; |
| case BRIG_OPCODE_PACKETID: |
| return "packetid"; |
| case BRIG_OPCODE_WORKGROUPID: |
| return "workgroupid"; |
| case BRIG_OPCODE_WORKGROUPSIZE: |
| return "workgroupsize"; |
| case BRIG_OPCODE_WORKITEMABSID: |
| return "workitemabsid"; |
| case BRIG_OPCODE_WORKITEMFLATABSID: |
| return "workitemflatabsid"; |
| case BRIG_OPCODE_WORKITEMFLATID: |
| return "workitemflatid"; |
| case BRIG_OPCODE_WORKITEMID: |
| return "workitemid"; |
| case BRIG_OPCODE_CLEARDETECTEXCEPT: |
| return "cleardetectexcept"; |
| case BRIG_OPCODE_GETDETECTEXCEPT: |
| return "getdetectexcept"; |
| case BRIG_OPCODE_SETDETECTEXCEPT: |
| return "setdetectexcept"; |
| case BRIG_OPCODE_ADDQUEUEWRITEINDEX: |
| return "addqueuewriteindex"; |
| case BRIG_OPCODE_CASQUEUEWRITEINDEX: |
| return "casqueuewriteindex"; |
| case BRIG_OPCODE_LDQUEUEREADINDEX: |
| return "ldqueuereadindex"; |
| case BRIG_OPCODE_LDQUEUEWRITEINDEX: |
| return "ldqueuewriteindex"; |
| case BRIG_OPCODE_STQUEUEREADINDEX: |
| return "stqueuereadindex"; |
| case BRIG_OPCODE_STQUEUEWRITEINDEX: |
| return "stqueuewriteindex"; |
| case BRIG_OPCODE_CLOCK: |
| return "clock"; |
| case BRIG_OPCODE_CUID: |
| return "cuid"; |
| case BRIG_OPCODE_DEBUGTRAP: |
| return "debugtrap"; |
| case BRIG_OPCODE_GROUPBASEPTR: |
| return "groupbaseptr"; |
| case BRIG_OPCODE_KERNARGBASEPTR: |
| return "kernargbaseptr"; |
| case BRIG_OPCODE_LANEID: |
| return "laneid"; |
| case BRIG_OPCODE_MAXCUID: |
| return "maxcuid"; |
| case BRIG_OPCODE_MAXWAVEID: |
| return "maxwaveid"; |
| case BRIG_OPCODE_NULLPTR: |
| return "nullptr"; |
| case BRIG_OPCODE_WAVEID: |
| return "waveid"; |
| default: |
| return "UNKNOWN_OPCODE"; |
| } |
| } |
| |
| /* Return textual name of SEG. */ |
| |
| const char * |
| hsa_seg_name (BrigSegment8_t seg) |
| { |
| switch (seg) |
| { |
| case BRIG_SEGMENT_NONE: |
| return "none"; |
| case BRIG_SEGMENT_FLAT: |
| return "flat"; |
| case BRIG_SEGMENT_GLOBAL: |
| return "global"; |
| case BRIG_SEGMENT_READONLY: |
| return "readonly"; |
| case BRIG_SEGMENT_KERNARG: |
| return "kernarg"; |
| case BRIG_SEGMENT_GROUP: |
| return "group"; |
| case BRIG_SEGMENT_PRIVATE: |
| return "private"; |
| case BRIG_SEGMENT_SPILL: |
| return "spill"; |
| case BRIG_SEGMENT_ARG: |
| return "arg"; |
| default: |
| return "UNKNOWN_SEGMENT"; |
| } |
| } |
| |
| /* Return textual name of CMPOP. */ |
| |
| static const char * |
| hsa_cmpop_name (BrigCompareOperation8_t cmpop) |
| { |
| switch (cmpop) |
| { |
| case BRIG_COMPARE_EQ: |
| return "eq"; |
| case BRIG_COMPARE_NE: |
| return "ne"; |
| case BRIG_COMPARE_LT: |
| return "lt"; |
| case BRIG_COMPARE_LE: |
| return "le"; |
| case BRIG_COMPARE_GT: |
| return "gt"; |
| case BRIG_COMPARE_GE: |
| return "ge"; |
| case BRIG_COMPARE_EQU: |
| return "equ"; |
| case BRIG_COMPARE_NEU: |
| return "neu"; |
| case BRIG_COMPARE_LTU: |
| return "ltu"; |
| case BRIG_COMPARE_LEU: |
| return "leu"; |
| case BRIG_COMPARE_GTU: |
| return "gtu"; |
| case BRIG_COMPARE_GEU: |
| return "geu"; |
| case BRIG_COMPARE_NUM: |
| return "num"; |
| case BRIG_COMPARE_NAN: |
| return "nan"; |
| case BRIG_COMPARE_SEQ: |
| return "seq"; |
| case BRIG_COMPARE_SNE: |
| return "sne"; |
| case BRIG_COMPARE_SLT: |
| return "slt"; |
| case BRIG_COMPARE_SLE: |
| return "sle"; |
| case BRIG_COMPARE_SGT: |
| return "sgt"; |
| case BRIG_COMPARE_SGE: |
| return "sge"; |
| case BRIG_COMPARE_SGEU: |
| return "sgeu"; |
| case BRIG_COMPARE_SEQU: |
| return "sequ"; |
| case BRIG_COMPARE_SNEU: |
| return "sneu"; |
| case BRIG_COMPARE_SLTU: |
| return "sltu"; |
| case BRIG_COMPARE_SLEU: |
| return "sleu"; |
| case BRIG_COMPARE_SNUM: |
| return "snum"; |
| case BRIG_COMPARE_SNAN: |
| return "snan"; |
| case BRIG_COMPARE_SGTU: |
| return "sgtu"; |
| default: |
| return "UNKNOWN_COMPARISON"; |
| } |
| } |
| |
| /* Return textual name for memory order. */ |
| |
| static const char * |
| hsa_memsem_name (enum BrigMemoryOrder mo) |
| { |
| switch (mo) |
| { |
| case BRIG_MEMORY_ORDER_NONE: |
| return ""; |
| case BRIG_MEMORY_ORDER_RELAXED: |
| return "rlx"; |
| case BRIG_MEMORY_ORDER_SC_ACQUIRE: |
| return "scacq"; |
| case BRIG_MEMORY_ORDER_SC_RELEASE: |
| return "screl"; |
| case BRIG_MEMORY_ORDER_SC_ACQUIRE_RELEASE: |
| return "scar"; |
| default: |
| return "UNKNOWN_MEMORY_ORDER"; |
| } |
| } |
| |
| /* Return textual name for memory scope. */ |
| |
| static const char * |
| hsa_memscope_name (enum BrigMemoryScope scope) |
| { |
| switch (scope) |
| { |
| case BRIG_MEMORY_SCOPE_NONE: |
| return ""; |
| case BRIG_MEMORY_SCOPE_WORKITEM: |
| return "wi"; |
| case BRIG_MEMORY_SCOPE_WAVEFRONT: |
| return "wave"; |
| case BRIG_MEMORY_SCOPE_WORKGROUP: |
| return "wg"; |
| case BRIG_MEMORY_SCOPE_AGENT: |
| return "agent"; |
| case BRIG_MEMORY_SCOPE_SYSTEM: |
| return "sys"; |
| default: |
| return "UNKNOWN_SCOPE"; |
| } |
| } |
| |
| /* Return textual name for atomic operation. */ |
| |
| static const char * |
| hsa_m_atomicop_name (enum BrigAtomicOperation op) |
| { |
| switch (op) |
| { |
| case BRIG_ATOMIC_ADD: |
| return "add"; |
| case BRIG_ATOMIC_AND: |
| return "and"; |
| case BRIG_ATOMIC_CAS: |
| return "cas"; |
| case BRIG_ATOMIC_EXCH: |
| return "exch"; |
| case BRIG_ATOMIC_LD: |
| return "ld"; |
| case BRIG_ATOMIC_MAX: |
| return "max"; |
| case BRIG_ATOMIC_MIN: |
| return "min"; |
| case BRIG_ATOMIC_OR: |
| return "or"; |
| case BRIG_ATOMIC_ST: |
| return "st"; |
| case BRIG_ATOMIC_SUB: |
| return "sub"; |
| case BRIG_ATOMIC_WRAPDEC: |
| return "wrapdec"; |
| case BRIG_ATOMIC_WRAPINC: |
| return "wrapinc"; |
| case BRIG_ATOMIC_XOR: |
| return "xor"; |
| case BRIG_ATOMIC_WAIT_EQ: |
| return "wait_eq"; |
| case BRIG_ATOMIC_WAIT_NE: |
| return "wait_ne"; |
| case BRIG_ATOMIC_WAIT_LT: |
| return "wait_lt"; |
| case BRIG_ATOMIC_WAIT_GTE: |
| return "wait_gte"; |
| case BRIG_ATOMIC_WAITTIMEOUT_EQ: |
| return "waittimeout_eq"; |
| case BRIG_ATOMIC_WAITTIMEOUT_NE: |
| return "waittimeout_ne"; |
| case BRIG_ATOMIC_WAITTIMEOUT_LT: |
| return "waittimeout_lt"; |
| case BRIG_ATOMIC_WAITTIMEOUT_GTE: |
| return "waittimeout_gte"; |
| default: |
| return "UNKNOWN_ATOMIC_OP"; |
| } |
| } |
| |
| /* Return textual name for atomic operation. */ |
| |
| static const char * |
| hsa_width_specifier_name (BrigWidth8_t width) |
| { |
| switch (width) |
| { |
| case BRIG_WIDTH_NONE: |
| return "none"; |
| case BRIG_WIDTH_1: |
| return "1"; |
| case BRIG_WIDTH_2: |
| return "2"; |
| case BRIG_WIDTH_4: |
| return "4"; |
| case BRIG_WIDTH_8: |
| return "8"; |
| case BRIG_WIDTH_16: |
| return "16"; |
| case BRIG_WIDTH_32: |
| return "32"; |
| case BRIG_WIDTH_64: |
| return "64"; |
| case BRIG_WIDTH_128: |
| return "128"; |
| case BRIG_WIDTH_256: |
| return "256"; |
| case BRIG_WIDTH_512: |
| return "512"; |
| case BRIG_WIDTH_1024: |
| return "1024"; |
| case BRIG_WIDTH_2048: |
| return "2048"; |
| case BRIG_WIDTH_4096: |
| return "4096"; |
| case BRIG_WIDTH_8192: |
| return "8192"; |
| case BRIG_WIDTH_16384: |
| return "16384"; |
| case BRIG_WIDTH_32768: |
| return "32768"; |
| case BRIG_WIDTH_65536: |
| return "65536"; |
| case BRIG_WIDTH_131072: |
| return "131072"; |
| case BRIG_WIDTH_262144: |
| return "262144"; |
| case BRIG_WIDTH_524288: |
| return "524288"; |
| case BRIG_WIDTH_1048576: |
| return "1048576"; |
| case BRIG_WIDTH_2097152: |
| return "2097152"; |
| case BRIG_WIDTH_4194304: |
| return "4194304"; |
| case BRIG_WIDTH_8388608: |
| return "8388608"; |
| case BRIG_WIDTH_16777216: |
| return "16777216"; |
| case BRIG_WIDTH_33554432: |
| return "33554432"; |
| case BRIG_WIDTH_67108864: |
| return "67108864"; |
| case BRIG_WIDTH_134217728: |
| return "134217728"; |
| case BRIG_WIDTH_268435456: |
| return "268435456"; |
| case BRIG_WIDTH_536870912: |
| return "536870912"; |
| case BRIG_WIDTH_1073741824: |
| return "1073741824"; |
| case BRIG_WIDTH_2147483648: |
| return "2147483648"; |
| case BRIG_WIDTH_WAVESIZE: |
| return "wavesize"; |
| case BRIG_WIDTH_ALL: |
| return "all"; |
| default: |
| return "UNKNOWN_WIDTH"; |
| } |
| } |
| |
| /* Dump textual representation of HSA IL register REG to file F. */ |
| |
| static void |
| dump_hsa_reg (FILE *f, hsa_op_reg *reg, bool dump_type = false) |
| { |
| if (reg->m_reg_class) |
| fprintf (f, "$%c%i", reg->m_reg_class, reg->m_hard_num); |
| else |
| fprintf (f, "$_%i", reg->m_order); |
| if (dump_type) |
| fprintf (f, " (%s)", hsa_type_name (reg->m_type)); |
| } |
| |
| /* Dump textual representation of HSA IL immediate operand IMM to file F. */ |
| |
| static void |
| dump_hsa_immed (FILE *f, hsa_op_immed *imm) |
| { |
| bool unsigned_int_type |
| = (BRIG_TYPE_U8 | BRIG_TYPE_U16 | BRIG_TYPE_U32 | BRIG_TYPE_U64) |
| & imm->m_type; |
| |
| if (imm->m_tree_value) |
| print_generic_expr (f, imm->m_tree_value); |
| else |
| { |
| if (unsigned_int_type) |
| fprintf (f, HOST_WIDE_INT_PRINT_DEC, imm->m_int_value); |
| else |
| fprintf (f, HOST_WIDE_INT_PRINT_UNSIGNED, |
| (unsigned HOST_WIDE_INT) imm->m_int_value); |
| } |
| |
| fprintf (f, " (%s)", hsa_type_name (imm->m_type)); |
| } |
| |
| /* Dump textual representation of HSA IL address operand ADDR to file F. */ |
| |
| static void |
| dump_hsa_address (FILE *f, hsa_op_address *addr) |
| { |
| bool sth = false; |
| |
| if (addr->m_symbol) |
| { |
| sth = true; |
| if (addr->m_symbol->m_name) |
| fprintf (f, "[%%%s]", addr->m_symbol->m_name); |
| else |
| fprintf (f, "[%%__%s_%i]", hsa_seg_name (addr->m_symbol->m_segment), |
| addr->m_symbol->m_name_number); |
| } |
| |
| if (addr->m_reg) |
| { |
| fprintf (f, "["); |
| dump_hsa_reg (f, addr->m_reg); |
| if (addr->m_imm_offset != 0) |
| fprintf (f, " + " HOST_WIDE_INT_PRINT_DEC "]", addr->m_imm_offset); |
| else |
| fprintf (f, "]"); |
| } |
| else if (!sth || addr->m_imm_offset != 0) |
| fprintf (f, "[" HOST_WIDE_INT_PRINT_DEC "]", addr->m_imm_offset); |
| } |
| |
| /* Dump textual representation of HSA IL symbol SYMBOL to file F. */ |
| |
| static void |
| dump_hsa_symbol (FILE *f, hsa_symbol *symbol) |
| { |
| const char *name; |
| char buf[64]; |
| if (symbol->m_name) |
| name = symbol->m_name; |
| else |
| { |
| sprintf (buf, "__%s_%i", hsa_seg_name (symbol->m_segment), |
| symbol->m_name_number); |
| |
| name = buf; |
| } |
| |
| fprintf (f, "align(%u) %s_%s %s", hsa_byte_alignment (symbol->m_align), |
| hsa_seg_name (symbol->m_segment), |
| hsa_type_name (symbol->m_type & ~BRIG_TYPE_ARRAY_MASK), name); |
| |
| if (symbol->m_type & BRIG_TYPE_ARRAY_MASK) |
| fprintf (f, "[%lu]", (unsigned long) symbol->m_dim); |
| |
| if (symbol->m_directive_offset) |
| fprintf (f, " /* BRIG offset: %u */", symbol->m_directive_offset); |
| } |
| |
| /* Dump textual representation of HSA IL operand OP to file F. */ |
| |
| static void |
| dump_hsa_operand (FILE *f, hsa_op_base *op, bool dump_reg_type = false) |
| { |
| if (is_a <hsa_op_immed *> (op)) |
| dump_hsa_immed (f, as_a <hsa_op_immed *> (op)); |
| else if (is_a <hsa_op_reg *> (op)) |
| dump_hsa_reg (f, as_a <hsa_op_reg *> (op), dump_reg_type); |
| else if (is_a <hsa_op_address *> (op)) |
| dump_hsa_address (f, as_a <hsa_op_address *> (op)); |
| else |
| fprintf (f, "UNKNOWN_OP_KIND"); |
| } |
| |
| /* Dump textual representation of HSA IL operands in VEC to file F. */ |
| |
| static void |
| dump_hsa_operands (FILE *f, hsa_insn_basic *insn, int start = 0, |
| int end = -1, bool dump_reg_type = false) |
| { |
| if (end == -1) |
| end = insn->operand_count (); |
| |
| for (int i = start; i < end; i++) |
| { |
| dump_hsa_operand (f, insn->get_op (i), dump_reg_type); |
| if (i != end - 1) |
| fprintf (f, ", "); |
| } |
| } |
| |
| /* Indent F stream with INDENT spaces. */ |
| |
| static void indent_stream (FILE *f, int indent) |
| { |
| for (int i = 0; i < indent; i++) |
| fputc (' ', f); |
| } |
| |
| /* Dump textual representation of HSA IL instruction INSN to file F. Prepend |
| the instruction with *INDENT spaces and adjust the indentation for call |
| instructions as appropriate. */ |
| |
| static void |
| dump_hsa_insn_1 (FILE *f, hsa_insn_basic *insn, int *indent) |
| { |
| gcc_checking_assert (insn); |
| |
| if (insn->m_number) |
| fprintf (f, "%5d: ", insn->m_number); |
| |
| indent_stream (f, *indent); |
| |
| if (is_a <hsa_insn_phi *> (insn)) |
| { |
| hsa_insn_phi *phi = as_a <hsa_insn_phi *> (insn); |
| bool first = true; |
| dump_hsa_reg (f, phi->m_dest, true); |
| fprintf (f, " = PHI <"); |
| unsigned count = phi->operand_count (); |
| for (unsigned i = 0; i < count; i++) |
| { |
| if (!phi->get_op (i)) |
| break; |
| if (!first) |
| fprintf (f, ", "); |
| else |
| first = false; |
| dump_hsa_operand (f, phi->get_op (i), true); |
| } |
| fprintf (f, ">"); |
| } |
| else if (is_a <hsa_insn_signal *> (insn)) |
| { |
| hsa_insn_signal *mem = as_a <hsa_insn_signal *> (insn); |
| |
| fprintf (f, "%s", hsa_opcode_name (mem->m_opcode)); |
| fprintf (f, "_%s", hsa_m_atomicop_name (mem->m_signalop)); |
| if (mem->m_memory_order != BRIG_MEMORY_ORDER_NONE) |
| fprintf (f, "_%s", hsa_memsem_name (mem->m_memory_order)); |
| fprintf (f, "_%s ", hsa_type_name (mem->m_type)); |
| |
| dump_hsa_operands (f, mem); |
| } |
| |
| else if (is_a <hsa_insn_atomic *> (insn)) |
| { |
| hsa_insn_atomic *mem = as_a <hsa_insn_atomic *> (insn); |
| |
| /* Either operand[0] or operand[1] must be an address operand. */ |
| hsa_op_address *addr = NULL; |
| if (is_a <hsa_op_address *> (mem->get_op (0))) |
| addr = as_a <hsa_op_address *> (mem->get_op (0)); |
| else |
| addr = as_a <hsa_op_address *> (mem->get_op (1)); |
| |
| fprintf (f, "%s", hsa_opcode_name (mem->m_opcode)); |
| fprintf (f, "_%s", hsa_m_atomicop_name (mem->m_atomicop)); |
| if (addr->m_symbol) |
| fprintf (f, "_%s", hsa_seg_name (addr->m_symbol->m_segment)); |
| if (mem->m_memoryorder != BRIG_MEMORY_ORDER_NONE) |
| fprintf (f, "_%s", hsa_memsem_name (mem->m_memoryorder)); |
| if (mem->m_memoryscope != BRIG_MEMORY_SCOPE_NONE) |
| fprintf (f, "_%s", hsa_memscope_name (mem->m_memoryscope)); |
| fprintf (f, "_%s ", hsa_type_name (mem->m_type)); |
| |
| dump_hsa_operands (f, mem); |
| } |
| else if (is_a <hsa_insn_mem *> (insn)) |
| { |
| hsa_insn_mem *mem = as_a <hsa_insn_mem *> (insn); |
| hsa_op_address *addr = as_a <hsa_op_address *> (mem->get_op (1)); |
| |
| fprintf (f, "%s", hsa_opcode_name (mem->m_opcode)); |
| if (addr->m_symbol) |
| fprintf (f, "_%s", hsa_seg_name (addr->m_symbol->m_segment)); |
| if (mem->m_align != BRIG_ALIGNMENT_NONE) |
| fprintf (f, "_align(%u)", hsa_byte_alignment (mem->m_align)); |
| if (mem->m_equiv_class != 0) |
| fprintf (f, "_equiv(%i)", mem->m_equiv_class); |
| fprintf (f, "_%s ", hsa_type_name (mem->m_type)); |
| |
| dump_hsa_operand (f, mem->get_op (0)); |
| fprintf (f, ", "); |
| dump_hsa_address (f, addr); |
| } |
| else if (insn->m_opcode == BRIG_OPCODE_LDA) |
| { |
| hsa_op_address *addr = as_a <hsa_op_address *> (insn->get_op (1)); |
| |
| fprintf (f, "%s", hsa_opcode_name (insn->m_opcode)); |
| if (addr->m_symbol) |
| fprintf (f, "_%s", hsa_seg_name (addr->m_symbol->m_segment)); |
| fprintf (f, "_%s ", hsa_type_name (insn->m_type)); |
| |
| dump_hsa_operand (f, insn->get_op (0)); |
| fprintf (f, ", "); |
| dump_hsa_address (f, addr); |
| } |
| else if (is_a <hsa_insn_seg *> (insn)) |
| { |
| hsa_insn_seg *seg = as_a <hsa_insn_seg *> (insn); |
| fprintf (f, "%s_%s_%s_%s ", hsa_opcode_name (seg->m_opcode), |
| hsa_seg_name (seg->m_segment), |
| hsa_type_name (seg->m_type), hsa_type_name (seg->m_src_type)); |
| dump_hsa_reg (f, as_a <hsa_op_reg *> (seg->get_op (0))); |
| fprintf (f, ", "); |
| dump_hsa_operand (f, seg->get_op (1)); |
| } |
| else if (is_a <hsa_insn_cmp *> (insn)) |
| { |
| hsa_insn_cmp *cmp = as_a <hsa_insn_cmp *> (insn); |
| BrigType16_t src_type; |
| |
| if (is_a <hsa_op_reg *> (cmp->get_op (1))) |
| src_type = as_a <hsa_op_reg *> (cmp->get_op (1))->m_type; |
| else |
| src_type = as_a <hsa_op_immed *> (cmp->get_op (1))->m_type; |
| |
| fprintf (f, "%s_%s_%s_%s ", hsa_opcode_name (cmp->m_opcode), |
| hsa_cmpop_name (cmp->m_compare), |
| hsa_type_name (cmp->m_type), hsa_type_name (src_type)); |
| dump_hsa_reg (f, as_a <hsa_op_reg *> (cmp->get_op (0))); |
| fprintf (f, ", "); |
| dump_hsa_operand (f, cmp->get_op (1)); |
| fprintf (f, ", "); |
| dump_hsa_operand (f, cmp->get_op (2)); |
| } |
| else if (is_a <hsa_insn_cbr *> (insn)) |
| { |
| hsa_insn_cbr *br = as_a <hsa_insn_cbr *> (insn); |
| basic_block target = NULL; |
| edge_iterator ei; |
| edge e; |
| |
| fprintf (f, "%s ", hsa_opcode_name (br->m_opcode)); |
| if (br->m_opcode == BRIG_OPCODE_CBR) |
| { |
| dump_hsa_reg (f, as_a <hsa_op_reg *> (br->get_op (0))); |
| fprintf (f, ", "); |
| } |
| |
| FOR_EACH_EDGE (e, ei, br->m_bb->succs) |
| if (e->flags & EDGE_TRUE_VALUE) |
| { |
| target = e->dest; |
| break; |
| } |
| fprintf (f, "BB %i", hsa_bb_for_bb (target)->m_index); |
| } |
| else if (is_a <hsa_insn_sbr *> (insn)) |
| { |
| hsa_insn_sbr *sbr = as_a <hsa_insn_sbr *> (insn); |
| |
| fprintf (f, "%s ", hsa_opcode_name (sbr->m_opcode)); |
| dump_hsa_reg (f, as_a <hsa_op_reg *> (sbr->get_op (0))); |
| fprintf (f, ", ["); |
| |
| for (unsigned i = 0; i < sbr->m_jump_table.length (); i++) |
| { |
| fprintf (f, "BB %i", hsa_bb_for_bb (sbr->m_jump_table[i])->m_index); |
| if (i != sbr->m_jump_table.length () - 1) |
| fprintf (f, ", "); |
| } |
| } |
| else if (is_a <hsa_insn_br *> (insn)) |
| { |
| hsa_insn_br *br = as_a <hsa_insn_br *> (insn); |
| fprintf (f, "%s_width(%s) ", hsa_opcode_name (br->m_opcode), |
| hsa_width_specifier_name (br->m_width)); |
| } |
| else if (is_a <hsa_insn_arg_block *> (insn)) |
| { |
| hsa_insn_arg_block *arg_block = as_a <hsa_insn_arg_block *> (insn); |
| bool start_p = arg_block->m_kind == BRIG_KIND_DIRECTIVE_ARG_BLOCK_START; |
| char c = start_p ? '{' : '}'; |
| |
| if (start_p) |
| { |
| *indent += 2; |
| indent_stream (f, 2); |
| } |
| |
| if (!start_p) |
| *indent -= 2; |
| |
| fprintf (f, "%c", c); |
| } |
| else if (is_a <hsa_insn_call *> (insn)) |
| { |
| hsa_insn_call *call = as_a <hsa_insn_call *> (insn); |
| if (call->m_called_function) |
| { |
| const char *name = hsa_get_declaration_name (call->m_called_function); |
| fprintf (f, "call &%s", name); |
| } |
| else |
| { |
| char *name = call->m_called_internal_fn->name (); |
| fprintf (f, "call &%s", name); |
| free (name); |
| } |
| |
| if (call->m_output_arg) |
| fprintf (f, "(%%res) "); |
| |
| fprintf (f, "("); |
| for (unsigned i = 0; i < call->m_input_args.length (); i++) |
| { |
| fprintf (f, "%%__arg_%u", i); |
| |
| if (i != call->m_input_args.length () - 1) |
| fprintf (f, ", "); |
| } |
| fprintf (f, ")"); |
| } |
| else if (is_a <hsa_insn_comment *> (insn)) |
| { |
| hsa_insn_comment *c = as_a <hsa_insn_comment *> (insn); |
| fprintf (f, "%s", c->m_comment); |
| } |
| else if (is_a <hsa_insn_srctype *> (insn)) |
| { |
| hsa_insn_srctype *srctype = as_a <hsa_insn_srctype *> (insn); |
| |
| fprintf (f, "%s_%s_%s ", hsa_opcode_name (srctype->m_opcode), |
| hsa_type_name (srctype->m_type), |
| hsa_type_name (srctype->m_source_type)); |
| |
| dump_hsa_operands (f, insn); |
| } |
| else if (is_a <hsa_insn_packed *> (insn)) |
| { |
| hsa_insn_packed *packed = as_a <hsa_insn_packed *> (insn); |
| |
| fprintf (f, "%s_v%u_%s_%s ", hsa_opcode_name (packed->m_opcode), |
| packed->operand_count () - 1, |
| hsa_type_name (packed->m_type), |
| hsa_type_name (packed->m_source_type)); |
| |
| if (packed->m_opcode == BRIG_OPCODE_COMBINE) |
| { |
| dump_hsa_operand (f, insn->get_op (0)); |
| fprintf (f, ", ("); |
| dump_hsa_operands (f, insn, 1); |
| fprintf (f, ")"); |
| } |
| else if (packed->m_opcode == BRIG_OPCODE_EXPAND) |
| { |
| fprintf (f, "("); |
| dump_hsa_operands (f, insn, 0, insn->operand_count () - 1); |
| fprintf (f, "), "); |
| dump_hsa_operand (f, insn->get_op (insn->operand_count () - 1)); |
| |
| } |
| else |
| gcc_unreachable (); |
| } |
| else if (is_a <hsa_insn_alloca *> (insn)) |
| { |
| hsa_insn_alloca *alloca = as_a <hsa_insn_alloca *> (insn); |
| |
| fprintf (f, "%s_align(%u)_%s ", hsa_opcode_name (insn->m_opcode), |
| hsa_byte_alignment (alloca->m_align), |
| hsa_type_name (insn->m_type)); |
| |
| dump_hsa_operands (f, insn); |
| } |
| else if (hsa_insn_queue *qi = dyn_cast <hsa_insn_queue *> (insn)) |
| { |
| fprintf (f, "%s_%s_%s_%s ", hsa_opcode_name (qi->m_opcode), |
| hsa_seg_name (qi->m_segment), |
| hsa_memsem_name (qi->m_memory_order), |
| hsa_type_name (qi->m_type)); |
| |
| dump_hsa_operands (f, qi); |
| } |
| else |
| { |
| fprintf (f, "%s_%s ", hsa_opcode_name (insn->m_opcode), |
| hsa_type_name (insn->m_type)); |
| |
| dump_hsa_operands (f, insn); |
| } |
| |
| if (insn->m_brig_offset) |
| { |
| fprintf (f, " /* BRIG offset: %u", insn->m_brig_offset); |
| |
| for (unsigned i = 0; i < insn->operand_count (); i++) |
| fprintf (f, ", op%u: %u", i, insn->get_op (i)->m_brig_op_offset); |
| |
| fprintf (f, " */"); |
| } |
| |
| fprintf (f, "\n"); |
| } |
| |
| /* Dump textual representation of HSA IL instruction INSN to file F. */ |
| |
| void |
| dump_hsa_insn (FILE *f, hsa_insn_basic *insn) |
| { |
| int indent = 0; |
| dump_hsa_insn_1 (f, insn, &indent); |
| } |
| |
| /* Dump textual representation of HSA IL in HBB to file F. */ |
| |
| void |
| dump_hsa_bb (FILE *f, hsa_bb *hbb) |
| { |
| hsa_insn_basic *insn; |
| edge_iterator ei; |
| edge e; |
| basic_block true_bb = NULL, other = NULL; |
| |
| fprintf (f, "BB %i:\n", hbb->m_index); |
| |
| int indent = 2; |
| for (insn = hbb->m_first_phi; insn; insn = insn->m_next) |
| dump_hsa_insn_1 (f, insn, &indent); |
| |
| for (insn = hbb->m_first_insn; insn; insn = insn->m_next) |
| dump_hsa_insn_1 (f, insn, &indent); |
| |
| if (hbb->m_last_insn && is_a <hsa_insn_sbr *> (hbb->m_last_insn)) |
| goto exit; |
| |
| FOR_EACH_EDGE (e, ei, hbb->m_bb->succs) |
| if (e->flags & EDGE_TRUE_VALUE) |
| { |
| gcc_assert (!true_bb); |
| true_bb = e->dest; |
| } |
| else |
| { |
| gcc_assert (!other); |
| other = e->dest; |
| } |
| |
| if (true_bb) |
| { |
| if (!hbb->m_last_insn |
| || hbb->m_last_insn->m_opcode != BRIG_OPCODE_CBR) |
| fprintf (f, "WARNING: No branch insn for a true edge. \n"); |
| } |
| else if (hbb->m_last_insn |
| && hbb->m_last_insn->m_opcode == BRIG_OPCODE_CBR) |
| fprintf (f, "WARNING: No true edge for a cbr statement\n"); |
| |
| if (other && other->aux) |
| fprintf (f, " Fall-through to BB %i\n", |
| hsa_bb_for_bb (other)->m_index); |
| else if (hbb->m_last_insn |
| && hbb->m_last_insn->m_opcode != BRIG_OPCODE_RET) |
| fprintf (f, " WARNING: Fall through to a BB with no aux!\n"); |
| |
| exit: |
| fprintf (f, "\n"); |
| } |
| |
| /* Dump textual representation of HSA IL of the current function to file F. */ |
| |
| void |
| dump_hsa_cfun (FILE *f) |
| { |
| basic_block bb; |
| |
| if (hsa_cfun->m_global_symbols.length () > 0) |
| fprintf (f, "\nHSAIL in global scope\n"); |
| |
| for (unsigned i = 0; i < hsa_cfun->m_global_symbols.length (); i++) |
| { |
| fprintf (f, " "); |
| dump_hsa_symbol (f, hsa_cfun->m_global_symbols[i]); |
| fprintf (f, "\n"); |
| } |
| |
| fprintf (f, "\nHSAIL IL for %s\n", hsa_cfun->m_name); |
| |
| for (unsigned i = 0; i < hsa_cfun->m_private_variables.length (); i++) |
| { |
| fprintf (f, " "); |
| dump_hsa_symbol (f, hsa_cfun->m_private_variables[i]); |
| fprintf (f, "\n"); |
| } |
| |
| FOR_ALL_BB_FN (bb, cfun) |
| { |
| hsa_bb *hbb = (struct hsa_bb *) bb->aux; |
| dump_hsa_bb (f, hbb); |
| } |
| } |
| |
| /* Dump textual representation of HSA IL instruction INSN to stderr. */ |
| |
| DEBUG_FUNCTION void |
| debug_hsa_insn (hsa_insn_basic *insn) |
| { |
| dump_hsa_insn (stderr, insn); |
| } |
| |
| /* Dump textual representation of HSA IL in HBB to stderr. */ |
| |
| DEBUG_FUNCTION void |
| debug_hsa_bb (hsa_bb *hbb) |
| { |
| dump_hsa_bb (stderr, hbb); |
| } |
| |
| /* Dump textual representation of HSA IL of the current function to stderr. */ |
| |
| DEBUG_FUNCTION void |
| debug_hsa_cfun (void) |
| { |
| dump_hsa_cfun (stderr); |
| } |
| |
| /* Dump textual representation of an HSA operand to stderr. */ |
| |
| DEBUG_FUNCTION void |
| debug_hsa_operand (hsa_op_base *opc) |
| { |
| dump_hsa_operand (stderr, opc, true); |
| fprintf (stderr, "\n"); |
| } |
| |
| /* Dump textual representation of as HSA symbol. */ |
| |
| DEBUG_FUNCTION void |
| debug_hsa_symbol (hsa_symbol *symbol) |
| { |
| dump_hsa_symbol (stderr, symbol); |
| fprintf (stderr, "\n"); |
| } |
