Add isArch32Bit into TripleUtils

clang/lib/AST/MicrosoftCXXABI.cpp

 #include "clang/AST/Attr.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Mangle.h"
 #include "clang/AST/MangleNumberingContext.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/TargetInfo.h"
+#include "llvm/TargetParser/TripleUtils.h"
 
 using namespace clang;
 
 namespace {
 
 /// Numbers things which need to correspond across multiple TUs.
 /// Typically these are things like static locals, lambdas, or blocks.
 class MicrosoftNumberingContext : public MangleNumberingContext {
CXXABI::MemberPointerInfo MicrosoftCXXABI::getMemberPointerInfo(
   std::tie(Ptrs, Ints) = getMSMemberPointerSlots(MPT);
   MemberPointerInfo MPI;
   MPI.HasPadding = false;
   MPI.Width = Ptrs * PtrSize + Ints * IntSize;
 
   // When MSVC does x86_32 record layout, it aligns aggregate member pointers to
   // 8 bytes.  However, __alignof usually returns 4 for data memptrs and 8 for
   // function memptrs.
-  if (Ptrs + Ints > 1 && Target.getTriple().isArch32Bit())
+  if (Ptrs + Ints > 1 && llvm::TripleUtils::isArch32Bit(Target.getTriple()))
     MPI.Align = 64;
   else if (Ptrs)
     MPI.Align = Target.getPointerAlign(LangAS::Default);
   else
     MPI.Align = Target.getIntAlign();
 
   if (Target.getTriple().isArch64Bit()) {
     MPI.Width = llvm::alignTo(MPI.Width, MPI.Align);
     MPI.HasPadding = MPI.Width != (Ptrs * PtrSize + Ints * IntSize);
   }
   return MPI;
 }
 
 CXXABI *clang::CreateMicrosoftCXXABI(ASTContext &Ctx) {
   return new MicrosoftCXXABI(Ctx);
 }

clang/lib/AST/RecordLayoutBuilder.cpp

 //=== RecordLayoutBuilder.cpp - Helper class for building record layouts ---==//
 //
 // 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 "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Expr.h"
-#include "clang/AST/VTableBuilder.h"
 #include "clang/AST/RecordLayout.h"
+#include "clang/AST/VTableBuilder.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/TargetParser/TripleUtils.h"
 
 using namespace clang;
 
 namespace {
 
 /// BaseSubobjectInfo - Represents a single base subobject in a complete class.
 /// For a class hierarchy like
 ///
void ItaniumRecordLayoutBuilder::LayoutBitField(const FieldDecl *D) {
   }
 
   if (isAIXLayout(Context)) {
     if (StorageUnitSize < Context.getTypeSize(Context.UnsignedIntTy)) {
       // On AIX, [bool, char, short] bitfields have the same alignment
       // as [unsigned].
       StorageUnitSize = Context.getTypeSize(Context.UnsignedIntTy);
     } else if (StorageUnitSize > Context.getTypeSize(Context.UnsignedIntTy) &&
-               Context.getTargetInfo().getTriple().isArch32Bit() &&
+               llvm::TripleUtils::isArch32Bit(
+                   Context.getTargetInfo().getTriple()) &&
                FieldSize <= 32) {
       // Under 32-bit compile mode, the bitcontainer is 32 bits if a single
       // long long bitfield has length no greater than 32 bits.
       StorageUnitSize = 32;
 
       if (!AlignIsRequired)
         FieldAlign = 32;
     }

clang/lib/Basic/TargetInfo.cpp

 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticFrontend.h"
 #include "clang/Basic/LangOptions.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/TargetParser/TargetParser.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include <cstdlib>
 using namespace clang;
 
 static const LangASMap DefaultAddrSpaceMap = {0};
 // The fake address space map must have a distinct entry for each
 // language-specific address space.
 static const LangASMap FakeAddrSpaceMap = {
     0,  // Default
TargetInfo::TargetInfo(const llvm::Triple &T) : Triple(T) {
   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() ||
       T.isOHOSFamily())
-    NewAlign = Triple.isArch64Bit() ? 128 : Triple.isArch32Bit() ? 64 : 0;
+    NewAlign = Triple.isArch64Bit()                     ? 128
+               : llvm::TripleUtils::isArch32Bit(Triple) ? 64
+                                                        : 0;
   else if (T.isOSDarwin() || T.isOSOpenBSD())
     NewAlign = 128;
   else
     NewAlign = 0; // Infer from basic type alignment.
   HalfWidth = 16;
   HalfAlign = 16;
   FloatWidth = 32;
   FloatAlign = 32;

clang/lib/Basic/Targets/AArch64.cpp

 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/TargetBuiltins.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/TargetParser/AArch64TargetParser.h"
 #include "llvm/TargetParser/ARMTargetParserCommon.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include <optional>
 
 using namespace clang;
 using namespace clang::targets;
 
 static constexpr Builtin::Info BuiltinInfo[] = {
 #define BUILTIN(ID, TYPE, ATTRS)                                               \
   {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},

 bool AArch64TargetInfo::hasInt128Type() const { return true; }
 
 AArch64leTargetInfo::AArch64leTargetInfo(const llvm::Triple &Triple,
                                          const TargetOptions &Opts)
     : AArch64TargetInfo(Triple, Opts) {}
 
 void AArch64leTargetInfo::setDataLayout() {
   if (getTriple().isOSBinFormatMachO()) {
-    if(getTriple().isArch32Bit())
+    if (llvm::TripleUtils::isArch32Bit(getTriple()))
       resetDataLayout("e-m:o-p:32:32-i64:64-i128:128-n32:64-S128", "_");
     else
       resetDataLayout("e-m:o-i64:64-i128:128-n32:64-S128", "_");
   } else
     resetDataLayout("e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128");
 }
 
 void AArch64leTargetInfo::getTargetDefines(const LangOptions &Opts,
MinGWARM64TargetInfo::MinGWARM64TargetInfo(const llvm::Triple &Triple,
     : WindowsARM64TargetInfo(Triple, Opts) {
   TheCXXABI.set(TargetCXXABI::GenericAArch64);
 }
 
 DarwinAArch64TargetInfo::DarwinAArch64TargetInfo(const llvm::Triple &Triple,
                                                  const TargetOptions &Opts)
     : DarwinTargetInfo<AArch64leTargetInfo>(Triple, Opts) {
   Int64Type = SignedLongLong;
-  if (getTriple().isArch32Bit())
+  if (llvm::TripleUtils::isArch32Bit(getTriple()))
     IntMaxType = SignedLongLong;
 
   WCharType = SignedInt;
   UseSignedCharForObjCBool = false;
 
   LongDoubleWidth = LongDoubleAlign = SuitableAlign = 64;
   LongDoubleFormat = &llvm::APFloat::IEEEdouble();
 
   UseZeroLengthBitfieldAlignment = false;
 
-  if (getTriple().isArch32Bit()) {
+  if (llvm::TripleUtils::isArch32Bit(getTriple())) {
     UseBitFieldTypeAlignment = false;
     ZeroLengthBitfieldBoundary = 32;
     UseZeroLengthBitfieldAlignment = true;
     TheCXXABI.set(TargetCXXABI::WatchOS);
   } else
     TheCXXABI.set(TargetCXXABI::AppleARM64);
 }
 
 void DarwinAArch64TargetInfo::getOSDefines(const LangOptions &Opts,
                                            const llvm::Triple &Triple,
                                            MacroBuilder &Builder) const {
   Builder.defineMacro("__AARCH64_SIMD__");
-  if (Triple.isArch32Bit())
+  if (llvm::TripleUtils::isArch32Bit(Triple))
     Builder.defineMacro("__ARM64_ARCH_8_32__");
   else
     Builder.defineMacro("__ARM64_ARCH_8__");
   Builder.defineMacro("__ARM_NEON__");
   Builder.defineMacro("__REGISTER_PREFIX__", "");
   Builder.defineMacro("__arm64", "1");
   Builder.defineMacro("__arm64__", "1");
 

clang/lib/Basic/Targets/OSTargets.h

DarwinTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 
     if (Triple.isMacOSX())
       this->TLSSupported = !Triple.isMacOSXVersionLT(10, 7);
     else if (Triple.isiOS()) {
       // 64-bit iOS supported it from 8 onwards, 32-bit device from 9 onwards,
       // 32-bit simulator from 10 onwards.
       if (Triple.isArch64Bit())
         this->TLSSupported = !Triple.isOSVersionLT(8);
-      else if (Triple.isArch32Bit()) {
+      else if (llvm::TripleUtils::isArch32Bit(Triple)) {
         if (!Triple.isSimulatorEnvironment())
           this->TLSSupported = !Triple.isOSVersionLT(9);
         else
           this->TLSSupported = !Triple.isOSVersionLT(10);
       }
     } else if (Triple.isWatchOS()) {
       if (!Triple.isSimulatorEnvironment())
         this->TLSSupported = !Triple.isOSVersionLT(2);

clang/lib/Driver/ToolChains/AIX.cpp

 #include "CommonArgs.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/Path.h"
+#include "llvm/TargetParser/TripleUtils.h"
 
 using AIX = clang::driver::toolchains::AIX;
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang::driver::toolchains;
 
 using namespace llvm::opt;
 using namespace llvm::sys;
 
 void aix::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
                                   const InputInfo &Output,
                                   const InputInfoList &Inputs,
                                   const ArgList &Args,
                                   const char *LinkingOutput) const {
   ArgStringList CmdArgs;
 
-  const bool IsArch32Bit = getToolChain().getTriple().isArch32Bit();
+  const bool IsArch32Bit =
+      llvm::TripleUtils::isArch32Bit(getToolChain().getTriple());
   const bool IsArch64Bit = getToolChain().getTriple().isArch64Bit();
   // Only support 32 and 64 bit.
   if (!IsArch32Bit && !IsArch64Bit)
     llvm_unreachable("Unsupported bit width value.");
 
   // Specify the mode in which the as(1) command operates.
   if (IsArch32Bit) {
     CmdArgs.push_back("-a32");

 void aix::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                const InputInfo &Output,
                                const InputInfoList &Inputs, const ArgList &Args,
                                const char *LinkingOutput) const {
   const AIX &ToolChain = static_cast<const AIX &>(getToolChain());
   const Driver &D = ToolChain.getDriver();
   ArgStringList CmdArgs;
 
-  const bool IsArch32Bit = ToolChain.getTriple().isArch32Bit();
+  const bool IsArch32Bit =
+      llvm::TripleUtils::isArch32Bit(ToolChain.getTriple());
   const bool IsArch64Bit = ToolChain.getTriple().isArch64Bit();
   // Only support 32 and 64 bit.
   if (!(IsArch32Bit || IsArch64Bit))
     llvm_unreachable("Unsupported bit width value.");
 
   if (Arg *A = C.getArgs().getLastArg(options::OPT_G)) {
     D.Diag(diag::err_drv_unsupported_opt_for_target)
         << A->getSpelling() << D.getTargetTriple();

clang/lib/Driver/ToolChains/Darwin.cpp

 #include "llvm/Option/ArgList.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/TargetParser/TargetParser.h"
 #include "llvm/TargetParser/Triple.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include <cstdlib> // ::getenv
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang::driver::toolchains;
 using namespace clang;
 using namespace llvm::opt;
 
if (OSTarget->getEnvironment() == MacCatalyst &&
       getDriver().Diag(diag::err_drv_invalid_version_number)
           << OSTarget->getAsString(Args, Opts);
       Major = 13;
       Minor = 1;
       Micro = 0;
     }
     // For 32-bit targets, the deployment target for iOS has to be earlier than
     // iOS 11.
-    if (getTriple().isArch32Bit() && Major >= 11) {
+    if (llvm::TripleUtils::isArch32Bit(getTriple()) && Major >= 11) {
       // If the deployment target is explicitly specified, print a diagnostic.
       if (OSTarget->isExplicitlySpecified()) {
         if (OSTarget->getEnvironment() == MacCatalyst)
           getDriver().Diag(diag::err_invalid_macos_32bit_deployment_target);
         else
           getDriver().Diag(diag::warn_invalid_ios_deployment_target)
               << OSTarget->getAsString(Args, Opts);
         // Otherwise, set it to 10.99.99.

clang/lib/Driver/ToolChains/FreeBSD.cpp

 #include "CommonArgs.h"
 #include "clang/Config/config.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/TargetParser/TripleUtils.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang::driver::toolchains;
 using namespace clang;
 using namespace llvm::opt;
 
 void freebsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,

 /// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
 
 FreeBSD::FreeBSD(const Driver &D, const llvm::Triple &Triple,
                  const ArgList &Args)
     : Generic_ELF(D, Triple, Args) {
 
   // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall
   // back to '/usr/lib' if it doesn't exist.
-  if (Triple.isArch32Bit() &&
+  if (llvm::TripleUtils::isArch32Bit(Triple) &&
       D.getVFS().exists(concat(getDriver().SysRoot, "/usr/lib32/crt1.o")))
     getFilePaths().push_back(concat(getDriver().SysRoot, "/usr/lib32"));
   else
     getFilePaths().push_back(concat(getDriver().SysRoot, "/usr/lib"));
 }
 
 unsigned FreeBSD::GetDefaultDwarfVersion() const {
   unsigned Major = getTriple().getOSMajorVersion();

clang/lib/Driver/ToolChains/Gnu.h

 //===--- Gnu.h - Gnu Tool and 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_GNU_H
 #define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_GNU_H
 
 #include "Cuda.h"
 #include "LazyDetector.h"
 #include "ROCm.h"
 #include "clang/Driver/Tool.h"
 #include "clang/Driver/ToolChain.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include <set>
 
 namespace clang {
 namespace driver {
 
 struct DetectedMultilibs {
   /// The set of multilibs that the detected installation supports.
   MultilibSet Multilibs;
protected:
 
   /// \name ToolChain Implementation Helper Functions
   /// @{
 
   /// Check whether the target triple's architecture is 64-bits.
   bool isTarget64Bit() const { return getTriple().isArch64Bit(); }
 
   /// Check whether the target triple's architecture is 32-bits.
-  bool isTarget32Bit() const { return getTriple().isArch32Bit(); }
+  bool isTarget32Bit() const {
+    return llvm::TripleUtils::isArch32Bit(getTriple());
+  }
 
   void PushPPaths(ToolChain::path_list &PPaths);
   void AddMultilibPaths(const Driver &D, const std::string &SysRoot,
                         const std::string &OSLibDir,
                         const std::string &MultiarchTriple,
                         path_list &Paths);
   void AddMultiarchPaths(const Driver &D, const std::string &SysRoot,
                          const std::string &OSLibDir, path_list &Paths);

clang/lib/Driver/ToolChains/Gnu.cpp

 #include "clang/Driver/ToolChain.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/TargetParser/TargetParser.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include <system_error>
 
 using namespace clang::driver;
 using namespace clang::driver::toolchains;
 using namespace clang;
 using namespace llvm::opt;
 
 using tools::addMultilibFlag;
static bool findBiarchMultilibs(const Driver &D,
   // GCC toolchain for IAMCU doesn't have crtbegin.o, so look for libgcc.a.
   FilterNonExistent NonExistent(
       Path, TargetTriple.isOSIAMCU() ? "/libgcc.a" : "/crtbegin.o", D.getVFS());
 
   // Determine default multilib from: 32, 64, x32
   // Also handle cases such as 64 on 32, 32 on 64, etc.
   enum { UNKNOWN, WANT32, WANT64, WANTX32 } Want = UNKNOWN;
   const bool IsX32 = TargetTriple.isX32();
-  if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
+  if (llvm::TripleUtils::isArch32Bit(TargetTriple) && !NonExistent(Alt32))
     Want = WANT64;
-  if (TargetTriple.isArch32Bit() && !NonExistent(Alt32sparc))
+  if (llvm::TripleUtils::isArch32Bit(TargetTriple) && !NonExistent(Alt32sparc))
     Want = WANT64;
   else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
     Want = WANT64;
   else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
     Want = WANT32;
   else if (TargetTriple.isArch64Bit() && !NonExistent(Alt32sparc))
     Want = WANT64;
   else {
-    if (TargetTriple.isArch32Bit())
+    if (llvm::TripleUtils::isArch32Bit(TargetTriple))
       Want = NeedsBiarchSuffix ? WANT64 : WANT32;
     else if (IsX32)
       Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
     else
       Want = NeedsBiarchSuffix ? WANT32 : WANT64;
   }
 
   if (Want == WANT32)
static bool findBiarchMultilibs(const Driver &D,
   Result.Multilibs.push_back(Alt32);
   Result.Multilibs.push_back(Altx32);
   Result.Multilibs.push_back(Alt32sparc);
 
   Result.Multilibs.FilterOut(NonExistent);
 
   Multilib::flags_list Flags;
   addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32, "-m64", Flags);
-  addMultilibFlag(TargetTriple.isArch32Bit(), "-m32", Flags);
+  addMultilibFlag(llvm::TripleUtils::isArch32Bit(TargetTriple), "-m32", Flags);
   addMultilibFlag(TargetTriple.isArch64Bit() && IsX32, "-mx32", Flags);
 
   if (!Result.Multilibs.select(Flags, Result.SelectedMultilibs))
     return false;
 
   if (Result.SelectedMultilibs.back() == Alt64 ||
       Result.SelectedMultilibs.back() == Alt32 ||
       Result.SelectedMultilibs.back() == Altx32 ||

 ///
 /// FIXME: We shouldn't need an explicit TargetTriple parameter here, and
 /// should instead pull the target out of the driver. This is currently
 /// necessary because the driver doesn't store the final version of the target
 /// triple.
 void Generic_GCC::GCCInstallationDetector::init(
     const llvm::Triple &TargetTriple, const ArgList &Args,
     ArrayRef<std::string> ExtraTripleAliases) {
-  llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
-                                         ? TargetTriple.get64BitArchVariant()
-                                         : TargetTriple.get32BitArchVariant();
+  llvm::Triple BiarchVariantTriple =
+      llvm::TripleUtils::isArch32Bit(TargetTriple)
   // The library directories which may contain GCC installations.
   SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs;
   // The compatible GCC triples for this particular architecture.
   SmallVector<StringRef, 16> CandidateTripleAliases;
   SmallVector<StringRef, 16> CandidateBiarchTripleAliases;
   CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
                            CandidateTripleAliases, CandidateBiarchLibDirs,
                            CandidateBiarchTripleAliases);

clang/lib/Driver/ToolChains/Hurd.cpp

 //===--- Hurd.cpp - Hurd 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 "Hurd.h"
 #include "CommonArgs.h"
 #include "clang/Config/config.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/Options.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/TargetParser/TripleUtils.h"
 
 using namespace clang::driver;
 using namespace clang::driver::toolchains;
 using namespace clang;
 using namespace llvm::opt;
 
 using tools::addPathIfExists;
 
static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {
   //
   // 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)
     return "lib32";
 
-  return Triple.isArch32Bit() ? "lib" : "lib64";
+  return llvm::TripleUtils::isArch32Bit(Triple) ? "lib" : "lib64";
 }
 
 Hurd::Hurd(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();

clang/lib/Driver/ToolChains/Linux.cpp

 #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 "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include <system_error>
 
 using namespace clang::driver;
 using namespace clang::driver::toolchains;
 using namespace clang;
 using namespace llvm::opt;
 
 using tools::addPathIfExists;
if (Triple.isAndroid()) {
       if (CPUName == "mips32r2")
         return "libr2";
     }
     // lib32 directory has a special meaning on MIPS targets.
     // It contains N32 ABI binaries. Use this folder if produce
     // code for N32 ABI only.
     if (tools::mips::hasMipsAbiArg(Args, "n32"))
       return "lib32";
-    return Triple.isArch32Bit() ? "lib" : "lib64";
+    return llvm::TripleUtils::isArch32Bit(Triple) ? "lib" : "lib64";
   }
 
   // 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";
+  return llvm::TripleUtils::isArch32Bit(Triple) ? "lib" : "lib64";
 }
 
 Linux::Linux(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()});
   llvm::Triple::ArchType Arch = Triple.getArch();

clang/lib/Driver/ToolChains/WebAssembly.cpp

 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/TargetParser/TripleUtils.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang::driver::toolchains;
 using namespace clang;
 using namespace llvm::opt;
 
 /// Following the conventions in https://wiki.debian.org/Multiarch/Tuples,
static std::string AppendLTOLibDir(const std::string &Dir) {
     // LLVM in used, as the bitcode format is not stable.
     return Dir + "/llvm-lto/" LLVM_VERSION_STRING;
 }
 
 WebAssembly::WebAssembly(const Driver &D, const llvm::Triple &Triple,
                          const llvm::opt::ArgList &Args)
     : ToolChain(D, Triple, Args) {
 
-  assert(Triple.isArch32Bit() != Triple.isArch64Bit());
+  assert(llvm::TripleUtils::isArch32Bit(Triple) != Triple.isArch64Bit());
 
   getProgramPaths().push_back(getDriver().getInstalledDir());
 
   auto SysRoot = getDriver().SysRoot;
   if (getTriple().getOS() == llvm::Triple::UnknownOS) {
     // Theoretically an "unknown" OS should mean no standard libraries, however
     // it could also mean that a custom set of libraries is in use, so just add
     // /lib to the search path. Disable multiarch in this case, to discourage

clang/lib/Frontend/CompilerInvocation.cpp

#undef LANG_OPTION_WITH_MARSHALLING
   }
 
   // Get the OpenMP target triples if any.
   if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
     enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
     auto getArchPtrSize = [](const llvm::Triple &T) {
       if (llvm::TripleUtils::isArch16Bit(T))
         return Arch16Bit;
-      if (T.isArch32Bit())
+      if (llvm::TripleUtils::isArch32Bit(T))
         return Arch32Bit;
       assert(T.isArch64Bit() && "Expected 64-bit architecture");
       return Arch64Bit;
     };
 
     for (unsigned i = 0; i < A->getNumValues(); ++i) {
       llvm::Triple TT(A->getValue(i));
 

llvm/include/llvm/TargetParser/Triple.h

public:
 
   /// Test whether the architecture is 64-bit
   ///
   /// Note that this tests for 64-bit pointer width, and nothing else. Note
   /// that we intentionally expose only three predicates, 64-bit, 32-bit, and
   /// 16-bit. The inner details of pointer width for particular architectures
   /// is not summed up in the triple, and so only a coarse grained predicate
   /// system is provided.
+  //[[deprecated("Use TripleUtisl::isArch64Bit(const llvm::Triple&) instead.")]]
   bool isArch64Bit() const;
 
   /// Test whether the architecture is 32-bit
   ///
   /// Note that this tests for 32-bit pointer width, and nothing else.
-  bool isArch32Bit() const;
+  [[deprecated(
+      "Use TripleUtisl::isArch32Bit(const llvm::Triple&) instead.")]] bool
+  isArch32Bit() const;
+
+  /// Test whether the architecture is 16-bit
+  ///
+  /// Note that this tests for 16-bit pointer width, and nothing else.
+  [[deprecated(
+      "Use TripleUtisl::isArch16Bit(const llvm::Triple&) instead.")]] bool
+  isArch16Bit() const;
 
   /// Helper function for doing comparisons against version numbers included in
   /// the target triple.
   bool isOSVersionLT(unsigned Major, unsigned Minor = 0,
                      unsigned Micro = 0) const {
     if (Minor == 0) {
       return getOSVersion() < VersionTuple(Major);
     }

llvm/include/llvm/TargetParser/TripleUtils.h

 
 #include "llvm/TargetParser/Triple.h"
 #include <string>
 
 namespace llvm {
 
 class TripleUtils {
 public:
+  /// Test whether the architecture is 32-bit
+  ///
+  /// Note that this tests for 32-bit pointer width, and nothing else.
+  static bool isArch32Bit(const llvm::Triple &tripleImpl);
+
   /// Test whether the architecture is 16-bit
   ///
   /// Note that this tests for 16-bit pointer width, and nothing else.
 
   static bool isArch16Bit(const llvm::Triple &tripleImpl);
 };
 
 } // namespace llvm
 
 #endif
 No newline at end of file

llvm/lib/BinaryFormat/MachO.cpp

 //===-- llvm/BinaryFormat/MachO.cpp - The MachO file format -----*- 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 "llvm/BinaryFormat/MachO.h"
 #include "llvm/TargetParser/ARMTargetParser.h"
 #include "llvm/TargetParser/Triple.h"
+#include "llvm/TargetParser/TripleUtils.h"
 
 using namespace llvm;
 
 static MachO::CPUSubTypeX86 getX86SubType(const Triple &T) {
   assert(T.isX86());
-  if (T.isArch32Bit())
+  if (TripleUtils::isArch32Bit(T))
     return MachO::CPU_SUBTYPE_I386_ALL;
 
   assert(T.isArch64Bit());
   if (T.getArchName() == "x86_64h")
     return MachO::CPU_SUBTYPE_X86_64_H;
   return MachO::CPU_SUBTYPE_X86_64_ALL;
 }
 
case ARM::ArchKind::ARMV7M:
     return MachO::CPU_SUBTYPE_ARM_V7M;
   case ARM::ArchKind::ARMV7EM:
     return MachO::CPU_SUBTYPE_ARM_V7EM;
   }
 }
 
 static MachO::CPUSubTypeARM64 getARM64SubType(const Triple &T) {
   assert(T.isAArch64());
-  if (T.isArch32Bit())
+  if (TripleUtils::isArch32Bit(T))
     return (MachO::CPUSubTypeARM64)MachO::CPU_SUBTYPE_ARM64_32_V8;
   if (T.isArm64e())
     return MachO::CPU_SUBTYPE_ARM64E;
 
   return MachO::CPU_SUBTYPE_ARM64_ALL;
 }
 
 static MachO::CPUSubTypePowerPC getPowerPCSubType(const Triple &T) {
   return MachO::CPU_SUBTYPE_POWERPC_ALL;
 }
 
 static Error unsupported(const char *Str, const Triple &T) {
   return createStringError(std::errc::invalid_argument,
                            "Unsupported triple for mach-o cpu %s: %s", Str,
                            T.str().c_str());
 }
 
 Expected<uint32_t> MachO::getCPUType(const Triple &T) {
   if (!T.isOSBinFormatMachO())
     return unsupported("type", T);
-  if (T.isX86() && T.isArch32Bit())
+  if (T.isX86() && TripleUtils::isArch32Bit(T))
     return MachO::CPU_TYPE_X86;
   if (T.isX86() && T.isArch64Bit())
     return MachO::CPU_TYPE_X86_64;
   if (T.isARM() || T.isThumb())
     return MachO::CPU_TYPE_ARM;
   if (T.isAArch64())
-    return T.isArch32Bit() ? MachO::CPU_TYPE_ARM64_32 : MachO::CPU_TYPE_ARM64;
+    return TripleUtils::isArch32Bit(T) ? MachO::CPU_TYPE_ARM64_32
+                                       : MachO::CPU_TYPE_ARM64;
   if (T.getArch() == Triple::ppc)
     return MachO::CPU_TYPE_POWERPC;
   if (T.getArch() == Triple::ppc64)
     return MachO::CPU_TYPE_POWERPC64;
   return unsupported("type", T);
 }
 
 Expected<uint32_t> MachO::getCPUSubType(const Triple &T) {

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

 #include "llvm/Support/Base64.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/TargetParser/Triple.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include <cassert>
 #include <string>
 
 using namespace llvm;
 using namespace dwarf;
 
 static cl::opt<bool> JumpTableInFunctionSection(
     "jumptable-in-function-section", cl::Hidden, cl::init(false),
MCSection *TargetLoweringObjectFileXCOFF::getSectionForConstant(
   }
 
   return ReadOnlySection;
 }
 
 void TargetLoweringObjectFileXCOFF::Initialize(MCContext &Ctx,
                                                const TargetMachine &TgtM) {
   TargetLoweringObjectFile::Initialize(Ctx, TgtM);
-  TTypeEncoding =
-      dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_datarel |
-      (TgtM.getTargetTriple().isArch32Bit() ? dwarf::DW_EH_PE_sdata4
-                                            : dwarf::DW_EH_PE_sdata8);
+  TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_datarel |
+                  (TripleUtils::isArch32Bit(TgtM.getTargetTriple())
+                       ? dwarf::DW_EH_PE_sdata4
   PersonalityEncoding = 0;
   LSDAEncoding = 0;
   CallSiteEncoding = dwarf::DW_EH_PE_udata4;
 
   // AIX debug for thread local location is not ready. And for integrated as
   // mode, the relocatable address for the thread local variable will cause
   // linker error. So disable the location attribute generation for thread local
   // variables for now.

llvm/lib/ProfileData/InstrProfCorrelator.cpp

 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFLocationExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include <optional>
 
 #define DEBUG_TYPE "correlator"
 
 using namespace llvm;
 
 /// Get the __llvm_prf_cnts section.
 Expected<object::SectionRef> getCountersSection(const object::ObjectFile &Obj) {
InstrProfCorrelator::get(std::unique_ptr<MemoryBuffer> Buffer) {
 
   if (auto *Obj = dyn_cast<object::ObjectFile>(BinOrErr->get())) {
     auto CtxOrErr = Context::get(std::move(Buffer), *Obj);
     if (auto Err = CtxOrErr.takeError())
       return std::move(Err);
     auto T = Obj->makeTriple();
     if (T.isArch64Bit())
       return InstrProfCorrelatorImpl<uint64_t>::get(std::move(*CtxOrErr), *Obj);
-    if (T.isArch32Bit())
+    if (TripleUtils::isArch32Bit(T))
       return InstrProfCorrelatorImpl<uint32_t>::get(std::move(*CtxOrErr), *Obj);
   }
   return make_error<InstrProfError>(
       instrprof_error::unable_to_correlate_profile, "not an object file");
 }
 
 std::optional<size_t> InstrProfCorrelator::getDataSize() const {
   if (auto *C = dyn_cast<InstrProfCorrelatorImpl<uint32_t>>(this)) {

llvm/lib/Target/AArch64/AArch64Subtarget.h

 #include "AArch64SelectionDAGInfo.h"
 #include "llvm/CodeGen/GlobalISel/CallLowering.h"
 #include "llvm/CodeGen/GlobalISel/InlineAsmLowering.h"
 #include "llvm/CodeGen/GlobalISel/InstructionSelector.h"
 #include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
 #include "llvm/CodeGen/RegisterBankInfo.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/DataLayout.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include <string>
 
 #define GET_SUBTARGETINFO_HEADER
 #include "AArch64GenSubtargetInfo.inc"
 
 namespace llvm {
 class GlobalValue;
 class StringRef;
#include "AArch64GenSubtargetInfo.inc"
   bool isTargetFuchsia() const { return TargetTriple.isOSFuchsia(); }
   bool isWindowsArm64EC() const { return TargetTriple.isWindowsArm64EC(); }
 
   bool isTargetCOFF() const { return TargetTriple.isOSBinFormatCOFF(); }
   bool isTargetELF() const { return TargetTriple.isOSBinFormatELF(); }
   bool isTargetMachO() const { return TargetTriple.isOSBinFormatMachO(); }
 
   bool isTargetILP32() const {
-    return TargetTriple.isArch32Bit() ||
+    return llvm::TripleUtils::isArch32Bit(TargetTriple) ||
            TargetTriple.getEnvironment() == Triple::GNUILP32;
   }
 
   bool useAA() const override;
 
   bool addrSinkUsingGEPs() const override {
     // Keeping GEPs inbounds is important for exploiting AArch64
     // addressing-modes in ILP32 mode.

llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp

 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/TargetParser/Triple.h"
+#include "llvm/TargetParser/TripleUtils.h"
 using namespace llvm;
 
 namespace {
 
 class AArch64AsmBackend : public MCAsmBackend {
   static const unsigned PCRelFlagVal =
       MCFixupKindInfo::FKF_IsAlignedDownTo32Bits | MCFixupKindInfo::FKF_IsPCRel;
 protected:
public:
   DarwinAArch64AsmBackend(const Target &T, const Triple &TT,
                           const MCRegisterInfo &MRI)
       : AArch64AsmBackend(T, TT, /*IsLittleEndian*/ true), MRI(MRI) {}
 
   std::unique_ptr<MCObjectTargetWriter>
   createObjectTargetWriter() const override {
     uint32_t CPUType = cantFail(MachO::getCPUType(TheTriple));
     uint32_t CPUSubType = cantFail(MachO::getCPUSubType(TheTriple));
-    return createAArch64MachObjectWriter(CPUType, CPUSubType,
-                                         TheTriple.isArch32Bit());
+    return createAArch64MachObjectWriter(
+        CPUType, CPUSubType, llvm::TripleUtils::isArch32Bit(TheTriple));
   }
 
   /// Generate the compact unwind encoding from the CFI directives.
   uint32_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
                                          const MCContext *Ctxt) const override {
     ArrayRef<MCCFIInstruction> Instrs = FI->Instructions;
     if (Instrs.empty())
       return CU::UNWIND_ARM64_MODE_FRAMELESS;

llvm/lib/Target/LoongArch/LoongArchTargetMachine.cpp

 #include "MCTargetDesc/LoongArchBaseInfo.h"
 #include "TargetInfo/LoongArchTargetInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/CodeGen.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include "llvm/Transforms/Scalar.h"
 #include <optional>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "loongarch"
 
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeLoongArchTarget() {
   // Register the target.
   RegisterTargetMachine<LoongArchTargetMachine> X(getTheLoongArch32Target());
   RegisterTargetMachine<LoongArchTargetMachine> Y(getTheLoongArch64Target());
   auto *PR = PassRegistry::getPassRegistry();
   initializeLoongArchPreRAExpandPseudoPass(*PR);
   initializeLoongArchDAGToDAGISelPass(*PR);
 }
 
 static cl::opt<bool>
     EnableLoopDataPrefetch("loongarch-enable-loop-data-prefetch", cl::Hidden,
                            cl::desc("Enable the loop data prefetch pass"),
                            cl::init(false));
 
 static std::string computeDataLayout(const Triple &TT) {
   if (TT.isArch64Bit())
     return "e-m:e-p:64:64-i64:64-i128:128-n64-S128";
-  assert(TT.isArch32Bit() && "only LA32 and LA64 are currently supported");
+  assert(TripleUtils::isArch32Bit(TT) &&
+         "only LA32 and LA64 are currently supported");
   return "e-m:e-p:32:32-i64:64-n32-S128";
 }
 
 static Reloc::Model getEffectiveRelocModel(const Triple &TT,
                                            std::optional<Reloc::Model> RM) {
   return RM.value_or(Reloc::Static);
 }
 

llvm/lib/Target/PowerPC/PPCTargetMachine.cpp

 #include "llvm/InitializePasses.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/TargetParser/Triple.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include "llvm/Transforms/Scalar.h"
 #include <cassert>
 #include <memory>
 #include <optional>
 #include <string>
 
 using namespace llvm;
 
getEffectivePPCCodeModel(const Triple &TT, std::optional<CodeModel::Model> CM,
 
   if (JIT)
     return CodeModel::Small;
   if (TT.isOSAIX())
     return CodeModel::Small;
 
   assert(TT.isOSBinFormatELF() && "All remaining PPC OSes are ELF based.");
 
-  if (TT.isArch32Bit())
+  if (TripleUtils::isArch32Bit(TT))
     return CodeModel::Small;
 
   assert(TT.isArch64Bit() && "Unsupported PPC architecture.");
   return CodeModel::Medium;
 }
 
 
 static ScheduleDAGInstrs *createPPCMachineScheduler(MachineSchedContext *C) {

llvm/lib/Target/RISCV/RISCVTargetMachine.cpp

 #include "llvm/CodeGen/MIRYamlMapping.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Target/TargetOptions.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include "llvm/Transforms/IPO.h"
 #include <optional>
 using namespace llvm;
 
 static cl::opt<bool> EnableRedundantCopyElimination(
     "riscv-enable-copyelim",
     cl::desc("Enable the redundant copy elimination pass"), cl::init(true),
     cl::Hidden);
extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeRISCVTarget() {
   initializeRISCVInitUndefPass(*PR);
   initializeRISCVMoveMergePass(*PR);
   initializeRISCVPushPopOptPass(*PR);
 }
 
 static StringRef computeDataLayout(const Triple &TT) {
   if (TT.isArch64Bit())
     return "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128";
-  assert(TT.isArch32Bit() && "only RV32 and RV64 are currently supported");
+  assert(TripleUtils::isArch32Bit(TT) &&
+         "only RV32 and RV64 are currently supported");
   return "e-m:e-p:32:32-i64:64-n32-S128";
 }
 
 static Reloc::Model getEffectiveRelocModel(const Triple &TT,
                                            std::optional<Reloc::Model> RM) {
   return RM.value_or(Reloc::Static);
 }
 

llvm/lib/Target/X86/X86AsmPrinter.cpp

 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Target/TargetMachine.h"
+#include "llvm/TargetParser/TripleUtils.h"
 
 using namespace llvm;
 
 X86AsmPrinter::X86AsmPrinter(TargetMachine &TM,
                              std::unique_ptr<MCStreamer> Streamer)
     : AsmPrinter(TM, std::move(Streamer)), FM(*this) {}
 
 //===----------------------------------------------------------------------===//
if (TT.isOSBinFormatELF()) {
     unsigned FeatureFlagsAnd = 0;
     if (M.getModuleFlag("cf-protection-branch"))
       FeatureFlagsAnd |= ELF::GNU_PROPERTY_X86_FEATURE_1_IBT;
     if (M.getModuleFlag("cf-protection-return"))
       FeatureFlagsAnd |= ELF::GNU_PROPERTY_X86_FEATURE_1_SHSTK;
 
     if (FeatureFlagsAnd) {
       // Emit a .note.gnu.property section with the flags.
-      if (!TT.isArch32Bit() && !TT.isArch64Bit())
+      if (!TripleUtils::isArch32Bit(TT) && !TT.isArch64Bit())
         llvm_unreachable("CFProtection used on invalid architecture!");
       MCSection *Cur = OutStreamer->getCurrentSectionOnly();
       MCSection *Nt = MMI->getContext().getELFSection(
           ".note.gnu.property", ELF::SHT_NOTE, ELF::SHF_ALLOC);
       OutStreamer->switchSection(Nt);
 
       // Emitting note header.
       const int WordSize = TT.isArch64Bit() && !TT.isX32() ? 8 : 4;

llvm/lib/TargetParser/Host.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TargetParser/Triple.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include "llvm/TargetParser/X86TargetParser.h"
 #include <string.h>
 
 // Include the platform-specific parts of this class.
 #ifdef LLVM_ON_UNIX
 #include "Unix/Host.inc"
 #include <sched.h>
 #endif
std::string sys::getProcessTriple() {
   Triple PT(Triple::normalize(TargetTripleString));
 
 #if __APPLE__
   /// In Universal builds, LLVM_HOST_TRIPLE will have the wrong arch in one of
   /// the slices. This fixes that up.
   PT = withHostArch(PT);
 #endif
 
-  if (sizeof(void *) == 8 && PT.isArch32Bit())
+  if (sizeof(void *) == 8 && TripleUtils::isArch32Bit(PT))
     PT = PT.get64BitArchVariant();
   if (sizeof(void *) == 4 && PT.isArch64Bit())
     PT = PT.get32BitArchVariant();
 
   return PT.str();
 }
 
 void sys::printDefaultTargetAndDetectedCPU(raw_ostream &OS) {
 #if LLVM_VERSION_PRINTER_SHOW_HOST_TARGET_INFO
   std::string CPU = std::string(sys::getHostCPUName());
   if (CPU == "generic")
     CPU = "(unknown)";
   OS << "  Default target: " << sys::getDefaultTargetTriple() << '\n'
      << "  Host CPU: " << CPU << '\n';
 #endif
 }

llvm/lib/TargetParser/Triple.cpp

 bool Triple::isArch64Bit() const {
   return getArchPointerBitWidth(getArch()) == 64;
 }
 
 bool Triple::isArch32Bit() const {
   return getArchPointerBitWidth(getArch()) == 32;
 }
 
+bool Triple::isArch16Bit() const {
+  return getArchPointerBitWidth(getArch()) == 16;
+}
+
 Triple Triple::get32BitArchVariant() const {
   Triple T(*this);
   switch (getArch()) {
   case Triple::UnknownArch:
   case Triple::amdgcn:
   case Triple::avr:
   case Triple::bpfeb:
   case Triple::bpfel:

llvm/lib/TargetParser/TripleUtils.cpp

case llvm::Triple::x86_64:
     return 64;
   }
   llvm_unreachable("Invalid architecture value");
 }
 
 bool TripleUtils::isArch16Bit(const llvm::Triple &tripleImpl) {
   return getArchPointerBitWidth(tripleImpl.getArch()) == 16;
 }
+
+bool TripleUtils::isArch32Bit(const llvm::Triple &tripleImpl) {
+  return getArchPointerBitWidth(tripleImpl.getArch()) == 32;
+}
 No newline at end of file

llvm/lib/XRay/InstrumentationMap.cpp

 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/RelocationResolver.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/TargetParser/Triple.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
 #include <system_error>
 #include <vector>
 
 using namespace llvm;
 using namespace xray;
for (const object::SectionRef &Section : Sections) {
             Relocs.insert({Reloc.getOffset(), *AddendOrErr});
         }
       }
     }
   }
 
   // Copy the instrumentation map data into the Sleds data structure.
   auto C = Contents.bytes_begin();
-  bool Is32Bit = ObjFile.getBinary()->makeTriple().isArch32Bit();
+  bool Is32Bit = TripleUtils::isArch32Bit(ObjFile.getBinary()->makeTriple());
   size_t ELFSledEntrySize = Is32Bit ? 16 : 32;
 
   if ((C - Contents.bytes_end()) % ELFSledEntrySize != 0)
     return make_error<StringError>(
         Twine("Instrumentation map entries not evenly divisible by size of "
               "an XRay sled entry."),
         std::make_error_code(std::errc::executable_format_error));
 

llvm/tools/llvm-ml/llvm-ml.cpp

 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/TargetParser/Host.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include <ctime>
 #include <optional>
 
 using namespace llvm;
 using namespace llvm::opt;
 
 namespace {
 
int main(int Argc, char **Argv) {
   const Target *TheTarget = TargetRegistry::lookupTarget("", TheTriple, Error);
   if (!TheTarget) {
     WithColor::error(errs(), ProgName) << Error;
     return 1;
   }
   const std::string &TripleName = TheTriple.getTriple();
 
   bool SafeSEH = InputArgs.hasArg(OPT_safeseh);
-  if (SafeSEH && !(TheTriple.isArch32Bit() && TheTriple.isX86())) {
+  if (SafeSEH && !(TripleUtils::isArch32Bit(TheTriple) && TheTriple.isX86())) {
     WithColor::warning()
         << "/safeseh applies only to 32-bit X86 platforms; ignoring.\n";
     SafeSEH = false;
   }
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
       MemoryBuffer::getFileOrSTDIN(InputFilename);
   if (std::error_code EC = BufferPtr.getError()) {

llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp

for (WorklistT::iterator I = Worklist.begin(), E = Worklist.end();
     }
   }
 
   // If the -target-addr-end option wasn't explicitly passed, then set it to a
   // sensible default based on the target triple.
   if (TargetAddrEnd.getNumOccurrences() == 0) {
     if (llvm::TripleUtils::isArch16Bit(TargetTriple))
       TargetAddrEnd = (1ULL << 16) - 1;
-    else if (TargetTriple.isArch32Bit())
+    else if (llvm::TripleUtils::isArch32Bit(TargetTriple))
       TargetAddrEnd = (1ULL << 32) - 1;
     // TargetAddrEnd already has a sensible default for 64-bit systems, so
     // there's nothing to do in the 64-bit case.
   }
 
   // Process any elements remaining in the worklist.
   while (!Worklist.empty()) {
     auto *CurEntry = Worklist.front();

llvm/unittests/DebugInfo/DWARF/DwarfUtils.cpp

 //===--- unittests/DebugInfo/DWARF/DwarfUtils.cpp ---------------*- 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 "DwarfUtils.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/TargetParser/Host.h"
 #include "llvm/TargetParser/Triple.h"
+#include "llvm/TargetParser/TripleUtils.h"
 
 using namespace llvm;
 
 static void initLLVMIfNeeded() {
   static bool gInitialized = false;
   if (!gInitialized) {
     gInitialized = true;
     InitializeAllTargets();

 Triple llvm::dwarf::utils::getDefaultTargetTripleForAddrSize(uint8_t AddrSize) {
   Triple T = getNormalizedDefaultTargetTriple();
 
   assert((AddrSize == 4 || AddrSize == 8) &&
          "Only 32-bit/64-bit address size variants are supported");
 
   // If a 32-bit/64-bit address size was specified, try to convert the triple
   // if it is for the wrong variant.
-  if (AddrSize == 8 && T.isArch32Bit())
+  if (AddrSize == 8 && TripleUtils::isArch32Bit(T))
     return T.get64BitArchVariant();
   if (AddrSize == 4 && T.isArch64Bit())
     return T.get32BitArchVariant();
   return T;
 }
 
 bool llvm::dwarf::utils::isConfigurationSupported(Triple &T) {
   initLLVMIfNeeded();
   std::string Err;
   const Target *TheTarget = TargetRegistry::lookupTarget(T.getTriple(), Err);
   return TheTarget && TheTarget->hasMCAsmBackend();
 }

llvm/unittests/TargetParser/TripleTest.cpp

TEST(TripleTest, ParsedIDs) {
   EXPECT_EQ(Triple::Linux, T.getOS());
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
   EXPECT_TRUE(T.isArch64Bit());
 
   T = Triple("arm64_32-apple-ios");
   EXPECT_EQ(Triple::aarch64_32, T.getArch());
   EXPECT_EQ(Triple::IOS, T.getOS());
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
-  EXPECT_TRUE(T.isArch32Bit());
 
   T = Triple("dxil-unknown-shadermodel-pixel");
   EXPECT_EQ(Triple::dxil, T.getArch());
   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
   EXPECT_EQ(Triple::ShaderModel, T.getOS());
   EXPECT_EQ(Triple::Pixel, T.getEnvironment());
   EXPECT_FALSE(T.supportsCOMDAT());
 
TEST(TripleTest, MutateName) {
   EXPECT_EQ(Triple::x86, T.getArch());
   EXPECT_EQ(Triple::PC, T.getVendor());
   EXPECT_EQ(Triple::Darwin, T.getOS());
   EXPECT_EQ("i386-pc-darwin", T.getTriple());
 }
 
 TEST(TripleTest, BitWidthPredicates) {
   Triple T;
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::arm);
-  EXPECT_TRUE(T.isArch32Bit());
+  ;
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::hexagon);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::mips);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::mips64);
-  EXPECT_FALSE(T.isArch32Bit());
+  ;
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::msp430);
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::ppc);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::ppc64);
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::x86);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::x86_64);
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::amdil);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::amdil64);
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::hsail);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::hsail64);
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::spir);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::spir64);
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::spirv32);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
   EXPECT_TRUE(T.isSPIRV());
 
   T.setArch(Triple::spirv64);
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
   EXPECT_TRUE(T.isSPIRV());
 
   T.setArch(Triple::sparc);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::sparcel);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::sparcv9);
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::wasm32);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::wasm64);
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::avr);
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::lanai);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::riscv32);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
   EXPECT_TRUE(T.isRISCV());
 
   T.setArch(Triple::riscv64);
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
   EXPECT_TRUE(T.isRISCV());
 
   T.setArch(Triple::csky);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
   EXPECT_TRUE(T.isCSKY());
 
   T.setArch(Triple::loongarch32);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
   EXPECT_TRUE(T.isLoongArch());
   EXPECT_TRUE(T.isLoongArch32());
 
   T.setArch(Triple::loongarch64);
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
   EXPECT_TRUE(T.isLoongArch());
   EXPECT_TRUE(T.isLoongArch64());
 
   T.setArch(Triple::dxil);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
   EXPECT_TRUE(T.isDXIL());
 
   T.setArch(Triple::xtensa);
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 }
 
 TEST(TripleTest, BitWidthArchVariants) {
   Triple T;
   EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
 

 
 TEST(TripleTest, getOSVersion) {
   Triple T;
   VersionTuple Version;
 
   T = Triple("i386-apple-darwin9");
   EXPECT_TRUE(T.isMacOSX());
   EXPECT_FALSE(T.isiOS());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
   T.getMacOSXVersion(Version);
   EXPECT_EQ(VersionTuple(10, 5), Version);
   Version = T.getiOSVersion();
   EXPECT_EQ(VersionTuple(5), Version);
 
   T = Triple("x86_64-apple-darwin9");
   EXPECT_TRUE(T.isMacOSX());
   EXPECT_FALSE(T.isiOS());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
   T.getMacOSXVersion(Version);
   EXPECT_EQ(VersionTuple(10, 5), Version);
   Version = T.getiOSVersion();
   EXPECT_EQ(VersionTuple(5), Version);
 
   T = Triple("x86_64-apple-macosx");
   EXPECT_TRUE(T.isMacOSX());
   EXPECT_FALSE(T.isiOS());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
   T.getMacOSXVersion(Version);
   EXPECT_EQ(VersionTuple(10, 4), Version);
   Version = T.getiOSVersion();
   EXPECT_EQ(VersionTuple(5), Version);
 
   T = Triple("x86_64-apple-macosx10.7");
   EXPECT_TRUE(T.isMacOSX());
   EXPECT_FALSE(T.isiOS());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
   T.getMacOSXVersion(Version);
   EXPECT_EQ(VersionTuple(10, 7), Version);
   Version = T.getiOSVersion();
   EXPECT_EQ(VersionTuple(5), Version);
 
   T = Triple("x86_64-apple-macos11.0");
   EXPECT_TRUE(T.isMacOSX());
   EXPECT_FALSE(T.isiOS());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
   T.getMacOSXVersion(Version);
   EXPECT_EQ(VersionTuple(11, 0), Version);
 
   T = Triple("arm64-apple-macosx11.5.8");
   EXPECT_TRUE(T.isMacOSX());
   EXPECT_FALSE(T.isiOS());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
   T.getMacOSXVersion(Version);
   EXPECT_EQ(VersionTuple(11, 5, 8), Version);
 
   // 10.16 forms a valid triple, even though it's not
   // a version of a macOS.
   T = Triple("x86_64-apple-macos10.16");
   EXPECT_TRUE(T.isMacOSX());
TEST(TripleTest, getOSVersion) {
   T = Triple("x86_64-apple-darwin20.2");
   EXPECT_TRUE(T.isMacOSX());
   T.getMacOSXVersion(Version);
   EXPECT_EQ(VersionTuple(11), Version);
 
   T = Triple("armv7-apple-ios");
   EXPECT_FALSE(T.isMacOSX());
   EXPECT_TRUE(T.isiOS());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
   T.getMacOSXVersion(Version);
   EXPECT_EQ(VersionTuple(10, 4), Version);
   Version = T.getiOSVersion();
   EXPECT_EQ(VersionTuple(5), Version);
 
   T = Triple("armv7-apple-ios7.0");
   EXPECT_FALSE(T.isMacOSX());
   EXPECT_TRUE(T.isiOS());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
   T.getMacOSXVersion(Version);
   EXPECT_EQ(VersionTuple(10, 4), Version);
   Version = T.getiOSVersion();
   EXPECT_EQ(VersionTuple(7, 0), Version);
   EXPECT_FALSE(T.isSimulatorEnvironment());
 
   T = Triple("x86_64-apple-ios10.3-simulator");

llvm/unittests/TargetParser/TripleUtilsTest.cpp

 
 using namespace llvm;
 
 namespace {
 
 TEST(TripleUtilsTest, CheckArchBitWidth) {
   Triple T;
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
 
   T.setArch(Triple::arm);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::hexagon);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::mips);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::mips64);
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::msp430);
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_TRUE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::ppc);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::ppc64);
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::x86);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::x86_64);
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::amdil);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::amdil64);
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::hsail);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::hsail64);
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::spir);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::spir64);
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::spirv32);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::spirv64);
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::sparc);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::sparcel);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
   ;
 
   T.setArch(Triple::sparcv9);
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::wasm32);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::wasm64);
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::avr);
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_TRUE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::lanai);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::riscv32);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::riscv64);
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::csky);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::loongarch32);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::loongarch64);
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::dxil);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 
   T.setArch(Triple::xtensa);
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
   EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(T));
 }
 
+TEST(TripleUtilsTest, CheckArchBitWidthUsingOS) {
+  Triple T;
+  VersionTuple Version;
+
+  T = Triple("i386-apple-darwin9");
+  EXPECT_FALSE(T.isArch64Bit());
+
+  T = Triple("x86_64-apple-darwin9");
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
+
+  T = Triple("x86_64-apple-macosx");
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
+
+  T = Triple("x86_64-apple-macosx10.7");
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
+
+  T = Triple("x86_64-apple-macos11.0");
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
+
+  T = Triple("arm64-apple-macosx11.5.8");
+  EXPECT_TRUE(T.isArch64Bit());
+
+  T = Triple("armv7-apple-ios");
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
+
+  T = Triple("armv7-apple-ios7.0");
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
+}
+
 } // namespace
 No newline at end of file