Make -B a size_t, build and test w/ -m64

6 files changed, 78 insertions, 49 deletions

diff --git a/xdelta3/testing/regtest.cc b/xdelta3/testing/regtest.cc
index d31f6b5..d5864d6 100644
--- a/xdelta3/testing/regtest.cc
+++ b/xdelta3/testing/regtest.cc
@@ -46,7 +46,6 @@ void InMemoryEncodeDecode(const FileSpec &source_file,
   xd3_init_config(&decode_config, XD3_ADLER32);
 
   encode_config.winsize = Constants::WINDOW_SIZE;
-  encode_config.srcwin_maxsz = options.encode_srcwin_maxsz;
 
   // TODO! the smatcher setup isn't working,
 //   if (options.large_cksum_step) {
@@ -64,6 +63,8 @@ void InMemoryEncodeDecode(const FileSpec &source_file,
   encode_source.blksize = Constants::BLOCK_SIZE;
   decode_source.blksize = Constants::BLOCK_SIZE;
 
+  encode_source.max_winsize = options.encode_srcwin_maxsz;
+
   xd3_set_source (&encode_stream, &encode_source);
   xd3_set_source (&decode_stream, &decode_source);
 
diff --git a/xdelta3/xdelta3-blkcache.h b/xdelta3/xdelta3-blkcache.h
index 56b8973..63abde3 100644
--- a/xdelta3/xdelta3-blkcache.h
+++ b/xdelta3/xdelta3-blkcache.h
@@ -166,6 +166,7 @@ main_set_source (xd3_stream *stream, xd3_cmd cmd,
   source->ioh      = sfile;
   source->curblkno = (xoff_t) -1;
   source->curblk   = NULL;
+  source->max_winsize = option_srcwinsz;
 
   if ((ret = main_getblk_func (stream, source, 0)) != 0)
     {
@@ -193,6 +194,7 @@ main_set_source (xd3_stream *stream, xd3_cmd cmd,
       blksize = option_srcwinsz / MAX_LRU_SIZE;
       source->blksize = blksize;
       source->onblk = blksize;  /* xd3 sets onblk */
+      source->max_winsize = blksize;
       lru[0].size = blksize;
       lru_size = MAX_LRU_SIZE;
 
diff --git a/xdelta3/xdelta3-internal.h b/xdelta3/xdelta3-internal.h
index 955a277..f741005 100644
--- a/xdelta3/xdelta3-internal.h
+++ b/xdelta3/xdelta3-internal.h
@@ -24,7 +24,7 @@ typedef struct _main_file        main_file;
 typedef struct _main_extcomp     main_extcomp;
 
 void main_buffree (void *ptr);
-void* main_bufalloc (usize_t size);
+void* main_bufalloc (size_t size);
 void main_file_init (main_file *xfile);
 int main_file_close (main_file *xfile);
 void main_file_cleanup (main_file *xfile);
diff --git a/xdelta3/xdelta3-main.h b/xdelta3/xdelta3-main.h
index 71c8541..6fcd423 100644
--- a/xdelta3/xdelta3-main.h
+++ b/xdelta3/xdelta3-main.h
@@ -250,7 +250,7 @@ static const char *option_source_filename    = NULL;
 static int         option_level              = XD3_DEFAULT_LEVEL;
 static usize_t     option_iopt_size          = XD3_DEFAULT_IOPT_SIZE;
 static usize_t     option_winsize            = XD3_DEFAULT_WINSIZE;
-static usize_t     option_srcwinsz           = XD3_DEFAULT_SRCWINSZ;
+static size_t      option_srcwinsz           = XD3_DEFAULT_SRCWINSZ;
 static usize_t     option_sprevsz            = XD3_DEFAULT_SPREVSZ;
 
 /* These variables are supressed to avoid their use w/o support.  main() warns
@@ -309,7 +309,7 @@ static int main_getblk_func (xd3_stream *stream,
                              xd3_source *source,
                              xoff_t      blkno);
 static void main_free (void *ptr);
-static void* main_malloc (usize_t size);
+static void* main_malloc (size_t size);
 
 static int main_file_stat (main_file *xfile, xoff_t *size);
 static int main_file_seek (main_file *xfile, xoff_t pos);
@@ -443,15 +443,14 @@ reset_defaults(void)
 }
 
 static void*
-main_malloc1 (usize_t size)
+main_malloc1 (size_t size)
 {
   void* r = malloc (size);
   if (r == NULL) { XPR(NT "malloc: %s\n", xd3_mainerror (ENOMEM)); }
-  else if (option_verbose > 4) { XPR(NT "malloc: %u: %p\n", size, r); }
   return r;
 }
 
-void* main_bufalloc (usize_t size) {
+void* main_bufalloc (size_t size) {
 #if XD3_WIN32
   return VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
 #else
@@ -460,7 +459,7 @@ void* main_bufalloc (usize_t size) {
 }
 
 static void*
-main_malloc (usize_t size)
+main_malloc (size_t size)
 {
   void *r = main_malloc1 (size);
   if (r) { IF_DEBUG (main_mallocs += 1); }
@@ -469,7 +468,7 @@ main_malloc (usize_t size)
 
 static void*
 main_alloc (void   *opaque,
-            usize_t  items,
+            size_t  items,
             usize_t  size)
 {
   return main_malloc1 (items * size);
@@ -478,7 +477,6 @@ main_alloc (void   *opaque,
 static void
 main_free1 (void *opaque, void *ptr)
 {
-  if (option_verbose > 4) { XPR(NT "free: %p\n", ptr); }
   free (ptr);
 }
 
@@ -703,8 +701,8 @@ main_strtoxoff (const char* s, xoff_t *xo, char which)
 }
 
 static int
-main_atou (const char* arg, usize_t *xo, usize_t low,
-           usize_t high, char which)
+main_atoux (const char* arg, xoff_t *xo, xoff_t low,
+            xoff_t high, char which)
 {
   xoff_t x;
   int ret;
@@ -713,7 +711,7 @@ main_atou (const char* arg, usize_t *xo, usize_t low,
 
   if (x < low)
     {
-      XPR(NT "-%c: minimum value: %u\n", which, low);
+      XPR(NT "-%c: minimum value: %"Q"u\n", which, low);
       return EXIT_FAILURE;
     }
   if (high == 0)
@@ -722,10 +720,24 @@ main_atou (const char* arg, usize_t *xo, usize_t low,
     }
   if (x > high)
     {
-      XPR(NT "-%c: maximum value: %u\n", which, high);
+      XPR(NT "-%c: maximum value: %"Q"u\n", which, high);
       return EXIT_FAILURE;
     }
-  (*xo) = (usize_t)x;
+  (*xo) = x;
+  return 0;
+}
+
+static int
+main_atou (const char* arg, usize_t *uo, usize_t low,
+           usize_t high, char which) 
+{
+  int ret;
+  xoff_t xo;
+  if ((ret = main_atoux (arg, &xo, low, high, which)))
+    {
+      return ret;
+    }
+  *uo = (usize_t)xo;
   return 0;
 }
 
@@ -3102,7 +3114,6 @@ main_input (xd3_cmd     cmd,
     }
 
   config.winsize = winsize;
-  config.srcwin_maxsz = option_srcwinsz;
   config.getblk = main_getblk_func;
   config.flags = stream_flags;
 
@@ -3760,13 +3771,16 @@ int main (int argc, char **argv)
           break;
         case 'A': if (my_optarg == NULL) { option_use_appheader = 0; }
                   else { option_appheader = (uint8_t*) my_optarg; } break;
-        case 'B':
-          if ((ret = main_atou (my_optarg, & option_srcwinsz, XD3_MINSRCWINSZ,
-                                0, 'B')))
+        case 'B': {
+          xoff_t bsize;
+          if ((ret = main_atoux (my_optarg, & bsize,
+                                 XD3_MINSRCWINSZ, 0, 'B')))
             {
               goto exit;
             }
+          option_srcwinsz = bsize;
           break;
+        }
         case 'I':
           if ((ret = main_atou (my_optarg, & option_iopt_size, 0,
                                 0, 'I')))
diff --git a/xdelta3/xdelta3.c b/xdelta3/xdelta3.c
index 431bab9..eb44b89 100644
--- a/xdelta3/xdelta3.c
+++ b/xdelta3/xdelta3.c
@@ -1527,9 +1527,9 @@ xd3_swap_usize_t (usize_t* p1, usize_t* p2)
 
 /* It's not constant time, but it computes the log. */
 static int
-xd3_check_pow2 (usize_t value, usize_t *logof)
+xd3_check_pow2 (xoff_t value, usize_t *logof)
 {
-  usize_t x = 1;
+  xoff_t x = 1;
   usize_t nolog;
   if (logof == NULL) {
     logof = &nolog;
@@ -1558,6 +1558,16 @@ xd3_pow2_roundup (usize_t x)
   return i;
 }
 
+static xoff_t
+xd3_xoff_roundup (xoff_t x)
+{
+  xoff_t i = 1;
+  while (x > i) {
+    i <<= 1U;
+  }
+  return i;
+}
+
 static usize_t
 xd3_round_blksize (usize_t sz, usize_t blksz)
 {
@@ -2088,9 +2098,9 @@ xd3_decode_address (xd3_stream *stream, usize_t here,
 ***********************************************************************/
 
 static void*
-__xd3_alloc_func (void* opaque, usize_t items, usize_t size)
+__xd3_alloc_func (void* opaque, size_t items, usize_t size)
 {
-  return malloc ((size_t) items * (size_t) size);
+  return malloc (items * (size_t) size);
 }
 
 static void
@@ -2369,8 +2379,6 @@ xd3_config_stream(xd3_stream *stream,
 
   stream->winsize = config->winsize ? config->winsize : XD3_DEFAULT_WINSIZE;
   stream->sprevsz = config->sprevsz ? config->sprevsz : XD3_DEFAULT_SPREVSZ;
-  stream->srcwin_maxsz = config->srcwin_maxsz ?
-    config->srcwin_maxsz : XD3_DEFAULT_SRCWINSZ;
 
   if (config->iopt_size == 0)
     {
@@ -2651,15 +2659,23 @@ xd3_set_source (xd3_stream *stream,
 
   /* Enforce power-of-two blocksize so that source-block number
    * calculations are cheap. */
-  if (!xd3_check_pow2 (src->blksize, &shiftby) == 0)
+  if (xd3_check_pow2 (src->blksize, &shiftby) != 0)
     {
       src->blksize = xd3_pow2_roundup(src->blksize);
       xd3_check_pow2 (src->blksize, &shiftby);
-      IF_DEBUG1 (DP(RINT "raising srcblksz to %u\n", src->blksize));
+      IF_DEBUG1 (DP(RINT "raising src_blksz to %u\n", src->blksize));
     }
 
   src->shiftby = shiftby;
   src->maskby = (1 << shiftby) - 1;
+
+  if (xd3_check_pow2 (src->max_winsize, NULL) != 0)
+    {
+      src->max_winsize = xd3_xoff_roundup(src->max_winsize);
+      IF_DEBUG1 (DP(RINT "raising src_maxsize to %"Q"u\n", src->blksize));
+    }
+  src->max_winsize = max(src->max_winsize, XD3_ALLOCSIZE);
+
   return 0;
 }
 
@@ -3678,7 +3694,7 @@ xd3_encode_init (xd3_stream *stream, int full_init)
        * identical or short inputs require no table allocation. */
       if (large_comp)
         {
-          usize_t hash_values = (stream->srcwin_maxsz /
+          usize_t hash_values = (stream->src->max_winsize /
                                  stream->smatcher.large_step);
 
           xd3_size_hashtable (stream,
@@ -4117,7 +4133,6 @@ xd3_process_memory (int            is_encode,
 
   if (is_encode)
     {
-      config.srcwin_maxsz = source_size;
       config.winsize = min(input_size, (usize_t) XD3_DEFAULT_WINSIZE);
       config.iopt_size = min(input_size / 32, XD3_DEFAULT_IOPT_SIZE);
       config.iopt_size = max(config.iopt_size, 128U);
@@ -4137,6 +4152,7 @@ xd3_process_memory (int            is_encode,
       src.onblk = source_size;
       src.curblk = source;
       src.curblkno = 0;
+      src.max_winsize = source_size;
 
       if ((ret = xd3_set_source_and_size (&stream, &src, source_size)) != 0)
         {
@@ -4419,23 +4435,23 @@ xd3_source_match_setup (xd3_stream *stream, xoff_t srcpos)
       goto bad;
     }
 
-  /* Implement srcwin_maxsz, which prevents the encoder from seeking
+  /* Implement src->max_winsize, which prevents the encoder from seeking
    * back further than the LRU cache maintaining FIFO discipline, (to
    * avoid seeking).  Note the +1 here ensures that "frontier_pos" is
    * the address of the next byte in the stream, and ensures that the
    * maximum offset is less than the source window size (in
    * blocks). */
   frontier_pos =
-    (stream->src->frontier_blkno +1) * stream->src->blksize;
+    (stream->src->frontier_blkno + 1) * stream->src->blksize;
   IF_DEBUG1(DP(RINT "[match_setup] frontier_pos %"Q"u, srcpos %"Q"u, "
-               "srcwin_maxsz %u\n",
-               frontier_pos, srcpos, stream->srcwin_maxsz));
+               "src->max_winsize %u\n",
+               frontier_pos, srcpos, stream->src->max_winsize));
   if (srcpos < frontier_pos &&
-      frontier_pos - srcpos > stream->srcwin_maxsz) {
-    IF_DEBUG1(DP(RINT "[match_setup] rejected due to srcwin_maxsz "
+      frontier_pos - srcpos > stream->src->max_winsize) {
+    IF_DEBUG1(DP(RINT "[match_setup] rejected due to src->max_winsize "
                  "distance eof=%"Q"u srcpos=%"Q"u maxsz=%u\n",
                  xd3_source_eof (stream->src),
-                 srcpos, stream->srcwin_maxsz));
+                 srcpos, stream->src->max_winsize));
     goto bad;
   }
 
@@ -5034,7 +5050,7 @@ xd3_srcwin_move_point (xd3_stream *stream, usize_t *next_move_point)
    * maximum window size. */
   logical_input_cksum_pos = min((stream->total_in + stream->input_position) * 2,
                                 (stream->total_in + stream->input_position) +
-                                  (stream->srcwin_maxsz / 2));
+                                  (stream->src->max_winsize / 2));
 
   /* If srcwin_cksum_pos is already greater, wait until the difference
    * is met. */
@@ -5060,13 +5076,13 @@ xd3_srcwin_move_point (xd3_stream *stream, usize_t *next_move_point)
   /* Advance at least one source block.  With the command-line
    * defaults this means:
    *
-   * if (src->size <= srcwin_maxsz), index the entire source at once
+   * if (src->size <= src->max_winsize), index the entire source at once
    * using the position of the first non-match.  This is good for
    * small inputs, especially when the content may have moved anywhere
    * in the file (e.g., tar files).
    *
-   * if (src->size > srcwin_maxsz), index at least one block (which
-   * the command-line sets to 1/32 of srcwin_maxsz) ahead of the
+   * if (src->size > src->max_winsize), index at least one block (which
+   * the command-line sets to 1/32 of src->max_winsize) ahead of the
    * logical position.  This is good for different reasons: when a
    * long match spanning several source blocks is encountered, this
    * avoids computing checksums for those blocks.  If the data can
diff --git a/xdelta3/xdelta3.h b/xdelta3/xdelta3.h
index 6cffbf8..554359d 100644
--- a/xdelta3/xdelta3.h
+++ b/xdelta3/xdelta3.h
@@ -280,8 +280,8 @@ typedef struct _xd3_wininfo            xd3_wininfo;
  * provided as NULL, the stream returns XD3_GETSRCBLK. */
 
 typedef void*  (xd3_alloc_func)    (void       *opaque,
-                                    usize_t      items,
-                                    usize_t      size);
+                                    size_t      items,
+                                    usize_t     size);
 typedef void   (xd3_free_func)     (void       *opaque,
                                     void       *address);
 
@@ -692,10 +692,6 @@ struct _xd3_config
   usize_t             iopt_size;     /* entries in the
                                         instruction-optimizing
                                         buffer */
-  usize_t             srcwin_maxsz;  /* srcwin_size grows by a factor
-                                        of 2 when no matches are
-                                        found.  encoder will not seek
-                                        back further than this. */
 
   xd3_getblk_func   *getblk;        /* The three callbacks. */
   xd3_alloc_func    *alloc;
@@ -729,6 +725,7 @@ struct _xd3_source
   const char         *name;          /* its name, for debug/print
                                         purposes */
   void               *ioh;           /* opaque handle */
+  xoff_t              max_winsize;   /* maximum visible buffer */
 
   /* getblk sets */
   xoff_t              curblkno;      /* current block number: client
@@ -798,7 +795,6 @@ struct _xd3_stream
                                          size mask */
   usize_t           iopt_size;
   usize_t           iopt_unlimited;
-  usize_t           srcwin_maxsz;
 
   /* general configuration */
   xd3_getblk_func  *getblk;           /* set nxtblk, nxtblkno to scanblkno */
@@ -840,7 +836,7 @@ struct _xd3_stream
                                        * if there is at least one
                                        * match in the buffer. */
 
-  /* SRCWIN: these variables plus srcwin_maxsz above (set by config) */
+  /* SRCWIN */
   int                srcwin_decided;    /* boolean: true if srclen and
                                            srcbase have been
                                            decided. */
@@ -1070,11 +1066,11 @@ int     xd3_decode_memory (const uint8_t *input,
  *       src.curblkno = 0;
  *       src.onblk = source_size;
  *       src.curblk = source;
+ *       src.max_winsize = source_size;
  *       xd3_set_source(&stream, &src);
  *     }
  *
  *   config.flags = flags;
- *   config.srcwin_maxsz = source_size;
  *   config.winsize = input_size;
  *
  *   ... set smatcher, appheader, encoding-table, compression-level, etc.