https://github.com/Midar updated https://github.com/llvm/llvm-project/pull/191951
>From 13bf4d98f7a6d9fda11c11e3f3ee72f4dc52a7c7 Mon Sep 17 00:00:00 2001 From: Jonathan Schleifer <[email protected]> Date: Tue, 14 Apr 2026 08:23:21 -0500 Subject: [PATCH 1/2] Run clang-format on TargetParser/Triple.{cpp,h} It already got inconsistent because new chages require complying with clang-format on CI, while everything old is not complying with it. --- llvm/include/llvm/TargetParser/Triple.h | 146 ++-- llvm/lib/TargetParser/Triple.cpp | 841 ++++++++++++++++-------- 2 files changed, 598 insertions(+), 389 deletions(-) diff --git a/llvm/include/llvm/TargetParser/Triple.h b/llvm/include/llvm/TargetParser/Triple.h index 7c5aa52a1bd04..fb4aaaa067ae9 100644 --- a/llvm/include/llvm/TargetParser/Triple.h +++ b/llvm/include/llvm/TargetParser/Triple.h @@ -383,9 +383,7 @@ class Triple { ObjectFormat == Other.ObjectFormat; } - bool operator!=(const Triple &Other) const { - return !(*this == Other); - } + bool operator!=(const Triple &Other) const { return !(*this == Other); } bool operator<(const Triple &Other) const { return std::tie(Arch, SubArch, Vendor, OS, Environment, ObjectFormat, @@ -436,9 +434,7 @@ class Triple { OSType getOS() const { return OS; } /// Does this triple have the optional environment (fourth) component? - bool hasEnvironment() const { - return getEnvironmentName() != ""; - } + bool hasEnvironment() const { return getEnvironmentName() != ""; } /// Get the parsed environment type of this triple. EnvironmentType getEnvironment() const { return Environment; } @@ -602,23 +598,15 @@ class Triple { /// changes, i.e., if the two operating systems diverge or their version /// numbers get out of sync, that will need to be changed. /// watchOS has completely different version numbers so it is not included. - bool isiOS() const { - return getOS() == Triple::IOS || isTvOS(); - } + bool isiOS() const { return getOS() == Triple::IOS || isTvOS(); } /// Is this an Apple tvOS triple. - bool isTvOS() const { - return getOS() == Triple::TvOS; - } + bool isTvOS() const { return getOS() == Triple::TvOS; } /// Is this an Apple watchOS triple. - bool isWatchOS() const { - return getOS() == Triple::WatchOS; - } + bool isWatchOS() const { return getOS() == Triple::WatchOS; } - bool isWatchABI() const { - return getSubArch() == Triple::ARMSubArch_v7k; - } + bool isWatchABI() const { return getSubArch() == Triple::ARMSubArch_v7k; } /// Is this an Apple XROS triple. bool isXROS() const { return getOS() == Triple::XROS; } @@ -664,31 +652,19 @@ class Triple { isMacCatalystEnvironment())); } - bool isOSNetBSD() const { - return getOS() == Triple::NetBSD; - } + bool isOSNetBSD() const { return getOS() == Triple::NetBSD; } - bool isOSOpenBSD() const { - return getOS() == Triple::OpenBSD; - } + bool isOSOpenBSD() const { return getOS() == Triple::OpenBSD; } - bool isOSFreeBSD() const { - return getOS() == Triple::FreeBSD; - } + bool isOSFreeBSD() const { return getOS() == Triple::FreeBSD; } - bool isOSFuchsia() const { - return getOS() == Triple::Fuchsia; - } + bool isOSFuchsia() const { return getOS() == Triple::Fuchsia; } bool isOSDragonFly() const { return getOS() == Triple::DragonFly; } - bool isOSSolaris() const { - return getOS() == Triple::Solaris; - } + bool isOSSolaris() const { return getOS() == Triple::Solaris; } - bool isOSIAMCU() const { - return getOS() == Triple::ELFIAMCU; - } + bool isOSIAMCU() const { return getOS() == Triple::ELFIAMCU; } bool isOSUnknown() const { return getOS() == Triple::UnknownOS; } @@ -703,19 +679,13 @@ class Triple { } /// Tests whether the OS is Haiku. - bool isOSHaiku() const { - return getOS() == Triple::Haiku; - } + bool isOSHaiku() const { return getOS() == Triple::Haiku; } /// Tests whether the OS is UEFI. - bool isUEFI() const { - return getOS() == Triple::UEFI; - } + bool isUEFI() const { return getOS() == Triple::UEFI; } /// Tests whether the OS is Windows. - bool isOSWindows() const { - return getOS() == Triple::Win32; - } + bool isOSWindows() const { return getOS() == Triple::Win32; } /// Checks if the environment is MSVC. bool isKnownWindowsMSVCEnvironment() const { @@ -762,19 +732,13 @@ class Triple { } /// Tests whether the OS is Linux. - bool isOSLinux() const { - return getOS() == Triple::Linux; - } + bool isOSLinux() const { return getOS() == Triple::Linux; } /// Tests whether the OS is kFreeBSD. - bool isOSKFreeBSD() const { - return getOS() == Triple::KFreeBSD; - } + bool isOSKFreeBSD() const { return getOS() == Triple::KFreeBSD; } /// Tests whether the OS is Hurd. - bool isOSHurd() const { - return getOS() == Triple::Hurd; - } + bool isOSHurd() const { return getOS() == Triple::Hurd; } /// Tests whether the OS is WASI. bool isOSWASI() const { @@ -783,9 +747,7 @@ class Triple { } /// Tests whether the OS is Emscripten. - bool isOSEmscripten() const { - return getOS() == Triple::Emscripten; - } + bool isOSEmscripten() const { return getOS() == Triple::Emscripten; } /// Tests whether the OS uses glibc. bool isOSGlibc() const { @@ -795,44 +757,30 @@ class Triple { } /// Tests whether the OS is AIX. - bool isOSAIX() const { - return getOS() == Triple::AIX; - } + bool isOSAIX() const { return getOS() == Triple::AIX; } - bool isOSSerenity() const { - return getOS() == Triple::Serenity; - } + bool isOSSerenity() const { return getOS() == Triple::Serenity; } /// Tests whether the OS is QURT. bool isOSQurt() const { return getOS() == Triple::QURT; } /// Tests whether the OS uses the ELF binary format. - bool isOSBinFormatELF() const { - return getObjectFormat() == Triple::ELF; - } + bool isOSBinFormatELF() const { return getObjectFormat() == Triple::ELF; } /// Tests whether the OS uses the COFF binary format. - bool isOSBinFormatCOFF() const { - return getObjectFormat() == Triple::COFF; - } + bool isOSBinFormatCOFF() const { return getObjectFormat() == Triple::COFF; } /// Tests whether the OS uses the GOFF binary format. bool isOSBinFormatGOFF() const { return getObjectFormat() == Triple::GOFF; } /// Tests whether the environment is MachO. - bool isOSBinFormatMachO() const { - return getObjectFormat() == Triple::MachO; - } + bool isOSBinFormatMachO() const { return getObjectFormat() == Triple::MachO; } /// Tests whether the OS uses the Wasm binary format. - bool isOSBinFormatWasm() const { - return getObjectFormat() == Triple::Wasm; - } + bool isOSBinFormatWasm() const { return getObjectFormat() == Triple::Wasm; } /// Tests whether the OS uses the XCOFF binary format. - bool isOSBinFormatXCOFF() const { - return getObjectFormat() == Triple::XCOFF; - } + bool isOSBinFormatXCOFF() const { return getObjectFormat() == Triple::XCOFF; } /// Tests whether the OS uses the DXContainer binary format. bool isOSBinFormatDXContainer() const { @@ -847,16 +795,14 @@ class Triple { /// Tests whether the target is the PS4 platform. bool isPS4() const { - return getArch() == Triple::x86_64 && - getVendor() == Triple::SCEI && + return getArch() == Triple::x86_64 && getVendor() == Triple::SCEI && getOS() == Triple::PS4; } /// Tests whether the target is the PS5 platform. bool isPS5() const { - return getArch() == Triple::x86_64 && - getVendor() == Triple::SCEI && - getOS() == Triple::PS5; + return getArch() == Triple::x86_64 && getVendor() == Triple::SCEI && + getOS() == Triple::PS5; } /// Tests whether the target is the PS4 or PS5 platform. @@ -900,13 +846,9 @@ class Triple { bool isOSLiteOS() const { return getOS() == Triple::LiteOS; } /// Tests whether the target is DXIL. - bool isDXIL() const { - return getArch() == Triple::dxil; - } + bool isDXIL() const { return getArch() == Triple::dxil; } - bool isShaderModelOS() const { - return getOS() == Triple::ShaderModel; - } + bool isShaderModelOS() const { return getOS() == Triple::ShaderModel; } bool isVulkanOS() const { return getOS() == Triple::Vulkan; } @@ -941,9 +883,7 @@ class Triple { bool isSPIROrSPIRV() const { return isSPIR() || isSPIRV(); } /// Tests whether the target is SPIR-V Logical - bool isSPIRVLogical() const { - return getArch() == Triple::spirv; - } + bool isSPIRVLogical() const { return getArch() == Triple::spirv; } /// Tests whether the target is NVPTX (32- or 64-bit). bool isNVPTX() const { @@ -1091,9 +1031,7 @@ class Triple { } /// Tests whether the target is MIPS (little and big endian, 32- or 64-bit). - bool isMIPS() const { - return isMIPS32() || isMIPS64(); - } + bool isMIPS() const { return isMIPS32() || isMIPS64(); } /// Tests whether the target is PowerPC (32- or 64-bit LE or BE). bool isPPC() const { @@ -1153,9 +1091,7 @@ class Triple { bool isSPARC() const { return isSPARC32() || isSPARC64(); } /// Tests whether the target is SystemZ. - bool isSystemZ() const { - return getArch() == Triple::systemz; - } + bool isSystemZ() const { return getArch() == Triple::systemz; } /// Tests whether the target is x86 (32- or 64-bit). bool isX86() const { @@ -1169,9 +1105,7 @@ class Triple { bool isX86_64() const { return getArch() == Triple::x86_64; } /// Tests whether the target is VE - bool isVE() const { - return getArch() == Triple::ve; - } + bool isVE() const { return getArch() == Triple::ve; } /// Tests whether the target is wasm (32- and 64-bit). bool isWasm() const { @@ -1179,9 +1113,7 @@ class Triple { } // Tests whether the target is CSKY - bool isCSKY() const { - return getArch() == Triple::csky; - } + bool isCSKY() const { return getArch() == Triple::csky; } /// Tests whether the target is the Apple "arm64e" AArch64 subarch. bool isArm64e() const { @@ -1225,8 +1157,7 @@ class Triple { EnvironmentType Env = getEnvironment(); return Env == llvm::Triple::GNUEABIHF || Env == llvm::Triple::GNUEABIHFT64 || - Env == llvm::Triple::MuslEABIHF || - Env == llvm::Triple::EABIHF; + Env == llvm::Triple::MuslEABIHF || Env == llvm::Triple::EABIHF; } /// Tests whether the target supports comdat @@ -1413,7 +1344,6 @@ class Triple { LLVM_ABI std::string computeDataLayout(StringRef ABIName = "") const; }; -} // End llvm namespace - +} // namespace llvm #endif diff --git a/llvm/lib/TargetParser/Triple.cpp b/llvm/lib/TargetParser/Triple.cpp index 7a907808c0f34..63dac93b30df8 100644 --- a/llvm/lib/TargetParser/Triple.cpp +++ b/llvm/lib/TargetParser/Triple.cpp @@ -23,71 +23,131 @@ using namespace llvm; StringRef Triple::getArchTypeName(ArchType Kind) { switch (Kind) { - case UnknownArch: return "unknown"; - - case aarch64: return "aarch64"; - case aarch64_32: return "aarch64_32"; - case aarch64_be: return "aarch64_be"; - case amdgcn: return "amdgcn"; - case amdil64: return "amdil64"; - case amdil: return "amdil"; - case arc: return "arc"; - case arm: return "arm"; - case armeb: return "armeb"; - case avr: return "avr"; - case bpfeb: return "bpfeb"; - case bpfel: return "bpfel"; - case csky: return "csky"; - case dxil: return "dxil"; - case hexagon: return "hexagon"; - case hsail64: return "hsail64"; - case hsail: return "hsail"; - case kalimba: return "kalimba"; - case lanai: return "lanai"; - case loongarch32: return "loongarch32"; - case loongarch64: return "loongarch64"; - case m68k: return "m68k"; - case mips64: return "mips64"; - case mips64el: return "mips64el"; - case mips: return "mips"; - case mipsel: return "mipsel"; - case msp430: return "msp430"; - case nvptx64: return "nvptx64"; - case nvptx: return "nvptx"; - case ppc64: return "powerpc64"; - case ppc64le: return "powerpc64le"; - case ppc: return "powerpc"; - case ppcle: return "powerpcle"; - case r600: return "r600"; - case renderscript32: return "renderscript32"; - case renderscript64: return "renderscript64"; - case riscv32: return "riscv32"; - case riscv64: return "riscv64"; + case UnknownArch: + return "unknown"; + + case aarch64: + return "aarch64"; + case aarch64_32: + return "aarch64_32"; + case aarch64_be: + return "aarch64_be"; + case amdgcn: + return "amdgcn"; + case amdil64: + return "amdil64"; + case amdil: + return "amdil"; + case arc: + return "arc"; + case arm: + return "arm"; + case armeb: + return "armeb"; + case avr: + return "avr"; + case bpfeb: + return "bpfeb"; + case bpfel: + return "bpfel"; + case csky: + return "csky"; + case dxil: + return "dxil"; + case hexagon: + return "hexagon"; + case hsail64: + return "hsail64"; + case hsail: + return "hsail"; + case kalimba: + return "kalimba"; + case lanai: + return "lanai"; + case loongarch32: + return "loongarch32"; + case loongarch64: + return "loongarch64"; + case m68k: + return "m68k"; + case mips64: + return "mips64"; + case mips64el: + return "mips64el"; + case mips: + return "mips"; + case mipsel: + return "mipsel"; + case msp430: + return "msp430"; + case nvptx64: + return "nvptx64"; + case nvptx: + return "nvptx"; + case ppc64: + return "powerpc64"; + case ppc64le: + return "powerpc64le"; + case ppc: + return "powerpc"; + case ppcle: + return "powerpcle"; + case r600: + return "r600"; + case renderscript32: + return "renderscript32"; + case renderscript64: + return "renderscript64"; + case riscv32: + return "riscv32"; + case riscv64: + return "riscv64"; case riscv32be: return "riscv32be"; case riscv64be: return "riscv64be"; - case shave: return "shave"; - case sparc: return "sparc"; - case sparcel: return "sparcel"; - case sparcv9: return "sparcv9"; - case spir64: return "spir64"; - case spir: return "spir"; - case spirv: return "spirv"; - case spirv32: return "spirv32"; - case spirv64: return "spirv64"; - case systemz: return "s390x"; - case tce: return "tce"; - case tcele: return "tcele"; - case thumb: return "thumb"; - case thumbeb: return "thumbeb"; - case ve: return "ve"; - case wasm32: return "wasm32"; - case wasm64: return "wasm64"; - case x86: return "i386"; - case x86_64: return "x86_64"; - case xcore: return "xcore"; - case xtensa: return "xtensa"; + case shave: + return "shave"; + case sparc: + return "sparc"; + case sparcel: + return "sparcel"; + case sparcv9: + return "sparcv9"; + case spir64: + return "spir64"; + case spir: + return "spir"; + case spirv: + return "spirv"; + case spirv32: + return "spirv32"; + case spirv64: + return "spirv64"; + case systemz: + return "s390x"; + case tce: + return "tce"; + case tcele: + return "tcele"; + case thumb: + return "thumb"; + case thumbeb: + return "thumbeb"; + case ve: + return "ve"; + case wasm32: + return "wasm32"; + case wasm64: + return "wasm64"; + case x86: + return "i386"; + case x86_64: + return "x86_64"; + case xcore: + return "xcore"; + case xtensa: + return "xtensa"; } llvm_unreachable("Invalid ArchType!"); @@ -179,70 +239,95 @@ StringRef Triple::getArchTypePrefix(ArchType Kind) { case aarch64: case aarch64_be: - case aarch64_32: return "aarch64"; + case aarch64_32: + return "aarch64"; - case arc: return "arc"; + case arc: + return "arc"; case arm: case armeb: case thumb: - case thumbeb: return "arm"; + case thumbeb: + return "arm"; - case avr: return "avr"; + case avr: + return "avr"; case ppc64: case ppc64le: case ppc: - case ppcle: return "ppc"; + case ppcle: + return "ppc"; - case m68k: return "m68k"; + case m68k: + return "m68k"; case mips: case mipsel: case mips64: - case mips64el: return "mips"; + case mips64el: + return "mips"; - case hexagon: return "hexagon"; + case hexagon: + return "hexagon"; - case amdgcn: return "amdgcn"; - case r600: return "r600"; + case amdgcn: + return "amdgcn"; + case r600: + return "r600"; case bpfel: - case bpfeb: return "bpf"; + case bpfeb: + return "bpf"; case sparcv9: case sparcel: - case sparc: return "sparc"; + case sparc: + return "sparc"; - case systemz: return "s390"; + case systemz: + return "s390"; case x86: - case x86_64: return "x86"; + case x86_64: + return "x86"; - case xcore: return "xcore"; + case xcore: + return "xcore"; // NVPTX intrinsics are namespaced under nvvm. - case nvptx: return "nvvm"; - case nvptx64: return "nvvm"; + case nvptx: + return "nvvm"; + case nvptx64: + return "nvvm"; case amdil: - case amdil64: return "amdil"; + case amdil64: + return "amdil"; case hsail: - case hsail64: return "hsail"; + case hsail64: + return "hsail"; case spir: - case spir64: return "spir"; + case spir64: + return "spir"; case spirv: case spirv32: - case spirv64: return "spv"; - - case kalimba: return "kalimba"; - case lanai: return "lanai"; - case shave: return "shave"; + case spirv64: + return "spv"; + + case kalimba: + return "kalimba"; + case lanai: + return "lanai"; + case shave: + return "shave"; case wasm32: - case wasm64: return "wasm"; + case wasm64: + return "wasm"; case riscv32: case riscv64: @@ -250,37 +335,56 @@ StringRef Triple::getArchTypePrefix(ArchType Kind) { case riscv64be: return "riscv"; - case ve: return "ve"; - case csky: return "csky"; + case ve: + return "ve"; + case csky: + return "csky"; case loongarch32: - case loongarch64: return "loongarch"; + case loongarch64: + return "loongarch"; - case dxil: return "dx"; + case dxil: + return "dx"; - case xtensa: return "xtensa"; + case xtensa: + return "xtensa"; } } StringRef Triple::getVendorTypeName(VendorType Kind) { switch (Kind) { - case UnknownVendor: return "unknown"; - - case AMD: return "amd"; - case Apple: return "apple"; - case CSR: return "csr"; - case Freescale: return "fsl"; - case IBM: return "ibm"; - case ImaginationTechnologies: return "img"; + case UnknownVendor: + return "unknown"; + + case AMD: + return "amd"; + case Apple: + return "apple"; + case CSR: + return "csr"; + case Freescale: + return "fsl"; + case IBM: + return "ibm"; + case ImaginationTechnologies: + return "img"; case Intel: return "intel"; - case Mesa: return "mesa"; - case MipsTechnologies: return "mti"; - case NVIDIA: return "nvidia"; - case OpenEmbedded: return "oe"; - case PC: return "pc"; - case SCEI: return "scei"; - case SUSE: return "suse"; + case Mesa: + return "mesa"; + case MipsTechnologies: + return "mti"; + case NVIDIA: + return "nvidia"; + case OpenEmbedded: + return "oe"; + case PC: + return "pc"; + case SCEI: + return "scei"; + case SUSE: + return "suse"; case Meta: return "meta"; } @@ -290,55 +394,95 @@ StringRef Triple::getVendorTypeName(VendorType Kind) { StringRef Triple::getOSTypeName(OSType Kind) { switch (Kind) { - case UnknownOS: return "unknown"; - - case AIX: return "aix"; - case AMDHSA: return "amdhsa"; - case AMDPAL: return "amdpal"; - case BridgeOS: return "bridgeos"; - case CUDA: return "cuda"; - case Darwin: return "darwin"; - case DragonFly: return "dragonfly"; - case DriverKit: return "driverkit"; - case ELFIAMCU: return "elfiamcu"; - case Emscripten: return "emscripten"; - case FreeBSD: return "freebsd"; - case Fuchsia: return "fuchsia"; - case Haiku: return "haiku"; - case HermitCore: return "hermit"; - case Hurd: return "hurd"; - case IOS: return "ios"; - case KFreeBSD: return "kfreebsd"; - case Linux: return "linux"; - case Lv2: return "lv2"; - case MacOSX: return "macosx"; + case UnknownOS: + return "unknown"; + + case AIX: + return "aix"; + case AMDHSA: + return "amdhsa"; + case AMDPAL: + return "amdpal"; + case BridgeOS: + return "bridgeos"; + case CUDA: + return "cuda"; + case Darwin: + return "darwin"; + case DragonFly: + return "dragonfly"; + case DriverKit: + return "driverkit"; + case ELFIAMCU: + return "elfiamcu"; + case Emscripten: + return "emscripten"; + case FreeBSD: + return "freebsd"; + case Fuchsia: + return "fuchsia"; + case Haiku: + return "haiku"; + case HermitCore: + return "hermit"; + case Hurd: + return "hurd"; + case IOS: + return "ios"; + case KFreeBSD: + return "kfreebsd"; + case Linux: + return "linux"; + case Lv2: + return "lv2"; + case MacOSX: + return "macosx"; case Managarm: return "managarm"; - case Mesa3D: return "mesa3d"; - case NVCL: return "nvcl"; - case NetBSD: return "netbsd"; - case OpenBSD: return "openbsd"; - case PS4: return "ps4"; - case PS5: return "ps5"; - case RTEMS: return "rtems"; - case Solaris: return "solaris"; - case Serenity: return "serenity"; - case TvOS: return "tvos"; - case UEFI: return "uefi"; - case WASI: return "wasi"; + case Mesa3D: + return "mesa3d"; + case NVCL: + return "nvcl"; + case NetBSD: + return "netbsd"; + case OpenBSD: + return "openbsd"; + case PS4: + return "ps4"; + case PS5: + return "ps5"; + case RTEMS: + return "rtems"; + case Solaris: + return "solaris"; + case Serenity: + return "serenity"; + case TvOS: + return "tvos"; + case UEFI: + return "uefi"; + case WASI: + return "wasi"; case WASIp1: return "wasip1"; case WASIp2: return "wasip2"; case WASIp3: return "wasip3"; - case WatchOS: return "watchos"; - case Win32: return "windows"; - case ZOS: return "zos"; - case ShaderModel: return "shadermodel"; - case LiteOS: return "liteos"; - case XROS: return "xros"; - case Vulkan: return "vulkan"; + case WatchOS: + return "watchos"; + case Win32: + return "windows"; + case ZOS: + return "zos"; + case ShaderModel: + return "shadermodel"; + case LiteOS: + return "liteos"; + case XROS: + return "xros"; + case Vulkan: + return "vulkan"; case CheriotRTOS: return "cheriotrtos"; case OpenCL: @@ -356,62 +500,106 @@ StringRef Triple::getOSTypeName(OSType Kind) { StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) { switch (Kind) { - case UnknownEnvironment: return "unknown"; - case Android: return "android"; - case CODE16: return "code16"; - case CoreCLR: return "coreclr"; - case Cygnus: return "cygnus"; - case EABI: return "eabi"; - case EABIHF: return "eabihf"; - case GNU: return "gnu"; - case GNUT64: return "gnut64"; - case GNUABI64: return "gnuabi64"; - case GNUABIN32: return "gnuabin32"; - case GNUEABI: return "gnueabi"; - case GNUEABIT64: return "gnueabit64"; - case GNUEABIHF: return "gnueabihf"; - case GNUEABIHFT64: return "gnueabihft64"; - case GNUF32: return "gnuf32"; - case GNUF64: return "gnuf64"; - case GNUSF: return "gnusf"; - case GNUX32: return "gnux32"; - case GNUILP32: return "gnu_ilp32"; - case Itanium: return "itanium"; - case MSVC: return "msvc"; - case MacABI: return "macabi"; - case Musl: return "musl"; + case UnknownEnvironment: + return "unknown"; + case Android: + return "android"; + case CODE16: + return "code16"; + case CoreCLR: + return "coreclr"; + case Cygnus: + return "cygnus"; + case EABI: + return "eabi"; + case EABIHF: + return "eabihf"; + case GNU: + return "gnu"; + case GNUT64: + return "gnut64"; + case GNUABI64: + return "gnuabi64"; + case GNUABIN32: + return "gnuabin32"; + case GNUEABI: + return "gnueabi"; + case GNUEABIT64: + return "gnueabit64"; + case GNUEABIHF: + return "gnueabihf"; + case GNUEABIHFT64: + return "gnueabihft64"; + case GNUF32: + return "gnuf32"; + case GNUF64: + return "gnuf64"; + case GNUSF: + return "gnusf"; + case GNUX32: + return "gnux32"; + case GNUILP32: + return "gnu_ilp32"; + case Itanium: + return "itanium"; + case MSVC: + return "msvc"; + case MacABI: + return "macabi"; + case Musl: + return "musl"; case MuslABIN32: return "muslabin32"; case MuslABI64: return "muslabi64"; - case MuslEABI: return "musleabi"; - case MuslEABIHF: return "musleabihf"; + case MuslEABI: + return "musleabi"; + case MuslEABIHF: + return "musleabihf"; case MuslF32: return "muslf32"; case MuslSF: return "muslsf"; - case MuslX32: return "muslx32"; + case MuslX32: + return "muslx32"; case MuslWALI: return "muslwali"; - case Simulator: return "simulator"; - case Pixel: return "pixel"; - case Vertex: return "vertex"; - case Geometry: return "geometry"; - case Hull: return "hull"; - case Domain: return "domain"; - case Compute: return "compute"; - case Library: return "library"; - case RayGeneration: return "raygeneration"; - case Intersection: return "intersection"; - case AnyHit: return "anyhit"; - case ClosestHit: return "closesthit"; - case Miss: return "miss"; - case Callable: return "callable"; - case Mesh: return "mesh"; - case Amplification: return "amplification"; + case Simulator: + return "simulator"; + case Pixel: + return "pixel"; + case Vertex: + return "vertex"; + case Geometry: + return "geometry"; + case Hull: + return "hull"; + case Domain: + return "domain"; + case Compute: + return "compute"; + case Library: + return "library"; + case RayGeneration: + return "raygeneration"; + case Intersection: + return "intersection"; + case AnyHit: + return "anyhit"; + case ClosestHit: + return "closesthit"; + case Miss: + return "miss"; + case Callable: + return "callable"; + case Mesh: + return "mesh"; + case Amplification: + return "amplification"; case RootSignature: return "rootsignature"; - case OpenHOS: return "ohos"; + case OpenHOS: + return "ohos"; case PAuthTest: return "pauthtest"; case MTIA: @@ -427,15 +615,24 @@ StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) { StringRef Triple::getObjectFormatTypeName(ObjectFormatType Kind) { switch (Kind) { - case UnknownObjectFormat: return ""; - case COFF: return "coff"; - case ELF: return "elf"; - case GOFF: return "goff"; - case MachO: return "macho"; - case Wasm: return "wasm"; - case XCOFF: return "xcoff"; - case DXContainer: return "dxcontainer"; - case SPIRV: return "spirv"; + case UnknownObjectFormat: + return ""; + case COFF: + return "coff"; + case ELF: + return "elf"; + case GOFF: + return "goff"; + case MachO: + return "macho"; + case Wasm: + return "wasm"; + case XCOFF: + return "xcoff"; + case DXContainer: + return "dxcontainer"; + case SPIRV: + return "spirv"; } llvm_unreachable("unknown object format type"); } @@ -886,13 +1083,13 @@ static Triple::SubArchType parseSubArch(StringRef SubArchName) { // For now, this is the small part. Early return. if (ARMSubArch.empty()) return StringSwitch<Triple::SubArchType>(SubArchName) - .EndsWith("kalimba3", Triple::KalimbaSubArch_v3) - .EndsWith("kalimba4", Triple::KalimbaSubArch_v4) - .EndsWith("kalimba5", Triple::KalimbaSubArch_v5) - .Default(Triple::NoSubArch); + .EndsWith("kalimba3", Triple::KalimbaSubArch_v3) + .EndsWith("kalimba4", Triple::KalimbaSubArch_v4) + .EndsWith("kalimba5", Triple::KalimbaSubArch_v5) + .Default(Triple::NoSubArch); // ARM sub arch. - switch(ARM::parseArch(ARMSubArch)) { + switch (ARM::parseArch(ARMSubArch)) { case ARM::ArchKind::ARMV4: return Triple::NoSubArch; case ARM::ArchKind::ARMV4T: @@ -1117,10 +1314,8 @@ Triple::Triple(const Twine &Str) : Triple(Str.str()) {} /// the string representation. Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr) : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()), - Arch(parseArch(ArchStr.str())), - SubArch(parseSubArch(ArchStr.str())), - Vendor(parseVendor(VendorStr.str())), - OS(parseOS(OSStr.str())), + Arch(parseArch(ArchStr.str())), SubArch(parseSubArch(ArchStr.str())), + Vendor(parseVendor(VendorStr.str())), OS(parseOS(OSStr.str())), Environment(), ObjectFormat(Triple::UnknownObjectFormat) { ObjectFormat = getDefaultFormat(*this); } @@ -1133,11 +1328,10 @@ Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr) Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr, const Twine &EnvironmentStr) : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') + - EnvironmentStr).str()), - Arch(parseArch(ArchStr.str())), - SubArch(parseSubArch(ArchStr.str())), - Vendor(parseVendor(VendorStr.str())), - OS(parseOS(OSStr.str())), + EnvironmentStr) + .str()), + Arch(parseArch(ArchStr.str())), SubArch(parseSubArch(ArchStr.str())), + Vendor(parseVendor(VendorStr.str())), OS(parseOS(OSStr.str())), Environment(parseEnvironment(EnvironmentStr.str())), ObjectFormat(parseFormat(EnvironmentStr.str())) { if (ObjectFormat == Triple::UnknownObjectFormat) @@ -1250,7 +1444,8 @@ std::string Triple::normalize(StringRef Str, CanonicalForm Form) { bool Valid = false; StringRef Comp = Components[Idx]; switch (Pos) { - default: llvm_unreachable("unexpected component type!"); + default: + llvm_unreachable("unexpected component type!"); case 0: Arch = parseArch(Comp); Valid = Arch != UnknownArch; @@ -1424,7 +1619,7 @@ std::string Triple::normalize(StringRef Str, CanonicalForm Form) { } StringRef Triple::getArchName() const { - return StringRef(Data).split('-').first; // Isolate first component + return StringRef(Data).split('-').first; // Isolate first component } StringRef Triple::getVendorName() const { @@ -1500,7 +1695,8 @@ bool Triple::getMacOSXVersion(VersionTuple &Version) const { Version = getOSVersion(); switch (getOS()) { - default: llvm_unreachable("unexpected OS for Darwin triple"); + default: + llvm_unreachable("unexpected OS for Darwin triple"); case Darwin: // Default to darwin8, i.e., MacOSX 10.4. if (Version.getMajor() == 0) @@ -1548,7 +1744,8 @@ bool Triple::getMacOSXVersion(VersionTuple &Version) const { VersionTuple Triple::getiOSVersion() const { switch (getOS()) { - default: llvm_unreachable("unexpected OS for Darwin triple"); + default: + llvm_unreachable("unexpected OS for Darwin triple"); case Darwin: case MacOSX: // Ignore the version from the triple. This is only handled because the @@ -1599,7 +1796,8 @@ VersionTuple Triple::getiOSVersion() const { VersionTuple Triple::getWatchOSVersion() const { switch (getOS()) { - default: llvm_unreachable("unexpected OS for Darwin triple"); + default: + llvm_unreachable("unexpected OS for Darwin triple"); case Darwin: case MacOSX: // Ignore the version from the triple. This is only handled because the @@ -1674,9 +1872,7 @@ VersionTuple Triple::getDXILVersion() const { return DXILVersion; } -void Triple::setTriple(const Twine &Str) { - *this = Triple(Str); -} +void Triple::setTriple(const Twine &Str) { *this = Triple(Str); } void Triple::setArch(ArchType Kind, SubArchType SubArch) { setArchName(getArchName(Kind, SubArch)); @@ -1686,16 +1882,15 @@ void Triple::setVendor(VendorType Kind) { setVendorName(getVendorTypeName(Kind)); } -void Triple::setOS(OSType Kind) { - setOSName(getOSTypeName(Kind)); -} +void Triple::setOS(OSType Kind) { setOSName(getOSTypeName(Kind)); } void Triple::setEnvironment(EnvironmentType Kind) { if (ObjectFormat == getDefaultFormat(*this)) return setEnvironmentName(getEnvironmentTypeName(Kind)); setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") + - getObjectFormatTypeName(ObjectFormat)).str()); + getObjectFormatTypeName(ObjectFormat)) + .str()); } void Triple::setObjectFormat(ObjectFormatType Kind) { @@ -1703,7 +1898,8 @@ void Triple::setObjectFormat(ObjectFormatType Kind) { return setEnvironmentName(getObjectFormatTypeName(Kind)); setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") + - getObjectFormatTypeName(Kind)).str()); + getObjectFormatTypeName(Kind)) + .str()); } void Triple::setArchName(StringRef Str) { @@ -1716,15 +1912,15 @@ void Triple::setVendorName(StringRef Str) { void Triple::setOSName(StringRef Str) { if (hasEnvironment()) - setTriple(getArchName() + "-" + getVendorName() + "-" + Str + - "-" + getEnvironmentName()); + setTriple(getArchName() + "-" + getVendorName() + "-" + Str + "-" + + getEnvironmentName()); else setTriple(getArchName() + "-" + getVendorName() + "-" + Str); } void Triple::setEnvironmentName(StringRef Str) { - setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() + - "-" + Str); + setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() + "-" + + Str); } void Triple::setOSAndEnvironmentName(StringRef Str) { @@ -1888,33 +2084,61 @@ Triple Triple::get32BitArchVariant() const { // Already 32-bit. break; - case Triple::aarch64: T.setArch(Triple::arm); break; - case Triple::aarch64_be: T.setArch(Triple::armeb); break; - case Triple::amdil64: T.setArch(Triple::amdil); break; - case Triple::hsail64: T.setArch(Triple::hsail); break; - case Triple::loongarch64: T.setArch(Triple::loongarch32); break; + case Triple::aarch64: + T.setArch(Triple::arm); + break; + case Triple::aarch64_be: + T.setArch(Triple::armeb); + break; + case Triple::amdil64: + T.setArch(Triple::amdil); + break; + case Triple::hsail64: + T.setArch(Triple::hsail); + break; + case Triple::loongarch64: + T.setArch(Triple::loongarch32); + break; case Triple::mips64: T.setArch(Triple::mips, getSubArch()); break; case Triple::mips64el: T.setArch(Triple::mipsel, getSubArch()); break; - case Triple::nvptx64: T.setArch(Triple::nvptx); break; - case Triple::ppc64: T.setArch(Triple::ppc); break; - case Triple::ppc64le: T.setArch(Triple::ppcle); break; - case Triple::renderscript64: T.setArch(Triple::renderscript32); break; - case Triple::riscv64: T.setArch(Triple::riscv32); break; + case Triple::nvptx64: + T.setArch(Triple::nvptx); + break; + case Triple::ppc64: + T.setArch(Triple::ppc); + break; + case Triple::ppc64le: + T.setArch(Triple::ppcle); + break; + case Triple::renderscript64: + T.setArch(Triple::renderscript32); + break; + case Triple::riscv64: + T.setArch(Triple::riscv32); + break; case Triple::riscv64be: T.setArch(Triple::riscv32be); break; - case Triple::sparcv9: T.setArch(Triple::sparc); break; - case Triple::spir64: T.setArch(Triple::spir); break; + case Triple::sparcv9: + T.setArch(Triple::sparc); + break; + case Triple::spir64: + T.setArch(Triple::spir); + break; case Triple::spirv: case Triple::spirv64: T.setArch(Triple::spirv32, getSubArch()); break; - case Triple::wasm64: T.setArch(Triple::wasm32); break; - case Triple::x86_64: T.setArch(Triple::x86); break; + case Triple::wasm64: + T.setArch(Triple::wasm32); + break; + case Triple::x86_64: + T.setArch(Triple::x86); + break; } return T; } @@ -1968,36 +2192,70 @@ Triple Triple::get64BitArchVariant() const { // Already 64-bit. break; - case Triple::aarch64_32: T.setArch(Triple::aarch64); break; - case Triple::amdil: T.setArch(Triple::amdil64); break; - case Triple::arm: T.setArch(Triple::aarch64); break; - case Triple::armeb: T.setArch(Triple::aarch64_be); break; - case Triple::hsail: T.setArch(Triple::hsail64); break; - case Triple::loongarch32: T.setArch(Triple::loongarch64); break; + case Triple::aarch64_32: + T.setArch(Triple::aarch64); + break; + case Triple::amdil: + T.setArch(Triple::amdil64); + break; + case Triple::arm: + T.setArch(Triple::aarch64); + break; + case Triple::armeb: + T.setArch(Triple::aarch64_be); + break; + case Triple::hsail: + T.setArch(Triple::hsail64); + break; + case Triple::loongarch32: + T.setArch(Triple::loongarch64); + break; case Triple::mips: T.setArch(Triple::mips64, getSubArch()); break; case Triple::mipsel: T.setArch(Triple::mips64el, getSubArch()); break; - case Triple::nvptx: T.setArch(Triple::nvptx64); break; - case Triple::ppc: T.setArch(Triple::ppc64); break; - case Triple::ppcle: T.setArch(Triple::ppc64le); break; - case Triple::renderscript32: T.setArch(Triple::renderscript64); break; - case Triple::riscv32: T.setArch(Triple::riscv64); break; + case Triple::nvptx: + T.setArch(Triple::nvptx64); + break; + case Triple::ppc: + T.setArch(Triple::ppc64); + break; + case Triple::ppcle: + T.setArch(Triple::ppc64le); + break; + case Triple::renderscript32: + T.setArch(Triple::renderscript64); + break; + case Triple::riscv32: + T.setArch(Triple::riscv64); + break; case Triple::riscv32be: T.setArch(Triple::riscv64be); break; - case Triple::sparc: T.setArch(Triple::sparcv9); break; - case Triple::spir: T.setArch(Triple::spir64); break; + case Triple::sparc: + T.setArch(Triple::sparcv9); + break; + case Triple::spir: + T.setArch(Triple::spir64); + break; case Triple::spirv: case Triple::spirv32: T.setArch(Triple::spirv64, getSubArch()); break; - case Triple::thumb: T.setArch(Triple::aarch64); break; - case Triple::thumbeb: T.setArch(Triple::aarch64_be); break; - case Triple::wasm32: T.setArch(Triple::wasm64); break; - case Triple::x86: T.setArch(Triple::x86_64); break; + case Triple::thumb: + T.setArch(Triple::aarch64); + break; + case Triple::thumbeb: + T.setArch(Triple::aarch64_be); + break; + case Triple::wasm32: + T.setArch(Triple::wasm64); + break; + case Triple::x86: + T.setArch(Triple::x86_64); + break; } return T; } @@ -2048,24 +2306,36 @@ Triple Triple::getBigEndianArchVariant() const { T.setArch(UnknownArch); break; - case Triple::aarch64: T.setArch(Triple::aarch64_be); break; - case Triple::bpfel: T.setArch(Triple::bpfeb); break; + case Triple::aarch64: + T.setArch(Triple::aarch64_be); + break; + case Triple::bpfel: + T.setArch(Triple::bpfeb); + break; case Triple::mips64el: T.setArch(Triple::mips64, getSubArch()); break; case Triple::mipsel: T.setArch(Triple::mips, getSubArch()); break; - case Triple::ppcle: T.setArch(Triple::ppc); break; - case Triple::ppc64le: T.setArch(Triple::ppc64); break; + case Triple::ppcle: + T.setArch(Triple::ppc); + break; + case Triple::ppc64le: + T.setArch(Triple::ppc64); + break; case Triple::riscv32: T.setArch(Triple::riscv32be); break; case Triple::riscv64: T.setArch(Triple::riscv64be); break; - case Triple::sparcel: T.setArch(Triple::sparc); break; - case Triple::tcele: T.setArch(Triple::tce); break; + case Triple::sparcel: + T.setArch(Triple::sparc); + break; + case Triple::tcele: + T.setArch(Triple::tce); + break; default: llvm_unreachable("getBigEndianArchVariant: unknown triple."); } @@ -2091,24 +2361,36 @@ Triple Triple::getLittleEndianArchVariant() const { T.setArch(UnknownArch); break; - case Triple::aarch64_be: T.setArch(Triple::aarch64); break; - case Triple::bpfeb: T.setArch(Triple::bpfel); break; + case Triple::aarch64_be: + T.setArch(Triple::aarch64); + break; + case Triple::bpfeb: + T.setArch(Triple::bpfel); + break; case Triple::mips64: T.setArch(Triple::mips64el, getSubArch()); break; case Triple::mips: T.setArch(Triple::mipsel, getSubArch()); break; - case Triple::ppc: T.setArch(Triple::ppcle); break; - case Triple::ppc64: T.setArch(Triple::ppc64le); break; + case Triple::ppc: + T.setArch(Triple::ppcle); + break; + case Triple::ppc64: + T.setArch(Triple::ppc64le); + break; case Triple::riscv32be: T.setArch(Triple::riscv32); break; case Triple::riscv64be: T.setArch(Triple::riscv64); break; - case Triple::sparc: T.setArch(Triple::sparcel); break; - case Triple::tce: T.setArch(Triple::tcele); break; + case Triple::sparc: + T.setArch(Triple::sparcel); + break; + case Triple::tce: + T.setArch(Triple::tcele); + break; default: llvm_unreachable("getLittleEndianArchVariant: unknown triple."); } @@ -2412,8 +2694,7 @@ static_assert(Triple::Vertex - Triple::Pixel == 1, "incorrect HLSL stage order"); static_assert(Triple::Geometry - Triple::Pixel == 2, "incorrect HLSL stage order"); -static_assert(Triple::Hull - Triple::Pixel == 3, - "incorrect HLSL stage order"); +static_assert(Triple::Hull - Triple::Pixel == 3, "incorrect HLSL stage order"); static_assert(Triple::Domain - Triple::Pixel == 4, "incorrect HLSL stage order"); static_assert(Triple::Compute - Triple::Pixel == 5, @@ -2428,11 +2709,9 @@ static_assert(Triple::AnyHit - Triple::Pixel == 9, "incorrect HLSL stage order"); static_assert(Triple::ClosestHit - Triple::Pixel == 10, "incorrect HLSL stage order"); -static_assert(Triple::Miss - Triple::Pixel == 11, - "incorrect HLSL stage order"); +static_assert(Triple::Miss - Triple::Pixel == 11, "incorrect HLSL stage order"); static_assert(Triple::Callable - Triple::Pixel == 12, "incorrect HLSL stage order"); -static_assert(Triple::Mesh - Triple::Pixel == 13, - "incorrect HLSL stage order"); +static_assert(Triple::Mesh - Triple::Pixel == 13, "incorrect HLSL stage order"); static_assert(Triple::Amplification - Triple::Pixel == 14, "incorrect HLSL stage order"); >From 732f4a03b459ebcc03fb2317e1358809a3a1c593 Mon Sep 17 00:00:00 2001 From: Jonathan Schleifer <[email protected]> Date: Tue, 14 Apr 2026 00:18:28 -0500 Subject: [PATCH 2/2] Add support for MorphOS - Adds a MorphOS target - Adds toolchain for MorphOS - Adds -noixemul flag for MorphOS --- clang/include/clang/Basic/LangOptions.def | 2 + clang/include/clang/Options/Options.td | 7 + clang/lib/Basic/Targets.cpp | 2 + clang/lib/Basic/Targets/OSTargets.h | 32 ++++ clang/lib/Driver/CMakeLists.txt | 1 + clang/lib/Driver/Driver.cpp | 4 + clang/lib/Driver/ToolChains/Clang.cpp | 10 + clang/lib/Driver/ToolChains/MorphOS.cpp | 214 ++++++++++++++++++++++ clang/lib/Driver/ToolChains/MorphOS.h | 83 +++++++++ llvm/include/llvm/TargetParser/Triple.h | 3 + llvm/lib/TargetParser/Triple.cpp | 3 + 11 files changed, 361 insertions(+) create mode 100644 clang/lib/Driver/ToolChains/MorphOS.cpp create mode 100644 clang/lib/Driver/ToolChains/MorphOS.h diff --git a/clang/include/clang/Basic/LangOptions.def b/clang/include/clang/Basic/LangOptions.def index 6bba142aaf428..a63eac0b5c0c4 100644 --- a/clang/include/clang/Basic/LangOptions.def +++ b/clang/include/clang/Basic/LangOptions.def @@ -530,6 +530,8 @@ LANGOPT(EnableLifetimeSafetyTUAnalysis, 1, 0, NotCompatible, "Lifetime safety at LANGOPT(PreserveVec3Type, 1, 0, NotCompatible, "Preserve 3-component vector type") LANGOPT(Reflection , 1, 0, NotCompatible, "C++26 Reflection") +LANGOPT(NoIxemul, 1, 0, NotCompatible, "Do not use ixemul on MorphOS") + #undef LANGOPT #undef ENUM_LANGOPT #undef VALUE_LANGOPT diff --git a/clang/include/clang/Options/Options.td b/clang/include/clang/Options/Options.td index 5d2741e7e30e5..1d31532e5e204 100644 --- a/clang/include/clang/Options/Options.td +++ b/clang/include/clang/Options/Options.td @@ -10100,3 +10100,10 @@ def wasm_opt : Flag<["--"], "wasm-opt">, Group<m_Group>, HelpText<"Enable the wasm-opt optimizer (default)">, MarshallingInfoNegativeFlag<LangOpts<"NoWasmOpt">>; + +// Unfortunate naming to keep compatibility with GCC. +defm noixemul : BoolOption<"", "noixemul", + LangOpts<"NoIxemul">, DefaultFalse, + PosFlag<SetTrue, [], [ClangOption], "Do not use ixemul on MorphOS">, + NegFlag<SetFalse>, + BothFlags<[], [ClangOption, CC1Option]>>; diff --git a/clang/lib/Basic/Targets.cpp b/clang/lib/Basic/Targets.cpp index dc6ef6ed8f3f8..1eeafa71fdcd7 100644 --- a/clang/lib/Basic/Targets.cpp +++ b/clang/lib/Basic/Targets.cpp @@ -368,6 +368,8 @@ std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple, return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts); case llvm::Triple::FreeBSD: return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts); + case llvm::Triple::MorphOS: + return std::make_unique<MorphOSTargetInfo<PPC32TargetInfo>>(Triple, Opts); case llvm::Triple::NetBSD: return std::make_unique<NetBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts); case llvm::Triple::OpenBSD: diff --git a/clang/lib/Basic/Targets/OSTargets.h b/clang/lib/Basic/Targets/OSTargets.h index 16337d56f82c3..aee7f0fca3526 100644 --- a/clang/lib/Basic/Targets/OSTargets.h +++ b/clang/lib/Basic/Targets/OSTargets.h @@ -447,6 +447,38 @@ class LLVM_LIBRARY_VISIBILITY ManagarmTargetInfo : public OSTargetInfo<Target> { } }; +// MorphOS Target +template <typename Target> +class LLVM_LIBRARY_VISIBILITY MorphOSTargetInfo : public OSTargetInfo<Target> { +protected: + void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, + MacroBuilder &Builder) const override { + // MorphOS defines; list based off of gcc output + Builder.defineMacro("__MORPHOS__"); + Builder.defineMacro("__morphos__"); + Builder.defineMacro("__AMIGA__"); + Builder.defineMacro("__AMIGA"); + Builder.defineMacro("_AMIGA"); + Builder.defineMacro("AMIGA"); + Builder.defineMacro("__amigaos__"); + Builder.defineMacro("__amigaos"); + Builder.defineMacro("amigaos"); + if (Opts.NoIxemul) { + Builder.defineMacro("__libnix__"); + Builder.defineMacro("__libnix"); + Builder.defineMacro("libnix"); + } else { + Builder.defineMacro("__ixemul__"); + Builder.defineMacro("__ixemul"); + Builder.defineMacro("ixemul"); + } + } + +public: + MorphOSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) + : OSTargetInfo<Target>(Triple, Opts) {} +}; + // NetBSD Target template <typename Target> class LLVM_LIBRARY_VISIBILITY NetBSDTargetInfo : public OSTargetInfo<Target> { diff --git a/clang/lib/Driver/CMakeLists.txt b/clang/lib/Driver/CMakeLists.txt index b8b10b351633f..cb09669d0a1a8 100644 --- a/clang/lib/Driver/CMakeLists.txt +++ b/clang/lib/Driver/CMakeLists.txt @@ -80,6 +80,7 @@ add_clang_library(clangDriver ToolChains/Managarm.cpp ToolChains/MipsLinux.cpp ToolChains/MinGW.cpp + ToolChains/MorphOS.cpp ToolChains/MSP430.cpp ToolChains/MSVC.cpp ToolChains/NetBSD.cpp diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp index 39d2ad1f1c8c0..87a83a0fff588 100644 --- a/clang/lib/Driver/Driver.cpp +++ b/clang/lib/Driver/Driver.cpp @@ -37,6 +37,7 @@ #include "ToolChains/Managarm.h" #include "ToolChains/MinGW.h" #include "ToolChains/MipsLinux.h" +#include "ToolChains/MorphOS.h" #include "ToolChains/NetBSD.h" #include "ToolChains/OHOS.h" #include "ToolChains/OpenBSD.h" @@ -7152,6 +7153,9 @@ const ToolChain &Driver::getToolChain(const ArgList &Args, case llvm::Triple::ChipStar: TC = std::make_unique<toolchains::HIPSPVToolChain>(*this, Target, Args); break; + case llvm::Triple::MorphOS: + TC = std::make_unique<toolchains::MorphOS>(*this, Target, Args); + break; default: // Of these targets, Hexagon is the only one that might have // an OS of Linux, in which case it got handled above already. diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index f685abe9dad35..fd0376e651c4e 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -8071,6 +8071,16 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, addOpenMPHostOffloadingArgs(C, JA, Args, CmdArgs); + if (TC.getTriple().isOSMorphOS()) { + Args.AddLastArg(CmdArgs, options::OPT_noixemul); + } else { + // Reject MorphOS-specific link options on other targets. + for (const Arg *A : Args.filtered(options::OPT_noixemul)) { + D.Diag(diag::err_drv_unsupported_opt_for_target) + << A->getSpelling() << TripleStr; + } + } + if (Args.hasFlag(options::OPT_fdevirtualize_speculatively, options::OPT_fno_devirtualize_speculatively, /*Default value*/ false)) diff --git a/clang/lib/Driver/ToolChains/MorphOS.cpp b/clang/lib/Driver/ToolChains/MorphOS.cpp new file mode 100644 index 0000000000000..21fd12fc33649 --- /dev/null +++ b/clang/lib/Driver/ToolChains/MorphOS.cpp @@ -0,0 +1,214 @@ +//===--- MorphOS.cpp - MorphOS ToolChain Implementations --------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "MorphOS.h" +#include "clang/Config/config.h" +#include "clang/Driver/CommonArgs.h" +#include "clang/Driver/Compilation.h" +#include "clang/Driver/Driver.h" +#include "clang/Driver/SanitizerArgs.h" +#include "clang/Options/Options.h" +#include "llvm/Option/ArgList.h" +#include "llvm/Support/VirtualFileSystem.h" + +using namespace clang::driver; +using namespace clang::driver::tools; +using namespace clang::driver::toolchains; +using namespace clang; +using namespace llvm::opt; + +void morphos::Assembler::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { + const auto &ToolChain = static_cast<const MorphOS &>(getToolChain()); + ArgStringList CmdArgs; + + claimNoWarnArgs(Args); + + Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); + + CmdArgs.push_back("-o"); + CmdArgs.push_back(Output.getFilename()); + + for (const auto &II : Inputs) + CmdArgs.push_back(II.getFilename()); + + const char *Exec = Args.MakeArgString((ToolChain.GetProgramPath("as"))); + C.addCommand(std::make_unique<Command>(JA, *this, + ResponseFileSupport::AtFileCurCP(), + Exec, CmdArgs, Inputs, Output)); +} + +void morphos::Linker::ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, + const InputInfoList &Inputs, + const ArgList &Args, + const char *LinkingOutput) const { + const auto &ToolChain = static_cast<const MorphOS &>(getToolChain()); + const Driver &D = ToolChain.getDriver(); + ArgStringList CmdArgs; + // FIXME: Discover GCC instead of hard-coding the version. + const std::string GCCLibPath = D.SysRoot + "/lib/gcc-lib/ppc-morphos/15.1.0"; + const bool NoIxemul = Args.hasArg(options::OPT_noixemul); + + if (!D.SysRoot.empty()) + CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); + + CmdArgs.push_back("--defsym"); + CmdArgs.push_back("__abox__=1"); + CmdArgs.push_back("-Qy"); + + CmdArgs.push_back("-Bstatic"); + if (NoIxemul) { + Args.ClaimAllArgs(options::OPT_noixemul); + CmdArgs.push_back("--flavor=libnix"); + } else { + CmdArgs.push_back("--flavor=ixemul"); + } + + assert((Output.isFilename() || Output.isNothing()) && "Invalid output."); + if (Output.isFilename()) { + CmdArgs.push_back("-o"); + CmdArgs.push_back(Output.getFilename()); + } + + if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles, + options::OPT_r)) { + if (NoIxemul) { + CmdArgs.push_back(Args.MakeArgString( + GCCLibPath + "/../../../../ppc-morphos/lib/libnix/crt0i.o")); + CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "/libnix/ecrti.o")); + CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "/libnix/crtbegin.o")); + } else { + CmdArgs.push_back(Args.MakeArgString( + GCCLibPath + "/../../../../ppc-morphos/lib/crt0i.o")); + CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "/ecrti.o")); + CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "/crtbegin.o")); + } + } + + CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath)); + CmdArgs.push_back( + Args.MakeArgString("-L" + GCCLibPath + "/../../../../ppc-morphos/lib")); + CmdArgs.push_back(Args.MakeArgString("-L" + D.SysRoot + "/lib")); + + Args.addAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group, + options::OPT_s, options::OPT_t}); + ToolChain.AddFilePathLibArgs(Args, CmdArgs); + + AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA); + + if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs, + options::OPT_r)) { + if (D.CCCIsCXX()) { + if (ToolChain.ShouldLinkCXXStdlib(Args)) + ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); + CmdArgs.push_back("-lm"); + } + + // Silence warnings when linking C code with a C++ '-stdlib' argument. + Args.ClaimAllArgs(options::OPT_stdlib_EQ); + + CmdArgs.push_back("--start-group"); + CmdArgs.push_back("-lc"); + CmdArgs.push_back("-lgcc"); + CmdArgs.push_back("-labox"); + CmdArgs.push_back("-laboxstubs"); + CmdArgs.push_back("-lsavl"); + CmdArgs.push_back("--end-group"); + } + + if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles, + options::OPT_r)) { + if (NoIxemul) { + CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "/libnix/crtend.o")); + CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "/libnix/ecrtn.o")); + } else { + CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "/crtend.o")); + CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "/ecrtn.o")); + } + } + + const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath()); + C.addCommand(std::make_unique<Command>(JA, *this, + ResponseFileSupport::AtFileCurCP(), + Exec, CmdArgs, Inputs, Output)); +} + +/// MorphOS - MorphOS tool chain which can call as(1) and ld(1) directly. + +MorphOS::MorphOS(const Driver &D, const llvm::Triple &Triple, + const ArgList &Args) + : Generic_ELF(D, Triple, Args) { + if (!Args.hasArg(options::OPT_nostdlib)) { + getFilePaths().push_back(concat(getDriver().SysRoot, "/ppc-morphos/lib")); + } +} + +Tool *MorphOS::buildAssembler() const { + return new tools::morphos::Assembler(*this); +} + +Tool *MorphOS::buildLinker() const { return new tools::morphos::Linker(*this); } + +ToolChain::CXXStdlibType MorphOS::GetDefaultCXXStdlibType() const { + return ToolChain::CST_Libstdcxx; +} + +void MorphOS::AddClangSystemIncludeArgs( + const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const { + const Driver &D = getDriver(); + + if (DriverArgs.hasArg(options::OPT_nostdinc)) + return; + + if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { + SmallString<128> Dir(D.ResourceDir); + llvm::sys::path::append(Dir, "include"); + addSystemInclude(DriverArgs, CC1Args, Dir.str()); + } + + if (DriverArgs.hasArg(options::OPT_nostdlibinc)) + return; + + // Check for configure-time C include directories. + StringRef CIncludeDirs(C_INCLUDE_DIRS); + if (CIncludeDirs != "") { + SmallVector<StringRef, 5> dirs; + CIncludeDirs.split(dirs, ":"); + for (StringRef dir : dirs) { + StringRef Prefix = + llvm::sys::path::is_absolute(dir) ? StringRef(D.SysRoot) : ""; + addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir); + } + return; + } + + if (DriverArgs.hasArg(options::OPT_noixemul)) { + addExternCSystemInclude(DriverArgs, CC1Args, + concat(D.SysRoot, "/includestd")); + } + addExternCSystemInclude(DriverArgs, CC1Args, concat(D.SysRoot, "/include")); + addExternCSystemInclude(DriverArgs, CC1Args, + concat(D.SysRoot, "/usr/include")); + addExternCSystemInclude(DriverArgs, CC1Args, + concat(D.SysRoot, "/os-include")); +} + +void MorphOS::addLibStdCxxIncludePaths( + const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const { + // FIXME: Discover GCC instead of hard-coding the version. + addLibStdCXXIncludePaths( + concat(getDriver().SysRoot, + "/lib/gcc-lib/ppc-morphos/15.1.0/include/c++"), + "", "", DriverArgs, CC1Args); +} diff --git a/clang/lib/Driver/ToolChains/MorphOS.h b/clang/lib/Driver/ToolChains/MorphOS.h new file mode 100644 index 0000000000000..c58488ac36104 --- /dev/null +++ b/clang/lib/Driver/ToolChains/MorphOS.h @@ -0,0 +1,83 @@ +//===--- MorphOS.h - MorphOS ToolChain Implementations ----------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_MORPHOS_H +#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_MORPHOS_H + +#include "Gnu.h" +#include "clang/Driver/Tool.h" +#include "clang/Driver/ToolChain.h" + +namespace clang { +namespace driver { +namespace tools { + +/// Directly call GNU Binutils assembler and linker +namespace morphos { +class LLVM_LIBRARY_VISIBILITY Assembler final : public Tool { +public: + Assembler(const ToolChain &TC) + : Tool("morphos::Assembler", "assembler", TC) {} + + bool hasIntegratedCPP() const override { return false; } + + void ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, const InputInfoList &Inputs, + const llvm::opt::ArgList &TCArgs, + const char *LinkingOutput) const override; +}; + +class LLVM_LIBRARY_VISIBILITY Linker final : public Tool { +public: + Linker(const ToolChain &TC) : Tool("morphos::Linker", "linker", TC) {} + + bool hasIntegratedCPP() const override { return false; } + bool isLinkJob() const override { return true; } + + void ConstructJob(Compilation &C, const JobAction &JA, + const InputInfo &Output, const InputInfoList &Inputs, + const llvm::opt::ArgList &TCArgs, + const char *LinkingOutput) const override; +}; +} // end namespace morphos +} // end namespace tools + +namespace toolchains { + +class LLVM_LIBRARY_VISIBILITY MorphOS : public Generic_ELF { +public: + MorphOS(const Driver &D, const llvm::Triple &Triple, + const llvm::opt::ArgList &Args); + + bool IsMathErrnoDefault() const override { return false; } + bool IsObjCNonFragileABIDefault() const override { return true; } + + CXXStdlibType GetDefaultCXXStdlibType() const override; + + void + AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; + void + addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; + + UnwindTableLevel + getDefaultUnwindTableLevel(const llvm::opt::ArgList &Args) const override { + return UnwindTableLevel::Asynchronous; + } + +protected: + Tool *buildAssembler() const override; + Tool *buildLinker() const override; +}; + +} // end namespace toolchains +} // end namespace driver +} // end namespace clang + +#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_MORPHOS_H diff --git a/llvm/include/llvm/TargetParser/Triple.h b/llvm/include/llvm/TargetParser/Triple.h index fb4aaaa067ae9..e06cd373aebda 100644 --- a/llvm/include/llvm/TargetParser/Triple.h +++ b/llvm/include/llvm/TargetParser/Triple.h @@ -256,6 +256,7 @@ class Triple { ChipStar, Firmware, QURT, + MorphOS, LastOSType = QURT }; enum EnvironmentType { @@ -666,6 +667,8 @@ class Triple { bool isOSIAMCU() const { return getOS() == Triple::ELFIAMCU; } + bool isOSMorphOS() const { return getOS() == Triple::MorphOS; } + bool isOSUnknown() const { return getOS() == Triple::UnknownOS; } bool isGNUEnvironment() const { diff --git a/llvm/lib/TargetParser/Triple.cpp b/llvm/lib/TargetParser/Triple.cpp index 63dac93b30df8..1715da842c516 100644 --- a/llvm/lib/TargetParser/Triple.cpp +++ b/llvm/lib/TargetParser/Triple.cpp @@ -441,6 +441,8 @@ StringRef Triple::getOSTypeName(OSType Kind) { return "managarm"; case Mesa3D: return "mesa3d"; + case MorphOS: + return "morphos"; case NVCL: return "nvcl"; case NetBSD: @@ -921,6 +923,7 @@ static Triple::OSType parseOS(StringRef OSName) { .StartsWith("lv2", Triple::Lv2) .StartsWith("macos", Triple::MacOSX) .StartsWith("managarm", Triple::Managarm) + .StartsWith("morphos", Triple::MorphOS) .StartsWith("netbsd", Triple::NetBSD) .StartsWith("openbsd", Triple::OpenBSD) .StartsWith("solaris", Triple::Solaris) _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
