From 6156d208e6cc6e28a964be5dd34585bd54f6eadf Mon Sep 17 00:00:00 2001
From: Xavier Leroy <xavier.leroy@inria.fr>
Date: Wed, 27 Aug 2014 09:58:33 +0000
Subject: [PATCH 11/11] PR#6517: use ISO C99 types {,u}int{32,64}_t in
 preference to our homegrown types {,u}int{32,64}.

git-svn-id: http://caml.inria.fr/svn/ocaml/trunk@15131 f963ae5c-01c2-4b8c-9fe0-0dff7051ff02

----------------------------------------------------------------------
For Fedora:

This commit was cherry picked from upstream
commit b868c05ec91a7ee193010a421de768a3b1a80952 (SVN 15131).

See also:

http://caml.inria.fr/mantis/view.php?id=6517
---
 asmrun/backtrace.c                  |   6 +-
 byterun/alloc.h                     |   4 +-
 byterun/backtrace.c                 |   2 +-
 byterun/config.h                    |  35 +++++++----
 byterun/debugger.h                  |  28 ++++-----
 byterun/exec.h                      |   4 +-
 byterun/extern.c                    |   4 +-
 byterun/fix_code.c                  |   8 +--
 byterun/floats.c                    |   6 +-
 byterun/globroots.c                 |   4 +-
 byterun/hash.c                      |  44 +++++++-------
 byterun/hash.h                      |  12 ++--
 byterun/int64_emul.h                | 114 ++++++++++++++++++------------------
 byterun/int64_format.h              |   4 +-
 byterun/int64_native.h              |  20 +++----
 byterun/intern.c                    |  20 +++----
 byterun/interp.c                    |   2 +-
 byterun/intext.h                    |  12 ++--
 byterun/ints.c                      | 112 +++++++++++++++++------------------
 byterun/io.c                        |   6 +-
 byterun/io.h                        |   6 +-
 byterun/md5.c                       |  26 ++++----
 byterun/md5.h                       |   6 +-
 byterun/mlvalues.h                  |  12 ++--
 byterun/startup.c                   |  10 ++--
 byterun/startup.h                   |   4 +-
 byterun/str.c                       |  20 +++----
 config/auto-aux/int64align.c        |  14 ++---
 config/s-nt.h                       |   3 +
 configure                           |  25 ++------
 otherlibs/bigarray/bigarray_stubs.c |  48 +++++++--------
 otherlibs/num/nat_stubs.c           |  14 ++---
 otherlibs/unix/addrofstr.c          |   2 +-
 stdlib/header.c                     |   2 +-
 34 files changed, 319 insertions(+), 320 deletions(-)

diff --git a/asmrun/backtrace.c b/asmrun/backtrace.c
index c72a237..773e22c 100644
--- a/asmrun/backtrace.c
+++ b/asmrun/backtrace.c
@@ -217,7 +217,7 @@ static void extract_location_info(frame_descr * d,
                                   /*out*/ struct loc_info * li)
 {
   uintnat infoptr;
-  uint32 info1, info2;
+  uint32_t info1, info2;
 
   /* If no debugging information available, print nothing.
      When everything is compiled with -g, this corresponds to
@@ -232,8 +232,8 @@ static void extract_location_info(frame_descr * d,
              sizeof(char *) + sizeof(short) + sizeof(short) +
              sizeof(short) * d->num_live + sizeof(frame_descr *) - 1)
             & -sizeof(frame_descr *);
-  info1 = ((uint32 *)infoptr)[0];
-  info2 = ((uint32 *)infoptr)[1];
+  info1 = ((uint32_t *)infoptr)[0];
+  info2 = ((uint32_t *)infoptr)[1];
   /* Format of the two info words:
        llllllllllllllllllll aaaaaaaa bbbbbbbbbb nnnnnnnnnnnnnnnnnnnnnnnn kk
                           44       36         26                       2  0
diff --git a/byterun/alloc.h b/byterun/alloc.h
index f00a7ef..2a640eb 100644
--- a/byterun/alloc.h
+++ b/byterun/alloc.h
@@ -32,8 +32,8 @@ CAMLextern value caml_alloc_string (mlsize_t);  /* size in bytes */
 CAMLextern value caml_copy_string (char const *);
 CAMLextern value caml_copy_string_array (char const **);
 CAMLextern value caml_copy_double (double);
-CAMLextern value caml_copy_int32 (int32);       /* defined in [ints.c] */
-CAMLextern value caml_copy_int64 (int64);       /* defined in [ints.c] */
+CAMLextern value caml_copy_int32 (int32_t);       /* defined in [ints.c] */
+CAMLextern value caml_copy_int64 (int64_t);       /* defined in [ints.c] */
 CAMLextern value caml_copy_nativeint (intnat);  /* defined in [ints.c] */
 CAMLextern value caml_alloc_array (value (*funct) (char const *),
                                    char const ** array);
diff --git a/byterun/backtrace.c b/byterun/backtrace.c
index 76e3ddf..6ed56c8 100644
--- a/byterun/backtrace.c
+++ b/byterun/backtrace.c
@@ -229,7 +229,7 @@ static void read_debug_info(void)
   int fd;
   struct exec_trailer trail;
   struct channel * chan;
-  uint32 num_events, orig, i;
+  uint32_t num_events, orig, i;
   intnat j;
   value evl, l, ev_start;
 
diff --git a/byterun/config.h b/byterun/config.h
index f775988..6c86d16 100644
--- a/byterun/config.h
+++ b/byterun/config.h
@@ -25,24 +25,30 @@
 #include "compatibility.h"
 #endif
 
-/* Types for 32-bit integers, 64-bit integers,
+#ifdef HAS_STDINT_H
+#include <stdint.h>
+#endif
+
+/* Types for 32-bit integers, 64-bit integers, and
    native integers (as wide as a pointer type) */
 
+#ifndef ARCH_INT32_TYPE
 #if SIZEOF_INT == 4
-typedef int int32;
-typedef unsigned int uint32;
+#define ARCH_INT32_TYPE int
+#define ARCH_UINT32_TYPE unsigned int
 #define ARCH_INT32_PRINTF_FORMAT ""
 #elif SIZEOF_LONG == 4
-typedef long int32;
-typedef unsigned long uint32;
+#define ARCH_INT32_TYPE long
+#define ARCH_UINT32_TYPE unsigned long
 #define ARCH_INT32_PRINTF_FORMAT "l"
 #elif SIZEOF_SHORT == 4
-typedef short int32;
-typedef unsigned short uint32;
+#define ARCH_INT32_TYPE short
+#define ARCH_UINT32_TYPE unsigned short
 #define ARCH_INT32_PRINTF_FORMAT ""
 #else
 #error "No 32-bit integer type available"
 #endif
+#endif
 
 #ifndef ARCH_INT64_TYPE
 #if SIZEOF_LONGLONG == 8
@@ -58,8 +64,13 @@ typedef unsigned short uint32;
 #endif
 #endif
 
-typedef ARCH_INT64_TYPE int64;
-typedef ARCH_UINT64_TYPE uint64;
+#ifndef HAS_STDINT_H
+/* Not a C99 compiler, typically MSVC.  Define the C99 types we use. */
+typedef ARCH_INT32_TYPE int32_t;
+typedef ARCH_UINT32_TYPE uint32_t;
+typedef ARCH_INT64_TYPE int64_t;
+typedef ARCH_UINT64_TYPE uint64_t;
+#endif
 
 #if SIZEOF_PTR == SIZEOF_LONG
 /* Standard models: ILP32 or I32LP64 */
@@ -72,9 +83,9 @@ typedef int intnat;
 typedef unsigned int uintnat;
 #define ARCH_INTNAT_PRINTF_FORMAT ""
 #elif SIZEOF_PTR == 8
-/* Win64 model: IL32LLP64 */
-typedef int64 intnat;
-typedef uint64 uintnat;
+/* Win64 model: IL32P64 */
+typedef int64_t intnat;
+typedef uint64_t uintnat;
 #define ARCH_INTNAT_PRINTF_FORMAT ARCH_INT64_PRINTF_FORMAT
 #else
 #error "No integer type available to represent pointers"
diff --git a/byterun/debugger.h b/byterun/debugger.h
index b5079eb..e68ef75 100644
--- a/byterun/debugger.h
+++ b/byterun/debugger.h
@@ -37,17 +37,17 @@ void caml_debugger_cleanup_fork (void);
 /* Requests from the debugger to the runtime system */
 
 enum debugger_request {
-  REQ_SET_EVENT = 'e',          /* uint32 pos */
+  REQ_SET_EVENT = 'e',          /* uint32_t pos */
   /* Set an event on the instruction at position pos */
-  REQ_SET_BREAKPOINT = 'B',     /* uint32 pos, (char k) */
+  REQ_SET_BREAKPOINT = 'B',     /* uint32_t pos, (char k) */
   /* Set a breakpoint at position pos */
   /* In profiling mode, the breakpoint kind is set to k */
-  REQ_RESET_INSTR = 'i',        /* uint32 pos */
+  REQ_RESET_INSTR = 'i',        /* uint32_t pos */
   /* Clear an event or breapoint at position pos, restores initial instr. */
   REQ_CHECKPOINT = 'c',         /* no args */
   /* Checkpoint the runtime system by forking a child process.
      Reply is pid of child process or -1 if checkpoint failed. */
-  REQ_GO = 'g',                 /* uint32 n */
+  REQ_GO = 'g',                 /* uint32_t n */
   /* Run the program for n events.
      Reply is one of debugger_reply described below. */
   REQ_STOP = 's',               /* no args */
@@ -59,38 +59,38 @@ enum debugger_request {
      Reply is stack offset and current pc. */
   REQ_GET_FRAME = 'f',          /* no args */
   /* Return current frame location (stack offset + current pc). */
-  REQ_SET_FRAME = 'S',          /* uint32 stack_offset */
+  REQ_SET_FRAME = 'S',          /* uint32_t stack_offset */
   /* Set current frame to given stack offset. No reply. */
-  REQ_UP_FRAME = 'U',           /* uint32 n */
+  REQ_UP_FRAME = 'U',           /* uint32_t n */
   /* Move one frame up. Argument n is size of current frame (in words).
      Reply is stack offset and current pc, or -1 if top of stack reached. */
-  REQ_SET_TRAP_BARRIER = 'b',   /* uint32 offset */
+  REQ_SET_TRAP_BARRIER = 'b',   /* uint32_t offset */
   /* Set the trap barrier at the given offset. */
-  REQ_GET_LOCAL = 'L',          /* uint32 slot_number */
+  REQ_GET_LOCAL = 'L',          /* uint32_t slot_number */
   /* Return the local variable at the given slot in the current frame.
      Reply is one value. */
-  REQ_GET_ENVIRONMENT = 'E',    /* uint32 slot_number */
+  REQ_GET_ENVIRONMENT = 'E',    /* uint32_t slot_number */
   /* Return the local variable at the given slot in the heap environment
      of the current frame. Reply is one value. */
-  REQ_GET_GLOBAL = 'G',         /* uint32 global_number */
+  REQ_GET_GLOBAL = 'G',         /* uint32_t global_number */
   /* Return the specified global variable. Reply is one value. */
   REQ_GET_ACCU = 'A',           /* no args */
   /* Return the current contents of the accumulator. Reply is one value. */
   REQ_GET_HEADER = 'H',         /* mlvalue v */
   /* As REQ_GET_OBJ, but sends only the header. */
-  REQ_GET_FIELD = 'F',          /* mlvalue v, uint32 fieldnum */
+  REQ_GET_FIELD = 'F',          /* mlvalue v, uint32_t fieldnum */
   /* As REQ_GET_OBJ, but sends only one field. */
   REQ_MARSHAL_OBJ = 'M',        /* mlvalue v */
   /* Send a copy of the data structure rooted at v, using the same
      format as [caml_output_value]. */
   REQ_GET_CLOSURE_CODE = 'C',   /* mlvalue v */
   /* Send the code address of the given closure.
-     Reply is one uint32. */
-  REQ_SET_FORK_MODE = 'K'       /* uint32 m */
+     Reply is one uint32_t. */
+  REQ_SET_FORK_MODE = 'K'       /* uint32_t m */
   /* Set whether to follow the child (m=0) or the parent on fork. */
 };
 
-/* Replies to a REQ_GO request. All replies are followed by three uint32:
+/* Replies to a REQ_GO request. All replies are followed by three uint32_t:
    - the value of the event counter
    - the position of the stack
    - the current pc. */
diff --git a/byterun/exec.h b/byterun/exec.h
index a58bcf8..7e084ac 100644
--- a/byterun/exec.h
+++ b/byterun/exec.h
@@ -39,13 +39,13 @@
 
 struct section_descriptor {
   char name[4];                 /* Section name */
-  uint32 len;                   /* Length of data in bytes */
+  uint32_t len;                   /* Length of data in bytes */
 };
 
 /* Structure of the trailer. */
 
 struct exec_trailer {
-  uint32 num_sections;          /* Number of sections */
+  uint32_t num_sections;          /* Number of sections */
   char magic[12];               /* The magic number */
   struct section_descriptor * section; /* Not part of file */
 };
diff --git a/byterun/extern.c b/byterun/extern.c
index 33fa89a..e67d7a3 100644
--- a/byterun/extern.c
+++ b/byterun/extern.c
@@ -720,7 +720,7 @@ CAMLexport void caml_serialize_int_2(int i)
   extern_ptr += 2;
 }
 
-CAMLexport void caml_serialize_int_4(int32 i)
+CAMLexport void caml_serialize_int_4(int32_t i)
 {
   if (extern_ptr + 4 > extern_limit) grow_extern_output(4);
   extern_ptr[0] = i >> 24;
@@ -730,7 +730,7 @@ CAMLexport void caml_serialize_int_4(int32 i)
   extern_ptr += 4;
 }
 
-CAMLexport void caml_serialize_int_8(int64 i)
+CAMLexport void caml_serialize_int_8(int64_t i)
 {
   caml_serialize_block_8(&i, 1);
 }
diff --git a/byterun/fix_code.c b/byterun/fix_code.c
index 3380dc9..4fa0275 100644
--- a/byterun/fix_code.c
+++ b/byterun/fix_code.c
@@ -134,12 +134,12 @@ void caml_thread_code (code_t code, asize_t len)
     }
     *p++ = (opcode_t)(caml_instr_table[instr] - caml_instr_base);
     if (instr == SWITCH) {
-      uint32 sizes = *p++;
-      uint32 const_size = sizes & 0xFFFF;
-      uint32 block_size = sizes >> 16;
+      uint32_t sizes = *p++;
+      uint32_t const_size = sizes & 0xFFFF;
+      uint32_t block_size = sizes >> 16;
       p += const_size + block_size;
     } else if (instr == CLOSUREREC) {
-      uint32 nfuncs = *p++;
+      uint32_t nfuncs = *p++;
       p++;                      /* skip nvars */
       p += nfuncs;
     } else {
diff --git a/byterun/floats.c b/byterun/floats.c
index 7ff6d89..d8fdd05 100644
--- a/byterun/floats.c
+++ b/byterun/floats.c
@@ -378,9 +378,9 @@ CAMLprim value caml_log1p_float(value f)
 union double_as_two_int32 {
     double d;
 #if defined(ARCH_BIG_ENDIAN) || (defined(__arm__) && !defined(__ARM_EABI__))
-    struct { uint32 h; uint32 l; } i;
+    struct { uint32_t h; uint32_t l; } i;
 #else
-    struct { uint32 l; uint32 h; } i;
+    struct { uint32_t l; uint32_t h; } i;
 #endif
 };
 
@@ -467,7 +467,7 @@ CAMLprim value caml_classify_float(value vd)
   }
 #else
   union double_as_two_int32 u;
-  uint32 h, l;
+  uint32_t h, l;
 
   u.d = Double_val(vd);
   h = u.i.h;  l = u.i.l;
diff --git a/byterun/globroots.c b/byterun/globroots.c
index ded393e..d9111ee 100644
--- a/byterun/globroots.c
+++ b/byterun/globroots.c
@@ -43,11 +43,11 @@ struct global_root_list {
    (i.e. 2 * (NUM_LEVELS - 1)).  Moreover, the congruential PRNG
    is faster and guaranteed to be deterministic (to reproduce bugs). */
 
-static uint32 random_seed = 0;
+static uint32_t random_seed = 0;
 
 static int random_level(void)
 {
-  uint32 r;
+  uint32_t r;
   int level = 0;
 
   /* Linear congruence with modulus = 2^32, multiplier = 69069
diff --git a/byterun/hash.c b/byterun/hash.c
index f896426..12912d3 100644
--- a/byterun/hash.c
+++ b/byterun/hash.c
@@ -41,7 +41,7 @@
   h *= 0xc2b2ae35; \
   h ^= h >> 16;
 
-CAMLexport uint32 caml_hash_mix_uint32(uint32 h, uint32 d)
+CAMLexport uint32_t caml_hash_mix_uint32(uint32_t h, uint32_t d)
 {
   MIX(h, d);
   return h;
@@ -49,17 +49,17 @@ CAMLexport uint32 caml_hash_mix_uint32(uint32 h, uint32 d)
 
 /* Mix a platform-native integer. */
 
-CAMLexport uint32 caml_hash_mix_intnat(uint32 h, intnat d)
+CAMLexport uint32_t caml_hash_mix_intnat(uint32_t h, intnat d)
 {
-  uint32 n;
+  uint32_t n;
 #ifdef ARCH_SIXTYFOUR
   /* Mix the low 32 bits and the high 32 bits, in a way that preserves
-     32/64 compatibility: we want n = (uint32) d
+     32/64 compatibility: we want n = (uint32_t) d
      if d is in the range [-2^31, 2^31-1]. */
   n = (d >> 32) ^ (d >> 63) ^ d;
   /* If 0 <= d < 2^31:   d >> 32 = 0     d >> 63 = 0
      If -2^31 <= d < 0:  d >> 32 = -1    d >> 63 = -1
-     In both cases, n = (uint32) d.  */
+     In both cases, n = (uint32_t) d.  */
 #else
   n = d;
 #endif
@@ -69,9 +69,9 @@ CAMLexport uint32 caml_hash_mix_intnat(uint32 h, intnat d)
 
 /* Mix a 64-bit integer. */
 
-CAMLexport uint32 caml_hash_mix_int64(uint32 h, int64 d)
+CAMLexport uint32_t caml_hash_mix_int64(uint32_t h, int64_t d)
 {
-  uint32 hi = (uint32) (d >> 32), lo = (uint32) d;
+  uint32_t hi = (uint32_t) (d >> 32), lo = (uint32_t) d;
   MIX(h, lo);
   MIX(h, hi);
   return h;
@@ -82,17 +82,17 @@ CAMLexport uint32 caml_hash_mix_int64(uint32 h, int64 d)
    Treats all NaNs identically.
 */
 
-CAMLexport uint32 caml_hash_mix_double(uint32 hash, double d)
+CAMLexport uint32_t caml_hash_mix_double(uint32_t hash, double d)
 {
   union {
     double d;
 #if defined(ARCH_BIG_ENDIAN) || (defined(__arm__) && !defined(__ARM_EABI__))
-    struct { uint32 h; uint32 l; } i;
+    struct { uint32_t h; uint32_t l; } i;
 #else
-    struct { uint32 l; uint32 h; } i;
+    struct { uint32_t l; uint32_t h; } i;
 #endif
   } u;
-  uint32 h, l;
+  uint32_t h, l;
   /* Convert to two 32-bit halves */
   u.d = d;
   h = u.i.h; l = u.i.l;
@@ -115,14 +115,14 @@ CAMLexport uint32 caml_hash_mix_double(uint32 hash, double d)
    Treats all NaNs identically.
 */
 
-CAMLexport uint32 caml_hash_mix_float(uint32 hash, float d)
+CAMLexport uint32_t caml_hash_mix_float(uint32_t hash, float d)
 {
   union {
     float f;
-    uint32 i;
+    uint32_t i;
   } u;
-  uint32 n;
-  /* Convert to int32 */
+  uint32_t n;
+  /* Convert to int32_t */
   u.f = d;  n = u.i;
   /* Normalize NaNs */
   if ((n & 0x7F800000) == 0x7F800000 && (n & 0x007FFFFF) != 0) {
@@ -138,11 +138,11 @@ CAMLexport uint32 caml_hash_mix_float(uint32 hash, float d)
 
 /* Mix an OCaml string */
 
-CAMLexport uint32 caml_hash_mix_string(uint32 h, value s)
+CAMLexport uint32_t caml_hash_mix_string(uint32_t h, value s)
 {
   mlsize_t len = caml_string_length(s);
   mlsize_t i;
-  uint32 w;
+  uint32_t w;
 
   /* Mix by 32-bit blocks (little-endian) */
   for (i = 0; i + 4 <= len; i += 4) {
@@ -152,7 +152,7 @@ CAMLexport uint32 caml_hash_mix_string(uint32 h, value s)
         | (Byte_u(s, i+2) << 16)
         | (Byte_u(s, i+3) << 24);
 #else
-    w = *((uint32 *) &Byte_u(s, i));
+    w = *((uint32_t *) &Byte_u(s, i));
 #endif
     MIX(h, w);
   }
@@ -166,7 +166,7 @@ CAMLexport uint32 caml_hash_mix_string(uint32 h, value s)
   default: /*skip*/;     /* len & 3 == 0, no extra bytes, do nothing */
   }
   /* Finally, mix in the length.  Ignore the upper 32 bits, generally 0. */
-  h ^= (uint32) len;
+  h ^= (uint32_t) len;
   return h;
 }
 
@@ -184,7 +184,7 @@ CAMLprim value caml_hash(value count, value limit, value seed, value obj)
   intnat wr;                    /* One past position of last value in queue */
   intnat sz;                    /* Max number of values to put in queue */
   intnat num;                   /* Max number of meaningful values to see */
-  uint32 h;                     /* Rolling hash */
+  uint32_t h;                     /* Rolling hash */
   value v;
   mlsize_t i, len;
 
@@ -245,7 +245,7 @@ CAMLprim value caml_hash(value count, value limit, value seed, value obj)
         /* If no hashing function provided, do nothing. */
         /* Only use low 32 bits of custom hash, for 32/64 compatibility */
         if (Custom_ops_val(v)->hash != NULL) {
-          uint32 n = (uint32) Custom_ops_val(v)->hash(v);
+          uint32_t n = (uint32_t) Custom_ops_val(v)->hash(v);
           h = caml_hash_mix_uint32(h, n);
           num--;
         }
@@ -408,5 +408,5 @@ CAMLexport value caml_hash_variant(char const * tag)
 #endif
   /* Force sign extension of bit 31 for compatibility between 32 and 64-bit
      platforms */
-  return (int32) accu;
+  return (int32_t) accu;
 }
diff --git a/byterun/hash.h b/byterun/hash.h
index 436a8bb..6561397 100644
--- a/byterun/hash.h
+++ b/byterun/hash.h
@@ -18,12 +18,12 @@
 
 #include "mlvalues.h"
 
-CAMLextern uint32 caml_hash_mix_uint32(uint32 h, uint32 d);
-CAMLextern uint32 caml_hash_mix_intnat(uint32 h, intnat d);
-CAMLextern uint32 caml_hash_mix_int64(uint32 h, int64 d);
-CAMLextern uint32 caml_hash_mix_double(uint32 h, double d);
-CAMLextern uint32 caml_hash_mix_float(uint32 h, float d);
-CAMLextern uint32 caml_hash_mix_string(uint32 h, value s);
+CAMLextern uint32_t caml_hash_mix_uint32(uint32_t h, uint32_t d);
+CAMLextern uint32_t caml_hash_mix_intnat(uint32_t h, intnat d);
+CAMLextern uint32_t caml_hash_mix_int64(uint32_t h, int64_t d);
+CAMLextern uint32_t caml_hash_mix_double(uint32_t h, double d);
+CAMLextern uint32_t caml_hash_mix_float(uint32_t h, float d);
+CAMLextern uint32_t caml_hash_mix_string(uint32_t h, value s);
 
 
 #endif
diff --git a/byterun/int64_emul.h b/byterun/int64_emul.h
index ba7904a..2554df1 100644
--- a/byterun/int64_emul.h
+++ b/byterun/int64_emul.h
@@ -28,7 +28,7 @@
 #define I64_split(x,hi,lo) (hi = (x).h, lo = (x).l)
 
 /* Unsigned comparison */
-static int I64_ucompare(uint64 x, uint64 y)
+static int I64_ucompare(uint64_t x, uint64_t y)
 {
   if (x.h > y.h) return 1;
   if (x.h < y.h) return -1;
@@ -40,19 +40,19 @@ static int I64_ucompare(uint64 x, uint64 y)
 #define I64_ult(x, y) (I64_ucompare(x, y) < 0)
 
 /* Signed comparison */
-static int I64_compare(int64 x, int64 y)
+static int I64_compare(int64_t x, int64_t y)
 {
-  if ((int32)x.h > (int32)y.h) return 1;
-  if ((int32)x.h < (int32)y.h) return -1;
+  if ((int32_t)x.h > (int32_t)y.h) return 1;
+  if ((int32_t)x.h < (int32_t)y.h) return -1;
   if (x.l > y.l) return 1;
   if (x.l < y.l) return -1;
   return 0;
 }
 
 /* Negation */
-static int64 I64_neg(int64 x)
+static int64_t I64_neg(int64_t x)
 {
-  int64 res;
+  int64_t res;
   res.l = -x.l;
   res.h = ~x.h;
   if (res.l == 0) res.h++;
@@ -60,9 +60,9 @@ static int64 I64_neg(int64 x)
 }
 
 /* Addition */
-static int64 I64_add(int64 x, int64 y)
+static int64_t I64_add(int64_t x, int64_t y)
 {
-  int64 res;
+  int64_t res;
   res.l = x.l + y.l;
   res.h = x.h + y.h;
   if (res.l < x.l) res.h++;
@@ -70,9 +70,9 @@ static int64 I64_add(int64 x, int64 y)
 }
 
 /* Subtraction */
-static int64 I64_sub(int64 x, int64 y)
+static int64_t I64_sub(int64_t x, int64_t y)
 {
-  int64 res;
+  int64_t res;
   res.l = x.l - y.l;
   res.h = x.h - y.h;
   if (x.l < y.l) res.h--;
@@ -80,13 +80,13 @@ static int64 I64_sub(int64 x, int64 y)
 }
 
 /* Multiplication */
-static int64 I64_mul(int64 x, int64 y)
+static int64_t I64_mul(int64_t x, int64_t y)
 {
-  int64 res;
-  uint32 prod00 = (x.l & 0xFFFF) * (y.l & 0xFFFF);
-  uint32 prod10 = (x.l >> 16) * (y.l & 0xFFFF);
-  uint32 prod01 = (x.l & 0xFFFF) * (y.l >> 16);
-  uint32 prod11 = (x.l >> 16) * (y.l >> 16);
+  int64_t res;
+  uint32_t prod00 = (x.l & 0xFFFF) * (y.l & 0xFFFF);
+  uint32_t prod10 = (x.l >> 16) * (y.l & 0xFFFF);
+  uint32_t prod01 = (x.l & 0xFFFF) * (y.l >> 16);
+  uint32_t prod11 = (x.l >> 16) * (y.l >> 16);
   res.l = prod00;
   res.h = prod11 + (prod01 >> 16) + (prod10 >> 16);
   prod01 = prod01 << 16; res.l += prod01; if (res.l < prod01) res.h++;
@@ -96,39 +96,39 @@ static int64 I64_mul(int64 x, int64 y)
 }
 
 #define I64_is_zero(x) (((x).l | (x).h) == 0)
-#define I64_is_negative(x) ((int32) (x).h < 0)
+#define I64_is_negative(x) ((int32_t) (x).h < 0)
 #define I64_is_min_int(x) ((x).l == 0 && (x).h == 0x80000000U)
 #define I64_is_minus_one(x) (((x).l & (x).h) == 0xFFFFFFFFU)
 
 /* Bitwise operations */
-static int64 I64_and(int64 x, int64 y)
+static int64_t I64_and(int64_t x, int64_t y)
 {
-  int64 res;
+  int64_t res;
   res.l = x.l & y.l;
   res.h = x.h & y.h;
   return res;
 }
 
-static int64 I64_or(int64 x, int64 y)
+static int64_t I64_or(int64_t x, int64_t y)
 {
-  int64 res;
+  int64_t res;
   res.l = x.l | y.l;
   res.h = x.h | y.h;
   return res;
 }
 
-static int64 I64_xor(int64 x, int64 y)
+static int64_t I64_xor(int64_t x, int64_t y)
 {
-  int64 res;
+  int64_t res;
   res.l = x.l ^ y.l;
   res.h = x.h ^ y.h;
   return res;
 }
 
 /* Shifts */
-static int64 I64_lsl(int64 x, int s)
+static int64_t I64_lsl(int64_t x, int s)
 {
-  int64 res;
+  int64_t res;
   s = s & 63;
   if (s == 0) return x;
   if (s < 32) {
@@ -141,9 +141,9 @@ static int64 I64_lsl(int64 x, int s)
   return res;
 }
 
-static int64 I64_lsr(int64 x, int s)
+static int64_t I64_lsr(int64_t x, int s)
 {
-  int64 res;
+  int64_t res;
   s = s & 63;
   if (s == 0) return x;
   if (s < 32) {
@@ -156,17 +156,17 @@ static int64 I64_lsr(int64 x, int s)
   return res;
 }
 
-static int64 I64_asr(int64 x, int s)
+static int64_t I64_asr(int64_t x, int s)
 {
-  int64 res;
+  int64_t res;
   s = s & 63;
   if (s == 0) return x;
   if (s < 32) {
     res.l = (x.l >> s) | (x.h << (32 - s));
-    res.h = (int32) x.h >> s;
+    res.h = (int32_t) x.h >> s;
   } else {
-    res.l = (int32) x.h >> (s - 32);
-    res.h = (int32) x.h >> 31;
+    res.l = (int32_t) x.h >> (s - 32);
+    res.h = (int32_t) x.h >> 31;
   }
   return res;
 }
@@ -176,15 +176,15 @@ static int64 I64_asr(int64 x, int s)
 #define I64_SHL1(x) x.h = (x.h << 1) | (x.l >> 31); x.l <<= 1
 #define I64_SHR1(x) x.l = (x.l >> 1) | (x.h << 31); x.h >>= 1
 
-static void I64_udivmod(uint64 modulus, uint64 divisor,
-                        uint64 * quo, uint64 * mod)
+static void I64_udivmod(uint64_t modulus, uint64_t divisor,
+                        uint64_t * quo, uint64_t * mod)
 {
-  int64 quotient, mask;
+  int64_t quotient, mask;
   int cmp;
 
   quotient.h = 0; quotient.l = 0;
   mask.h = 0; mask.l = 1;
-  while ((int32) divisor.h >= 0) {
+  while ((int32_t) divisor.h >= 0) {
     cmp = I64_ucompare(divisor, modulus);
     I64_SHL1(divisor);
     I64_SHL1(mask);
@@ -202,27 +202,27 @@ static void I64_udivmod(uint64 modulus, uint64 divisor,
   *mod = modulus;
 }
 
-static int64 I64_div(int64 x, int64 y)
+static int64_t I64_div(int64_t x, int64_t y)
 {
-  int64 q, r;
-  int32 sign;
+  int64_t q, r;
+  int32_t sign;
 
   sign = x.h ^ y.h;
-  if ((int32) x.h < 0) x = I64_neg(x);
-  if ((int32) y.h < 0) y = I64_neg(y);
+  if ((int32_t) x.h < 0) x = I64_neg(x);
+  if ((int32_t) y.h < 0) y = I64_neg(y);
   I64_udivmod(x, y, &q, &r);
   if (sign < 0) q = I64_neg(q);
   return q;
 }
 
-static int64 I64_mod(int64 x, int64 y)
+static int64_t I64_mod(int64_t x, int64_t y)
 {
-  int64 q, r;
-  int32 sign;
+  int64_t q, r;
+  int32_t sign;
 
   sign = x.h;
-  if ((int32) x.h < 0) x = I64_neg(x);
-  if ((int32) y.h < 0) y = I64_neg(y);
+  if ((int32_t) x.h < 0) x = I64_neg(x);
+  if ((int32_t) y.h < 0) y = I64_neg(y);
   I64_udivmod(x, y, &q, &r);
   if (sign < 0) r = I64_neg(r);
   return r;
@@ -230,49 +230,49 @@ static int64 I64_mod(int64 x, int64 y)
 
 /* Coercions */
 
-static int64 I64_of_int32(int32 x)
+static int64_t I64_of_int32(int32_t x)
 {
-  int64 res;
+  int64_t res;
   res.l = x;
   res.h = x >> 31;
   return res;
 }
 
-#define I64_to_int32(x) ((int32) (x).l)
+#define I64_to_int32(x) ((int32_t) (x).l)
 
 /* Note: we assume sizeof(intnat) = 4 here, which is true otherwise
    autoconfiguration would have selected native 64-bit integers */
 #define I64_of_intnat I64_of_int32
 #define I64_to_intnat I64_to_int32
 
-static double I64_to_double(int64 x)
+static double I64_to_double(int64_t x)
 {
   double res;
-  int32 sign = x.h;
+  int32_t sign = x.h;
   if (sign < 0) x = I64_neg(x);
   res = ldexp((double) x.h, 32) + x.l;
   if (sign < 0) res = -res;
   return res;
 }
 
-static int64 I64_of_double(double f)
+static int64_t I64_of_double(double f)
 {
-  int64 res;
+  int64_t res;
   double frac, integ;
   int neg;
 
   neg = (f < 0);
   f = fabs(f);
   frac = modf(ldexp(f, -32), &integ);
-  res.h = (uint32) integ;
-  res.l = (uint32) ldexp(frac, 32);
+  res.h = (uint32_t) integ;
+  res.l = (uint32_t) ldexp(frac, 32);
   if (neg) res = I64_neg(res);
   return res;
 }
 
-static int64 I64_bswap(int64 x)
+static int64_t I64_bswap(int64_t x)
 {
-  int64 res;
+  int64_t res;
   res.h = (((x.l & 0x000000FF) << 24) |
            ((x.l & 0x0000FF00) << 8) |
            ((x.l & 0x00FF0000) >> 8) |
diff --git a/byterun/int64_format.h b/byterun/int64_format.h
index b0de527..aa8f1ab 100644
--- a/byterun/int64_format.h
+++ b/byterun/int64_format.h
@@ -17,7 +17,7 @@
 #ifndef CAML_INT64_FORMAT_H
 #define CAML_INT64_FORMAT_H
 
-static void I64_format(char * buffer, char * fmt, int64 x)
+static void I64_format(char * buffer, char * fmt, int64_t x)
 {
   static char conv_lower[] = "0123456789abcdef";
   static char conv_upper[] = "0123456789ABCDEF";
@@ -26,7 +26,7 @@ static void I64_format(char * buffer, char * fmt, int64 x)
   int base, width, sign, i, rawlen;
   char * cvtbl;
   char * p, * r;
-  int64 wbase, digit;
+  int64_t wbase, digit;
 
   /* Parsing of format */
   justify = '+';
diff --git a/byterun/int64_native.h b/byterun/int64_native.h
index e9ffe67..b6716ad 100644
--- a/byterun/int64_native.h
+++ b/byterun/int64_native.h
@@ -18,36 +18,36 @@
 #ifndef CAML_INT64_NATIVE_H
 #define CAML_INT64_NATIVE_H
 
-#define I64_literal(hi,lo) ((int64)(hi) << 32 | (lo))
-#define I64_split(x,hi,lo) (hi = (uint32)((x)>>32), lo = (uint32)(x))
+#define I64_literal(hi,lo) ((int64_t)(hi) << 32 | (lo))
+#define I64_split(x,hi,lo) (hi = (uint32_t)((x)>>32), lo = (uint32_t)(x))
 #define I64_compare(x,y) (((x) > (y)) - ((x) < (y)))
-#define I64_ult(x,y) ((uint64)(x) < (uint64)(y))
+#define I64_ult(x,y) ((uint64_t)(x) < (uint64_t)(y))
 #define I64_neg(x) (-(x))
 #define I64_add(x,y) ((x) + (y))
 #define I64_sub(x,y) ((x) - (y))
 #define I64_mul(x,y) ((x) * (y))
 #define I64_is_zero(x) ((x) == 0)
 #define I64_is_negative(x) ((x) < 0)
-#define I64_is_min_int(x) ((x) == ((int64)1 << 63))
+#define I64_is_min_int(x) ((x) == ((int64_t)1 << 63))
 #define I64_is_minus_one(x) ((x) == -1)
 
 #define I64_div(x,y) ((x) / (y))
 #define I64_mod(x,y) ((x) % (y))
 #define I64_udivmod(x,y,quo,rem) \
-  (*(rem) = (uint64)(x) % (uint64)(y), \
-   *(quo) = (uint64)(x) / (uint64)(y))
+  (*(rem) = (uint64_t)(x) % (uint64_t)(y), \
+   *(quo) = (uint64_t)(x) / (uint64_t)(y))
 #define I64_and(x,y) ((x) & (y))
 #define I64_or(x,y) ((x) | (y))
 #define I64_xor(x,y) ((x) ^ (y))
 #define I64_lsl(x,y) ((x) << (y))
 #define I64_asr(x,y) ((x) >> (y))
-#define I64_lsr(x,y) ((uint64)(x) >> (y))
+#define I64_lsr(x,y) ((uint64_t)(x) >> (y))
 #define I64_to_intnat(x) ((intnat) (x))
 #define I64_of_intnat(x) ((intnat) (x))
-#define I64_to_int32(x) ((int32) (x))
-#define I64_of_int32(x) ((int64) (x))
+#define I64_to_int32(x) ((int32_t) (x))
+#define I64_of_int32(x) ((int64_t) (x))
 #define I64_to_double(x) ((double)(x))
-#define I64_of_double(x) ((int64)(x))
+#define I64_of_double(x) ((int64_t)(x))
 
 #define I64_bswap(x) ((((x) & 0x00000000000000FFULL) << 56) | \
                       (((x) & 0x000000000000FF00ULL) << 40) | \
diff --git a/byterun/intern.c b/byterun/intern.c
index e0fcc5d..638ff72 100644
--- a/byterun/intern.c
+++ b/byterun/intern.c
@@ -553,7 +553,7 @@ static void intern_add_to_heap(mlsize_t whsize)
 
 value caml_input_val(struct channel *chan)
 {
-  uint32 magic;
+  uint32_t magic;
   mlsize_t block_len, num_objects, whsize;
   char * block;
   value res;
@@ -663,7 +663,7 @@ static value input_val_from_block(void)
 
 CAMLexport value caml_input_value_from_malloc(char * data, intnat ofs)
 {
-  uint32 magic;
+  uint32_t magic;
   value obj;
 
   intern_input = (unsigned char *) data;
@@ -681,7 +681,7 @@ CAMLexport value caml_input_value_from_malloc(char * data, intnat ofs)
 
 CAMLexport value caml_input_value_from_block(char * data, intnat len)
 {
-  uint32 magic;
+  uint32_t magic;
   mlsize_t block_len;
   value obj;
 
@@ -700,7 +700,7 @@ CAMLexport value caml_input_value_from_block(char * data, intnat len)
 
 CAMLprim value caml_marshal_data_size(value buff, value ofs)
 {
-  uint32 magic;
+  uint32_t magic;
   mlsize_t block_len;
 
   intern_src = &Byte_u(buff, Long_val(ofs));
@@ -771,26 +771,26 @@ CAMLexport int caml_deserialize_sint_2(void)
   return read16s();
 }
 
-CAMLexport uint32 caml_deserialize_uint_4(void)
+CAMLexport uint32_t caml_deserialize_uint_4(void)
 {
   return read32u();
 }
 
-CAMLexport int32 caml_deserialize_sint_4(void)
+CAMLexport int32_t caml_deserialize_sint_4(void)
 {
   return read32s();
 }
 
-CAMLexport uint64 caml_deserialize_uint_8(void)
+CAMLexport uint64_t caml_deserialize_uint_8(void)
 {
-  uint64 i;
+  uint64_t i;
   caml_deserialize_block_8(&i, 1);
   return i;
 }
 
-CAMLexport int64 caml_deserialize_sint_8(void)
+CAMLexport int64_t caml_deserialize_sint_8(void)
 {
-  int64 i;
+  int64_t i;
   caml_deserialize_block_8(&i, 1);
   return i;
 }
diff --git a/byterun/interp.c b/byterun/interp.c
index 9b682ba..e22b28b 100644
--- a/byterun/interp.c
+++ b/byterun/interp.c
@@ -793,7 +793,7 @@ value caml_interprete(code_t prog, asize_t prog_size)
       if (accu == Val_false) pc += *pc; else pc++;
       Next;
     Instruct(SWITCH): {
-      uint32 sizes = *pc++;
+      uint32_t sizes = *pc++;
       if (Is_block(accu)) {
         intnat index = Tag_val(accu);
         Assert ((uintnat) index < (sizes >> 16));
diff --git a/byterun/intext.h b/byterun/intext.h
index f7aa655..2c108a4 100644
--- a/byterun/intext.h
+++ b/byterun/intext.h
@@ -119,8 +119,8 @@ CAMLextern value caml_input_value_from_block(char * data, intnat len);
 
 CAMLextern void caml_serialize_int_1(int i);
 CAMLextern void caml_serialize_int_2(int i);
-CAMLextern void caml_serialize_int_4(int32 i);
-CAMLextern void caml_serialize_int_8(int64 i);
+CAMLextern void caml_serialize_int_4(int32_t i);
+CAMLextern void caml_serialize_int_8(int64_t i);
 CAMLextern void caml_serialize_float_4(float f);
 CAMLextern void caml_serialize_float_8(double f);
 CAMLextern void caml_serialize_block_1(void * data, intnat len);
@@ -133,10 +133,10 @@ CAMLextern int caml_deserialize_uint_1(void);
 CAMLextern int caml_deserialize_sint_1(void);
 CAMLextern int caml_deserialize_uint_2(void);
 CAMLextern int caml_deserialize_sint_2(void);
-CAMLextern uint32 caml_deserialize_uint_4(void);
-CAMLextern int32 caml_deserialize_sint_4(void);
-CAMLextern uint64 caml_deserialize_uint_8(void);
-CAMLextern int64 caml_deserialize_sint_8(void);
+CAMLextern uint32_t caml_deserialize_uint_4(void);
+CAMLextern int32_t caml_deserialize_sint_4(void);
+CAMLextern uint64_t caml_deserialize_uint_8(void);
+CAMLextern int64_t caml_deserialize_sint_8(void);
 CAMLextern float caml_deserialize_float_4(void);
 CAMLextern double caml_deserialize_float_8(void);
 CAMLextern void caml_deserialize_block_1(void * data, intnat len);
diff --git a/byterun/ints.c b/byterun/ints.c
index d762c76..056e82a 100644
--- a/byterun/ints.c
+++ b/byterun/ints.c
@@ -172,8 +172,8 @@ CAMLprim value caml_format_int(value fmt, value arg)
 
 static int int32_cmp(value v1, value v2)
 {
-  int32 i1 = Int32_val(v1);
-  int32 i2 = Int32_val(v2);
+  int32_t i1 = Int32_val(v1);
+  int32_t i2 = Int32_val(v2);
   return (i1 > i2) - (i1 < i2);
 }
 
@@ -191,7 +191,7 @@ static void int32_serialize(value v, uintnat * wsize_32,
 
 static uintnat int32_deserialize(void * dst)
 {
-  *((int32 *) dst) = caml_deserialize_sint_4();
+  *((int32_t *) dst) = caml_deserialize_sint_4();
   return 4;
 }
 
@@ -205,7 +205,7 @@ CAMLexport struct custom_operations caml_int32_ops = {
   custom_compare_ext_default
 };
 
-CAMLexport value caml_copy_int32(int32 i)
+CAMLexport value caml_copy_int32(int32_t i)
 {
   value res = caml_alloc_custom(&caml_int32_ops, 4, 0, 1);
   Int32_val(res) = i;
@@ -226,8 +226,8 @@ CAMLprim value caml_int32_mul(value v1, value v2)
 
 CAMLprim value caml_int32_div(value v1, value v2)
 {
-  int32 dividend = Int32_val(v1);
-  int32 divisor = Int32_val(v2);
+  int32_t dividend = Int32_val(v1);
+  int32_t divisor = Int32_val(v2);
   if (divisor == 0) caml_raise_zero_divide();
   /* PR#4740: on some processors, division crashes on overflow.
      Implement the same behavior as for type "int". */
@@ -237,8 +237,8 @@ CAMLprim value caml_int32_div(value v1, value v2)
 
 CAMLprim value caml_int32_mod(value v1, value v2)
 {
-  int32 dividend = Int32_val(v1);
-  int32 divisor = Int32_val(v2);
+  int32_t dividend = Int32_val(v1);
+  int32_t divisor = Int32_val(v2);
   if (divisor == 0) caml_raise_zero_divide();
   /* PR#4740: on some processors, modulus crashes if division overflows.
      Implement the same behavior as for type "int". */
@@ -262,9 +262,9 @@ CAMLprim value caml_int32_shift_right(value v1, value v2)
 { return caml_copy_int32(Int32_val(v1) >> Int_val(v2)); }
 
 CAMLprim value caml_int32_shift_right_unsigned(value v1, value v2)
-{ return caml_copy_int32((uint32)Int32_val(v1) >> Int_val(v2)); }
+{ return caml_copy_int32((uint32_t)Int32_val(v1) >> Int_val(v2)); }
 
-static int32 caml_swap32(int32 x)
+static int32_t caml_swap32(int32_t x)
 {
   return (((x & 0x000000FF) << 24) |
           ((x & 0x0000FF00) << 8) |
@@ -285,15 +285,15 @@ CAMLprim value caml_int32_to_int(value v)
 { return Val_long(Int32_val(v)); }
 
 CAMLprim value caml_int32_of_float(value v)
-{ return caml_copy_int32((int32)(Double_val(v))); }
+{ return caml_copy_int32((int32_t)(Double_val(v))); }
 
 CAMLprim value caml_int32_to_float(value v)
 { return caml_copy_double((double)(Int32_val(v))); }
 
 CAMLprim value caml_int32_compare(value v1, value v2)
 {
-  int32 i1 = Int32_val(v1);
-  int32 i2 = Int32_val(v2);
+  int32_t i1 = Int32_val(v1);
+  int32_t i2 = Int32_val(v2);
   int res = (i1 > i2) - (i1 < i2);
   return Val_int(res);
 }
@@ -313,14 +313,14 @@ CAMLprim value caml_int32_of_string(value s)
 
 CAMLprim value caml_int32_bits_of_float(value vd)
 {
-  union { float d; int32 i; } u;
+  union { float d; int32_t i; } u;
   u.d = Double_val(vd);
   return caml_copy_int32(u.i);
 }
 
 CAMLprim value caml_int32_float_of_bits(value vi)
 {
-  union { float d; int32 i; } u;
+  union { float d; int32_t i; } u;
   u.i = Int32_val(vi);
   return caml_copy_double(u.d);
 }
@@ -329,11 +329,11 @@ CAMLprim value caml_int32_float_of_bits(value vi)
 
 #ifdef ARCH_ALIGN_INT64
 
-CAMLexport int64 caml_Int64_val(value v)
+CAMLexport int64_t caml_Int64_val(value v)
 {
-  union { int32 i[2]; int64 j; } buffer;
-  buffer.i[0] = ((int32 *) Data_custom_val(v))[0];
-  buffer.i[1] = ((int32 *) Data_custom_val(v))[1];
+  union { int32_t i[2]; int64_t j; } buffer;
+  buffer.i[0] = ((int32_t *) Data_custom_val(v))[0];
+  buffer.i[1] = ((int32_t *) Data_custom_val(v))[1];
   return buffer.j;
 }
 
@@ -341,15 +341,15 @@ CAMLexport int64 caml_Int64_val(value v)
 
 static int int64_cmp(value v1, value v2)
 {
-  int64 i1 = Int64_val(v1);
-  int64 i2 = Int64_val(v2);
+  int64_t i1 = Int64_val(v1);
+  int64_t i2 = Int64_val(v2);
   return (i1 > i2) - (i1 < i2);
 }
 
 static intnat int64_hash(value v)
 {
-  int64 x = Int64_val(v);
-  uint32 lo = (uint32) x, hi = (uint32) (x >> 32);
+  int64_t x = Int64_val(v);
+  uint32_t lo = (uint32_t) x, hi = (uint32_t) (x >> 32);
   return hi ^ lo;
 }
 
@@ -363,12 +363,12 @@ static void int64_serialize(value v, uintnat * wsize_32,
 static uintnat int64_deserialize(void * dst)
 {
 #ifndef ARCH_ALIGN_INT64
-  *((int64 *) dst) = caml_deserialize_sint_8();
+  *((int64_t *) dst) = caml_deserialize_sint_8();
 #else
-  union { int32 i[2]; int64 j; } buffer;
+  union { int32_t i[2]; int64_t j; } buffer;
   buffer.j = caml_deserialize_sint_8();
-  ((int32 *) dst)[0] = buffer.i[0];
-  ((int32 *) dst)[1] = buffer.i[1];
+  ((int32_t *) dst)[0] = buffer.i[0];
+  ((int32_t *) dst)[1] = buffer.i[1];
 #endif
   return 8;
 }
@@ -383,16 +383,16 @@ CAMLexport struct custom_operations caml_int64_ops = {
   custom_compare_ext_default
 };
 
-CAMLexport value caml_copy_int64(int64 i)
+CAMLexport value caml_copy_int64(int64_t i)
 {
   value res = caml_alloc_custom(&caml_int64_ops, 8, 0, 1);
 #ifndef ARCH_ALIGN_INT64
   Int64_val(res) = i;
 #else
-  union { int32 i[2]; int64 j; } buffer;
+  union { int32_t i[2]; int64_t j; } buffer;
   buffer.j = i;
-  ((int32 *) Data_custom_val(res))[0] = buffer.i[0];
-  ((int32 *) Data_custom_val(res))[1] = buffer.i[1];
+  ((int32_t *) Data_custom_val(res))[0] = buffer.i[0];
+  ((int32_t *) Data_custom_val(res))[1] = buffer.i[1];
 #endif
   return res;
 }
@@ -413,23 +413,23 @@ CAMLprim value caml_int64_mul(value v1, value v2)
 
 CAMLprim value caml_int64_div(value v1, value v2)
 {
-  int64 dividend = Int64_val(v1);
-  int64 divisor = Int64_val(v2);
+  int64_t dividend = Int64_val(v1);
+  int64_t divisor = Int64_val(v2);
   if (divisor == 0) caml_raise_zero_divide();
   /* PR#4740: on some processors, division crashes on overflow.
      Implement the same behavior as for type "int". */
-  if (dividend == ((int64)1 << 63) && divisor == -1) return v1;
+  if (dividend == ((int64_t)1 << 63) && divisor == -1) return v1;
   return caml_copy_int64(Int64_val(v1) / divisor);
 }
 
 CAMLprim value caml_int64_mod(value v1, value v2)
 {
-  int64 dividend = Int64_val(v1);
-  int64 divisor = Int64_val(v2);
+  int64_t dividend = Int64_val(v1);
+  int64_t divisor = Int64_val(v2);
   if (divisor == 0) caml_raise_zero_divide();
   /* PR#4740: on some processors, division crashes on overflow.
      Implement the same behavior as for type "int". */
-  if (dividend == ((int64)1 << 63) && divisor == -1) return caml_copy_int64(0);
+  if (dividend == ((int64_t)1 << 63) && divisor == -1) return caml_copy_int64(0);
   return caml_copy_int64(Int64_val(v1) % divisor);
 }
 
@@ -449,7 +449,7 @@ CAMLprim value caml_int64_shift_right(value v1, value v2)
 { return caml_copy_int64(Int64_val(v1) >> Int_val(v2)); }
 
 CAMLprim value caml_int64_shift_right_unsigned(value v1, value v2)
-{ return caml_copy_int64((uint64) (Int64_val(v1)) >>  Int_val(v2)); }
+{ return caml_copy_int64((uint64_t) (Int64_val(v1)) >>  Int_val(v2)); }
 
 #ifdef ARCH_SIXTYFOUR
 static value caml_swap64(value x)
@@ -470,7 +470,7 @@ value caml_int64_direct_bswap(value v)
 
 CAMLprim value caml_int64_bswap(value v)
 {
-  int64 x = Int64_val(v);
+  int64_t x = Int64_val(v);
   return caml_copy_int64
     (((x & 0x00000000000000FFULL) << 56) |
      ((x & 0x000000000000FF00ULL) << 40) |
@@ -483,33 +483,33 @@ CAMLprim value caml_int64_bswap(value v)
 }
 
 CAMLprim value caml_int64_of_int(value v)
-{ return caml_copy_int64((int64) (Long_val(v))); }
+{ return caml_copy_int64((int64_t) (Long_val(v))); }
 
 CAMLprim value caml_int64_to_int(value v)
 { return Val_long((intnat) (Int64_val(v))); }
 
 CAMLprim value caml_int64_of_float(value v)
-{ return caml_copy_int64((int64) (Double_val(v))); }
+{ return caml_copy_int64((int64_t) (Double_val(v))); }
 
 CAMLprim value caml_int64_to_float(value v)
 { return caml_copy_double((double) (Int64_val(v))); }
 
 CAMLprim value caml_int64_of_int32(value v)
-{ return caml_copy_int64((int64) (Int32_val(v))); }
+{ return caml_copy_int64((int64_t) (Int32_val(v))); }
 
 CAMLprim value caml_int64_to_int32(value v)
-{ return caml_copy_int32((int32) (Int64_val(v))); }
+{ return caml_copy_int32((int32_t) (Int64_val(v))); }
 
 CAMLprim value caml_int64_of_nativeint(value v)
-{ return caml_copy_int64((int64) (Nativeint_val(v))); }
+{ return caml_copy_int64((int64_t) (Nativeint_val(v))); }
 
 CAMLprim value caml_int64_to_nativeint(value v)
 { return caml_copy_nativeint((intnat) (Int64_val(v))); }
 
 CAMLprim value caml_int64_compare(value v1, value v2)
 {
-  int64 i1 = Int64_val(v1);
-  int64 i2 = Int64_val(v2);
+  int64_t i1 = Int64_val(v1);
+  int64_t i2 = Int64_val(v2);
   return Val_int((i1 > i2) - (i1 < i2));
 }
 
@@ -524,11 +524,11 @@ CAMLprim value caml_int64_format(value fmt, value arg)
 CAMLprim value caml_int64_of_string(value s)
 {
   char * p;
-  uint64 res, threshold;
+  uint64_t res, threshold;
   int sign, base, d;
 
   p = parse_sign_and_base(String_val(s), &base, &sign);
-  threshold = ((uint64) -1) / base;
+  threshold = ((uint64_t) -1) / base;
   d = parse_digit(*p);
   if (d < 0 || d >= base) caml_failwith("int_of_string");
   res = d;
@@ -541,7 +541,7 @@ CAMLprim value caml_int64_of_string(value s)
     if (res > threshold) caml_failwith("int_of_string");
     res = base * res + d;
     /* Detect overflow in addition (base * res) + d */
-    if (res < (uint64) d) caml_failwith("int_of_string");
+    if (res < (uint64_t) d) caml_failwith("int_of_string");
   }
   if (p != String_val(s) + caml_string_length(s)){
     caml_failwith("int_of_string");
@@ -549,9 +549,9 @@ CAMLprim value caml_int64_of_string(value s)
   if (base == 10) {
     /* Signed representation expected, allow -2^63 to 2^63 - 1 only */
     if (sign >= 0) {
-      if (res >= (uint64)1 << 63) caml_failwith("int_of_string");
+      if (res >= (uint64_t)1 << 63) caml_failwith("int_of_string");
     } else {
-      if (res >  (uint64)1 << 63) caml_failwith("int_of_string");
+      if (res >  (uint64_t)1 << 63) caml_failwith("int_of_string");
     }
   }
   if (sign < 0) res = - res;
@@ -560,20 +560,20 @@ CAMLprim value caml_int64_of_string(value s)
 
 CAMLprim value caml_int64_bits_of_float(value vd)
 {
-  union { double d; int64 i; int32 h[2]; } u;
+  union { double d; int64_t i; int32_t h[2]; } u;
   u.d = Double_val(vd);
 #if defined(__arm__) && !defined(__ARM_EABI__)
-  { int32 t = u.h[0]; u.h[0] = u.h[1]; u.h[1] = t; }
+  { int32_t t = u.h[0]; u.h[0] = u.h[1]; u.h[1] = t; }
 #endif
   return caml_copy_int64(u.i);
 }
 
 CAMLprim value caml_int64_float_of_bits(value vi)
 {
-  union { double d; int64 i; int32 h[2]; } u;
+  union { double d; int64_t i; int32_t h[2]; } u;
   u.i = Int64_val(vi);
 #if defined(__arm__) && !defined(__ARM_EABI__)
-  { int32 t = u.h[0]; u.h[0] = u.h[1]; u.h[1] = t; }
+  { int32_t t = u.h[0]; u.h[0] = u.h[1]; u.h[1] = t; }
 #endif
   return caml_copy_double(u.d);
 }
@@ -606,7 +606,7 @@ static void nativeint_serialize(value v, uintnat * wsize_32,
 #ifdef ARCH_SIXTYFOUR
   if (l >= -((intnat)1 << 31) && l < ((intnat)1 << 31)) {
     caml_serialize_int_1(1);
-    caml_serialize_int_4((int32) l);
+    caml_serialize_int_4((int32_t) l);
   } else {
     caml_serialize_int_1(2);
     caml_serialize_int_8(l);
diff --git a/byterun/io.c b/byterun/io.c
index 5f04a96..bedc0f0 100644
--- a/byterun/io.c
+++ b/byterun/io.c
@@ -207,7 +207,7 @@ CAMLexport void caml_flush(struct channel *channel)
 
 /* Output data */
 
-CAMLexport void caml_putword(struct channel *channel, uint32 w)
+CAMLexport void caml_putword(struct channel *channel, uint32_t w)
 {
   if (! caml_channel_binary_mode(channel))
     caml_failwith("output_binary_int: not a binary channel");
@@ -303,10 +303,10 @@ CAMLexport unsigned char caml_refill(struct channel *channel)
   return (unsigned char)(channel->buff[0]);
 }
 
-CAMLexport uint32 caml_getword(struct channel *channel)
+CAMLexport uint32_t caml_getword(struct channel *channel)
 {
   int i;
-  uint32 res;
+  uint32_t res;
 
   if (! caml_channel_binary_mode(channel))
     caml_failwith("input_binary_int: not a binary channel");
diff --git a/byterun/io.h b/byterun/io.h
index 64a8bf5..5a9c037 100644
--- a/byterun/io.h
+++ b/byterun/io.h
@@ -78,12 +78,12 @@ CAMLextern value caml_alloc_channel(struct channel *chan);
 
 CAMLextern int caml_flush_partial (struct channel *);
 CAMLextern void caml_flush (struct channel *);
-CAMLextern void caml_putword (struct channel *, uint32);
+CAMLextern void caml_putword (struct channel *, uint32_t);
 CAMLextern int caml_putblock (struct channel *, char *, intnat);
 CAMLextern void caml_really_putblock (struct channel *, char *, intnat);
 
 CAMLextern unsigned char caml_refill (struct channel *);
-CAMLextern uint32 caml_getword (struct channel *);
+CAMLextern uint32_t caml_getword (struct channel *);
 CAMLextern int caml_getblock (struct channel *, char *, intnat);
 CAMLextern int caml_really_getblock (struct channel *, char *, intnat);
 
@@ -107,7 +107,7 @@ CAMLextern struct channel * caml_all_opened_channels;
 #define Unlock_exn() \
   if (caml_channel_mutex_unlock_exn != NULL) (*caml_channel_mutex_unlock_exn)()
 
-/* Conversion between file_offset and int64 */
+/* Conversion between file_offset and int64_t */
 
 #define Val_file_offset(fofs) caml_copy_int64(fofs)
 #define File_offset_val(v) ((file_offset) Int64_val(v))
diff --git a/byterun/md5.c b/byterun/md5.c
index 10ac76a..2dc90a2 100644
--- a/byterun/md5.c
+++ b/byterun/md5.c
@@ -97,11 +97,11 @@ CAMLexport void caml_md5_block(unsigned char digest[16],
 #else
 static void byteReverse(unsigned char * buf, unsigned longs)
 {
-    uint32 t;
+    uint32_t t;
     do {
-        t = (uint32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
+        t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
             ((unsigned) buf[1] << 8 | buf[0]);
-        *(uint32 *) buf = t;
+        *(uint32_t *) buf = t;
         buf += 4;
     } while (--longs);
 }
@@ -129,12 +129,12 @@ CAMLexport void caml_MD5Init(struct MD5Context *ctx)
 CAMLexport void caml_MD5Update(struct MD5Context *ctx, unsigned char *buf,
                                uintnat len)
 {
-    uint32 t;
+    uint32_t t;
 
     /* Update bitcount */
 
     t = ctx->bits[0];
-    if ((ctx->bits[0] = t + ((uint32) len << 3)) < t)
+    if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t)
         ctx->bits[1]++;         /* Carry from low to high */
     ctx->bits[1] += len >> 29;
 
@@ -152,7 +152,7 @@ CAMLexport void caml_MD5Update(struct MD5Context *ctx, unsigned char *buf,
         }
         memcpy(p, buf, t);
         byteReverse(ctx->in, 16);
-        caml_MD5Transform(ctx->buf, (uint32 *) ctx->in);
+        caml_MD5Transform(ctx->buf, (uint32_t *) ctx->in);
         buf += t;
         len -= t;
     }
@@ -161,7 +161,7 @@ CAMLexport void caml_MD5Update(struct MD5Context *ctx, unsigned char *buf,
     while (len >= 64) {
         memcpy(ctx->in, buf, 64);
         byteReverse(ctx->in, 16);
-        caml_MD5Transform(ctx->buf, (uint32 *) ctx->in);
+        caml_MD5Transform(ctx->buf, (uint32_t *) ctx->in);
         buf += 64;
         len -= 64;
     }
@@ -196,7 +196,7 @@ CAMLexport void caml_MD5Final(unsigned char *digest, struct MD5Context *ctx)
         /* Two lots of padding:  Pad the first block to 64 bytes */
         memset(p, 0, count);
         byteReverse(ctx->in, 16);
-        caml_MD5Transform(ctx->buf, (uint32 *) ctx->in);
+        caml_MD5Transform(ctx->buf, (uint32_t *) ctx->in);
 
         /* Now fill the next block with 56 bytes */
         memset(ctx->in, 0, 56);
@@ -207,10 +207,10 @@ CAMLexport void caml_MD5Final(unsigned char *digest, struct MD5Context *ctx)
     byteReverse(ctx->in, 14);
 
     /* Append length in bits and transform */
-    ((uint32 *) ctx->in)[14] = ctx->bits[0];
-    ((uint32 *) ctx->in)[15] = ctx->bits[1];
+    ((uint32_t *) ctx->in)[14] = ctx->bits[0];
+    ((uint32_t *) ctx->in)[15] = ctx->bits[1];
 
-    caml_MD5Transform(ctx->buf, (uint32 *) ctx->in);
+    caml_MD5Transform(ctx->buf, (uint32_t *) ctx->in);
     byteReverse((unsigned char *) ctx->buf, 4);
     memcpy(digest, ctx->buf, 16);
     memset(ctx, 0, sizeof(*ctx));        /* In case it's sensitive */
@@ -233,9 +233,9 @@ CAMLexport void caml_MD5Final(unsigned char *digest, struct MD5Context *ctx)
  * reflect the addition of 16 longwords of new data.  caml_MD5Update blocks
  * the data and converts bytes into longwords for this routine.
  */
-CAMLexport void caml_MD5Transform(uint32 *buf, uint32 *in)
+CAMLexport void caml_MD5Transform(uint32_t *buf, uint32_t *in)
 {
-    register uint32 a, b, c, d;
+    register uint32_t a, b, c, d;
 
     a = buf[0];
     b = buf[1];
diff --git a/byterun/md5.h b/byterun/md5.h
index d8aff09..f63667d 100644
--- a/byterun/md5.h
+++ b/byterun/md5.h
@@ -26,8 +26,8 @@ CAMLextern void caml_md5_block(unsigned char digest[16],
                                void * data, uintnat len);
 
 struct MD5Context {
-        uint32 buf[4];
-        uint32 bits[2];
+        uint32_t buf[4];
+        uint32_t bits[2];
         unsigned char in[64];
 };
 
@@ -35,7 +35,7 @@ CAMLextern void caml_MD5Init (struct MD5Context *context);
 CAMLextern void caml_MD5Update (struct MD5Context *context, unsigned char *buf,
                                 uintnat len);
 CAMLextern void caml_MD5Final (unsigned char *digest, struct MD5Context *ctx);
-CAMLextern void caml_MD5Transform (uint32 *buf, uint32 *in);
+CAMLextern void caml_MD5Transform (uint32_t *buf, uint32_t *in);
 
 
 #endif /* CAML_MD5_H */
diff --git a/byterun/mlvalues.h b/byterun/mlvalues.h
index 268bcfe..a08948e 100644
--- a/byterun/mlvalues.h
+++ b/byterun/mlvalues.h
@@ -38,8 +38,8 @@ extern "C" {
   bp: Pointer to the first byte of a block.  (a char *)
   op: Pointer to the first field of a block.  (a value *)
   hp: Pointer to the header of a block.  (a char *)
-  int32: Four bytes on all architectures.
-  int64: Eight bytes on all architectures.
+  int32_t: Four bytes on all architectures.
+  int64_t: Eight bytes on all architectures.
 
   Remark: A block size is always a multiple of the word size, and at least
           one word plus the header.
@@ -161,7 +161,7 @@ bits  63    10 9     8 7   0
 /* Fields are numbered from 0. */
 #define Field(x, i) (((value *)(x)) [i])           /* Also an l-value. */
 
-typedef int32 opcode_t;
+typedef int32_t opcode_t;
 typedef opcode_t * code_t;
 
 /* NOTE: [Forward_tag] and [Infix_tag] must be just under
@@ -262,12 +262,12 @@ struct custom_operations;       /* defined in [custom.h] */
 
 /* Int32.t, Int64.t and Nativeint.t are represented as custom blocks. */
 
-#define Int32_val(v) (*((int32 *) Data_custom_val(v)))
+#define Int32_val(v) (*((int32_t *) Data_custom_val(v)))
 #define Nativeint_val(v) (*((intnat *) Data_custom_val(v)))
 #ifndef ARCH_ALIGN_INT64
-#define Int64_val(v) (*((int64 *) Data_custom_val(v)))
+#define Int64_val(v) (*((int64_t *) Data_custom_val(v)))
 #else
-CAMLextern int64 caml_Int64_val(value v);
+CAMLextern int64_t caml_Int64_val(value v);
 #define Int64_val(v) caml_Int64_val(v)
 #endif
 
diff --git a/byterun/startup.c b/byterun/startup.c
index 3697220..ab926ef 100644
--- a/byterun/startup.c
+++ b/byterun/startup.c
@@ -79,7 +79,7 @@ static void init_atoms(void)
 
 /* Read the trailer of a bytecode file */
 
-static void fixup_endianness_trailer(uint32 * p)
+static void fixup_endianness_trailer(uint32_t * p)
 {
 #ifndef ARCH_BIG_ENDIAN
   Reverse_32(p, p);
@@ -153,7 +153,7 @@ void caml_read_section_descriptors(int fd, struct exec_trailer *trail)
    Return the length of the section data in bytes, or -1 if no section
    found with that name. */
 
-int32 caml_seek_optional_section(int fd, struct exec_trailer *trail, char *name)
+int32_t caml_seek_optional_section(int fd, struct exec_trailer *trail, char *name)
 {
   long ofs;
   int i;
@@ -172,9 +172,9 @@ int32 caml_seek_optional_section(int fd, struct exec_trailer *trail, char *name)
 /* Position fd at the beginning of the section having the given name.
    Return the length of the section data in bytes. */
 
-int32 caml_seek_section(int fd, struct exec_trailer *trail, char *name)
+int32_t caml_seek_section(int fd, struct exec_trailer *trail, char *name)
 {
-  int32 len = caml_seek_optional_section(fd, trail, name);
+  int32_t len = caml_seek_optional_section(fd, trail, name);
   if (len == -1)
     caml_fatal_error_arg("Fatal_error: section `%s' is missing\n", name);
   return len;
@@ -185,7 +185,7 @@ int32 caml_seek_section(int fd, struct exec_trailer *trail, char *name)
 
 static char * read_section(int fd, struct exec_trailer *trail, char *name)
 {
-  int32 len;
+  int32_t len;
   char * data;
 
   len = caml_seek_optional_section(fd, trail, name);
diff --git a/byterun/startup.h b/byterun/startup.h
index 3dda64b..3268d88 100644
--- a/byterun/startup.h
+++ b/byterun/startup.h
@@ -30,9 +30,9 @@ enum { FILE_NOT_FOUND = -1, BAD_BYTECODE  = -2 };
 extern int caml_attempt_open(char **name, struct exec_trailer *trail,
                              int do_open_script);
 extern void caml_read_section_descriptors(int fd, struct exec_trailer *trail);
-extern int32 caml_seek_optional_section(int fd, struct exec_trailer *trail,
+extern int32_t caml_seek_optional_section(int fd, struct exec_trailer *trail,
                                         char *name);
-extern int32 caml_seek_section(int fd, struct exec_trailer *trail, char *name);
+extern int32_t caml_seek_section(int fd, struct exec_trailer *trail, char *name);
 
 
 #endif /* CAML_STARTUP_H */
diff --git a/byterun/str.c b/byterun/str.c
index 6effa91..9c7baa1 100644
--- a/byterun/str.c
+++ b/byterun/str.c
@@ -101,7 +101,7 @@ CAMLprim value caml_string_get32(value str, value index)
 
 CAMLprim value caml_string_get64(value str, value index)
 {
-  uint64 res;
+  uint64_t res;
   unsigned char b1, b2, b3, b4, b5, b6, b7, b8;
   intnat idx = Long_val(index);
   if (idx < 0 || idx + 7 >= caml_string_length(str)) caml_array_bound_error();
@@ -114,15 +114,15 @@ CAMLprim value caml_string_get64(value str, value index)
   b7 = Byte_u(str, idx + 6);
   b8 = Byte_u(str, idx + 7);
 #ifdef ARCH_BIG_ENDIAN
-  res = (uint64) b1 << 56 | (uint64) b2 << 48
-        | (uint64) b3 << 40 | (uint64) b4 << 32
-        | (uint64) b5 << 24 | (uint64) b6 << 16
-        | (uint64) b7 << 8 | (uint64) b8;
+  res = (uint64_t) b1 << 56 | (uint64_t) b2 << 48
+        | (uint64_t) b3 << 40 | (uint64_t) b4 << 32
+        | (uint64_t) b5 << 24 | (uint64_t) b6 << 16
+        | (uint64_t) b7 << 8 | (uint64_t) b8;
 #else
-  res = (uint64) b8 << 56 | (uint64) b7 << 48
-        | (uint64) b6 << 40 | (uint64) b5 << 32
-        | (uint64) b4 << 24 | (uint64) b3 << 16
-        | (uint64) b2 << 8 | (uint64) b1;
+  res = (uint64_t) b8 << 56 | (uint64_t) b7 << 48
+        | (uint64_t) b6 << 40 | (uint64_t) b5 << 32
+        | (uint64_t) b4 << 24 | (uint64_t) b3 << 16
+        | (uint64_t) b2 << 8 | (uint64_t) b1;
 #endif
   return caml_copy_int64(res);
 }
@@ -174,7 +174,7 @@ CAMLprim value caml_string_set32(value str, value index, value newval)
 CAMLprim value caml_string_set64(value str, value index, value newval)
 {
   unsigned char b1, b2, b3, b4, b5, b6, b7, b8;
-  int64 val;
+  int64_t val;
   intnat idx = Long_val(index);
   if (idx < 0 || idx + 7 >= caml_string_length(str)) caml_array_bound_error();
   val = Int64_val(newval);
diff --git a/config/auto-aux/int64align.c b/config/auto-aux/int64align.c
index 5795e48..c143986 100644
--- a/config/auto-aux/int64align.c
+++ b/config/auto-aux/int64align.c
@@ -17,18 +17,18 @@
 #include "m.h"
 
 #if defined(ARCH_INT64_TYPE)
-typedef ARCH_INT64_TYPE int64;
+typedef ARCH_INT64_TYPE int64_t;
 #elif SIZEOF_LONG == 8
-typedef long int64;
+typedef long int64_t;
 #elif SIZEOF_LONGLONG == 8
-typedef long long int64;
+typedef long long int64_t;
 #else
 #error "No 64-bit integer type available"
 #endif
 
-int64 foo;
+int64_t foo;
 
-void access_int64(int64 *p)
+void access_int64(int64_t *p)
 {
   foo = *p;
 }
@@ -49,8 +49,8 @@ int main(void)
   signal(SIGBUS, sig_handler);
 #endif
   if(setjmp(failure) == 0) {
-    access_int64((int64 *) n);
-    access_int64((int64 *) (n+1));
+    access_int64((int64_t *) n);
+    access_int64((int64_t *) (n+1));
     res = 0;
   } else {
     res = 1;
diff --git a/config/s-nt.h b/config/s-nt.h
index 6df440b..603b050 100644
--- a/config/s-nt.h
+++ b/config/s-nt.h
@@ -15,6 +15,9 @@
 
 #define OCAML_OS_TYPE "Win32"
 
+#ifdef __MINGW32__
+#define HAS_STDINT_H
+#endif
 #undef BSD_SIGNALS
 #define HAS_STRERROR
 #define HAS_SOCKETS
diff --git a/configure b/configure
index 0bf4ebd..8a9be78 100755
--- a/configure
+++ b/configure
@@ -615,26 +615,6 @@ case "$target" in
     esac
 esac
 
-# Check semantics of division and modulus
-
-sh ./runtest divmod.c
-case $? in
-  0) inf "Native division and modulus have round-towards-zero semantics," \
-         "will use them."
-     echo "#undef NONSTANDARD_DIV_MOD" >> m.h;;
-  1) inf "Native division and modulus do not have round-towards-zero"
-         "semantics, will use software emulation."
-     echo "#define NONSTANDARD_DIV_MOD" >> m.h;;
-  *) case $target in
-       *-*-mingw*) inf "Native division and modulus have round-towards-zero" \
-                       "semantics, will use them."
-                   echo "#undef NONSTANDARD_DIV_MOD" >> m.h;;
-       *) wrn "Something went wrong while checking native division and modulus"\
-              "please report it at http://http://caml.inria.fr/mantis/"
-          echo "#define NONSTANDARD_DIV_MOD" >> m.h;;
-     esac;;
-esac
-
 # Shared library support
 
 shared_libraries_supported=false
@@ -1085,6 +1065,11 @@ if sh ./hasgot -i sys/types.h -i sys/socket.h -i netinet/in.h \
   echo "#define HAS_IPV6" >> s.h
 fi
 
+if sh ./hasgot -i stdint.h; then
+  inf "stdint.h found."
+  echo "#define HAS_STDINT_H" >> s.h
+fi
+
 if sh ./hasgot -i unistd.h; then
   inf "unistd.h found."
   echo "#define HAS_UNISTD" >> s.h
diff --git a/otherlibs/bigarray/bigarray_stubs.c b/otherlibs/bigarray/bigarray_stubs.c
index 7e63cbf..f2ccb92 100644
--- a/otherlibs/bigarray/bigarray_stubs.c
+++ b/otherlibs/bigarray/bigarray_stubs.c
@@ -279,9 +279,9 @@ value caml_ba_get_N(value vb, value * vind, int nind)
   case CAML_BA_UINT16:
     return Val_int(((uint16 *) b->data)[offset]);
   case CAML_BA_INT32:
-    return caml_copy_int32(((int32 *) b->data)[offset]);
+    return caml_copy_int32(((int32_t *) b->data)[offset]);
   case CAML_BA_INT64:
-    return caml_copy_int64(((int64 *) b->data)[offset]);
+    return caml_copy_int64(((int64_t *) b->data)[offset]);
   case CAML_BA_NATIVE_INT:
     return caml_copy_nativeint(((intnat *) b->data)[offset]);
   case CAML_BA_CAML_INT:
@@ -388,7 +388,7 @@ CAMLprim value caml_ba_uint8_get32(value vb, value vind)
 
 CAMLprim value caml_ba_uint8_get64(value vb, value vind)
 {
-  uint64 res;
+  uint64_t res;
   unsigned char b1, b2, b3, b4, b5, b6, b7, b8;
   intnat idx = Long_val(vind);
   struct caml_ba_array * b = Caml_ba_array_val(vb);
@@ -402,15 +402,15 @@ CAMLprim value caml_ba_uint8_get64(value vb, value vind)
   b7 = ((unsigned char*) b->data)[idx+6];
   b8 = ((unsigned char*) b->data)[idx+7];
 #ifdef ARCH_BIG_ENDIAN
-  res = (uint64) b1 << 56 | (uint64) b2 << 48
-        | (uint64) b3 << 40 | (uint64) b4 << 32
-        | (uint64) b5 << 24 | (uint64) b6 << 16
-        | (uint64) b7 << 8 | (uint64) b8;
+  res = (uint64_t) b1 << 56 | (uint64_t) b2 << 48
+        | (uint64_t) b3 << 40 | (uint64_t) b4 << 32
+        | (uint64_t) b5 << 24 | (uint64_t) b6 << 16
+        | (uint64_t) b7 << 8 | (uint64_t) b8;
 #else
-  res = (uint64) b8 << 56 | (uint64) b7 << 48
-        | (uint64) b6 << 40 | (uint64) b5 << 32
-        | (uint64) b4 << 24 | (uint64) b3 << 16
-        | (uint64) b2 << 8 | (uint64) b1;
+  res = (uint64_t) b8 << 56 | (uint64_t) b7 << 48
+        | (uint64_t) b6 << 40 | (uint64_t) b5 << 32
+        | (uint64_t) b4 << 24 | (uint64_t) b3 << 16
+        | (uint64_t) b2 << 8 | (uint64_t) b1;
 #endif
   return caml_copy_int64(res);
 }
@@ -447,9 +447,9 @@ static value caml_ba_set_aux(value vb, value * vind, intnat nind, value newval)
   case CAML_BA_UINT16:
     ((int16 *) b->data)[offset] = Int_val(newval); break;
   case CAML_BA_INT32:
-    ((int32 *) b->data)[offset] = Int32_val(newval); break;
+    ((int32_t *) b->data)[offset] = Int32_val(newval); break;
   case CAML_BA_INT64:
-    ((int64 *) b->data)[offset] = Int64_val(newval); break;
+    ((int64_t *) b->data)[offset] = Int64_val(newval); break;
   case CAML_BA_NATIVE_INT:
     ((intnat *) b->data)[offset] = Nativeint_val(newval); break;
   case CAML_BA_CAML_INT:
@@ -577,7 +577,7 @@ CAMLprim value caml_ba_uint8_set64(value vb, value vind, value newval)
 {
   unsigned char b1, b2, b3, b4, b5, b6, b7, b8;
   intnat idx = Long_val(vind);
-  int64 val;
+  int64_t val;
   struct caml_ba_array * b = Caml_ba_array_val(vb);
   if (idx < 0 || idx >= b->dim[0] - 7) caml_array_bound_error();
   val = Int64_val(newval);
@@ -760,9 +760,9 @@ static int caml_ba_compare(value v1, value v2)
   case CAML_BA_UINT16:
     DO_INTEGER_COMPARISON(uint16);
   case CAML_BA_INT32:
-    DO_INTEGER_COMPARISON(int32);
+    DO_INTEGER_COMPARISON(int32_t);
   case CAML_BA_INT64:
-    DO_INTEGER_COMPARISON(int64);
+    DO_INTEGER_COMPARISON(int64_t);
   case CAML_BA_CAML_INT:
   case CAML_BA_NATIVE_INT:
     DO_INTEGER_COMPARISON(intnat);
@@ -780,7 +780,7 @@ static intnat caml_ba_hash(value v)
 {
   struct caml_ba_array * b = Caml_ba_array_val(v);
   intnat num_elts, n;
-  uint32 h, w;
+  uint32_t h, w;
   int i;
 
   num_elts = 1;
@@ -820,7 +820,7 @@ static intnat caml_ba_hash(value v)
   }
   case CAML_BA_INT32:
   {
-    uint32 * p = b->data;
+    uint32_t * p = b->data;
     if (num_elts > 64) num_elts = 64;
     for (n = 0; n < num_elts; n++, p++) h = caml_hash_mix_uint32(h, *p);
     break;
@@ -835,7 +835,7 @@ static intnat caml_ba_hash(value v)
   }
   case CAML_BA_INT64:
   {
-    int64 * p = b->data;
+    int64_t * p = b->data;
     if (num_elts > 32) num_elts = 32;
     for (n = 0; n < num_elts; n++, p++) h = caml_hash_mix_int64(h, *p);
     break;
@@ -878,7 +878,7 @@ static void caml_ba_serialize_longarray(void * data,
   } else {
     caml_serialize_int_1(0);
     for (n = 0, p = data; n < num_elts; n++, p++)
-      caml_serialize_int_4((int32) *p);
+      caml_serialize_int_4((int32_t) *p);
   }
 #else
   caml_serialize_int_1(0);
@@ -1181,14 +1181,14 @@ CAMLprim value caml_ba_fill(value vb, value vinit)
     break;
   }
   case CAML_BA_INT32: {
-    int32 init = Int32_val(vinit);
-    int32 * p;
+    int32_t init = Int32_val(vinit);
+    int32_t * p;
     for (p = b->data; num_elts > 0; p++, num_elts--) *p = init;
     break;
   }
   case CAML_BA_INT64: {
-    int64 init = Int64_val(vinit);
-    int64 * p;
+    int64_t init = Int64_val(vinit);
+    int64_t * p;
     for (p = b->data; num_elts > 0; p++, num_elts--) *p = init;
     break;
   }
diff --git a/otherlibs/num/nat_stubs.c b/otherlibs/num/nat_stubs.c
index 9a62759..d718a05 100644
--- a/otherlibs/num/nat_stubs.c
+++ b/otherlibs/num/nat_stubs.c
@@ -347,9 +347,9 @@ static void serialize_nat(value nat,
   if (len >= ((mlsize_t)1 << 32))
     failwith("output_value: nat too big");
 #endif
-  serialize_int_4((int32) len);
+  serialize_int_4((int32_t) len);
 #if defined(ARCH_SIXTYFOUR) && defined(ARCH_BIG_ENDIAN)
-  { int32 * p;
+  { int32_t * p;
     mlsize_t i;
     for (i = len, p = Data_custom_val(nat); i > 0; i -= 2, p += 2) {
       serialize_int_4(p[1]);    /* low 32 bits of 64-bit digit */
@@ -369,7 +369,7 @@ static uintnat deserialize_nat(void * dst)
 
   len = deserialize_uint_4();
 #if defined(ARCH_SIXTYFOUR) && defined(ARCH_BIG_ENDIAN)
-  { uint32 * p;
+  { uint32_t * p;
     mlsize_t i;
     for (i = len, p = dst; i > 1; i -= 2, p += 2) {
       p[1] = deserialize_uint_4();   /* low 32 bits of 64-bit digit */
@@ -385,7 +385,7 @@ static uintnat deserialize_nat(void * dst)
   deserialize_block_4(dst, len);
 #if defined(ARCH_SIXTYFOUR)
   if (len & 1){
-    ((uint32 *) dst)[len] = 0;
+    ((uint32_t *) dst)[len] = 0;
     ++ len;
   }
 #endif
@@ -396,7 +396,7 @@ static uintnat deserialize_nat(void * dst)
 static intnat hash_nat(value v)
 {
   bngsize len, i;
-  uint32 h;
+  uint32_t h;
 
   len = bng_num_digits(&Digit_val(v,0), Wosize_val(v) - 1);
   h = 0;
@@ -406,10 +406,10 @@ static intnat hash_nat(value v)
     /* Mix the two 32-bit halves as if we were on a 32-bit platform,
        namely low 32 bits first, then high 32 bits.
        Also, ignore final 32 bits if they are zero. */
-    h = caml_hash_mix_uint32(h, (uint32) d);
+    h = caml_hash_mix_uint32(h, (uint32_t) d);
     d = d >> 32;
     if (d == 0 && i + 1 == len) break;
-    h = caml_hash_mix_uint32(h, (uint32) d);
+    h = caml_hash_mix_uint32(h, (uint32_t) d);
 #else
     h = caml_hash_mix_uint32(h, d);
 #endif
diff --git a/otherlibs/unix/addrofstr.c b/otherlibs/unix/addrofstr.c
index e17841f..a2830ba 100644
--- a/otherlibs/unix/addrofstr.c
+++ b/otherlibs/unix/addrofstr.c
@@ -73,7 +73,7 @@ CAMLprim value unix_inet_addr_of_string(value s)
 #else
   struct in_addr address;
   address.s_addr = inet_addr(String_val(s));
-  if (address.s_addr == (uint32) -1) failwith("inet_addr_of_string");
+  if (address.s_addr == (uint32_t) -1) failwith("inet_addr_of_string");
   return alloc_inet_addr(&address);
 #endif
 }
diff --git a/stdlib/header.c b/stdlib/header.c
index cb3d995..93cdfeb 100644
--- a/stdlib/header.c
+++ b/stdlib/header.c
@@ -133,7 +133,7 @@ static char * read_runtime_path(int fd)
   char buffer[TRAILER_SIZE];
   static char runtime_path[MAXPATHLEN];
   int num_sections, i;
-  uint32 path_size;
+  uint32_t path_size;
   long ofs;
 
   lseek(fd, (long) -TRAILER_SIZE, SEEK_END);
-- 
2.0.4