[CIR][ABI][AArch64][Lowering] Initial support for return of struct types (#1004)

This PR adds a support for return values of a struct type. There are two
cases that are not covered by this PR and will be added later.

Author: gitoleg

clang/include/clang/CIR/MissingFeatures.h

@@ -230,6 +230,7 @@ struct MissingFeatures {
   static bool shouldInstrumentFunction() { return false; }
   static bool xray() { return false; }
   static bool buildConstrainedFPCall() { return false; }
+  static bool emitEmptyRecordCheck() { return false; }
 
   // Inline assembly
   static bool asmGoto() { return false; }

clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/AArch64.cpp

@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-
 #include "clang/CIR/Target/AArch64.h"
 #include "ABIInfoImpl.h"
 #include "LowerFunctionInfo.h"
@@ -105,6 +104,39 @@ ABIArgInfo AArch64ABIInfo::classifyReturnType(Type RetTy,
                 : ABIArgInfo::getDirect());
   }
 
+  uint64_t Size = getContext().getTypeSize(RetTy);
+  cir_cconv_assert(!::cir::MissingFeatures::emitEmptyRecordCheck());
+  cir_cconv_assert(
+      !::cir::MissingFeatures::supportisHomogeneousAggregateQueryForAArch64());
+
+  // Aggregates <= 16 bytes are returned directly in registers or on the stack.
+  if (Size <= 128) {
+    if (Size <= 64 && !getDataLayout().isBigEndian()) {
+      // Composite types are returned in lower bits of a 64-bit register for LE,
+      // and in higher bits for BE. However, integer types are always returned
+      // in lower bits for both LE and BE, and they are not rounded up to
+      // 64-bits. We can skip rounding up of composite types for LE, but not for
+      // BE, otherwise composite types will be indistinguishable from integer
+      // types.
+      return ABIArgInfo::getDirect(
+          mlir::cir::IntType::get(LT.getMLIRContext(), Size, false));
+    }
+
+    unsigned Alignment = getContext().getTypeAlign(RetTy);
+    Size = llvm::alignTo(Size, 64); // round up to multiple of 8 bytes
+
+    // We use a pair of i64 for 16-byte aggregate with 8-byte alignment.
+    // For aggregates with 16-byte alignment, we use i128.
+    if (Alignment < 128 && Size == 128) {
+      mlir::Type baseTy =
+          mlir::cir::IntType::get(LT.getMLIRContext(), 64, false);
+      return ABIArgInfo::getDirect(
+          mlir::cir::ArrayType::get(LT.getMLIRContext(), baseTy, Size / 64));
+    }
+
+    cir_cconv_unreachable("NYI");
+  }
+
   cir_cconv_unreachable("NYI");
 }
 

clang/test/CIR/CallConvLowering/AArch64/aarch64-cc-structs.c

@@ -0,0 +1,62 @@
+// RUN: %clang_cc1 -triple aarch64-unknown-linux-gnu -fclangir -fclangir-call-conv-lowering -emit-cir-flat -mmlir --mlir-print-ir-after=cir-call-conv-lowering %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s
+
+#include <stdint.h>
+
+typedef struct {
+  short a;  
+} LT_64;
+
+typedef struct {
+  int64_t a;
+} EQ_64;
+
+typedef struct {
+  int64_t a;
+  int b;
+} LT_128;
+
+typedef struct {
+  int64_t a;
+  int64_t b;
+} EQ_128;
+
+// CHECK: cir.func {{.*@ret_lt_64}}() -> !u16i
+// CHECK:   %[[#V0:]] = cir.alloca !ty_LT_64_, !cir.ptr<!ty_LT_64_>, ["__retval"]
+// CHECK:   %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!ty_LT_64_>), !cir.ptr<!u16i>
+// CHECK:   %[[#V2:]] = cir.load %[[#V1]] : !cir.ptr<!u16i>, !u16i
+// CHECK:   cir.return %[[#V2]] : !u16i
+LT_64 ret_lt_64() {
+  LT_64 x;
+  return x;
+}
+
+// CHECK: cir.func {{.*@ret_eq_64}}() -> !u64i
+// CHECK:   %[[#V0:]] = cir.alloca !ty_EQ_64_, !cir.ptr<!ty_EQ_64_>, ["__retval"]
+// CHECK:   %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!ty_EQ_64_>), !cir.ptr<!u64i>
+// CHECK:   %[[#V2:]] = cir.load %[[#V1]] : !cir.ptr<!u64i>, !u64i
+// CHECK:   cir.return %[[#V2]] : !u64i
+EQ_64 ret_eq_64() {
+  EQ_64 x;
+  return x;
+}
+
+// CHECK: cir.func {{.*@ret_lt_128}}() -> !cir.array<!u64i x 2>
+// CHECK:   %[[#V0:]] = cir.alloca !ty_LT_128_, !cir.ptr<!ty_LT_128_>, ["__retval"]
+// CHECK:   %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!ty_LT_128_>), !cir.ptr<!cir.array<!u64i x 2>>
+// CHECK:   %[[#V2:]] = cir.load %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>, !cir.array<!u64i x 2>
+// CHECK:   cir.return %[[#V2]] : !cir.array<!u64i x 2>
+LT_128 ret_lt_128() {
+  LT_128 x;
+  return x;
+}
+
+// CHECK: cir.func {{.*@ret_eq_128}}() -> !cir.array<!u64i x 2>
+// CHECK:   %[[#V0:]] = cir.alloca !ty_EQ_128_, !cir.ptr<!ty_EQ_128_>, ["__retval"]
+// CHECK:   %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!ty_EQ_128_>), !cir.ptr<!cir.array<!u64i x 2>>
+// CHECK:   %[[#V2:]] = cir.load %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>, !cir.array<!u64i x 2>
+// CHECK:   cir.return %[[#V2]] : !cir.array<!u64i x 2>
+EQ_128 ret_eq_128() {
+  EQ_128 x;
+  return x;
+}