From patchwork Fri Mar 15 12:21:15 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tobias Burnus X-Patchwork-Id: 1912472 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=baylibre-com.20230601.gappssmtp.com header.i=@baylibre-com.20230601.gappssmtp.com header.a=rsa-sha256 header.s=20230601 header.b=vDLNwyXJ; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4Tx3K23cQ4z1yWn for ; Fri, 15 Mar 2024 23:21:56 +1100 (AEDT) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 0DC87385771B for ; Fri, 15 Mar 2024 12:21:53 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-ej1-x62a.google.com (mail-ej1-x62a.google.com [IPv6:2a00:1450:4864:20::62a]) by sourceware.org (Postfix) with ESMTPS id 1CAB53858D28 for ; Fri, 15 Mar 2024 12:21:19 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 1CAB53858D28 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=baylibre.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=baylibre.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 1CAB53858D28 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2a00:1450:4864:20::62a ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1710505289; cv=none; b=t0IJHhWqzolELmmyspc5vxMpfbAdGMwXxobtFpe+VPjX6QVflC2OmaGk84eIWxiYqazzfZ6cn77oQTTCN0Z/fo8VZkqK9Hmv3H3JOjyXltHYA8/CwTXuPskWT7RnZhrSaaehAkqwmyO2T4vHTJ2C+FYpbjaLezM9r82CZDcgioU= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1710505289; c=relaxed/simple; bh=JFNSf7APcMeS+2A6HnIom2IiGuenBpQIHjid5umB9Bo=; h=DKIM-Signature:Message-ID:Date:MIME-Version:To:From:Subject; b=xHWTsZoHVNKoU+nCaQeB0YqvOm6u5HIe2PwxLkR8O0X8mGXXJUDZpajb+UfOYUU2Jdpgx1SeOjV2TcrF3NDF89BVZy6LN9/YsIHQ5nOfUfQMAxiukG6OhVqKXNIgJHXaweUImlQJ803LR7UlSwL90m2IS72pKYjcRWoxaz2qiec= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-ej1-x62a.google.com with SMTP id a640c23a62f3a-a4675aaa2e8so201291466b.0 for ; Fri, 15 Mar 2024 05:21:19 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre-com.20230601.gappssmtp.com; s=20230601; t=1710505277; x=1711110077; darn=gcc.gnu.org; h=subject:from:to:content-language:user-agent:mime-version:date :message-id:from:to:cc:subject:date:message-id:reply-to; bh=Eu1GQ52kvOWACcst11TZuwNUczh5d3n98t0HIEZHXNQ=; b=vDLNwyXJpQ6bEYrm1zEoJ9zCJo5zMqG8FvvTH9gwBh0Mkvz9VheSzZwfVwfpXWialK fhshhR0xn74c00MuRPi5zggA4HY1C9Z6wwy6fGAtu8oZ3l//dfitT9OgfDCQakUWhEn9 gp5AvQ3bK1ZbiFEl9PIrN7bd+PWJ26huczP9JqPBe6chCJURivsjDIGiQXyxYRv1vioP hGrpBMhkCHCBzeDDNZwE258KjtQtxuBa9EZbbf/lZ5Afa+rpx2cUbmQSj1d3cYeje0Zv xU4F5DnLdiOxArRx2BU4s7XT9XplChgIjCnLCOX6CR+YoNj8mx2PPrg4YLwFQFu04aFB dGdw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1710505277; x=1711110077; h=subject:from:to:content-language:user-agent:mime-version:date :message-id:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=Eu1GQ52kvOWACcst11TZuwNUczh5d3n98t0HIEZHXNQ=; b=Us0Pvpq8ERAEvVgV5Xe3n785Cy9gu9TOte1yV7sDtQbWw4Rfj9wwez9lpxDs80WiVn dPS8qQVmfQtvA0Jkhyg6LRFPFnpokmzxi1viLCgdvfBBlmbRLpgIPlv5A+r3jhHT8tzA TkYUMyj6VlZNaLIvC/tRTxd1BsFGmbByA+cMCLyvYJcm0uP09G4OU5A5+lltlLB1RjpE d0frVXCdM6FLtPVyeIas+BU0PTTxUCET78I7PmuY1Ap0p9SB5vfXV97dBstc/I/93D9W 3IArRiJBBSzQKHRL8zdbafb+jkD2EMf0GsoamrqIPAJyFz12zQDeh60DuL7fDLnBPfgI 7mAg== X-Forwarded-Encrypted: i=1; AJvYcCVpeIZOFBL5skxIWaruKuEw04MnagwrSbEYsmjxcG2Om2/dqHjmWhqawNY57emvuhRX5ke3STZdmCDLlb0uQOPkaTCBkvQsTQ== X-Gm-Message-State: AOJu0Yzrm7kp0DYpGCrJ5fcrHW4LfsZq03Fl0y+1HYt/QSeh5jOLLZRR Hc+bTJiURtJMA5Ik1ZHreZATXn2TS1zT/UglxL2EF7i2cjNTlkAJg/6fYBs9AeA= X-Google-Smtp-Source: AGHT+IGjuCh3HWDV9lOx4Gd/bwUmfPE5QWcAnNR0RfYurOgvQhZ6ZuSg8bCJc07y5PMjYLUffi1x3Q== X-Received: by 2002:a17:906:acf:b0:a46:7780:bdb3 with SMTP id z15-20020a1709060acf00b00a467780bdb3mr1881009ejf.53.1710505276557; Fri, 15 Mar 2024 05:21:16 -0700 (PDT) Received: from ?IPV6:2001:16b8:3ff0:2b00:cfc4:8aae:e498:745b? ([2001:16b8:3ff0:2b00:cfc4:8aae:e498:745b]) by smtp.gmail.com with ESMTPSA id gx27-20020a1709068a5b00b00a465fd3977esm1691521ejc.143.2024.03.15.05.21.15 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Fri, 15 Mar 2024 05:21:16 -0700 (PDT) Message-ID: <43531053-8d71-454e-b15a-c721682cb443@baylibre.com> Date: Fri, 15 Mar 2024 13:21:15 +0100 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Content-Language: en-US To: Andrew Stubbs , gcc-patches From: Tobias Burnus Subject: [Patch][RFC] GCN: Define ISA archs in gcn-devices.def and use it X-Spam-Status: No, score=-11.9 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, GIT_PATCH_0, HTML_MESSAGE, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Given the large number of AMD GPU ISAs and the number of files which have to be adapted, I wonder whether it makes sense to consolidate this a bit, especially in the light that we may want to support more in the future. Besides using some macros, I also improved the diagnostic if the object code couldn't be recognized (shouldn't happen) or if the GPU is unsupported (likely; it now prints the GPU string). I was initially thinking of resolving the arch encoded in the eflag to a string, but as this is about GCC-generated code, it seemed to be unlikely of much use. [It should that rare that we might also go back to the static string instead of outputting the hex value of the eflag.] Note: I only modified mkoffload.cc and plugin-gcn.c, but with some tweaks it could also be used for other files in gcc/config/gcn/. If you add a new ISA, you still need to update plugin-gcn.c's max_isa_vgprs and the xnack/sram-ecc handling in mkoffload.c's main, but that should be all for those two files. Thoughts? Tobias PS: I think the patch is fine and builds, but I have not tested it on an AMD GPU machine, yet. PPS: For using for other files, see also in config/nvptx which uses nvptx-sm.def to generate several files. GCN: Define ISA archs in gcn-devices.def and use it Adding new a GCN ISAs requires to update many files, making it more likely to miss a file; by adding the gcn-devices.def file and using it in config/gcn/mkoffload.cc and libgomp/plugin/plugin-gcn.c, it reduces the duplications. gcc/ChangeLog: * config/gcn/mkoffload.cc (EF_AMDGPU_MACH_AMDGCN_...): Replace explicit #define by an enum created from gcn-devices.def. (main): Use gcn-devices.def definitions for -march=gfx.* string parsing. libgomp/ChangeLog: * plugin/gcn-devices.def: New file. * plugin/plugin-gcn.c (gcn_..._s): Remove. (enum EF_AMDGPU_MACH): Generate EF_AMDGPU_MACH_AMDGCN_... using gcn-devices.def. (isa_hsa_name, isa_gcc_name, isa_code): Use gcn-devices.def to handle the ISAs. (max_isa_vgprs): Update used enum name (GFX90a -> GFX90A). (isa_matches_agent, GOMP_OFFLOAD_init_device): Be more verbose in case of an unsupported ISA. gcc/config/gcn/mkoffload.cc | 42 ++++++--------- libgomp/plugin/gcn-devices.def | 62 ++++++++++++++++++++++ libgomp/plugin/plugin-gcn.c | 118 +++++++++++++++-------------------------- 3 files changed, 119 insertions(+), 103 deletions(-) diff --git a/gcc/config/gcn/mkoffload.cc b/gcc/config/gcn/mkoffload.cc index fe443abba21..081110d7030 100644 --- a/gcc/config/gcn/mkoffload.cc +++ b/gcc/config/gcn/mkoffload.cc @@ -47,20 +47,14 @@ #undef ELFABIVERSION_AMDGPU_HSA_V4 #define ELFABIVERSION_AMDGPU_HSA_V4 2 -#undef EF_AMDGPU_MACH_AMDGCN_GFX803 -#define EF_AMDGPU_MACH_AMDGCN_GFX803 0x2a -#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_GFX1030 -#define EF_AMDGPU_MACH_AMDGCN_GFX1030 0x36 -#undef EF_AMDGPU_MACH_AMDGCN_GFX1100 -#define EF_AMDGPU_MACH_AMDGCN_GFX1100 0x41 +/* Use an enum as macros cannot define macros and + assume that EF_AMDGPU_MACH_AMDGCN_... is not #defined. */ +enum { +#define AMDGPU_ISA(suffix, str, val) \ + EF_AMDGPU_MACH_AMDGCN_ ## suffix = val, +#include "../libgomp/plugin/gcn-devices.def" +#undef AMDGPU_ISA +}; #define EF_AMDGPU_FEATURE_XNACK_V4 0x300 /* Mask. */ #define EF_AMDGPU_FEATURE_XNACK_UNSUPPORTED_V4 0x000 @@ -959,18 +953,12 @@ main (int argc, char **argv) dumppfx = argv[++i]; else if (strcmp (argv[i], "-march=fiji") == 0) elf_arch = EF_AMDGPU_MACH_AMDGCN_GFX803; - else if (strcmp (argv[i], "-march=gfx900") == 0) - elf_arch = EF_AMDGPU_MACH_AMDGCN_GFX900; - else if (strcmp (argv[i], "-march=gfx906") == 0) - elf_arch = EF_AMDGPU_MACH_AMDGCN_GFX906; - else if (strcmp (argv[i], "-march=gfx908") == 0) - elf_arch = EF_AMDGPU_MACH_AMDGCN_GFX908; - else if (strcmp (argv[i], "-march=gfx90a") == 0) - elf_arch = EF_AMDGPU_MACH_AMDGCN_GFX90a; - else if (strcmp (argv[i], "-march=gfx1030") == 0) - elf_arch = EF_AMDGPU_MACH_AMDGCN_GFX1030; - else if (strcmp (argv[i], "-march=gfx1100") == 0) - elf_arch = EF_AMDGPU_MACH_AMDGCN_GFX1100; +#define AMDGPU_ISA(suffix, str, val) \ + else if (strcmp (argv[i], "-march=" str) == 0) \ + elf_arch = EF_AMDGPU_MACH_AMDGCN_ ## suffix; +#include "../libgomp/plugin/gcn-devices.def" +#undef AMDGPU_ISA + #define STR "-mstack-size=" else if (startswith (argv[i], STR)) gcn_stack_size = atoi (argv[i] + strlen (STR)); @@ -1029,7 +1017,7 @@ main (int argc, char **argv) if (TEST_SRAM_ECC_UNSET (elf_flags)) SET_SRAM_ECC_ANY (elf_flags); break; - case EF_AMDGPU_MACH_AMDGCN_GFX90a: + case EF_AMDGPU_MACH_AMDGCN_GFX90A: if (TEST_XNACK_UNSET (elf_flags)) SET_XNACK_ANY (elf_flags); if (TEST_SRAM_ECC_UNSET (elf_flags)) diff --git a/libgomp/plugin/gcn-devices.def b/libgomp/plugin/gcn-devices.def new file mode 100644 index 00000000000..8a51fa16fbc --- /dev/null +++ b/libgomp/plugin/gcn-devices.def @@ -0,0 +1,62 @@ +/* The enum mirrors the corresponding LLVM enum's values for the ISAs. + See https://llvm.org/docs/AMDGPUUsage.html#amdgpu-ef-amdgpu-mach-table + and llvm/include/llvm/BinaryFormat/ELF.h. */ + +#ifndef AMDGPU_ISA_UNSUPPORTED +#define AMDGPU_ISA_UNSUPPORTED(suffix, str, val) +#endif + +AMDGPU_ISA_UNSUPPORTED (GFX600, "gfx600", 0x020) +AMDGPU_ISA_UNSUPPORTED (GFX601, "gfx601", 0x021) +AMDGPU_ISA_UNSUPPORTED (GFX700, "gfx700", 0x022) +AMDGPU_ISA_UNSUPPORTED (GFX701, "gfx701", 0x023) +AMDGPU_ISA_UNSUPPORTED (GFX702, "gfx702", 0x024) +AMDGPU_ISA_UNSUPPORTED (GFX703, "gfx703", 0x025) +AMDGPU_ISA_UNSUPPORTED (GFX704, "gfx704", 0x026) +AMDGPU_ISA_UNSUPPORTED (RESERVED_0X27, "gfx704", 0x027) +AMDGPU_ISA_UNSUPPORTED (GFX801, "gfx801", 0x028) +AMDGPU_ISA_UNSUPPORTED (GFX802, "gfx802", 0x029) +AMDGPU_ISA (GFX803, "gfx803", 0x02a) /* FIJI */ +AMDGPU_ISA_UNSUPPORTED (GFX810, "gfx810", 0x02b) +AMDGPU_ISA (GFX900, "gfx900", 0x02c) +AMDGPU_ISA_UNSUPPORTED (GFX902, "gfx902", 0x02d) +AMDGPU_ISA_UNSUPPORTED (GFX904, "gfx904", 0x02e) +AMDGPU_ISA (GFX906, "gfx906", 0x02f) +AMDGPU_ISA (GFX908, "gfx908", 0x030) +AMDGPU_ISA_UNSUPPORTED (GFX909, "gfx909", 0x031) +AMDGPU_ISA_UNSUPPORTED (GFX90C, "gfx90c", 0x032) +AMDGPU_ISA_UNSUPPORTED (GFX1010, "gfx1010", 0x033) +AMDGPU_ISA_UNSUPPORTED (GFX1011, "gfx1011", 0x034) +AMDGPU_ISA_UNSUPPORTED (GFX1012, "gfx1012", 0x035) +AMDGPU_ISA (GFX1030, "gfx1030", 0x036) +AMDGPU_ISA_UNSUPPORTED (GFX1031, "gfx1031", 0x037) +AMDGPU_ISA_UNSUPPORTED (GFX1032, "gfx1032", 0x038) +AMDGPU_ISA_UNSUPPORTED (GFX1033, "gfx1033", 0x039) +AMDGPU_ISA_UNSUPPORTED (GFX602, "gfx602", 0x03a) +AMDGPU_ISA_UNSUPPORTED (GFX705, "gfx705", 0x03b) +AMDGPU_ISA_UNSUPPORTED (GFX805, "gfx805", 0x03c) +AMDGPU_ISA_UNSUPPORTED (GFX1035, "gfx1035", 0x03d) +AMDGPU_ISA_UNSUPPORTED (GFX1034, "gfx1034", 0x03e) +AMDGPU_ISA (GFX90A, "gfx90a", 0x03f) +AMDGPU_ISA_UNSUPPORTED (GFX940, "gfx940", 0x040) +AMDGPU_ISA (GFX1100, "gfx1100", 0x041) +AMDGPU_ISA_UNSUPPORTED (GFX1013, "gfx1013", 0x042) +AMDGPU_ISA_UNSUPPORTED (GFX1150, "gfx1150", 0x043) +AMDGPU_ISA_UNSUPPORTED (GFX1103, "gfx1103", 0x044) +AMDGPU_ISA_UNSUPPORTED (GFX1036, "gfx1036", 0x045) +AMDGPU_ISA_UNSUPPORTED (GFX1101, "gfx1101", 0x046) +AMDGPU_ISA_UNSUPPORTED (GFX1102, "gfx1102", 0x047) +AMDGPU_ISA_UNSUPPORTED (GFX1200, "gfx1200", 0x048) +AMDGPU_ISA_UNSUPPORTED (RESERVED_0X49, "reserved_0x49", 0x049) +AMDGPU_ISA_UNSUPPORTED (GFX1151, "gfx1151", 0x04a) +AMDGPU_ISA_UNSUPPORTED (GFX941, "gfx941", 0x04b) +AMDGPU_ISA_UNSUPPORTED (GFX942, "gfx942", 0x04c) +AMDGPU_ISA_UNSUPPORTED (RESERVED_0X4D, "reserved_0x4d", 0x04d) +AMDGPU_ISA_UNSUPPORTED (GFX1201, "gfx1201", 0x04e) +AMDGPU_ISA_UNSUPPORTED (RESERVED_0X4F, "reserved_0x4f", 0x04f) +AMDGPU_ISA_UNSUPPORTED (RESERVED_0X50, "reserved_0x50", 0x050) +AMDGPU_ISA_UNSUPPORTED (GFX9_GENERIC, "gfx9_generic", 0x051) +AMDGPU_ISA_UNSUPPORTED (GFX10_1_GENERIC, "gfx10_1_generic", 0x052) +AMDGPU_ISA_UNSUPPORTED (GFX10_3_GENERIC, "gfx10_3_generic", 0x053) +AMDGPU_ISA_UNSUPPORTED (GFX11_GENERIC, "gfx11_generic", 0x054) +AMDGPU_ISA_UNSUPPORTED (RESERVED_0X55, "reserved 0x55", 0x055) diff --git a/libgomp/plugin/plugin-gcn.c b/libgomp/plugin/plugin-gcn.c index 7e141a85f31..31bf8fd22d3 100644 --- a/libgomp/plugin/plugin-gcn.c +++ b/libgomp/plugin/plugin-gcn.c @@ -379,19 +379,11 @@ struct gcn_image_desc 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 */ - 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_GFX1030 = 0x036, - EF_AMDGPU_MACH_AMDGCN_GFX1100 = 0x041 +#define AMDGPU_ISA(suffix, str, val) EF_AMDGPU_MACH_AMDGCN_ ## suffix = val, +#include "gcn-devices.def" +#undef AMDGPU_ISA } EF_AMDGPU_MACH; const static int EF_AMDGPU_MACH_MASK = 0x000000ff; @@ -1670,36 +1662,19 @@ elf_gcn_isa_field (Elf64_Ehdr *image) 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_gfx1030_s = "gfx1030"; -const static char *gcn_gfx1100_s = "gfx1100"; -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_hsa_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_GFX1030: - return gcn_gfx1030_s; - case EF_AMDGPU_MACH_AMDGCN_GFX1100: - return gcn_gfx1100_s; +#define AMDGPU_ISA(suffix, str, val) \ + case EF_AMDGPU_MACH_AMDGCN_ ## suffix: \ + return str; +#include "gcn-devices.def" +#undef AMDGPU_ISA } return NULL; } @@ -1709,7 +1684,8 @@ isa_hsa_name (int isa) { Keep in sync with /gcc/config/gcn/gcn.{c,opt}. */ static const char* -isa_gcc_name (int isa) { +isa_gcc_name (int isa) +{ switch(isa) { case EF_AMDGPU_MACH_AMDGCN_GFX803: @@ -1723,27 +1699,13 @@ isa_gcc_name (int isa) { 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_gfx1030_s, gcn_isa_name_len)) - return EF_AMDGPU_MACH_AMDGCN_GFX1030; - - if (!strncmp (isa, gcn_gfx1100_s, gcn_isa_name_len)) - return EF_AMDGPU_MACH_AMDGCN_GFX1100; +isa_code(const char *isa) +{ +#define AMDGPU_ISA(suffix, str, val) \ + if (!strcmp (str, isa)) \ + return EF_AMDGPU_MACH_AMDGCN_ ## suffix; +#include "gcn-devices.def" +#undef AMDGPU_ISA return EF_AMDGPU_MACH_UNSUPPORTED; } @@ -1760,7 +1722,7 @@ max_isa_vgprs (int isa) case EF_AMDGPU_MACH_AMDGCN_GFX906: case EF_AMDGPU_MACH_AMDGCN_GFX908: return 256; - case EF_AMDGPU_MACH_AMDGCN_GFX90a: + case EF_AMDGPU_MACH_AMDGCN_GFX90A: return 512; case EF_AMDGPU_MACH_AMDGCN_GFX1030: return 512; /* 512 SIMD32 = 256 wavefrontsize64. */ @@ -2466,25 +2428,24 @@ 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); - if (!isa_s) - { - hsa_error ("Unsupported ISA in GCN code object.", HSA_STATUS_ERROR); - return false; - } - if (isa_field != agent->device_isa) + if (!isa_s || 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); - 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); - + char msg[101 + 3*7 + 1]; + if (!isa_s) + snprintf (msg, sizeof msg, + "Unsupported ISA %x in GCN code object.", isa_field); + else + { + const char *agent_isa_s = isa_hsa_name (agent->device_isa); + const char *agent_isa_gcc_s = isa_gcc_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); + } hsa_error (msg, HSA_STATUS_ERROR); return false; } @@ -3393,7 +3354,12 @@ GOMP_OFFLOAD_init_device (int n) 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[31 + 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);