builtin/gc: fix signedness issues in ODB-related functionality

There are a couple of signedness issues in ODB-related functionality.
These are not a problem because we disable -Wsign-compare in this file,
but once we move these functions into "odb/source-files.c" they will
result in warnings.

Fix those issues:

  - In `too_many_loose_objects()` we receive a signed limit, but compare
    it with the unsigned actual number of loose objects. This is fixed
    by bailing out immediately when the limit is smaller than or equal
    to zero, which we also do similarly in other places. The warning is
    then squelched via a cast.

  - In `find_base_packs()` we compare the signed size of the pack
    against the unsigned limit. As the pack size is always going to be a
    positive file size it's safe to cast it to an unsigned value.

  - In `odb_optimize()` we compare the unsigned `keep_pack.nr` value
    against the signed `gc_auto_pack_limit`. We only reach this code
    when `too_many_packs()` returns true-ish, and that can only happen
    when `gc_auto_pack_limit > 0`. Consequently, we can fix the warning
    by casting the limit to an unsigned value.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/gc.c b/builtin/gc.c
index 32071824887cda501d8d67da79d513a078482fe4..8cf3781313bc53cb9cb4834a6aa160815851288f 100644 (file)
--- a/builtin/gc.c
+++ b/builtin/gc.c
@@ -430,19 +430,21 @@ out:
 
 static int too_many_loose_objects(struct odb_source_files *files, int limit)
 {
-       /*
-        * This is weird, but stems from legacy behaviour: the GC auto
-        * threshold was always essentially interpreted as if it was rounded up
-        * to the next multiple 256 of, so we retain this behaviour for now.
-        */
-       int auto_threshold = DIV_ROUND_UP(limit, 256) * 256;
        unsigned long loose_count;
 
+       if (limit <= 0)
+               return 0;
+
        if (odb_source_count_objects(&files->loose->base, ODB_COUNT_OBJECTS_APPROXIMATE,
                                     &loose_count) < 0)
                return 0;
 
-       return loose_count > auto_threshold;
+       /*
+        * This is weird, but stems from legacy behaviour: the GC auto
+        * threshold was always essentially interpreted as if it was rounded up
+        * to the next multiple 256 of, so we retain this behaviour for now.
+        */
+       return loose_count > (DIV_ROUND_UP(((unsigned long) limit), 256) * 256);
 }
 
 static struct packed_git *find_base_packs(struct odb_source_files *files,
@@ -456,7 +458,7 @@ static struct packed_git *find_base_packs(struct odb_source_files *files,
                if (e->pack->is_cruft)
                        continue;
                if (limit) {
-                       if (e->pack->pack_size >= limit)
+                       if ((uintmax_t) e->pack->pack_size >= limit)
                                string_list_append(packs, e->pack->pack_name);
                } else if (!base || base->pack_size < e->pack->pack_size) {
                        base = e->pack;
@@ -946,7 +948,7 @@ static int odb_optimize(struct object_database *odb,
 
                                if (big_pack_threshold) {
                                        find_base_packs(files, &keep_pack, big_pack_threshold);
-                                       if (keep_pack.nr >= gc_auto_pack_limit) {
+                                       if (keep_pack.nr >= (unsigned long) gc_auto_pack_limit) {
                                                string_list_clear(&keep_pack, 0);
                                                find_base_packs(files, &keep_pack, 0);
                                        }