llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-lldb Author: satyanarayana reddy janga (satyajanga) <details> <summary>Changes</summary> Teach ArchSpec and ObjectFileELF about AMD (R600 and GCN/amdgcn) GPU architectures so GPU ELF object files and triples resolve to a precise architecture. - ArchSpec: add eCore_amd_gpu_* cores with matching kCore ranges, core definitions, and ELF arch-definition entries (EM_AMDGPU + EF_AMDGPU_MACH_* flags). The exact AMD GPU model is carried in the bottom byte of the ELF e_flags and stored as the architecture sub type; for amdgcn/r600 the model name is also appended to the triple environment so it round-trips through the triple string. Add GetElfCPUType/GetElfCPUSubType and GetData/CodeByteSize accessors. - ObjectFileELF: decode the GPU model from the AMDGPU ELF header (AMDGPUVariantFromElfFlags) and map ELFOSABI_AMDGPU_HSA to the AMDHSA OS. Remove the stale post-detection vendor assert (legacy scaffolding from commit f6a1312f1b30, which assumed ELF never sets a vendor): AMDGPU's canonical triple amdgcn-amd-amdhsa legitimately names AMD as the vendor. - Tests: unit-test the ELF-header -> architecture mapping in ArchSpecTest and an end-to-end AMDGPU ELF in TestObjectFileELF. The processor list, e_flags machine values, OSABI and ABI versions follow llvm/include/llvm/BinaryFormat/ELF.h (AMDGPU_MACH_LIST) and the AMDGPU code-object spec documented at https://llvm.org/docs/AMDGPUUsage.html. \ --- Patch is 38.06 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/206369.diff 5 Files Affected: - (modified) lldb/include/lldb/Utility/ArchSpec.h (+98-1) - (modified) lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp (+28-7) - (modified) lldb/source/Utility/ArchSpec.cpp (+503-21) - (modified) lldb/unittests/ObjectFile/ELF/TestObjectFileELF.cpp (+93) - (modified) lldb/unittests/Utility/ArchSpecTest.cpp (+43) ``````````diff diff --git a/lldb/include/lldb/Utility/ArchSpec.h b/lldb/include/lldb/Utility/ArchSpec.h index 160f81c2fa501..f4e7ff3ad90f5 100644 --- a/lldb/include/lldb/Utility/ArchSpec.h +++ b/lldb/include/lldb/Utility/ArchSpec.h @@ -240,6 +240,84 @@ class ArchSpec { eCore_wasm32, + eCore_amd_gpu_r600_R600, + eCore_amd_gpu_r600_R630, + eCore_amd_gpu_r600_RS880, + eCore_amd_gpu_r600_RV670, + eCore_amd_gpu_r600_RV710, + eCore_amd_gpu_r600_RV730, + eCore_amd_gpu_r600_RV770, + eCore_amd_gpu_r600_CEDAR, + eCore_amd_gpu_r600_CYPRESS, + eCore_amd_gpu_r600_JUNIPER, + eCore_amd_gpu_r600_REDWOOD, + eCore_amd_gpu_r600_SUMO, + eCore_amd_gpu_r600_BARTS, + eCore_amd_gpu_r600_CAICOS, + eCore_amd_gpu_r600_CAYMAN, + eCore_amd_gpu_r600_TURKS, + eCore_amd_gpu_r600_unknown, + eCore_amd_gpu_gcn_GFX600, + eCore_amd_gpu_gcn_GFX601, + eCore_amd_gpu_gcn_GFX602, + eCore_amd_gpu_gcn_GFX700, + eCore_amd_gpu_gcn_GFX701, + eCore_amd_gpu_gcn_GFX702, + eCore_amd_gpu_gcn_GFX703, + eCore_amd_gpu_gcn_GFX704, + eCore_amd_gpu_gcn_GFX705, + eCore_amd_gpu_gcn_GFX801, + eCore_amd_gpu_gcn_GFX802, + eCore_amd_gpu_gcn_GFX803, + eCore_amd_gpu_gcn_GFX805, + eCore_amd_gpu_gcn_GFX810, + eCore_amd_gpu_gcn_GFX900, + eCore_amd_gpu_gcn_GFX902, + eCore_amd_gpu_gcn_GFX904, + eCore_amd_gpu_gcn_GFX906, + eCore_amd_gpu_gcn_GFX908, + eCore_amd_gpu_gcn_GFX909, + eCore_amd_gpu_gcn_GFX90A, + eCore_amd_gpu_gcn_GFX90C, + eCore_amd_gpu_gcn_GFX942, + eCore_amd_gpu_gcn_GFX950, + eCore_amd_gpu_gcn_GFX1010, + eCore_amd_gpu_gcn_GFX1011, + eCore_amd_gpu_gcn_GFX1012, + eCore_amd_gpu_gcn_GFX1013, + eCore_amd_gpu_gcn_GFX1030, + eCore_amd_gpu_gcn_GFX1031, + eCore_amd_gpu_gcn_GFX1032, + eCore_amd_gpu_gcn_GFX1033, + eCore_amd_gpu_gcn_GFX1034, + eCore_amd_gpu_gcn_GFX1035, + eCore_amd_gpu_gcn_GFX1036, + eCore_amd_gpu_gcn_GFX1100, + eCore_amd_gpu_gcn_GFX1101, + eCore_amd_gpu_gcn_GFX1102, + eCore_amd_gpu_gcn_GFX1103, + eCore_amd_gpu_gcn_GFX1150, + eCore_amd_gpu_gcn_GFX1151, + eCore_amd_gpu_gcn_GFX1152, + eCore_amd_gpu_gcn_GFX1153, + eCore_amd_gpu_gcn_GFX1154, + eCore_amd_gpu_gcn_GFX1170, + eCore_amd_gpu_gcn_GFX1171, + eCore_amd_gpu_gcn_GFX1172, + eCore_amd_gpu_gcn_GFX1200, + eCore_amd_gpu_gcn_GFX1201, + eCore_amd_gpu_gcn_GFX1250, + eCore_amd_gpu_gcn_GFX1251, + eCore_amd_gpu_gcn_GFX1310, + eCore_amd_gpu_gcn_GFX9_GENERIC, + eCore_amd_gpu_gcn_GFX9_4_GENERIC, + eCore_amd_gpu_gcn_GFX10_1_GENERIC, + eCore_amd_gpu_gcn_GFX10_3_GENERIC, + eCore_amd_gpu_gcn_GFX11_GENERIC, + eCore_amd_gpu_gcn_GFX12_GENERIC, + eCore_amd_gpu_gcn_GFX12_5_GENERIC, + eCore_amd_gpu_gcn_unknown, + kNumCores, kCore_invalid, @@ -286,7 +364,10 @@ class ArchSpec { kCore_mips64el_last = eCore_mips64r6el, kCore_mips_first = eCore_mips32, - kCore_mips_last = eCore_mips64r6el + kCore_mips_last = eCore_mips64r6el, + + kCore_amd_gpu_first = eCore_amd_gpu_r600_R600, + kCore_amd_gpu_last = eCore_amd_gpu_gcn_unknown }; @@ -454,6 +535,22 @@ class ArchSpec { uint32_t GetMachOCPUSubType() const; + uint32_t GetElfCPUType() const; + + uint32_t GetElfCPUSubType() const; + + /// Architecture data byte width accessor + /// + /// \return the size in 8-bit (host) bytes of a minimum addressable unit + /// from the Architecture's data bus + uint32_t GetDataByteSize() const; + + /// Architecture code byte width accessor + /// + /// \return the size in 8-bit (host) bytes of a minimum addressable unit + /// from the Architecture's code bus + uint32_t GetCodeByteSize() const; + /// Architecture triple accessor. /// /// \return A triple describing this ArchSpec. diff --git a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp index 7e4190d673fc5..91d7ad7c2169a 100644 --- a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp +++ b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp @@ -362,6 +362,29 @@ static uint32_t loongarchVariantFromElfFlags(const elf::ELFHeader &header) { } } +static uint32_t AMDGPUVariantFromElfFlags(const elf::ELFHeader &header) { + // The flags contain the exact GPU model for HSA only. The sub type is set to + // a valid EF_AMDGPU_MACH_ define from the ELF.h file in llvm. + if (header.e_ident[EI_OSABI] == ELFOSABI_AMDGPU_HSA) { + switch (header.e_ident[EI_ABIVERSION]) { + case ELFABIVERSION_AMDGPU_HSA_V2: + // Flags bits not parsed for this include: + // EF_AMDGPU_FEATURE_XNACK_V2 + // EF_AMDGPU_FEATURE_TRAP_HANDLER_V2 + break; // No CPU model is defined in HSA V2 + + case ELFABIVERSION_AMDGPU_HSA_V3: + case ELFABIVERSION_AMDGPU_HSA_V4: + case ELFABIVERSION_AMDGPU_HSA_V5: + case ELFABIVERSION_AMDGPU_HSA_V6: + // The sub type is the bottom byte of the e_flags which defines the + // EF_AMDGPU_MACH value that identifies the actual CPU model. + return header.e_flags & EF_AMDGPU_MACH; + } + } + return LLDB_INVALID_CPUTYPE; // No subtype. +} + static uint32_t subTypeFromElfHeader(const elf::ELFHeader &header) { if (header.e_machine == llvm::ELF::EM_MIPS) return mipsVariantFromElfFlags(header); @@ -371,6 +394,8 @@ static uint32_t subTypeFromElfHeader(const elf::ELFHeader &header) { return riscvVariantFromElfFlags(header); else if (header.e_machine == llvm::ELF::EM_LOONGARCH) return loongarchVariantFromElfFlags(header); + else if (header.e_machine == llvm::ELF::EM_AMDGPU) + return AMDGPUVariantFromElfFlags(header); return LLDB_INVALID_CPUTYPE; } @@ -584,6 +609,9 @@ static bool GetOsFromOSABI(unsigned char osabi_byte, case ELFOSABI_SOLARIS: ostype = llvm::Triple::OSType::Solaris; break; + case ELFOSABI_AMDGPU_HSA: + ostype = llvm::Triple::OSType::AMDHSA; + break; default: ostype = llvm::Triple::OSType::UnknownOS; } @@ -618,7 +646,6 @@ ModuleSpecList ObjectFileELF::GetModuleSpecifications( if (spec.GetArchitecture().IsValid()) { llvm::Triple::OSType ostype; - llvm::Triple::VendorType vendor; llvm::Triple::OSType spec_ostype = spec.GetArchitecture().GetTriple().getOS(); @@ -626,12 +653,6 @@ ModuleSpecList ObjectFileELF::GetModuleSpecifications( __FUNCTION__, file.GetPath().c_str(), OSABIAsCString(header.e_ident[EI_OSABI])); - // SetArchitecture should have set the vendor to unknown - vendor = spec.GetArchitecture().GetTriple().getVendor(); - assert(vendor == llvm::Triple::UnknownVendor); - UNUSED_IF_ASSERT_DISABLED(vendor); - - // // Validate it is ok to remove GetOsFromOSABI GetOsFromOSABI(header.e_ident[EI_OSABI], ostype); assert(spec_ostype == ostype); diff --git a/lldb/source/Utility/ArchSpec.cpp b/lldb/source/Utility/ArchSpec.cpp index 6eecf4f1b0995..91943da561e63 100644 --- a/lldb/source/Utility/ArchSpec.cpp +++ b/lldb/source/Utility/ArchSpec.cpp @@ -13,6 +13,7 @@ #include "lldb/Utility/StringList.h" #include "lldb/lldb-defines.h" #include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/StringSwitch.h" #include "llvm/BinaryFormat/COFF.h" #include "llvm/BinaryFormat/ELF.h" #include "llvm/BinaryFormat/MachO.h" @@ -40,6 +41,22 @@ struct CoreDefinition { } // namespace lldb_private +#define AMD_GPU_CORE_DEF_R600(sub) \ + {eByteOrderLittle, \ + 4, \ + 4, \ + 16, \ + llvm::Triple::r600, \ + ArchSpec::eCore_amd_gpu_r600_##sub, \ + "r600"} +#define AMD_GPU_CORE_DEF_GCN(sub) \ + {eByteOrderLittle, \ + 8, \ + 4, \ + 16, \ + llvm::Triple::amdgcn, \ + ArchSpec::eCore_amd_gpu_gcn_##sub, \ + "amdgcn"} // This core information can be looked using the ArchSpec::Core as the index static constexpr const CoreDefinition g_core_definitions[] = { {eByteOrderLittle, 4, 2, 4, llvm::Triple::arm, ArchSpec::eCore_arm_generic, @@ -254,6 +271,83 @@ static constexpr const CoreDefinition g_core_definitions[] = { {eByteOrderLittle, 4, 1, 4, llvm::Triple::wasm32, ArchSpec::eCore_wasm32, "wasm32"}, + AMD_GPU_CORE_DEF_R600(R600), + AMD_GPU_CORE_DEF_R600(R630), + AMD_GPU_CORE_DEF_R600(RS880), + AMD_GPU_CORE_DEF_R600(RV670), + AMD_GPU_CORE_DEF_R600(RV710), + AMD_GPU_CORE_DEF_R600(RV730), + AMD_GPU_CORE_DEF_R600(RV770), + AMD_GPU_CORE_DEF_R600(CEDAR), + AMD_GPU_CORE_DEF_R600(CYPRESS), + AMD_GPU_CORE_DEF_R600(JUNIPER), + AMD_GPU_CORE_DEF_R600(REDWOOD), + AMD_GPU_CORE_DEF_R600(SUMO), + AMD_GPU_CORE_DEF_R600(BARTS), + AMD_GPU_CORE_DEF_R600(CAICOS), + AMD_GPU_CORE_DEF_R600(CAYMAN), + AMD_GPU_CORE_DEF_R600(TURKS), + AMD_GPU_CORE_DEF_R600(unknown), + AMD_GPU_CORE_DEF_GCN(GFX600), + AMD_GPU_CORE_DEF_GCN(GFX601), + AMD_GPU_CORE_DEF_GCN(GFX602), + AMD_GPU_CORE_DEF_GCN(GFX700), + AMD_GPU_CORE_DEF_GCN(GFX701), + AMD_GPU_CORE_DEF_GCN(GFX702), + AMD_GPU_CORE_DEF_GCN(GFX703), + AMD_GPU_CORE_DEF_GCN(GFX704), + AMD_GPU_CORE_DEF_GCN(GFX705), + AMD_GPU_CORE_DEF_GCN(GFX801), + AMD_GPU_CORE_DEF_GCN(GFX802), + AMD_GPU_CORE_DEF_GCN(GFX803), + AMD_GPU_CORE_DEF_GCN(GFX805), + AMD_GPU_CORE_DEF_GCN(GFX810), + AMD_GPU_CORE_DEF_GCN(GFX900), + AMD_GPU_CORE_DEF_GCN(GFX902), + AMD_GPU_CORE_DEF_GCN(GFX904), + AMD_GPU_CORE_DEF_GCN(GFX906), + AMD_GPU_CORE_DEF_GCN(GFX908), + AMD_GPU_CORE_DEF_GCN(GFX909), + AMD_GPU_CORE_DEF_GCN(GFX90A), + AMD_GPU_CORE_DEF_GCN(GFX90C), + AMD_GPU_CORE_DEF_GCN(GFX942), + AMD_GPU_CORE_DEF_GCN(GFX950), + AMD_GPU_CORE_DEF_GCN(GFX1010), + AMD_GPU_CORE_DEF_GCN(GFX1011), + AMD_GPU_CORE_DEF_GCN(GFX1012), + AMD_GPU_CORE_DEF_GCN(GFX1013), + AMD_GPU_CORE_DEF_GCN(GFX1030), + AMD_GPU_CORE_DEF_GCN(GFX1031), + AMD_GPU_CORE_DEF_GCN(GFX1032), + AMD_GPU_CORE_DEF_GCN(GFX1033), + AMD_GPU_CORE_DEF_GCN(GFX1034), + AMD_GPU_CORE_DEF_GCN(GFX1035), + AMD_GPU_CORE_DEF_GCN(GFX1036), + AMD_GPU_CORE_DEF_GCN(GFX1100), + AMD_GPU_CORE_DEF_GCN(GFX1101), + AMD_GPU_CORE_DEF_GCN(GFX1102), + AMD_GPU_CORE_DEF_GCN(GFX1103), + AMD_GPU_CORE_DEF_GCN(GFX1150), + AMD_GPU_CORE_DEF_GCN(GFX1151), + AMD_GPU_CORE_DEF_GCN(GFX1152), + AMD_GPU_CORE_DEF_GCN(GFX1153), + AMD_GPU_CORE_DEF_GCN(GFX1154), + AMD_GPU_CORE_DEF_GCN(GFX1170), + AMD_GPU_CORE_DEF_GCN(GFX1171), + AMD_GPU_CORE_DEF_GCN(GFX1172), + AMD_GPU_CORE_DEF_GCN(GFX1200), + AMD_GPU_CORE_DEF_GCN(GFX1201), + AMD_GPU_CORE_DEF_GCN(GFX1250), + AMD_GPU_CORE_DEF_GCN(GFX1251), + AMD_GPU_CORE_DEF_GCN(GFX1310), + AMD_GPU_CORE_DEF_GCN(GFX9_GENERIC), + AMD_GPU_CORE_DEF_GCN(GFX9_4_GENERIC), + AMD_GPU_CORE_DEF_GCN(GFX10_1_GENERIC), + AMD_GPU_CORE_DEF_GCN(GFX10_3_GENERIC), + AMD_GPU_CORE_DEF_GCN(GFX11_GENERIC), + AMD_GPU_CORE_DEF_GCN(GFX12_GENERIC), + AMD_GPU_CORE_DEF_GCN(GFX12_5_GENERIC), + AMD_GPU_CORE_DEF_GCN(unknown), }; // Ensure that we have an entry in the g_core_definitions for each core. If you @@ -383,6 +477,12 @@ static const ArchDefinition g_macho_arch_def = {eArchTypeMachO, std::size(g_macho_arch_entries), g_macho_arch_entries, "mach-o"}; +#define AMD_GPU_ARCH_DEF_R600(sub) \ + {ArchSpec::eCore_amd_gpu_r600_##sub, llvm::ELF::EM_AMDGPU, \ + llvm::ELF::EF_AMDGPU_MACH_R600_##sub} +#define AMD_GPU_ARCH_DEF_GCN(sub) \ + {ArchSpec::eCore_amd_gpu_gcn_##sub, llvm::ELF::EM_AMDGPU, \ + llvm::ELF::EF_AMDGPU_MACH_AMDGCN_##sub} //===----------------------------------------------------------------------===// // A table that gets searched linearly for matches. This table is used to // convert cpu type and subtypes to architecture names, and to convert @@ -421,6 +521,91 @@ static const ArchDefinitionEntry g_elf_arch_entries[] = { {ArchSpec::eCore_riscv64, llvm::ELF::EM_RISCV, ArchSpec::eRISCVSubType_riscv64}, // riscv64 {ArchSpec::eCore_loongarch32, llvm::ELF::EM_LOONGARCH, ArchSpec::eLoongArchSubType_loongarch32}, // loongarch32 {ArchSpec::eCore_loongarch64, llvm::ELF::EM_LOONGARCH, ArchSpec::eLoongArchSubType_loongarch64}, // loongarch64 + AMD_GPU_ARCH_DEF_R600(R600), + AMD_GPU_ARCH_DEF_R600(R630), + AMD_GPU_ARCH_DEF_R600(RS880), + AMD_GPU_ARCH_DEF_R600(RV670), + AMD_GPU_ARCH_DEF_R600(RV710), + AMD_GPU_ARCH_DEF_R600(RV730), + AMD_GPU_ARCH_DEF_R600(RV770), + AMD_GPU_ARCH_DEF_R600(CEDAR), + AMD_GPU_ARCH_DEF_R600(CYPRESS), + AMD_GPU_ARCH_DEF_R600(JUNIPER), + AMD_GPU_ARCH_DEF_R600(REDWOOD), + AMD_GPU_ARCH_DEF_R600(SUMO), + AMD_GPU_ARCH_DEF_R600(BARTS), + AMD_GPU_ARCH_DEF_R600(CAICOS), + AMD_GPU_ARCH_DEF_R600(CAYMAN), + AMD_GPU_ARCH_DEF_R600(TURKS), + // Catch-all for an AMDGPU object whose model can't be decoded (no sub + // type, e.g. a non-HSA object or HSA code-object v2). NOTE: this table is + // searched linearly and returns the first match, so this R600 entry + // shadows the eCore_amd_gpu_gcn_unknown catch-all at the end of the GCN + // block below -- an unidentified AMDGPU therefore resolves to R600 rather + // than GCN. Left as-is for now (matches the original GPU patch); whether + // GCN is the better default is worth revisiting. + {ArchSpec::eCore_amd_gpu_r600_unknown, llvm::ELF::EM_AMDGPU}, + AMD_GPU_ARCH_DEF_GCN(GFX600), + AMD_GPU_ARCH_DEF_GCN(GFX601), + AMD_GPU_ARCH_DEF_GCN(GFX602), + AMD_GPU_ARCH_DEF_GCN(GFX700), + AMD_GPU_ARCH_DEF_GCN(GFX701), + AMD_GPU_ARCH_DEF_GCN(GFX702), + AMD_GPU_ARCH_DEF_GCN(GFX703), + AMD_GPU_ARCH_DEF_GCN(GFX704), + AMD_GPU_ARCH_DEF_GCN(GFX705), + AMD_GPU_ARCH_DEF_GCN(GFX801), + AMD_GPU_ARCH_DEF_GCN(GFX802), + AMD_GPU_ARCH_DEF_GCN(GFX803), + AMD_GPU_ARCH_DEF_GCN(GFX805), + AMD_GPU_ARCH_DEF_GCN(GFX810), + AMD_GPU_ARCH_DEF_GCN(GFX900), + AMD_GPU_ARCH_DEF_GCN(GFX902), + AMD_GPU_ARCH_DEF_GCN(GFX904), + AMD_GPU_ARCH_DEF_GCN(GFX906), + AMD_GPU_ARCH_DEF_GCN(GFX908), + AMD_GPU_ARCH_DEF_GCN(GFX909), + AMD_GPU_ARCH_DEF_GCN(GFX90A), + AMD_GPU_ARCH_DEF_GCN(GFX90C), + AMD_GPU_ARCH_DEF_GCN(GFX942), + AMD_GPU_ARCH_DEF_GCN(GFX950), + AMD_GPU_ARCH_DEF_GCN(GFX1010), + AMD_GPU_ARCH_DEF_GCN(GFX1011), + AMD_GPU_ARCH_DEF_GCN(GFX1012), + AMD_GPU_ARCH_DEF_GCN(GFX1013), + AMD_GPU_ARCH_DEF_GCN(GFX1030), + AMD_GPU_ARCH_DEF_GCN(GFX1031), + AMD_GPU_ARCH_DEF_GCN(GFX1032), + AMD_GPU_ARCH_DEF_GCN(GFX1033), + AMD_GPU_ARCH_DEF_GCN(GFX1034), + AMD_GPU_ARCH_DEF_GCN(GFX1035), + AMD_GPU_ARCH_DEF_GCN(GFX1036), + AMD_GPU_ARCH_DEF_GCN(GFX1100), + AMD_GPU_ARCH_DEF_GCN(GFX1101), + AMD_GPU_ARCH_DEF_GCN(GFX1102), + AMD_GPU_ARCH_DEF_GCN(GFX1103), + AMD_GPU_ARCH_DEF_GCN(GFX1150), + AMD_GPU_ARCH_DEF_GCN(GFX1151), + AMD_GPU_ARCH_DEF_GCN(GFX1152), + AMD_GPU_ARCH_DEF_GCN(GFX1153), + AMD_GPU_ARCH_DEF_GCN(GFX1154), + AMD_GPU_ARCH_DEF_GCN(GFX1170), + AMD_GPU_ARCH_DEF_GCN(GFX1171), + AMD_GPU_ARCH_DEF_GCN(GFX1172), + AMD_GPU_ARCH_DEF_GCN(GFX1200), + AMD_GPU_ARCH_DEF_GCN(GFX1201), + AMD_GPU_ARCH_DEF_GCN(GFX1250), + AMD_GPU_ARCH_DEF_GCN(GFX1251), + AMD_GPU_ARCH_DEF_GCN(GFX1310), + AMD_GPU_ARCH_DEF_GCN(GFX9_GENERIC), + AMD_GPU_ARCH_DEF_GCN(GFX9_4_GENERIC), + AMD_GPU_ARCH_DEF_GCN(GFX10_1_GENERIC), + AMD_GPU_ARCH_DEF_GCN(GFX10_3_GENERIC), + AMD_GPU_ARCH_DEF_GCN(GFX11_GENERIC), + AMD_GPU_ARCH_DEF_GCN(GFX12_GENERIC), + AMD_GPU_ARCH_DEF_GCN(GFX12_5_GENERIC), + // Unknown AMD GCN GPU + {ArchSpec::eCore_amd_gpu_gcn_unknown, llvm::ELF::EM_AMDGPU}, }; // clang-format on @@ -524,6 +709,8 @@ FindArchDefinitionEntry(const ArchDefinition *def, ArchSpec::Core core) { return nullptr; } +static llvm::StringRef GetAMDGPUVariantName(uint32_t sub); + //===----------------------------------------------------------------------===// // Constructors and destructors. @@ -652,33 +839,57 @@ std::string ArchSpec::GetClangTargetCPU() const { if (GetTriple().isARM()) cpu = llvm::ARM::getARMCPUForArch(GetTriple(), "").str(); + + if (GetTriple().isAMDGPU()) { + uint32_t sub = GetElfCPUSubType(); + if (sub != LLDB_INVALID_CPUTYPE) + cpu = GetAMDGPUVariantName(sub); + } return cpu; } -uint32_t ArchSpec::GetMachOCPUType() const { - const CoreDefinition *core_def = FindCoreDefinition(m_core); - if (core_def) { - const ArchDefinitionEntry *arch_def = - FindArchDefinitionEntry(&g_macho_arch_def, core_def->core); - if (arch_def) { - return arch_def->cpu; - } - } +static const ArchDefinitionEntry * +FindArchDefEntryIfCoreIsValid(const ArchDefinition *def, ArchSpec::Core core) { + if (const CoreDefinition *core_def = FindCoreDefinition(core)) + return FindArchDefinitionEntry(def, core_def->core); + + return nullptr; +} + +static uint32_t GetCPUType(const ArchDefinition *def, ArchSpec::Core core) { + if (const ArchDefinitionEntry *arch_def = + FindArchDefEntryIfCoreIsValid(def, core)) + return arch_def->cpu; return LLDB_INVALID_CPUTYPE; } -uint32_t ArchSpec::GetMachOCPUSubType() const { - const CoreDefinition *core_def = FindCoreDefinition(m_core); - if (core_def) { - const ArchDefinitionEntry *arch_def = - FindArchDefinitionEntry(&g_macho_arch_def, core_def->core); - if (arch_def) { - return arch_def->sub; - } - } +static uint32_t GetCPUSubType(const ArchDefinition *def, ArchSpec::Core core) { + if (const ArchDefinitionEntry *arch_def = + FindArchDefEntryIfCoreIsValid(def, core)) + return arch_def->sub; return LLDB_INVALID_CPUTYPE; } +uint32_t ArchSpec::GetMachOCPUType() const { + return GetCPUType(&g_macho_arch_def, m_core); +} + +uint32_t ArchSpec::GetMachOCPUSubType() const { + return GetCPUSubType(&g_macho_arch_def, m_core); +} + +uint32_t ArchSpec::GetElfCPUType() const { + return GetCPUType(&g_elf_arch_def, m_core); +} + +uint32_t ArchSpec::GetElfCPUSubType() const { + return GetCPUSubType(&g_elf_arch_def, m_core); +} + +uint32_t ArchSpec::GetDataByteSize() const { return 1; } + +uint32_t ArchSpec::GetCodeByteSize() const { return 1; } + llvm::Triple::ArchType ArchSpec::GetMachine() const { const CoreDefinition *core_def = FindCoreDefinition(m_core); if (core_def) @@ -849,6 +1060,249 @@ void ArchSpec::MergeFrom(const ArchSpec &other) { } } +static llvm::StringRef GetAMDGPUVariantName(uint32_t sub) { + switch (sub) { + case llvm::ELF::EF_AMDGPU_MACH_R600_R600: + return "r600"; + case llvm::ELF::EF_AMDGPU_MACH_R600_R630: + return "r630"; + case llvm::ELF::EF_AMDGPU_MACH_R600_RS880: + return "rs880"; + case llvm::ELF::EF_AMDGPU_MACH_R600_RV670: + return "rv670"; + case llvm::ELF::EF_AMDGPU_MACH_R600_RV710: + return "rv710"; + case llvm::ELF::EF_AMDGPU_MACH_R600_RV730: + return "rv730"; + case llvm::ELF::EF_AMDGPU_MACH_R600_RV770: + return "rv770"; + case llvm::ELF::EF_AMDGPU_MACH_R600_CEDAR: + return "cedar"; + case llvm::ELF::EF_AMDGPU_MACH_R600_CYPRESS: + return "cypress"; + case llvm::ELF::EF_AMDGPU_MACH_R600_JUNIPER: + return "juniper"; + case llvm::ELF::EF_AMDGPU_MACH_R600_REDWOOD: + return "redwood"; + case llvm::ELF::EF_AMDGPU_MACH_R600_SUMO: + return "sumo"; + case llvm::ELF::EF_AMDGPU_MACH_R600_BARTS: + return "barts"; + case llvm::ELF::EF_AMDGPU_MACH_R600_CAICOS: + return "caicos"; + case llvm::ELF::EF_AMDGPU_MACH_R600_CAYMAN: + return "cayman"; + case llvm... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/206369 _______________________________________________ lldb-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
