1/* BFD back-end for Intel 960 b.out binaries. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002, 2003, 2004, 2005 4 Free Software Foundation, Inc. 5 Written by Cygnus Support. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 22 23#include "bfd.h" 24#include "sysdep.h" 25#include "libbfd.h" 26#include "bfdlink.h" 27#include "genlink.h" 28#include "bout.h" 29#include "libiberty.h" 30 31#include "aout/stab_gnu.h" 32#include "libaout.h" /* BFD a.out internal data structures. */ 33 34#define ABS32CODE 0 35#define ABS32CODE_SHRUNK 1 36#define PCREL24 2 37#define CALLJ 3 38#define ABS32 4 39#define PCREL13 5 40#define ABS32_MAYBE_RELAXABLE 1 41#define ABS32_WAS_RELAXABLE 2 42 43#define ALIGNER 10 44#define ALIGNDONE 11 45 46static reloc_howto_type howto_reloc_callj = 47 HOWTO (CALLJ, 0, 2, 24, TRUE, 0, complain_overflow_signed, 0,"callj", TRUE, 0x00ffffff, 0x00ffffff,FALSE); 48static reloc_howto_type howto_reloc_abs32 = 49 HOWTO (ABS32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"abs32", TRUE, 0xffffffff,0xffffffff,FALSE); 50static reloc_howto_type howto_reloc_pcrel24 = 51 HOWTO (PCREL24, 0, 2, 24, TRUE, 0, complain_overflow_signed,0,"pcrel24", TRUE, 0x00ffffff,0x00ffffff,FALSE); 52static reloc_howto_type howto_reloc_pcrel13 = 53 HOWTO (PCREL13, 0, 2, 13, TRUE, 0, complain_overflow_signed,0,"pcrel13", TRUE, 0x00001fff,0x00001fff,FALSE); 54static reloc_howto_type howto_reloc_abs32codeshrunk = 55 HOWTO (ABS32CODE_SHRUNK, 0, 2, 24, TRUE, 0, complain_overflow_signed, 0,"callx->callj", TRUE, 0x00ffffff, 0x00ffffff,FALSE); 56static reloc_howto_type howto_reloc_abs32code = 57 HOWTO (ABS32CODE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"callx", TRUE, 0xffffffff,0xffffffff,FALSE); 58 59static reloc_howto_type howto_align_table[] = 60{ 61 HOWTO (ALIGNER, 0, 0x1, 0, FALSE, 0, complain_overflow_dont, 0, "align16", FALSE, 0, 0, FALSE), 62 HOWTO (ALIGNER, 0, 0x3, 0, FALSE, 0, complain_overflow_dont, 0, "align32", FALSE, 0, 0, FALSE), 63 HOWTO (ALIGNER, 0, 0x7, 0, FALSE, 0, complain_overflow_dont, 0, "align64", FALSE, 0, 0, FALSE), 64 HOWTO (ALIGNER, 0, 0xf, 0, FALSE, 0, complain_overflow_dont, 0, "align128", FALSE, 0, 0, FALSE), 65}; 66 67static reloc_howto_type howto_done_align_table[] = 68{ 69 HOWTO (ALIGNDONE, 0x1, 0x1, 0, FALSE, 0, complain_overflow_dont, 0, "donealign16", FALSE, 0, 0, FALSE), 70 HOWTO (ALIGNDONE, 0x3, 0x3, 0, FALSE, 0, complain_overflow_dont, 0, "donealign32", FALSE, 0, 0, FALSE), 71 HOWTO (ALIGNDONE, 0x7, 0x7, 0, FALSE, 0, complain_overflow_dont, 0, "donealign64", FALSE, 0, 0, FALSE), 72 HOWTO (ALIGNDONE, 0xf, 0xf, 0, FALSE, 0, complain_overflow_dont, 0, "donealign128", FALSE, 0, 0, FALSE), 73}; 74 75/* Swaps the information in an executable header taken from a raw byte 76 stream memory image, into the internal exec_header structure. */ 77 78static void 79bout_swap_exec_header_in (bfd *abfd, 80 struct external_exec *bytes, 81 struct internal_exec *execp) 82{ 83 /* Now fill in fields in the execp, from the bytes in the raw data. */ 84 execp->a_info = H_GET_32 (abfd, bytes->e_info); 85 execp->a_text = GET_WORD (abfd, bytes->e_text); 86 execp->a_data = GET_WORD (abfd, bytes->e_data); 87 execp->a_bss = GET_WORD (abfd, bytes->e_bss); 88 execp->a_syms = GET_WORD (abfd, bytes->e_syms); 89 execp->a_entry = GET_WORD (abfd, bytes->e_entry); 90 execp->a_trsize = GET_WORD (abfd, bytes->e_trsize); 91 execp->a_drsize = GET_WORD (abfd, bytes->e_drsize); 92 execp->a_tload = GET_WORD (abfd, bytes->e_tload); 93 execp->a_dload = GET_WORD (abfd, bytes->e_dload); 94 execp->a_talign = bytes->e_talign[0]; 95 execp->a_dalign = bytes->e_dalign[0]; 96 execp->a_balign = bytes->e_balign[0]; 97 execp->a_relaxable = bytes->e_relaxable[0]; 98} 99 100/* Swaps the information in an internal exec header structure into the 101 supplied buffer ready for writing to disk. */ 102 103static void 104bout_swap_exec_header_out (bfd *abfd, 105 struct internal_exec *execp, 106 struct external_exec *bytes) 107{ 108 /* Now fill in fields in the raw data, from the fields in the exec struct. */ 109 H_PUT_32 (abfd, execp->a_info , bytes->e_info); 110 PUT_WORD (abfd, execp->a_text , bytes->e_text); 111 PUT_WORD (abfd, execp->a_data , bytes->e_data); 112 PUT_WORD (abfd, execp->a_bss , bytes->e_bss); 113 PUT_WORD (abfd, execp->a_syms , bytes->e_syms); 114 PUT_WORD (abfd, execp->a_entry , bytes->e_entry); 115 PUT_WORD (abfd, execp->a_trsize, bytes->e_trsize); 116 PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize); 117 PUT_WORD (abfd, execp->a_tload , bytes->e_tload); 118 PUT_WORD (abfd, execp->a_dload , bytes->e_dload); 119 bytes->e_talign[0] = execp->a_talign; 120 bytes->e_dalign[0] = execp->a_dalign; 121 bytes->e_balign[0] = execp->a_balign; 122 bytes->e_relaxable[0] = execp->a_relaxable; 123} 124 125/* Finish up the opening of a b.out file for reading. Fill in all the 126 fields that are not handled by common code. */ 127 128static const bfd_target * 129b_out_callback (bfd *abfd) 130{ 131 struct internal_exec *execp = exec_hdr (abfd); 132 unsigned long bss_start; 133 134 /* Architecture and machine type. */ 135 bfd_set_arch_mach (abfd, 136 bfd_arch_i960, /* B.out only used on i960. */ 137 bfd_mach_i960_core /* Default. */ 138 ); 139 140 /* The positions of the string table and symbol table. */ 141 obj_str_filepos (abfd) = N_STROFF (*execp); 142 obj_sym_filepos (abfd) = N_SYMOFF (*execp); 143 144 /* The alignments of the sections. */ 145 obj_textsec (abfd)->alignment_power = execp->a_talign; 146 obj_datasec (abfd)->alignment_power = execp->a_dalign; 147 obj_bsssec (abfd)->alignment_power = execp->a_balign; 148 149 /* The starting addresses of the sections. */ 150 obj_textsec (abfd)->vma = execp->a_tload; 151 obj_datasec (abfd)->vma = execp->a_dload; 152 153 obj_textsec (abfd)->lma = obj_textsec (abfd)->vma; 154 obj_datasec (abfd)->lma = obj_datasec (abfd)->vma; 155 156 /* And reload the sizes, since the aout module zaps them. */ 157 obj_textsec (abfd)->size = execp->a_text; 158 159 bss_start = execp->a_dload + execp->a_data; /* BSS = end of data section. */ 160 obj_bsssec (abfd)->vma = align_power (bss_start, execp->a_balign); 161 162 obj_bsssec (abfd)->lma = obj_bsssec (abfd)->vma; 163 164 /* The file positions of the sections. */ 165 obj_textsec (abfd)->filepos = N_TXTOFF (*execp); 166 obj_datasec (abfd)->filepos = N_DATOFF (*execp); 167 168 /* The file positions of the relocation info. */ 169 obj_textsec (abfd)->rel_filepos = N_TROFF (*execp); 170 obj_datasec (abfd)->rel_filepos = N_DROFF (*execp); 171 172 adata (abfd).page_size = 1; /* Not applicable. */ 173 adata (abfd).segment_size = 1; /* Not applicable. */ 174 adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE; 175 176 if (execp->a_relaxable) 177 abfd->flags |= BFD_IS_RELAXABLE; 178 return abfd->xvec; 179} 180 181static const bfd_target * 182b_out_object_p (bfd *abfd) 183{ 184 struct internal_exec anexec; 185 struct external_exec exec_bytes; 186 bfd_size_type amt = EXEC_BYTES_SIZE; 187 188 if (bfd_bread ((void *) &exec_bytes, amt, abfd) != amt) 189 { 190 if (bfd_get_error () != bfd_error_system_call) 191 bfd_set_error (bfd_error_wrong_format); 192 return 0; 193 } 194 195 anexec.a_info = H_GET_32 (abfd, exec_bytes.e_info); 196 197 if (N_BADMAG (anexec)) 198 { 199 bfd_set_error (bfd_error_wrong_format); 200 return 0; 201 } 202 203 bout_swap_exec_header_in (abfd, &exec_bytes, &anexec); 204 return aout_32_some_aout_object_p (abfd, &anexec, b_out_callback); 205} 206 207struct bout_data_struct 208 { 209 struct aoutdata a; 210 struct internal_exec e; 211 }; 212 213static bfd_boolean 214b_out_mkobject (bfd *abfd) 215{ 216 struct bout_data_struct *rawptr; 217 bfd_size_type amt = sizeof (struct bout_data_struct); 218 219 rawptr = bfd_zalloc (abfd, amt); 220 if (rawptr == NULL) 221 return FALSE; 222 223 abfd->tdata.bout_data = rawptr; 224 exec_hdr (abfd) = &rawptr->e; 225 226 obj_textsec (abfd) = NULL; 227 obj_datasec (abfd) = NULL; 228 obj_bsssec (abfd) = NULL; 229 230 return TRUE; 231} 232 233static int 234b_out_symbol_cmp (const void * a_ptr, const void * b_ptr) 235{ 236 struct aout_symbol ** a = (struct aout_symbol **) a_ptr; 237 struct aout_symbol ** b = (struct aout_symbol **) b_ptr; 238 asection *sec; 239 bfd_vma av, bv; 240 241 /* Primary key is address. */ 242 sec = bfd_get_section (&(*a)->symbol); 243 av = sec->output_section->vma + sec->output_offset + (*a)->symbol.value; 244 sec = bfd_get_section (&(*b)->symbol); 245 bv = sec->output_section->vma + sec->output_offset + (*b)->symbol.value; 246 247 if (av < bv) 248 return -1; 249 if (av > bv) 250 return 1; 251 252 /* Secondary key puts CALLNAME syms last and BALNAME syms first, 253 so that they have the best chance of being contiguous. */ 254 if (IS_BALNAME ((*a)->other) || IS_CALLNAME ((*b)->other)) 255 return -1; 256 if (IS_CALLNAME ((*a)->other) || IS_BALNAME ((*b)->other)) 257 return 1; 258 259 return 0; 260} 261 262static bfd_boolean 263b_out_squirt_out_relocs (bfd *abfd, asection *section) 264{ 265 arelent **generic; 266 int r_extern = 0; 267 int r_idx; 268 int incode_mask; 269 int len_1; 270 unsigned int count = section->reloc_count; 271 struct relocation_info *native, *natptr; 272 bfd_size_type natsize; 273 int extern_mask, pcrel_mask, len_2, callj_mask; 274 275 if (count == 0) 276 return TRUE; 277 278 generic = section->orelocation; 279 natsize = (bfd_size_type) count * sizeof (struct relocation_info); 280 native = bfd_malloc (natsize); 281 if (!native && natsize != 0) 282 return FALSE; 283 284 if (bfd_header_big_endian (abfd)) 285 { 286 /* Big-endian bit field allocation order. */ 287 pcrel_mask = 0x80; 288 extern_mask = 0x10; 289 len_2 = 0x40; 290 len_1 = 0x20; 291 callj_mask = 0x02; 292 incode_mask = 0x08; 293 } 294 else 295 { 296 /* Little-endian bit field allocation order. */ 297 pcrel_mask = 0x01; 298 extern_mask = 0x08; 299 len_2 = 0x04; 300 len_1 = 0x02; 301 callj_mask = 0x40; 302 incode_mask = 0x10; 303 } 304 305 for (natptr = native; count > 0; --count, ++natptr, ++generic) 306 { 307 arelent *g = *generic; 308 unsigned char *raw = (unsigned char *) natptr; 309 asymbol *sym = *(g->sym_ptr_ptr); 310 asection *output_section = sym->section->output_section; 311 312 H_PUT_32 (abfd, g->address, raw); 313 /* Find a type in the output format which matches the input howto - 314 at the moment we assume input format == output format FIXME!! */ 315 r_idx = 0; 316 /* FIXME: Need callj stuff here, and to check the howto entries to 317 be sure they are real for this architecture. */ 318 if (g->howto== &howto_reloc_callj) 319 raw[7] = callj_mask + pcrel_mask + len_2; 320 else if (g->howto == &howto_reloc_pcrel24) 321 raw[7] = pcrel_mask + len_2; 322 else if (g->howto == &howto_reloc_pcrel13) 323 raw[7] = pcrel_mask + len_1; 324 else if (g->howto == &howto_reloc_abs32code) 325 raw[7] = len_2 + incode_mask; 326 else if (g->howto >= howto_align_table 327 && g->howto <= (howto_align_table + ARRAY_SIZE (howto_align_table) - 1)) 328 { 329 /* symnum == -2; extern_mask not set, pcrel_mask set. */ 330 r_idx = -2; 331 r_extern = 0; 332 raw[7] = (pcrel_mask 333 | ((g->howto - howto_align_table) << 1)); 334 } 335 else 336 raw[7] = len_2; 337 338 if (r_idx != 0) 339 /* Already mucked with r_extern, r_idx. */; 340 else if (bfd_is_com_section (output_section) 341 || bfd_is_abs_section (output_section) 342 || bfd_is_und_section (output_section)) 343 { 344 if (bfd_abs_section_ptr->symbol == sym) 345 { 346 /* Whoops, looked like an abs symbol, but is really an offset 347 from the abs section. */ 348 r_idx = 0; 349 r_extern = 0; 350 } 351 else 352 { 353 /* Fill in symbol. */ 354 r_extern = 1; 355 r_idx = (*g->sym_ptr_ptr)->udata.i; 356 } 357 } 358 else 359 { 360 /* Just an ordinary section. */ 361 r_extern = 0; 362 r_idx = output_section->target_index; 363 } 364 365 if (bfd_header_big_endian (abfd)) 366 { 367 raw[4] = (unsigned char) (r_idx >> 16); 368 raw[5] = (unsigned char) (r_idx >> 8); 369 raw[6] = (unsigned char) (r_idx ); 370 } 371 else 372 { 373 raw[6] = (unsigned char) (r_idx >> 16); 374 raw[5] = (unsigned char) (r_idx>> 8); 375 raw[4] = (unsigned char) (r_idx ); 376 } 377 378 if (r_extern) 379 raw[7] |= extern_mask; 380 } 381 382 if (bfd_bwrite ((void *) native, natsize, abfd) != natsize) 383 { 384 free (native); 385 return FALSE; 386 } 387 388 free (native); 389 390 return TRUE; 391} 392 393static bfd_boolean 394b_out_write_object_contents (bfd *abfd) 395{ 396 struct external_exec swapped_hdr; 397 bfd_size_type amt; 398 399 if (! aout_32_make_sections (abfd)) 400 return FALSE; 401 402 exec_hdr (abfd)->a_info = BMAGIC; 403 404 exec_hdr (abfd)->a_text = obj_textsec (abfd)->size; 405 exec_hdr (abfd)->a_data = obj_datasec (abfd)->size; 406 exec_hdr (abfd)->a_bss = obj_bsssec (abfd)->size; 407 exec_hdr (abfd)->a_syms = bfd_get_symcount (abfd) * 12; 408 exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd); 409 exec_hdr (abfd)->a_trsize = (obj_textsec (abfd)->reloc_count) * 8; 410 exec_hdr (abfd)->a_drsize = (obj_datasec (abfd)->reloc_count) * 8; 411 412 exec_hdr (abfd)->a_talign = obj_textsec (abfd)->alignment_power; 413 exec_hdr (abfd)->a_dalign = obj_datasec (abfd)->alignment_power; 414 exec_hdr (abfd)->a_balign = obj_bsssec (abfd)->alignment_power; 415 416 exec_hdr (abfd)->a_tload = obj_textsec (abfd)->vma; 417 exec_hdr (abfd)->a_dload = obj_datasec (abfd)->vma; 418 419 bout_swap_exec_header_out (abfd, exec_hdr (abfd), &swapped_hdr); 420 421 amt = EXEC_BYTES_SIZE; 422 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 423 || bfd_bwrite ((void *) &swapped_hdr, amt, abfd) != amt) 424 return FALSE; 425 426 /* Now write out reloc info, followed by syms and strings */ 427 if (bfd_get_symcount (abfd) != 0) 428 { 429 /* Make sure {CALL,BAL}NAME symbols remain adjacent on output 430 by sorting. This is complicated by the fact that stabs are 431 also ordered. Solve this by shifting all stabs to the end 432 in order, then sorting the rest. */ 433 434 asymbol **outsyms, **p, **q; 435 436 outsyms = bfd_get_outsymbols (abfd); 437 p = outsyms + bfd_get_symcount (abfd); 438 439 for (q = p--; p >= outsyms; p--) 440 { 441 if ((*p)->flags & BSF_DEBUGGING) 442 { 443 asymbol *t = *--q; 444 *q = *p; 445 *p = t; 446 } 447 } 448 449 if (q > outsyms) 450 qsort (outsyms, (size_t) (q - outsyms), sizeof (asymbol*), 451 b_out_symbol_cmp); 452 453 /* Back to your regularly scheduled program. */ 454 if (bfd_seek (abfd, (file_ptr) (N_SYMOFF (*exec_hdr (abfd))), SEEK_SET) 455 != 0) 456 return FALSE; 457 458 if (! aout_32_write_syms (abfd)) 459 return FALSE; 460 461 if (bfd_seek (abfd, (file_ptr) (N_TROFF (*exec_hdr (abfd))), SEEK_SET) 462 != 0) 463 return FALSE; 464 465 if (!b_out_squirt_out_relocs (abfd, obj_textsec (abfd))) 466 return FALSE; 467 if (bfd_seek (abfd, (file_ptr) (N_DROFF (*exec_hdr (abfd))), SEEK_SET) 468 != 0) 469 return FALSE; 470 471 if (!b_out_squirt_out_relocs (abfd, obj_datasec (abfd))) 472 return FALSE; 473 } 474 return TRUE; 475} 476 477/* Some reloc hackery. */ 478 479#define CALLS 0x66003800 /* Template for 'calls' instruction */ 480#define BAL 0x0b000000 /* Template for 'bal' instruction */ 481#define BAL_MASK 0x00ffffff 482#define BALX 0x85f00000 /* Template for 'balx' instruction */ 483#define BALX_MASK 0x0007ffff 484#define CALL 0x09000000 485#define PCREL13_MASK 0x1fff 486 487#define output_addr(sec) ((sec)->output_offset+(sec)->output_section->vma) 488 489static bfd_vma 490get_value (arelent *reloc, 491 struct bfd_link_info *link_info, 492 asection *input_section) 493{ 494 bfd_vma value; 495 asymbol *symbol = *(reloc->sym_ptr_ptr); 496 497 /* A symbol holds a pointer to a section, and an offset from the 498 base of the section. To relocate, we find where the section will 499 live in the output and add that in. */ 500 if (bfd_is_und_section (symbol->section)) 501 { 502 struct bfd_link_hash_entry *h; 503 504 /* The symbol is undefined in this BFD. Look it up in the 505 global linker hash table. FIXME: This should be changed when 506 we convert b.out to use a specific final_link function and 507 change the interface to bfd_relax_section to not require the 508 generic symbols. */ 509 h = bfd_wrapped_link_hash_lookup (input_section->owner, link_info, 510 bfd_asymbol_name (symbol), 511 FALSE, FALSE, TRUE); 512 if (h != (struct bfd_link_hash_entry *) NULL 513 && (h->type == bfd_link_hash_defined 514 || h->type == bfd_link_hash_defweak)) 515 value = h->u.def.value + output_addr (h->u.def.section); 516 else if (h != (struct bfd_link_hash_entry *) NULL 517 && h->type == bfd_link_hash_common) 518 value = h->u.c.size; 519 else 520 { 521 if (! ((*link_info->callbacks->undefined_symbol) 522 (link_info, bfd_asymbol_name (symbol), 523 input_section->owner, input_section, reloc->address, 524 TRUE))) 525 abort (); 526 value = 0; 527 } 528 } 529 else 530 value = symbol->value + output_addr (symbol->section); 531 532 /* Add the value contained in the relocation. */ 533 value += reloc->addend; 534 535 return value; 536} 537 538/* Magic to turn callx into calljx. */ 539 540static bfd_reloc_status_type 541calljx_callback (bfd *abfd, 542 struct bfd_link_info *link_info, 543 arelent *reloc_entry, 544 void * src, 545 void * dst, 546 asection *input_section) 547{ 548 int word = bfd_get_32 (abfd, src); 549 asymbol *symbol_in = *(reloc_entry->sym_ptr_ptr); 550 aout_symbol_type *symbol = aout_symbol (symbol_in); 551 bfd_vma value; 552 553 value = get_value (reloc_entry, link_info, input_section); 554 555 if (IS_CALLNAME (symbol->other)) 556 { 557 aout_symbol_type *balsym = symbol+1; 558 int inst = bfd_get_32 (abfd, (bfd_byte *) src-4); 559 560 /* The next symbol should be an N_BALNAME. */ 561 BFD_ASSERT (IS_BALNAME (balsym->other)); 562 inst &= BALX_MASK; 563 inst |= BALX; 564 bfd_put_32 (abfd, (bfd_vma) inst, (bfd_byte *) dst-4); 565 symbol = balsym; 566 value = (symbol->symbol.value 567 + output_addr (symbol->symbol.section)); 568 } 569 570 word += value + reloc_entry->addend; 571 572 bfd_put_32 (abfd, (bfd_vma) word, dst); 573 return bfd_reloc_ok; 574} 575 576/* Magic to turn call into callj. */ 577 578static bfd_reloc_status_type 579callj_callback (bfd *abfd, 580 struct bfd_link_info *link_info, 581 arelent *reloc_entry, 582 void * data, 583 unsigned int srcidx, 584 unsigned int dstidx, 585 asection *input_section, 586 bfd_boolean shrinking) 587{ 588 int word = bfd_get_32 (abfd, (bfd_byte *) data + srcidx); 589 asymbol *symbol_in = *(reloc_entry->sym_ptr_ptr); 590 aout_symbol_type *symbol = aout_symbol (symbol_in); 591 bfd_vma value; 592 593 value = get_value (reloc_entry, link_info, input_section); 594 595 if (IS_OTHER (symbol->other)) 596 /* Call to a system procedure - replace code with system 597 procedure number. */ 598 word = CALLS | (symbol->other - 1); 599 600 else if (IS_CALLNAME (symbol->other)) 601 { 602 aout_symbol_type *balsym = symbol+1; 603 604 /* The next symbol should be an N_BALNAME. */ 605 BFD_ASSERT (IS_BALNAME (balsym->other)); 606 607 /* We are calling a leaf, so replace the call instruction with a 608 bal. */ 609 word = BAL | ((word 610 + output_addr (balsym->symbol.section) 611 + balsym->symbol.value + reloc_entry->addend 612 - dstidx 613 - output_addr (input_section)) 614 & BAL_MASK); 615 } 616 else if ((symbol->symbol.flags & BSF_SECTION_SYM) != 0) 617 { 618 /* A callj against a symbol in the same section is a fully 619 resolved relative call. We don't need to do anything here. 620 If the symbol is not in the same section, I'm not sure what 621 to do; fortunately, this case will probably never arise. */ 622 BFD_ASSERT (! shrinking); 623 BFD_ASSERT (symbol->symbol.section == input_section); 624 } 625 else 626 word = CALL | (((word & BAL_MASK) 627 + value 628 + reloc_entry->addend 629 - (shrinking ? dstidx : 0) 630 - output_addr (input_section)) 631 & BAL_MASK); 632 633 bfd_put_32 (abfd, (bfd_vma) word, (bfd_byte *) data + dstidx); 634 return bfd_reloc_ok; 635} 636 637static reloc_howto_type * 638b_out_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code) 639{ 640 switch (code) 641 { 642 default: 643 return 0; 644 case BFD_RELOC_I960_CALLJ: 645 return &howto_reloc_callj; 646 case BFD_RELOC_32: 647 case BFD_RELOC_CTOR: 648 return &howto_reloc_abs32; 649 case BFD_RELOC_24_PCREL: 650 return &howto_reloc_pcrel24; 651 } 652} 653 654/* Allocate enough room for all the reloc entries, plus pointers to them all. */ 655 656static bfd_boolean 657b_out_slurp_reloc_table (bfd *abfd, sec_ptr asect, asymbol **symbols) 658{ 659 struct relocation_info *rptr; 660 unsigned int counter; 661 arelent *cache_ptr; 662 int extern_mask, pcrel_mask, callj_mask, length_shift; 663 int incode_mask; 664 int size_mask; 665 bfd_vma prev_addr = 0; 666 unsigned int count; 667 bfd_size_type reloc_size, amt; 668 struct relocation_info *relocs; 669 arelent *reloc_cache; 670 671 if (asect->relocation) 672 return TRUE; 673 674 if (!aout_32_slurp_symbol_table (abfd)) 675 return FALSE; 676 677 if (asect == obj_datasec (abfd)) 678 reloc_size = exec_hdr (abfd)->a_drsize; 679 else if (asect == obj_textsec (abfd)) 680 reloc_size = exec_hdr (abfd)->a_trsize; 681 else if (asect == obj_bsssec (abfd)) 682 reloc_size = 0; 683 else 684 { 685 bfd_set_error (bfd_error_invalid_operation); 686 return FALSE; 687 } 688 689 if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0) 690 return FALSE; 691 count = reloc_size / sizeof (struct relocation_info); 692 693 relocs = bfd_malloc (reloc_size); 694 if (!relocs && reloc_size != 0) 695 return FALSE; 696 697 amt = ((bfd_size_type) count + 1) * sizeof (arelent); 698 reloc_cache = bfd_malloc (amt); 699 if (!reloc_cache) 700 { 701 if (relocs != NULL) 702 free (relocs); 703 return FALSE; 704 } 705 706 if (bfd_bread ((void *) relocs, reloc_size, abfd) != reloc_size) 707 { 708 free (reloc_cache); 709 if (relocs != NULL) 710 free (relocs); 711 return FALSE; 712 } 713 714 if (bfd_header_big_endian (abfd)) 715 { 716 /* Big-endian bit field allocation order. */ 717 pcrel_mask = 0x80; 718 extern_mask = 0x10; 719 incode_mask = 0x08; 720 callj_mask = 0x02; 721 size_mask = 0x20; 722 length_shift = 5; 723 } 724 else 725 { 726 /* Little-endian bit field allocation order. */ 727 pcrel_mask = 0x01; 728 extern_mask = 0x08; 729 incode_mask = 0x10; 730 callj_mask = 0x40; 731 size_mask = 0x02; 732 length_shift = 1; 733 } 734 735 for (rptr = relocs, cache_ptr = reloc_cache, counter = 0; 736 counter < count; 737 counter++, rptr++, cache_ptr++) 738 { 739 unsigned char *raw = (unsigned char *)rptr; 740 unsigned int symnum; 741 742 cache_ptr->address = H_GET_32 (abfd, raw + 0); 743 cache_ptr->howto = 0; 744 745 if (bfd_header_big_endian (abfd)) 746 symnum = (raw[4] << 16) | (raw[5] << 8) | raw[6]; 747 else 748 symnum = (raw[6] << 16) | (raw[5] << 8) | raw[4]; 749 750 if (raw[7] & extern_mask) 751 { 752 /* If this is set then the r_index is an index into the symbol table; 753 if the bit is not set then r_index contains a section map. 754 We either fill in the sym entry with a pointer to the symbol, 755 or point to the correct section. */ 756 cache_ptr->sym_ptr_ptr = symbols + symnum; 757 cache_ptr->addend = 0; 758 } 759 else 760 { 761 /* In a.out symbols are relative to the beginning of the 762 file rather than sections ? 763 (look in translate_from_native_sym_flags) 764 The reloc entry addend has added to it the offset into the 765 file of the data, so subtract the base to make the reloc 766 section relative. */ 767 int s; 768 769 /* Sign-extend symnum from 24 bits to whatever host uses. */ 770 s = symnum; 771 if (s & (1 << 23)) 772 s |= (~0) << 24; 773 774 cache_ptr->sym_ptr_ptr = (asymbol **)NULL; 775 switch (s) 776 { 777 case N_TEXT: 778 case N_TEXT | N_EXT: 779 cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr; 780 cache_ptr->addend = - obj_textsec (abfd)->vma; 781 break; 782 case N_DATA: 783 case N_DATA | N_EXT: 784 cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr; 785 cache_ptr->addend = - obj_datasec (abfd)->vma; 786 break; 787 case N_BSS: 788 case N_BSS | N_EXT: 789 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; 790 cache_ptr->addend = - obj_bsssec (abfd)->vma; 791 break; 792 case N_ABS: 793 case N_ABS | N_EXT: 794 cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr; 795 cache_ptr->addend = 0; 796 break; 797 case -2: /* .align */ 798 if (raw[7] & pcrel_mask) 799 { 800 cache_ptr->howto = &howto_align_table[(raw[7] >> length_shift) & 3]; 801 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 802 } 803 else 804 { 805 /* .org? */ 806 abort (); 807 } 808 cache_ptr->addend = 0; 809 break; 810 default: 811 BFD_ASSERT (FALSE); 812 break; 813 } 814 } 815 816 /* The i960 only has a few relocation types: 817 abs 32-bit and pcrel 24bit. except for callj's! */ 818 if (cache_ptr->howto != 0) 819 ; 820 else if (raw[7] & callj_mask) 821 { 822 cache_ptr->howto = &howto_reloc_callj; 823 } 824 else if ( raw[7] & pcrel_mask) 825 { 826 if (raw[7] & size_mask) 827 cache_ptr->howto = &howto_reloc_pcrel13; 828 else 829 cache_ptr->howto = &howto_reloc_pcrel24; 830 } 831 else 832 { 833 if (raw[7] & incode_mask) 834 cache_ptr->howto = &howto_reloc_abs32code; 835 else 836 cache_ptr->howto = &howto_reloc_abs32; 837 } 838 839 if (cache_ptr->address < prev_addr) 840 { 841 /* Ouch! this reloc is out of order, insert into the right place. */ 842 arelent tmp; 843 arelent *cursor = cache_ptr-1; 844 bfd_vma stop = cache_ptr->address; 845 846 tmp = *cache_ptr; 847 while (cursor->address > stop && cursor >= reloc_cache) 848 { 849 cursor[1] = cursor[0]; 850 cursor--; 851 } 852 853 cursor[1] = tmp; 854 } 855 else 856 prev_addr = cache_ptr->address; 857 } 858 859 if (relocs != NULL) 860 free (relocs); 861 asect->relocation = reloc_cache; 862 asect->reloc_count = count; 863 864 return TRUE; 865} 866 867/* This is stupid. This function should be a boolean predicate. */ 868 869static long 870b_out_canonicalize_reloc (bfd *abfd, 871 sec_ptr section, 872 arelent **relptr, 873 asymbol **symbols) 874{ 875 arelent *tblptr; 876 unsigned int count; 877 878 if ((section->flags & SEC_CONSTRUCTOR) != 0) 879 { 880 arelent_chain *chain = section->constructor_chain; 881 882 for (count = 0; count < section->reloc_count; count++) 883 { 884 *relptr++ = &chain->relent; 885 chain = chain->next; 886 } 887 } 888 else 889 { 890 if (section->relocation == NULL 891 && ! b_out_slurp_reloc_table (abfd, section, symbols)) 892 return -1; 893 894 tblptr = section->relocation; 895 for (count = 0; count++ < section->reloc_count;) 896 *relptr++ = tblptr++; 897 } 898 899 *relptr = NULL; 900 901 return section->reloc_count; 902} 903 904static long 905b_out_get_reloc_upper_bound (bfd *abfd, sec_ptr asect) 906{ 907 if (bfd_get_format (abfd) != bfd_object) 908 { 909 bfd_set_error (bfd_error_invalid_operation); 910 return -1; 911 } 912 913 if (asect->flags & SEC_CONSTRUCTOR) 914 return sizeof (arelent *) * (asect->reloc_count + 1); 915 916 if (asect == obj_datasec (abfd)) 917 return (sizeof (arelent *) * 918 ((exec_hdr (abfd)->a_drsize / sizeof (struct relocation_info)) 919 + 1)); 920 921 if (asect == obj_textsec (abfd)) 922 return (sizeof (arelent *) * 923 ((exec_hdr (abfd)->a_trsize / sizeof (struct relocation_info)) 924 + 1)); 925 926 if (asect == obj_bsssec (abfd)) 927 return 0; 928 929 bfd_set_error (bfd_error_invalid_operation); 930 return -1; 931} 932 933 934static bfd_boolean 935b_out_set_section_contents (bfd *abfd, 936 asection *section, 937 const void * location, 938 file_ptr offset, 939 bfd_size_type count) 940{ 941 if (! abfd->output_has_begun) 942 { 943 /* Set by bfd.c handler. */ 944 if (! aout_32_make_sections (abfd)) 945 return FALSE; 946 947 obj_textsec (abfd)->filepos = sizeof (struct external_exec); 948 obj_datasec (abfd)->filepos = obj_textsec (abfd)->filepos 949 + obj_textsec (abfd)->size; 950 } 951 952 /* Regardless, once we know what we're doing, we might as well get going. */ 953 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0) 954 return FALSE; 955 956 if (count == 0) 957 return TRUE; 958 959 return bfd_bwrite ((void *) location, count, abfd) == count; 960} 961 962static bfd_boolean 963b_out_set_arch_mach (bfd *abfd, 964 enum bfd_architecture arch, 965 unsigned long machine) 966{ 967 bfd_default_set_arch_mach (abfd, arch, machine); 968 969 if (arch == bfd_arch_unknown) /* Unknown machine arch is OK. */ 970 return TRUE; 971 972 if (arch == bfd_arch_i960) /* i960 default is OK. */ 973 switch (machine) 974 { 975 case bfd_mach_i960_core: 976 case bfd_mach_i960_kb_sb: 977 case bfd_mach_i960_mc: 978 case bfd_mach_i960_xa: 979 case bfd_mach_i960_ca: 980 case bfd_mach_i960_ka_sa: 981 case bfd_mach_i960_jx: 982 case bfd_mach_i960_hx: 983 case 0: 984 return TRUE; 985 default: 986 return FALSE; 987 } 988 989 return FALSE; 990} 991 992static int 993b_out_sizeof_headers (bfd *ignore_abfd ATTRIBUTE_UNUSED, bfd_boolean ignore ATTRIBUTE_UNUSED) 994{ 995 return sizeof (struct external_exec); 996} 997 998static void 999perform_slip (bfd *abfd, 1000 unsigned int slip, 1001 asection *input_section, 1002 bfd_vma value) 1003{ 1004 asymbol **s; 1005 1006 s = _bfd_generic_link_get_symbols (abfd); 1007 BFD_ASSERT (s != (asymbol **) NULL); 1008 1009 /* Find all symbols past this point, and make them know 1010 what's happened. */ 1011 while (*s) 1012 { 1013 asymbol *p = *s; 1014 1015 if (p->section == input_section) 1016 { 1017 /* This was pointing into this section, so mangle it. */ 1018 if (p->value > value) 1019 { 1020 p->value -=slip; 1021 1022 if (p->udata.p != NULL) 1023 { 1024 struct generic_link_hash_entry *h; 1025 1026 h = (struct generic_link_hash_entry *) p->udata.p; 1027 BFD_ASSERT (h->root.type == bfd_link_hash_defined); 1028 h->root.u.def.value -= slip; 1029 BFD_ASSERT (h->root.u.def.value == p->value); 1030 } 1031 } 1032 } 1033 s++; 1034 } 1035} 1036 1037/* This routine works out if the thing we want to get to can be 1038 reached with a 24bit offset instead of a 32 bit one. 1039 If it can, then it changes the amode. */ 1040 1041static int 1042abs32code (bfd *abfd, 1043 asection *input_section, 1044 arelent *r, 1045 unsigned int shrink, 1046 struct bfd_link_info *link_info) 1047{ 1048 bfd_vma value = get_value (r, link_info, input_section); 1049 bfd_vma dot = output_addr (input_section) + r->address; 1050 bfd_vma gap; 1051 1052 /* See if the address we're looking at within 2^23 bytes of where 1053 we are, if so then we can use a small branch rather than the 1054 jump we were going to. */ 1055 gap = value - (dot - shrink); 1056 1057 if (-1 << 23 < (long)gap && (long)gap < 1 << 23) 1058 { 1059 /* Change the reloc type from 32bitcode possible 24, to 24bit 1060 possible 32. */ 1061 r->howto = &howto_reloc_abs32codeshrunk; 1062 /* The place to relc moves back by four bytes. */ 1063 r->address -=4; 1064 1065 /* This will be four bytes smaller in the long run. */ 1066 shrink += 4 ; 1067 perform_slip (abfd, 4, input_section, r->address-shrink + 4); 1068 } 1069 1070 return shrink; 1071} 1072 1073static int 1074aligncode (bfd *abfd, 1075 asection *input_section, 1076 arelent *r, 1077 unsigned int shrink) 1078{ 1079 bfd_vma dot = output_addr (input_section) + r->address; 1080 bfd_vma gap; 1081 bfd_vma old_end; 1082 bfd_vma new_end; 1083 unsigned int shrink_delta; 1084 int size = r->howto->size; 1085 1086 /* Reduce the size of the alignment so that it's still aligned but 1087 smaller - the current size is already the same size as or bigger 1088 than the alignment required. */ 1089 1090 /* Calculate the first byte following the padding before we optimize. */ 1091 old_end = ((dot + size ) & ~size) + size+1; 1092 /* Work out where the new end will be - remember that we're smaller 1093 than we used to be. */ 1094 new_end = ((dot - shrink + size) & ~size); 1095 1096 /* This is the new end. */ 1097 gap = old_end - ((dot + size) & ~size); 1098 1099 shrink_delta = (old_end - new_end) - shrink; 1100 1101 if (shrink_delta) 1102 { 1103 /* Change the reloc so that it knows how far to align to. */ 1104 r->howto = howto_done_align_table + (r->howto - howto_align_table); 1105 1106 /* Encode the stuff into the addend - for future use we need to 1107 know how big the reloc used to be. */ 1108 r->addend = old_end - dot + r->address; 1109 1110 /* This will be N bytes smaller in the long run, adjust all the symbols. */ 1111 perform_slip (abfd, shrink_delta, input_section, r->address - shrink); 1112 shrink += shrink_delta; 1113 } 1114 1115 return shrink; 1116} 1117 1118static bfd_boolean 1119b_out_bfd_relax_section (bfd *abfd, 1120 asection *i, 1121 struct bfd_link_info *link_info, 1122 bfd_boolean *again) 1123{ 1124 /* Get enough memory to hold the stuff. */ 1125 bfd *input_bfd = i->owner; 1126 asection *input_section = i; 1127 unsigned int shrink = 0 ; 1128 arelent **reloc_vector = NULL; 1129 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section); 1130 1131 if (reloc_size < 0) 1132 return FALSE; 1133 1134 /* We only run this relaxation once. It might work to run it 1135 multiple times, but it hasn't been tested. */ 1136 *again = FALSE; 1137 1138 if (reloc_size) 1139 { 1140 long reloc_count; 1141 1142 reloc_vector = bfd_malloc ((bfd_size_type) reloc_size); 1143 if (reloc_vector == NULL && reloc_size != 0) 1144 goto error_return; 1145 1146 /* Get the relocs and think about them. */ 1147 reloc_count = 1148 bfd_canonicalize_reloc (input_bfd, input_section, reloc_vector, 1149 _bfd_generic_link_get_symbols (input_bfd)); 1150 if (reloc_count < 0) 1151 goto error_return; 1152 if (reloc_count > 0) 1153 { 1154 arelent **parent; 1155 1156 for (parent = reloc_vector; *parent; parent++) 1157 { 1158 arelent *r = *parent; 1159 1160 switch (r->howto->type) 1161 { 1162 case ALIGNER: 1163 /* An alignment reloc. */ 1164 shrink = aligncode (abfd, input_section, r, shrink); 1165 break; 1166 case ABS32CODE: 1167 /* A 32bit reloc in an addressing mode. */ 1168 shrink = abs32code (input_bfd, input_section, r, shrink, 1169 link_info); 1170 break; 1171 case ABS32CODE_SHRUNK: 1172 shrink += 4; 1173 break; 1174 } 1175 } 1176 } 1177 } 1178 input_section->size -= shrink; 1179 1180 if (reloc_vector != NULL) 1181 free (reloc_vector); 1182 return TRUE; 1183 error_return: 1184 if (reloc_vector != NULL) 1185 free (reloc_vector); 1186 return FALSE; 1187} 1188 1189static bfd_byte * 1190b_out_bfd_get_relocated_section_contents (bfd *output_bfd, 1191 struct bfd_link_info *link_info, 1192 struct bfd_link_order *link_order, 1193 bfd_byte *data, 1194 bfd_boolean relocatable, 1195 asymbol **symbols) 1196{ 1197 /* Get enough memory to hold the stuff. */ 1198 bfd *input_bfd = link_order->u.indirect.section->owner; 1199 asection *input_section = link_order->u.indirect.section; 1200 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section); 1201 arelent **reloc_vector = NULL; 1202 long reloc_count; 1203 1204 if (reloc_size < 0) 1205 goto error_return; 1206 1207 /* If producing relocatable output, don't bother to relax. */ 1208 if (relocatable) 1209 return bfd_generic_get_relocated_section_contents (output_bfd, link_info, 1210 link_order, 1211 data, relocatable, 1212 symbols); 1213 1214 reloc_vector = bfd_malloc ((bfd_size_type) reloc_size); 1215 if (reloc_vector == NULL && reloc_size != 0) 1216 goto error_return; 1217 1218 /* Read in the section. */ 1219 BFD_ASSERT (bfd_get_section_contents (input_bfd, 1220 input_section, 1221 data, 1222 (bfd_vma) 0, 1223 input_section->size)); 1224 1225 reloc_count = bfd_canonicalize_reloc (input_bfd, 1226 input_section, 1227 reloc_vector, 1228 symbols); 1229 if (reloc_count < 0) 1230 goto error_return; 1231 if (reloc_count > 0) 1232 { 1233 arelent **parent = reloc_vector; 1234 arelent *reloc ; 1235 unsigned int dst_address = 0; 1236 unsigned int src_address = 0; 1237 unsigned int run; 1238 unsigned int idx; 1239 1240 /* Find how long a run we can do. */ 1241 while (dst_address < link_order->size) 1242 { 1243 reloc = *parent; 1244 if (reloc) 1245 { 1246 /* Note that the relaxing didn't tie up the addresses in the 1247 relocation, so we use the original address to work out the 1248 run of non-relocated data. */ 1249 BFD_ASSERT (reloc->address >= src_address); 1250 run = reloc->address - src_address; 1251 parent++; 1252 } 1253 else 1254 run = link_order->size - dst_address; 1255 1256 /* Copy the bytes. */ 1257 for (idx = 0; idx < run; idx++) 1258 data[dst_address++] = data[src_address++]; 1259 1260 /* Now do the relocation. */ 1261 if (reloc) 1262 { 1263 switch (reloc->howto->type) 1264 { 1265 case ABS32CODE: 1266 calljx_callback (input_bfd, link_info, reloc, 1267 src_address + data, dst_address + data, 1268 input_section); 1269 src_address += 4; 1270 dst_address += 4; 1271 break; 1272 case ABS32: 1273 bfd_put_32 (input_bfd, 1274 (bfd_get_32 (input_bfd, data + src_address) 1275 + get_value (reloc, link_info, input_section)), 1276 data + dst_address); 1277 src_address += 4; 1278 dst_address += 4; 1279 break; 1280 case CALLJ: 1281 callj_callback (input_bfd, link_info, reloc, data, 1282 src_address, dst_address, input_section, 1283 FALSE); 1284 src_address += 4; 1285 dst_address += 4; 1286 break; 1287 case ALIGNDONE: 1288 BFD_ASSERT (reloc->addend >= src_address); 1289 BFD_ASSERT ((bfd_vma) reloc->addend 1290 <= input_section->size); 1291 src_address = reloc->addend; 1292 dst_address = ((dst_address + reloc->howto->size) 1293 & ~reloc->howto->size); 1294 break; 1295 case ABS32CODE_SHRUNK: 1296 /* This used to be a callx, but we've found out that a 1297 callj will reach, so do the right thing. */ 1298 callj_callback (input_bfd, link_info, reloc, data, 1299 src_address + 4, dst_address, input_section, 1300 TRUE); 1301 dst_address += 4; 1302 src_address += 8; 1303 break; 1304 case PCREL24: 1305 { 1306 long int word = bfd_get_32 (input_bfd, 1307 data + src_address); 1308 bfd_vma value; 1309 1310 value = get_value (reloc, link_info, input_section); 1311 word = ((word & ~BAL_MASK) 1312 | (((word & BAL_MASK) 1313 + value 1314 - output_addr (input_section) 1315 + reloc->addend) 1316 & BAL_MASK)); 1317 1318 bfd_put_32 (input_bfd, (bfd_vma) word, data + dst_address); 1319 dst_address += 4; 1320 src_address += 4; 1321 1322 } 1323 break; 1324 case PCREL13: 1325 { 1326 long int word = bfd_get_32 (input_bfd, 1327 data + src_address); 1328 bfd_vma value; 1329 1330 value = get_value (reloc, link_info, input_section); 1331 word = ((word & ~PCREL13_MASK) 1332 | (((word & PCREL13_MASK) 1333 + value 1334 + reloc->addend 1335 - output_addr (input_section)) 1336 & PCREL13_MASK)); 1337 1338 bfd_put_32 (input_bfd, (bfd_vma) word, data + dst_address); 1339 dst_address += 4; 1340 src_address += 4; 1341 } 1342 break; 1343 1344 default: 1345 abort (); 1346 } 1347 } 1348 } 1349 } 1350 if (reloc_vector != NULL) 1351 free (reloc_vector); 1352 return data; 1353 error_return: 1354 if (reloc_vector != NULL) 1355 free (reloc_vector); 1356 return NULL; 1357} 1358 1359 1360/* Build the transfer vectors for Big and Little-Endian B.OUT files. */ 1361 1362#define aout_32_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol 1363#define aout_32_close_and_cleanup aout_32_bfd_free_cached_info 1364#define b_out_bfd_link_hash_table_create _bfd_generic_link_hash_table_create 1365#define b_out_bfd_link_hash_table_free _bfd_generic_link_hash_table_free 1366#define b_out_bfd_link_add_symbols _bfd_generic_link_add_symbols 1367#define b_out_bfd_link_just_syms _bfd_generic_link_just_syms 1368#define b_out_bfd_final_link _bfd_generic_final_link 1369#define b_out_bfd_link_split_section _bfd_generic_link_split_section 1370#define b_out_bfd_gc_sections bfd_generic_gc_sections 1371#define b_out_bfd_merge_sections bfd_generic_merge_sections 1372#define b_out_bfd_is_group_section bfd_generic_is_group_section 1373#define b_out_bfd_discard_group bfd_generic_discard_group 1374#define b_out_section_already_linked _bfd_generic_section_already_linked 1375#define aout_32_get_section_contents_in_window _bfd_generic_get_section_contents_in_window 1376 1377extern const bfd_target b_out_vec_little_host; 1378 1379const bfd_target b_out_vec_big_host = 1380{ 1381 "b.out.big", /* Name. */ 1382 bfd_target_aout_flavour, 1383 BFD_ENDIAN_LITTLE, /* Data byte order. */ 1384 BFD_ENDIAN_BIG, /* Header byte order. */ 1385 (HAS_RELOC | EXEC_P | /* Object flags. */ 1386 HAS_LINENO | HAS_DEBUG | 1387 HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ), 1388 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA), 1389 '_', /* Symbol leading char. */ 1390 ' ', /* AR_pad_char. */ 1391 16, /* AR_max_namelen. */ 1392 1393 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 1394 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 1395 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data. */ 1396 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 1397 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 1398 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */ 1399 {_bfd_dummy_target, b_out_object_p, /* bfd_check_format. */ 1400 bfd_generic_archive_p, _bfd_dummy_target}, 1401 {bfd_false, b_out_mkobject, /* bfd_set_format. */ 1402 _bfd_generic_mkarchive, bfd_false}, 1403 {bfd_false, b_out_write_object_contents, /* bfd_write_contents. */ 1404 _bfd_write_archive_contents, bfd_false}, 1405 1406 BFD_JUMP_TABLE_GENERIC (aout_32), 1407 BFD_JUMP_TABLE_COPY (_bfd_generic), 1408 BFD_JUMP_TABLE_CORE (_bfd_nocore), 1409 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_bsd), 1410 BFD_JUMP_TABLE_SYMBOLS (aout_32), 1411 BFD_JUMP_TABLE_RELOCS (b_out), 1412 BFD_JUMP_TABLE_WRITE (b_out), 1413 BFD_JUMP_TABLE_LINK (b_out), 1414 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 1415 1416 & b_out_vec_little_host, 1417 1418 NULL 1419}; 1420 1421const bfd_target b_out_vec_little_host = 1422{ 1423 "b.out.little", /* Name. */ 1424 bfd_target_aout_flavour, 1425 BFD_ENDIAN_LITTLE, /* Data byte order. */ 1426 BFD_ENDIAN_LITTLE, /* Header byte order. */ 1427 (HAS_RELOC | EXEC_P | /* Object flags. */ 1428 HAS_LINENO | HAS_DEBUG | 1429 HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ), 1430 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA), 1431 '_', /* Symbol leading char. */ 1432 ' ', /* AR_pad_char. */ 1433 16, /* AR_max_namelen. */ 1434 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 1435 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 1436 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data. */ 1437 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 1438 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 1439 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Headers. */ 1440 1441 {_bfd_dummy_target, b_out_object_p, /* bfd_check_format. */ 1442 bfd_generic_archive_p, _bfd_dummy_target}, 1443 {bfd_false, b_out_mkobject, /* bfd_set_format. */ 1444 _bfd_generic_mkarchive, bfd_false}, 1445 {bfd_false, b_out_write_object_contents, /* bfd_write_contents. */ 1446 _bfd_write_archive_contents, bfd_false}, 1447 1448 BFD_JUMP_TABLE_GENERIC (aout_32), 1449 BFD_JUMP_TABLE_COPY (_bfd_generic), 1450 BFD_JUMP_TABLE_CORE (_bfd_nocore), 1451 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_bsd), 1452 BFD_JUMP_TABLE_SYMBOLS (aout_32), 1453 BFD_JUMP_TABLE_RELOCS (b_out), 1454 BFD_JUMP_TABLE_WRITE (b_out), 1455 BFD_JUMP_TABLE_LINK (b_out), 1456 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 1457 1458 & b_out_vec_big_host, 1459 1460 NULL 1461}; 1462