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