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