[ObjC] Encode pointers to C++ classes as "^v" if the encoded string would otherwise include template specialization types

[ahatanak]

Summary

This helps reduce the size of the encoded C++ type strings in the binary.

This is enabled by default only on Darwin, but can be enabled/disabled via command line options.

rdar://63288571

[ahatanak]

This patch focuses only on reducing the encoded size of classes with template specialization, but if the information about pointed-to types isn't used at all, clang can always emit "^v" for C++ pointer types. Or it might make more sense to base the decision on whether the type is POD rather than on whether the string includes template specialization.

[rjmccall]

You might want to test nested classes of class templates. I don't know if we encode nested classes in any reasonable way in the first place.

I'm generally okay with being aggressive about stripping this kind of information from encodings, since encodings are not good enough to do type reflection in ObjC++ anyway. If you did decide you wanted to preserve more information from the encoding, though, you could consider only applying this at the innermost level that mentions a template specialization type, rather than the outermost. That is, the new logic seems to not expand the X in X* if X recursively has a field that's a pointer to a template specialization, rather than expanding X and then not expanding the type of that one field. Definitely not something I think you need to do now, though.

[theraven]

I'm broadly in favour of this change, but with the GNUstep ABIs this is an ABI-breaking change and so should not be on by default. The type encoding leaks into the ABI in two ways:

• Dispatch is dependent on type, which avoids some stack corruption bugs on NeXT-style runtimes. This means that the types of the selector in the caller and the selector in the method definition must match. I don't see a problem with turning this change off for this specific case, because it's incredibly rare to pass complex C++ template types as arguments to Objective-C methods.
• The variable that contains the offset of ivars includes the type encoding, so that changing the type of a public ivar breaks linkage, rather than just subtly corrupting data later. We could leave this change on for any @private or @package ivars, but changing the type encoding for public ivars will break code linking with existing frameworks.

I'm quite happy with this to be opt-in for non-Apple runtimes and opt-out for Apple runtimes.

[rjmccall]

Since this is just in pointee types, I suspect this is fine for dispatch outside of targets (like that one old Cray) where sizeof(void*) != sizeof(some_struct*), which I don't believe we generally support. But yeah, if this affects GNU-runtime ivar mangling, we need a way to not disturb this for that case.

[ahatanak]

Enable this optimization only on Darwin.

[ahatanak]

Upload patch with context.

[ahatanak]

Add test cases for nested class.

[theraven]

clang/include/clang/Driver/Options.td

2113

I think there's some magic in Options.td for defining the thing and its no- variant together. I don't think you want the f prefix in the name either if it's an f-option.

clang/lib/Driver/ToolChains/Clang.cpp

5784

I don't think this should be guarded on Darwin, it should be guarded on whether the ObjCRuntime is a NeXT-family runtime. It might be fine to enable this for all non-GNUstep runtimes (the GCC ABI has typed selectors, but doesn't use the type information for dispatch and doesn't have non-fragile ivars. I believe the ObjFW runtime is the same).

[ahatanak]

• Use BoolFOption to define both the positive and negative options.
• Enable the optimization if the ObjC runtime is a NeXT-family runtime.

[theraven]

Thanks!

[thakis]

Very cool change, I wanted something like this for a long time :)

It seems to break Index/preamble-reparse-changed-module.m on some platforms:
http://45.33.8.238/linux/39727/step_7.txt
http://45.33.8.238/macm1/3788/step_6.txt

Does the failure make sense to you?

[ahatanak]

In D96816#2572218, @thakis wrote:

Very cool change, I wanted something like this for a long time :)

It seems to break Index/preamble-reparse-changed-module.m on some platforms:
http://45.33.8.238/linux/39727/step_7.txt
http://45.33.8.238/macm1/3788/step_6.txt

Does the failure make sense to you?

I don't know why the test is failing. It doesn't fail on my machine.

This is also broken: http://green.lab.llvm.org/green/job/lldb-cmake/29029/

I'm not sure if it's related to the one you saw.

[thakis]

I ssh'd into one of the failing boxes and ran the failing command without piping it into filecheck. Here's the output:

thakis@dotc:~/src/llvm-project$ env CINDEXTEST_EDITING=1 CINDEXTEST_EXECUTE_COMMAND="cp /usr/local/google/home/thakis/src/llvm-project/clang/test/Index/Inputs/preamble-reparse-changed-module/new-head.h /usr/local/google/home/thakis/src/llvm-project/out/gn/obj/clang/test/Index/Output/preamble-reparse-changed-module.m.tmp/mod/head.h" CINDEXTEST_EXECUTE_AFTER_TRIAL=1      /usr/local/google/home/thakis/src/llvm-project/out/gn/bin/c-index-test -test-load-source-reparse 3 local /usr/local/google/home/thakis/src/llvm-project/clang/test/Index/preamble-reparse-changed-module.m -I /usr/local/google/home/thakis/src/llvm-project/out/gn/obj/clang/test/Index/Output/preamble-reparse-changed-module.m.tmp -I /usr/local/google/home/thakis/src/llvm-project/out/gn/obj/clang/test/Index/Output/preamble-reparse-changed-module.m.tmp/mod -fmodules -fmodules-cache-path=/usr/local/google/home/thakis/src/llvm-project/out/gn/obj/clang/test/Index/Output/preamble-reparse-changed-module.m.tmp/mcp 
c-index-test: ../../llvm/include/llvm/ADT/SmallVector.h:281: llvm::SmallVectorTemplateCommon::const_reference llvm::SmallVectorTemplateCommon<unsigned long, void>::operator[](llvm::SmallVectorTemplateCommon::size_type) const [T = unsigned long]: Assertion `idx < size()' failed.
libclang: crash detected during parsing: {
  'source_filename' : '(null)'
  'command_line_args' : ['clang', '/usr/local/google/home/thakis/src/llvm-project/clang/test/Index/preamble-reparse-changed-module.m', '-I', '/usr/local/google/home/thakis/src/llvm-project/out/gn/obj/clang/test/Index/Output/preamble-reparse-changed-module.m.tmp', '-I', '/usr/local/google/home/thakis/src/llvm-project/out/gn/obj/clang/test/Index/Output/preamble-reparse-changed-module.m.tmp/mod', '-fmodules', '-fmodules-cache-path=/usr/local/google/home/thakis/src/llvm-project/out/gn/obj/clang/test/Index/Output/preamble-reparse-changed-module.m.tmp/mcp'],
  'unsaved_files' : [],
  'options' : 13,
}
Unable to load translation unit!
Failure: libclang crashed

Do you build without assertions locally maybe?

[thakis]

#3  0x00007ffff78ee662 in __GI___assert_fail (assertion=0x90165c "idx < size()", 
    file=0xc60efe "../../llvm/include/llvm/ADT/SmallVector.h", line=281, 
    function=0xa8780d "llvm::SmallVectorTemplateCommon::const_reference llvm::SmallVectorTemplateCommon<unsigned long, void>::operator[](llvm::SmallVectorTemplateCommon::size_type) const [T = unsigned long]") at assert.c:101
#4  0x000000000444401a in clang::ASTReader::ParseLanguageOptions(llvm::SmallVector<unsigned long, 64u> const&, bool, clang::ASTReaderListener&, bool) ()
#5  0x000000000443eb62 in clang::ASTReader::ReadOptionsBlock(llvm::BitstreamCursor&, unsigned int, bool, clang::ASTReaderListener&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&) ()
#6  0x00000000044474c5 in clang::ASTReader::ReadControlBlock(clang::serialization::ModuleFile&, llvm::SmallVectorImpl<clang::ASTReader::ImportedModule>&, clang::serialization::ModuleFile const*, unsigned int) ()
#7  0x000000000444a901 in clang::ASTReader::ReadASTCore(llvm::StringRef, clang::serialization::ModuleKind, clang::SourceLocation, clang::serialization::ModuleFile*, llvm::SmallVectorImpl<clang::ASTReader::ImportedModule>&, long, long, clang::ASTFileSignature, unsigned int) ()
#8  0x00000000044584f8 in clang::ASTReader::ReadAST(llvm::StringRef, clang::serialization::ModuleKind, clang::SourceLocation, unsigned int, llvm::SmallVectorImpl<clang::ASTReader::ImportedSubmodule>*) ()
#9  0x00000000042c07a5 in clang::CompilerInstance::findOrCompileModuleAndReadAST(llvm::StringRef, clang::SourceLocation, clang::SourceLocation, bool) ()
#10 0x00000000042c4650 in clang::CompilerInstance::loadModule(clang::SourceLocation, llvm::ArrayRef<std::pair<clang::IdentifierInfo*, clang::SourceLocation> >, clang::Module::NameVisibilityKind, bool) ()
#11 0x00000000049713c6 in clang::Preprocessor::LexAfterModuleImport(clang::Token&) ()
#12 0x0000000004972afb in clang::Preprocessor::Lex(clang::Token&) ()
#13 0x0000000004e6421d in clang::Parser::ParseModuleName(clang::SourceLocation, llvm::SmallVectorImpl<std::pair<clang::IdentifierInfo*, clang::SourceLocation> >&, bool) ()
#14 0x0000000004e5c9f5 in clang::Parser::ParseModuleImport(clang::SourceLocation) ()
#15 0x0000000004ed2e23 in clang::Parser::ParseObjCAtDirectives(clang::Parser::ParsedAttributesWithRange&) ()
#16 0x0000000004e5d802 in clang::Parser::ParseExternalDeclaration(clang::Parser::ParsedAttributesWithRange&, clang::ParsingDeclSpec*) ()
#17 0x0000000004e5b7e6 in clang::Parser::ParseTopLevelDecl(clang::OpaquePtr<clang::DeclGroupRef>&, bool) ()
#18 0x0000000004e5af77 in clang::Parser::ParseFirstTopLevelDecl(clang::OpaquePtr<clang::DeclGroupRef>&) ()
#19 0x0000000004e5632d in clang::ParseAST(clang::Sema&, bool, bool) ()
#20 0x000000000434e3a3 in clang::FrontendAction::Execute() ()
#21 0x0000000004261cc6 in clang::ASTUnit::Parse(std::shared_ptr<clang::PCHContainerOperations>, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem>) ()
#22 0x0000000004265d8d in clang::ASTUnit::LoadFromCompilerInvocation(std::shared_ptr<clang::PCHContainerOperations>, unsigned int, llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem>) ()
#23 0x0000000004267090 in clang::ASTUnit::LoadFromCommandLine(char const**, char const**, std::shared_ptr<clang::PCHContainerOperations>, llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine>, llvm::StringRef, bool, clang::CaptureDiagsKind, llvm::ArrayRef<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, llvm::MemoryBuffer*> >, bool, unsigned int, clang::TranslationUnitKind, bool, bool, bool, clang::SkipFunctionBodiesScope, bool, bool, bool, bool, llvm::Optional<llvm::StringRef>, std::unique_ptr<clang::ASTUnit, std::default_delete<clang::ASTUnit> >*, llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem>) ()
#24 0x00000000045c7b05 in void llvm::function_ref<void ()>::callback_fn<clang_parseTranslationUnit2FullArgv::$_1>(long) ()
#25 0x000000000464d955 in llvm::CrashRecoveryContext::RunSafely(llvm::function_ref<void ()>) ()
#26 0x000000000464db04 in RunSafelyOnThread_Dispatch(void*) ()

Maybe the problem is that the test reuses a serialized module from an earlier run, and this changes serialization stuff without bumping the serialization version?

[thakis]

See maybe also https://reviews.llvm.org/D73202 . Do we need to bump serialization::VERSION_MINOR ?

[thakis]

In D96816#2572431, @thakis wrote:

See maybe also https://reviews.llvm.org/D73202 . Do we need to bump serialization::VERSION_MINOR ?

I gave

[thakis]

In D96816#2572431, @thakis wrote:

See maybe also https://reviews.llvm.org/D73202 . Do we need to bump serialization::VERSION_MINOR ?

I gave that a try in http://reviews.llvm.org/rG063236646849564094f5fcfc947ad36dba0efedb . Looks like it did the trick: http://45.33.8.238/linux/39740/step_7.txt Some other test is also broken, but the breakage caused by this change is fixed in that build. So the failure happened with LLVM_APPEND_VC_REV=NO.

[ahatanak]

I still don't understand why the test was failing, but did we have to bump the version because a new LangOpt (EncodeCXXClassTemplateSpec) was added?

[dexonsmith]

In D96816#2572552, @ahatanak wrote:

I still don't understand why the test was failing, but did we have to bump the version because a new LangOpt (EncodeCXXClassTemplateSpec) was added?

Here are the RUN lines:

// RUN: mkdir -p %t/mod
// RUN: touch %t/empty.h
// RUN: cp %S/Inputs/preamble-reparse-changed-module/module.modulemap %t/mod
// RUN: cp %S/Inputs/preamble-reparse-changed-module/head.h %t/mod

// RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_EXECUTE_COMMAND="cp %S/Inputs/preamble-reparse-changed-module/new-head.h %t/mod/head.h" CINDEXTEST_EXECUTE_AFTER_TRIAL=1 \
// RUN:     c-index-test -test-load-source-reparse 3 local %s -I %t -I %t/mod -fmodules -fmodules-cache-path=%t/mcp 2>&1 | FileCheck %s

It wouldn't have failed in a clean build.

The test is reusing the module cache path %t/mcp from the previous run. I think most implicit modules tests make themselves robust to incremental builds by adding something like this before the first use of the cache:

// RUN: rm -rf %t/mcp

[thakis]

In D96816#2572589, @dexonsmith wrote:

In D96816#2572552, @ahatanak wrote:

I still don't understand why the test was failing, but did we have to bump the version because a new LangOpt (EncodeCXXClassTemplateSpec) was added?

Here are the RUN lines:

// RUN: mkdir -p %t/mod
// RUN: touch %t/empty.h
// RUN: cp %S/Inputs/preamble-reparse-changed-module/module.modulemap %t/mod
// RUN: cp %S/Inputs/preamble-reparse-changed-module/head.h %t/mod

// RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_EXECUTE_COMMAND="cp %S/Inputs/preamble-reparse-changed-module/new-head.h %t/mod/head.h" CINDEXTEST_EXECUTE_AFTER_TRIAL=1 \
// RUN:     c-index-test -test-load-source-reparse 3 local %s -I %t -I %t/mod -fmodules -fmodules-cache-path=%t/mcp 2>&1 | FileCheck %s

It wouldn't have failed in a clean build.

The test is reusing the module cache path %t/mcp from the previous run. I think most implicit modules tests make themselves robust to incremental builds by adding something like this before the first use of the cache:

// RUN: rm -rf %t/mcp

Right; see also description of https://reviews.llvm.org/D73202

However, while that makes the test more robust, the test kind of found a real bug that actual users could've hit (...but only uses who build with LLVM_APPEND_VC_REV=NO), since users usually don't manually manage cache dirs.

[ahatanak]

I managed to reproduce the failure by building everything with -DLLVM_APPEND_VC_REV=NO.

What I found was that any BENIGN_LANGOPT added to LangOptions.def would cause the test to fail since CompilerInvocation::getModuleHash doesn't use the option to compute the hash if it's a BENIGN_LANGOPT. The test was added a month ago, so I think my commit was the first to cause the failure. If I use LANGOPT instead of BENIGN_LANGOPT, the test passes.

The description of BENIGN_LANGOPT says "for options that don't affect the construction of the AST in any way" and since the option can change the AST (e.g., the value of unsigned length = sizeof(@encode(S)); will differ depending on whether the member for the option is set or not), I think I should have used LANGOPT instead of BENIGN_LANGOPT.

Since this is something that is easy to overlook, should there be a comment to remind people to update the version whenever they add a BENIGN_LANGOPT?

clang/include/clang/Basic/LangOptions.def

 LANGOPT(CPlusPlus17       , 1, 0, "C++17")
 LANGOPT(CPlusPlus20       , 1, 0, "C++20")
 LANGOPT(CPlusPlus2b       , 1, 0, "C++2b")
 LANGOPT(ObjC              , 1, 0, "Objective-C")
 BENIGN_LANGOPT(ObjCDefaultSynthProperties , 1, 0,
                "Objective-C auto-synthesized properties")
 BENIGN_LANGOPT(EncodeExtendedBlockSig , 1, 0,
                "Encoding extended block type signature")
+BENIGN_LANGOPT(EncodeCXXClassTemplateSpec , 1, 0,
+               "Fully encode c++ class template specialization")
 BENIGN_LANGOPT(ObjCInferRelatedResultType , 1, 1,
                "Objective-C related result type inference")
 LANGOPT(AppExt , 1, 0, "Objective-C App Extension")
 LANGOPT(Trigraphs         , 1, 0,"trigraphs")
 LANGOPT(LineComment       , 1, 0, "'//' comments")
 LANGOPT(Bool              , 1, 0, "bool, true, and false keywords")
 LANGOPT(Half              , 1, 0, "half keyword")
 LANGOPT(WChar             , 1, CPlusPlus, "wchar_t keyword")

clang/include/clang/Driver/Options.td

 def fno_unwind_tables : Flag<["-"], "fno-unwind-tables">, Group<f_Group>;
 def fno_verbose_asm : Flag<["-"], "fno-verbose-asm">, Group<f_Group>, Flags<[CC1Option]>,
   MarshallingInfoNegativeFlag<CodeGenOpts<"AsmVerbose">>;
 def fno_working_directory : Flag<["-"], "fno-working-directory">, Group<f_Group>;
 def fno_wrapv : Flag<["-"], "fno-wrapv">, Group<f_Group>;
 def fobjc_arc : Flag<["-"], "fobjc-arc">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Synthesize retain and release calls for Objective-C pointers">;
 def fno_objc_arc : Flag<["-"], "fno-objc-arc">, Group<f_Group>;
+defm objc_encode_cxx_class_template_spec : BoolFOption<"objc-encode-cxx-class-template-spec",
+  LangOpts<"EncodeCXXClassTemplateSpec">, DefaultFalse,
+  PosFlag<SetTrue, [CC1Option], "Fully encode c++ class template specialization">,
+  NegFlag<SetFalse>>;
 defm objc_convert_messages_to_runtime_calls : BoolFOption<"objc-convert-messages-to-runtime-calls",
   CodeGenOpts<"ObjCConvertMessagesToRuntimeCalls">, DefaultTrue,
   NegFlag<SetFalse, [CC1Option]>, PosFlag<SetTrue>>;
 defm objc_arc_exceptions : OptInFFlag<"objc-arc-exceptions",
   "Use EH-safe code when synthesizing retains and releases in -fobjc-arc",
   "", "", [], CodeGenOpts<"ObjCAutoRefCountExceptions">>;
 def fobjc_atdefs : Flag<["-"], "fobjc-atdefs">, Group<clang_ignored_f_Group>;
 def fobjc_call_cxx_cdtors : Flag<["-"], "fobjc-call-cxx-cdtors">, Group<clang_ignored_f_Group>;
 defm objc_exceptions : BoolFOption<"objc-exceptions",
   LangOpts<"ObjCExceptions">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option], "Enable Objective-C exceptions">, NegFlag<SetFalse>>;

clang/lib/AST/ASTContext.cpp

if (Ctx->getLangOpts().ObjCRuntime.isGNUFamily()) {
     else {
       const auto *BT = T->castAs<BuiltinType>();
       S += getObjCEncodingForPrimitiveType(Ctx, BT);
     }
   }
   S += llvm::utostr(FD->getBitWidthValue(*Ctx));
 }
 
+// Helper function for determining whether the encoded type string would include
+// a template specialization type.
+static bool hasTemplateSpecializationInEncodedString(const Type *T,
+                                                     bool VisitBasesAndFields) {
+  T = T->getBaseElementTypeUnsafe();
+
+  if (auto *PT = T->getAs<PointerType>())
+    return hasTemplateSpecializationInEncodedString(
+        PT->getPointeeType().getTypePtr(), false);
+
+  auto *CXXRD = T->getAsCXXRecordDecl();
+
+  if (!CXXRD)
+    return false;
+
+  if (isa<ClassTemplateSpecializationDecl>(CXXRD))
+    return true;
+
+  if (!CXXRD->hasDefinition() || !VisitBasesAndFields)
+    return false;
+
+  for (auto B : CXXRD->bases())
+    if (hasTemplateSpecializationInEncodedString(B.getType().getTypePtr(),
+                                                 true))
+      return true;
+
+  for (auto *FD : CXXRD->fields())
+    if (hasTemplateSpecializationInEncodedString(FD->getType().getTypePtr(),
+                                                 true))
+      return true;
+
+  return false;
+}
+
 // FIXME: Use SmallString for accumulating string.
 void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string &S,
                                             const ObjCEncOptions Options,
                                             const FieldDecl *FD,
                                             QualType *NotEncodedT) const {
   CanQualType CT = getCanonicalType(T);
   switch (CT->getTypeClass()) {
   case Type::Builtin:
   case Type::Enum:
     if (FD && FD->isBitField())
       return EncodeBitField(this, S, T, FD);
     if (const auto *BT = dyn_cast<BuiltinType>(CT))
       S += getObjCEncodingForPrimitiveType(this, BT);
     else
       S += ObjCEncodingForEnumType(this, cast<EnumType>(CT));
     return;
 
   case Type::Complex:
     S += 'j';
     getObjCEncodingForTypeImpl(T->castAs<ComplexType>()->getElementType(), S,
                                ObjCEncOptions(),
                                /*Field=*/nullptr);
     return;
 
   case Type::Atomic:
     S += 'A';
     getObjCEncodingForTypeImpl(T->castAs<AtomicType>()->getValueType(), S,
                                ObjCEncOptions(),
if (PointeeTy->isCharType()) {
         S += '#';
         return;
       }
       // GCC binary compat: Need to convert "struct objc_object *" to "@".
       if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) {
         S += '@';
         return;
       }
+      // If the encoded string for the class includes template names, just emit
+      // "^v" for pointers to the class.
+      if (getLangOpts().CPlusPlus &&
+          (!getLangOpts().EncodeCXXClassTemplateSpec &&
+           hasTemplateSpecializationInEncodedString(
+               RTy, Options.ExpandPointedToStructures()))) {
+        S += "^v";
+        return;
+      }
       // fall through...
     }
     S += '^';
     getLegacyIntegralTypeEncoding(PointeeTy);
 
     ObjCEncOptions NewOptions;
     if (Options.ExpandPointedToStructures())
       NewOptions.setExpandStructures();

clang/lib/Driver/ToolChains/Clang.cpp

 
   // -fencode-extended-block-signature=1 is default.
   if (TC.IsEncodeExtendedBlockSignatureDefault())
     CmdArgs.push_back("-fencode-extended-block-signature");
 
   if (Args.hasFlag(options::OPT_fcoroutines_ts, options::OPT_fno_coroutines_ts,
                    false) &&
       types::isCXX(InputType)) {
     CmdArgs.push_back("-fcoroutines-ts");
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
                   options::OPT_fno_double_square_bracket_attributes);
 
   // -faccess-control is default.
   if (Args.hasFlag(options::OPT_fno_access_control,
                    options::OPT_faccess_control, false))

 
   Args.AddLastArg(CmdArgs, options::OPT_flegacy_pass_manager,
                   options::OPT_fno_legacy_pass_manager);
 
   ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, Inputs, CmdArgs, rewriteKind);
   RenderObjCOptions(TC, D, RawTriple, Args, Runtime, rewriteKind != RK_None,
                     Input, CmdArgs);
 
+  if (types::isObjC(Input.getType()) &&
+      Args.hasFlag(options::OPT_fobjc_encode_cxx_class_template_spec,
+                   options::OPT_fno_objc_encode_cxx_class_template_spec,
+                   !Runtime.isNeXTFamily()))
+    CmdArgs.push_back("-fobjc-encode-cxx-class-template-spec");
+
   if (Args.hasFlag(options::OPT_fapplication_extension,
                    options::OPT_fno_application_extension, false))
     CmdArgs.push_back("-fapplication-extension");
 
   // Handle GCC-style exception args.
   if (!C.getDriver().IsCLMode())
     addExceptionArgs(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs);
 

clang/test/CodeGenObjCXX/encode.mm

-// RUN: %clang_cc1 -Wno-objc-root-class -std=gnu++98 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck --check-prefixes CHECK,CHECKCXX98 %s
-// RUN: %clang_cc1 -Wno-objc-root-class -std=gnu++20 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck --check-prefixes CHECK,CHECKCXX20 %s
+// RUN: %clang_cc1 -Wno-objc-root-class -std=gnu++98 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck --check-prefixes CHECK,CHECKCXX98,CHECK-NO-TEMP-SPEC %s
+// RUN: %clang_cc1 -Wno-objc-root-class -std=gnu++20 %s -triple=x86_64-apple-darwin10 -emit-llvm -o - | FileCheck --check-prefixes CHECK,CHECKCXX20,CHECK-NO-TEMP-SPEC %s
+// RUN: %clang_cc1 -Wno-objc-root-class -std=gnu++20 %s -triple=x86_64-apple-darwin10 -fobjc-encode-cxx-class-template-spec -emit-llvm -o - | FileCheck --check-prefixes CHECK,CHECKCXX20,CHECK-TEMP-SPEC %s
 
 // CHECK: v17@0:8{vector<float, float, float>=}16
 // CHECK: {vector<float, float, float>=}
 // CHECK: v24@0:816
 
 template <typename T1, typename T2, typename T3> struct vector {
   vector();
   vector(T1,T2,T3);
namespace PR48048 {
   struct I {
     int m;
     [[no_unique_address]] F n;
   };
   // CHECKCXX20: @_ZN7PR480481xE ={{.*}} constant [6 x i8] c"{I=i}\00"
   extern const char x[] = @encode(I);
 }
 #endif
+
+namespace test_cxx_template_specialization {
+template <class T>
+struct B0 {
+  T a;
+};
+struct D0 : B0<int> {};
+struct D1 : D0 {};
+struct D2 : virtual B0<int> {};
+struct S0 {
+  B0<int> a;
+};
+struct S1 {
+  B0<int> *a;
+};
+struct S2 {
+  S1 *a;
+};
+template <class T>
+union U0 {
+  T a;
+};
+typedef B0<int> TD0;
+typedef B0<int> *Array0[4];
+
+template <class T>
+struct Outer0 {
+  struct Inner0 {
+    int a;
+  };
+  template <class T1>
+  struct Inner1 {
+    T a;
+    T1 b;
+  };
+};
+
+// CHECK: @[[STR22:.*]] = {{.*}} [12 x i8] c"{B0<int>=i}\00"
+// CHECK: @_ZN32test_cxx_template_specialization2b0E = {{.*}} ([12 x i8], [12 x i8]* @[[STR22]], i32 0, i32 0)
+// CHECK-NO-TEMP-SPEC: @[[STR23:.*]] = {{.*}} [3 x i8] c"^v\00"
+// CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization3b01E = {{.*}} ([3 x i8], [3 x i8]* @[[STR23]], i32 0, i32 0)
+// CHECK-TEMP-SPEC: @[[STR23:.*]] = {{.*}} [13 x i8] c"^{B0<int>=i}\00"
+// CHECK-TEMP-SPEC: @_ZN32test_cxx_template_specialization3b01E = {{.*}} ([13 x i8], [13 x i8]* @[[STR23]], i32 0, i32 0)
+// CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization3b02E = {{.*}} ([3 x i8], [3 x i8]* @[[STR23]], i32 0, i32 0)
+// CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization2d0E = {{.*}} ([3 x i8], [3 x i8]* @[[STR23]], i32 0, i32 0)
+// CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization2d1E = {{.*}} ([3 x i8], [3 x i8]* @[[STR23]], i32 0, i32 0)
+// CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization2d2E = {{.*}} ([3 x i8], [3 x i8]* @[[STR23]], i32 0, i32 0)
+// CHECK: @[[STR24:.*]] = {{.*}} [7 x i8] c"^^{D2}\00"
+// CHECK: @_ZN32test_cxx_template_specialization3d21E = {{.*}} ([7 x i8], [7 x i8]* @[[STR24]], i32 0, i32 0)
+// CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization2s0E = {{.*}} ([3 x i8], [3 x i8]* @[[STR23]], i32 0, i32 0)
+// CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization2s1E = {{.*}} ([3 x i8], [3 x i8]* @[[STR23]], i32 0, i32 0)
+// CHECK: @[[STR25:.*]] = {{.*}} [12 x i8] c"^{S2=^{S1}}\00"
+// CHECK: @_ZN32test_cxx_template_specialization2s2E = {{.*}} ([12 x i8], [12 x i8]* @[[STR25]], i32 0, i32 0)
+// CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization2u0E = {{.*}} ([3 x i8], [3 x i8]* @[[STR23]], i32 0, i32 0)
+// CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization3td0E = {{.*}} ([3 x i8], [3 x i8]* @[[STR23]], i32 0, i32 0)
+// CHECK-NO-TEMP-SPEC: @[[STR26:.*]] = {{.*}} [6 x i8] c"[4^v]\00"
+// CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization2a0E = {{.*}} ([6 x i8], [6 x i8]* @[[STR26]], i32 0, i32 0)
+// CHECK: @[[STR27:.*]] = {{.*}} [11 x i8] c"^{Inner0=}\00"
+// CHECK: @_ZN32test_cxx_template_specialization6inner0E = {{.*}} ([11 x i8], [11 x i8]* @[[STR27]], i32 0, i32 0)
+// CHECK-NO-TEMP-SPEC: @_ZN32test_cxx_template_specialization6inner1E = {{.*}} ([3 x i8], [3 x i8]* @.str.23, i32 0, i32 0)
+// CHECK-TEMP-SPEC: @[[STR34:.*]] = {{.*}} [18 x i8] c"^{Inner1<float>=}\00"
+// CHECK-TEMP-SPEC: @_ZN32test_cxx_template_specialization6inner1E = {{.*}} ([18 x i8], [18 x i8]* @[[STR34]], i32 0, i32 0)
+
+const char *b0 = @encode(B0<int>);
+const char *b01 = @encode(B0<int> *);
+const char *b02 = @encode(B0<int> &);
+const char *d0 = @encode(D0 *);
+const char *d1 = @encode(D1 *);
+const char *d2 = @encode(D2 *);
+const char *d21 = @encode(D2 **);
+const char *s0 = @encode(S0 *);
+const char *s1 = @encode(S1 *);
+const char *s2 = @encode(S2 *);
+const char *u0 = @encode(U0<int> *);
+const char *td0 = @encode(TD0 *);
+const char *a0 = @encode(Array0);
+const char *inner0 = @encode(Outer0<int>::Inner0 *);
+const char *inner1 = @encode(Outer0<int>::Inner1<float> *);
+}

clang/test/Driver/objc-encode-cxx-class-template-spec.m

+// RUN: %clang -target arm64-apple-ios11 -### %s -o - 2>&1 | FileCheck -check-prefix=DISABLE-ENC %s
+// RUN: %clang -target arm64-apple-ios11 -fobjc-encode-cxx-class-template-spec -### %s -o - 2>&1 | FileCheck -check-prefix=ENABLE-ENC %s
+// RUN: %clang -target x86_64-linux-gnu -fobjc-runtime=gnustep -### %s -o - 2>&1 | FileCheck -check-prefix=ENABLE-ENC %s
+// RUN: %clang -target x86_64-linux-gnu -fobjc-runtime=gnustep -fno-objc-encode-cxx-class-template-spec -### %s -o - 2>&1 |  FileCheck -check-prefix=DISABLE-ENC %s
+
+// DISABLE-ENC-NOT: -fobjc-encode-cxx-class-template-spec
+// ENABLE-ENC: -fobjc-encode-cxx-class-template-spec