bfd/nlm32-alpha.c

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