Hide more symbols

Apparently `-fvisibility=hidden` is not sufficient to hide some of the
symbols in this library. I've explicitly marked the symbols that were
flagged as being incorrectly exported as "hidden" so hopefully no one
drags them out again.

This is a statically linked library, so the symbols shouldn't need to be
exported for this work work. To ensure that this is the case and that
we're still hitting the overridden API with all of the hidden symbols, I
added a debug log line to the fixed `AsyncTask::waitFuture`
implementation and have verified that we see the compat56 log message
emitted from executables that need the compat56 library.

Author: etcwilde

stdlib/toolchain/Compatibility56/CMakeLists.txt

@@ -2,6 +2,10 @@ set(library_name "swiftCompatibility56")
 
 include_directories("include/" "${SWIFT_STDLIB_SOURCE_DIR}")
 
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN YES)
+
 add_compile_definitions(SWIFT_COMPATIBILITY56)
 add_swift_target_library("${library_name}" STATIC
   Overrides.cpp

stdlib/toolchain/Compatibility56/Concurrency/Task.cpp

@@ -15,6 +15,7 @@ FutureFragment::Status AsyncTask::waitFuture(AsyncTask *waitingTask,
                                              TaskContinuationFunction *resumeFn,
                                              AsyncContext *callerContext,
                                              OpaqueValue *result) {
+  SWIFT_TASK_DEBUG_LOG("compat 56 task task %p", this);
   using Status = FutureFragment::Status;
   using WaitQueueItem = FutureFragment::WaitQueueItem;
 

stdlib/toolchain/Compatibility56/Overrides.cpp

@@ -39,13 +39,15 @@ struct ConcurrencyOverrideSection {
 
 #undef OVERRIDE
 
+__attribute__((visibility("hidden")))
 ConcurrencyOverrideSection Swift56ConcurrencyOverrides
 __attribute__((used, section("__DATA,__s_async_hook"))) = {
   .version = 0,
   .task_future_wait = swift56override_swift_task_future_wait,
   .task_future_wait_throwing = swift56override_swift_task_future_wait_throwing,
 };
 
+__attribute__((visibility("hidden")))
 RuntimeOverrideSection Swift56RuntimeOverrides
 __attribute__((used, section("__DATA,__swift56_hooks"))) = {
   .version = 0,

stdlib/toolchain/Compatibility56/include/Concurrency/Error.h

@@ -23,6 +23,7 @@
 
 namespace swift {
 
+__attribute__((visibility("hidden")))
 SWIFT_NORETURN void swift_Concurrency_fatalError(uint32_t flags, const char *format, ...);
 
 } // namespace swift

stdlib/toolchain/Compatibility56/include/Concurrency/Task.h

@@ -307,7 +307,9 @@ class AsyncTask : public Job {
   ///
   /// Generally this should be done immediately after updating
   /// ActiveTask.
+  __attribute__((visibility("hidden")))
   void flagAsRunning();
+  __attribute__((visibility("hidden")))
   void flagAsRunning_slow();
 
   /// Flag that this task is now suspended.  This can update the
@@ -316,26 +318,33 @@ class AsyncTask : public Job {
   /// clearing ActiveTask and immediately before enqueuing the task
   /// somewhere.  TODO: record where the task is enqueued if
   /// possible.
+  __attribute__((visibility("hidden")))
   void flagAsSuspended();
+  __attribute__((visibility("hidden")))
   void flagAsSuspended_slow();
 
   /// Flag that this task is now completed. This normally does not do anything
   /// but can be used to locally insert logging.
+  __attribute__((visibility("hidden")))
   void flagAsCompleted();
 
   /// Check whether this task has been cancelled.
   /// Checking this is, of course, inherently race-prone on its own.
+  __attribute__((visibility("hidden")))
   bool isCancelled() const;
 
   // ==== Task Local Values ----------------------------------------------------
 
+  __attribute__((visibility("hidden")))
   void localValuePush(const HeapObject *key,
                       /* +1 */ OpaqueValue *value,
                       const Metadata *valueType);
 
+  __attribute__((visibility("hidden")))
   OpaqueValue *localValueGet(const HeapObject *key);
 
   /// Returns true if storage has still more bindings.
+  __attribute__((visibility("hidden")))
   bool localValuePop();
 
   // ==== Child Fragment -------------------------------------------------------
@@ -563,6 +572,7 @@ class AsyncTask : public Job {
   /// the future has completed and can be queried.
   /// The waiting task's async context will be intialized with the parameters if
   /// the current's task state is executing.
+  __attribute__((visibility("hidden")))
   FutureFragment::Status waitFuture(AsyncTask *waitingTask,
                                     AsyncContext *waitingTaskContext,
                                     TaskContinuationFunction *resumeFn,

stdlib/toolchain/Compatibility56/include/Concurrency/TaskPrivate.h

@@ -106,18 +106,23 @@ class TaskFutureWaitAsyncContext : public AsyncContext {
 
 /// Adopt the voucher stored in `task`. This removes the voucher from the task
 /// and adopts it on the current thread.
+__attribute__((visibility("hidden")))
 void adoptTaskVoucher(AsyncTask *task);
 
 /// Restore the voucher for `task`. This un-adopts the current thread's voucher
 /// and stores it back into the task again.
+__attribute__((visibility("hidden")))
 void restoreTaskVoucher(AsyncTask *task);
 
 /// release() establishes a happens-before relation with a preceding acquire()
 /// on the same address.
+__attribute__((visibility("hidden")))
 void _swift_tsan_acquire(void *addr);
+__attribute__((visibility("hidden")))
 void _swift_tsan_release(void *addr);
 
 /// Clear the active task reference for the current thread.
+__attribute__((visibility("hidden")))
 AsyncTask *_swift_task_clearCurrent();
 
 /// The current state of a task's status records.

stdlib/toolchain/Compatibility56/include/Concurrency/TaskStatus.h

@@ -159,6 +159,7 @@ class CancellationNotificationStatusRecord : public TaskStatusRecord {
 };
 
 /// Return the current thread's active task reference.
+__attribute__((visibility("hidden")))
 SWIFT_CC(swift)
 AsyncTask *swift_task_getCurrent(void);
 } // namespace swift

stdlib/toolchain/Compatibility56/include/Concurrency/Threading/MutexPThread.h

@@ -56,6 +56,7 @@ typedef pthread_mutex_t MutexHandle;
 ///
 /// See ConditionVariable
 struct ConditionPlatformHelper {
+  __attribute__((visibility("hidden")))
 #if SWIFT_CONDITION_SUPPORTS_CONSTEXPR
   static constexpr
 #else
@@ -65,10 +66,15 @@ struct ConditionPlatformHelper {
       staticInit() {
     return PTHREAD_COND_INITIALIZER;
   };
+  __attribute__((visibility("hidden")))
   static void init(ConditionHandle &condition);
+  __attribute__((visibility("hidden")))
   static void destroy(ConditionHandle &condition);
+  __attribute__((visibility("hidden")))
   static void notifyOne(ConditionHandle &condition);
+  __attribute__((visibility("hidden")))
   static void notifyAll(ConditionHandle &condition);
+  __attribute__((visibility("hidden")))
   static void wait(ConditionHandle &condition, ConditionMutexHandle &mutex);
 };
 
@@ -77,6 +83,7 @@ struct ConditionPlatformHelper {
 ///
 /// See Mutex
 struct MutexPlatformHelper {
+  __attribute__((visibility("hidden")))
 #if SWIFT_MUTEX_SUPPORTS_CONSTEXPR
   static constexpr
 #else
@@ -86,6 +93,7 @@ struct MutexPlatformHelper {
       conditionStaticInit() {
     return PTHREAD_MUTEX_INITIALIZER;
   };
+  __attribute__((visibility("hidden")))
 #if SWIFT_MUTEX_SUPPORTS_CONSTEXPR
   static constexpr
 #else
@@ -99,30 +107,46 @@ struct MutexPlatformHelper {
     return PTHREAD_MUTEX_INITIALIZER;
 #endif  
   }
+
+  __attribute__((visibility("hidden")))
   static void init(ConditionMutexHandle &mutex, bool checked = false);
+
+  __attribute__((visibility("hidden")))
   static void destroy(ConditionMutexHandle &mutex);
+  __attribute__((visibility("hidden")))
   static void lock(ConditionMutexHandle &mutex);
+  __attribute__((visibility("hidden")))
   static void unlock(ConditionMutexHandle &mutex);
+  __attribute__((visibility("hidden")))
   static bool try_lock(ConditionMutexHandle &mutex);
 
   // The ConditionMutexHandle versions handle everything on-Apple platforms.
 #if HAS_OS_UNFAIR_LOCK
 
+  __attribute__((visibility("hidden")))
   static void init(MutexHandle &mutex, bool checked = false);
+  __attribute__((visibility("hidden")))
   static void destroy(MutexHandle &mutex);
+  __attribute__((visibility("hidden")))
   static void lock(MutexHandle &mutex);
+  __attribute__((visibility("hidden")))
   static void unlock(MutexHandle &mutex);
+  __attribute__((visibility("hidden")))
   static bool try_lock(MutexHandle &mutex);
 
   // os_unfair_lock always checks for errors, so just call through.
+  __attribute__((visibility("hidden")))
   static void unsafeLock(MutexHandle &mutex) { lock(mutex); }
+  __attribute__((visibility("hidden")))
   static void unsafeUnlock(MutexHandle &mutex) { unlock(mutex); }
 #endif
 
   // The unsafe versions don't do error checking.
+  __attribute__((visibility("hidden")))
   static void unsafeLock(ConditionMutexHandle &mutex) {
     (void)pthread_mutex_lock(&mutex);
   }
+  __attribute__((visibility("hidden")))
   static void unsafeUnlock(ConditionMutexHandle &mutex) {
     (void)pthread_mutex_unlock(&mutex);
   }
@@ -133,6 +157,8 @@ struct MutexPlatformHelper {
 ///
 /// See ReadWriteLock
 struct ReadWriteLockPlatformHelper {
+
+  __attribute__((visibility("hidden")))
 #if SWIFT_READWRITELOCK_SUPPORTS_CONSTEXPR
   static constexpr
 #else
@@ -143,13 +169,21 @@ struct ReadWriteLockPlatformHelper {
     return PTHREAD_RWLOCK_INITIALIZER;
   };
 
+  __attribute__((visibility("hidden")))
   static void init(ReadWriteLockHandle &rwlock);
+  __attribute__((visibility("hidden")))
   static void destroy(ReadWriteLockHandle &rwlock);
+  __attribute__((visibility("hidden")))
   static void readLock(ReadWriteLockHandle &rwlock);
+  __attribute__((visibility("hidden")))
   static bool try_readLock(ReadWriteLockHandle &rwlock);
+  __attribute__((visibility("hidden")))
   static void readUnlock(ReadWriteLockHandle &rwlock);
+  __attribute__((visibility("hidden")))
   static void writeLock(ReadWriteLockHandle &rwlock);
+  __attribute__((visibility("hidden")))
   static bool try_writeLock(ReadWriteLockHandle &rwlock);
+  __attribute__((visibility("hidden")))
   static void writeUnlock(ReadWriteLockHandle &rwlock);
 };
 }

stdlib/toolchain/Compatibility56/include/Runtime/Concurrency.h

@@ -82,6 +82,7 @@ using FutureAsyncSignature =
 /// This has no effect if the task already has at least the given priority.
 /// Returns the priority of the task.
 SWIFT_CC(swift)
+__attribute__((visibility("hidden")))
 JobPriority swift_task_escalateBackdeploy56(AsyncTask *task,
                                             JobPriority newPriority);
 } // namespace swift