[darwin] Disable the -Wpsabi warning

[arphaman]

Summary

The Darwin targets don't enable AVX/AVX512 by default to support Rosetta 2, so the new -Wpsabi warning adds unwanted noise to our SDK. Users who build for AVX/AVX512 for Darwin are already supposed to take extra care when it comes to the ABI differences and the SDK.

[arphaman]

add missing test fix

[ab]

Hmm, is there a more general way to disable warnings? I'm not familiar with these parts, so I'll defer to you folks =]

clang/lib/CodeGen/TargetInfo.cpp

2515–2516

I wouldn't explain it this way, maybe something like ^ ?

2564–2568

also very minor nitpick: if you pass around some WarnOnSSE bool or something, you'd have the darwin explanation with this psABI comment here, might be nicer

[arphaman]

Address Ahmed's comments.

[arphaman]

clang/lib/CodeGen/TargetInfo.cpp

2564–2568

This didn't really fit well here as there's also a second invocation of checkAVXParam for the return type, which would need a second check for whether the warning is enabled or not, so I moved your suggestion into checkAVXParam itself.

clang/lib/CodeGen/TargetInfo.cpp

static void initFeatureMaps(const ASTContext &Ctx,
   }
 }
 
 static bool checkAVXParamFeature(DiagnosticsEngine &Diag,
                                  SourceLocation CallLoc,
                                  const llvm::StringMap<bool> &CallerMap,
                                  const llvm::StringMap<bool> &CalleeMap,
                                  QualType Ty, StringRef Feature,
-                                 bool IsArgument) {
+                                 bool IsArgument, bool EnableWarning) {
   bool CallerHasFeat = CallerMap.lookup(Feature);
   bool CalleeHasFeat = CalleeMap.lookup(Feature);
-  if (!CallerHasFeat && !CalleeHasFeat)
+  if (!CallerHasFeat && !CalleeHasFeat) {
+    if (!EnableWarning)
+      return false;
     return Diag.Report(CallLoc, diag::warn_avx_calling_convention)
            << IsArgument << Ty << Feature;
+  }
 
   // Mixing calling conventions here is very clearly an error.
   if (!CallerHasFeat || !CalleeHasFeat)
     return Diag.Report(CallLoc, diag::err_avx_calling_convention)
            << IsArgument << Ty << Feature;
 
   // Else, both caller and callee have the required feature, so there is no need
   // to diagnose.
   return false;
 }
 
 static bool checkAVXParam(DiagnosticsEngine &Diag, ASTContext &Ctx,
                           SourceLocation CallLoc,
                           const llvm::StringMap<bool> &CallerMap,
                           const llvm::StringMap<bool> &CalleeMap, QualType Ty,
                           bool IsArgument) {
+  // Note: Darwin x86_64 targets a baseline CPU which doesn't enable
+  // AVX/AVX512, so it allows passing wide vectors in SSE: don't warn.
+  // Darwin users who do enable AVX/AVX512 are responsible for ensuring safe
+  // usage of wide vector types.
+  // However, x86_64h does enable AVX by default in all functions.
+  bool EnableWarning = !Ctx.getTargetInfo().getTriple().isOSDarwin();
   uint64_t Size = Ctx.getTypeSize(Ty);
   if (Size > 256)
     return checkAVXParamFeature(Diag, CallLoc, CallerMap, CalleeMap, Ty,
-                                "avx512f", IsArgument);
+                                "avx512f", IsArgument, EnableWarning);
 
   if (Size > 128)
     return checkAVXParamFeature(Diag, CallLoc, CallerMap, CalleeMap, Ty, "avx",
-                                IsArgument);
+                                IsArgument, EnableWarning);
 
   return false;
 }
 
 void X86_64TargetCodeGenInfo::checkFunctionCallABI(
     CodeGenModule &CGM, SourceLocation CallLoc, const FunctionDecl *Caller,
     const FunctionDecl *Callee, const CallArgList &Args) const {
   llvm::StringMap<bool> CallerMap;
   llvm::StringMap<bool> CalleeMap;
   unsigned ArgIndex = 0;
 
   // We need to loop through the actual call arguments rather than the the
   // function's parameters, in case this variadic.
   for (const CallArg &Arg : Args) {
     // The "avx" feature changes how vectors >128 in size are passed. "avx512f"
     // additionally changes how vectors >256 in size are passed. Like GCC, we
     // warn when a function is called with an argument where this will change.
     // Unlike GCC, we also error when it is an obvious ABI mismatch, that is,
     // the caller and callee features are mismatched.
     // Unfortunately, we cannot do this diagnostic in SEMA, since the callee can
     // change its ABI with attribute-target after this call.
     if (Arg.getType()->isVectorType() &&
         CGM.getContext().getTypeSize(Arg.getType()) > 128) {
       initFeatureMaps(CGM.getContext(), CallerMap, Caller, CalleeMap, Callee);
       QualType Ty = Arg.getType();
       // The CallArg seems to have desugared the type already, so for clearer
       // diagnostics, replace it with the type in the FunctionDecl if possible.

clang/test/CodeGen/target-avx-abi-diag.c

-// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -verify=no256,no512 -o - -S
-// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -target-feature +avx -verify=no512 -o - -S
+// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -verify=no256,no512,no256-err,no512-err -o - -S
+// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -target-feature +avx -verify=no512,no512-err -o - -S
 // RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -target-feature +avx512f -verify=both -o - -S
+
+// RUN: %clang_cc1 %s -triple=x86_64-apple-macos -verify=no256-err,no512-err -o - -S
+// RUN: %clang_cc1 %s -triple=x86_64-apple-macos -target-feature +avx -verify=no512-err -o - -S
 // REQUIRES: x86-registered-target
 
 // both-no-diagnostics
 
 typedef short avx512fType __attribute__((vector_size(64)));
 typedef short avx256Type __attribute__((vector_size(32)));
 
 __attribute__((target("avx"))) void takesAvx256(avx256Type t);
void call_warn(void) {
 
   variadic(1, t1); // no256-warning {{AVX vector argument of type 'avx256Type' (vector of 16 'short' values) without 'avx' enabled changes the ABI}}
   variadic(3, t2); // no512-warning {{AVX vector argument of type 'avx512fType' (vector of 32 'short' values) without 'avx512f' enabled changes the ABI}}
 }
 
 // If only 1 side has an attribute, error.
 void call_errors(void) {
   avx256Type t1;
-  takesAvx256(t1); // no256-error {{AVX vector argument of type 'avx256Type' (vector of 16 'short' values) without 'avx' enabled changes the ABI}}
+  takesAvx256(t1); // no256-err-error {{AVX vector argument of type 'avx256Type' (vector of 16 'short' values) without 'avx' enabled changes the ABI}}
   avx512fType t2;
-  takesAvx512(t2); // no512-error {{AVX vector argument of type 'avx512fType' (vector of 32 'short' values) without 'avx512f' enabled changes the ABI}}
+  takesAvx512(t2); // no512-err-error {{AVX vector argument of type 'avx512fType' (vector of 32 'short' values) without 'avx512f' enabled changes the ABI}}
 
-  variadic_err(1, t1); // no256-error {{AVX vector argument of type 'avx256Type' (vector of 16 'short' values) without 'avx' enabled changes the ABI}}
-  variadic_err(3, t2); // no512-error {{AVX vector argument of type 'avx512fType' (vector of 32 'short' values) without 'avx512f' enabled changes the ABI}}
+  variadic_err(1, t1); // no256-err-error {{AVX vector argument of type 'avx256Type' (vector of 16 'short' values) without 'avx' enabled changes the ABI}}
+  variadic_err(3, t2); // no512-err-error {{AVX vector argument of type 'avx512fType' (vector of 32 'short' values) without 'avx512f' enabled changes the ABI}}
 }
 
 // These two don't diagnose anything, since these are valid calls.
 __attribute__((target("avx"))) void call_avx256_ok(void) {
   avx256Type t;
   takesAvx256(t);
 }
 
 __attribute__((target("avx512f"))) void call_avx512_ok(void) {
   avx512fType t;
   takesAvx512(t);
 }

clang/test/CodeGen/target-builtin-error-3.c

 }
 static inline half16 __attribute__((__overloadable__)) convert_half( float16 a ) {
   half16 r;
   r.lo = convert_half(a.lo);
   return r;
 }
 void avx_test( uint16_t *destData, float16 argbF)
 {
-  // expected-warning@+1{{AVX vector argument of type 'float16' (vector of 16 'float' values) without 'avx512f' enabled changes the ABI}}
   ((half16U *)destData)[0] = convert_half(argbF);
 }