[LLVM][OHOS] Clang toolchain and targets

[kpdev42]

Summary

Add a clang part of OpenHarmony target

Related LLVM part: D138202

~~~

Huawei RRI, OS Lab

[DavidSpickett]

I'm not familiar with the details of toolchain config, but added some general comments.

clang/lib/Driver/ToolChains/CommonArgs.cpp

1385

Collapse this into if isohos && triple.getarch is....

1675

Please add a comment explaining this. Even if it is just "OHOS is only compatible with libunwind". At least then we know it's nothing more mysterious.

clang/lib/Driver/ToolChains/Gnu.cpp

645–647

And musl is what OHOS uses? Please add that to the comment if so "for musl, which OHOS uses...".

2319

No riscv related changes needed in this file?

clang/lib/Driver/ToolChains/OHOS.cpp

165

Keep FIXMEs that refer to stuff outside the project downstream please :)

373

Maybe this helps? https://github.com/llvm/llvm-project/blob/e00c73c856a325008afead10cfb3e9d0fc4a1e41/clang/lib/Driver/ToolChains/Linux.cpp#L235

(no idea myself)

clang/test/Driver/ohos.c

241

This one is checking that we do not link to a pthread library, because when using musl, it already provides one?

Just checking you're not accepting the option but doing the opposite here. Worth adding a comment to explain the reasoning.

[kpdev42]

clang/test/Driver/ohos.c

241

Yes, musl implements pthread api, so we do not need to link with libpthread

[kpdev42]

Address review comments and rebase

[kpdev42]

Fix test case

[DavidSpickett]

Looks good in general. If there are some incorrect details you'll find them later.

[TWeaver]

Good morning,

I believe the two tests added in this patch, clang::ohos.c and clang::ohos.cpp are failing on the following buildbot:

https://lab.llvm.org/buildbot/#/builders/216/builds/18323

is anyone able to take a look?

thanks,
Tom W

[DavidSpickett]

Also failing on our Windows on Arm bot: https://lab.llvm.org/buildbot/#/builders/65/builds/8607

I think some lines need to account for Windows slashes, {{/|\\\\}} should do that.

[mysterymath]

This is also causing a breakage on the Linux and Mac Fuchsia toolchain builds:
https://luci-milo.appspot.com/ui/p/fuchsia/builders/toolchain.ci/clang-linux-x64/b8786633328903858561/overview

[mysterymath]

It looks like these tests don't pass when LLVM_ENABLE_LINKER_BUILD_ID is set; I've issued a revert until this can be fixed to unblock the Fuchsia toolchain.

[kpdev42]

In D145227#4192628, @DavidSpickett wrote:

Also failing on our Windows on Arm bot: https://lab.llvm.org/buildbot/#/builders/65/builds/8607

I think some lines need to account for Windows slashes, {{/|\\\\}} should do that.

Yes, sorry... Fixed https://github.com/llvm/llvm-project/commit/28997feb0c3ac243cb5cc89d7682993e23463ca7

[MaskRay]

clang/lib/Driver/ToolChains/OHOS.h

39

Why is useRelaxRelocations false?

[kpdev42]

clang/lib/Driver/ToolChains/OHOS.h

39

Thank you for mentioning. I would say that there is no precise reason for it. And it will be changed to true in the nearest future.

clang/include/clang/Basic/Attr.td

return llvm::StringSwitch<llvm::StringRef>(Platform)
              .Case("ios_app_extension", "iOS (App Extension)")
              .Case("macos_app_extension", "macOS (App Extension)")
              .Case("tvos_app_extension", "tvOS (App Extension)")
              .Case("watchos_app_extension", "watchOS (App Extension)")
              .Case("maccatalyst", "macCatalyst")
              .Case("maccatalyst_app_extension", "macCatalyst (App Extension)")
              .Case("swift", "Swift")
              .Case("shadermodel", "HLSL ShaderModel")
+             .Case("ohos", "OpenHarmony OS")
              .Default(llvm::StringRef());
 }
 static llvm::StringRef getPlatformNameSourceSpelling(llvm::StringRef Platform) {
     return llvm::StringSwitch<llvm::StringRef>(Platform)
              .Case("ios", "iOS")
              .Case("macos", "macOS")
              .Case("tvos", "tvOS")
              .Case("watchos", "watchOS")

clang/include/clang/Driver/ToolChain.h

public:
   // Returns target specific runtime paths.
   path_list getRuntimePaths() const;
 
   // Returns target specific standard library paths.
   path_list getStdlibPaths() const;
 
   // Returns <ResourceDir>/lib/<OSName>/<arch>.  This is used by runtimes (such
   // as OpenMP) to find arch-specific libraries.
-  std::string getArchSpecificLibPath() const;
+  virtual std::string getArchSpecificLibPath() const;
 
   // Returns <OSname> part of above.
   virtual StringRef getOSLibName() const;
 
   /// needsProfileRT - returns true if instrumentation profile is on.
   static bool needsProfileRT(const llvm::opt::ArgList &Args);
 
   /// Returns true if gcov instrumentation (-fprofile-arcs or --coverage) is on.

clang/lib/Basic/TargetInfo.cpp

TargetInfo::TargetInfo(const llvm::Triple &T) : Triple(T) {
   SuitableAlign = 64;
   DefaultAlignForAttributeAligned = 128;
   MinGlobalAlign = 0;
   // From the glibc documentation, on GNU systems, malloc guarantees 16-byte
   // alignment on 64-bit systems and 8-byte alignment on 32-bit systems. See
   // https://www.gnu.org/software/libc/manual/html_node/Malloc-Examples.html.
   // This alignment guarantee also applies to Windows and Android. On Darwin
   // and OpenBSD, the alignment is 16 bytes on both 64-bit and 32-bit systems.
-  if (T.isGNUEnvironment() || T.isWindowsMSVCEnvironment() || T.isAndroid())
+  if (T.isGNUEnvironment() || T.isWindowsMSVCEnvironment() || T.isAndroid() ||
+      T.isOHOSFamily())
     NewAlign = Triple.isArch64Bit() ? 128 : Triple.isArch32Bit() ? 64 : 0;
   else if (T.isOSDarwin() || T.isOSOpenBSD())
     NewAlign = 128;
   else
     NewAlign = 0; // Infer from basic type alignment.
   HalfWidth = 16;
   HalfAlign = 16;
   FloatWidth = 32;

clang/lib/Basic/Targets.cpp

case llvm::Triple::aarch64:
     switch (os) {
     case llvm::Triple::CloudABI:
       return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts);
     case llvm::Triple::FreeBSD:
       return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
     case llvm::Triple::Fuchsia:
       return new FuchsiaTargetInfo<AArch64leTargetInfo>(Triple, Opts);
     case llvm::Triple::Linux:
+      switch (Triple.getEnvironment()) {
+      default:
         return new LinuxTargetInfo<AArch64leTargetInfo>(Triple, Opts);
+      case llvm::Triple::OpenHOS:
+        return new OHOSTargetInfo<AArch64leTargetInfo>(Triple, Opts);
+      }
     case llvm::Triple::NetBSD:
       return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
     case llvm::Triple::OpenBSD:
       return new OpenBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
     case llvm::Triple::Win32:
       switch (Triple.getEnvironment()) {
       case llvm::Triple::GNU:
         return new MinGWARM64TargetInfo(Triple, Opts);
TargetInfo *AllocateTarget(const llvm::Triple &Triple,
   case llvm::Triple::thumb:
     if (Triple.isOSBinFormatMachO())
       return new DarwinARMTargetInfo(Triple, Opts);
 
     switch (os) {
     case llvm::Triple::CloudABI:
       return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts);
     case llvm::Triple::Linux:
+      switch (Triple.getEnvironment()) {
+      default:
         return new LinuxTargetInfo<ARMleTargetInfo>(Triple, Opts);
+      case llvm::Triple::OpenHOS:
+        return new OHOSTargetInfo<ARMleTargetInfo>(Triple, Opts);
+      }
+    case llvm::Triple::LiteOS:
+      return new OHOSTargetInfo<ARMleTargetInfo>(Triple, Opts);
     case llvm::Triple::FreeBSD:
       return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
     case llvm::Triple::NetBSD:
       return new NetBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
     case llvm::Triple::OpenBSD:
       return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
     case llvm::Triple::RTEMS:
       return new RTEMSTargetInfo<ARMleTargetInfo>(Triple, Opts);
case llvm::Triple::NetBSD:
       return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
     default:
       return new MipsTargetInfo(Triple, Opts);
     }
 
   case llvm::Triple::mipsel:
     switch (os) {
     case llvm::Triple::Linux:
+      switch (Triple.getEnvironment()) {
+      default:
         return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
+      case llvm::Triple::OpenHOS:
+        return new OHOSTargetInfo<MipsTargetInfo>(Triple, Opts);
+      }
     case llvm::Triple::RTEMS:
       return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
     case llvm::Triple::FreeBSD:
       return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
     case llvm::Triple::NetBSD:
       return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
     case llvm::Triple::NaCl:
       return new NaClTargetInfo<NaClMips32TargetInfo>(Triple, Opts);
case llvm::Triple::riscv64:
     switch (os) {
     case llvm::Triple::FreeBSD:
       return new FreeBSDTargetInfo<RISCV64TargetInfo>(Triple, Opts);
     case llvm::Triple::OpenBSD:
       return new OpenBSDTargetInfo<RISCV64TargetInfo>(Triple, Opts);
     case llvm::Triple::Fuchsia:
       return new FuchsiaTargetInfo<RISCV64TargetInfo>(Triple, Opts);
     case llvm::Triple::Linux:
+      switch (Triple.getEnvironment()) {
+      default:
         return new LinuxTargetInfo<RISCV64TargetInfo>(Triple, Opts);
+      case llvm::Triple::OpenHOS:
+        return new OHOSTargetInfo<RISCV64TargetInfo>(Triple, Opts);
+      }
     default:
       return new RISCV64TargetInfo(Triple, Opts);
     }
 
   case llvm::Triple::sparc:
     switch (os) {
     case llvm::Triple::Linux:
       return new LinuxTargetInfo<SparcV8TargetInfo>(Triple, Opts);
case llvm::Triple::x86_64:
     case llvm::Triple::CloudABI:
       return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts);
     case llvm::Triple::Linux: {
       switch (Triple.getEnvironment()) {
       default:
         return new LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts);
       case llvm::Triple::Android:
         return new AndroidX86_64TargetInfo(Triple, Opts);
+      case llvm::Triple::OpenHOS:
+        return new OHOSX86_64TargetInfo(Triple, Opts);
       }
     }
     case llvm::Triple::DragonFly:
       return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
     case llvm::Triple::NetBSD:
       return new NetBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
     case llvm::Triple::OpenBSD:
       return new OpenBSDX86_64TargetInfo(Triple, Opts);

clang/lib/Basic/Targets/ARM.cpp

ARMTargetInfo::ARMTargetInfo(const llvm::Triple &Triple,
   } else {
     // Select the default based on the platform.
     switch (Triple.getEnvironment()) {
     case llvm::Triple::Android:
     case llvm::Triple::GNUEABI:
     case llvm::Triple::GNUEABIHF:
     case llvm::Triple::MuslEABI:
     case llvm::Triple::MuslEABIHF:
+    case llvm::Triple::OpenHOS:
       setABI("aapcs-linux");
       break;
     case llvm::Triple::EABIHF:
     case llvm::Triple::EABI:
       setABI("aapcs");
       break;
     case llvm::Triple::GNU:
       setABI("apcs-gnu");

clang/lib/Basic/Targets/OSTargets.h

explicit EmscriptenTargetInfo(const llvm::Triple &Triple,
     // 16 bytes allows emscripten to have an 8-byte-aligned max_align_t which
     // in turn gives is a 8-byte aligned malloc.
     // Emscripten's ABI is unstable and we may change this back to 128 to match
     // the WebAssembly default in the future.
     this->LongDoubleAlign = 64;
   }
 };
 
+// OHOS target
+template <typename Target>
+class LLVM_LIBRARY_VISIBILITY OHOSTargetInfo : public OSTargetInfo<Target> {
+protected:
+  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
+                    MacroBuilder &Builder) const override {
+    // Linux defines; list based off of gcc output
+    DefineStd(Builder, "unix", Opts);
+
+    Builder.defineMacro("__ELF__");
+
+    // Generic OHOS target defines
+    if (Triple.isOHOSFamily()) {
+      Builder.defineMacro("__OHOS_FAMILY__", "1");
+
+      auto Version = Triple.getEnvironmentVersion();
+      this->PlatformName = "ohos";
+      this->PlatformMinVersion = Version;
+      Builder.defineMacro("__OHOS_Major__", Twine(Version.getMajor()));
+      if (auto Minor = Version.getMinor())
+        Builder.defineMacro("__OHOS_Minor__", Twine(*Minor));
+      if (auto Subminor = Version.getSubminor())
+        Builder.defineMacro("__OHOS_Micro__", Twine(*Subminor));
+    }
+
+    if (Triple.isOpenHOS())
+      Builder.defineMacro("__OHOS__");
+
+    if (Triple.isOSLinux()) {
+      DefineStd(Builder, "linux", Opts);
+    } else if (Triple.isOSLiteOS()) {
+      Builder.defineMacro("__LITEOS__");
+    }
+
+    if (Opts.POSIXThreads)
+      Builder.defineMacro("_REENTRANT");
+    if (Opts.CPlusPlus)
+      Builder.defineMacro("_GNU_SOURCE");
+    if (this->HasFloat128)
+      Builder.defineMacro("__FLOAT128__");
+  }
+
+public:
+  OHOSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
+      : OSTargetInfo<Target>(Triple, Opts) {
+    this->WIntType = TargetInfo::UnsignedInt;
+
+    switch (Triple.getArch()) {
+    default:
+      break;
+    case llvm::Triple::x86:
+    case llvm::Triple::x86_64:
+      this->HasFloat128 = true;
+      break;
+    }
+  }
+
+  const char *getStaticInitSectionSpecifier() const override {
+    return ".text.startup";
+  }
+};
+
 } // namespace targets
 } // namespace clang
 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H

clang/lib/Basic/Targets/X86.h

 class LLVM_LIBRARY_VISIBILITY AndroidX86_64TargetInfo
     : public LinuxTargetInfo<X86_64TargetInfo> {
 public:
   AndroidX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts) {
     LongDoubleFormat = &llvm::APFloat::IEEEquad();
   }
 };
+
+// x86_32 OHOS target
+class LLVM_LIBRARY_VISIBILITY OHOSX86_32TargetInfo
+    : public OHOSTargetInfo<X86_32TargetInfo> {
+public:
+  OHOSX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
+      : OHOSTargetInfo<X86_32TargetInfo>(Triple, Opts) {
+    SuitableAlign = 32;
+    LongDoubleWidth = 64;
+    LongDoubleFormat = &llvm::APFloat::IEEEdouble();
+  }
+};
+
+// x86_64 OHOS target
+class LLVM_LIBRARY_VISIBILITY OHOSX86_64TargetInfo
+    : public OHOSTargetInfo<X86_64TargetInfo> {
+public:
+  OHOSX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
+      : OHOSTargetInfo<X86_64TargetInfo>(Triple, Opts) {
+    LongDoubleFormat = &llvm::APFloat::IEEEquad();
+  }
+};
 } // namespace targets
 } // namespace clang
 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_X86_H

clang/lib/CodeGen/ABIInfo.h

public:
     // the ABI information any lower than CodeGen. Of course, for
     // VAArg handling it has to be at this level; there is no way to
     // abstract this out.
     virtual CodeGen::Address EmitVAArg(CodeGen::CodeGenFunction &CGF,
                                        CodeGen::Address VAListAddr,
                                        QualType Ty) const = 0;
 
     bool isAndroid() const;
+    bool isOHOSFamily() const;
 
     /// Emit the target dependent code to load a value of
     /// \arg Ty from the \c __builtin_ms_va_list pointed to by \arg VAListAddr.
     virtual CodeGen::Address EmitMSVAArg(CodeGen::CodeGenFunction &CGF,
                                          CodeGen::Address VAListAddr,
                                          QualType Ty) const;
 
     virtual bool isHomogeneousAggregateBaseType(QualType Ty) const;

clang/lib/CodeGen/TargetInfo.cpp

 }
 
 const CodeGenOptions &ABIInfo::getCodeGenOpts() const {
   return CGT.getCodeGenOpts();
 }
 
 bool ABIInfo::isAndroid() const { return getTarget().getTriple().isAndroid(); }
 
+bool ABIInfo::isOHOSFamily() const {
+  return getTarget().getTriple().isOHOSFamily();
+}
+
 bool ABIInfo::isHomogeneousAggregateBaseType(QualType Ty) const {
   return false;
 }
 
 bool ABIInfo::isHomogeneousAggregateSmallEnough(const Type *Base,
                                                 uint64_t Members) const {
   return false;
 }
case BuiltinType::BFloat16:
           llvm::Type::getBFloatTy(getVMContext()), 8);
       break;
     }
     return ABIArgInfo::getDirect(ResType);
   }
 
   uint64_t Size = getContext().getTypeSize(Ty);
   // Android promotes <2 x i8> to i16, not i32
-  if (isAndroid() && (Size <= 16)) {
+  if ((isAndroid() || isOHOSFamily()) && (Size <= 16)) {
     llvm::Type *ResType = llvm::Type::getInt16Ty(getVMContext());
     return ABIArgInfo::getDirect(ResType);
   }
   if (Size <= 32) {
     llvm::Type *ResType = llvm::Type::getInt32Ty(getVMContext());
     return ABIArgInfo::getDirect(ResType);
   }
   if (Size == 64) {
bool isEABI() const {
     case llvm::Triple::EABI:
     case llvm::Triple::EABIHF:
     case llvm::Triple::GNUEABI:
     case llvm::Triple::GNUEABIHF:
     case llvm::Triple::MuslEABI:
     case llvm::Triple::MuslEABIHF:
       return true;
     default:
-      return false;
+      return getTarget().getTriple().isOHOSFamily();
     }
   }
 
   bool isEABIHF() const {
     switch (getTarget().getTriple().getEnvironment()) {
     case llvm::Triple::EABIHF:
     case llvm::Triple::GNUEABIHF:
     case llvm::Triple::MuslEABIHF:

clang/lib/Driver/CMakeLists.txt

add_clang_library(clangDriver
   ToolChains/MipsLinux.cpp
   ToolChains/MinGW.cpp
   ToolChains/Minix.cpp
   ToolChains/MSP430.cpp
   ToolChains/MSVC.cpp
   ToolChains/Myriad.cpp
   ToolChains/NaCl.cpp
   ToolChains/NetBSD.cpp
+  ToolChains/OHOS.cpp
   ToolChains/OpenBSD.cpp
   ToolChains/PS4CPU.cpp
   ToolChains/RISCVToolchain.cpp
   ToolChains/Solaris.cpp
   ToolChains/SPIRV.cpp
   ToolChains/TCE.cpp
   ToolChains/VEToolchain.cpp
   ToolChains/WebAssembly.cpp

clang/lib/Driver/Driver.cpp

 #include "ToolChains/MSP430.h"
 #include "ToolChains/MSVC.h"
 #include "ToolChains/MinGW.h"
 #include "ToolChains/Minix.h"
 #include "ToolChains/MipsLinux.h"
 #include "ToolChains/Myriad.h"
 #include "ToolChains/NaCl.h"
 #include "ToolChains/NetBSD.h"
+#include "ToolChains/OHOS.h"
 #include "ToolChains/OpenBSD.h"
 #include "ToolChains/PPCFreeBSD.h"
 #include "ToolChains/PPCLinux.h"
 #include "ToolChains/PS4CPU.h"
 #include "ToolChains/RISCVToolchain.h"
 #include "ToolChains/SPIRV.h"
 #include "ToolChains/Solaris.h"
 #include "ToolChains/TCE.h"
case llvm::Triple::ELFIAMCU:
                !Target.hasEnvironment())
         TC = std::make_unique<toolchains::MipsLLVMToolChain>(*this, Target,
                                                               Args);
       else if (Target.isPPC())
         TC = std::make_unique<toolchains::PPCLinuxToolChain>(*this, Target,
                                                               Args);
       else if (Target.getArch() == llvm::Triple::ve)
         TC = std::make_unique<toolchains::VEToolChain>(*this, Target, Args);
-
+      else if (Target.isOHOSFamily())
+        TC = std::make_unique<toolchains::OHOS>(*this, Target, Args);
       else
         TC = std::make_unique<toolchains::Linux>(*this, Target, Args);
       break;
     case llvm::Triple::NaCl:
       TC = std::make_unique<toolchains::NaClToolChain>(*this, Target, Args);
       break;
     case llvm::Triple::Fuchsia:
       TC = std::make_unique<toolchains::Fuchsia>(*this, Target, Args);
case llvm::Triple::PS5:
       TC = std::make_unique<toolchains::PS5CPU>(*this, Target, Args);
       break;
     case llvm::Triple::Contiki:
       TC = std::make_unique<toolchains::Contiki>(*this, Target, Args);
       break;
     case llvm::Triple::Hurd:
       TC = std::make_unique<toolchains::Hurd>(*this, Target, Args);
       break;
+    case llvm::Triple::LiteOS:
+      TC = std::make_unique<toolchains::OHOS>(*this, Target, Args);
+      break;
     case llvm::Triple::ZOS:
       TC = std::make_unique<toolchains::ZOS>(*this, Target, Args);
       break;
     case llvm::Triple::ShaderModel:
       TC = std::make_unique<toolchains::HLSLToolChain>(*this, Target, Args);
       break;
     default:
       // Of these targets, Hexagon is the only one that might have

clang/lib/Driver/ToolChains/Arch/AArch64.cpp

if (Args.hasArg(options::OPT_mno_neg_immediates))
     Features.push_back("+no-neg-immediates");
 
   if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
                                options::OPT_mno_fix_cortex_a53_835769)) {
     if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
       Features.push_back("+fix-cortex-a53-835769");
     else
       Features.push_back("-fix-cortex-a53-835769");
-  } else if (Triple.isAndroid()) {
+  } else if (Triple.isAndroid() || Triple.isOHOSFamily()) {
     // Enabled A53 errata (835769) workaround by default on android
     Features.push_back("+fix-cortex-a53-835769");
   } else if (Triple.isOSFuchsia()) {
     std::string CPU = getCPUName(D, Args, Triple);
     if (CPU.empty() || CPU == "generic" || CPU == "cortex-a53")
       Features.push_back("+fix-cortex-a53-835769");
   }
 
   if (Args.getLastArg(options::OPT_mno_bti_at_return_twice))
     Features.push_back("+no-bti-at-return-twice");
 }

clang/lib/Driver/ToolChains/Arch/ARM.cpp

if (IsThumb || IsMProfile || Triple.isOSWindows()) {
     else
       ArchName = "thumb";
   }
   Triple.setArchName(ArchName + Suffix.str());
 }
 
 void arm::setFloatABIInTriple(const Driver &D, const ArgList &Args,
                               llvm::Triple &Triple) {
+  if (Triple.isOSLiteOS()) {
+    Triple.setEnvironment(llvm::Triple::OpenHOS);
+    return;
+  }
+
   bool isHardFloat =
       (arm::getARMFloatABI(D, Triple, Args) == arm::FloatABI::Hard);
 
   switch (Triple.getEnvironment()) {
   case llvm::Triple::GNUEABI:
   case llvm::Triple::GNUEABIHF:
     Triple.setEnvironment(isHardFloat ? llvm::Triple::GNUEABIHF
                                       : llvm::Triple::GNUEABI);
     break;
   case llvm::Triple::EABI:
   case llvm::Triple::EABIHF:
     Triple.setEnvironment(isHardFloat ? llvm::Triple::EABIHF
                                       : llvm::Triple::EABI);
     break;
   case llvm::Triple::MuslEABI:
   case llvm::Triple::MuslEABIHF:
     Triple.setEnvironment(isHardFloat ? llvm::Triple::MuslEABIHF
                                       : llvm::Triple::MuslEABI);
     break;
+  case llvm::Triple::OpenHOS:
+    break;
   default: {
     arm::FloatABI DefaultABI = arm::getDefaultFloatABI(Triple);
     if (DefaultABI != arm::FloatABI::Invalid &&
         isHardFloat != (DefaultABI == arm::FloatABI::Hard)) {
       Arg *ABIArg =
           Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
                           options::OPT_mfloat_abi_EQ);
       assert(ABIArg && "Non-default float abi expected to be from arg");
default:
       return FloatABI::Soft;
     }
     break;
 
   case llvm::Triple::OpenBSD:
     return FloatABI::SoftFP;
 
   default:
+    if (Triple.isOHOSFamily())
+      return FloatABI::Soft;
     switch (Triple.getEnvironment()) {
     case llvm::Triple::GNUEABIHF:
     case llvm::Triple::MuslEABIHF:
     case llvm::Triple::EABIHF:
       return FloatABI::Hard;
     case llvm::Triple::GNUEABI:
     case llvm::Triple::MuslEABI:
     case llvm::Triple::EABI:

clang/lib/Driver/ToolChains/CommonArgs.cpp

 
 void tools::linkSanitizerRuntimeDeps(const ToolChain &TC,
                                      ArgStringList &CmdArgs) {
   // Force linking against the system libraries sanitizers depends on
   // (see PR15823 why this is necessary).
   CmdArgs.push_back(getAsNeededOption(TC, false));
   // There's no libpthread or librt on RTEMS & Android.
   if (TC.getTriple().getOS() != llvm::Triple::RTEMS &&
-      !TC.getTriple().isAndroid()) {
+      !TC.getTriple().isAndroid() && !TC.getTriple().isOHOSFamily()) {
     CmdArgs.push_back("-lpthread");
     if (!TC.getTriple().isOSOpenBSD())
       CmdArgs.push_back("-lrt");
   }
   CmdArgs.push_back("-lm");
   // There's no libdl on all OSes.
   if (!TC.getTriple().isOSFreeBSD() && !TC.getTriple().isOSNetBSD() &&
       !TC.getTriple().isOSOpenBSD() &&
case llvm::Triple::x86_64:
       IsPICLevelTwo = true;
       break;
 
     default:
       break;
     }
   }
 
+  // OHOS-specific defaults for PIC/PIE
+  if (Triple.isOHOSFamily() && Triple.getArch() == llvm::Triple::aarch64)
+    PIC = true;
+
   // OpenBSD-specific defaults for PIE
   if (Triple.isOSOpenBSD()) {
     switch (ToolChain.getArch()) {
     case llvm::Triple::arm:
     case llvm::Triple::aarch64:
     case llvm::Triple::mips64:
     case llvm::Triple::mips64el:
     case llvm::Triple::x86:

 // gcc static-pie: -lgcc             -lgcc_eh
 // g++ static-pie: -lgcc             -lgcc_eh
 //
 // Also, certain targets need additional adjustments.
 
 static void AddUnwindLibrary(const ToolChain &TC, const Driver &D,
                              ArgStringList &CmdArgs, const ArgList &Args) {
   ToolChain::UnwindLibType UNW = TC.GetUnwindLibType(Args);
+  // By default OHOS binaries are linked statically to libunwind.
+  if (TC.getTriple().isOHOSFamily() && UNW == ToolChain::UNW_CompilerRT) {
+    CmdArgs.push_back("-l:libunwind.a");
+    return;
+  }
+
   // Targets that don't use unwind libraries.
   if ((TC.getTriple().isAndroid() && UNW == ToolChain::UNW_Libgcc) ||
       TC.getTriple().isOSIAMCU() || TC.getTriple().isOSBinFormatWasm() ||
       TC.getTriple().isWindowsMSVCEnvironment() || UNW == ToolChain::UNW_None)
     return;
 
   LibGccType LGT = getLibGccType(TC, D, Args);
   bool AsNeeded = LGT == LibGccType::UnspecifiedLibGcc &&

clang/lib/Driver/ToolChains/Gnu.cpp

void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   // Generic_ELF instead.
   const toolchains::Generic_ELF &ToolChain =
       static_cast<const toolchains::Generic_ELF &>(getToolChain());
   const Driver &D = ToolChain.getDriver();
 
   const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
 
   const llvm::Triple::ArchType Arch = ToolChain.getArch();
+  const bool isOHOSFamily = ToolChain.getTriple().isOHOSFamily();
   const bool isAndroid = ToolChain.getTriple().isAndroid();
   const bool IsIAMCU = ToolChain.getTriple().isOSIAMCU();
   const bool IsVE = ToolChain.getTriple().isVE();
   const bool IsPIE = getPIE(Args, ToolChain);
   const bool IsStaticPIE = getStaticPIE(Args, ToolChain);
   const bool IsStatic = getStatic(Args);
   const bool HasCRTBeginEndFiles =
       ToolChain.getTriple().hasEnvironment() ||
if (Triple.isARM() || Triple.isThumb() || Triple.isAArch64()) {
     if (IsBigEndian)
       arm::appendBE8LinkFlag(Args, CmdArgs, Triple);
     IsBigEndian = IsBigEndian || Arch == llvm::Triple::aarch64_be;
     CmdArgs.push_back(IsBigEndian ? "-EB" : "-EL");
   }
 
   // Most Android ARM64 targets should enable the linker fix for erratum
   // 843419. Only non-Cortex-A53 devices are allowed to skip this flag.
-  if (Arch == llvm::Triple::aarch64 && isAndroid) {
+  if (Arch == llvm::Triple::aarch64 && (isAndroid || isOHOSFamily)) {
     std::string CPU = getCPUName(D, Args, Triple);
     if (CPU.empty() || CPU == "generic" || CPU == "cortex-a53")
       CmdArgs.push_back("--fix-cortex-a53-843419");
   }
 
   ToolChain.addExtraOpts(CmdArgs);
 
   CmdArgs.push_back("--eh-frame-hdr");
if (!Args.hasArg(options::OPT_nodefaultlibs)) {
       // TODO: Issue #41880 and D118021.
       if (getToolChain().getTriple().getArch() == llvm::Triple::sparc) {
         CmdArgs.push_back("--push-state");
         CmdArgs.push_back("--as-needed");
         CmdArgs.push_back("-latomic");
         CmdArgs.push_back("--pop-state");
       }
 
-      if (WantPthread && !isAndroid)
+      // We don't need libpthread neither for bionic (Android) nor for musl,
+      // (used by OHOS as runtime library).
+      if (WantPthread && !isAndroid && !isOHOSFamily)
         CmdArgs.push_back("-lpthread");
 
       if (Args.hasArg(options::OPT_fsplit_stack))
         CmdArgs.push_back("--wrap=pthread_create");
 
       if (!Args.hasArg(options::OPT_nolibc))
         CmdArgs.push_back("-lc");
 
/*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
 
   static const char *const MIPSLibDirs[] = {"/libo32", "/lib"};
   static const char *const MIPSTriples[] = {
       "mips-linux-gnu", "mips-mti-linux", "mips-mti-linux-gnu",
       "mips-img-linux-gnu", "mipsisa32r6-linux-gnu"};
   static const char *const MIPSELLibDirs[] = {"/libo32", "/lib"};
   static const char *const MIPSELTriples[] = {
       "mipsel-linux-gnu", "mips-img-linux-gnu", "mipsisa32r6el-linux-gnu"};
 
   static const char *const MIPS64LibDirs[] = {"/lib64", "/lib"};
   static const char *const MIPS64Triples[] = {
       "mips64-linux-gnu",      "mips-mti-linux-gnu",
       "mips-img-linux-gnu",    "mips64-linux-gnuabi64",
       "mipsisa64r6-linux-gnu", "mipsisa64r6-linux-gnuabi64"};
   static const char *const MIPS64ELLibDirs[] = {"/lib64", "/lib"};
   static const char *const MIPS64ELTriples[] = {
       "mips64el-linux-gnu",      "mips-mti-linux-gnu",

clang/lib/Driver/ToolChains/OHOS.h

+//===--- OHOS.h - OHOS 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_OHOS_H
+#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_OHOS_H
+
+#include "Linux.h"
+#include "clang/Driver/Tool.h"
+#include "clang/Driver/ToolChain.h"
+
+namespace clang {
+namespace driver {
+namespace toolchains {
+
+class LLVM_LIBRARY_VISIBILITY OHOS : public Generic_ELF {
+public:
+  OHOS(const Driver &D, const llvm::Triple &Triple,
+          const llvm::opt::ArgList &Args);
+
+  bool HasNativeLLVMSupport() const override { return true; }
+  bool IsIntegratedAssemblerDefault() const override { return true; }
+  bool IsMathErrnoDefault() const override { return false; }
+  RuntimeLibType GetDefaultRuntimeLibType() const override {
+    return ToolChain::RLT_CompilerRT;
+  }
+  CXXStdlibType GetDefaultCXXStdlibType() const override {
+    return ToolChain::CST_Libcxx;
+  }
+  // Not add -funwind-tables by default
+  bool isPICDefault() const override { return false; }
+  bool isPIEDefault(const llvm::opt::ArgList &Args) const override { return true; }
+  bool isPICDefaultForced() const override { return false; }
+  bool useRelaxRelocations() const override { return false; }
+  UnwindLibType GetUnwindLibType(const llvm::opt::ArgList &Args) const override;
+  UnwindLibType GetDefaultUnwindLibType() const override { return UNW_CompilerRT; }
+
+  RuntimeLibType
+  GetRuntimeLibType(const llvm::opt::ArgList &Args) const override;
+  CXXStdlibType
+  GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
+
+  void
+  AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+                            llvm::opt::ArgStringList &CC1Args) const override;
+  void
+  AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+                               llvm::opt::ArgStringList &CC1Args) const override;
+  void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
+                           llvm::opt::ArgStringList &CmdArgs) const override;
+
+  std::string computeSysRoot() const override;
+  std::string getDynamicLinker(const llvm::opt::ArgList &Args) const override;
+
+  std::string
+  getCompilerRT(const llvm::opt::ArgList &Args, StringRef Component,
+                FileType Type = ToolChain::FT_Static) const override;
+
+  const char *getDefaultLinker() const override {
+    return "ld.lld";
+  }
+
+  Tool *buildLinker() const override {
+    return new tools::gnutools::Linker(*this);
+  }
+  Tool *buildAssembler() const override {
+    return new tools::gnutools::Assembler(*this);
+  }
+
+  path_list getRuntimePaths() const;
+
+protected:
+  std::string getMultiarchTriple(const llvm::Triple &T) const;
+  std::string getMultiarchTriple(const Driver &D,
+                                 const llvm::Triple &TargetTriple,
+                                 StringRef SysRoot) const override;
+  void addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const override;
+  SanitizerMask getSupportedSanitizers() const override;
+  void addProfileRTLibs(const llvm::opt::ArgList &Args,
+                             llvm::opt::ArgStringList &CmdArgs) const override;
+  std::string getArchSpecificLibPath() const override;
+private:
+  Multilib SelectedMultilib;
+};
+
+} // end namespace toolchains
+} // end namespace driver
+} // end namespace clang
+
+#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_OHOS_H

clang/lib/Driver/ToolChains/OHOS.cpp

+//===--- OHOS.cpp - OHOS 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 "OHOS.h"
+#include "Arch/ARM.h"
+#include "CommonArgs.h"
+#include "clang/Config/config.h"
+#include "clang/Driver/Compilation.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/DriverDiagnostic.h"
+#include "clang/Driver/Options.h"
+#include "clang/Driver/SanitizerArgs.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/ProfileData/InstrProf.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+using namespace clang::driver;
+using namespace clang::driver::toolchains;
+using namespace clang::driver::tools;
+using namespace clang;
+using namespace llvm::opt;
+using namespace clang::driver::tools::arm;
+
+using tools::addMultilibFlag;
+using tools::addPathIfExists;
+
+static bool findOHOSMuslMultilibs(const Multilib::flags_list &Flags,
+                                  DetectedMultilibs &Result) {
+  MultilibSet Multilibs;
+  Multilibs.push_back(Multilib());
+  // -mcpu=cortex-a7
+  // -mfloat-abi=soft -mfloat-abi=softfp -mfloat-abi=hard
+  // -mfpu=neon-vfpv4
+  Multilibs.push_back(Multilib("/a7_soft", {}, {}, 1,
+                          {"+mcpu=cortex-a7", "+mfloat-abi=soft"}));
+
+  Multilibs.push_back(Multilib("/a7_softfp_neon-vfpv4", {}, {}, 1,
+                          {"+mcpu=cortex-a7", "+mfloat-abi=softfp", "+mfpu=neon-vfpv4"}));
+
+  Multilibs.push_back(Multilib("/a7_hard_neon-vfpv4", {}, {}, 1,
+                          {"+mcpu=cortex-a7", "+mfloat-abi=hard", "+mfpu=neon-vfpv4"}));
+
+  if (Multilibs.select(Flags, Result.SelectedMultilib)) {
+    Result.Multilibs = Multilibs;
+    return true;
+  }
+  return false;
+}
+
+static bool findOHOSMultilibs(const Driver &D,
+                                      const ToolChain &TC,
+                                      const llvm::Triple &TargetTriple,
+                                      StringRef Path, const ArgList &Args,
+                                      DetectedMultilibs &Result) {
+  Multilib::flags_list Flags;
+  bool IsA7 = false;
+  if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
+    IsA7 = A->getValue() == StringRef("cortex-a7");
+  addMultilibFlag(IsA7, "mcpu=cortex-a7", Flags);
+
+  bool IsMFPU = false;
+  if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
+    IsMFPU = A->getValue() == StringRef("neon-vfpv4");
+  addMultilibFlag(IsMFPU, "mfpu=neon-vfpv4", Flags);
+
+  tools::arm::FloatABI ARMFloatABI = getARMFloatABI(D, TargetTriple, Args);
+  addMultilibFlag((ARMFloatABI == tools::arm::FloatABI::Soft),
+      "mfloat-abi=soft", Flags);
+  addMultilibFlag((ARMFloatABI == tools::arm::FloatABI::SoftFP),
+      "mfloat-abi=softfp", Flags);
+  addMultilibFlag((ARMFloatABI == tools::arm::FloatABI::Hard),
+      "mfloat-abi=hard", Flags);
+
+  return findOHOSMuslMultilibs(Flags, Result);
+}
+
+std::string OHOS::getMultiarchTriple(const llvm::Triple &T) const {
+  // For most architectures, just use whatever we have rather than trying to be
+  // clever.
+  switch (T.getArch()) {
+  default:
+    break;
+
+  // We use the existence of '/lib/<triple>' as a directory to detect some
+  // common linux triples that don't quite match the Clang triple for both
+  // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
+  // regardless of what the actual target triple is.
+  case llvm::Triple::arm:
+  case llvm::Triple::thumb:
+    return T.isOSLiteOS() ? "arm-liteos-ohos" : "arm-linux-ohos";
+  case llvm::Triple::riscv32:
+    return "riscv32-linux-ohos";
+  case llvm::Triple::riscv64:
+    return "riscv64-linux-ohos";
+  case llvm::Triple::mipsel:
+    return "mipsel-linux-ohos";
+  case llvm::Triple::x86:
+    return "i686-linux-ohos";
+  case llvm::Triple::x86_64:
+    return "x86_64-linux-ohos";
+  case llvm::Triple::aarch64:
+    return "aarch64-linux-ohos";
+  }
+  return T.str();
+}
+
+std::string OHOS::getMultiarchTriple(const Driver &D,
+                                     const llvm::Triple &TargetTriple,
+                                     StringRef SysRoot) const {
+  return getMultiarchTriple(TargetTriple);
+}
+
+static std::string makePath(const std::initializer_list<std::string> &IL) {
+  SmallString<128> P;
+  for (const auto &S : IL)
+    llvm::sys::path::append(P, S);
+  return static_cast<std::string>(P.str());
+}
+
+/// OHOS Toolchain
+OHOS::OHOS(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
+    : Generic_ELF(D, Triple, Args) {
+  std::string SysRoot = computeSysRoot();
+
+  // Select the correct multilib according to the given arguments.
+  DetectedMultilibs Result;
+  findOHOSMultilibs(D, *this, Triple, "", Args, Result);
+  Multilibs = Result.Multilibs;
+  SelectedMultilib = Result.SelectedMultilib;
+
+  getFilePaths().clear();
+  std::string CandidateLibPath = getArchSpecificLibPath();
+  if (getVFS().exists(CandidateLibPath))
+    getFilePaths().push_back(CandidateLibPath);
+
+  getLibraryPaths().clear();
+  for (auto &Path : getRuntimePaths())
+    if (getVFS().exists(Path))
+      getLibraryPaths().push_back(Path);
+
+  // OHOS sysroots contain a library directory for each supported OS
+  // version as well as some unversioned libraries in the usual multiarch
+  // directory. Support --target=aarch64-linux-ohosX.Y.Z or
+  // --target=aarch64-linux-ohosX.Y or --target=aarch64-linux-ohosX
+  path_list &Paths = getFilePaths();
+  std::string SysRootLibPath = makePath({SysRoot, "usr", "lib"});
+  std::string MultiarchTriple = getMultiarchTriple(getTriple());
+  addPathIfExists(D, makePath({SysRootLibPath, SelectedMultilib.gccSuffix()}),
+                  Paths);
+  addPathIfExists(D,
+                  makePath({D.Dir, "..", "lib", MultiarchTriple,
+                            SelectedMultilib.gccSuffix()}),
+                  Paths);
+
+  addPathIfExists(
+      D,
+      makePath({SysRootLibPath, MultiarchTriple, SelectedMultilib.gccSuffix()}),
+      Paths);
+}
+
+ToolChain::RuntimeLibType OHOS::GetRuntimeLibType(
+    const ArgList &Args) const {
+  if (Arg *A = Args.getLastArg(clang::driver::options::OPT_rtlib_EQ)) {
+    StringRef Value = A->getValue();
+    if (Value != "compiler-rt")
+      getDriver().Diag(clang::diag::err_drv_invalid_rtlib_name)
+          << A->getAsString(Args);
+  }
+
+  return ToolChain::RLT_CompilerRT;
+}
+
+ToolChain::CXXStdlibType
+OHOS::GetCXXStdlibType(const ArgList &Args) const {
+  if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
+    StringRef Value = A->getValue();
+    if (Value != "libc++")
+      getDriver().Diag(diag::err_drv_invalid_stdlib_name)
+        << A->getAsString(Args);
+  }
+
+  return ToolChain::CST_Libcxx;
+}
+
+void OHOS::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
+                                        ArgStringList &CC1Args) const {
+  const Driver &D = getDriver();
+  const llvm::Triple &Triple = getTriple();
+  std::string SysRoot = computeSysRoot();
+
+  if (DriverArgs.hasArg(options::OPT_nostdinc))
+    return;
+
+  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;
+
+  // 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;
+  }
+
+  addExternCSystemInclude(DriverArgs, CC1Args,
+                          SysRoot + "/usr/include/" +
+                              getMultiarchTriple(Triple));
+  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
+  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
+}
+
+void OHOS::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
+                                        ArgStringList &CC1Args) const {
+  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
+      DriverArgs.hasArg(options::OPT_nostdincxx))
+    return;
+
+  switch (GetCXXStdlibType(DriverArgs)) {
+  case ToolChain::CST_Libcxx: {
+    std::string IncPath = makePath({getDriver().Dir, "..", "include"});
+    std::string IncTargetPath =
+        makePath({IncPath, getMultiarchTriple(getTriple()), "c++", "v1"});
+    if (getVFS().exists(IncTargetPath)) {
+      addSystemInclude(DriverArgs, CC1Args, makePath({IncPath, "c++", "v1"}));
+      addSystemInclude(DriverArgs, CC1Args, IncTargetPath);
+    }
+    break;
+  }
+
+  default:
+    llvm_unreachable("invalid stdlib name");
+  }
+}
+
+void OHOS::AddCXXStdlibLibArgs(const ArgList &Args,
+                                  ArgStringList &CmdArgs) const {
+  switch (GetCXXStdlibType(Args)) {
+  case ToolChain::CST_Libcxx:
+    CmdArgs.push_back("-lc++");
+    CmdArgs.push_back("-lc++abi");
+    CmdArgs.push_back("-lunwind");
+    break;
+
+  case ToolChain::CST_Libstdcxx:
+    llvm_unreachable("invalid stdlib name");
+  }
+}
+
+std::string OHOS::computeSysRoot() const {
+  std::string SysRoot =
+      !getDriver().SysRoot.empty()
+          ? getDriver().SysRoot
+          : makePath({getDriver().getInstalledDir(), "..", "..", "sysroot"});
+  if (!llvm::sys::fs::exists(SysRoot))
+    return std::string();
+
+  std::string ArchRoot = makePath({SysRoot, getMultiarchTriple(getTriple())});
+  return llvm::sys::fs::exists(ArchRoot) ? ArchRoot : SysRoot;
+}
+
+ToolChain::path_list OHOS::getRuntimePaths() const {
+  SmallString<128> P;
+  path_list Paths;
+  const Driver &D = getDriver();
+  const llvm::Triple &Triple = getTriple();
+
+  // First try the triple passed to driver as --target=<triple>.
+  P.assign(D.ResourceDir);
+  llvm::sys::path::append(P, "lib", D.getTargetTriple(), SelectedMultilib.gccSuffix());
+  Paths.push_back(P.c_str());
+
+  // Second try the normalized triple.
+  P.assign(D.ResourceDir);
+  llvm::sys::path::append(P, "lib", Triple.str(), SelectedMultilib.gccSuffix());
+  Paths.push_back(P.c_str());
+
+  // Third try the effective triple.
+  P.assign(D.ResourceDir);
+  std::string SysRoot = computeSysRoot();
+  llvm::sys::path::append(P, "lib", getMultiarchTriple(Triple),
+                          SelectedMultilib.gccSuffix());
+  Paths.push_back(P.c_str());
+
+  return Paths;
+}
+
+std::string OHOS::getDynamicLinker(const ArgList &Args) const {
+  const llvm::Triple &Triple = getTriple();
+  const llvm::Triple::ArchType Arch = getArch();
+
+  assert(Triple.isMusl());
+  std::string ArchName;
+  bool IsArm = false;
+
+  switch (Arch) {
+  case llvm::Triple::arm:
+  case llvm::Triple::thumb:
+    ArchName = "arm";
+    IsArm = true;
+    break;
+  case llvm::Triple::armeb:
+  case llvm::Triple::thumbeb:
+    ArchName = "armeb";
+    IsArm = true;
+    break;
+  default:
+    ArchName = Triple.getArchName().str();
+  }
+  if (IsArm &&
+      (tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard))
+    ArchName += "hf";
+
+  return "/lib/ld-musl-" + ArchName + ".so.1";
+}
+
+std::string OHOS::getCompilerRT(const ArgList &Args, StringRef Component,
+                                FileType Type) const {
+  SmallString<128> Path(getDriver().ResourceDir);
+  llvm::sys::path::append(Path, "lib", getMultiarchTriple(getTriple()),
+                          SelectedMultilib.gccSuffix());
+  const char *Prefix =
+      Type == ToolChain::FT_Object ? "" : "lib";
+  const char *Suffix;
+  switch (Type) {
+  case ToolChain::FT_Object:
+    Suffix = ".o";
+    break;
+  case ToolChain::FT_Static:
+    Suffix = ".a";
+    break;
+  case ToolChain::FT_Shared:
+    Suffix = ".so";
+    break;
+  }
+  llvm::sys::path::append(
+      Path, Prefix + Twine("clang_rt.") + Component + Suffix);
+  return static_cast<std::string>(Path.str());
+}
+
+void OHOS::addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const {
+  CmdArgs.push_back("-z");
+  CmdArgs.push_back("now");
+  CmdArgs.push_back("-z");
+  CmdArgs.push_back("relro");
+  CmdArgs.push_back("-z");
+  CmdArgs.push_back("max-page-size=4096");
+  // .gnu.hash section is not compatible with the MIPS target
+  if (getArch() != llvm::Triple::mipsel)
+    CmdArgs.push_back("--hash-style=both");
+#ifdef ENABLE_LINKER_BUILD_ID
+  CmdArgs.push_back("--build-id");
+#endif
+  CmdArgs.push_back("--enable-new-dtags");
+}
+
+SanitizerMask OHOS::getSupportedSanitizers() const {
+  SanitizerMask Res = ToolChain::getSupportedSanitizers();
+  Res |= SanitizerKind::Address;
+  Res |= SanitizerKind::PointerCompare;
+  Res |= SanitizerKind::PointerSubtract;
+  Res |= SanitizerKind::Fuzzer;
+  Res |= SanitizerKind::FuzzerNoLink;
+  Res |= SanitizerKind::Memory;
+  Res |= SanitizerKind::Vptr;
+  Res |= SanitizerKind::SafeStack;
+  Res |= SanitizerKind::Scudo;
+  // TODO: kASAN for liteos ??
+  // TODO: Support TSAN and HWASAN and update mask.
+  return Res;
+}
+
+// TODO: Make a base class for Linux and OHOS and move this there.
+void OHOS::addProfileRTLibs(const llvm::opt::ArgList &Args,
+                             llvm::opt::ArgStringList &CmdArgs) const {
+  // Add linker option -u__llvm_profile_runtime to cause runtime
+  // initialization module to be linked in.
+  if (needsProfileRT(Args))
+    CmdArgs.push_back(Args.MakeArgString(
+        Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
+  ToolChain::addProfileRTLibs(Args, CmdArgs);
+}
+
+std::string OHOS::getArchSpecificLibPath() const {
+  llvm::Triple Triple = getTriple();
+  return makePath({getDriver().ResourceDir, "lib", getMultiarchTriple(Triple)});
+}
+
+ToolChain::UnwindLibType OHOS::GetUnwindLibType(const llvm::opt::ArgList &Args) const {
+  if (const Arg *A = Args.getLastArg(options::OPT_unwindlib_EQ))
+    return Generic_ELF::GetUnwindLibType(Args);
+  return GetDefaultUnwindLibType();
+}

clang/test/CodeGen/aarch64-fix-cortex-a53-835769.c

 // RUN: %clang -O3 -target aarch64-linux-eabi %s -S -o- \
 // RUN:   | FileCheck --check-prefix=CHECK-NO --check-prefix=CHECK %s
 // RUN: %clang -O3 -target aarch64-linux-eabi -mfix-cortex-a53-835769 %s -S -o- 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-YES --check-prefix=CHECK %s
 // RUN: %clang -O3 -target aarch64-linux-eabi -mno-fix-cortex-a53-835769 %s -S -o- 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-NO --check-prefix=CHECK %s
 
 // RUN: %clang -O3 -target aarch64-android-eabi %s -S -o- \
 // RUN:   | FileCheck --check-prefix=CHECK-YES --check-prefix=CHECK %s
+// RUN: %clang -O3 -target aarch64-linux-ohos %s -S -o- \
+// RUN:   | FileCheck --check-prefix=CHECK-YES --check-prefix=CHECK %s
 // RUN: %clang -O3 -target aarch64-android-eabi -mfix-cortex-a53-835769 %s -S -o- \
 // RUN:   | FileCheck --check-prefix=CHECK-YES --check-prefix=CHECK %s
 // RUN: %clang -O3 -target aarch64-android-eabi -mno-fix-cortex-a53-835769 %s -S -o- \
 // RUN:   | FileCheck --check-prefix=CHECK-NO --check-prefix=CHECK %s
 
 // REQUIRES: aarch64-registered-target
 
 typedef long int64_t;

clang/test/Driver/ohos.c

+// RUN: %clang %s -### -no-canonical-prefixes --target=arm-liteos \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     --sysroot=%S/Inputs/ohos_native_tree/sysroot -fuse-ld=lld -march=armv7-a 2>&1 \
+// RUN:     | FileCheck -check-prefixes=CHECK,CHECK-ARM %s
+// RUN: %clang %s -### -no-canonical-prefixes --target=arm-liteos \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     --sysroot=%S/Inputs/ohos_native_tree/sysroot -fuse-ld=lld -march=armv7-a -mcpu=cortex-a7 -mfloat-abi=soft 2>&1 \
+// RUN:     | FileCheck -check-prefixes=CHECK,CHECK-ARM-A7-SOFT %s
+// CHECK: {{.*}}clang{{.*}}" "-cc1"
+// CHECK-NOT: "--mrelax-relocations"
+// CHECK-NOT: "-munwind-tables"
+// CHECK: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
+// CHECK: "-isysroot" "[[SYSROOT:[^"]+]]"
+// CHECK: "-internal-externc-isystem" "[[SYSROOT]]{{/|\\\\}}include"
+// CHECK-NOT: "-fsanitize=safe-stack"
+// CHECK-NOT: "-stack-protector" "2"
+// CHECK-NOT: "-fno-common"
+// CHECK: {{.*}}ld.lld{{.*}}" "--sysroot=[[SYSROOT]]"
+// CHECK-NOT: "--sysroot=[[SYSROOT]]"
+// CHECK: "-pie"
+// CHECK-NOT: "--build-id"
+// CHECK: "--hash-style=both"
+// CHECK: "-dynamic-linker" "/lib/ld-musl-arm.so.1"
+// CHECK: Scrt1.o
+// CHECK: crti.o
+// CHECK: clang_rt.crtbegin.o
+// CHECK-ARM: "-L[[SYSROOT]]/usr/lib/arm-liteos-ohos/"
+// CHECK-ARM-A7-SOFT: "-L[[SYSROOT]]/usr/lib/arm-liteos-ohos/a7_soft"
+// CHECK-ARM: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.builtins.a"
+// CHECK-ARM-A7-SOFT: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos/a7_soft{{/|\\\\}}libclang_rt.builtins.a"
+// CHECK: "-lc"
+// CHECK: clang_rt.crtend.o
+// CHECK: crtn.o
+
+// RUN: %clang %s -### --target=arm-liteos -rtlib=libgcc -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-RTLIB
+// CHECK-RTLIB: error: invalid runtime library name in argument '-rtlib=libgcc'
+
+// RUN: %clang %s -### --target=arm-liteos -static -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-STATIC
+// CHECK-STATIC: "-static"
+// CHECK-STATIC-NOT: "-Bdynamic"
+// CHECK-STATIC: "-l:libunwind.a"
+// CHECK-STATIC: "-lc"
+
+// RUN: %clang %s -### --target=arm-liteos -shared -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-SHARED
+// CHECK-SHARED-NOT: "-pie"
+// CHECK-SHARED: "-shared"
+// CHECK-SHARED: "-lc"
+// CHECK-SHARED: "-l:libunwind.a"
+
+// RUN: %clang %s -### --target=arm-linux-ohos -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-RUNTIME
+// RUN: %clang %s -### --target=aarch64-linux-ohos -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-RUNTIME
+// RUN: %clang %s -### --target=mipsel-linux-ohos -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-RUNTIME
+// RUN: %clang %s -### --target=x86_64-linux-ohos -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-RUNTIME
+// CHECK-RUNTIME: "{{.*}}/libclang_rt.builtins.a"
+// CHECK-RUNTIME: "-l:libunwind.a"
+// CHECK-LIBM: "-lm"
+
+// RUN: %clang %s -### --target=arm-liteos -r -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-RELOCATABLE
+// CHECK-RELOCATABLE-NOT: "-pie"
+// CHECK-RELOCATABLE-NOT: "--build-id"
+// CHECK-RELOCATABLE: "-r"
+
+// RUN: %clang %s -### --target=arm-liteos -nodefaultlibs -fuse-ld=lld 2>&1 \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     | FileCheck %s -check-prefix=CHECK-NODEFAULTLIBS
+// CHECK-NODEFAULTLIBS: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
+// CHECK-NODEFAULTLIBS-NOT: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.builtins.a"
+// CHECK-NODEFAULTLIBS-NOT: "-lc"
+
+// RUN: %clang %s -### --target=arm-liteos -nostdlib -fuse-ld=lld 2>&1 \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     | FileCheck %s -check-prefix=CHECK-NOSTDLIB
+// CHECK-NOSTDLIB: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
+// CHECK-NOSTDLIB-NOT: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.builtins.a"
+// CHECK-NOSTDLIB-NOT: "-lc"
+
+// RUN: %clang %s -### --target=arm-liteos -nolibc -fuse-ld=lld 2>&1 \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     | FileCheck %s -check-prefix=CHECK-NOLIBC
+// CHECK-NOLIBC: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
+// CHECK-NOLIBC: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.builtins.a"
+// CHECK-NOLIBC-NOT: "-lc"
+
+// RUN: %clang %s -### --target=arm-liteos \
+// RUN:     -fsanitize=safe-stack 2>&1 \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     -fuse-ld=lld \
+// RUN:     | FileCheck %s -check-prefix=CHECK-SAFESTACK
+// CHECK-SAFESTACK: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
+// CHECK-SAFESTACK: "-fsanitize=safe-stack"
+// CHECK-SAFESTACK: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.safestack.a"
+// CHECK-SAFESTACK: "__safestack_init"
+
+// RUN: %clang %s -### --target=arm-liteos \
+// RUN:     -fsanitize=address 2>&1 \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     -fuse-ld=lld \
+// RUN:     | FileCheck %s -check-prefix=CHECK-ASAN-ARM
+// CHECK-ASAN-ARM: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
+// CHECK-ASAN-ARM: "-fsanitize=address"
+// CHECK-ASAN-ARM: "-fsanitize-address-use-after-scope"
+// CHECK-ASAN-ARM: "-dynamic-linker" "/lib/ld-musl-arm.so.1"
+// CHECK-ASAN-ARM: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.asan.a"
+// CHECK-ASAN-ARM-NOT: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.asan-preinit.a"
+
+// RUN: %clang %s -### --target=arm-liteos \
+// RUN:     -fsanitize=address -fPIC -shared 2>&1 \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     -shared-libsan \
+// RUN:     -fuse-ld=lld \
+// RUN:     | FileCheck %s -check-prefix=CHECK-ASAN-SHARED
+// CHECK-ASAN-SHARED: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
+// CHECK-ASAN-SHARED: "-fsanitize=address"
+// CHECK-ASAN-SHARED: "-fsanitize-address-use-after-scope"
+// CHECK-ASAN-SHARED: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.asan.so"
+// CHECK-ASAN-SHARED-NOT: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.asan-preinit.a"
+
+// RUN: %clang %s -### --target=arm-liteos \
+// RUN:     -fsanitize=fuzzer 2>&1 \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     -fuse-ld=lld \
+// RUN:     | FileCheck %s -check-prefix=CHECK-FUZZER-ARM
+// CHECK-FUZZER-ARM: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
+// CHECK-FUZZER-ARM: "-fsanitize=fuzzer,fuzzer-no-link"
+// CHECK-FUZZER-ARM: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.fuzzer.a"
+
+// RUN: %clang %s -### --target=arm-liteos \
+// RUN:     -fsanitize=scudo 2>&1 \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     -fuse-ld=lld \
+// RUN:     | FileCheck %s -check-prefix=CHECK-SCUDO-ARM
+// CHECK-SCUDO-ARM: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
+// CHECK-SCUDO-ARM: "-fsanitize=scudo"
+// CHECK-SCUDO-ARM: "-pie"
+// CHECK-SCUDO-ARM: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.scudo_standalone.a"
+
+// RUN: %clang %s -### --target=arm-liteos \
+// RUN:     -fsanitize=scudo -fPIC -shared 2>&1 \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     -shared-libsan \
+// RUN:     -fuse-ld=lld \
+// RUN:     | FileCheck %s -check-prefix=CHECK-SCUDO-SHARED
+// CHECK-SCUDO-SHARED: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
+// CHECK-SCUDO-SHARED: "-fsanitize=scudo"
+// CHECK-SCUDO-SHARED: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.scudo_standalone.so"
+
+// RUN: %clang %s -### --target=arm-liteos \
+// RUN:     -fxray-instrument -fxray-modes=xray-basic \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-XRAY-ARM
+// CHECK-XRAY-ARM: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
+// CHECK-XRAY-ARM: "-fxray-instrument"
+// CHECK-XRAY-ARM: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.xray.a"
+// CHECK-XRAY-ARM: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.xray-basic.a"
+
+// RUN: %clang %s -### --target=arm-liteos \
+// RUN:     -O3 -flto -mcpu=cortex-a53 2>&1 \
+// RUN:     -fuse-ld=lld \
+// RUN:     | FileCheck %s -check-prefix=CHECK-LTO
+// CHECK-LTO: "-plugin-opt=mcpu=cortex-a53"
+// CHECK-LTO: "-plugin-opt=O3"
+
+// RUN: %clang %s -### --target=arm-liteos \
+// RUN:     -flto=thin -flto-jobs=8 -mcpu=cortex-a7 2>&1 \
+// RUN:     -fuse-ld=lld \
+// RUN:     | FileCheck %s -check-prefix=CHECK-THINLTO
+// CHECK-THINLTO: "-plugin-opt=mcpu=cortex-a7"
+// CHECK-THINLTO: "-plugin-opt=thinlto"
+// CHECK-THINLTO: "-plugin-opt=jobs=8"
+
+// RUN: %clang %s -### --target=arm-liteos \
+// RUN:     -ccc-install-dir %S/Inputs/ohos_native_tree/llvm/bin \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     --sysroot=%S/Inputs/ohos_native_tree/sysroot \
+// RUN:     -march=armv7-a -mfloat-abi=soft 2>&1\
+// RUN:     | FileCheck %s -check-prefixes=CHECK-MULTILIB,CHECK-MULTILIB-SF,CHECK-MULTILIB-ARM
+// RUN: %clang %s -### --target=arm-liteos \
+// RUN:     -ccc-install-dir %S/Inputs/ohos_native_tree/llvm/bin \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     --sysroot=%S/Inputs/ohos_native_tree/sysroot \
+// RUN:     -march=armv7-a -mcpu=cortex-a7 -mfloat-abi=soft 2>&1\
+// RUN:     | FileCheck %s -check-prefixes=CHECK-MULTILIB,CHECK-MULTILIB-SF,CHECK-MULTILIB-ARM-A7-SOFT
+// RUN: %clang %s -### --target=arm-liteos  \
+// RUN:     -ccc-install-dir %S/Inputs/ohos_native_tree/llvm/bin \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     --sysroot=%S/Inputs/ohos_native_tree/sysroot \
+// RUN:     -march=armv7-a -mcpu=cortex-a7 -mfloat-abi=softfp -mfpu=neon-vfpv4 2>&1\
+// RUN:     | FileCheck %s -check-prefixes=CHECK-MULTILIB,CHECK-MULTILIB-SF,CHECK-MULTILIB-ARM-A7-SOFTFP
+// RUN: %clang %s -### --target=arm-liteos  \
+// RUN:     -ccc-install-dir %S/Inputs/ohos_native_tree/llvm/bin \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     --sysroot=%S/Inputs/ohos_native_tree/sysroot \
+// RUN:     -march=armv7-a -mcpu=cortex-a7 -mfloat-abi=hard -mfpu=neon-vfpv4 2>&1\
+// RUN:     | FileCheck %s -check-prefixes=CHECK-MULTILIB,CHECK-MULTILIB-HF,CHECK-MULTILIB-ARM-A7-HARD
+// CHECK-MULTILIB: {{.*}}clang{{.*}}" "-cc1"
+// CHECK-MULTILIB: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
+// CHECK-MULTILIB: "-isysroot" "[[SYSROOT:[^"]+]]"
+// CHECK-MULTILIB: {{.*}}ld.lld{{.*}}" "--sysroot=[[SYSROOT]]"
+// CHECK-MULTILIB-SF: "-dynamic-linker" "/lib/ld-musl-arm.so.1"
+// CHECK-MULTILIB-HF: "-dynamic-linker" "/lib/ld-musl-armhf.so.1"
+
+// CHECK-MULTILIB-ARM: "-L[[SYSROOT]]/usr/lib/arm-liteos-ohos/"
+
+// CHECK-MULTILIB-ARM-A7-SOFT: "-L[[SYSROOT]]/usr/lib/arm-liteos-ohos/a7_soft"
+
+// CHECK-MULTILIB-ARM-A7-SOFTFP: "-L[[SYSROOT]]/usr/lib/arm-liteos-ohos/a7_softfp_neon-vfpv4"
+
+// CHECK-MULTILIB-ARM-A7-HARD: "-L[[SYSROOT]]/usr/lib/arm-liteos-ohos/a7_hard_neon-vfpv4"
+
+// CHECK-MULTILIB-ARM: "[[RESOURCE_DIR]]/lib/arm-liteos-ohos/libclang_rt.builtins.a"
+// CHECK-MULTILIB-ARM-A7-SOFT: "[[RESOURCE_DIR]]/lib/arm-liteos-ohos/a7_soft/libclang_rt.builtins.a"
+// CHECK-MULTILIB-ARM-A7-SOFTFP: "[[RESOURCE_DIR]]/lib/arm-liteos-ohos/a7_softfp_neon-vfpv4/libclang_rt.builtins.a"
+// CHECK-MULTILIB-ARM-A7-HARD: "[[RESOURCE_DIR]]/lib/arm-liteos-ohos/a7_hard_neon-vfpv4/libclang_rt.builtins.a"
+
+// RUN: %clang %s -### -no-canonical-prefixes --target=arm-linux-ohos -fprofile-instr-generate -v \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     --sysroot=%S/Inputs/ohos_native_tree/sysroot -fuse-ld=lld -march=armv7-a 2>&1 \
+// RUN:     | FileCheck -check-prefixes=CHECK-PROFILE-RTLIB %s
+
+// CHECK-PROFILE-RTLIB: -u__llvm_profile_runtime
+// CHECK-PROFILE-RTLIB: libclang_rt.profile
+
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     --target=arm64-linux-ohos -pthread \
+// RUN:     --gcc-toolchain="" \
+// RUN:     --sysroot=%S/Inputs/ohos_native_tree/sysroot \
+// RUN:     -shared \
+// RUN:   | FileCheck --check-prefix=CHECK-OHOS-PTHREAD %s
+
+// CHECK-OHOS-PTHREAD-NOT: -lpthread
+

clang/test/Driver/ohos.cpp

+// RUN: %clangxx %s -### -no-canonical-prefixes --target=arm-liteos -march=armv7-a \
+// RUN:     -ccc-install-dir %S/Inputs/ohos_native_tree/llvm/bin \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     --sysroot=%S/Inputs/ohos_native_tree/sysroot -fuse-ld=lld 2>&1 | FileCheck %s
+// CHECK: {{.*}}clang{{.*}}" "-cc1"
+// CHECK: "-triple" "armv7-unknown-liteos-ohos"
+// CHECK-NOT: "-fuse-init-array"
+// CHECK: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
+// CHECK: "-isysroot" "[[SYSROOT:[^"]+]]"
+// CHECK: "-internal-externc-isystem" "[[SYSROOT]]{{/|\\\\}}include"
+// CHECK: {{.*}}ld.lld{{.*}}" "--sysroot=[[SYSROOT]]"
+// CHECK: "-pie"
+// CHECK-NOT: "--build-id"
+// CHECK: "-dynamic-linker" "/lib/ld-musl-arm.so.1"
+// CHECK: Scrt1.o
+// CHECK: crti.o
+// CHECK: clang_rt.crtbegin.o
+// CHECK: "-L{{.*[/\\]}}lib/arm-liteos-ohos/"
+// CHECK-NOT: "--push-state"
+// CHECK-NOT: "--as-needed"
+// CHECK: "-lc++"
+// CHECK: "-lm"
+// CHECK-NOT: "--pop-state"
+// CHECK: "[[RESOURCE_DIR]]{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}libclang_rt.builtins.a"
+// CHECK: "-lc"
+// CHECK: clang_rt.crtend.o
+// CHECK: crtn.o
+
+// RUN: %clangxx %s -### --target=arm-unknown-liteos -stdlib=libstdc++ \
+// RUN:     -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-STDLIB
+// CHECK-STDLIB: error: invalid library name in argument '-stdlib=libstdc++'
+
+// RUN: %clangxx %s -### --target=arm-unknown-liteos -static-libstdc++ \
+// RUN:     -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-STATIC
+// CHECK-STATIC-NOT: "--push-state"
+// CHECK-STATIC-NOT: "--as-needed"
+// CHECK-STATIC: "-Bstatic"
+// CHECK-STATIC: "-lc++"
+// CHECK-STATIC: "-Bdynamic"
+// CHECK-STATIC: "-lm"
+// CHECK-STATIC-NOT: "--pop-state"
+// CHECK-STATIC: "-lc"
+
+// RUN: %clangxx %s -### --target=arm-unknown-liteos -static \
+// RUN:     -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-STATIC1
+// CHECK-STATIC1-NOT: "-fuse-init-array"
+// CHECK-STATIC1: "-static"
+// CHECK-STATIC1: "-lc++"
+// CHECK-STATIC1: "-lc++abi"
+// CHECK-STATIC1: "-lunwind"
+// CHECK-STATIC1: "-lm"
+// CHECK-STATIC1: "-lc"
+
+// RUN: %clangxx %s -### --target=arm-unknown-liteos -march=armv7-a -mfloat-abi=soft -static -fPIE -fPIC -fpic -pie \
+// RUN:     --sysroot=%S/Inputs/ohos_native_tree/sysroot -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-STATIC2
+// CHECK-STATIC2: "-isysroot" "[[SYSROOT:[^"]+]]"
+// CHECK-STATIC2: {{.*}}ld.lld{{.*}}" "--sysroot=[[SYSROOT]]"
+// CHECK-STATIC2: "-static"
+// CHECK-STATIC2: "-lc++"
+// CHECK-STATIC2: "-lc++abi"
+// CHECK-STATIC2: "-lunwind"
+// CHECK-STATIC2: "-lm"
+// CHECK-STATIC2: "-lc"
+
+// RUN: %clangxx %s -### --target=arm-liteos -nostdlib++ -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-NOSTDLIBXX
+// CHECK-NOSTDLIBXX-NOT: "-lc++"
+// CHECK-NOSTDLIBXX: "-lm"
+// CHECK-NOSTDLIBXX: "-lc"
+
+// RUN: %clangxx %s -### --target=arm-liteos \
+// RUN:     -ccc-install-dir %S/Inputs/ohos_native_tree/llvm/bin \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     --sysroot=%S/Inputs/ohos_native_tree/sysroot \
+// RUN:     -march=armv7-a -mfloat-abi=soft 2>&1\
+// RUN:     | FileCheck %s -check-prefixes=CHECK-MULTILIB,CHECK-MULTILIB-SF,CHECK-MULTILIB-ARM
+// RUN: %clangxx %s -### --target=arm-liteos \
+// RUN:     -ccc-install-dir %S/Inputs/ohos_native_tree/llvm/bin \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     --sysroot=%S/Inputs/ohos_native_tree/sysroot \
+// RUN:     -march=armv7-a -mcpu=cortex-a7 -mfloat-abi=soft 2>&1\
+// RUN:     | FileCheck %s -check-prefixes=CHECK-MULTILIB,CHECK-MULTILIB-SF,CHECK-MULTILIB-ARM-A7-SOFT
+// RUN: %clangxx %s -### --target=arm-liteos  \
+// RUN:     -ccc-install-dir %S/Inputs/ohos_native_tree/llvm/bin \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     --sysroot=%S/Inputs/ohos_native_tree/sysroot \
+// RUN:     -march=armv7-a -mcpu=cortex-a7 -mfloat-abi=softfp -mfpu=neon-vfpv4 2>&1\
+// RUN:     | FileCheck %s -check-prefixes=CHECK-MULTILIB,CHECK-MULTILIB-SF,CHECK-MULTILIB-ARM-A7-SOFTFP
+// RUN: %clangxx %s -### --target=arm-liteos  \
+// RUN:     -ccc-install-dir %S/Inputs/ohos_native_tree/llvm/bin \
+// RUN:     -resource-dir=%S/Inputs/ohos_native_tree/llvm/lib/clang/x.y.z \
+// RUN:     --sysroot=%S/Inputs/ohos_native_tree/sysroot \
+// RUN:     -march=armv7-a -mcpu=cortex-a7 -mfloat-abi=hard -mfpu=neon-vfpv4 2>&1\
+// RUN:     | FileCheck %s -check-prefixes=CHECK-MULTILIB,CHECK-MULTILIB-HF,CHECK-MULTILIB-ARM-A7-HARD
+// CHECK-MULTILIB: {{.*}}clang{{.*}}" "-cc1"
+// CHECK-MULTILIB: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
+// CHECK-MULTILIB: "-isysroot" "[[SYSROOT:[^"]+]]"
+// CHECK-MULTILIB: {{.*}}ld.lld{{.*}}" "--sysroot=[[SYSROOT]]"
+// CHECK-MULTILIB-SF: "-dynamic-linker" "/lib/ld-musl-arm.so.1"
+// CHECK-MULTILIB-HF: "-dynamic-linker" "/lib/ld-musl-armhf.so.1"
+
+// CHECK-MULTILIB-ARM: "-L{{.*}}{{/|\\\\}}..{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}"
+// CHECK-MULTILIB-ARM: "-L[[SYSROOT]]/usr/lib/arm-liteos-ohos/"
+
+// CHECK-MULTILIB-ARM-A7-SOFT: "-L{{.*}}{{/|\\\\}}..{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}a7_soft"
+// CHECK-MULTILIB-ARM-A7-SOFT: "-L[[SYSROOT]]/usr/lib/arm-liteos-ohos/a7_soft"
+
+// CHECK-MULTILIB-ARM-A7-SOFTFP: "-L{{.*}}{{/|\\\\}}..{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}a7_softfp_neon-vfpv4"
+// CHECK-MULTILIB-ARM-A7-SOFTFP: "-L[[SYSROOT]]/usr/lib/arm-liteos-ohos/a7_softfp_neon-vfpv4"
+
+// CHECK-MULTILIB-ARM-A7-HARD: "-L{{.*}}{{/|\\\\}}..{{/|\\\\}}lib{{/|\\\\}}arm-liteos-ohos{{/|\\\\}}a7_hard_neon-vfpv4"
+// CHECK-MULTILIB-ARM-A7-HARD: "-L[[SYSROOT]]/usr/lib/arm-liteos-ohos/a7_hard_neon-vfpv4"
+
+// CHECK-MULTILIB-ARM: "[[RESOURCE_DIR]]/lib/arm-liteos-ohos/libclang_rt.builtins.a"
+// CHECK-MULTILIB-ARM-A7-SOFT: "[[RESOURCE_DIR]]/lib/arm-liteos-ohos/a7_soft/libclang_rt.builtins.a"
+// CHECK-MULTILIB-ARM-A7-SOFTFP: "[[RESOURCE_DIR]]/lib/arm-liteos-ohos/a7_softfp_neon-vfpv4/libclang_rt.builtins.a"
+// CHECK-MULTILIB-ARM-A7-HARD: "[[RESOURCE_DIR]]/lib/arm-liteos-ohos/a7_hard_neon-vfpv4/libclang_rt.builtins.a"

clang/test/Preprocessor/ohos.c

+// RUN: %clang_cc1 -x c++ -E -dM -ffreestanding -triple=arm-linux-ohos < /dev/null | FileCheck %s -match-full-lines -check-prefix=ARM-OHOS-CXX
+// RUN: %clang_cc1 -x c++ -E -dM -ffreestanding -triple=aarch64-linux-ohos < /dev/null | FileCheck %s -match-full-lines -check-prefix=ARM64-OHOS-CXX
+// RUN: %clang_cc1 -x c++ -E -dM -ffreestanding -triple=riscv64-linux-ohos < /dev/null | FileCheck %s -match-full-lines -check-prefix=RISCV64-OHOS-CXX
+// RUN: %clang_cc1 -x c++ -E -dM -ffreestanding -triple=mipsel-linux-ohos < /dev/null | FileCheck %s -match-full-lines -check-prefix=MIPSEL-OHOS-CXX
+// RUN: %clang_cc1 -x c++ -E -dM -ffreestanding -triple=x86_64-linux-ohos < /dev/null | FileCheck %s -match-full-lines -check-prefix=X86_64-OHOS-CXX
+// RUN: %clang_cc1 -E -dM -ffreestanding -triple=arm-linux-ohos < /dev/null | FileCheck %s -check-prefix=OHOS-DEFS
+
+// ARM-OHOS-CXX: #define __STDCPP_DEFAULT_NEW_ALIGNMENT__ 8U
+// ARM64-OHOS-CXX: #define __STDCPP_DEFAULT_NEW_ALIGNMENT__ 16UL
+// RISCV64-OHOS-CXX: #define __STDCPP_DEFAULT_NEW_ALIGNMENT__ 16UL
+// MIPSEL-OHOS-CXX: #define __STDCPP_DEFAULT_NEW_ALIGNMENT__ 8U
+// X86_64-OHOS-CXX: #define __STDCPP_DEFAULT_NEW_ALIGNMENT__ 16UL
+// OHOS-DEFS: __OHOS_FAMILY__
+// OHOS-DEFS: __OHOS__
+// OHOS-DEFS-NOT: __OHOS__