Fixes to compiler warnings in MSVC

firmware/lib/cgptlib/cgptlib.c

 /* Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "cgptlib.h"
 #include "cgptlib_internal.h"
 #include "crc32.h"
 #include "gpt.h"
 #include "utility.h"
 
 /* global types to compare against */
 const Guid guid_unused = GPT_ENT_TYPE_UNUSED;
 const Guid guid_chromeos_kernel = GPT_ENT_TYPE_CHROMEOS_KERNEL;
 
 
 int GptInit(GptData *gpt) {
   int retval;
 
   gpt->modified = 0;
   gpt->current_kernel = CGPT_KERNEL_ENTRY_NOT_FOUND;
   gpt->current_priority = 999;
 
   retval = GptSanityCheck(gpt);
-  if (GPT_SUCCESS != retval)
+  if (GPT_SUCCESS != retval) {
+    debug("GptInit() failed sanity check\n");
     return retval;
+  }
 
   GptRepair(gpt);
   return GPT_SUCCESS;
 }
 
 
 int GptNextKernelEntry(GptData* gpt, uint64_t* start_sector, uint64_t* size) {
   GptHeader* header = (GptHeader*)gpt->primary_header;
   GptEntry* entries = (GptEntry*)gpt->primary_entries;
   GptEntry* e;
   int new_kernel = CGPT_KERNEL_ENTRY_NOT_FOUND;
   int new_prio = 0;
-  int i;
+  uint32_t i;
 
   /* If we already found a kernel, continue the scan at the current
    * kernel's prioity, in case there is another kernel with the same
    * priority. */
   if (gpt->current_kernel != CGPT_KERNEL_ENTRY_NOT_FOUND) {
     for (i = gpt->current_kernel + 1; i < header->number_of_entries; i++) {
       e = entries + i;
       if (!IsKernelEntry(e))
         continue;
+      debug("GptNextKernelEntry looking at same prio partition %d\n", i);
+      debug("GptNextKernelEntry s%d t%d p%d\n",
+            GetEntrySuccessful(e), GetEntryTries(e), GetEntryPriority(e));
       if (!(GetEntrySuccessful(e) || GetEntryTries(e)))
         continue;
       if (GetEntryPriority(e) == gpt->current_priority) {
         gpt->current_kernel = i;
         *start_sector = e->starting_lba;
         *size = e->ending_lba - e->starting_lba + 1;
+        debug("GptNextKernelEntry likes that one\n");
         return GPT_SUCCESS;
       }
     }
   }
 
   /* We're still here, so scan for the remaining kernel with the
    * highest priority less than the previous attempt. */
   for (i = 0, e = entries; i < header->number_of_entries; i++, e++) {
     int current_prio = GetEntryPriority(e);
     if (!IsKernelEntry(e))
       continue;
+    debug("GptNextKernelEntry looking at new prio partition %d\n", i);
+    debug("GptNextKernelEntry s%d t%d p%d\n",
+          GetEntrySuccessful(e), GetEntryTries(e), GetEntryPriority(e));
     if (!(GetEntrySuccessful(e) || GetEntryTries(e)))
       continue;
     if (current_prio >= gpt->current_priority)
       continue;  /* Already returned this kernel in a previous call */
     if (current_prio > new_prio) {
       new_kernel = i;
       new_prio = current_prio;
     }
   }
 
   /* Save what we found.  Note that if we didn't find a new kernel,
    * new_prio will still be -1, so future calls to this function will
    * also fail. */
   gpt->current_kernel = new_kernel;
   gpt->current_priority = new_prio;
 
-  if (CGPT_KERNEL_ENTRY_NOT_FOUND == new_kernel)
+  if (CGPT_KERNEL_ENTRY_NOT_FOUND == new_kernel) {
+    debug("GptNextKernelEntry no more kernels\n");
     return GPT_ERROR_NO_VALID_KERNEL;
+  }
 
+  debug("GptNextKernelEntry likes that one\n");
   e = entries + new_kernel;
   *start_sector = e->starting_lba;
   *size = e->ending_lba - e->starting_lba + 1;
   return GPT_SUCCESS;
 }
 
 
 int GptUpdateKernelEntry(GptData* gpt, uint32_t update_type) {
   GptHeader* header = (GptHeader*)gpt->primary_header;
   GptEntry* entries = (GptEntry*)gpt->primary_entries;
@@ skipping 45 matching lines @@
 
   /* Use the repair function to update the other copy of the GPT.
    * This is a tad inefficient, but is much faster than the disk I/O
    * to update the GPT on disk so it doesn't matter. */
   gpt->valid_headers = MASK_PRIMARY;
   gpt->valid_entries = MASK_PRIMARY;
   GptRepair(gpt);
 
   return GPT_SUCCESS;
 }