[ARM] Add poly64_t on AArch32.

[stuij]

Summary

The poly64 types are guarded with ifdefs for AArch64 only. This is wrong. This
was also incorrectly documented in the ACLE spec, but this has been rectified in
the latest release. See paragraph 13.1.2 "Vector data types":

https://developer.arm.com/docs/101028/latest

This patch was written by Alexandros Lamprineas.

[stuij]

adhere to attribution conventions

[stuij]

added testing

[ostannard]

Should poly128_t be available on AArch32 too? I don't see anything in the ACLE version you linked restricting it to AArch64 only, and the intrinsics reference has a number of intrinsics available for both ISAs using it.

clang/include/clang/Basic/TargetBuiltins.h

160

Should Poly128 be in this list too?

clang/lib/Sema/SemaType.cpp

7659

The version of the ACLE you linked says all polynomial types are unsigned, not mentioning any difference between AArch32 and AArch64:

poly8_t, poly16_t, poly64_t and poly128_t are defined as unsigned integer types. It is unspecified whether these are the same type as uint8_t, uint16_t, uint64_t and uint128_t for overloading and mangling purposes.

Maybe this is something left over from an old version of the ACLE which needs updating now?

[labrinea]

Should poly128_t be available on AArch32 too? I don't see anything in the ACLE version you linked restricting it to AArch64 only, and the intrinsics reference has a number of intrinsics available for both ISAs using it.

It should but it is not that simple. The reason it is not available is that __int128_t is not supported in AArch32. I think that is future work, since this patch unblocks the bfloat reinterpret_cast patch, which btw is annotated with TODO comments regarding the poly128_t type for AArch32.

clang/lib/Sema/SemaType.cpp

7646

@ostannard according to this comment it seems there has been some divergence between AArch64 and AArch32 and now is too late to change. If the ACLE doesn't say so, maybe it should.

[ostannard]

Ok, LGTM.

clang/include/clang/Basic/TargetBuiltins.h

NeonTypeFlags(EltType ET, bool IsUnsigned, bool IsQuad) : Flags(ET) {
         Flags |= UnsignedFlag;
       if (IsQuad)
         Flags |= QuadFlag;
     }
 
     EltType getEltType() const { return (EltType)(Flags & EltTypeMask); }
     bool isPoly() const {
       EltType ET = getEltType();
-      return ET == Poly8 || ET == Poly16;
+      return ET == Poly8 || ET == Poly16 || ET == Poly64;
     }
     bool isUnsigned() const { return (Flags & UnsignedFlag) != 0; }
     bool isQuad() const { return (Flags & QuadFlag) != 0; }
   };
 
   /// Flags to identify the types for overloaded SVE builtins.
   class SVETypeFlags {
     uint64_t Flags;

clang/lib/AST/ItaniumMangle.cpp

if (T->getVectorKind() == VectorType::NeonPolyVector) {
     case BuiltinType::SChar:
     case BuiltinType::UChar:
       EltName = "poly8_t";
       break;
     case BuiltinType::Short:
     case BuiltinType::UShort:
       EltName = "poly16_t";
       break;
+    case BuiltinType::LongLong:
     case BuiltinType::ULongLong:
       EltName = "poly64_t";
       break;
     default: llvm_unreachable("unexpected Neon polynomial vector element type");
     }
   } else {
     switch (cast<BuiltinType>(EltType)->getKind()) {
     case BuiltinType::SChar:     EltName = "int8_t"; break;

clang/lib/Sema/SemaType.cpp

 static bool isPermittedNeonBaseType(QualType &Ty,
                                     VectorType::VectorKind VecKind, Sema &S) {
   const BuiltinType *BTy = Ty->getAs<BuiltinType>();
   if (!BTy)
     return false;
 
   llvm::Triple Triple = S.Context.getTargetInfo().getTriple();
 
   // Signed poly is mathematically wrong, but has been baked into some ABIs by
   // now.
   bool IsPolyUnsigned = Triple.getArch() == llvm::Triple::aarch64 ||
                         Triple.getArch() == llvm::Triple::aarch64_32 ||
                         Triple.getArch() == llvm::Triple::aarch64_be;
   if (VecKind == VectorType::NeonPolyVector) {
     if (IsPolyUnsigned) {
-      // AArch64 polynomial vectors are unsigned and support poly64.
+      // AArch64 polynomial vectors are unsigned.
       return BTy->getKind() == BuiltinType::UChar ||
              BTy->getKind() == BuiltinType::UShort ||
              BTy->getKind() == BuiltinType::ULong ||
              BTy->getKind() == BuiltinType::ULongLong;
     } else {
-      // AArch32 polynomial vector are signed.
+      // AArch32 polynomial vectors are signed.
       return BTy->getKind() == BuiltinType::SChar ||
-             BTy->getKind() == BuiltinType::Short;
+             BTy->getKind() == BuiltinType::Short ||
+             BTy->getKind() == BuiltinType::LongLong;
     }
   }
 
   // Non-polynomial vector types: the usual suspects are allowed, as well as
   // float64_t on AArch64.
   if ((Triple.isArch64Bit() || Triple.getArch() == llvm::Triple::aarch64_32) &&
       BTy->getKind() == BuiltinType::Double)
     return true;

clang/test/CodeGen/arm-poly64.c

+// RUN: %clang_cc1 -triple armv8.2a-arm-none-eabi -target-feature +neon \
+// RUN:  -emit-llvm -o - %s | FileCheck %s
+
+// Test that we can use the poly64 type on AArch32
+
+#include <arm_neon.h>
+
+// CHECK-LABEL: @test_poly64
+// CHECK: ret i64 %0
+poly64_t test_poly64(poly64_t a) {
+  return a;
+}

clang/utils/TableGen/NeonEmitter.cpp

void NeonEmitter::run(raw_ostream &OS) {
   OS << "#ifdef __aarch64__\n";
   OS << "typedef uint8_t poly8_t;\n";
   OS << "typedef uint16_t poly16_t;\n";
   OS << "typedef uint64_t poly64_t;\n";
   OS << "typedef __uint128_t poly128_t;\n";
   OS << "#else\n";
   OS << "typedef int8_t poly8_t;\n";
   OS << "typedef int16_t poly16_t;\n";
+  OS << "typedef int64_t poly64_t;\n";
   OS << "#endif\n";
 
   // Emit Neon vector typedefs.
   std::string TypedefTypes(
       "cQcsQsiQilQlUcQUcUsQUsUiQUiUlQUlhQhfQfdQdPcQPcPsQPsPlQPl");
   std::vector<TypeSpec> TDTypeVec = TypeSpec::fromTypeSpecs(TypedefTypes);
 
   // Emit vector typedefs.
   bool InIfdef = false;
   for (auto &TS : TDTypeVec) {
     bool IsA64 = false;
     Type T(TS, ".");
-    if (T.isDouble() || (T.isPoly() && T.getElementSizeInBits() == 64))
+    if (T.isDouble())
       IsA64 = true;
 
     if (InIfdef && !IsA64) {
       OS << "#endif\n";
       InIfdef = false;
     }
     if (!InIfdef && IsA64) {
       OS << "#ifdef __aarch64__\n";
void NeonEmitter::run(raw_ostream &OS) {
   OS << "\n";
 
   // Emit struct typedefs.
   InIfdef = false;
   for (unsigned NumMembers = 2; NumMembers <= 4; ++NumMembers) {
     for (auto &TS : TDTypeVec) {
       bool IsA64 = false;
       Type T(TS, ".");
-      if (T.isDouble() || (T.isPoly() && T.getElementSizeInBits() == 64))
+      if (T.isDouble())
         IsA64 = true;
 
       if (InIfdef && !IsA64) {
         OS << "#endif\n";
         InIfdef = false;
       }
       if (!InIfdef && IsA64) {
         OS << "#ifdef __aarch64__\n";