Clean up RTS Linker Windows.
authorTamar Christina <tamar@zhox.com>
Wed, 18 Jan 2017 21:21:40 +0000 (16:21 -0500)
committerBen Gamari <ben@smart-cactus.org>
Wed, 18 Jan 2017 22:39:48 +0000 (17:39 -0500)
Clean up the linker code for PE.

1. Stop copying structures from the windows header
   and use those that are in the headers. There's no
   point in copying them and we got a few types wrong.

2. Replace custom typedef with C99 types. If we're not
   going to use the Windows type aliases, at least use
   standard ones.

Test Plan: ./validate

Reviewers: simonmar, austin, erikd, bgamari

Reviewed By: simonmar, bgamari

Subscribers: dfeuer, thomie, #ghc_windows_task_force

Differential Revision: https://phabricator.haskell.org/D2944

rts/linker/PEi386.c
rts/linker/PEi386.h

index 1d0682b..824c821 100644 (file)
 #include <shfolder.h> /* SHGetFolderPathW */
 #include <math.h>
 #include <wchar.h>
 #include <shfolder.h> /* SHGetFolderPathW */
 #include <math.h>
 #include <wchar.h>
+#include <stdbool.h>
+#include <stdint.h>
 
 
-static UChar *cstring_from_COFF_symbol_name(
-    UChar* name,
-    UChar* strtab);
+static uint8_t* cstring_from_COFF_symbol_name(
+    uint8_t* name,
+    uint8_t* strtab);
 
 #if defined(x86_64_HOST_ARCH)
 static size_t makeSymbolExtra_PEi386(
     ObjectCode* oc,
     size_t s,
 
 #if defined(x86_64_HOST_ARCH)
 static size_t makeSymbolExtra_PEi386(
     ObjectCode* oc,
     size_t s,
-    char* symbol);
+    SymbolName* symbol);
 #endif
 
 static void addDLLHandle(
     pathchar* dll_name,
     HINSTANCE instance);
 
 #endif
 
 static void addDLLHandle(
     pathchar* dll_name,
     HINSTANCE instance);
 
-static int verifyCOFFHeader(
+static bool verifyCOFFHeader(
     COFF_header *hdr,
     pathchar *filename);
 
     COFF_header *hdr,
     pathchar *filename);
 
@@ -93,10 +95,6 @@ static int verifyCOFFHeader(
 extern IMAGE_DOS_HEADER __ImageBase;
 #define __image_base (void*)((HINSTANCE)&__ImageBase)
 
 extern IMAGE_DOS_HEADER __ImageBase;
 #define __image_base (void*)((HINSTANCE)&__ImageBase)
 
-// MingW-w64 is missing these from the implementation. So we have to look them up
-typedef DLL_DIRECTORY_COOKIE(WINAPI *LPAddDLLDirectory)(PCWSTR NewDirectory);
-typedef WINBOOL(WINAPI *LPRemoveDLLDirectory)(DLL_DIRECTORY_COOKIE Cookie);
-
 void initLinker_PEi386()
 {
     if (!ghciInsertSymbolTable(WSTR("(GHCi/Ld special symbols)"),
 void initLinker_PEi386()
 {
     if (!ghciInsertSymbolTable(WSTR("(GHCi/Ld special symbols)"),
@@ -116,26 +114,9 @@ void initLinker_PEi386()
 #endif
 }
 
 #endif
 }
 
-/* A record for storing handles into DLLs. */
-typedef
-struct _OpenedDLL {
-    pathchar*          name;
-    struct _OpenedDLL* next;
-    HINSTANCE instance;
-}
-    OpenedDLL;
-
 /* A list thereof. */
 static OpenedDLL* opened_dlls = NULL;
 
 /* A list thereof. */
 static OpenedDLL* opened_dlls = NULL;
 
-/* A record for storing indirectly linked functions from DLLs. */
-typedef
-struct _IndirectAddr {
-    SymbolAddr*           addr;
-    struct _IndirectAddr* next;
-}
-    IndirectAddr;
-
 /* A list thereof. */
 static IndirectAddr* indirects = NULL;
 
 /* A list thereof. */
 static IndirectAddr* indirects = NULL;
 
@@ -168,11 +149,11 @@ addDLL_PEi386( pathchar *dll_name )
 {
    /* ------------------- Win32 DLL loader ------------------- */
 
 {
    /* ------------------- Win32 DLL loader ------------------- */
 
-   pathchar*      buf;
+   pathchar*  buf;
    OpenedDLL* o_dll;
    HINSTANCE  instance;
 
    OpenedDLL* o_dll;
    HINSTANCE  instance;
 
-   IF_DEBUG(linker, debugBelch("\naddDLL; dll_name = `%" PATH_FMT "'\n", dll_name));
+   IF_DEBUG(linker, debugBelch("addDLL; dll_name = `%" PATH_FMT "'\n", dll_name));
 
    /* See if we've already got it, and ignore if so. */
    for (o_dll = opened_dlls; o_dll != NULL; o_dll = o_dll->next) {
 
    /* See if we've already got it, and ignore if so. */
    for (o_dll = opened_dlls; o_dll != NULL; o_dll = o_dll->next) {
@@ -197,8 +178,7 @@ addDLL_PEi386( pathchar *dll_name )
    const wchar_t *formats[] = { L"%ls.DLL", L"%ls.DRV", L"lib%ls.DLL", L"%ls" };
    const DWORD flags[]      = { LOAD_LIBRARY_SEARCH_USER_DIRS | LOAD_LIBRARY_SEARCH_DEFAULT_DIRS, 0 };
 
    const wchar_t *formats[] = { L"%ls.DLL", L"%ls.DRV", L"lib%ls.DLL", L"%ls" };
    const DWORD flags[]      = { LOAD_LIBRARY_SEARCH_USER_DIRS | LOAD_LIBRARY_SEARCH_DEFAULT_DIRS, 0 };
 
-   int cFormat;
-   int cFlag;
+   int cFormat, cFlag;
    int flags_start = 1; // Assume we don't support the new API
 
    /* Detect if newer API are available, if not, skip the first flags entry */
    int flags_start = 1; // Assume we don't support the new API
 
    /* Detect if newer API are available, if not, skip the first flags entry */
@@ -250,7 +230,7 @@ error:
 pathchar* findSystemLibrary_PEi386( pathchar* dll_name )
 {
     const unsigned int init_buf_size = 1024;
 pathchar* findSystemLibrary_PEi386( pathchar* dll_name )
 {
     const unsigned int init_buf_size = 1024;
-    unsigned int bufsize     = init_buf_size;
+    unsigned int bufsize             = init_buf_size;
     wchar_t* result = malloc(sizeof(wchar_t) * bufsize);
     DWORD wResult   = SearchPathW(NULL, dll_name, NULL, bufsize, result, NULL);
 
     wchar_t* result = malloc(sizeof(wchar_t) * bufsize);
     DWORD wResult   = SearchPathW(NULL, dll_name, NULL, bufsize, result, NULL);
 
@@ -276,7 +256,7 @@ HsPtr addLibrarySearchPath_PEi386(pathchar* dll_path)
     HsPtr result = NULL;
 
     const unsigned int init_buf_size = 4096;
     HsPtr result = NULL;
 
     const unsigned int init_buf_size = 4096;
-    int bufsize = init_buf_size;
+    int bufsize                      = init_buf_size;
 
     // Make sure the path is an absolute path
     WCHAR* abs_path = malloc(sizeof(WCHAR) * init_buf_size);
 
     // Make sure the path is an absolute path
     WCHAR* abs_path = malloc(sizeof(WCHAR) * init_buf_size);
@@ -335,9 +315,9 @@ HsPtr addLibrarySearchPath_PEi386(pathchar* dll_path)
     return result;
 }
 
     return result;
 }
 
-HsBool removeLibrarySearchPath_PEi386(HsPtr dll_path_index)
+bool removeLibrarySearchPath_PEi386(HsPtr dll_path_index)
 {
 {
-    HsBool result = 0;
+    bool result = false;
 
     if (dll_path_index != NULL) {
         HINSTANCE hDLL = LoadLibraryW(L"Kernel32.DLL");
 
     if (dll_path_index != NULL) {
         HINSTANCE hDLL = LoadLibraryW(L"Kernel32.DLL");
@@ -356,11 +336,11 @@ HsBool removeLibrarySearchPath_PEi386(HsPtr dll_path_index)
 
         if (!result) {
             sysErrorBelch("removeLibrarySearchPath: (Win32 error %lu)", GetLastError());
 
         if (!result) {
             sysErrorBelch("removeLibrarySearchPath: (Win32 error %lu)", GetLastError());
-            return HS_BOOL_FALSE;
+            return false;
         }
     }
 
         }
     }
 
-    return result == 0 ? HS_BOOL_TRUE : HS_BOOL_FALSE;
+    return result == 0;
 }
 
 
 }
 
 
@@ -384,12 +364,12 @@ allocateImageAndTrampolines (
        size_t n;
 
        n = fread(&hdr, 1, sizeof_COFF_header, f);
        size_t n;
 
        n = fread(&hdr, 1, sizeof_COFF_header, f);
-       if (n != sizeof(COFF_header)) {
-           errorBelch("getNumberOfSymbols: error whilst reading `%s' header in `%S'",
+       if (n != sizeof_COFF_header) {
+           errorBelch("getNumberOfSymbols: error whilst reading `%s' header in `%" PATH_FMT "'",
                member_name, arch_name);
            return NULL;
        }
                member_name, arch_name);
            return NULL;
        }
-       fseek(f, -sizeof_COFF_header, SEEK_CUR);
+       fseek(f, -(long int)sizeof_COFF_header, SEEK_CUR);
 
        if (!verifyCOFFHeader(&hdr, arch_name)) {
            return 0;
 
        if (!verifyCOFFHeader(&hdr, arch_name)) {
            return 0;
@@ -421,27 +401,27 @@ allocateImageAndTrampolines (
    return image + PEi386_IMAGE_OFFSET;
 }
 
    return image + PEi386_IMAGE_OFFSET;
 }
 
-int findAndLoadImportLibrary(ObjectCode* oc)
+bool findAndLoadImportLibrary(ObjectCode* oc)
 {
     int i;
 
     COFF_header*  hdr;
     COFF_section* sectab;
     COFF_symbol*  symtab;
 {
     int i;
 
     COFF_header*  hdr;
     COFF_section* sectab;
     COFF_symbol*  symtab;
-    UChar*        strtab;
+    uint8_t*      strtab;
 
     hdr = (COFF_header*)(oc->image);
     sectab = (COFF_section*)(
 
     hdr = (COFF_header*)(oc->image);
     sectab = (COFF_section*)(
-        ((UChar*)(oc->image))
+        ((uint8_t*)(oc->image))
         + sizeof_COFF_header + hdr->SizeOfOptionalHeader
         );
 
     symtab = (COFF_symbol*)(
         + sizeof_COFF_header + hdr->SizeOfOptionalHeader
         );
 
     symtab = (COFF_symbol*)(
-        ((UChar*)(oc->image))
+        ((uint8_t*)(oc->image))
         + hdr->PointerToSymbolTable
         );
 
         + hdr->PointerToSymbolTable
         );
 
-    strtab = ((UChar*)symtab)
+    strtab = ((uint8_t*)symtab)
         + hdr->NumberOfSymbols * sizeof_COFF_symbol;
 
     for (i = 0; i < oc->n_sections; i++)
         + hdr->NumberOfSymbols * sizeof_COFF_symbol;
 
     for (i = 0; i < oc->n_sections; i++)
@@ -476,7 +456,7 @@ int findAndLoadImportLibrary(ObjectCode* oc)
 
             if (result != NULL) {
                 errorBelch("Could not load `%s'. Reason: %s\n", (char*)dllName, result);
 
             if (result != NULL) {
                 errorBelch("Could not load `%s'. Reason: %s\n", (char*)dllName, result);
-                return 0;
+                return false;
             }
 
             break;
             }
 
             break;
@@ -485,13 +465,13 @@ int findAndLoadImportLibrary(ObjectCode* oc)
         stgFree(secname);
     }
 
         stgFree(secname);
     }
 
-    return 1;
+    return true;
 }
 
 }
 
-int checkAndLoadImportLibrary( pathchar* arch_name, char* member_name, FILE* f)
+bool checkAndLoadImportLibrary( pathchar* arch_name, char* member_name, FILE* f )
 {
     char* image;
 {
     char* image;
-    static HsBool load_dll_warn = HS_BOOL_FALSE;
+    static bool load_dll_warn = false;
 
     if (load_dll_warn) { return 0; }
 
 
     if (load_dll_warn) { return 0; }
 
@@ -504,16 +484,16 @@ int checkAndLoadImportLibrary( pathchar* arch_name, char* member_name, FILE* f)
     if (n != sizeof(COFF_header)) {
         errorBelch("getNumberOfSymbols: error whilst reading `%s' header in `%" PATH_FMT "'\n",
             member_name, arch_name);
     if (n != sizeof(COFF_header)) {
         errorBelch("getNumberOfSymbols: error whilst reading `%s' header in `%" PATH_FMT "'\n",
             member_name, arch_name);
-        return 0;
+        return false;
     }
 
     }
 
-    if (hdr.Sig1 != 0x0 || hdr.Sig2 != 0xFFFF) {
-        fseek(f, -sizeof_COFF_import_Header, SEEK_CUR);
+    if (hdr.Sig1 != 0x0 || hdr.Sig2 != IMPORT_OBJECT_HDR_SIG2) {
+        fseek(f, -(long int)sizeof_COFF_import_Header, SEEK_CUR);
         IF_DEBUG(linker, debugBelch("loadArchive: Object `%s` is not an import lib. Skipping...\n", member_name));
         IF_DEBUG(linker, debugBelch("loadArchive: Object `%s` is not an import lib. Skipping...\n", member_name));
-        return 0;
+        return false;
     }
 
     }
 
-    IF_DEBUG(linker, debugBelch("loadArchive: reading %d bytes at %ld\n", hdr.SizeOfData, ftell(f)));
+    IF_DEBUG(linker, debugBelch("loadArchive: reading %lu bytes at %ld\n", hdr.SizeOfData, ftell(f)));
 
     image = malloc(hdr.SizeOfData);
     n = fread(image, 1, hdr.SizeOfData, f);
 
     image = malloc(hdr.SizeOfData);
     n = fread(image, 1, hdr.SizeOfData, f);
@@ -531,29 +511,29 @@ int checkAndLoadImportLibrary( pathchar* arch_name, char* member_name, FILE* f)
     mbstowcs(dll, dllName, nameLen);
     free(dllName);
 
     mbstowcs(dll, dllName, nameLen);
     free(dllName);
 
-    IF_DEBUG(linker, debugBelch("loadArchive: read symbol %s from lib `%ls'\n", symbol, dll));
+    IF_DEBUG(linker, debugBelch("loadArchive: read symbol %s from lib `%" PATH_FMT "'\n", symbol, dll));
     const char* result = addDLL(dll);
 
     free(image);
 
     if (result != NULL) {
     const char* result = addDLL(dll);
 
     free(image);
 
     if (result != NULL) {
-        errorBelch("Could not load `%ls'. Reason: %s\n", dll, result);
-        load_dll_warn = HS_BOOL_TRUE;
+        errorBelch("Could not load `%" PATH_FMT "'. Reason: %s\n", dll, result);
+        load_dll_warn = true;
 
         free(dll);
         fseek(f, -(n + sizeof_COFF_import_Header), SEEK_CUR);
 
         free(dll);
         fseek(f, -(n + sizeof_COFF_import_Header), SEEK_CUR);
-        return 0;
+        return false;
     }
 
     free(dll);
     }
 
     free(dll);
-    return 1;
+    return true;
 }
 
 static void
 }
 
 static void
-printName ( UChar* name, UChar* strtab )
+printName ( uint8_t* name, uint8_t* strtab )
 {
    if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
 {
    if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
-      UInt32 strtab_offset = * (UInt32*)(name+4);
+      uint32_t strtab_offset = * (uint32_t*)(name+4);
       debugBelch("%s", strtab + strtab_offset );
    } else {
       int i;
       debugBelch("%s", strtab + strtab_offset );
    } else {
       int i;
@@ -566,10 +546,10 @@ printName ( UChar* name, UChar* strtab )
 
 
 static void
 
 
 static void
-copyName ( UChar* name, UChar* strtab, UChar* dst, int dstSize )
+copyName ( uint8_t* name, uint8_t* strtab, uint8_t* dst, int dstSize )
 {
    if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
 {
    if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
-      UInt32 strtab_offset = * (UInt32*)(name+4);
+      uint32_t strtab_offset = * (uint32_t*)(name+4);
       strncpy ( (char*)dst, (char*)strtab+strtab_offset, dstSize );
       dst[dstSize-1] = 0;
    } else {
       strncpy ( (char*)dst, (char*)strtab+strtab_offset, dstSize );
       dst[dstSize-1] = 0;
    } else {
@@ -585,16 +565,16 @@ copyName ( UChar* name, UChar* strtab, UChar* dst, int dstSize )
 }
 
 
 }
 
 
-static UChar *
-cstring_from_COFF_symbol_name ( UChar* name, UChar* strtab )
+static uint8_t *
+cstring_from_COFF_symbol_name ( uint8_t* name, uint8_t* strtab )
 {
 {
-   UChar* newstr;
+   uint8_t* newstr;
    /* If the string is longer than 8 bytes, look in the
       string table for it -- this will be correctly zero terminated.
    */
    if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
    /* If the string is longer than 8 bytes, look in the
       string table for it -- this will be correctly zero terminated.
    */
    if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
-      UInt32 strtab_offset = * (UInt32*)(name+4);
-      return ((UChar*)strtab) + strtab_offset;
+      uint32_t strtab_offset = * (uint32_t*)(name+4);
+      return strtab + strtab_offset;
    }
    /* Otherwise, if shorter than 8 bytes, return the original,
       which by defn is correctly terminated.
    }
    /* Otherwise, if shorter than 8 bytes, return the original,
       which by defn is correctly terminated.
@@ -616,7 +596,7 @@ cstring_from_COFF_symbol_name ( UChar* name, UChar* strtab )
    consistency we *always* copy the string; the caller must free it
 */
 char *
    consistency we *always* copy the string; the caller must free it
 */
 char *
-cstring_from_section_name (UChar* name, UChar* strtab)
+cstring_from_section_name (uint8_t* name, uint8_t* strtab)
 {
     char *newstr;
 
 {
     char *newstr;
 
@@ -625,14 +605,14 @@ cstring_from_section_name (UChar* name, UChar* strtab)
         int len = strlen(((char*)strtab) + strtab_offset);
 
         newstr = stgMallocBytes(len+1, "cstring_from_section_symbol_name");
         int len = strlen(((char*)strtab) + strtab_offset);
 
         newstr = stgMallocBytes(len+1, "cstring_from_section_symbol_name");
-        strcpy((char*)newstr, (char*)((UChar*)strtab) + strtab_offset);
+        strcpy(newstr, (char*)strtab + strtab_offset);
         return newstr;
     }
     else
     {
         newstr = stgMallocBytes(9, "cstring_from_section_symbol_name");
         ASSERT(newstr);
         return newstr;
     }
     else
     {
         newstr = stgMallocBytes(9, "cstring_from_section_symbol_name");
         ASSERT(newstr);
-        strncpy((char*)newstr,(char*)name,8);
+        strncpy(newstr,(char*)name,8);
         newstr[8] = 0;
         return newstr;
     }
         newstr[8] = 0;
         return newstr;
     }
@@ -641,7 +621,7 @@ cstring_from_section_name (UChar* name, UChar* strtab)
 /* See Note [mingw-w64 name decoration scheme] */
 #ifndef x86_64_HOST_ARCH
 static void
 /* See Note [mingw-w64 name decoration scheme] */
 #ifndef x86_64_HOST_ARCH
 static void
-zapTrailingAtSign ( UChar* sym )
+zapTrailingAtSign ( uint8_t* sym )
 {
 #  define my_isdigit(c) ((c) >= '0' && (c) <= '9')
    int i, j;
 {
 #  define my_isdigit(c) ((c) >= '0' && (c) <= '9')
    int i, j;
@@ -656,31 +636,8 @@ zapTrailingAtSign ( UChar* sym )
 }
 #endif
 
 }
 #endif
 
-/* See Note [mingw-w64 name decoration scheme] */
-#ifndef x86_64_HOST_ARCH
-#define STRIP_LEADING_UNDERSCORE 1
-#else
-#define STRIP_LEADING_UNDERSCORE 0
-#endif
-
-/*
-  Note [mingw-w64 name decoration scheme]
-
-  What's going on with name decoration? Well, original code
-  have some crufty and ad-hocish paths related mostly to very old
-  mingw gcc/binutils/runtime combinations. Now mingw-w64 offers pretty
-  uniform and MS-compatible decoration scheme across its tools and runtime.
-
-  The scheme is pretty straightforward: on 32 bit objects symbols are exported
-  with underscore prepended (and @ + stack size suffix appended for stdcall
-  functions), on 64 bits no underscore is prepended and no suffix is appended
-  because we have no stdcall convention on 64 bits.
-
-  See #9218
-*/
-
 SymbolAddr*
 SymbolAddr*
-lookupSymbolInDLLs ( UChar *lbl )
+lookupSymbolInDLLs ( uint8_t *lbl )
 {
     OpenedDLL* o_dll;
     SymbolAddr* sym;
 {
     OpenedDLL* o_dll;
     SymbolAddr* sym;
@@ -725,18 +682,18 @@ lookupSymbolInDLLs ( UChar *lbl )
     return NULL;
 }
 
     return NULL;
 }
 
-static int
-verifyCOFFHeader (COFF_header *hdr, pathchar *fileName)
+static bool
+verifyCOFFHeader ( COFF_header *hdr, pathchar *fileName )
 {
 #if defined(i386_HOST_ARCH)
 {
 #if defined(i386_HOST_ARCH)
-   if (hdr->Machine != 0x14c) {
+   if (hdr->Machine != IMAGE_FILE_MACHINE_I386) {
       errorBelch("%" PATH_FMT ": Not x86 PEi386", fileName);
       errorBelch("%" PATH_FMT ": Not x86 PEi386", fileName);
-      return 0;
+      return false;
    }
 #elif defined(x86_64_HOST_ARCH)
    }
 #elif defined(x86_64_HOST_ARCH)
-   if (hdr->Machine != 0x8664) {
+   if (hdr->Machine != IMAGE_FILE_MACHINE_AMD64) {
       errorBelch("%" PATH_FMT ": Not x86_64 PEi386", fileName);
       errorBelch("%" PATH_FMT ": Not x86_64 PEi386", fileName);
-      return 0;
+      return false;
    }
 #else
    errorBelch("PEi386 not supported on this arch");
    }
 #else
    errorBelch("PEi386 not supported on this arch");
@@ -747,60 +704,60 @@ verifyCOFFHeader (COFF_header *hdr, pathchar *fileName)
                  fileName);
       return 0;
    }
                  fileName);
       return 0;
    }
-   if ( /* (hdr->Characteristics & MYIMAGE_FILE_RELOCS_STRIPPED) || */
-        (hdr->Characteristics & MYIMAGE_FILE_EXECUTABLE_IMAGE) ||
-        (hdr->Characteristics & MYIMAGE_FILE_DLL) ||
-        (hdr->Characteristics & MYIMAGE_FILE_SYSTEM) ) {
+   if ( /* (hdr->Characteristics & IMAGE_FILE_RELOCS_STRIPPED) || */
+        (hdr->Characteristics & IMAGE_FILE_EXECUTABLE_IMAGE) ||
+        (hdr->Characteristics & IMAGE_FILE_DLL             ) ||
+        (hdr->Characteristics & IMAGE_FILE_SYSTEM          ) ) {
       errorBelch("%" PATH_FMT ": Not a PEi386 object file", fileName);
       errorBelch("%" PATH_FMT ": Not a PEi386 object file", fileName);
-      return 0;
+      return false;
    }
    }
-   if ( (hdr->Characteristics & MYIMAGE_FILE_BYTES_REVERSED_HI)
-        /* || !(hdr->Characteristics & MYIMAGE_FILE_32BIT_MACHINE) */ ) {
+   if ( (hdr->Characteristics & IMAGE_FILE_BYTES_REVERSED_HI)
+        /* || !(hdr->Characteristics & IMAGE_FILE_32BIT_MACHINE) */ ) {
       errorBelch("%" PATH_FMT ": Invalid PEi386 word size or endiannness: %d",
                  fileName,
                  (int)(hdr->Characteristics));
       errorBelch("%" PATH_FMT ": Invalid PEi386 word size or endiannness: %d",
                  fileName,
                  (int)(hdr->Characteristics));
-      return 0;
+      return false;
    }
    }
-   return 1;
+   return true;
 }
 
 }
 
-int
+bool
 ocVerifyImage_PEi386 ( ObjectCode* oc )
 {
    int i;
 ocVerifyImage_PEi386 ( ObjectCode* oc )
 {
    int i;
-   UInt32 j, noRelocs;
+   uint32_t j, noRelocs;
    COFF_header*  hdr;
    COFF_section* sectab;
    COFF_symbol*  symtab;
    COFF_header*  hdr;
    COFF_section* sectab;
    COFF_symbol*  symtab;
-   UChar*        strtab;
+   uint8_t*        strtab;
    /* debugBelch("\nLOADING %s\n", oc->fileName); */
    hdr = (COFF_header*)(oc->image);
    sectab = (COFF_section*) (
    /* debugBelch("\nLOADING %s\n", oc->fileName); */
    hdr = (COFF_header*)(oc->image);
    sectab = (COFF_section*) (
-               ((UChar*)(oc->image))
+               ((uint8_t*)(oc->image))
                + sizeof_COFF_header + hdr->SizeOfOptionalHeader
             );
    symtab = (COFF_symbol*) (
                + sizeof_COFF_header + hdr->SizeOfOptionalHeader
             );
    symtab = (COFF_symbol*) (
-               ((UChar*)(oc->image))
+               ((uint8_t*)(oc->image))
                + hdr->PointerToSymbolTable
             );
                + hdr->PointerToSymbolTable
             );
-   strtab = ((UChar*)symtab)
+   strtab = ((uint8_t*)symtab)
             + hdr->NumberOfSymbols * sizeof_COFF_symbol;
 
    if (!verifyCOFFHeader(hdr, oc->fileName)) {
             + hdr->NumberOfSymbols * sizeof_COFF_symbol;
 
    if (!verifyCOFFHeader(hdr, oc->fileName)) {
-       return 0;
+       return false;
    }
 
    /* If the string table size is way crazy, this might indicate that
       there are more than 64k relocations, despite claims to the
       contrary.  Hence this test. */
    }
 
    /* If the string table size is way crazy, this might indicate that
       there are more than 64k relocations, despite claims to the
       contrary.  Hence this test. */
-   /* debugBelch("strtab size %d\n", * (UInt32*)strtab); */
+   /* debugBelch("strtab size %d\n", * (uint32_t*)strtab); */
 #if 0
 #if 0
-   if ( (*(UInt32*)strtab) > 600000 ) {
+   if ( (*(uint32_t*)strtab) > 600000 ) {
       /* Note that 600k has no special significance other than being
          big enough to handle the almost-2MB-sized lumps that
          constitute HSwin32*.o. */
       debugBelch("PEi386 object has suspiciously large string table; > 64k relocs?");
       /* Note that 600k has no special significance other than being
          big enough to handle the almost-2MB-sized lumps that
          constitute HSwin32*.o. */
       debugBelch("PEi386 object has suspiciously large string table; > 64k relocs?");
-      return 0;
+      return false;
    }
 #endif
 
    }
 #endif
 
@@ -827,23 +784,23 @@ ocVerifyImage_PEi386 ( ObjectCode* oc )
    /* No further verification after this point; only debug printing. */
    i = 0;
    IF_DEBUG(linker, i=1);
    /* No further verification after this point; only debug printing. */
    i = 0;
    IF_DEBUG(linker, i=1);
-   if (i == 0) return 1;
+   if (i == 0) return true;
 
    debugBelch("sectab offset = %" FMT_SizeT "\n",
 
    debugBelch("sectab offset = %" FMT_SizeT "\n",
-              ((UChar*)sectab) - ((UChar*)hdr) );
+              ((uint8_t*)sectab) - ((uint8_t*)hdr) );
    debugBelch("symtab offset = %" FMT_SizeT "\n",
    debugBelch("symtab offset = %" FMT_SizeT "\n",
-              ((UChar*)symtab) - ((UChar*)hdr) );
+              ((uint8_t*)symtab) - ((uint8_t*)hdr) );
    debugBelch("strtab offset = %" FMT_SizeT "\n",
    debugBelch("strtab offset = %" FMT_SizeT "\n",
-              ((UChar*)strtab) - ((UChar*)hdr) );
+              ((uint8_t*)strtab) - ((uint8_t*)hdr) );
 
    debugBelch("\n" );
 
    debugBelch("\n" );
-   debugBelch( "Machine:           0x%x\n", (UInt32)(hdr->Machine) );
-   debugBelch( "# sections:        %d\n",   (UInt32)(hdr->NumberOfSections) );
-   debugBelch( "time/date:         0x%x\n", (UInt32)(hdr->TimeDateStamp) );
-   debugBelch( "symtab offset:     %d\n",   (UInt32)(hdr->PointerToSymbolTable) );
-   debugBelch( "# symbols:         %d\n",   (UInt32)(hdr->NumberOfSymbols) );
-   debugBelch( "sz of opt hdr:     %d\n",   (UInt32)(hdr->SizeOfOptionalHeader) );
-   debugBelch( "characteristics:   0x%x\n", (UInt32)(hdr->Characteristics) );
+   debugBelch( "Machine:           0x%x\n", (uint32_t)(hdr->Machine) );
+   debugBelch( "# sections:        %d\n",   (uint32_t)(hdr->NumberOfSections) );
+   debugBelch( "time/date:         0x%x\n", (uint32_t)(hdr->TimeDateStamp) );
+   debugBelch( "symtab offset:     %d\n",   (uint32_t)(hdr->PointerToSymbolTable) );
+   debugBelch( "# symbols:         %d\n",   (uint32_t)(hdr->NumberOfSymbols) );
+   debugBelch( "sz of opt hdr:     %d\n",   (uint32_t)(hdr->SizeOfOptionalHeader) );
+   debugBelch( "characteristics:   0x%x\n", (uint32_t)(hdr->Characteristics) );
 
    /* Print the section table. */
    debugBelch("\n" );
 
    /* Print the section table. */
    debugBelch("\n" );
@@ -862,14 +819,14 @@ ocVerifyImage_PEi386 ( ObjectCode* oc )
       printName ( sectab_i->Name, strtab );
       debugBelch(
                 "'\n"
       printName ( sectab_i->Name, strtab );
       debugBelch(
                 "'\n"
-                "    vsize %d\n"
-                "    vaddr %d\n"
-                "  data sz %d\n"
+                "    vsize %lu\n"
+                "    vaddr %lu\n"
+                "  data sz %lu\n"
                 " data off 0x%p\n"
                 " data off 0x%p\n"
-                "  num rel %d\n"
-                "  off rel %d\n"
-                "  ptr raw 0x%x\n",
-                sectab_i->VirtualSize,
+                "  num rel %hu\n"
+                "  off rel %lu\n"
+                "  ptr raw 0x%lx\n",
+                sectab_i->Misc.VirtualSize,
                 sectab_i->VirtualAddress,
                 sectab_i->SizeOfRawData,
                 section.start,
                 sectab_i->VirtualAddress,
                 sectab_i->SizeOfRawData,
                 section.start,
@@ -878,10 +835,10 @@ ocVerifyImage_PEi386 ( ObjectCode* oc )
                 sectab_i->PointerToRawData
               );
       reltab = (COFF_reloc*) (
                 sectab_i->PointerToRawData
               );
       reltab = (COFF_reloc*) (
-                  ((UChar*)(oc->image)) + sectab_i->PointerToRelocations
+                  ((uint8_t*)(oc->image)) + sectab_i->PointerToRelocations
                );
 
                );
 
-      if ( sectab_i->Characteristics & MYIMAGE_SCN_LNK_NRELOC_OVFL ) {
+      if ( sectab_i->Characteristics & IMAGE_SCN_LNK_NRELOC_OVFL ) {
         /* If the relocation field (a short) has overflowed, the
          * real count can be found in the first reloc entry.
          *
         /* If the relocation field (a short) has overflowed, the
          * real count can be found in the first reloc entry.
          *
@@ -901,22 +858,22 @@ ocVerifyImage_PEi386 ( ObjectCode* oc )
          COFF_reloc* rel = (COFF_reloc*)
                            myindex ( sizeof_COFF_reloc, reltab, j );
          debugBelch(
          COFF_reloc* rel = (COFF_reloc*)
                            myindex ( sizeof_COFF_reloc, reltab, j );
          debugBelch(
-                   "        type 0x%-4x   vaddr 0x%-8x   name `",
-                   (UInt32)rel->Type,
+                   "        type 0x%-4x   vaddr 0x%-8lx   name `",
+                   (uint32_t)rel->Type,
                    rel->VirtualAddress );
          sym = (COFF_symbol*)
                myindex ( sizeof_COFF_symbol, symtab, rel->SymbolTableIndex );
          /* Hmm..mysterious looking offset - what's it for? SOF */
                    rel->VirtualAddress );
          sym = (COFF_symbol*)
                myindex ( sizeof_COFF_symbol, symtab, rel->SymbolTableIndex );
          /* Hmm..mysterious looking offset - what's it for? SOF */
-         printName ( sym->Name, strtab -10 );
+         printName ( sym->N.ShortName, strtab -10 );
          debugBelch("'\n" );
       }
 
       debugBelch("\n" );
    }
    debugBelch("\n" );
          debugBelch("'\n" );
       }
 
       debugBelch("\n" );
    }
    debugBelch("\n" );
-   debugBelch("string table has size 0x%x\n", * (UInt32*)strtab );
+   debugBelch("string table has size 0x%x\n", * (uint32_t*)strtab );
    debugBelch("---START of string table---\n");
    debugBelch("---START of string table---\n");
-   for (i = 4; i < *(Int32*)strtab; i++) {
+   for (i = 4; i < *(int32_t*)strtab; i++) {
       if (strtab[i] == 0)
          debugBelch("\n"); else
          debugBelch("%c", strtab[i] );
       if (strtab[i] == 0)
          debugBelch("\n"); else
          debugBelch("%c", strtab[i] );
@@ -927,7 +884,7 @@ ocVerifyImage_PEi386 ( ObjectCode* oc )
    i = 0;
    while (1) {
       COFF_symbol* symtab_i;
    i = 0;
    while (1) {
       COFF_symbol* symtab_i;
-      if (i >= (Int32)(hdr->NumberOfSymbols)) break;
+      if (i >= (int32_t)(hdr->NumberOfSymbols)) break;
       symtab_i = (COFF_symbol*)
                  myindex ( sizeof_COFF_symbol, symtab, i );
       debugBelch(
       symtab_i = (COFF_symbol*)
                  myindex ( sizeof_COFF_symbol, symtab, i );
       debugBelch(
@@ -935,58 +892,58 @@ ocVerifyImage_PEi386 ( ObjectCode* oc )
                 "     name `",
                 i
               );
                 "     name `",
                 i
               );
-      printName ( symtab_i->Name, strtab );
+      printName ( symtab_i->N.ShortName, strtab );
       debugBelch(
                 "'\n"
       debugBelch(
                 "'\n"
-                "    value 0x%x\n"
+                "    value 0x%lx\n"
                 "   1+sec# %d\n"
                 "     type 0x%x\n"
                 "   sclass 0x%x\n"
                 "     nAux %d\n",
                 symtab_i->Value,
                 "   1+sec# %d\n"
                 "     type 0x%x\n"
                 "   sclass 0x%x\n"
                 "     nAux %d\n",
                 symtab_i->Value,
-                (Int32)(symtab_i->SectionNumber),
-                (UInt32)symtab_i->Type,
-                (UInt32)symtab_i->StorageClass,
-                (UInt32)symtab_i->NumberOfAuxSymbols
+                (int32_t)(symtab_i->SectionNumber),
+                (uint32_t)symtab_i->Type,
+                (uint32_t)symtab_i->StorageClass,
+                (uint32_t)symtab_i->NumberOfAuxSymbols
               );
       i += symtab_i->NumberOfAuxSymbols;
       i++;
    }
 
    debugBelch("\n" );
               );
       i += symtab_i->NumberOfAuxSymbols;
       i++;
    }
 
    debugBelch("\n" );
-   return 1;
+   return true;
 }
 
 }
 
-int
+bool
 ocGetNames_PEi386 ( ObjectCode* oc )
 {
    COFF_header*  hdr;
    COFF_section* sectab;
    COFF_symbol*  symtab;
 ocGetNames_PEi386 ( ObjectCode* oc )
 {
    COFF_header*  hdr;
    COFF_section* sectab;
    COFF_symbol*  symtab;
-   UChar*        strtab;
+   uint8_t*        strtab;
 
 
-   UChar*     sname;
+   uint8_t*     sname;
    SymbolAddr* addr;
    int        i;
 
    hdr = (COFF_header*)(oc->image);
    sectab = (COFF_section*) (
    SymbolAddr* addr;
    int        i;
 
    hdr = (COFF_header*)(oc->image);
    sectab = (COFF_section*) (
-               ((UChar*)(oc->image))
+               ((uint8_t*)(oc->image))
                + sizeof_COFF_header + hdr->SizeOfOptionalHeader
             );
    symtab = (COFF_symbol*) (
                + sizeof_COFF_header + hdr->SizeOfOptionalHeader
             );
    symtab = (COFF_symbol*) (
-               ((UChar*)(oc->image))
+               ((uint8_t*)(oc->image))
                + hdr->PointerToSymbolTable
             );
                + hdr->PointerToSymbolTable
             );
-   strtab = ((UChar*)(oc->image))
+   strtab = ((uint8_t*)(oc->image))
             + hdr->PointerToSymbolTable
             + hdr->NumberOfSymbols * sizeof_COFF_symbol;
 
    /* Allocate space for any (local, anonymous) .bss sections. */
 
    for (i = 0; i < hdr->NumberOfSections; i++) {
             + hdr->PointerToSymbolTable
             + hdr->NumberOfSymbols * sizeof_COFF_symbol;
 
    /* Allocate space for any (local, anonymous) .bss sections. */
 
    for (i = 0; i < hdr->NumberOfSections; i++) {
-      UInt32 bss_sz;
-      UChar* zspace;
+      uint32_t bss_sz;
+      uint8_t* zspace;
       COFF_section* sectab_i
          = (COFF_section*)
            myindex ( sizeof_COFF_section, sectab, i );
       COFF_section* sectab_i
          = (COFF_section*)
            myindex ( sizeof_COFF_section, sectab, i );
@@ -1016,10 +973,10 @@ ocGetNames_PEi386 ( ObjectCode* oc )
        * variable decls into the .bss section. (The specific function in Q which
        * triggered this is libraries/base/cbits/dirUtils.c:__hscore_getFolderPath())
        */
        * variable decls into the .bss section. (The specific function in Q which
        * triggered this is libraries/base/cbits/dirUtils.c:__hscore_getFolderPath())
        */
-      if (sectab_i->VirtualSize == 0 && sectab_i->SizeOfRawData == 0) continue;
+      if (sectab_i->Misc.VirtualSize == 0 && sectab_i->SizeOfRawData == 0) continue;
       /* This is a non-empty .bss section.
          Allocate zeroed space for it */
       /* This is a non-empty .bss section.
          Allocate zeroed space for it */
-      bss_sz = sectab_i->VirtualSize;
+      bss_sz = sectab_i->Misc.VirtualSize;
       if ( bss_sz < sectab_i->SizeOfRawData) { bss_sz = sectab_i->SizeOfRawData; }
       zspace = stgCallocBytes(1, bss_sz, "ocGetNames_PEi386(anonymous bss)");
       oc->sections[i].start = zspace;
       if ( bss_sz < sectab_i->SizeOfRawData) { bss_sz = sectab_i->SizeOfRawData; }
       zspace = stgCallocBytes(1, bss_sz, "ocGetNames_PEi386(anonymous bss)");
       oc->sections[i].start = zspace;
@@ -1030,9 +987,9 @@ ocGetNames_PEi386 ( ObjectCode* oc )
    /* Copy section information into the ObjectCode. */
 
    for (i = 0; i < hdr->NumberOfSections; i++) {
    /* Copy section information into the ObjectCode. */
 
    for (i = 0; i < hdr->NumberOfSections; i++) {
-      UChar* start;
-      UChar* end;
-      UInt32 sz;
+      uint8_t* start;
+      uint8_t* end;
+      uint32_t sz;
 
       /* By default consider all section as CODE or DATA, which means we want to load them. */
       SectionKind kind
 
       /* By default consider all section as CODE or DATA, which means we want to load them. */
       SectionKind kind
@@ -1047,25 +1004,25 @@ ocGetNames_PEi386 ( ObjectCode* oc )
       IF_DEBUG(linker, debugBelch("section name = %s\n", secname ));
 
       /* The PE file section flag indicates whether the section contains code or data. */
       IF_DEBUG(linker, debugBelch("section name = %s\n", secname ));
 
       /* The PE file section flag indicates whether the section contains code or data. */
-      if (sectab_i->Characteristics & MYIMAGE_SCN_CNT_CODE ||
-          sectab_i->Characteristics & MYIMAGE_SCN_CNT_INITIALIZED_DATA)
+      if (sectab_i->Characteristics & IMAGE_SCN_CNT_CODE ||
+          sectab_i->Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
          kind = SECTIONKIND_CODE_OR_RODATA;
 
       /* Check next if it contains any uninitialized data */
          kind = SECTIONKIND_CODE_OR_RODATA;
 
       /* Check next if it contains any uninitialized data */
-      if (sectab_i->Characteristics & MYIMAGE_SCN_CNT_UNINITIALIZED_DATA)
+      if (sectab_i->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
          kind = SECTIONKIND_RWDATA;
 
       /* Finally check if it can be discarded. This will also ignore .debug sections */
          kind = SECTIONKIND_RWDATA;
 
       /* Finally check if it can be discarded. This will also ignore .debug sections */
-      if (sectab_i->Characteristics & MYIMAGE_SCN_MEM_DISCARDABLE ||
-          sectab_i->Characteristics & MYIMAGE_SCN_LNK_REMOVE)
+      if (sectab_i->Characteristics & IMAGE_SCN_MEM_DISCARDABLE ||
+          sectab_i->Characteristics & IMAGE_SCN_LNK_REMOVE)
           kind = SECTIONKIND_OTHER;
 
       if (0==strcmp(".ctors", (char*)secname))
          kind = SECTIONKIND_INIT_ARRAY;
 
           kind = SECTIONKIND_OTHER;
 
       if (0==strcmp(".ctors", (char*)secname))
          kind = SECTIONKIND_INIT_ARRAY;
 
-      ASSERT(sectab_i->SizeOfRawData == 0 || sectab_i->VirtualSize == 0);
+      ASSERT(sectab_i->SizeOfRawData == 0 || sectab_i->Misc.VirtualSize == 0);
       sz = sectab_i->SizeOfRawData;
       sz = sectab_i->SizeOfRawData;
-      if (sz < sectab_i->VirtualSize) sz = sectab_i->VirtualSize;
+      if (sz < sectab_i->Misc.VirtualSize) sz = sectab_i->Misc.VirtualSize;
 
       start = section.start;
       end   = start + sz - 1;
 
       start = section.start;
       end   = start + sz - 1;
@@ -1090,9 +1047,9 @@ ocGetNames_PEi386 ( ObjectCode* oc )
       COFF_symbol* symtab_i;
        symtab_i = (COFF_symbol*)
            myindex ( sizeof_COFF_symbol, symtab, i );
       COFF_symbol* symtab_i;
        symtab_i = (COFF_symbol*)
            myindex ( sizeof_COFF_symbol, symtab, i );
-       if (symtab_i->SectionNumber == MYIMAGE_SYM_UNDEFINED
+       if (symtab_i->SectionNumber == IMAGE_SYM_UNDEFINED
            && symtab_i->Value > 0
            && symtab_i->Value > 0
-           && symtab_i->StorageClass != MYIMAGE_SYM_CLASS_SECTION) {
+           && symtab_i->StorageClass != IMAGE_SYM_CLASS_SECTION) {
            globalBssSize += symtab_i->Value;
        }
        i += symtab_i->NumberOfAuxSymbols;
            globalBssSize += symtab_i->Value;
        }
        i += symtab_i->NumberOfAuxSymbols;
@@ -1118,13 +1075,13 @@ ocGetNames_PEi386 ( ObjectCode* oc )
       symtab_i = (COFF_symbol*)
                  myindex ( sizeof_COFF_symbol, symtab, i );
 
       symtab_i = (COFF_symbol*)
                  myindex ( sizeof_COFF_symbol, symtab, i );
 
-      addr  = NULL;
-      HsBool isWeak = HS_BOOL_FALSE;
-      if (   symtab_i->SectionNumber != MYIMAGE_SYM_UNDEFINED
+      addr = NULL;
+      bool isWeak = false;
+      if (   symtab_i->SectionNumber != IMAGE_SYM_UNDEFINED
           && symtab_i->SectionNumber > 0) {
          /* This symbol is global and defined, viz, exported */
           && symtab_i->SectionNumber > 0) {
          /* This symbol is global and defined, viz, exported */
-         /* for MYIMAGE_SYMCLASS_EXTERNAL
-                && !MYIMAGE_SYM_UNDEFINED,
+         /* for IMAGE_SYMCLASS_EXTERNAL
+                && !IMAGE_SYM_UNDEFINED,
             the address of the symbol is:
                 address of relevant section + offset in section
          */
             the address of the symbol is:
                 address of relevant section + offset in section
          */
@@ -1132,44 +1089,44 @@ ocGetNames_PEi386 ( ObjectCode* oc )
             = (COFF_section*) myindex ( sizeof_COFF_section,
                                         sectab,
                                         symtab_i->SectionNumber-1 );
             = (COFF_section*) myindex ( sizeof_COFF_section,
                                         sectab,
                                         symtab_i->SectionNumber-1 );
-         if (symtab_i->StorageClass == MYIMAGE_SYM_CLASS_EXTERNAL
-            || (   symtab_i->StorageClass == MYIMAGE_SYM_CLASS_STATIC
-                && sectabent->Characteristics & MYIMAGE_SCN_LNK_COMDAT)
+         if (symtab_i->StorageClass == IMAGE_SYM_CLASS_EXTERNAL
+            || (   symtab_i->StorageClass == IMAGE_SYM_CLASS_STATIC
+                && sectabent->Characteristics & IMAGE_SCN_LNK_COMDAT)
             ) {
                  addr = (void*)((size_t)oc->sections[symtab_i->SectionNumber-1].start
                       + symtab_i->Value);
             ) {
                  addr = (void*)((size_t)oc->sections[symtab_i->SectionNumber-1].start
                       + symtab_i->Value);
-                 if (sectabent->Characteristics & MYIMAGE_SCN_LNK_COMDAT) {
-                    isWeak = HS_BOOL_TRUE;
+                 if (sectabent->Characteristics & IMAGE_SCN_LNK_COMDAT) {
+                    isWeak = true;
               }
          }
       }
               }
          }
       }
-      else if (symtab_i->StorageClass == MYIMAGE_SYM_CLASS_WEAK_EXTERNAL) {
-          isWeak = HS_BOOL_TRUE;
+      else if (symtab_i->StorageClass == IMAGE_SYM_CLASS_WEAK_EXTERNAL) {
+          isWeak = true;
       }
       }
-      else if (  symtab_i->SectionNumber == MYIMAGE_SYM_UNDEFINED
+      else if (  symtab_i->SectionNumber == IMAGE_SYM_UNDEFINED
               && symtab_i->Value > 0) {
          /* This symbol isn't in any section at all, ie, global bss.
             Allocate zeroed space for it from the BSS section */
           addr = bss;
           bss = (SymbolAddr*)((StgWord)bss + (StgWord)symtab_i->Value);
               && symtab_i->Value > 0) {
          /* This symbol isn't in any section at all, ie, global bss.
             Allocate zeroed space for it from the BSS section */
           addr = bss;
           bss = (SymbolAddr*)((StgWord)bss + (StgWord)symtab_i->Value);
-          IF_DEBUG(linker, debugBelch("bss symbol @ %p %u\n", addr, symtab_i->Value));
+          IF_DEBUG(linker, debugBelch("bss symbol @ %p %lu\n", addr, symtab_i->Value));
       }
 
       }
 
-      sname = cstring_from_COFF_symbol_name(symtab_i->Name, strtab);
-      if (addr != NULL || isWeak == HS_BOOL_TRUE) {
+      sname = cstring_from_COFF_symbol_name(symtab_i->N.ShortName, strtab);
+      if (addr != NULL || isWeak) {
 
          /* debugBelch("addSymbol %p `%s' Weak:%lld \n", addr, sname, isWeak); */
          IF_DEBUG(linker, debugBelch("addSymbol %p `%s'\n", addr,sname));
          ASSERT(i >= 0 && i < oc->n_symbols);
          /* cstring_from_COFF_symbol_name always succeeds. */
          oc->symbols[i] = (SymbolName*)sname;
 
          /* debugBelch("addSymbol %p `%s' Weak:%lld \n", addr, sname, isWeak); */
          IF_DEBUG(linker, debugBelch("addSymbol %p `%s'\n", addr,sname));
          ASSERT(i >= 0 && i < oc->n_symbols);
          /* cstring_from_COFF_symbol_name always succeeds. */
          oc->symbols[i] = (SymbolName*)sname;
-         if (isWeak == HS_BOOL_TRUE) {
+         if (isWeak) {
              setWeakSymbol(oc, sname);
          }
 
          if (! ghciInsertSymbolTable(oc->fileName, symhash, (SymbolName*)sname, addr,
                                      isWeak, oc)) {
              setWeakSymbol(oc, sname);
          }
 
          if (! ghciInsertSymbolTable(oc->fileName, symhash, (SymbolName*)sname, addr,
                                      isWeak, oc)) {
-             return 0;
+             return false;
          }
       } else {
           /* We're skipping the symbol, but if we ever load this
          }
       } else {
           /* We're skipping the symbol, but if we ever load this
@@ -1182,7 +1139,7 @@ ocGetNames_PEi386 ( ObjectCode* oc )
                    "     name `",
                    i
                  );
                    "     name `",
                    i
                  );
-         printName ( symtab_i->Name, strtab );
+         printName ( symtab_i->N.ShortName, strtab );
          debugBelch(
                    "'\n"
                    "    value 0x%x\n"
          debugBelch(
                    "'\n"
                    "    value 0x%x\n"
@@ -1191,10 +1148,10 @@ ocGetNames_PEi386 ( ObjectCode* oc )
                    "   sclass 0x%x\n"
                    "     nAux %d\n",
                    symtab_i->Value,
                    "   sclass 0x%x\n"
                    "     nAux %d\n",
                    symtab_i->Value,
-                   (Int32)(symtab_i->SectionNumber),
-                   (UInt32)symtab_i->Type,
-                   (UInt32)symtab_i->StorageClass,
-                   (UInt32)symtab_i->NumberOfAuxSymbols
+                   (int32_t)(symtab_i->SectionNumber),
+                   (uint32_t)symtab_i->Type,
+                   (uint32_t)symtab_i->StorageClass,
+                   (uint32_t)symtab_i->NumberOfAuxSymbols
                  );
 #        endif
       }
                  );
 #        endif
       }
@@ -1202,7 +1159,7 @@ ocGetNames_PEi386 ( ObjectCode* oc )
       i += symtab_i->NumberOfAuxSymbols;
    }
 
       i += symtab_i->NumberOfAuxSymbols;
    }
 
-   return 1;
+   return true;
 }
 
 #if defined(x86_64_HOST_ARCH)
 }
 
 #if defined(x86_64_HOST_ARCH)
@@ -1210,7 +1167,7 @@ ocGetNames_PEi386 ( ObjectCode* oc )
 /* We've already reserved a room for symbol extras in loadObj,
  * so simply set correct pointer here.
  */
 /* We've already reserved a room for symbol extras in loadObj,
  * so simply set correct pointer here.
  */
-int
+bool
 ocAllocateSymbolExtras_PEi386 ( ObjectCode* oc )
 {
    oc->symbol_extras = (SymbolExtra*)(oc->image - PEi386_IMAGE_OFFSET
 ocAllocateSymbolExtras_PEi386 ( ObjectCode* oc )
 {
    oc->symbol_extras = (SymbolExtra*)(oc->image - PEi386_IMAGE_OFFSET
@@ -1218,7 +1175,7 @@ ocAllocateSymbolExtras_PEi386 ( ObjectCode* oc )
    oc->first_symbol_extra = 0;
    oc->n_symbol_extras = ((COFF_header*)oc->image)->NumberOfSymbols;
 
    oc->first_symbol_extra = 0;
    oc->n_symbol_extras = ((COFF_header*)oc->image)->NumberOfSymbols;
 
-   return 1;
+   return true;
 }
 
 static size_t
 }
 
 static size_t
@@ -1246,36 +1203,36 @@ makeSymbolExtra_PEi386( ObjectCode* oc, size_t s, char* symbol )
 
 #endif /* x86_64_HOST_ARCH */
 
 
 #endif /* x86_64_HOST_ARCH */
 
-int
+bool
 ocResolve_PEi386 ( ObjectCode* oc )
 {
    COFF_header*  hdr;
    COFF_section* sectab;
    COFF_symbol*  symtab;
 ocResolve_PEi386 ( ObjectCode* oc )
 {
    COFF_header*  hdr;
    COFF_section* sectab;
    COFF_symbol*  symtab;
-   UChar*        strtab;
+   uint8_t*      strtab;
 
 
-   UInt32        A;
-   size_t        S;
-   SymbolAddr*    pP;
+   uint32_t    A;
+   size_t      S;
+   SymbolAddr* pP;
 
    int i;
 
    int i;
-   UInt32 j, noRelocs;
+   uint32_t j, noRelocs;
 
    /* ToDo: should be variable-sized?  But is at least safe in the
       sense of buffer-overrun-proof. */
 
    /* ToDo: should be variable-sized?  But is at least safe in the
       sense of buffer-overrun-proof. */
-   UChar symbol[1000];
+   uint8_t symbol[1000];
    /* debugBelch("resolving for %s\n", oc->fileName); */
 
    hdr = (COFF_header*)(oc->image);
    sectab = (COFF_section*) (
    /* debugBelch("resolving for %s\n", oc->fileName); */
 
    hdr = (COFF_header*)(oc->image);
    sectab = (COFF_section*) (
-               ((UChar*)(oc->image))
+               ((uint8_t*)(oc->image))
                + sizeof_COFF_header + hdr->SizeOfOptionalHeader
             );
    symtab = (COFF_symbol*) (
                + sizeof_COFF_header + hdr->SizeOfOptionalHeader
             );
    symtab = (COFF_symbol*) (
-               ((UChar*)(oc->image))
+               ((uint8_t*)(oc->image))
                + hdr->PointerToSymbolTable
             );
                + hdr->PointerToSymbolTable
             );
-   strtab = ((UChar*)(oc->image))
+   strtab = ((uint8_t*)(oc->image))
             + hdr->PointerToSymbolTable
             + hdr->NumberOfSymbols * sizeof_COFF_symbol;
 
             + hdr->PointerToSymbolTable
             + hdr->NumberOfSymbols * sizeof_COFF_symbol;
 
@@ -1285,7 +1242,7 @@ ocResolve_PEi386 ( ObjectCode* oc )
            myindex ( sizeof_COFF_section, sectab, i );
       COFF_reloc* reltab
          = (COFF_reloc*) (
            myindex ( sizeof_COFF_section, sectab, i );
       COFF_reloc* reltab
          = (COFF_reloc*) (
-              ((UChar*)(oc->image)) + sectab_i->PointerToRelocations
+              ((uint8_t*)(oc->image)) + sectab_i->PointerToRelocations
            );
       Section section = oc->sections[i];
 
            );
       Section section = oc->sections[i];
 
@@ -1304,7 +1261,7 @@ ocResolve_PEi386 ( ObjectCode* oc )
 
       stgFree(secname);
 
 
       stgFree(secname);
 
-      if ( sectab_i->Characteristics & MYIMAGE_SCN_LNK_NRELOC_OVFL ) {
+      if ( sectab_i->Characteristics & IMAGE_SCN_LNK_NRELOC_OVFL ) {
         /* If the relocation field (a short) has overflowed, the
          * real count can be found in the first reloc entry.
          *
         /* If the relocation field (a short) has overflowed, the
          * real count can be found in the first reloc entry.
          *
@@ -1345,7 +1302,7 @@ ocResolve_PEi386 ( ObjectCode* oc )
                  - sectab_i->VirtualAddress
               );
          /* the existing contents of pP */
                  - sectab_i->VirtualAddress
               );
          /* the existing contents of pP */
-         A = *(UInt32*)pP;
+         A = *(uint32_t*)pP;
          /* the symbol to connect to */
          sym = (COFF_symbol*)
                myindex ( sizeof_COFF_symbol,
          /* the symbol to connect to */
          sym = (COFF_symbol*)
                myindex ( sizeof_COFF_symbol,
@@ -1353,35 +1310,35 @@ ocResolve_PEi386 ( ObjectCode* oc )
          IF_DEBUG(linker,
                   debugBelch(
                             "reloc sec %2d num %3d:  type 0x%-4x   "
          IF_DEBUG(linker,
                   debugBelch(
                             "reloc sec %2d num %3d:  type 0x%-4x   "
-                            "vaddr 0x%-8x   name `",
+                            "vaddr 0x%-8lx   name `",
                             i, j,
                             i, j,
-                            (UInt32)reltab_j->Type,
+                            (uint32_t)reltab_j->Type,
                             reltab_j->VirtualAddress );
                             reltab_j->VirtualAddress );
-                            printName ( sym->Name, strtab );
+                            printName ( sym->N.ShortName, strtab );
                             debugBelch("'\n" ));
 
                             debugBelch("'\n" ));
 
-         if (sym->StorageClass == MYIMAGE_SYM_CLASS_STATIC) {
+         if (sym->StorageClass == IMAGE_SYM_CLASS_STATIC) {
             Section section = oc->sections[sym->SectionNumber-1];
             S = ((size_t)(section.start))
               + ((size_t)(sym->Value));
          } else {
             Section section = oc->sections[sym->SectionNumber-1];
             S = ((size_t)(section.start))
               + ((size_t)(sym->Value));
          } else {
-            copyName ( sym->Name, strtab, symbol, 1000-1 );
+            copyName ( sym->N.ShortName, strtab, symbol, 1000-1 );
             S = (size_t) lookupSymbol_( (char*)symbol );
             if ((void*)S == NULL) {
 
                 errorBelch("%" PATH_FMT ": unknown symbol `%s'\n", oc->fileName, symbol);
             S = (size_t) lookupSymbol_( (char*)symbol );
             if ((void*)S == NULL) {
 
                 errorBelch("%" PATH_FMT ": unknown symbol `%s'\n", oc->fileName, symbol);
-                return 0;
+                return false;
             }
          }
          /* All supported relocations write at least 4 bytes */
          checkProddableBlock(oc, pP, 4);
          switch (reltab_j->Type) {
 #if defined(i386_HOST_ARCH)
             }
          }
          /* All supported relocations write at least 4 bytes */
          checkProddableBlock(oc, pP, 4);
          switch (reltab_j->Type) {
 #if defined(i386_HOST_ARCH)
-            case MYIMAGE_REL_I386_DIR32:
-            case MYIMAGE_REL_I386_DIR32NB:
-               *(UInt32 *)pP = ((UInt32)S) + A;
+            case IMAGE_REL_I386_DIR32:
+            case IMAGE_REL_I386_DIR32NB:
+               *(uint32_t *)pP = ((uint32_t)S) + A;
                break;
                break;
-            case MYIMAGE_REL_I386_REL32:
+            case IMAGE_REL_I386_REL32:
                /* Tricky.  We have to insert a displacement at
                   pP which, when added to the PC for the _next_
                   insn, gives the address of the target (S).
                /* Tricky.  We have to insert a displacement at
                   pP which, when added to the PC for the _next_
                   insn, gives the address of the target (S).
@@ -1407,15 +1364,15 @@ ocResolve_PEi386 ( ObjectCode* oc )
                   relocations with non-zero values. Adding the displacement is
                   the right thing to do.
                */
                   relocations with non-zero values. Adding the displacement is
                   the right thing to do.
                */
-               *(UInt32 *)pP = ((UInt32)S) + A - ((UInt32)(size_t)pP) - 4;
+               *(uint32_t *)pP = ((uint32_t)S) + A - ((uint32_t)(size_t)pP) - 4;
                break;
 #elif defined(x86_64_HOST_ARCH)
             case 1: /* R_X86_64_64 (ELF constant 1) - IMAGE_REL_AMD64_ADDR64 (PE constant 1) */
                {
                break;
 #elif defined(x86_64_HOST_ARCH)
             case 1: /* R_X86_64_64 (ELF constant 1) - IMAGE_REL_AMD64_ADDR64 (PE constant 1) */
                {
-                   UInt64 A;
+                   uint64_t A;
                    checkProddableBlock(oc, pP, 8);
                    checkProddableBlock(oc, pP, 8);
-                   A = *(UInt64*)pP;
-                   *(UInt64 *)pP = ((UInt64)S) + ((UInt64)A);
+                   A = *(uint64_t*)pP;
+                   *(uint64_t *)pP = ((uint64_t)S) + ((uint64_t)A);
                    break;
                }
             case 2: /* R_X86_64_32 (ELF constant 10) - IMAGE_REL_AMD64_ADDR32 (PE constant 2) */
                    break;
                }
             case 2: /* R_X86_64_32 (ELF constant 10) - IMAGE_REL_AMD64_ADDR32 (PE constant 2) */
@@ -1425,7 +1382,7 @@ ocResolve_PEi386 ( ObjectCode* oc )
                    size_t v;
                    v = S + ((size_t)A);
                    if (v >> 32) {
                    size_t v;
                    v = S + ((size_t)A);
                    if (v >> 32) {
-                       copyName ( sym->Name, strtab, symbol, 1000-1 );
+                       copyName ( sym->N.ShortName, strtab, symbol, 1000-1 );
                        S = makeSymbolExtra_PEi386(oc, S, (char *)symbol);
                        /* And retry */
                        v = S + ((size_t)A);
                        S = makeSymbolExtra_PEi386(oc, S, (char *)symbol);
                        /* And retry */
                        v = S + ((size_t)A);
@@ -1434,39 +1391,39 @@ ocResolve_PEi386 ( ObjectCode* oc )
                                 v, (char *)symbol);
                        }
                    }
                                 v, (char *)symbol);
                        }
                    }
-                   *(UInt32 *)pP = (UInt32)v;
+                   *(uint32_t *)pP = (uint32_t)v;
                    break;
                }
             case 4: /* R_X86_64_PC32 (ELF constant 2) - IMAGE_REL_AMD64_REL32 (PE constant 4) */
                {
                    intptr_t v;
                    break;
                }
             case 4: /* R_X86_64_PC32 (ELF constant 2) - IMAGE_REL_AMD64_REL32 (PE constant 4) */
                {
                    intptr_t v;
-                   v = ((intptr_t)S) + ((intptr_t)(Int32)A) - ((intptr_t)pP) - 4;
+                   v = ((intptr_t)S) + ((intptr_t)(int32_t)A) - ((intptr_t)pP) - 4;
                    if ((v >> 32) && ((-v) >> 32)) {
                        /* Make the trampoline then */
                    if ((v >> 32) && ((-v) >> 32)) {
                        /* Make the trampoline then */
-                       copyName ( sym->Name, strtab, symbol, 1000-1 );
+                       copyName ( sym->N.ShortName, strtab, symbol, 1000-1 );
                        S = makeSymbolExtra_PEi386(oc, S, (char *)symbol);
                        /* And retry */
                        S = makeSymbolExtra_PEi386(oc, S, (char *)symbol);
                        /* And retry */
-                       v = ((intptr_t)S) + ((intptr_t)(Int32)A) - ((intptr_t)pP) - 4;
+                       v = ((intptr_t)S) + ((intptr_t)(int32_t)A) - ((intptr_t)pP) - 4;
                        if ((v >> 32) && ((-v) >> 32)) {
                            barf("IMAGE_REL_AMD64_REL32: High bits are set in %zx for %s",
                                 v, (char *)symbol);
                        }
                    }
                        if ((v >> 32) && ((-v) >> 32)) {
                            barf("IMAGE_REL_AMD64_REL32: High bits are set in %zx for %s",
                                 v, (char *)symbol);
                        }
                    }
-                   *(UInt32 *)pP = (UInt32)v;
+                   *(uint32_t *)pP = (uint32_t)v;
                    break;
                }
 #endif
             default:
                debugBelch("%" PATH_FMT ": unhandled PEi386 relocation type %d\n",
                      oc->fileName, reltab_j->Type);
                    break;
                }
 #endif
             default:
                debugBelch("%" PATH_FMT ": unhandled PEi386 relocation type %d\n",
                      oc->fileName, reltab_j->Type);
-               return 0;
+               return false;
          }
 
       }
    }
 
    IF_DEBUG(linker, debugBelch("completed %" PATH_FMT "\n", oc->fileName));
          }
 
       }
    }
 
    IF_DEBUG(linker, debugBelch("completed %" PATH_FMT "\n", oc->fileName));
-   return 1;
+   return true;
 }
 
 /*
 }
 
 /*
@@ -1484,20 +1441,20 @@ ocResolve_PEi386 ( ObjectCode* oc )
   See #9907
 */
 
   See #9907
 */
 
-int
+bool
 ocRunInit_PEi386 ( ObjectCode *oc )
 {
     COFF_header*  hdr;
     COFF_section* sectab;
 ocRunInit_PEi386 ( ObjectCode *oc )
 {
     COFF_header*  hdr;
     COFF_section* sectab;
-    UChar*        strtab;
+    uint8_t*        strtab;
     int i;
 
     hdr = (COFF_header*)(oc->image);
     sectab = (COFF_section*) (
     int i;
 
     hdr = (COFF_header*)(oc->image);
     sectab = (COFF_section*) (
-                ((UChar*)(oc->image))
+                ((uint8_t*)(oc->image))
                 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
              );
                 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
              );
-    strtab = ((UChar*)(oc->image))
+    strtab = ((uint8_t*)(oc->image))
              + hdr->PointerToSymbolTable
              + hdr->NumberOfSymbols * sizeof_COFF_symbol;
 
              + hdr->PointerToSymbolTable
              + hdr->NumberOfSymbols * sizeof_COFF_symbol;
 
@@ -1520,7 +1477,7 @@ ocRunInit_PEi386 ( ObjectCode *oc )
         Section section = oc->sections[i];
         char *secname = cstring_from_section_name(sectab_i->Name, strtab);
         if (0 == strcmp(".ctors", (char*)secname)) {
         Section section = oc->sections[i];
         char *secname = cstring_from_section_name(sectab_i->Name, strtab);
         if (0 == strcmp(".ctors", (char*)secname)) {
-            UChar *init_startC = section.start;
+            uint8_t *init_startC = section.start;
             init_t *init_start, *init_end, *init;
             init_start = (init_t*)init_startC;
             init_end = (init_t*)(init_startC + sectab_i->SizeOfRawData);
             init_t *init_start, *init_end, *init;
             init_start = (init_t*)init_startC;
             init_end = (init_t*)(init_startC + sectab_i->SizeOfRawData);
@@ -1531,7 +1488,7 @@ ocRunInit_PEi386 ( ObjectCode *oc )
         }
     }
     freeProgEnvv(envc, envv);
         }
     }
     freeProgEnvv(envc, envv);
-    return 1;
+    return true;
 }
 
 SymbolAddr *lookupSymbol_PEi386(SymbolName *lbl)
 }
 
 SymbolAddr *lookupSymbol_PEi386(SymbolName *lbl)
index 020b84b..09b8c91 100644 (file)
@@ -4,6 +4,8 @@
 #include "Rts.h"
 #include "LinkerInternals.h"
 #include "PathUtils.h"
 #include "Rts.h"
 #include "LinkerInternals.h"
 #include "PathUtils.h"
+#include <windows.h>
+#include <stdbool.h>
 
 #include "BeginPrivate.h"
 
 
 #include "BeginPrivate.h"
 
 #define PEi386_IMAGE_OFFSET 0
 #endif
 
 #define PEi386_IMAGE_OFFSET 0
 #endif
 
-void initLinker_PEi386(void);
-const char * addDLL_PEi386(pathchar *dll_name);
-void freePreloadObjectFile_PEi386(ObjectCode *oc);
+void initLinker_PEi386( void );
+const char * addDLL_PEi386( pathchar *dll_name );
+void freePreloadObjectFile_PEi386( ObjectCode *oc );
 
 
-int findAndLoadImportLibrary(ObjectCode* oc);
-int checkAndLoadImportLibrary( pathchar* arch_name, char* member_name, FILE* f);
+bool findAndLoadImportLibrary( ObjectCode* oc );
+bool checkAndLoadImportLibrary( pathchar* arch_name, char* member_name, FILE* f);
 
 
-pathchar* findSystemLibrary_PEi386(pathchar* dll_name);
-HsPtr addLibrarySearchPath_PEi386(pathchar* dll_path);
-HsBool removeLibrarySearchPath_PEi386(HsPtr dll_path_index);
+pathchar* findSystemLibrary_PEi386( pathchar* dll_name );
+HsPtr addLibrarySearchPath_PEi386( pathchar* dll_path );
+bool removeLibrarySearchPath_PEi386( HsPtr dll_path_index );
 
 
-int ocResolve_PEi386     ( ObjectCode* oc );
-int ocRunInit_PEi386     ( ObjectCode *oc );
-int ocGetNames_PEi386    ( ObjectCode* oc );
-int ocVerifyImage_PEi386 ( ObjectCode* oc );
+bool ocResolve_PEi386     ( ObjectCode* oc );
+bool ocRunInit_PEi386     ( ObjectCode *oc );
+bool ocGetNames_PEi386    ( ObjectCode* oc );
+bool ocVerifyImage_PEi386 ( ObjectCode* oc );
 SymbolAddr *lookupSymbol_PEi386(SymbolName *lbl);
 SymbolAddr *lookupSymbol_PEi386(SymbolName *lbl);
-int ocAllocateSymbolExtras_PEi386 ( ObjectCode* oc );
+bool ocAllocateSymbolExtras_PEi386 ( ObjectCode* oc );
 void *lookupSymbolInDLLs ( unsigned char *lbl );
 /* See Note [mingw-w64 name decoration scheme] */
 
 void *lookupSymbolInDLLs ( unsigned char *lbl );
 /* See Note [mingw-w64 name decoration scheme] */
 
@@ -43,118 +45,66 @@ allocateImageAndTrampolines (
 /********************************************
  * COFF/PE headers
  ********************************************/
 /********************************************
  * COFF/PE headers
  ********************************************/
-typedef unsigned char          UChar;
-typedef unsigned short         UInt16;
-typedef short                  Int16;
-typedef unsigned int           UInt32;
-typedef          int           Int32;
-typedef unsigned long long int UInt64;
+typedef IMAGE_FILE_HEADER COFF_header;
+#define sizeof_COFF_header sizeof(COFF_header)
 
 
+/* Section 7.1 PE Specification */
+typedef IMPORT_OBJECT_HEADER COFF_import_header;
+#define sizeof_COFF_import_Header sizeof(COFF_import_header)
 
 
-typedef
-struct {
-    UInt16 Machine;
-    UInt16 NumberOfSections;
-    UInt32 TimeDateStamp;
-    UInt32 PointerToSymbolTable;
-    UInt32 NumberOfSymbols;
-    UInt16 SizeOfOptionalHeader;
-    UInt16 Characteristics;
-}
-COFF_header;
-
-#define sizeof_COFF_header 20
+typedef IMAGE_SECTION_HEADER COFF_section;
+#define sizeof_COFF_section sizeof(COFF_section)
 
 
-/* Section 7.1 PE Specification */
+
+typedef IMAGE_SYMBOL COFF_symbol;
+#define sizeof_COFF_symbol sizeof(COFF_symbol)
+
+
+typedef IMAGE_RELOCATION COFF_reloc;
+#define sizeof_COFF_reloc sizeof(COFF_reloc)
+
+// MingW-w64 is missing these from the implementation. So we have to look them up
+typedef DLL_DIRECTORY_COOKIE(WINAPI *LPAddDLLDirectory)(PCWSTR NewDirectory);
+typedef WINBOOL(WINAPI *LPRemoveDLLDirectory)(DLL_DIRECTORY_COOKIE Cookie);
+
+/* A record for storing handles into DLLs. */
 typedef
 typedef
-struct {
-    UInt16 Sig1;
-    UInt16 Sig2;
-    UInt16 Version;
-    UInt16 Machine;
-    UInt32 TimeDateStamp;
-    UInt32 SizeOfData;
-    UInt16 Ordinal;
-    UInt16 Type_NameType_Reserved;
-}
-COFF_import_header;
-
-#define sizeof_COFF_import_Header 20
+struct _OpenedDLL {
+    pathchar*          name;
+    struct _OpenedDLL* next;
+    HINSTANCE instance;
+} OpenedDLL;
 
 
+/* A record for storing indirectly linked functions from DLLs. */
 typedef
 typedef
-struct {
-    UChar  Name[8];
-    UInt32 VirtualSize;
-    UInt32 VirtualAddress;
-    UInt32 SizeOfRawData;
-    UInt32 PointerToRawData;
-    UInt32 PointerToRelocations;
-    UInt32 PointerToLinenumbers;
-    UInt16 NumberOfRelocations;
-    UInt16 NumberOfLineNumbers;
-    UInt32 Characteristics;
-}
-COFF_section;
-
-#define sizeof_COFF_section 40
+struct _IndirectAddr {
+    SymbolAddr*           addr;
+    struct _IndirectAddr* next;
+} IndirectAddr;
 
 
+/* See Note [mingw-w64 name decoration scheme] */
+#ifndef x86_64_HOST_ARCH
+#define STRIP_LEADING_UNDERSCORE 1
+#else
+#define STRIP_LEADING_UNDERSCORE 0
+#endif
 
 
-typedef
-struct {
-    UChar  Name[8];
-    UInt32 Value;
-    Int16  SectionNumber;
-    UInt16 Type;
-    UChar  StorageClass;
-    UChar  NumberOfAuxSymbols;
-}
-COFF_symbol;
+/*
+Note [mingw-w64 name decoration scheme]
 
 
-#define sizeof_COFF_symbol 18
+What's going on with name decoration? Well, original code
+have some crufty and ad-hocish paths related mostly to very old
+mingw gcc/binutils/runtime combinations. Now mingw-w64 offers pretty
+uniform and MS-compatible decoration scheme across its tools and runtime.
 
 
+The scheme is pretty straightforward: on 32 bit objects symbols are exported
+with underscore prepended (and @ + stack size suffix appended for stdcall
+functions), on 64 bits no underscore is prepended and no suffix is appended
+because we have no stdcall convention on 64 bits.
+
+See #9218
+*/
 
 
-typedef
-struct {
-    UInt32 VirtualAddress;
-    UInt32 SymbolTableIndex;
-    UInt16 Type;
-}
-COFF_reloc;
-
-#define sizeof_COFF_reloc 10
-
-/* From PE spec doc, section 3.3.2 */
-/* Note use of MYIMAGE_* since IMAGE_* are already defined in
-windows.h -- for the same purpose, but I want to know what I'm
-getting, here. */
-#define MYIMAGE_FILE_RELOCS_STRIPPED        0x0001
-#define MYIMAGE_FILE_EXECUTABLE_IMAGE       0x0002
-#define MYIMAGE_FILE_DLL                    0x2000
-#define MYIMAGE_FILE_SYSTEM                 0x1000
-#define MYIMAGE_FILE_BYTES_REVERSED_HI      0x8000
-#define MYIMAGE_FILE_BYTES_REVERSED_LO      0x0080
-#define MYIMAGE_FILE_32BIT_MACHINE          0x0100
-
-/* From PE spec doc, section 5.4.2 and 5.4.4 */
-#define MYIMAGE_SYM_CLASS_EXTERNAL          2
-#define MYIMAGE_SYM_CLASS_STATIC            3
-#define MYIMAGE_SYM_UNDEFINED               0
-#define MYIMAGE_SYM_CLASS_SECTION           104
-#define MYIMAGE_SYM_CLASS_WEAK_EXTERNAL     105
-
-/* From PE spec doc, section 3.1 */
-#define MYIMAGE_SCN_CNT_CODE                0x00000020
-#define MYIMAGE_SCN_CNT_INITIALIZED_DATA    0x00000040
-#define MYIMAGE_SCN_CNT_UNINITIALIZED_DATA  0x00000080
-#define MYIMAGE_SCN_LNK_COMDAT              0x00001000
-#define MYIMAGE_SCN_LNK_NRELOC_OVFL         0x01000000
-#define MYIMAGE_SCN_LNK_REMOVE              0x00000800
-#define MYIMAGE_SCN_MEM_DISCARDABLE         0x02000000
-
-/* From PE spec doc, section 5.2.1 */
-#define MYIMAGE_REL_I386_DIR32              0x0006
-#define MYIMAGE_REL_I386_DIR32NB            0x0007
-#define MYIMAGE_REL_I386_REL32              0x0014
 
 #include "EndPrivate.h"
 
 
 #include "EndPrivate.h"