Changeset 609 for branches/GNU/src/binutils/bfd/ecofflink.c

Timestamp:

Aug 16, 2003, 6:59:22 PM (22 years ago)

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/bfd/ecofflink.c (modified) (97 diffs, 1 prop)

branches/GNU/src/binutils/bfd/ecofflink.c

@@ -1 +1 @@
 /* Routines to link ECOFF debugging information.
-   Copyright 1993, 1994, 1995, 1996, 1997, 2000
+   Copyright 1993, 1994, 1995, 1996, 1997, 2000, 2001, 2002
    Free Software Foundation, Inc.
    Written by Ian Lance Taylor, Cygnus Support, <ian@cygnus.com>.
 
-This file is part of BFD, the Binary File Descriptor library.
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   This file is part of BFD, the Binary File Descriptor library.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "bfd.h"
@@ -34 +34 @@
 
 
-static boolean ecoff_add_bytes PARAMS ((char **buf, char **bufend,
-                                        size_t need));
+static bfd_boolean ecoff_add_bytes
+  PARAMS ((char **buf, char **bufend, size_t need));
 static struct bfd_hash_entry *string_hash_newfunc
   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
            const char *));
-static void ecoff_align_debug PARAMS ((bfd *abfd,
-                                       struct ecoff_debug_info *debug,
-                                       const struct ecoff_debug_swap *swap));
-static boolean ecoff_write_symhdr PARAMS ((bfd *, struct ecoff_debug_info *,
-                                           const struct ecoff_debug_swap *,
-                                           file_ptr where));
-static int cmp_fdrtab_entry PARAMS ((const PTR, const PTR));
-static boolean mk_fdrtab PARAMS ((bfd *,
-                                  struct ecoff_debug_info * const,
-                                  const struct ecoff_debug_swap * const,
-                                  struct ecoff_find_line *));
-static long fdrtab_lookup PARAMS ((struct ecoff_find_line *, bfd_vma));
-static boolean lookup_line
+static void ecoff_align_debug
+  PARAMS ((bfd *abfd, struct ecoff_debug_info *debug,
+           const struct ecoff_debug_swap *swap));
+static bfd_boolean ecoff_write_symhdr
+  PARAMS ((bfd *, struct ecoff_debug_info *, const struct ecoff_debug_swap *,
+           file_ptr where));
+static int cmp_fdrtab_entry
+  PARAMS ((const PTR, const PTR));
+static bfd_boolean mk_fdrtab
+  PARAMS ((bfd *, struct ecoff_debug_info * const,
+           const struct ecoff_debug_swap * const, struct ecoff_find_line *));
+static long fdrtab_lookup
+  PARAMS ((struct ecoff_find_line *, bfd_vma));
+static bfd_boolean lookup_line
   PARAMS ((bfd *, struct ecoff_debug_info * const,
            const struct ecoff_debug_swap * const, struct ecoff_find_line *));
@@ -257 +258 @@
 /* Add bytes to a buffer.  Return success.  */
 
-static boolean
+static bfd_boolean
 ecoff_add_bytes (buf, bufend, need)
      char **buf;
@@ -276 +277 @@
         want = ALLOC_SIZE;
     }
-  newbuf = (char *) bfd_realloc (*buf, have + want);
+  newbuf = (char *) bfd_realloc (*buf, (bfd_size_type) have + want);
   if (newbuf == NULL)
-    return false;
+    return FALSE;
   *buf = newbuf;
   *bufend = *buf + have + want;
-  return true;
+  return TRUE;
 }
 
@@ -351 +352 @@
   unsigned long size;
   /* Whether this information comes from a file or not.  */
-  boolean filep;
+  bfd_boolean filep;
   union
     {
@@ -404 +405 @@
 /* Add a file entry to a shuffle list.  */
 
-static boolean add_file_shuffle PARAMS ((struct accumulate *,
-                                      struct shuffle **,
-                                      struct shuffle **, bfd *, file_ptr,
-                                      unsigned long));
-
-static boolean
+static bfd_boolean add_file_shuffle
+  PARAMS ((struct accumulate *, struct shuffle **, struct shuffle **,
+           bfd *, file_ptr, unsigned long));
+
+static bfd_boolean
 add_file_shuffle (ainfo, head, tail, input_bfd, offset, size)
      struct accumulate *ainfo;
@@ -429 +429 @@
       if ((*tail)->size > ainfo->largest_file_shuffle)
         ainfo->largest_file_shuffle = (*tail)->size;
-      return true;
+      return TRUE;
     }
 
@@ -437 +437 @@
     {
       bfd_set_error (bfd_error_no_memory);
-      return false;
+      return FALSE;
     }
   n->next = NULL;
   n->size = size;
-  n->filep = true;
+  n->filep = TRUE;
   n->u.file.input_bfd = input_bfd;
   n->u.file.offset = offset;
@@ -451 +451 @@
   if (size > ainfo->largest_file_shuffle)
     ainfo->largest_file_shuffle = size;
-  return true;
+  return TRUE;
 }
 
 /* Add a memory entry to a shuffle list.  */
 
-static boolean add_memory_shuffle PARAMS ((struct accumulate *,
-                                           struct shuffle **head,
-                                           struct shuffle **tail,
-                                           bfd_byte *data, unsigned long size));
-
-static boolean
+static bfd_boolean add_memory_shuffle
+  PARAMS ((struct accumulate *, struct shuffle **head, struct shuffle **tail,
+           bfd_byte *data, unsigned long size));
+
+static bfd_boolean
 add_memory_shuffle (ainfo, head, tail, data, size)
      struct accumulate *ainfo;
@@ -476 +475 @@
     {
       bfd_set_error (bfd_error_no_memory);
-      return false;
+      return FALSE;
     }
   n->next = NULL;
   n->size = size;
-  n->filep = false;
+  n->filep = FALSE;
   n->u.memory = (PTR) data;
   if (*head == (struct shuffle *) NULL)
@@ -487 +486 @@
     (*tail)->next = n;
   *tail = n;
-  return true;
+  return TRUE;
 }
 
@@ -501 +500 @@
 {
   struct accumulate *ainfo;
-
-  ainfo = (struct accumulate *) bfd_malloc (sizeof (struct accumulate));
+  bfd_size_type amt = sizeof (struct accumulate);
+
+  ainfo = (struct accumulate *) bfd_malloc (amt);
   if (!ainfo)
     return NULL;
@@ -579 +579 @@
    bfd_ecoff_debug_init.  */
 
-boolean
+bfd_boolean
 bfd_ecoff_debug_accumulate (handle, output_bfd, output_debug, output_swap,
                             input_bfd, input_debug, input_swap,
@@ -625 +625 @@
   long oldrfdbase = 0;
   bfd_byte *fdr_out;
+  bfd_size_type amt;
 
   /* Use section_adjust to hold the value to add to a symbol in a
@@ -665 +666 @@
   fdr_end = fdr_start + input_symhdr->ifdMax * fdr_add;
 
-  input_debug->ifdmap = (RFDT *) bfd_alloc (input_bfd,
-                                            (input_symhdr->ifdMax
-                                             * sizeof (RFDT)));
+  amt = input_symhdr->ifdMax;
+  amt *= sizeof (RFDT);
+  input_debug->ifdmap = (RFDT *) bfd_alloc (input_bfd, amt);
 
   sz = (input_symhdr->crfd + input_symhdr->ifdMax) * external_rfd_size;
@@ -674 +675 @@
     {
       bfd_set_error (bfd_error_no_memory);
-      return false;
+      return FALSE;
     }
   if (!add_memory_shuffle (ainfo, &ainfo->rfd, &ainfo->rfd_end, rfd_out, sz))
-    return false;
+    return FALSE;
 
   copied = 0;
@@ -716 +717 @@
           name = input_debug->ss + fdr.issBase + fdr.rss;
 
-          lookup = (char *) bfd_malloc (strlen (name) + 20);
+          lookup = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 20);
           if (lookup == NULL)
-            return false;
+            return FALSE;
           sprintf (lookup, "%s %lx %lx", name, fdr.csym, fdr.caux);
 
-          fh = string_hash_lookup (&ainfo->fdr_hash, lookup, true, true);
+          fh = string_hash_lookup (&ainfo->fdr_hash, lookup, TRUE, TRUE);
           free (lookup);
           if (fh == (struct string_hash_entry *) NULL)
-            return false;
+            return FALSE;
 
           if (fh->val != -1)
@@ -775 +776 @@
     {
       bfd_set_error (bfd_error_no_memory);
-      return false;
+      return FALSE;
     }
   if (!add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end, fdr_out, sz))
-    return false;
+    return FALSE;
   for (fdr_ptr = fdr_start, i = 0;
        fdr_ptr < fdr_end;
@@ -788 +789 @@
       bfd_byte *lraw_src;
       bfd_byte *lraw_end;
-      boolean fgotfilename;
+      bfd_boolean fgotfilename;
 
       if (input_debug->ifdmap[i] < output_symhdr->ifdMax)
@@ -824 +825 @@
       /* Swap in the local symbols, adjust their values, and swap them
          out again.  */
-      fgotfilename = false;
+      fgotfilename = FALSE;
       sz = fdr.csym * external_sym_size;
       sym_out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz);
@@ -830 +831 @@
         {
           bfd_set_error (bfd_error_no_memory);
-          return false;
+          return FALSE;
         }
       if (!add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end, sym_out,
                                sz))
-        return false;
+        return FALSE;
       lraw_src = ((bfd_byte *) input_debug->external_sym
                   + fdr.isymBase * input_swap->external_sym_size);
@@ -886 +887 @@
           if (! info->relocateable)
             {
-              boolean ffilename;
+              bfd_boolean ffilename;
               const char *name;
 
               if (! fgotfilename && internal_sym.iss == fdr.rss)
-                ffilename = true;
+                ffilename = TRUE;
               else
-                ffilename = false;
+                ffilename = FALSE;
 
               /* Hash the name into the string table.  */
@@ -902 +903 @@
                   struct string_hash_entry *sh;
 
-                  sh = string_hash_lookup (&ainfo->str_hash, name, true, true);
+                  sh = string_hash_lookup (&ainfo->str_hash, name, TRUE, TRUE);
                   if (sh == (struct string_hash_entry *) NULL)
-                    return false;
+                    return FALSE;
                   if (sh->val == -1)
                     {
@@ -922 +923 @@
                 {
                   fdr.rss = internal_sym.iss;
-                  fgotfilename = true;
+                  fgotfilename = TRUE;
                 }
             }
@@ -941 +942 @@
       if (fdr.cbLine > 0)
         {
+          file_ptr pos = input_symhdr->cbLineOffset + fdr.cbLineOffset;
           if (!add_file_shuffle (ainfo, &ainfo->line, &ainfo->line_end,
-                                 input_bfd,
-                                 input_symhdr->cbLineOffset + fdr.cbLineOffset,
-                                 fdr.cbLine))
-            return false;
+                                 input_bfd, pos, (unsigned long) fdr.cbLine))
+            return FALSE;
           fdr.ilineBase = output_symhdr->ilineMax;
           fdr.cbLineOffset = output_symhdr->cbLine;
@@ -953 +953 @@
       if (fdr.caux > 0)
         {
+          file_ptr pos = (input_symhdr->cbAuxOffset
+                          + fdr.iauxBase * sizeof (union aux_ext));
           if (!add_file_shuffle (ainfo, &ainfo->aux, &ainfo->aux_end,
-                                 input_bfd,
-                                 (input_symhdr->cbAuxOffset
-                                  + fdr.iauxBase * sizeof (union aux_ext)),
+                                 input_bfd, pos,
                                  fdr.caux * sizeof (union aux_ext)))
-            return false;
+            return FALSE;
           fdr.iauxBase = output_symhdr->iauxMax;
           output_symhdr->iauxMax += fdr.caux;
@@ -974 +974 @@
       else if (fdr.cbSs > 0)
         {
+          file_ptr pos = input_symhdr->cbSsOffset + fdr.issBase;
           if (!add_file_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end,
-                                 input_bfd,
-                                 input_symhdr->cbSsOffset + fdr.issBase,
-                                 fdr.cbSs))
-            return false;
+                                 input_bfd, pos, (unsigned long) fdr.cbSs))
+            return FALSE;
           fdr.issBase = output_symhdr->issMax;
           output_symhdr->issMax += fdr.cbSs;
@@ -993 +992 @@
           if (fdr.cpd > 0)
             {
+              file_ptr pos = (input_symhdr->cbPdOffset
+                              + fdr.ipdFirst * external_pdr_size);
+              unsigned long size = fdr.cpd * external_pdr_size;
               if (!add_file_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end,
-                                     input_bfd,
-                                     (input_symhdr->cbPdOffset
-                                      + fdr.ipdFirst * external_pdr_size),
-                                     fdr.cpd * external_pdr_size))
-                return false;
+                                     input_bfd, pos, size))
+                return FALSE;
             }
           BFD_ASSERT (external_opt_size == input_swap->external_opt_size);
           if (fdr.copt > 0)
             {
+              file_ptr pos = (input_symhdr->cbOptOffset
+                              + fdr.ioptBase * external_opt_size);
+              unsigned long size = fdr.copt * external_opt_size;
               if (!add_file_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end,
-                                     input_bfd,
-                                     (input_symhdr->cbOptOffset
-                                      + fdr.ioptBase * external_opt_size),
-                                     fdr.copt * external_opt_size))
-                return false;
+                                     input_bfd, pos, size))
+                return FALSE;
             }
         }
@@ -1031 +1030 @@
             {
               bfd_set_error (bfd_error_no_memory);
-              return false;
+              return FALSE;
             }
           if (!add_memory_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end, out,
                                    sz))
-            return false;
+            return FALSE;
           for (; in < end; in += insz, out += outsz)
             {
@@ -1072 +1071 @@
             {
               bfd_set_error (bfd_error_no_memory);
-              return false;
+              return FALSE;
             }
           if (!add_memory_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end, out,
                                    sz))
-            return false;
+            return FALSE;
           for (; in < end; in += insz, out += outsz)
             {
@@ -1108 +1107 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -1114 +1113 @@
    Return the offset from the fdr string base.  */
 
-static long ecoff_add_string PARAMS ((struct accumulate *,
-                                      struct bfd_link_info *,
-                                      struct ecoff_debug_info *,
-                                      FDR *fdr, const char *string));
+static long ecoff_add_string
+  PARAMS ((struct accumulate *, struct bfd_link_info *,
+           struct ecoff_debug_info *, FDR *fdr, const char *string));
 
 static long
@@ -1146 +1144 @@
       struct string_hash_entry *sh;
 
-      sh = string_hash_lookup (&ainfo->str_hash, string, true, true);
+      sh = string_hash_lookup (&ainfo->str_hash, string, TRUE, TRUE);
       if (sh == (struct string_hash_entry *) NULL)
         return -1;
@@ -1168 +1166 @@
 /* Add debugging information from a non-ECOFF file.  */
 
-boolean
+bfd_boolean
 bfd_ecoff_debug_accumulate_other (handle, output_bfd, output_debug,
                                   output_swap, input_bfd, info)
@@ -1205 +1203 @@
   fdr.cbSs = 0;
   fdr.rss = ecoff_add_string (ainfo, info, output_debug, &fdr,
-                              bfd_get_filename (input_bfd));
+                              bfd_archive_filename (input_bfd));
   if (fdr.rss == -1)
-    return false;
+    return FALSE;
   fdr.isymBase = output_symhdr->isymMax;
 
@@ -1213 +1211 @@
   symsize = bfd_get_symtab_upper_bound (input_bfd);
   if (symsize < 0)
-    return false;
-  symbols = (asymbol **) bfd_alloc (output_bfd, symsize);
+    return FALSE;
+  symbols = (asymbol **) bfd_alloc (output_bfd, (bfd_size_type) symsize);
   if (symbols == (asymbol **) NULL)
-    return false;
+    return FALSE;
   symcount = bfd_canonicalize_symtab (input_bfd, symbols);
   if (symcount < 0)
-    return false;
+    return FALSE;
   sym_end = symbols + symcount;
 
@@ -1237 +1235 @@
 
       if (internal_sym.iss == -1)
-        return false;
+        return FALSE;
       if (bfd_is_com_section ((*sym_ptr)->section)
           || bfd_is_und_section ((*sym_ptr)->section))
@@ -1254 +1252 @@
         {
           bfd_set_error (bfd_error_no_memory);
-          return false;
+          return FALSE;
         }
       (*swap_sym_out) (output_bfd, &internal_sym, external_sym);
       add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end,
-                          external_sym, output_swap->external_sym_size);
+                          external_sym,
+                          (unsigned long) output_swap->external_sym_size);
       ++fdr.csym;
       ++output_symhdr->isymMax;
@@ -1274 +1273 @@
     {
       bfd_set_error (bfd_error_no_memory);
-      return false;
+      return FALSE;
     }
   (*output_swap->swap_fdr_out) (output_bfd, &fdr, external_fdr);
   add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end,
-                      external_fdr, output_swap->external_fdr_size);
+                      external_fdr,
+                      (unsigned long) output_swap->external_fdr_size);
 
   ++output_symhdr->ifdMax;
 
-  return true;
+  return TRUE;
 }
 
@@ -1290 +1290 @@
    this interface, so that must be changed to do something else.  */
 
-boolean
+bfd_boolean
 bfd_ecoff_debug_externals (abfd, debug, swap, relocateable, get_extr,
                            set_index)
@@ -1296 +1296 @@
      struct ecoff_debug_info *debug;
      const struct ecoff_debug_swap *swap;
-     boolean relocateable;
-     boolean (*get_extr) PARAMS ((asymbol *, EXTR *));
+     bfd_boolean relocateable;
+     bfd_boolean (*get_extr) PARAMS ((asymbol *, EXTR *));
      void (*set_index) PARAMS ((asymbol *, bfd_size_type));
 {
@@ -1306 +1306 @@
   sym_ptr_ptr = bfd_get_outsymbols (abfd);
   if (sym_ptr_ptr == NULL)
-    return true;
+    return TRUE;
 
   for (c = bfd_get_symcount (abfd); c > 0; c--, sym_ptr_ptr++)
@@ -1316 +1316 @@
 
       /* Get the external symbol information.  */
-      if ((*get_extr) (sym_ptr, &esym) == false)
+      if (! (*get_extr) (sym_ptr, &esym))
         continue;
 
       /* If we're producing an executable, move common symbols into
          bss.  */
-      if (relocateable == false)
+      if (! relocateable)
         {
           if (esym.asym.sc == scCommon)
@@ -1351 +1351 @@
       if (! bfd_ecoff_debug_one_external (abfd, debug, swap,
                                           sym_ptr->name, &esym))
-        return false;
-    }
-
-  return true;
+        return FALSE;
+    }
+
+  return TRUE;
 }
 
 /* Add a single external symbol to the debugging information.  */
 
-boolean
+bfd_boolean
 bfd_ecoff_debug_one_external (abfd, debug, swap, name, esym)
      bfd *abfd;
@@ -1378 +1378 @@
       < symhdr->issExtMax + namelen + 1)
     {
-      if (ecoff_add_bytes ((char **) &debug->ssext,
-                           (char **) &debug->ssext_end,
-                           symhdr->issExtMax + namelen + 1)
-          == false)
-        return false;
+      if (! ecoff_add_bytes ((char **) &debug->ssext,
+                             (char **) &debug->ssext_end,
+                             symhdr->issExtMax + namelen + 1))
+        return FALSE;
     }
   if ((size_t) ((char *) debug->external_ext_end
@@ -1388 +1387 @@
       < (symhdr->iextMax + 1) * external_ext_size)
     {
-      if (ecoff_add_bytes ((char **) &debug->external_ext,
-                           (char **) &debug->external_ext_end,
-                           (symhdr->iextMax + 1) * external_ext_size)
-          == false)
-        return false;
+      if (! ecoff_add_bytes ((char **) &debug->external_ext,
+                             (char **) &debug->external_ext_end,
+                             (symhdr->iextMax + 1) * (size_t) external_ext_size))
+        return FALSE;
     }
 
@@ -1406 +1404 @@
   symhdr->issExtMax += namelen + 1;
 
-  return true;
+  return TRUE;
 }
 
@@ -1507 +1505 @@
    correctly.  */
 
-static boolean
+static bfd_boolean
 ecoff_write_symhdr (abfd, debug, swap, where)
      bfd *abfd;
@@ -1521 +1519 @@
   /* Go to the right location in the file.  */
   if (bfd_seek (abfd, where, SEEK_SET) != 0)
-    return false;
+    return FALSE;
 
   where += swap->external_hdr_size;
@@ -1550 +1548 @@
 #undef SET
 
-  buff = (PTR) bfd_malloc ((size_t) swap->external_hdr_size);
+  buff = (PTR) bfd_malloc (swap->external_hdr_size);
   if (buff == NULL && swap->external_hdr_size != 0)
     goto error_return;
 
   (*swap->swap_hdr_out) (abfd, symhdr, buff);
-  if (bfd_write (buff, 1, swap->external_hdr_size, abfd)
+  if (bfd_bwrite (buff, swap->external_hdr_size, abfd)
       != swap->external_hdr_size)
     goto error_return;
@@ -1561 +1559 @@
   if (buff != NULL)
     free (buff);
-  return true;
+  return TRUE;
  error_return:
   if (buff != NULL)
     free (buff);
-  return false;
+  return FALSE;
 }
 
@@ -1574 +1572 @@
    symbolic header.  */
 
-boolean
+bfd_boolean
 bfd_ecoff_write_debug (abfd, debug, swap, where)
      bfd *abfd;
@@ -1584 +1582 @@
 
   if (! ecoff_write_symhdr (abfd, debug, swap, where))
-    return false;
+    return FALSE;
 
 #define WRITE(ptr, count, size, offset) \
   BFD_ASSERT (symhdr->offset == 0 \
               || (bfd_vma) bfd_tell (abfd) == symhdr->offset); \
-  if (bfd_write ((PTR) debug->ptr, size, symhdr->count, abfd) \
+  if (bfd_bwrite ((PTR) debug->ptr, (bfd_size_type) size * symhdr->count, abfd)\
       != size * symhdr->count) \
-    return false;
+    return FALSE;
 
   WRITE (line, cbLine, sizeof (unsigned char), cbLineOffset);
@@ -1598 +1596 @@
   WRITE (external_sym, isymMax, swap->external_sym_size, cbSymOffset);
   WRITE (external_opt, ioptMax, swap->external_opt_size, cbOptOffset);
-  WRITE (external_aux, iauxMax, sizeof (union aux_ext), cbAuxOffset);
+  WRITE (external_aux, iauxMax, (bfd_size_type) sizeof (union aux_ext),
+         cbAuxOffset);
   WRITE (ss, issMax, sizeof (char), cbSsOffset);
   WRITE (ssext, issExtMax, sizeof (char), cbSsExtOffset);
@@ -1606 +1605 @@
 #undef WRITE
 
-  return true;
+  return TRUE;
 }
 
 /* Write out a shuffle list.  */
 
-static boolean ecoff_write_shuffle PARAMS ((bfd *,
-                                            const struct ecoff_debug_swap *,
-                                            struct shuffle *, PTR space));
-
-static boolean
+static bfd_boolean ecoff_write_shuffle
+  PARAMS ((bfd *, const struct ecoff_debug_swap *, struct shuffle *,
+           PTR space));
+
+static bfd_boolean
 ecoff_write_shuffle (abfd, swap, shuffle, space)
      bfd *abfd;
@@ -1630 +1629 @@
       if (! l->filep)
         {
-          if (bfd_write (l->u.memory, 1, l->size, abfd) != l->size)
-            return false;
+          if (bfd_bwrite (l->u.memory, (bfd_size_type) l->size, abfd)
+              != l->size)
+            return FALSE;
         }
       else
         {
           if (bfd_seek (l->u.file.input_bfd, l->u.file.offset, SEEK_SET) != 0
-              || bfd_read (space, 1, l->size, l->u.file.input_bfd) != l->size
-              || bfd_write (space, 1, l->size, abfd) != l->size)
-            return false;
+              || bfd_bread (space, (bfd_size_type) l->size,
+                           l->u.file.input_bfd) != l->size
+              || bfd_bwrite (space, (bfd_size_type) l->size, abfd) != l->size)
+            return FALSE;
         }
       total += l->size;
@@ -1649 +1650 @@
 
       i = swap->debug_align - (total & (swap->debug_align - 1));
-      s = (bfd_byte *) bfd_malloc (i);
+      s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i);
       if (s == NULL && i != 0)
-        return false;
-
-      memset ((PTR) s, 0, i);
-      if (bfd_write ((PTR) s, 1, i, abfd) != i)
+        return FALSE;
+
+      if (bfd_bwrite ((PTR) s, (bfd_size_type) i, abfd) != i)
         {
           free (s);
-          return false;
+          return FALSE;
         }
       free (s);
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -1668 +1668 @@
    information.  */
 
-boolean
+bfd_boolean
 bfd_ecoff_write_accumulated_debug (handle, abfd, debug, swap, info, where)
      PTR handle;
@@ -1679 +1679 @@
   struct accumulate *ainfo = (struct accumulate *) handle;
   PTR space = NULL;
+  bfd_size_type amt;
 
   if (! ecoff_write_symhdr (abfd, debug, swap, where))
     goto error_return;
 
-  space = (PTR) bfd_malloc (ainfo->largest_file_shuffle);
+  amt = ainfo->largest_file_shuffle;
+  space = (PTR) bfd_malloc (amt);
   if (space == NULL && ainfo->largest_file_shuffle != 0)
     goto error_return;
@@ -1710 +1712 @@
       BFD_ASSERT (ainfo->ss == (struct shuffle *) NULL);
       null = 0;
-      if (bfd_write ((PTR) &null, 1, 1, abfd) != 1)
+      if (bfd_bwrite ((PTR) &null, (bfd_size_type) 1, abfd) != 1)
         goto error_return;
       total = 1;
@@ -1721 +1723 @@
 
           len = strlen (sh->root.string);
-          if (bfd_write ((PTR) sh->root.string, 1, len + 1, abfd) != len + 1)
+          amt = len + 1;
+          if (bfd_bwrite ((PTR) sh->root.string, amt, abfd) != amt)
             goto error_return;
           total += len + 1;
@@ -1732 +1735 @@
 
           i = swap->debug_align - (total & (swap->debug_align - 1));
-          s = (bfd_byte *) bfd_malloc (i);
+          s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i);
           if (s == NULL && i != 0)
             goto error_return;
-          memset ((PTR) s, 0, i);
-          if (bfd_write ((PTR) s, 1, i, abfd) != i)
+
+          if (bfd_bwrite ((PTR) s, (bfd_size_type) i, abfd) != i)
             {
               free (s);
@@ -1747 +1750 @@
   /* The external strings and symbol are not converted over to using
      shuffles.  FIXME: They probably should be.  */
-  if (bfd_write (debug->ssext, 1, debug->symbolic_header.issExtMax, abfd)
-      != (bfd_size_type) debug->symbolic_header.issExtMax)
+  amt = debug->symbolic_header.issExtMax;
+  if (bfd_bwrite (debug->ssext, amt, abfd) != amt)
     goto error_return;
   if ((debug->symbolic_header.issExtMax & (swap->debug_align - 1)) != 0)
@@ -1757 +1760 @@
       i = (swap->debug_align
            - (debug->symbolic_header.issExtMax & (swap->debug_align - 1)));
-      s = (bfd_byte *) bfd_malloc (i);
+      s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i);
       if (s == NULL && i != 0)
         goto error_return;
-      memset ((PTR) s, 0, i);
-      if (bfd_write ((PTR) s, 1, i, abfd) != i)
+
+      if (bfd_bwrite ((PTR) s, (bfd_size_type) i, abfd) != i)
         {
           free (s);
@@ -1777 +1780 @@
                   == (bfd_vma) bfd_tell (abfd)));
 
-  if (bfd_write (debug->external_ext, swap->external_ext_size,
-                 debug->symbolic_header.iextMax, abfd)
-      != debug->symbolic_header.iextMax * swap->external_ext_size)
+  amt = debug->symbolic_header.iextMax * swap->external_ext_size;
+  if (bfd_bwrite (debug->external_ext, amt, abfd) != amt)
     goto error_return;
 
   if (space != NULL)
     free (space);
-  return true;
+  return TRUE;
 
  error_return:
   if (space != NULL)
     free (space);
-  return false;
+  return FALSE;
 }
 
@@ -1821 +1823 @@
    search.  */
 
-static boolean
+static bfd_boolean
 mk_fdrtab (abfd, debug_info, debug_swap, line_info)
      bfd *abfd;
@@ -1832 +1834 @@
   FDR *fdr_start;
   FDR *fdr_end;
-  boolean stabs;
+  bfd_boolean stabs;
   long len;
+  bfd_size_type amt;
 
   fdr_start = debug_info->fdr;
   fdr_end = fdr_start + debug_info->symbolic_header.ifdMax;
 
-  /* First, let's see how long the table needs to be: */
+  /* First, let's see how long the table needs to be.  */
   for (len = 0, fdr_ptr = fdr_start; fdr_ptr < fdr_end; fdr_ptr++)
     {
-      if (fdr_ptr->cpd == 0)    /* skip FDRs that have no PDRs */
+      if (fdr_ptr->cpd == 0)    /* Skip FDRs that have no PDRs.  */
         continue;
       ++len;
     }
 
-  /* Now, create and fill in the table: */
-
-  line_info->fdrtab = ((struct ecoff_fdrtab_entry*)
-                       bfd_zalloc (abfd,
-                                   len * sizeof (struct ecoff_fdrtab_entry)));
+  /* Now, create and fill in the table.  */
+  amt = (bfd_size_type) len * sizeof (struct ecoff_fdrtab_entry);
+  line_info->fdrtab = (struct ecoff_fdrtab_entry*) bfd_zalloc (abfd, amt);
   if (line_info->fdrtab == NULL)
-    return false;
+    return FALSE;
   line_info->fdrtab_len = len;
 
@@ -1864 +1865 @@
          a file with stabs debugging information, the second local
          symbol is named @stabs.  */
-      stabs = false;
+      stabs = FALSE;
       if (fdr_ptr->csym >= 2)
         {
@@ -1871 +1872 @@
 
           sym_ptr = ((char *) debug_info->external_sym
-                     + (fdr_ptr->isymBase + 1)*debug_swap->external_sym_size);
+                     + (fdr_ptr->isymBase + 1) * debug_swap->external_sym_size);
           (*debug_swap->swap_sym_in) (abfd, sym_ptr, &sym);
           if (strcmp (debug_info->ss + fdr_ptr->issBase + sym.iss,
                       STABS_SYMBOL) == 0)
-            stabs = true;
+            stabs = TRUE;
         }
 
       if (!stabs)
         {
-          bfd_size_type external_pdr_size;
-          char *pdr_ptr;
-          PDR pdr;
-
-          external_pdr_size = debug_swap->external_pdr_size;
-
-          pdr_ptr = ((char *) debug_info->external_pdr
-                     + fdr_ptr->ipdFirst * external_pdr_size);
-          (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr);
+          /* eraxxon: There are at least two problems with this computation:
+             1) PDRs do *not* contain offsets but full vma's; and typically the
+             address of the first PDR is the address of the FDR, which will
+             make (most) of the results of the original computation 0!
+             2) Once in a wacky while, the Compaq compiler generated PDR
+             addresses do not equal the FDR vma, but they (the PDR address)
+             are still vma's and not offsets.  Cf. comments in
+             'lookup_line'.  */
+#if 0
+            bfd_size_type external_pdr_size;
+            char *pdr_ptr;
+            PDR pdr;
+            
+            external_pdr_size = debug_swap->external_pdr_size;
+            
+            pdr_ptr = ((char *) debug_info->external_pdr
+                      + fdr_ptr->ipdFirst * external_pdr_size);
+            (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr);
           /* The address of the first PDR is the offset of that
              procedure relative to the beginning of file FDR.  */
-          tab->base_addr = fdr_ptr->adr - pdr.adr;
+            tab->base_addr = fdr_ptr->adr - pdr.adr;
+#else
+          /* The address of the first PDR is the offset of that
+             procedure relative to the beginning of file FDR.  */
+          tab->base_addr = fdr_ptr->adr; 
+#endif
         }
       else
         {
           /* XXX I don't know about stabs, so this is a guess
-             (davidm@cs.arizona.edu): */
+             (davidm@cs.arizona.edu).  */
           tab->base_addr = fdr_ptr->adr;
         }
@@ -1907 +1922 @@
      static functions in include files), where this does not hold.
      Use "odump -PFv" to verify...  */
-  qsort ((PTR) line_info->fdrtab, len,
+  qsort ((PTR) line_info->fdrtab, (size_t) len,
          sizeof (struct ecoff_fdrtab_entry), cmp_fdrtab_entry);
 
-  return true;
+  return TRUE;
 }
 
@@ -1940 +1955 @@
         low = mid + 1;
     }
+
+  /* eraxxon: at this point 'offset' is either lower than the lowest entry or
+     higher than the highest entry. In the former case high = low = mid = 0;
+     we want to return -1.  In the latter case, low = high and mid = low - 1;
+     we want to return the index of the highest entry.  Only in former case
+     will the following 'catch-all' test be true.  */
   ++mid;
 
-  /* last entry is catch-all for all higher addresses: */
+  /* Last entry is catch-all for all higher addresses.  */
   if (offset < tab[mid].base_addr)
     return -1;
@@ -1948 +1969 @@
  find_min:
 
+  /* eraxxon: There may be multiple FDRs in the table with the
+     same base_addr; make sure that we are at the first one.  */
   while (mid > 0 && tab[mid - 1].base_addr == tab[mid].base_addr)
     --mid;
@@ -1957 +1980 @@
    LINE_INFO->cache.  */
 
-static boolean
+static bfd_boolean
 lookup_line (abfd, debug_info, debug_swap, line_info)
      bfd *abfd;
@@ -1966 +1989 @@
   struct ecoff_fdrtab_entry *tab;
   bfd_vma offset;
-  boolean stabs;
+  bfd_boolean stabs;
   FDR *fdr_ptr;
   int i;
 
+  /* eraxxon: note that 'offset' is the full vma, not a section offset.  */
   offset = line_info->cache.start;
 
@@ -1976 +2000 @@
   if (line_info->fdrtab == NULL
       && !mk_fdrtab (abfd, debug_info, debug_swap, line_info))
-    return false;
+    return FALSE;
 
   tab = line_info->fdrtab;
 
-  /* find first FDR for address OFFSET */
+  /* Find first FDR for address OFFSET.  */
   i = fdrtab_lookup (line_info, offset);
   if (i < 0)
-    return false;               /* no FDR, no fun...  */
+    return FALSE;               /* no FDR, no fun...  */
+  
+  /* eraxxon: 'fdrtab_lookup' doesn't give what we want, at least for Compaq's
+     C++ compiler 6.2.  Consider three FDRs with starting addresses of x, y,
+     and z, respectively, such that x < y < z.  Assume further that
+     y < 'offset' < z.  It is possble at times that the PDR for 'offset' is
+     associated with FDR x and *not* with FDR y.  Erg!!
+
+     From a binary dump of my C++ test case 'moo' using Compaq's coffobjanl
+     (output format has been edited for our purposes):
+
+     FDR [2]: (main.C): First instruction: 0x12000207c <x>
+       PDR [5] for File [2]: LoopTest__Xv                 <0x1200020a0> (a)
+       PDR [7] for File [2]: foo__Xv                      <0x120002168>
+     FDR [1]: (-1):     First instruction: 0x1200020e8 <y>
+       PDR [3] for File [1]:                              <0x120001ad0> (b)
+     FDR [6]: (-1):     First instruction: 0x1200026f0 <z>
+
+     (a) In the case of PDR5, the vma is such that the first few instructions
+     of the procedure can be found.  But since the size of this procedure is
+     160b, the vma will soon cross into the 'address space' of FDR1 and no
+     debugging info will be found.  How repugnant!
+
+     (b) It is also possible for a PDR to have a *lower* vma than its associated
+     FDR; see FDR1 and PDR3.  Gross!
+
+     Since the FDRs that are causing so much havok (in this case) 1) do not
+     describe actual files (fdr.rss == -1), and 2) contain only compiler
+     genarated routines, I thought a simple fix would be to exclude them from
+     the FDR table in 'mk_fdrtab'.  But, besides not knowing for certain
+     whether this would be correct, it creates an additional problem.  If we
+     happen to ask for source file info on a compiler generated (procedure)
+     symbol -- which is still in the symbol table -- the result can be
+     information from a real procedure!  This is because compiler generated
+     procedures with vma's higher than the last FDR in the fdr table will be
+     associated with a PDR from this FDR, specifically the PDR with the
+     highest vma.  This wasn't a problem before, because each procedure had a
+     PDR.  (Yes, this problem could be eliminated if we kept the size of the
+     last PDR around, but things are already getting ugly).
+
+     Probably, a better solution would be to have a sorted PDR table.  Each
+     PDR would have a pointer to its FDR so file information could still be
+     obtained.  A FDR table could still be constructed if necessary -- since
+     it only contains pointers, not much extra memory would be used -- but
+     the PDR table would be searched to locate debugging info.
+
+     There is still at least one remaining issue.  Sometimes a FDR can have a
+     bogus name, but contain PDRs that should belong to another FDR with a
+     real name.  E.g:
+
+     FDR [3]: 0000000120001b50 (/home/.../Array.H~alt~deccxx_5E5A62AD)
+       PDR [a] for File [3]: 0000000120001b50
+       PDR [b] for File [3]: 0000000120001cf0
+       PDR [c] for File [3]: 0000000120001dc8
+       PDR [d] for File [3]: 0000000120001e40
+       PDR [e] for File [3]: 0000000120001eb8
+       PDR [f] for File [3]: 0000000120001f4c
+     FDR [4]: 0000000120001b50 (/home/.../Array.H)
+
+     Here, FDR4 has the correct name, but should (seemingly) contain PDRa-f.
+     The symbol table for PDR4 does contain symbols for PDRa-f, but so does
+     the symbol table for FDR3.  However the former is different; perhaps this
+     can be detected easily. (I'm not sure at this point.)  This problem only
+     seems to be associated with files with templates.  I am assuming the idea
+     is that there is a 'fake' FDR (with PDRs) for each differently typed set
+     of templates that must be generated.  Currently, FDR4 is completely
+     excluded from the FDR table in 'mk_fdrtab' because it contains no PDRs.
+
+     Since I don't have time to prepare a real fix for this right now, be
+     prepared for 'A Horrible Hack' to force the inspection of all non-stabs
+     FDRs.  It's coming...  */
   fdr_ptr = tab[i].fdr;
 
@@ -1989 +2083 @@
      file with stabs debugging information, the second local symbol is
      named @stabs.  */
-  stabs = false;
+  stabs = FALSE;
   if (fdr_ptr->csym >= 2)
     {
@@ -2000 +2094 @@
       if (strcmp (debug_info->ss + fdr_ptr->issBase + sym.iss,
                   STABS_SYMBOL) == 0)
-        stabs = true;
+        stabs = TRUE;
     }
 
@@ -2009 +2103 @@
       char *best_pdr = NULL;
       FDR *best_fdr;
-      bfd_vma best_dist = ~0;
+      bfd_signed_vma best_dist = -1;
       PDR pdr;
       unsigned char *line_ptr;
@@ -2071 +2165 @@
       external_pdr_size = debug_swap->external_pdr_size;
 
-      /* Make offset relative to object file's start-address: */
+#if 0 /* eraxxon: PDR addresses (pdr.adr) are not relative to FDRs!
+         Leave 'offset' alone.  */
+      /* Make offset relative to object file's start-address.  */
       offset -= tab[i].base_addr;
+#endif
+      /* eraxxon: The Horrible Hack: Because of the problems above, set 'i'
+         to 0 so we look through all FDRs.
+
+         Because FDR's without any symbols are assumed to be non-stabs,
+         searching through all FDRs may cause the following code to try to
+         read stabs FDRs as ECOFF ones.  However, I don't think this will
+         harm anything.  */
+      i = 0;
+      
       /* Search FDR list starting at tab[i] for the PDR that best matches
          OFFSET.  Normally, the FDR list is only one entry long.  */
@@ -2078 +2184 @@
       do
         {
-          bfd_vma dist, min_dist = 0;
+          /* eraxxon: 'dist' and 'min_dist' can be negative now
+             because we iterate over every FDR rather than just ones
+             with a base address less than or equal to 'offset'.  */
+          bfd_signed_vma dist = -1, min_dist = -1;
           char *pdr_hold;
           char *pdr_end;
@@ -2101 +2210 @@
                 {
                   dist = offset - (pdr.adr - 0x10 * pdr.prof);
-                  if (!pdr_hold || dist < min_dist)
+
+                  /* eraxxon: 'dist' can be negative now.  Note that
+                     'min_dist' can be negative if 'pdr_hold' below is NULL.  */
+                  if (!pdr_hold || (dist >= 0 && dist < min_dist))
                     {
                       min_dist = dist;
@@ -2109 +2221 @@
             }
 
-          if (!best_pdr || min_dist < best_dist)
+          if (!best_pdr || (min_dist >= 0 && min_dist < best_dist))
             {
-              best_dist = min_dist;
+              best_dist = (bfd_vma) min_dist;  
               best_fdr = fdr_ptr;
               best_pdr = pdr_hold;
             }
-          /* continue looping until base_addr of next entry is different: */
-        }
-      while (++i < line_info->fdrtab_len
-             && tab[i].base_addr == tab[i - 1].base_addr);
+          /* Continue looping until base_addr of next entry is different.  */
+        }
+      /* eraxxon: We want to iterate over all FDRs.
+         See previous comment about 'fdrtab_lookup'.  */
+      while (++i < line_info->fdrtab_len);
 
       if (!best_fdr || !best_pdr)
-        return false;                   /* shouldn't happen...  */
-
-      /* phew, finally we got something that we can hold onto: */
+        return FALSE;                   /* Shouldn't happen...  */
+
+      /* Phew, finally we got something that we can hold onto.  */
       fdr_ptr = best_fdr;
       pdr_ptr = best_pdr;
@@ -2133 +2246 @@
       line_end = debug_info->line + fdr_ptr->cbLineOffset + fdr_ptr->cbLine;
 
-      /* Make offset relative to procedure entry: */
+      /* Make offset relative to procedure entry.  */
       offset -= pdr.adr - 0x10 * pdr.prof;
       lineno = pdr.lnLow;
@@ -2214 +2327 @@
       bfd_vma low_func_vma;
       bfd_vma low_line_vma;
-      boolean past_line;
-      boolean past_fn;
+      bfd_boolean past_line;
+      bfd_boolean past_fn;
       char *sym_ptr, *sym_ptr_end;
       size_t len, funclen;
@@ -2241 +2354 @@
       low_func_vma = 0;
       low_line_vma = 0;
-      past_line = false;
-      past_fn = false;
+      past_line = FALSE;
+      past_fn = FALSE;
 
       external_sym_size = debug_swap->external_sym_size;
@@ -2292 +2405 @@
                 case N_FUN:
                   if (sym.value > offset)
-                    past_fn = true;
+                    past_fn = TRUE;
                   else if (sym.value >= low_func_vma)
                     {
@@ -2305 +2418 @@
             {
               if (sym.value > offset)
-                past_line = true;
+                past_line = TRUE;
               else if (sym.value >= low_line_vma)
                 {
@@ -2335 +2448 @@
           if (line_info->find_buffer != NULL)
             free (line_info->find_buffer);
-          buffer = (char *) bfd_malloc (len);
+          buffer = (char *) bfd_malloc ((bfd_size_type) len);
           if (buffer == NULL)
-            return false;
+            return FALSE;
           line_info->find_buffer = buffer;
         }
@@ -2365 +2478 @@
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Do the work of find_nearest_line.  */
 
-boolean
+bfd_boolean
 _bfd_ecoff_locate_line (abfd, section, offset, debug_info, debug_swap,
                         line_info, filename_ptr, functionname_ptr, retline_ptr)
@@ -2396 +2509 @@
         {
           line_info->cache.sect = NULL;
-          return false;
+          return FALSE;
         }
     }
@@ -2404 +2517 @@
   *retline_ptr = line_info->cache.line_num;
 
-  return true;
+  return TRUE;
 }
 
@@ -2418 +2531 @@
 /* Collect a shuffle into a memory buffer.  */
 
-static boolean ecoff_collect_shuffle PARAMS ((struct shuffle *, bfd_byte *));
-
-static boolean
+static bfd_boolean ecoff_collect_shuffle
+  PARAMS ((struct shuffle *, bfd_byte *));
+
+static bfd_boolean
 ecoff_collect_shuffle (l, buff)
      struct shuffle *l;
@@ -2435 +2549 @@
         {
           if (bfd_seek (l->u.file.input_bfd, l->u.file.offset, SEEK_SET) != 0
-              || bfd_read (buff, 1, l->size, l->u.file.input_bfd) != l->size)
-            return false;
+              || (bfd_bread (buff, (bfd_size_type) l->size, l->u.file.input_bfd)
+                  != l->size))
+            return FALSE;
         }
       total += l->size;
@@ -2442 +2557 @@
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Copy PDR information into a memory buffer.  */
 
-boolean
+bfd_boolean
 _bfd_ecoff_get_accumulated_pdr (handle, buff)
      PTR handle;
@@ -2459 +2574 @@
 /* Copy symbol information into a memory buffer.  */
 
-boolean
+bfd_boolean
 _bfd_ecoff_get_accumulated_sym (handle, buff)
      PTR handle;
@@ -2471 +2586 @@
 /* Copy the string table into a memory buffer.  */
 
-boolean
+bfd_boolean
 _bfd_ecoff_get_accumulated_ss (handle, buff)
      PTR handle;
@@ -2498 +2613 @@
     }
 
-  return true;
-}
+  return TRUE;
+}