Check for completeness of the SwiftOnoneSupport library

When compiling SwiftOnoneSupport, issue errors for missing functions which are expected in the module.
This ensures ABI compatibility.

rdar://problem/48924409

Author: eeckstein

include/swift/AST/DiagnosticsSIL.def

@@ -251,8 +251,13 @@ ERROR(circular_transparent,none,
       "inlining 'transparent' functions forms circular loop", ())
 NOTE(note_while_inlining,none,
      "while inlining here", ())
+
+// Pre-specializations
 ERROR(cannot_prespecialize,none,
       "Cannot pre-specialize %0", (StringRef))
+ERROR(missing_prespecialization,none,
+      "Pre-specialized function %0 missing in SwiftOnoneSupport module",
+      (StringRef))
 
 // Arithmetic diagnostics.
 ERROR(integer_conversion_overflow,none,

include/swift/Frontend/FrontendOptions.h

@@ -158,6 +158,10 @@ class FrontendOptions {
   /// module appears to not be a public module.
   Optional<bool> SerializeOptionsForDebugging;
 
+  /// When true, check if all required SwiftOnoneSupport symbols are present in
+  /// the module.
+  bool CheckOnoneSupportCompleteness = false;
+
   /// If set, inserts instrumentation useful for testing the debugger.
   bool DebuggerTestingTransform = false;
 

include/swift/Option/FrontendOptions.td

@@ -416,6 +416,9 @@ def import_module : Separate<["-"], "import-module">,
 def print_stats : Flag<["-"], "print-stats">,
   HelpText<"Print various statistics">;
 
+def check_onone_completeness : Flag<["-"], "check-onone-completeness">,
+  HelpText<"Print errors if the compile OnoneSupport module is missing symbols">;
+
 def debugger_testing_transform : Flag<["-"], "debugger-testing-transform">,
   HelpText<"Instrument the code with calls to an intrinsic that record the expected values of "
            "local variables so they can be compared against the results from the debugger.">;

include/swift/SILOptimizer/Utils/Generics.h

@@ -319,6 +319,12 @@ class GenericFuncSpecializer {
 /// prespecialization for -Onone support.
 bool isKnownPrespecialization(StringRef SpecName);
 
+/// Checks if all OnoneSupport pre-specializations are included in the module
+/// as public functions.
+///
+/// Issues errors for all missing functions.
+void checkCompletenessOfPrespecializations(SILModule &M);
+
 /// Create a new apply based on an old one, but with a different
 /// function being applied.
 ApplySite replaceWithSpecializedFunction(ApplySite AI, SILFunction *NewF,

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -96,6 +96,8 @@ bool ArgsToFrontendOptionsConverter::convert(
   setUnsignedIntegerArgument(OPT_switch_checking_invocation_threshold_EQ, 10,
                              Opts.SwitchCheckingInvocationThreshold);
 
+  Opts.CheckOnoneSupportCompleteness = Args.hasArg(OPT_check_onone_completeness);
+
   Opts.DebuggerTestingTransform = Args.hasArg(OPT_debugger_testing_transform);
 
   computePlaygroundOptions();

lib/Frontend/Frontend.cpp

@@ -29,6 +29,7 @@
 #include "swift/Parse/Lexer.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
+#include "swift/SILOptimizer/Utils/Generics.h"
 #include "swift/Serialization/SerializationOptions.h"
 #include "swift/Serialization/SerializedModuleLoader.h"
 #include "swift/Strings.h"
@@ -1110,6 +1111,11 @@ static void performSILOptimizations(CompilerInvocation &Invocation,
   } else {
     runSILOptimizationPasses(*SM);
   }
+  if (Invocation.getFrontendOptions().CheckOnoneSupportCompleteness &&
+      // TODO: handle non-ObjC based stdlib builds, e.g. on linux.
+      Invocation.getLangOptions().EnableObjCInterop) {
+    checkCompletenessOfPrespecializations(*SM);
+  }
 }
 
 static void countStatsPostSILOpt(UnifiedStatsReporter &Stats,

lib/SILOptimizer/Utils/Generics.cpp

@@ -2590,6 +2590,20 @@ bool swift::isKnownPrespecialization(StringRef SpecName) {
   return PrespecSet.count(SpecName) != 0;
 }
 
+void swift::checkCompletenessOfPrespecializations(SILModule &M) {
+  const char **Pos = &PrespecSymbols[0];
+  while (const char *Sym = *Pos++) {
+    StringRef FunctionName(Sym);
+    SILFunction *F = M.lookUpFunction(FunctionName);
+    if (!F || F->getLinkage() != SILLinkage::Public) {
+      M.getASTContext().Diags.diagnose(SourceLoc(),
+                                       diag::missing_prespecialization,
+                                       FunctionName);
+    }
+  }
+
+}
+
 /// Try to look up an existing specialization in the specialization cache.
 /// If it is found, it tries to link this specialization.
 ///

stdlib/public/SwiftOnoneSupport/CMakeLists.txt

@@ -6,7 +6,7 @@ add_swift_target_library(swiftSwiftOnoneSupport ${SWIFT_STDLIB_LIBRARY_BUILD_TYP
   # _explicitly_ special-cased to result in extra symbols generated by the
   # optimizer, meaning TBDGen can't (and shouldn't: it has to run
   # pre-optimization for performance) list them.
-  SWIFT_COMPILE_FLAGS "-parse-stdlib" "-Xllvm" "-sil-inline-generics=false" "-Xfrontend" "-validate-tbd-against-ir=none" "${SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS}"
+  SWIFT_COMPILE_FLAGS "-parse-stdlib" "-Xllvm" "-sil-inline-generics=false" "-Xfrontend" "-validate-tbd-against-ir=none" "-Xfrontend" "-check-onone-completeness" "${SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS}"
   LINK_FLAGS "${SWIFT_RUNTIME_SWIFT_LINK_FLAGS}"
   INSTALL_IN_COMPONENT stdlib)
 if(WINDOWS IN_LIST SWIFT_SDKS)