coff-alpha.c revision 130562
1/* BFD back-end for ALPHA Extended-Coff files. 2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 3 Free Software Foundation, Inc. 4 Modified from coff-mips.c by Steve Chamberlain <sac@cygnus.com> and 5 Ian Lance Taylor <ian@cygnus.com>. 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 "bfdlink.h" 26#include "libbfd.h" 27#include "coff/internal.h" 28#include "coff/sym.h" 29#include "coff/symconst.h" 30#include "coff/ecoff.h" 31#include "coff/alpha.h" 32#include "aout/ar.h" 33#include "libcoff.h" 34#include "libecoff.h" 35 36/* Prototypes for static functions. */ 37 38static const bfd_target *alpha_ecoff_object_p 39 PARAMS ((bfd *)); 40static bfd_boolean alpha_ecoff_bad_format_hook 41 PARAMS ((bfd *abfd, PTR filehdr)); 42static PTR alpha_ecoff_mkobject_hook 43 PARAMS ((bfd *, PTR filehdr, PTR aouthdr)); 44static void alpha_ecoff_swap_reloc_in 45 PARAMS ((bfd *, PTR, struct internal_reloc *)); 46static void alpha_ecoff_swap_reloc_out 47 PARAMS ((bfd *, const struct internal_reloc *, PTR)); 48static void alpha_adjust_reloc_in 49 PARAMS ((bfd *, const struct internal_reloc *, arelent *)); 50static void alpha_adjust_reloc_out 51 PARAMS ((bfd *, const arelent *, struct internal_reloc *)); 52static reloc_howto_type *alpha_bfd_reloc_type_lookup 53 PARAMS ((bfd *, bfd_reloc_code_real_type)); 54static bfd_byte *alpha_ecoff_get_relocated_section_contents 55 PARAMS ((bfd *abfd, struct bfd_link_info *, struct bfd_link_order *, 56 bfd_byte *data, bfd_boolean relocatable, asymbol **symbols)); 57static bfd_vma alpha_convert_external_reloc 58 PARAMS ((bfd *, struct bfd_link_info *, bfd *, struct external_reloc *, 59 struct ecoff_link_hash_entry *)); 60static bfd_boolean alpha_relocate_section 61 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, PTR)); 62static bfd_boolean alpha_adjust_headers 63 PARAMS ((bfd *, struct internal_filehdr *, struct internal_aouthdr *)); 64static PTR alpha_ecoff_read_ar_hdr 65 PARAMS ((bfd *)); 66static bfd *alpha_ecoff_get_elt_at_filepos 67 PARAMS ((bfd *, file_ptr)); 68static bfd *alpha_ecoff_openr_next_archived_file 69 PARAMS ((bfd *, bfd *)); 70static bfd *alpha_ecoff_get_elt_at_index 71 PARAMS ((bfd *, symindex)); 72 73/* ECOFF has COFF sections, but the debugging information is stored in 74 a completely different format. ECOFF targets use some of the 75 swapping routines from coffswap.h, and some of the generic COFF 76 routines in coffgen.c, but, unlike the real COFF targets, do not 77 use coffcode.h itself. 78 79 Get the generic COFF swapping routines, except for the reloc, 80 symbol, and lineno ones. Give them ecoff names. Define some 81 accessor macros for the large sizes used for Alpha ECOFF. */ 82 83#define GET_FILEHDR_SYMPTR H_GET_64 84#define PUT_FILEHDR_SYMPTR H_PUT_64 85#define GET_AOUTHDR_TSIZE H_GET_64 86#define PUT_AOUTHDR_TSIZE H_PUT_64 87#define GET_AOUTHDR_DSIZE H_GET_64 88#define PUT_AOUTHDR_DSIZE H_PUT_64 89#define GET_AOUTHDR_BSIZE H_GET_64 90#define PUT_AOUTHDR_BSIZE H_PUT_64 91#define GET_AOUTHDR_ENTRY H_GET_64 92#define PUT_AOUTHDR_ENTRY H_PUT_64 93#define GET_AOUTHDR_TEXT_START H_GET_64 94#define PUT_AOUTHDR_TEXT_START H_PUT_64 95#define GET_AOUTHDR_DATA_START H_GET_64 96#define PUT_AOUTHDR_DATA_START H_PUT_64 97#define GET_SCNHDR_PADDR H_GET_64 98#define PUT_SCNHDR_PADDR H_PUT_64 99#define GET_SCNHDR_VADDR H_GET_64 100#define PUT_SCNHDR_VADDR H_PUT_64 101#define GET_SCNHDR_SIZE H_GET_64 102#define PUT_SCNHDR_SIZE H_PUT_64 103#define GET_SCNHDR_SCNPTR H_GET_64 104#define PUT_SCNHDR_SCNPTR H_PUT_64 105#define GET_SCNHDR_RELPTR H_GET_64 106#define PUT_SCNHDR_RELPTR H_PUT_64 107#define GET_SCNHDR_LNNOPTR H_GET_64 108#define PUT_SCNHDR_LNNOPTR H_PUT_64 109 110#define ALPHAECOFF 111 112#define NO_COFF_RELOCS 113#define NO_COFF_SYMBOLS 114#define NO_COFF_LINENOS 115#define coff_swap_filehdr_in alpha_ecoff_swap_filehdr_in 116#define coff_swap_filehdr_out alpha_ecoff_swap_filehdr_out 117#define coff_swap_aouthdr_in alpha_ecoff_swap_aouthdr_in 118#define coff_swap_aouthdr_out alpha_ecoff_swap_aouthdr_out 119#define coff_swap_scnhdr_in alpha_ecoff_swap_scnhdr_in 120#define coff_swap_scnhdr_out alpha_ecoff_swap_scnhdr_out 121#include "coffswap.h" 122 123/* Get the ECOFF swapping routines. */ 124#define ECOFF_64 125#include "ecoffswap.h" 126 127/* How to process the various reloc types. */ 128 129static bfd_reloc_status_type reloc_nil 130 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 131 132static bfd_reloc_status_type 133reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message) 134 bfd *abfd ATTRIBUTE_UNUSED; 135 arelent *reloc ATTRIBUTE_UNUSED; 136 asymbol *sym ATTRIBUTE_UNUSED; 137 PTR data ATTRIBUTE_UNUSED; 138 asection *sec ATTRIBUTE_UNUSED; 139 bfd *output_bfd ATTRIBUTE_UNUSED; 140 char **error_message ATTRIBUTE_UNUSED; 141{ 142 return bfd_reloc_ok; 143} 144 145/* In case we're on a 32-bit machine, construct a 64-bit "-1" value 146 from smaller values. Start with zero, widen, *then* decrement. */ 147#define MINUS_ONE (((bfd_vma)0) - 1) 148 149static reloc_howto_type alpha_howto_table[] = 150{ 151 /* Reloc type 0 is ignored by itself. However, it appears after a 152 GPDISP reloc to identify the location where the low order 16 bits 153 of the gp register are loaded. */ 154 HOWTO (ALPHA_R_IGNORE, /* type */ 155 0, /* rightshift */ 156 0, /* size (0 = byte, 1 = short, 2 = long) */ 157 8, /* bitsize */ 158 TRUE, /* pc_relative */ 159 0, /* bitpos */ 160 complain_overflow_dont, /* complain_on_overflow */ 161 reloc_nil, /* special_function */ 162 "IGNORE", /* name */ 163 TRUE, /* partial_inplace */ 164 0, /* src_mask */ 165 0, /* dst_mask */ 166 TRUE), /* pcrel_offset */ 167 168 /* A 32 bit reference to a symbol. */ 169 HOWTO (ALPHA_R_REFLONG, /* type */ 170 0, /* rightshift */ 171 2, /* size (0 = byte, 1 = short, 2 = long) */ 172 32, /* bitsize */ 173 FALSE, /* pc_relative */ 174 0, /* bitpos */ 175 complain_overflow_bitfield, /* complain_on_overflow */ 176 0, /* special_function */ 177 "REFLONG", /* name */ 178 TRUE, /* partial_inplace */ 179 0xffffffff, /* src_mask */ 180 0xffffffff, /* dst_mask */ 181 FALSE), /* pcrel_offset */ 182 183 /* A 64 bit reference to a symbol. */ 184 HOWTO (ALPHA_R_REFQUAD, /* type */ 185 0, /* rightshift */ 186 4, /* size (0 = byte, 1 = short, 2 = long) */ 187 64, /* bitsize */ 188 FALSE, /* pc_relative */ 189 0, /* bitpos */ 190 complain_overflow_bitfield, /* complain_on_overflow */ 191 0, /* special_function */ 192 "REFQUAD", /* name */ 193 TRUE, /* partial_inplace */ 194 MINUS_ONE, /* src_mask */ 195 MINUS_ONE, /* dst_mask */ 196 FALSE), /* pcrel_offset */ 197 198 /* A 32 bit GP relative offset. This is just like REFLONG except 199 that when the value is used the value of the gp register will be 200 added in. */ 201 HOWTO (ALPHA_R_GPREL32, /* type */ 202 0, /* rightshift */ 203 2, /* size (0 = byte, 1 = short, 2 = long) */ 204 32, /* bitsize */ 205 FALSE, /* pc_relative */ 206 0, /* bitpos */ 207 complain_overflow_bitfield, /* complain_on_overflow */ 208 0, /* special_function */ 209 "GPREL32", /* name */ 210 TRUE, /* partial_inplace */ 211 0xffffffff, /* src_mask */ 212 0xffffffff, /* dst_mask */ 213 FALSE), /* pcrel_offset */ 214 215 /* Used for an instruction that refers to memory off the GP 216 register. The offset is 16 bits of the 32 bit instruction. This 217 reloc always seems to be against the .lita section. */ 218 HOWTO (ALPHA_R_LITERAL, /* type */ 219 0, /* rightshift */ 220 2, /* size (0 = byte, 1 = short, 2 = long) */ 221 16, /* bitsize */ 222 FALSE, /* pc_relative */ 223 0, /* bitpos */ 224 complain_overflow_signed, /* complain_on_overflow */ 225 0, /* special_function */ 226 "LITERAL", /* name */ 227 TRUE, /* partial_inplace */ 228 0xffff, /* src_mask */ 229 0xffff, /* dst_mask */ 230 FALSE), /* pcrel_offset */ 231 232 /* This reloc only appears immediately following a LITERAL reloc. 233 It identifies a use of the literal. It seems that the linker can 234 use this to eliminate a portion of the .lita section. The symbol 235 index is special: 1 means the literal address is in the base 236 register of a memory format instruction; 2 means the literal 237 address is in the byte offset register of a byte-manipulation 238 instruction; 3 means the literal address is in the target 239 register of a jsr instruction. This does not actually do any 240 relocation. */ 241 HOWTO (ALPHA_R_LITUSE, /* type */ 242 0, /* rightshift */ 243 2, /* size (0 = byte, 1 = short, 2 = long) */ 244 32, /* bitsize */ 245 FALSE, /* pc_relative */ 246 0, /* bitpos */ 247 complain_overflow_dont, /* complain_on_overflow */ 248 reloc_nil, /* special_function */ 249 "LITUSE", /* name */ 250 FALSE, /* partial_inplace */ 251 0, /* src_mask */ 252 0, /* dst_mask */ 253 FALSE), /* pcrel_offset */ 254 255 /* Load the gp register. This is always used for a ldah instruction 256 which loads the upper 16 bits of the gp register. The next reloc 257 will be an IGNORE reloc which identifies the location of the lda 258 instruction which loads the lower 16 bits. The symbol index of 259 the GPDISP instruction appears to actually be the number of bytes 260 between the ldah and lda instructions. This gives two different 261 ways to determine where the lda instruction is; I don't know why 262 both are used. The value to use for the relocation is the 263 difference between the GP value and the current location; the 264 load will always be done against a register holding the current 265 address. */ 266 HOWTO (ALPHA_R_GPDISP, /* type */ 267 16, /* rightshift */ 268 2, /* size (0 = byte, 1 = short, 2 = long) */ 269 16, /* bitsize */ 270 TRUE, /* pc_relative */ 271 0, /* bitpos */ 272 complain_overflow_dont, /* complain_on_overflow */ 273 reloc_nil, /* special_function */ 274 "GPDISP", /* name */ 275 TRUE, /* partial_inplace */ 276 0xffff, /* src_mask */ 277 0xffff, /* dst_mask */ 278 TRUE), /* pcrel_offset */ 279 280 /* A 21 bit branch. The native assembler generates these for 281 branches within the text segment, and also fills in the PC 282 relative offset in the instruction. */ 283 HOWTO (ALPHA_R_BRADDR, /* type */ 284 2, /* rightshift */ 285 2, /* size (0 = byte, 1 = short, 2 = long) */ 286 21, /* bitsize */ 287 TRUE, /* pc_relative */ 288 0, /* bitpos */ 289 complain_overflow_signed, /* complain_on_overflow */ 290 0, /* special_function */ 291 "BRADDR", /* name */ 292 TRUE, /* partial_inplace */ 293 0x1fffff, /* src_mask */ 294 0x1fffff, /* dst_mask */ 295 FALSE), /* pcrel_offset */ 296 297 /* A hint for a jump to a register. */ 298 HOWTO (ALPHA_R_HINT, /* type */ 299 2, /* rightshift */ 300 2, /* size (0 = byte, 1 = short, 2 = long) */ 301 14, /* bitsize */ 302 TRUE, /* pc_relative */ 303 0, /* bitpos */ 304 complain_overflow_dont, /* complain_on_overflow */ 305 0, /* special_function */ 306 "HINT", /* name */ 307 TRUE, /* partial_inplace */ 308 0x3fff, /* src_mask */ 309 0x3fff, /* dst_mask */ 310 FALSE), /* pcrel_offset */ 311 312 /* 16 bit PC relative offset. */ 313 HOWTO (ALPHA_R_SREL16, /* type */ 314 0, /* rightshift */ 315 1, /* size (0 = byte, 1 = short, 2 = long) */ 316 16, /* bitsize */ 317 TRUE, /* pc_relative */ 318 0, /* bitpos */ 319 complain_overflow_signed, /* complain_on_overflow */ 320 0, /* special_function */ 321 "SREL16", /* name */ 322 TRUE, /* partial_inplace */ 323 0xffff, /* src_mask */ 324 0xffff, /* dst_mask */ 325 FALSE), /* pcrel_offset */ 326 327 /* 32 bit PC relative offset. */ 328 HOWTO (ALPHA_R_SREL32, /* type */ 329 0, /* rightshift */ 330 2, /* size (0 = byte, 1 = short, 2 = long) */ 331 32, /* bitsize */ 332 TRUE, /* pc_relative */ 333 0, /* bitpos */ 334 complain_overflow_signed, /* complain_on_overflow */ 335 0, /* special_function */ 336 "SREL32", /* name */ 337 TRUE, /* partial_inplace */ 338 0xffffffff, /* src_mask */ 339 0xffffffff, /* dst_mask */ 340 FALSE), /* pcrel_offset */ 341 342 /* A 64 bit PC relative offset. */ 343 HOWTO (ALPHA_R_SREL64, /* type */ 344 0, /* rightshift */ 345 4, /* size (0 = byte, 1 = short, 2 = long) */ 346 64, /* bitsize */ 347 TRUE, /* pc_relative */ 348 0, /* bitpos */ 349 complain_overflow_signed, /* complain_on_overflow */ 350 0, /* special_function */ 351 "SREL64", /* name */ 352 TRUE, /* partial_inplace */ 353 MINUS_ONE, /* src_mask */ 354 MINUS_ONE, /* dst_mask */ 355 FALSE), /* pcrel_offset */ 356 357 /* Push a value on the reloc evaluation stack. */ 358 HOWTO (ALPHA_R_OP_PUSH, /* type */ 359 0, /* rightshift */ 360 0, /* size (0 = byte, 1 = short, 2 = long) */ 361 0, /* bitsize */ 362 FALSE, /* pc_relative */ 363 0, /* bitpos */ 364 complain_overflow_dont, /* complain_on_overflow */ 365 0, /* special_function */ 366 "OP_PUSH", /* name */ 367 FALSE, /* partial_inplace */ 368 0, /* src_mask */ 369 0, /* dst_mask */ 370 FALSE), /* pcrel_offset */ 371 372 /* Store the value from the stack at the given address. Store it in 373 a bitfield of size r_size starting at bit position r_offset. */ 374 HOWTO (ALPHA_R_OP_STORE, /* type */ 375 0, /* rightshift */ 376 4, /* size (0 = byte, 1 = short, 2 = long) */ 377 64, /* bitsize */ 378 FALSE, /* pc_relative */ 379 0, /* bitpos */ 380 complain_overflow_dont, /* complain_on_overflow */ 381 0, /* special_function */ 382 "OP_STORE", /* name */ 383 FALSE, /* partial_inplace */ 384 0, /* src_mask */ 385 MINUS_ONE, /* dst_mask */ 386 FALSE), /* pcrel_offset */ 387 388 /* Subtract the reloc address from the value on the top of the 389 relocation stack. */ 390 HOWTO (ALPHA_R_OP_PSUB, /* type */ 391 0, /* rightshift */ 392 0, /* size (0 = byte, 1 = short, 2 = long) */ 393 0, /* bitsize */ 394 FALSE, /* pc_relative */ 395 0, /* bitpos */ 396 complain_overflow_dont, /* complain_on_overflow */ 397 0, /* special_function */ 398 "OP_PSUB", /* name */ 399 FALSE, /* partial_inplace */ 400 0, /* src_mask */ 401 0, /* dst_mask */ 402 FALSE), /* pcrel_offset */ 403 404 /* Shift the value on the top of the relocation stack right by the 405 given value. */ 406 HOWTO (ALPHA_R_OP_PRSHIFT, /* type */ 407 0, /* rightshift */ 408 0, /* size (0 = byte, 1 = short, 2 = long) */ 409 0, /* bitsize */ 410 FALSE, /* pc_relative */ 411 0, /* bitpos */ 412 complain_overflow_dont, /* complain_on_overflow */ 413 0, /* special_function */ 414 "OP_PRSHIFT", /* name */ 415 FALSE, /* partial_inplace */ 416 0, /* src_mask */ 417 0, /* dst_mask */ 418 FALSE), /* pcrel_offset */ 419 420 /* Adjust the GP value for a new range in the object file. */ 421 HOWTO (ALPHA_R_GPVALUE, /* type */ 422 0, /* rightshift */ 423 0, /* size (0 = byte, 1 = short, 2 = long) */ 424 0, /* bitsize */ 425 FALSE, /* pc_relative */ 426 0, /* bitpos */ 427 complain_overflow_dont, /* complain_on_overflow */ 428 0, /* special_function */ 429 "GPVALUE", /* name */ 430 FALSE, /* partial_inplace */ 431 0, /* src_mask */ 432 0, /* dst_mask */ 433 FALSE) /* pcrel_offset */ 434}; 435 436/* Recognize an Alpha ECOFF file. */ 437 438static const bfd_target * 439alpha_ecoff_object_p (abfd) 440 bfd *abfd; 441{ 442 static const bfd_target *ret; 443 444 ret = coff_object_p (abfd); 445 446 if (ret != NULL) 447 { 448 asection *sec; 449 450 /* Alpha ECOFF has a .pdata section. The lnnoptr field of the 451 .pdata section is the number of entries it contains. Each 452 entry takes up 8 bytes. The number of entries is required 453 since the section is aligned to a 16 byte boundary. When we 454 link .pdata sections together, we do not want to include the 455 alignment bytes. We handle this on input by faking the size 456 of the .pdata section to remove the unwanted alignment bytes. 457 On output we will set the lnnoptr field and force the 458 alignment. */ 459 sec = bfd_get_section_by_name (abfd, _PDATA); 460 if (sec != (asection *) NULL) 461 { 462 bfd_size_type size; 463 464 size = sec->line_filepos * 8; 465 BFD_ASSERT (size == bfd_section_size (abfd, sec) 466 || size + 8 == bfd_section_size (abfd, sec)); 467 if (! bfd_set_section_size (abfd, sec, size)) 468 return NULL; 469 } 470 } 471 472 return ret; 473} 474 475/* See whether the magic number matches. */ 476 477static bfd_boolean 478alpha_ecoff_bad_format_hook (abfd, filehdr) 479 bfd *abfd ATTRIBUTE_UNUSED; 480 PTR filehdr; 481{ 482 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 483 484 if (ALPHA_ECOFF_BADMAG (*internal_f)) 485 return FALSE; 486 487 return TRUE; 488} 489 490/* This is a hook called by coff_real_object_p to create any backend 491 specific information. */ 492 493static PTR 494alpha_ecoff_mkobject_hook (abfd, filehdr, aouthdr) 495 bfd *abfd; 496 PTR filehdr; 497 PTR aouthdr; 498{ 499 PTR ecoff; 500 501 ecoff = _bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr); 502 503 if (ecoff != NULL) 504 { 505 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 506 507 /* Set additional BFD flags according to the object type from the 508 machine specific file header flags. */ 509 switch (internal_f->f_flags & F_ALPHA_OBJECT_TYPE_MASK) 510 { 511 case F_ALPHA_SHARABLE: 512 abfd->flags |= DYNAMIC; 513 break; 514 case F_ALPHA_CALL_SHARED: 515 /* Always executable if using shared libraries as the run time 516 loader might resolve undefined references. */ 517 abfd->flags |= (DYNAMIC | EXEC_P); 518 break; 519 } 520 } 521 return ecoff; 522} 523 524/* Reloc handling. */ 525 526/* Swap a reloc in. */ 527 528static void 529alpha_ecoff_swap_reloc_in (abfd, ext_ptr, intern) 530 bfd *abfd; 531 PTR ext_ptr; 532 struct internal_reloc *intern; 533{ 534 const RELOC *ext = (RELOC *) ext_ptr; 535 536 intern->r_vaddr = H_GET_64 (abfd, ext->r_vaddr); 537 intern->r_symndx = H_GET_32 (abfd, ext->r_symndx); 538 539 BFD_ASSERT (bfd_header_little_endian (abfd)); 540 541 intern->r_type = ((ext->r_bits[0] & RELOC_BITS0_TYPE_LITTLE) 542 >> RELOC_BITS0_TYPE_SH_LITTLE); 543 intern->r_extern = (ext->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0; 544 intern->r_offset = ((ext->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE) 545 >> RELOC_BITS1_OFFSET_SH_LITTLE); 546 /* Ignored the reserved bits. */ 547 intern->r_size = ((ext->r_bits[3] & RELOC_BITS3_SIZE_LITTLE) 548 >> RELOC_BITS3_SIZE_SH_LITTLE); 549 550 if (intern->r_type == ALPHA_R_LITUSE 551 || intern->r_type == ALPHA_R_GPDISP) 552 { 553 /* Handle the LITUSE and GPDISP relocs specially. Its symndx 554 value is not actually a symbol index, but is instead a 555 special code. We put the code in the r_size field, and 556 clobber the symndx. */ 557 if (intern->r_size != 0) 558 abort (); 559 intern->r_size = intern->r_symndx; 560 intern->r_symndx = RELOC_SECTION_NONE; 561 } 562 else if (intern->r_type == ALPHA_R_IGNORE) 563 { 564 /* The IGNORE reloc generally follows a GPDISP reloc, and is 565 against the .lita section. The section is irrelevant. */ 566 if (! intern->r_extern && 567 intern->r_symndx == RELOC_SECTION_ABS) 568 abort (); 569 if (! intern->r_extern && intern->r_symndx == RELOC_SECTION_LITA) 570 intern->r_symndx = RELOC_SECTION_ABS; 571 } 572} 573 574/* Swap a reloc out. */ 575 576static void 577alpha_ecoff_swap_reloc_out (abfd, intern, dst) 578 bfd *abfd; 579 const struct internal_reloc *intern; 580 PTR dst; 581{ 582 RELOC *ext = (RELOC *) dst; 583 long symndx; 584 unsigned char size; 585 586 /* Undo the hackery done in swap_reloc_in. */ 587 if (intern->r_type == ALPHA_R_LITUSE 588 || intern->r_type == ALPHA_R_GPDISP) 589 { 590 symndx = intern->r_size; 591 size = 0; 592 } 593 else if (intern->r_type == ALPHA_R_IGNORE 594 && ! intern->r_extern 595 && intern->r_symndx == RELOC_SECTION_ABS) 596 { 597 symndx = RELOC_SECTION_LITA; 598 size = intern->r_size; 599 } 600 else 601 { 602 symndx = intern->r_symndx; 603 size = intern->r_size; 604 } 605 606 BFD_ASSERT (intern->r_extern 607 || (intern->r_symndx >= 0 && intern->r_symndx <= 14)); 608 609 H_PUT_64 (abfd, intern->r_vaddr, ext->r_vaddr); 610 H_PUT_32 (abfd, symndx, ext->r_symndx); 611 612 BFD_ASSERT (bfd_header_little_endian (abfd)); 613 614 ext->r_bits[0] = ((intern->r_type << RELOC_BITS0_TYPE_SH_LITTLE) 615 & RELOC_BITS0_TYPE_LITTLE); 616 ext->r_bits[1] = ((intern->r_extern ? RELOC_BITS1_EXTERN_LITTLE : 0) 617 | ((intern->r_offset << RELOC_BITS1_OFFSET_SH_LITTLE) 618 & RELOC_BITS1_OFFSET_LITTLE)); 619 ext->r_bits[2] = 0; 620 ext->r_bits[3] = ((size << RELOC_BITS3_SIZE_SH_LITTLE) 621 & RELOC_BITS3_SIZE_LITTLE); 622} 623 624/* Finish canonicalizing a reloc. Part of this is generic to all 625 ECOFF targets, and that part is in ecoff.c. The rest is done in 626 this backend routine. It must fill in the howto field. */ 627 628static void 629alpha_adjust_reloc_in (abfd, intern, rptr) 630 bfd *abfd; 631 const struct internal_reloc *intern; 632 arelent *rptr; 633{ 634 if (intern->r_type > ALPHA_R_GPVALUE) 635 abort (); 636 637 switch (intern->r_type) 638 { 639 case ALPHA_R_BRADDR: 640 case ALPHA_R_SREL16: 641 case ALPHA_R_SREL32: 642 case ALPHA_R_SREL64: 643 /* This relocs appear to be fully resolved when they are against 644 internal symbols. Against external symbols, BRADDR at least 645 appears to be resolved against the next instruction. */ 646 if (! intern->r_extern) 647 rptr->addend = 0; 648 else 649 rptr->addend = - (intern->r_vaddr + 4); 650 break; 651 652 case ALPHA_R_GPREL32: 653 case ALPHA_R_LITERAL: 654 /* Copy the gp value for this object file into the addend, to 655 ensure that we are not confused by the linker. */ 656 if (! intern->r_extern) 657 rptr->addend += ecoff_data (abfd)->gp; 658 break; 659 660 case ALPHA_R_LITUSE: 661 case ALPHA_R_GPDISP: 662 /* The LITUSE and GPDISP relocs do not use a symbol, or an 663 addend, but they do use a special code. Put this code in the 664 addend field. */ 665 rptr->addend = intern->r_size; 666 break; 667 668 case ALPHA_R_OP_STORE: 669 /* The STORE reloc needs the size and offset fields. We store 670 them in the addend. */ 671 BFD_ASSERT (intern->r_offset <= 256 && intern->r_size <= 256); 672 rptr->addend = (intern->r_offset << 8) + intern->r_size; 673 break; 674 675 case ALPHA_R_OP_PUSH: 676 case ALPHA_R_OP_PSUB: 677 case ALPHA_R_OP_PRSHIFT: 678 /* The PUSH, PSUB and PRSHIFT relocs do not actually use an 679 address. I believe that the address supplied is really an 680 addend. */ 681 rptr->addend = intern->r_vaddr; 682 break; 683 684 case ALPHA_R_GPVALUE: 685 /* Set the addend field to the new GP value. */ 686 rptr->addend = intern->r_symndx + ecoff_data (abfd)->gp; 687 break; 688 689 case ALPHA_R_IGNORE: 690 /* If the type is ALPHA_R_IGNORE, make sure this is a reference 691 to the absolute section so that the reloc is ignored. For 692 some reason the address of this reloc type is not adjusted by 693 the section vma. We record the gp value for this object file 694 here, for convenience when doing the GPDISP relocation. */ 695 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 696 rptr->address = intern->r_vaddr; 697 rptr->addend = ecoff_data (abfd)->gp; 698 break; 699 700 default: 701 break; 702 } 703 704 rptr->howto = &alpha_howto_table[intern->r_type]; 705} 706 707/* When writing out a reloc we need to pull some values back out of 708 the addend field into the reloc. This is roughly the reverse of 709 alpha_adjust_reloc_in, except that there are several changes we do 710 not need to undo. */ 711 712static void 713alpha_adjust_reloc_out (abfd, rel, intern) 714 bfd *abfd ATTRIBUTE_UNUSED; 715 const arelent *rel; 716 struct internal_reloc *intern; 717{ 718 switch (intern->r_type) 719 { 720 case ALPHA_R_LITUSE: 721 case ALPHA_R_GPDISP: 722 intern->r_size = rel->addend; 723 break; 724 725 case ALPHA_R_OP_STORE: 726 intern->r_size = rel->addend & 0xff; 727 intern->r_offset = (rel->addend >> 8) & 0xff; 728 break; 729 730 case ALPHA_R_OP_PUSH: 731 case ALPHA_R_OP_PSUB: 732 case ALPHA_R_OP_PRSHIFT: 733 intern->r_vaddr = rel->addend; 734 break; 735 736 case ALPHA_R_IGNORE: 737 intern->r_vaddr = rel->address; 738 break; 739 740 default: 741 break; 742 } 743} 744 745/* The size of the stack for the relocation evaluator. */ 746#define RELOC_STACKSIZE (10) 747 748/* Alpha ECOFF relocs have a built in expression evaluator as well as 749 other interdependencies. Rather than use a bunch of special 750 functions and global variables, we use a single routine to do all 751 the relocation for a section. I haven't yet worked out how the 752 assembler is going to handle this. */ 753 754static bfd_byte * 755alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order, 756 data, relocatable, symbols) 757 bfd *abfd; 758 struct bfd_link_info *link_info; 759 struct bfd_link_order *link_order; 760 bfd_byte *data; 761 bfd_boolean relocatable; 762 asymbol **symbols; 763{ 764 bfd *input_bfd = link_order->u.indirect.section->owner; 765 asection *input_section = link_order->u.indirect.section; 766 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section); 767 arelent **reloc_vector = NULL; 768 long reloc_count; 769 bfd *output_bfd = relocatable ? abfd : (bfd *) NULL; 770 bfd_vma gp; 771 bfd_boolean gp_undefined; 772 bfd_vma stack[RELOC_STACKSIZE]; 773 int tos = 0; 774 775 if (reloc_size < 0) 776 goto error_return; 777 reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size); 778 if (reloc_vector == NULL && reloc_size != 0) 779 goto error_return; 780 781 if (! bfd_get_section_contents (input_bfd, input_section, data, 782 (file_ptr) 0, input_section->_raw_size)) 783 goto error_return; 784 785 /* The section size is not going to change. */ 786 input_section->_cooked_size = input_section->_raw_size; 787 input_section->reloc_done = TRUE; 788 789 reloc_count = bfd_canonicalize_reloc (input_bfd, input_section, 790 reloc_vector, symbols); 791 if (reloc_count < 0) 792 goto error_return; 793 if (reloc_count == 0) 794 goto successful_return; 795 796 /* Get the GP value for the output BFD. */ 797 gp_undefined = FALSE; 798 gp = _bfd_get_gp_value (abfd); 799 if (gp == 0) 800 { 801 if (relocatable) 802 { 803 asection *sec; 804 bfd_vma lo; 805 806 /* Make up a value. */ 807 lo = (bfd_vma) -1; 808 for (sec = abfd->sections; sec != NULL; sec = sec->next) 809 { 810 if (sec->vma < lo 811 && (strcmp (sec->name, ".sbss") == 0 812 || strcmp (sec->name, ".sdata") == 0 813 || strcmp (sec->name, ".lit4") == 0 814 || strcmp (sec->name, ".lit8") == 0 815 || strcmp (sec->name, ".lita") == 0)) 816 lo = sec->vma; 817 } 818 gp = lo + 0x8000; 819 _bfd_set_gp_value (abfd, gp); 820 } 821 else 822 { 823 struct bfd_link_hash_entry *h; 824 825 h = bfd_link_hash_lookup (link_info->hash, "_gp", FALSE, FALSE, 826 TRUE); 827 if (h == (struct bfd_link_hash_entry *) NULL 828 || h->type != bfd_link_hash_defined) 829 gp_undefined = TRUE; 830 else 831 { 832 gp = (h->u.def.value 833 + h->u.def.section->output_section->vma 834 + h->u.def.section->output_offset); 835 _bfd_set_gp_value (abfd, gp); 836 } 837 } 838 } 839 840 for (; *reloc_vector != (arelent *) NULL; reloc_vector++) 841 { 842 arelent *rel; 843 bfd_reloc_status_type r; 844 char *err; 845 846 rel = *reloc_vector; 847 r = bfd_reloc_ok; 848 switch (rel->howto->type) 849 { 850 case ALPHA_R_IGNORE: 851 rel->address += input_section->output_offset; 852 break; 853 854 case ALPHA_R_REFLONG: 855 case ALPHA_R_REFQUAD: 856 case ALPHA_R_BRADDR: 857 case ALPHA_R_HINT: 858 case ALPHA_R_SREL16: 859 case ALPHA_R_SREL32: 860 case ALPHA_R_SREL64: 861 if (relocatable 862 && ((*rel->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0) 863 { 864 rel->address += input_section->output_offset; 865 break; 866 } 867 r = bfd_perform_relocation (input_bfd, rel, data, input_section, 868 output_bfd, &err); 869 break; 870 871 case ALPHA_R_GPREL32: 872 /* This relocation is used in a switch table. It is a 32 873 bit offset from the current GP value. We must adjust it 874 by the different between the original GP value and the 875 current GP value. The original GP value is stored in the 876 addend. We adjust the addend and let 877 bfd_perform_relocation finish the job. */ 878 rel->addend -= gp; 879 r = bfd_perform_relocation (input_bfd, rel, data, input_section, 880 output_bfd, &err); 881 if (r == bfd_reloc_ok && gp_undefined) 882 { 883 r = bfd_reloc_dangerous; 884 err = (char *) _("GP relative relocation used when GP not defined"); 885 } 886 break; 887 888 case ALPHA_R_LITERAL: 889 /* This is a reference to a literal value, generally 890 (always?) in the .lita section. This is a 16 bit GP 891 relative relocation. Sometimes the subsequent reloc is a 892 LITUSE reloc, which indicates how this reloc is used. 893 This sometimes permits rewriting the two instructions 894 referred to by the LITERAL and the LITUSE into different 895 instructions which do not refer to .lita. This can save 896 a memory reference, and permits removing a value from 897 .lita thus saving GP relative space. 898 899 We do not these optimizations. To do them we would need 900 to arrange to link the .lita section first, so that by 901 the time we got here we would know the final values to 902 use. This would not be particularly difficult, but it is 903 not currently implemented. */ 904 905 { 906 unsigned long insn; 907 908 /* I believe that the LITERAL reloc will only apply to a 909 ldq or ldl instruction, so check my assumption. */ 910 insn = bfd_get_32 (input_bfd, data + rel->address); 911 BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29 912 || ((insn >> 26) & 0x3f) == 0x28); 913 914 rel->addend -= gp; 915 r = bfd_perform_relocation (input_bfd, rel, data, input_section, 916 output_bfd, &err); 917 if (r == bfd_reloc_ok && gp_undefined) 918 { 919 r = bfd_reloc_dangerous; 920 err = 921 (char *) _("GP relative relocation used when GP not defined"); 922 } 923 } 924 break; 925 926 case ALPHA_R_LITUSE: 927 /* See ALPHA_R_LITERAL above for the uses of this reloc. It 928 does not cause anything to happen, itself. */ 929 rel->address += input_section->output_offset; 930 break; 931 932 case ALPHA_R_GPDISP: 933 /* This marks the ldah of an ldah/lda pair which loads the 934 gp register with the difference of the gp value and the 935 current location. The second of the pair is r_size bytes 936 ahead; it used to be marked with an ALPHA_R_IGNORE reloc, 937 but that no longer happens in OSF/1 3.2. */ 938 { 939 unsigned long insn1, insn2; 940 bfd_vma addend; 941 942 /* Get the two instructions. */ 943 insn1 = bfd_get_32 (input_bfd, data + rel->address); 944 insn2 = bfd_get_32 (input_bfd, data + rel->address + rel->addend); 945 946 BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */ 947 BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */ 948 949 /* Get the existing addend. We must account for the sign 950 extension done by lda and ldah. */ 951 addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff); 952 if (insn1 & 0x8000) 953 { 954 addend -= 0x80000000; 955 addend -= 0x80000000; 956 } 957 if (insn2 & 0x8000) 958 addend -= 0x10000; 959 960 /* The existing addend includes the different between the 961 gp of the input BFD and the address in the input BFD. 962 Subtract this out. */ 963 addend -= (ecoff_data (input_bfd)->gp 964 - (input_section->vma + rel->address)); 965 966 /* Now add in the final gp value, and subtract out the 967 final address. */ 968 addend += (gp 969 - (input_section->output_section->vma 970 + input_section->output_offset 971 + rel->address)); 972 973 /* Change the instructions, accounting for the sign 974 extension, and write them out. */ 975 if (addend & 0x8000) 976 addend += 0x10000; 977 insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff); 978 insn2 = (insn2 & 0xffff0000) | (addend & 0xffff); 979 980 bfd_put_32 (input_bfd, (bfd_vma) insn1, data + rel->address); 981 bfd_put_32 (input_bfd, (bfd_vma) insn2, 982 data + rel->address + rel->addend); 983 984 rel->address += input_section->output_offset; 985 } 986 break; 987 988 case ALPHA_R_OP_PUSH: 989 /* Push a value on the reloc evaluation stack. */ 990 { 991 asymbol *symbol; 992 bfd_vma relocation; 993 994 if (relocatable) 995 { 996 rel->address += input_section->output_offset; 997 break; 998 } 999 1000 /* Figure out the relocation of this symbol. */ 1001 symbol = *rel->sym_ptr_ptr; 1002 1003 if (bfd_is_und_section (symbol->section)) 1004 r = bfd_reloc_undefined; 1005 1006 if (bfd_is_com_section (symbol->section)) 1007 relocation = 0; 1008 else 1009 relocation = symbol->value; 1010 relocation += symbol->section->output_section->vma; 1011 relocation += symbol->section->output_offset; 1012 relocation += rel->addend; 1013 1014 if (tos >= RELOC_STACKSIZE) 1015 abort (); 1016 1017 stack[tos++] = relocation; 1018 } 1019 break; 1020 1021 case ALPHA_R_OP_STORE: 1022 /* Store a value from the reloc stack into a bitfield. */ 1023 { 1024 bfd_vma val; 1025 int offset, size; 1026 1027 if (relocatable) 1028 { 1029 rel->address += input_section->output_offset; 1030 break; 1031 } 1032 1033 if (tos == 0) 1034 abort (); 1035 1036 /* The offset and size for this reloc are encoded into the 1037 addend field by alpha_adjust_reloc_in. */ 1038 offset = (rel->addend >> 8) & 0xff; 1039 size = rel->addend & 0xff; 1040 1041 val = bfd_get_64 (abfd, data + rel->address); 1042 val &=~ (((1 << size) - 1) << offset); 1043 val |= (stack[--tos] & ((1 << size) - 1)) << offset; 1044 bfd_put_64 (abfd, val, data + rel->address); 1045 } 1046 break; 1047 1048 case ALPHA_R_OP_PSUB: 1049 /* Subtract a value from the top of the stack. */ 1050 { 1051 asymbol *symbol; 1052 bfd_vma relocation; 1053 1054 if (relocatable) 1055 { 1056 rel->address += input_section->output_offset; 1057 break; 1058 } 1059 1060 /* Figure out the relocation of this symbol. */ 1061 symbol = *rel->sym_ptr_ptr; 1062 1063 if (bfd_is_und_section (symbol->section)) 1064 r = bfd_reloc_undefined; 1065 1066 if (bfd_is_com_section (symbol->section)) 1067 relocation = 0; 1068 else 1069 relocation = symbol->value; 1070 relocation += symbol->section->output_section->vma; 1071 relocation += symbol->section->output_offset; 1072 relocation += rel->addend; 1073 1074 if (tos == 0) 1075 abort (); 1076 1077 stack[tos - 1] -= relocation; 1078 } 1079 break; 1080 1081 case ALPHA_R_OP_PRSHIFT: 1082 /* Shift the value on the top of the stack. */ 1083 { 1084 asymbol *symbol; 1085 bfd_vma relocation; 1086 1087 if (relocatable) 1088 { 1089 rel->address += input_section->output_offset; 1090 break; 1091 } 1092 1093 /* Figure out the relocation of this symbol. */ 1094 symbol = *rel->sym_ptr_ptr; 1095 1096 if (bfd_is_und_section (symbol->section)) 1097 r = bfd_reloc_undefined; 1098 1099 if (bfd_is_com_section (symbol->section)) 1100 relocation = 0; 1101 else 1102 relocation = symbol->value; 1103 relocation += symbol->section->output_section->vma; 1104 relocation += symbol->section->output_offset; 1105 relocation += rel->addend; 1106 1107 if (tos == 0) 1108 abort (); 1109 1110 stack[tos - 1] >>= relocation; 1111 } 1112 break; 1113 1114 case ALPHA_R_GPVALUE: 1115 /* I really don't know if this does the right thing. */ 1116 gp = rel->addend; 1117 gp_undefined = FALSE; 1118 break; 1119 1120 default: 1121 abort (); 1122 } 1123 1124 if (relocatable) 1125 { 1126 asection *os = input_section->output_section; 1127 1128 /* A partial link, so keep the relocs. */ 1129 os->orelocation[os->reloc_count] = rel; 1130 os->reloc_count++; 1131 } 1132 1133 if (r != bfd_reloc_ok) 1134 { 1135 switch (r) 1136 { 1137 case bfd_reloc_undefined: 1138 if (! ((*link_info->callbacks->undefined_symbol) 1139 (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr), 1140 input_bfd, input_section, rel->address, TRUE))) 1141 goto error_return; 1142 break; 1143 case bfd_reloc_dangerous: 1144 if (! ((*link_info->callbacks->reloc_dangerous) 1145 (link_info, err, input_bfd, input_section, 1146 rel->address))) 1147 goto error_return; 1148 break; 1149 case bfd_reloc_overflow: 1150 if (! ((*link_info->callbacks->reloc_overflow) 1151 (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr), 1152 rel->howto->name, rel->addend, input_bfd, 1153 input_section, rel->address))) 1154 goto error_return; 1155 break; 1156 case bfd_reloc_outofrange: 1157 default: 1158 abort (); 1159 break; 1160 } 1161 } 1162 } 1163 1164 if (tos != 0) 1165 abort (); 1166 1167 successful_return: 1168 if (reloc_vector != NULL) 1169 free (reloc_vector); 1170 return data; 1171 1172 error_return: 1173 if (reloc_vector != NULL) 1174 free (reloc_vector); 1175 return NULL; 1176} 1177 1178/* Get the howto structure for a generic reloc type. */ 1179 1180static reloc_howto_type * 1181alpha_bfd_reloc_type_lookup (abfd, code) 1182 bfd *abfd ATTRIBUTE_UNUSED; 1183 bfd_reloc_code_real_type code; 1184{ 1185 int alpha_type; 1186 1187 switch (code) 1188 { 1189 case BFD_RELOC_32: 1190 alpha_type = ALPHA_R_REFLONG; 1191 break; 1192 case BFD_RELOC_64: 1193 case BFD_RELOC_CTOR: 1194 alpha_type = ALPHA_R_REFQUAD; 1195 break; 1196 case BFD_RELOC_GPREL32: 1197 alpha_type = ALPHA_R_GPREL32; 1198 break; 1199 case BFD_RELOC_ALPHA_LITERAL: 1200 alpha_type = ALPHA_R_LITERAL; 1201 break; 1202 case BFD_RELOC_ALPHA_LITUSE: 1203 alpha_type = ALPHA_R_LITUSE; 1204 break; 1205 case BFD_RELOC_ALPHA_GPDISP_HI16: 1206 alpha_type = ALPHA_R_GPDISP; 1207 break; 1208 case BFD_RELOC_ALPHA_GPDISP_LO16: 1209 alpha_type = ALPHA_R_IGNORE; 1210 break; 1211 case BFD_RELOC_23_PCREL_S2: 1212 alpha_type = ALPHA_R_BRADDR; 1213 break; 1214 case BFD_RELOC_ALPHA_HINT: 1215 alpha_type = ALPHA_R_HINT; 1216 break; 1217 case BFD_RELOC_16_PCREL: 1218 alpha_type = ALPHA_R_SREL16; 1219 break; 1220 case BFD_RELOC_32_PCREL: 1221 alpha_type = ALPHA_R_SREL32; 1222 break; 1223 case BFD_RELOC_64_PCREL: 1224 alpha_type = ALPHA_R_SREL64; 1225 break; 1226#if 0 1227 case ???: 1228 alpha_type = ALPHA_R_OP_PUSH; 1229 break; 1230 case ???: 1231 alpha_type = ALPHA_R_OP_STORE; 1232 break; 1233 case ???: 1234 alpha_type = ALPHA_R_OP_PSUB; 1235 break; 1236 case ???: 1237 alpha_type = ALPHA_R_OP_PRSHIFT; 1238 break; 1239 case ???: 1240 alpha_type = ALPHA_R_GPVALUE; 1241 break; 1242#endif 1243 default: 1244 return (reloc_howto_type *) NULL; 1245 } 1246 1247 return &alpha_howto_table[alpha_type]; 1248} 1249 1250/* A helper routine for alpha_relocate_section which converts an 1251 external reloc when generating relocatable output. Returns the 1252 relocation amount. */ 1253 1254static bfd_vma 1255alpha_convert_external_reloc (output_bfd, info, input_bfd, ext_rel, h) 1256 bfd *output_bfd ATTRIBUTE_UNUSED; 1257 struct bfd_link_info *info; 1258 bfd *input_bfd; 1259 struct external_reloc *ext_rel; 1260 struct ecoff_link_hash_entry *h; 1261{ 1262 unsigned long r_symndx; 1263 bfd_vma relocation; 1264 1265 BFD_ASSERT (info->relocatable); 1266 1267 if (h->root.type == bfd_link_hash_defined 1268 || h->root.type == bfd_link_hash_defweak) 1269 { 1270 asection *hsec; 1271 const char *name; 1272 1273 /* This symbol is defined in the output. Convert the reloc from 1274 being against the symbol to being against the section. */ 1275 1276 /* Clear the r_extern bit. */ 1277 ext_rel->r_bits[1] &=~ RELOC_BITS1_EXTERN_LITTLE; 1278 1279 /* Compute a new r_symndx value. */ 1280 hsec = h->root.u.def.section; 1281 name = bfd_get_section_name (output_bfd, hsec->output_section); 1282 1283 r_symndx = (unsigned long) -1; 1284 switch (name[1]) 1285 { 1286 case 'A': 1287 if (strcmp (name, "*ABS*") == 0) 1288 r_symndx = RELOC_SECTION_ABS; 1289 break; 1290 case 'b': 1291 if (strcmp (name, ".bss") == 0) 1292 r_symndx = RELOC_SECTION_BSS; 1293 break; 1294 case 'd': 1295 if (strcmp (name, ".data") == 0) 1296 r_symndx = RELOC_SECTION_DATA; 1297 break; 1298 case 'f': 1299 if (strcmp (name, ".fini") == 0) 1300 r_symndx = RELOC_SECTION_FINI; 1301 break; 1302 case 'i': 1303 if (strcmp (name, ".init") == 0) 1304 r_symndx = RELOC_SECTION_INIT; 1305 break; 1306 case 'l': 1307 if (strcmp (name, ".lita") == 0) 1308 r_symndx = RELOC_SECTION_LITA; 1309 else if (strcmp (name, ".lit8") == 0) 1310 r_symndx = RELOC_SECTION_LIT8; 1311 else if (strcmp (name, ".lit4") == 0) 1312 r_symndx = RELOC_SECTION_LIT4; 1313 break; 1314 case 'p': 1315 if (strcmp (name, ".pdata") == 0) 1316 r_symndx = RELOC_SECTION_PDATA; 1317 break; 1318 case 'r': 1319 if (strcmp (name, ".rdata") == 0) 1320 r_symndx = RELOC_SECTION_RDATA; 1321 else if (strcmp (name, ".rconst") == 0) 1322 r_symndx = RELOC_SECTION_RCONST; 1323 break; 1324 case 's': 1325 if (strcmp (name, ".sdata") == 0) 1326 r_symndx = RELOC_SECTION_SDATA; 1327 else if (strcmp (name, ".sbss") == 0) 1328 r_symndx = RELOC_SECTION_SBSS; 1329 break; 1330 case 't': 1331 if (strcmp (name, ".text") == 0) 1332 r_symndx = RELOC_SECTION_TEXT; 1333 break; 1334 case 'x': 1335 if (strcmp (name, ".xdata") == 0) 1336 r_symndx = RELOC_SECTION_XDATA; 1337 break; 1338 } 1339 1340 if (r_symndx == (unsigned long) -1) 1341 abort (); 1342 1343 /* Add the section VMA and the symbol value. */ 1344 relocation = (h->root.u.def.value 1345 + hsec->output_section->vma 1346 + hsec->output_offset); 1347 } 1348 else 1349 { 1350 /* Change the symndx value to the right one for 1351 the output BFD. */ 1352 r_symndx = h->indx; 1353 if (r_symndx == (unsigned long) -1) 1354 { 1355 /* Caller must give an error. */ 1356 r_symndx = 0; 1357 } 1358 relocation = 0; 1359 } 1360 1361 /* Write out the new r_symndx value. */ 1362 H_PUT_32 (input_bfd, r_symndx, ext_rel->r_symndx); 1363 1364 return relocation; 1365} 1366 1367/* Relocate a section while linking an Alpha ECOFF file. This is 1368 quite similar to get_relocated_section_contents. Perhaps they 1369 could be combined somehow. */ 1370 1371static bfd_boolean 1372alpha_relocate_section (output_bfd, info, input_bfd, input_section, 1373 contents, external_relocs) 1374 bfd *output_bfd; 1375 struct bfd_link_info *info; 1376 bfd *input_bfd; 1377 asection *input_section; 1378 bfd_byte *contents; 1379 PTR external_relocs; 1380{ 1381 asection **symndx_to_section, *lita_sec; 1382 struct ecoff_link_hash_entry **sym_hashes; 1383 bfd_vma gp; 1384 bfd_boolean gp_undefined; 1385 bfd_vma stack[RELOC_STACKSIZE]; 1386 int tos = 0; 1387 struct external_reloc *ext_rel; 1388 struct external_reloc *ext_rel_end; 1389 bfd_size_type amt; 1390 1391 /* We keep a table mapping the symndx found in an internal reloc to 1392 the appropriate section. This is faster than looking up the 1393 section by name each time. */ 1394 symndx_to_section = ecoff_data (input_bfd)->symndx_to_section; 1395 if (symndx_to_section == (asection **) NULL) 1396 { 1397 amt = NUM_RELOC_SECTIONS * sizeof (asection *); 1398 symndx_to_section = (asection **) bfd_alloc (input_bfd, amt); 1399 if (!symndx_to_section) 1400 return FALSE; 1401 1402 symndx_to_section[RELOC_SECTION_NONE] = NULL; 1403 symndx_to_section[RELOC_SECTION_TEXT] = 1404 bfd_get_section_by_name (input_bfd, ".text"); 1405 symndx_to_section[RELOC_SECTION_RDATA] = 1406 bfd_get_section_by_name (input_bfd, ".rdata"); 1407 symndx_to_section[RELOC_SECTION_DATA] = 1408 bfd_get_section_by_name (input_bfd, ".data"); 1409 symndx_to_section[RELOC_SECTION_SDATA] = 1410 bfd_get_section_by_name (input_bfd, ".sdata"); 1411 symndx_to_section[RELOC_SECTION_SBSS] = 1412 bfd_get_section_by_name (input_bfd, ".sbss"); 1413 symndx_to_section[RELOC_SECTION_BSS] = 1414 bfd_get_section_by_name (input_bfd, ".bss"); 1415 symndx_to_section[RELOC_SECTION_INIT] = 1416 bfd_get_section_by_name (input_bfd, ".init"); 1417 symndx_to_section[RELOC_SECTION_LIT8] = 1418 bfd_get_section_by_name (input_bfd, ".lit8"); 1419 symndx_to_section[RELOC_SECTION_LIT4] = 1420 bfd_get_section_by_name (input_bfd, ".lit4"); 1421 symndx_to_section[RELOC_SECTION_XDATA] = 1422 bfd_get_section_by_name (input_bfd, ".xdata"); 1423 symndx_to_section[RELOC_SECTION_PDATA] = 1424 bfd_get_section_by_name (input_bfd, ".pdata"); 1425 symndx_to_section[RELOC_SECTION_FINI] = 1426 bfd_get_section_by_name (input_bfd, ".fini"); 1427 symndx_to_section[RELOC_SECTION_LITA] = 1428 bfd_get_section_by_name (input_bfd, ".lita"); 1429 symndx_to_section[RELOC_SECTION_ABS] = bfd_abs_section_ptr; 1430 symndx_to_section[RELOC_SECTION_RCONST] = 1431 bfd_get_section_by_name (input_bfd, ".rconst"); 1432 1433 ecoff_data (input_bfd)->symndx_to_section = symndx_to_section; 1434 } 1435 1436 sym_hashes = ecoff_data (input_bfd)->sym_hashes; 1437 1438 /* On the Alpha, the .lita section must be addressable by the global 1439 pointer. To support large programs, we need to allow multiple 1440 global pointers. This works as long as each input .lita section 1441 is <64KB big. This implies that when producing relocatable 1442 output, the .lita section is limited to 64KB. . */ 1443 1444 lita_sec = symndx_to_section[RELOC_SECTION_LITA]; 1445 gp = _bfd_get_gp_value (output_bfd); 1446 if (! info->relocatable && lita_sec != NULL) 1447 { 1448 struct ecoff_section_tdata *lita_sec_data; 1449 1450 /* Make sure we have a section data structure to which we can 1451 hang on to the gp value we pick for the section. */ 1452 lita_sec_data = ecoff_section_data (input_bfd, lita_sec); 1453 if (lita_sec_data == NULL) 1454 { 1455 amt = sizeof (struct ecoff_section_tdata); 1456 lita_sec_data = ((struct ecoff_section_tdata *) 1457 bfd_zalloc (input_bfd, amt)); 1458 ecoff_section_data (input_bfd, lita_sec) = lita_sec_data; 1459 } 1460 1461 if (lita_sec_data->gp != 0) 1462 { 1463 /* If we already assigned a gp to this section, we better 1464 stick with that value. */ 1465 gp = lita_sec_data->gp; 1466 } 1467 else 1468 { 1469 bfd_vma lita_vma; 1470 bfd_size_type lita_size; 1471 1472 lita_vma = lita_sec->output_offset + lita_sec->output_section->vma; 1473 lita_size = lita_sec->_cooked_size; 1474 if (lita_size == 0) 1475 lita_size = lita_sec->_raw_size; 1476 1477 if (gp == 0 1478 || lita_vma < gp - 0x8000 1479 || lita_vma + lita_size >= gp + 0x8000) 1480 { 1481 /* Either gp hasn't been set at all or the current gp 1482 cannot address this .lita section. In both cases we 1483 reset the gp to point into the "middle" of the 1484 current input .lita section. */ 1485 if (gp && !ecoff_data (output_bfd)->issued_multiple_gp_warning) 1486 { 1487 (*info->callbacks->warning) (info, 1488 _("using multiple gp values"), 1489 (char *) NULL, output_bfd, 1490 (asection *) NULL, (bfd_vma) 0); 1491 ecoff_data (output_bfd)->issued_multiple_gp_warning = TRUE; 1492 } 1493 if (lita_vma < gp - 0x8000) 1494 gp = lita_vma + lita_size - 0x8000; 1495 else 1496 gp = lita_vma + 0x8000; 1497 1498 } 1499 1500 lita_sec_data->gp = gp; 1501 } 1502 1503 _bfd_set_gp_value (output_bfd, gp); 1504 } 1505 1506 gp_undefined = (gp == 0); 1507 1508 BFD_ASSERT (bfd_header_little_endian (output_bfd)); 1509 BFD_ASSERT (bfd_header_little_endian (input_bfd)); 1510 1511 ext_rel = (struct external_reloc *) external_relocs; 1512 ext_rel_end = ext_rel + input_section->reloc_count; 1513 for (; ext_rel < ext_rel_end; ext_rel++) 1514 { 1515 bfd_vma r_vaddr; 1516 unsigned long r_symndx; 1517 int r_type; 1518 int r_extern; 1519 int r_offset; 1520 int r_size; 1521 bfd_boolean relocatep; 1522 bfd_boolean adjust_addrp; 1523 bfd_boolean gp_usedp; 1524 bfd_vma addend; 1525 1526 r_vaddr = H_GET_64 (input_bfd, ext_rel->r_vaddr); 1527 r_symndx = H_GET_32 (input_bfd, ext_rel->r_symndx); 1528 1529 r_type = ((ext_rel->r_bits[0] & RELOC_BITS0_TYPE_LITTLE) 1530 >> RELOC_BITS0_TYPE_SH_LITTLE); 1531 r_extern = (ext_rel->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0; 1532 r_offset = ((ext_rel->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE) 1533 >> RELOC_BITS1_OFFSET_SH_LITTLE); 1534 /* Ignored the reserved bits. */ 1535 r_size = ((ext_rel->r_bits[3] & RELOC_BITS3_SIZE_LITTLE) 1536 >> RELOC_BITS3_SIZE_SH_LITTLE); 1537 1538 relocatep = FALSE; 1539 adjust_addrp = TRUE; 1540 gp_usedp = FALSE; 1541 addend = 0; 1542 1543 switch (r_type) 1544 { 1545 default: 1546 abort (); 1547 1548 case ALPHA_R_IGNORE: 1549 /* This reloc appears after a GPDISP reloc. On earlier 1550 versions of OSF/1, It marked the position of the second 1551 instruction to be altered by the GPDISP reloc, but it is 1552 not otherwise used for anything. For some reason, the 1553 address of the relocation does not appear to include the 1554 section VMA, unlike the other relocation types. */ 1555 if (info->relocatable) 1556 H_PUT_64 (input_bfd, input_section->output_offset + r_vaddr, 1557 ext_rel->r_vaddr); 1558 adjust_addrp = FALSE; 1559 break; 1560 1561 case ALPHA_R_REFLONG: 1562 case ALPHA_R_REFQUAD: 1563 case ALPHA_R_HINT: 1564 relocatep = TRUE; 1565 break; 1566 1567 case ALPHA_R_BRADDR: 1568 case ALPHA_R_SREL16: 1569 case ALPHA_R_SREL32: 1570 case ALPHA_R_SREL64: 1571 if (r_extern) 1572 addend += - (r_vaddr + 4); 1573 relocatep = TRUE; 1574 break; 1575 1576 case ALPHA_R_GPREL32: 1577 /* This relocation is used in a switch table. It is a 32 1578 bit offset from the current GP value. We must adjust it 1579 by the different between the original GP value and the 1580 current GP value. */ 1581 relocatep = TRUE; 1582 addend = ecoff_data (input_bfd)->gp - gp; 1583 gp_usedp = TRUE; 1584 break; 1585 1586 case ALPHA_R_LITERAL: 1587 /* This is a reference to a literal value, generally 1588 (always?) in the .lita section. This is a 16 bit GP 1589 relative relocation. Sometimes the subsequent reloc is a 1590 LITUSE reloc, which indicates how this reloc is used. 1591 This sometimes permits rewriting the two instructions 1592 referred to by the LITERAL and the LITUSE into different 1593 instructions which do not refer to .lita. This can save 1594 a memory reference, and permits removing a value from 1595 .lita thus saving GP relative space. 1596 1597 We do not these optimizations. To do them we would need 1598 to arrange to link the .lita section first, so that by 1599 the time we got here we would know the final values to 1600 use. This would not be particularly difficult, but it is 1601 not currently implemented. */ 1602 1603 /* I believe that the LITERAL reloc will only apply to a ldq 1604 or ldl instruction, so check my assumption. */ 1605 { 1606 unsigned long insn; 1607 1608 insn = bfd_get_32 (input_bfd, 1609 contents + r_vaddr - input_section->vma); 1610 BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29 1611 || ((insn >> 26) & 0x3f) == 0x28); 1612 } 1613 1614 relocatep = TRUE; 1615 addend = ecoff_data (input_bfd)->gp - gp; 1616 gp_usedp = TRUE; 1617 break; 1618 1619 case ALPHA_R_LITUSE: 1620 /* See ALPHA_R_LITERAL above for the uses of this reloc. It 1621 does not cause anything to happen, itself. */ 1622 break; 1623 1624 case ALPHA_R_GPDISP: 1625 /* This marks the ldah of an ldah/lda pair which loads the 1626 gp register with the difference of the gp value and the 1627 current location. The second of the pair is r_symndx 1628 bytes ahead. It used to be marked with an ALPHA_R_IGNORE 1629 reloc, but OSF/1 3.2 no longer does that. */ 1630 { 1631 unsigned long insn1, insn2; 1632 1633 /* Get the two instructions. */ 1634 insn1 = bfd_get_32 (input_bfd, 1635 contents + r_vaddr - input_section->vma); 1636 insn2 = bfd_get_32 (input_bfd, 1637 (contents 1638 + r_vaddr 1639 - input_section->vma 1640 + r_symndx)); 1641 1642 BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */ 1643 BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */ 1644 1645 /* Get the existing addend. We must account for the sign 1646 extension done by lda and ldah. */ 1647 addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff); 1648 if (insn1 & 0x8000) 1649 { 1650 /* This is addend -= 0x100000000 without causing an 1651 integer overflow on a 32 bit host. */ 1652 addend -= 0x80000000; 1653 addend -= 0x80000000; 1654 } 1655 if (insn2 & 0x8000) 1656 addend -= 0x10000; 1657 1658 /* The existing addend includes the difference between the 1659 gp of the input BFD and the address in the input BFD. 1660 We want to change this to the difference between the 1661 final GP and the final address. */ 1662 addend += (gp 1663 - ecoff_data (input_bfd)->gp 1664 + input_section->vma 1665 - (input_section->output_section->vma 1666 + input_section->output_offset)); 1667 1668 /* Change the instructions, accounting for the sign 1669 extension, and write them out. */ 1670 if (addend & 0x8000) 1671 addend += 0x10000; 1672 insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff); 1673 insn2 = (insn2 & 0xffff0000) | (addend & 0xffff); 1674 1675 bfd_put_32 (input_bfd, (bfd_vma) insn1, 1676 contents + r_vaddr - input_section->vma); 1677 bfd_put_32 (input_bfd, (bfd_vma) insn2, 1678 contents + r_vaddr - input_section->vma + r_symndx); 1679 1680 gp_usedp = TRUE; 1681 } 1682 break; 1683 1684 case ALPHA_R_OP_PUSH: 1685 case ALPHA_R_OP_PSUB: 1686 case ALPHA_R_OP_PRSHIFT: 1687 /* Manipulate values on the reloc evaluation stack. The 1688 r_vaddr field is not an address in input_section, it is 1689 the current value (including any addend) of the object 1690 being used. */ 1691 if (! r_extern) 1692 { 1693 asection *s; 1694 1695 s = symndx_to_section[r_symndx]; 1696 if (s == (asection *) NULL) 1697 abort (); 1698 addend = s->output_section->vma + s->output_offset - s->vma; 1699 } 1700 else 1701 { 1702 struct ecoff_link_hash_entry *h; 1703 1704 h = sym_hashes[r_symndx]; 1705 if (h == (struct ecoff_link_hash_entry *) NULL) 1706 abort (); 1707 1708 if (! info->relocatable) 1709 { 1710 if (h->root.type == bfd_link_hash_defined 1711 || h->root.type == bfd_link_hash_defweak) 1712 addend = (h->root.u.def.value 1713 + h->root.u.def.section->output_section->vma 1714 + h->root.u.def.section->output_offset); 1715 else 1716 { 1717 /* Note that we pass the address as 0, since we 1718 do not have a meaningful number for the 1719 location within the section that is being 1720 relocated. */ 1721 if (! ((*info->callbacks->undefined_symbol) 1722 (info, h->root.root.string, input_bfd, 1723 input_section, (bfd_vma) 0, TRUE))) 1724 return FALSE; 1725 addend = 0; 1726 } 1727 } 1728 else 1729 { 1730 if (h->root.type != bfd_link_hash_defined 1731 && h->root.type != bfd_link_hash_defweak 1732 && h->indx == -1) 1733 { 1734 /* This symbol is not being written out. Pass 1735 the address as 0, as with undefined_symbol, 1736 above. */ 1737 if (! ((*info->callbacks->unattached_reloc) 1738 (info, h->root.root.string, input_bfd, 1739 input_section, (bfd_vma) 0))) 1740 return FALSE; 1741 } 1742 1743 addend = alpha_convert_external_reloc (output_bfd, info, 1744 input_bfd, 1745 ext_rel, h); 1746 } 1747 } 1748 1749 addend += r_vaddr; 1750 1751 if (info->relocatable) 1752 { 1753 /* Adjust r_vaddr by the addend. */ 1754 H_PUT_64 (input_bfd, addend, ext_rel->r_vaddr); 1755 } 1756 else 1757 { 1758 switch (r_type) 1759 { 1760 case ALPHA_R_OP_PUSH: 1761 if (tos >= RELOC_STACKSIZE) 1762 abort (); 1763 stack[tos++] = addend; 1764 break; 1765 1766 case ALPHA_R_OP_PSUB: 1767 if (tos == 0) 1768 abort (); 1769 stack[tos - 1] -= addend; 1770 break; 1771 1772 case ALPHA_R_OP_PRSHIFT: 1773 if (tos == 0) 1774 abort (); 1775 stack[tos - 1] >>= addend; 1776 break; 1777 } 1778 } 1779 1780 adjust_addrp = FALSE; 1781 break; 1782 1783 case ALPHA_R_OP_STORE: 1784 /* Store a value from the reloc stack into a bitfield. If 1785 we are generating relocatable output, all we do is 1786 adjust the address of the reloc. */ 1787 if (! info->relocatable) 1788 { 1789 bfd_vma mask; 1790 bfd_vma val; 1791 1792 if (tos == 0) 1793 abort (); 1794 1795 /* Get the relocation mask. The separate steps and the 1796 casts to bfd_vma are attempts to avoid a bug in the 1797 Alpha OSF 1.3 C compiler. See reloc.c for more 1798 details. */ 1799 mask = 1; 1800 mask <<= (bfd_vma) r_size; 1801 mask -= 1; 1802 1803 /* FIXME: I don't know what kind of overflow checking, 1804 if any, should be done here. */ 1805 val = bfd_get_64 (input_bfd, 1806 contents + r_vaddr - input_section->vma); 1807 val &=~ mask << (bfd_vma) r_offset; 1808 val |= (stack[--tos] & mask) << (bfd_vma) r_offset; 1809 bfd_put_64 (input_bfd, val, 1810 contents + r_vaddr - input_section->vma); 1811 } 1812 break; 1813 1814 case ALPHA_R_GPVALUE: 1815 /* I really don't know if this does the right thing. */ 1816 gp = ecoff_data (input_bfd)->gp + r_symndx; 1817 gp_undefined = FALSE; 1818 break; 1819 } 1820 1821 if (relocatep) 1822 { 1823 reloc_howto_type *howto; 1824 struct ecoff_link_hash_entry *h = NULL; 1825 asection *s = NULL; 1826 bfd_vma relocation; 1827 bfd_reloc_status_type r; 1828 1829 /* Perform a relocation. */ 1830 1831 howto = &alpha_howto_table[r_type]; 1832 1833 if (r_extern) 1834 { 1835 h = sym_hashes[r_symndx]; 1836 /* If h is NULL, that means that there is a reloc 1837 against an external symbol which we thought was just 1838 a debugging symbol. This should not happen. */ 1839 if (h == (struct ecoff_link_hash_entry *) NULL) 1840 abort (); 1841 } 1842 else 1843 { 1844 if (r_symndx >= NUM_RELOC_SECTIONS) 1845 s = NULL; 1846 else 1847 s = symndx_to_section[r_symndx]; 1848 1849 if (s == (asection *) NULL) 1850 abort (); 1851 } 1852 1853 if (info->relocatable) 1854 { 1855 /* We are generating relocatable output, and must 1856 convert the existing reloc. */ 1857 if (r_extern) 1858 { 1859 if (h->root.type != bfd_link_hash_defined 1860 && h->root.type != bfd_link_hash_defweak 1861 && h->indx == -1) 1862 { 1863 /* This symbol is not being written out. */ 1864 if (! ((*info->callbacks->unattached_reloc) 1865 (info, h->root.root.string, input_bfd, 1866 input_section, r_vaddr - input_section->vma))) 1867 return FALSE; 1868 } 1869 1870 relocation = alpha_convert_external_reloc (output_bfd, 1871 info, 1872 input_bfd, 1873 ext_rel, 1874 h); 1875 } 1876 else 1877 { 1878 /* This is a relocation against a section. Adjust 1879 the value by the amount the section moved. */ 1880 relocation = (s->output_section->vma 1881 + s->output_offset 1882 - s->vma); 1883 } 1884 1885 /* If this is PC relative, the existing object file 1886 appears to already have the reloc worked out. We 1887 must subtract out the old value and add in the new 1888 one. */ 1889 if (howto->pc_relative) 1890 relocation -= (input_section->output_section->vma 1891 + input_section->output_offset 1892 - input_section->vma); 1893 1894 /* Put in any addend. */ 1895 relocation += addend; 1896 1897 /* Adjust the contents. */ 1898 r = _bfd_relocate_contents (howto, input_bfd, relocation, 1899 (contents 1900 + r_vaddr 1901 - input_section->vma)); 1902 } 1903 else 1904 { 1905 /* We are producing a final executable. */ 1906 if (r_extern) 1907 { 1908 /* This is a reloc against a symbol. */ 1909 if (h->root.type == bfd_link_hash_defined 1910 || h->root.type == bfd_link_hash_defweak) 1911 { 1912 asection *hsec; 1913 1914 hsec = h->root.u.def.section; 1915 relocation = (h->root.u.def.value 1916 + hsec->output_section->vma 1917 + hsec->output_offset); 1918 } 1919 else 1920 { 1921 if (! ((*info->callbacks->undefined_symbol) 1922 (info, h->root.root.string, input_bfd, 1923 input_section, 1924 r_vaddr - input_section->vma, TRUE))) 1925 return FALSE; 1926 relocation = 0; 1927 } 1928 } 1929 else 1930 { 1931 /* This is a reloc against a section. */ 1932 relocation = (s->output_section->vma 1933 + s->output_offset 1934 - s->vma); 1935 1936 /* Adjust a PC relative relocation by removing the 1937 reference to the original source section. */ 1938 if (howto->pc_relative) 1939 relocation += input_section->vma; 1940 } 1941 1942 r = _bfd_final_link_relocate (howto, 1943 input_bfd, 1944 input_section, 1945 contents, 1946 r_vaddr - input_section->vma, 1947 relocation, 1948 addend); 1949 } 1950 1951 if (r != bfd_reloc_ok) 1952 { 1953 switch (r) 1954 { 1955 default: 1956 case bfd_reloc_outofrange: 1957 abort (); 1958 case bfd_reloc_overflow: 1959 { 1960 const char *name; 1961 1962 if (r_extern) 1963 name = sym_hashes[r_symndx]->root.root.string; 1964 else 1965 name = bfd_section_name (input_bfd, 1966 symndx_to_section[r_symndx]); 1967 if (! ((*info->callbacks->reloc_overflow) 1968 (info, name, alpha_howto_table[r_type].name, 1969 (bfd_vma) 0, input_bfd, input_section, 1970 r_vaddr - input_section->vma))) 1971 return FALSE; 1972 } 1973 break; 1974 } 1975 } 1976 } 1977 1978 if (info->relocatable && adjust_addrp) 1979 { 1980 /* Change the address of the relocation. */ 1981 H_PUT_64 (input_bfd, 1982 (input_section->output_section->vma 1983 + input_section->output_offset 1984 - input_section->vma 1985 + r_vaddr), 1986 ext_rel->r_vaddr); 1987 } 1988 1989 if (gp_usedp && gp_undefined) 1990 { 1991 if (! ((*info->callbacks->reloc_dangerous) 1992 (info, _("GP relative relocation used when GP not defined"), 1993 input_bfd, input_section, r_vaddr - input_section->vma))) 1994 return FALSE; 1995 /* Only give the error once per link. */ 1996 gp = 4; 1997 _bfd_set_gp_value (output_bfd, gp); 1998 gp_undefined = FALSE; 1999 } 2000 } 2001 2002 if (tos != 0) 2003 abort (); 2004 2005 return TRUE; 2006} 2007 2008/* Do final adjustments to the filehdr and the aouthdr. This routine 2009 sets the dynamic bits in the file header. */ 2010 2011static bfd_boolean 2012alpha_adjust_headers (abfd, fhdr, ahdr) 2013 bfd *abfd; 2014 struct internal_filehdr *fhdr; 2015 struct internal_aouthdr *ahdr ATTRIBUTE_UNUSED; 2016{ 2017 if ((abfd->flags & (DYNAMIC | EXEC_P)) == (DYNAMIC | EXEC_P)) 2018 fhdr->f_flags |= F_ALPHA_CALL_SHARED; 2019 else if ((abfd->flags & DYNAMIC) != 0) 2020 fhdr->f_flags |= F_ALPHA_SHARABLE; 2021 return TRUE; 2022} 2023 2024/* Archive handling. In OSF/1 (or Digital Unix) v3.2, Digital 2025 introduced archive packing, in which the elements in an archive are 2026 optionally compressed using a simple dictionary scheme. We know 2027 how to read such archives, but we don't write them. */ 2028 2029#define alpha_ecoff_slurp_armap _bfd_ecoff_slurp_armap 2030#define alpha_ecoff_slurp_extended_name_table \ 2031 _bfd_ecoff_slurp_extended_name_table 2032#define alpha_ecoff_construct_extended_name_table \ 2033 _bfd_ecoff_construct_extended_name_table 2034#define alpha_ecoff_truncate_arname _bfd_ecoff_truncate_arname 2035#define alpha_ecoff_write_armap _bfd_ecoff_write_armap 2036#define alpha_ecoff_generic_stat_arch_elt _bfd_ecoff_generic_stat_arch_elt 2037#define alpha_ecoff_update_armap_timestamp _bfd_ecoff_update_armap_timestamp 2038 2039/* A compressed file uses this instead of ARFMAG. */ 2040 2041#define ARFZMAG "Z\012" 2042 2043/* Read an archive header. This is like the standard routine, but it 2044 also accepts ARFZMAG. */ 2045 2046static PTR 2047alpha_ecoff_read_ar_hdr (abfd) 2048 bfd *abfd; 2049{ 2050 struct areltdata *ret; 2051 struct ar_hdr *h; 2052 2053 ret = (struct areltdata *) _bfd_generic_read_ar_hdr_mag (abfd, ARFZMAG); 2054 if (ret == NULL) 2055 return NULL; 2056 2057 h = (struct ar_hdr *) ret->arch_header; 2058 if (strncmp (h->ar_fmag, ARFZMAG, 2) == 0) 2059 { 2060 bfd_byte ab[8]; 2061 2062 /* This is a compressed file. We must set the size correctly. 2063 The size is the eight bytes after the dummy file header. */ 2064 if (bfd_seek (abfd, (file_ptr) FILHSZ, SEEK_CUR) != 0 2065 || bfd_bread (ab, (bfd_size_type) 8, abfd) != 8 2066 || bfd_seek (abfd, (file_ptr) (- (FILHSZ + 8)), SEEK_CUR) != 0) 2067 return NULL; 2068 2069 ret->parsed_size = H_GET_64 (abfd, ab); 2070 } 2071 2072 return (PTR) ret; 2073} 2074 2075/* Get an archive element at a specified file position. This is where 2076 we uncompress the archive element if necessary. */ 2077 2078static bfd * 2079alpha_ecoff_get_elt_at_filepos (archive, filepos) 2080 bfd *archive; 2081 file_ptr filepos; 2082{ 2083 bfd *nbfd = NULL; 2084 struct areltdata *tdata; 2085 struct ar_hdr *hdr; 2086 bfd_byte ab[8]; 2087 bfd_size_type size; 2088 bfd_byte *buf, *p; 2089 struct bfd_in_memory *bim; 2090 2091 nbfd = _bfd_get_elt_at_filepos (archive, filepos); 2092 if (nbfd == NULL) 2093 goto error_return; 2094 2095 if ((nbfd->flags & BFD_IN_MEMORY) != 0) 2096 { 2097 /* We have already expanded this BFD. */ 2098 return nbfd; 2099 } 2100 2101 tdata = (struct areltdata *) nbfd->arelt_data; 2102 hdr = (struct ar_hdr *) tdata->arch_header; 2103 if (strncmp (hdr->ar_fmag, ARFZMAG, 2) != 0) 2104 return nbfd; 2105 2106 /* We must uncompress this element. We do this by copying it into a 2107 memory buffer, and making bfd_bread and bfd_seek use that buffer. 2108 This can use a lot of memory, but it's simpler than getting a 2109 temporary file, making that work with the file descriptor caching 2110 code, and making sure that it is deleted at all appropriate 2111 times. It can be changed if it ever becomes important. */ 2112 2113 /* The compressed file starts with a dummy ECOFF file header. */ 2114 if (bfd_seek (nbfd, (file_ptr) FILHSZ, SEEK_SET) != 0) 2115 goto error_return; 2116 2117 /* The next eight bytes are the real file size. */ 2118 if (bfd_bread (ab, (bfd_size_type) 8, nbfd) != 8) 2119 goto error_return; 2120 size = H_GET_64 (nbfd, ab); 2121 2122 if (size == 0) 2123 buf = NULL; 2124 else 2125 { 2126 bfd_size_type left; 2127 bfd_byte dict[4096]; 2128 unsigned int h; 2129 bfd_byte b; 2130 2131 buf = (bfd_byte *) bfd_alloc (nbfd, size); 2132 if (buf == NULL) 2133 goto error_return; 2134 p = buf; 2135 2136 left = size; 2137 2138 /* I don't know what the next eight bytes are for. */ 2139 if (bfd_bread (ab, (bfd_size_type) 8, nbfd) != 8) 2140 goto error_return; 2141 2142 /* This is the uncompression algorithm. It's a simple 2143 dictionary based scheme in which each character is predicted 2144 by a hash of the previous three characters. A control byte 2145 indicates whether the character is predicted or whether it 2146 appears in the input stream; each control byte manages the 2147 next eight bytes in the output stream. */ 2148 memset (dict, 0, sizeof dict); 2149 h = 0; 2150 while (bfd_bread (&b, (bfd_size_type) 1, nbfd) == 1) 2151 { 2152 unsigned int i; 2153 2154 for (i = 0; i < 8; i++, b >>= 1) 2155 { 2156 bfd_byte n; 2157 2158 if ((b & 1) == 0) 2159 n = dict[h]; 2160 else 2161 { 2162 if (! bfd_bread (&n, (bfd_size_type) 1, nbfd)) 2163 goto error_return; 2164 dict[h] = n; 2165 } 2166 2167 *p++ = n; 2168 2169 --left; 2170 if (left == 0) 2171 break; 2172 2173 h <<= 4; 2174 h ^= n; 2175 h &= sizeof dict - 1; 2176 } 2177 2178 if (left == 0) 2179 break; 2180 } 2181 } 2182 2183 /* Now the uncompressed file contents are in buf. */ 2184 bim = ((struct bfd_in_memory *) 2185 bfd_alloc (nbfd, (bfd_size_type) sizeof (struct bfd_in_memory))); 2186 if (bim == NULL) 2187 goto error_return; 2188 bim->size = size; 2189 bim->buffer = buf; 2190 2191 nbfd->mtime_set = TRUE; 2192 nbfd->mtime = strtol (hdr->ar_date, (char **) NULL, 10); 2193 2194 nbfd->flags |= BFD_IN_MEMORY; 2195 nbfd->iostream = (PTR) bim; 2196 BFD_ASSERT (! nbfd->cacheable); 2197 2198 return nbfd; 2199 2200 error_return: 2201 if (nbfd != NULL) 2202 bfd_close (nbfd); 2203 return NULL; 2204} 2205 2206/* Open the next archived file. */ 2207 2208static bfd * 2209alpha_ecoff_openr_next_archived_file (archive, last_file) 2210 bfd *archive; 2211 bfd *last_file; 2212{ 2213 file_ptr filestart; 2214 2215 if (last_file == NULL) 2216 filestart = bfd_ardata (archive)->first_file_filepos; 2217 else 2218 { 2219 struct areltdata *t; 2220 struct ar_hdr *h; 2221 bfd_size_type size; 2222 2223 /* We can't use arelt_size here, because that uses parsed_size, 2224 which is the uncompressed size. We need the compressed size. */ 2225 t = (struct areltdata *) last_file->arelt_data; 2226 h = (struct ar_hdr *) t->arch_header; 2227 size = strtol (h->ar_size, (char **) NULL, 10); 2228 2229 /* Pad to an even boundary... 2230 Note that last_file->origin can be odd in the case of 2231 BSD-4.4-style element with a long odd size. */ 2232 filestart = last_file->origin + size; 2233 filestart += filestart % 2; 2234 } 2235 2236 return alpha_ecoff_get_elt_at_filepos (archive, filestart); 2237} 2238 2239/* Open the archive file given an index into the armap. */ 2240 2241static bfd * 2242alpha_ecoff_get_elt_at_index (abfd, index) 2243 bfd *abfd; 2244 symindex index; 2245{ 2246 carsym *entry; 2247 2248 entry = bfd_ardata (abfd)->symdefs + index; 2249 return alpha_ecoff_get_elt_at_filepos (abfd, entry->file_offset); 2250} 2251 2252/* This is the ECOFF backend structure. The backend field of the 2253 target vector points to this. */ 2254 2255static const struct ecoff_backend_data alpha_ecoff_backend_data = 2256{ 2257 /* COFF backend structure. */ 2258 { 2259 (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */ 2260 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */ 2261 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */ 2262 (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/ 2263 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */ 2264 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */ 2265 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */ 2266 alpha_ecoff_swap_filehdr_out, alpha_ecoff_swap_aouthdr_out, 2267 alpha_ecoff_swap_scnhdr_out, 2268 FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, TRUE, FALSE, 4, FALSE, 2, 2269 alpha_ecoff_swap_filehdr_in, alpha_ecoff_swap_aouthdr_in, 2270 alpha_ecoff_swap_scnhdr_in, NULL, 2271 alpha_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook, 2272 alpha_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags, 2273 _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table, 2274 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 2275 NULL, NULL, NULL 2276 }, 2277 /* Supported architecture. */ 2278 bfd_arch_alpha, 2279 /* Initial portion of armap string. */ 2280 "________64", 2281 /* The page boundary used to align sections in a demand-paged 2282 executable file. E.g., 0x1000. */ 2283 0x2000, 2284 /* TRUE if the .rdata section is part of the text segment, as on the 2285 Alpha. FALSE if .rdata is part of the data segment, as on the 2286 MIPS. */ 2287 TRUE, 2288 /* Bitsize of constructor entries. */ 2289 64, 2290 /* Reloc to use for constructor entries. */ 2291 &alpha_howto_table[ALPHA_R_REFQUAD], 2292 { 2293 /* Symbol table magic number. */ 2294 magicSym2, 2295 /* Alignment of debugging information. E.g., 4. */ 2296 8, 2297 /* Sizes of external symbolic information. */ 2298 sizeof (struct hdr_ext), 2299 sizeof (struct dnr_ext), 2300 sizeof (struct pdr_ext), 2301 sizeof (struct sym_ext), 2302 sizeof (struct opt_ext), 2303 sizeof (struct fdr_ext), 2304 sizeof (struct rfd_ext), 2305 sizeof (struct ext_ext), 2306 /* Functions to swap in external symbolic data. */ 2307 ecoff_swap_hdr_in, 2308 ecoff_swap_dnr_in, 2309 ecoff_swap_pdr_in, 2310 ecoff_swap_sym_in, 2311 ecoff_swap_opt_in, 2312 ecoff_swap_fdr_in, 2313 ecoff_swap_rfd_in, 2314 ecoff_swap_ext_in, 2315 _bfd_ecoff_swap_tir_in, 2316 _bfd_ecoff_swap_rndx_in, 2317 /* Functions to swap out external symbolic data. */ 2318 ecoff_swap_hdr_out, 2319 ecoff_swap_dnr_out, 2320 ecoff_swap_pdr_out, 2321 ecoff_swap_sym_out, 2322 ecoff_swap_opt_out, 2323 ecoff_swap_fdr_out, 2324 ecoff_swap_rfd_out, 2325 ecoff_swap_ext_out, 2326 _bfd_ecoff_swap_tir_out, 2327 _bfd_ecoff_swap_rndx_out, 2328 /* Function to read in symbolic data. */ 2329 _bfd_ecoff_slurp_symbolic_info 2330 }, 2331 /* External reloc size. */ 2332 RELSZ, 2333 /* Reloc swapping functions. */ 2334 alpha_ecoff_swap_reloc_in, 2335 alpha_ecoff_swap_reloc_out, 2336 /* Backend reloc tweaking. */ 2337 alpha_adjust_reloc_in, 2338 alpha_adjust_reloc_out, 2339 /* Relocate section contents while linking. */ 2340 alpha_relocate_section, 2341 /* Do final adjustments to filehdr and aouthdr. */ 2342 alpha_adjust_headers, 2343 /* Read an element from an archive at a given file position. */ 2344 alpha_ecoff_get_elt_at_filepos 2345}; 2346 2347/* Looking up a reloc type is Alpha specific. */ 2348#define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup 2349 2350/* So is getting relocated section contents. */ 2351#define _bfd_ecoff_bfd_get_relocated_section_contents \ 2352 alpha_ecoff_get_relocated_section_contents 2353 2354/* Handling file windows is generic. */ 2355#define _bfd_ecoff_get_section_contents_in_window \ 2356 _bfd_generic_get_section_contents_in_window 2357 2358/* Relaxing sections is generic. */ 2359#define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section 2360#define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections 2361#define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections 2362#define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group 2363 2364const bfd_target ecoffalpha_little_vec = 2365{ 2366 "ecoff-littlealpha", /* name */ 2367 bfd_target_ecoff_flavour, 2368 BFD_ENDIAN_LITTLE, /* data byte order is little */ 2369 BFD_ENDIAN_LITTLE, /* header byte order is little */ 2370 2371 (HAS_RELOC | EXEC_P | /* object flags */ 2372 HAS_LINENO | HAS_DEBUG | 2373 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), 2374 2375 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA), 2376 0, /* leading underscore */ 2377 ' ', /* ar_pad_char */ 2378 15, /* ar_max_namelen */ 2379 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 2380 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 2381 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */ 2382 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 2383 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 2384 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */ 2385 2386 {_bfd_dummy_target, alpha_ecoff_object_p, /* bfd_check_format */ 2387 _bfd_ecoff_archive_p, _bfd_dummy_target}, 2388 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */ 2389 _bfd_generic_mkarchive, bfd_false}, 2390 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */ 2391 _bfd_write_archive_contents, bfd_false}, 2392 2393 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff), 2394 BFD_JUMP_TABLE_COPY (_bfd_ecoff), 2395 BFD_JUMP_TABLE_CORE (_bfd_nocore), 2396 BFD_JUMP_TABLE_ARCHIVE (alpha_ecoff), 2397 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff), 2398 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff), 2399 BFD_JUMP_TABLE_WRITE (_bfd_ecoff), 2400 BFD_JUMP_TABLE_LINK (_bfd_ecoff), 2401 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 2402 2403 NULL, 2404 2405 (PTR) &alpha_ecoff_backend_data 2406}; 2407