bfd/nlm32-sparc.c

   1 /* Support for 32-bit SPARC NLM (NetWare Loadable Module)
   2    Copyright 1993, 1994, 1999, 2000, 2001, 2002, 2003, 2004, 2005
   3    Free Software Foundation, Inc.
   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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24
  25 #define ARCH_SIZE 32
  26
  27 #include "nlm/sparc32-ext.h"
  28 #define Nlm_External_Fixed_Header       Nlm32_sparc_External_Fixed_Header
  29
  30 #include "libnlm.h"
  31
  32 enum reloc_type
  33 {
  34   R_SPARC_NONE = 0,
  35   R_SPARC_8,            R_SPARC_16,             R_SPARC_32,
  36   R_SPARC_DISP8,        R_SPARC_DISP16,         R_SPARC_DISP32,
  37   R_SPARC_WDISP30,      R_SPARC_WDISP22,
  38   R_SPARC_HI22,         R_SPARC_22,
  39   R_SPARC_13,           R_SPARC_LO10,
  40   R_SPARC_GOT10,        R_SPARC_GOT13,          R_SPARC_GOT22,
  41   R_SPARC_PC10,         R_SPARC_PC22,
  42   R_SPARC_WPLT30,
  43   R_SPARC_COPY,
  44   R_SPARC_GLOB_DAT,     R_SPARC_JMP_SLOT,
  45   R_SPARC_RELATIVE,
  46   R_SPARC_UA32,
  47   R_SPARC_max
  48 };
  49
  50 static reloc_howto_type nlm32_sparc_howto_table[] =
  51 {
  52   HOWTO (R_SPARC_NONE,    0,0, 0,FALSE,0,complain_overflow_dont,    0,"R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
  53   HOWTO (R_SPARC_8,       0,0, 8,FALSE,0,complain_overflow_bitfield,0,"R_SPARC_8",       FALSE,0,0x000000ff,TRUE),
  54   HOWTO (R_SPARC_16,      0,1,16,FALSE,0,complain_overflow_bitfield,0,"R_SPARC_16",      FALSE,0,0x0000ffff,TRUE),
  55   HOWTO (R_SPARC_32,      0,2,32,FALSE,0,complain_overflow_bitfield,0,"R_SPARC_32",      FALSE,0,0xffffffff,TRUE),
  56   HOWTO (R_SPARC_DISP8,   0,0, 8,TRUE, 0,complain_overflow_signed,  0,"R_SPARC_DISP8",   FALSE,0,0x000000ff,TRUE),
  57   HOWTO (R_SPARC_DISP16,  0,1,16,TRUE, 0,complain_overflow_signed,  0,"R_SPARC_DISP16",  FALSE,0,0x0000ffff,TRUE),
  58   HOWTO (R_SPARC_DISP32,  0,2,32,TRUE, 0,complain_overflow_signed,  0,"R_SPARC_DISP32",  FALSE,0,0x00ffffff,TRUE),
  59   HOWTO (R_SPARC_WDISP30, 2,2,30,TRUE, 0,complain_overflow_signed,  0,"R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE),
  60   HOWTO (R_SPARC_WDISP22, 2,2,22,TRUE, 0,complain_overflow_signed,  0,"R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE),
  61   HOWTO (R_SPARC_HI22,   10,2,22,FALSE,0,complain_overflow_dont,    0,"R_SPARC_HI22",    FALSE,0,0x003fffff,TRUE),
  62   HOWTO (R_SPARC_22,      0,2,22,FALSE,0,complain_overflow_bitfield,0,"R_SPARC_22",      FALSE,0,0x003fffff,TRUE),
  63   HOWTO (R_SPARC_13,      0,2,13,FALSE,0,complain_overflow_bitfield,0,"R_SPARC_13",      FALSE,0,0x00001fff,TRUE),
  64   HOWTO (R_SPARC_LO10,    0,2,10,FALSE,0,complain_overflow_dont,    0,"R_SPARC_LO10",    FALSE,0,0x000003ff,TRUE),
  65   HOWTO (R_SPARC_GOT10,   0,2,10,FALSE,0,complain_overflow_bitfield,0,"R_SPARC_GOT10",   FALSE,0,0x000003ff,TRUE),
  66   HOWTO (R_SPARC_GOT13,   0,2,13,FALSE,0,complain_overflow_bitfield,0,"R_SPARC_GOT13",   FALSE,0,0x00001fff,TRUE),
  67   HOWTO (R_SPARC_GOT22,  10,2,22,FALSE,0,complain_overflow_bitfield,0,"R_SPARC_GOT22",   FALSE,0,0x003fffff,TRUE),
  68   HOWTO (R_SPARC_PC10,    0,2,10,FALSE,0,complain_overflow_bitfield,0,"R_SPARC_PC10",    FALSE,0,0x000003ff,TRUE),
  69   HOWTO (R_SPARC_PC22,    0,2,22,FALSE,0,complain_overflow_bitfield,0,"R_SPARC_PC22",    FALSE,0,0x003fffff,TRUE),
  70   HOWTO (R_SPARC_WPLT30,  0,0,00,FALSE,0,complain_overflow_dont,    0,"R_SPARC_WPLT30",  FALSE,0,0x00000000,TRUE),
  71   HOWTO (R_SPARC_COPY,    0,0,00,FALSE,0,complain_overflow_dont,    0,"R_SPARC_COPY",    FALSE,0,0x00000000,TRUE),
  72   HOWTO (R_SPARC_GLOB_DAT,0,0,00,FALSE,0,complain_overflow_dont,    0,"R_SPARC_GLOB_DAT",FALSE,0,0x00000000,TRUE),
  73   HOWTO (R_SPARC_JMP_SLOT,0,0,00,FALSE,0,complain_overflow_dont,    0,"R_SPARC_JMP_SLOT",FALSE,0,0x00000000,TRUE),
  74   HOWTO (R_SPARC_RELATIVE,0,0,00,FALSE,0,complain_overflow_dont,    0,"R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE),
  75   HOWTO (R_SPARC_UA32,    0,0,00,FALSE,0,complain_overflow_dont,    0,"R_SPARC_UA32",    FALSE,0,0x00000000,TRUE),
  76 };
  77
  78 /* Read a NetWare sparc reloc.  */
  79
  80 struct nlm32_sparc_reloc_ext
  81 {
  82   unsigned char offset[4];
  83   unsigned char addend[4];
  84   unsigned char type[1];
  85   unsigned char pad1[3];
  86 };
  87
  88 static bfd_boolean
  89 nlm_sparc_read_reloc (bfd *abfd,
  90                       nlmNAME (symbol_type) *sym ATTRIBUTE_UNUSED,
  91                       asection **secp,
  92                       arelent *rel)
  93 {
  94   bfd_vma val, addend;
  95   unsigned int index;
  96   unsigned int type;
  97   struct nlm32_sparc_reloc_ext tmp_reloc;
  98   asection *code_sec, *data_sec;
  99
 100   if (bfd_bread (&tmp_reloc, (bfd_size_type) 12, abfd) != 12)
 101     return FALSE;
 102
 103   code_sec = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
 104   data_sec = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
 105
 106   *secp = code_sec;
 107
 108   val = bfd_get_32 (abfd, tmp_reloc.offset);
 109   addend = bfd_get_32 (abfd, tmp_reloc.addend);
 110   type = bfd_get_8 (abfd, tmp_reloc.type);
 111
 112   rel->address = val;
 113   rel->addend = addend;
 114   rel->howto = NULL;
 115
 116   for (index = 0;
 117        index < sizeof (nlm32_sparc_howto_table) / sizeof (reloc_howto_type);
 118        index++)
 119     if (nlm32_sparc_howto_table[index].type == type)
 120       {
 121         rel->howto = &nlm32_sparc_howto_table[index];
 122         break;
 123       }
 124
 125 #ifdef DEBUG
 126   fprintf (stderr, "%s:  address = %08lx, addend = %08lx, type = %d, howto = %08lx\n",
 127            __FUNCTION__, rel->address, rel->addend, type, rel->howto);
 128 #endif
 129   return TRUE;
 130
 131 }
 132
 133 /* Write a NetWare sparc reloc.  */
 134
 135 static bfd_boolean
 136 nlm_sparc_write_reloc (bfd * abfd, asection * sec, arelent * rel)
 137 {
 138   bfd_vma val;
 139   struct nlm32_sparc_reloc_ext tmp_reloc;
 140   unsigned int index;
 141   int type = -1;
 142   reloc_howto_type *tmp;
 143
 144   for (index = 0;
 145        index < sizeof (nlm32_sparc_howto_table) / sizeof (reloc_howto_type);
 146        index++)
 147     {
 148       tmp = &nlm32_sparc_howto_table[index];
 149
 150       if (tmp->rightshift == rel->howto->rightshift
 151           && tmp->size == rel->howto->size
 152           && tmp->bitsize == rel->howto->bitsize
 153           && tmp->pc_relative == rel->howto->pc_relative
 154           && tmp->bitpos == rel->howto->bitpos
 155           && tmp->src_mask == rel->howto->src_mask
 156           && tmp->dst_mask == rel->howto->dst_mask)
 157         {
 158           type = tmp->type;
 159           break;
 160         }
 161     }
 162   if (type == -1)
 163     abort ();
 164
 165   /* Netware wants a list of relocs for each address.
 166      Format is:
 167         long    offset
 168         long    addend
 169         char    type
 170      That should be it.  */
 171
 172   /* The value we write out is the offset into the appropriate
 173      segment.  This offset is the section vma, adjusted by the vma of
 174      the lowest section in that segment, plus the address of the
 175      relocation.  */
 176   val = bfd_get_section_vma (abfd, sec) + rel->address;
 177
 178 #ifdef DEBUG
 179   fprintf (stderr, "%s:  val = %08lx, addend = %08lx, type = %d\n",
 180            __FUNCTION__, val, rel->addend, rel->howto->type);
 181 #endif
 182   bfd_put_32 (abfd, val, tmp_reloc.offset);
 183   bfd_put_32 (abfd, rel->addend, tmp_reloc.addend);
 184   bfd_put_8 (abfd, (short) (rel->howto->type), tmp_reloc.type);
 185
 186   if (bfd_bwrite (&tmp_reloc, (bfd_size_type) 12, abfd) != 12)
 187     return FALSE;
 188
 189   return TRUE;
 190 }
 191
 192 /* Mangle relocs for SPARC NetWare.  We can just use the standard
 193    SPARC relocs.  */
 194
 195 static bfd_boolean
 196 nlm_sparc_mangle_relocs (bfd *abfd ATTRIBUTE_UNUSED,
 197                          asection *sec ATTRIBUTE_UNUSED,
 198                          const void * data ATTRIBUTE_UNUSED,
 199                          bfd_vma offset ATTRIBUTE_UNUSED,
 200                          bfd_size_type count ATTRIBUTE_UNUSED)
 201 {
 202   return TRUE;
 203 }
 204
 205 /* Read a NetWare sparc import record.  */
 206
 207 static bfd_boolean
 208 nlm_sparc_read_import (bfd *abfd, nlmNAME (symbol_type) *sym)
 209 {
 210   struct nlm_relent *nlm_relocs;        /* Relocation records for symbol.  */
 211   bfd_size_type rcount;                 /* Number of relocs.  */
 212   bfd_byte temp[NLM_TARGET_LONG_SIZE];  /* Temporary 32-bit value.  */
 213   unsigned char symlength;              /* Length of symbol name.  */
 214   char *name;
 215
 216   /* First, read in the number of relocation
 217      entries for this symbol.  */
 218   if (bfd_bread (temp, (bfd_size_type) 4, abfd) != 4)
 219     return FALSE;
 220
 221   rcount = bfd_get_32 (abfd, temp);
 222
 223   /* Next, read in the length of the symbol.  */
 224   if (bfd_bread (& symlength, (bfd_size_type) sizeof (symlength), abfd)
 225       != sizeof (symlength))
 226     return FALSE;
 227   sym -> symbol.the_bfd = abfd;
 228   name = bfd_alloc (abfd, (bfd_size_type) symlength + 1);
 229   if (name == NULL)
 230     return FALSE;
 231
 232   /* Then read in the symbol.  */
 233   if (bfd_bread (name, (bfd_size_type) symlength, abfd) != symlength)
 234     return FALSE;
 235   name[symlength] = '\0';
 236   sym -> symbol.name = name;
 237   sym -> symbol.flags = 0;
 238   sym -> symbol.value = 0;
 239   sym -> symbol.section = bfd_und_section_ptr;
 240
 241   /* Next, start reading in the relocs.  */
 242   nlm_relocs = bfd_alloc (abfd, rcount * sizeof (struct nlm_relent));
 243   if (!nlm_relocs)
 244     return FALSE;
 245   sym -> relocs = nlm_relocs;
 246   sym -> rcnt = 0;
 247   while (sym -> rcnt < rcount)
 248     {
 249       asection *section;
 250
 251       if (! nlm_sparc_read_reloc (abfd, sym, &section, &nlm_relocs -> reloc))
 252         return FALSE;
 253       nlm_relocs -> section = section;
 254       nlm_relocs++;
 255       sym -> rcnt++;
 256     }
 257
 258   return TRUE;
 259 }
 260
 261 static bfd_boolean
 262 nlm_sparc_write_import (bfd * abfd, asection * sec, arelent * rel)
 263 {
 264   char temp[4];
 265   asection *code, *data, *bss, *symsec;
 266   bfd_vma base;
 267
 268   code = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
 269   data = bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
 270   bss = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
 271   symsec = (*rel->sym_ptr_ptr)->section;
 272
 273   if (symsec == code)
 274     base = 0;
 275   else if (symsec == data)
 276     base = code->size;
 277   else if (symsec == bss)
 278     base = code->size + data->size;
 279   else
 280     base = 0;
 281
 282 #ifdef DEBUG
 283   fprintf (stderr, "%s:  <%x, 1>\n\t",
 284            __FUNCTION__, base + (*rel->sym_ptr_ptr)->value);
 285 #endif
 286   bfd_put_32 (abfd, base + (*rel->sym_ptr_ptr)->value, temp);
 287   if (bfd_bwrite (temp, (bfd_size_type) 4, abfd) != 4)
 288     return FALSE;
 289   bfd_put_32 (abfd, (bfd_vma) 1, temp);
 290   if (bfd_bwrite (temp, (bfd_size_type) 4, abfd) != 4)
 291     return FALSE;
 292   if (! nlm_sparc_write_reloc (abfd, sec, rel))
 293     return FALSE;
 294   return TRUE;
 295 }
 296
 297 /* Write out an external reference.  */
 298
 299 static bfd_boolean
 300 nlm_sparc_write_external (bfd *abfd,
 301                           bfd_size_type count,
 302                           asymbol *sym,
 303                           struct reloc_and_sec *relocs)
 304 {
 305   unsigned int i;
 306   bfd_byte len;
 307   unsigned char temp[NLM_TARGET_LONG_SIZE];
 308
 309   bfd_put_32 (abfd, count, temp);
 310   if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd) != sizeof (temp))
 311     return FALSE;
 312
 313   len = strlen (sym->name);
 314   if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
 315        != sizeof (bfd_byte))
 316       || bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
 317     return FALSE;
 318
 319   for (i = 0; i < count; i++)
 320     if (! nlm_sparc_write_reloc (abfd, relocs[i].sec, relocs[i].rel))
 321       return FALSE;
 322
 323   return TRUE;
 324 }
 325
 326 static bfd_boolean
 327 nlm_sparc_write_export (bfd * abfd, asymbol * sym, bfd_vma value)
 328 {
 329   bfd_byte len;
 330   bfd_byte temp[4];
 331
 332 #ifdef DEBUG
 333   fprintf (stderr, "%s: <%x, %d, %s>\n",
 334            __FUNCTION__, value, strlen (sym->name), sym->name);
 335 #endif
 336   bfd_put_32 (abfd, value, temp);
 337   len = strlen (sym->name);
 338
 339   if (bfd_bwrite (temp, (bfd_size_type) 4, abfd) != 4
 340       || bfd_bwrite (&len, (bfd_size_type) 1, abfd) != 1
 341       || bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
 342     return FALSE;
 343
 344   return TRUE;
 345 }
 346
 347 #undef nlm_swap_fixed_header_in
 348 #undef nlm_swap_fixed_header_out
 349
 350 #include "nlmswap.h"
 351
 352 static const struct nlm_backend_data nlm32_sparc_backend =
 353 {
 354   "NetWare SPARC Module   \032",
 355   sizeof (Nlm32_sparc_External_Fixed_Header),
 356   0,    /* Optional_prefix_size.  */
 357   bfd_arch_sparc,
 358   0,
 359   FALSE,
 360   0,    /* Backend_object_p.  */
 361   0,    /* Write_prefix_func.  */
 362   nlm_sparc_read_reloc,
 363   nlm_sparc_mangle_relocs,
 364   nlm_sparc_read_import,
 365   nlm_sparc_write_import,
 366   0,    /* Set_public_section.  */
 367   0,    /* Get_public_offset.  */
 368   nlm_swap_fixed_header_in,
 369   nlm_swap_fixed_header_out,
 370   nlm_sparc_write_external,
 371   nlm_sparc_write_export
 372 };
 373
 374 #define TARGET_BIG_NAME         "nlm32-sparc"
 375 #define TARGET_BIG_SYM          nlmNAME (sparc_vec)
 376 #define TARGET_BACKEND_DATA     & nlm32_sparc_backend
 377
 378 #include "nlm-target.h"