AArch64: classify Triple::aarch64_32 as AArch64

[t.p.northover]

Summary

We want arm64_32 to omit leaf frame pointers. At the moment this is predicated on isAArch64 and fails because Triple::aarch64_32 doesn't count. That's logically incorrect, and fortunately that function is used infrequently enough that we can update its callers where appropriate, as here.

[dexonsmith]

clang/lib/Driver/ToolChain.cpp

1066

Is there a short-form we'd want for this?

Here are two ideas:

// getTriple().isAArch64_64() and getTriple().isAArch64_32()
bool Triple::isAArch64_64() { return isAArch64() && isArch64Bit(); }
bool Triple::isAArch64_32() { return isAArch64() && isArch32Bit(); }

// getTriple().isAArch64(64) and getTriple().isAArch64(32)
bool Triple::isAArch64(int Bits) {
  assert(Bits == 32 || Bits == 64);
  if (!isAArch64())
    return false;
  return isArch64Bit() ? Bits == 64 : Bits == 32;
}

Or do you think it's better as-is?

llvm/include/llvm/ADT/Triple.h

715

Should the comment be changed?

[t.p.northover]

clang/lib/Driver/ToolChain.cpp

1066

Tricky one. The bare "64" and "32" are a bit non-descript, but having both isAArch64 and isArch64 in the same line seems just slightly worse to me so I'll update the patch.

[Gerolf]

LGTM.

[t.p.northover]

Thanks Gerolf. Committed:

To github.com:llvm/llvm-project.git

ae9d96a656a1..152df3add156  master -> master

clang/lib/Driver/ToolChain.cpp

SanitizerMask Res =
       SanitizerKind::UnsignedShiftBase | SanitizerKind::ImplicitConversion |
       SanitizerKind::Nullability | SanitizerKind::LocalBounds;
   if (getTriple().getArch() == llvm::Triple::x86 ||
       getTriple().getArch() == llvm::Triple::x86_64 ||
       getTriple().getArch() == llvm::Triple::arm || getTriple().isWasm() ||
       getTriple().isAArch64())
     Res |= SanitizerKind::CFIICall;
   if (getTriple().getArch() == llvm::Triple::x86_64 ||
-      getTriple().isAArch64() || getTriple().isRISCV())
+      getTriple().isAArch64(64) || getTriple().isRISCV())
     Res |= SanitizerKind::ShadowCallStack;
-  if (getTriple().isAArch64())
+  if (getTriple().isAArch64(64))
     Res |= SanitizerKind::MemTag;
   return Res;
 }
 
 void ToolChain::AddCudaIncludeArgs(const ArgList &DriverArgs,
                                    ArgStringList &CC1Args) const {}
 
 void ToolChain::AddHIPIncludeArgs(const ArgList &DriverArgs,

clang/test/Driver/frame-pointer-elim.c

 
 // On AArch64 and PS4, default to omitting the frame pointer on leaf functions
 // RUN: %clang -### -target aarch64 -S %s 2>&1 | \
 // RUN:   FileCheck --check-prefix=KEEP-NON-LEAF %s
 // RUN: %clang -### -target x86_64-scei-ps4 -S %s 2>&1 | \
 // RUN:   FileCheck --check-prefix=KEEP-NON-LEAF %s
 // RUN: %clang -### -target x86_64-scei-ps4 -S -O2 %s 2>&1 | \
 // RUN:   FileCheck --check-prefix=KEEP-NON-LEAF %s
+// RUN: %clang -### -target aarch64-apple-darwin -arch arm64_32 -S %s 2>&1 | \
+// RUN:   FileCheck --check-prefix=KEEP-NON-LEAF %s
 
 // RUN: %clang -### -target powerpc64 -S %s 2>&1 | \
 // RUN:   FileCheck --check-prefix=KEEP-ALL %s
 // RUN: %clang -### -target powerpc64 -S -O1 %s 2>&1 | \
 // RUN:   FileCheck --check-prefix=KEEP-NONE %s
 
 // For AAarch32 (A32, T32) linux targets, default omit frame pointer when
 // optimizations are enabled.

llvm/include/llvm/ADT/Triple.h

bool isThumb() const {
     return getArch() == Triple::thumb || getArch() == Triple::thumbeb;
   }
 
   /// Tests whether the target is ARM (little and big endian).
   bool isARM() const {
     return getArch() == Triple::arm || getArch() == Triple::armeb;
   }
 
   /// Tests whether the target is AArch64 (little and big endian).
   bool isAArch64() const {
-    return getArch() == Triple::aarch64 || getArch() == Triple::aarch64_be;
+    return getArch() == Triple::aarch64 || getArch() == Triple::aarch64_be ||
+           getArch() == Triple::aarch64_32;
+  }
+
+  /// Tests whether the target is AArch64 and pointers are the size specified by
+  /// \p PointerWidth.
+  bool isAArch64(int PointerWidth) const {
+    assert(PointerWidth == 64 || PointerWidth == 32);
+    if (!isAArch64())
+      return false;
+    return isArch64Bit() ? PointerWidth == 64 : PointerWidth == 32;
   }
 
   /// Tests whether the target is MIPS 32-bit (little and big endian).
   bool isMIPS32() const {
     return getArch() == Triple::mips || getArch() == Triple::mipsel;
   }
 
   /// Tests whether the target is MIPS 64-bit (little and big endian).

llvm/lib/BinaryFormat/MachO.cpp

static MachO::CPUSubTypeARM getARMSubType(const Triple &T) {
   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() || T.getArch() == Triple::aarch64_32);
+  assert(T.isAArch64());
   if (T.isArch32Bit())
     return (MachO::CPUSubTypeARM64)MachO::CPU_SUBTYPE_ARM64_32_V8;
   if (T.getArchName() == "arm64e")
     return MachO::CPU_SUBTYPE_ARM64E;
 
   return MachO::CPU_SUBTYPE_ARM64_ALL;
 }
 
if (!T.isOSBinFormatMachO())
     return unsupported("type", T);
   if (T.isX86() && T.isArch32Bit())
     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 MachO::CPU_TYPE_ARM64;
-  if (T.getArch() == Triple::aarch64_32)
-    return MachO::CPU_TYPE_ARM64_32;
+    return T.isArch32Bit() ? 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) {