https://github.com/no92 created https://github.com/llvm/llvm-project/pull/87845
This PR aims to add a target for [managarm](https://github.com/managarm/managarm). The targets `{x86_64,aarch64,riscv64}-pc-managarm-{kernel,system}` are enabled by this PR and have been tested to work on managarm. >From 09288d0ab62d6ca13bd5dea4cfa5d78e67901e89 Mon Sep 17 00:00:00 2001 From: no92 <no92.m...@gmail.com> Date: Tue, 2 Apr 2024 18:24:04 +0200 Subject: [PATCH] [llvm] Add triples for managarm --- clang/lib/Basic/Targets.cpp | 9 + clang/lib/Basic/Targets/OSTargets.h | 30 +++ clang/lib/Driver/CMakeLists.txt | 1 + clang/lib/Driver/Driver.cpp | 4 + clang/lib/Driver/ToolChains/Gnu.cpp | 13 +- clang/lib/Driver/ToolChains/Managarm.cpp | 230 +++++++++++++++++++++ clang/lib/Driver/ToolChains/Managarm.h | 54 +++++ llvm/include/llvm/ADT/bit.h | 2 +- llvm/include/llvm/TargetParser/Triple.h | 5 +- llvm/lib/Support/Unix/Path.inc | 13 +- llvm/lib/TargetParser/Triple.cpp | 6 + llvm/unittests/TargetParser/TripleTest.cpp | 24 +++ 12 files changed, 381 insertions(+), 10 deletions(-) create mode 100644 clang/lib/Driver/ToolChains/Managarm.cpp create mode 100644 clang/lib/Driver/ToolChains/Managarm.h diff --git a/clang/lib/Basic/Targets.cpp b/clang/lib/Basic/Targets.cpp index e3283510c6aac7..356b1888aca80d 100644 --- a/clang/lib/Basic/Targets.cpp +++ b/clang/lib/Basic/Targets.cpp @@ -160,6 +160,9 @@ std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple, return std::make_unique<OHOSTargetInfo<AArch64leTargetInfo>>(Triple, Opts); } + case llvm::Triple::Managarm: + return std::make_unique<ManagarmTargetInfo<AArch64leTargetInfo>>(Triple, + Opts); case llvm::Triple::NetBSD: return std::make_unique<NetBSDTargetInfo<AArch64leTargetInfo>>(Triple, Opts); @@ -463,6 +466,9 @@ std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple, return std::make_unique<OHOSTargetInfo<RISCV64TargetInfo>>(Triple, Opts); } + case llvm::Triple::Managarm: + return std::make_unique<ManagarmTargetInfo<RISCV64TargetInfo>>(Triple, + Opts); default: return std::make_unique<RISCV64TargetInfo>(Triple, Opts); } @@ -646,6 +652,9 @@ std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple, return std::make_unique<PS5OSTargetInfo<X86_64TargetInfo>>(Triple, Opts); case llvm::Triple::Hurd: return std::make_unique<HurdTargetInfo<X86_64TargetInfo>>(Triple, Opts); + case llvm::Triple::Managarm: + return std::make_unique<ManagarmTargetInfo<X86_64TargetInfo>>(Triple, + Opts); default: return std::make_unique<X86_64TargetInfo>(Triple, Opts); } diff --git a/clang/lib/Basic/Targets/OSTargets.h b/clang/lib/Basic/Targets/OSTargets.h index 4366c1149e4053..7e966ec32b911b 100644 --- a/clang/lib/Basic/Targets/OSTargets.h +++ b/clang/lib/Basic/Targets/OSTargets.h @@ -369,6 +369,36 @@ class LLVM_LIBRARY_VISIBILITY LinuxTargetInfo : public OSTargetInfo<Target> { } }; +// Managarm Target +template <typename Target> +class LLVM_LIBRARY_VISIBILITY ManagarmTargetInfo : public OSTargetInfo<Target> { +protected: + void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, + MacroBuilder &Builder) const override { + Builder.defineMacro("__managarm__"); + Builder.defineMacro("__ELF__"); + if (Opts.POSIXThreads) + Builder.defineMacro("_REENTRANT"); + if (Opts.CPlusPlus) + Builder.defineMacro("_GNU_SOURCE"); + if (this->HasFloat128) + Builder.defineMacro("__FLOAT128__"); + } + +public: + ManagarmTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) + : OSTargetInfo<Target>(Triple, Opts) { + switch (Triple.getArch()) { + default: + break; + case llvm::Triple::x86: + case llvm::Triple::x86_64: + this->HasFloat128 = true; + break; + } + } +}; + // 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 58427e3f83c420..afdf39ed6fb61a 100644 --- a/clang/lib/Driver/CMakeLists.txt +++ b/clang/lib/Driver/CMakeLists.txt @@ -65,6 +65,7 @@ add_clang_library(clangDriver ToolChains/HLSL.cpp ToolChains/Hurd.cpp ToolChains/Linux.cpp + ToolChains/Managarm.cpp ToolChains/MipsLinux.cpp ToolChains/MinGW.cpp ToolChains/MSP430.cpp diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp index e7335a61b10c53..d5203c21c10e2d 100644 --- a/clang/lib/Driver/Driver.cpp +++ b/clang/lib/Driver/Driver.cpp @@ -32,6 +32,7 @@ #include "ToolChains/Linux.h" #include "ToolChains/MSP430.h" #include "ToolChains/MSVC.h" +#include "ToolChains/Managarm.h" #include "ToolChains/MinGW.h" #include "ToolChains/MipsLinux.h" #include "ToolChains/NaCl.h" @@ -6351,6 +6352,9 @@ const ToolChain &Driver::getToolChain(const ArgList &Args, case llvm::Triple::Fuchsia: TC = std::make_unique<toolchains::Fuchsia>(*this, Target, Args); break; + case llvm::Triple::Managarm: + TC = std::make_unique<toolchains::Managarm>(*this, Target, Args); + break; case llvm::Triple::Solaris: TC = std::make_unique<toolchains::Solaris>(*this, Target, Args); break; diff --git a/clang/lib/Driver/ToolChains/Gnu.cpp b/clang/lib/Driver/ToolChains/Gnu.cpp index dedbfac6cb25d2..d75df71e164e7b 100644 --- a/clang/lib/Driver/ToolChains/Gnu.cpp +++ b/clang/lib/Driver/ToolChains/Gnu.cpp @@ -228,6 +228,8 @@ static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) { return "elf_iamcu"; return "elf_i386"; case llvm::Triple::aarch64: + if (T.getOS() == llvm::Triple::Managarm) + return "aarch64managarm"; return "aarch64linux"; case llvm::Triple::aarch64_be: return "aarch64linuxb"; @@ -2456,7 +2458,8 @@ void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes( static const char *const AArch64LibDirs[] = {"/lib64", "/lib"}; static const char *const AArch64Triples[] = { "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-redhat-linux", - "aarch64-suse-linux"}; + "aarch64-suse-linux", "aarch64-managarm", "aarch64-managarm-mlibc", + "aarch64-managarm-kernel"}; static const char *const AArch64beLibDirs[] = {"/lib"}; static const char *const AArch64beTriples[] = {"aarch64_be-none-linux-gnu", "aarch64_be-linux-gnu"}; @@ -2486,7 +2489,8 @@ void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes( "x86_64-redhat-linux", "x86_64-suse-linux", "x86_64-manbo-linux-gnu", "x86_64-linux-gnu", "x86_64-slackware-linux", "x86_64-unknown-linux", - "x86_64-amazon-linux"}; + "x86_64-amazon-linux", "x86_64-managarm", + "x86_64-managarm-mlibc", "x86_64-managarm-kernel"}; static const char *const X32Triples[] = {"x86_64-linux-gnux32", "x86_64-pc-linux-gnux32"}; static const char *const X32LibDirs[] = {"/libx32", "/lib"}; @@ -2562,7 +2566,10 @@ void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes( static const char *const RISCV64LibDirs[] = {"/lib64", "/lib"}; static const char *const RISCV64Triples[] = {"riscv64-unknown-linux-gnu", "riscv64-linux-gnu", - "riscv64-unknown-elf"}; + "riscv64-unknown-elf", + "riscv64-managarm", + "riscv64-managarm-kernel", + "riscv64-managarm-mlibc"}; static const char *const SPARCv8LibDirs[] = {"/lib32", "/lib"}; static const char *const SPARCv8Triples[] = {"sparc-linux-gnu", diff --git a/clang/lib/Driver/ToolChains/Managarm.cpp b/clang/lib/Driver/ToolChains/Managarm.cpp new file mode 100644 index 00000000000000..044822e4407a15 --- /dev/null +++ b/clang/lib/Driver/ToolChains/Managarm.cpp @@ -0,0 +1,230 @@ +//===--- Managarm.h - Managarm ToolChain Implementations --------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "Managarm.h" +#include "Arch/ARM.h" +#include "Arch/Mips.h" +#include "Arch/PPC.h" +#include "Arch/RISCV.h" +#include "CommonArgs.h" +#include "clang/Config/config.h" +#include "clang/Driver/Distro.h" +#include "clang/Driver/Driver.h" +#include "clang/Driver/Options.h" +#include "clang/Driver/SanitizerArgs.h" +#include "llvm/Option/ArgList.h" +#include "llvm/ProfileData/InstrProf.h" +#include "llvm/Support/Path.h" +#include <system_error> + +using namespace clang::driver; +using namespace clang::driver::toolchains; +using namespace clang; +using namespace llvm::opt; + +using tools::addPathIfExists; + +/// \brief Get our best guess at the multiarch triple for a target. +std::string Managarm::getMultiarchTriple(const Driver &D, + const llvm::Triple &TargetTriple, + StringRef SysRoot) const { + // For most architectures, just use whatever we have rather than trying to be + // clever. + switch (TargetTriple.getArch()) { + default: + break; + + case llvm::Triple::x86_64: + // We don't want this for x32, otherwise it will match x86_64 libs + return "x86_64-managarm"; + case llvm::Triple::aarch64: + return "aarch64-managarm"; + case llvm::Triple::riscv64: + return "riscv64-managarm"; + } + return TargetTriple.str(); +} + +static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) { + // It happens that only x86, PPC and SPARC use the 'lib32' variant of + // oslibdir, and using that variant while targeting other architectures causes + // problems because the libraries are laid out in shared system roots that + // can't cope with a 'lib32' library search path being considered. So we only + // enable them when we know we may need it. + // + // FIXME: This is a bit of a hack. We should really unify this code for + // reasoning about oslibdir spellings with the lib dir spellings in the + // GCCInstallationDetector, but that is a more significant refactoring. + if (Triple.getArch() == llvm::Triple::x86 || Triple.isPPC32() || + Triple.getArch() == llvm::Triple::sparc) + return "lib32"; + + if (Triple.getArch() == llvm::Triple::x86_64 && Triple.isX32()) + return "libx32"; + + if (Triple.getArch() == llvm::Triple::riscv32) + return "lib32"; + + return Triple.isArch32Bit() ? "lib" : "lib64"; +} + +Managarm::Managarm(const Driver &D, const llvm::Triple &Triple, + const ArgList &Args) + : Generic_ELF(D, Triple, Args) { + GCCInstallation.init(Triple, Args); + Multilibs = GCCInstallation.getMultilibs(); + SelectedMultilibs.assign({GCCInstallation.getMultilib()}); + std::string SysRoot = computeSysRoot(); + + ToolChain::path_list &PPaths = getProgramPaths(); + Generic_GCC::PushPPaths(PPaths); + +#ifdef ENABLE_LINKER_BUILD_ID + ExtraOpts.push_back("--build-id"); +#endif + + // The selection of paths to try here is designed to match the patterns which + // the GCC driver itself uses, as this is part of the GCC-compatible driver. + // This was determined by running GCC in a fake filesystem, creating all + // possible permutations of these directories, and seeing which ones it added + // to the link paths. + path_list &Paths = getFilePaths(); + + const std::string OSLibDir = std::string(getOSLibDir(Triple, Args)); + const std::string MultiarchTriple = getMultiarchTriple(D, Triple, SysRoot); + + Generic_GCC::AddMultilibPaths(D, SysRoot, OSLibDir, MultiarchTriple, Paths); + + addPathIfExists(D, concat(SysRoot, "/lib", MultiarchTriple), Paths); + addPathIfExists(D, concat(SysRoot, "/lib/..", OSLibDir), Paths); + addPathIfExists(D, concat(SysRoot, "/usr/lib/", MultiarchTriple), Paths); + addPathIfExists(D, concat(SysRoot, "/usr/lib/../", OSLibDir), Paths); + + Generic_GCC::AddMultiarchPaths(D, SysRoot, OSLibDir, Paths); + + addPathIfExists(D, SysRoot + "/lib", Paths); + addPathIfExists(D, SysRoot + "/usr/lib", Paths); +} + +bool Managarm::HasNativeLLVMSupport() const { return true; } + +Tool *Managarm::buildLinker() const { + return new tools::gnutools::Linker(*this); +} + +Tool *Managarm::buildAssembler() const { + return new tools::gnutools::Assembler(*this); +} + +std::string Managarm::computeSysRoot() const { + if (!getDriver().SysRoot.empty()) + return getDriver().SysRoot; + return std::string(); +} + +std::string Managarm::getDynamicLinker(const ArgList &Args) const { + switch (getTriple().getArch()) { + case llvm::Triple::aarch64: + return "/lib/aarch64-managarm/ld.so"; + case llvm::Triple::riscv64: { + StringRef ABIName = tools::riscv::getRISCVABI(Args, getTriple()); + return ("/lib/riscv64-managarm/ld-riscv64-" + ABIName + ".so").str(); + } + case llvm::Triple::x86_64: + return "/lib/x86_64-managarm/ld.so"; + default: + llvm_unreachable("unsupported architecture"); + } +} + +void Managarm::AddClangSystemIncludeArgs(const ArgList &DriverArgs, + ArgStringList &CC1Args) const { + const Driver &D = getDriver(); + std::string SysRoot = computeSysRoot(); + + if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc)) + return; + + if (!DriverArgs.hasArg(options::OPT_nostdlibinc)) + return; + + addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include"); + + if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { + SmallString<128> P(D.ResourceDir); + llvm::sys::path::append(P, "include"); + addSystemInclude(DriverArgs, CC1Args, P); + } + + if (DriverArgs.hasArg(options::OPT_nostdlibinc)) + return; + + // LOCAL_INCLUDE_DIR + addSystemInclude(DriverArgs, CC1Args, concat(SysRoot, "/usr/local/include")); + // TOOL_INCLUDE_DIR + AddMultilibIncludeArgs(DriverArgs, CC1Args); + + // 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(SysRoot) : ""; + addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir); + } + return; + } + + // On systems using multiarch and Android, add /usr/include/$triple before + // /usr/include. + std::string MultiarchIncludeDir = getMultiarchTriple(D, getTriple(), SysRoot); + if (!MultiarchIncludeDir.empty() && + D.getVFS().exists(concat(SysRoot, "/usr/include", MultiarchIncludeDir))) + addExternCSystemInclude( + DriverArgs, CC1Args, + concat(SysRoot, "/usr/include", MultiarchIncludeDir)); + + // Add an include of '/include' directly. This isn't provided by default by + // system GCCs, but is often used with cross-compiling GCCs, and harmless to + // add even when Clang is acting as-if it were a system compiler. + addExternCSystemInclude(DriverArgs, CC1Args, concat(SysRoot, "/include")); + + addExternCSystemInclude(DriverArgs, CC1Args, concat(SysRoot, "/usr/include")); +} + +void Managarm::addLibStdCxxIncludePaths( + const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const { + // We need a detected GCC installation on Managarm to provide libstdc++'s + // headers. + if (!GCCInstallation.isValid()) + return; + + StringRef TripleStr = GCCInstallation.getTriple().str(); + + // Try generic GCC detection. + Generic_GCC::addGCCLibStdCxxIncludePaths(DriverArgs, CC1Args, TripleStr); +} + +SanitizerMask Managarm::getSupportedSanitizers() const { + const bool IsX86 = getTriple().getArch() == llvm::Triple::x86; + const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64; + SanitizerMask Res = ToolChain::getSupportedSanitizers(); + Res |= SanitizerKind::PointerCompare; + Res |= SanitizerKind::PointerSubtract; + Res |= SanitizerKind::KernelAddress; + Res |= SanitizerKind::Vptr; + if (IsX86_64) + Res |= SanitizerKind::KernelMemory; + if (IsX86 || IsX86_64) + Res |= SanitizerKind::Function; + return Res; +} diff --git a/clang/lib/Driver/ToolChains/Managarm.h b/clang/lib/Driver/ToolChains/Managarm.h new file mode 100644 index 00000000000000..003ba6f8495c51 --- /dev/null +++ b/clang/lib/Driver/ToolChains/Managarm.h @@ -0,0 +1,54 @@ +//===--- Managarm.h - Managarm ToolChain Implementations --------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_MANAGARM_H +#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_MANAGARM_H + +#include "Gnu.h" +#include "clang/Driver/ToolChain.h" + +namespace clang { +namespace driver { +namespace toolchains { + +class LLVM_LIBRARY_VISIBILITY Managarm : public Generic_ELF { +public: + Managarm(const Driver &D, const llvm::Triple &Triple, + const llvm::opt::ArgList &Args); + + bool HasNativeLLVMSupport() const override; + + std::string getMultiarchTriple(const Driver &D, + const llvm::Triple &TargetTriple, + StringRef SysRoot) 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; + SanitizerMask getSupportedSanitizers() const override; + virtual std::string computeSysRoot() const override; + + virtual std::string + getDynamicLinker(const llvm::opt::ArgList &Args) const override; + + std::vector<std::string> ExtraOpts; + +protected: + Tool *buildAssembler() const override; + Tool *buildLinker() const override; +}; + +} // end namespace toolchains +} // end namespace driver +} // end namespace clang + +#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_MANAGARM_H diff --git a/llvm/include/llvm/ADT/bit.h b/llvm/include/llvm/ADT/bit.h index c42b5e686bdc9c..7a36ef2eb5163d 100644 --- a/llvm/include/llvm/ADT/bit.h +++ b/llvm/include/llvm/ADT/bit.h @@ -29,7 +29,7 @@ #if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__) || \ defined(__Fuchsia__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) || \ - defined(__OpenBSD__) || defined(__DragonFly__) + defined(__OpenBSD__) || defined(__DragonFly__) || defined(__managarm__) #include <endian.h> #elif defined(_AIX) #include <sys/machine.h> diff --git a/llvm/include/llvm/TargetParser/Triple.h b/llvm/include/llvm/TargetParser/Triple.h index f256e2b205a889..0babe558e35305 100644 --- a/llvm/include/llvm/TargetParser/Triple.h +++ b/llvm/include/llvm/TargetParser/Triple.h @@ -196,6 +196,7 @@ class Triple { Linux, Lv2, // PS3 MacOSX, + Managarm, NetBSD, OpenBSD, Solaris, @@ -279,8 +280,10 @@ class Triple { Amplification, OpenCL, OpenHOS, + Kernel, + Mlibc, - LastEnvironmentType = OpenHOS + LastEnvironmentType = Mlibc }; enum ObjectFormatType { UnknownObjectFormat, diff --git a/llvm/lib/Support/Unix/Path.inc b/llvm/lib/Support/Unix/Path.inc index 968e2c459f3fb1..614763b2c4f0b5 100644 --- a/llvm/lib/Support/Unix/Path.inc +++ b/llvm/lib/Support/Unix/Path.inc @@ -74,7 +74,8 @@ extern char **environ; #include <sys/types.h> #if !defined(__APPLE__) && !defined(__OpenBSD__) && !defined(__FreeBSD__) && \ - !defined(__linux__) && !defined(__FreeBSD_kernel__) && !defined(_AIX) + !defined(__linux__) && !defined(__FreeBSD_kernel__) && !defined(_AIX) && \ + !defined(__managarm__) #include <sys/statvfs.h> #define STATVFS statvfs #define FSTATVFS fstatvfs @@ -83,7 +84,7 @@ extern char **environ; #if defined(__OpenBSD__) || defined(__FreeBSD__) #include <sys/mount.h> #include <sys/param.h> -#elif defined(__linux__) +#elif defined(__linux__) || defined(__managarm__) #if defined(HAVE_LINUX_MAGIC_H) #include <linux/magic.h> #else @@ -129,7 +130,8 @@ const file_t kInvalidFile = -1; #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || \ defined(__FreeBSD_kernel__) || defined(__linux__) || defined(__CYGWIN__) || \ defined(__DragonFly__) || defined(_AIX) || defined(__GNU__) || \ - (defined(__sun__) && defined(__svr4__) || defined(__HAIKU__)) + (defined(__sun__) && defined(__svr4__) || defined(__HAIKU__)) || \ + defined(__managarm__) static int test_dir(char ret[PATH_MAX], const char *dir, const char *bin) { struct stat sb; char fullpath[PATH_MAX]; @@ -250,7 +252,8 @@ std::string getMainExecutable(const char *argv0, void *MainAddr) { // If we don't have procfs mounted, fall back to argv[0] if (getprogpath(exe_path, argv0) != NULL) return exe_path; -#elif defined(__linux__) || defined(__CYGWIN__) || defined(__gnu_hurd__) +#elif defined(__linux__) || defined(__CYGWIN__) || defined(__gnu_hurd__) || \ + defined(__managarm__) char exe_path[PATH_MAX]; const char *aPath = "/proc/self/exe"; if (sys::fs::exists(aPath)) { @@ -477,7 +480,7 @@ std::error_code remove(const Twine &path, bool IgnoreNonExisting) { } static bool is_local_impl(struct STATVFS &Vfs) { -#if defined(__linux__) || defined(__GNU__) +#if defined(__linux__) || defined(__GNU__) || defined(__managarm__) #ifndef NFS_SUPER_MAGIC #define NFS_SUPER_MAGIC 0x6969 #endif diff --git a/llvm/lib/TargetParser/Triple.cpp b/llvm/lib/TargetParser/Triple.cpp index 624679ff507a7f..42ad9db3007908 100644 --- a/llvm/lib/TargetParser/Triple.cpp +++ b/llvm/lib/TargetParser/Triple.cpp @@ -257,6 +257,7 @@ StringRef Triple::getOSTypeName(OSType Kind) { 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 NaCl: return "nacl"; @@ -327,6 +328,8 @@ StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) { case OpenCL: return "opencl"; case OpenHOS: return "ohos"; + case Kernel: return "kernel"; + case Mlibc: return "mlibc"; } llvm_unreachable("Invalid EnvironmentType!"); @@ -619,6 +622,7 @@ static Triple::OSType parseOS(StringRef OSName) { .StartsWith("linux", Triple::Linux) .StartsWith("lv2", Triple::Lv2) .StartsWith("macos", Triple::MacOSX) + .StartsWith("managarm", Triple::Managarm) .StartsWith("netbsd", Triple::NetBSD) .StartsWith("openbsd", Triple::OpenBSD) .StartsWith("solaris", Triple::Solaris) @@ -698,6 +702,8 @@ static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) { .StartsWith("amplification", Triple::Amplification) .StartsWith("opencl", Triple::OpenCL) .StartsWith("ohos", Triple::OpenHOS) + .StartsWith("kernel", Triple::Kernel) + .StartsWith("mlibc", Triple::Mlibc) .Default(Triple::UnknownEnvironment); } diff --git a/llvm/unittests/TargetParser/TripleTest.cpp b/llvm/unittests/TargetParser/TripleTest.cpp index e1e1bbd76ecda6..92b652d899a871 100644 --- a/llvm/unittests/TargetParser/TripleTest.cpp +++ b/llvm/unittests/TargetParser/TripleTest.cpp @@ -1007,6 +1007,30 @@ TEST(TripleTest, ParsedIDs) { EXPECT_EQ(Triple::Serenity, T.getOS()); EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); + T = Triple("aarch64-pc-managarm-mlibc"); + EXPECT_EQ(Triple::aarch64, T.getArch()); + EXPECT_EQ(Triple::PC, T.getVendor()); + EXPECT_EQ(Triple::Managarm, T.getOS()); + EXPECT_EQ(Triple::Mlibc, T.getEnvironment()); + + T = Triple("aarch64-pc-managarm-kernel"); + EXPECT_EQ(Triple::aarch64, T.getArch()); + EXPECT_EQ(Triple::PC, T.getVendor()); + EXPECT_EQ(Triple::Managarm, T.getOS()); + EXPECT_EQ(Triple::Kernel, T.getEnvironment()); + + T = Triple("x86_64-pc-managarm-mlibc"); + EXPECT_EQ(Triple::x86_64, T.getArch()); + EXPECT_EQ(Triple::PC, T.getVendor()); + EXPECT_EQ(Triple::Managarm, T.getOS()); + EXPECT_EQ(Triple::Mlibc, T.getEnvironment()); + + T = Triple("x86_64-pc-managarm-kernel"); + EXPECT_EQ(Triple::x86_64, T.getArch()); + EXPECT_EQ(Triple::PC, T.getVendor()); + EXPECT_EQ(Triple::Managarm, T.getOS()); + EXPECT_EQ(Triple::Kernel, T.getEnvironment()); + T = Triple("huh"); EXPECT_EQ(Triple::UnknownArch, T.getArch()); } _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
