Add ASTMangler.AllowStandardSubstitutions to allow using a stripped-down libswiftCore (#40009)

Author: kubamracek

include/swift/AST/ASTMangler.h

@@ -56,6 +56,10 @@ class ASTMangler : public Mangler {
   /// to fill these in.
   bool AllowSymbolicReferences = false;
 
+  /// If enabled, allows the use of standard substitutions for types in the
+  /// standard library.
+  bool AllowStandardSubstitutions = true;
+
   /// If enabled, allows the use of standard substitutions for types in the
   /// concurrency library.
   bool AllowConcurrencyStandardSubstitutions = true;

include/swift/AST/IRGenOptions.h

@@ -356,6 +356,10 @@ class IRGenOptions {
   /// Whether to disable using mangled names for accessing concrete type metadata.
   unsigned DisableConcreteTypeMetadataMangledNameAccessors : 1;
 
+  /// Whether to disable referencing stdlib symbols via mangled names in
+  /// reflection mangling.
+  unsigned DisableStandardSubstitutionsInReflectionMangling : 1;
+
   unsigned EnableGlobalISel : 1;
 
   unsigned VirtualFunctionElimination : 1;
@@ -425,6 +429,7 @@ class IRGenOptions {
         GenerateProfile(false), EnableDynamicReplacementChaining(false),
         DisableRoundTripDebugTypes(false), DisableDebuggerShadowCopies(false),
         DisableConcreteTypeMetadataMangledNameAccessors(false),
+        DisableStandardSubstitutionsInReflectionMangling(false),
         EnableGlobalISel(false), VirtualFunctionElimination(false),
         WitnessMethodElimination(false), ConditionalRuntimeRecords(false),
         InternalizeAtLink(false),

include/swift/Option/FrontendOptions.td

@@ -634,6 +634,10 @@ def disable_debugger_shadow_copies : Flag<["-"], "disable-debugger-shadow-copies
 def disable_concrete_type_metadata_mangled_name_accessors : Flag<["-"], "disable-concrete-type-metadata-mangled-name-accessors">,
   HelpText<"Disable concrete type metadata access by mangled name">,
   Flags<[FrontendOption, HelpHidden]>;
+
+def disable_standard_substitutions_in_reflection_mangling : Flag<["-"], "disable-standard-substitutions-in-reflection-mangling">,
+  HelpText<"Disable referencing stdlib symbols via mangled names in reflection mangling">,
+  Flags<[FrontendOption, HelpHidden]>;
 
 def playground : Flag<["-"], "playground">,
   HelpText<"Apply the playground semantics and transformation">;

lib/AST/ASTMangler.cpp

@@ -3023,6 +3023,9 @@ bool ASTMangler::tryAppendStandardSubstitution(const GenericTypeDecl *decl) {
       !dc->getParentModule()->hasStandardSubstitutions())
     return false;
 
+  if (!AllowStandardSubstitutions)
+    return false;
+
   if (isa<NominalTypeDecl>(decl)) {
     if (auto Subst = getStandardTypeSubst(
             decl->getName().str(), AllowConcurrencyStandardSubstitutions)) {

lib/Frontend/CompilerInvocation.cpp

@@ -1760,6 +1760,9 @@ static bool ParseIRGenArgs(IRGenOptions &Opts, ArgList &Args,
   if (Args.hasArg(OPT_disable_concrete_type_metadata_mangled_name_accessors))
     Opts.DisableConcreteTypeMetadataMangledNameAccessors = true;
 
+  if (Args.hasArg(OPT_disable_standard_substitutions_in_reflection_mangling))
+    Opts.DisableStandardSubstitutionsInReflectionMangling = true;
+
   if (Args.hasArg(OPT_use_jit)) {
     Opts.UseJIT = true;
     if (const Arg *A = Args.getLastArg(OPT_dump_jit)) {
@@ -1995,32 +1998,14 @@ static bool ParseIRGenArgs(IRGenOptions &Opts, ArgList &Args,
 
   if (Args.hasArg(OPT_enable_llvm_vfe)) {
     Opts.VirtualFunctionElimination = true;
-
-    // FIXME(mracek): There are still some situations where we use mangled name
-    // without symbolic references, which means the dependency is not statically
-    // visible to the compiler/linker. Temporarily disable mangled accessors
-    // until we fix that.
-    Opts.DisableConcreteTypeMetadataMangledNameAccessors = true;
   }
 
   if (Args.hasArg(OPT_enable_llvm_wme)) {
     Opts.WitnessMethodElimination = true;
-
-    // FIXME(mracek): There are still some situations where we use mangled name
-    // without symbolic references, which means the dependency is not statically
-    // visible to the compiler/linker. Temporarily disable mangled accessors
-    // until we fix that.
-    Opts.DisableConcreteTypeMetadataMangledNameAccessors = true;
   }
 
   if (Args.hasArg(OPT_conditional_runtime_records)) {
     Opts.ConditionalRuntimeRecords = true;
-
-    // FIXME(mracek): There are still some situations where we use mangled name
-    // without symbolic references, which means the dependency is not statically
-    // visible to the compiler/linker. Temporarily disable mangled accessors
-    // until we fix that.
-    Opts.DisableConcreteTypeMetadataMangledNameAccessors = true;
   }
 
   if (Args.hasArg(OPT_internalize_at_link)) {

lib/IRGen/IRGenMangler.cpp

@@ -98,7 +98,8 @@ IRGenMangler::withSymbolicReferences(IRGenModule &IGM,
       // The short-substitution types in the standard library have compact
       // manglings already, and the runtime ought to have a lookup table for
       // them. Symbolic referencing would be wasteful.
-      if (type->getModuleContext()->hasStandardSubstitutions()
+      if (AllowStandardSubstitutions
+          && type->getModuleContext()->hasStandardSubstitutions()
           && Mangle::getStandardTypeSubst(
                type->getName().str(), AllowConcurrencyStandardSubstitutions)) {
         return false;
@@ -159,6 +160,11 @@ IRGenMangler::mangleTypeForReflection(IRGenModule &IGM,
       AllowConcurrencyStandardSubstitutions = false;
   }
 
+  llvm::SaveAndRestore<bool> savedAllowStandardSubstitutions(
+      AllowStandardSubstitutions);
+  if (IGM.getOptions().DisableStandardSubstitutionsInReflectionMangling)
+    AllowStandardSubstitutions = false;
+
   llvm::SaveAndRestore<bool> savedAllowMarkerProtocols(
       AllowMarkerProtocols, false);
   return withSymbolicReferences(IGM, [&]{

stdlib/cmake/modules/SwiftSource.cmake

@@ -494,6 +494,10 @@ function(_compile_swift_files
     list(APPEND swift_flags "-Xfrontend" "-disable-autolinking-runtime-compatibility-concurrency")
   endif()
 
+  if(NOT SWIFT_STDLIB_SHORT_MANGLING_LOOKUPS)
+    list(APPEND swift_flags "-Xfrontend" "-disable-standard-substitutions-in-reflection-mangling")
+  endif()
+
   if (SWIFTFILE_IS_STDLIB_CORE OR SWIFTFILE_IS_SDK_OVERLAY)
     list(APPEND swift_flags "-warn-swift3-objc-inference-complete")
   endif()

test/lit.cfg

@@ -950,6 +950,10 @@ if run_vendor == 'apple':
         swift_execution_tests_extra_flags += \
                 ' -Xfrontend -disable-implicit-concurrency-module-import'
 
+        # To have visible references from symbolic manglings
+        swift_execution_tests_extra_flags += \
+                ' -Xfrontend -disable-standard-substitutions-in-reflection-mangling'
+
         # Link all "freestanding" tests with -dead_strip, which can effectively
         # even remove parts of the stdlib and runtime, if it's not needed. Since
         # it's a very desired behavior, let's enable it for all executable tests.