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