diff --git a/addrcheck/ac_main.c b/addrcheck/ac_main.c
index c5e2b51..14b188a 100644
--- a/addrcheck/ac_main.c
+++ b/addrcheck/ac_main.c
@@ -250,8 +250,7 @@
 /*------------------------------------------------------------*/
 
 static /* __inline__ */
-void set_address_range_perms ( Addr a, UInt len, 
-                               UInt example_a_bit )
+void set_address_range_perms ( Addr a, SizeT len, UInt example_a_bit )
 {
    UChar     abyte8;
    UInt      sm_off;
@@ -357,14 +356,14 @@
 
 /* Set permissions for address ranges ... */
 
-static void ac_make_noaccess ( Addr a, UInt len )
+static void ac_make_noaccess ( Addr a, SizeT len )
 {
    PROF_EVENT(35);
    DEBUG("ac_make_noaccess(%p, %x)\n", a, len);
    set_address_range_perms ( a, len, VGM_BIT_INVALID );
 }
 
-static void ac_make_accessible ( Addr a, UInt len )
+static void ac_make_accessible ( Addr a, SizeT len )
 {
    PROF_EVENT(38);
    DEBUG("ac_make_accessible(%p, %x)\n", a, len);
@@ -449,7 +448,7 @@
 
 /* Block-copy permissions (needed for implementing realloc()). */
 
-static void ac_copy_address_range_state ( Addr src, Addr dst, UInt len )
+static void ac_copy_address_range_state ( Addr src, Addr dst, SizeT len )
 {
    UInt i;
 
@@ -469,7 +468,7 @@
    know what it is. */
 
 static __inline__
-Bool ac_check_accessible ( Addr a, UInt len, Addr* bad_addr )
+Bool ac_check_accessible ( Addr a, SizeT len, Addr* bad_addr )
 {
    UInt  i;
    UChar abit;
@@ -488,7 +487,7 @@
 
 /* The opposite; check that an address range is inaccessible. */
 static
-Bool ac_check_noaccess ( Addr a, UInt len, Addr* bad_addr )
+Bool ac_check_noaccess ( Addr a, SizeT len, Addr* bad_addr )
 {
    UInt  i;
    UChar abit;
@@ -535,7 +534,7 @@
 
 static __inline__
 void ac_check_is_accessible ( CorePart part, ThreadId tid,
-                              Char* s, Addr base, UInt size, Bool isWrite )
+                              Char* s, Addr base, SizeT size, Bool isWrite )
 {
    Bool ok;
    Addr bad_addr;
@@ -573,14 +572,14 @@
 
 static
 void ac_check_is_writable ( CorePart part, ThreadId tid,
-                            Char* s, Addr base, UInt size )
+                            Char* s, Addr base, SizeT size )
 {
    ac_check_is_accessible ( part, tid, s, base, size, /*isWrite*/True );
 }
 
 static
 void ac_check_is_readable ( CorePart part, ThreadId tid,
-                            Char* s, Addr base, UInt size )
+                            Char* s, Addr base, SizeT size )
 {     
    ac_check_is_accessible ( part, tid, s, base, size, /*isWrite*/False );
 }
@@ -605,7 +604,7 @@
 }
 
 static
-void ac_new_mem_startup( Addr a, UInt len, Bool rr, Bool ww, Bool xx )
+void ac_new_mem_startup( Addr a, SizeT len, Bool rr, Bool ww, Bool xx )
 {
    /* Ignore the permissions, just make it readable.  Seems to work... */
    DEBUG("new_mem_startup(%p, %u, rr=%u, ww=%u, xx=%u)\n", a,len,rr,ww,xx);
@@ -613,13 +612,13 @@
 }
 
 static
-void ac_new_mem_heap ( Addr a, UInt len, Bool is_inited )
+void ac_new_mem_heap ( Addr a, SizeT len, Bool is_inited )
 {
    ac_make_accessible(a, len);
 }
 
 static
-void ac_set_perms (Addr a, UInt len, Bool rr, Bool ww, Bool xx)
+void ac_set_perms (Addr a, SizeT len, Bool rr, Bool ww, Bool xx)
 {
    DEBUG("ac_set_perms(%p, %u, rr=%u ww=%u, xx=%u)\n",
                               a, len, rr, ww, xx);
diff --git a/coregrind/toolfuncs.def b/coregrind/toolfuncs.def
index 1a98ea7..73ff43e 100644
--- a/coregrind/toolfuncs.def
+++ b/coregrind/toolfuncs.def
@@ -179,16 +179,16 @@
 ## malloc() et al.  See above how to do this.)
 
 ## These ones occur at startup, upon some signals, and upon some syscalls
-void,	new_mem_startup,	Addr a, UInt len, Bool rr, Bool ww, Bool xx
-void,	new_mem_stack_signal,	Addr a, UInt len
-void,	new_mem_brk,	Addr a, UInt len
-void,	new_mem_mmap,	Addr a, UInt len, Bool rr, Bool ww, Bool xx
+void,	new_mem_startup,	Addr a, SizeT len, Bool rr, Bool ww, Bool xx
+void,	new_mem_stack_signal,	Addr a, SizeT len
+void,	new_mem_brk,	Addr a, SizeT len
+void,	new_mem_mmap,	Addr a, SizeT len, Bool rr, Bool ww, Bool xx
 
-void,	copy_mem_remap,	Addr from, Addr to, UInt len
-void,	change_mem_mprotect,	Addr a, UInt len, Bool rr, Bool ww, Bool xx
-void,	die_mem_stack_signal,	Addr a, UInt len
-void,	die_mem_brk,	Addr a, UInt len
-void,	die_mem_munmap,	Addr a, UInt len
+void,	copy_mem_remap,	Addr from, Addr to, SizeT len
+void,	change_mem_mprotect,	Addr a, SizeT len, Bool rr, Bool ww, Bool xx
+void,	die_mem_stack_signal,	Addr a, SizeT len
+void,	die_mem_brk,	Addr a, SizeT len
+void,	die_mem_munmap,	Addr a, SizeT len
 
 ## These ones are called when %esp changes.  A tool could track these itself
 ## (except for ban_mem_stack) but it's much easier to use the core's help.
@@ -204,26 +204,26 @@
 void,	new_mem_stack_12,	Addr new_ESP
 void,	new_mem_stack_16,	Addr new_ESP
 void,	new_mem_stack_32,	Addr new_ESP
-void,	new_mem_stack,	Addr a, UInt len
+void,	new_mem_stack,	Addr a, SizeT len
 
 void,	die_mem_stack_4,	Addr die_ESP
 void,	die_mem_stack_8,	Addr die_ESP
 void,	die_mem_stack_12,	Addr die_ESP
 void,	die_mem_stack_16,	Addr die_ESP
 void,	die_mem_stack_32,	Addr die_ESP
-void,	die_mem_stack,	Addr a, UInt len
+void,	die_mem_stack,	Addr a, SizeT len
 
 ## Used for redzone at end of thread stacks
-void,	ban_mem_stack,	Addr a, UInt len
+void,	ban_mem_stack,	Addr a, SizeT len
 
 ## These ones occur around syscalls, signal handling, etc
-void,	pre_mem_read,	CorePart part, ThreadId tid, Char* s, Addr a, UInt size
+void,	pre_mem_read,	CorePart part, ThreadId tid, Char* s, Addr a, SizeT size
 void,	pre_mem_read_asciiz,	CorePart part, ThreadId tid, Char* s, Addr a
-void,	pre_mem_write,	CorePart part, ThreadId tid, Char* s, Addr a, UInt size
+void,	pre_mem_write,	CorePart part, ThreadId tid, Char* s, Addr a, SizeT size
 ## Not implemented yet -- have to add in lots of places, which is a
 ## pain.  Won't bother unless/until there's a need.
-## void (*post_mem_read)  ( ThreadState* tst, Char* s, Addr a, UInt size );
-void,	post_mem_write,	Addr a, UInt size
+## void (*post_mem_read)  ( ThreadState* tst, Char* s, Addr a, SizeT size );
+void,	post_mem_write,	Addr a, SizeT size
 
 
 ## Register events -- if `shadow_regs' need is set, all should probably be
diff --git a/helgrind/hg_main.c b/helgrind/hg_main.c
index 9560d24..c6a57dd 100644
--- a/helgrind/hg_main.c
+++ b/helgrind/hg_main.c
@@ -1585,7 +1585,7 @@
 }
 
 static
-void set_address_range_state ( Addr a, UInt len /* in bytes */, 
+void set_address_range_state ( Addr a, SizeT len /* in bytes */, 
                                VgeInitStatus status )
 {
    Addr end;
@@ -1660,19 +1660,19 @@
 }
 
 
-static void make_segment_readable ( Addr a, UInt len )
+static void make_segment_readable ( Addr a, SizeT len )
 {
    //PROF_EVENT(??);    PPP
    set_address_range_state ( a, len, Vge_SegmentInit );
 }
 
-static void make_writable ( Addr a, UInt len )
+static void make_writable ( Addr a, SizeT len )
 {
    //PROF_EVENT(36);  PPP
    set_address_range_state( a, len, Vge_VirginInit );
 }
 
-static void make_readable ( Addr a, UInt len )
+static void make_readable ( Addr a, SizeT len )
 {
    //PROF_EVENT(37);  PPP
    set_address_range_state( a, len, Vge_VirginInit );
@@ -1680,7 +1680,7 @@
 
 
 /* Block-copy states (needed for implementing realloc()). */
-static void copy_address_range_state(Addr src, Addr dst, UInt len)
+static void copy_address_range_state(Addr src, Addr dst, SizeT len)
 {
    UInt i;
 
@@ -1693,25 +1693,25 @@
 }
 
 // SSS: put these somewhere better
-static void eraser_mem_read (Addr a, UInt data_size, ThreadId tid);
-static void eraser_mem_write(Addr a, UInt data_size, ThreadId tid);
+static void eraser_mem_read (Addr a, SizeT data_size, ThreadId tid);
+static void eraser_mem_write(Addr a, SizeT data_size, ThreadId tid);
 
 static void eraser_mem_help_read_1(Addr a) REGPARM(1);
 static void eraser_mem_help_read_2(Addr a) REGPARM(1);
 static void eraser_mem_help_read_4(Addr a) REGPARM(1);
-static void eraser_mem_help_read_N(Addr a, UInt size) REGPARM(2);
+static void eraser_mem_help_read_N(Addr a, SizeT size) REGPARM(2);
 
 static void eraser_mem_help_write_1(Addr a, UInt val) REGPARM(2);
 static void eraser_mem_help_write_2(Addr a, UInt val) REGPARM(2);
 static void eraser_mem_help_write_4(Addr a, UInt val) REGPARM(2);
-static void eraser_mem_help_write_N(Addr a, UInt size) REGPARM(2);
+static void eraser_mem_help_write_N(Addr a, SizeT size) REGPARM(2);
 
 static void bus_lock(void);
 static void bus_unlock(void);
 
 static
 void eraser_pre_mem_read(CorePart part, ThreadId tid,
-                         Char* s, Addr base, UInt size )
+                         Char* s, Addr base, SizeT size )
 {
    if (tid > 50) { VG_(printf)("pid = %d, s = `%s`, part = %d\n", tid, s, part); VG_(skin_panic)("a");}
    eraser_mem_read(base, size, tid);
@@ -1726,7 +1726,7 @@
 
 static
 void eraser_pre_mem_write(CorePart part, ThreadId tid,
-                          Char* s, Addr base, UInt size )
+                          Char* s, Addr base, SizeT size )
 {
    eraser_mem_write(base, size, tid);
 }
@@ -1734,7 +1734,7 @@
 
 
 static
-void eraser_new_mem_startup( Addr a, UInt len, Bool rr, Bool ww, Bool xx )
+void eraser_new_mem_startup( Addr a, SizeT len, Bool rr, Bool ww, Bool xx )
 {
    /* Ignore the permissions, just make it readable.  Seems to work... */
    make_segment_readable(a, len);
@@ -1742,7 +1742,7 @@
 
 
 static
-void eraser_new_mem_heap ( Addr a, UInt len, Bool is_inited )
+void eraser_new_mem_heap ( Addr a, SizeT len, Bool is_inited )
 {
    if (is_inited) {
       make_readable(a, len);
@@ -1752,7 +1752,7 @@
 }
 
 static
-void eraser_set_perms (Addr a, UInt len,
+void eraser_set_perms (Addr a, SizeT len,
                        Bool rr, Bool ww, Bool xx)
 {
    if      (rr) make_readable(a, len);
@@ -1761,13 +1761,13 @@
 }
 
 static
-void eraser_new_mem_stack_private(Addr a, UInt len)
+void eraser_new_mem_stack_private(Addr a, SizeT len)
 {
    set_address_range_state(a, len, Vge_NonVirginInit);
 }
 
 static
-void eraser_new_mem_stack(Addr a, UInt len)
+void eraser_new_mem_stack(Addr a, SizeT len)
 {
    set_address_range_state(a, len, Vge_VirginInit);
 }
@@ -3034,7 +3034,7 @@
    }
 }
 
-static void eraser_mem_read(Addr a, UInt size, ThreadId tid)
+static void eraser_mem_read(Addr a, SizeT size, ThreadId tid)
 {
    Addr end;
 
@@ -3139,7 +3139,7 @@
    }
 }
 
-static void eraser_mem_write(Addr a, UInt size, ThreadId tid)
+static void eraser_mem_write(Addr a, SizeT size, ThreadId tid)
 {
    Addr     end;
 
@@ -3167,7 +3167,7 @@
    eraser_mem_read(a, 4, VG_(get_current_tid)());
 }
 
-REGPARM(2) static void eraser_mem_help_read_N(Addr a, UInt size)
+REGPARM(2) static void eraser_mem_help_read_N(Addr a, SizeT size)
 {
    eraser_mem_read(a, size, VG_(get_current_tid)());
 }
@@ -3187,7 +3187,7 @@
    if (*(UInt *)a != val)
       eraser_mem_write(a, 4, VG_(get_current_tid)());
 }
-REGPARM(2) static void eraser_mem_help_write_N(Addr a, UInt size)
+REGPARM(2) static void eraser_mem_help_write_N(Addr a, SizeT size)
 {
    eraser_mem_write(a, size, VG_(get_current_tid)());
 }
@@ -3374,7 +3374,7 @@
 
 void SK_(post_clo_init)(void)
 {
-   void (*stack_tracker)(Addr a, UInt len);
+   void (*stack_tracker)(Addr a, SizeT len);
    
    if (clo_execontext) {
       execontext_map = VG_(malloc)(sizeof(ExeContextMap *) * 65536);
diff --git a/memcheck/mac_malloc_wrappers.c b/memcheck/mac_malloc_wrappers.c
index e272f20..23f59b6 100644
--- a/memcheck/mac_malloc_wrappers.c
+++ b/memcheck/mac_malloc_wrappers.c
@@ -45,13 +45,13 @@
 UInt VG_(vg_malloc_redzone_szB) = 16;
 
 /* Function pointers for the two tools to track interesting events. */
-void (*MAC_(new_mem_heap)) ( Addr a, UInt len, Bool is_inited )  = NULL;
-void (*MAC_(ban_mem_heap)) ( Addr a, UInt len )                  = NULL;
-void (*MAC_(die_mem_heap)) ( Addr a, UInt len )                  = NULL;
-void (*MAC_(copy_mem_heap))( Addr from, Addr to, UInt len )      = NULL;
+void (*MAC_(new_mem_heap)) ( Addr a, SizeT len, Bool is_inited )  = NULL;
+void (*MAC_(ban_mem_heap)) ( Addr a, SizeT len )                  = NULL;
+void (*MAC_(die_mem_heap)) ( Addr a, SizeT len )                  = NULL;
+void (*MAC_(copy_mem_heap))( Addr from, Addr to, SizeT len )      = NULL;
 
 /* Function pointers for internal sanity checking. */
-Bool (*MAC_(check_noaccess))( Addr a, UInt len, Addr* bad_addr ) = NULL;
+Bool (*MAC_(check_noaccess))( Addr a, SizeT len, Addr* bad_addr ) = NULL;
 
 
 /*------------------------------------------------------------*/
diff --git a/memcheck/mac_shared.h b/memcheck/mac_shared.h
index b009e51..d9a84ab 100644
--- a/memcheck/mac_shared.h
+++ b/memcheck/mac_shared.h
@@ -277,13 +277,13 @@
 extern VgHashTable MAC_(mempool_list);
 
 /* Function pointers for the two tools to track interesting events. */
-extern void (*MAC_(new_mem_heap)) ( Addr a, UInt len, Bool is_inited );
-extern void (*MAC_(ban_mem_heap)) ( Addr a, UInt len );
-extern void (*MAC_(die_mem_heap)) ( Addr a, UInt len );
-extern void (*MAC_(copy_mem_heap))( Addr from, Addr to, UInt len );
+extern void (*MAC_(new_mem_heap)) ( Addr a, SizeT len, Bool is_inited );
+extern void (*MAC_(ban_mem_heap)) ( Addr a, SizeT len );
+extern void (*MAC_(die_mem_heap)) ( Addr a, SizeT len );
+extern void (*MAC_(copy_mem_heap))( Addr from, Addr to, SizeT len );
 
 /* Function pointers for internal sanity checking. */
-extern Bool (*MAC_(check_noaccess))( Addr a, UInt len, Addr* bad_addr );
+extern Bool (*MAC_(check_noaccess))( Addr a, SizeT len, Addr* bad_addr );
 
 /* Used in describe_addr() */
 extern Bool (*MAC_(describe_addr_supp))    ( Addr a, AddrInfo* ai );
@@ -357,8 +357,8 @@
 extern REGPARM(1) void MAC_(die_mem_stack_16) ( Addr old_ESP );
 extern REGPARM(1) void MAC_(new_mem_stack_32) ( Addr old_ESP );
 extern REGPARM(1) void MAC_(die_mem_stack_32) ( Addr old_ESP );
-extern            void MAC_(die_mem_stack) ( Addr a, UInt len);
-extern            void MAC_(new_mem_stack) ( Addr a, UInt len);
+extern            void MAC_(die_mem_stack) ( Addr a, SizeT len);
+extern            void MAC_(new_mem_stack) ( Addr a, SizeT len);
 
 
 /*------------------------------------------------------------*/
@@ -520,13 +520,13 @@
    }                                                                          \
 }                                                                             \
                                                                               \
-void MAC_(new_mem_stack) ( Addr a, UInt len )                                 \
+void MAC_(new_mem_stack) ( Addr a, SizeT len )                                \
 {                                                                             \
    PROF_EVENT(115);                                                           \
    UNALIGNED_NEW ( a, len );                                                  \
 }                                                                             \
                                                                               \
-void MAC_(die_mem_stack) ( Addr a, UInt len )                                 \
+void MAC_(die_mem_stack) ( Addr a, SizeT len )                                \
 {                                                                             \
    PROF_EVENT(125);                                                           \
    UNALIGNED_DIE ( a, len );                                                  \
diff --git a/memcheck/mc_include.h b/memcheck/mc_include.h
index 948cef8..9d97925 100644
--- a/memcheck/mc_include.h
+++ b/memcheck/mc_include.h
@@ -129,17 +129,17 @@
 extern REGPARM(1) UInt MC_(helperc_LOADV2)  ( Addr );
 extern REGPARM(1) UInt MC_(helperc_LOADV4)  ( Addr );
 
-extern REGPARM(2) void MC_(fpu_write_check) ( Addr addr, Int size );
-extern REGPARM(2) void MC_(fpu_read_check)  ( Addr addr, Int size );
+extern REGPARM(2) void MC_(fpu_write_check) ( Addr addr, SizeT size );
+extern REGPARM(2) void MC_(fpu_read_check)  ( Addr addr, SizeT size );
 
 
 /* For client requests */
-extern void MC_(make_noaccess) ( Addr a, UInt len );
-extern void MC_(make_readable) ( Addr a, UInt len );
-extern void MC_(make_writable) ( Addr a, UInt len );
+extern void MC_(make_noaccess) ( Addr a, SizeT len );
+extern void MC_(make_readable) ( Addr a, SizeT len );
+extern void MC_(make_writable) ( Addr a, SizeT len );
 
-extern Bool MC_(check_writable) ( Addr a, UInt len, Addr* bad_addr );
-extern Bool MC_(check_readable) ( Addr a, UInt len, Addr* bad_addr );
+extern Bool MC_(check_writable) ( Addr a, SizeT len, Addr* bad_addr );
+extern Bool MC_(check_readable) ( Addr a, SizeT len, Addr* bad_addr );
 
 extern void MC_(detect_memory_leaks) ( void );
 
@@ -147,7 +147,7 @@
                ThreadId tid,
                Addr dataV, 
                Addr vbitsV, 
-               UInt size, 
+               SizeT size, 
                Bool setting /* True <=> set vbits,  False <=> get vbits */ 
             );
 
diff --git a/memcheck/mc_main.c b/memcheck/mc_main.c
index a8369cf..34dff45 100644
--- a/memcheck/mc_main.c
+++ b/memcheck/mc_main.c
@@ -99,8 +99,8 @@
 static void mc_wr_V4_SLOWLY ( Addr a, UInt vbytes );
 static void mc_wr_V2_SLOWLY ( Addr a, UInt vbytes );
 static void mc_wr_V1_SLOWLY ( Addr a, UInt vbytes );
-static void mc_fpu_read_check_SLOWLY ( Addr addr, Int size );
-static void mc_fpu_write_check_SLOWLY ( Addr addr, Int size );
+static void mc_fpu_read_check_SLOWLY  ( Addr addr, SizeT size );
+static void mc_fpu_write_check_SLOWLY ( Addr addr, SizeT size );
 
 /*------------------------------------------------------------*/
 /*--- Data defns.                                          ---*/
@@ -266,7 +266,7 @@
 /*--- Setting permissions over address ranges.             ---*/
 /*------------------------------------------------------------*/
 
-static void set_address_range_perms ( Addr a, UInt len, 
+static void set_address_range_perms ( Addr a, SizeT len, 
                                       UInt example_a_bit,
                                       UInt example_v_bit )
 {
@@ -389,24 +389,24 @@
 
 /* Set permissions for address ranges ... */
 
-void MC_(make_noaccess) ( Addr a, UInt len )
+void MC_(make_noaccess) ( Addr a, SizeT len )
 {
    PROF_EVENT(35);
-   DEBUG("MC_(make_noaccess)(%p, %x)\n", a, len);
+   DEBUG("MC_(make_noaccess)(%p, %llu)\n", a, (ULong)len);
    set_address_range_perms ( a, len, VGM_BIT_INVALID, VGM_BIT_INVALID );
 }
 
-void MC_(make_writable) ( Addr a, UInt len )
+void MC_(make_writable) ( Addr a, SizeT len )
 {
    PROF_EVENT(36);
-   DEBUG("MC_(make_writable)(%p, %x)\n", a, len);
+   DEBUG("MC_(make_writable)(%p, %llu)\n", a, (ULong)len);
    set_address_range_perms ( a, len, VGM_BIT_VALID, VGM_BIT_INVALID );
 }
 
-void MC_(make_readable) ( Addr a, UInt len )
+void MC_(make_readable) ( Addr a, SizeT len )
 {
    PROF_EVENT(37);
-   DEBUG("MC_(make_readable)(%p, 0x%x)\n", a, len);
+   DEBUG("MC_(make_readable)(%p, %llu)\n", a, (ULong)len);
    set_address_range_perms ( a, len, VGM_BIT_VALID, VGM_BIT_VALID );
 }
 
@@ -491,9 +491,9 @@
                     );
 
 /* Block-copy permissions (needed for implementing realloc()). */
-static void mc_copy_address_range_state ( Addr src, Addr dst, UInt len )
+static void mc_copy_address_range_state ( Addr src, Addr dst, SizeT len )
 {
-   UInt i;
+   SizeT i;
 
    DEBUG("mc_copy_address_range_state\n");
 
@@ -516,9 +516,9 @@
    returns False, and if bad_addr is non-NULL, sets *bad_addr to
    indicate the lowest failing address.  Functions below are
    similar. */
-Bool MC_(check_noaccess) ( Addr a, UInt len, Addr* bad_addr )
+Bool MC_(check_noaccess) ( Addr a, SizeT len, Addr* bad_addr )
 {
-   UInt  i;
+   SizeT i;
    UChar abit;
    PROF_EVENT(42);
    for (i = 0; i < len; i++) {
@@ -533,9 +533,9 @@
    return True;
 }
 
-Bool MC_(check_writable) ( Addr a, UInt len, Addr* bad_addr )
+Bool MC_(check_writable) ( Addr a, SizeT len, Addr* bad_addr )
 {
-   UInt  i;
+   SizeT i;
    UChar abit;
    PROF_EVENT(42);
    for (i = 0; i < len; i++) {
@@ -550,9 +550,9 @@
    return True;
 }
 
-Bool MC_(check_readable) ( Addr a, UInt len, Addr* bad_addr )
+Bool MC_(check_readable) ( Addr a, SizeT len, Addr* bad_addr )
 {
-   UInt  i;
+   SizeT i;
    UChar abit;
    UChar vbyte;
 
@@ -603,7 +603,7 @@
 
 static
 void mc_check_is_writable ( CorePart part, ThreadId tid, Char* s,
-                            Addr base, UInt size )
+                            Addr base, SizeT size )
 {
    Bool ok;
    Addr bad_addr;
@@ -634,7 +634,7 @@
 
 static
 void mc_check_is_readable ( CorePart part, ThreadId tid, Char* s,
-                            Addr base, UInt size )
+                            Addr base, SizeT size )
 {     
    Bool ok;
    Addr bad_addr;
@@ -688,15 +688,16 @@
 
 
 static
-void mc_new_mem_startup( Addr a, UInt len, Bool rr, Bool ww, Bool xx )
+void mc_new_mem_startup( Addr a, SizeT len, Bool rr, Bool ww, Bool xx )
 {
    /* Ignore the permissions, just make it readable.  Seems to work... */
-   DEBUG("mc_new_mem_startup(%p, %u, rr=%u, ww=%u, xx=%u)\n", a,len,rr,ww,xx);
+   DEBUG("mc_new_mem_startup(%p, %llu, rr=%u, ww=%u, xx=%u)\n",
+         a,(ULong)len,rr,ww,xx);
    MC_(make_readable)(a, len);
 }
 
 static
-void mc_new_mem_heap ( Addr a, UInt len, Bool is_inited )
+void mc_new_mem_heap ( Addr a, SizeT len, Bool is_inited )
 {
    if (is_inited) {
       MC_(make_readable)(a, len);
@@ -706,9 +707,10 @@
 }
 
 static
-void mc_set_perms (Addr a, UInt len, Bool rr, Bool ww, Bool xx)
+void mc_set_perms (Addr a, SizeT len, Bool rr, Bool ww, Bool xx)
 {
-   DEBUG("mc_set_perms(%p, %u, rr=%u ww=%u, xx=%u)\n", a, len, rr, ww, xx);
+   DEBUG("mc_set_perms(%p, %llu, rr=%u ww=%u, xx=%u)\n",
+         a, (ULong)len, rr, ww, xx);
    if      (rr) MC_(make_readable)(a, len);
    else if (ww) MC_(make_writable)(a, len);
    else         MC_(make_noaccess)(a, len);
@@ -1108,7 +1110,7 @@
    ------------------------------------------------------------------ */
 
 REGPARM(2)
-void MC_(fpu_read_check) ( Addr addr, Int size )
+void MC_(fpu_read_check) ( Addr addr, SizeT size )
 {
    /* Ensure the read area is both addressible and valid (ie,
       readable).  If there's an address error, don't report a value
@@ -1200,7 +1202,7 @@
 
 
 REGPARM(2)
-void MC_(fpu_write_check) ( Addr addr, Int size )
+void MC_(fpu_write_check) ( Addr addr, SizeT size )
 {
    /* Ensure the written area is addressible, and moan if otherwise.
       If it is addressible, make it valid, otherwise invalid. 
@@ -1290,7 +1292,7 @@
    there's an addr error, don't report a value error even if it
    exists. */
 
-void mc_fpu_read_check_SLOWLY ( Addr addr, Int size )
+void mc_fpu_read_check_SLOWLY ( Addr addr, SizeT size )
 {
    Int  i;
    Bool aerr = False;
@@ -1316,7 +1318,7 @@
 /* Generic version.  Test for addr errors.  Valid addresses are
    given valid values, and invalid addresses invalid values. */
 
-void mc_fpu_write_check_SLOWLY ( Addr addr, Int size )
+void mc_fpu_write_check_SLOWLY ( Addr addr, SizeT size )
 {
    Int  i;
    Addr a_here;
@@ -1350,7 +1352,7 @@
    ThreadId tid,
    Addr dataV, 
    Addr vbitsV, 
-   UInt size, 
+   SizeT size, 
    Bool setting /* True <=> set vbits,  False <=> get vbits */ 
 )
 {
@@ -1358,8 +1360,8 @@
    Bool addressibleV = True;
    UInt* data  = (UInt*)dataV;
    UInt* vbits = (UInt*)vbitsV;
-   UInt  szW   = size / 4; /* sigh */
-   UInt  i;
+   SizeT szW   = size / 4; /* sigh */
+   SizeT i;
    UInt* dataP  = NULL; /* bogus init to keep gcc happy */
    UInt* vbitsP = NULL; /* ditto */