Make CC mangling conditional on the ABI version

[rnk]

@rsmith asked if we should make this mangling conditional on the ABI version. I implemented it here, let me know if you think it's worth the extra code complexity. Our mingw ABI hasn't been particularly stable, but I think going forward we'll want to start mangling new calling convention attributes (regcall, maybe?) this way, and we'll want to make it conditional on the ABI version using something like this code structure.

[rjmccall]

I think the core question is whether there are any vendors who care about ABI stability for these attributes who don't care about the bugfix. Speaking for Apple, we would rather have the bugfix. Sony might have different thoughts; CC'ing Paul.

[probinson]

Sorry for not noticing this sooner. The TL;DR is, the current patch does not affect PS4, so go ahead; but see the long version for other considerations.

First, the general point: The PS4 ABI does not fit neatly into the sequential ClangABI versioning scheme. We forked a while back, and adopted a few subsequent changes and didn't adopt other changes. Just to make everyone's life less boring. And give me migraines. So, whenever ABI-related things happen, we need to be conscious of that (not fitting neatly; my headaches are not a consideration).

Second, IIUC the PS4 ABI ignores all the calling-convention attributes that are handled specially by this patch. So to that degree, PS4 doesn't care. We don't support the MS-specific ones, in particular.

That said, I've discovered that there are at least a few of these non-target-specific CC attributes that we fail to ignore, such as vectorcall, and there's internal discussion to sort out what to do about that. None of which should prevent this patch from going forward.

[rjmccall]

Okay. In my opinion, then, we should just do this unconditionally.

[rnk]

In D55781#1351541, @rjmccall wrote:

Okay. In my opinion, then, we should just do this unconditionally.

Sounds good to me.

clang/lib/AST/ItaniumMangle.cpp

private:
   // Declare manglers for every type class.
 #define ABSTRACT_TYPE(CLASS, PARENT)
 #define NON_CANONICAL_TYPE(CLASS, PARENT)
 #define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T);
 #include "clang/AST/TypeNodes.def"
 
   void mangleType(const TagType*);
   void mangleType(TemplateName);
-  static StringRef getCallingConvQualifierName(CallingConv CC);
+  StringRef getCallingConvQualifierName(CallingConv CC);
+  StringRef maybeQualifyCallingConv(StringRef CCQual,
+                                    LangOptions::ClangABI PrevVer);
   void mangleExtParameterInfo(FunctionProtoType::ExtParameterInfo info);
   void mangleExtFunctionInfo(const FunctionType *T);
   void mangleBareFunctionType(const FunctionProtoType *T, bool MangleReturnType,
                               const FunctionDecl *FD = nullptr);
   void mangleNeonVectorType(const VectorType *T);
   void mangleNeonVectorType(const DependentVectorType *T);
   void mangleAArch64NeonVectorType(const VectorType *T);
   void mangleAArch64NeonVectorType(const DependentVectorType *T);
#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
   case BuiltinType::Id: \
     type_name = "ocl_" #ExtType; \
     Out << type_name.size() << type_name; \
     break;
 #include "clang/Basic/OpenCLExtensionTypes.def"
   }
 }
 
+/// Use a vendor extension qualifier for this calling convention if the current
+/// version is after the version before this mangling was introduced in clang.
+StringRef
+CXXNameMangler::maybeQualifyCallingConv(StringRef CCQual,
+                                        LangOptions::ClangABI PrevVer) {
+  auto CurrentABIVersion = getASTContext().getLangOpts().getClangABICompat();
+  return (CurrentABIVersion > PrevVer) ? CCQual : "";
+}
+
 StringRef CXXNameMangler::getCallingConvQualifierName(CallingConv CC) {
   switch (CC) {
   case CC_C:
     return "";
 
   case CC_X86VectorCall:
   case CC_X86Pascal:
   case CC_X86RegCall:
   case CC_AAPCS:
   case CC_AAPCS_VFP:
   case CC_AArch64VectorCall:
   case CC_IntelOclBicc:
   case CC_SpirFunction:
   case CC_OpenCLKernel:
   case CC_PreserveMost:
   case CC_PreserveAll:
     // FIXME: we should be mangling all of the above.
     return "";
 
   case CC_X86StdCall:
-    return "stdcall";
+    return maybeQualifyCallingConv("stdcall", LangOptions::ClangABI::Ver7);
   case CC_X86FastCall:
-    return "fastcall";
+    return maybeQualifyCallingConv("fastcall", LangOptions::ClangABI::Ver7);
   case CC_X86ThisCall:
-    return "thiscall";
+    return maybeQualifyCallingConv("thiscall", LangOptions::ClangABI::Ver7);
   case CC_X86_64SysV:
-    return "sysv_abi";
+    return maybeQualifyCallingConv("sysv_abi", LangOptions::ClangABI::Ver7);
   case CC_Win64:
-    return "ms_abi";
+    return maybeQualifyCallingConv("ms_abi", LangOptions::ClangABI::Ver7);
+
   case CC_Swift:
     return "swiftcall";
   }
   llvm_unreachable("bad calling convention");
 }
 
 void CXXNameMangler::mangleExtFunctionInfo(const FunctionType *T) {
   // Fast path.

clang/test/CodeGenCXX/mangle-win-ccs-old.cpp

+// RUN: %clang_cc1 %s -emit-llvm -triple i686-windows-gnu -o - | FileCheck %s --check-prefix=MINGW32
+// RUN: %clang_cc1 %s -emit-llvm -triple i686-windows-gnu -o - -fclang-abi-compat=7 | FileCheck %s --check-prefix=MINGW32-OLD
+// RUN: %clang_cc1 %s -emit-llvm -triple x86_64-windows-gnu -o - | FileCheck %s --check-prefix=MINGW64
+// RUN: %clang_cc1 %s -emit-llvm -triple x86_64-windows-gnu -o - -fclang-abi-compat=7 | FileCheck %s --check-prefix=MINGW64-OLD
+// RUN: %clang_cc1 %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s --check-prefix=LINUX
+// RUN: %clang_cc1 %s -emit-llvm -triple x86_64-linux-gnu -o - -fclang-abi-compat=7 | FileCheck %s --check-prefix=LINUX-OLD
+
+#if defined(__i386__) && defined(__MINGW32__)
+void cb_cdecl   (void (                          *cb)(int)) { cb(42); }
+void cb_stdcall (void (__attribute__((stdcall )) *cb)(int)) { cb(42); }
+void cb_fastcall(void (__attribute__((fastcall)) *cb)(int)) { cb(42); }
+void cb_thiscall(void (__attribute__((thiscall)) *cb)(int)) { cb(42); }
+
+// MINGW32: define dso_local void @_Z8cb_cdeclPFviE(void (i32)* %cb)
+// MINGW32: define dso_local void @_Z10cb_stdcallPU7stdcallFviE(void (i32)* %cb)
+// MINGW32: define dso_local void @_Z11cb_fastcallPU8fastcallFviE(void (i32)* %cb)
+// MINGW32: define dso_local void @_Z11cb_thiscallPU8thiscallFviE(void (i32)* %cb)
+
+// MINGW32-OLD: define dso_local void @_Z8cb_cdeclPFviE(void (i32)* %cb)
+// MINGW32-OLD: define dso_local void @_Z10cb_stdcallPFviE(void (i32)* %cb)
+// MINGW32-OLD: define dso_local void @_Z11cb_fastcallPFviE(void (i32)* %cb)
+// MINGW32-OLD: define dso_local void @_Z11cb_thiscallPFviE(void (i32)* %cb)
+#endif
+
+#if defined(__x86_64__) && defined(__MINGW32__)
+void cb_sysvabi(void (__attribute__((sysv_abi)) *cb)(int)) { cb(42); }
+void cb_msabi  (void (__attribute__((ms_abi  )) *cb)(int)) { cb(42); }
+
+// MINGW64: define dso_local void @_Z10cb_sysvabiPU8sysv_abiFviE(void (i32)* %cb)
+// MINGW64: define dso_local void @_Z8cb_msabiPFviE(void (i32)* %cb)
+
+// MINGW64-OLD: define dso_local void @_Z10cb_sysvabiPFviE(void (i32)* %cb)
+// MINGW64-OLD: define dso_local void @_Z8cb_msabiPFviE(void (i32)* %cb)
+#endif
+
+#if defined(__x86_64__) && defined(__linux__)
+void cb_sysvabi(void (__attribute__((sysv_abi)) *cb)(int)) { cb(42); }
+void cb_msabi  (void (__attribute__((ms_abi  )) *cb)(int)) { cb(42); }
+
+// LINUX: define void @_Z10cb_sysvabiPFviE(void (i32)* %cb)
+// LINUX: define void @_Z8cb_msabiPU6ms_abiFviE(void (i32)* %cb)
+
+// LINUX-OLD: define void @_Z10cb_sysvabiPFviE(void (i32)* %cb)
+// LINUX-OLD: define void @_Z8cb_msabiPFviE(void (i32)* %cb)
+#endif