Commit ea90a3a9a1

@@ -224,7 +224,7 @@ limitations in handling dllimport attribute.  */
 
 #ifndef __MSVCRT_VERSION__
 /*  High byte is the major version, low byte is the minor. */
-# define __MSVCRT_VERSION__ 0x1400
+# define __MSVCRT_VERSION__ 0x700
 #endif
 
 

@@ -0,0 +1,7 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+int _newmode = 0;

@@ -0,0 +1,22 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#include <crtdefs.h>
+#include <sect_attribs.h>
+#include <corecrt_startup.h>
+
+__declspec(dllimport) int __lconv_init (void);
+
+int mingw_initcharmax = 0;
+
+int _charmax = 255;
+
+static int my_lconv_init(void)
+{
+  return __lconv_init();
+}
+
+_CRTALLOC(".CRT$XIC") _PIFV __mingw_pinit = my_lconv_init;

@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <sect_attribs.h>
+
+#ifdef _MSC_VER
+#pragma comment(linker, "/merge:.CRT=.rdata")
+#endif
+
+typedef void (__cdecl *_PVFV)(void);
+
+_CRTALLOC(".CRT$XIA") _PVFV __xi_a[] = { NULL };
+_CRTALLOC(".CRT$XIZ") _PVFV __xi_z[] = { NULL };
+_CRTALLOC(".CRT$XCA") _PVFV __xc_a[] = { NULL };
+_CRTALLOC(".CRT$XCZ") _PVFV __xc_z[] = { NULL };

@@ -0,0 +1,20 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#include <windows.h>
+
+extern HINSTANCE __mingw_winmain_hInstance;
+extern LPSTR __mingw_winmain_lpCmdLine;
+extern DWORD __mingw_winmain_nShowCmd;
+
+/*ARGSUSED*/
+int main (int     __UNUSED_PARAM(flags),
+	  char ** __UNUSED_PARAM(cmdline),
+	  char ** __UNUSED_PARAM(inst))
+{
+  return (int) WinMain (__mingw_winmain_hInstance, NULL,
+			__mingw_winmain_lpCmdLine, __mingw_winmain_nShowCmd);
+}

@@ -0,0 +1,25 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+#include <windows.h>
+
+/* Do the UNICODE prototyping of WinMain.  Be aware that in winbase.h WinMain is a macro
+   defined to wWinMain.  */
+int WINAPI wWinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPWSTR lpCmdLine,int nShowCmd);
+
+extern HINSTANCE __mingw_winmain_hInstance;
+extern LPWSTR __mingw_winmain_lpCmdLine;
+extern DWORD __mingw_winmain_nShowCmd;
+
+int wmain (int, wchar_t **, wchar_t **);
+
+/*ARGSUSED*/
+int wmain (int        __UNUSED_PARAM(flags),
+	   wchar_t ** __UNUSED_PARAM(cmdline),
+	   wchar_t ** __UNUSED_PARAM(inst))
+{
+  return (int) wWinMain (__mingw_winmain_hInstance, NULL,
+			__mingw_winmain_lpCmdLine, __mingw_winmain_nShowCmd);
+}

@@ -0,0 +1,32 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+void _fpreset (void);
+
+void _fpreset (void)
+{
+#if defined(_ARM_) || defined(__arm__)
+  __asm__ __volatile__ (
+    "vmsr	fpscr, %0\n\t" : : "r"(0 /* INITIAL_FPSCR */));
+#elif defined(_ARM64_) || defined(__aarch64__)
+  __asm__ __volatile__ (
+    "msr	fpcr, %0\n\t" : : "r"(0LL /* INITIAL_FPSCR */));
+#else
+#ifdef __GNUC__
+  __asm__ ("fninit");
+#else /* msvc: */
+  __asm fninit;
+#endif
+#endif
+}
+
+#ifdef __GNUC__
+void __attribute__ ((alias ("_fpreset"))) fpreset(void);
+#else
+void fpreset(void) {
+    _fpreset();
+}
+#endif

@@ -0,0 +1,290 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#include <windows.h>
+#include <excpt.h>
+#include <string.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <memory.h>
+#include <signal.h>
+#include <stdio.h>
+
+#if defined (_WIN64) && defined (__ia64__)
+#error FIXME: Unsupported __ImageBase implementation.
+#else
+#ifndef _MSC_VER
+#define __ImageBase __MINGW_LSYMBOL(_image_base__)
+#endif
+/* This symbol is defined by the linker.  */
+extern IMAGE_DOS_HEADER __ImageBase;
+#endif
+
+#pragma pack(push,1)
+typedef struct _UNWIND_INFO {
+  BYTE VersionAndFlags;
+  BYTE PrologSize;
+  BYTE CountOfUnwindCodes;
+  BYTE FrameRegisterAndOffset;
+  ULONG AddressOfExceptionHandler;
+} UNWIND_INFO,*PUNWIND_INFO;
+#pragma pack(pop)
+
+PIMAGE_SECTION_HEADER _FindPESectionByName (const char *);
+PIMAGE_SECTION_HEADER _FindPESectionExec (size_t);
+PBYTE _GetPEImageBase (void);
+
+int __mingw_init_ehandler (void);
+extern void _fpreset (void);
+
+#if defined(__x86_64__) && !defined(_MSC_VER)
+EXCEPTION_DISPOSITION __mingw_SEH_error_handler(struct _EXCEPTION_RECORD *, void *, struct _CONTEXT *, void *);
+
+#define MAX_PDATA_ENTRIES 32
+static RUNTIME_FUNCTION emu_pdata[MAX_PDATA_ENTRIES];
+static UNWIND_INFO emu_xdata[MAX_PDATA_ENTRIES];
+
+int
+__mingw_init_ehandler (void)
+{
+  static int was_here = 0;
+  size_t e = 0;
+  PIMAGE_SECTION_HEADER pSec;
+  PBYTE _ImageBase = _GetPEImageBase ();
+  
+  if (was_here || !_ImageBase)
+    return was_here;
+  was_here = 1;
+  if (_FindPESectionByName (".pdata") != NULL)
+    return 1;
+
+  /* Allocate # of e tables and entries.  */
+  memset (emu_pdata, 0, sizeof (RUNTIME_FUNCTION) * MAX_PDATA_ENTRIES);
+  memset (emu_xdata, 0, sizeof (UNWIND_INFO) * MAX_PDATA_ENTRIES);
+    
+  e = 0;
+  /* Fill tables and entries.  */
+  while (e < MAX_PDATA_ENTRIES && (pSec = _FindPESectionExec (e)) != NULL)
+    {
+      emu_xdata[e].VersionAndFlags = 9; /* UNW_FLAG_EHANDLER | UNW_VERSION */
+      emu_xdata[e].AddressOfExceptionHandler =
+	(DWORD)(size_t) ((LPBYTE)__mingw_SEH_error_handler - _ImageBase);
+      emu_pdata[e].BeginAddress = pSec->VirtualAddress;
+      emu_pdata[e].EndAddress = pSec->VirtualAddress + pSec->Misc.VirtualSize;
+      emu_pdata[e].UnwindData =
+	(DWORD)(size_t)((LPBYTE)&emu_xdata[e] - _ImageBase);
+      ++e;
+    }
+#ifdef _DEBUG_CRT
+  if (!e || e > MAX_PDATA_ENTRIES)
+    abort ();
+#endif
+  /* RtlAddFunctionTable.  */
+  if (e != 0)
+    RtlAddFunctionTable (emu_pdata, e, (DWORD64)_ImageBase);
+  return 1;
+}
+
+extern void _fpreset (void);
+
+EXCEPTION_DISPOSITION
+__mingw_SEH_error_handler (struct _EXCEPTION_RECORD* ExceptionRecord,
+			   void *EstablisherFrame  __attribute__ ((unused)),
+			   struct _CONTEXT* ContextRecord __attribute__ ((unused)),
+			   void *DispatcherContext __attribute__ ((unused)))
+{
+  EXCEPTION_DISPOSITION action = ExceptionContinueSearch; /* EXCEPTION_CONTINUE_SEARCH; */
+  void (*old_handler) (int);
+  int reset_fpu = 0;
+
+  switch (ExceptionRecord->ExceptionCode)
+    {
+    case EXCEPTION_ACCESS_VIOLATION:
+      /* test if the user has set SIGSEGV */
+      old_handler = signal (SIGSEGV, SIG_DFL);
+      if (old_handler == SIG_IGN)
+	{
+	  /* this is undefined if the signal was raised by anything other
+	     than raise ().  */
+	  signal (SIGSEGV, SIG_IGN);
+	  action = 0; //EXCEPTION_CONTINUE_EXECUTION;
+	}
+      else if (old_handler != SIG_DFL)
+	{
+	  /* This means 'old' is a user defined function. Call it */
+	  (*old_handler) (SIGSEGV);
+	  action = 0; // EXCEPTION_CONTINUE_EXECUTION;
+	}
+      else
+        action = 4; /* EXCEPTION_EXECUTE_HANDLER; */
+      break;
+    case EXCEPTION_ILLEGAL_INSTRUCTION:
+    case EXCEPTION_PRIV_INSTRUCTION:
+      /* test if the user has set SIGILL */
+      old_handler = signal (SIGILL, SIG_DFL);
+      if (old_handler == SIG_IGN)
+	{
+	  /* this is undefined if the signal was raised by anything other
+	     than raise ().  */
+	  signal (SIGILL, SIG_IGN);
+	  action = 0; // EXCEPTION_CONTINUE_EXECUTION;
+	}
+      else if (old_handler != SIG_DFL)
+	{
+	  /* This means 'old' is a user defined function. Call it */
+	  (*old_handler) (SIGILL);
+	  action = 0; // EXCEPTION_CONTINUE_EXECUTION;
+	}
+      else
+        action = 4; /* EXCEPTION_EXECUTE_HANDLER;*/
+      break;
+    case EXCEPTION_FLT_INVALID_OPERATION:
+    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
+    case EXCEPTION_FLT_DENORMAL_OPERAND:
+    case EXCEPTION_FLT_OVERFLOW:
+    case EXCEPTION_FLT_UNDERFLOW:
+    case EXCEPTION_FLT_INEXACT_RESULT:
+      reset_fpu = 1;
+      /* fall through. */
+
+    case EXCEPTION_INT_DIVIDE_BY_ZERO:
+      /* test if the user has set SIGFPE */
+      old_handler = signal (SIGFPE, SIG_DFL);
+      if (old_handler == SIG_IGN)
+	{
+	  signal (SIGFPE, SIG_IGN);
+	  if (reset_fpu)
+	    _fpreset ();
+	  action = 0; // EXCEPTION_CONTINUE_EXECUTION;
+	}
+      else if (old_handler != SIG_DFL)
+	{
+	  /* This means 'old' is a user defined function. Call it */
+	  (*old_handler) (SIGFPE);
+	  action = 0; // EXCEPTION_CONTINUE_EXECUTION;
+	}
+      break;
+    case EXCEPTION_DATATYPE_MISALIGNMENT:
+    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
+    case EXCEPTION_FLT_STACK_CHECK:
+    case EXCEPTION_INT_OVERFLOW:
+    case EXCEPTION_INVALID_HANDLE:
+    /*case EXCEPTION_POSSIBLE_DEADLOCK: */
+      action = 0; // EXCEPTION_CONTINUE_EXECUTION;
+      break;
+    default:
+      break;
+    }
+  return action;
+}
+
+#endif
+
+LPTOP_LEVEL_EXCEPTION_FILTER __mingw_oldexcpt_handler = NULL;
+
+long CALLBACK
+_gnu_exception_handler (EXCEPTION_POINTERS *exception_data);
+
+#define GCC_MAGIC (('G' << 16) | ('C' << 8) | 'C' | (1U << 29))
+
+long CALLBACK
+_gnu_exception_handler (EXCEPTION_POINTERS *exception_data)
+{
+  void (*old_handler) (int);
+  long action = EXCEPTION_CONTINUE_SEARCH;
+  int reset_fpu = 0;
+
+#ifdef __SEH__
+  if ((exception_data->ExceptionRecord->ExceptionCode & 0x20ffffff) == GCC_MAGIC)
+    {
+      if ((exception_data->ExceptionRecord->ExceptionFlags & EXCEPTION_NONCONTINUABLE) == 0)
+        return EXCEPTION_CONTINUE_EXECUTION;
+    }
+#endif
+
+  switch (exception_data->ExceptionRecord->ExceptionCode)
+    {
+    case EXCEPTION_ACCESS_VIOLATION:
+      /* test if the user has set SIGSEGV */
+      old_handler = signal (SIGSEGV, SIG_DFL);
+      if (old_handler == SIG_IGN)
+	{
+	  /* this is undefined if the signal was raised by anything other
+	     than raise ().  */
+	  signal (SIGSEGV, SIG_IGN);
+	  action = EXCEPTION_CONTINUE_EXECUTION;
+	}
+      else if (old_handler != SIG_DFL)
+	{
+	  /* This means 'old' is a user defined function. Call it */
+	  (*old_handler) (SIGSEGV);
+	  action = EXCEPTION_CONTINUE_EXECUTION;
+	}
+      break;
+
+    case EXCEPTION_ILLEGAL_INSTRUCTION:
+    case EXCEPTION_PRIV_INSTRUCTION:
+      /* test if the user has set SIGILL */
+      old_handler = signal (SIGILL, SIG_DFL);
+      if (old_handler == SIG_IGN)
+	{
+	  /* this is undefined if the signal was raised by anything other
+	     than raise ().  */
+	  signal (SIGILL, SIG_IGN);
+	  action = EXCEPTION_CONTINUE_EXECUTION;
+	}
+      else if (old_handler != SIG_DFL)
+	{
+	  /* This means 'old' is a user defined function. Call it */
+	  (*old_handler) (SIGILL);
+	  action = EXCEPTION_CONTINUE_EXECUTION;
+	}
+      break;
+
+    case EXCEPTION_FLT_INVALID_OPERATION:
+    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
+    case EXCEPTION_FLT_DENORMAL_OPERAND:
+    case EXCEPTION_FLT_OVERFLOW:
+    case EXCEPTION_FLT_UNDERFLOW:
+    case EXCEPTION_FLT_INEXACT_RESULT:
+      reset_fpu = 1;
+      /* fall through. */
+
+    case EXCEPTION_INT_DIVIDE_BY_ZERO:
+      /* test if the user has set SIGFPE */
+      old_handler = signal (SIGFPE, SIG_DFL);
+      if (old_handler == SIG_IGN)
+	{
+	  signal (SIGFPE, SIG_IGN);
+	  if (reset_fpu)
+	    _fpreset ();
+	  action = EXCEPTION_CONTINUE_EXECUTION;
+	}
+      else if (old_handler != SIG_DFL)
+	{
+	  /* This means 'old' is a user defined function. Call it */
+	  (*old_handler) (SIGFPE);
+	  action = EXCEPTION_CONTINUE_EXECUTION;
+	}
+      break;
+#ifdef _WIN64
+    case EXCEPTION_DATATYPE_MISALIGNMENT:
+    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
+    case EXCEPTION_FLT_STACK_CHECK:
+    case EXCEPTION_INT_OVERFLOW:
+    case EXCEPTION_INVALID_HANDLE:
+    /*case EXCEPTION_POSSIBLE_DEADLOCK: */
+      action = EXCEPTION_CONTINUE_EXECUTION;
+      break;
+#endif
+    default:
+      break;
+    }
+
+  if (action == EXCEPTION_CONTINUE_SEARCH && __mingw_oldexcpt_handler)
+    action = (*__mingw_oldexcpt_handler)(exception_data);
+  return action;
+}

@@ -0,0 +1,151 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#include <sect_attribs.h>
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <corecrt_startup.h>
+#include <process.h>
+
+
+typedef void (__thiscall * dtor_fn)(void*);
+int __cxa_atexit(dtor_fn dtor, void *obj, void *dso);
+int __cxa_thread_atexit(dtor_fn dtor, void *obj, void *dso);
+
+typedef struct dtor_obj dtor_obj;
+struct dtor_obj {
+  dtor_fn dtor;
+  void *obj;
+  dtor_obj *next;
+};
+
+HANDLE __dso_handle;
+extern char __mingw_module_is_dll;
+
+static CRITICAL_SECTION lock;
+static int inited = 0;
+static dtor_obj *global_dtors = NULL;
+static __thread dtor_obj *tls_dtors = NULL;
+
+int __cxa_atexit(dtor_fn dtor, void *obj, void *dso) {
+  if (!inited)
+    return 1;
+  assert(!dso || dso == &__dso_handle);
+  dtor_obj *handler = (dtor_obj *) calloc(1, sizeof(*handler));
+  if (!handler)
+    return 1;
+  handler->dtor = dtor;
+  handler->obj = obj;
+  EnterCriticalSection(&lock);
+  handler->next = global_dtors;
+  global_dtors = handler;
+  LeaveCriticalSection(&lock);
+  return 0;
+}
+
+static void run_dtor_list(dtor_obj **ptr) {
+  dtor_obj *list = *ptr;
+  while (list) {
+    list->dtor(list->obj);
+    dtor_obj *next = list->next;
+    free(list);
+    list = next;
+  }
+  *ptr = NULL;
+}
+
+int __cxa_thread_atexit(dtor_fn dtor, void *obj, void *dso) {
+  if (!inited)
+    return 1;
+  assert(!dso || dso == &__dso_handle);
+  dtor_obj *handler = (dtor_obj *) calloc(1, sizeof(*handler));
+  if (!handler)
+    return 1;
+  handler->dtor = dtor;
+  handler->obj = obj;
+  handler->next = tls_dtors;
+  tls_dtors = handler;
+  return 0;
+}
+
+static void WINAPI tls_atexit_callback(HANDLE __UNUSED_PARAM(hDllHandle), DWORD dwReason, LPVOID __UNUSED_PARAM(lpReserved)) {
+  if (dwReason == DLL_PROCESS_DETACH) {
+    run_dtor_list(&tls_dtors);
+    run_dtor_list(&global_dtors);
+  }
+}
+
+static void WINAPI tls_callback(HANDLE hDllHandle, DWORD dwReason, LPVOID __UNUSED_PARAM(lpReserved)) {
+  switch (dwReason) {
+  case DLL_PROCESS_ATTACH:
+    if (inited == 0) {
+      InitializeCriticalSection(&lock);
+      __dso_handle = hDllHandle;
+      /*
+       * We can only call _register_thread_local_exe_atexit_callback once
+       * in a process; if we call it a second time the process terminates.
+       * When DLLs are unloaded, this callback is invoked before we run the
+       * _onexit tables, but for exes, we need to ask this to be called before
+       * all other registered atexit functions.
+       * Since we are registered as a normal TLS callback, we will be called
+       * another time later as well, but that doesn't matter, it's safe to
+       * invoke this with DLL_PROCESS_DETACH twice.
+       */
+      if (!__mingw_module_is_dll)
+        _register_thread_local_exe_atexit_callback(tls_atexit_callback);
+    }
+    inited = 1;
+    break;
+  case DLL_PROCESS_DETACH:
+    /*
+     * If there are other threads still running that haven't been detached,
+     * we don't attempt to run their destructors (MSVC doesn't either), but
+     * simply leak the destructor list and whatever resources the destructors
+     * would have released.
+     *
+     * From Vista onwards, we could have used FlsAlloc to get a TLS key that
+     * runs a destructor on each thread that has a value attached ot it, but
+     * since MSVC doesn't run destructors on other threads in this case,
+     * users shouldn't assume it and we don't attempt to do anything potentially
+     * risky about it. TL;DR, threads with pending TLS destructors for a DLL
+     * need to be joined before unloading the DLL.
+     *
+     * This gets called both when exiting cleanly (via exit or returning from
+     * main, or when a DLL is unloaded), and when exiting bypassing some of
+     * the cleanup, by calling _exit or ExitProcess. In the latter cases,
+     * destructors (both TLS and global) in loaded DLLs still get called,
+     * but only TLS destructors get called for the main executable, global
+     * variables' destructors don't run. (This matches what MSVC does with
+     * a dynamically linked CRT.)
+     */
+    run_dtor_list(&tls_dtors);
+    if (__mingw_module_is_dll) {
+      /* For DLLs, run dtors when detached. For EXEs, run dtors via the
+       * thread local atexit callback, to make sure they don't run when
+       * exiting the process with _exit or ExitProcess. */
+      run_dtor_list(&global_dtors);
+    }
+    if (inited == 1) {
+      inited = 0;
+      DeleteCriticalSection(&lock);
+    }
+    break;
+  case DLL_THREAD_ATTACH:
+    break;
+  case DLL_THREAD_DETACH:
+    run_dtor_list(&tls_dtors);
+    break;
+  }
+}
+
+_CRTALLOC(".CRT$XLE") PIMAGE_TLS_CALLBACK __xl_e = (PIMAGE_TLS_CALLBACK) tls_callback;

@@ -0,0 +1,25 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#ifdef CRTDLL
+#undef CRTDLL
+#endif
+
+#include <internal.h>
+
+extern int _dowildcard;
+
+#ifdef WPRFLAG
+int __CRTDECL
+__wsetargv (void)
+#else
+int __CRTDECL
+__setargv (void)
+#endif
+{
+  _dowildcard = 1;
+  return 0;
+}

@@ -0,0 +1,22 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#ifdef CRTDLL
+#undef CRTDLL
+#endif
+
+#include <internal.h>
+
+#ifdef WPRFLAG
+int __CRTDECL
+_wsetargv (void)
+#else
+int __CRTDECL
+_setargv (void)
+#endif
+{
+  return 0;
+}

@@ -0,0 +1,85 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#include <windows.h>
+#include <stdlib.h>
+#include <setjmp.h>
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+typedef void (*func_ptr) (void);
+extern func_ptr __CTOR_LIST__[];
+extern func_ptr __DTOR_LIST__[];
+
+void __do_global_dtors (void);
+void __do_global_ctors (void);
+void __main (void);
+
+void
+__do_global_dtors (void)
+{
+  static func_ptr *p = __DTOR_LIST__ + 1;
+
+  while (*p)
+    {
+      (*(p)) ();
+      p++;
+    }
+}
+
+#ifndef HAVE_CTOR_LIST
+// If the linker didn't provide __CTOR_LIST__, we provided it ourselves,
+// and then we also know we have __CTOR_END__ available.
+extern func_ptr __CTOR_END__[];
+extern func_ptr __DTOR_END__[];
+
+void __do_global_ctors (void)
+{
+  static func_ptr *p = __CTOR_END__ - 1;
+  while (*p != (func_ptr) -1) {
+    (*(p))();
+    p--;
+  }
+  atexit (__do_global_dtors);
+}
+
+#else
+// old method that iterates the list twice because old linker scripts do not have __CTOR_END__
+
+void
+__do_global_ctors (void)
+{
+  unsigned long nptrs = (unsigned long) (ptrdiff_t) __CTOR_LIST__[0];
+  unsigned long i;
+
+  if (nptrs == (unsigned long) -1)
+    {
+      for (nptrs = 0; __CTOR_LIST__[nptrs + 1] != 0; nptrs++);
+    }
+
+  for (i = nptrs; i >= 1; i--)
+    {
+      __CTOR_LIST__[i] ();
+    }
+
+  atexit (__do_global_dtors);
+}
+
+#endif
+
+static int initialized = 0;
+
+void
+__main (void)
+{
+  if (!initialized)
+    {
+      initialized = 1;
+      __do_global_ctors ();
+    }
+}

@@ -0,0 +1,154 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#define WIN32_NO_STATUS
+#include <stdlib.h>	/* abort () */
+#include <windows.h>
+#undef  WIN32_NO_STATUS
+#include <ntstatus.h>	/* STATUS macros */
+#ifdef _WIN64
+#include <intrin.h>
+#endif
+
+#ifdef _WIN64
+#define DEFAULT_SECURITY_COOKIE 0x00002B992DDFA232ll
+#else
+#define DEFAULT_SECURITY_COOKIE 0xBB40E64E
+#endif
+
+/* Externals.  */
+
+typedef LONG NTSTATUS;	/* same as in ntdef.h / winternl.h */
+
+#define UNW_FLAG_NHANDLER   0x0
+
+typedef union
+{
+  unsigned __int64 ft_scalar;
+  FILETIME ft_struct;
+} FT;
+
+static EXCEPTION_RECORD GS_ExceptionRecord;
+static CONTEXT GS_ContextRecord;
+
+static const EXCEPTION_POINTERS GS_ExceptionPointers = {
+  &GS_ExceptionRecord,&GS_ContextRecord
+};
+
+DECLSPEC_SELECTANY UINT_PTR __security_cookie = DEFAULT_SECURITY_COOKIE;
+DECLSPEC_SELECTANY UINT_PTR __security_cookie_complement = ~(DEFAULT_SECURITY_COOKIE);
+
+void __cdecl __security_init_cookie (void);
+
+void __cdecl
+__security_init_cookie (void)
+{
+  UINT_PTR cookie;
+  FT systime = { 0, };
+  LARGE_INTEGER perfctr;
+
+  if (__security_cookie != DEFAULT_SECURITY_COOKIE)
+    {
+      __security_cookie_complement = ~__security_cookie;
+      return;
+    }
+
+  GetSystemTimeAsFileTime (&systime.ft_struct);
+#ifdef _WIN64
+  cookie = systime.ft_scalar;
+#else
+  cookie = systime.ft_struct.dwLowDateTime;
+  cookie ^= systime.ft_struct.dwHighDateTime;
+#endif
+
+  cookie ^= GetCurrentProcessId ();
+  cookie ^= GetCurrentThreadId ();
+  cookie ^= GetTickCount ();
+
+  QueryPerformanceCounter (&perfctr);
+#ifdef _WIN64
+  cookie ^= perfctr.QuadPart;
+#else
+  cookie ^= perfctr.LowPart;
+  cookie ^= perfctr.HighPart;
+#endif
+
+#ifdef _WIN64
+  cookie &= 0x0000ffffffffffffll;
+#endif
+
+  if (cookie == DEFAULT_SECURITY_COOKIE)
+    cookie = DEFAULT_SECURITY_COOKIE + 1;
+  __security_cookie = cookie;
+  __security_cookie_complement = ~cookie;
+}
+
+
+#if defined(__GNUC__) /* wrap msvc intrinsics onto gcc builtins */
+#undef  _ReturnAddress
+#undef  _AddressOfReturnAddress
+#define _ReturnAddress()		__builtin_return_address(0)
+#define _AddressOfReturnAddress()	__builtin_frame_address (0)
+#endif /* __GNUC__ */
+
+__declspec(noreturn) void __cdecl __report_gsfailure (ULONG_PTR);
+
+#define UNUSED_PARAM(x) { x = x; }
+__declspec(noreturn) void __cdecl
+__report_gsfailure (ULONG_PTR StackCookie)
+{
+  volatile UINT_PTR cookie[2] __MINGW_ATTRIB_UNUSED;
+#if defined(_WIN64) && !defined(__aarch64__)
+  ULONG64 controlPC, imgBase, establisherFrame;
+  PRUNTIME_FUNCTION fctEntry;
+  PVOID hndData;
+
+  RtlCaptureContext (&GS_ContextRecord);
+  controlPC = GS_ContextRecord.Rip;
+  fctEntry = RtlLookupFunctionEntry (controlPC, &imgBase, NULL);
+  if (fctEntry != NULL)
+    {
+      RtlVirtualUnwind (UNW_FLAG_NHANDLER, imgBase, controlPC, fctEntry,
+			&GS_ContextRecord, &hndData, &establisherFrame, NULL);
+    }
+  else
+#endif /* _WIN64 */
+    {
+#if defined(__x86_64__) || defined(_AMD64_)
+      GS_ContextRecord.Rip = (ULONGLONG) _ReturnAddress();
+      GS_ContextRecord.Rsp = (ULONGLONG) _AddressOfReturnAddress() + 8;
+#elif defined(__i386__) || defined(_X86_)
+      GS_ContextRecord.Eip = (DWORD) _ReturnAddress();
+      GS_ContextRecord.Esp = (DWORD) _AddressOfReturnAddress() + 4;
+#elif defined(__arm__) || defined(_ARM_)
+      GS_ContextRecord.Pc = (DWORD) _ReturnAddress();
+      GS_ContextRecord.Sp = (DWORD) _AddressOfReturnAddress() + 4;
+#endif /* _WIN64 */
+    }
+
+#if defined(__x86_64__) || defined(_AMD64_)
+  GS_ExceptionRecord.ExceptionAddress = (PVOID) GS_ContextRecord.Rip;
+  GS_ContextRecord.Rcx = StackCookie;
+#elif defined(__i386__) || defined(_X86_)
+  GS_ExceptionRecord.ExceptionAddress = (PVOID) GS_ContextRecord.Eip;
+  GS_ContextRecord.Ecx = StackCookie;
+#elif defined(__arm__) || defined(_ARM_)
+  GS_ExceptionRecord.ExceptionAddress = (PVOID) GS_ContextRecord.Pc;
+  UNUSED_PARAM(StackCookie);
+#endif /* _WIN64 */
+  GS_ExceptionRecord.ExceptionCode = STATUS_STACK_BUFFER_OVERRUN;
+  GS_ExceptionRecord.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
+  cookie[0] = __security_cookie;
+  cookie[1] = __security_cookie_complement;
+  SetUnhandledExceptionFilter (NULL);
+  UnhandledExceptionFilter ((EXCEPTION_POINTERS *) &GS_ExceptionPointers);
+  TerminateProcess (GetCurrentProcess (), STATUS_STACK_BUFFER_OVERRUN);
+  abort();
+}
+

@@ -0,0 +1,76 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#include <internal.h>
+#include <math.h>
+#include <stdio.h>
+
+typedef int (__cdecl *fUserMathErr)(struct _exception *);
+static fUserMathErr stUserMathErr;
+
+void __mingw_raise_matherr (int typ, const char *name, double a1, double a2,
+			    double rslt)
+{
+  struct _exception ex;
+  if (!stUserMathErr)
+    return;
+  ex.type = typ;
+  ex.name = (char*)name;
+  ex.arg1 = a1;
+  ex.arg2 = a2;
+  ex.retval = rslt;
+  (*stUserMathErr)(&ex);
+}
+
+#undef __setusermatherr
+
+void __mingw_setusermatherr (int (__cdecl *f)(struct _exception *))
+{
+  stUserMathErr = f;
+  __setusermatherr (f);
+}
+
+int __CRTDECL
+_matherr (struct _exception *pexcept)
+{
+  const char * type;
+
+  switch(pexcept->type)
+    {
+      case _DOMAIN:
+	type = "Argument domain error (DOMAIN)";
+	break;
+
+      case _SING:
+	type = "Argument singularity (SIGN)";
+	break;
+
+      case _OVERFLOW:
+	type = "Overflow range error (OVERFLOW)";
+	break;
+
+      case _PLOSS:
+	type = "Partial loss of significance (PLOSS)";
+	break;
+
+      case _TLOSS:
+	type = "Total loss of significance (TLOSS)";
+	break;
+
+      case _UNDERFLOW:
+	type = "The result is too small to be represented (UNDERFLOW)";
+	break;
+
+      default:
+	type = "Unknown error";
+	break;
+    }
+
+  fprintf (stderr, "_matherr(): %s in %s(%g, %g)  (retval=%g)\n", 
+	  type, pexcept->name, pexcept->arg1, pexcept->arg2, pexcept->retval);
+  return 0;
+}
+

@@ -0,0 +1,31 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#include <oscalls.h>
+#include <internal.h>
+#include <process.h>
+#include <math.h>
+#include <stdlib.h>
+#include <tchar.h>
+#include <sect_attribs.h>
+#include <locale.h>
+
+extern const PIMAGE_TLS_CALLBACK __dyn_tls_init_callback;
+
+void * __cdecl
+_decode_pointer (void *codedptr)
+{
+  return (void *) codedptr;
+}
+
+void * __cdecl
+_encode_pointer (void *ptr)
+{
+  return ptr;
+}
+
+/* 0:console, 1:windows.  */
+int mingw_app_type = 0;

@@ -0,0 +1,14 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#include <crtdefs.h>
+#include <internal.h>
+
+_PGLOBAL
+volatile unsigned int __native_dllmain_reason = UINT_MAX;
+volatile unsigned int __native_vcclrit_reason = UINT_MAX;
+volatile __enative_startup_state __native_startup_state;
+volatile void *__native_startup_lock;

@@ -0,0 +1,230 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#include <windows.h>
+#include <string.h>
+
+#if defined (_WIN64) && defined (__ia64__)
+#error FIXME: Unsupported __ImageBase implementation.
+#else
+#ifdef __GNUC__
+/* Hack, for bug in ld.  Will be removed soon.  */
+#define __ImageBase __MINGW_LSYMBOL(_image_base__)
+#endif
+/* This symbol is defined by the linker.  */
+extern IMAGE_DOS_HEADER __ImageBase;
+#endif
+
+WINBOOL _ValidateImageBase (PBYTE);
+
+WINBOOL
+_ValidateImageBase (PBYTE pImageBase)
+{
+  PIMAGE_DOS_HEADER pDOSHeader;
+  PIMAGE_NT_HEADERS pNTHeader;
+  PIMAGE_OPTIONAL_HEADER pOptHeader;
+
+  pDOSHeader = (PIMAGE_DOS_HEADER) pImageBase;
+  if (pDOSHeader->e_magic != IMAGE_DOS_SIGNATURE)
+    return FALSE;
+  pNTHeader = (PIMAGE_NT_HEADERS) ((PBYTE) pDOSHeader + pDOSHeader->e_lfanew);
+  if (pNTHeader->Signature != IMAGE_NT_SIGNATURE)
+    return FALSE;
+  pOptHeader = (PIMAGE_OPTIONAL_HEADER) &pNTHeader->OptionalHeader;
+  if (pOptHeader->Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)
+    return FALSE;
+  return TRUE;
+}
+
+PIMAGE_SECTION_HEADER _FindPESection (PBYTE, DWORD_PTR);
+
+PIMAGE_SECTION_HEADER
+_FindPESection (PBYTE pImageBase, DWORD_PTR rva)
+{
+  PIMAGE_NT_HEADERS pNTHeader;
+  PIMAGE_SECTION_HEADER pSection;
+  unsigned int iSection;
+
+  pNTHeader = (PIMAGE_NT_HEADERS) (pImageBase + ((PIMAGE_DOS_HEADER) pImageBase)->e_lfanew);
+
+  for (iSection = 0, pSection = IMAGE_FIRST_SECTION (pNTHeader);
+    iSection < pNTHeader->FileHeader.NumberOfSections;
+    ++iSection,++pSection)
+    {
+      if (rva >= pSection->VirtualAddress
+	  && rva < pSection->VirtualAddress + pSection->Misc.VirtualSize)
+	return pSection;
+    }
+  return NULL;
+}
+
+PIMAGE_SECTION_HEADER _FindPESectionByName (const char *);
+
+PIMAGE_SECTION_HEADER
+_FindPESectionByName (const char *pName)
+{
+  PBYTE pImageBase;
+  PIMAGE_NT_HEADERS pNTHeader;
+  PIMAGE_SECTION_HEADER pSection;
+  unsigned int iSection;
+
+  /* Long names aren't supported.  */
+  if (strlen (pName) > IMAGE_SIZEOF_SHORT_NAME)
+    return NULL;
+
+  pImageBase = (PBYTE) &__ImageBase;
+  if (! _ValidateImageBase (pImageBase))
+    return NULL;
+
+  pNTHeader = (PIMAGE_NT_HEADERS) (pImageBase + ((PIMAGE_DOS_HEADER) pImageBase)->e_lfanew);
+
+  for (iSection = 0, pSection = IMAGE_FIRST_SECTION (pNTHeader);
+    iSection < pNTHeader->FileHeader.NumberOfSections;
+    ++iSection,++pSection)
+    {
+      if (!strncmp ((char *) &pSection->Name[0], pName, IMAGE_SIZEOF_SHORT_NAME))
+	return pSection;
+    }
+  return NULL;
+}
+
+int __mingw_GetSectionCount (void);
+PIMAGE_SECTION_HEADER __mingw_GetSectionForAddress (LPVOID p);
+
+PIMAGE_SECTION_HEADER
+__mingw_GetSectionForAddress (LPVOID p)
+{
+  PBYTE pImageBase;
+  DWORD_PTR rva;
+
+  pImageBase = (PBYTE) &__ImageBase;
+  if (! _ValidateImageBase (pImageBase))
+    return NULL;
+
+  rva = (DWORD_PTR) (((PBYTE) p) - pImageBase);
+  return _FindPESection (pImageBase, rva);
+}
+
+int
+__mingw_GetSectionCount (void)
+{
+  PBYTE pImageBase;
+  PIMAGE_NT_HEADERS pNTHeader;
+
+  pImageBase = (PBYTE) &__ImageBase;
+  if (! _ValidateImageBase (pImageBase))
+    return 0;
+
+  pNTHeader = (PIMAGE_NT_HEADERS) (pImageBase + ((PIMAGE_DOS_HEADER) pImageBase)->e_lfanew);
+
+  return (int) pNTHeader->FileHeader.NumberOfSections;
+}
+
+
+PIMAGE_SECTION_HEADER _FindPESectionExec (size_t);
+
+PIMAGE_SECTION_HEADER
+_FindPESectionExec (size_t eNo)
+{
+  PBYTE pImageBase;
+  PIMAGE_NT_HEADERS pNTHeader;
+  PIMAGE_SECTION_HEADER pSection;
+  unsigned int iSection;
+
+  pImageBase = (PBYTE) &__ImageBase;
+  if (! _ValidateImageBase (pImageBase))
+    return NULL;
+
+  pNTHeader = (PIMAGE_NT_HEADERS) (pImageBase + ((PIMAGE_DOS_HEADER) pImageBase)->e_lfanew);
+
+  for (iSection = 0, pSection = IMAGE_FIRST_SECTION (pNTHeader);
+    iSection < pNTHeader->FileHeader.NumberOfSections;
+    ++iSection,++pSection)
+    {
+      if ((pSection->Characteristics & IMAGE_SCN_MEM_EXECUTE) != 0)
+      {
+	if (!eNo)
+	  return pSection;
+	--eNo;
+      }
+    }
+  return NULL;
+}
+
+PBYTE _GetPEImageBase (void);
+
+PBYTE
+_GetPEImageBase (void)
+{
+  PBYTE pImageBase;
+  pImageBase = (PBYTE) &__ImageBase;
+  if (! _ValidateImageBase (pImageBase))
+    return NULL;
+  return pImageBase;
+}
+
+WINBOOL _IsNonwritableInCurrentImage (PBYTE);
+
+WINBOOL
+_IsNonwritableInCurrentImage (PBYTE pTarget)
+{
+  PBYTE pImageBase;
+  DWORD_PTR rvaTarget;
+  PIMAGE_SECTION_HEADER pSection;
+
+  pImageBase = (PBYTE) &__ImageBase;
+  if (! _ValidateImageBase (pImageBase))
+    return FALSE;
+  rvaTarget = pTarget - pImageBase;
+  pSection = _FindPESection (pImageBase, rvaTarget);
+  if (pSection == NULL)
+    return FALSE;
+  return (pSection->Characteristics & IMAGE_SCN_MEM_WRITE) == 0;
+}
+
+const char *
+__mingw_enum_import_library_names (int);
+
+const char *
+__mingw_enum_import_library_names (int i)
+{
+  PBYTE pImageBase;
+  PIMAGE_NT_HEADERS pNTHeader;
+  PIMAGE_IMPORT_DESCRIPTOR importDesc;
+  PIMAGE_SECTION_HEADER pSection;
+  DWORD importsStartRVA;
+
+  pImageBase = (PBYTE) &__ImageBase;
+  if (! _ValidateImageBase (pImageBase))
+    return NULL;
+
+  pNTHeader = (PIMAGE_NT_HEADERS) (pImageBase + ((PIMAGE_DOS_HEADER) pImageBase)->e_lfanew);
+  
+  importsStartRVA = pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
+  if (!importsStartRVA)
+    return NULL;
+
+  pSection = _FindPESection (pImageBase, importsStartRVA);
+  if (!pSection)
+      return NULL;
+
+  importDesc = (PIMAGE_IMPORT_DESCRIPTOR) (pImageBase + importsStartRVA);
+  if (!importDesc)
+    return NULL;
+            
+  for (;;)
+    {
+      if (importDesc->TimeDateStamp == 0 && importDesc->Name == 0)
+        break;
+
+      if (i <= 0)
+       return (char *) (pImageBase + importDesc->Name);
+      --i;
+      importDesc++;
+    }
+
+  return NULL;
+}

@@ -0,0 +1,8 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+char __RUNTIME_PSEUDO_RELOC_LIST_END__ = 0;
+char __RUNTIME_PSEUDO_RELOC_LIST__ = 0;

@@ -0,0 +1,487 @@
+/* pseudo-reloc.c
+
+   Contributed by Egor Duda  <deo@logos-m.ru>
+   Modified by addition of runtime_pseudo_reloc version 2
+   by Kai Tietz  <kai.tietz@onevision.com>
+	
+   THIS SOFTWARE IS NOT COPYRIGHTED
+
+   This source code is offered for use in the public domain. You may
+   use, modify or distribute it freely.
+
+   This code is distributed in the hope that it will be useful but
+   WITHOUT ANY WARRANTY. ALL WARRENTIES, EXPRESS OR IMPLIED ARE HEREBY
+   DISCLAMED. This includes but is not limited to warrenties of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*/
+
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <memory.h>
+#include <internal.h>
+
+#if defined(__CYGWIN__)
+#include <wchar.h>
+#include <ntdef.h>
+#include <sys/cygwin.h>
+/* copied from winsup.h */
+# define NO_COPY __attribute__((nocommon)) __attribute__((section(".data_cygwin_nocopy")))
+/* custom status code: */
+#define STATUS_ILLEGAL_DLL_PSEUDO_RELOCATION ((NTSTATUS) 0xe0000269)
+#define SHORT_MSG_BUF_SZ 128
+#else
+# define NO_COPY
+#endif
+
+#ifdef __GNUC__
+#define ATTRIBUTE_NORETURN __attribute__ ((noreturn))
+#else
+#define ATTRIBUTE_NORETURN
+#endif
+
+#ifndef __MINGW_LSYMBOL
+#define __MINGW_LSYMBOL(sym) sym
+#endif
+
+extern char __RUNTIME_PSEUDO_RELOC_LIST__;
+extern char __RUNTIME_PSEUDO_RELOC_LIST_END__;
+extern char __MINGW_LSYMBOL(_image_base__);
+
+void _pei386_runtime_relocator (void);
+
+/* v1 relocation is basically:
+ *   *(base + .target) += .addend
+ * where (base + .target) is always assumed to point
+ * to a DWORD (4 bytes).
+ */
+typedef struct {
+  DWORD addend;
+  DWORD target;
+} runtime_pseudo_reloc_item_v1;
+
+/* v2 relocation is more complex. In effect, it is
+ *    *(base + .target) += *(base + .sym) - (base + .sym)
+ * with care taken in both reading, sign extension, and writing
+ * because .flags may indicate that (base + .target) may point
+ * to a BYTE, WORD, DWORD, or QWORD (w64).
+ */
+typedef struct {
+  DWORD sym;
+  DWORD target;
+  DWORD flags;
+} runtime_pseudo_reloc_item_v2;
+
+typedef struct {
+  DWORD magic1;
+  DWORD magic2;
+  DWORD version;
+} runtime_pseudo_reloc_v2;
+
+static void ATTRIBUTE_NORETURN
+__report_error (const char *msg, ...)
+{
+#ifdef __CYGWIN__
+  /* This function is used to print short error messages
+   * to stderr, which may occur during DLL initialization
+   * while fixing up 'pseudo' relocations. This early, we
+   * may not be able to use cygwin stdio functions, so we
+   * use the win32 WriteFile api. This should work with both
+   * normal win32 console IO handles, redirected ones, and
+   * cygwin ptys.
+   */
+  char buf[SHORT_MSG_BUF_SZ];
+  wchar_t module[PATH_MAX];
+  char * posix_module = NULL;
+  static const char   UNKNOWN_MODULE[] = "<unknown module>: ";
+  static const size_t UNKNOWN_MODULE_LEN = sizeof (UNKNOWN_MODULE) - 1;
+  static const char   CYGWIN_FAILURE_MSG[] = "Cygwin runtime failure: ";
+  static const size_t CYGWIN_FAILURE_MSG_LEN = sizeof (CYGWIN_FAILURE_MSG) - 1;
+  DWORD len;
+  DWORD done;
+  va_list args;
+  HANDLE errh = GetStdHandle (STD_ERROR_HANDLE);
+  ssize_t modulelen = GetModuleFileNameW (NULL, module, PATH_MAX);
+
+  if (errh == INVALID_HANDLE_VALUE)
+    cygwin_internal (CW_EXIT_PROCESS,
+                     STATUS_ILLEGAL_DLL_PSEUDO_RELOCATION,
+                     1);
+
+  if (modulelen > 0)
+    posix_module = cygwin_create_path (CCP_WIN_W_TO_POSIX, module);
+
+  va_start (args, msg);
+  len = (DWORD) vsnprintf (buf, SHORT_MSG_BUF_SZ, msg, args);
+  va_end (args);
+  buf[SHORT_MSG_BUF_SZ-1] = '\0'; /* paranoia */
+
+  if (posix_module)
+    {
+      WriteFile (errh, (PCVOID)CYGWIN_FAILURE_MSG,
+                 CYGWIN_FAILURE_MSG_LEN, &done, NULL);
+      WriteFile (errh, (PCVOID)posix_module,
+                 strlen(posix_module), &done, NULL);
+      WriteFile (errh, (PCVOID)": ", 2, &done, NULL);
+      WriteFile (errh, (PCVOID)buf, len, &done, NULL);
+      free (posix_module);
+    }
+  else
+    {
+      WriteFile (errh, (PCVOID)CYGWIN_FAILURE_MSG,
+                 CYGWIN_FAILURE_MSG_LEN, &done, NULL);
+      WriteFile (errh, (PCVOID)UNKNOWN_MODULE,
+                 UNKNOWN_MODULE_LEN, &done, NULL);
+      WriteFile (errh, (PCVOID)buf, len, &done, NULL);
+    }
+  WriteFile (errh, (PCVOID)"\n", 1, &done, NULL);
+
+  cygwin_internal (CW_EXIT_PROCESS,
+                   STATUS_ILLEGAL_DLL_PSEUDO_RELOCATION,
+                   1);
+  /* not reached, but silences noreturn warning */
+  abort ();
+#else
+  va_list argp;
+  va_start (argp, msg);
+# ifdef __MINGW64_VERSION_MAJOR
+  fprintf (stderr, "Mingw-w64 runtime failure:\n");
+  vfprintf (stderr, msg, argp);
+# else
+  fprintf (stderr, "Mingw runtime failure:\n");
+  vfprintf (stderr, msg, argp);
+#endif
+  va_end (argp);
+  abort ();
+#endif
+}
+
+/* For mingw-w64 we have additional helpers to get image information
+   on runtime.  This allows us to cache for pseudo-relocation pass
+   the temporary access of code/read-only sections.
+   This step speeds up pseudo-relocation pass.  */
+#ifdef __MINGW64_VERSION_MAJOR
+extern int __mingw_GetSectionCount (void);
+extern PIMAGE_SECTION_HEADER __mingw_GetSectionForAddress (LPVOID p);
+extern PBYTE _GetPEImageBase (void);
+
+typedef struct sSecInfo {
+  /* Keeps altered section flags, or zero if nothing was changed.  */
+  DWORD old_protect;
+  PVOID base_address;
+  SIZE_T region_size;
+  PBYTE sec_start;
+  PIMAGE_SECTION_HEADER hash;
+} sSecInfo;
+
+static sSecInfo *the_secs = NULL;
+static int maxSections = 0;
+
+static void
+mark_section_writable (LPVOID addr)
+{
+  MEMORY_BASIC_INFORMATION b;
+  PIMAGE_SECTION_HEADER h;
+  int i;
+
+  for (i = 0; i < maxSections; i++)
+    {
+      if (the_secs[i].sec_start <= ((LPBYTE) addr)
+          && ((LPBYTE) addr) < (the_secs[i].sec_start + the_secs[i].hash->Misc.VirtualSize))
+        return;
+    }
+  h = __mingw_GetSectionForAddress (addr);
+  if (!h)
+    {
+      __report_error ("Address %p has no image-section", addr);
+      return;
+    }
+  the_secs[i].hash = h;
+  the_secs[i].old_protect = 0;
+  the_secs[i].sec_start = _GetPEImageBase () + h->VirtualAddress;
+
+  if (!VirtualQuery (the_secs[i].sec_start, &b, sizeof(b)))
+    {
+      __report_error ("  VirtualQuery failed for %d bytes at address %p",
+		      (int) h->Misc.VirtualSize, the_secs[i].sec_start);
+      return;
+    }
+
+  if (b.Protect != PAGE_EXECUTE_READWRITE && b.Protect != PAGE_READWRITE
+      && b.Protect != PAGE_EXECUTE_WRITECOPY && b.Protect != PAGE_WRITECOPY)
+    {
+      the_secs[i].base_address = b.BaseAddress;
+      the_secs[i].region_size = b.RegionSize;
+      if (!VirtualProtect (b.BaseAddress, b.RegionSize,
+			   PAGE_EXECUTE_READWRITE,
+			   &the_secs[i].old_protect))
+	__report_error ("  VirtualProtect failed with code 0x%x",
+	  (int) GetLastError ());
+    }
+  ++maxSections;
+  return;
+}
+
+static void
+restore_modified_sections (void)
+{
+  int i;
+  DWORD oldprot;
+
+  for (i = 0; i < maxSections; i++)
+    {
+      if (the_secs[i].old_protect == 0)
+        continue;
+      VirtualProtect (the_secs[i].base_address, the_secs[i].region_size,
+                      the_secs[i].old_protect, &oldprot);
+    }
+}
+
+#endif /* __MINGW64_VERSION_MAJOR */
+
+/* This function temporarily marks the page containing addr
+ * writable, before copying len bytes from *src to *addr, and
+ * then restores the original protection settings to the page.
+ *
+ * Using this function eliminates the requirement with older
+ * pseudo-reloc implementations, that sections containing
+ * pseudo-relocs (such as .text and .rdata) be permanently
+ * marked writable. This older behavior sabotaged any memory
+ * savings achieved by shared libraries on win32 -- and was
+ * slower, too.  However, on cygwin as of binutils 2.20 the
+ * .text section is still marked writable, and the .rdata section
+ * is folded into the (writable) .data when --enable-auto-import.
+ */
+static void
+__write_memory (void *addr, const void *src, size_t len)
+{
+  if (!len)
+    return;
+
+#ifdef __MINGW64_VERSION_MAJOR
+  /* Mark the section writable once, and unset it in
+   * restore_modified_sections */
+  mark_section_writable ((LPVOID) addr);
+#else
+  MEMORY_BASIC_INFORMATION b;
+  DWORD oldprot = 0;
+  int call_unprotect = 0;
+
+  if (!VirtualQuery (addr, &b, sizeof(b)))
+    {
+      __report_error ("  VirtualQuery failed for %d bytes at address %p",
+		      (int) sizeof(b), addr);
+    }
+
+  /* Temporarily allow write access to read-only protected memory.  */
+  if (b.Protect != PAGE_EXECUTE_READWRITE && b.Protect != PAGE_READWRITE
+      && b.Protect != PAGE_WRITECOPY && b.Protect != PAGE_EXECUTE_WRITECOPY)
+    {
+      call_unprotect = 1;
+      VirtualProtect (b.BaseAddress, b.RegionSize, PAGE_EXECUTE_READWRITE,
+		      &oldprot);
+    }
+#endif
+
+  /* write the data. */
+  memcpy (addr, src, len);
+
+#ifndef __MINGW64_VERSION_MAJOR
+  /* Restore original protection. */
+  if (call_unprotect
+      && b.Protect != PAGE_EXECUTE_READWRITE && b.Protect != PAGE_READWRITE
+      && b.Protect != PAGE_WRITECOPY && b.Protect != PAGE_EXECUTE_WRITECOPY)
+    VirtualProtect (b.BaseAddress, b.RegionSize, oldprot, &oldprot);
+#endif
+}
+
+#define RP_VERSION_V1 0
+#define RP_VERSION_V2 1
+
+static void
+do_pseudo_reloc (void * start, void * end, void * base)
+{
+  ptrdiff_t addr_imp, reldata;
+  ptrdiff_t reloc_target = (ptrdiff_t) ((char *)end - (char*)start);
+  runtime_pseudo_reloc_v2 *v2_hdr = (runtime_pseudo_reloc_v2 *) start;
+  runtime_pseudo_reloc_item_v2 *r;
+
+  /* A valid relocation list will contain at least one entry, and
+   * one v1 data structure (the smallest one) requires two DWORDs.
+   * So, if the relocation list is smaller than 8 bytes, bail.
+   */
+  if (reloc_target < 8)
+    return;
+
+  /* Check if this is the old pseudo relocation version.  */
+  /* There are two kinds of v1 relocation lists:
+   *   1) With a (v2-style) version header. In this case, the
+   *      first entry in the list is a 3-DWORD structure, with
+   *      value:
+   *         { 0, 0, RP_VERSION_V1 }
+   *      In this case, we skip to the next entry in the list,
+   *      knowing that all elements after the head item can
+   *      be cast to runtime_pseudo_reloc_item_v1.
+   *   2) Without a (v2-style) version header. In this case, the
+   *      first element in the list IS an actual v1 relocation
+   *      record, which is two DWORDs.  Because there will never
+   *      be a case where a v1 relocation record has both
+   *      addend == 0 and target == 0, this case will not be
+   *      confused with the prior one.
+   * All current binutils, when generating a v1 relocation list,
+   * use the second (e.g. original) form -- that is, without the
+   * v2-style version header.
+   */
+  if (reloc_target >= 12
+      && v2_hdr->magic1 == 0 && v2_hdr->magic2 == 0
+      && v2_hdr->version == RP_VERSION_V1)
+    {
+      /* We have a list header item indicating that the rest
+       * of the list contains v1 entries.  Move the pointer to
+       * the first true v1 relocation record.  By definition,
+       * that v1 element will not have both addend == 0 and
+       * target == 0 (and thus, when interpreted as a
+       * runtime_pseudo_reloc_v2, it will not have both
+       * magic1 == 0 and magic2 == 0).
+       */
+      v2_hdr++;
+    }
+
+  if (v2_hdr->magic1 != 0 || v2_hdr->magic2 != 0)
+    {
+      /*************************
+       * Handle v1 relocations *
+       *************************/
+      runtime_pseudo_reloc_item_v1 * o;
+      for (o = (runtime_pseudo_reloc_item_v1 *) v2_hdr;
+	   o < (runtime_pseudo_reloc_item_v1 *)end;
+           o++)
+	{
+	  DWORD newval;
+	  reloc_target = (ptrdiff_t) base + o->target;
+	  newval = (*((DWORD*) reloc_target)) + o->addend;
+	  __write_memory ((void *) reloc_target, &newval, sizeof(DWORD));
+	}
+      return;
+    }
+
+  /* If we got this far, then we have relocations of version 2 or newer */
+
+  /* Check if this is a known version.  */
+  if (v2_hdr->version != RP_VERSION_V2)
+    {
+      __report_error ("  Unknown pseudo relocation protocol version %d.\n",
+		      (int) v2_hdr->version);
+      return;
+    }
+
+  /*************************
+   * Handle v2 relocations *
+   *************************/
+
+  /* Walk over header. */
+  r = (runtime_pseudo_reloc_item_v2 *) &v2_hdr[1];
+
+  for (; r < (runtime_pseudo_reloc_item_v2 *) end; r++)
+    {
+      /* location where new address will be written */
+      reloc_target = (ptrdiff_t) base + r->target;
+
+      /* get sym pointer. It points either to the iat entry
+       * of the referenced element, or to the stub function.
+       */
+      addr_imp = (ptrdiff_t) base + r->sym;
+      addr_imp = *((ptrdiff_t *) addr_imp);
+
+      /* read existing relocation value from image, casting to the
+       * bitsize indicated by the 8 LSBs of flags. If the value is
+       * negative, manually sign-extend to ptrdiff_t width. Raise an
+       * error if the bitsize indicated by the 8 LSBs of flags is not
+       * supported.
+       */
+      switch ((r->flags & 0xff))
+        {
+          case 8:
+	    reldata = (ptrdiff_t) (*((unsigned char *)reloc_target));
+	    if ((reldata & 0x80) != 0)
+	      reldata |= ~((ptrdiff_t) 0xff);
+	    break;
+	  case 16:
+	    reldata = (ptrdiff_t) (*((unsigned short *)reloc_target));
+	    if ((reldata & 0x8000) != 0)
+	      reldata |= ~((ptrdiff_t) 0xffff);
+	    break;
+	  case 32:
+	    reldata = (ptrdiff_t) (*((unsigned int *)reloc_target));
+#ifdef _WIN64
+	    if ((reldata & 0x80000000) != 0)
+	      reldata |= ~((ptrdiff_t) 0xffffffff);
+#endif
+	    break;
+#ifdef _WIN64
+	  case 64:
+	    reldata = (ptrdiff_t) (*((unsigned long long *)reloc_target));
+	    break;
+#endif
+	  default:
+	    reldata=0;
+	    __report_error ("  Unknown pseudo relocation bit size %d.\n",
+		    (int) (r->flags & 0xff));
+	    break;
+        }
+
+      /* Adjust the relocation value */
+      reldata -= ((ptrdiff_t) base + r->sym);
+      reldata += addr_imp;
+
+      /* Write the new relocation value back to *reloc_target */
+      switch ((r->flags & 0xff))
+	{
+         case 8:
+           __write_memory ((void *) reloc_target, &reldata, 1);
+	   break;
+	 case 16:
+           __write_memory ((void *) reloc_target, &reldata, 2);
+	   break;
+	 case 32:
+           __write_memory ((void *) reloc_target, &reldata, 4);
+	   break;
+#ifdef _WIN64
+	 case 64:
+           __write_memory ((void *) reloc_target, &reldata, 8);
+	   break;
+#endif
+	}
+     }
+}
+
+void
+_pei386_runtime_relocator (void)
+{
+  static NO_COPY int was_init = 0;
+#ifdef __MINGW64_VERSION_MAJOR
+  int mSecs;
+#endif /* __MINGW64_VERSION_MAJOR */
+
+  if (was_init)
+    return;
+  ++was_init;
+#ifdef __MINGW64_VERSION_MAJOR
+  mSecs = __mingw_GetSectionCount ();
+  the_secs = (sSecInfo *) alloca (sizeof (sSecInfo) * (size_t) mSecs);
+  maxSections = 0;
+#endif /* __MINGW64_VERSION_MAJOR */
+
+  do_pseudo_reloc (&__RUNTIME_PSEUDO_RELOC_LIST__,
+		   &__RUNTIME_PSEUDO_RELOC_LIST_END__,
+#ifdef __GNUC__
+		   &__MINGW_LSYMBOL(_image_base__)
+#else
+		   &__ImageBase
+#endif
+		   );
+#ifdef __MINGW64_VERSION_MAJOR
+  restore_modified_sections ();
+#endif /* __MINGW64_VERSION_MAJOR */
+}

@@ -0,0 +1,13 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ *
+ * Written by Kai Tietz  <kai.tietz@onevision.com>
+ */
+
+/* We support TLS cleanup code in any case. If shared version of libgcc is used _CRT_MT has value 1,
+ otherwise
+   we do tls cleanup in runtime and _CRT_MT has value 2.  */
+int _CRT_MT = 2;
+

@@ -0,0 +1,33 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ *
+ * Written by Kai Tietz  <kai.tietz@onevision.com>
+ */
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <stdlib.h>
+
+int __mingwthr_key_dtor (DWORD key, void (*dtor)(void *));
+int __mingwthr_remove_key_dtor (DWORD key);
+
+extern int ___w64_mingwthr_remove_key_dtor (DWORD key);
+extern int ___w64_mingwthr_add_key_dtor (DWORD key, void (*dtor)(void *));
+
+int
+__mingwthr_remove_key_dtor (DWORD key)
+{
+   return ___w64_mingwthr_remove_key_dtor (key);
+}
+
+int
+__mingwthr_key_dtor (DWORD key, void (*dtor)(void *))
+{
+  if (dtor)
+    return ___w64_mingwthr_add_key_dtor (key, dtor);
+
+  return 0;
+}

@@ -0,0 +1,175 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ *
+ * Written by Kai Tietz  <kai.tietz@onevision.com>
+ */
+
+#ifdef CRTDLL
+#undef CRTDLL
+#endif
+
+#include <sect_attribs.h>
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+
+#include <stdio.h>
+#include <memory.h>
+#include <malloc.h>
+#include <corecrt_startup.h>
+
+extern WINBOOL __mingw_TLScallback (HANDLE hDllHandle, DWORD reason, LPVOID reserved);
+
+#define FUNCS_PER_NODE 30
+
+typedef struct TlsDtorNode {
+  int count;
+  struct TlsDtorNode *next;
+  _PVFV funcs[FUNCS_PER_NODE];
+} TlsDtorNode;
+
+ULONG _tls_index = 0;
+
+/* TLS raw template data start and end. 
+   We use here pointer-types for start/end so that tls-data remains
+   aligned on pointer-size-width.  This seems to be required for
+   pe-loader. */
+_CRTALLOC(".tls") char *_tls_start = NULL;
+_CRTALLOC(".tls$ZZZ") char *_tls_end = NULL;
+
+_CRTALLOC(".CRT$XLA") PIMAGE_TLS_CALLBACK __xl_a = 0;
+_CRTALLOC(".CRT$XLZ") PIMAGE_TLS_CALLBACK __xl_z = 0;
+
+const IMAGE_TLS_DIRECTORY _tls_used = {
+  (ULONG_PTR) &_tls_start, (ULONG_PTR) &_tls_end,
+  (ULONG_PTR) &_tls_index, (ULONG_PTR) (&__xl_a+1),
+  (ULONG) 0, (ULONG) 0
+};
+
+#ifndef __CRT_THREAD
+#ifdef HAVE_ATTRIBUTE_THREAD
+#define __CRT_THREAD	__declspec(thread)
+#else
+#define __CRT_THREAD    __thread
+#endif
+#endif
+
+#define DISABLE_MS_TLS 1
+
+static _CRTALLOC(".CRT$XDA") _PVFV __xd_a = 0;
+static _CRTALLOC(".CRT$XDZ") _PVFV __xd_z = 0;
+
+#if !defined (DISABLE_MS_TLS)
+static __CRT_THREAD TlsDtorNode *dtor_list;
+static __CRT_THREAD TlsDtorNode dtor_list_head;
+#endif
+
+extern int _CRT_MT;
+
+BOOL WINAPI __dyn_tls_init (HANDLE, DWORD, LPVOID);
+
+BOOL WINAPI
+__dyn_tls_init (HANDLE hDllHandle, DWORD dwReason, LPVOID lpreserved)
+{
+  _PVFV *pfunc;
+  uintptr_t ps;
+
+  /* We don't let us trick here.  */
+  if (_CRT_MT != 2)
+   _CRT_MT = 2;
+
+  if (dwReason != DLL_THREAD_ATTACH)
+    {
+      if (dwReason == DLL_PROCESS_ATTACH)
+        __mingw_TLScallback (hDllHandle, dwReason, lpreserved);
+      return TRUE;
+    }
+
+  ps = (uintptr_t) &__xd_a;
+  ps += sizeof (uintptr_t);
+  for ( ; ps != (uintptr_t) &__xd_z; ps += sizeof (uintptr_t))
+    {
+      pfunc = (_PVFV *) ps;
+      if (*pfunc != NULL)
+	(*pfunc)();
+    }
+  return TRUE;
+}
+
+const PIMAGE_TLS_CALLBACK __dyn_tls_init_callback = (const PIMAGE_TLS_CALLBACK) __dyn_tls_init;
+_CRTALLOC(".CRT$XLC") PIMAGE_TLS_CALLBACK __xl_c = (PIMAGE_TLS_CALLBACK) __dyn_tls_init;
+
+int __cdecl __tlregdtor (_PVFV);
+
+int __cdecl
+__tlregdtor (_PVFV func)
+{
+  if (!func)
+    return 0;
+#if !defined (DISABLE_MS_TLS)
+  if (dtor_list == NULL)
+    {
+      dtor_list = &dtor_list_head;
+      dtor_list_head.count = 0;
+    }
+    else if (dtor_list->count == FUNCS_PER_NODE)
+    {
+      TlsDtorNode *pnode = (TlsDtorNode *) malloc (sizeof (TlsDtorNode));
+      if (pnode == NULL)
+	return -1;
+      pnode->count = 0;
+      pnode->next = dtor_list;
+      dtor_list = pnode;
+
+      dtor_list->count = 0;
+    }
+  dtor_list->funcs[dtor_list->count++] = func;
+#endif
+  return 0;
+}
+
+static BOOL WINAPI
+__dyn_tls_dtor (HANDLE hDllHandle, DWORD dwReason, LPVOID lpreserved)
+{
+#if !defined (DISABLE_MS_TLS)
+  TlsDtorNode *pnode, *pnext;
+  int i;
+#endif
+
+  if (dwReason != DLL_THREAD_DETACH && dwReason != DLL_PROCESS_DETACH)
+    return TRUE;
+  /* As TLS variables are detroyed already by DLL_THREAD_DETACH
+     call, we have to avoid access on the possible DLL_PROCESS_DETACH
+     call the already destroyed TLS vars.
+     TODO: The used local thread based variables have to be handled
+     manually, so that we can control their lifetime here.  */
+#if !defined (DISABLE_MS_TLS)
+  if (dwReason != DLL_PROCESS_DETACH)
+    {
+      for (pnode = dtor_list; pnode != NULL; pnode = pnext)
+        {
+          for (i = pnode->count - 1; i >= 0; --i)
+	    {
+	      if (pnode->funcs[i] != NULL)
+	        (*pnode->funcs[i])();
+	    }
+          pnext = pnode->next;
+          if (pnext != NULL)
+	    free ((void *) pnode);
+        }
+    }
+#endif
+  __mingw_TLScallback (hDllHandle, dwReason, lpreserved);
+  return TRUE;
+}
+
+_CRTALLOC(".CRT$XLD") PIMAGE_TLS_CALLBACK __xl_d = (PIMAGE_TLS_CALLBACK) __dyn_tls_dtor;
+
+
+int mingw_initltsdrot_force = 0;
+int mingw_initltsdyn_force = 0;
+int mingw_initltssuo_force = 0;