tmake_file="${tmake_file} ft32/t-ft32"
;;
amdgcn-*-amdhsa)
- tm_file="elfos.h gcn/gcn-hsa.h gcn/gcn.h newlib-stdint.h"
+ tm_file="elfos.h gcn/gcn-hsa.h gcn/gcn.h newlib-stdint.h ./gcn-device-macros.h"
tmake_file="gcn/t-gcn-hsa"
native_system_header_dir=/include
extra_modes=gcn/gcn-modes.def
extra_objs="${extra_objs} gcn-tree.o"
+ extra_options="${extra_options} gcn/gcn-tables.opt"
case "$host" in
x86_64*-*-linux-gnu )
if test "$ac_cv_search_dlopen" != no; then
--- /dev/null
+/* Copyright (C) 2024 Free Software Foundation, Inc.
+
+ This file 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 of the License, or (at your option)
+ any later version.
+
+ This file 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/>. */
+
+/* GCN Device Configurations.
+
+ This file contains all the device-specific information needed for both
+ GCC and Libgomp. Please respect the formatting and field comments as
+ this file is read by Awk scripts in addition to the C++ preprocessor.
+
+ To add a new device:
+ 1. Add a new GCN_DEVICE instance below.
+ 2. Add the name to the list in config.gcc.
+ 3. Allow gcn-tables.opt to regenerate.
+ 4. Implement target-specific metadata and new features using
+ PROCESSOR_<NAME> (or a new ISA feature flag).
+ 5. Consider adding to the set of device-specific tests in the libgomp
+ testsuite.
+
+ New ISA variants are defined in gcn-opts.h. Please use the feature macros
+ in any conditionals, rather than depending on specific devices or ISAs
+ directly.
+
+ GCN_DEVICE field descriptions:
+ 0 "name" (text, external)
+ Lower case device name used in -march=name, diagnostics,
+ assembler directives, etc.
+ 1 "NAME" (text, external)
+ Upper case device name used in macros.
+ 2 "ELF" (hex integer, external)
+ Magic number used assigned to this device for use in elf_flags.
+ 3 "ISA" (enum gcn_isa, internal)
+ ISA variant for instruction selection, etc.
+ 4 "XNACK default" (enum hsaco_attr_type, internal)
+ Default value for the -mattr=[-+]xnack setting. May need to correspond
+ to the assembler expectations for this device.
+ 5 "SRAM_ECC default" (enum hsaco_attr_type, internal)
+ Default value for the -mattr=[-+]sram-ecc setting. Only really used
+ to ensure that the binary is in a known state mkoffload can match.
+ 6 "WAVE64 mode" (enum hsaco_attr_type, internal)
+ Set "on" for devices where this needs to be configured, "unsupported"
+ otherwise (meaning no special treatment needed). GCC does not support
+ wave32 mode.
+ 7 "CU mode" (enum hsaco_attr_type, internal)
+ Set "on" for devices that have this feature, "unsupported" otherwise
+ (meaning that CU mode is not optional on the device). GCC does not
+ support CU mode off.
+ 8 "Max ISA VGPRs" (integer, internal)
+ Define how many registers there are in the VGPR register file, for the
+ purposes of calculating maximum occupancy. Some devices have AVGPRs
+ in the same register file, some have more registers than are
+ addressable from a single kernel. Used by libgomp's plugin-gcn.c.
+
+ Fields marked "external", above, have values defined elsewhere (HSA, ROCM,
+ LLVM, ELF, etc.) and must have matching definitions here. Fields marked
+ "internal" are defined and used only in GCC (although some may have
+ user-visible effects) and may be refactored as needed. */
+
+GCN_DEVICE(gfx900, GFX900, 0x2c, ISA_GCN5,
+ /* XNACK default */ HSACO_ATTR_OFF,
+ /* SRAM_ECC default */ HSACO_ATTR_UNSUPPORTED,
+ /* WAVE64 mode */ HSACO_ATTR_UNSUPPORTED,
+ /* CU mode */ HSACO_ATTR_UNSUPPORTED,
+ /* Max ISA VGPRs */ 256
+ )
+
+GCN_DEVICE(gfx906, GFX906, 0x2f, ISA_GCN5,
+ /* XNACK default */ HSACO_ATTR_OFF,
+ /* SRAM_ECC default */ HSACO_ATTR_UNSUPPORTED,
+ /* WAVE64 mode */ HSACO_ATTR_UNSUPPORTED,
+ /* CU mode */ HSACO_ATTR_UNSUPPORTED,
+ /* Max ISA VGPRs */ 256
+ )
+
+GCN_DEVICE(gfx908, GFX908, 0x30, ISA_CDNA1,
+ /* XNACK default */ HSACO_ATTR_OFF,
+ /* SRAM_ECC default */ HSACO_ATTR_ANY,
+ /* WAVE64 mode */ HSACO_ATTR_UNSUPPORTED,
+ /* CU mode */ HSACO_ATTR_UNSUPPORTED,
+ /* Max ISA VGPRs */ 256
+ )
+
+GCN_DEVICE(gfx90a, GFX90A, 0x3f, ISA_CDNA2,
+ /* XNACK default */ HSACO_ATTR_ANY,
+ /* SRAM_ECC default */ HSACO_ATTR_ANY,
+ /* WAVE64 mode */ HSACO_ATTR_UNSUPPORTED,
+ /* CU mode */ HSACO_ATTR_UNSUPPORTED,
+ /* Max ISA VGPRs */ 512
+ )
+
+GCN_DEVICE(gfx90c, GFX90C, 0x32, ISA_GCN5,
+ /* XNACK default */ HSACO_ATTR_ANY,
+ /* SRAM_ECC default */ HSACO_ATTR_UNSUPPORTED,
+ /* WAVE64 mode */ HSACO_ATTR_UNSUPPORTED,
+ /* CU mode */ HSACO_ATTR_UNSUPPORTED,
+ /* Max ISA VGPRs */ 256
+ )
+
+GCN_DEVICE(gfx1030, GFX1030, 0x36, ISA_RDNA2,
+ /* XNACK default */ HSACO_ATTR_UNSUPPORTED,
+ /* SRAM_ECC default */ HSACO_ATTR_UNSUPPORTED,
+ /* WAVE64 mode */ HSACO_ATTR_ON,
+ /* CU mode */ HSACO_ATTR_ON,
+ /* Max ISA VGPRs */ 512 /* 512 SIMD32 = 256 wavefrontsize64. */
+ )
+
+GCN_DEVICE(gfx1036, GFX1036, 0x45, ISA_RDNA2,
+ /* XNACK default */ HSACO_ATTR_UNSUPPORTED,
+ /* SRAM_ECC default */ HSACO_ATTR_UNSUPPORTED,
+ /* WAVE64 mode */ HSACO_ATTR_ON,
+ /* CU mode */ HSACO_ATTR_ON,
+ /* Max ISA VGPRs */ 512 /* 512 SIMD32 = 256 wavefrontsize64. */
+ )
+
+GCN_DEVICE(gfx1100, GFX1100, 0x41, ISA_RDNA3,
+ /* XNACK default */ HSACO_ATTR_UNSUPPORTED,
+ /* SRAM_ECC default */ HSACO_ATTR_UNSUPPORTED,
+ /* WAVE64 mode */ HSACO_ATTR_ON,
+ /* CU mode */ HSACO_ATTR_ON,
+ /* Max ISA VGPRs */ 1536 /* 1536 SIMD32 = 768 wavefrontsize64. */
+ )
+
+GCN_DEVICE(gfx1103, GFX1103, 0x44, ISA_RDNA3,
+ /* XNACK default */ HSACO_ATTR_UNSUPPORTED,
+ /* SRAM_ECC default */ HSACO_ATTR_UNSUPPORTED,
+ /* WAVE64 mode */ HSACO_ATTR_ON,
+ /* CU mode */ HSACO_ATTR_ON,
+ /* Max ISA VGPRs */ 1536
+ )
+
+#undef GCN_DEVICE
GCC supports LLVM >= 13.0.1 and only LLVM >= 14 supports version 5. */
#define ABI_VERSION_SPEC "--amdhsa-code-object-version=4"
-/* Note that the XNACK and SRAM-ECC settings must match those in mkoffload.cc
- as the latter creates new ELF object file when debugging is enabled and
- the ELF flags (e_flags) of that generated file must be identical to those
- generated by the compiler. */
-
-#define NO_XNACK "march=gfx1030:;march=gfx1036:;march=gfx1100:;march=gfx1103:;" \
- /* These match the defaults set in gcn.cc. */ \
- "!mxnack*|mxnack=default:%{march=gfx900|march=gfx906|march=gfx908:-mattr=-xnack};"
-#define NO_SRAM_ECC "!march=*:;march=gfx900:;march=gfx906:;march=gfx90c:;"
-
-/* In HSACOv4 no attribute setting means the binary supports "any" hardware
- configuration. The name of the attribute also changed. */
-#define SRAMOPT "msram-ecc=on:-mattr=+sramecc;msram-ecc=off:-mattr=-sramecc"
-#define XNACKOPT "mxnack=on:-mattr=+xnack;mxnack=off:-mattr=-xnack"
+#include "gcn-device-macros.h"
/* Use LLVM assembler and linker options. */
#define ASM_SPEC "-triple=amdgcn--amdhsa " \
"%{march=*:-mcpu=%*} " \
ABI_VERSION_SPEC " " \
- "%{" NO_XNACK XNACKOPT "} " \
- "%{" NO_SRAM_ECC SRAMOPT "} " \
- "%{march=gfx1030|march=gfx1036|march=gfx1100|march=gfx1103:-mattr=+wavefrontsize64} " \
- "%{march=gfx1030|march=gfx1036|march=gfx1100|march=gfx1103:-mattr=+cumode} " \
+ XNACKOPT \
+ SRAMOPT \
+ WAVE64OPT \
+ CUMODEOPT \
"-filetype=obj"
#define LINK_SPEC "--pie --export-dynamic"
#define LIB_SPEC "-lc"
#ifndef GCN_OPTS_H
#define GCN_OPTS_H
-/* Which processor to generate code or schedule for. */
+/* Create constants for PROCESSOR_GFX???. */
enum processor_type
{
- PROCESSOR_VEGA10, // gfx900
- PROCESSOR_VEGA20, // gfx906
- PROCESSOR_GFX908,
- PROCESSOR_GFX90a,
- PROCESSOR_GFX90c,
- PROCESSOR_GFX1030,
- PROCESSOR_GFX1036,
- PROCESSOR_GFX1100,
- PROCESSOR_GFX1103
+#define GCN_DEVICE(name, NAME, ...) \
+ PROCESSOR_ ## NAME,
+#include "gcn-devices.def"
+ PROCESSOR_COUNT
};
-#define TARGET_VEGA10 (gcn_arch == PROCESSOR_VEGA10)
-#define TARGET_VEGA20 (gcn_arch == PROCESSOR_VEGA20)
-#define TARGET_GFX908 (gcn_arch == PROCESSOR_GFX908)
-#define TARGET_GFX90a (gcn_arch == PROCESSOR_GFX90a)
-#define TARGET_GFX90c (gcn_arch == PROCESSOR_GFX90c)
-#define TARGET_GFX1030 (gcn_arch == PROCESSOR_GFX1030)
-#define TARGET_GFX1036 (gcn_arch == PROCESSOR_GFX1036)
-#define TARGET_GFX1100 (gcn_arch == PROCESSOR_GFX1100)
-#define TARGET_GFX1103 (gcn_arch == PROCESSOR_GFX1103)
-
/* Set in gcn_option_override. */
extern enum gcn_isa {
ISA_UNKNOWN,
#define TARGET_PACKED_WORK_ITEMS (TARGET_CDNA2_PLUS || TARGET_RDNA3)
-#define TARGET_XNACK (flag_xnack != HSACO_ATTR_OFF)
+#define TARGET_XNACK (flag_xnack == HSACO_ATTR_ON \
+ || flag_xnack == HSACO_ATTR_ANY)
enum hsaco_attr_type
{
+ HSACO_ATTR_UNSUPPORTED,
HSACO_ATTR_OFF,
HSACO_ATTR_ON,
HSACO_ATTR_ANY,
/* Different devices uses different cache control instructions. */
#define TARGET_WBINVL1_CACHE (!TARGET_RDNA2_PLUS)
#define TARGET_GLn_CACHE TARGET_RDNA2_PLUS
+/* Some devices have TGSPLIT, which needs at least metadata. */
+#define TARGET_TGSPLIT TARGET_CDNA2_PLUS
#endif
--- /dev/null
+; -*- buffer-read-only: t -*-
+; Generated automatically by gen-opt-tables.awk from gcn-devices.def.
+; Do not edit.
+
+; Copyright (C) 2024 Free Software Foundation, Inc.
+
+; 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/>.
+
+Enum
+Name(gpu_type) Type(enum processor_type)
+GCN GPU type to use:
+
+EnumValue
+Enum(gpu_type) String(gfx900) Value(PROCESSOR_GFX900)
+
+EnumValue
+Enum(gpu_type) String(gfx906) Value(PROCESSOR_GFX906)
+
+EnumValue
+Enum(gpu_type) String(gfx908) Value(PROCESSOR_GFX908)
+
+EnumValue
+Enum(gpu_type) String(gfx90a) Value(PROCESSOR_GFX90A)
+
+EnumValue
+Enum(gpu_type) String(gfx90c) Value(PROCESSOR_GFX90C)
+
+EnumValue
+Enum(gpu_type) String(gfx1030) Value(PROCESSOR_GFX1030)
+
+EnumValue
+Enum(gpu_type) String(gfx1036) Value(PROCESSOR_GFX1036)
+
+EnumValue
+Enum(gpu_type) String(gfx1100) Value(PROCESSOR_GFX1100)
+
+EnumValue
+Enum(gpu_type) String(gfx1103) Value(PROCESSOR_GFX1103)
--- /dev/null
+; Autogenerated by regenerate-opt-urls.py from gcc/config/gcn/gcn-tables.opt and generated HTML
+
#define MAX_NORMAL_VGPR_COUNT 24
#define MAX_NORMAL_AVGPR_COUNT 24
+/* Import all the data from gcn-devices.def.
+ The PROCESSOR_GFXnnn should be indices for this table. */
+const struct gcn_device_def gcn_devices[] = {
+#define GCN_DEVICE(name, NAME, ELF, ISA, XNACK, SRAMECC, WAVE64, CU, VGPRS) \
+ {PROCESSOR_ ## NAME, #name, #NAME, ISA, XNACK, SRAMECC, WAVE64, CU, VGPRS},
+#include "gcn-devices.def"
+};
+
/* }}} */
/* {{{ Initialization and options. */
if (!flag_pic)
flag_pic = flag_pie;
- gcn_isa = (gcn_arch == PROCESSOR_VEGA10 ? ISA_GCN5
- : gcn_arch == PROCESSOR_VEGA20 ? ISA_GCN5
- : gcn_arch == PROCESSOR_GFX908 ? ISA_CDNA1
- : gcn_arch == PROCESSOR_GFX90a ? ISA_CDNA2
- : gcn_arch == PROCESSOR_GFX90c ? ISA_GCN5
- : gcn_arch == PROCESSOR_GFX1030 ? ISA_RDNA2
- : gcn_arch == PROCESSOR_GFX1036 ? ISA_RDNA2
- : gcn_arch == PROCESSOR_GFX1100 ? ISA_RDNA3
- : gcn_arch == PROCESSOR_GFX1103 ? ISA_RDNA3
- : ISA_UNKNOWN);
- gcc_assert (gcn_isa != ISA_UNKNOWN);
+ gcc_assert (gcn_arch >= 0 && gcn_arch < PROCESSOR_COUNT);
+ gcn_isa = gcn_devices[gcn_arch].isa;
/* Reserve 1Kb (somewhat arbitrarily) of LDS space for reduction results and
worker broadcasts. */
}
/* gfx1030 and gfx1100 do not support XNACK. */
- if (gcn_arch == PROCESSOR_GFX1030
- || gcn_arch == PROCESSOR_GFX1036
- || gcn_arch == PROCESSOR_GFX1100
- || gcn_arch == PROCESSOR_GFX1103)
+ if (gcn_devices[gcn_arch].xnack_default == HSACO_ATTR_UNSUPPORTED)
{
if (flag_xnack == HSACO_ATTR_ON)
error ("%<-mxnack=on%> is incompatible with %<-march=%s%>",
- (gcn_arch == PROCESSOR_GFX1030 ? "gfx1030"
- : gcn_arch == PROCESSOR_GFX1036 ? "gfx1036"
- : gcn_arch == PROCESSOR_GFX1100 ? "gfx1100"
- : gcn_arch == PROCESSOR_GFX1103 ? "gfx1103"
- : NULL));
- /* Allow HSACO_ATTR_ANY silently because that's the default. */
- flag_xnack = HSACO_ATTR_OFF;
+ gcn_devices[gcn_arch].name);
+ /* Allow HSACO_ATTR_ANY silently. */
+ flag_xnack = HSACO_ATTR_UNSUPPORTED;
}
/* There's no need for XNACK on devices without USM, and there are register
available.
FIXME: can the regalloc mean the default can be really "any"? */
if (flag_xnack == HSACO_ATTR_DEFAULT)
- switch (gcn_arch)
- {
- case PROCESSOR_VEGA10:
- case PROCESSOR_VEGA20:
- case PROCESSOR_GFX908:
- flag_xnack = HSACO_ATTR_OFF;
- break;
- case PROCESSOR_GFX90a:
- case PROCESSOR_GFX90c:
- flag_xnack = HSACO_ATTR_ANY;
- break;
- default:
- gcc_unreachable ();
- }
+ flag_xnack = gcn_devices[gcn_arch].xnack_default;
if (flag_sram_ecc == HSACO_ATTR_DEFAULT)
- flag_sram_ecc = HSACO_ATTR_ANY;
+ flag_sram_ecc = gcn_devices[gcn_arch].sramecc_default;
}
/* }}} */
case omp_device_arch:
return strcmp (name, "amdgcn") == 0 || strcmp (name, "gcn") == 0;
case omp_device_isa:
- if (strcmp (name, "gfx900") == 0)
- return gcn_arch == PROCESSOR_VEGA10;
- if (strcmp (name, "gfx906") == 0)
- return gcn_arch == PROCESSOR_VEGA20;
- if (strcmp (name, "gfx908") == 0)
- return gcn_arch == PROCESSOR_GFX908;
- if (strcmp (name, "gfx90a") == 0)
- return gcn_arch == PROCESSOR_GFX90a;
- if (strcmp (name, "gfx90c") == 0)
- return gcn_arch == PROCESSOR_GFX90c;
- if (strcmp (name, "gfx1030") == 0)
- return gcn_arch == PROCESSOR_GFX1030;
- if (strcmp (name, "gfx1036") == 0)
- return gcn_arch == PROCESSOR_GFX1036;
- if (strcmp (name, "gfx1100") == 0)
- return gcn_arch == PROCESSOR_GFX1100;
- if (strcmp (name, "gfx1103") == 0)
- return gcn_arch == PROCESSOR_GFX1103;
- return 0;
+ return strcmp (name, gcn_devices[gcn_arch].name) == 0;
default:
gcc_unreachable ();
}
configuration. */
const char *xnack = (flag_xnack == HSACO_ATTR_ON ? ":xnack+"
: flag_xnack == HSACO_ATTR_OFF ? ":xnack-"
- : "");
+ : "" /* Unsupported or "any". */);
const char *sram_ecc = (flag_sram_ecc == HSACO_ATTR_ON ? ":sramecc+"
: flag_sram_ecc == HSACO_ATTR_OFF ? ":sramecc-"
- : "");
-
- const char *cpu;
- switch (gcn_arch)
- {
- case PROCESSOR_VEGA10:
- cpu = "gfx900";
- sram_ecc = "";
- break;
- case PROCESSOR_VEGA20:
- cpu = "gfx906";
- sram_ecc = "";
- break;
- case PROCESSOR_GFX908:
- cpu = "gfx908";
- break;
- case PROCESSOR_GFX90a:
- cpu = "gfx90a";
- break;
- case PROCESSOR_GFX90c:
- cpu = "gfx90c";
- sram_ecc = "";
- break;
- case PROCESSOR_GFX1030:
- cpu = "gfx1030";
- xnack = "";
- sram_ecc = "";
- break;
- case PROCESSOR_GFX1036:
- cpu = "gfx1036";
- xnack = "";
- sram_ecc = "";
- break;
- case PROCESSOR_GFX1100:
- cpu = "gfx1100";
- xnack = "";
- sram_ecc = "";
- break;
- case PROCESSOR_GFX1103:
- cpu = "gfx1103";
- xnack = "";
- sram_ecc = "";
- break;
- default: gcc_unreachable ();
- }
+ : "" /* Unsupported or "any". */);
+ const char *cpu = gcn_devices[gcn_arch].name;
fprintf(asm_out_file, "\t.amdgcn_target \"amdgcn-unknown-amdhsa--%s%s%s\"\n",
cpu, sram_ecc, xnack);
if (!TARGET_ARCHITECTED_FLAT_SCRATCH)
fprintf (file,
"\t .amdhsa_reserve_flat_scratch\t0\n");
- if (gcn_arch == PROCESSOR_GFX90a)
+ if (TARGET_AVGPR_COMBINED)
fprintf (file,
- "\t .amdhsa_accum_offset\t%i\n"
- "\t .amdhsa_tg_split\t0\n",
+ "\t .amdhsa_accum_offset\t%i\n",
vgpr); /* The AGPRs come after the VGPRs. */
+ if (TARGET_TGSPLIT)
+ fprintf (file,
+ "\t .amdhsa_tg_split\t0\n");
fputs ("\t.end_amdhsa_kernel\n", file);
#if 1
(TARGET_WAVE64_COMPAT
? " ; wavefrontsize64 counts double on SIMD32"
: ""));
- if (gcn_arch == PROCESSOR_GFX90a || gcn_arch == PROCESSOR_GFX908)
+ if (TARGET_AVGPRS)
fprintf (file, " .agpr_count: %i\n", avgpr);
fputs (" .end_amdgpu_metadata\n", file);
#endif
#include "config/gcn/gcn-opts.h"
+extern const struct gcn_device_def {
+ enum processor_type id;
+ const char *name;
+ const char *NAME;
+ enum gcn_isa isa;
+
+ /* Features. */
+ enum hsaco_attr_type xnack_default;
+ enum hsaco_attr_type sramecc_default;
+ enum hsaco_attr_type wave64_default;
+ enum hsaco_attr_type cumode_default;
+ int max_isa_vgprs;
+} gcn_devices[];
+
#define TARGET_CPU_CPP_BUILTINS() \
do \
{ \
builtin_define ("__RDNA3__"); \
else \
gcc_unreachable (); \
- if (TARGET_VEGA10) \
- builtin_define ("__gfx900__"); \
- else if (TARGET_VEGA20) \
- builtin_define ("__gfx906__"); \
- else if (TARGET_GFX908) \
- builtin_define ("__gfx908__"); \
- else if (TARGET_GFX90a) \
- builtin_define ("__gfx90a__"); \
- else if (TARGET_GFX90c) \
- builtin_define ("__gfx90c__"); \
- else if (TARGET_GFX1030) \
- builtin_define ("__gfx1030__"); \
- else if (TARGET_GFX1036) \
- builtin_define ("__gfx1036__"); \
- else if (TARGET_GFX1100) \
- builtin_define ("__gfx1100__"); \
- else if (TARGET_GFX1103) \
- builtin_define ("__gfx1103__"); \
- else \
- gcc_unreachable (); \
+ char *name = (char *)xmalloc (sizeof (gcn_devices[gcn_arch].name) + 5); \
+ sprintf (name, "__%s__", gcn_devices[gcn_arch].name); \
+ builtin_define (name); \
} while (0)
#define ASSEMBLER_DIALECT (TARGET_RDNA2_PLUS ? 1 : 0)
HeaderInclude
config/gcn/gcn-opts.h
-Enum
-Name(gpu_type) Type(enum processor_type)
-GCN GPU type to use:
-
-EnumValue
-Enum(gpu_type) String(gfx900) Value(PROCESSOR_VEGA10)
-
-EnumValue
-Enum(gpu_type) String(gfx906) Value(PROCESSOR_VEGA20)
-
-EnumValue
-Enum(gpu_type) String(gfx908) Value(PROCESSOR_GFX908)
-
-EnumValue
-Enum(gpu_type) String(gfx90a) Value(PROCESSOR_GFX90a)
-
-EnumValue
-Enum(gpu_type) String(gfx90c) Value(PROCESSOR_GFX90c)
-
-EnumValue
-Enum(gpu_type) String(gfx1030) Value(PROCESSOR_GFX1030)
-
-EnumValue
-Enum(gpu_type) String(gfx1036) Value(PROCESSOR_GFX1036)
-
-EnumValue
-Enum(gpu_type) String(gfx1100) Value(PROCESSOR_GFX1100)
-
-EnumValue
-Enum(gpu_type) String(gfx1103) Value(PROCESSOR_GFX1103)
-
march=
-Target RejectNegative Negative(march=) Joined ToLower Enum(gpu_type) Var(gcn_arch) Init(PROCESSOR_VEGA10)
+Target RejectNegative Negative(march=) Joined ToLower Enum(gpu_type) Var(gcn_arch) Init(PROCESSOR_GFX900)
Specify the name of the target GPU.
mtune=
-Target RejectNegative Negative(mtune=) Joined ToLower Enum(gpu_type) Var(gcn_tune) Init(PROCESSOR_VEGA10)
+Target RejectNegative Negative(mtune=) Joined ToLower Enum(gpu_type) Var(gcn_tune) Init(PROCESSOR_GFX900)
Specify the name of the target GPU.
m32
Compile for devices requiring XNACK enabled. Default \"any\" if USM is supported.
msram-ecc=
-Target RejectNegative Joined ToLower Enum(hsaco_attr_type) Var(flag_sram_ecc) Init(HSACO_ATTR_ANY)
+Target RejectNegative Joined ToLower Enum(hsaco_attr_type) Var(flag_sram_ecc) Init(HSACO_ATTR_DEFAULT)
Compile for devices with the SRAM ECC feature enabled, or not. Default \"any\".
-param=gcn-preferred-vectorization-factor=
--- /dev/null
+# Generate $objdir/gcn-device-macros.h from gcn-devices.def
+#
+# Copyright (C) 2024 Free Software Foundation, Inc.
+#
+# 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/>.
+
+BEGIN {
+ FS= "[(,] *"
+
+ print "/* Generated by gen-gcn-device-macros.awk from gcn-devices.def."
+ print " Do not edit. */"
+
+ list=""
+}
+
+/^GCN_DEVICE\(/ {
+ gfx=$2
+ list=(list " OPT_" gfx)
+
+ print ""
+ next
+}
+
+/XNACK default.*HSACO_ATTR_UNSUPPORTED/ {
+ printf "\n#define XNACK_%s \"march=%s:;\"", gfx, gfx
+ next
+}
+
+/XNACK default.*HSACO_ATTR_OFF/ {
+ printf "\n#define XNACK_%s \"march=%s:%{!mxnack*|mxnack=default|mxnack=off:-mattr=-xnack;mxnack=on:-mattr=+xnack};\"", gfx, gfx
+ next
+}
+
+/XNACK default.*HSACO_ATTR_ANY/ {
+ printf "\n#define XNACK_%s \"march=%s:%{mxnack=off:-mattr=-xnack;mxnack=on:-mattr=+xnack};\"", gfx, gfx
+ next
+}
+
+/XNACK default.*HSACO/ {
+ print FILENAME ":" NR ": error: unhandled HSACO default at line (gen-gcn-device-macros.awk)" > "/dev/stderr"
+ exit 1
+}
+
+/SRAM_ECC default.*HSACO_ATTR_UNSUPPORTED/ {
+ printf "\n#define SRAM_%s \"march=%s:;\"", gfx, gfx
+ next
+}
+
+/SRAM_ECC default.*HSACO_ATTR_ANY/ {
+ printf "\n#define SRAM_%s \"march=%s:%{msram-ecc=on:-mattr=+sramecc;msram-ecc=off:-mattr=-sramecc};\"", gfx, gfx
+ next
+}
+
+/SRAM_ECC default.*HSACO/ {
+ print FILENAME ":" NR ": error: unhandled HSACO default at line (gen-gcn-device-macros.awk)" > "/dev/stderr"
+ exit 1
+}
+
+/WAVE64 mode.*HSACO_ATTR_UNSUPPORTED/ {
+ printf "\n#define WAVE64_%s \"march=%s:;\"", gfx, gfx
+ next
+}
+
+/WAVE64 mode.*HSACO_ATTR_ON/ {
+ printf "\n#define WAVE64_%s \"march=%s:-mattr=+wavefrontsize64;\"", gfx, gfx
+ next
+}
+
+/WAVE64 mode.*HSACO/ {
+ print FILENAME ":" NR ": error: unhandled HSACO default at line (gen-gcn-device-macros.awk)" > "/dev/stderr"
+ exit 1
+}
+
+/CU mode.*HSACO_ATTR_UNSUPPORTED/ {
+ printf "\n#define CU_%s \"march=%s:;\"", gfx, gfx
+ next
+}
+
+/CU mode.*HSACO_ATTR_ON/ {
+ printf "\n#define CU_%s \"march=%s:-mattr=+cumode;\"", gfx, gfx
+ next
+}
+
+/CU mode.*HSACO/ {
+ print FILENAME ":" NR ": error: unhandled HSACO default at line (gen-gcn-device-macros.awk)" > "/dev/stderr"
+ exit 1
+}
+
+END {
+ print ""
+ print ""
+ printf "#define XNACKOPT \"%%{\"%s \":%%eexpected march\\n} \"\n", gensub (/OPT/, "XNACK", "g", list)
+ printf "#define SRAMOPT \"%%{\"%s \":%%eexpected march\\n} \"\n", gensub (/OPT/, "SRAM", "g", list)
+ printf "#define WAVE64OPT \"%%{\"%s \":%%eexpected march\\n} \"\n", gensub (/OPT/, "WAVE64", "g", list)
+ printf "#define CUMODEOPT \"%%{\"%s \":%%eexpected march\\n} \"\n", gensub (/OPT/, "CU", "g", list)
+}
--- /dev/null
+# Generate gcn-tables.opt from gcn-devices.def
+#
+# Copyright (C) 2024 Free Software Foundation, Inc.
+#
+# 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/>.
+
+BEGIN {
+ FS= "[(,] *"
+
+ print "; -*- buffer-read-only: t -*-"
+ print "; Generated automatically by gen-opt-tables.awk from gcn-devices.def."
+ print "; Do not edit."
+ print ""
+ print "; Copyright (C) 2024 Free Software Foundation, Inc."
+ print ""
+ print "; This file is part of GCC."
+ print ""
+ print "; GCC is free software; you can redistribute it and/or modify"
+ print "; it under the terms of the GNU General Public License as"
+ print "; published by the Free Software Foundation; either version 3,"
+ print "; or (at your option) any later version."
+ print ""
+ print "; GCC is distributed in the hope that it will be useful,"
+ print "; but WITHOUT ANY WARRANTY; without even the implied warranty of"
+ print "; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the"
+ print "; GNU General Public License for more details."
+ print ""
+ print "; You should have received a copy of the GNU General Public"
+ print "; License along with GCC; see the file COPYING3. If not see"
+ print "; <http://www.gnu.org/licenses/>."
+ print ""
+ print "Enum"
+ print "Name(gpu_type) Type(enum processor_type)"
+ print "GCN GPU type to use:"
+}
+
+/^GCN_DEVICE\(/ {
+ print ""
+ print "EnumValue"
+ print "Enum(gpu_type) String(" $2 ") Value(PROCESSOR_" $3 ")"
+}
#undef ELFABIVERSION_AMDGPU_HSA_V4
#define ELFABIVERSION_AMDGPU_HSA_V4 2
-#undef EF_AMDGPU_MACH_AMDGCN_GFX900
-#define EF_AMDGPU_MACH_AMDGCN_GFX900 0x2c
-#undef EF_AMDGPU_MACH_AMDGCN_GFX906
-#define EF_AMDGPU_MACH_AMDGCN_GFX906 0x2f
-#undef EF_AMDGPU_MACH_AMDGCN_GFX908
-#define EF_AMDGPU_MACH_AMDGCN_GFX908 0x30
-#undef EF_AMDGPU_MACH_AMDGCN_GFX90a
-#define EF_AMDGPU_MACH_AMDGCN_GFX90a 0x3f
-#undef EF_AMDGPU_MACH_AMDGCN_GFX90c
-#define EF_AMDGPU_MACH_AMDGCN_GFX90c 0x32
-#undef EF_AMDGPU_MACH_AMDGCN_GFX1030
-#define EF_AMDGPU_MACH_AMDGCN_GFX1030 0x36
-#undef EF_AMDGPU_MACH_AMDGCN_GFX1036
-#define EF_AMDGPU_MACH_AMDGCN_GFX1036 0x45
-#undef EF_AMDGPU_MACH_AMDGCN_GFX1100
-#define EF_AMDGPU_MACH_AMDGCN_GFX1100 0x41
-#undef EF_AMDGPU_MACH_AMDGCN_GFX1103
-#define EF_AMDGPU_MACH_AMDGCN_GFX1103 0x44
+/* Extract the EF_AMDGPU_MACH_AMDGCN_GFXnnn from the def file. */
+enum elf_arch_code {
+#define GCN_DEVICE(name, NAME, ELF_ARCH, ...) \
+ EF_AMDGPU_MACH_AMDGCN_ ## NAME = ELF_ARCH,
+#include "gcn-devices.def"
+#undef GCN_DEVICE
+};
#define EF_AMDGPU_FEATURE_XNACK_V4 0x300 /* Mask. */
#define EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4 0x000
static int
get_arch (const char *str, const char *with_arch_str)
{
- if (strcmp (str, "gfx900") == 0)
- return EF_AMDGPU_MACH_AMDGCN_GFX900;
- else if (strcmp (str, "gfx906") == 0)
- return EF_AMDGPU_MACH_AMDGCN_GFX906;
- else if (strcmp (str, "gfx908") == 0)
- return EF_AMDGPU_MACH_AMDGCN_GFX908;
- else if (strcmp (str, "gfx90a") == 0)
- return EF_AMDGPU_MACH_AMDGCN_GFX90a;
- else if (strcmp (str, "gfx90c") == 0)
- return EF_AMDGPU_MACH_AMDGCN_GFX90c;
- else if (strcmp (str, "gfx1030") == 0)
- return EF_AMDGPU_MACH_AMDGCN_GFX1030;
- else if (strcmp (str, "gfx1036") == 0)
- return EF_AMDGPU_MACH_AMDGCN_GFX1036;
- else if (strcmp (str, "gfx1100") == 0)
- return EF_AMDGPU_MACH_AMDGCN_GFX1100;
- else if (strcmp (str, "gfx1103") == 0)
- return EF_AMDGPU_MACH_AMDGCN_GFX1103;
-
+ /* Use the def file to map the name to the elf_arch_code. */
+ if (!str) ;
+#define GCN_DEVICE(name, NAME, ELF, ...) \
+ else if (strcmp (str, #name) == 0) \
+ return ELF;
+#include "gcn-devices.def"
+#undef GCN_DEVICE
+
+ /* else */
error ("unrecognized argument in option %<-march=%s%>", str);
/* The suggestions are based on the configured multilib support; the compiler
gcc_unreachable ();
}
- /* This must match gcn-hsa.h's settings for NO_XNACK, NO_SRAM_ECC
- and ASM_SPEC. */
+ /* Set the default ELF flags for XNACK. */
switch (elf_arch)
{
- case EF_AMDGPU_MACH_AMDGCN_GFX1030:
- case EF_AMDGPU_MACH_AMDGCN_GFX1036:
- case EF_AMDGPU_MACH_AMDGCN_GFX1100:
- case EF_AMDGPU_MACH_AMDGCN_GFX1103:
- SET_XNACK_UNSET (elf_flags);
- SET_SRAM_ECC_UNSET (elf_flags);
- break;
- case EF_AMDGPU_MACH_AMDGCN_GFX900:
- SET_XNACK_OFF (elf_flags);
- SET_SRAM_ECC_UNSET (elf_flags);
- break;
- case EF_AMDGPU_MACH_AMDGCN_GFX906:
- SET_XNACK_OFF (elf_flags);
- SET_SRAM_ECC_ANY (elf_flags);
- break;
- case EF_AMDGPU_MACH_AMDGCN_GFX908:
- SET_XNACK_OFF (elf_flags);
- if (TEST_SRAM_ECC_UNSET (elf_flags))
- SET_SRAM_ECC_ANY (elf_flags);
- break;
- case EF_AMDGPU_MACH_AMDGCN_GFX90a:
- if (TEST_XNACK_UNSET (elf_flags))
- SET_XNACK_ANY (elf_flags);
- if (TEST_SRAM_ECC_UNSET (elf_flags))
- SET_SRAM_ECC_ANY (elf_flags);
- break;
- case EF_AMDGPU_MACH_AMDGCN_GFX90c:
- if (TEST_XNACK_UNSET (elf_flags))
- SET_XNACK_ANY (elf_flags);
- SET_SRAM_ECC_UNSET (elf_flags);
- break;
+#define GCN_DEVICE(name, NAME, ELF, ISA, XNACK, SRAM, ...) \
+ case ELF: XNACK; break;
+#define HSACO_ATTR_UNSUPPORTED SET_XNACK_UNSET (elf_flags)
+#define HSACO_ATTR_OFF SET_XNACK_OFF (elf_flags)
+#define HSACO_ATTR_ANY \
+ if (TEST_XNACK_UNSET (elf_flags)) SET_XNACK_ANY (elf_flags)
+#include "gcn-devices.def"
+#undef HSACO_ATTR_UNSUPPORTED
+#undef HSACO_ATTR_OFF
+#undef HSACO_ATTR_ANY
+ default:
+ fatal_error (input_location, "unhandled architecture");
+ }
+
+ /* Set the default ELF flags for SRAM_ECC. */
+ switch (elf_arch)
+ {
+#define GCN_DEVICE(name, NAME, ELF, ISA, XNACK, SRAM, ...) \
+ case ELF: SRAM; break;
+#define HSACO_ATTR_UNSUPPORTED SET_SRAM_ECC_UNSET (elf_flags)
+#define HSACO_ATTR_OFF SET_SRAM_ECC_OFF (elf_flags)
+#define HSACO_ATTR_ANY \
+ if (TEST_SRAM_ECC_UNSET (elf_flags)) SET_SRAM_ECC_ANY (elf_flags)
+#include "gcn-devices.def"
+#undef HSACO_ATTR_UNSUPPORTED
+#undef HSACO_ATTR_OFF
+#undef HSACO_ATTR_ANY
default:
fatal_error (input_location, "unhandled architecture");
}
$(COMPILE) $<
$(POSTCOMPILE)
ALL_HOST_OBJS += gcn-tree.o
+
+$(srcdir)/config/gcn/gcn-tables.opt: $(srcdir)/config/gcn/gcn-devices.def $(srcdir)/config/gcn/gen-opt-tables.awk
+ $(AWK) -f $(srcdir)/config/gcn/gen-opt-tables.awk $< > $@
+
+gcn-device-macros.h: $(srcdir)/config/gcn/gcn-devices.def $(srcdir)/config/gcn/gen-gcn-device-macros.awk
+ $(AWK) -f $(srcdir)/config/gcn/gen-gcn-device-macros.awk $< > $@
+generated_files += gcn-device-macros.h
-omp-device-properties-gcn: $(srcdir)/config/gcn/gcn.cc
+omp-device-properties-gcn: $(srcdir)/config/gcn/gcn-devices.def
echo kind: gpu > $@
echo arch: amdgcn gcn >> $@
- echo isa: gfx900 gfx906 gfx908 gfx90a gfx90c gfx1030 gfx1036 gfx1100 gfx1103 >> $@
+ echo isa: `grep -o -P '(?<=GCN_DEVICE\()gfx[0-9a-f]+(?=,)' $<` >> $@
const unsigned global_variable_count;
};
-/* This enum mirrors the corresponding LLVM enum's values for all ISAs that we
- support.
- See https://llvm.org/docs/AMDGPUUsage.html#amdgpu-ef-amdgpu-mach-table */
+/* Enum values corresponding to the the ELF architecture codes.
+ Only 'special' values are actually referenced in this file, but having them
+ all may aid debugging. */
typedef enum {
EF_AMDGPU_MACH_UNSUPPORTED = -1,
- EF_AMDGPU_MACH_AMDGCN_GFX803 = 0x02a,
- EF_AMDGPU_MACH_AMDGCN_GFX900 = 0x02c,
- EF_AMDGPU_MACH_AMDGCN_GFX906 = 0x02f,
- EF_AMDGPU_MACH_AMDGCN_GFX908 = 0x030,
- EF_AMDGPU_MACH_AMDGCN_GFX90a = 0x03f,
- EF_AMDGPU_MACH_AMDGCN_GFX90c = 0x032,
- EF_AMDGPU_MACH_AMDGCN_GFX1030 = 0x036,
- EF_AMDGPU_MACH_AMDGCN_GFX1036 = 0x045,
- EF_AMDGPU_MACH_AMDGCN_GFX1100 = 0x041,
- EF_AMDGPU_MACH_AMDGCN_GFX1103 = 0x044
+#define GCN_DEVICE(name, NAME, ELF, ...) \
+ EF_AMDGPU_MACH_AMDGCN_ ## NAME = ELF,
+#include "../../gcc/config/gcn/gcn-devices.def"
} EF_AMDGPU_MACH;
const static int EF_AMDGPU_MACH_MASK = 0x000000ff;
return image->e_flags & EF_AMDGPU_MACH_MASK;
}
-const static char *gcn_gfx803_s = "gfx803";
-const static char *gcn_gfx900_s = "gfx900";
-const static char *gcn_gfx906_s = "gfx906";
-const static char *gcn_gfx908_s = "gfx908";
-const static char *gcn_gfx90a_s = "gfx90a";
-const static char *gcn_gfx90c_s = "gfx90c";
-const static char *gcn_gfx1030_s = "gfx1030";
-const static char *gcn_gfx1036_s = "gfx1036";
-const static char *gcn_gfx1100_s = "gfx1100";
-const static char *gcn_gfx1103_s = "gfx1103";
-const static int gcn_isa_name_len = 7;
-
/* Returns the name that the HSA runtime uses for the ISA or NULL if we do not
support the ISA. */
static const char*
-isa_hsa_name (int isa) {
+isa_name (int isa) {
switch(isa)
{
- case EF_AMDGPU_MACH_AMDGCN_GFX803:
- return gcn_gfx803_s;
- case EF_AMDGPU_MACH_AMDGCN_GFX900:
- return gcn_gfx900_s;
- case EF_AMDGPU_MACH_AMDGCN_GFX906:
- return gcn_gfx906_s;
- case EF_AMDGPU_MACH_AMDGCN_GFX908:
- return gcn_gfx908_s;
- case EF_AMDGPU_MACH_AMDGCN_GFX90a:
- return gcn_gfx90a_s;
- case EF_AMDGPU_MACH_AMDGCN_GFX90c:
- return gcn_gfx90c_s;
- case EF_AMDGPU_MACH_AMDGCN_GFX1030:
- return gcn_gfx1030_s;
- case EF_AMDGPU_MACH_AMDGCN_GFX1036:
- return gcn_gfx1036_s;
- case EF_AMDGPU_MACH_AMDGCN_GFX1100:
- return gcn_gfx1100_s;
- case EF_AMDGPU_MACH_AMDGCN_GFX1103:
- return gcn_gfx1103_s;
+#define GCN_DEVICE(name, NAME, ELF, ...) \
+ case ELF: return #name;
+#include "../../gcc/config/gcn/gcn-devices.def"
}
return NULL;
}
-/* Returns the user-facing name that GCC uses to identify the architecture (e.g.
- with -march) or NULL if we do not support the ISA.
- Keep in sync with /gcc/config/gcn/gcn.{c,opt}. */
-
-static const char*
-isa_gcc_name (int isa) {
- switch(isa)
- {
- case EF_AMDGPU_MACH_AMDGCN_GFX803:
- return "fiji";
- default:
- return isa_hsa_name (isa);
- }
-}
-
/* Returns the code which is used in the GCN object code to identify the ISA with
the given name (as used by the HSA runtime). */
static gcn_isa
isa_code(const char *isa) {
- if (!strncmp (isa, gcn_gfx803_s, gcn_isa_name_len))
- return EF_AMDGPU_MACH_AMDGCN_GFX803;
-
- if (!strncmp (isa, gcn_gfx900_s, gcn_isa_name_len))
- return EF_AMDGPU_MACH_AMDGCN_GFX900;
-
- if (!strncmp (isa, gcn_gfx906_s, gcn_isa_name_len))
- return EF_AMDGPU_MACH_AMDGCN_GFX906;
-
- if (!strncmp (isa, gcn_gfx908_s, gcn_isa_name_len))
- return EF_AMDGPU_MACH_AMDGCN_GFX908;
-
- if (!strncmp (isa, gcn_gfx90a_s, gcn_isa_name_len))
- return EF_AMDGPU_MACH_AMDGCN_GFX90a;
-
- if (!strncmp (isa, gcn_gfx90c_s, gcn_isa_name_len))
- return EF_AMDGPU_MACH_AMDGCN_GFX90c;
-
- if (!strncmp (isa, gcn_gfx1030_s, gcn_isa_name_len))
- return EF_AMDGPU_MACH_AMDGCN_GFX1030;
-
- if (!strncmp (isa, gcn_gfx1036_s, gcn_isa_name_len))
- return EF_AMDGPU_MACH_AMDGCN_GFX1036;
-
- if (!strncmp (isa, gcn_gfx1100_s, gcn_isa_name_len))
- return EF_AMDGPU_MACH_AMDGCN_GFX1100;
-
- if (!strncmp (isa, gcn_gfx1103_s, gcn_isa_name_len))
- return EF_AMDGPU_MACH_AMDGCN_GFX1103;
+#define GCN_DEVICE(name, NAME, ELF, ...) \
+ if (!strcmp (isa, #name)) return ELF;
+#include "../../gcc/config/gcn/gcn-devices.def"
return EF_AMDGPU_MACH_UNSUPPORTED;
}
{
switch (isa)
{
- case EF_AMDGPU_MACH_AMDGCN_GFX803:
- case EF_AMDGPU_MACH_AMDGCN_GFX900:
- case EF_AMDGPU_MACH_AMDGCN_GFX906:
- case EF_AMDGPU_MACH_AMDGCN_GFX908:
- return 256;
- case EF_AMDGPU_MACH_AMDGCN_GFX90a:
- return 512;
- case EF_AMDGPU_MACH_AMDGCN_GFX90c:
- return 256;
- case EF_AMDGPU_MACH_AMDGCN_GFX1030:
- case EF_AMDGPU_MACH_AMDGCN_GFX1036:
- return 512; /* 512 SIMD32 = 256 wavefrontsize64. */
- case EF_AMDGPU_MACH_AMDGCN_GFX1100:
- case EF_AMDGPU_MACH_AMDGCN_GFX1103:
- return 1536; /* 1536 SIMD32 = 768 wavefrontsize64. */
- }
- GOMP_PLUGIN_fatal ("unhandled ISA in max_isa_vgprs");
+#define GCN_DEVICE(name, NAME, ELF, ISA, XNACK, SRAM, WAVE64, CU, \
+ MAX_ISA_VGPRS, ...) \
+ case ELF: return MAX_ISA_VGPRS;
+#include "../../gcc/config/gcn/gcn-devices.def"
+ default:
+ GOMP_PLUGIN_fatal ("unhandled ISA in max_isa_vgprs");
+ }
}
/* }}} */
isa_matches_agent (struct agent_info *agent, Elf64_Ehdr *image)
{
int isa_field = elf_gcn_isa_field (image);
- const char* isa_s = isa_hsa_name (isa_field);
+ const char* isa_s = isa_name (isa_field);
if (!isa_s)
{
hsa_error ("Unsupported ISA in GCN code object.", HSA_STATUS_ERROR);
if (isa_field != agent->device_isa)
{
char msg[120];
- const char *agent_isa_s = isa_hsa_name (agent->device_isa);
- const char *agent_isa_gcc_s = isa_gcc_name (agent->device_isa);
+ const char *agent_isa_s = isa_name (agent->device_isa);
assert (agent_isa_s);
- assert (agent_isa_gcc_s);
snprintf (msg, sizeof msg,
"GCN code object ISA '%s' does not match GPU ISA '%s'.\n"
"Try to recompile with '-foffload-options=-march=%s'.\n",
- isa_s, agent_isa_s, agent_isa_gcc_s);
+ isa_s, agent_isa_s, agent_isa_s);
hsa_error (msg, HSA_STATUS_ERROR);
return false;
agent->device_isa = isa_code (agent->name);
if (agent->device_isa == EF_AMDGPU_MACH_UNSUPPORTED)
- return hsa_error ("Unknown GCN agent architecture", HSA_STATUS_ERROR);
+ {
+ char msg[33 + 64 + 1];
+ snprintf (msg, sizeof msg,
+ "Unknown GCN agent architecture '%s'", agent->name);
+ return hsa_error (msg, HSA_STATUS_ERROR);
+ }
status = hsa_fns.hsa_agent_get_info_fn (agent->id, HSA_AGENT_INFO_VENDOR_NAME,
&agent->vendor_name);
projects / thirdparty / gcc.git / commitdiff
