[OHOS] Add support for OpenHarmony

[kpdev42]

Summary

Add support for OpenHarmony OS

General OpenHarmony OS discussion on discourse thread "[RFC] Add support for OpenHarmony OS"
https://discourse.llvm.org/t/rfc-add-support-for-openharmony-os/66656

[kpdev42]

Remove tls-related changes
Add link to dicourse thread

[kpdev42]

Ping) Any thoughts, questions?

[kpdev42]

Ping

[kpdev42]

ping

[DavidSpickett]

Please include context with the diff (https://llvm.org/docs/Phabricator.html#requesting-a-review-via-the-web-interface).

(Phab doesn't have the full repo backing each diff so the context lets us see what the surrounding code is)

[arsenm]

I'm generally of the opinion that anything and everything can go into Triple

llvm/include/llvm/ADT/Triple.h

742 ↗

(On Diff #476198)

As someone who's never heard of this operating system, this helper name isn't particularly enlightening

[arsenm]

llvm/test/Transforms/SafeStack/AArch64/unreachable.ll

6 ↗

(On Diff #476198)

New tests should use opaque pointers (has this one somehow missed conversion?)

[jrtc27]

llvm/include/llvm/ADT/Triple.h

250 ↗

(On Diff #476198)

Keep blank line

270 ↗

(On Diff #476198)

Keep blank line

742 ↗

(On Diff #476198)

What if I give aarch64-liteos-gnu?

llvm/include/llvm/BinaryFormat/MinidumpConstants.def

118

What's with the 0x8206 gap?

llvm/test/Transforms/SafeStack/AArch64/abi.ll

2 ↗

(On Diff #476198)

These diffs don't belong here, the tests pass without them

[DavidSpickett]

llvm/test/Transforms/SafeStack/AArch64/abi.ll

7 ↗

(On Diff #476198)

This should have a comment if there is some OpenHarmony specific behaviour here.

llvm/test/Transforms/SafeStack/AArch64/unreachable.ll

6 ↗

(On Diff #476198)

Same here please note why OpenHarmony needs this specific check. Also note that FileCheck %s --check-prefix=OHOSMUSL will only check that prefix, not that plus the CHECK. I don't know if that is what you intended.

llvm/unittests/ADT/TripleTest.cpp

813 ↗

(On Diff #476198)

Is the "canonical" triple here arm-unknown-liteos-ohos ? I guess you are testing here to make sure that liteos implies ohos if ohos is not in the triple already.

[kpdev42]

Rebase and clean

[kpdev42]

llvm/include/llvm/ADT/Triple.h

742 ↗

(On Diff #476198)

We currently assume environment for liteos is always ohos. Thus gnu env will be ignored.

[DavidSpickett]

llvm/include/llvm/BinaryFormat/MinidumpConstants.def

118

Is this still relevant?

[kpdev42]

llvm/include/llvm/BinaryFormat/MinidumpConstants.def

118

Actually, no, it was changed from 0x8207 in initial diff to 0x8206 in current one

[DavidSpickett]

LGTM, all comments have been addressed.

Please add [llvm] at the start of the commit title as well. If you are landing it using arc, edit the title here in the web interface first. It has a habit of choosing that over the local version in my experience.

[kpdev42]

In D138202#4154806, @DavidSpickett wrote:

LGTM, all comments have been addressed.

Please add [llvm] at the start of the commit title as well. If you are landing it using arc, edit the title here in the web interface first. It has a habit of choosing that over the local version in my experience.

Sorry, forgot to add this tag, mea culpa. Will add it in next patches. Thank you for the review

llvm/include/llvm/BinaryFormat/MinidumpConstants.def

 HANDLE_MDMP_PLATFORM(0x8000, Unix) // Generic Unix-ish
 HANDLE_MDMP_PLATFORM(0x8101, MacOSX) // Mac OS X/Darwin
 HANDLE_MDMP_PLATFORM(0x8102, IOS) // iOS
 HANDLE_MDMP_PLATFORM(0x8201, Linux) // Linux
 HANDLE_MDMP_PLATFORM(0x8202, Solaris) // Solaris
 HANDLE_MDMP_PLATFORM(0x8203, Android) // Android
 HANDLE_MDMP_PLATFORM(0x8204, PS3) // PS3
 HANDLE_MDMP_PLATFORM(0x8205, NaCl) // Native Client (NaCl)
+HANDLE_MDMP_PLATFORM(0x8206, OpenHOS) // OpenHarmony OS
 
 HANDLE_MDMP_PROTECT(0x01, NoAccess, PAGE_NO_ACCESS)
 HANDLE_MDMP_PROTECT(0x02, ReadOnly, PAGE_READ_ONLY)
 HANDLE_MDMP_PROTECT(0x04, ReadWrite, PAGE_READ_WRITE)
 HANDLE_MDMP_PROTECT(0x08, WriteCopy, PAGE_WRITE_COPY)
 HANDLE_MDMP_PROTECT(0x10, Execute, PAGE_EXECUTE)
 HANDLE_MDMP_PROTECT(0x20, ExecuteRead, PAGE_EXECUTE_READ)
 HANDLE_MDMP_PROTECT(0x40, ExecuteReadWrite, PAGE_EXECUTE_READ_WRITE)

llvm/include/llvm/TargetParser/Triple.h

enum OSType {
     Mesa3D,
     Contiki,
     AMDPAL,     // AMD PAL Runtime
     HermitCore, // HermitCore Unikernel/Multikernel
     Hurd,       // GNU/Hurd
     WASI,       // Experimental WebAssembly OS
     Emscripten,
     ShaderModel, // DirectX ShaderModel
-    LastOSType = ShaderModel
+    LiteOS,
+    LastOSType = LiteOS
   };
   enum EnvironmentType {
     UnknownEnvironment,
 
     GNU,
     GNUABIN32,
     GNUABI64,
     GNUEABI,
enum EnvironmentType {
     RayGeneration,
     Intersection,
     AnyHit,
     ClosestHit,
     Miss,
     Callable,
     Mesh,
     Amplification,
-
-    LastEnvironmentType = Amplification
+    OpenHOS,
+    LastEnvironmentType = OpenHOS
   };
   enum ObjectFormatType {
     UnknownObjectFormat,
 
     COFF,
     DXContainer,
     ELF,
     GOFF,
bool isAndroidVersionLT(unsigned Major) const {
     return Version < VersionTuple(Major);
   }
 
   /// Tests whether the environment is musl-libc
   bool isMusl() const {
     return getEnvironment() == Triple::Musl ||
            getEnvironment() == Triple::MuslEABI ||
            getEnvironment() == Triple::MuslEABIHF ||
-           getEnvironment() == Triple::MuslX32;
+           getEnvironment() == Triple::MuslX32 ||
+           getEnvironment() == Triple::OpenHOS || isOSLiteOS();
   }
 
+  /// Tests whether the target is OHOS
+  /// LiteOS default enviroment is also OHOS, but omited on triple.
+  bool isOHOSFamily() const { return isOpenHOS() || isOSLiteOS(); }
+
+  bool isOpenHOS() const { return getEnvironment() == Triple::OpenHOS; }
+
+  bool isOSLiteOS() const { return getOS() == Triple::LiteOS; }
+
   /// Tests whether the target is DXIL.
   bool isDXIL() const {
     return getArch() == Triple::dxil;
   }
 
   /// Tests whether the target is SPIR (32- or 64-bit).
   bool isSPIR() const {
     return getArch() == Triple::spir || getArch() == Triple::spir64;
public:
   /// handling standard.
   bool isTargetEHABICompatible() const {
     return (isARM() || isThumb()) &&
            (getEnvironment() == Triple::EABI ||
             getEnvironment() == Triple::GNUEABI ||
             getEnvironment() == Triple::MuslEABI ||
             getEnvironment() == Triple::EABIHF ||
             getEnvironment() == Triple::GNUEABIHF ||
+            getEnvironment() == Triple::OpenHOS ||
             getEnvironment() == Triple::MuslEABIHF || isAndroid()) &&
            isOSBinFormatELF();
   }
 
   /// Tests whether the target is T32.
   bool isArmT32() const {
     switch (getSubArch()) {
     case Triple::ARMSubArch_v8m_baseline:

llvm/lib/Target/ARM/ARMSubtarget.h

#include "ARMGenSubtargetInfo.inc"
   }
   bool isTargetGNUAEABI() const {
     return (TargetTriple.getEnvironment() == Triple::GNUEABI ||
             TargetTriple.getEnvironment() == Triple::GNUEABIHF) &&
            !isTargetDarwin() && !isTargetWindows();
   }
   bool isTargetMuslAEABI() const {
     return (TargetTriple.getEnvironment() == Triple::MuslEABI ||
-            TargetTriple.getEnvironment() == Triple::MuslEABIHF) &&
+            TargetTriple.getEnvironment() == Triple::MuslEABIHF ||
+            TargetTriple.getEnvironment() == Triple::OpenHOS) &&
            !isTargetDarwin() && !isTargetWindows();
   }
 
   // ARM Targets that support EHABI exception handling standard
   // Darwin uses SjLj. Other targets might need more checks.
   bool isTargetEHABICompatible() const {
     return TargetTriple.isTargetEHABICompatible();
   }

llvm/lib/Target/ARM/ARMTargetMachine.cpp

ARMBaseTargetMachine::ARMBaseTargetMachine(const Target &T, const Triple &TT,
 
   // Default to triple-appropriate EABI
   if (Options.EABIVersion == EABI::Default ||
       Options.EABIVersion == EABI::Unknown) {
     // musl is compatible with glibc with regard to EABI version
     if ((TargetTriple.getEnvironment() == Triple::GNUEABI ||
          TargetTriple.getEnvironment() == Triple::GNUEABIHF ||
          TargetTriple.getEnvironment() == Triple::MuslEABI ||
-         TargetTriple.getEnvironment() == Triple::MuslEABIHF) &&
+         TargetTriple.getEnvironment() == Triple::MuslEABIHF ||
+         TargetTriple.getEnvironment() == Triple::OpenHOS) &&
         !(TargetTriple.isOSWindows() || TargetTriple.isOSDarwin()))
       this->Options.EABIVersion = EABI::GNU;
     else
       this->Options.EABIVersion = EABI::EABI5;
   }
 
   if (TT.isOSBinFormatMachO()) {
     this->Options.TrapUnreachable = true;

llvm/lib/TargetParser/AArch64TargetParser.cpp

for (const auto &C : CpuInfos)
       Values.push_back(C.Name);
 
   for (const auto &Alias : CpuAliases)
     Values.push_back(Alias.Alias);
 }
 
 bool AArch64::isX18ReservedByDefault(const Triple &TT) {
   return TT.isAndroid() || TT.isOSDarwin() || TT.isOSFuchsia() ||
-         TT.isOSWindows();
+         TT.isOSWindows() || TT.isOHOSFamily();
 }
 
 // Allows partial match, ex. "v8a" matches "armv8a".
 std::optional<AArch64::ArchInfo> AArch64::parseArch(StringRef Arch) {
   Arch = llvm::ARM::getCanonicalArchName(Arch);
   if (checkArchVersion(Arch) < 8)
     return {};
 

llvm/lib/TargetParser/ARMTargetParser.cpp

StringRef ARM::computeDefaultTargetABI(const Triple &TT, StringRef CPU) {
   case Triple::MuslEABIHF:
     return "aapcs-linux";
   case Triple::EABIHF:
   case Triple::EABI:
     return "aapcs";
   default:
     if (TT.isOSNetBSD())
       return "apcs-gnu";
-    if (TT.isOSOpenBSD())
+    if (TT.isOSOpenBSD() || TT.isOHOSFamily())
       return "aapcs-linux";
     return "aapcs";
   }
 }
 
 StringRef ARM::getARMCPUForArch(const llvm::Triple &Triple, StringRef MArch) {
   if (MArch.empty())
     MArch = Triple.getArchName();

llvm/lib/TargetParser/Triple.cpp

StringRef Triple::getOSTypeName(OSType Kind) {
   case RTEMS: return "rtems";
   case Solaris: return "solaris";
   case TvOS: return "tvos";
   case WASI: return "wasi";
   case WatchOS: return "watchos";
   case Win32: return "windows";
   case ZOS: return "zos";
   case ShaderModel: return "shadermodel";
+  case LiteOS: return "liteos";
   }
 
   llvm_unreachable("Invalid OSType");
 }
 
 StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) {
   switch (Kind) {
   case UnknownEnvironment: return "unknown";
StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) {
   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 OpenHOS: return "ohos";
   }
 
   llvm_unreachable("Invalid EnvironmentType!");
 }
 
 static Triple::ArchType parseBPFArch(StringRef ArchName) {
   if (ArchName.equals("bpf")) {
     if (sys::IsLittleEndianHost)
return StringSwitch<Triple::OSType>(OSName)
     .StartsWith("mesa3d", Triple::Mesa3D)
     .StartsWith("contiki", Triple::Contiki)
     .StartsWith("amdpal", Triple::AMDPAL)
     .StartsWith("hermit", Triple::HermitCore)
     .StartsWith("hurd", Triple::Hurd)
     .StartsWith("wasi", Triple::WASI)
     .StartsWith("emscripten", Triple::Emscripten)
     .StartsWith("shadermodel", Triple::ShaderModel)
+    .StartsWith("liteos", Triple::LiteOS)
     .Default(Triple::UnknownOS);
 }
 
 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
   return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
       .StartsWith("eabihf", Triple::EABIHF)
       .StartsWith("eabi", Triple::EABI)
       .StartsWith("gnuabin32", Triple::GNUABIN32)
return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
       .StartsWith("raygeneration", Triple::RayGeneration)
       .StartsWith("intersection", Triple::Intersection)
       .StartsWith("anyhit", Triple::AnyHit)
       .StartsWith("closesthit", Triple::ClosestHit)
       .StartsWith("miss", Triple::Miss)
       .StartsWith("callable", Triple::Callable)
       .StartsWith("mesh", Triple::Mesh)
       .StartsWith("amplification", Triple::Amplification)
+      .StartsWith("ohos", Triple::OpenHOS)
       .Default(Triple::UnknownEnvironment);
 }
 
 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
   return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
       // "xcoff" must come before "coff" because of the order-dependendent
       // pattern matching.
       .EndsWith("xcoff", Triple::XCOFF)

llvm/test/CodeGen/AArch64/arm64-platform-reg.ll

 ; RUN: llc -mtriple=arm64-apple-ios -mattr=+reserve-x18 -o - %s | FileCheck %s --check-prefix=CHECK-RESERVE --check-prefix=CHECK-RESERVE-X18
 ; RUN: llc -mtriple=arm64-freebsd-gnu -mattr=+reserve-x18 -o - %s | FileCheck %s --check-prefix=CHECK-RESERVE --check-prefix=CHECK-RESERVE-X18
 ; RUN: llc -mtriple=arm64-linux-gnu -o - %s | FileCheck %s
 ; RUN: llc -mtriple=aarch64-linux-android -o - %s | FileCheck %s --check-prefix=CHECK-RESERVE --check-prefix=CHECK-RESERVE-X18
+; RUN: llc -mtriple=aarch64-linux-ohos -o - %s | FileCheck %s --check-prefix=CHECK-RESERVE --check-prefix=CHECK-RESERVE-X18
 ; RUN: llc -mtriple=aarch64-fuchsia -o - %s | FileCheck %s --check-prefix=CHECK-RESERVE --check-prefix=CHECK-RESERVE-X18
 ; RUN: llc -mtriple=aarch64-windows -o - %s | FileCheck %s --check-prefix=CHECK-RESERVE --check-prefix=CHECK-RESERVE-X18
 
 ; Test reserve-x# options individually.
 ; RUN: llc -mtriple=arm64-linux-gnu -mattr=+reserve-x1 -o - %s | FileCheck %s --check-prefixes=CHECK-RESERVE,CHECK-RESERVE-X1
 ; RUN: llc -mtriple=arm64-linux-gnu -mattr=+reserve-x2 -o - %s | FileCheck %s --check-prefixes=CHECK-RESERVE,CHECK-RESERVE-X2
 ; RUN: llc -mtriple=arm64-linux-gnu -mattr=+reserve-x3 -o - %s | FileCheck %s --check-prefixes=CHECK-RESERVE,CHECK-RESERVE-X3
 ; RUN: llc -mtriple=arm64-linux-gnu -mattr=+reserve-x4 -o - %s | FileCheck %s --check-prefixes=CHECK-RESERVE,CHECK-RESERVE-X4

llvm/unittests/TargetParser/TripleTest.cpp

TEST(TripleTest, ParsedIDs) {
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 
   T = Triple("xtensa-unknown-unknown");
   EXPECT_EQ(Triple::xtensa, T.getArch());
   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
   EXPECT_EQ(Triple::UnknownOS, T.getOS());
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 
+  T = Triple("arm-unknown-linux-ohos");
+  EXPECT_EQ(Triple::arm, T.getArch());
+  EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::OpenHOS, T.getEnvironment());
+
+  T = Triple("arm-unknown-liteos");
+  EXPECT_EQ(Triple::arm, T.getArch());
+  EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
+  EXPECT_EQ(Triple::LiteOS, T.getOS());
+  EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
+
   T = Triple("huh");
   EXPECT_EQ(Triple::UnknownArch, T.getArch());
 }
 
 static std::string Join(StringRef A, StringRef B, StringRef C) {
   std::string Str = std::string(A);
   Str += '-';
   Str += B;