[clang] [llvm] Add support for MorphOS (PR #191951)
Jonathan Schleifer via cfe-commits
cfe-commits at lists.llvm.org
Tue Apr 14 06:31:36 PDT 2026
https://github.com/Midar updated https://github.com/llvm/llvm-project/pull/191951
>From 69ca832faff909f86491fb58868e551b23c4d817 Mon Sep 17 00:00:00 2001
From: Jonathan Schleifer <js at nil.im>
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 79381d8e510dd3f512c532144fddfe5f3e4aafa6 Mon Sep 17 00:00:00 2001
From: Jonathan Schleifer <js at nil.im>
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)
More information about the cfe-commits
mailing list