Fixups

Author: MacDue

clang/lib/CodeGen/Targets/AArch64.cpp

@@ -1146,38 +1146,37 @@ void AArch64TargetCodeGenInfo::checkFunctionABI(
   }
 }
 
-enum class ArmStreamingInlinability : uint8_t {
+enum ArmSMEInlinability : uint8_t {
   Ok = 0,
-  IncompatibleStreamingModes = 1,
   MismatchedStreamingCompatibility = 1 << 1,
-  CalleeHasNewZA = 1 << 2,
-  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/CalleeHasNewZA),
+  IncompatibleStreamingModes = 1,
+  CalleeRequiresNewZA = 1 << 2,
+  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/CalleeRequiresNewZA),
 };
 
-/// Determines if there are any streaming ABI issues with inlining \p Callee
-/// into \p Caller. Returns the issues in the ArmStreamingInlinability bit enum
-/// (multiple bits can be set).
-static ArmStreamingInlinability
-GetArmStreamingInlinability(const FunctionDecl *Caller,
-                            const FunctionDecl *Callee) {
+/// Determines if there are any Arm SME ABI issues with inlining \p Callee into
+/// \p Caller. Returns the issues in the ArmSMEInlinability bit enum (multiple
+/// bits can be set).
+static ArmSMEInlinability GetArmSMEInlinability(const FunctionDecl *Caller,
+                                                const FunctionDecl *Callee) {
   bool CallerIsStreaming =
       IsArmStreamingFunction(Caller, /*IncludeLocallyStreaming=*/true);
   bool CalleeIsStreaming =
       IsArmStreamingFunction(Callee, /*IncludeLocallyStreaming=*/true);
   bool CallerIsStreamingCompatible = isStreamingCompatible(Caller);
   bool CalleeIsStreamingCompatible = isStreamingCompatible(Callee);
 
-  ArmStreamingInlinability Inlinability = ArmStreamingInlinability::Ok;
+  ArmSMEInlinability Inlinability = ArmSMEInlinability::Ok;
 
   if (!CalleeIsStreamingCompatible &&
       (CallerIsStreaming != CalleeIsStreaming || CallerIsStreamingCompatible)) {
-    Inlinability |= ArmStreamingInlinability::MismatchedStreamingCompatibility;
+    Inlinability |= ArmSMEInlinability::MismatchedStreamingCompatibility;
     if (CalleeIsStreaming)
-      Inlinability |= ArmStreamingInlinability::IncompatibleStreamingModes;
+      Inlinability |= ArmSMEInlinability::IncompatibleStreamingModes;
   }
   if (auto *NewAttr = Callee->getAttr<ArmNewAttr>())
     if (NewAttr->isNewZA())
-      Inlinability |= ArmStreamingInlinability::CalleeHasNewZA;
+      Inlinability |= ArmSMEInlinability::CalleeRequiresNewZA;
 
   return Inlinability;
 }
@@ -1188,18 +1187,18 @@ void AArch64TargetCodeGenInfo::checkFunctionCallABIStreaming(
   if (!Caller || !Callee || !Callee->hasAttr<AlwaysInlineAttr>())
     return;
 
-  ArmStreamingInlinability Inlinability =
-      GetArmStreamingInlinability(Caller, Callee);
+  ArmSMEInlinability Inlinability = GetArmSMEInlinability(Caller, Callee);
 
-  if (bool(Inlinability &
-           ArmStreamingInlinability::MismatchedStreamingCompatibility))
+  if ((Inlinability & ArmSMEInlinability::MismatchedStreamingCompatibility) !=
+      0)
     CGM.getDiags().Report(
-        CallLoc, bool(Inlinability &
-                      ArmStreamingInlinability::IncompatibleStreamingModes)
-                     ? diag::err_function_always_inline_attribute_mismatch
-                     : diag::warn_function_always_inline_attribute_mismatch)
+        CallLoc,
+        (Inlinability & ArmSMEInlinability::IncompatibleStreamingModes) != 0
+            ? diag::err_function_always_inline_attribute_mismatch
+            : diag::warn_function_always_inline_attribute_mismatch)
         << Caller->getDeclName() << Callee->getDeclName() << "streaming";
-  if (bool(Inlinability & ArmStreamingInlinability::CalleeHasNewZA))
+
+  if ((Inlinability & ArmSMEInlinability::CalleeRequiresNewZA) != 0)
     CGM.getDiags().Report(CallLoc, diag::err_function_always_inline_new_za)
         << Callee->getDeclName();
 }
@@ -1238,8 +1237,7 @@ void AArch64TargetCodeGenInfo::checkFunctionCallABI(CodeGenModule &CGM,
 bool AArch64TargetCodeGenInfo::wouldInliningViolateFunctionCallABI(
     const FunctionDecl *Caller, const FunctionDecl *Callee) const {
   return Caller && Callee &&
-         GetArmStreamingInlinability(Caller, Callee) !=
-             ArmStreamingInlinability::Ok;
+         GetArmSMEInlinability(Caller, Callee) != ArmSMEInlinability::Ok;
 }
 
 void AArch64ABIInfo::appendAttributeMangling(TargetClonesAttr *Attr,

clang/test/CodeGen/AArch64/sme-flatten-streaming-attrs.c renamed to clang/test/CodeGen/AArch64/sme-inline-callees-streaming-attrs.c

@@ -1,23 +1,33 @@
-// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -emit-llvm -target-feature +sme %s -o - | FileCheck %s
+// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -emit-llvm -target-feature +sme %s -DUSE_FLATTEN -o - | FileCheck %s
+// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -emit-llvm -target-feature +sme %s -DUSE_ALWAYS_INLINE_STMT -o - | FileCheck %s
 
 // REQUIRES: aarch64-registered-target
 
 extern void was_inlined(void);
 
-#define __flatten  __attribute__((flatten))
+#if defined(USE_FLATTEN)
+    #define FN_ATTR __attribute__((flatten))
+    #define STMT_ATTR
+#elif defined(USE_ALWAYS_INLINE_STMT)
+    #define FN_ATTR
+    #define STMT_ATTR [[clang::always_inline]]
+#else
+    #error Expected USE_FLATTEN or USE_ALWAYS_INLINE_STMT to be defined.
+#endif
+
 void fn(void) { was_inlined(); }
 void fn_streaming_compatible(void) __arm_streaming_compatible { was_inlined(); }
 void fn_streaming(void) __arm_streaming { was_inlined(); }
 __arm_locally_streaming void fn_locally_streaming(void) { was_inlined(); }
 __arm_new("za") void fn_streaming_new_za(void) __arm_streaming { was_inlined(); }
 
-__flatten
+FN_ATTR
 void caller(void) {
-    fn();
-    fn_streaming_compatible();
-    fn_streaming();
-    fn_locally_streaming();
-    fn_streaming_new_za();
+    STMT_ATTR fn();
+    STMT_ATTR fn_streaming_compatible();
+    STMT_ATTR fn_streaming();
+    STMT_ATTR fn_locally_streaming();
+    STMT_ATTR fn_streaming_new_za();
 }
 // CHECK-LABEL: void @caller()
 //  CHECK-NEXT: entry:
@@ -27,12 +37,12 @@ void caller(void) {
 //  CHECK-NEXT:   call void @fn_locally_streaming
 //  CHECK-NEXT:   call void @fn_streaming_new_za
 
-__flatten void caller_streaming_compatible(void) __arm_streaming_compatible {
-    fn();
-    fn_streaming_compatible();
-    fn_streaming();
-    fn_locally_streaming();
-    fn_streaming_new_za();
+FN_ATTR void caller_streaming_compatible(void) __arm_streaming_compatible {
+    STMT_ATTR fn();
+    STMT_ATTR fn_streaming_compatible();
+    STMT_ATTR fn_streaming();
+    STMT_ATTR fn_locally_streaming();
+    STMT_ATTR fn_streaming_new_za();
 }
 // CHECK-LABEL: void @caller_streaming_compatible()
 //  CHECK-NEXT: entry:
@@ -42,12 +52,12 @@ __flatten void caller_streaming_compatible(void) __arm_streaming_compatible {
 //  CHECK-NEXT:   call void @fn_locally_streaming
 //  CHECK-NEXT:   call void @fn_streaming_new_za
 
-__flatten void caller_streaming(void) __arm_streaming {
-    fn();
-    fn_streaming_compatible();
-    fn_streaming();
-    fn_locally_streaming();
-    fn_streaming_new_za();
+FN_ATTR void caller_streaming(void) __arm_streaming {
+    STMT_ATTR fn();
+    STMT_ATTR fn_streaming_compatible();
+    STMT_ATTR fn_streaming();
+    STMT_ATTR fn_locally_streaming();
+    STMT_ATTR fn_streaming_new_za();
 }
 // CHECK-LABEL: void @caller_streaming()
 //  CHECK-NEXT: entry:
@@ -57,13 +67,13 @@ __flatten void caller_streaming(void) __arm_streaming {
 //  CHECK-NEXT:   call void @was_inlined
 //  CHECK-NEXT:   call void @fn_streaming_new_za
 
-__flatten __arm_locally_streaming
+FN_ATTR __arm_locally_streaming
 void caller_locally_streaming(void) {
-    fn();
-    fn_streaming_compatible();
-    fn_streaming();
-    fn_locally_streaming();
-    fn_streaming_new_za();
+    STMT_ATTR fn();
+    STMT_ATTR fn_streaming_compatible();
+    STMT_ATTR fn_streaming();
+    STMT_ATTR fn_locally_streaming();
+    STMT_ATTR fn_streaming_new_za();
 }
 // CHECK-LABEL: void @caller_locally_streaming()
 //  CHECK-NEXT: entry: