[Clang] follow-up D128745, use ClangABICompat15 instead of ClangABICompat14

[ychen]

Summary

Since the patch missed release 15.x and will be included in release 16.x. Also, simplify related tests.

[aaron.ballman]

Good catch @royjacobson on the ABI version number needing to be bumped! LGTM

clang/docs/ReleaseNotes.rst

 ---------------------------
 
 C2x Feature Support
 -------------------
 
 C++ Language Changes in Clang
 -----------------------------
 
-- Implemented DR692, DR1395 and DR1432. Use the ``-fclang-abi-compat=14`` option
+- Implemented DR692, DR1395 and DR1432. Use the ``-fclang-abi-compat=15`` option
   to get the old partial ordering behavior regarding packs.
 
 C++20 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 - Support capturing structured bindings in lambdas
   (`P1091R3 <https://wg21.link/p1091r3>`_ and `P1381R1 <https://wg21.link/P1381R1>`).
   This fixes issues `GH52720 <https://github.com/llvm/llvm-project/issues/52720>`_,

clang/include/clang/Basic/LangOptions.h

enum class ClangABI {
     /// This causes clang to:
     ///   - mangle dependent nested names incorrectly.
     ///   - pack non-POD members of packed structs.
     ///   - make trivial only those defaulted copy constructors with a
     ///     parameter-type-list equivalent to the parameter-type-list of an
     ///     implicit declaration.
     Ver14,
 
+    /// Attempt to be ABI-compatible with code generated by Clang 15.0.x.
+    /// This causes clang to:
+    ///   - Reverse the implementation for DR692, DR1395 and DR1432.
+    Ver15,
+
     /// Conform to the underlying platform's C and C++ ABIs as closely
     /// as we can.
     Latest
   };
 
   enum class CoreFoundationABI {
     /// No interoperability ABI has been specified
     Unspecified,

clang/lib/Frontend/CompilerInvocation.cpp

#undef LANG_OPTION_WITH_MARSHALLING
   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver9)
     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "9.0", SA);
   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver11)
     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "11.0", SA);
   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver12)
     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "12.0", SA);
   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver14)
     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "14.0", SA);
+  else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver15)
+    GenerateArg(Args, OPT_fclang_abi_compat_EQ, "15.0", SA);
 
   if (Opts.getSignReturnAddressScope() ==
       LangOptions::SignReturnAddressScopeKind::All)
     GenerateArg(Args, OPT_msign_return_address_EQ, "all", SA);
   else if (Opts.getSignReturnAddressScope() ==
            LangOptions::SignReturnAddressScopeKind::NonLeaf)
     GenerateArg(Args, OPT_msign_return_address_EQ, "non-leaf", SA);
 
if (!VerParts.first.startswith("0") &&
       else if (Major <= 9)
         Opts.setClangABICompat(LangOptions::ClangABI::Ver9);
       else if (Major <= 11)
         Opts.setClangABICompat(LangOptions::ClangABI::Ver11);
       else if (Major <= 12)
         Opts.setClangABICompat(LangOptions::ClangABI::Ver12);
       else if (Major <= 14)
         Opts.setClangABICompat(LangOptions::ClangABI::Ver14);
+      else if (Major <= 15)
+        Opts.setClangABICompat(LangOptions::ClangABI::Ver15);
     } else if (Ver != "latest") {
       Diags.Report(diag::err_drv_invalid_value)
           << A->getAsString(Args) << A->getValue();
     }
   }
 
   if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
     StringRef SignScope = A->getValue();

clang/lib/Sema/SemaTemplateDeduction.cpp

DeduceTemplateArguments(Sema &S,
   }
 
   // DR692, DR1395
   // C++0x [temp.deduct.type]p10:
   // If the parameter-declaration corresponding to P_i ...
   // During partial ordering, if Ai was originally a function parameter pack:
   // - if P does not contain a function parameter type corresponding to Ai then
   //   Ai is ignored;
-  bool ClangABICompat14 = S.Context.getLangOpts().getClangABICompat() <=
-                          LangOptions::ClangABI::Ver14;
-  if (!ClangABICompat14 && PartialOrdering && ArgIdx + 1 == NumArgs &&
+  bool ClangABICompat15 = S.Context.getLangOpts().getClangABICompat() <=
+                          LangOptions::ClangABI::Ver15;
+  if (!ClangABICompat15 && PartialOrdering && ArgIdx + 1 == NumArgs &&
       isa<PackExpansionType>(Args[ArgIdx]))
     return Sema::TDK_Success;
 
   // Make sure we don't have any extra arguments.
   if (ArgIdx < NumArgs)
     return Sema::TDK_MiscellaneousDeductionFailure;
 
   return Sema::TDK_Success;
static bool isSameTemplateArg(ASTContext &Context,
   // If we're checking deduced arguments (X) against original arguments (Y),
   // we will have flattened packs to non-expansions in X.
   if (PackExpansionMatchesPack && X.isPackExpansion() && !Y.isPackExpansion())
     X = X.getPackExpansionPattern();
 
   if (X.getKind() != Y.getKind())
     return false;
 
-  bool ClangABICompat14 =
-      Context.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver14;
+  bool ClangABICompat15 =
+      Context.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver15;
 
   switch (X.getKind()) {
     case TemplateArgument::Null:
       llvm_unreachable("Comparing NULL template argument");
 
     case TemplateArgument::Type:
       return Context.getCanonicalType(X.getAsType()) ==
              Context.getCanonicalType(Y.getAsType());
switch (X.getKind()) {
     case TemplateArgument::Expression: {
       llvm::FoldingSetNodeID XID, YID;
       X.getAsExpr()->Profile(XID, Context, true);
       Y.getAsExpr()->Profile(YID, Context, true);
       return XID == YID;
     }
 
     case TemplateArgument::Pack:
-      if (ClangABICompat14) {
+      if (ClangABICompat15) {
         if (X.pack_size() != Y.pack_size())
           return false;
 
         for (TemplateArgument::pack_iterator XP = X.pack_begin(),
                                              XPEnd = X.pack_end(),
                                              YP = Y.pack_begin();
              XP != XPEnd; ++XP, ++YP)
           if (!isSameTemplateArg(Context, *XP, *YP, PartialOrdering,
getMoreSpecialized(Sema &S, QualType T1, QualType T2, TemplateLikeDecl *P1,
   bool Better2 = isAtLeastAsSpecializedAs(S, T2, T1, P1, Info);
   if (IsMoreSpecialThanPrimaryCheck && !Better2)
     return P1;
 
   if (!Better1 && !Better2)
     return nullptr;
 
   if (Better1 && Better2) {
-    bool ClangABICompat14 = S.Context.getLangOpts().getClangABICompat() <=
-                            LangOptions::ClangABI::Ver14;
-    if (!ClangABICompat14) {
+    bool ClangABICompat15 = S.Context.getLangOpts().getClangABICompat() <=
+                            LangOptions::ClangABI::Ver15;
+    if (!ClangABICompat15) {
       // Consider this a fix for CWG1432. Similar to the fix for CWG1395.
       auto *TST1 = T1->castAs<TemplateSpecializationType>();
       auto *TST2 = T2->castAs<TemplateSpecializationType>();
       if (TST1->getNumArgs()) {
         const TemplateArgument &TA1 = TST1->template_arguments().back();
         if (TA1.getKind() == TemplateArgument::Pack) {
           assert(TST1->getNumArgs() == TST2->getNumArgs());
           const TemplateArgument &TA2 = TST2->template_arguments().back();

clang/test/CXX/temp/temp.decls/temp.class.spec/p8-0x.cpp

 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fclang-abi-compat=15.0 -std=c++11 -fsyntax-only -verify %s
 
 template<int ...Values> struct X1;
 
 template<int ...Values>  // expected-note {{non-deducible}}
 struct X1<0, Values+1 ...>; // expected-error{{contains a template parameter that cannot be deduced}}
 
 template<typename T, int ...Values> struct X2; // expected-note {{here}}
 template<int ...Values> struct X2<X1<Values...>, Values+1 ...> {}; // ok (DR1315)
 X2<X1<1, 2, 3>, 2, 3, 4> x2; // ok
 X2<X1<1, 2, 3>, 2, 3, 4, 5> x3; // expected-error {{undefined template}}

clang/test/CodeGen/partial-order-variadic.cpp

-// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fclang-abi-compat=14 -DCLANG_ABI_COMPAT=14 %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s --check-prefix=CHECK-14
-// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fclang-abi-compat=15 -DCLANG_ABI_COMPAT=15 %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s --check-prefixes=CHECK,AFTER-15
 
-#if defined(CLANG_ABI_COMPAT) && CLANG_ABI_COMPAT <= 14
-
-// CHECK-14: %"struct.temp_func_order_example3::S" = type { i8 }
-
-// CHECK-14: define dso_local void @_ZN24temp_func_order_example31hEi(i32 noundef %i)
-// CHECK-14-NEXT:  entry:
-// CHECK-14-NEXT:    %i.addr = alloca i32, align 4
-// CHECK-14-NEXT:    %r = alloca ptr, align 8
-// CHECK-14-NEXT:    %a = alloca %"struct.temp_func_order_example3::S", align 1
-// CHECK-14-NEXT:    store i32 %i, ptr %i.addr, align 4
-// CHECK-14-NEXT:    %call = call noundef nonnull align 4 dereferenceable(4) ptr @_ZN24temp_func_order_example31gIiJEEERiPT_DpT0_(ptr noundef %i.addr)
-// CHECK-14-NEXT:    store ptr %call, ptr %r, align 8
-// CHECK-14-NEXT:    ret void
-
-namespace temp_func_order_example3 {
-  template <typename T, typename... U> int &g(T *, U...);
-  template <typename T> void g(T);
-
-  template <typename T, typename... Ts> struct S;
-  template <typename T> struct S<T> {};
-
-  void h(int i) {
-    int &r = g(&i);
-    S<int> a;
-  }
-}
-
-#else
+// CHECK: %struct.S = type { i8 }
+// CHECK: @_Z2ggiRi
+// CHECK: @_Z1gIiJEERiPT_DpT0_
+void gg(int i, int &r) {
+  r = g(&i);
 
-// CHECK: %"struct.temp_deduct_type_example1::A" = type { i8 }
+// CHECK: @_Z1hIJiEEvDpPT_
+template<class ...T> void h(T*...) {}
+template<class T>    void h(const T&) {}
+template void h(int*);
 
-// CHECK: $_ZN25temp_deduct_type_example31fIiJEEEvPT_DpT0_ = comdat any
+#if !defined(CLANG_ABI_COMPAT)
 
-// CHECK: define dso_local void @_ZN25temp_deduct_type_example11fEv()
-// CHECK-NEXT: entry:
-// CHECK-NEXT:   %a = alloca %"struct.temp_deduct_type_example1::A", align 1
-// CHECK-NEXT:   ret void
-
-// CHECK: define weak_odr void @_ZN25temp_deduct_type_example31fIiJEEEvPT_DpT0_(ptr noundef %0)
-// CHECK-NEXT: entry:
-// CHECK-NEXT:   %.addr = alloca ptr, align 8
-// CHECK-NEXT:   store ptr %0, ptr %.addr, align 8
-// CHECK-NEXT:   ret void
+// AFTER-15: @_Z1fIiJEEvPT_DpT0_
+template<class T, class... U> void f(T*, U...){}
+template<class T> void f(T){}
+template void f(int*);
 
-namespace temp_deduct_type_example1 {
-  template<class T, class... U> struct A;
-  template<class T1, class T2, class... U> struct A<T1,T2*,U...> {};
-  template<class T1, class T2> struct A<T1,T2>;
-  template struct A<int, int*>;
-  void f() { A<int, int*> a; }
-}
-
-namespace temp_deduct_type_example3 {
-  template<class T, class... U> void f(T*, U...){}
-  template<class T> void f(T){}
-  template void f(int*);
-}
 
 #endif