Don't use BFD_VMA_FMT in binutils

BFD_VMA_FMT can't be used in format strings that need to be
translated, because the translation won't work when the type of
bfd_vma differs from the machine used to compile .pot files.  We've
known about this for a long time, but patches slip through review.

So just get rid of BFD_VMA_FMT, instead using the appropriate PRId64,
PRIu64, PRIx64 or PRIo64 and SCN variants for scanf.  The patch is
mostly mechanical, the only thing requiring any thought is casts
needed to preserve PRId64 output from bfd_vma values, or to preserve
one of the unsigned output formats from bfd_signed_vma values.

diff --git a/bfd/archive.c b/bfd/archive.c
index 9ad61adc6159a2731a0443353f393baeea48bf5d..19d167112bc7ef1c6d72966b6514207fa3866739 100644 (file)
--- a/bfd/archive.c
+++ b/bfd/archive.c
@@ -192,7 +192,7 @@ _bfd_ar_sizepad (char *p, size_t n, bfd_size_type size)
   char buf[21];
   size_t len;
 
-  snprintf (buf, sizeof (buf), "%-10" BFD_VMA_FMT "u", size);
+  snprintf (buf, sizeof (buf), "%-10" PRIu64, (uint64_t) size);
   len = strlen (buf);
   if (len > n)
     {
@@ -485,7 +485,7 @@ _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
 {
   struct ar_hdr hdr;
   char *hdrp = (char *) &hdr;
-  bfd_size_type parsed_size;
+  uint64_t parsed_size;
   struct areltdata *ared;
   char *filename = NULL;
   ufile_ptr filesize;
@@ -514,7 +514,7 @@ _bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
   errno = 0;
   fmag_save = hdr.ar_fmag[0];
   hdr.ar_fmag[0] = 0;
-  scan = sscanf (hdr.ar_size, "%" BFD_VMA_FMT "u", &parsed_size);
+  scan = sscanf (hdr.ar_size, "%" SCNu64, &parsed_size);
   hdr.ar_fmag[0] = fmag_save;
   if (scan != 1)
     {

diff --git a/bfd/coff64-rs6000.c b/bfd/coff64-rs6000.c
index ce1c518282ea04bf2e7f35d6ac980ced27597060..c5dc95c1836f2c67935cd63c846c84f38df7c030 100644 (file)
--- a/bfd/coff64-rs6000.c
+++ b/bfd/coff64-rs6000.c
@@ -1595,7 +1595,7 @@ xcoff64_ppc_relocate_section (bfd *output_bfd,
 
            default:
              _bfd_error_handler
-               (_("%pB: relocation (%d) at (0x%" BFD_VMA_FMT "x) has wrong"
+               (_("%pB: relocation (%d) at (0x%" PRIx64 ") has wrong"
                   " r_rsize (0x%x)\n"),
                 input_bfd, rel->r_type, rel->r_vaddr, rel->r_size);
              return false;

diff --git a/bfd/coffcode.h b/bfd/coffcode.h
index 6de6ecdea39a1c95b19b30760788f5a107aef759..0dc68a9a25fb9fcfeb18e669c594b97221ea76e4 100644 (file)
--- a/bfd/coffcode.h
+++ b/bfd/coffcode.h
@@ -2495,15 +2495,15 @@ coff_print_aux (bfd *abfd ATTRIBUTE_UNUSED,
       if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
        {
          BFD_ASSERT (! aux->fix_scnlen);
-         fprintf (file, "val %5" BFD_VMA_FMT "d",
-                  aux->u.auxent.x_csect.x_scnlen.l);
+         fprintf (file, "val %5" PRId64,
+                  (int64_t) aux->u.auxent.x_csect.x_scnlen.l);
        }
       else
        {
          fprintf (file, "indx ");
          if (! aux->fix_scnlen)
-           fprintf (file, "%4" BFD_VMA_FMT "d",
-                    aux->u.auxent.x_csect.x_scnlen.l);
+           fprintf (file, "%4" PRId64,
+                    (int64_t) aux->u.auxent.x_csect.x_scnlen.l);
          else
            fprintf (file, "%4ld",
                     (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));

diff --git a/bfd/elf.c b/bfd/elf.c
index 3e64cdf6699395024fd5e39bbd192553f58cdde0..346eea39b1ff4bbff7d4ffbe6bb24868f725a076 100644 (file)
--- a/bfd/elf.c
+++ b/bfd/elf.c
@@ -1750,7 +1750,7 @@ _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
 
              if (!strcmp (name, ""))
                {
-                 sprintf (ab, "%#" BFD_VMA_FMT "x", dyn.d_tag);
+                 sprintf (ab, "%#" PRIx64, (uint64_t) dyn.d_tag);
                  name = ab;
                }
              break;

diff --git a/bfd/elf32-rx.c b/bfd/elf32-rx.c
index 6df021468b500f4c0b79c68ae0cf9aae741cd2af..34eb88403d01b360fb1680e5282da1a1abafded2 100644 (file)
--- a/bfd/elf32-rx.c
+++ b/bfd/elf32-rx.c
@@ -3972,16 +3972,17 @@ rx_table_map (struct bfd_hash_entry *vent, void *vinfo)
 
   bfd_hash_traverse (&(info->info->hash->table), rx_table_map_2, info);
 
-  fprintf (info->mapfile, "\nRX Vector Table: %s has %d entries at 0x%08" BFD_VMA_FMT "x\n\n",
-          tname, info->table_size, start_addr);
+  fprintf (info->mapfile,
+          "\nRX Vector Table: %s has %d entries at 0x%08" PRIx64 "\n\n",
+          tname, info->table_size, (uint64_t) start_addr);
 
   if (info->table_default_entry)
-    fprintf (info->mapfile, "  default handler is: %s at 0x%08" BFD_VMA_FMT "x\n",
+    fprintf (info->mapfile, "  default handler is: %s at 0x%08" PRIx64 "\n",
             info->table_default_entry->root.string,
-            info->table_default_handler);
+            (uint64_t) info->table_default_handler);
   else if (info->table_default_handler != (bfd_vma)(-1))
-    fprintf (info->mapfile, "  default handler is at 0x%08" BFD_VMA_FMT "x\n",
-            info->table_default_handler);
+    fprintf (info->mapfile, "  default handler is at 0x%08" PRIx64 "\n",
+            (uint64_t) info->table_default_handler);
   else
     fprintf (info->mapfile, "  no default handler\n");
 
@@ -3997,7 +3998,8 @@ rx_table_map (struct bfd_hash_entry *vent, void *vinfo)
        }
       need_elipses = 1;
 
-      fprintf (info->mapfile, "  0x%08" BFD_VMA_FMT "x [%3d] ", start_addr + 4 * idx, idx);
+      fprintf (info->mapfile,
+              "  0x%08" PRIx64 " [%3d] ", (uint64_t) start_addr + 4 * idx, idx);
 
       if (info->table_handlers[idx] == (bfd_vma) (-1))
        fprintf (info->mapfile, "(no handler found)\n");
@@ -4012,12 +4014,15 @@ rx_table_map (struct bfd_hash_entry *vent, void *vinfo)
 
       else if (info->table_entries[idx])
        {
-         fprintf (info->mapfile, "0x%08" BFD_VMA_FMT "x %s\n", info->table_handlers[idx], info->table_entries[idx]->root.string);
+         fprintf (info->mapfile, "0x%08" PRIx64 " %s\n",
+                  (uint64_t) info->table_handlers[idx],
+                  info->table_entries[idx]->root.string);
        }
 
       else
        {
-         fprintf (info->mapfile, "0x%08" BFD_VMA_FMT "x ???\n", info->table_handlers[idx]);
+         fprintf (info->mapfile, "0x%08" PRIx64 " ???\n",
+                  (uint64_t) info->table_handlers[idx]);
        }
     }
   if (need_elipses)

diff --git a/bfd/elf64-ppc.c b/bfd/elf64-ppc.c
index 570b3563f2ce6232f5857e05a8ded5802f2a2f40..cfcd263173c45c5b11e40b6c9220c0cd5cbfb57b 100644 (file)
--- a/bfd/elf64-ppc.c
+++ b/bfd/elf64-ppc.c
@@ -11670,7 +11670,7 @@ dump_stub (const char *header,
   fprintf (stderr, "%s id = %u type = %s:%s:%s\n",
           header, stub_entry->id, t1, t2, t3);
   fprintf (stderr, "name = %s\n", stub_entry->root.string);
-  fprintf (stderr, "offset = 0x%" BFD_VMA_FMT "x:", stub_entry->stub_offset);
+  fprintf (stderr, "offset = 0x%" PRIx64 ":", stub_entry->stub_offset);
   for (size_t i = stub_entry->stub_offset; i < end_offset; i += 4)
     {
       asection *stub_sec = stub_entry->group->stub_sec;
@@ -11736,8 +11736,8 @@ ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
        fprintf (stderr, "Expected id %u, got %u\n",
                 htab->stub_id, stub_entry->id);
       if (stub_entry->stub_offset < stub_entry->group->stub_sec->size)
-       fprintf (stderr, "Expected offset >= %" BFD_VMA_FMT "x, got %"
-                BFD_VMA_FMT "x\n", stub_entry->group->stub_sec->size,
+       fprintf (stderr, "Expected offset >= %" PRIx64 ", got %"
+                PRIx64 "\n", stub_entry->group->stub_sec->size,
                 stub_entry->stub_offset);
       if (esd->sec_type == sec_stub)
        dump_stub ("Previous:", esd->u.last_ent, stub_entry->stub_offset);

diff --git a/bfd/elfcode.h b/bfd/elfcode.h
index 4d4cb68164ab7728e6050ccd060b8cb93ddb576d..39c84b4d0fd99a65d79c30e3a378cb4293ab1f7e 100644 (file)
--- a/bfd/elfcode.h
+++ b/bfd/elfcode.h
@@ -1002,9 +1002,10 @@ elf_write_relocs (bfd *abfd, asection *sec, void *data)
          && ptr->howto->bitsize > 32
          && ptr->addend - INT32_MIN > UINT32_MAX)
        {
-         _bfd_error_handler (_("%pB: %pA+%"BFD_VMA_FMT"x: "
-                               "relocation addend %"BFD_VMA_FMT"x too large"),
-                             abfd, sec, ptr->address, ptr->addend);
+         _bfd_error_handler (_("%pB: %pA+%" PRIx64 ": "
+                               "relocation addend %" PRIx64 " too large"),
+                             abfd, sec, (uint64_t) ptr->address,
+                             (uint64_t) ptr->addend);
          *failedp = true;
          bfd_set_error (bfd_error_bad_value);
        }

diff --git a/bfd/elfnn-aarch64.c b/bfd/elfnn-aarch64.c
index ac48a175720d205224796bec6183d21573f0d727..7b93672c0df1b752385fe61ac5419549d5d79395 100644 (file)
--- a/bfd/elfnn-aarch64.c
+++ b/bfd/elfnn-aarch64.c
@@ -3037,21 +3037,21 @@ elfNN_aarch64_stub_name (const asection *input_section,
       len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 16 + 1;
       stub_name = bfd_malloc (len);
       if (stub_name != NULL)
-       snprintf (stub_name, len, "%08x_%s+%" BFD_VMA_FMT "x",
+       snprintf (stub_name, len, "%08x_%s+%" PRIx64,
                  (unsigned int) input_section->id,
                  hash->root.root.root.string,
-                 rel->r_addend);
+                 (uint64_t) rel->r_addend);
     }
   else
     {
       len = 8 + 1 + 8 + 1 + 8 + 1 + 16 + 1;
       stub_name = bfd_malloc (len);
       if (stub_name != NULL)
-       snprintf (stub_name, len, "%08x_%x:%x+%" BFD_VMA_FMT "x",
+       snprintf (stub_name, len, "%08x_%x:%x+%" PRIx64,
                  (unsigned int) input_section->id,
                  (unsigned int) sym_sec->id,
                  (unsigned int) ELFNN_R_SYM (rel->r_info),
-                 rel->r_addend);
+                 (uint64_t) rel->r_addend);
     }
 
   return stub_name;
@@ -4118,10 +4118,10 @@ _bfd_aarch64_erratum_843419_stub_name (asection *input_section,
   char *stub_name = bfd_malloc (len);
 
   if (stub_name != NULL)
-    snprintf (stub_name, len, "e843419@%04x_%08x_%" BFD_VMA_FMT "x",
+    snprintf (stub_name, len, "e843419@%04x_%08x_%" PRIx64,
              input_section->owner->id,
              input_section->id,
-             offset);
+             (uint64_t) offset);
   return stub_name;
 }
 
@@ -5358,15 +5358,13 @@ _bfd_aarch64_erratum_843419_branch_to_stub (struct bfd_hash_entry *gen_entry,
     }
   else
     {
-      char imm_buf[128];
-
-      sprintf (imm_buf, "%" BFD_VMA_FMT "x", imm);
       abfd = stub_entry->target_section->owner;
       _bfd_error_handler
-       (_("%pB: error: erratum 843419 immediate 0x%s "
-          "out of range for ADR (input file too large) and "
+       (_("%pB: error: erratum 843419 immediate 0x%" PRIx64
+          " out of range for ADR (input file too large) and "
           "--fix-cortex-a53-843419=adr used.  Run the linker with "
-          "--fix-cortex-a53-843419=full instead"), abfd, imm_buf);
+          "--fix-cortex-a53-843419=full instead"),
+        abfd, (uint64_t) (bfd_vma) imm);
       bfd_set_error (bfd_error_bad_value);
       /* This function is called inside a hashtable traversal and the error
         handlers called above turn into non-fatal errors.  Which means this

diff --git a/binutils/bucomm.c b/binutils/bucomm.c
index 583419055870559bd9f9b63638351976dac8a82d..5c4abf9cd7c2091f0e34a14c91aeee97266270db 100644 (file)
--- a/binutils/bucomm.c
+++ b/binutils/bucomm.c
@@ -455,7 +455,6 @@ print_arelt_descr (FILE *file, bfd *abfd, bool verbose, bool offsets)
          char timebuf[40];
          time_t when = buf.st_mtime;
          const char *ctime_result = (const char *) ctime (&when);
-         bfd_size_type size;
 
          /* PR binutils/17605: Check for corrupt time values.  */
          if (ctime_result == NULL)
@@ -466,11 +465,10 @@ print_arelt_descr (FILE *file, bfd *abfd, bool verbose, bool offsets)
 
          mode_string (buf.st_mode, modebuf);
          modebuf[10] = '\0';
-         size = buf.st_size;
          /* POSIX 1003.2/D11 says to skip first character (entry type).  */
-         fprintf (file, "%s %ld/%ld %6" BFD_VMA_FMT "u %s ", modebuf + 1,
+         fprintf (file, "%s %ld/%ld %6" PRIu64 " %s ", modebuf + 1,
                   (long) buf.st_uid, (long) buf.st_gid,
-                  size, timebuf);
+                  (uint64_t) buf.st_size, timebuf);
        }
     }
 

diff --git a/binutils/coffdump.c b/binutils/coffdump.c
index bccc395e5f881f1878a82d892c9dfad25d5272f1..00a32ccae977c4e974923bde694a711dfcbc042b 100644 (file)
--- a/binutils/coffdump.c
+++ b/binutils/coffdump.c
@@ -366,8 +366,7 @@ dump_coff_scope (struct coff_scope *p)
   if (p)
     {
       tab (1);
-      printf ("%s %" BFD_VMA_FMT "x ",
-             _("List of blocks "), (bfd_vma) (uintptr_t) p);
+      printf ("%s %p ", _("List of blocks "), p);
 
       if (p->sec)
        printf( "  %s %x..%x",  p->sec->name,p->offset, p->offset + p->size -1);

diff --git a/binutils/od-xcoff.c b/binutils/od-xcoff.c
index 8c4c2595d61d34bd0ec9f437d70a17cee49aee3a..c5c82736e4a2b4f5cbe06a7a059bae6390a48617 100644 (file)
--- a/binutils/od-xcoff.c
+++ b/binutils/od-xcoff.c
@@ -1686,42 +1686,42 @@ dump_dumpx_core (bfd *abfd, struct external_core_dumpx *hdr)
       printf ("  entries:    %u\n",
              (unsigned) bfd_h_get_16 (abfd, hdr->c_entries));
 #ifdef BFD64
-      printf ("  fdsinfox:   offset: 0x%08" BFD_VMA_FMT "x\n",
+      printf ("  fdsinfox:   offset: 0x%08" PRIx64 "\n",
              bfd_h_get_64 (abfd, hdr->c_fdsinfox));
-      printf ("  loader:     offset: 0x%08" BFD_VMA_FMT "x, "
-             "size: 0x%" BFD_VMA_FMT"x\n",
+      printf ("  loader:     offset: 0x%08" PRIx64 ", "
+             "size: 0x%" PRIx64 "\n",
              bfd_h_get_64 (abfd, hdr->c_loader),
              bfd_h_get_64 (abfd, hdr->c_lsize));
-      printf ("  thr:        offset: 0x%08" BFD_VMA_FMT "x, nbr: %u\n",
+      printf ("  thr:        offset: 0x%08" PRIx64 ", nbr: %u\n",
              bfd_h_get_64 (abfd, hdr->c_thr),
              (unsigned) bfd_h_get_32 (abfd, hdr->c_n_thr));
-      printf ("  segregions: offset: 0x%08" BFD_VMA_FMT "x, "
-             "nbr: %" BFD_VMA_FMT "u\n",
+      printf ("  segregions: offset: 0x%08" PRIx64 ", "
+             "nbr: %" PRIu64 "\n",
              bfd_h_get_64 (abfd, hdr->c_segregion),
              bfd_h_get_64 (abfd, hdr->c_segs));
-      printf ("  stack:      offset: 0x%08" BFD_VMA_FMT "x, "
-             "org: 0x%" BFD_VMA_FMT"x, "
-             "size: 0x%" BFD_VMA_FMT"x\n",
+      printf ("  stack:      offset: 0x%08" PRIx64 ", "
+             "org: 0x%" PRIx64 ", "
+             "size: 0x%" PRIx64 "\n",
              bfd_h_get_64 (abfd, hdr->c_stack),
              bfd_h_get_64 (abfd, hdr->c_stackorg),
              bfd_h_get_64 (abfd, hdr->c_size));
-      printf ("  data:       offset: 0x%08" BFD_VMA_FMT "x, "
-             "org: 0x%" BFD_VMA_FMT"x, "
-             "size: 0x%" BFD_VMA_FMT"x\n",
+      printf ("  data:       offset: 0x%08" PRIx64 ", "
+             "org: 0x%" PRIx64 ", "
+             "size: 0x%" PRIx64 "\n",
              bfd_h_get_64 (abfd, hdr->c_data),
              bfd_h_get_64 (abfd, hdr->c_dataorg),
              bfd_h_get_64 (abfd, hdr->c_datasize));
-      printf ("  sdata:         org: 0x%" BFD_VMA_FMT"x, "
-             "size: 0x%" BFD_VMA_FMT"x\n",
+      printf ("  sdata:         org: 0x%" PRIx64 ", "
+             "size: 0x%" PRIx64 "\n",
              bfd_h_get_64 (abfd, hdr->c_sdorg),
              bfd_h_get_64 (abfd, hdr->c_sdsize));
-      printf ("  vmmregions: offset: 0x%" BFD_VMA_FMT"x, "
-             "num: 0x%" BFD_VMA_FMT"x\n",
+      printf ("  vmmregions: offset: 0x%" PRIx64 ", "
+             "num: 0x%" PRIx64 "\n",
              bfd_h_get_64 (abfd, hdr->c_vmm),
              bfd_h_get_64 (abfd, hdr->c_vmmregions));
       printf ("  impl:       0x%08x\n",
              (unsigned) bfd_h_get_32 (abfd, hdr->c_impl));
-      printf ("  cprs:       0x%" BFD_VMA_FMT "x\n",
+      printf ("  cprs:       0x%" PRIx64 "\n",
              bfd_h_get_64 (abfd, hdr->c_cprs));
 #endif
     }

diff --git a/binutils/readelf.c b/binutils/readelf.c
index 157f8d8f6fba054fceddd7febd0fe31700c0b4ad..de572dd0b7e940470e5b51a9c937ab990b2ee654 100644 (file)
--- a/binutils/readelf.c
+++ b/binutils/readelf.c
@@ -430,30 +430,6 @@ get_dynamic_name (const Filedata *filedata, size_t offset)
 #define GNU_HASH_SECTION_NAME(filedata)                \
   filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
 \f
-/* Print a BFD_VMA to an internal buffer, for use in error messages.
-   BFD_FMA_FMT can't be used in translated strings.  */
-
-static const char *
-bfd_vmatoa (char *fmtch, bfd_vma value)
-{
-  /* bfd_vmatoa is used more then once in a printf call for output.
-     Cycle through an array of buffers.  */
-  static int buf_pos = 0;
-  static struct bfd_vmatoa_buf
-  {
-    char place[64];
-  } buf[4];
-  char *ret;
-  char fmt[32];
-
-  ret = buf[buf_pos++].place;
-  buf_pos %= ARRAY_SIZE (buf);
-
-  sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
-  snprintf (ret, sizeof (buf[0].place), fmt, value);
-  return ret;
-}
-
 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
    OFFSET + the offset of the current archive member, if we are examining an
    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
@@ -484,9 +460,9 @@ get_data (void *         var,
       || (size_t) amt != amt)
     {
       if (reason)
-       error (_("Size truncation prevents reading %s"
-                " elements of size %s for %s\n"),
-              bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
+       error (_("Size truncation prevents reading %" PRIu64
+                " elements of size %" PRIu64 " for %s\n"),
+              (uint64_t) nmemb, (uint64_t) size, reason);
       return NULL;
     }
 
@@ -494,9 +470,9 @@ get_data (void *         var,
   if (amt / size != nmemb || (size_t) amt + 1 == 0)
     {
       if (reason)
-       error (_("Size overflow prevents reading %s"
-                " elements of size %s for %s\n"),
-              bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
+       error (_("Size overflow prevents reading %" PRIu64
+                " elements of size %" PRIu64 " for %s\n"),
+              (uint64_t) nmemb, (uint64_t) size, reason);
       return NULL;
     }
 
@@ -507,8 +483,8 @@ get_data (void *         var,
       || amt > filedata->file_size - filedata->archive_file_offset - offset)
     {
       if (reason)
-       error (_("Reading %s bytes extends past end of file for %s\n"),
-              bfd_vmatoa ("u", amt), reason);
+       error (_("Reading %" PRIu64 " bytes extends past end of file for %s\n"),
+              (uint64_t) amt, reason);
       return NULL;
     }
 
@@ -530,8 +506,8 @@ get_data (void *         var,
       if (mvar == NULL)
        {
          if (reason)
-           error (_("Out of memory allocating %s bytes for %s\n"),
-                  bfd_vmatoa ("u", amt), reason);
+           error (_("Out of memory allocating %" PRIu64 " bytes for %s\n"),
+                  (uint64_t) amt, reason);
          return NULL;
        }
 
@@ -541,8 +517,8 @@ get_data (void *         var,
   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
     {
       if (reason)
-       error (_("Unable to read in %s bytes of %s\n"),
-              bfd_vmatoa ("u", amt), reason);
+       error (_("Unable to read in %" PRIu64 " bytes of %s\n"),
+              (uint64_t) amt, reason);
       if (mvar != var)
        free (mvar);
       return NULL;
@@ -573,34 +549,34 @@ print_vma (bfd_vma vma, print_mode mode)
 
     case DEC_5:
       if (vma <= 99999)
-       return printf ("%5" BFD_VMA_FMT "d", vma);
+       return printf ("%5" PRId64, (int64_t) vma);
       /* Fall through.  */
     case PREFIX_HEX:
       nc = printf ("0x");
       /* Fall through.  */
     case HEX:
-      return nc + printf ("%" BFD_VMA_FMT "x", vma);
+      return nc + printf ("%" PRIx64, (uint64_t) vma);
 
     case PREFIX_HEX_5:
       nc = printf ("0x");
       /* Fall through.  */
     case HEX_5:
-      return nc + printf ("%05" BFD_VMA_FMT "x", vma);
+      return nc + printf ("%05" PRIx64, (uint64_t) vma);
 
     case DEC:
-      return printf ("%" BFD_VMA_FMT "d", vma);
+      return printf ("%" PRId64, (int64_t) (bfd_signed_vma) vma);
 
     case UNSIGNED:
-      return printf ("%" BFD_VMA_FMT "u", vma);
+      return printf ("%" PRIu64, (uint64_t) vma);
 
     case UNSIGNED_5:
-      return printf ("%5" BFD_VMA_FMT "u", vma);
+      return printf ("%5" PRIu64, (uint64_t) vma);
 
     case OCTAL:
-      return printf ("%" BFD_VMA_FMT "o", vma);
+      return printf ("%" PRIo64, (uint64_t) vma);
 
     case OCTAL_5:
-      return printf ("%5" BFD_VMA_FMT "o", vma);
+      return printf ("%5" PRIo64, (uint64_t) vma);
 
     default:
       /* FIXME: Report unrecognised mode ?  */
@@ -1511,15 +1487,16 @@ dump_relocations (Filedata *          filedata,
     {
       bfd_vma * relrs;
       const char *format
-         = is_32bit_elf ? "%08" BFD_VMA_FMT "x\n" : "%016" BFD_VMA_FMT "x\n";
+       = is_32bit_elf ? "%08" PRIx64 "\n" : "%016" PRIx64 "\n";
 
       if (!slurp_relr_relocs (filedata, rel_offset, rel_size, &relrs,
                              &rel_size))
        return false;
 
-      printf (ngettext ("  %lu offset\n", "  %lu offsets\n", rel_size), rel_size);
+      printf (ngettext ("  %lu offset\n", "  %lu offsets\n", rel_size),
+             rel_size);
       for (i = 0; i < rel_size; i++)
-       printf (format, relrs[i]);
+       printf (format, (uint64_t) relrs[i]);
       free (relrs);
       return true;
     }
@@ -1582,9 +1559,9 @@ dump_relocations (Filedata *          filedata,
       else
        {
          printf (do_wide
-                 ? "%16.16" BFD_VMA_FMT "x  %16.16" BFD_VMA_FMT "x "
-                 : "%12.12" BFD_VMA_FMT "x  %12.12" BFD_VMA_FMT "x ",
-                 offset, inf);
+                 ? "%16.16" PRIx64 "  %16.16" PRIx64 " "
+                 : "%12.12" PRIx64 "  %12.12" PRIx64 " ",
+                 (uint64_t) offset, (uint64_t) inf);
        }
 
       switch (filedata->file_header.e_machine)
@@ -2089,9 +2066,9 @@ dump_relocations (Filedata *          filedata,
                  bfd_vma off = rels[i].r_addend;
 
                  if ((bfd_signed_vma) off < 0)
-                   printf (" - %" BFD_VMA_FMT "x", - off);
+                   printf (" - %" PRIx64, (uint64_t) -off);
                  else
-                   printf (" + %" BFD_VMA_FMT "x", off);
+                   printf (" + %" PRIx64, (uint64_t) off);
                }
            }
        }
@@ -2101,9 +2078,9 @@ dump_relocations (Filedata *          filedata,
 
          printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
          if ((bfd_signed_vma) off < 0)
-           printf ("-%" BFD_VMA_FMT "x", - off);
+           printf ("-%" PRIx64, (uint64_t) -off);
          else
-           printf ("%" BFD_VMA_FMT "x", off);
+           printf ("%" PRIx64, (uint64_t) off);
        }
 
       if (filedata->file_header.e_machine == EM_SPARCV9
@@ -6031,12 +6008,15 @@ process_program_headers (Filedata * filedata)
                filedata->file_name, get_file_type (filedata));
       else
        printf (_("\nElf file type is %s\n"), get_file_type (filedata));
-      printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
-      printf (ngettext ("There is %d program header, starting at offset %s\n",
-                       "There are %d program headers, starting at offset %s\n",
+      printf (_("Entry point 0x%" PRIx64 "\n"),
+             (uint64_t) filedata->file_header.e_entry);
+      printf (ngettext ("There is %d program header,"
+                       " starting at offset %" PRIu64 "\n",
+                       "There are %d program headers,"
+                       " starting at offset %" PRIu64 "\n",
                        filedata->file_header.e_phnum),
              filedata->file_header.e_phnum,
-             bfd_vmatoa ("u", filedata->file_header.e_phoff));
+             (uint64_t) filedata->file_header.e_phoff);
     }
 
   if (! get_program_headers (filedata))
@@ -8220,8 +8200,8 @@ dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *i
       const char *rtype;
 
       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
-      printf ("%08" BFD_VMA_FMT "x ",
-              (bfd_vma) BYTE_GET (imrs [i].rela_offset));
+      printf ("%08" PRIx64 " ",
+             (uint64_t) BYTE_GET (imrs [i].rela_offset));
       type = BYTE_GET (imrs [i].type);
       rtype = elf_ia64_reloc_type (type);
       if (rtype == NULL)
@@ -8230,8 +8210,8 @@ dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *i
         printf ("%-31s ", rtype);
       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
-      printf ("%08" BFD_VMA_FMT "x\n",
-              (bfd_vma) BYTE_GET (imrs [i].sym_offset));
+      printf ("%08" PRIx64 "\n",
+             (uint64_t) BYTE_GET (imrs [i].sym_offset));
     }
 
   free (imrs);
@@ -10949,8 +10929,9 @@ get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_si
   if (sizeof (size_t) < sizeof (bfd_size_type)
       && (bfd_size_type) ((size_t) number) != number)
     {
-      error (_("Size truncation prevents reading %s elements of size %u\n"),
-            bfd_vmatoa ("u", number), ent_size);
+      error (_("Size truncation prevents reading %" PRIu64
+              " elements of size %u\n"),
+            (uint64_t) number, ent_size);
       return NULL;
     }
 
@@ -10958,23 +10939,23 @@ get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_si
      attempting to allocate memory when the read is bound to fail.  */
   if (ent_size * number > filedata->file_size)
     {
-      error (_("Invalid number of dynamic entries: %s\n"),
-            bfd_vmatoa ("u", number));
+      error (_("Invalid number of dynamic entries: %" PRIu64 "\n"),
+            (uint64_t) number);
       return NULL;
     }
 
   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
   if (e_data == NULL)
     {
-      error (_("Out of memory reading %s dynamic entries\n"),
-            bfd_vmatoa ("u", number));
+      error (_("Out of memory reading %" PRIu64 " dynamic entries\n"),
+            (uint64_t) number);
       return NULL;
     }
 
   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
     {
-      error (_("Unable to read in %s bytes of dynamic data\n"),
-            bfd_vmatoa ("u", number * ent_size));
+      error (_("Unable to read in %" PRIu64 " bytes of dynamic data\n"),
+            (uint64_t) number * ent_size);
       free (e_data);
       return NULL;
     }
@@ -10982,8 +10963,8 @@ get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_si
   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
   if (i_data == NULL)
     {
-      error (_("Out of memory allocating space for %s dynamic entries\n"),
-            bfd_vmatoa ("u", number));
+      error (_("Out of memory allocating space for %" PRIu64 " dynamic entries\n"),
+            (uint64_t) number);
       free (e_data);
       return NULL;
     }
@@ -20741,8 +20722,8 @@ print_ia64_vms_note (Elf_Internal_Note * pnote)
        goto desc_size_fail;
       /* FIXME: Generate an error if descsz > 8 ?  */
 
-      printf ("0x%016" BFD_VMA_FMT "x\n",
-             (bfd_vma) byte_get ((unsigned char *) pnote->descdata, 8));
+      printf ("0x%016" PRIx64 "\n",
+             (uint64_t) byte_get ((unsigned char *) pnote->descdata, 8));
       break;
 
     case NT_VMS_LINKTIME:
@@ -20775,8 +20756,8 @@ print_ia64_vms_note (Elf_Internal_Note * pnote)
       printf (_("   Last modified  : "));
       print_vms_time (byte_get ((unsigned char *) pnote->descdata + 8, 8));
       printf (_("\n   Link flags  : "));
-      printf ("0x%016" BFD_VMA_FMT "x\n",
-             (bfd_vma) byte_get ((unsigned char *) pnote->descdata + 16, 8));
+      printf ("0x%016" PRIx64 "\n",
+             (uint64_t) byte_get ((unsigned char *) pnote->descdata + 16, 8));
       printf (_("   Header flags: 0x%08x\n"),
              (unsigned) byte_get ((unsigned char *) pnote->descdata + 24, 4));
       printf (_("   Image id    : %.*s\n"), maxlen - 32, pnote->descdata + 32);

diff --git a/binutils/size.c b/binutils/size.c
index 710402537e5ab64ce380b6af8fa964a8606ae30e..9bdafcb7ac54bfe2e8ea9c78e964cf8e38e7fe7d 100644 (file)
--- a/binutils/size.c
+++ b/binutils/size.c
@@ -440,10 +440,9 @@ size_number (bfd_size_type num)
 {
   char buffer[40];
 
-  sprintf (buffer,
-          (radix == decimal ? "%" BFD_VMA_FMT "u" :
-          ((radix == octal) ? "0%" BFD_VMA_FMT "o" : "0x%" BFD_VMA_FMT "x")),
-          num);
+  sprintf (buffer, (radix == decimal ? "%" PRIu64
+                   : radix == octal ? "0%" PRIo64 : "0x%" PRIx64),
+          (uint64_t) num);
 
   return strlen (buffer);
 }
@@ -453,10 +452,9 @@ rprint_number (int width, bfd_size_type num)
 {
   char buffer[40];
 
-  sprintf (buffer,
-          (radix == decimal ? "%" BFD_VMA_FMT "u" :
-          ((radix == octal) ? "0%" BFD_VMA_FMT "o" : "0x%" BFD_VMA_FMT "x")),
-          num);
+  sprintf (buffer, (radix == decimal ? "%" PRIu64
+                   : radix == octal ? "0%" PRIo64 : "0x%" PRIx64),
+          (uint64_t) num);
 
   printf ("%*s", width, buffer);
 }

diff --git a/gas/config/tc-arc.c b/gas/config/tc-arc.c
index a606078f5b89942daa720d45e045fc8f9667cd35..51afb79c8679b2478e2f2aaec555f51ad8ff5857 100644 (file)
--- a/gas/config/tc-arc.c
+++ b/gas/config/tc-arc.c
@@ -2815,11 +2815,11 @@ md_pcrel_from_section (fixS *fixP,
        }
     }
 
-  pr_debug ("pcrel from %"BFD_VMA_FMT"x + %lx = %"BFD_VMA_FMT"x, "
-           "symbol: %s (%"BFD_VMA_FMT"x)\n",
-           fixP->fx_frag->fr_address, fixP->fx_where, base,
+  pr_debug ("pcrel from %" PRIx64 " + %lx = %" PRIx64 ", "
+           "symbol: %s (%" PRIx64 ")\n",
+           (uint64_t) fixP->fx_frag->fr_address, fixP->fx_where, (uint64_t) base,
            fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "(null)",
-           fixP->fx_addsy ? S_GET_VALUE (fixP->fx_addsy) : 0);
+           fixP->fx_addsy ? (uint64_t) S_GET_VALUE (fixP->fx_addsy) : (uint64_t) 0);
 
   return base;
 }
@@ -3311,9 +3311,9 @@ md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
   table_entry = TC_GENERIC_RELAX_TABLE + fragP->fr_subtype;
 
   pr_debug ("%s:%d: md_convert_frag, subtype: %d, fix: %d, "
-           "var: %"BFD_VMA_FMT"d\n",
+           "var: %" PRId64 "\n",
            fragP->fr_file, fragP->fr_line,
-           fragP->fr_subtype, fix, fragP->fr_var);
+           fragP->fr_subtype, fix, (int64_t) fragP->fr_var);
 
   if (fragP->fr_subtype <= 0
       && fragP->fr_subtype >= arc_num_relax_opcodes)

diff --git a/gas/config/tc-i386.c b/gas/config/tc-i386.c
index 62d583be47ca29bf39d88ea10f1f47775fdb58bd..8a893c48b74a7b79f709954795abb59bd42c19b4 100644 (file)
--- a/gas/config/tc-i386.c
+++ b/gas/config/tc-i386.c
@@ -3185,8 +3185,8 @@ static void
 pe (expressionS *e)
 {
   fprintf (stdout, "    operation     %d\n", e->X_op);
-  fprintf (stdout, "    add_number    %" BFD_VMA_FMT "d (%" BFD_VMA_FMT "x)\n",
-          e->X_add_number, e->X_add_number);
+  fprintf (stdout, "    add_number    %" PRId64 " (%" PRIx64 ")\n",
+          (int64_t) e->X_add_number, (uint64_t) (valueT) e->X_add_number);
   if (e->X_add_symbol)
     {
       fprintf (stdout, "    add_symbol    ");

diff --git a/gas/config/tc-riscv.c b/gas/config/tc-riscv.c
index ecdffbef5892099881d61f6b567c808fea2053e3..34ce68e82529ac72bad182c7f9bfe626f111574e 100644 (file)
--- a/gas/config/tc-riscv.c
+++ b/gas/config/tc-riscv.c
@@ -1683,8 +1683,8 @@ load_const (int reg, expressionS *ep)
 
       md_assemblef ("slli x%d, x%d, 0x%x", reg, reg, shift);
       if (lower.X_add_number != 0)
-       md_assemblef ("addi x%d, x%d, %" BFD_VMA_FMT "d", reg, reg,
-                     lower.X_add_number);
+       md_assemblef ("addi x%d, x%d, %" PRId64, reg, reg,
+                     (int64_t) lower.X_add_number);
     }
   else
     {
@@ -1696,13 +1696,13 @@ load_const (int reg, expressionS *ep)
          /* Discard low part and zero-extend upper immediate.  */
          upper_imm = ((uint32_t)upper.X_add_number >> shift);
 
-         md_assemblef ("lui x%d, 0x%" BFD_VMA_FMT "x", reg, upper_imm);
+         md_assemblef ("lui x%d, 0x%" PRIx64, reg, (uint64_t) upper_imm);
          hi_reg = reg;
        }
 
       if (lower.X_add_number != 0 || hi_reg == 0)
-       md_assemblef ("%s x%d, x%d, %" BFD_VMA_FMT "d", ADD32_INSN, reg, hi_reg,
-                     lower.X_add_number);
+       md_assemblef ("%s x%d, x%d, %" PRId64, ADD32_INSN, reg, hi_reg,
+                     (int64_t) lower.X_add_number);
     }
 }
 

diff --git a/gas/macro.c b/gas/macro.c
index e2cfbee5439fd18bb3dc9e72d9b51e4a27550969..d799ba586e5aa4459a351298e5001d1059710bfd 100644 (file)
--- a/gas/macro.c
+++ b/gas/macro.c
@@ -419,7 +419,7 @@ get_any_string (size_t idx, sb *in, sb *out)
                               idx + 1,
                               in,
                               &val);
-         sprintf (buf, "%" BFD_VMA_FMT "d", val);
+         sprintf (buf, "%" PRId64, (int64_t) val);
          sb_add_string (out, buf);
        }
       else if (in->ptr[idx] == '"'

diff --git a/gprof/corefile.c b/gprof/corefile.c
index 2838d49f9d22926affc5a62bd351bbdf914d51cd..0ca32c48ed43afa77a3860666a2652ed2d32f34e 100644 (file)
--- a/gprof/corefile.c
+++ b/gprof/corefile.c
@@ -560,7 +560,9 @@ core_create_syms_from (const char * sym_table_file)
 
       sym_init (symtab.limit);
 
-      sscanf (address, "%" BFD_VMA_FMT "x", &(symtab.limit->addr) );
+      uint64_t addr;
+      sscanf (address, "%" SCNx64, &addr);
+      symtab.limit->addr = addr;
 
       symtab.limit->name = (char *) xmalloc (strlen (name) + 1);
       strcpy ((char *) symtab.limit->name, name);

diff --git a/ld/ldlang.c b/ld/ldlang.c
index 865c28bf6aae2f0ffef67577f1289dc06a4079d3..03daba6ef7f083c72f719aedc874f000049c166b 100644 (file)
--- a/ld/ldlang.c
+++ b/ld/ldlang.c
@@ -9632,16 +9632,16 @@ lang_ld_feature (char *str)
 /* Pretty print memory amount.  */
 
 static void
-lang_print_memory_size (bfd_vma sz)
+lang_print_memory_size (uint64_t sz)
 {
   if ((sz & 0x3fffffff) == 0)
-    printf ("%10" BFD_VMA_FMT "u GB", sz >> 30);
+    printf ("%10" PRIu64 " GB", sz >> 30);
   else if ((sz & 0xfffff) == 0)
-    printf ("%10" BFD_VMA_FMT "u MB", sz >> 20);
+    printf ("%10" PRIu64 " MB", sz >> 20);
   else if ((sz & 0x3ff) == 0)
-    printf ("%10" BFD_VMA_FMT "u KB", sz >> 10);
+    printf ("%10" PRIu64 " KB", sz >> 10);
   else
-    printf (" %10" BFD_VMA_FMT "u B", sz);
+    printf (" %10" PRIu64 " B", sz);
 }
 
 /* Implement --print-memory-usage: disply per region memory usage.  */
@@ -9658,7 +9658,7 @@ lang_print_memory_usage (void)
 
       printf ("%16s: ",r->name_list.name);
       lang_print_memory_size (used_length);
-      lang_print_memory_size ((bfd_vma) r->length);
+      lang_print_memory_size (r->length);
 
       if (r->length != 0)
        {

diff --git a/opcodes/s12z-dis.c b/opcodes/s12z-dis.c
index 972aad80bff79dfd094b426f5c6b59f2624ccba2..4c07d5a41f25a072818b1cdbba7b16c0678c9dde 100644 (file)
--- a/opcodes/s12z-dis.c
+++ b/opcodes/s12z-dis.c
@@ -205,14 +205,14 @@ operand_separator (struct disassemble_info *info)
    there is no symbol.  If BASE is non zero, then the a PC relative adddress is
    assumend (ie BASE is the value in the PC.  */
 static void
-decode_possible_symbol (bfd_vma addr, bfd_vma base,
+decode_possible_symbol (bfd_signed_vma addr, bfd_vma base,
                         struct disassemble_info *info, bool relative)
 {
-  const char *fmt = relative  ? "*%+" BFD_VMA_FMT "d" : "%" BFD_VMA_FMT "d";
+  const char *fmt = relative ? "*%+" PRId64 : "%" PRId64;
   asymbol *sym = info->symbol_at_address_func (addr + base, info);
 
   if (!sym)
-    (*info->fprintf_func) (info->stream, fmt, addr);
+    (*info->fprintf_func) (info->stream, fmt, (int64_t) addr);
   else
     (*info->fprintf_func) (info->stream, "%s", bfd_asymbol_name (sym));
 }