stdlib/msvc: Runtime with MSVC library

This patch is for libswiftCore.lib, linking with the library set of Visual Studio 2015. Clang with the option -fms-extension is used to build.

Author: tinysun212

include/swift/Runtime/HeapObject.h

@@ -106,8 +106,8 @@ struct TwoWordPair {
   // in registers, so cram the result into an unsigned long long.
   // Use an enum class with implicit conversions so we don't dirty C callers
   // too much.
-#if __arm__ || __i386__ || defined(__CYGWIN__)
-#if defined(__CYGWIN__)
+#if __arm__ || __i386__ || defined(__CYGWIN__) || defined(_MSC_VER)
+#if defined(__CYGWIN__) || defined(_MSC_VER)
   enum class Return : unsigned __int128 {};
 #else
   enum class Return : unsigned long long {};

include/swift/Runtime/Mutex.h

@@ -22,6 +22,8 @@
 
 #if (defined(__APPLE__) || defined(__linux__) || defined(__CYGWIN__) || defined(__FreeBSD__))
 #include "swift/Runtime/MutexPThread.h"
+#elif defined(_MSC_VER)
+#include "swift/Runtime/MutexWin32.h"
 #else
 #error "Implement equivalent of MutexPThread.h/cpp for your platform."
 #endif

include/swift/Runtime/MutexWin32.h

@@ -0,0 +1,95 @@
+//===--- MutexWin32.h - ---------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Mutex, ConditionVariable, Read/Write lock, and Scoped lock implementations
+// using Windows Slim Reader/Writer Locks and Conditional Variables.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_RUNTIME_MUTEX_WIN32_H
+#define SWIFT_RUNTIME_MUTEX_WIN32_H
+
+#include <windows.h>
+
+namespace swift {
+
+typedef CONDITION_VARIABLE ConditionHandle;
+typedef SRWLOCK MutexHandle;
+typedef SRWLOCK ReadWriteLockHandle;
+
+#define CONDITION_SUPPORTS_CONSTEXPR 1
+#define MUTEX_SUPPORTS_CONSTEXPR 1
+#define READWRITELOCK_SUPPORTS_CONSTEXPR 1
+
+struct ConditionPlatformHelper {
+  static constexpr ConditionHandle staticInit() {
+    return CONDITION_VARIABLE_INIT;
+  };
+  static void init(ConditionHandle &condition) {
+    InitializeConditionVariable(&condition);
+  }
+  static void destroy(ConditionHandle &condition) {}
+  static void notifyOne(ConditionHandle &condition) {
+    WakeConditionVariable(&condition);
+  }
+  static void notifyAll(ConditionHandle &condition) {
+    WakeAllConditionVariable(&condition);
+  }
+  static void wait(ConditionHandle &condition, MutexHandle &mutex);
+};
+
+struct MutexPlatformHelper {
+  static constexpr MutexHandle staticInit() { return SRWLOCK_INIT; }
+  static void init(MutexHandle &mutex, bool checked = false) {
+    InitializeSRWLock(&mutex);
+  }
+  static void destroy(MutexHandle &mutex) {}
+  static void lock(MutexHandle &mutex) { AcquireSRWLockExclusive(&mutex); }
+  static void unlock(MutexHandle &mutex) { ReleaseSRWLockExclusive(&mutex); }
+  static bool try_lock(MutexHandle &mutex) {
+    return TryAcquireSRWLockExclusive(&mutex) != 0;
+  }
+  // The unsafe versions don't do error checking.
+  static void unsafeLock(MutexHandle &mutex) {
+    AcquireSRWLockExclusive(&mutex);
+  }
+  static void unsafeUnlock(MutexHandle &mutex) {
+    ReleaseSRWLockExclusive(&mutex);
+  }
+};
+
+struct ReadWriteLockPlatformHelper {
+  static constexpr ReadWriteLockHandle staticInit() { return SRWLOCK_INIT; }
+  static void init(ReadWriteLockHandle &rwlock) { InitializeSRWLock(&rwlock); }
+  static void destroy(ReadWriteLockHandle &rwlock) {}
+  static void readLock(ReadWriteLockHandle &rwlock) {
+    AcquireSRWLockShared(&rwlock);
+  }
+  static bool try_readLock(ReadWriteLockHandle &rwlock) {
+    return TryAcquireSRWLockShared(&rwlock) != 0;
+  }
+  static void readUnlock(ReadWriteLockHandle &rwlock) {
+    ReleaseSRWLockShared(&rwlock);
+  }
+  static void writeLock(ReadWriteLockHandle &rwlock) {
+    AcquireSRWLockExclusive(&rwlock);
+  }
+  static bool try_writeLock(ReadWriteLockHandle &rwlock) {
+    return TryAcquireSRWLockExclusive(&rwlock) != 0;
+  }
+  static void writeUnlock(ReadWriteLockHandle &rwlock) {
+    ReleaseSRWLockExclusive(&rwlock);
+  }
+};
+}
+
+#endif

stdlib/public/SwiftShims/LibcShims.h

@@ -31,6 +31,8 @@ namespace swift { extern "C" {
 // the current platform in the runtime code.
 #if defined(__linux__) && defined (__arm__) && !defined(__android__)
 typedef      int __swift_ssize_t;
+#elif defined(_MSC_VER)
+typedef long long __swift_ssize_t;
 #else
 typedef long int __swift_ssize_t;
 #endif

stdlib/public/runtime/CMakeLists.txt

@@ -18,9 +18,17 @@ if(SWIFT_RUNTIME_ENABLE_LEAK_CHECKER)
 endif()
 
 set(swift_runtime_port_sources)
-if("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN")
+if("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
   set(swift_runtime_port_sources
+      MutexWin32.cpp
       CygwinPort.cpp)
+elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN")
+  set(swift_runtime_port_sources
+      MutexPThread.cpp
+      CygwinPort.cpp)
+else()
+  set(swift_runtime_port_sources
+      MutexPThread.cpp)
 endif()
 
 list(APPEND swift_runtime_compile_flags
@@ -48,7 +56,6 @@ set(swift_runtime_sources
     KnownMetadata.cpp
     Metadata.cpp
     MetadataLookup.cpp
-    MutexPThread.cpp
     Once.cpp
     Portability.cpp
     ProtocolConformance.cpp
@@ -60,6 +67,8 @@ set(swift_runtime_sources
 set(LLVM_OPTIONAL_SOURCES
     Remangle.cpp
     swift_sections.S
+    MutexPThread.cpp
+    MutexWin32.cpp
     CygwinPort.cpp
     ${swift_runtime_sources}
     ${swift_runtime_objc_sources}

stdlib/public/runtime/CygwinPort.cpp

@@ -133,7 +133,7 @@ uint8_t *swift::_swift_getSectionDataPE(void *handle, const char *sectionName,
 
   return nullptr;
 }
-
+#if !defined(_MSC_VER)
 void swift::_swift_once_f(uintptr_t *predicate, void *context,
                           void (*function)(void *)) {
   // FIXME: This implementation does a global lock, which is much worse than
@@ -148,3 +148,4 @@ void swift::_swift_once_f(uintptr_t *predicate, void *context,
   } else
     swiftOnceMutex.unlock();
 }
+#endif

stdlib/public/runtime/Errors.cpp

@@ -18,18 +18,24 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
+#if defined(_MSC_VER)
+#include <io.h>
+#else
 #include <unistd.h>
+#endif
+#if !defined(_MSC_VER)
 #include <pthread.h>
+#endif
 #include <stdarg.h>
 #include "swift/Runtime/Debug.h"
 #include "swift/Runtime/Mutex.h"
 #include "swift/Basic/Demangle.h"
 #include "swift/Basic/LLVM.h"
 #include "llvm/ADT/StringRef.h"
-
+#if !defined(_MSC_VER)
 #include <cxxabi.h>
-
-#if !defined(__CYGWIN__) && !defined(__ANDROID__)
+#endif
+#if !defined(__CYGWIN__) && !defined(__ANDROID__) && !defined(_MSC_VER)
 
 // execinfo.h is not available on Android. Checks in this file ensure that
 // fatalError behaves as expected, but without stack traces.
@@ -51,7 +57,7 @@ enum: uint32_t {
 
 using namespace swift;
 
-#if !defined(__CYGWIN__) && !defined(__ANDROID__)
+#if !defined(__CYGWIN__) && !defined(__ANDROID__) && !defined(_MSC_VER)
 
 static bool getSymbolNameAddr(llvm::StringRef libraryName, Dl_info dlinfo,
                               std::string &symbolName, uintptr_t &addrOut) {
@@ -188,11 +194,16 @@ reportOnCrash(uint32_t flags, const char *message)
 static void
 reportNow(uint32_t flags, const char *message)
 {
+#if defined(_MSC_VER)
+#define STDERR_FILENO 2
+  _write(STDERR_FILENO, message, strlen(message));
+#else
   write(STDERR_FILENO, message, strlen(message));
+#endif
 #ifdef __APPLE__
   asl_log(NULL, NULL, ASL_LEVEL_ERR, "%s", message);
 #endif
-#if !defined(__CYGWIN__) && !defined(__ANDROID__)
+#if !defined(__CYGWIN__) && !defined(__ANDROID__) && !defined(_MSC_VER)
   if (flags & FatalErrorFlags::ReportBacktrace) {
     fputs("Current stack trace:\n", stderr);
     constexpr unsigned maxSupportedStackDepth = 128;
@@ -223,7 +234,13 @@ swift::fatalError(uint32_t flags, const char *format, ...)
   va_start(args, format);
 
   char *log;
+#if defined(_MSC_VER)
+  int len = _vscprintf(format, args) + 1;
+  log = reinterpret_cast<char *>(malloc(len));
+  vsprintf(log, format, args);
+#else
   vasprintf(&log, format, args);
+#endif
 
   swift_reportError(flags, log);
   abort();

stdlib/public/runtime/HeapObject.cpp

@@ -28,7 +28,9 @@
 #include <cstring>
 #include <cstdio>
 #include <cstdlib>
+#if !defined(_MSC_VER)
 #include <unistd.h>
+#endif
 #include "../SwiftShims/RuntimeShims.h"
 #if SWIFT_OBJC_INTEROP
 # include <objc/NSObject.h>

stdlib/public/runtime/Metadata.cpp

@@ -28,8 +28,14 @@
 #include <condition_variable>
 #include <new>
 #include <cctype>
+#if defined(_MSC_VER)
+// Avoid defining macro max(), min() which conflict with std::max(), std::min()
+#define NOMINMAX
+#include <windows.h>
+#else
 #include <sys/mman.h>
 #include <unistd.h>
+#endif
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Hashing.h"
 #include "ErrorObject.h"
@@ -56,19 +62,45 @@
 using namespace swift;
 using namespace metadataimpl;
 
+// allocate memory up to a nearby page boundary
+static void *swift_allocPage(size_t size) {
+#if defined(_MSC_VER)
+  auto mem = VirtualAlloc(
+      nullptr, size, MEM_TOP_DOWN | MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+#else
+  auto mem = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE,
+                  VM_TAG_FOR_SWIFT_METADATA, 0);
+  if (mem == MAP_FAILED)
+    mem = nullptr;
+#endif
+  return mem;
+}
+
+// free memory allocated by swift_allocPage()
+// On success, swift_freePage() returns 0, on failure -1
+static int swift_freePage(void *addr, size_t size) {
+#if defined(_MSC_VER)
+  return VirtualFree(addr, 0, MEM_RELEASE) == 0 ? -1 : 0;
+#else
+  return munmap(addr, size);
+#endif
+}
+
 void *MetadataAllocator::alloc(size_t size) {
 #if defined(__APPLE__)
   const uintptr_t PageSizeMask = vm_page_mask;
+#elif defined(_MSC_VER)
+  SYSTEM_INFO SystemInfo;
+  GetSystemInfo(&SystemInfo);
+  const uintptr_t PageSizeMask = SystemInfo.dwPageSize - 1;
 #else
   static const uintptr_t PageSizeMask = sysconf(_SC_PAGESIZE) - 1;
 #endif
   // If the requested size is a page or larger, map page(s) for it
   // specifically.
   if (LLVM_UNLIKELY(size > PageSizeMask)) {
-    auto mem = mmap(nullptr, (size + PageSizeMask) & ~PageSizeMask,
-                    PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,
-                    VM_TAG_FOR_SWIFT_METADATA, 0);
-    if (mem == MAP_FAILED)
+    void *mem = swift_allocPage((size + PageSizeMask) & ~PageSizeMask);
+    if (!mem)
       crash("unable to allocate memory for metadata cache");
     return mem;
   }
@@ -83,13 +115,9 @@ void *MetadataAllocator::alloc(size_t size) {
     if (LLVM_UNLIKELY(((uintptr_t)next & ~PageSizeMask)
                         != (((uintptr_t)end & ~PageSizeMask)))) {
       // Allocate a new page if we haven't already.
-      allocation = mmap(nullptr, PageSizeMask + 1,
-                        PROT_READ|PROT_WRITE,
-                        MAP_ANON|MAP_PRIVATE,
-                        VM_TAG_FOR_SWIFT_METADATA,
-                        /*offset*/ 0);
+      allocation = swift_allocPage(PageSizeMask + 1);
 
-      if (allocation == MAP_FAILED)
+      if (!allocation)
         crash("unable to allocate memory for metadata cache");
 
       next = (char*) allocation;
@@ -107,7 +135,7 @@ void *MetadataAllocator::alloc(size_t size) {
     // This potentially causes us to perform multiple mmaps under contention,
     // but it keeps the fast path pristine.
     if (allocation) {
-      munmap(allocation, PageSizeMask + 1);
+      swift_freePage(allocation, PageSizeMask + 1);
     }
   }
 }

stdlib/public/runtime/MetadataLookup.cpp

@@ -34,7 +34,11 @@
 #include <link.h>
 #endif
 
+#if defined(_MSC_VER)
+#include <windows.h>
+#else
 #include <dlfcn.h>
+#endif
 
 using namespace swift;
 using namespace Demangle;
@@ -49,7 +53,7 @@ using namespace Demangle;
 #define SWIFT_TYPE_METADATA_SECTION "__swift2_types"
 #elif defined(__ELF__)
 #define SWIFT_TYPE_METADATA_SECTION ".swift2_type_metadata_start"
-#elif defined(__CYGWIN__)
+#elif defined(__CYGWIN__) || defined(_MSC_VER)
 #define SWIFT_TYPE_METADATA_SECTION ".sw2tymd"
 #endif
 

stdlib/public/runtime/MutexWin32.cpp

@@ -0,0 +1,32 @@
+//===--- MutexWin32.cpp - -------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Mutex, ConditionVariable, Read/Write lock, and Scoped lock implementations
+// using Windows Slim Reader/Writer Locks and Conditional Variables.
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/Runtime/Mutex.h"
+#include "swift/Runtime/Debug.h"
+
+using namespace swift;
+
+void ConditionPlatformHelper::wait(CONDITION_VARIABLE &condition,
+                                   SRWLOCK &mutex) {
+  BOOL result = SleepConditionVariableSRW(&condition, &mutex, INFINITE, 0);
+  if (result == FALSE) {
+    DWORD errorcode = GetLastError();
+    fatalError(/* flags = */ 0,
+               "'SleepConditionVariableSRW()' failed with error code %d\n",
+               errorcode);
+  }
+}