octets vs bytes changes for binutils

diff --git a/binutils/ChangeLog b/binutils/ChangeLog
index ab9f7f7283b136b15d39f928bbedc7876edc703d..7256abdb9ffbd992667ee3b1cb83dfcac92592c4 100644 (file)
--- a/binutils/ChangeLog
+++ b/binutils/ChangeLog
@@ -1,3 +1,9 @@
+2000-02-03  Timothy Wall <twall@redhat.com>
+
+       * binutils/objdump.c (dump_section_header, find_symbol_for_address,
+       show_line, disassemble_bytes, disassemble_data, dump_data):
+       distinguish between octets and bytes.
+       
 2000-01-27  Thomas de Lellis  <tdel@windriver.com>
 
         * nm.c (print_symbol_info_bsd): Use bfd_is_undefined_symclass to

diff --git a/binutils/objdump.c b/binutils/objdump.c
index f2baff21bf3c51f71d29e9482566560e81d055f0..97dcc8c0e67c5c65655f12c0b65765e3fb98fc02 100644 (file)
--- a/binutils/objdump.c
+++ b/binutils/objdump.c
@@ -337,10 +337,11 @@ dump_section_header (abfd, section, ignored)
      PTR ignored ATTRIBUTE_UNUSED;
 {
   char *comma = "";
+  int opb = bfd_octets_per_byte (abfd);
 
   printf ("%3d %-13s %08lx  ", section->index,
          bfd_get_section_name (abfd, section),
-         (unsigned long) bfd_section_size (abfd, section));
+         (unsigned long) bfd_section_size (abfd, section) / opb);
   printf_vma (bfd_get_section_vma (abfd, section));
   printf ("  ");
   printf_vma (section->lma);
@@ -739,6 +740,7 @@ find_symbol_for_address (abfd, sec, vma, require_sec, place)
   long min = 0;
   long max = sorted_symcount;
   long thisplace;
+  int opb = bfd_octets_per_byte (abfd); 
 
   if (sorted_symcount < 1)
     return NULL;
@@ -786,7 +788,7 @@ find_symbol_for_address (abfd, sec, vma, require_sec, place)
          || ((abfd->flags & HAS_RELOC) != 0
              && vma >= bfd_get_section_vma (abfd, sec)
              && vma < (bfd_get_section_vma (abfd, sec)
-                       + bfd_section_size (abfd, sec)))))
+                       + bfd_section_size (abfd, sec) / opb))))
     {
       long i;
 
@@ -1010,10 +1012,10 @@ skip_to_line (p, line, show)
    listing.  */
 
 static void
-show_line (abfd, section, off)
+show_line (abfd, section, addr_offset)
      bfd *abfd;
      asection *section;
-     bfd_vma off;
+     bfd_vma addr_offset;
 {
   CONST char *filename;
   CONST char *functionname;
@@ -1022,7 +1024,7 @@ show_line (abfd, section, off)
   if (! with_line_numbers && ! with_source_code)
     return;
 
-  if (! bfd_find_nearest_line (abfd, section, syms, off, &filename,
+  if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
                               &functionname, &line))
     return;
 
@@ -1231,31 +1233,33 @@ objdump_sprintf (va_alist)
 /* Disassemble some data in memory between given values.  */
 
 static void
-disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp,
+disassemble_bytes (info, disassemble_fn, insns, data, 
+                   start_offset, stop_offset, relppp,
                   relppend)
      struct disassemble_info *info;
      disassembler_ftype disassemble_fn;
      boolean insns;
      bfd_byte *data;
-     bfd_vma start;
-     bfd_vma stop;
+     bfd_vma start_offset;
+     bfd_vma stop_offset;
      arelent ***relppp;
      arelent **relppend;
 {
   struct objdump_disasm_info *aux;
   asection *section;
-  int bytes_per_line;
+  int octets_per_line;
   boolean done_dot;
   int skip_addr_chars;
-  bfd_vma i;
+  bfd_vma addr_offset;
+  int opb = info->octets_per_byte;
 
   aux = (struct objdump_disasm_info *) info->application_data;
   section = aux->sec;
 
   if (insns)
-    bytes_per_line = 4;
+    octets_per_line = 4;
   else
-    bytes_per_line = 16;
+    octets_per_line = 16;
 
   /* Figure out how many characters to skip at the start of an
      address, to make the disassembly look nicer.  We discard leading
@@ -1267,8 +1271,8 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp,
       char buf[30];
       char *s;
 
-      sprintf_vma (buf,
-                  section->vma + bfd_section_size (section->owner, section));
+      sprintf_vma (buf, section->vma + 
+                   bfd_section_size (section->owner, section) / opb);
       s = buf;
       while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
             && s[4] == '0')
@@ -1281,34 +1285,35 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp,
   info->insn_info_valid = 0;
 
   done_dot = false;
-  i = start;
-  while (i < stop)
+  addr_offset = start_offset;
+  while (addr_offset < stop_offset)
     {
       bfd_vma z;
-      int bytes = 0;
+      int octets = 0;
       boolean need_nl = false;
 
-      /* If we see more than SKIP_ZEROES bytes of zeroes, we just
+      /* If we see more than SKIP_ZEROES octets of zeroes, we just
          print `...'.  */
-      for (z = i; z < stop; z++)
+      for (z = addr_offset * opb; z < stop_offset * opb; z++)
        if (data[z] != 0)
          break;
       if (! disassemble_zeroes
          && (info->insn_info_valid == 0
              || info->branch_delay_insns == 0)
-         && (z - i >= SKIP_ZEROES
-             || (z == stop && z - i < SKIP_ZEROES_AT_END)))
+         && (z - addr_offset * opb >= SKIP_ZEROES
+             || (z == stop_offset * opb && 
+                  z - addr_offset * opb < SKIP_ZEROES_AT_END)))
        {
          printf ("\t...\n");
 
-         /* If there are more nonzero bytes to follow, we only skip
+         /* If there are more nonzero octets to follow, we only skip
              zeroes in multiples of 4, to try to avoid running over
              the start of an instruction which happens to start with
              zero.  */
-         if (z != stop)
-           z = i + ((z - i) &~ 3);
+         if (z != stop_offset * opb)
+           z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
 
-         bytes = z - i;
+         octets = z - addr_offset * opb;
        }
       else
        {
@@ -1320,13 +1325,13 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp,
          done_dot = false;
 
          if (with_line_numbers || with_source_code)
-           show_line (aux->abfd, section, i);
+           show_line (aux->abfd, section, addr_offset);
 
          if (! prefix_addresses)
            {
              char *s;
 
-             sprintf_vma (buf, section->vma + i);
+             sprintf_vma (buf, section->vma + addr_offset);
              for (s = buf + skip_addr_chars; *s == '0'; s++)
                *s = ' ';
              if (*s == '\0')
@@ -1336,7 +1341,7 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp,
          else
            {
              aux->require_sec = true;
-             objdump_print_address (section->vma + i, info);
+             objdump_print_address (section->vma + addr_offset, info);
              aux->require_sec = false;
              putchar (' ');
            }
@@ -1351,21 +1356,21 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp,
              info->bytes_per_line = 0;
              info->bytes_per_chunk = 0;
 
-             /* FIXME: This is wrong.  It tests the number of bytes
+             /* FIXME: This is wrong.  It tests the number of octets
                  in the last instruction, not the current one.  */
              if (*relppp < relppend
-                 && (**relppp)->address >= i
-                 && (**relppp)->address < i + bytes)
+                 && (**relppp)->address >= addr_offset
+                 && (**relppp)->address < addr_offset + octets / opb)
                info->flags = INSN_HAS_RELOC;
              else
                info->flags = 0;
 
-             bytes = (*disassemble_fn) (section->vma + i, info);
+             octets = (*disassemble_fn) (section->vma + addr_offset, info);
              info->fprintf_func = (fprintf_ftype) fprintf;
              info->stream = stdout;
              if (info->bytes_per_line != 0)
-               bytes_per_line = info->bytes_per_line;
-             if (bytes < 0)
+               octets_per_line = info->bytes_per_line;
+             if (octets < 0)
                {
                  if (sfile.current != sfile.buffer)
                    printf ("%s\n", sfile.buffer);
@@ -1377,18 +1382,18 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp,
            {
              bfd_vma j;
 
-             bytes = bytes_per_line;
-             if (i + bytes > stop)
-               bytes = stop - i;
+             octets = octets_per_line;
+             if (addr_offset + octets / opb > stop_offset)
+               octets = (stop_offset - addr_offset) * opb;
 
-             for (j = i; j < i + bytes; ++j)
+             for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
                {
                  if (isprint (data[j]))
-                   buf[j - i] = data[j];
+                   buf[j - addr_offset * opb] = data[j];
                  else
-                   buf[j - i] = '.';
+                   buf[j - addr_offset * opb] = '.';
                }
-             buf[j - i] = '\0';
+             buf[j - addr_offset * opb] = '\0';
            }
 
          if (prefix_addresses
@@ -1398,17 +1403,17 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp,
              bfd_vma j;
 
              /* If ! prefix_addresses and ! wide_output, we print
-                 bytes_per_line bytes per line.  */
-             pb = bytes;
-             if (pb > bytes_per_line && ! prefix_addresses && ! wide_output)
-               pb = bytes_per_line;
+                 octets_per_line octets per line.  */
+             pb = octets;
+             if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
+               pb = octets_per_line;
 
              if (info->bytes_per_chunk)
                bpc = info->bytes_per_chunk;
              else
                bpc = 1;
 
-             for (j = i; j < i + pb; j += bpc)
+             for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
                {
                  int k;
                  if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
@@ -1425,7 +1430,7 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp,
                    }
                }
 
-             for (; pb < bytes_per_line; pb += bpc)
+             for (; pb < octets_per_line; pb += bpc)
                {
                  int k;
 
@@ -1453,25 +1458,25 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp,
              ? show_raw_insn > 0
              : show_raw_insn >= 0)
            {
-             while (pb < bytes)
+             while (pb < octets)
                {
                  bfd_vma j;
                  char *s;
 
                  putchar ('\n');
-                 j = i + pb;
+                 j = addr_offset * opb + pb;
 
-                 sprintf_vma (buf, section->vma + j);
+                 sprintf_vma (buf, section->vma + j / opb);
                  for (s = buf + skip_addr_chars; *s == '0'; s++)
                    *s = ' ';
                  if (*s == '\0')
                    *--s = '0';
                  printf ("%s:\t", buf + skip_addr_chars);
 
-                 pb += bytes_per_line;
-                 if (pb > bytes)
-                   pb = bytes;
-                 for (; j < i + pb; j += bpc)
+                 pb += octets_per_line;
+                 if (pb > octets)
+                   pb = octets;
+                 for (; j < addr_offset * opb + pb; j += bpc)
                    {
                      int k;
 
@@ -1501,8 +1506,8 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp,
          && (section->flags & SEC_RELOC) != 0)
        {
          while ((*relppp) < relppend
-                && ((**relppp)->address >= (bfd_vma) i
-                    && (**relppp)->address < (bfd_vma) i + bytes))
+                && ((**relppp)->address >= (bfd_vma) addr_offset
+                    && (**relppp)->address < (bfd_vma) addr_offset + octets / opb))
            {
              arelent *q;
 
@@ -1553,7 +1558,7 @@ disassemble_bytes (info, disassemble_fn, insns, data, start, stop, relppp,
       if (need_nl)
        printf ("\n");
 
-      i += bytes;
+      addr_offset += octets / opb;
     }
 }
 
@@ -1563,11 +1568,12 @@ static void
 disassemble_data (abfd)
      bfd *abfd;
 {
-  long i;
+  long addr_offset;
   disassembler_ftype disassemble_fn;
   struct disassemble_info disasm_info;
   struct objdump_disasm_info aux;
   asection *section;
+  int opb = bfd_octets_per_byte (abfd);
 
   print_files = NULL;
   prev_functionname = NULL;
@@ -1589,6 +1595,7 @@ disassemble_data (abfd)
   aux.require_sec = false;
   disasm_info.print_address_func = objdump_print_address;
   disasm_info.symbol_at_address_func = objdump_symbol_at_address;
+  disasm_info.octets_per_byte = opb;
 
   if (machine != (char *) NULL)
     {
@@ -1646,7 +1653,7 @@ disassemble_data (abfd)
       arelent **relbuf = NULL;
       arelent **relpp = NULL;
       arelent **relppend = NULL;
-      long stop;
+      long stop_offset;
       asymbol *sym = NULL;
       long place = 0;
 
@@ -1709,37 +1716,37 @@ disassemble_data (abfd)
       disasm_info.buffer_length = datasize;
       if (start_address == (bfd_vma) -1
          || start_address < disasm_info.buffer_vma)
-       i = 0;
+       addr_offset = 0;
       else
-       i = start_address - disasm_info.buffer_vma;
+       addr_offset = start_address - disasm_info.buffer_vma;
       if (stop_address == (bfd_vma) -1)
-       stop = datasize;
+       stop_offset = datasize / opb;
       else
        {
          if (stop_address < disasm_info.buffer_vma)
-           stop = 0;
+           stop_offset = 0;
          else
-           stop = stop_address - disasm_info.buffer_vma;
-         if (stop > disasm_info.buffer_length)
-           stop = disasm_info.buffer_length;
+           stop_offset = stop_address - disasm_info.buffer_vma;
+         if (stop_offset > disasm_info.buffer_length / opb)
+           stop_offset = disasm_info.buffer_length / opb;
        }
 
-      sym = find_symbol_for_address (abfd, section, section->vma + i,
+      sym = find_symbol_for_address (abfd, section, section->vma + addr_offset,
                                     true, &place);
 
-      while (i < stop)
+      while (addr_offset < stop_offset)
        {
          asymbol *nextsym;
-         long nextstop;
+         long nextstop_offset;
          boolean insns;
          
-         if (sym != NULL && bfd_asymbol_value (sym) <= section->vma + i)
+         if (sym != NULL && bfd_asymbol_value (sym) <= section->vma + addr_offset)
            {
              int x;
 
              for (x = place;
                   (x < sorted_symcount
-                   && bfd_asymbol_value (sorted_syms[x]) <= section->vma + i);
+                   && bfd_asymbol_value (sorted_syms[x]) <= section->vma + addr_offset);
                   ++x)
                continue;
              disasm_info.symbols = & sorted_syms[place];
@@ -1752,13 +1759,13 @@ disassemble_data (abfd)
            {
              printf ("\n");
              objdump_print_addr_with_sym (abfd, section, sym,
-                                          section->vma + i,
+                                          section->vma + addr_offset,
                                           &disasm_info,
                                           false);
              printf (":\n");
            }
          
-         if (sym != NULL && bfd_asymbol_value (sym) > section->vma + i)
+         if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset)
            nextsym = sym;
          else if (sym == NULL)
            nextsym = NULL;
@@ -1779,19 +1786,19 @@ disassemble_data (abfd)
                nextsym = sorted_syms[place];
            }
          
-         if (sym != NULL && bfd_asymbol_value (sym) > section->vma + i)
+         if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset)
            {
-             nextstop = bfd_asymbol_value (sym) - section->vma;
-             if (nextstop > stop)
-               nextstop = stop;
+             nextstop_offset = bfd_asymbol_value (sym) - section->vma;
+             if (nextstop_offset > stop_offset)
+               nextstop_offset = stop_offset;
            }
          else if (nextsym == NULL)
-           nextstop = stop;
+           nextstop_offset = stop_offset;
          else
            {
-             nextstop = bfd_asymbol_value (nextsym) - section->vma;
-             if (nextstop > stop)
-               nextstop = stop;
+             nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
+             if (nextstop_offset > stop_offset)
+               nextstop_offset = stop_offset;
            }
          
          /* If a symbol is explicitly marked as being an object
@@ -1799,7 +1806,7 @@ disassemble_data (abfd)
             disassembling them.  */
          if (disassemble_all
              || sym == NULL
-             || bfd_asymbol_value (sym) > section->vma + i
+             || bfd_asymbol_value (sym) > section->vma + addr_offset
              || ((sym->flags & BSF_OBJECT) == 0
                  && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
                      == NULL)
@@ -1810,10 +1817,10 @@ disassemble_data (abfd)
          else
            insns = false;
          
-         disassemble_bytes (&disasm_info, disassemble_fn, insns, data, i,
-                            nextstop, &relpp, relppend);
+         disassemble_bytes (&disasm_info, disassemble_fn, insns, data, 
+                             addr_offset, nextstop_offset, &relpp, relppend);
          
-         i = nextstop;
+         addr_offset = nextstop_offset;
          sym = nextsym;
        }
       
@@ -2249,8 +2256,9 @@ dump_data (abfd)
   asection *section;
   bfd_byte *data = 0;
   bfd_size_type datasize = 0;
-  bfd_size_type i;
-  bfd_size_type start, stop;
+  bfd_size_type addr_offset;
+  bfd_size_type start_offset, stop_offset;
+  int opb = bfd_octets_per_byte (abfd);
 
   for (section = abfd->sections; section != NULL; section =
        section->next)
@@ -2274,28 +2282,31 @@ dump_data (abfd)
 
              if (start_address == (bfd_vma) -1
                  || start_address < section->vma)
-               start = 0;
+               start_offset = 0;
              else
-               start = start_address - section->vma;
+               start_offset = start_address - section->vma;
              if (stop_address == (bfd_vma) -1)
-               stop = bfd_section_size (abfd, section);
+               stop_offset = bfd_section_size (abfd, section) / opb;
              else
                {
                  if (stop_address < section->vma)
-                   stop = 0;
+                   stop_offset = 0;
                  else
-                   stop = stop_address - section->vma;
-                 if (stop > bfd_section_size (abfd, section))
-                   stop = bfd_section_size (abfd, section);
+                   stop_offset = stop_address - section->vma;
+                 if (stop_offset > bfd_section_size (abfd, section) / opb)
+                   stop_offset = bfd_section_size (abfd, section) / opb;
                }
-             for (i = start; i < stop; i += onaline)
+             for (addr_offset = start_offset; 
+                   addr_offset < stop_offset; addr_offset += onaline)
                {
                  bfd_size_type j;
 
-                 printf (" %04lx ", (unsigned long int) (i + section->vma));
-                 for (j = i; j < i + onaline; j++)
+                 printf (" %04lx ", (unsigned long int) 
+                          (addr_offset + section->vma));
+                 for (j = addr_offset * opb; 
+                       j < addr_offset * opb + onaline; j++)
                    {
-                     if (j < stop)
+                     if (j < stop_offset * opb)
                        printf ("%02x", (unsigned) (data[j]));
                      else
                        printf ("  ");
@@ -2304,9 +2315,9 @@ dump_data (abfd)
                    }
 
                  printf (" ");
-                 for (j = i; j < i + onaline; j++)
+                 for (j = addr_offset; j < addr_offset * opb + onaline; j++)
                    {
-                     if (j >= stop)
+                     if (j >= stop_offset * opb)
                        printf (" ");
                      else
                        printf ("%c", isprint (data[j]) ? data[j] : '.');

diff --git a/include/ChangeLog b/include/ChangeLog
index c526639d5f726c9d8b47bbfa8da8ffa3ac056547..062d73233b82e5c9cef14db9522d4c440362b4b6 100644 (file)
--- a/include/ChangeLog
+++ b/include/ChangeLog
@@ -1,3 +1,8 @@
+2000-02-03  Timothy Wall <twall@redhat.com>
+
+       * dis-asm.h (struct disassemble_info): Added octets_per_byte
+       field and initialize it to one (1).
+       
 2000-01-27  Nick Clifton  <nickc@redhat.com>
 
        * dis-asm.h: Add prototype for disassembler_usage().

diff --git a/include/dis-asm.h b/include/dis-asm.h
index 98a7d1737aafc2789702632899974121bf4a778e..8dc9b712e3fb71d60d00c56e1b7c18dc0d96bea2 100644 (file)
--- a/include/dis-asm.h
+++ b/include/dis-asm.h
@@ -121,6 +121,11 @@ typedef struct disassemble_info {
   int bytes_per_chunk;
   enum bfd_endian display_endian;
 
+  /* Number of octets per incremented target address 
+     Normally one, but some DSPs have byte sizes of 16 or 32 bits
+   */
+  int octets_per_byte;
+
   /* Results from instruction decoders.  Not all decoders yet support
      this information.  This info is set each time an instruction is
      decoded, and is only valid for the last such instruction.
@@ -229,6 +234,7 @@ extern int generic_symbol_at_address
   (INFO).arch = bfd_arch_unknown, \
   (INFO).mach = 0, \
   (INFO).endian = BFD_ENDIAN_UNKNOWN, \
+  (INFO).octets_per_byte = 1, \
   INIT_DISASSEMBLE_INFO_NO_ARCH(INFO, STREAM, FPRINTF_FUNC)
 
 /* Call this macro to initialize only the internal variables for the

diff --git a/opcodes/ChangeLog b/opcodes/ChangeLog
index cda0156132737e5ac23bdd39066bff0a5ca035d9..2b72067cb1c38359fabc803fae1ebf79dd62c193 100644 (file)
--- a/opcodes/ChangeLog
+++ b/opcodes/ChangeLog
@@ -1,3 +1,9 @@
+2000-02-03  Timothy Wall  <twall@redhat.com>   
+       
+       * dis-buf.c (buffer_read_memory):  Use octets_per_byte field
+       to adjust target address bounds checking and calculate the
+       appropriate octet offset into data.
+       
 2000-01-27  Nick Clifton  <nickc@redhat.com>
 
        * arm-dis.c: (parse_disassembler_option): Rename to

diff --git a/opcodes/dis-buf.c b/opcodes/dis-buf.c
index 523fe72789dbcfd939cd1cd13ed72e4562150d76..65b1edb3e66f32171b9032337187e8435551b5bc 100644 (file)
--- a/opcodes/dis-buf.c
+++ b/opcodes/dis-buf.c
@@ -29,11 +29,17 @@ buffer_read_memory (memaddr, myaddr, length, info)
      int length;
      struct disassemble_info *info;
 {
+  int opb = info->octets_per_byte;
+  int end_addr_offset = length / opb;
+  int max_addr_offset = info->buffer_length / opb; 
+  int octets = (memaddr - info->buffer_vma) * opb;
+
   if (memaddr < info->buffer_vma
-      || memaddr - info->buffer_vma + length > info->buffer_length)
+      || memaddr - info->buffer_vma + end_addr_offset > max_addr_offset)
     /* Out of bounds.  Use EIO because GDB uses it.  */
     return EIO;
-  memcpy (myaddr, info->buffer + (memaddr - info->buffer_vma), length);
+  memcpy (myaddr, info->buffer + octets, length);
+
   return 0;
 }