[AArch64][SVE] CodeGen of ACLE Builtin Types

[sdesmalen]

Summary

This patch adds codegen support for the ACLE builtin types added in:

https://reviews.llvm.org/D62960

so that the ACLE builtin types are emitted as corresponding scalable
vector types in LLVM.

[efriedma]

clang/lib/CodeGen/CodeGenTypes.cpp

559

Is there a reason to make getSVEType a separate function, as opposed to just writing out the cases inline?

Also, we can probably get rid of the "cannot yet generate code for SVE type" error?

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

230

Please submit this separately.

[sdesmalen]

• Inlined function into switch statement
• Removed changes to IRTranslator.cpp from this patch.

[efriedma]

LGTM

clang/lib/CodeGen/CGDecl.cpp

if (NRVO) {
         // declaration. We also have to do it in C if there's a jump to an
         // earlier point in the current block because non-VLA lifetimes begin as
         // soon as the containing block is entered, not when its variables
         // actually come into scope; suppressing the lifetime annotations
         // completely in this case is unnecessarily pessimistic, but again, this
         // is rare.
         if (!Bypasses.IsBypassed(&D) &&
             !(!getLangOpts().CPlusPlus && hasLabelBeenSeenInCurrentScope())) {
-          uint64_t size = CGM.getDataLayout().getTypeAllocSize(allocaTy);
+          llvm::TypeSize size =
+              CGM.getDataLayout().getTypeAllocSize(allocaTy);
           emission.SizeForLifetimeMarkers =
-              EmitLifetimeStart(size, AllocaAddr.getPointer());
+              size.isScalable() ? EmitLifetimeStart(-1, AllocaAddr.getPointer())
+                                : EmitLifetimeStart(size.getFixedSize(),
+                                                    AllocaAddr.getPointer());
         }
       } else {
         assert(!emission.useLifetimeMarkers());
       }
     }
   } else {
     EnsureInsertPoint();
 

clang/lib/CodeGen/CodeGenTypes.cpp

if (SkippedLayout)
     TypeCache.clear();
 
   if (RecordsBeingLaidOut.empty())
     while (!DeferredRecords.empty())
       ConvertRecordDeclType(DeferredRecords.pop_back_val());
   return ResultType;
 }
 
+static llvm::Type *getSVEType(ASTContext &Ctx, llvm::LLVMContext &LLVMCtx,
+                              BuiltinType::Kind K) {
+  switch (K) {
+  case BuiltinType::SveInt8:
+  case BuiltinType::SveUint8:
+    return llvm::VectorType::get(llvm::IntegerType::get(LLVMCtx, 8),
+                                 {16, true});
+  case BuiltinType::SveInt16:
+  case BuiltinType::SveUint16:
+    return llvm::VectorType::get(llvm::IntegerType::get(LLVMCtx, 16),
+                                 {8, true});
+  case BuiltinType::SveInt32:
+  case BuiltinType::SveUint32:
+    return llvm::VectorType::get(llvm::IntegerType::get(LLVMCtx, 32),
+                                 {4, true});
+  case BuiltinType::SveInt64:
+  case BuiltinType::SveUint64:
+    return llvm::VectorType::get(llvm::IntegerType::get(LLVMCtx, 64),
+                                 {2, true});
+  case BuiltinType::SveFloat16:
+    return llvm::VectorType::get(
+        getTypeForFormat(LLVMCtx, Ctx.getFloatTypeSemantics(Ctx.HalfTy),
+                         /* UseNativeHalf = */ true),
+        {8, true});
+  case BuiltinType::SveFloat32:
+    return llvm::VectorType::get(
+        getTypeForFormat(LLVMCtx, Ctx.getFloatTypeSemantics(Ctx.FloatTy),
+                         /* UseNativeHalf = */ false),
+        {4, true});
+  case BuiltinType::SveFloat64:
+    return llvm::VectorType::get(
+        getTypeForFormat(LLVMCtx, Ctx.getFloatTypeSemantics(Ctx.DoubleTy),
+                         /* UseNativeHalf = */ false),
+        {2, true});
+  case BuiltinType::SveBool:
+    return llvm::VectorType::get(llvm::IntegerType::get(LLVMCtx, 1),
+                                 {16, true});
+  default:
+    break;
+  }
+  return nullptr;
+}
 /// ConvertType - Convert the specified type to its LLVM form.
 llvm::Type *CodeGenTypes::ConvertType(QualType T) {
   T = Context.getCanonicalType(T);
 
   const Type *Ty = T.getTypePtr();
 
   // RecordTypes are cached and processed specially.
   if (const RecordType *RT = dyn_cast<RecordType>(Ty))

 #include "clang/Basic/OpenCLExtensionTypes.def"
     case BuiltinType::OCLSampler:
     case BuiltinType::OCLEvent:
     case BuiltinType::OCLClkEvent:
     case BuiltinType::OCLQueue:
     case BuiltinType::OCLReserveID:
       ResultType = CGM.getOpenCLRuntime().convertOpenCLSpecificType(Ty);
       break;
-
-    // TODO: real CodeGen support for SVE types requires more infrastructure
-    // to be added first.  Report an error until then.
-#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+#define SVE_TYPE(Name, Id, SingletonId) \
+    case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
-    {
+      ResultType = getSVEType(getContext(), getLLVMContext(),
+                              cast<BuiltinType>(Ty)->getKind());
+      if (!ResultType) {
         unsigned DiagID = CGM.getDiags().getCustomDiagID(
             DiagnosticsEngine::Error,
             "cannot yet generate code for SVE type '%0'");
         auto *BT = cast<BuiltinType>(Ty);
         auto Name = BT->getName(CGM.getContext().getPrintingPolicy());
         CGM.getDiags().Report(DiagID) << Name;
         // Return something safe.
         ResultType = llvm::IntegerType::get(getLLVMContext(), 32);
-      break;
     }
-
+    break;
     case BuiltinType::Dependent:
 #define BUILTIN_TYPE(Id, SingletonId)
 #define PLACEHOLDER_TYPE(Id, SingletonId) \
     case BuiltinType::Id:
 #include "clang/AST/BuiltinTypes.def"
       llvm_unreachable("Unexpected placeholder builtin type!");
     }
     break;

clang/test/CodeGen/aarch64-sve.c

 // RUN: not %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve \
-// RUN:  -emit-llvm -o - %s -debug-info-kind=limited 2>&1 | FileCheck %s
+// RUN:  -emit-llvm -o - %s -debug-info-kind=limited 2>&1 | FileCheck %s -check-prefix=CHECK-DEBUG
+// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve \
+// RUN:  -emit-llvm -o - %s 2>&1 | FileCheck %s -check-prefix=CHECK
 
-// Placeholder test for SVE types
+// CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVInt8_t'
+// CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVInt16_t'
+// CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVInt32_t'
+// CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVInt64_t'
+// CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVUint8_t'
+// CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVUint16_t'
+// CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVUint32_t'
+// CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVUint64_t'
+// CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVFloat16_t'
+// CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVFloat32_t'
+// CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVFloat64_t'
+// CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVBool_t'
 
-// CHECK: cannot yet generate code for SVE type '__SVInt8_t'
-// CHECK: cannot yet generate debug info for SVE type '__SVInt8_t'
+// CHECK: @ptr = common global <vscale x 16 x i8>* null, align 8
+// CHECK: %s8 = alloca <vscale x 16 x i8>, align 16
+// CHECK: %s16 = alloca <vscale x 8 x i16>, align 16
+// CHECK: %s32 = alloca <vscale x 4 x i32>, align 16
+// CHECK: %s64 = alloca <vscale x 2 x i64>, align 16
+// CHECK: %u8 = alloca <vscale x 16 x i8>, align 16
+// CHECK: %u16 = alloca <vscale x 8 x i16>, align 16
+// CHECK: %u32 = alloca <vscale x 4 x i32>, align 16
+// CHECK: %u64 = alloca <vscale x 2 x i64>, align 16
+// CHECK: %f16 = alloca <vscale x 8 x half>, align 16
+// CHECK: %f32 = alloca <vscale x 4 x float>, align 16
+// CHECK: %f64 = alloca <vscale x 2 x double>, align 16
+// CHECK: %b8 = alloca <vscale x 16 x i1>, align 2
 
 __SVInt8_t *ptr;
+
+void test_locals(void) {
+  __SVInt8_t s8;
+  __SVInt16_t s16;
+  __SVInt32_t s32;
+  __SVInt64_t s64;
+
+  __SVUint8_t u8;
+  __SVUint16_t u16;
+  __SVUint32_t u32;
+  __SVUint64_t u64;
+
+  __SVFloat16_t f16;
+  __SVFloat32_t f32;
+  __SVFloat64_t f64;
+
+  __SVBool_t b8;
+}

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

ArrayRef<Register> IRTranslator::getOrCreateVRegs(const Value &Val) {
 
   return *VRegs;
 }
 
 int IRTranslator::getOrCreateFrameIndex(const AllocaInst &AI) {
   if (FrameIndices.find(&AI) != FrameIndices.end())
     return FrameIndices[&AI];
 
-  uint64_t ElementSize = DL->getTypeAllocSize(AI.getAllocatedType());
+  uint64_t ElementSize =
+      DL->getTypeAllocSize(AI.getAllocatedType()).getKnownMinSize();
   uint64_t Size =
       ElementSize * cast<ConstantInt>(AI.getArraySize())->getZExtValue();
 
   // Always allocate at least one byte.
   Size = std::max<uint64_t>(Size, 1u);
 
   unsigned Alignment = AI.getAlignment();
   if (!Alignment)