bfd/nlm32-alpha.c

   1 /* Support for 32-bit Alpha NLM (NetWare Loadable Module)
   2    Copyright (C) 1993 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Cygnus Support.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /* This file describes the 32 bit Alpha NLM format.  You might think
  22    that an Alpha chip would use a 64 bit format, but, for some reason,
  23    it doesn't.  */
  24
  25 #include "bfd.h"
  26 #include "sysdep.h"
  27 #include "libbfd.h"
  28
  29 #define ARCH_SIZE 32
  30
  31 #include "nlm/alpha-ext.h"
  32 #define Nlm_External_Fixed_Header       Nlm32_alpha_External_Fixed_Header
  33
  34 #include "libnlm.h"
  35
  36 static boolean nlm_alpha_backend_object_p
  37   PARAMS ((bfd *));
  38 static boolean nlm_alpha_write_prefix
  39   PARAMS ((bfd *));
  40 static boolean nlm_alpha_read_reloc
  41   PARAMS ((bfd *, nlmNAME(symbol_type) *, asection **, arelent *));
  42 static boolean nlm_alpha_mangle_relocs
  43   PARAMS ((bfd *, asection *, PTR, bfd_vma, bfd_size_type));
  44 static boolean nlm_alpha_read_import
  45   PARAMS ((bfd *, nlmNAME(symbol_type) *));
  46 static boolean nlm_alpha_write_import
  47   PARAMS ((bfd *, asection *, arelent *));
  48 static boolean nlm_alpha_set_public_section
  49   PARAMS ((bfd *, nlmNAME(symbol_type) *));
  50 static bfd_vma nlm_alpha_get_public_offset
  51   PARAMS ((bfd *, asymbol *));
  52 static boolean nlm_alpha_write_external
  53   PARAMS ((bfd *, bfd_size_type, asymbol *, struct reloc_and_sec *));
  54 \f
  55 /* Alpha NLM's have a prefix header before the standard NLM.  This
  56    function reads it in, verifies the version, and seeks the bfd to
  57    the location before the regular NLM header.  */
  58
  59 static boolean
  60 nlm_alpha_backend_object_p (abfd)
  61      bfd *abfd;
  62 {
  63   struct nlm32_alpha_external_prefix_header s;
  64   bfd_size_type size;
  65
  66   if (bfd_read ((PTR) &s, sizeof s, 1, abfd) != sizeof s)
  67     return false;
  68
  69   if (bfd_h_get_32 (abfd, s.magic) != NLM32_ALPHA_MAGIC)
  70     return false;
  71
  72   /* FIXME: Should we check the format number?  */
  73
  74   /* Skip to the end of the header.  */
  75   size = bfd_h_get_32 (abfd, s.size);
  76   if (bfd_seek (abfd, size, SEEK_SET) != 0)
  77     return false;
  78
  79   return true;
  80 }
  81
  82 /* Write out the prefix.  */
  83
  84 static boolean
  85 nlm_alpha_write_prefix (abfd)
  86      bfd *abfd;
  87 {
  88   struct nlm32_alpha_external_prefix_header s;
  89
  90   memset (&s, 0, sizeof s);
  91   bfd_h_put_32 (abfd, (bfd_vma) NLM32_ALPHA_MAGIC, s.magic);
  92   bfd_h_put_32 (abfd, (bfd_vma) 2, s.format);
  93   bfd_h_put_32 (abfd, (bfd_vma) sizeof s, s.size);
  94   if (bfd_write ((PTR) &s, sizeof s, 1, abfd) != sizeof s)
  95     {
  96       bfd_error = system_call_error;
  97       return false;
  98     }
  99   return true;
 100 }
 101 \f
 102 /* How to process the various reloc types.  */
 103
 104 static reloc_howto_type nlm32_alpha_howto_table[] =
 105 {
 106   /* Reloc type 0 is ignored by itself.  However, it appears after a
 107      GPDISP reloc to identify the location where the low order 16 bits
 108      of the gp register are loaded.  */
 109   HOWTO (ALPHA_R_IGNORE,        /* type */
 110          0,                     /* rightshift */
 111          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 112          8,                     /* bitsize */
 113          false,                 /* pc_relative */
 114          0,                     /* bitpos */
 115          complain_overflow_dont, /* complain_on_overflow */
 116          0,                     /* special_function */
 117          "IGNORE",              /* name */
 118          false,                 /* partial_inplace */
 119          0,                     /* src_mask */
 120          0,                     /* dst_mask */
 121          false),                /* pcrel_offset */
 122
 123   /* A 32 bit reference to a symbol.  */
 124   HOWTO (ALPHA_R_REFLONG,       /* type */
 125          0,                     /* rightshift */
 126          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 127          32,                    /* bitsize */
 128          false,                 /* pc_relative */
 129          0,                     /* bitpos */
 130          complain_overflow_bitfield, /* complain_on_overflow */
 131          0,                     /* special_function */
 132          "REFLONG",             /* name */
 133          true,                  /* partial_inplace */
 134          0xffffffff,            /* src_mask */
 135          0xffffffff,            /* dst_mask */
 136          false),                /* pcrel_offset */
 137
 138   /* A 64 bit reference to a symbol.  */
 139   HOWTO (ALPHA_R_REFQUAD,       /* type */
 140          0,                     /* rightshift */
 141          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 142          64,                    /* bitsize */
 143          false,                 /* pc_relative */
 144          0,                     /* bitpos */
 145          complain_overflow_bitfield, /* complain_on_overflow */
 146          0,                     /* special_function */
 147          "REFQUAD",             /* name */
 148          true,                  /* partial_inplace */
 149          0xffffffffffffffff,    /* src_mask */
 150          0xffffffffffffffff,    /* dst_mask */
 151          false),                /* pcrel_offset */
 152
 153   /* A 32 bit GP relative offset.  This is just like REFLONG except
 154      that when the value is used the value of the gp register will be
 155      added in.  */
 156   HOWTO (ALPHA_R_GPREL32,       /* type */
 157          0,                     /* rightshift */
 158          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 159          32,                    /* bitsize */
 160          false,                 /* pc_relative */
 161          0,                     /* bitpos */
 162          complain_overflow_bitfield, /* complain_on_overflow */
 163          0,                     /* special_function */
 164          "GPREL32",             /* name */
 165          true,                  /* partial_inplace */
 166          0xffffffff,            /* src_mask */
 167          0xffffffff,            /* dst_mask */
 168          false),                /* pcrel_offset */
 169
 170   /* Used for an instruction that refers to memory off the GP
 171      register.  The offset is 16 bits of the 32 bit instruction.  This
 172      reloc always seems to be against the .lita section.  */
 173   HOWTO (ALPHA_R_LITERAL,       /* type */
 174          0,                     /* rightshift */
 175          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 176          16,                    /* bitsize */
 177          false,                 /* pc_relative */
 178          0,                     /* bitpos */
 179          complain_overflow_signed, /* complain_on_overflow */
 180          0,                     /* special_function */
 181          "LITERAL",             /* name */
 182          true,                  /* partial_inplace */
 183          0xffff,                /* src_mask */
 184          0xffff,                /* dst_mask */
 185          false),                /* pcrel_offset */
 186
 187   /* This reloc only appears immediately following a LITERAL reloc.
 188      It identifies a use of the literal.  It seems that the linker can
 189      use this to eliminate a portion of the .lita section.  The symbol
 190      index is special: 1 means the literal address is in the base
 191      register of a memory format instruction; 2 means the literal
 192      address is in the byte offset register of a byte-manipulation
 193      instruction; 3 means the literal address is in the target
 194      register of a jsr instruction.  This does not actually do any
 195      relocation.  */
 196   HOWTO (ALPHA_R_LITUSE,        /* type */
 197          0,                     /* rightshift */
 198          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 199          32,                    /* bitsize */
 200          false,                 /* pc_relative */
 201          0,                     /* bitpos */
 202          complain_overflow_dont, /* complain_on_overflow */
 203          0,                     /* special_function */
 204          "LITUSE",              /* name */
 205          false,                 /* partial_inplace */
 206          0,                     /* src_mask */
 207          0,                     /* dst_mask */
 208          false),                /* pcrel_offset */
 209
 210   /* Load the gp register.  This is always used for a ldah instruction
 211      which loads the upper 16 bits of the gp register.  The next reloc
 212      will be an IGNORE reloc which identifies the location of the lda
 213      instruction which loads the lower 16 bits.  The symbol index of
 214      the GPDISP instruction appears to actually be the number of bytes
 215      between the ldah and lda instructions.  This gives two different
 216      ways to determine where the lda instruction is; I don't know why
 217      both are used.  The value to use for the relocation is the
 218      difference between the GP value and the current location; the
 219      load will always be done against a register holding the current
 220      address.  */
 221   HOWTO (ALPHA_R_GPDISP,        /* type */
 222          16,                    /* rightshift */
 223          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 224          16,                    /* bitsize */
 225          true,                  /* pc_relative */
 226          0,                     /* bitpos */
 227          complain_overflow_dont, /* complain_on_overflow */
 228          0,                     /* special_function */
 229          "GPDISP",              /* name */
 230          true,                  /* partial_inplace */
 231          0xffff,                /* src_mask */
 232          0xffff,                /* dst_mask */
 233          true),                 /* pcrel_offset */
 234
 235   /* A 21 bit branch.  The native assembler generates these for
 236      branches within the text segment, and also fills in the PC
 237      relative offset in the instruction.  It seems to me that this
 238      reloc, unlike the others, is not partial_inplace.  */
 239   HOWTO (ALPHA_R_BRADDR,        /* type */
 240          2,                     /* rightshift */
 241          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 242          21,                    /* bitsize */
 243          true,                  /* pc_relative */
 244          0,                     /* bitpos */
 245          complain_overflow_signed, /* complain_on_overflow */
 246          0,                     /* special_function */
 247          "BRADDR",              /* name */
 248          false,                 /* partial_inplace */
 249          0,                     /* src_mask */
 250          0x1fffff,              /* dst_mask */
 251          false),                /* pcrel_offset */
 252
 253   /* A hint for a jump to a register.  */
 254   HOWTO (ALPHA_R_HINT,          /* type */
 255          2,                     /* rightshift */
 256          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 257          14,                    /* bitsize */
 258          false,                 /* pc_relative */
 259          0,                     /* bitpos */
 260          complain_overflow_dont, /* complain_on_overflow */
 261          0,                     /* special_function */
 262          "HINT",                /* name */
 263          true,                  /* partial_inplace */
 264          0x3fff,                /* src_mask */
 265          0x3fff,                /* dst_mask */
 266          false),                /* pcrel_offset */
 267
 268   /* 16 bit PC relative offset.  */
 269   HOWTO (ALPHA_R_SREL16,        /* type */
 270          0,                     /* rightshift */
 271          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 272          16,                    /* bitsize */
 273          true,                  /* pc_relative */
 274          0,                     /* bitpos */
 275          complain_overflow_signed, /* complain_on_overflow */
 276          0,                     /* special_function */
 277          "SREL16",              /* name */
 278          true,                  /* partial_inplace */
 279          0xffff,                /* src_mask */
 280          0xffff,                /* dst_mask */
 281          false),                /* pcrel_offset */
 282
 283   /* 32 bit PC relative offset.  */
 284   HOWTO (ALPHA_R_SREL32,        /* type */
 285          0,                     /* rightshift */
 286          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 287          32,                    /* bitsize */
 288          true,                  /* pc_relative */
 289          0,                     /* bitpos */
 290          complain_overflow_signed, /* complain_on_overflow */
 291          0,                     /* special_function */
 292          "SREL32",              /* name */
 293          true,                  /* partial_inplace */
 294          0xffffffff,            /* src_mask */
 295          0xffffffff,            /* dst_mask */
 296          false),                /* pcrel_offset */
 297
 298   /* A 64 bit PC relative offset.  */
 299   HOWTO (ALPHA_R_SREL64,        /* type */
 300          0,                     /* rightshift */
 301          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 302          64,                    /* bitsize */
 303          true,                  /* pc_relative */
 304          0,                     /* bitpos */
 305          complain_overflow_signed, /* complain_on_overflow */
 306          0,                     /* special_function */
 307          "SREL64",              /* name */
 308          true,                  /* partial_inplace */
 309          0xffffffffffffffff,    /* src_mask */
 310          0xffffffffffffffff,    /* dst_mask */
 311          false),                /* pcrel_offset */
 312
 313   /* Push a value on the reloc evaluation stack.  */
 314   HOWTO (ALPHA_R_OP_PUSH,       /* type */
 315          0,                     /* rightshift */
 316          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 317          0,                     /* bitsize */
 318          false,                 /* pc_relative */
 319          0,                     /* bitpos */
 320          complain_overflow_dont, /* complain_on_overflow */
 321          0,                     /* special_function */
 322          "OP_PUSH",             /* name */
 323          false,                 /* partial_inplace */
 324          0,                     /* src_mask */
 325          0,                     /* dst_mask */
 326          false),                /* pcrel_offset */
 327
 328   /* Store the value from the stack at the given address.  Store it in
 329      a bitfield of size r_size starting at bit position r_offset.  */
 330   HOWTO (ALPHA_R_OP_STORE,      /* type */
 331          0,                     /* rightshift */
 332          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          64,                    /* bitsize */
 334          false,                 /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_dont, /* complain_on_overflow */
 337          0,                     /* special_function */
 338          "OP_STORE",            /* name */
 339          false,                 /* partial_inplace */
 340          0,                     /* src_mask */
 341          0xffffffffffffffff,    /* dst_mask */
 342          false),                /* pcrel_offset */
 343
 344   /* Subtract the reloc address from the value on the top of the
 345      relocation stack.  */
 346   HOWTO (ALPHA_R_OP_PSUB,       /* type */
 347          0,                     /* rightshift */
 348          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 349          0,                     /* bitsize */
 350          false,                 /* pc_relative */
 351          0,                     /* bitpos */
 352          complain_overflow_dont, /* complain_on_overflow */
 353          0,                     /* special_function */
 354          "OP_PSUB",             /* name */
 355          false,                 /* partial_inplace */
 356          0,                     /* src_mask */
 357          0,                     /* dst_mask */
 358          false),                /* pcrel_offset */
 359
 360   /* Shift the value on the top of the relocation stack right by the
 361      given value.  */
 362   HOWTO (ALPHA_R_OP_PRSHIFT,    /* type */
 363          0,                     /* rightshift */
 364          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 365          0,                     /* bitsize */
 366          false,                 /* pc_relative */
 367          0,                     /* bitpos */
 368          complain_overflow_dont, /* complain_on_overflow */
 369          0,                      /* special_function */
 370          "OP_PRSHIFT",          /* name */
 371          false,                 /* partial_inplace */
 372          0,                     /* src_mask */
 373          0,                     /* dst_mask */
 374          false),                /* pcrel_offset */
 375
 376   /* Adjust the GP value for a new range in the object file.  */
 377   HOWTO (ALPHA_R_GPVALUE,       /* type */
 378          0,                     /* rightshift */
 379          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 380          0,                     /* bitsize */
 381          false,                 /* pc_relative */
 382          0,                     /* bitpos */
 383          complain_overflow_dont, /* complain_on_overflow */
 384          0,                     /* special_function */
 385          "GPVALUE",             /* name */
 386          false,                 /* partial_inplace */
 387          0,                     /* src_mask */
 388          0,                     /* dst_mask */
 389          false)                 /* pcrel_offset */
 390 };
 391
 392 static reloc_howto_type nlm32_alpha_nw_howto =
 393   HOWTO (ALPHA_R_NW_RELOC,      /* type */
 394          0,                     /* rightshift */
 395          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 396          0,                     /* bitsize */
 397          false,                 /* pc_relative */
 398          0,                     /* bitpos */
 399          complain_overflow_dont, /* complain_on_overflow */
 400          0,                     /* special_function */
 401          "NW_RELOC",            /* name */
 402          false,                 /* partial_inplace */
 403          0,                     /* src_mask */
 404          0,                     /* dst_mask */
 405          false);                /* pcrel_offset */
 406
 407 /* Read an Alpha NLM reloc.  This routine keeps some static data which
 408    it uses when handling local relocs.  This only works correctly
 409    because all the local relocs are read at once.  */
 410
 411 static boolean
 412 nlm_alpha_read_reloc (abfd, sym, secp, rel)
 413      bfd *abfd;
 414      nlmNAME(symbol_type) *sym;
 415      asection **secp;
 416      arelent *rel;
 417 {
 418   static bfd_vma gp_value;
 419   static bfd_vma lita_address;
 420   struct nlm32_alpha_external_reloc ext;
 421   bfd_vma r_vaddr;
 422   long r_symndx;
 423   int r_type, r_extern, r_offset, r_size;
 424   asection *code_sec, *data_sec;
 425
 426   /* Read the reloc from the file.  */
 427   if (bfd_read (&ext, sizeof ext, 1, abfd) != sizeof ext)
 428     {
 429       bfd_error = system_call_error;
 430       return false;
 431     }
 432
 433   /* Swap in the reloc information.  */
 434   r_vaddr = bfd_h_get_64 (abfd, (bfd_byte *) ext.r_vaddr);
 435   r_symndx = bfd_h_get_32 (abfd, (bfd_byte *) ext.r_symndx);
 436
 437   BFD_ASSERT (abfd->xvec->header_byteorder_big_p == false);
 438
 439   r_type = ((ext.r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
 440             >> RELOC_BITS0_TYPE_SH_LITTLE);
 441   r_extern = (ext.r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
 442   r_offset = ((ext.r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
 443               >> RELOC_BITS1_OFFSET_SH_LITTLE);
 444   /* Ignore the reserved bits.  */
 445   r_size = ((ext.r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
 446             >> RELOC_BITS3_SIZE_SH_LITTLE);
 447
 448   /* Fill in the BFD arelent structure.  */
 449   code_sec = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
 450   data_sec = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
 451   if (r_extern)
 452     {
 453       /* External relocations are only used for imports.  */
 454       BFD_ASSERT (sym != NULL);
 455       /* We don't need to set sym_ptr_ptr for this case.  It is set in
 456          nlm_canonicalize_reloc.  */
 457       rel->sym_ptr_ptr = NULL;
 458       rel->addend = 0;
 459     }
 460   else
 461     {
 462       /* Internal relocations are only used for local relocation
 463          fixups.  If they are not NW_RELOC or GPDISP or IGNORE, they
 464          must be against .text or .data.  */
 465       BFD_ASSERT (r_type == ALPHA_R_NW_RELOC || sym == NULL);
 466       if (r_type == ALPHA_R_NW_RELOC
 467           || r_type == ALPHA_R_GPDISP
 468           || r_type == ALPHA_R_IGNORE)
 469         {
 470           rel->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
 471           rel->addend = 0;
 472         }
 473       else if (r_symndx == ALPHA_RELOC_SECTION_TEXT)
 474         {
 475           rel->sym_ptr_ptr = code_sec->symbol_ptr_ptr;
 476           BFD_ASSERT (bfd_get_section_vma (abfd, code_sec) == 0);
 477           rel->addend = 0;
 478         }
 479       else if (r_symndx == ALPHA_RELOC_SECTION_DATA)
 480         {
 481           rel->sym_ptr_ptr = data_sec->symbol_ptr_ptr;
 482           rel->addend = - bfd_get_section_vma (abfd, data_sec);
 483         }
 484       else
 485         {
 486           BFD_ASSERT (0);
 487           rel->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
 488           rel->addend = 0;
 489         }
 490     }
 491
 492   /* We use the address to determine whether the reloc is in the .text
 493      or .data section.  R_NW_RELOC relocs don't really have a section,
 494      so we put them in .text.  */
 495   if (r_type == ALPHA_R_NW_RELOC
 496       || r_vaddr < bfd_section_size (abfd, code_sec))
 497     {
 498       *secp = code_sec;
 499       rel->address = r_vaddr;
 500     }
 501   else
 502     {
 503       *secp = data_sec;
 504       rel->address = r_vaddr - bfd_section_size (abfd, code_sec);
 505     }
 506
 507   /* We must adjust the addend based on the type.  */
 508   BFD_ASSERT ((r_type >= 0 && r_type <= ALPHA_R_GPVALUE)
 509               || r_type == ALPHA_R_NW_RELOC);
 510
 511   switch (r_type)
 512     {
 513     case ALPHA_R_BRADDR:
 514     case ALPHA_R_SREL16:
 515     case ALPHA_R_SREL32:
 516     case ALPHA_R_SREL64:
 517       /* The PC relative relocs do not seem to use the section VMA as
 518          a negative addend.  */
 519       rel->addend = 0;
 520       break;
 521
 522     case ALPHA_R_GPREL32:
 523       /* Copy the gp value for this object file into the addend, to
 524          ensure that we are not confused by the linker.  */
 525       if (! r_extern)
 526         rel->addend += gp_value;
 527       break;
 528
 529     case ALPHA_R_LITERAL:
 530       BFD_ASSERT (! r_extern);
 531       rel->addend += lita_address;
 532       break;
 533
 534     case ALPHA_R_LITUSE:
 535     case ALPHA_R_GPDISP:
 536       /* The LITUSE and GPDISP relocs do not use a symbol, or an
 537          addend, but they do use a special code.  Put this code in the
 538          addend field.  */
 539       rel->addend = r_symndx;
 540       rel->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
 541       break;
 542
 543     case ALPHA_R_OP_STORE:
 544       /* The STORE reloc needs the size and offset fields.  We store
 545          them in the addend.  */
 546       BFD_ASSERT (r_offset < 256 && r_size < 256);
 547       rel->addend = (r_offset << 8) + r_size;
 548       break;
 549
 550     case ALPHA_R_OP_PUSH:
 551     case ALPHA_R_OP_PSUB:
 552     case ALPHA_R_OP_PRSHIFT:
 553       /* The PUSH, PSUB and PRSHIFT relocs do not actually use an
 554          address.  I believe that the address supplied is really an
 555          addend.  */
 556       rel->addend = r_vaddr;
 557       break;
 558
 559     case ALPHA_R_GPVALUE:
 560       /* Record the new gp value.  */
 561       gp_value += r_symndx;
 562       rel->addend = gp_value;
 563       break;
 564
 565     case ALPHA_R_IGNORE:
 566       /* If the type is ALPHA_R_IGNORE, make sure this is a reference
 567          to the absolute section so that the reloc is ignored.  For
 568          some reason the address of this reloc type is not adjusted by
 569          the section vma.  We record the gp value for this object file
 570          here, for convenience when doing the GPDISP relocation.  */
 571       rel->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
 572       rel->address = r_vaddr;
 573       rel->addend = gp_value;
 574       break;
 575
 576     case ALPHA_R_NW_RELOC:
 577       /* If this is SETGP, we set the addend to 0.  Otherwise we set
 578          the addend to the size of the .lita section (this is
 579          r_symndx) plus 1.  We have already set the address of the
 580          reloc to r_vaddr.  */
 581       if (r_size == ALPHA_R_NW_RELOC_SETGP)
 582         {
 583           gp_value = r_vaddr;
 584           rel->addend = 0;
 585         }
 586       else if (r_size == ALPHA_R_NW_RELOC_LITA)
 587         {
 588           lita_address = r_vaddr;
 589           rel->addend = r_symndx + 1;
 590         }
 591       else
 592         BFD_ASSERT (0);
 593       rel->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
 594       break;
 595
 596     default:
 597       break;
 598     }
 599
 600   if (r_type == ALPHA_R_NW_RELOC)
 601     rel->howto = &nlm32_alpha_nw_howto;
 602   else
 603     rel->howto = &nlm32_alpha_howto_table[r_type];
 604
 605   return true;
 606 }
 607
 608 /* Mangle Alpha NLM relocs for output.  */
 609
 610 static boolean
 611 nlm_alpha_mangle_relocs (abfd, sec, data, offset, count)
 612      bfd *abfd;
 613      asection *sec;
 614      PTR data;
 615      bfd_vma offset;
 616      bfd_size_type count;
 617 {
 618   return true;
 619 }
 620
 621 /* Read an ALPHA NLM import record */
 622
 623 static boolean
 624 nlm_alpha_read_import (abfd, sym)
 625      bfd *abfd;
 626      nlmNAME(symbol_type) *sym;
 627 {
 628   struct nlm_relent *nlm_relocs;        /* relocation records for symbol */
 629   bfd_size_type rcount;                 /* number of relocs */
 630   bfd_byte temp[NLM_TARGET_LONG_SIZE];  /* temporary 32-bit value */
 631   unsigned char symlength;              /* length of symbol name */
 632
 633   if (bfd_read ((PTR) &symlength, sizeof (symlength), 1, abfd)
 634       != sizeof (symlength))
 635     {
 636       bfd_error = system_call_error;
 637       return (false);
 638     }
 639   sym -> symbol.the_bfd = abfd;
 640   sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
 641   if (!sym -> symbol.name)
 642     {
 643       bfd_error = no_memory;
 644       return false;
 645     }
 646   if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
 647       != symlength)
 648     {
 649       bfd_error = system_call_error;
 650       return (false);
 651     }
 652   sym -> symbol.flags = 0;
 653   sym -> symbol.value = 0;
 654   sym -> symbol.section = &bfd_und_section;
 655   if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
 656     {
 657       bfd_error = system_call_error;
 658       return (false);
 659     }
 660   rcount = bfd_h_get_32 (abfd, temp);
 661   nlm_relocs = ((struct nlm_relent *)
 662                 bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
 663   if (!nlm_relocs)
 664     {
 665       bfd_error = no_memory;
 666       return false;
 667     }
 668   sym -> relocs = nlm_relocs;
 669   sym -> rcnt = 0;
 670   while (sym -> rcnt < rcount)
 671     {
 672       asection *section;
 673
 674       if (nlm_alpha_read_reloc (abfd, sym, &section,
 675                                 &nlm_relocs -> reloc)
 676           == false)
 677         return false;
 678       nlm_relocs -> section = section;
 679       nlm_relocs++;
 680       sym -> rcnt++;
 681     }
 682
 683   return true;
 684 }
 685
 686 /* Write an Alpha NLM reloc.  */
 687
 688 static boolean
 689 nlm_alpha_write_import (abfd, sec, rel)
 690      bfd *abfd;
 691      asection *sec;
 692      arelent *rel;
 693 {
 694   asymbol *sym;
 695   bfd_vma r_vaddr;
 696   long r_symndx;
 697   int r_type, r_extern, r_offset, r_size;
 698   struct nlm32_alpha_external_reloc ext;
 699
 700   sym = *rel->sym_ptr_ptr;
 701
 702   /* Get values for the relocation fields.  */
 703   r_type = rel->howto->type;
 704   if (r_type != ALPHA_R_NW_RELOC)
 705     {
 706       r_vaddr = bfd_get_section_vma (abfd, sec) + rel->address;
 707       if ((sec->flags & SEC_CODE) == 0)
 708         r_vaddr += bfd_section_size (abfd,
 709                                      bfd_get_section_by_name (abfd,
 710                                                               NLM_CODE_NAME));
 711       if (bfd_get_section (sym) == &bfd_und_section)
 712         {
 713           r_extern = 1;
 714           r_symndx = 0;
 715         }
 716       else
 717         {
 718           r_extern = 0;
 719           if (bfd_get_section_flags (abfd, bfd_get_section (sym)) & SEC_CODE)
 720             r_symndx = ALPHA_RELOC_SECTION_TEXT;
 721           else
 722             r_symndx = ALPHA_RELOC_SECTION_DATA;
 723         }
 724       r_offset = 0;
 725       r_size = 0;
 726
 727       switch (r_type)
 728         {
 729         case ALPHA_R_LITUSE:
 730         case ALPHA_R_GPDISP:
 731           r_symndx = rel->addend;
 732           break;
 733
 734         case ALPHA_R_OP_STORE:
 735           r_size = rel->addend & 0xff;
 736           r_offset = (rel->addend >> 8) & 0xff;
 737           break;
 738
 739         case ALPHA_R_OP_PUSH:
 740         case ALPHA_R_OP_PSUB:
 741         case ALPHA_R_OP_PRSHIFT:
 742           r_vaddr = rel->addend;
 743           break;
 744
 745         case ALPHA_R_IGNORE:
 746           r_vaddr = rel->address;
 747           break;
 748
 749         default:
 750           break;
 751         }
 752     }
 753   else
 754     {
 755       /* r_type == ALPHA_R_NW_RELOC */
 756       r_vaddr = rel->address;
 757       if (rel->addend == 0)
 758         {
 759           r_symndx = 0;
 760           r_size = ALPHA_R_NW_RELOC_SETGP;
 761         }
 762       else
 763         {
 764           r_symndx = rel->addend - 1;
 765           r_size = ALPHA_R_NW_RELOC_LITA;
 766         }
 767       r_extern = 0;
 768       r_offset = 0;
 769     }
 770
 771   /* Swap out the relocation fields.  */
 772   bfd_h_put_64 (abfd, r_vaddr, (bfd_byte *) ext.r_vaddr);
 773   bfd_h_put_32 (abfd, r_symndx, (bfd_byte *) ext.r_symndx);
 774
 775   BFD_ASSERT (abfd->xvec->header_byteorder_big_p == false);
 776
 777   ext.r_bits[0] = ((r_type << RELOC_BITS0_TYPE_SH_LITTLE)
 778                    & RELOC_BITS0_TYPE_LITTLE);
 779   ext.r_bits[1] = ((r_extern ? RELOC_BITS1_EXTERN_LITTLE : 0)
 780                    | ((r_offset << RELOC_BITS1_OFFSET_SH_LITTLE)
 781                       & RELOC_BITS1_OFFSET_LITTLE));
 782   ext.r_bits[2] = 0;
 783   ext.r_bits[3] = ((r_size << RELOC_BITS3_SIZE_SH_LITTLE)
 784                    & RELOC_BITS3_SIZE_LITTLE);
 785
 786   /* Write out the relocation.  */
 787   if (bfd_write (&ext, sizeof ext, 1, abfd) != sizeof ext)
 788     {
 789       bfd_error = system_call_error;
 790       return false;
 791     }
 792
 793   return true;
 794 }
 795 \f
 796 /* Alpha NetWare does not use the high bit to determine whether a
 797    public symbol is in the code segment or the data segment.  Instead,
 798    it just uses the address.  The set_public_section and
 799    get_public_offset routines override the default code which uses the
 800    high bit.  */
 801
 802 /* Set the section for a public symbol.  */
 803
 804 static boolean
 805 nlm_alpha_set_public_section (abfd, sym)
 806      bfd *abfd;
 807      nlmNAME(symbol_type) *sym;
 808 {
 809   asection *code_sec, *data_sec;
 810
 811   code_sec = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
 812   data_sec = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
 813   if (sym->symbol.value < bfd_section_size (abfd, code_sec))
 814     {
 815       sym->symbol.section = code_sec;
 816       sym->symbol.flags |= BSF_FUNCTION;
 817     }
 818   else
 819     {
 820       sym->symbol.section = data_sec;
 821       sym->symbol.value -= bfd_section_size (abfd, code_sec);
 822       /* The data segment had better be aligned.  */
 823       BFD_ASSERT ((bfd_section_size (abfd, code_sec) & 0xf) == 0);
 824     }
 825   return true;
 826 }
 827
 828 /* Get the offset to write out for a public symbol.  */
 829
 830 static bfd_vma
 831 nlm_alpha_get_public_offset (abfd, sym)
 832      bfd *abfd;
 833      asymbol *sym;
 834 {
 835   return bfd_asymbol_value (sym);
 836 }
 837 \f
 838 /* Write an Alpha NLM external symbol.  */
 839
 840 static boolean
 841 nlm_alpha_write_external (abfd, count, sym, relocs)
 842      bfd *abfd;
 843      bfd_size_type count;
 844      asymbol *sym;
 845      struct reloc_and_sec *relocs;
 846 {
 847   int i;
 848   bfd_byte len;
 849   unsigned char temp[NLM_TARGET_LONG_SIZE];
 850   arelent r;
 851
 852   len = strlen (sym->name);
 853   if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd) != sizeof(bfd_byte))
 854       || bfd_write (sym->name, len, 1, abfd) != len)
 855     {
 856       bfd_error = system_call_error;
 857       return false;
 858     }
 859
 860   bfd_put_32 (abfd, count + 2, temp);
 861   if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
 862     {
 863       bfd_error = system_call_error;
 864       return false;
 865     }
 866
 867   /* The first two relocs for each external symbol are the .lita
 868      address and the GP value.  */
 869   r.sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
 870   r.howto = &nlm32_alpha_nw_howto;
 871
 872   r.address = nlm_alpha_backend_data (abfd)->lita_address;
 873   r.addend = nlm_alpha_backend_data (abfd)->lita_size + 1;
 874   if (nlm_alpha_write_import (abfd, (asection *) NULL, &r) == false)
 875     return false;
 876
 877   r.address = nlm_alpha_backend_data (abfd)->gp;
 878   r.addend = 0;
 879   if (nlm_alpha_write_import (abfd, (asection *) NULL, &r) == false)
 880     return false;
 881
 882   for (i = 0; i < count; i++)
 883     {
 884       if (nlm_alpha_write_import (abfd, relocs[i].sec,
 885                                   relocs[i].rel) == false)
 886         return false;
 887     }
 888
 889   return true;
 890 }
 891
 892 #include "nlmswap.h"
 893
 894 static const struct nlm_backend_data nlm32_alpha_backend =
 895 {
 896   "NetWare Alpha Module   \032",
 897   sizeof (Nlm32_alpha_External_Fixed_Header),
 898   sizeof (struct nlm32_alpha_external_prefix_header),
 899   bfd_arch_alpha,
 900   0,
 901   true, /* no uninitialized data permitted by Alpha NetWare.  */
 902   nlm_alpha_backend_object_p,
 903   nlm_alpha_write_prefix,
 904   nlm_alpha_read_reloc,
 905   nlm_alpha_mangle_relocs,
 906   nlm_alpha_read_import,
 907   nlm_alpha_write_import,
 908   nlm_alpha_set_public_section,
 909   nlm_alpha_get_public_offset,
 910   nlm_swap_fixed_header_in,
 911   nlm_swap_fixed_header_out,
 912   nlm_alpha_write_external,
 913   0,    /* write_export */
 914 };
 915
 916 #define TARGET_LITTLE_NAME              "nlm32-alpha"
 917 #define TARGET_LITTLE_SYM               nlmNAME(alpha_vec)
 918 #define TARGET_BACKEND_DATA             &nlm32_alpha_backend
 919
 920 #include "nlm-target.h"