Removal of HSA offloading from gcc and libgomp

This patch removes the generation of HSAIL from the compiler, the HSA
offloading plugin from libgomp and the associated testsuite tests and
infrastructure bits from the respective testsuites.

Apart from removal of the obvious files, I removed bits that I found
by searching for HSA related terms and by re-tracing my steps and
looking at the patches that introduced HSA in the first place.  I did
not remove everything these patches brought in, for example:

  - the mechanism to pass offload-target specific info from the application to
    the offloading plugin - but the same mechanism is also used to
    communicate number of teams and the thread limit to all offload targets.

  - run_func hook in gomp_device_descr stays too, although now it is
    not used.  If some future offload target would like the ability to
    refuse to offload some functions, it can use it.  It is easy to
    remove as a follow-up if it is considered clutter, though.

  - configure options --with-hsa-runtime=PATH, -with-hsa-runtime-include=PATH
    and --with-hsa-runtime-lib=PATH rmeain because GCN uses them too.

  - Surprisingly, GOMP_TARGET_ARG_HSA_KERNEL_ATTRIBUTES (a constant
    from gomp-constants.h) appears in the source of the amdgcn libgomp
    plugin, although I tend to think that code path is not ever used
    and this patch certainly removes it from the compiler.
    Nevertheless, it seems it has potential value beyond HSAIL and so
    I've kept it, it can of course always be easily removed in the
    future of GCN folk abandon it too.

  - I assume constants OFFLOAD_TARGET_TYPE_HSA and GOMP_DEVICE_HSA
    need to stay indefinitely too just so that no future offload
    target picks that number.

  - I have kept dg-require-effective-target
    offload_device_nonshared_as requirement of thests which have it.

It is quite probable I missed some small HSA artifacts but those
should be easy to remove later as we find them.

include/ChangeLog:

2020-07-24  Martin Jambor  <mjambor@suse.cz>

	* gomp-constants.h (GOMP_VERSION_HSA): Remove.

gcc/ChangeLog:

2020-07-24  Martin Jambor  <mjambor@suse.cz>

	* hsa-brig-format.h: Moved to brig/brigfrontend.
	* hsa-brig.c: Removed.
	* hsa-builtins.def: Likewise.
	* hsa-common.c: Likewise.
	* hsa-common.h: Likewise.
	* hsa-dump.c: Likewise.
	* hsa-gen.c: Likewise.
	* hsa-regalloc.c: Likewise.
	* ipa-hsa.c: Likewise.
	* omp-grid.c: Likewise.
	* omp-grid.h: Likewise.
	* Makefile.in (BUILTINS_DEF): Remove hsa-builtins.def.
	(OBJS): Remove hsa-common.o, hsa-gen.o, hsa-regalloc.o, hsa-brig.o,
	hsa-dump.o, ipa-hsa.c and omp-grid.o.
	(GTFILES): Removed hsa-common.c and omp-expand.c.
	* builtins.def: Remove processing of hsa-builtins.def.
	(DEF_HSA_BUILTIN): Remove.
	* common.opt (flag_disable_hsa): Remove.
	(-Whsa): Ignore.
	* config.in (ENABLE_HSA): Removed.
	* configure.ac: Removed handling configuration for hsa offloading.
	(ENABLE_HSA): Removed.
	* configure: Regenerated.
	* doc/install.texi (--enable-offload-targets): Remove hsa from the
	example.
	(--with-hsa-runtime): Reword to reference any HSA run-time, not
	specifically HSA offloading.
	* doc/invoke.texi (Option Summary): Remove -Whsa.
	(Warning Options): Likewise.
	(Optimize Options): Remove hsa-gen-debug-stores.
	* doc/passes.texi (Regular IPA passes): Remove section on IPA HSA
	pass.
	* gimple-low.c (lower_stmt): Remove GIMPLE_OMP_GRID_BODY case.
	* gimple-pretty-print.c (dump_gimple_omp_for): Likewise.
	(dump_gimple_omp_block): Likewise.
	(pp_gimple_stmt_1): Likewise.
	* gimple-walk.c (walk_gimple_stmt): Likewise.
	* gimple.c (gimple_build_omp_grid_body): Removed function.
	(gimple_copy): Remove GIMPLE_OMP_GRID_BODY case.
	* gimple.def (GIMPLE_OMP_GRID_BODY): Removed.
	* gimple.h (gf_mask): Removed GF_OMP_PARALLEL_GRID_PHONY,
	OMP_FOR_KIND_GRID_LOOP, GF_OMP_FOR_GRID_PHONY,
	GF_OMP_FOR_GRID_INTRA_GROUP, GF_OMP_FOR_GRID_GROUP_ITER and
	GF_OMP_TEAMS_GRID_PHONY.  Renumbered GF_OMP_FOR_KIND_SIMD and
	GF_OMP_TEAMS_HOST.
	(gimple_build_omp_grid_body): Removed declaration.
	(gimple_has_substatements): Remove GIMPLE_OMP_GRID_BODY case.
	(gimple_omp_for_grid_phony): Removed.
	(gimple_omp_for_set_grid_phony): Likewise.
	(gimple_omp_for_grid_intra_group): Likewise.
	(gimple_omp_for_grid_intra_group): Likewise.
	(gimple_omp_for_grid_group_iter): Likewise.
	(gimple_omp_for_set_grid_group_iter): Likewise.
	(gimple_omp_parallel_grid_phony): Likewise.
	(gimple_omp_parallel_set_grid_phony): Likewise.
	(gimple_omp_teams_grid_phony): Likewise.
	(gimple_omp_teams_set_grid_phony): Likewise.
	(CASE_GIMPLE_OMP): Remove GIMPLE_OMP_GRID_BODY case.
	* lto-section-in.c (lto_section_name): Removed hsa.
	* lto-streamer.h (lto_section_type): Removed LTO_section_ipa_hsa.
	* lto-wrapper.c (compile_images_for_offload_targets): Remove special
	handling of hsa.
	* omp-expand.c: Do not include hsa-common.h and gt-omp-expand.h.
	(parallel_needs_hsa_kernel_p): Removed.
	(grid_launch_attributes_trees): Likewise.
	(grid_launch_attributes_trees): Likewise.
	(grid_create_kernel_launch_attr_types): Likewise.
	(grid_insert_store_range_dim): Likewise.
	(grid_get_kernel_launch_attributes): Likewise.
	(get_target_arguments): Remove code passing HSA grid sizes.
	(grid_expand_omp_for_loop): Remove.
	(grid_arg_decl_map): Likewise.
	(grid_remap_kernel_arg_accesses): Likewise.
	(grid_expand_target_grid_body): Likewise.
	(expand_omp): Remove call to grid_expand_target_grid_body.
	(omp_make_gimple_edges): Remove GIMPLE_OMP_GRID_BODY case.
	* omp-general.c: Do not include hsa-common.h.
	(omp_maybe_offloaded): Do not check for HSA offloading.
	(omp_context_selector_matches): Likewise.
	* omp-low.c: Do not include hsa-common.h and omp-grid.h.
	(build_outer_var_ref): Remove handling of GIMPLE_OMP_GRID_BODY.
	(scan_sharing_clauses): Remove handling of OMP_CLAUSE__GRIDDIM_.
	(scan_omp_parallel): Remove handling of the phoney variant.
	(check_omp_nesting_restrictions): Remove handling of
	GIMPLE_OMP_GRID_BODY and GF_OMP_FOR_KIND_GRID_LOOP.
	(scan_omp_1_stmt): Remove handling of GIMPLE_OMP_GRID_BODY.
	(lower_omp_for_lastprivate): Remove handling of gridified loops.
	(lower_omp_for): Remove phony loop handling.
	(lower_omp_taskreg): Remove phony construct handling.
	(lower_omp_teams): Likewise.
	(lower_omp_grid_body): Removed.
	(lower_omp_1): Remove GIMPLE_OMP_GRID_BODY case.
	(execute_lower_omp): Do not call omp_grid_gridify_all_targets.
	* opts.c (common_handle_option): Do not handle hsa when processing
	OPT_foffload_.
	* params.opt (hsa-gen-debug-stores): Remove.
	* passes.def: Remove pass_ipa_hsa and pass_gen_hsail.
	* timevar.def: Remove TV_IPA_HSA.
	* toplev.c: Do not include hsa-common.h.
	(compile_file): Do not call hsa_output_brig.
	* tree-core.h (enum omp_clause_code): Remove OMP_CLAUSE__GRIDDIM_.
	(tree_omp_clause): Remove union field dimension.
	* tree-nested.c (convert_nonlocal_omp_clauses): Remove the
	OMP_CLAUSE__GRIDDIM_ case.
	(convert_local_omp_clauses): Likewise.
	* tree-pass.h (make_pass_gen_hsail): Remove declaration.
	(make_pass_ipa_hsa): Likewise.
	* tree-pretty-print.c (dump_omp_clause): Remove GIMPLE_OMP_GRID_BODY
	case.
	* tree.c (omp_clause_num_ops): Remove the element corresponding to
	OMP_CLAUSE__GRIDDIM_.
	(omp_clause_code_name): Likewise.
	(walk_tree_1): Remove GIMPLE_OMP_GRID_BODY case.
	* tree.h (OMP_CLAUSE__GRIDDIM__DIMENSION): Remove.
	(OMP_CLAUSE__GRIDDIM__SIZE): Likewise.
	(OMP_CLAUSE__GRIDDIM__GROUP): Likewise.

gcc/fortran/ChangeLog:

2020-07-24  Martin Jambor  <mjambor@suse.cz>

	* f95-lang.c (gfc_init_builtin_functions): Remove processing of
	hsa-builtins.def.

gcc/brig/ChangeLog:

2020-07-24  Martin Jambor  <mjambor@suse.cz>

	* brigfrontend/brig-util.h (hsa_type_packed_p): Declared.
	* brigfrontend/brig-util.cc (hsa_type_packed_p): Moved here from
	removed gcc/hsa-common.c.

libgomp/ChangeLog:

2020-07-24  Martin Jambor  <mjambor@suse.cz>

	* plugin/Makefrag.am: Remove configuration of HSA plugin.
	* aclocal.m4: Regenerated.
	* Makefile.in: Regenerated.
	* config.h.in: Regenerated.
	* configure: Regenerated.
	* plugin/configfrag.ac: Likewise.
	* plugin/hsa_ext_finalize.h: Removed.
	* plugin/plugin-hsa.c: Likewise.
	* testsuite/Makefile.in: Regenerated.
	* testsuite/lib/libgomp.exp
	(offload_target_to_openacc_device_type): Remove hsa case.
	(check_effective_target_hsa_offloading_selected_nocache): Removed
	(check_effective_target_hsa_offloading_selected): Likewise.
	(libgomp_init): Do not add -Wno-hsa to additional_flags.
	* testsuite/libgomp.hsa.c/alloca-1.c: Removed test.
	* testsuite/libgomp.hsa.c/bitfield-1.c: Likewise.
	* testsuite/libgomp.hsa.c/bits-insns.c: Likewise.
	* testsuite/libgomp.hsa.c/builtins-1.c: Likewise.
	* testsuite/libgomp.hsa.c/c.exp: Likewise.
	* testsuite/libgomp.hsa.c/complex-1.c: Likewise.
	* testsuite/libgomp.hsa.c/complex-align-2.c: Likewise.
	* testsuite/libgomp.hsa.c/formal-actual-args-1.c: Likewise.
	* testsuite/libgomp.hsa.c/function-call-1.c: Likewise.
	* testsuite/libgomp.hsa.c/get-level-1.c: Likewise.
	* testsuite/libgomp.hsa.c/gridify-1.c: Likewise.
	* testsuite/libgomp.hsa.c/gridify-2.c: Likewise.
	* testsuite/libgomp.hsa.c/gridify-3.c: Likewise.
	* testsuite/libgomp.hsa.c/gridify-4.c: Likewise.
	* testsuite/libgomp.hsa.c/memory-operations-1.c: Likewise.
	* testsuite/libgomp.hsa.c/pr69568.c: Likewise.
	* testsuite/libgomp.hsa.c/pr82416.c: Likewise.
	* testsuite/libgomp.hsa.c/rotate-1.c: Likewise.
	* testsuite/libgomp.hsa.c/staticvar.c: Likewise.
	* testsuite/libgomp.hsa.c/switch-1.c: Likewise.
	* testsuite/libgomp.hsa.c/switch-branch-1.c: Likewise.
	* testsuite/libgomp.hsa.c/switch-sbr-2.c: Likewise.
	* testsuite/libgomp.hsa.c/tiling-1.c: Likewise.
	* testsuite/libgomp.hsa.c/tiling-2.c: Likewise.

gcc/testsuite/ChangeLog:

2020-07-24  Martin Jambor  <mjambor@suse.cz>

	* lib/target-supports.exp (check_effective_target_offload_hsa):
	Removed.
	* c-c++-common/gomp/gridify-1.c: Removed test.
	* c-c++-common/gomp/gridify-2.c: Likewise.
	* c-c++-common/gomp/gridify-3.c: Likewise.
	* c-c++-common/gomp/hsa-indirect-call-1.c: Likewise.
	* gfortran.dg/gomp/gridify-1.f90: Likewise.
	* gcc.dg/gomp/gomp.exp: Do not pass -Wno-hsa to tests.
	* g++.dg/gomp/gomp.exp: Likewise.
	* gfortran.dg/gomp/gomp.exp: Likewise.

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");
-}