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>.
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
26 #include "coff/internal.h"
28 #include "coff/symconst.h"
29 #include "coff/ecoff.h"
31 static boolean ecoff_add_bytes
PARAMS ((char **buf
, char **bufend
,
33 static struct bfd_hash_entry
*string_hash_newfunc
34 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*,
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
*,
43 /* Obstack allocation and deallocation routines. */
44 #define obstack_chunk_alloc bfd_xmalloc_by_size_t
45 #define obstack_chunk_free free
47 /* The minimum amount of data to allocate. */
48 #define ALLOC_SIZE (4064)
50 /* Add bytes to a buffer. Return success. */
53 ecoff_add_bytes (buf
, bufend
, need
)
62 have
= *bufend
- *buf
;
68 if (want
< ALLOC_SIZE
)
72 newbuf
= (char *) malloc (have
+ want
);
74 newbuf
= (char *) realloc (*buf
, have
+ want
);
77 bfd_error
= no_memory
;
81 *bufend
= *buf
+ have
+ want
;
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. */
89 struct string_hash_entry
91 struct bfd_hash_entry root
;
92 /* FDR index or string table offset. */
94 /* Next entry in string table. */
95 struct string_hash_entry
*next
;
98 struct string_hash_table
100 struct bfd_hash_table table
;
103 /* Routine to create an entry in a string hash table. */
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
;
111 struct string_hash_entry
*ret
= (struct string_hash_entry
*) entry
;
113 /* Allocate the structure if it has not already been allocated by a
115 if (ret
== (struct string_hash_entry
*) NULL
)
116 ret
= ((struct string_hash_entry
*)
117 bfd_hash_allocate (table
, sizeof (struct string_hash_entry
)));
119 /* Call the allocation method of the superclass. */
120 ret
= ((struct string_hash_entry
*)
121 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
123 /* Initialize the local fields. */
127 return (struct bfd_hash_entry
*) ret
;
130 /* Look up an entry in an string hash table. */
132 #define string_hash_lookup(t, string, create, copy) \
133 ((struct string_hash_entry *) \
134 bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
136 /* We can't afford to read in all the debugging information when we do
137 a link. Instead, we build a list of these structures to show how
138 different parts of the input file map to the output file. */
142 /* The next entry in this linked list. */
143 struct shuffle
*next
;
144 /* The length of the information. */
146 /* Whether this information comes from a file or not. */
152 /* The BFD the data comes from. */
154 /* The offset within input_bfd. */
157 /* The data to be written out. */
162 /* This structure holds information across calls to
163 bfd_ecoff_debug_accumulate. */
167 /* The FDR hash table. */
168 struct string_hash_table fdr_hash
;
169 /* The strings hash table. */
170 struct string_hash_table str_hash
;
171 /* Linked lists describing how to shuffle the input debug
172 information into the output file. We keep a pointer to both the
173 head and the tail. */
174 struct shuffle
*line
;
175 struct shuffle
*line_end
;
177 struct shuffle
*pdr_end
;
179 struct shuffle
*sym_end
;
181 struct shuffle
*opt_end
;
183 struct shuffle
*aux_end
;
185 struct shuffle
*ss_end
;
186 struct string_hash_entry
*ss_hash
;
187 struct string_hash_entry
*ss_hash_end
;
189 struct shuffle
*fdr_end
;
191 struct shuffle
*rfd_end
;
192 /* The size of the largest file shuffle. */
193 unsigned long largest_file_shuffle
;
194 /* An obstack for debugging information. */
195 struct obstack memory
;
198 /* Add a file entry to a shuffle list. */
200 static void add_file_shuffle
PARAMS ((struct accumulate
*,
202 struct shuffle
**, bfd
*, file_ptr
,
206 add_file_shuffle (ainfo
, head
, tail
, input_bfd
, offset
, size
)
207 struct accumulate
*ainfo
;
208 struct shuffle
**head
;
209 struct shuffle
**tail
;
216 if (*tail
!= (struct shuffle
*) NULL
218 && (*tail
)->u
.file
.input_bfd
== input_bfd
219 && (*tail
)->u
.file
.offset
+ (*tail
)->size
== offset
)
221 /* Just merge this entry onto the existing one. */
222 (*tail
)->size
+= size
;
223 if ((*tail
)->size
> ainfo
->largest_file_shuffle
)
224 ainfo
->largest_file_shuffle
= (*tail
)->size
;
228 n
= (struct shuffle
*) obstack_alloc (&ainfo
->memory
,
229 sizeof (struct shuffle
));
233 n
->u
.file
.input_bfd
= input_bfd
;
234 n
->u
.file
.offset
= offset
;
235 if (*head
== (struct shuffle
*) NULL
)
237 if (*tail
!= (struct shuffle
*) NULL
)
240 if (size
> ainfo
->largest_file_shuffle
)
241 ainfo
->largest_file_shuffle
= size
;
244 /* Add a memory entry to a shuffle list. */
246 static void add_memory_shuffle
PARAMS ((struct accumulate
*,
247 struct shuffle
**head
,
248 struct shuffle
**tail
,
249 bfd_byte
*data
, unsigned long size
));
252 add_memory_shuffle (ainfo
, head
, tail
, data
, size
)
253 struct accumulate
*ainfo
;
254 struct shuffle
**head
;
255 struct shuffle
**tail
;
261 n
= (struct shuffle
*) obstack_alloc (&ainfo
->memory
,
262 sizeof (struct shuffle
));
266 n
->u
.memory
= (PTR
) data
;
267 if (*head
== (struct shuffle
*) NULL
)
269 if (*tail
!= (struct shuffle
*) NULL
)
274 /* Initialize the FDR hash table. This returns a handle which is then
275 passed in to bfd_ecoff_debug_accumulate, et. al. */
279 bfd_ecoff_debug_init (output_bfd
, output_debug
, output_swap
, info
)
281 struct ecoff_debug_info
*output_debug
;
282 const struct ecoff_debug_swap
*output_swap
;
283 struct bfd_link_info
*info
;
285 struct accumulate
*ainfo
;
287 ainfo
= (struct accumulate
*) bfd_xmalloc (sizeof (struct accumulate
));
288 if (! bfd_hash_table_init_n (&ainfo
->fdr_hash
.table
, string_hash_newfunc
,
293 ainfo
->line_end
= NULL
;
295 ainfo
->pdr_end
= NULL
;
297 ainfo
->sym_end
= NULL
;
299 ainfo
->opt_end
= NULL
;
301 ainfo
->aux_end
= NULL
;
303 ainfo
->ss_end
= NULL
;
304 ainfo
->ss_hash
= NULL
;
305 ainfo
->ss_hash_end
= NULL
;
307 ainfo
->fdr_end
= NULL
;
309 ainfo
->rfd_end
= NULL
;
311 ainfo
->largest_file_shuffle
= 0;
313 if (! info
->relocateable
)
315 if (! bfd_hash_table_init (&ainfo
->str_hash
.table
, string_hash_newfunc
))
318 /* The first entry in the string table is the empty string. */
319 output_debug
->symbolic_header
.issMax
= 1;
322 obstack_begin (&ainfo
->memory
, 4050);
327 /* Free the accumulated debugging information. */
331 bfd_ecoff_debug_free (handle
, output_bfd
, output_debug
, output_swap
, info
)
334 struct ecoff_debug_info
*output_debug
;
335 const struct ecoff_debug_swap
*output_swap
;
336 struct bfd_link_info
*info
;
338 struct accumulate
*ainfo
= (struct accumulate
*) handle
;
340 bfd_hash_table_free (&ainfo
->fdr_hash
.table
);
342 if (! info
->relocateable
)
343 bfd_hash_table_free (&ainfo
->str_hash
.table
);
345 obstack_free (&ainfo
->memory
, (PTR
) NULL
);
350 /* Accumulate the debugging information from INPUT_BFD into
351 OUTPUT_BFD. The INPUT_DEBUG argument points to some ECOFF
352 debugging information which we want to link into the information
353 pointed to by the OUTPUT_DEBUG argument. OUTPUT_SWAP and
354 INPUT_SWAP point to the swapping information needed. INFO is the
355 linker information structure. HANDLE is returned by
356 bfd_ecoff_debug_init. */
360 bfd_ecoff_debug_accumulate (handle
, output_bfd
, output_debug
, output_swap
,
361 input_bfd
, input_debug
, input_swap
,
365 struct ecoff_debug_info
*output_debug
;
366 const struct ecoff_debug_swap
*output_swap
;
368 struct ecoff_debug_info
*input_debug
;
369 const struct ecoff_debug_swap
*input_swap
;
370 struct bfd_link_info
*info
;
372 struct accumulate
*ainfo
= (struct accumulate
*) handle
;
373 void (* const swap_sym_in
) PARAMS ((bfd
*, PTR
, SYMR
*))
374 = input_swap
->swap_sym_in
;
375 void (* const swap_rfd_in
) PARAMS ((bfd
*, PTR
, RFDT
*))
376 = input_swap
->swap_rfd_in
;
377 void (* const swap_sym_out
) PARAMS ((bfd
*, const SYMR
*, PTR
))
378 = output_swap
->swap_sym_out
;
379 void (* const swap_fdr_out
) PARAMS ((bfd
*, const FDR
*, PTR
))
380 = output_swap
->swap_fdr_out
;
381 void (* const swap_rfd_out
) PARAMS ((bfd
*, const RFDT
*, PTR
))
382 = output_swap
->swap_rfd_out
;
383 bfd_size_type external_pdr_size
= output_swap
->external_pdr_size
;
384 bfd_size_type external_sym_size
= output_swap
->external_sym_size
;
385 bfd_size_type external_opt_size
= output_swap
->external_opt_size
;
386 bfd_size_type external_fdr_size
= output_swap
->external_fdr_size
;
387 bfd_size_type external_rfd_size
= output_swap
->external_rfd_size
;
388 HDRR
* const output_symhdr
= &output_debug
->symbolic_header
;
389 HDRR
* const input_symhdr
= &input_debug
->symbolic_header
;
390 bfd_vma section_adjust
[scMax
];
395 bfd_size_type fdr_add
;
406 /* Use section_adjust to hold the value to add to a symbol in a
407 particular section. */
408 memset ((PTR
) section_adjust
, 0, sizeof section_adjust
);
410 #define SET(name, indx) \
411 sec = bfd_get_section_by_name (input_bfd, name); \
413 section_adjust[indx] = (sec->output_section->vma \
414 + sec->output_offset \
417 SET (".text", scText
);
418 SET (".data", scData
);
420 SET (".sdata", scSData
);
421 SET (".sbss", scSBss
);
422 /* scRdata section may be either .rdata or .rodata. */
423 SET (".rdata", scRData
);
424 SET (".rodata", scRData
);
425 SET (".init", scInit
);
426 SET (".fini", scFini
);
430 /* Find all the debugging information based on the FDR's. We need
431 to handle them whether they are swapped or not. */
432 if (input_debug
->fdr
!= (FDR
*) NULL
)
434 fdr_start
= (bfd_byte
*) input_debug
->fdr
;
435 fdr_add
= sizeof (FDR
);
439 fdr_start
= (bfd_byte
*) input_debug
->external_fdr
;
440 fdr_add
= input_swap
->external_fdr_size
;
442 fdr_end
= fdr_start
+ input_symhdr
->ifdMax
* fdr_add
;
444 input_debug
->ifdmap
= (RFDT
*) bfd_alloc (input_bfd
,
445 (input_symhdr
->ifdMax
448 sz
= (input_symhdr
->crfd
+ input_symhdr
->ifdMax
) * external_rfd_size
;
449 rfd_out
= (bfd_byte
*) obstack_alloc (&ainfo
->memory
, sz
);
450 add_memory_shuffle (ainfo
, &ainfo
->rfd
, &ainfo
->rfd_end
, rfd_out
, sz
);
454 /* Look through the FDR's to see which ones we are going to include
455 in the final output. We do not want duplicate FDR information
456 for header files, because ECOFF debugging is often very large.
457 When we find an FDR with no line information which can be merged,
458 we look it up in a hash table to ensure that we only include it
459 once. We keep a table mapping FDR numbers to the final number
460 they get with the BFD, so that we can refer to it when we write
461 out the external symbols. */
462 for (fdr_ptr
= fdr_start
, i
= 0;
464 fdr_ptr
+= fdr_add
, i
++, rfd_out
+= external_rfd_size
)
468 if (input_debug
->fdr
!= (FDR
*) NULL
)
469 fdr
= *(FDR
*) fdr_ptr
;
471 (*input_swap
->swap_fdr_in
) (input_bfd
, (PTR
) fdr_ptr
, &fdr
);
473 /* See if this FDR can be merged with an existing one. */
474 if (fdr
.cbLine
== 0 && fdr
.rss
!= -1 && fdr
.fMerge
)
478 struct string_hash_entry
*fh
;
480 /* We look up a string formed from the file name and the
481 number of symbols. Sometimes an include file will
482 conditionally define a typedef or something based on the
483 order of include files. Using the number of symbols as a
484 hash reduces the chance that we will merge symbol
485 information that should not be merged. */
486 name
= input_debug
->ss
+ fdr
.issBase
+ fdr
.rss
;
487 lookup
= (char *) alloca (strlen (name
) + 20);
488 sprintf (lookup
, "%s %lx", name
, fdr
.csym
);
490 fh
= string_hash_lookup (&ainfo
->fdr_hash
, lookup
, true, true);
491 if (fh
== (struct string_hash_entry
*) NULL
)
496 input_debug
->ifdmap
[i
] = fh
->val
;
497 (*swap_rfd_out
) (output_bfd
, input_debug
->ifdmap
+ i
,
500 /* Don't copy this FDR. */
504 fh
->val
= output_symhdr
->ifdMax
+ copied
;
507 input_debug
->ifdmap
[i
] = output_symhdr
->ifdMax
+ copied
;
508 (*swap_rfd_out
) (output_bfd
, input_debug
->ifdmap
+ i
, (PTR
) rfd_out
);
512 newrfdbase
= output_symhdr
->crfd
;
513 output_symhdr
->crfd
+= input_symhdr
->ifdMax
;
515 /* Copy over any existing RFD's. RFD's are only created by the
516 linker, so this will only happen for input files which are the
517 result of a partial link. */
518 rfd_in
= (bfd_byte
*) input_debug
->external_rfd
;
519 rfd_end
= rfd_in
+ input_symhdr
->crfd
* input_swap
->external_rfd_size
;
522 rfd_in
+= input_swap
->external_rfd_size
)
526 (*swap_rfd_in
) (input_bfd
, (PTR
) rfd_in
, &rfd
);
527 BFD_ASSERT (rfd
>= 0 && rfd
< input_symhdr
->ifdMax
);
528 rfd
= input_debug
->ifdmap
[rfd
];
529 (*swap_rfd_out
) (output_bfd
, &rfd
, (PTR
) rfd_out
);
530 rfd_out
+= external_rfd_size
;
533 oldrfdbase
= output_symhdr
->crfd
;
534 output_symhdr
->crfd
+= input_symhdr
->crfd
;
536 /* Look through the FDR's and copy over all associated debugging
538 sz
= copied
* external_fdr_size
;
539 fdr_out
= (bfd_byte
*) obstack_alloc (&ainfo
->memory
, sz
);
540 add_memory_shuffle (ainfo
, &ainfo
->fdr
, &ainfo
->fdr_end
, fdr_out
, sz
);
541 for (fdr_ptr
= fdr_start
, i
= 0;
543 fdr_ptr
+= fdr_add
, i
++)
549 boolean fgotfilename
;
551 if (input_debug
->ifdmap
[i
] < output_symhdr
->ifdMax
)
553 /* We are not copying this FDR. */
557 if (input_debug
->fdr
!= (FDR
*) NULL
)
558 fdr
= *(FDR
*) fdr_ptr
;
560 (*input_swap
->swap_fdr_in
) (input_bfd
, (PTR
) fdr_ptr
, &fdr
);
562 /* FIXME: It is conceivable that this FDR points to the .init or
563 .fini section, in which case this will not do the right
565 fdr
.adr
+= section_adjust
[scText
];
567 /* Swap in the local symbols, adjust their values, and swap them
569 fgotfilename
= false;
570 sz
= fdr
.csym
* external_sym_size
;
571 sym_out
= (bfd_byte
*) obstack_alloc (&ainfo
->memory
, sz
);
572 add_memory_shuffle (ainfo
, &ainfo
->sym
, &ainfo
->sym_end
, sym_out
, sz
);
573 lraw_src
= ((bfd_byte
*) input_debug
->external_sym
574 + fdr
.isymBase
* input_swap
->external_sym_size
);
575 lraw_end
= lraw_src
+ fdr
.csym
* input_swap
->external_sym_size
;
576 for (; lraw_src
< lraw_end
; lraw_src
+= input_swap
->external_sym_size
)
580 (*swap_sym_in
) (input_bfd
, (PTR
) lraw_src
, &internal_sym
);
582 BFD_ASSERT (internal_sym
.sc
!= scCommon
583 && internal_sym
.sc
!= scSCommon
);
585 /* Adjust the symbol value if appropriate. */
586 switch (internal_sym
.st
)
589 if (ECOFF_IS_STAB (&internal_sym
))
597 internal_sym
.value
+= section_adjust
[internal_sym
.sc
];
604 /* If we are doing a final link, we hash all the strings in
605 the local symbol table together. This reduces the amount
606 of space required by debugging information. We don't do
607 this when performing a relocateable link because it would
608 prevent us from easily merging different FDR's. */
609 if (! info
->relocateable
)
614 if (! fgotfilename
&& internal_sym
.iss
== fdr
.rss
)
619 /* Hash the name into the string table. */
620 name
= input_debug
->ss
+ fdr
.issBase
+ internal_sym
.iss
;
622 internal_sym
.iss
= 0;
625 struct string_hash_entry
*sh
;
627 sh
= string_hash_lookup (&ainfo
->str_hash
, name
, true, true);
628 if (sh
== (struct string_hash_entry
*) NULL
)
632 sh
->val
= output_symhdr
->issMax
;
633 output_symhdr
->issMax
+= strlen (name
) + 1;
634 if (ainfo
->ss_hash
== (struct string_hash_entry
*) NULL
)
636 if (ainfo
->ss_hash_end
637 != (struct string_hash_entry
*) NULL
)
638 ainfo
->ss_hash_end
->next
= sh
;
639 ainfo
->ss_hash_end
= sh
;
641 internal_sym
.iss
= sh
->val
;
646 fdr
.rss
= internal_sym
.iss
;
651 (*swap_sym_out
) (output_bfd
, &internal_sym
, sym_out
);
652 sym_out
+= external_sym_size
;
655 fdr
.isymBase
= output_symhdr
->isymMax
;
656 output_symhdr
->isymMax
+= fdr
.csym
;
658 /* Copy the information that does not need swapping. */
661 add_file_shuffle (ainfo
, &ainfo
->line
, &ainfo
->line_end
,
663 input_symhdr
->cbLineOffset
+ fdr
.cbLineOffset
,
665 fdr
.ilineBase
= output_symhdr
->ilineMax
;
666 fdr
.cbLineOffset
= output_symhdr
->cbLine
;
667 output_symhdr
->ilineMax
+= fdr
.cline
;
668 output_symhdr
->cbLine
+= fdr
.cbLine
;
672 add_file_shuffle (ainfo
, &ainfo
->aux
, &ainfo
->aux_end
,
674 (input_symhdr
->cbAuxOffset
675 + fdr
.iauxBase
* sizeof (union aux_ext
)),
676 fdr
.caux
* sizeof (union aux_ext
));
677 fdr
.iauxBase
= output_symhdr
->iauxMax
;
678 output_symhdr
->iauxMax
+= fdr
.caux
;
680 if (! info
->relocateable
)
683 /* When are are hashing strings, we lie about the number of
684 strings attached to each FDR. We need to set cbSs
685 because some versions of dbx apparently use it to decide
686 how much of the string table to read in. */
688 fdr
.cbSs
= output_symhdr
->issMax
;
690 else if (fdr
.cbSs
> 0)
692 add_file_shuffle (ainfo
, &ainfo
->ss
, &ainfo
->ss_end
,
694 input_symhdr
->cbSsOffset
+ fdr
.issBase
,
696 fdr
.issBase
= output_symhdr
->issMax
;
697 output_symhdr
->issMax
+= fdr
.cbSs
;
700 if (output_bfd
->xvec
->header_byteorder_big_p
701 == input_bfd
->xvec
->header_byteorder_big_p
)
703 /* The two BFD's have the same endianness, so simply copying
704 the information will suffice. */
705 BFD_ASSERT (external_pdr_size
== input_swap
->external_pdr_size
);
707 add_file_shuffle (ainfo
, &ainfo
->pdr
, &ainfo
->pdr_end
,
709 (input_symhdr
->cbPdOffset
710 + fdr
.ipdFirst
* external_pdr_size
),
711 fdr
.cpd
* external_pdr_size
);
712 BFD_ASSERT (external_opt_size
== input_swap
->external_opt_size
);
714 add_file_shuffle (ainfo
, &ainfo
->opt
, &ainfo
->opt_end
,
716 (input_symhdr
->cbOptOffset
717 + fdr
.ioptBase
* external_opt_size
),
718 fdr
.copt
* external_opt_size
);
722 bfd_size_type outsz
, insz
;
727 /* The two BFD's have different endianness, so we must swap
728 everything in and out. This code would always work, but
729 it would be unnecessarily slow in the normal case. */
730 outsz
= external_pdr_size
;
731 insz
= input_swap
->external_pdr_size
;
732 in
= ((bfd_byte
*) input_debug
->external_pdr
733 + fdr
.ipdFirst
* insz
);
734 end
= in
+ fdr
.cpd
* insz
;
735 sz
= fdr
.cpd
* outsz
;
736 out
= (bfd_byte
*) obstack_alloc (&ainfo
->memory
, sz
);
737 add_memory_shuffle (ainfo
, &ainfo
->pdr
, &ainfo
->pdr_end
, out
, sz
);
738 for (; in
< end
; in
+= insz
, out
+= outsz
)
742 (*input_swap
->swap_pdr_in
) (input_bfd
, (PTR
) in
, &pdr
);
743 (*output_swap
->swap_pdr_out
) (output_bfd
, &pdr
, (PTR
) out
);
746 /* Swap over the optimization information. */
747 outsz
= external_opt_size
;
748 insz
= input_swap
->external_opt_size
;
749 in
= ((bfd_byte
*) input_debug
->external_opt
750 + fdr
.ioptBase
* insz
);
751 end
= in
+ fdr
.copt
* insz
;
752 sz
= fdr
.copt
* outsz
;
753 out
= (bfd_byte
*) obstack_alloc (&ainfo
->memory
, sz
);
754 add_memory_shuffle (ainfo
, &ainfo
->opt
, &ainfo
->opt_end
, out
, sz
);
755 for (; in
< end
; in
+= insz
, out
+= outsz
)
759 (*input_swap
->swap_opt_in
) (input_bfd
, (PTR
) in
, &opt
);
760 (*output_swap
->swap_opt_out
) (output_bfd
, &opt
, (PTR
) out
);
764 fdr
.ipdFirst
= output_symhdr
->ipdMax
;
765 output_symhdr
->ipdMax
+= fdr
.cpd
;
766 fdr
.ioptBase
= output_symhdr
->ioptMax
;
767 output_symhdr
->ioptMax
+= fdr
.copt
;
771 /* Point this FDR at the table of RFD's we created. */
772 fdr
.rfdBase
= newrfdbase
;
773 fdr
.crfd
= input_symhdr
->ifdMax
;
777 /* Point this FDR at the remapped RFD's. */
778 fdr
.rfdBase
+= oldrfdbase
;
781 (*swap_fdr_out
) (output_bfd
, &fdr
, fdr_out
);
782 fdr_out
+= external_fdr_size
;
783 ++output_symhdr
->ifdMax
;
789 /* Add a string to the debugging information we are accumulating.
790 Return the offset from the fdr string base. */
792 static long ecoff_add_string
PARAMS ((struct accumulate
*,
793 struct bfd_link_info
*,
794 struct ecoff_debug_info
*,
795 FDR
*fdr
, const char *string
));
798 ecoff_add_string (ainfo
, info
, debug
, fdr
, string
)
799 struct accumulate
*ainfo
;
800 struct bfd_link_info
*info
;
801 struct ecoff_debug_info
*debug
;
809 symhdr
= &debug
->symbolic_header
;
810 len
= strlen (string
);
811 if (info
->relocateable
)
813 add_memory_shuffle (ainfo
, &ainfo
->ss
, &ainfo
->ss_end
, (PTR
) string
,
815 ret
= symhdr
->issMax
;
816 symhdr
->issMax
+= len
+ 1;
817 fdr
->cbSs
+= len
+ 1;
821 struct string_hash_entry
*sh
;
823 sh
= string_hash_lookup (&ainfo
->str_hash
, string
, true, true);
824 if (sh
== (struct string_hash_entry
*) NULL
)
825 return (bfd_size_type
) -1;
828 sh
->val
= symhdr
->issMax
;
829 symhdr
->issMax
+= len
+ 1;
830 if (ainfo
->ss_hash
== (struct string_hash_entry
*) NULL
)
832 if (ainfo
->ss_hash_end
833 != (struct string_hash_entry
*) NULL
)
834 ainfo
->ss_hash_end
->next
= sh
;
835 ainfo
->ss_hash_end
= sh
;
843 /* Add debugging information from a non-ECOFF file. */
846 bfd_ecoff_debug_accumulate_other (handle
, output_bfd
, output_debug
,
847 output_swap
, input_bfd
, info
)
850 struct ecoff_debug_info
*output_debug
;
851 const struct ecoff_debug_swap
*output_swap
;
853 struct bfd_link_info
*info
;
855 struct accumulate
*ainfo
= (struct accumulate
*) handle
;
856 void (* const swap_sym_out
) PARAMS ((bfd
*, const SYMR
*, PTR
))
857 = output_swap
->swap_sym_out
;
858 HDRR
*output_symhdr
= &output_debug
->symbolic_header
;
866 memset (&fdr
, 0, sizeof fdr
);
868 sec
= bfd_get_section_by_name (input_bfd
, ".text");
870 fdr
.adr
= sec
->output_section
->vma
+ sec
->output_offset
;
873 /* FIXME: What about .init or .fini? */
877 fdr
.issBase
= output_symhdr
->issMax
;
879 fdr
.rss
= ecoff_add_string (ainfo
, info
, output_debug
, &fdr
,
880 bfd_get_filename (input_bfd
));
883 fdr
.isymBase
= output_symhdr
->isymMax
;
885 /* Get the local symbols from the input BFD. */
886 symbols
= (asymbol
**) bfd_alloc (output_bfd
,
887 get_symtab_upper_bound (input_bfd
));
888 if (symbols
== (asymbol
**) NULL
)
890 bfd_error
= no_memory
;
893 sym_end
= symbols
+ bfd_canonicalize_symtab (input_bfd
, symbols
);
895 /* Handle the local symbols. Any external symbols are handled
898 for (sym_ptr
= symbols
; sym_ptr
!= sym_end
; sym_ptr
++)
903 if (((*sym_ptr
)->flags
& BSF_EXPORT
) != 0)
905 memset (&internal_sym
, 0, sizeof internal_sym
);
906 internal_sym
.iss
= ecoff_add_string (ainfo
, info
, output_debug
, &fdr
,
909 if (internal_sym
.iss
== -1)
911 if (bfd_is_com_section ((*sym_ptr
)->section
)
912 || (*sym_ptr
)->section
== &bfd_und_section
)
913 internal_sym
.value
= (*sym_ptr
)->value
;
915 internal_sym
.value
= ((*sym_ptr
)->value
916 + (*sym_ptr
)->section
->output_offset
917 + (*sym_ptr
)->section
->output_section
->vma
);
918 internal_sym
.st
= stNil
;
919 internal_sym
.sc
= scUndefined
;
920 internal_sym
.index
= indexNil
;
922 external_sym
= (PTR
) obstack_alloc (&ainfo
->memory
,
923 output_swap
->external_sym_size
);
924 (*swap_sym_out
) (output_bfd
, &internal_sym
, external_sym
);
925 add_memory_shuffle (ainfo
, &ainfo
->sym
, &ainfo
->sym_end
,
926 external_sym
, output_swap
->external_sym_size
);
928 ++output_symhdr
->isymMax
;
931 bfd_release (output_bfd
, (PTR
) symbols
);
933 /* Leave everything else in the FDR zeroed out. This will cause
934 the lang field to be langC. The fBigendian field will
935 indicate little endian format, but it doesn't matter because
936 it only applies to aux fields and there are none. */
937 external_fdr
= (PTR
) obstack_alloc (&ainfo
->memory
,
938 output_swap
->external_fdr_size
);
939 (*output_swap
->swap_fdr_out
) (output_bfd
, &fdr
, external_fdr
);
940 add_memory_shuffle (ainfo
, &ainfo
->fdr
, &ainfo
->fdr_end
,
941 external_fdr
, output_swap
->external_fdr_size
);
943 ++output_symhdr
->ifdMax
;
948 /* Set up ECOFF debugging information for the external symbols.
949 FIXME: This is done using a memory buffer, but it should be
950 probably be changed to use a shuffle structure. The assembler uses
951 this interface, so that must be changed to do something else. */
954 bfd_ecoff_debug_externals (abfd
, debug
, swap
, relocateable
, get_extr
,
957 struct ecoff_debug_info
*debug
;
958 const struct ecoff_debug_swap
*swap
;
959 boolean relocateable
;
960 boolean (*get_extr
) PARAMS ((asymbol
*, EXTR
*));
961 void (*set_index
) PARAMS ((asymbol
*, bfd_size_type
));
963 HDRR
* const symhdr
= &debug
->symbolic_header
;
964 asymbol
**sym_ptr_ptr
;
967 sym_ptr_ptr
= bfd_get_outsymbols (abfd
);
968 if (sym_ptr_ptr
== NULL
)
971 for (c
= bfd_get_symcount (abfd
); c
> 0; c
--, sym_ptr_ptr
++)
976 sym_ptr
= *sym_ptr_ptr
;
978 /* Get the external symbol information. */
979 if ((*get_extr
) (sym_ptr
, &esym
) == false)
982 /* If we're producing an executable, move common symbols into
984 if (relocateable
== false)
986 if (esym
.asym
.sc
== scCommon
)
987 esym
.asym
.sc
= scBss
;
988 else if (esym
.asym
.sc
== scSCommon
)
989 esym
.asym
.sc
= scSBss
;
992 if (bfd_is_com_section (sym_ptr
->section
)
993 || sym_ptr
->section
== &bfd_und_section
)
994 esym
.asym
.value
= sym_ptr
->value
;
996 esym
.asym
.value
= (sym_ptr
->value
997 + sym_ptr
->section
->output_offset
998 + sym_ptr
->section
->output_section
->vma
);
1001 (*set_index
) (sym_ptr
, (bfd_size_type
) symhdr
->iextMax
);
1003 if (! bfd_ecoff_debug_one_external (abfd
, debug
, swap
,
1004 sym_ptr
->name
, &esym
))
1011 /* Add a single external symbol to the debugging information. */
1014 bfd_ecoff_debug_one_external (abfd
, debug
, swap
, name
, esym
)
1016 struct ecoff_debug_info
*debug
;
1017 const struct ecoff_debug_swap
*swap
;
1021 const bfd_size_type external_ext_size
= swap
->external_ext_size
;
1022 void (* const swap_ext_out
) PARAMS ((bfd
*, const EXTR
*, PTR
))
1023 = swap
->swap_ext_out
;
1024 HDRR
* const symhdr
= &debug
->symbolic_header
;
1027 namelen
= strlen (name
);
1029 if (debug
->ssext_end
- debug
->ssext
1030 < symhdr
->issExtMax
+ namelen
+ 1)
1032 if (ecoff_add_bytes ((char **) &debug
->ssext
,
1033 (char **) &debug
->ssext_end
,
1034 symhdr
->issExtMax
+ namelen
+ 1)
1038 if ((char *) debug
->external_ext_end
- (char *) debug
->external_ext
1039 < (symhdr
->iextMax
+ 1) * external_ext_size
)
1041 if (ecoff_add_bytes ((char **) &debug
->external_ext
,
1042 (char **) &debug
->external_ext_end
,
1043 (symhdr
->iextMax
+ 1) * external_ext_size
)
1048 esym
->asym
.iss
= symhdr
->issExtMax
;
1050 (*swap_ext_out
) (abfd
, esym
,
1051 ((char *) debug
->external_ext
1052 + symhdr
->iextMax
* swap
->external_ext_size
));
1056 strcpy (debug
->ssext
+ symhdr
->issExtMax
, name
);
1057 symhdr
->issExtMax
+= namelen
+ 1;
1062 /* Align the ECOFF debugging information. */
1066 ecoff_align_debug (abfd
, debug
, swap
)
1068 struct ecoff_debug_info
*debug
;
1069 const struct ecoff_debug_swap
*swap
;
1071 HDRR
* const symhdr
= &debug
->symbolic_header
;
1072 bfd_size_type debug_align
, aux_align
, rfd_align
;
1075 /* Adjust the counts so that structures are aligned. */
1076 debug_align
= swap
->debug_align
;
1077 aux_align
= debug_align
/ sizeof (union aux_ext
);
1078 rfd_align
= debug_align
/ swap
->external_rfd_size
;
1080 add
= debug_align
- (symhdr
->cbLine
& (debug_align
- 1));
1081 if (add
!= debug_align
)
1083 if (debug
->line
!= (unsigned char *) NULL
)
1084 memset (debug
->line
+ symhdr
->cbLine
, 0, add
);
1085 symhdr
->cbLine
+= add
;
1088 add
= debug_align
- (symhdr
->issMax
& (debug_align
- 1));
1089 if (add
!= debug_align
)
1091 if (debug
->ss
!= (char *) NULL
)
1092 memset (debug
->ss
+ symhdr
->issMax
, 0, add
);
1093 symhdr
->issMax
+= add
;
1096 add
= debug_align
- (symhdr
->issExtMax
& (debug_align
- 1));
1097 if (add
!= debug_align
)
1099 if (debug
->ssext
!= (char *) NULL
)
1100 memset (debug
->ssext
+ symhdr
->issExtMax
, 0, add
);
1101 symhdr
->issExtMax
+= add
;
1104 add
= aux_align
- (symhdr
->iauxMax
& (aux_align
- 1));
1105 if (add
!= aux_align
)
1107 if (debug
->external_aux
!= (union aux_ext
*) NULL
)
1108 memset (debug
->external_aux
+ symhdr
->iauxMax
, 0,
1109 add
* sizeof (union aux_ext
));
1110 symhdr
->iauxMax
+= add
;
1113 add
= rfd_align
- (symhdr
->crfd
& (rfd_align
- 1));
1114 if (add
!= rfd_align
)
1116 if (debug
->external_rfd
!= (PTR
) NULL
)
1117 memset (((char *) debug
->external_rfd
1118 + symhdr
->crfd
* swap
->external_rfd_size
),
1119 0, add
* swap
->external_rfd_size
);
1120 symhdr
->crfd
+= add
;
1124 /* Return the size required by the ECOFF debugging information. */
1127 bfd_ecoff_debug_size (abfd
, debug
, swap
)
1129 struct ecoff_debug_info
*debug
;
1130 const struct ecoff_debug_swap
*swap
;
1134 ecoff_align_debug (abfd
, debug
, swap
);
1135 tot
= swap
->external_hdr_size
;
1137 #define ADD(count, size) \
1138 tot += debug->symbolic_header.count * size
1140 ADD (cbLine
, sizeof (unsigned char));
1141 ADD (idnMax
, swap
->external_dnr_size
);
1142 ADD (ipdMax
, swap
->external_pdr_size
);
1143 ADD (isymMax
, swap
->external_sym_size
);
1144 ADD (ioptMax
, swap
->external_opt_size
);
1145 ADD (iauxMax
, sizeof (union aux_ext
));
1146 ADD (issMax
, sizeof (char));
1147 ADD (issExtMax
, sizeof (char));
1148 ADD (ifdMax
, swap
->external_fdr_size
);
1149 ADD (crfd
, swap
->external_rfd_size
);
1150 ADD (iextMax
, swap
->external_ext_size
);
1157 /* Write out the ECOFF symbolic header, given the file position it is
1158 going to be placed at. This assumes that the counts are set
1162 ecoff_write_symhdr (abfd
, debug
, swap
, where
)
1164 struct ecoff_debug_info
*debug
;
1165 const struct ecoff_debug_swap
*swap
;
1168 HDRR
* const symhdr
= &debug
->symbolic_header
;
1171 ecoff_align_debug (abfd
, debug
, swap
);
1173 /* Go to the right location in the file. */
1174 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1177 where
+= swap
->external_hdr_size
;
1179 /* Fill in the file offsets. */
1180 #define SET(offset, count, size) \
1181 if (symhdr->count == 0) \
1182 symhdr->offset = 0; \
1185 symhdr->offset = where; \
1186 where += symhdr->count * size; \
1189 SET (cbLineOffset
, cbLine
, sizeof (unsigned char));
1190 SET (cbDnOffset
, idnMax
, swap
->external_dnr_size
);
1191 SET (cbPdOffset
, ipdMax
, swap
->external_pdr_size
);
1192 SET (cbSymOffset
, isymMax
, swap
->external_sym_size
);
1193 SET (cbOptOffset
, ioptMax
, swap
->external_opt_size
);
1194 SET (cbAuxOffset
, iauxMax
, sizeof (union aux_ext
));
1195 SET (cbSsOffset
, issMax
, sizeof (char));
1196 SET (cbSsExtOffset
, issExtMax
, sizeof (char));
1197 SET (cbFdOffset
, ifdMax
, swap
->external_fdr_size
);
1198 SET (cbRfdOffset
, crfd
, swap
->external_rfd_size
);
1199 SET (cbExtOffset
, iextMax
, swap
->external_ext_size
);
1202 buff
= (PTR
) alloca (swap
->external_hdr_size
);
1203 (*swap
->swap_hdr_out
) (abfd
, symhdr
, buff
);
1204 if (bfd_write (buff
, 1, swap
->external_hdr_size
, abfd
)
1205 != swap
->external_hdr_size
)
1211 /* Write out the ECOFF debugging information. This function assumes
1212 that the information (the pointers and counts) in *DEBUG have been
1213 set correctly. WHERE is the position in the file to write the
1214 information to. This function fills in the file offsets in the
1218 bfd_ecoff_write_debug (abfd
, debug
, swap
, where
)
1220 struct ecoff_debug_info
*debug
;
1221 const struct ecoff_debug_swap
*swap
;
1224 HDRR
* const symhdr
= &debug
->symbolic_header
;
1226 if (! ecoff_write_symhdr (abfd
, debug
, swap
, where
))
1229 #define WRITE(ptr, count, size, offset) \
1230 BFD_ASSERT (symhdr->offset == 0 || bfd_tell (abfd) == symhdr->offset); \
1231 if (bfd_write ((PTR) debug->ptr, size, symhdr->count, abfd) \
1232 != size * symhdr->count) \
1235 WRITE (line
, cbLine
, sizeof (unsigned char), cbLineOffset
);
1236 WRITE (external_dnr
, idnMax
, swap
->external_dnr_size
, cbDnOffset
);
1237 WRITE (external_pdr
, ipdMax
, swap
->external_pdr_size
, cbPdOffset
);
1238 WRITE (external_sym
, isymMax
, swap
->external_sym_size
, cbSymOffset
);
1239 WRITE (external_opt
, ioptMax
, swap
->external_opt_size
, cbOptOffset
);
1240 WRITE (external_aux
, iauxMax
, sizeof (union aux_ext
), cbAuxOffset
);
1241 WRITE (ss
, issMax
, sizeof (char), cbSsOffset
);
1242 WRITE (ssext
, issExtMax
, sizeof (char), cbSsExtOffset
);
1243 WRITE (external_fdr
, ifdMax
, swap
->external_fdr_size
, cbFdOffset
);
1244 WRITE (external_rfd
, crfd
, swap
->external_rfd_size
, cbRfdOffset
);
1245 WRITE (external_ext
, iextMax
, swap
->external_ext_size
, cbExtOffset
);
1251 /* Write out a shuffle list. */
1253 static boolean ecoff_write_shuffle
PARAMS ((bfd
*,
1254 const struct ecoff_debug_swap
*,
1255 struct shuffle
*, PTR space
));
1258 ecoff_write_shuffle (abfd
, swap
, shuffle
, space
)
1260 const struct ecoff_debug_swap
*swap
;
1261 struct shuffle
*shuffle
;
1264 register struct shuffle
*l
;
1265 unsigned long total
;
1268 for (l
= shuffle
; l
!= (struct shuffle
*) NULL
; l
= l
->next
)
1272 if (bfd_write (l
->u
.memory
, 1, l
->size
, abfd
) != l
->size
)
1277 if (bfd_seek (l
->u
.file
.input_bfd
, l
->u
.file
.offset
, SEEK_SET
) != 0
1278 || bfd_read (space
, 1, l
->size
, l
->u
.file
.input_bfd
) != l
->size
1279 || bfd_write (space
, 1, l
->size
, abfd
) != l
->size
)
1285 if ((total
& (swap
->debug_align
- 1)) != 0)
1290 i
= swap
->debug_align
- (total
& (swap
->debug_align
- 1));
1291 s
= (bfd_byte
*) alloca (i
);
1293 if (bfd_write ((PTR
) s
, 1, i
, abfd
) != i
)
1300 /* Write out debugging information using accumulated linker
1304 bfd_ecoff_write_accumulated_debug (handle
, abfd
, debug
, swap
, info
, where
)
1307 struct ecoff_debug_info
*debug
;
1308 const struct ecoff_debug_swap
*swap
;
1309 struct bfd_link_info
*info
;
1312 struct accumulate
*ainfo
= (struct accumulate
*) handle
;
1315 if (! ecoff_write_symhdr (abfd
, debug
, swap
, where
))
1318 space
= (PTR
) alloca (ainfo
->largest_file_shuffle
);
1320 if (! ecoff_write_shuffle (abfd
, swap
, ainfo
->line
, space
)
1321 || ! ecoff_write_shuffle (abfd
, swap
, ainfo
->pdr
, space
)
1322 || ! ecoff_write_shuffle (abfd
, swap
, ainfo
->sym
, space
)
1323 || ! ecoff_write_shuffle (abfd
, swap
, ainfo
->opt
, space
)
1324 || ! ecoff_write_shuffle (abfd
, swap
, ainfo
->aux
, space
))
1327 /* The string table is written out from the hash table if this is a
1329 if (info
->relocateable
)
1331 BFD_ASSERT (ainfo
->ss_hash
== (struct string_hash_entry
*) NULL
);
1332 if (! ecoff_write_shuffle (abfd
, swap
, ainfo
->ss
, space
))
1337 unsigned long total
;
1339 struct string_hash_entry
*sh
;
1341 BFD_ASSERT (ainfo
->ss
== (struct shuffle
*) NULL
);
1343 if (bfd_write ((PTR
) &null
, 1, 1, abfd
) != 1)
1346 BFD_ASSERT (ainfo
->ss_hash
== NULL
|| ainfo
->ss_hash
->val
== 1);
1347 for (sh
= ainfo
->ss_hash
;
1348 sh
!= (struct string_hash_entry
*) NULL
;
1353 len
= strlen (sh
->root
.string
);
1354 if (bfd_write ((PTR
) sh
->root
.string
, 1, len
+ 1, abfd
) != len
+ 1)
1359 if ((total
& (swap
->debug_align
- 1)) != 0)
1364 i
= swap
->debug_align
- (total
& (swap
->debug_align
- 1));
1365 s
= (bfd_byte
*) alloca (i
);
1367 if (bfd_write ((PTR
) s
, 1, i
, abfd
) != i
)
1372 /* The external strings and symbol are not converted over to using
1373 shuffles. FIXME: They probably should be. */
1374 if (bfd_write (debug
->ssext
, 1, debug
->symbolic_header
.issExtMax
, abfd
)
1375 != debug
->symbolic_header
.issExtMax
)
1377 if ((debug
->symbolic_header
.issExtMax
& (swap
->debug_align
- 1)) != 0)
1382 i
= (swap
->debug_align
1383 - (debug
->symbolic_header
.issExtMax
& (swap
->debug_align
- 1)));
1384 s
= (bfd_byte
*) alloca (i
);
1386 if (bfd_write ((PTR
) s
, 1, i
, abfd
) != i
)
1390 if (! ecoff_write_shuffle (abfd
, swap
, ainfo
->fdr
, space
)
1391 || ! ecoff_write_shuffle (abfd
, swap
, ainfo
->rfd
, space
))
1394 BFD_ASSERT (debug
->symbolic_header
.cbExtOffset
== 0
1395 || debug
->symbolic_header
.cbExtOffset
== bfd_tell (abfd
));
1397 if (bfd_write (debug
->external_ext
, swap
->external_ext_size
,
1398 debug
->symbolic_header
.iextMax
, abfd
)
1399 != debug
->symbolic_header
.iextMax
* swap
->external_ext_size
)