FreeBSD compatibility patch

cmake/modules/FindICU.cmake

@@ -17,7 +17,7 @@ foreach(MODULE ${ICU_FIND_COMPONENTS})
 
     find_path(ICU_${MODULE}_INCLUDE_DIR unicode
       HINTS ${PC_ICU_${MODULE}_INCLUDEDIR} ${PC_ICU_${MODULE}_INCLUDE_DIRS})
-    set(ICU_${MODULE}_INCLUDE_DIR ${ICU_${MODULE}_INCLUDE_DIR})
+    set(ICU_${MODULE}_INCLUDE_DIRS ${ICU_${MODULE}_INCLUDE_DIR})
 
     find_library(ICU_${MODULE}_LIBRARY NAMES icu${module}
       HINTS ${PC_ICU_${MODULE}_LIBDIR} ${PC_ICU_${MODULE}_LIBRARY_DIRS})

stdlib/private/SwiftPrivatePthreadExtras/PthreadBarriers.swift

@@ -43,8 +43,13 @@ public var _stdlib_PTHREAD_BARRIER_SERIAL_THREAD: CInt {
 }
 
 public struct _stdlib_pthread_barrier_t {
+#if CYGWIN || os(FreeBSD)
+  var mutex: UnsafeMutablePointer<pthread_mutex_t?>?
+  var cond: UnsafeMutablePointer<pthread_cond_t?>?
+#else
   var mutex: UnsafeMutablePointer<pthread_mutex_t>?
   var cond: UnsafeMutablePointer<pthread_cond_t>?
+#endif
 
   /// The number of threads to synchronize.
   var count: CUnsignedInt = 0

stdlib/private/SwiftPrivatePthreadExtras/SwiftPrivatePthreadExtras.swift

@@ -59,9 +59,15 @@ internal func invokeBlockContext(
   return context.run()
 }
 
+#if CYGWIN || os(FreeBSD)
+public typealias _stdlib_pthread_attr_t = UnsafePointer<pthread_attr_t?>
+#else
+public typealias _stdlib_pthread_attr_t = UnsafePointer<pthread_attr_t>
+#endif
+
 /// Block-based wrapper for `pthread_create`.
 public func _stdlib_pthread_create_block<Argument, Result>(
-  _ attr: UnsafePointer<pthread_attr_t>?,
+  _ attr: _stdlib_pthread_attr_t?,
   _ start_routine: @escaping (Argument) -> Result,
   _ arg: Argument
 ) -> (CInt, pthread_t?) {

stdlib/public/Platform/glibc.modulemap.gyb

@@ -26,7 +26,9 @@ module SwiftGlibc [system] {
   link "util"
 % end
 
+% if CMAKE_SDK != "FREEBSD":
   link "dl"
+% end
 
   // C standard library
   module C {
@@ -35,6 +37,8 @@ module SwiftGlibc [system] {
       header "${GLIBC_INCLUDE_PATH}/complex.h"
       export *
     }
+% end
+% if CMAKE_SDK in ["LINUX", "CYGWIN"]:
     module pty {
       header "${GLIBC_INCLUDE_PATH}/pty.h"
       export *
@@ -44,6 +48,16 @@ module SwiftGlibc [system] {
       export *
     }
 % end
+% if CMAKE_SDK == "FREEBSD":
+    module pty {
+      header "${GLIBC_INCLUDE_PATH}/libutil.h"
+      export *
+    }
+    module utmp {
+      header "${GLIBC_INCLUDE_PATH}/utmpx.h"
+      export *
+    }
+% end
 
 % if CMAKE_SDK in ["LINUX", "ANDROID", "CYGWIN"]:
     module features {
@@ -355,10 +369,12 @@ module SwiftGlibc [system] {
         header "${GLIBC_ARCH_INCLUDE_PATH}/sys/select.h"
         export *
       }
+% if CMAKE_SDK != "FREEBSD":
       module sendfile {
         header "${GLIBC_ARCH_INCLUDE_PATH}/sys/sendfile.h"
         export *
       }
+% end
       module socket {
         header "${GLIBC_ARCH_INCLUDE_PATH}/sys/socket.h"
         export *
@@ -379,6 +395,12 @@ module SwiftGlibc [system] {
         header "${GLIBC_ARCH_INCLUDE_PATH}/sys/types.h"
         export *
       }
+% if CMAKE_SDK in ["FREEBSD"]:
+      module event {
+        header "${GLIBC_ARCH_INCLUDE_PATH}/sys/event.h"
+        export *
+      }
+% end
       module uio {
         header "${GLIBC_ARCH_INCLUDE_PATH}/sys/uio.h"
         export *

stdlib/public/stubs/CMakeLists.txt

@@ -18,6 +18,18 @@ set(LLVM_OPTIONAL_SOURCES
     ${swift_stubs_objc_sources}
     ${swift_stubs_unicode_normalization_sources})
 
+# ICU isn't required on Darwin, but is on every other platform.
+# Now in case we're cross-compiling from Darwin for another platform,
+# the find_package should still be executed.
+if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+  set(icu_required "")
+else()
+  set(icu_required "REQUIRED")
+endif()
+
+find_package(ICU ${icu_required} COMPONENTS uc)
+set(ICU_UC_LIBRARY "")
+
 set(swift_stubs_c_compile_flags ${SWIFT_RUNTIME_CORE_CXX_FLAGS})
 list(APPEND swift_stubs_c_compile_flags -DswiftCore_EXPORTS)
 

stdlib/public/stubs/CommandLine.cpp

@@ -57,7 +57,7 @@ extern "C" char ** _swift_stdlib_getUnsafeArgvArgc(int *outArgLen) {
   *outArgLen = *_NSGetArgc();
   return *_NSGetArgv();
 }
-#elif defined(__linux__) || defined(__CYGWIN__) || defined(__FreeBSD__)
+#elif defined(__linux__) || defined(__CYGWIN__)
 SWIFT_RUNTIME_STDLIB_INTERFACE
 extern "C" char ** _swift_stdlib_getUnsafeArgvArgc(int *outArgLen) {
   assert(outArgLen != nullptr);
@@ -104,6 +104,57 @@ extern "C" char ** _swift_stdlib_getUnsafeArgvArgc(int *outArgLen) {
   *outArgLen = __argc;
   return __argv;
 }
+#elif defined(__FreeBSD__)
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/sysctl.h>
+
+SWIFT_RUNTIME_STDLIB_INTERFACE
+extern "C" char ** _swift_stdlib_getUnsafeArgvArgc(int *outArgLen) {
+  assert(outArgLen != nullptr);
+
+  if (_swift_stdlib_ProcessOverrideUnsafeArgv) {
+    *outArgLen = _swift_stdlib_ProcessOverrideUnsafeArgc;
+    return _swift_stdlib_ProcessOverrideUnsafeArgv;
+  }
+
+  char *argPtr = NULL; // or use ARG_MAX? 8192 is used in LLDB though..
+  int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_ARGS, getpid() };
+  size_t argPtrSize = 0;
+  for (int i = 0; i < 3 && !argPtr; i++) { // give up after 3 tries
+    if (sysctl(mib, 4, NULL, &argPtrSize, NULL, 0) != -1) {
+      argPtr = (char *)malloc(argPtrSize);
+      if (sysctl(mib, 4, argPtr, &argPtrSize, NULL, 0) == -1) {
+        free(argPtr);
+        argPtr = NULL;
+        if (errno != ENOMEM)
+          break;
+      }
+    } else {
+      break;
+    }
+  }
+  if (!argPtr)
+    swift::fatalError(0, "fatal error: could not retrieve commandline "
+                         "arguments: sysctl: %s.\n", strerror(errno));
+
+  char *curPtr = argPtr;
+  char *endPtr = argPtr + argPtrSize;
+
+  std::vector<char *> argvec;
+  for (; curPtr < endPtr; curPtr += strlen(curPtr) + 1)
+    argvec.push_back(strdup(curPtr));
+  *outArgLen = argvec.size();
+  char **outBuf = (char **)calloc(argvec.size() + 1, sizeof(char *));
+  std::copy(argvec.begin(), argvec.end(), outBuf);
+  outBuf[argvec.size()] = nullptr;
+
+  free(argPtr);
+
+  return outBuf;
+}
 #else // __ANDROID__; Add your favorite arch's command line arg grabber here.
 SWIFT_RUNTIME_STDLIB_INTERFACE
 extern "C" char ** _swift_stdlib_getUnsafeArgvArgc(int *outArgLen) {

tools/swift-demangle/swift-demangle.cpp

@@ -14,6 +14,10 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if defined(__FreeBSD__)
+#define _WITH_GETLINE
+#endif
+
 #include "swift/Basic/DemangleWrappers.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/CommandLine.h"

utils/build-script-impl

@@ -409,6 +409,7 @@ function set_build_options_for_host() {
             SWIFT_HOST_VARIANT="freebsd"
             SWIFT_HOST_VARIANT_SDK="FREEBSD"
             SWIFT_HOST_VARIANT_ARCH="x86_64"
+            USE_GOLD_LINKER=1
             ;;
         cygwin-x86_64)
             SWIFT_HOST_VARIANT="windows"