feat: Migrate isArch16Bit

[Pivnoy]

Summary

Started refactor the Triple class to convert it to data class

[Pivnoy]

Add deprecated attribute

[Pivnoy]

Fix some format mistake

[Pivnoy]

Add test for isArch32Bit to TripleUtilsTest

[Pivnoy]

Migrate isArch64Bit to TripleUtils

[Pivnoy]

Fix clang-format issues

[asb]

Is there some separate discussion thread or proposal about this refactoring and its motivations?

[Pivnoy]

This discussion was the main motivation for this change.
https://discourse.llvm.org/t/rfc-refactor-triple-related-classes/70410/11
As a result, Triple should become a data class, and its dependencies such as Architecture, Operating System etc. represent in the form of interfaces that can be implemented for the necessary instances.

[Pivnoy]

clang-format fix

[MaskRay]

In D157497#4584621, @Pivnoy wrote:

This discussion was the main motivation for this change.
https://discourse.llvm.org/t/rfc-refactor-triple-related-classes/70410/11
As a result, Triple should become a data class, and its dependencies such as Architecture, Operating System etc. represent in the form of interfaces that can be implemented for the necessary instances.

FWIW I still don't see advantages by switching to the new llvm::TripleUtils::isArch32Bit style. How is it better than the current way?

[bulbazord]

In D157497#4586165, @MaskRay wrote:

In D157497#4584621, @Pivnoy wrote:

This discussion was the main motivation for this change.
https://discourse.llvm.org/t/rfc-refactor-triple-related-classes/70410/11
As a result, Triple should become a data class, and its dependencies such as Architecture, Operating System etc. represent in the form of interfaces that can be implemented for the necessary instances.

FWIW I still don't see advantages by switching to the new llvm::TripleUtils::isArch32Bit style. How is it better than the current way?

+1
What advantages does this approach bring? I re-read the RFC in the discourse link you posted and I'm still not sure why this approach is desirable. Happy to discuss further either on this PR or in the discourse thread.

[Pivnoy]

At the moment, the TargetParser architecture is extensible. This complicates the addition of new architectures, operating systems, and so on.
In the main discussion, it was proposed to redesign the architecture of this module in order to increase the possibility of adding new architectures, etc.
The main idea of the rework was to separate the Triple entity into a data-class, and create a number of interfaces from components that would include Triple, through the implementation of which it would be possible to represent various data bindings of the components. At the moment, Triple is overflowing with various methods that do not fully meet the ideas of OOP.
Since the TargetParser module is quite large and has many dependencies throughout the llvm-project, it was first of all supposed to remove these methods from Triple, since they would not correspond to OOP ideas.
This would help to gradually rid Triple of unnecessary dependencies, and gradually change the architecture inside Triple, without breaking code of another LLVM developers.

[Pivnoy]

@bulbazord
@MaskRay

[nikic]

This change looks strictly worse in isolation, the proposal on discourse did not reach consensus, and looking at the diagram in https://discourse.llvm.org/t/rfc-refactor-triple-related-classes/70410/11 there is zero chance that it is ever going to be accepted.

[bulbazord]

In D157497#4592330, @Pivnoy wrote:

At the moment, the TargetParser architecture is extensible. This complicates the addition of new architectures, operating systems, and so on.
In the main discussion, it was proposed to redesign the architecture of this module in order to increase the possibility of adding new architectures, etc.
The main idea of the rework was to separate the Triple entity into a data-class, and create a number of interfaces from components that would include Triple, through the implementation of which it would be possible to represent various data bindings of the components. At the moment, Triple is overflowing with various methods that do not fully meet the ideas of OOP.
Since the TargetParser module is quite large and has many dependencies throughout the llvm-project, it was first of all supposed to remove these methods from Triple, since they would not correspond to OOP ideas.
This would help to gradually rid Triple of unnecessary dependencies, and gradually change the architecture inside Triple, without breaking code of another LLVM developers.

I'm still not sure how this would make things simpler. I'll be as specific is possible in what does not click for me.

There is an inherent complexity in parsing triples. Architectures can have variants and subvariants, compilers and other tools do different things for the same architecture and OS when there are different vendors, the environment can subtly change things like ABI, the list goes on. I don't think you're going to be able to wholesale reduce complexity here. The proposal you've laid out here is certainly very OOP-like (in some sense of the phrase "OOP") but you present your ideas under the assumption that this style of OOP is the ideal to strive for. Why is that? Why is this better than what exists today? Is it easier to debug? Is it more performant? Is it easier to maintain? I personally do not think it will be better than what already exists in any of those ways.

In the original discourse thread, you also made the argument that the potential performance overhead and binary size increase should be unnoticeable and that with modern machines we do not need to fight for each microsecond. Without any numbers for performance or size, this is not an argument I can accept. Knowingly adding a performance/size regression to your build tools without an appropriate tradeoff does not make sense to do.

If you want to do this, please provide a concrete argument for what benefit this brings.

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

 //===--- OSTargets.h - Declare OS target feature support --------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares OS specific TargetInfo types.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H
 #define LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H
 
 #include "Targets.h"
+#include "llvm/TargetParser/TripleUtils.h"
 
 namespace clang {
 namespace targets {
 
 template <typename TgtInfo>
 class LLVM_LIBRARY_VISIBILITY OSTargetInfo : public TgtInfo {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
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

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

 #include "llvm/Support/Process.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/TargetParser/Host.h"
 #include "llvm/TargetParser/Triple.h"
+#include "llvm/TargetParser/TripleUtils.h"
 #include <algorithm>
 #include <atomic>
 #include <cassert>
 #include <cstddef>
 #include <cstring>
 #include <ctime>
 #include <fstream>
 #include <limits>
if (Opts.OpenMPIsTargetDevice) {
     if (Args.hasArg(OPT_fopenmp_assume_threads_oversubscription))
       Opts.OpenMPThreadSubscription = true;
   }
 
   // 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 (T.isArch16Bit())
+      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:
   /// 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.
   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 TripleUtils::isArch32Bit(const llvm::Triple& tripleImpl) "
+               "instead.")]] bool
+  isArch32Bit() const;
 
   /// Test whether the architecture is 16-bit
   ///
   /// Note that this tests for 16-bit pointer width, and nothing else.
-  bool isArch16Bit() const;
+  [[deprecated("Use TripleUtils::isArch16Bit(const llvm::Triple& tripleImpl) "
+               "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

+//===-- llvm/TargetParser/TripleUtils.h - Triple Utils class--*- 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_TARGETPARSER_TRIPLE_UTILS_H
+#define LLVM_TARGETPARSER_TRIPLE_UTILS_H
+
+#include "llvm/TargetParser/Triple.h"
+#include <string>
+
+namespace llvm {
+
+class TripleUtils {
+public:
+  /// 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);
+
+  static bool isArch32Bit(const llvm::Triple &tripleImpl);
+};
+
+} // namespace llvm
+
+#endif
 No newline at end of file

llvm/lib/Analysis/TargetLibraryInfo.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/TargetParser/Triple.h"
+#include "llvm/TargetParser/TripleUtils.h"
 using namespace llvm;
 
 static cl::opt<TargetLibraryInfoImpl::VectorLibrary> ClVectorLibrary(
     "vector-library", cl::Hidden, cl::desc("Vector functions library"),
     cl::init(TargetLibraryInfoImpl::NoLibrary),
     cl::values(clEnumValN(TargetLibraryInfoImpl::NoLibrary, "none",
                           "No vector functions library"),
                clEnumValN(TargetLibraryInfoImpl::Accelerate, "Accelerate",
static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
   TLI.setShouldExtI32Param(ShouldExtI32Param);
   TLI.setShouldExtI32Return(ShouldExtI32Return);
   TLI.setShouldSignExtI32Param(ShouldSignExtI32Param);
   TLI.setShouldSignExtI32Return(ShouldSignExtI32Return);
 
   // Let's assume by default that the size of int is 32 bits, unless the target
   // is a 16-bit architecture because then it most likely is 16 bits. If that
   // isn't true for a target those defaults should be overridden below.
-  TLI.setIntSize(T.isArch16Bit() ? 16 : 32);
+  TLI.setIntSize(llvm::TripleUtils::isArch16Bit(T) ? 16 : 32);
 
   // There is really no runtime library on AMDGPU, apart from
   // __kmpc_alloc/free_shared.
   if (T.isAMDGPU()) {
     TLI.disableAllFunctions();
     TLI.setAvailable(llvm::LibFunc___kmpc_alloc_shared);
     TLI.setAvailable(llvm::LibFunc___kmpc_free_shared);
     return;

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 |
+                  (llvm::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:
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());
+                                         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(llvm::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(llvm::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/CMakeLists.txt

add_llvm_component_library(LLVMTargetParser
   ARMTargetParser.cpp
   CSKYTargetParser.cpp
   Host.cpp
   LoongArchTargetParser.cpp
   RISCVTargetParser.cpp
   SubtargetFeature.cpp
   TargetParser.cpp
   Triple.cpp
+  TripleUtils.cpp
   X86TargetParser.cpp
 
   ADDITIONAL_HEADER_DIRS
   Unix
   Windows
 
   LINK_COMPONENTS
   Support
 
   DEPENDS
   RISCVTargetParserTableGen
   )

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 && llvm::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/TripleUtils.cpp

+//===--- TripleUtils.cpp - Triple Utils class --------------------------===//
+//
+// 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/TargetParser/TripleUtils.h"
+#include "llvm/Support/ErrorHandling.h"
+using namespace llvm;
+
+static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
+  switch (Arch) {
+  case llvm::Triple::UnknownArch:
+    return 0;
+
+  case llvm::Triple::avr:
+  case llvm::Triple::msp430:
+    return 16;
+
+  case llvm::Triple::aarch64_32:
+  case llvm::Triple::amdil:
+  case llvm::Triple::arc:
+  case llvm::Triple::arm:
+  case llvm::Triple::armeb:
+  case llvm::Triple::csky:
+  case llvm::Triple::dxil:
+  case llvm::Triple::hexagon:
+  case llvm::Triple::hsail:
+  case llvm::Triple::kalimba:
+  case llvm::Triple::lanai:
+  case llvm::Triple::le32:
+  case llvm::Triple::loongarch32:
+  case llvm::Triple::m68k:
+  case llvm::Triple::mips:
+  case llvm::Triple::mipsel:
+  case llvm::Triple::nvptx:
+  case llvm::Triple::ppc:
+  case llvm::Triple::ppcle:
+  case llvm::Triple::r600:
+  case llvm::Triple::renderscript32:
+  case llvm::Triple::riscv32:
+  case llvm::Triple::shave:
+  case llvm::Triple::sparc:
+  case llvm::Triple::sparcel:
+  case llvm::Triple::spir:
+  case llvm::Triple::spirv32:
+  case llvm::Triple::tce:
+  case llvm::Triple::tcele:
+  case llvm::Triple::thumb:
+  case llvm::Triple::thumbeb:
+  case llvm::Triple::wasm32:
+  case llvm::Triple::x86:
+  case llvm::Triple::xcore:
+  case llvm::Triple::xtensa:
+    return 32;
+
+  case llvm::Triple::aarch64:
+  case llvm::Triple::aarch64_be:
+  case llvm::Triple::amdgcn:
+  case llvm::Triple::amdil64:
+  case llvm::Triple::bpfeb:
+  case llvm::Triple::bpfel:
+  case llvm::Triple::hsail64:
+  case llvm::Triple::le64:
+  case llvm::Triple::loongarch64:
+  case llvm::Triple::mips64:
+  case llvm::Triple::mips64el:
+  case llvm::Triple::nvptx64:
+  case llvm::Triple::ppc64:
+  case llvm::Triple::ppc64le:
+  case llvm::Triple::renderscript64:
+  case llvm::Triple::riscv64:
+  case llvm::Triple::sparcv9:
+  case llvm::Triple::spir64:
+  case llvm::Triple::spirv64:
+  case llvm::Triple::systemz:
+  case llvm::Triple::ve:
+  case llvm::Triple::wasm64:
+  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

 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MSVCErrorWorkarounds.h"
 #include "llvm/Support/Memory.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
-
+#include "llvm/TargetParser/TripleUtils.h"
 #include <future>
 #include <list>
 
 using namespace llvm;
 using namespace llvm::object;
 
 static cl::OptionCategory RTDyldCategory("RTDyld Options");
 
if (LoadAddr != static_cast<uint64_t>(
         AlreadyAllocated[LoadAddr] = (*Tmp)->MB.allocatedSize();
       Worklist.erase(Tmp);
     }
   }
 
   // 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 (TargetTriple.isArch16Bit())
+    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/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   TargetParser
   )
 
 add_llvm_unittest(TargetParserTests
   CSKYTargetParserTest.cpp
   Host.cpp
   TargetParserTest.cpp
   TripleTest.cpp
+  TripleUtilsTest.cpp
   )
 
 target_link_libraries(TargetParserTests PRIVATE LLVMTestingSupport)

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.isArch16Bit());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::arm);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::hexagon);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::mips);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::mips64);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::msp430);
-  EXPECT_TRUE(T.isArch16Bit());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::ppc);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::ppc64);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::x86);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::x86_64);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::amdil);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::amdil64);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::hsail);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::hsail64);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::spir);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::spir64);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::spirv32);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
   EXPECT_TRUE(T.isSPIRV());
 
   T.setArch(Triple::spirv64);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
   EXPECT_TRUE(T.isSPIRV());
 
   T.setArch(Triple::sparc);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::sparcel);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::sparcv9);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::wasm32);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::wasm64);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
 
   T.setArch(Triple::avr);
-  EXPECT_TRUE(T.isArch16Bit());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::lanai);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
 
   T.setArch(Triple::riscv32);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
   EXPECT_TRUE(T.isRISCV());
 
   T.setArch(Triple::riscv64);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
   EXPECT_TRUE(T.isRISCV());
 
   T.setArch(Triple::csky);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
   EXPECT_TRUE(T.isCSKY());
 
   T.setArch(Triple::loongarch32);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
   EXPECT_TRUE(T.isLoongArch());
   EXPECT_TRUE(T.isLoongArch32());
 
   T.setArch(Triple::loongarch64);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_FALSE(T.isArch32Bit());
   EXPECT_TRUE(T.isArch64Bit());
   EXPECT_TRUE(T.isLoongArch());
   EXPECT_TRUE(T.isLoongArch64());
 
   T.setArch(Triple::dxil);
-  EXPECT_FALSE(T.isArch16Bit());
-  EXPECT_TRUE(T.isArch32Bit());
   EXPECT_FALSE(T.isArch64Bit());
   EXPECT_TRUE(T.isDXIL());
 
   T.setArch(Triple::xtensa);
-  EXPECT_FALSE(T.isArch16Bit());
-  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_FALSE(T.isArch16Bit());
-  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.isArch16Bit());
-  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.isArch16Bit());
-  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.isArch16Bit());
-  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.isArch16Bit());
-  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.isArch16Bit());
-  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_FALSE(T.isArch16Bit());
-  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_FALSE(T.isArch16Bit());
-  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

+//===----------- TripleUtils.cpp - TripleUtils unit tests
+//---------------------------===//
+//
+// 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/TargetParser/TripleUtils.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+
+TEST(TripleUtilsTest, CheckArchBitWidth) {
+  Triple T;
+  EXPECT_FALSE(llvm::TripleUtils::isArch32Bit(T));
+  EXPECT_FALSE(llvm::TripleUtils::isArch16Bit(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, CheckArchBitWidthUsingOSVersion) {
+  Triple T;
+  VersionTuple Version;
+
+  T = Triple("i386-apple-darwin9");
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
+
+  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_FALSE(llvm::TripleUtils::isArch32Bit(T));
+
+  T = Triple("armv7-apple-ios");
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
+
+  T = Triple("armv7-apple-ios7.0");
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
+
+  T = Triple("arm64_32-apple-ios");
+  EXPECT_TRUE(llvm::TripleUtils::isArch32Bit(T));
+}
+
+} // namespace
 No newline at end of file