1/* Routines to link ECOFF debugging information. 2 Copyright 1993, 1994, 1995, 1996, 1997, 2000, 2001, 2002, 2003, 2004 3 Free Software Foundation, Inc. 4 Written by Ian Lance Taylor, Cygnus Support, <ian@cygnus.com>. 5 6 This file is part of BFD, the Binary File Descriptor library. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 21 22#include "bfd.h" 23#include "sysdep.h" 24#include "bfdlink.h" 25#include "libbfd.h" 26#include "objalloc.h" 27#include "aout/stab_gnu.h" 28#include "coff/internal.h" 29#include "coff/sym.h" 30#include "coff/symconst.h" 31#include "coff/ecoff.h" 32#include "libcoff.h" 33#include "libecoff.h" 34 35static bfd_boolean ecoff_add_bytes 36 PARAMS ((char **buf, char **bufend, size_t need)); 37static struct bfd_hash_entry *string_hash_newfunc 38 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, 39 const char *)); 40static void ecoff_align_debug 41 PARAMS ((bfd *abfd, struct ecoff_debug_info *debug, 42 const struct ecoff_debug_swap *swap)); 43static bfd_boolean ecoff_write_symhdr 44 PARAMS ((bfd *, struct ecoff_debug_info *, const struct ecoff_debug_swap *, 45 file_ptr where)); 46static int cmp_fdrtab_entry 47 PARAMS ((const PTR, const PTR)); 48static bfd_boolean mk_fdrtab 49 PARAMS ((bfd *, struct ecoff_debug_info * const, 50 const struct ecoff_debug_swap * const, struct ecoff_find_line *)); 51static long fdrtab_lookup 52 PARAMS ((struct ecoff_find_line *, bfd_vma)); 53static bfd_boolean lookup_line 54 PARAMS ((bfd *, struct ecoff_debug_info * const, 55 const struct ecoff_debug_swap * const, struct ecoff_find_line *)); 56 57/* Routines to swap auxiliary information in and out. I am assuming 58 that the auxiliary information format is always going to be target 59 independent. */ 60 61/* Swap in a type information record. 62 BIGEND says whether AUX symbols are big-endian or little-endian; this 63 info comes from the file header record (fh-fBigendian). */ 64 65void 66_bfd_ecoff_swap_tir_in (bigend, ext_copy, intern) 67 int bigend; 68 const struct tir_ext *ext_copy; 69 TIR *intern; 70{ 71 struct tir_ext ext[1]; 72 73 *ext = *ext_copy; /* Make it reasonable to do in-place. */ 74 75 /* now the fun stuff... */ 76 if (bigend) { 77 intern->fBitfield = 0 != (ext->t_bits1[0] & TIR_BITS1_FBITFIELD_BIG); 78 intern->continued = 0 != (ext->t_bits1[0] & TIR_BITS1_CONTINUED_BIG); 79 intern->bt = (ext->t_bits1[0] & TIR_BITS1_BT_BIG) 80 >> TIR_BITS1_BT_SH_BIG; 81 intern->tq4 = (ext->t_tq45[0] & TIR_BITS_TQ4_BIG) 82 >> TIR_BITS_TQ4_SH_BIG; 83 intern->tq5 = (ext->t_tq45[0] & TIR_BITS_TQ5_BIG) 84 >> TIR_BITS_TQ5_SH_BIG; 85 intern->tq0 = (ext->t_tq01[0] & TIR_BITS_TQ0_BIG) 86 >> TIR_BITS_TQ0_SH_BIG; 87 intern->tq1 = (ext->t_tq01[0] & TIR_BITS_TQ1_BIG) 88 >> TIR_BITS_TQ1_SH_BIG; 89 intern->tq2 = (ext->t_tq23[0] & TIR_BITS_TQ2_BIG) 90 >> TIR_BITS_TQ2_SH_BIG; 91 intern->tq3 = (ext->t_tq23[0] & TIR_BITS_TQ3_BIG) 92 >> TIR_BITS_TQ3_SH_BIG; 93 } else { 94 intern->fBitfield = 0 != (ext->t_bits1[0] & TIR_BITS1_FBITFIELD_LITTLE); 95 intern->continued = 0 != (ext->t_bits1[0] & TIR_BITS1_CONTINUED_LITTLE); 96 intern->bt = (ext->t_bits1[0] & TIR_BITS1_BT_LITTLE) 97 >> TIR_BITS1_BT_SH_LITTLE; 98 intern->tq4 = (ext->t_tq45[0] & TIR_BITS_TQ4_LITTLE) 99 >> TIR_BITS_TQ4_SH_LITTLE; 100 intern->tq5 = (ext->t_tq45[0] & TIR_BITS_TQ5_LITTLE) 101 >> TIR_BITS_TQ5_SH_LITTLE; 102 intern->tq0 = (ext->t_tq01[0] & TIR_BITS_TQ0_LITTLE) 103 >> TIR_BITS_TQ0_SH_LITTLE; 104 intern->tq1 = (ext->t_tq01[0] & TIR_BITS_TQ1_LITTLE) 105 >> TIR_BITS_TQ1_SH_LITTLE; 106 intern->tq2 = (ext->t_tq23[0] & TIR_BITS_TQ2_LITTLE) 107 >> TIR_BITS_TQ2_SH_LITTLE; 108 intern->tq3 = (ext->t_tq23[0] & TIR_BITS_TQ3_LITTLE) 109 >> TIR_BITS_TQ3_SH_LITTLE; 110 } 111 112#ifdef TEST 113 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0) 114 abort (); 115#endif 116} 117 118/* Swap out a type information record. 119 BIGEND says whether AUX symbols are big-endian or little-endian; this 120 info comes from the file header record (fh-fBigendian). */ 121 122void 123_bfd_ecoff_swap_tir_out (bigend, intern_copy, ext) 124 int bigend; 125 const TIR *intern_copy; 126 struct tir_ext *ext; 127{ 128 TIR intern[1]; 129 130 *intern = *intern_copy; /* Make it reasonable to do in-place. */ 131 132 /* now the fun stuff... */ 133 if (bigend) { 134 ext->t_bits1[0] = ((intern->fBitfield ? TIR_BITS1_FBITFIELD_BIG : 0) 135 | (intern->continued ? TIR_BITS1_CONTINUED_BIG : 0) 136 | ((intern->bt << TIR_BITS1_BT_SH_BIG) 137 & TIR_BITS1_BT_BIG)); 138 ext->t_tq45[0] = (((intern->tq4 << TIR_BITS_TQ4_SH_BIG) 139 & TIR_BITS_TQ4_BIG) 140 | ((intern->tq5 << TIR_BITS_TQ5_SH_BIG) 141 & TIR_BITS_TQ5_BIG)); 142 ext->t_tq01[0] = (((intern->tq0 << TIR_BITS_TQ0_SH_BIG) 143 & TIR_BITS_TQ0_BIG) 144 | ((intern->tq1 << TIR_BITS_TQ1_SH_BIG) 145 & TIR_BITS_TQ1_BIG)); 146 ext->t_tq23[0] = (((intern->tq2 << TIR_BITS_TQ2_SH_BIG) 147 & TIR_BITS_TQ2_BIG) 148 | ((intern->tq3 << TIR_BITS_TQ3_SH_BIG) 149 & TIR_BITS_TQ3_BIG)); 150 } else { 151 ext->t_bits1[0] = ((intern->fBitfield ? TIR_BITS1_FBITFIELD_LITTLE : 0) 152 | (intern->continued ? TIR_BITS1_CONTINUED_LITTLE : 0) 153 | ((intern->bt << TIR_BITS1_BT_SH_LITTLE) 154 & TIR_BITS1_BT_LITTLE)); 155 ext->t_tq45[0] = (((intern->tq4 << TIR_BITS_TQ4_SH_LITTLE) 156 & TIR_BITS_TQ4_LITTLE) 157 | ((intern->tq5 << TIR_BITS_TQ5_SH_LITTLE) 158 & TIR_BITS_TQ5_LITTLE)); 159 ext->t_tq01[0] = (((intern->tq0 << TIR_BITS_TQ0_SH_LITTLE) 160 & TIR_BITS_TQ0_LITTLE) 161 | ((intern->tq1 << TIR_BITS_TQ1_SH_LITTLE) 162 & TIR_BITS_TQ1_LITTLE)); 163 ext->t_tq23[0] = (((intern->tq2 << TIR_BITS_TQ2_SH_LITTLE) 164 & TIR_BITS_TQ2_LITTLE) 165 | ((intern->tq3 << TIR_BITS_TQ3_SH_LITTLE) 166 & TIR_BITS_TQ3_LITTLE)); 167 } 168 169#ifdef TEST 170 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0) 171 abort (); 172#endif 173} 174 175/* Swap in a relative symbol record. BIGEND says whether it is in 176 big-endian or little-endian format.*/ 177 178void 179_bfd_ecoff_swap_rndx_in (bigend, ext_copy, intern) 180 int bigend; 181 const struct rndx_ext *ext_copy; 182 RNDXR *intern; 183{ 184 struct rndx_ext ext[1]; 185 186 *ext = *ext_copy; /* Make it reasonable to do in-place. */ 187 188 /* now the fun stuff... */ 189 if (bigend) { 190 intern->rfd = (ext->r_bits[0] << RNDX_BITS0_RFD_SH_LEFT_BIG) 191 | ((ext->r_bits[1] & RNDX_BITS1_RFD_BIG) 192 >> RNDX_BITS1_RFD_SH_BIG); 193 intern->index = ((ext->r_bits[1] & RNDX_BITS1_INDEX_BIG) 194 << RNDX_BITS1_INDEX_SH_LEFT_BIG) 195 | (ext->r_bits[2] << RNDX_BITS2_INDEX_SH_LEFT_BIG) 196 | (ext->r_bits[3] << RNDX_BITS3_INDEX_SH_LEFT_BIG); 197 } else { 198 intern->rfd = (ext->r_bits[0] << RNDX_BITS0_RFD_SH_LEFT_LITTLE) 199 | ((ext->r_bits[1] & RNDX_BITS1_RFD_LITTLE) 200 << RNDX_BITS1_RFD_SH_LEFT_LITTLE); 201 intern->index = ((ext->r_bits[1] & RNDX_BITS1_INDEX_LITTLE) 202 >> RNDX_BITS1_INDEX_SH_LITTLE) 203 | (ext->r_bits[2] << RNDX_BITS2_INDEX_SH_LEFT_LITTLE) 204 | ((unsigned int) ext->r_bits[3] 205 << RNDX_BITS3_INDEX_SH_LEFT_LITTLE); 206 } 207 208#ifdef TEST 209 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0) 210 abort (); 211#endif 212} 213 214/* Swap out a relative symbol record. BIGEND says whether it is in 215 big-endian or little-endian format.*/ 216 217void 218_bfd_ecoff_swap_rndx_out (bigend, intern_copy, ext) 219 int bigend; 220 const RNDXR *intern_copy; 221 struct rndx_ext *ext; 222{ 223 RNDXR intern[1]; 224 225 *intern = *intern_copy; /* Make it reasonable to do in-place. */ 226 227 /* now the fun stuff... */ 228 if (bigend) { 229 ext->r_bits[0] = intern->rfd >> RNDX_BITS0_RFD_SH_LEFT_BIG; 230 ext->r_bits[1] = (((intern->rfd << RNDX_BITS1_RFD_SH_BIG) 231 & RNDX_BITS1_RFD_BIG) 232 | ((intern->index >> RNDX_BITS1_INDEX_SH_LEFT_BIG) 233 & RNDX_BITS1_INDEX_BIG)); 234 ext->r_bits[2] = intern->index >> RNDX_BITS2_INDEX_SH_LEFT_BIG; 235 ext->r_bits[3] = intern->index >> RNDX_BITS3_INDEX_SH_LEFT_BIG; 236 } else { 237 ext->r_bits[0] = intern->rfd >> RNDX_BITS0_RFD_SH_LEFT_LITTLE; 238 ext->r_bits[1] = (((intern->rfd >> RNDX_BITS1_RFD_SH_LEFT_LITTLE) 239 & RNDX_BITS1_RFD_LITTLE) 240 | ((intern->index << RNDX_BITS1_INDEX_SH_LITTLE) 241 & RNDX_BITS1_INDEX_LITTLE)); 242 ext->r_bits[2] = intern->index >> RNDX_BITS2_INDEX_SH_LEFT_LITTLE; 243 ext->r_bits[3] = intern->index >> RNDX_BITS3_INDEX_SH_LEFT_LITTLE; 244 } 245 246#ifdef TEST 247 if (memcmp ((char *)ext, (char *)intern, sizeof (*intern)) != 0) 248 abort (); 249#endif 250} 251 252/* The minimum amount of data to allocate. */ 253#define ALLOC_SIZE (4064) 254 255/* Add bytes to a buffer. Return success. */ 256 257static bfd_boolean 258ecoff_add_bytes (buf, bufend, need) 259 char **buf; 260 char **bufend; 261 size_t need; 262{ 263 size_t have; 264 size_t want; 265 char *newbuf; 266 267 have = *bufend - *buf; 268 if (have > need) 269 want = ALLOC_SIZE; 270 else 271 { 272 want = need - have; 273 if (want < ALLOC_SIZE) 274 want = ALLOC_SIZE; 275 } 276 newbuf = (char *) bfd_realloc (*buf, (bfd_size_type) have + want); 277 if (newbuf == NULL) 278 return FALSE; 279 *buf = newbuf; 280 *bufend = *buf + have + want; 281 return TRUE; 282} 283 284/* We keep a hash table which maps strings to numbers. We use it to 285 map FDR names to indices in the output file, and to map local 286 strings when combining stabs debugging information. */ 287 288struct string_hash_entry 289{ 290 struct bfd_hash_entry root; 291 /* FDR index or string table offset. */ 292 long val; 293 /* Next entry in string table. */ 294 struct string_hash_entry *next; 295}; 296 297struct string_hash_table 298{ 299 struct bfd_hash_table table; 300}; 301 302/* Routine to create an entry in a string hash table. */ 303 304static struct bfd_hash_entry * 305string_hash_newfunc (entry, table, string) 306 struct bfd_hash_entry *entry; 307 struct bfd_hash_table *table; 308 const char *string; 309{ 310 struct string_hash_entry *ret = (struct string_hash_entry *) entry; 311 312 /* Allocate the structure if it has not already been allocated by a 313 subclass. */ 314 if (ret == (struct string_hash_entry *) NULL) 315 ret = ((struct string_hash_entry *) 316 bfd_hash_allocate (table, sizeof (struct string_hash_entry))); 317 if (ret == (struct string_hash_entry *) NULL) 318 return NULL; 319 320 /* Call the allocation method of the superclass. */ 321 ret = ((struct string_hash_entry *) 322 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); 323 324 if (ret) 325 { 326 /* Initialize the local fields. */ 327 ret->val = -1; 328 ret->next = NULL; 329 } 330 331 return (struct bfd_hash_entry *) ret; 332} 333 334/* Look up an entry in an string hash table. */ 335 336#define string_hash_lookup(t, string, create, copy) \ 337 ((struct string_hash_entry *) \ 338 bfd_hash_lookup (&(t)->table, (string), (create), (copy))) 339 340/* We can't afford to read in all the debugging information when we do 341 a link. Instead, we build a list of these structures to show how 342 different parts of the input file map to the output file. */ 343 344struct shuffle 345{ 346 /* The next entry in this linked list. */ 347 struct shuffle *next; 348 /* The length of the information. */ 349 unsigned long size; 350 /* Whether this information comes from a file or not. */ 351 bfd_boolean filep; 352 union 353 { 354 struct 355 { 356 /* The BFD the data comes from. */ 357 bfd *input_bfd; 358 /* The offset within input_bfd. */ 359 file_ptr offset; 360 } file; 361 /* The data to be written out. */ 362 PTR memory; 363 } u; 364}; 365 366/* This structure holds information across calls to 367 bfd_ecoff_debug_accumulate. */ 368 369struct accumulate 370{ 371 /* The FDR hash table. */ 372 struct string_hash_table fdr_hash; 373 /* The strings hash table. */ 374 struct string_hash_table str_hash; 375 /* Linked lists describing how to shuffle the input debug 376 information into the output file. We keep a pointer to both the 377 head and the tail. */ 378 struct shuffle *line; 379 struct shuffle *line_end; 380 struct shuffle *pdr; 381 struct shuffle *pdr_end; 382 struct shuffle *sym; 383 struct shuffle *sym_end; 384 struct shuffle *opt; 385 struct shuffle *opt_end; 386 struct shuffle *aux; 387 struct shuffle *aux_end; 388 struct shuffle *ss; 389 struct shuffle *ss_end; 390 struct string_hash_entry *ss_hash; 391 struct string_hash_entry *ss_hash_end; 392 struct shuffle *fdr; 393 struct shuffle *fdr_end; 394 struct shuffle *rfd; 395 struct shuffle *rfd_end; 396 /* The size of the largest file shuffle. */ 397 unsigned long largest_file_shuffle; 398 /* An objalloc for debugging information. */ 399 struct objalloc *memory; 400}; 401 402/* Add a file entry to a shuffle list. */ 403 404static bfd_boolean add_file_shuffle 405 PARAMS ((struct accumulate *, struct shuffle **, struct shuffle **, 406 bfd *, file_ptr, unsigned long)); 407 408static bfd_boolean 409add_file_shuffle (ainfo, head, tail, input_bfd, offset, size) 410 struct accumulate *ainfo; 411 struct shuffle **head; 412 struct shuffle **tail; 413 bfd *input_bfd; 414 file_ptr offset; 415 unsigned long size; 416{ 417 struct shuffle *n; 418 419 if (*tail != (struct shuffle *) NULL 420 && (*tail)->filep 421 && (*tail)->u.file.input_bfd == input_bfd 422 && (*tail)->u.file.offset + (*tail)->size == (unsigned long) offset) 423 { 424 /* Just merge this entry onto the existing one. */ 425 (*tail)->size += size; 426 if ((*tail)->size > ainfo->largest_file_shuffle) 427 ainfo->largest_file_shuffle = (*tail)->size; 428 return TRUE; 429 } 430 431 n = (struct shuffle *) objalloc_alloc (ainfo->memory, 432 sizeof (struct shuffle)); 433 if (!n) 434 { 435 bfd_set_error (bfd_error_no_memory); 436 return FALSE; 437 } 438 n->next = NULL; 439 n->size = size; 440 n->filep = TRUE; 441 n->u.file.input_bfd = input_bfd; 442 n->u.file.offset = offset; 443 if (*head == (struct shuffle *) NULL) 444 *head = n; 445 if (*tail != (struct shuffle *) NULL) 446 (*tail)->next = n; 447 *tail = n; 448 if (size > ainfo->largest_file_shuffle) 449 ainfo->largest_file_shuffle = size; 450 return TRUE; 451} 452 453/* Add a memory entry to a shuffle list. */ 454 455static bfd_boolean add_memory_shuffle 456 PARAMS ((struct accumulate *, struct shuffle **head, struct shuffle **tail, 457 bfd_byte *data, unsigned long size)); 458 459static bfd_boolean 460add_memory_shuffle (ainfo, head, tail, data, size) 461 struct accumulate *ainfo; 462 struct shuffle **head; 463 struct shuffle **tail; 464 bfd_byte *data; 465 unsigned long size; 466{ 467 struct shuffle *n; 468 469 n = (struct shuffle *) objalloc_alloc (ainfo->memory, 470 sizeof (struct shuffle)); 471 if (!n) 472 { 473 bfd_set_error (bfd_error_no_memory); 474 return FALSE; 475 } 476 n->next = NULL; 477 n->size = size; 478 n->filep = FALSE; 479 n->u.memory = (PTR) data; 480 if (*head == (struct shuffle *) NULL) 481 *head = n; 482 if (*tail != (struct shuffle *) NULL) 483 (*tail)->next = n; 484 *tail = n; 485 return TRUE; 486} 487 488/* Initialize the FDR hash table. This returns a handle which is then 489 passed in to bfd_ecoff_debug_accumulate, et. al. */ 490 491PTR 492bfd_ecoff_debug_init (output_bfd, output_debug, output_swap, info) 493 bfd *output_bfd ATTRIBUTE_UNUSED; 494 struct ecoff_debug_info *output_debug; 495 const struct ecoff_debug_swap *output_swap ATTRIBUTE_UNUSED; 496 struct bfd_link_info *info; 497{ 498 struct accumulate *ainfo; 499 bfd_size_type amt = sizeof (struct accumulate); 500 501 ainfo = (struct accumulate *) bfd_malloc (amt); 502 if (!ainfo) 503 return NULL; 504 if (! bfd_hash_table_init_n (&ainfo->fdr_hash.table, string_hash_newfunc, 505 1021)) 506 return NULL; 507 508 ainfo->line = NULL; 509 ainfo->line_end = NULL; 510 ainfo->pdr = NULL; 511 ainfo->pdr_end = NULL; 512 ainfo->sym = NULL; 513 ainfo->sym_end = NULL; 514 ainfo->opt = NULL; 515 ainfo->opt_end = NULL; 516 ainfo->aux = NULL; 517 ainfo->aux_end = NULL; 518 ainfo->ss = NULL; 519 ainfo->ss_end = NULL; 520 ainfo->ss_hash = NULL; 521 ainfo->ss_hash_end = NULL; 522 ainfo->fdr = NULL; 523 ainfo->fdr_end = NULL; 524 ainfo->rfd = NULL; 525 ainfo->rfd_end = NULL; 526 527 ainfo->largest_file_shuffle = 0; 528 529 if (! info->relocatable) 530 { 531 if (! bfd_hash_table_init (&ainfo->str_hash.table, string_hash_newfunc)) 532 return NULL; 533 534 /* The first entry in the string table is the empty string. */ 535 output_debug->symbolic_header.issMax = 1; 536 } 537 538 ainfo->memory = objalloc_create (); 539 if (ainfo->memory == NULL) 540 { 541 bfd_set_error (bfd_error_no_memory); 542 return NULL; 543 } 544 545 return (PTR) ainfo; 546} 547 548/* Free the accumulated debugging information. */ 549 550void 551bfd_ecoff_debug_free (handle, output_bfd, output_debug, output_swap, info) 552 PTR handle; 553 bfd *output_bfd ATTRIBUTE_UNUSED; 554 struct ecoff_debug_info *output_debug ATTRIBUTE_UNUSED; 555 const struct ecoff_debug_swap *output_swap ATTRIBUTE_UNUSED; 556 struct bfd_link_info *info; 557{ 558 struct accumulate *ainfo = (struct accumulate *) handle; 559 560 bfd_hash_table_free (&ainfo->fdr_hash.table); 561 562 if (! info->relocatable) 563 bfd_hash_table_free (&ainfo->str_hash.table); 564 565 objalloc_free (ainfo->memory); 566 567 free (ainfo); 568} 569 570/* Accumulate the debugging information from INPUT_BFD into 571 OUTPUT_BFD. The INPUT_DEBUG argument points to some ECOFF 572 debugging information which we want to link into the information 573 pointed to by the OUTPUT_DEBUG argument. OUTPUT_SWAP and 574 INPUT_SWAP point to the swapping information needed. INFO is the 575 linker information structure. HANDLE is returned by 576 bfd_ecoff_debug_init. */ 577 578bfd_boolean 579bfd_ecoff_debug_accumulate (handle, output_bfd, output_debug, output_swap, 580 input_bfd, input_debug, input_swap, 581 info) 582 PTR handle; 583 bfd *output_bfd; 584 struct ecoff_debug_info *output_debug; 585 const struct ecoff_debug_swap *output_swap; 586 bfd *input_bfd; 587 struct ecoff_debug_info *input_debug; 588 const struct ecoff_debug_swap *input_swap; 589 struct bfd_link_info *info; 590{ 591 struct accumulate *ainfo = (struct accumulate *) handle; 592 void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *)) 593 = input_swap->swap_sym_in; 594 void (* const swap_rfd_in) PARAMS ((bfd *, PTR, RFDT *)) 595 = input_swap->swap_rfd_in; 596 void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR)) 597 = output_swap->swap_sym_out; 598 void (* const swap_fdr_out) PARAMS ((bfd *, const FDR *, PTR)) 599 = output_swap->swap_fdr_out; 600 void (* const swap_rfd_out) PARAMS ((bfd *, const RFDT *, PTR)) 601 = output_swap->swap_rfd_out; 602 bfd_size_type external_pdr_size = output_swap->external_pdr_size; 603 bfd_size_type external_sym_size = output_swap->external_sym_size; 604 bfd_size_type external_opt_size = output_swap->external_opt_size; 605 bfd_size_type external_fdr_size = output_swap->external_fdr_size; 606 bfd_size_type external_rfd_size = output_swap->external_rfd_size; 607 HDRR * const output_symhdr = &output_debug->symbolic_header; 608 HDRR * const input_symhdr = &input_debug->symbolic_header; 609 bfd_vma section_adjust[scMax]; 610 asection *sec; 611 bfd_byte *fdr_start; 612 bfd_byte *fdr_ptr; 613 bfd_byte *fdr_end; 614 bfd_size_type fdr_add; 615 unsigned int copied; 616 RFDT i; 617 unsigned long sz; 618 bfd_byte *rfd_out; 619 bfd_byte *rfd_in; 620 bfd_byte *rfd_end; 621 long newrfdbase = 0; 622 long oldrfdbase = 0; 623 bfd_byte *fdr_out; 624 bfd_size_type amt; 625 626 /* Use section_adjust to hold the value to add to a symbol in a 627 particular section. */ 628 memset ((PTR) section_adjust, 0, sizeof section_adjust); 629 630#define SET(name, indx) \ 631 sec = bfd_get_section_by_name (input_bfd, name); \ 632 if (sec != NULL) \ 633 section_adjust[indx] = (sec->output_section->vma \ 634 + sec->output_offset \ 635 - sec->vma); 636 637 SET (".text", scText); 638 SET (".data", scData); 639 SET (".bss", scBss); 640 SET (".sdata", scSData); 641 SET (".sbss", scSBss); 642 /* scRdata section may be either .rdata or .rodata. */ 643 SET (".rdata", scRData); 644 SET (".rodata", scRData); 645 SET (".init", scInit); 646 SET (".fini", scFini); 647 SET (".rconst", scRConst); 648 649#undef SET 650 651 /* Find all the debugging information based on the FDR's. We need 652 to handle them whether they are swapped or not. */ 653 if (input_debug->fdr != (FDR *) NULL) 654 { 655 fdr_start = (bfd_byte *) input_debug->fdr; 656 fdr_add = sizeof (FDR); 657 } 658 else 659 { 660 fdr_start = (bfd_byte *) input_debug->external_fdr; 661 fdr_add = input_swap->external_fdr_size; 662 } 663 fdr_end = fdr_start + input_symhdr->ifdMax * fdr_add; 664 665 amt = input_symhdr->ifdMax; 666 amt *= sizeof (RFDT); 667 input_debug->ifdmap = (RFDT *) bfd_alloc (input_bfd, amt); 668 669 sz = (input_symhdr->crfd + input_symhdr->ifdMax) * external_rfd_size; 670 rfd_out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz); 671 if (!input_debug->ifdmap || !rfd_out) 672 { 673 bfd_set_error (bfd_error_no_memory); 674 return FALSE; 675 } 676 if (!add_memory_shuffle (ainfo, &ainfo->rfd, &ainfo->rfd_end, rfd_out, sz)) 677 return FALSE; 678 679 copied = 0; 680 681 /* Look through the FDR's to see which ones we are going to include 682 in the final output. We do not want duplicate FDR information 683 for header files, because ECOFF debugging is often very large. 684 When we find an FDR with no line information which can be merged, 685 we look it up in a hash table to ensure that we only include it 686 once. We keep a table mapping FDR numbers to the final number 687 they get with the BFD, so that we can refer to it when we write 688 out the external symbols. */ 689 for (fdr_ptr = fdr_start, i = 0; 690 fdr_ptr < fdr_end; 691 fdr_ptr += fdr_add, i++, rfd_out += external_rfd_size) 692 { 693 FDR fdr; 694 695 if (input_debug->fdr != (FDR *) NULL) 696 fdr = *(FDR *) fdr_ptr; 697 else 698 (*input_swap->swap_fdr_in) (input_bfd, (PTR) fdr_ptr, &fdr); 699 700 /* See if this FDR can be merged with an existing one. */ 701 if (fdr.cbLine == 0 && fdr.rss != -1 && fdr.fMerge) 702 { 703 const char *name; 704 char *lookup; 705 struct string_hash_entry *fh; 706 707 /* We look up a string formed from the file name and the 708 number of symbols and aux entries. Sometimes an include 709 file will conditionally define a typedef or something 710 based on the order of include files. Using the number of 711 symbols and aux entries as a hash reduces the chance that 712 we will merge symbol information that should not be 713 merged. */ 714 name = input_debug->ss + fdr.issBase + fdr.rss; 715 716 lookup = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 20); 717 if (lookup == NULL) 718 return FALSE; 719 sprintf (lookup, "%s %lx %lx", name, fdr.csym, fdr.caux); 720 721 fh = string_hash_lookup (&ainfo->fdr_hash, lookup, TRUE, TRUE); 722 free (lookup); 723 if (fh == (struct string_hash_entry *) NULL) 724 return FALSE; 725 726 if (fh->val != -1) 727 { 728 input_debug->ifdmap[i] = fh->val; 729 (*swap_rfd_out) (output_bfd, input_debug->ifdmap + i, 730 (PTR) rfd_out); 731 732 /* Don't copy this FDR. */ 733 continue; 734 } 735 736 fh->val = output_symhdr->ifdMax + copied; 737 } 738 739 input_debug->ifdmap[i] = output_symhdr->ifdMax + copied; 740 (*swap_rfd_out) (output_bfd, input_debug->ifdmap + i, (PTR) rfd_out); 741 ++copied; 742 } 743 744 newrfdbase = output_symhdr->crfd; 745 output_symhdr->crfd += input_symhdr->ifdMax; 746 747 /* Copy over any existing RFD's. RFD's are only created by the 748 linker, so this will only happen for input files which are the 749 result of a partial link. */ 750 rfd_in = (bfd_byte *) input_debug->external_rfd; 751 rfd_end = rfd_in + input_symhdr->crfd * input_swap->external_rfd_size; 752 for (; 753 rfd_in < rfd_end; 754 rfd_in += input_swap->external_rfd_size) 755 { 756 RFDT rfd; 757 758 (*swap_rfd_in) (input_bfd, (PTR) rfd_in, &rfd); 759 BFD_ASSERT (rfd >= 0 && rfd < input_symhdr->ifdMax); 760 rfd = input_debug->ifdmap[rfd]; 761 (*swap_rfd_out) (output_bfd, &rfd, (PTR) rfd_out); 762 rfd_out += external_rfd_size; 763 } 764 765 oldrfdbase = output_symhdr->crfd; 766 output_symhdr->crfd += input_symhdr->crfd; 767 768 /* Look through the FDR's and copy over all associated debugging 769 information. */ 770 sz = copied * external_fdr_size; 771 fdr_out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz); 772 if (!fdr_out) 773 { 774 bfd_set_error (bfd_error_no_memory); 775 return FALSE; 776 } 777 if (!add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end, fdr_out, sz)) 778 return FALSE; 779 for (fdr_ptr = fdr_start, i = 0; 780 fdr_ptr < fdr_end; 781 fdr_ptr += fdr_add, i++) 782 { 783 FDR fdr; 784 bfd_vma fdr_adr; 785 bfd_byte *sym_out; 786 bfd_byte *lraw_src; 787 bfd_byte *lraw_end; 788 bfd_boolean fgotfilename; 789 790 if (input_debug->ifdmap[i] < output_symhdr->ifdMax) 791 { 792 /* We are not copying this FDR. */ 793 continue; 794 } 795 796 if (input_debug->fdr != (FDR *) NULL) 797 fdr = *(FDR *) fdr_ptr; 798 else 799 (*input_swap->swap_fdr_in) (input_bfd, (PTR) fdr_ptr, &fdr); 800 801 fdr_adr = fdr.adr; 802 803 /* FIXME: It is conceivable that this FDR points to the .init or 804 .fini section, in which case this will not do the right 805 thing. */ 806 fdr.adr += section_adjust[scText]; 807 808 /* Swap in the local symbols, adjust their values, and swap them 809 out again. */ 810 fgotfilename = FALSE; 811 sz = fdr.csym * external_sym_size; 812 sym_out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz); 813 if (!sym_out) 814 { 815 bfd_set_error (bfd_error_no_memory); 816 return FALSE; 817 } 818 if (!add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end, sym_out, 819 sz)) 820 return FALSE; 821 lraw_src = ((bfd_byte *) input_debug->external_sym 822 + fdr.isymBase * input_swap->external_sym_size); 823 lraw_end = lraw_src + fdr.csym * input_swap->external_sym_size; 824 for (; lraw_src < lraw_end; lraw_src += input_swap->external_sym_size) 825 { 826 SYMR internal_sym; 827 828 (*swap_sym_in) (input_bfd, (PTR) lraw_src, &internal_sym); 829 830 BFD_ASSERT (internal_sym.sc != scCommon 831 && internal_sym.sc != scSCommon); 832 833 /* Adjust the symbol value if appropriate. */ 834 switch (internal_sym.st) 835 { 836 case stNil: 837 if (ECOFF_IS_STAB (&internal_sym)) 838 break; 839 /* Fall through. */ 840 case stGlobal: 841 case stStatic: 842 case stLabel: 843 case stProc: 844 case stStaticProc: 845 internal_sym.value += section_adjust[internal_sym.sc]; 846 break; 847 848 default: 849 break; 850 } 851 852 /* If we are doing a final link, we hash all the strings in 853 the local symbol table together. This reduces the amount 854 of space required by debugging information. We don't do 855 this when performing a relocatable link because it would 856 prevent us from easily merging different FDR's. */ 857 if (! info->relocatable) 858 { 859 bfd_boolean ffilename; 860 const char *name; 861 862 if (! fgotfilename && internal_sym.iss == fdr.rss) 863 ffilename = TRUE; 864 else 865 ffilename = FALSE; 866 867 /* Hash the name into the string table. */ 868 name = input_debug->ss + fdr.issBase + internal_sym.iss; 869 if (*name == '\0') 870 internal_sym.iss = 0; 871 else 872 { 873 struct string_hash_entry *sh; 874 875 sh = string_hash_lookup (&ainfo->str_hash, name, TRUE, TRUE); 876 if (sh == (struct string_hash_entry *) NULL) 877 return FALSE; 878 if (sh->val == -1) 879 { 880 sh->val = output_symhdr->issMax; 881 output_symhdr->issMax += strlen (name) + 1; 882 if (ainfo->ss_hash == (struct string_hash_entry *) NULL) 883 ainfo->ss_hash = sh; 884 if (ainfo->ss_hash_end 885 != (struct string_hash_entry *) NULL) 886 ainfo->ss_hash_end->next = sh; 887 ainfo->ss_hash_end = sh; 888 } 889 internal_sym.iss = sh->val; 890 } 891 892 if (ffilename) 893 { 894 fdr.rss = internal_sym.iss; 895 fgotfilename = TRUE; 896 } 897 } 898 899 (*swap_sym_out) (output_bfd, &internal_sym, sym_out); 900 sym_out += external_sym_size; 901 } 902 903 fdr.isymBase = output_symhdr->isymMax; 904 output_symhdr->isymMax += fdr.csym; 905 906 /* Copy the information that does not need swapping. */ 907 908 /* FIXME: If we are relaxing, we need to adjust the line 909 numbers. Frankly, forget it. Anybody using stabs debugging 910 information will not use this line number information, and 911 stabs are adjusted correctly. */ 912 if (fdr.cbLine > 0) 913 { 914 file_ptr pos = input_symhdr->cbLineOffset + fdr.cbLineOffset; 915 if (!add_file_shuffle (ainfo, &ainfo->line, &ainfo->line_end, 916 input_bfd, pos, (unsigned long) fdr.cbLine)) 917 return FALSE; 918 fdr.ilineBase = output_symhdr->ilineMax; 919 fdr.cbLineOffset = output_symhdr->cbLine; 920 output_symhdr->ilineMax += fdr.cline; 921 output_symhdr->cbLine += fdr.cbLine; 922 } 923 if (fdr.caux > 0) 924 { 925 file_ptr pos = (input_symhdr->cbAuxOffset 926 + fdr.iauxBase * sizeof (union aux_ext)); 927 if (!add_file_shuffle (ainfo, &ainfo->aux, &ainfo->aux_end, 928 input_bfd, pos, 929 fdr.caux * sizeof (union aux_ext))) 930 return FALSE; 931 fdr.iauxBase = output_symhdr->iauxMax; 932 output_symhdr->iauxMax += fdr.caux; 933 } 934 if (! info->relocatable) 935 { 936 937 /* When are are hashing strings, we lie about the number of 938 strings attached to each FDR. We need to set cbSs 939 because some versions of dbx apparently use it to decide 940 how much of the string table to read in. */ 941 fdr.issBase = 0; 942 fdr.cbSs = output_symhdr->issMax; 943 } 944 else if (fdr.cbSs > 0) 945 { 946 file_ptr pos = input_symhdr->cbSsOffset + fdr.issBase; 947 if (!add_file_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end, 948 input_bfd, pos, (unsigned long) fdr.cbSs)) 949 return FALSE; 950 fdr.issBase = output_symhdr->issMax; 951 output_symhdr->issMax += fdr.cbSs; 952 } 953 954 if (output_bfd->xvec->header_byteorder 955 == input_bfd->xvec->header_byteorder) 956 { 957 /* The two BFD's have the same endianness, and we don't have 958 to adjust the PDR addresses, so simply copying the 959 information will suffice. */ 960 BFD_ASSERT (external_pdr_size == input_swap->external_pdr_size); 961 if (fdr.cpd > 0) 962 { 963 file_ptr pos = (input_symhdr->cbPdOffset 964 + fdr.ipdFirst * external_pdr_size); 965 unsigned long size = fdr.cpd * external_pdr_size; 966 if (!add_file_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end, 967 input_bfd, pos, size)) 968 return FALSE; 969 } 970 BFD_ASSERT (external_opt_size == input_swap->external_opt_size); 971 if (fdr.copt > 0) 972 { 973 file_ptr pos = (input_symhdr->cbOptOffset 974 + fdr.ioptBase * external_opt_size); 975 unsigned long size = fdr.copt * external_opt_size; 976 if (!add_file_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end, 977 input_bfd, pos, size)) 978 return FALSE; 979 } 980 } 981 else 982 { 983 bfd_size_type outsz, insz; 984 bfd_byte *in; 985 bfd_byte *end; 986 bfd_byte *out; 987 988 /* The two BFD's have different endianness, so we must swap 989 everything in and out. This code would always work, but 990 it would be unnecessarily slow in the normal case. */ 991 outsz = external_pdr_size; 992 insz = input_swap->external_pdr_size; 993 in = ((bfd_byte *) input_debug->external_pdr 994 + fdr.ipdFirst * insz); 995 end = in + fdr.cpd * insz; 996 sz = fdr.cpd * outsz; 997 out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz); 998 if (!out) 999 { 1000 bfd_set_error (bfd_error_no_memory); 1001 return FALSE; 1002 } 1003 if (!add_memory_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end, out, 1004 sz)) 1005 return FALSE; 1006 for (; in < end; in += insz, out += outsz) 1007 { 1008 PDR pdr; 1009 1010 (*input_swap->swap_pdr_in) (input_bfd, (PTR) in, &pdr); 1011 (*output_swap->swap_pdr_out) (output_bfd, &pdr, (PTR) out); 1012 } 1013 1014 /* Swap over the optimization information. */ 1015 outsz = external_opt_size; 1016 insz = input_swap->external_opt_size; 1017 in = ((bfd_byte *) input_debug->external_opt 1018 + fdr.ioptBase * insz); 1019 end = in + fdr.copt * insz; 1020 sz = fdr.copt * outsz; 1021 out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz); 1022 if (!out) 1023 { 1024 bfd_set_error (bfd_error_no_memory); 1025 return FALSE; 1026 } 1027 if (!add_memory_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end, out, 1028 sz)) 1029 return FALSE; 1030 for (; in < end; in += insz, out += outsz) 1031 { 1032 OPTR opt; 1033 1034 (*input_swap->swap_opt_in) (input_bfd, (PTR) in, &opt); 1035 (*output_swap->swap_opt_out) (output_bfd, &opt, (PTR) out); 1036 } 1037 } 1038 1039 fdr.ipdFirst = output_symhdr->ipdMax; 1040 output_symhdr->ipdMax += fdr.cpd; 1041 fdr.ioptBase = output_symhdr->ioptMax; 1042 output_symhdr->ioptMax += fdr.copt; 1043 1044 if (fdr.crfd <= 0) 1045 { 1046 /* Point this FDR at the table of RFD's we created. */ 1047 fdr.rfdBase = newrfdbase; 1048 fdr.crfd = input_symhdr->ifdMax; 1049 } 1050 else 1051 { 1052 /* Point this FDR at the remapped RFD's. */ 1053 fdr.rfdBase += oldrfdbase; 1054 } 1055 1056 (*swap_fdr_out) (output_bfd, &fdr, fdr_out); 1057 fdr_out += external_fdr_size; 1058 ++output_symhdr->ifdMax; 1059 } 1060 1061 return TRUE; 1062} 1063 1064/* Add a string to the debugging information we are accumulating. 1065 Return the offset from the fdr string base. */ 1066 1067static long ecoff_add_string 1068 PARAMS ((struct accumulate *, struct bfd_link_info *, 1069 struct ecoff_debug_info *, FDR *fdr, const char *string)); 1070 1071static long 1072ecoff_add_string (ainfo, info, debug, fdr, string) 1073 struct accumulate *ainfo; 1074 struct bfd_link_info *info; 1075 struct ecoff_debug_info *debug; 1076 FDR *fdr; 1077 const char *string; 1078{ 1079 HDRR *symhdr; 1080 size_t len; 1081 bfd_size_type ret; 1082 1083 symhdr = &debug->symbolic_header; 1084 len = strlen (string); 1085 if (info->relocatable) 1086 { 1087 if (!add_memory_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end, (PTR) string, 1088 len + 1)) 1089 return -1; 1090 ret = symhdr->issMax; 1091 symhdr->issMax += len + 1; 1092 fdr->cbSs += len + 1; 1093 } 1094 else 1095 { 1096 struct string_hash_entry *sh; 1097 1098 sh = string_hash_lookup (&ainfo->str_hash, string, TRUE, TRUE); 1099 if (sh == (struct string_hash_entry *) NULL) 1100 return -1; 1101 if (sh->val == -1) 1102 { 1103 sh->val = symhdr->issMax; 1104 symhdr->issMax += len + 1; 1105 if (ainfo->ss_hash == (struct string_hash_entry *) NULL) 1106 ainfo->ss_hash = sh; 1107 if (ainfo->ss_hash_end 1108 != (struct string_hash_entry *) NULL) 1109 ainfo->ss_hash_end->next = sh; 1110 ainfo->ss_hash_end = sh; 1111 } 1112 ret = sh->val; 1113 } 1114 1115 return ret; 1116} 1117 1118/* Add debugging information from a non-ECOFF file. */ 1119 1120bfd_boolean 1121bfd_ecoff_debug_accumulate_other (handle, output_bfd, output_debug, 1122 output_swap, input_bfd, info) 1123 PTR handle; 1124 bfd *output_bfd; 1125 struct ecoff_debug_info *output_debug; 1126 const struct ecoff_debug_swap *output_swap; 1127 bfd *input_bfd; 1128 struct bfd_link_info *info; 1129{ 1130 struct accumulate *ainfo = (struct accumulate *) handle; 1131 void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR)) 1132 = output_swap->swap_sym_out; 1133 HDRR *output_symhdr = &output_debug->symbolic_header; 1134 FDR fdr; 1135 asection *sec; 1136 asymbol **symbols; 1137 asymbol **sym_ptr; 1138 asymbol **sym_end; 1139 long symsize; 1140 long symcount; 1141 PTR external_fdr; 1142 1143 memset ((PTR) &fdr, 0, sizeof fdr); 1144 1145 sec = bfd_get_section_by_name (input_bfd, ".text"); 1146 if (sec != NULL) 1147 fdr.adr = sec->output_section->vma + sec->output_offset; 1148 else 1149 { 1150 /* FIXME: What about .init or .fini? */ 1151 fdr.adr = 0; 1152 } 1153 1154 fdr.issBase = output_symhdr->issMax; 1155 fdr.cbSs = 0; 1156 fdr.rss = ecoff_add_string (ainfo, info, output_debug, &fdr, 1157 input_bfd->filename); 1158 if (fdr.rss == -1) 1159 return FALSE; 1160 fdr.isymBase = output_symhdr->isymMax; 1161 1162 /* Get the local symbols from the input BFD. */ 1163 symsize = bfd_get_symtab_upper_bound (input_bfd); 1164 if (symsize < 0) 1165 return FALSE; 1166 symbols = (asymbol **) bfd_alloc (output_bfd, (bfd_size_type) symsize); 1167 if (symbols == (asymbol **) NULL) 1168 return FALSE; 1169 symcount = bfd_canonicalize_symtab (input_bfd, symbols); 1170 if (symcount < 0) 1171 return FALSE; 1172 sym_end = symbols + symcount; 1173 1174 /* Handle the local symbols. Any external symbols are handled 1175 separately. */ 1176 fdr.csym = 0; 1177 for (sym_ptr = symbols; sym_ptr != sym_end; sym_ptr++) 1178 { 1179 SYMR internal_sym; 1180 PTR external_sym; 1181 1182 if (((*sym_ptr)->flags & BSF_EXPORT) != 0) 1183 continue; 1184 memset ((PTR) &internal_sym, 0, sizeof internal_sym); 1185 internal_sym.iss = ecoff_add_string (ainfo, info, output_debug, &fdr, 1186 (*sym_ptr)->name); 1187 1188 if (internal_sym.iss == -1) 1189 return FALSE; 1190 if (bfd_is_com_section ((*sym_ptr)->section) 1191 || bfd_is_und_section ((*sym_ptr)->section)) 1192 internal_sym.value = (*sym_ptr)->value; 1193 else 1194 internal_sym.value = ((*sym_ptr)->value 1195 + (*sym_ptr)->section->output_offset 1196 + (*sym_ptr)->section->output_section->vma); 1197 internal_sym.st = stNil; 1198 internal_sym.sc = scUndefined; 1199 internal_sym.index = indexNil; 1200 1201 external_sym = (PTR) objalloc_alloc (ainfo->memory, 1202 output_swap->external_sym_size); 1203 if (!external_sym) 1204 { 1205 bfd_set_error (bfd_error_no_memory); 1206 return FALSE; 1207 } 1208 (*swap_sym_out) (output_bfd, &internal_sym, external_sym); 1209 add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end, 1210 external_sym, 1211 (unsigned long) output_swap->external_sym_size); 1212 ++fdr.csym; 1213 ++output_symhdr->isymMax; 1214 } 1215 1216 bfd_release (output_bfd, (PTR) symbols); 1217 1218 /* Leave everything else in the FDR zeroed out. This will cause 1219 the lang field to be langC. The fBigendian field will 1220 indicate little endian format, but it doesn't matter because 1221 it only applies to aux fields and there are none. */ 1222 external_fdr = (PTR) objalloc_alloc (ainfo->memory, 1223 output_swap->external_fdr_size); 1224 if (!external_fdr) 1225 { 1226 bfd_set_error (bfd_error_no_memory); 1227 return FALSE; 1228 } 1229 (*output_swap->swap_fdr_out) (output_bfd, &fdr, external_fdr); 1230 add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end, 1231 external_fdr, 1232 (unsigned long) output_swap->external_fdr_size); 1233 1234 ++output_symhdr->ifdMax; 1235 1236 return TRUE; 1237} 1238 1239/* Set up ECOFF debugging information for the external symbols. 1240 FIXME: This is done using a memory buffer, but it should be 1241 probably be changed to use a shuffle structure. The assembler uses 1242 this interface, so that must be changed to do something else. */ 1243 1244bfd_boolean 1245bfd_ecoff_debug_externals (abfd, debug, swap, relocatable, get_extr, 1246 set_index) 1247 bfd *abfd; 1248 struct ecoff_debug_info *debug; 1249 const struct ecoff_debug_swap *swap; 1250 bfd_boolean relocatable; 1251 bfd_boolean (*get_extr) PARAMS ((asymbol *, EXTR *)); 1252 void (*set_index) PARAMS ((asymbol *, bfd_size_type)); 1253{ 1254 HDRR * const symhdr = &debug->symbolic_header; 1255 asymbol **sym_ptr_ptr; 1256 size_t c; 1257 1258 sym_ptr_ptr = bfd_get_outsymbols (abfd); 1259 if (sym_ptr_ptr == NULL) 1260 return TRUE; 1261 1262 for (c = bfd_get_symcount (abfd); c > 0; c--, sym_ptr_ptr++) 1263 { 1264 asymbol *sym_ptr; 1265 EXTR esym; 1266 1267 sym_ptr = *sym_ptr_ptr; 1268 1269 /* Get the external symbol information. */ 1270 if (! (*get_extr) (sym_ptr, &esym)) 1271 continue; 1272 1273 /* If we're producing an executable, move common symbols into 1274 bss. */ 1275 if (! relocatable) 1276 { 1277 if (esym.asym.sc == scCommon) 1278 esym.asym.sc = scBss; 1279 else if (esym.asym.sc == scSCommon) 1280 esym.asym.sc = scSBss; 1281 } 1282 1283 if (bfd_is_com_section (sym_ptr->section) 1284 || bfd_is_und_section (sym_ptr->section) 1285 || sym_ptr->section->output_section == (asection *) NULL) 1286 { 1287 /* FIXME: gas does not keep the value of a small undefined 1288 symbol in the symbol itself, because of relocation 1289 problems. */ 1290 if (esym.asym.sc != scSUndefined 1291 || esym.asym.value == 0 1292 || sym_ptr->value != 0) 1293 esym.asym.value = sym_ptr->value; 1294 } 1295 else 1296 esym.asym.value = (sym_ptr->value 1297 + sym_ptr->section->output_offset 1298 + sym_ptr->section->output_section->vma); 1299 1300 if (set_index) 1301 (*set_index) (sym_ptr, (bfd_size_type) symhdr->iextMax); 1302 1303 if (! bfd_ecoff_debug_one_external (abfd, debug, swap, 1304 sym_ptr->name, &esym)) 1305 return FALSE; 1306 } 1307 1308 return TRUE; 1309} 1310 1311/* Add a single external symbol to the debugging information. */ 1312 1313bfd_boolean 1314bfd_ecoff_debug_one_external (abfd, debug, swap, name, esym) 1315 bfd *abfd; 1316 struct ecoff_debug_info *debug; 1317 const struct ecoff_debug_swap *swap; 1318 const char *name; 1319 EXTR *esym; 1320{ 1321 const bfd_size_type external_ext_size = swap->external_ext_size; 1322 void (* const swap_ext_out) PARAMS ((bfd *, const EXTR *, PTR)) 1323 = swap->swap_ext_out; 1324 HDRR * const symhdr = &debug->symbolic_header; 1325 size_t namelen; 1326 1327 namelen = strlen (name); 1328 1329 if ((size_t) (debug->ssext_end - debug->ssext) 1330 < symhdr->issExtMax + namelen + 1) 1331 { 1332 if (! ecoff_add_bytes ((char **) &debug->ssext, 1333 (char **) &debug->ssext_end, 1334 symhdr->issExtMax + namelen + 1)) 1335 return FALSE; 1336 } 1337 if ((size_t) ((char *) debug->external_ext_end 1338 - (char *) debug->external_ext) 1339 < (symhdr->iextMax + 1) * external_ext_size) 1340 { 1341 if (! ecoff_add_bytes ((char **) &debug->external_ext, 1342 (char **) &debug->external_ext_end, 1343 (symhdr->iextMax + 1) * (size_t) external_ext_size)) 1344 return FALSE; 1345 } 1346 1347 esym->asym.iss = symhdr->issExtMax; 1348 1349 (*swap_ext_out) (abfd, esym, 1350 ((char *) debug->external_ext 1351 + symhdr->iextMax * swap->external_ext_size)); 1352 1353 ++symhdr->iextMax; 1354 1355 strcpy (debug->ssext + symhdr->issExtMax, name); 1356 symhdr->issExtMax += namelen + 1; 1357 1358 return TRUE; 1359} 1360 1361/* Align the ECOFF debugging information. */ 1362 1363static void 1364ecoff_align_debug (abfd, debug, swap) 1365 bfd *abfd ATTRIBUTE_UNUSED; 1366 struct ecoff_debug_info *debug; 1367 const struct ecoff_debug_swap *swap; 1368{ 1369 HDRR * const symhdr = &debug->symbolic_header; 1370 bfd_size_type debug_align, aux_align, rfd_align; 1371 size_t add; 1372 1373 /* Adjust the counts so that structures are aligned. */ 1374 debug_align = swap->debug_align; 1375 aux_align = debug_align / sizeof (union aux_ext); 1376 rfd_align = debug_align / swap->external_rfd_size; 1377 1378 add = debug_align - (symhdr->cbLine & (debug_align - 1)); 1379 if (add != debug_align) 1380 { 1381 if (debug->line != (unsigned char *) NULL) 1382 memset ((PTR) (debug->line + symhdr->cbLine), 0, add); 1383 symhdr->cbLine += add; 1384 } 1385 1386 add = debug_align - (symhdr->issMax & (debug_align - 1)); 1387 if (add != debug_align) 1388 { 1389 if (debug->ss != (char *) NULL) 1390 memset ((PTR) (debug->ss + symhdr->issMax), 0, add); 1391 symhdr->issMax += add; 1392 } 1393 1394 add = debug_align - (symhdr->issExtMax & (debug_align - 1)); 1395 if (add != debug_align) 1396 { 1397 if (debug->ssext != (char *) NULL) 1398 memset ((PTR) (debug->ssext + symhdr->issExtMax), 0, add); 1399 symhdr->issExtMax += add; 1400 } 1401 1402 add = aux_align - (symhdr->iauxMax & (aux_align - 1)); 1403 if (add != aux_align) 1404 { 1405 if (debug->external_aux != (union aux_ext *) NULL) 1406 memset ((PTR) (debug->external_aux + symhdr->iauxMax), 0, 1407 add * sizeof (union aux_ext)); 1408 symhdr->iauxMax += add; 1409 } 1410 1411 add = rfd_align - (symhdr->crfd & (rfd_align - 1)); 1412 if (add != rfd_align) 1413 { 1414 if (debug->external_rfd != (PTR) NULL) 1415 memset ((PTR) ((char *) debug->external_rfd 1416 + symhdr->crfd * swap->external_rfd_size), 1417 0, (size_t) (add * swap->external_rfd_size)); 1418 symhdr->crfd += add; 1419 } 1420} 1421 1422/* Return the size required by the ECOFF debugging information. */ 1423 1424bfd_size_type 1425bfd_ecoff_debug_size (abfd, debug, swap) 1426 bfd *abfd; 1427 struct ecoff_debug_info *debug; 1428 const struct ecoff_debug_swap *swap; 1429{ 1430 bfd_size_type tot; 1431 1432 ecoff_align_debug (abfd, debug, swap); 1433 tot = swap->external_hdr_size; 1434 1435#define ADD(count, size) \ 1436 tot += debug->symbolic_header.count * size 1437 1438 ADD (cbLine, sizeof (unsigned char)); 1439 ADD (idnMax, swap->external_dnr_size); 1440 ADD (ipdMax, swap->external_pdr_size); 1441 ADD (isymMax, swap->external_sym_size); 1442 ADD (ioptMax, swap->external_opt_size); 1443 ADD (iauxMax, sizeof (union aux_ext)); 1444 ADD (issMax, sizeof (char)); 1445 ADD (issExtMax, sizeof (char)); 1446 ADD (ifdMax, swap->external_fdr_size); 1447 ADD (crfd, swap->external_rfd_size); 1448 ADD (iextMax, swap->external_ext_size); 1449 1450#undef ADD 1451 1452 return tot; 1453} 1454 1455/* Write out the ECOFF symbolic header, given the file position it is 1456 going to be placed at. This assumes that the counts are set 1457 correctly. */ 1458 1459static bfd_boolean 1460ecoff_write_symhdr (abfd, debug, swap, where) 1461 bfd *abfd; 1462 struct ecoff_debug_info *debug; 1463 const struct ecoff_debug_swap *swap; 1464 file_ptr where; 1465{ 1466 HDRR * const symhdr = &debug->symbolic_header; 1467 char *buff = NULL; 1468 1469 ecoff_align_debug (abfd, debug, swap); 1470 1471 /* Go to the right location in the file. */ 1472 if (bfd_seek (abfd, where, SEEK_SET) != 0) 1473 return FALSE; 1474 1475 where += swap->external_hdr_size; 1476 1477 symhdr->magic = swap->sym_magic; 1478 1479 /* Fill in the file offsets. */ 1480#define SET(offset, count, size) \ 1481 if (symhdr->count == 0) \ 1482 symhdr->offset = 0; \ 1483 else \ 1484 { \ 1485 symhdr->offset = where; \ 1486 where += symhdr->count * size; \ 1487 } 1488 1489 SET (cbLineOffset, cbLine, sizeof (unsigned char)); 1490 SET (cbDnOffset, idnMax, swap->external_dnr_size); 1491 SET (cbPdOffset, ipdMax, swap->external_pdr_size); 1492 SET (cbSymOffset, isymMax, swap->external_sym_size); 1493 SET (cbOptOffset, ioptMax, swap->external_opt_size); 1494 SET (cbAuxOffset, iauxMax, sizeof (union aux_ext)); 1495 SET (cbSsOffset, issMax, sizeof (char)); 1496 SET (cbSsExtOffset, issExtMax, sizeof (char)); 1497 SET (cbFdOffset, ifdMax, swap->external_fdr_size); 1498 SET (cbRfdOffset, crfd, swap->external_rfd_size); 1499 SET (cbExtOffset, iextMax, swap->external_ext_size); 1500#undef SET 1501 1502 buff = (PTR) bfd_malloc (swap->external_hdr_size); 1503 if (buff == NULL && swap->external_hdr_size != 0) 1504 goto error_return; 1505 1506 (*swap->swap_hdr_out) (abfd, symhdr, buff); 1507 if (bfd_bwrite (buff, swap->external_hdr_size, abfd) 1508 != swap->external_hdr_size) 1509 goto error_return; 1510 1511 if (buff != NULL) 1512 free (buff); 1513 return TRUE; 1514 error_return: 1515 if (buff != NULL) 1516 free (buff); 1517 return FALSE; 1518} 1519 1520/* Write out the ECOFF debugging information. This function assumes 1521 that the information (the pointers and counts) in *DEBUG have been 1522 set correctly. WHERE is the position in the file to write the 1523 information to. This function fills in the file offsets in the 1524 symbolic header. */ 1525 1526bfd_boolean 1527bfd_ecoff_write_debug (abfd, debug, swap, where) 1528 bfd *abfd; 1529 struct ecoff_debug_info *debug; 1530 const struct ecoff_debug_swap *swap; 1531 file_ptr where; 1532{ 1533 HDRR * const symhdr = &debug->symbolic_header; 1534 1535 if (! ecoff_write_symhdr (abfd, debug, swap, where)) 1536 return FALSE; 1537 1538#define WRITE(ptr, count, size, offset) \ 1539 BFD_ASSERT (symhdr->offset == 0 \ 1540 || (bfd_vma) bfd_tell (abfd) == symhdr->offset); \ 1541 if (bfd_bwrite ((PTR) debug->ptr, (bfd_size_type) size * symhdr->count, abfd)\ 1542 != size * symhdr->count) \ 1543 return FALSE; 1544 1545 WRITE (line, cbLine, sizeof (unsigned char), cbLineOffset); 1546 WRITE (external_dnr, idnMax, swap->external_dnr_size, cbDnOffset); 1547 WRITE (external_pdr, ipdMax, swap->external_pdr_size, cbPdOffset); 1548 WRITE (external_sym, isymMax, swap->external_sym_size, cbSymOffset); 1549 WRITE (external_opt, ioptMax, swap->external_opt_size, cbOptOffset); 1550 WRITE (external_aux, iauxMax, (bfd_size_type) sizeof (union aux_ext), 1551 cbAuxOffset); 1552 WRITE (ss, issMax, sizeof (char), cbSsOffset); 1553 WRITE (ssext, issExtMax, sizeof (char), cbSsExtOffset); 1554 WRITE (external_fdr, ifdMax, swap->external_fdr_size, cbFdOffset); 1555 WRITE (external_rfd, crfd, swap->external_rfd_size, cbRfdOffset); 1556 WRITE (external_ext, iextMax, swap->external_ext_size, cbExtOffset); 1557#undef WRITE 1558 1559 return TRUE; 1560} 1561 1562/* Write out a shuffle list. */ 1563 1564static bfd_boolean ecoff_write_shuffle 1565 PARAMS ((bfd *, const struct ecoff_debug_swap *, struct shuffle *, 1566 PTR space)); 1567 1568static bfd_boolean 1569ecoff_write_shuffle (abfd, swap, shuffle, space) 1570 bfd *abfd; 1571 const struct ecoff_debug_swap *swap; 1572 struct shuffle *shuffle; 1573 PTR space; 1574{ 1575 register struct shuffle *l; 1576 unsigned long total; 1577 1578 total = 0; 1579 for (l = shuffle; l != (struct shuffle *) NULL; l = l->next) 1580 { 1581 if (! l->filep) 1582 { 1583 if (bfd_bwrite (l->u.memory, (bfd_size_type) l->size, abfd) 1584 != l->size) 1585 return FALSE; 1586 } 1587 else 1588 { 1589 if (bfd_seek (l->u.file.input_bfd, l->u.file.offset, SEEK_SET) != 0 1590 || bfd_bread (space, (bfd_size_type) l->size, 1591 l->u.file.input_bfd) != l->size 1592 || bfd_bwrite (space, (bfd_size_type) l->size, abfd) != l->size) 1593 return FALSE; 1594 } 1595 total += l->size; 1596 } 1597 1598 if ((total & (swap->debug_align - 1)) != 0) 1599 { 1600 unsigned int i; 1601 bfd_byte *s; 1602 1603 i = swap->debug_align - (total & (swap->debug_align - 1)); 1604 s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i); 1605 if (s == NULL && i != 0) 1606 return FALSE; 1607 1608 if (bfd_bwrite ((PTR) s, (bfd_size_type) i, abfd) != i) 1609 { 1610 free (s); 1611 return FALSE; 1612 } 1613 free (s); 1614 } 1615 1616 return TRUE; 1617} 1618 1619/* Write out debugging information using accumulated linker 1620 information. */ 1621 1622bfd_boolean 1623bfd_ecoff_write_accumulated_debug (handle, abfd, debug, swap, info, where) 1624 PTR handle; 1625 bfd *abfd; 1626 struct ecoff_debug_info *debug; 1627 const struct ecoff_debug_swap *swap; 1628 struct bfd_link_info *info; 1629 file_ptr where; 1630{ 1631 struct accumulate *ainfo = (struct accumulate *) handle; 1632 PTR space = NULL; 1633 bfd_size_type amt; 1634 1635 if (! ecoff_write_symhdr (abfd, debug, swap, where)) 1636 goto error_return; 1637 1638 amt = ainfo->largest_file_shuffle; 1639 space = (PTR) bfd_malloc (amt); 1640 if (space == NULL && ainfo->largest_file_shuffle != 0) 1641 goto error_return; 1642 1643 if (! ecoff_write_shuffle (abfd, swap, ainfo->line, space) 1644 || ! ecoff_write_shuffle (abfd, swap, ainfo->pdr, space) 1645 || ! ecoff_write_shuffle (abfd, swap, ainfo->sym, space) 1646 || ! ecoff_write_shuffle (abfd, swap, ainfo->opt, space) 1647 || ! ecoff_write_shuffle (abfd, swap, ainfo->aux, space)) 1648 goto error_return; 1649 1650 /* The string table is written out from the hash table if this is a 1651 final link. */ 1652 if (info->relocatable) 1653 { 1654 BFD_ASSERT (ainfo->ss_hash == (struct string_hash_entry *) NULL); 1655 if (! ecoff_write_shuffle (abfd, swap, ainfo->ss, space)) 1656 goto error_return; 1657 } 1658 else 1659 { 1660 unsigned long total; 1661 bfd_byte null; 1662 struct string_hash_entry *sh; 1663 1664 BFD_ASSERT (ainfo->ss == (struct shuffle *) NULL); 1665 null = 0; 1666 if (bfd_bwrite ((PTR) &null, (bfd_size_type) 1, abfd) != 1) 1667 goto error_return; 1668 total = 1; 1669 BFD_ASSERT (ainfo->ss_hash == NULL || ainfo->ss_hash->val == 1); 1670 for (sh = ainfo->ss_hash; 1671 sh != (struct string_hash_entry *) NULL; 1672 sh = sh->next) 1673 { 1674 size_t len; 1675 1676 len = strlen (sh->root.string); 1677 amt = len + 1; 1678 if (bfd_bwrite ((PTR) sh->root.string, amt, abfd) != amt) 1679 goto error_return; 1680 total += len + 1; 1681 } 1682 1683 if ((total & (swap->debug_align - 1)) != 0) 1684 { 1685 unsigned int i; 1686 bfd_byte *s; 1687 1688 i = swap->debug_align - (total & (swap->debug_align - 1)); 1689 s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i); 1690 if (s == NULL && i != 0) 1691 goto error_return; 1692 1693 if (bfd_bwrite ((PTR) s, (bfd_size_type) i, abfd) != i) 1694 { 1695 free (s); 1696 goto error_return; 1697 } 1698 free (s); 1699 } 1700 } 1701 1702 /* The external strings and symbol are not converted over to using 1703 shuffles. FIXME: They probably should be. */ 1704 amt = debug->symbolic_header.issExtMax; 1705 if (bfd_bwrite (debug->ssext, amt, abfd) != amt) 1706 goto error_return; 1707 if ((debug->symbolic_header.issExtMax & (swap->debug_align - 1)) != 0) 1708 { 1709 unsigned int i; 1710 bfd_byte *s; 1711 1712 i = (swap->debug_align 1713 - (debug->symbolic_header.issExtMax & (swap->debug_align - 1))); 1714 s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i); 1715 if (s == NULL && i != 0) 1716 goto error_return; 1717 1718 if (bfd_bwrite ((PTR) s, (bfd_size_type) i, abfd) != i) 1719 { 1720 free (s); 1721 goto error_return; 1722 } 1723 free (s); 1724 } 1725 1726 if (! ecoff_write_shuffle (abfd, swap, ainfo->fdr, space) 1727 || ! ecoff_write_shuffle (abfd, swap, ainfo->rfd, space)) 1728 goto error_return; 1729 1730 BFD_ASSERT (debug->symbolic_header.cbExtOffset == 0 1731 || (debug->symbolic_header.cbExtOffset 1732 == (bfd_vma) bfd_tell (abfd))); 1733 1734 amt = debug->symbolic_header.iextMax * swap->external_ext_size; 1735 if (bfd_bwrite (debug->external_ext, amt, abfd) != amt) 1736 goto error_return; 1737 1738 if (space != NULL) 1739 free (space); 1740 return TRUE; 1741 1742 error_return: 1743 if (space != NULL) 1744 free (space); 1745 return FALSE; 1746} 1747 1748/* Handle the find_nearest_line function for both ECOFF and MIPS ELF 1749 files. */ 1750 1751/* Compare FDR entries. This is called via qsort. */ 1752 1753static int 1754cmp_fdrtab_entry (leftp, rightp) 1755 const PTR leftp; 1756 const PTR rightp; 1757{ 1758 const struct ecoff_fdrtab_entry *lp = 1759 (const struct ecoff_fdrtab_entry *) leftp; 1760 const struct ecoff_fdrtab_entry *rp = 1761 (const struct ecoff_fdrtab_entry *) rightp; 1762 1763 if (lp->base_addr < rp->base_addr) 1764 return -1; 1765 if (lp->base_addr > rp->base_addr) 1766 return 1; 1767 return 0; 1768} 1769 1770/* Each file descriptor (FDR) has a memory address, to simplify 1771 looking up an FDR by address, we build a table covering all FDRs 1772 that have a least one procedure descriptor in them. The final 1773 table will be sorted by address so we can look it up via binary 1774 search. */ 1775 1776static bfd_boolean 1777mk_fdrtab (abfd, debug_info, debug_swap, line_info) 1778 bfd *abfd; 1779 struct ecoff_debug_info * const debug_info; 1780 const struct ecoff_debug_swap * const debug_swap; 1781 struct ecoff_find_line *line_info; 1782{ 1783 struct ecoff_fdrtab_entry *tab; 1784 FDR *fdr_ptr; 1785 FDR *fdr_start; 1786 FDR *fdr_end; 1787 bfd_boolean stabs; 1788 long len; 1789 bfd_size_type amt; 1790 1791 fdr_start = debug_info->fdr; 1792 fdr_end = fdr_start + debug_info->symbolic_header.ifdMax; 1793 1794 /* First, let's see how long the table needs to be. */ 1795 for (len = 0, fdr_ptr = fdr_start; fdr_ptr < fdr_end; fdr_ptr++) 1796 { 1797 if (fdr_ptr->cpd == 0) /* Skip FDRs that have no PDRs. */ 1798 continue; 1799 ++len; 1800 } 1801 1802 /* Now, create and fill in the table. */ 1803 amt = (bfd_size_type) len * sizeof (struct ecoff_fdrtab_entry); 1804 line_info->fdrtab = (struct ecoff_fdrtab_entry*) bfd_zalloc (abfd, amt); 1805 if (line_info->fdrtab == NULL) 1806 return FALSE; 1807 line_info->fdrtab_len = len; 1808 1809 tab = line_info->fdrtab; 1810 for (fdr_ptr = fdr_start; fdr_ptr < fdr_end; fdr_ptr++) 1811 { 1812 if (fdr_ptr->cpd == 0) 1813 continue; 1814 1815 /* Check whether this file has stabs debugging information. In 1816 a file with stabs debugging information, the second local 1817 symbol is named @stabs. */ 1818 stabs = FALSE; 1819 if (fdr_ptr->csym >= 2) 1820 { 1821 char *sym_ptr; 1822 SYMR sym; 1823 1824 sym_ptr = ((char *) debug_info->external_sym 1825 + (fdr_ptr->isymBase + 1) * debug_swap->external_sym_size); 1826 (*debug_swap->swap_sym_in) (abfd, sym_ptr, &sym); 1827 if (strcmp (debug_info->ss + fdr_ptr->issBase + sym.iss, 1828 STABS_SYMBOL) == 0) 1829 stabs = TRUE; 1830 } 1831 1832 if (!stabs) 1833 { 1834 /* eraxxon: There are at least two problems with this computation: 1835 1) PDRs do *not* contain offsets but full vma's; and typically the 1836 address of the first PDR is the address of the FDR, which will 1837 make (most) of the results of the original computation 0! 1838 2) Once in a wacky while, the Compaq compiler generated PDR 1839 addresses do not equal the FDR vma, but they (the PDR address) 1840 are still vma's and not offsets. Cf. comments in 1841 'lookup_line'. */ 1842#if 0 1843 bfd_size_type external_pdr_size; 1844 char *pdr_ptr; 1845 PDR pdr; 1846 1847 external_pdr_size = debug_swap->external_pdr_size; 1848 1849 pdr_ptr = ((char *) debug_info->external_pdr 1850 + fdr_ptr->ipdFirst * external_pdr_size); 1851 (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr); 1852 /* The address of the first PDR is the offset of that 1853 procedure relative to the beginning of file FDR. */ 1854 tab->base_addr = fdr_ptr->adr - pdr.adr; 1855#else 1856 /* The address of the first PDR is the offset of that 1857 procedure relative to the beginning of file FDR. */ 1858 tab->base_addr = fdr_ptr->adr; 1859#endif 1860 } 1861 else 1862 { 1863 /* XXX I don't know about stabs, so this is a guess 1864 (davidm@cs.arizona.edu). */ 1865 tab->base_addr = fdr_ptr->adr; 1866 } 1867 tab->fdr = fdr_ptr; 1868 ++tab; 1869 } 1870 1871 /* Finally, the table is sorted in increasing memory-address order. 1872 The table is mostly sorted already, but there are cases (e.g., 1873 static functions in include files), where this does not hold. 1874 Use "odump -PFv" to verify... */ 1875 qsort ((PTR) line_info->fdrtab, (size_t) len, 1876 sizeof (struct ecoff_fdrtab_entry), cmp_fdrtab_entry); 1877 1878 return TRUE; 1879} 1880 1881/* Return index of first FDR that covers to OFFSET. */ 1882 1883static long 1884fdrtab_lookup (line_info, offset) 1885 struct ecoff_find_line *line_info; 1886 bfd_vma offset; 1887{ 1888 long low, high, len; 1889 long mid = -1; 1890 struct ecoff_fdrtab_entry *tab; 1891 1892 len = line_info->fdrtab_len; 1893 if (len == 0) 1894 return -1; 1895 1896 tab = line_info->fdrtab; 1897 for (low = 0, high = len - 1 ; low != high ;) 1898 { 1899 mid = (high + low) / 2; 1900 if (offset >= tab[mid].base_addr && offset < tab[mid + 1].base_addr) 1901 goto find_min; 1902 1903 if (tab[mid].base_addr > offset) 1904 high = mid; 1905 else 1906 low = mid + 1; 1907 } 1908 1909 /* eraxxon: at this point 'offset' is either lower than the lowest entry or 1910 higher than the highest entry. In the former case high = low = mid = 0; 1911 we want to return -1. In the latter case, low = high and mid = low - 1; 1912 we want to return the index of the highest entry. Only in former case 1913 will the following 'catch-all' test be true. */ 1914 ++mid; 1915 1916 /* Last entry is catch-all for all higher addresses. */ 1917 if (offset < tab[mid].base_addr) 1918 return -1; 1919 1920 find_min: 1921 1922 /* eraxxon: There may be multiple FDRs in the table with the 1923 same base_addr; make sure that we are at the first one. */ 1924 while (mid > 0 && tab[mid - 1].base_addr == tab[mid].base_addr) 1925 --mid; 1926 1927 return mid; 1928} 1929 1930/* Look up a line given an address, storing the information in 1931 LINE_INFO->cache. */ 1932 1933static bfd_boolean 1934lookup_line (abfd, debug_info, debug_swap, line_info) 1935 bfd *abfd; 1936 struct ecoff_debug_info * const debug_info; 1937 const struct ecoff_debug_swap * const debug_swap; 1938 struct ecoff_find_line *line_info; 1939{ 1940 struct ecoff_fdrtab_entry *tab; 1941 bfd_vma offset; 1942 bfd_boolean stabs; 1943 FDR *fdr_ptr; 1944 int i; 1945 1946 /* eraxxon: note that 'offset' is the full vma, not a section offset. */ 1947 offset = line_info->cache.start; 1948 1949 /* Build FDR table (sorted by object file's base-address) if we 1950 don't have it already. */ 1951 if (line_info->fdrtab == NULL 1952 && !mk_fdrtab (abfd, debug_info, debug_swap, line_info)) 1953 return FALSE; 1954 1955 tab = line_info->fdrtab; 1956 1957 /* Find first FDR for address OFFSET. */ 1958 i = fdrtab_lookup (line_info, offset); 1959 if (i < 0) 1960 return FALSE; /* no FDR, no fun... */ 1961 1962 /* eraxxon: 'fdrtab_lookup' doesn't give what we want, at least for Compaq's 1963 C++ compiler 6.2. Consider three FDRs with starting addresses of x, y, 1964 and z, respectively, such that x < y < z. Assume further that 1965 y < 'offset' < z. It is possible at times that the PDR for 'offset' is 1966 associated with FDR x and *not* with FDR y. Erg!! 1967 1968 From a binary dump of my C++ test case 'moo' using Compaq's coffobjanl 1969 (output format has been edited for our purposes): 1970 1971 FDR [2]: (main.C): First instruction: 0x12000207c <x> 1972 PDR [5] for File [2]: LoopTest__Xv <0x1200020a0> (a) 1973 PDR [7] for File [2]: foo__Xv <0x120002168> 1974 FDR [1]: (-1): First instruction: 0x1200020e8 <y> 1975 PDR [3] for File [1]: <0x120001ad0> (b) 1976 FDR [6]: (-1): First instruction: 0x1200026f0 <z> 1977 1978 (a) In the case of PDR5, the vma is such that the first few instructions 1979 of the procedure can be found. But since the size of this procedure is 1980 160b, the vma will soon cross into the 'address space' of FDR1 and no 1981 debugging info will be found. How repugnant! 1982 1983 (b) It is also possible for a PDR to have a *lower* vma than its associated 1984 FDR; see FDR1 and PDR3. Gross! 1985 1986 Since the FDRs that are causing so much havok (in this case) 1) do not 1987 describe actual files (fdr.rss == -1), and 2) contain only compiler 1988 generated routines, I thought a simple fix would be to exclude them from 1989 the FDR table in 'mk_fdrtab'. But, besides not knowing for certain 1990 whether this would be correct, it creates an additional problem. If we 1991 happen to ask for source file info on a compiler generated (procedure) 1992 symbol -- which is still in the symbol table -- the result can be 1993 information from a real procedure! This is because compiler generated 1994 procedures with vma's higher than the last FDR in the fdr table will be 1995 associated with a PDR from this FDR, specifically the PDR with the 1996 highest vma. This wasn't a problem before, because each procedure had a 1997 PDR. (Yes, this problem could be eliminated if we kept the size of the 1998 last PDR around, but things are already getting ugly). 1999 2000 Probably, a better solution would be to have a sorted PDR table. Each 2001 PDR would have a pointer to its FDR so file information could still be 2002 obtained. A FDR table could still be constructed if necessary -- since 2003 it only contains pointers, not much extra memory would be used -- but 2004 the PDR table would be searched to locate debugging info. 2005 2006 There is still at least one remaining issue. Sometimes a FDR can have a 2007 bogus name, but contain PDRs that should belong to another FDR with a 2008 real name. E.g: 2009 2010 FDR [3]: 0000000120001b50 (/home/.../Array.H~alt~deccxx_5E5A62AD) 2011 PDR [a] for File [3]: 0000000120001b50 2012 PDR [b] for File [3]: 0000000120001cf0 2013 PDR [c] for File [3]: 0000000120001dc8 2014 PDR [d] for File [3]: 0000000120001e40 2015 PDR [e] for File [3]: 0000000120001eb8 2016 PDR [f] for File [3]: 0000000120001f4c 2017 FDR [4]: 0000000120001b50 (/home/.../Array.H) 2018 2019 Here, FDR4 has the correct name, but should (seemingly) contain PDRa-f. 2020 The symbol table for PDR4 does contain symbols for PDRa-f, but so does 2021 the symbol table for FDR3. However the former is different; perhaps this 2022 can be detected easily. (I'm not sure at this point.) This problem only 2023 seems to be associated with files with templates. I am assuming the idea 2024 is that there is a 'fake' FDR (with PDRs) for each differently typed set 2025 of templates that must be generated. Currently, FDR4 is completely 2026 excluded from the FDR table in 'mk_fdrtab' because it contains no PDRs. 2027 2028 Since I don't have time to prepare a real fix for this right now, be 2029 prepared for 'A Horrible Hack' to force the inspection of all non-stabs 2030 FDRs. It's coming... */ 2031 fdr_ptr = tab[i].fdr; 2032 2033 /* Check whether this file has stabs debugging information. In a 2034 file with stabs debugging information, the second local symbol is 2035 named @stabs. */ 2036 stabs = FALSE; 2037 if (fdr_ptr->csym >= 2) 2038 { 2039 char *sym_ptr; 2040 SYMR sym; 2041 2042 sym_ptr = ((char *) debug_info->external_sym 2043 + (fdr_ptr->isymBase + 1) * debug_swap->external_sym_size); 2044 (*debug_swap->swap_sym_in) (abfd, sym_ptr, &sym); 2045 if (strcmp (debug_info->ss + fdr_ptr->issBase + sym.iss, 2046 STABS_SYMBOL) == 0) 2047 stabs = TRUE; 2048 } 2049 2050 if (!stabs) 2051 { 2052 bfd_size_type external_pdr_size; 2053 char *pdr_ptr; 2054 char *best_pdr = NULL; 2055 FDR *best_fdr; 2056 bfd_signed_vma best_dist = -1; 2057 PDR pdr; 2058 unsigned char *line_ptr; 2059 unsigned char *line_end; 2060 int lineno; 2061 /* This file uses ECOFF debugging information. Each FDR has a 2062 list of procedure descriptors (PDR). The address in the FDR 2063 is the absolute address of the first procedure. The address 2064 in the first PDR gives the offset of that procedure relative 2065 to the object file's base-address. The addresses in 2066 subsequent PDRs specify each procedure's address relative to 2067 the object file's base-address. To make things more juicy, 2068 whenever the PROF bit in the PDR is set, the real entry point 2069 of the procedure may be 16 bytes below what would normally be 2070 the procedure's entry point. Instead, DEC came up with a 2071 wicked scheme to create profiled libraries "on the fly": 2072 instead of shipping a regular and a profiled version of each 2073 library, they insert 16 bytes of unused space in front of 2074 each procedure and set the "prof" bit in the PDR to indicate 2075 that there is a gap there (this is done automagically by "as" 2076 when option "-pg" is specified). Thus, normally, you link 2077 against such a library and, except for lots of 16 byte gaps 2078 between functions, things will behave as usual. However, 2079 when invoking "ld" with option "-pg", it will fill those gaps 2080 with code that calls mcount(). It then moves the function's 2081 entry point down by 16 bytes, and out pops a binary that has 2082 all functions profiled. 2083 2084 NOTE: Neither FDRs nor PDRs are strictly sorted in memory 2085 order. For example, when including header-files that 2086 define functions, the FDRs follow behind the including 2087 file, even though their code may have been generated at 2088 a lower address. File coff-alpha.c from libbfd 2089 illustrates this (use "odump -PFv" to look at a file's 2090 FDR/PDR). Similarly, PDRs are sometimes out of order 2091 as well. An example of this is OSF/1 v3.0 libc's 2092 malloc.c. I'm not sure why this happens, but it could 2093 be due to optimizations that reorder a function's 2094 position within an object-file. 2095 2096 Strategy: 2097 2098 On the first call to this function, we build a table of FDRs 2099 that is sorted by the base-address of the object-file the FDR 2100 is referring to. Notice that each object-file may contain 2101 code from multiple source files (e.g., due to code defined in 2102 include files). Thus, for any given base-address, there may 2103 be multiple FDRs (but this case is, fortunately, uncommon). 2104 lookup(addr) guarantees to return the first FDR that applies 2105 to address ADDR. Thus, after invoking lookup(), we have a 2106 list of FDRs that may contain the PDR for ADDR. Next, we 2107 walk through the PDRs of these FDRs and locate the one that 2108 is closest to ADDR (i.e., for which the difference between 2109 ADDR and the PDR's entry point is positive and minimal). 2110 Once, the right FDR and PDR are located, we simply walk 2111 through the line-number table to lookup the line-number that 2112 best matches ADDR. Obviously, things could be sped up by 2113 keeping a sorted list of PDRs instead of a sorted list of 2114 FDRs. However, this would increase space requirements 2115 considerably, which is undesirable. */ 2116 external_pdr_size = debug_swap->external_pdr_size; 2117 2118#if 0 /* eraxxon: PDR addresses (pdr.adr) are not relative to FDRs! 2119 Leave 'offset' alone. */ 2120 /* Make offset relative to object file's start-address. */ 2121 offset -= tab[i].base_addr; 2122#endif 2123 /* eraxxon: The Horrible Hack: Because of the problems above, set 'i' 2124 to 0 so we look through all FDRs. 2125 2126 Because FDR's without any symbols are assumed to be non-stabs, 2127 searching through all FDRs may cause the following code to try to 2128 read stabs FDRs as ECOFF ones. However, I don't think this will 2129 harm anything. */ 2130 i = 0; 2131 2132 /* Search FDR list starting at tab[i] for the PDR that best matches 2133 OFFSET. Normally, the FDR list is only one entry long. */ 2134 best_fdr = NULL; 2135 do 2136 { 2137 /* eraxxon: 'dist' and 'min_dist' can be negative now 2138 because we iterate over every FDR rather than just ones 2139 with a base address less than or equal to 'offset'. */ 2140 bfd_signed_vma dist = -1, min_dist = -1; 2141 char *pdr_hold; 2142 char *pdr_end; 2143 2144 fdr_ptr = tab[i].fdr; 2145 2146 pdr_ptr = ((char *) debug_info->external_pdr 2147 + fdr_ptr->ipdFirst * external_pdr_size); 2148 pdr_end = pdr_ptr + fdr_ptr->cpd * external_pdr_size; 2149 (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr); 2150 /* Find PDR that is closest to OFFSET. If pdr.prof is set, 2151 the procedure entry-point *may* be 0x10 below pdr.adr. We 2152 simply pretend that pdr.prof *implies* a lower entry-point. 2153 This is safe because it just means that may identify 4 NOPs 2154 in front of the function as belonging to the function. */ 2155 for (pdr_hold = NULL; 2156 pdr_ptr < pdr_end; 2157 (pdr_ptr += external_pdr_size, 2158 (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr))) 2159 { 2160 if (offset >= (pdr.adr - 0x10 * pdr.prof)) 2161 { 2162 dist = offset - (pdr.adr - 0x10 * pdr.prof); 2163 2164 /* eraxxon: 'dist' can be negative now. Note that 2165 'min_dist' can be negative if 'pdr_hold' below is NULL. */ 2166 if (!pdr_hold || (dist >= 0 && dist < min_dist)) 2167 { 2168 min_dist = dist; 2169 pdr_hold = pdr_ptr; 2170 } 2171 } 2172 } 2173 2174 if (!best_pdr || (min_dist >= 0 && min_dist < best_dist)) 2175 { 2176 best_dist = (bfd_vma) min_dist; 2177 best_fdr = fdr_ptr; 2178 best_pdr = pdr_hold; 2179 } 2180 /* Continue looping until base_addr of next entry is different. */ 2181 } 2182 /* eraxxon: We want to iterate over all FDRs. 2183 See previous comment about 'fdrtab_lookup'. */ 2184 while (++i < line_info->fdrtab_len); 2185 2186 if (!best_fdr || !best_pdr) 2187 return FALSE; /* Shouldn't happen... */ 2188 2189 /* Phew, finally we got something that we can hold onto. */ 2190 fdr_ptr = best_fdr; 2191 pdr_ptr = best_pdr; 2192 (*debug_swap->swap_pdr_in) (abfd, (PTR) pdr_ptr, &pdr); 2193 /* Now we can look for the actual line number. The line numbers 2194 are stored in a very funky format, which I won't try to 2195 describe. The search is bounded by the end of the FDRs line 2196 number entries. */ 2197 line_end = debug_info->line + fdr_ptr->cbLineOffset + fdr_ptr->cbLine; 2198 2199 /* Make offset relative to procedure entry. */ 2200 offset -= pdr.adr - 0x10 * pdr.prof; 2201 lineno = pdr.lnLow; 2202 line_ptr = debug_info->line + fdr_ptr->cbLineOffset + pdr.cbLineOffset; 2203 while (line_ptr < line_end) 2204 { 2205 int delta; 2206 unsigned int count; 2207 2208 delta = *line_ptr >> 4; 2209 if (delta >= 0x8) 2210 delta -= 0x10; 2211 count = (*line_ptr & 0xf) + 1; 2212 ++line_ptr; 2213 if (delta == -8) 2214 { 2215 delta = (((line_ptr[0]) & 0xff) << 8) + ((line_ptr[1]) & 0xff); 2216 if (delta >= 0x8000) 2217 delta -= 0x10000; 2218 line_ptr += 2; 2219 } 2220 lineno += delta; 2221 if (offset < count * 4) 2222 { 2223 line_info->cache.stop += count * 4 - offset; 2224 break; 2225 } 2226 offset -= count * 4; 2227 } 2228 2229 /* If fdr_ptr->rss is -1, then this file does not have full 2230 symbols, at least according to gdb/mipsread.c. */ 2231 if (fdr_ptr->rss == -1) 2232 { 2233 line_info->cache.filename = NULL; 2234 if (pdr.isym == -1) 2235 line_info->cache.functionname = NULL; 2236 else 2237 { 2238 EXTR proc_ext; 2239 2240 (*debug_swap->swap_ext_in) 2241 (abfd, 2242 ((char *) debug_info->external_ext 2243 + pdr.isym * debug_swap->external_ext_size), 2244 &proc_ext); 2245 line_info->cache.functionname = (debug_info->ssext 2246 + proc_ext.asym.iss); 2247 } 2248 } 2249 else 2250 { 2251 SYMR proc_sym; 2252 2253 line_info->cache.filename = (debug_info->ss 2254 + fdr_ptr->issBase 2255 + fdr_ptr->rss); 2256 (*debug_swap->swap_sym_in) 2257 (abfd, 2258 ((char *) debug_info->external_sym 2259 + ((fdr_ptr->isymBase + pdr.isym) 2260 * debug_swap->external_sym_size)), 2261 &proc_sym); 2262 line_info->cache.functionname = (debug_info->ss 2263 + fdr_ptr->issBase 2264 + proc_sym.iss); 2265 } 2266 if (lineno == ilineNil) 2267 lineno = 0; 2268 line_info->cache.line_num = lineno; 2269 } 2270 else 2271 { 2272 bfd_size_type external_sym_size; 2273 const char *directory_name; 2274 const char *main_file_name; 2275 const char *current_file_name; 2276 const char *function_name; 2277 const char *line_file_name; 2278 bfd_vma low_func_vma; 2279 bfd_vma low_line_vma; 2280 bfd_boolean past_line; 2281 bfd_boolean past_fn; 2282 char *sym_ptr, *sym_ptr_end; 2283 size_t len, funclen; 2284 char *buffer = NULL; 2285 2286 /* This file uses stabs debugging information. When gcc is not 2287 optimizing, it will put the line number information before 2288 the function name stabs entry. When gcc is optimizing, it 2289 will put the stabs entry for all the function first, followed 2290 by the line number information. (This appears to happen 2291 because of the two output files used by the -mgpopt switch, 2292 which is implied by -O). This means that we must keep 2293 looking through the symbols until we find both a line number 2294 and a function name which are beyond the address we want. */ 2295 2296 line_info->cache.filename = NULL; 2297 line_info->cache.functionname = NULL; 2298 line_info->cache.line_num = 0; 2299 2300 directory_name = NULL; 2301 main_file_name = NULL; 2302 current_file_name = NULL; 2303 function_name = NULL; 2304 line_file_name = NULL; 2305 low_func_vma = 0; 2306 low_line_vma = 0; 2307 past_line = FALSE; 2308 past_fn = FALSE; 2309 2310 external_sym_size = debug_swap->external_sym_size; 2311 2312 sym_ptr = ((char *) debug_info->external_sym 2313 + (fdr_ptr->isymBase + 2) * external_sym_size); 2314 sym_ptr_end = sym_ptr + (fdr_ptr->csym - 2) * external_sym_size; 2315 for (; 2316 sym_ptr < sym_ptr_end && (! past_line || ! past_fn); 2317 sym_ptr += external_sym_size) 2318 { 2319 SYMR sym; 2320 2321 (*debug_swap->swap_sym_in) (abfd, sym_ptr, &sym); 2322 2323 if (ECOFF_IS_STAB (&sym)) 2324 { 2325 switch (ECOFF_UNMARK_STAB (sym.index)) 2326 { 2327 case N_SO: 2328 main_file_name = current_file_name = 2329 debug_info->ss + fdr_ptr->issBase + sym.iss; 2330 2331 /* Check the next symbol to see if it is also an 2332 N_SO symbol. */ 2333 if (sym_ptr + external_sym_size < sym_ptr_end) 2334 { 2335 SYMR nextsym; 2336 2337 (*debug_swap->swap_sym_in) (abfd, 2338 sym_ptr + external_sym_size, 2339 &nextsym); 2340 if (ECOFF_IS_STAB (&nextsym) 2341 && ECOFF_UNMARK_STAB (nextsym.index) == N_SO) 2342 { 2343 directory_name = current_file_name; 2344 main_file_name = current_file_name = 2345 debug_info->ss + fdr_ptr->issBase + nextsym.iss; 2346 sym_ptr += external_sym_size; 2347 } 2348 } 2349 break; 2350 2351 case N_SOL: 2352 current_file_name = 2353 debug_info->ss + fdr_ptr->issBase + sym.iss; 2354 break; 2355 2356 case N_FUN: 2357 if (sym.value > offset) 2358 past_fn = TRUE; 2359 else if (sym.value >= low_func_vma) 2360 { 2361 low_func_vma = sym.value; 2362 function_name = 2363 debug_info->ss + fdr_ptr->issBase + sym.iss; 2364 } 2365 break; 2366 } 2367 } 2368 else if (sym.st == stLabel && sym.index != indexNil) 2369 { 2370 if (sym.value > offset) 2371 past_line = TRUE; 2372 else if (sym.value >= low_line_vma) 2373 { 2374 low_line_vma = sym.value; 2375 line_file_name = current_file_name; 2376 line_info->cache.line_num = sym.index; 2377 } 2378 } 2379 } 2380 2381 if (line_info->cache.line_num != 0) 2382 main_file_name = line_file_name; 2383 2384 /* We need to remove the stuff after the colon in the function 2385 name. We also need to put the directory name and the file 2386 name together. */ 2387 if (function_name == NULL) 2388 len = funclen = 0; 2389 else 2390 len = funclen = strlen (function_name) + 1; 2391 2392 if (main_file_name != NULL 2393 && directory_name != NULL 2394 && main_file_name[0] != '/') 2395 len += strlen (directory_name) + strlen (main_file_name) + 1; 2396 2397 if (len != 0) 2398 { 2399 if (line_info->find_buffer != NULL) 2400 free (line_info->find_buffer); 2401 buffer = (char *) bfd_malloc ((bfd_size_type) len); 2402 if (buffer == NULL) 2403 return FALSE; 2404 line_info->find_buffer = buffer; 2405 } 2406 2407 if (function_name != NULL) 2408 { 2409 char *colon; 2410 2411 strcpy (buffer, function_name); 2412 colon = strchr (buffer, ':'); 2413 if (colon != NULL) 2414 *colon = '\0'; 2415 line_info->cache.functionname = buffer; 2416 } 2417 2418 if (main_file_name != NULL) 2419 { 2420 if (directory_name == NULL || main_file_name[0] == '/') 2421 line_info->cache.filename = main_file_name; 2422 else 2423 { 2424 sprintf (buffer + funclen, "%s%s", directory_name, 2425 main_file_name); 2426 line_info->cache.filename = buffer + funclen; 2427 } 2428 } 2429 } 2430 2431 return TRUE; 2432} 2433 2434/* Do the work of find_nearest_line. */ 2435 2436bfd_boolean 2437_bfd_ecoff_locate_line (abfd, section, offset, debug_info, debug_swap, 2438 line_info, filename_ptr, functionname_ptr, retline_ptr) 2439 bfd *abfd; 2440 asection *section; 2441 bfd_vma offset; 2442 struct ecoff_debug_info * const debug_info; 2443 const struct ecoff_debug_swap * const debug_swap; 2444 struct ecoff_find_line *line_info; 2445 const char **filename_ptr; 2446 const char **functionname_ptr; 2447 unsigned int *retline_ptr; 2448{ 2449 offset += section->vma; 2450 2451 if (line_info->cache.sect == NULL 2452 || line_info->cache.sect != section 2453 || offset < line_info->cache.start 2454 || offset >= line_info->cache.stop) 2455 { 2456 line_info->cache.sect = section; 2457 line_info->cache.start = offset; 2458 line_info->cache.stop = offset; 2459 if (! lookup_line (abfd, debug_info, debug_swap, line_info)) 2460 { 2461 line_info->cache.sect = NULL; 2462 return FALSE; 2463 } 2464 } 2465 2466 *filename_ptr = line_info->cache.filename; 2467 *functionname_ptr = line_info->cache.functionname; 2468 *retline_ptr = line_info->cache.line_num; 2469 2470 return TRUE; 2471} 2472 2473/* These routines copy symbolic information into a memory buffer. 2474 2475 FIXME: The whole point of the shuffle code is to avoid storing 2476 everything in memory, since the linker is such a memory hog. This 2477 code makes that effort useless. It is only called by the MIPS ELF 2478 code when generating a shared library, so it is not that big a 2479 deal, but it should be fixed eventually. */ 2480 2481/* Collect a shuffle into a memory buffer. */ 2482 2483static bfd_boolean ecoff_collect_shuffle 2484 PARAMS ((struct shuffle *, bfd_byte *)); 2485 2486static bfd_boolean 2487ecoff_collect_shuffle (l, buff) 2488 struct shuffle *l; 2489 bfd_byte *buff; 2490{ 2491 unsigned long total; 2492 2493 total = 0; 2494 for (; l != (struct shuffle *) NULL; l = l->next) 2495 { 2496 if (! l->filep) 2497 memcpy (buff, l->u.memory, l->size); 2498 else 2499 { 2500 if (bfd_seek (l->u.file.input_bfd, l->u.file.offset, SEEK_SET) != 0 2501 || (bfd_bread (buff, (bfd_size_type) l->size, l->u.file.input_bfd) 2502 != l->size)) 2503 return FALSE; 2504 } 2505 total += l->size; 2506 buff += l->size; 2507 } 2508 2509 return TRUE; 2510} 2511 2512/* Copy PDR information into a memory buffer. */ 2513 2514bfd_boolean 2515_bfd_ecoff_get_accumulated_pdr (handle, buff) 2516 PTR handle; 2517 bfd_byte *buff; 2518{ 2519 struct accumulate *ainfo = (struct accumulate *) handle; 2520 2521 return ecoff_collect_shuffle (ainfo->pdr, buff); 2522} 2523 2524/* Copy symbol information into a memory buffer. */ 2525 2526bfd_boolean 2527_bfd_ecoff_get_accumulated_sym (handle, buff) 2528 PTR handle; 2529 bfd_byte *buff; 2530{ 2531 struct accumulate *ainfo = (struct accumulate *) handle; 2532 2533 return ecoff_collect_shuffle (ainfo->sym, buff); 2534} 2535 2536/* Copy the string table into a memory buffer. */ 2537 2538bfd_boolean 2539_bfd_ecoff_get_accumulated_ss (handle, buff) 2540 PTR handle; 2541 bfd_byte *buff; 2542{ 2543 struct accumulate *ainfo = (struct accumulate *) handle; 2544 struct string_hash_entry *sh; 2545 unsigned long total; 2546 2547 /* The string table is written out from the hash table if this is a 2548 final link. */ 2549 BFD_ASSERT (ainfo->ss == (struct shuffle *) NULL); 2550 *buff++ = '\0'; 2551 total = 1; 2552 BFD_ASSERT (ainfo->ss_hash == NULL || ainfo->ss_hash->val == 1); 2553 for (sh = ainfo->ss_hash; 2554 sh != (struct string_hash_entry *) NULL; 2555 sh = sh->next) 2556 { 2557 size_t len; 2558 2559 len = strlen (sh->root.string); 2560 memcpy (buff, (PTR) sh->root.string, len + 1); 2561 total += len + 1; 2562 buff += len + 1; 2563 } 2564 2565 return TRUE; 2566} 2567