bfd/ecofflink.c

   1 /* Routines to link ECOFF debugging information.
   2    Copyright 1993 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Cygnus Support, <ian@cygnus.com>.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "bfdlink.h"
  24 #include "libbfd.h"
  25 #include "obstack.h"
  26 #include "coff/internal.h"
  27 #include "coff/sym.h"
  28 #include "coff/symconst.h"
  29 #include "coff/ecoff.h"
  30 \f
  31 static boolean ecoff_add_bytes PARAMS ((char **buf, char **bufend,
  32                                         size_t need));
  33 static struct bfd_hash_entry *string_hash_newfunc
  34   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
  35            const char *));
  36 static void ecoff_align_debug PARAMS ((bfd *abfd,
  37                                        struct ecoff_debug_info *debug,
  38                                        const struct ecoff_debug_swap *swap));
  39 static boolean ecoff_write_symhdr PARAMS ((bfd *, struct ecoff_debug_info *,
  40                                            const struct ecoff_debug_swap *,
  41                                            file_ptr where));
  42
  43 /* Obstack allocation and deallocation routines.  */
  44 #define obstack_chunk_alloc malloc
  45 #define obstack_chunk_free free
  46 \f
  47 /* The minimum amount of data to allocate.  */
  48 #define ALLOC_SIZE (4064)
  49
  50 /* Add bytes to a buffer.  Return success.  */
  51
  52 static boolean
  53 ecoff_add_bytes (buf, bufend, need)
  54      char **buf;
  55      char **bufend;
  56      size_t need;
  57 {
  58   size_t have;
  59   size_t want;
  60   char *newbuf;
  61
  62   have = *bufend - *buf;
  63   if (have > need)
  64     want = ALLOC_SIZE;
  65   else
  66     {
  67       want = need - have;
  68       if (want < ALLOC_SIZE)
  69         want = ALLOC_SIZE;
  70     }
  71   if (*buf == NULL)
  72     newbuf = (char *) malloc (have + want);
  73   else
  74     newbuf = (char *) realloc (*buf, have + want);
  75   if (newbuf == NULL)
  76     {
  77       bfd_set_error (bfd_error_no_memory);
  78       return false;
  79     }
  80   *buf = newbuf;
  81   *bufend = *buf + have + want;
  82   return true;
  83 }
  84
  85 /* We keep a hash table which maps strings to numbers.  We use it to
  86    map FDR names to indices in the output file, and to map local
  87    strings when combining stabs debugging information.  */
  88
  89 struct string_hash_entry
  90 {
  91   struct bfd_hash_entry root;
  92   /* FDR index or string table offset.  */
  93   long val;
  94   /* Next entry in string table.  */
  95   struct string_hash_entry *next;
  96 };
  97
  98 struct string_hash_table
  99 {
 100   struct bfd_hash_table table;
 101 };
 102
 103 /* Routine to create an entry in a string hash table.  */
 104
 105 static struct bfd_hash_entry *
 106 string_hash_newfunc (entry, table, string)
 107      struct bfd_hash_entry *entry;
 108      struct bfd_hash_table *table;
 109      const char *string;
 110 {
 111   struct string_hash_entry *ret = (struct string_hash_entry *) entry;
 112
 113   /* Allocate the structure if it has not already been allocated by a
 114      subclass.  */
 115   if (ret == (struct string_hash_entry *) NULL)
 116     ret = ((struct string_hash_entry *)
 117            bfd_hash_allocate (table, sizeof (struct string_hash_entry)));
 118   if (ret == (struct string_hash_entry *) NULL)
 119     {
 120       bfd_set_error (bfd_error_no_memory);
 121       return NULL;
 122     }
 123
 124   /* Call the allocation method of the superclass.  */
 125   ret = ((struct string_hash_entry *)
 126          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
 127
 128   if (ret)
 129     {
 130       /* Initialize the local fields.  */
 131       ret->val = -1;
 132       ret->next = NULL;
 133     }
 134
 135   return (struct bfd_hash_entry *) ret;
 136 }
 137
 138 /* Look up an entry in an string hash table.  */
 139
 140 #define string_hash_lookup(t, string, create, copy) \
 141   ((struct string_hash_entry *) \
 142    bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
 143
 144 /* We can't afford to read in all the debugging information when we do
 145    a link.  Instead, we build a list of these structures to show how
 146    different parts of the input file map to the output file.  */
 147
 148 struct shuffle
 149 {
 150   /* The next entry in this linked list.  */
 151   struct shuffle *next;
 152   /* The length of the information.  */
 153   unsigned long size;
 154   /* Whether this information comes from a file or not.  */
 155   boolean filep;
 156   union
 157     {
 158       struct
 159         {
 160           /* The BFD the data comes from.  */
 161           bfd *input_bfd;
 162           /* The offset within input_bfd.  */
 163           file_ptr offset;
 164         } file;
 165       /* The data to be written out.  */
 166       PTR memory;
 167     } u;
 168 };
 169
 170 /* This structure holds information across calls to
 171    bfd_ecoff_debug_accumulate.  */
 172
 173 struct accumulate
 174 {
 175   /* The FDR hash table.  */
 176   struct string_hash_table fdr_hash;
 177   /* The strings hash table.  */
 178   struct string_hash_table str_hash;
 179   /* Linked lists describing how to shuffle the input debug
 180      information into the output file.  We keep a pointer to both the
 181      head and the tail.  */
 182   struct shuffle *line;
 183   struct shuffle *line_end;
 184   struct shuffle *pdr;
 185   struct shuffle *pdr_end;
 186   struct shuffle *sym;
 187   struct shuffle *sym_end;
 188   struct shuffle *opt;
 189   struct shuffle *opt_end;
 190   struct shuffle *aux;
 191   struct shuffle *aux_end;
 192   struct shuffle *ss;
 193   struct shuffle *ss_end;
 194   struct string_hash_entry *ss_hash;
 195   struct string_hash_entry *ss_hash_end;
 196   struct shuffle *fdr;
 197   struct shuffle *fdr_end;
 198   struct shuffle *rfd;
 199   struct shuffle *rfd_end;
 200   /* The size of the largest file shuffle.  */
 201   unsigned long largest_file_shuffle;
 202   /* An obstack for debugging information.  */
 203   struct obstack memory;
 204 };
 205
 206 /* Add a file entry to a shuffle list.  */
 207
 208 static boolean add_file_shuffle PARAMS ((struct accumulate *,
 209                                       struct shuffle **,
 210                                       struct shuffle **, bfd *, file_ptr,
 211                                       unsigned long));
 212
 213 static boolean
 214 add_file_shuffle (ainfo, head, tail, input_bfd, offset, size)
 215      struct accumulate *ainfo;
 216      struct shuffle **head;
 217      struct shuffle **tail;
 218      bfd *input_bfd;
 219      file_ptr offset;
 220      unsigned long size;
 221 {
 222   struct shuffle *n;
 223
 224   if (*tail != (struct shuffle *) NULL
 225       && (*tail)->filep
 226       && (*tail)->u.file.input_bfd == input_bfd
 227       && (*tail)->u.file.offset + (*tail)->size == offset)
 228     {
 229       /* Just merge this entry onto the existing one.  */
 230       (*tail)->size += size;
 231       if ((*tail)->size > ainfo->largest_file_shuffle)
 232         ainfo->largest_file_shuffle = (*tail)->size;
 233       return true;
 234     }
 235
 236   n = (struct shuffle *) obstack_alloc (&ainfo->memory,
 237                                         sizeof (struct shuffle));
 238   if (!n)
 239     {
 240       bfd_set_error (bfd_error_no_memory);
 241       return false;
 242     }
 243   n->next = NULL;
 244   n->size = size;
 245   n->filep = true;
 246   n->u.file.input_bfd = input_bfd;
 247   n->u.file.offset = offset;
 248   if (*head == (struct shuffle *) NULL)
 249     *head = n;
 250   if (*tail != (struct shuffle *) NULL)
 251     (*tail)->next = n;
 252   *tail = n;
 253   if (size > ainfo->largest_file_shuffle)
 254     ainfo->largest_file_shuffle = size;
 255   return true;
 256 }
 257
 258 /* Add a memory entry to a shuffle list.  */
 259
 260 static boolean add_memory_shuffle PARAMS ((struct accumulate *,
 261                                            struct shuffle **head,
 262                                            struct shuffle **tail,
 263                                            bfd_byte *data, unsigned long size));
 264
 265 static boolean
 266 add_memory_shuffle (ainfo, head, tail, data, size)
 267      struct accumulate *ainfo;
 268      struct shuffle **head;
 269      struct shuffle **tail;
 270      bfd_byte *data;
 271      unsigned long size;
 272 {
 273   struct shuffle *n;
 274
 275   n = (struct shuffle *) obstack_alloc (&ainfo->memory,
 276                                         sizeof (struct shuffle));
 277   if (!n)
 278     {
 279       bfd_set_error (bfd_error_no_memory);
 280       return false;
 281     }
 282   n->next = NULL;
 283   n->size = size;
 284   n->filep = false;
 285   n->u.memory = (PTR) data;
 286   if (*head == (struct shuffle *) NULL)
 287     *head = n;
 288   if (*tail != (struct shuffle *) NULL)
 289     (*tail)->next = n;
 290   *tail = n;
 291   return true;
 292 }
 293
 294 /* Initialize the FDR hash table.  This returns a handle which is then
 295    passed in to bfd_ecoff_debug_accumulate, et. al.  */
 296
 297 /*ARGSUSED*/
 298 PTR
 299 bfd_ecoff_debug_init (output_bfd, output_debug, output_swap, info)
 300      bfd *output_bfd;
 301      struct ecoff_debug_info *output_debug;
 302      const struct ecoff_debug_swap *output_swap;
 303      struct bfd_link_info *info;
 304 {
 305   struct accumulate *ainfo;
 306
 307   ainfo = (struct accumulate *) malloc (sizeof (struct accumulate));
 308   if (!ainfo)
 309     {
 310       bfd_set_error (bfd_error_no_memory);
 311       return NULL;
 312     }
 313   if (! bfd_hash_table_init_n (&ainfo->fdr_hash.table, string_hash_newfunc,
 314                                1021))
 315     return NULL;
 316
 317   ainfo->line = NULL;
 318   ainfo->line_end = NULL;
 319   ainfo->pdr = NULL;
 320   ainfo->pdr_end = NULL;
 321   ainfo->sym = NULL;
 322   ainfo->sym_end = NULL;
 323   ainfo->opt = NULL;
 324   ainfo->opt_end = NULL;
 325   ainfo->aux = NULL;
 326   ainfo->aux_end = NULL;
 327   ainfo->ss = NULL;
 328   ainfo->ss_end = NULL;
 329   ainfo->ss_hash = NULL;
 330   ainfo->ss_hash_end = NULL;
 331   ainfo->fdr = NULL;
 332   ainfo->fdr_end = NULL;
 333   ainfo->rfd = NULL;
 334   ainfo->rfd_end = NULL;
 335
 336   ainfo->largest_file_shuffle = 0;
 337
 338   if (! info->relocateable)
 339     {
 340       if (! bfd_hash_table_init (&ainfo->str_hash.table, string_hash_newfunc))
 341         return NULL;
 342
 343       /* The first entry in the string table is the empty string.  */
 344       output_debug->symbolic_header.issMax = 1;
 345     }
 346
 347   if (!obstack_begin (&ainfo->memory, 4050))
 348     {
 349       bfd_set_error (bfd_error_no_memory);
 350       return NULL;
 351     }
 352
 353   return (PTR) ainfo;
 354 }
 355
 356 /* Free the accumulated debugging information.  */
 357
 358 /*ARGSUSED*/
 359 void
 360 bfd_ecoff_debug_free (handle, output_bfd, output_debug, output_swap, info)
 361      PTR handle;
 362      bfd *output_bfd;
 363      struct ecoff_debug_info *output_debug;
 364      const struct ecoff_debug_swap *output_swap;
 365      struct bfd_link_info *info;
 366 {
 367   struct accumulate *ainfo = (struct accumulate *) handle;
 368
 369   bfd_hash_table_free (&ainfo->fdr_hash.table);
 370
 371   if (! info->relocateable)
 372     bfd_hash_table_free (&ainfo->str_hash.table);
 373
 374   obstack_free (&ainfo->memory, (PTR) NULL);
 375
 376   free (ainfo);
 377 }
 378
 379 /* Accumulate the debugging information from INPUT_BFD into
 380    OUTPUT_BFD.  The INPUT_DEBUG argument points to some ECOFF
 381    debugging information which we want to link into the information
 382    pointed to by the OUTPUT_DEBUG argument.  OUTPUT_SWAP and
 383    INPUT_SWAP point to the swapping information needed.  INFO is the
 384    linker information structure.  HANDLE is returned by
 385    bfd_ecoff_debug_init.  */
 386
 387 /*ARGSUSED*/
 388 boolean
 389 bfd_ecoff_debug_accumulate (handle, output_bfd, output_debug, output_swap,
 390                             input_bfd, input_debug, input_swap,
 391                             info)
 392      PTR handle;
 393      bfd *output_bfd;
 394      struct ecoff_debug_info *output_debug;
 395      const struct ecoff_debug_swap *output_swap;
 396      bfd *input_bfd;
 397      struct ecoff_debug_info *input_debug;
 398      const struct ecoff_debug_swap *input_swap;
 399      struct bfd_link_info *info;
 400 {
 401   struct accumulate *ainfo = (struct accumulate *) handle;
 402   void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *))
 403     = input_swap->swap_sym_in;
 404   void (* const swap_rfd_in) PARAMS ((bfd *, PTR, RFDT *))
 405     = input_swap->swap_rfd_in;
 406   void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
 407     = output_swap->swap_sym_out;
 408   void (* const swap_fdr_out) PARAMS ((bfd *, const FDR *, PTR))
 409     = output_swap->swap_fdr_out;
 410   void (* const swap_rfd_out) PARAMS ((bfd *, const RFDT *, PTR))
 411     = output_swap->swap_rfd_out;
 412   bfd_size_type external_pdr_size = output_swap->external_pdr_size;
 413   bfd_size_type external_sym_size = output_swap->external_sym_size;
 414   bfd_size_type external_opt_size = output_swap->external_opt_size;
 415   bfd_size_type external_fdr_size = output_swap->external_fdr_size;
 416   bfd_size_type external_rfd_size = output_swap->external_rfd_size;
 417   HDRR * const output_symhdr = &output_debug->symbolic_header;
 418   HDRR * const input_symhdr = &input_debug->symbolic_header;
 419   bfd_vma section_adjust[scMax];
 420   asection *sec;
 421   bfd_byte *fdr_start;
 422   bfd_byte *fdr_ptr;
 423   bfd_byte *fdr_end;
 424   bfd_size_type fdr_add;
 425   unsigned int copied;
 426   RFDT i;
 427   unsigned long sz;
 428   bfd_byte *rfd_out;
 429   bfd_byte *rfd_in;
 430   bfd_byte *rfd_end;
 431   long newrfdbase = 0;
 432   long oldrfdbase = 0;
 433   bfd_byte *fdr_out;
 434
 435   /* Use section_adjust to hold the value to add to a symbol in a
 436      particular section.  */
 437   memset ((PTR) section_adjust, 0, sizeof section_adjust);
 438
 439 #define SET(name, indx) \
 440   sec = bfd_get_section_by_name (input_bfd, name); \
 441   if (sec != NULL) \
 442     section_adjust[indx] = (sec->output_section->vma \
 443                             + sec->output_offset \
 444                             - sec->vma);
 445
 446   SET (".text", scText);
 447   SET (".data", scData);
 448   SET (".bss", scBss);
 449   SET (".sdata", scSData);
 450   SET (".sbss", scSBss);
 451   /* scRdata section may be either .rdata or .rodata.  */
 452   SET (".rdata", scRData);
 453   SET (".rodata", scRData);
 454   SET (".init", scInit);
 455   SET (".fini", scFini);
 456
 457 #undef SET
 458
 459   /* Find all the debugging information based on the FDR's.  We need
 460      to handle them whether they are swapped or not.  */
 461   if (input_debug->fdr != (FDR *) NULL)
 462     {
 463       fdr_start = (bfd_byte *) input_debug->fdr;
 464       fdr_add = sizeof (FDR);
 465     }
 466   else
 467     {
 468       fdr_start = (bfd_byte *) input_debug->external_fdr;
 469       fdr_add = input_swap->external_fdr_size;
 470     }
 471   fdr_end = fdr_start + input_symhdr->ifdMax * fdr_add;
 472
 473   input_debug->ifdmap = (RFDT *) bfd_alloc (input_bfd,
 474                                             (input_symhdr->ifdMax
 475                                              * sizeof (RFDT)));
 476
 477   sz = (input_symhdr->crfd + input_symhdr->ifdMax) * external_rfd_size;
 478   rfd_out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
 479   if (!input_debug->ifdmap || !rfd_out)
 480     {
 481       bfd_set_error (bfd_error_no_memory);
 482       return false;
 483     }
 484   if (!add_memory_shuffle (ainfo, &ainfo->rfd, &ainfo->rfd_end, rfd_out, sz))
 485     return false;
 486
 487   copied = 0;
 488
 489   /* Look through the FDR's to see which ones we are going to include
 490      in the final output.  We do not want duplicate FDR information
 491      for header files, because ECOFF debugging is often very large.
 492      When we find an FDR with no line information which can be merged,
 493      we look it up in a hash table to ensure that we only include it
 494      once.  We keep a table mapping FDR numbers to the final number
 495      they get with the BFD, so that we can refer to it when we write
 496      out the external symbols.  */
 497   for (fdr_ptr = fdr_start, i = 0;
 498        fdr_ptr < fdr_end;
 499        fdr_ptr += fdr_add, i++, rfd_out += external_rfd_size)
 500     {
 501       FDR fdr;
 502
 503       if (input_debug->fdr != (FDR *) NULL)
 504         fdr = *(FDR *) fdr_ptr;
 505       else
 506         (*input_swap->swap_fdr_in) (input_bfd, (PTR) fdr_ptr, &fdr);
 507
 508       /* See if this FDR can be merged with an existing one.  */
 509       if (fdr.cbLine == 0 && fdr.rss != -1 && fdr.fMerge)
 510         {
 511           const char *name;
 512           char *lookup;
 513           struct string_hash_entry *fh;
 514
 515           /* We look up a string formed from the file name and the
 516              number of symbols.  Sometimes an include file will
 517              conditionally define a typedef or something based on the
 518              order of include files.  Using the number of symbols as a
 519              hash reduces the chance that we will merge symbol
 520              information that should not be merged.  */
 521           name = input_debug->ss + fdr.issBase + fdr.rss;
 522
 523           lookup = (char *) malloc (strlen (name) + 20);
 524           if (lookup == NULL)
 525             {
 526               bfd_set_error (bfd_error_no_memory);
 527               return false;
 528             }
 529           sprintf (lookup, "%s %lx", name, fdr.csym);
 530
 531           fh = string_hash_lookup (&ainfo->fdr_hash, lookup, true, true);
 532           free (lookup);
 533           if (fh == (struct string_hash_entry *) NULL)
 534             return false;
 535
 536           if (fh->val != -1)
 537             {
 538               input_debug->ifdmap[i] = fh->val;
 539               (*swap_rfd_out) (output_bfd, input_debug->ifdmap + i,
 540                                (PTR) rfd_out);
 541
 542               /* Don't copy this FDR.  */
 543               continue;
 544             }
 545
 546           fh->val = output_symhdr->ifdMax + copied;
 547         }
 548
 549       input_debug->ifdmap[i] = output_symhdr->ifdMax + copied;
 550       (*swap_rfd_out) (output_bfd, input_debug->ifdmap + i, (PTR) rfd_out);
 551       ++copied;
 552     }
 553
 554   newrfdbase = output_symhdr->crfd;
 555   output_symhdr->crfd += input_symhdr->ifdMax;
 556
 557   /* Copy over any existing RFD's.  RFD's are only created by the
 558      linker, so this will only happen for input files which are the
 559      result of a partial link.  */
 560   rfd_in = (bfd_byte *) input_debug->external_rfd;
 561   rfd_end = rfd_in + input_symhdr->crfd * input_swap->external_rfd_size;
 562   for (;
 563        rfd_in < rfd_end;
 564        rfd_in += input_swap->external_rfd_size)
 565     {
 566       RFDT rfd;
 567
 568       (*swap_rfd_in) (input_bfd, (PTR) rfd_in, &rfd);
 569       BFD_ASSERT (rfd >= 0 && rfd < input_symhdr->ifdMax);
 570       rfd = input_debug->ifdmap[rfd];
 571       (*swap_rfd_out) (output_bfd, &rfd, (PTR) rfd_out);
 572       rfd_out += external_rfd_size;
 573     }
 574
 575   oldrfdbase = output_symhdr->crfd;
 576   output_symhdr->crfd += input_symhdr->crfd;
 577
 578   /* Look through the FDR's and copy over all associated debugging
 579      information.  */
 580   sz = copied * external_fdr_size;
 581   fdr_out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
 582   if (!fdr_out)
 583     {
 584       bfd_set_error (bfd_error_no_memory);
 585       return false;
 586     }
 587   if (!add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end, fdr_out, sz))
 588     return false;
 589   for (fdr_ptr = fdr_start, i = 0;
 590        fdr_ptr < fdr_end;
 591        fdr_ptr += fdr_add, i++)
 592     {
 593       FDR fdr;
 594       bfd_byte *sym_out;
 595       bfd_byte *lraw_src;
 596       bfd_byte *lraw_end;
 597       boolean fgotfilename;
 598
 599       if (input_debug->ifdmap[i] < output_symhdr->ifdMax)
 600         {
 601           /* We are not copying this FDR.  */
 602           continue;
 603         }
 604
 605       if (input_debug->fdr != (FDR *) NULL)
 606         fdr = *(FDR *) fdr_ptr;
 607       else
 608         (*input_swap->swap_fdr_in) (input_bfd, (PTR) fdr_ptr, &fdr);
 609
 610       /* Adjust the FDR address for any changes that may have been
 611          made by relaxing.  */
 612       if (input_debug->adjust != (struct ecoff_value_adjust *) NULL)
 613         {
 614           bfd_vma adr;
 615           struct ecoff_value_adjust *adjust;
 616
 617           adr = fdr.adr;
 618           for (adjust = input_debug->adjust;
 619                adjust != (struct ecoff_value_adjust *) NULL;
 620                adjust = adjust->next)
 621             if (adr >= adjust->start
 622                 && adr < adjust->end)
 623               fdr.adr += adjust->adjust;
 624         }
 625
 626       /* FIXME: It is conceivable that this FDR points to the .init or
 627          .fini section, in which case this will not do the right
 628          thing.  */
 629       fdr.adr += section_adjust[scText];
 630
 631       /* Swap in the local symbols, adjust their values, and swap them
 632          out again.  */
 633       fgotfilename = false;
 634       sz = fdr.csym * external_sym_size;
 635       sym_out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
 636       if (!sym_out)
 637         {
 638           bfd_set_error (bfd_error_no_memory);
 639           return false;
 640         }
 641       if (!add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end, sym_out, sz))
 642         return false;
 643       lraw_src = ((bfd_byte *) input_debug->external_sym
 644                   + fdr.isymBase * input_swap->external_sym_size);
 645       lraw_end = lraw_src + fdr.csym * input_swap->external_sym_size;
 646       for (;  lraw_src < lraw_end;  lraw_src += input_swap->external_sym_size)
 647         {
 648           SYMR internal_sym;
 649
 650           (*swap_sym_in) (input_bfd, (PTR) lraw_src, &internal_sym);
 651
 652           BFD_ASSERT (internal_sym.sc != scCommon
 653                       && internal_sym.sc != scSCommon);
 654
 655           /* Adjust the symbol value if appropriate.  */
 656           switch (internal_sym.st)
 657             {
 658             case stNil:
 659               if (ECOFF_IS_STAB (&internal_sym))
 660                 break;
 661               /* Fall through.  */
 662             case stGlobal:
 663             case stStatic:
 664             case stLabel:
 665             case stProc:
 666             case stStaticProc:
 667               if (input_debug->adjust != (struct ecoff_value_adjust *) NULL)
 668                 {
 669                   bfd_vma value;
 670                   struct ecoff_value_adjust *adjust;
 671
 672                   value = internal_sym.value;
 673                   for (adjust = input_debug->adjust;
 674                        adjust != (struct ecoff_value_adjust *) NULL;
 675                        adjust = adjust->next)
 676                     if (value >= adjust->start
 677                         && value < adjust->end)
 678                       internal_sym.value += adjust->adjust;
 679                 }
 680               internal_sym.value += section_adjust[internal_sym.sc];
 681               break;
 682
 683             default:
 684               break;
 685             }
 686
 687           /* If we are doing a final link, we hash all the strings in
 688              the local symbol table together.  This reduces the amount
 689              of space required by debugging information.  We don't do
 690              this when performing a relocateable link because it would
 691              prevent us from easily merging different FDR's.  */
 692           if (! info->relocateable)
 693             {
 694               boolean ffilename;
 695               const char *name;
 696
 697               if (! fgotfilename && internal_sym.iss == fdr.rss)
 698                 ffilename = true;
 699               else
 700                 ffilename = false;
 701
 702               /* Hash the name into the string table.  */
 703               name = input_debug->ss + fdr.issBase + internal_sym.iss;
 704               if (*name == '\0')
 705                 internal_sym.iss = 0;
 706               else
 707                 {
 708                   struct string_hash_entry *sh;
 709
 710                   sh = string_hash_lookup (&ainfo->str_hash, name, true, true);
 711                   if (sh == (struct string_hash_entry *) NULL)
 712                     return false;
 713                   if (sh->val == -1)
 714                     {
 715                       sh->val = output_symhdr->issMax;
 716                       output_symhdr->issMax += strlen (name) + 1;
 717                       if (ainfo->ss_hash == (struct string_hash_entry *) NULL)
 718                         ainfo->ss_hash = sh;
 719                       if (ainfo->ss_hash_end
 720                           != (struct string_hash_entry *) NULL)
 721                         ainfo->ss_hash_end->next = sh;
 722                       ainfo->ss_hash_end = sh;
 723                     }
 724                   internal_sym.iss = sh->val;
 725                 }
 726
 727               if (ffilename)
 728                 {
 729                   fdr.rss = internal_sym.iss;
 730                   fgotfilename = true;
 731                 }
 732             }
 733
 734           (*swap_sym_out) (output_bfd, &internal_sym, sym_out);
 735           sym_out += external_sym_size;
 736         }
 737
 738       fdr.isymBase = output_symhdr->isymMax;
 739       output_symhdr->isymMax += fdr.csym;
 740
 741       /* Copy the information that does not need swapping.  */
 742       if (fdr.cbLine > 0)
 743         {
 744           if (!add_file_shuffle (ainfo, &ainfo->line, &ainfo->line_end,
 745                             input_bfd,
 746                             input_symhdr->cbLineOffset + fdr.cbLineOffset,
 747                             fdr.cbLine))
 748             return false;
 749           fdr.ilineBase = output_symhdr->ilineMax;
 750           fdr.cbLineOffset = output_symhdr->cbLine;
 751           output_symhdr->ilineMax += fdr.cline;
 752           output_symhdr->cbLine += fdr.cbLine;
 753         }
 754       if (fdr.caux > 0)
 755         {
 756           if (!add_file_shuffle (ainfo, &ainfo->aux, &ainfo->aux_end,
 757                             input_bfd,
 758                             (input_symhdr->cbAuxOffset
 759                              + fdr.iauxBase * sizeof (union aux_ext)),
 760                             fdr.caux * sizeof (union aux_ext)))
 761             return false;
 762           fdr.iauxBase = output_symhdr->iauxMax;
 763           output_symhdr->iauxMax += fdr.caux;
 764         }
 765       if (! info->relocateable)
 766         {
 767
 768           /* When are are hashing strings, we lie about the number of
 769              strings attached to each FDR.  We need to set cbSs
 770              because some versions of dbx apparently use it to decide
 771              how much of the string table to read in.  */
 772           fdr.issBase = 0;
 773           fdr.cbSs = output_symhdr->issMax;
 774         }
 775       else if (fdr.cbSs > 0)
 776         {
 777           if (!add_file_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end,
 778                             input_bfd,
 779                             input_symhdr->cbSsOffset + fdr.issBase,
 780                             fdr.cbSs))
 781             return false;
 782           fdr.issBase = output_symhdr->issMax;
 783           output_symhdr->issMax += fdr.cbSs;
 784         }
 785
 786       if (output_bfd->xvec->header_byteorder_big_p
 787           == input_bfd->xvec->header_byteorder_big_p)
 788         {
 789           /* The two BFD's have the same endianness, so simply copying
 790              the information will suffice.  */
 791           BFD_ASSERT (external_pdr_size == input_swap->external_pdr_size);
 792           if (fdr.cpd > 0)
 793             {
 794               if (!add_file_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end,
 795                                      input_bfd,
 796                                      (input_symhdr->cbPdOffset
 797                                       + fdr.ipdFirst * external_pdr_size),
 798                                      fdr.cpd * external_pdr_size))
 799                 return false;
 800             }
 801           BFD_ASSERT (external_opt_size == input_swap->external_opt_size);
 802           if (fdr.copt > 0)
 803             {
 804               if (!add_file_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end,
 805                                      input_bfd,
 806                                      (input_symhdr->cbOptOffset
 807                                       + fdr.ioptBase * external_opt_size),
 808                                      fdr.copt * external_opt_size))
 809                 return false;
 810             }
 811         }
 812       else
 813         {
 814           bfd_size_type outsz, insz;
 815           bfd_byte *in;
 816           bfd_byte *end;
 817           bfd_byte *out;
 818
 819           /* The two BFD's have different endianness, so we must swap
 820              everything in and out.  This code would always work, but
 821              it would be unnecessarily slow in the normal case.  */
 822           outsz = external_pdr_size;
 823           insz = input_swap->external_pdr_size;
 824           in = ((bfd_byte *) input_debug->external_pdr
 825                 + fdr.ipdFirst * insz);
 826           end = in + fdr.cpd * insz;
 827           sz = fdr.cpd * outsz;
 828           out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
 829           if (!out)
 830             {
 831               bfd_set_error (bfd_error_no_memory);
 832               return false;
 833             }
 834           if (!add_memory_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end, out, sz))
 835             return false;
 836           for (; in < end; in += insz, out += outsz)
 837             {
 838               PDR pdr;
 839
 840               (*input_swap->swap_pdr_in) (input_bfd, (PTR) in, &pdr);
 841               (*output_swap->swap_pdr_out) (output_bfd, &pdr, (PTR) out);
 842             }
 843
 844           /* Swap over the optimization information.  */
 845           outsz = external_opt_size;
 846           insz = input_swap->external_opt_size;
 847           in = ((bfd_byte *) input_debug->external_opt
 848                 + fdr.ioptBase * insz);
 849           end = in + fdr.copt * insz;
 850           sz = fdr.copt * outsz;
 851           out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
 852           if (!out)
 853             {
 854               bfd_set_error (bfd_error_no_memory);
 855               return false;
 856             }
 857           if (!add_memory_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end, out, sz))
 858             return false;
 859           for (; in < end; in += insz, out += outsz)
 860             {
 861               OPTR opt;
 862
 863               (*input_swap->swap_opt_in) (input_bfd, (PTR) in, &opt);
 864               (*output_swap->swap_opt_out) (output_bfd, &opt, (PTR) out);
 865             }
 866         }
 867
 868       fdr.ipdFirst = output_symhdr->ipdMax;
 869       output_symhdr->ipdMax += fdr.cpd;
 870       fdr.ioptBase = output_symhdr->ioptMax;
 871       output_symhdr->ioptMax += fdr.copt;
 872
 873       if (fdr.crfd <= 0)
 874         {
 875           /* Point this FDR at the table of RFD's we created.  */
 876           fdr.rfdBase = newrfdbase;
 877           fdr.crfd = input_symhdr->ifdMax;
 878         }
 879       else
 880         {
 881           /* Point this FDR at the remapped RFD's.  */
 882           fdr.rfdBase += oldrfdbase;
 883         }
 884
 885       (*swap_fdr_out) (output_bfd, &fdr, fdr_out);
 886       fdr_out += external_fdr_size;
 887       ++output_symhdr->ifdMax;
 888     }
 889
 890   return true;
 891 }
 892
 893 /* Add a string to the debugging information we are accumulating.
 894    Return the offset from the fdr string base.  */
 895
 896 static long ecoff_add_string PARAMS ((struct accumulate *,
 897                                       struct bfd_link_info *,
 898                                       struct ecoff_debug_info *,
 899                                       FDR *fdr, const char *string));
 900
 901 static long
 902 ecoff_add_string (ainfo, info, debug, fdr, string)
 903      struct accumulate *ainfo;
 904      struct bfd_link_info *info;
 905      struct ecoff_debug_info *debug;
 906      FDR *fdr;
 907      const char *string;
 908 {
 909   HDRR *symhdr;
 910   size_t len;
 911   bfd_size_type ret;
 912
 913   symhdr = &debug->symbolic_header;
 914   len = strlen (string);
 915   if (info->relocateable)
 916     {
 917       if (!add_memory_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end, (PTR) string,
 918                                len + 1))
 919         return -1;
 920       ret = symhdr->issMax;
 921       symhdr->issMax += len + 1;
 922       fdr->cbSs += len + 1;
 923     }
 924   else
 925     {
 926       struct string_hash_entry *sh;
 927
 928       sh = string_hash_lookup (&ainfo->str_hash, string, true, true);
 929       if (sh == (struct string_hash_entry *) NULL)
 930         return -1;
 931       if (sh->val == -1)
 932         {
 933           sh->val = symhdr->issMax;
 934           symhdr->issMax += len + 1;
 935           if (ainfo->ss_hash == (struct string_hash_entry *) NULL)
 936             ainfo->ss_hash = sh;
 937           if (ainfo->ss_hash_end
 938               != (struct string_hash_entry *) NULL)
 939             ainfo->ss_hash_end->next = sh;
 940           ainfo->ss_hash_end = sh;
 941         }
 942       ret = sh->val;
 943     }
 944
 945   return ret;
 946 }
 947
 948 /* Add debugging information from a non-ECOFF file.  */
 949
 950 boolean
 951 bfd_ecoff_debug_accumulate_other (handle, output_bfd, output_debug,
 952                                   output_swap, input_bfd, info)
 953      PTR handle;
 954      bfd *output_bfd;
 955      struct ecoff_debug_info *output_debug;
 956      const struct ecoff_debug_swap *output_swap;
 957      bfd *input_bfd;
 958      struct bfd_link_info *info;
 959 {
 960   struct accumulate *ainfo = (struct accumulate *) handle;
 961   void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
 962     = output_swap->swap_sym_out;
 963   HDRR *output_symhdr = &output_debug->symbolic_header;
 964   FDR fdr;
 965   asection *sec;
 966   asymbol **symbols;
 967   asymbol **sym_ptr;
 968   asymbol **sym_end;
 969   PTR external_fdr;
 970
 971   memset ((PTR) &fdr, 0, sizeof fdr);
 972
 973   sec = bfd_get_section_by_name (input_bfd, ".text");
 974   if (sec != NULL)
 975     fdr.adr = sec->output_section->vma + sec->output_offset;
 976   else
 977     {
 978       /* FIXME: What about .init or .fini?  */
 979       fdr.adr = 0;
 980     }
 981
 982   fdr.issBase = output_symhdr->issMax;
 983   fdr.cbSs = 0;
 984   fdr.rss = ecoff_add_string (ainfo, info, output_debug, &fdr,
 985                               bfd_get_filename (input_bfd));
 986   if (fdr.rss == -1)
 987     return false;
 988   fdr.isymBase = output_symhdr->isymMax;
 989
 990   /* Get the local symbols from the input BFD.  */
 991   symbols = (asymbol **) bfd_alloc (output_bfd,
 992                                     get_symtab_upper_bound (input_bfd));
 993   if (symbols == (asymbol **) NULL)
 994     {
 995       bfd_set_error (bfd_error_no_memory);
 996       return false;
 997     }
 998   sym_end = symbols + bfd_canonicalize_symtab (input_bfd, symbols);
 999
1000   /* Handle the local symbols.  Any external symbols are handled
1001      separately.  */
1002   fdr.csym = 0;
1003   for (sym_ptr = symbols; sym_ptr != sym_end; sym_ptr++)
1004     {
1005       SYMR internal_sym;
1006       PTR external_sym;
1007
1008       if (((*sym_ptr)->flags & BSF_EXPORT) != 0)
1009         continue;
1010       memset ((PTR) &internal_sym, 0, sizeof internal_sym);
1011       internal_sym.iss = ecoff_add_string (ainfo, info, output_debug, &fdr,
1012                                            (*sym_ptr)->name);
1013
1014       if (internal_sym.iss == -1)
1015         return false;
1016       if (bfd_is_com_section ((*sym_ptr)->section)
1017           || (*sym_ptr)->section == &bfd_und_section)
1018         internal_sym.value = (*sym_ptr)->value;
1019       else
1020         internal_sym.value = ((*sym_ptr)->value
1021                               + (*sym_ptr)->section->output_offset
1022                               + (*sym_ptr)->section->output_section->vma);
1023       internal_sym.st = stNil;
1024       internal_sym.sc = scUndefined;
1025       internal_sym.index = indexNil;
1026
1027       external_sym = (PTR) obstack_alloc (&ainfo->memory,
1028                                           output_swap->external_sym_size);
1029       if (!external_sym)
1030         {
1031           bfd_set_error (bfd_error_no_memory);
1032           return false;
1033         }
1034       (*swap_sym_out) (output_bfd, &internal_sym, external_sym);
1035       add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end,
1036                           external_sym, output_swap->external_sym_size);
1037       ++fdr.csym;
1038       ++output_symhdr->isymMax;
1039     }
1040
1041   bfd_release (output_bfd, (PTR) symbols);
1042
1043   /* Leave everything else in the FDR zeroed out.  This will cause
1044      the lang field to be langC.  The fBigendian field will
1045      indicate little endian format, but it doesn't matter because
1046      it only applies to aux fields and there are none.  */
1047   external_fdr = (PTR) obstack_alloc (&ainfo->memory,
1048                                       output_swap->external_fdr_size);
1049   if (!external_fdr)
1050     {
1051       bfd_set_error (bfd_error_no_memory);
1052       return false;
1053     }
1054   (*output_swap->swap_fdr_out) (output_bfd, &fdr, external_fdr);
1055   add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end,
1056                       external_fdr, output_swap->external_fdr_size);
1057
1058   ++output_symhdr->ifdMax;
1059
1060   return true;
1061 }
1062
1063 /* Set up ECOFF debugging information for the external symbols.
1064    FIXME: This is done using a memory buffer, but it should be
1065    probably be changed to use a shuffle structure.  The assembler uses
1066    this interface, so that must be changed to do something else.  */
1067
1068 boolean
1069 bfd_ecoff_debug_externals (abfd, debug, swap, relocateable, get_extr,
1070                            set_index)
1071      bfd *abfd;
1072      struct ecoff_debug_info *debug;
1073      const struct ecoff_debug_swap *swap;
1074      boolean relocateable;
1075      boolean (*get_extr) PARAMS ((asymbol *, EXTR *));
1076      void (*set_index) PARAMS ((asymbol *, bfd_size_type));
1077 {
1078   HDRR * const symhdr = &debug->symbolic_header;
1079   asymbol **sym_ptr_ptr;
1080   size_t c;
1081
1082   sym_ptr_ptr = bfd_get_outsymbols (abfd);
1083   if (sym_ptr_ptr == NULL)
1084     return true;
1085
1086   for (c = bfd_get_symcount (abfd); c > 0; c--, sym_ptr_ptr++)
1087     {
1088       asymbol *sym_ptr;
1089       EXTR esym;
1090
1091       sym_ptr = *sym_ptr_ptr;
1092
1093       /* Get the external symbol information.  */
1094       if ((*get_extr) (sym_ptr, &esym) == false)
1095         continue;
1096
1097       /* If we're producing an executable, move common symbols into
1098          bss.  */
1099       if (relocateable == false)
1100         {
1101           if (esym.asym.sc == scCommon)
1102             esym.asym.sc = scBss;
1103           else if (esym.asym.sc == scSCommon)
1104             esym.asym.sc = scSBss;
1105         }
1106
1107       if (bfd_is_com_section (sym_ptr->section)
1108           || sym_ptr->section == &bfd_und_section)
1109         {
1110           /* FIXME: gas does not keep the value of a small undefined
1111              symbol in the symbol itself, because of relocation
1112              problems.  */
1113           if (esym.asym.sc != scSUndefined
1114               || esym.asym.value == 0
1115               || sym_ptr->value != 0)
1116             esym.asym.value = sym_ptr->value;
1117         }
1118       else
1119         esym.asym.value = (sym_ptr->value
1120                            + sym_ptr->section->output_offset
1121                            + sym_ptr->section->output_section->vma);
1122
1123       if (set_index)
1124         (*set_index) (sym_ptr, (bfd_size_type) symhdr->iextMax);
1125
1126       if (! bfd_ecoff_debug_one_external (abfd, debug, swap,
1127                                           sym_ptr->name, &esym))
1128         return false;
1129     }
1130
1131   return true;
1132 }
1133
1134 /* Add a single external symbol to the debugging information.  */
1135
1136 boolean
1137 bfd_ecoff_debug_one_external (abfd, debug, swap, name, esym)
1138      bfd *abfd;
1139      struct ecoff_debug_info *debug;
1140      const struct ecoff_debug_swap *swap;
1141      const char *name;
1142      EXTR *esym;
1143 {
1144   const bfd_size_type external_ext_size = swap->external_ext_size;
1145   void (* const swap_ext_out) PARAMS ((bfd *, const EXTR *, PTR))
1146     = swap->swap_ext_out;
1147   HDRR * const symhdr = &debug->symbolic_header;
1148   size_t namelen;
1149
1150   namelen = strlen (name);
1151
1152   if (debug->ssext_end - debug->ssext
1153       < symhdr->issExtMax + namelen + 1)
1154     {
1155       if (ecoff_add_bytes ((char **) &debug->ssext,
1156                            (char **) &debug->ssext_end,
1157                            symhdr->issExtMax + namelen + 1)
1158           == false)
1159         return false;
1160     }
1161   if ((char *) debug->external_ext_end - (char *) debug->external_ext
1162       < (symhdr->iextMax + 1) * external_ext_size)
1163     {
1164       if (ecoff_add_bytes ((char **) &debug->external_ext,
1165                            (char **) &debug->external_ext_end,
1166                            (symhdr->iextMax + 1) * external_ext_size)
1167           == false)
1168         return false;
1169     }
1170
1171   esym->asym.iss = symhdr->issExtMax;
1172
1173   (*swap_ext_out) (abfd, esym,
1174                    ((char *) debug->external_ext
1175                     + symhdr->iextMax * swap->external_ext_size));
1176
1177   ++symhdr->iextMax;
1178
1179   strcpy (debug->ssext + symhdr->issExtMax, name);
1180   symhdr->issExtMax += namelen + 1;
1181
1182   return true;
1183 }
1184
1185 /* Align the ECOFF debugging information.  */
1186
1187 /*ARGSUSED*/
1188 static void
1189 ecoff_align_debug (abfd, debug, swap)
1190      bfd *abfd;
1191      struct ecoff_debug_info *debug;
1192      const struct ecoff_debug_swap *swap;
1193 {
1194   HDRR * const symhdr = &debug->symbolic_header;
1195   bfd_size_type debug_align, aux_align, rfd_align;
1196   size_t add;
1197
1198   /* Adjust the counts so that structures are aligned.  */
1199   debug_align = swap->debug_align;
1200   aux_align = debug_align / sizeof (union aux_ext);
1201   rfd_align = debug_align / swap->external_rfd_size;
1202
1203   add = debug_align - (symhdr->cbLine & (debug_align - 1));
1204   if (add != debug_align)
1205     {
1206       if (debug->line != (unsigned char *) NULL)
1207         memset ((PTR) (debug->line + symhdr->cbLine), 0, add);
1208       symhdr->cbLine += add;
1209     }
1210
1211   add = debug_align - (symhdr->issMax & (debug_align - 1));
1212   if (add != debug_align)
1213     {
1214       if (debug->ss != (char *) NULL)
1215         memset ((PTR) (debug->ss + symhdr->issMax), 0, add);
1216       symhdr->issMax += add;
1217     }
1218
1219   add = debug_align - (symhdr->issExtMax & (debug_align - 1));
1220   if (add != debug_align)
1221     {
1222       if (debug->ssext != (char *) NULL)
1223         memset ((PTR) (debug->ssext + symhdr->issExtMax), 0, add);
1224       symhdr->issExtMax += add;
1225     }
1226
1227   add = aux_align - (symhdr->iauxMax & (aux_align - 1));
1228   if (add != aux_align)
1229     {
1230       if (debug->external_aux != (union aux_ext *) NULL)
1231         memset ((PTR) (debug->external_aux + symhdr->iauxMax), 0,
1232                 add * sizeof (union aux_ext));
1233       symhdr->iauxMax += add;
1234     }
1235
1236   add = rfd_align - (symhdr->crfd & (rfd_align - 1));
1237   if (add != rfd_align)
1238     {
1239       if (debug->external_rfd != (PTR) NULL)
1240         memset ((PTR) ((char *) debug->external_rfd
1241                        + symhdr->crfd * swap->external_rfd_size),
1242                 0, add * swap->external_rfd_size);
1243       symhdr->crfd += add;
1244     }
1245 }
1246
1247 /* Return the size required by the ECOFF debugging information.  */
1248
1249 bfd_size_type
1250 bfd_ecoff_debug_size (abfd, debug, swap)
1251      bfd *abfd;
1252      struct ecoff_debug_info *debug;
1253      const struct ecoff_debug_swap *swap;
1254 {
1255   bfd_size_type tot;
1256
1257   ecoff_align_debug (abfd, debug, swap);
1258   tot = swap->external_hdr_size;
1259
1260 #define ADD(count, size) \
1261   tot += debug->symbolic_header.count * size
1262
1263   ADD (cbLine, sizeof (unsigned char));
1264   ADD (idnMax, swap->external_dnr_size);
1265   ADD (ipdMax, swap->external_pdr_size);
1266   ADD (isymMax, swap->external_sym_size);
1267   ADD (ioptMax, swap->external_opt_size);
1268   ADD (iauxMax, sizeof (union aux_ext));
1269   ADD (issMax, sizeof (char));
1270   ADD (issExtMax, sizeof (char));
1271   ADD (ifdMax, swap->external_fdr_size);
1272   ADD (crfd, swap->external_rfd_size);
1273   ADD (iextMax, swap->external_ext_size);
1274
1275 #undef ADD
1276
1277   return tot;
1278 }
1279
1280 /* Write out the ECOFF symbolic header, given the file position it is
1281    going to be placed at.  This assumes that the counts are set
1282    correctly.  */
1283
1284 static boolean
1285 ecoff_write_symhdr (abfd, debug, swap, where)
1286      bfd *abfd;
1287      struct ecoff_debug_info *debug;
1288      const struct ecoff_debug_swap *swap;
1289      file_ptr where;
1290 {
1291   HDRR * const symhdr = &debug->symbolic_header;
1292   char *buff = NULL;
1293
1294   ecoff_align_debug (abfd, debug, swap);
1295
1296   /* Go to the right location in the file.  */
1297   if (bfd_seek (abfd, where, SEEK_SET) != 0)
1298     return false;
1299
1300   where += swap->external_hdr_size;
1301
1302   symhdr->magic = swap->sym_magic;
1303
1304   /* Fill in the file offsets.  */
1305 #define SET(offset, count, size) \
1306   if (symhdr->count == 0) \
1307     symhdr->offset = 0; \
1308   else \
1309     { \
1310       symhdr->offset = where; \
1311       where += symhdr->count * size; \
1312     }
1313
1314   SET (cbLineOffset, cbLine, sizeof (unsigned char));
1315   SET (cbDnOffset, idnMax, swap->external_dnr_size);
1316   SET (cbPdOffset, ipdMax, swap->external_pdr_size);
1317   SET (cbSymOffset, isymMax, swap->external_sym_size);
1318   SET (cbOptOffset, ioptMax, swap->external_opt_size);
1319   SET (cbAuxOffset, iauxMax, sizeof (union aux_ext));
1320   SET (cbSsOffset, issMax, sizeof (char));
1321   SET (cbSsExtOffset, issExtMax, sizeof (char));
1322   SET (cbFdOffset, ifdMax, swap->external_fdr_size);
1323   SET (cbRfdOffset, crfd, swap->external_rfd_size);
1324   SET (cbExtOffset, iextMax, swap->external_ext_size);
1325 #undef SET
1326
1327   buff = (PTR) malloc (swap->external_hdr_size);
1328   if (buff == NULL && swap->external_hdr_size != 0)
1329     {
1330       bfd_set_error (bfd_error_no_memory);
1331       goto error_return;
1332     }
1333
1334   (*swap->swap_hdr_out) (abfd, symhdr, buff);
1335   if (bfd_write (buff, 1, swap->external_hdr_size, abfd)
1336       != swap->external_hdr_size)
1337     goto error_return;
1338
1339   if (buff != NULL)
1340     free (buff);
1341   return true;
1342  error_return:
1343   if (buff != NULL)
1344     free (buff);
1345   return false;
1346 }
1347
1348 /* Write out the ECOFF debugging information.  This function assumes
1349    that the information (the pointers and counts) in *DEBUG have been
1350    set correctly.  WHERE is the position in the file to write the
1351    information to.  This function fills in the file offsets in the
1352    symbolic header.  */
1353
1354 boolean
1355 bfd_ecoff_write_debug (abfd, debug, swap, where)
1356      bfd *abfd;
1357      struct ecoff_debug_info *debug;
1358      const struct ecoff_debug_swap *swap;
1359      file_ptr where;
1360 {
1361   HDRR * const symhdr = &debug->symbolic_header;
1362
1363   if (! ecoff_write_symhdr (abfd, debug, swap, where))
1364     return false;
1365
1366 #define WRITE(ptr, count, size, offset) \
1367   BFD_ASSERT (symhdr->offset == 0 || bfd_tell (abfd) == symhdr->offset); \
1368   if (bfd_write ((PTR) debug->ptr, size, symhdr->count, abfd) \
1369       != size * symhdr->count) \
1370     return false;
1371
1372   WRITE (line, cbLine, sizeof (unsigned char), cbLineOffset);
1373   WRITE (external_dnr, idnMax, swap->external_dnr_size, cbDnOffset);
1374   WRITE (external_pdr, ipdMax, swap->external_pdr_size, cbPdOffset);
1375   WRITE (external_sym, isymMax, swap->external_sym_size, cbSymOffset);
1376   WRITE (external_opt, ioptMax, swap->external_opt_size, cbOptOffset);
1377   WRITE (external_aux, iauxMax, sizeof (union aux_ext), cbAuxOffset);
1378   WRITE (ss, issMax, sizeof (char), cbSsOffset);
1379   WRITE (ssext, issExtMax, sizeof (char), cbSsExtOffset);
1380   WRITE (external_fdr, ifdMax, swap->external_fdr_size, cbFdOffset);
1381   WRITE (external_rfd, crfd, swap->external_rfd_size, cbRfdOffset);
1382   WRITE (external_ext, iextMax, swap->external_ext_size, cbExtOffset);
1383 #undef WRITE
1384
1385   return true;
1386 }
1387
1388 /* Write out a shuffle list.  */
1389
1390 static boolean ecoff_write_shuffle PARAMS ((bfd *,
1391                                             const struct ecoff_debug_swap *,
1392                                             struct shuffle *, PTR space));
1393
1394 static boolean
1395 ecoff_write_shuffle (abfd, swap, shuffle, space)
1396      bfd *abfd;
1397      const struct ecoff_debug_swap *swap;
1398      struct shuffle *shuffle;
1399      PTR space;
1400 {
1401   register struct shuffle *l;
1402   unsigned long total;
1403
1404   total = 0;
1405   for (l = shuffle; l != (struct shuffle *) NULL; l = l->next)
1406     {
1407       if (! l->filep)
1408         {
1409           if (bfd_write (l->u.memory, 1, l->size, abfd) != l->size)
1410             return false;
1411         }
1412       else
1413         {
1414           if (bfd_seek (l->u.file.input_bfd, l->u.file.offset, SEEK_SET) != 0
1415               || bfd_read (space, 1, l->size, l->u.file.input_bfd) != l->size
1416               || bfd_write (space, 1, l->size, abfd) != l->size)
1417             return false;
1418         }
1419       total += l->size;
1420     }
1421
1422   if ((total & (swap->debug_align - 1)) != 0)
1423     {
1424       int i;
1425       bfd_byte *s;
1426
1427       i = swap->debug_align - (total & (swap->debug_align - 1));
1428       s = (bfd_byte *) malloc (i);
1429       if (s == NULL && i != 0)
1430         {
1431           bfd_set_error (bfd_error_no_memory);
1432           return false;
1433         }
1434
1435       memset ((PTR) s, 0, i);
1436       if (bfd_write ((PTR) s, 1, i, abfd) != i)
1437         {
1438           free (s);
1439           return false;
1440         }
1441       free (s);
1442     }
1443
1444   return true;
1445 }
1446
1447 /* Write out debugging information using accumulated linker
1448    information.  */
1449
1450 boolean
1451 bfd_ecoff_write_accumulated_debug (handle, abfd, debug, swap, info, where)
1452      PTR handle;
1453      bfd *abfd;
1454      struct ecoff_debug_info *debug;
1455      const struct ecoff_debug_swap *swap;
1456      struct bfd_link_info *info;
1457      file_ptr where;
1458 {
1459   struct accumulate *ainfo = (struct accumulate *) handle;
1460   PTR space = NULL;
1461
1462   if (! ecoff_write_symhdr (abfd, debug, swap, where))
1463     goto error_return;
1464
1465   space = (PTR) malloc (ainfo->largest_file_shuffle);
1466   if (space == NULL && ainfo->largest_file_shuffle != 0)
1467     {
1468       bfd_set_error (bfd_error_no_memory);
1469       goto error_return;
1470     }
1471
1472   if (! ecoff_write_shuffle (abfd, swap, ainfo->line, space)
1473       || ! ecoff_write_shuffle (abfd, swap, ainfo->pdr, space)
1474       || ! ecoff_write_shuffle (abfd, swap, ainfo->sym, space)
1475       || ! ecoff_write_shuffle (abfd, swap, ainfo->opt, space)
1476       || ! ecoff_write_shuffle (abfd, swap, ainfo->aux, space))
1477     goto error_return;
1478
1479   /* The string table is written out from the hash table if this is a
1480      final link.  */
1481   if (info->relocateable)
1482     {
1483       BFD_ASSERT (ainfo->ss_hash == (struct string_hash_entry *) NULL);
1484       if (! ecoff_write_shuffle (abfd, swap, ainfo->ss, space))
1485         goto error_return;
1486     }
1487   else
1488     {
1489       unsigned long total;
1490       bfd_byte null;
1491       struct string_hash_entry *sh;
1492
1493       BFD_ASSERT (ainfo->ss == (struct shuffle *) NULL);
1494       null = 0;
1495       if (bfd_write ((PTR) &null, 1, 1, abfd) != 1)
1496         goto error_return;
1497       total = 1;
1498       BFD_ASSERT (ainfo->ss_hash == NULL || ainfo->ss_hash->val == 1);
1499       for (sh = ainfo->ss_hash;
1500            sh != (struct string_hash_entry *) NULL;
1501            sh = sh->next)
1502         {
1503           size_t len;
1504
1505           len = strlen (sh->root.string);
1506           if (bfd_write ((PTR) sh->root.string, 1, len + 1, abfd) != len + 1)
1507             goto error_return;
1508           total += len + 1;
1509         }
1510
1511       if ((total & (swap->debug_align - 1)) != 0)
1512         {
1513           int i;
1514           bfd_byte *s;
1515
1516           i = swap->debug_align - (total & (swap->debug_align - 1));
1517           s = (bfd_byte *) malloc (i);
1518           if (s == NULL && i != 0)
1519             {
1520               bfd_set_error (bfd_error_no_memory);
1521               goto error_return;
1522             }
1523           memset ((PTR) s, 0, i);
1524           if (bfd_write ((PTR) s, 1, i, abfd) != i)
1525             {
1526               free (s);
1527               goto error_return;
1528             }
1529           free (s);
1530         }
1531     }
1532
1533   /* The external strings and symbol are not converted over to using
1534      shuffles.  FIXME: They probably should be.  */
1535   if (bfd_write (debug->ssext, 1, debug->symbolic_header.issExtMax, abfd)
1536       != debug->symbolic_header.issExtMax)
1537     goto error_return;
1538   if ((debug->symbolic_header.issExtMax & (swap->debug_align - 1)) != 0)
1539     {
1540       int i;
1541       bfd_byte *s;
1542
1543       i = (swap->debug_align
1544            - (debug->symbolic_header.issExtMax & (swap->debug_align - 1)));
1545       s = (bfd_byte *) malloc (i);
1546       if (s == NULL && i != 0)
1547         {
1548           bfd_set_error (bfd_error_no_memory);
1549           goto error_return;
1550         }
1551       memset ((PTR) s, 0, i);
1552       if (bfd_write ((PTR) s, 1, i, abfd) != i)
1553         {
1554           free (s);
1555           goto error_return;
1556         }
1557       free (s);
1558     }
1559
1560   if (! ecoff_write_shuffle (abfd, swap, ainfo->fdr, space)
1561       || ! ecoff_write_shuffle (abfd, swap, ainfo->rfd, space))
1562     goto error_return;
1563
1564   BFD_ASSERT (debug->symbolic_header.cbExtOffset == 0
1565               || debug->symbolic_header.cbExtOffset == bfd_tell (abfd));
1566
1567   if (bfd_write (debug->external_ext, swap->external_ext_size,
1568                  debug->symbolic_header.iextMax, abfd)
1569       != debug->symbolic_header.iextMax * swap->external_ext_size)
1570     goto error_return;
1571
1572   if (space != NULL)
1573     free (space);
1574   return true;
1575
1576  error_return:
1577   if (space != NULL)
1578     free (space);
1579   return false;
1580 }