aboutsummaryrefslogtreecommitdiff
path: root/gcc/hsa-dump.c
diff options
context:
space:
mode:
Diffstat (limited to 'gcc/hsa-dump.c')
-rw-r--r--gcc/hsa-dump.c1278
1 files changed, 0 insertions, 1278 deletions
diff --git a/gcc/hsa-dump.c b/gcc/hsa-dump.c
deleted file mode 100644
index 23aa4c9..0000000
--- a/gcc/hsa-dump.c
+++ /dev/null
@@ -1,1278 +0,0 @@
-/* Infrastructure to dump our HSAIL IL
- Copyright (C) 2013-2020 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 "alloc-pool.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 = (class 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");
-}
generated by cgit v1.1 at 2025-08-10 23:39:28 +0000