[Concurrency] [shims] Don't declare exit in the concurrency shims

Don't delete the OS declaration of `exit` because the concurrency shims aren't always imported, and so the shim declaration might not always be available.
Don't override the OS declaration of `exit` in the concurrency shims since we can't just delete the OS one. Instead, set up internal shims just for building Concurrency that forward declares `exit`.

Author: ian-twilightcoder

CHANGELOG.md

@@ -59,6 +59,12 @@
   Having been [gated](https://github.com/apple/swift/pull/28171) behind a
   compiler warning since at least Swift 5.2, this syntax is now rejected.
 
+* [bugfix][]:
+
+  \_SwiftConcurrencyShims used to declare the `exit` function, even though it
+  might not be available. The declaration has been removed, and must be imported
+  from the appropriate C library module (e.g. Darwin or SwiftGlibc)
+
 ## Swift 5.10
 
 * Swift 5.10 closes all known static data-race safey holes in complete strict

lib/ClangImporter/ImportDecl.cpp

@@ -3388,26 +3388,24 @@ namespace {
                     ->getTopLevelModule()
                     ->getFullModuleName() == n;
         };
-        if ((decl->getOwningModule() &&
-             importer::isCxxStdModule(decl->getOwningModule()))) {
+        
+        if (clang::Module *owningModule = decl->getOwningModule();
+            owningModule && importer::isCxxStdModule(owningModule)) {
           if (isAlternativeCStdlibFunctionFromTextualHeader(decl)) {
             return nullptr;
           }
-          auto filename =
-              Impl.getClangPreprocessor().getSourceManager().getFilename(
-                  decl->getLocation());
-          if (filename.endswith("cmath") || filename.endswith("math.h") ||
-              filename.endswith("stdlib.h") || filename.endswith("cstdlib")) {
-            return nullptr;
+
+          auto &sourceManager = Impl.getClangPreprocessor().getSourceManager();
+          if (const auto file = sourceManager.getFileEntryForID(
+                  sourceManager.getFileID(decl->getLocation()))) {
+            auto filename = file->getName();
+            if ((file->getDir() == owningModule->Directory) &&
+                (filename.endswith("cmath") || filename.endswith("math.h") ||
+                 filename.endswith("stdlib.h") || filename.endswith("cstdlib"))) {
+              return nullptr;
+            }
           }
         }
-        // Use the exit function from _SwiftConcurrency.h as it is platform
-        // agnostic.
-        if ((topLevelModuleEq(decl, "Darwin") ||
-             topLevelModuleEq(decl, "SwiftGlibc")) &&
-            decl->getDeclName().isIdentifier() && decl->getName() == "exit") {
-          return nullptr;
-        }
       }
 
       auto dc =

lib/SILGen/SILGen.cpp

@@ -450,16 +450,51 @@ FuncDecl *SILGenModule::getSwiftJobRun() {
 
 FuncDecl *SILGenModule::getExit() {
   ASTContext &C = getASTContext();
-  ModuleDecl *concurrencyShims =
-      C.getModuleByIdentifier(C.getIdentifier("_SwiftConcurrencyShims"));
 
-  if (!concurrencyShims)
-    return nullptr;
+  // Try the most likely modules.
+  Identifier mostLikelyIdentifier;
+  const llvm::Triple &triple = C.LangOpts.Target;
+  if (triple.isOSDarwin()) {
+    mostLikelyIdentifier = C.getIdentifier("Darwin");
+  } else if (triple.isOSWASI()) {
+    mostLikelyIdentifier = C.getIdentifier("SwiftWASILibc");
+  } else if (triple.isWindowsMSVCEnvironment()) {
+    mostLikelyIdentifier = C.getIdentifier("ucrt");
+  } else {
+    mostLikelyIdentifier = C.getIdentifier("SwiftGlibc");
+  }
+  ModuleDecl *exitModule = C.getModuleByIdentifier(mostLikelyIdentifier);
+  FuncDecl *exitFunction = nullptr;
+  if (exitModule) {
+    exitFunction = evaluateOrDefault(
+        C.evaluator,
+        LookupIntrinsicRequest{exitModule, C.getIdentifier("exit")},
+        /*default=*/nullptr);
+  }
+
+  if (!exitFunction) {
+    // No go, look for it in any loaded module. Several of the internal
+    // Swift modules or swift-corelibs modules may have absorbed <stdlib.h>
+    // when buliding without fully specified clang modules in the OS/SDK.
+    for (const auto &loadedModuleVector : C.getLoadedModules()) {
+      if (loadedModuleVector.first == mostLikelyIdentifier) {
+        continue;
+      }
 
-  return evaluateOrDefault(
-      C.evaluator,
-      LookupIntrinsicRequest{concurrencyShims, C.getIdentifier("exit")},
-      /*default=*/nullptr);
+      ModuleDecl *loadedModule = loadedModuleVector.second;
+      if (loadedModule) {
+        exitFunction = evaluateOrDefault(
+            C.evaluator,
+            LookupIntrinsicRequest{loadedModule, C.getIdentifier("exit")},
+            /*default=*/nullptr);
+      }
+      if (exitFunction) {
+        break;
+      }
+    }
+  }
+
+  return exitFunction;
 }
 
 ProtocolConformance *SILGenModule::getNSErrorConformanceToError() {

lib/SILGen/SILGenTopLevel.cpp

@@ -214,7 +214,23 @@ void SILGenFunction::emitCallToMain(FuncDecl *mainFunc) {
     B.createReturn(loc, exitCode);
   } else {
     FuncDecl *exitFuncDecl = SGM.getExit();
-    assert(exitFuncDecl && "Failed to find exit function declaration");
+    if (!exitFuncDecl) {
+      // If it doesn't exist, we can conjure one up instead of crashing
+      // @_extern(c)
+      // func exit(_: Int32) -> Never
+      ASTContext &ctx = getASTContext();
+      ModuleDecl *moduleDecl = mainFunc->getModuleContext();
+      ParameterList *params =
+          ParameterList::createWithoutLoc(ParamDecl::createImplicit(
+              ctx, Identifier(), Identifier(), ctx.getInt32Type(), moduleDecl));
+      exitFuncDecl = FuncDecl::createImplicit(
+          ctx, StaticSpellingKind::None,
+          DeclName(ctx, DeclBaseName(ctx.getIdentifier("exit")), params), {},
+          /*async*/ false, /*throws*/ false, /*thrownType*/ Type(), {}, params,
+          ctx.getNeverType(), moduleDecl);
+      exitFuncDecl->getAttrs().add(new (ctx) ExternAttr(
+          llvm::None, llvm::None, ExternKind::C, /*implicit*/ true));
+    }
     SILFunction *exitSILFunc = SGM.getFunction(
         SILDeclRef(exitFuncDecl, SILDeclRef::Kind::Func, /*isForeign*/ true),
         NotForDefinition);

stdlib/public/Concurrency/CMakeLists.txt

@@ -11,7 +11,7 @@
 #===----------------------------------------------------------------------===#
 
 set(SWIFT_RUNTIME_CONCURRENCY_C_FLAGS)
-set(SWIFT_RUNTIME_CONCURRENCY_SWIFT_FLAGS)
+set(SWIFT_RUNTIME_CONCURRENCY_SWIFT_FLAGS -I${CMAKE_CURRENT_SOURCE_DIR}/InternalShims)
 
 set(swift_concurrency_private_link_libraries)
 if(CMAKE_SYSTEM_NAME STREQUAL "Windows")

stdlib/public/Concurrency/InternalShims/module.modulemap

@@ -0,0 +1,6 @@
+module SwiftConcurrencyInternalShims {
+  module stdlib {
+    header "stdlib_shims.h"
+    export *
+  }
+}

stdlib/public/Concurrency/InternalShims/stdlib_shims.h

@@ -0,0 +1,27 @@
+//===--- stdlib_shims.h - Swift Concurrency Support -----------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  Forward declarations of <stdlib.h> interfaces so that Swift Concurrency
+//  doesn't depend on the C library.
+//
+//===----------------------------------------------------------------------===//
+#ifndef STDLIB_SHIMS_H
+#define STDLIB_SHIMS_H
+
+#ifdef __cplusplus
+extern "C" [[noreturn]]
+#endif
+void exit(int);
+
+#define EXIT_SUCCESS 0
+
+#endif // STDLIB_SHIMS_H

stdlib/public/Concurrency/Task.swift

@@ -12,6 +12,7 @@
 
 import Swift
 @_implementationOnly import _SwiftConcurrencyShims
+@_implementationOnly import SwiftConcurrencyInternalShims
 
 // ==== Task -------------------------------------------------------------------
 

stdlib/public/SwiftShims/swift/shims/_SwiftConcurrency.h

@@ -30,11 +30,4 @@ typedef struct _SwiftContext {
 } // namespace swift
 #endif
 
-#ifdef __cplusplus
-extern "C" [[noreturn]]
-#endif
-void exit(int);
-
-#define EXIT_SUCCESS 0
-
 #endif // SWIFT_CONCURRENCY_H

test/Backtracing/DwarfReader.swift

@@ -7,6 +7,15 @@
 // REQUIRES: backtracing
 
 @_spi(DwarfTest) import _Backtracing
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(SwiftWASILibc)
+import SwiftWASILibc
+#elseif canImport(ucrt)
+import ucrt
+#elseif canImport(SwiftGlibc)
+import SwiftGlibc
+#endif
 
 @main
 struct DwarfReader {