rebase

Created using spr 1.3.5

Author: lanza

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/LowerCall.cpp

@@ -47,8 +47,13 @@ arrangeFreeFunctionLikeCall(LowerTypes &LT, LowerModule &LM,
 
   cir_cconv_assert(!::cir::MissingFeatures::chainCall() && !chainCall && "NYI");
   FnInfoOpts opts = chainCall ? FnInfoOpts::IsChainCall : FnInfoOpts::None;
-  return LT.arrangeLLVMFunctionInfo(fnType.getReturnType(), opts,
-                                    fnType.getInputs(), required);
+
+  SmallVector<Type> argTypes;
+  for (const auto &a : args)
+    argTypes.push_back(a.getType());
+
+  return LT.arrangeLLVMFunctionInfo(fnType.getReturnType(), opts, argTypes,
+                                    required);
 }
 
 /// Adds the formal parameters in FPT to the given prefix. If any parameter in

clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerFunctionInfo.h

@@ -49,12 +49,15 @@ class RequiredArgs {
     if (!prototype.isVarArg())
       return All;
 
-    cir_cconv_assert_or_abort(!::cir::MissingFeatures::variadicFunctions(),
-                              "NYI");
-    return All; // FIXME(cir): Temporary workaround for the assertion above.
+    return RequiredArgs(prototype.getNumInputs() + additional);
   }
 
   bool allowsOptionalArgs() const { return NumRequired != ~0U; }
+
+  unsigned getNumRequiredArgs() const {
+    assert(allowsOptionalArgs());
+    return NumRequired;
+  }
 };
 
 // Implementation detail of LowerFunctionInfo, factored out so it can be
@@ -149,14 +152,9 @@ class LowerFunctionInfo final
 
   unsigned arg_size() const { return NumArgs; }
 
-  bool isVariadic() const {
-    cir_cconv_assert(!::cir::MissingFeatures::variadicFunctions());
-    return false;
-  }
+  bool isVariadic() const { return Required.allowsOptionalArgs(); }
   unsigned getNumRequiredArgs() const {
-    if (isVariadic())
-      cir_cconv_unreachable("NYI");
-    return arg_size();
+    return isVariadic() ? Required.getNumRequiredArgs() : arg_size();
   }
 
   Type getReturnType() const { return getArgsBuffer()[0].type; }

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;
+}

clang/test/CIR/CallConvLowering/x86_64/varargs.c

@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -fclangir-call-conv-lowering -emit-cir-flat -mmlir --mlir-print-ir-after=cir-call-conv-lowering %s -o %t.cir
+
+int printf(const char *str, ...);
+
+// CHECK: cir.func {{.*@bar}}
+// CHECK:   %[[#V1:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
+// CHECK:   %[[#V2:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
+// CHECK:   cir.store %arg0, %[[#V0]] : !s32i, !cir.ptr<!s32i>
+// CHECK:   cir.store %arg1, %[[#V1]] : !s32i, !cir.ptr<!s32i>
+// CHECK:   %[[#V2:]] = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 7>>
+// CHECK:   %[[#V3:]] = cir.cast(array_to_ptrdecay, %[[#V2]] : !cir.ptr<!cir.array<!s8i x 7>>), !cir.ptr<!s8i>
+// CHECK:   %[[#V4:]] = cir.load %[[#V1]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[#V5:]] = cir.load %[[#V2]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[#V6:]] = cir.call @printf(%[[#V3]], %[[#V4]], %[[#V5]]) : (!cir.ptr<!s8i>, !s32i, !s32i) -> !s32i
+void bar(int a, int b) {
+  printf("%d %d\n", a, b);
+}