Rename duplicated swift::fatalError definition in swiftRuntime and swift_Concurrency

Both swiftRuntime and swift_Concurrency had swift::fatalError
implementation, but it causes symbol conflict when -static-stdlib.

This patch renames one of the impl in swift_Concurrency to avoid
conflict.

(cherry picked from commit 709359c)
(cherry picked from commit 9abe6a2)

Author: kateinoigakukun

stdlib/public/Concurrency/CMakeLists.txt

@@ -47,6 +47,7 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
   CheckedContinuation.swift
   GlobalExecutor.cpp
   Errors.swift
+  Error.cpp
   Executor.swift
   AsyncCompactMapSequence.swift
   AsyncDropFirstSequence.swift

stdlib/public/Concurrency/Error.cpp

@@ -0,0 +1,19 @@
+//===--- Error.cpp - Error handling support code --------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Error.h"
+
+// swift::fatalError is not exported from libswiftCore and not shared, so define another
+// internal function instead.
+SWIFT_NORETURN void swift::swift_Concurrency_fatalError(uint32_t flags, const char *format, ...) {
+  abort();
+}

stdlib/public/Concurrency/Error.h

@@ -0,0 +1,30 @@
+//===--- Error.h - Swift Concurrency error helpers --------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Error handling support.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_CONCURRENCY_ERRORS_H
+#define SWIFT_CONCURRENCY_ERRORS_H
+
+#include "../SwiftShims/Visibility.h"
+#include <cstdint>
+#include <stdlib.h>
+
+namespace swift {
+
+SWIFT_NORETURN void swift_Concurrency_fatalError(uint32_t flags, const char *format, ...);
+
+} // namespace swift
+
+#endif

stdlib/public/Concurrency/GlobalExecutor.cpp

@@ -57,6 +57,7 @@
 #include "swift/Runtime/Concurrency.h"
 #include "swift/Runtime/EnvironmentVariables.h"
 #include "TaskPrivate.h"
+#include "Error.h"
 
 #include <dispatch/dispatch.h>
 
@@ -267,7 +268,7 @@ static std::atomic<dispatch_queue_t> globalQueueCache[globalQueueCacheCount];
 static dispatch_queue_t getGlobalQueue(JobPriority priority) {
   size_t numericPriority = static_cast<size_t>(priority);
   if (numericPriority >= globalQueueCacheCount)
-    fatalError(0, "invalid job priority %#zx");
+    swift_Concurrency_fatalError(0, "invalid job priority %#zx");
 
   auto *ptr = &globalQueueCache[numericPriority];
   auto queue = ptr->load(std::memory_order_relaxed);

stdlib/public/Concurrency/Mutex.cpp

@@ -10,12 +10,12 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "Error.h"
+
+#define SWIFT_FATAL_ERROR swift_Concurrency_fatalError
+
 // Include the runtime's mutex support code.
 // FIXME: figure out some reasonable way to share this stuff
 
 #include "../runtime/MutexPThread.cpp"
 #include "../runtime/MutexWin32.cpp"
-
-SWIFT_NORETURN void swift::fatalError(uint32_t flags, const char *format, ...) {
-  abort();
-}

stdlib/public/Concurrency/Task.cpp

@@ -26,6 +26,7 @@
 #include "TaskPrivate.h"
 #include "AsyncCall.h"
 #include "Debug.h"
+#include "Error.h"
 
 #include <dispatch/dispatch.h>
 
@@ -786,7 +787,7 @@ static void swift_task_future_waitImpl(
   }
 
   case FutureFragment::Status::Error:
-    fatalError(0, "future reported an error, but wait cannot throw");
+    swift_Concurrency_fatalError(0, "future reported an error, but wait cannot throw");
   }
 }
 

stdlib/public/Concurrency/TaskAlloc.cpp

@@ -20,7 +20,6 @@
 #include "swift/Runtime/Concurrency.h"
 #include "swift/ABI/Task.h"
 #include "TaskPrivate.h"
-
 #include <stdlib.h>
 
 using namespace swift;

stdlib/public/Concurrency/TaskPrivate.h

@@ -25,6 +25,9 @@
 #include "swift/Runtime/Exclusivity.h"
 #include "swift/Runtime/HeapObject.h"
 
+#include "Error.h"
+
+#define SWIFT_FATAL_ERROR swift_Concurrency_fatalError
 #include "../runtime/StackAllocator.h"
 
 #if HAVE_PTHREAD_H

stdlib/public/runtime/MutexPThread.cpp

@@ -20,6 +20,13 @@
 #endif
 
 #if defined(_POSIX_THREADS) && !defined(SWIFT_STDLIB_SINGLE_THREADED_RUNTIME)
+
+// Notes: swift::fatalError is not shared between libswiftCore and libswift_Concurrency
+// and libswift_Concurrency uses swift_Concurrency_fatalError instead.
+#ifndef SWIFT_FATAL_ERROR
+#define SWIFT_FATAL_ERROR swift::fatalError
+#endif
+
 #include "swift/Runtime/Mutex.h"
 
 #include "swift/Runtime/Debug.h"
@@ -32,8 +39,8 @@ using namespace swift;
   do {                                                                         \
     int errorcode = PThreadFunction;                                           \
     if (errorcode != 0) {                                                      \
-      fatalError(/* flags = */ 0, "'%s' failed with error '%s'(%d)\n",         \
-                 #PThreadFunction, errorName(errorcode), errorcode);           \
+      SWIFT_FATAL_ERROR(/* flags = */ 0, "'%s' failed with error '%s'(%d)\n",  \
+                        #PThreadFunction, errorName(errorcode), errorcode);    \
     }                                                                          \
   } while (false)
 
@@ -44,8 +51,8 @@ using namespace swift;
       return true;                                                             \
     if (returnFalseOnEBUSY && errorcode == EBUSY)                              \
       return false;                                                            \
-    fatalError(/* flags = */ 0, "'%s' failed with error '%s'(%d)\n",           \
-               #PThreadFunction, errorName(errorcode), errorcode);             \
+    SWIFT_FATAL_ERROR(/* flags = */ 0, "'%s' failed with error '%s'(%d)\n",    \
+                      #PThreadFunction, errorName(errorcode), errorcode);      \
   } while (false)
 
 static const char *errorName(int errorcode) {

stdlib/public/runtime/MutexWin32.cpp

@@ -16,6 +16,13 @@
 //===----------------------------------------------------------------------===//
 
 #if defined(_WIN32)
+
+// Notes: swift::fatalError is not shared between libswiftCore and libswift_Concurrency
+// and libswift_Concurrency uses swift_Concurrency_fatalError instead.
+#ifndef SWIFT_FATAL_ERROR
+#define SWIFT_FATAL_ERROR swift::fatalError
+#endif
+
 #include "swift/Runtime/Mutex.h"
 #include "swift/Runtime/Debug.h"
 
@@ -26,9 +33,9 @@ void ConditionPlatformHelper::wait(CONDITION_VARIABLE &condition,
   BOOL result = SleepConditionVariableSRW(&condition, &mutex, INFINITE, 0);
   if (!result) {
     DWORD errorcode = GetLastError();
-    fatalError(/* flags = */ 0,
-               "'SleepConditionVariableSRW()' failed with error code %d\n",
-               errorcode);
+    SWIFT_FATAL_ERROR(/* flags = */ 0,
+                      "'SleepConditionVariableSRW()' failed with error code %d\n",
+                      errorcode);
   }
 }
 #endif