home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / gnu / gdb-4.12.tar.gz / gdb-4.12.tar / gdb-4.12 / bfd / nlm32-sparc.c < prev    next >
C/C++ Source or Header  |  1994-02-03  |  12KB  |  402 lines
  1. /* Support for 32-bit SPARC NLM (NetWare Loadable Module)
  2.    Copyright (C) 1993 Free Software Foundation, Inc.
  3.  
  4. This file is part of BFD, the Binary File Descriptor library.
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include "bfd.h"
  21. #include "sysdep.h"
  22. #include "libbfd.h"
  23.  
  24. #define ARCH_SIZE 32
  25.  
  26. #include "nlm/sparc32-ext.h"
  27. #define Nlm_External_Fixed_Header    Nlm32_sparc_External_Fixed_Header
  28.  
  29. #include "libnlm.h"
  30.  
  31. static boolean nlm_sparc_read_reloc
  32.   PARAMS ((bfd *, nlmNAME(symbol_type) *, asection **, arelent *));
  33. static boolean nlm_sparc_write_reloc
  34.   PARAMS ((bfd *, asection *, arelent *));
  35. static boolean nlm_sparc_mangle_relocs
  36.   PARAMS ((bfd *, asection *, PTR, bfd_vma, bfd_size_type));
  37. static boolean nlm_sparc_read_import
  38.   PARAMS ((bfd *, nlmNAME(symbol_type) *));
  39. static boolean nlm_sparc_write_import
  40.   PARAMS ((bfd *, asection *, arelent *));
  41. static boolean nlm_sparc_write_external
  42.   PARAMS ((bfd *, bfd_size_type, asymbol *, struct reloc_and_sec *));
  43.  
  44. enum reloc_type
  45.   {
  46.     R_SPARC_NONE = 0,
  47.     R_SPARC_8,        R_SPARC_16,        R_SPARC_32, 
  48.     R_SPARC_DISP8,    R_SPARC_DISP16,        R_SPARC_DISP32, 
  49.     R_SPARC_WDISP30,    R_SPARC_WDISP22,
  50.     R_SPARC_HI22,    R_SPARC_22,
  51.     R_SPARC_13,        R_SPARC_LO10,
  52.     R_SPARC_GOT10,    R_SPARC_GOT13,        R_SPARC_GOT22,
  53.     R_SPARC_PC10,    R_SPARC_PC22,
  54.     R_SPARC_WPLT30,
  55.     R_SPARC_COPY,
  56.     R_SPARC_GLOB_DAT,    R_SPARC_JMP_SLOT,
  57.     R_SPARC_RELATIVE,
  58.     R_SPARC_UA32,
  59.     R_SPARC_max
  60.   };
  61.  
  62. #if 0
  63. static CONST char *CONST reloc_type_names[] =
  64. {
  65.   "R_SPARC_NONE",
  66.   "R_SPARC_8",        "R_SPARC_16",        "R_SPARC_32",
  67.   "R_SPARC_DISP8",    "R_SPARC_DISP16",    "R_SPARC_DISP32",
  68.   "R_SPARC_WDISP30",    "R_SPARC_WDISP22",
  69.   "R_SPARC_HI22",    "R_SPARC_22",
  70.   "R_SPARC_13",        "R_SPARC_LO10",
  71.   "R_SPARC_GOT10",    "R_SPARC_GOT13",    "R_SPARC_GOT22",
  72.   "R_SPARC_PC10",    "R_SPARC_PC22",
  73.   "R_SPARC_WPLT30",
  74.   "R_SPARC_COPY",
  75.   "R_SPARC_GLOB_DAT",    "R_SPARC_JMP_SLOT",
  76.   "R_SPARC_RELATIVE",
  77.   "R_SPARC_UA32",
  78. };
  79. #endif
  80.  
  81. static reloc_howto_type nlm32_sparc_howto_table[] = 
  82. {
  83.   HOWTO(R_SPARC_NONE,    0,0, 0,false,0,complain_overflow_dont,    0,"R_SPARC_NONE",    false,0,0x00000000,true),
  84.   HOWTO(R_SPARC_8,       0,0, 8,false,0,complain_overflow_bitfield,0,"R_SPARC_8",       false,0,0x000000ff,true),
  85.   HOWTO(R_SPARC_16,      0,1,16,false,0,complain_overflow_bitfield,0,"R_SPARC_16",      false,0,0x0000ffff,true),
  86.   HOWTO(R_SPARC_32,      0,2,32,false,0,complain_overflow_bitfield,0,"R_SPARC_32",      false,0,0xffffffff,true),
  87.   HOWTO(R_SPARC_DISP8,   0,0, 8,true, 0,complain_overflow_signed,  0,"R_SPARC_DISP8",   false,0,0x000000ff,true),
  88.   HOWTO(R_SPARC_DISP16,  0,1,16,true, 0,complain_overflow_signed,  0,"R_SPARC_DISP16",  false,0,0x0000ffff,true),
  89.   HOWTO(R_SPARC_DISP32,  0,2,32,true, 0,complain_overflow_signed,  0,"R_SPARC_DISP32",  false,0,0x00ffffff,true),
  90.   HOWTO(R_SPARC_WDISP30, 2,2,30,true, 0,complain_overflow_signed,  0,"R_SPARC_WDISP30", false,0,0x3fffffff,true),
  91.   HOWTO(R_SPARC_WDISP22, 2,2,22,true, 0,complain_overflow_signed,  0,"R_SPARC_WDISP22", false,0,0x003fffff,true),
  92.   HOWTO(R_SPARC_HI22,   10,2,22,false,0,complain_overflow_dont,    0,"R_SPARC_HI22",    false,0,0x003fffff,true),
  93.   HOWTO(R_SPARC_22,      0,2,22,false,0,complain_overflow_bitfield,0,"R_SPARC_22",      false,0,0x003fffff,true),
  94.   HOWTO(R_SPARC_13,      0,2,13,false,0,complain_overflow_bitfield,0,"R_SPARC_13",      false,0,0x00001fff,true),
  95.   HOWTO(R_SPARC_LO10,    0,2,10,false,0,complain_overflow_dont,    0,"R_SPARC_LO10",    false,0,0x000003ff,true),
  96.   HOWTO(R_SPARC_GOT10,   0,2,10,false,0,complain_overflow_bitfield,0,"R_SPARC_GOT10",   false,0,0x000003ff,true),
  97.   HOWTO(R_SPARC_GOT13,   0,2,13,false,0,complain_overflow_bitfield,0,"R_SPARC_GOT13",   false,0,0x00001fff,true),
  98.   HOWTO(R_SPARC_GOT22,  10,2,22,false,0,complain_overflow_bitfield,0,"R_SPARC_GOT22",   false,0,0x003fffff,true),
  99.   HOWTO(R_SPARC_PC10,    0,2,10,false,0,complain_overflow_bitfield,0,"R_SPARC_PC10",    false,0,0x000003ff,true),
  100.   HOWTO(R_SPARC_PC22,    0,2,22,false,0,complain_overflow_bitfield,0,"R_SPARC_PC22",    false,0,0x003fffff,true),
  101.   HOWTO(R_SPARC_WPLT30,  0,0,00,false,0,complain_overflow_dont,    0,"R_SPARC_WPLT30",  false,0,0x00000000,true),
  102.   HOWTO(R_SPARC_COPY,    0,0,00,false,0,complain_overflow_dont,    0,"R_SPARC_COPY",    false,0,0x00000000,true),
  103.   HOWTO(R_SPARC_GLOB_DAT,0,0,00,false,0,complain_overflow_dont,    0,"R_SPARC_GLOB_DAT",false,0,0x00000000,true),
  104.   HOWTO(R_SPARC_JMP_SLOT,0,0,00,false,0,complain_overflow_dont,    0,"R_SPARC_JMP_SLOT",false,0,0x00000000,true),
  105.   HOWTO(R_SPARC_RELATIVE,0,0,00,false,0,complain_overflow_dont,    0,"R_SPARC_RELATIVE",false,0,0x00000000,true),
  106.   HOWTO(R_SPARC_UA32,    0,0,00,false,0,complain_overflow_dont,    0,"R_SPARC_UA32",    false,0,0x00000000,true),
  107. };
  108.  
  109. /* Read a NetWare sparc reloc.  */
  110.  
  111. struct nlm32_sparc_reloc_ext {
  112.   unsigned char offset[4];
  113.   unsigned char addend[4];
  114.   unsigned char type[1];
  115.   unsigned char pad1[3];
  116. };
  117.  
  118. static boolean
  119. nlm_sparc_read_reloc (abfd, sym, secp, rel)
  120.      bfd *abfd;
  121.      nlmNAME(symbol_type) *sym;
  122.      asection **secp;
  123.      arelent *rel;
  124. {
  125.   bfd_byte temp[4];
  126.   bfd_vma val, addend;
  127.   const char *name;
  128.   int index;
  129.   unsigned int type;
  130.   struct nlm32_sparc_reloc_ext tmp_reloc;
  131.  
  132.   if (bfd_read (&tmp_reloc, 12, 1, abfd) != 12) {
  133.     bfd_error = system_call_error;
  134.     return false;
  135.   }
  136.  
  137.   *secp = bfd_get_section_by_name (abfd, NLM_CODE_NAME);
  138.  
  139.   val = bfd_get_32 (abfd, tmp_reloc.offset);
  140.   addend = bfd_get_32 (abfd, tmp_reloc.addend);
  141.   type = bfd_get_8 (abfd, tmp_reloc.type);
  142.  
  143.   rel->address = val;
  144.   rel->addend = addend;
  145.   rel->howto = NULL;
  146.  
  147.   for (index = 0;
  148.        index < sizeof(nlm32_sparc_howto_table) / sizeof(reloc_howto_type);
  149.        index++)
  150.     if (nlm32_sparc_howto_table[index].type == type) {
  151.       rel->howto = &nlm32_sparc_howto_table[index];
  152.       break;
  153.     }
  154.  
  155. #ifdef DEBUG
  156.   fprintf (stderr, "%s:  address = %08lx, addend = %08lx, type = %d, howto = %08lx\n",
  157.        __FILE__, rel->address, rel->addend, type, rel->howto);
  158. #endif
  159.   return true;
  160.  
  161. }
  162.  
  163. /* Write a NetWare sparc reloc.  */
  164.  
  165. static boolean
  166. nlm_sparc_write_reloc (abfd, sec, rel)
  167.      bfd *abfd;
  168.      asection *sec;
  169.      arelent *rel;
  170. {
  171.   bfd_vma val;
  172.   struct nlm32_sparc_reloc_ext tmp_reloc = {0};
  173.   int index;
  174.   int type = -1;
  175.   reloc_howto_type *tmp;
  176.  
  177.   
  178.   for (index = 0;
  179.        index < sizeof (nlm32_sparc_howto_table) / sizeof(reloc_howto_type);
  180.        index++) {
  181.     tmp = &nlm32_sparc_howto_table[index];
  182.  
  183.     if (tmp->rightshift == rel->howto->rightshift
  184.     && tmp->size == rel->howto->size
  185.     && tmp->bitsize == rel->howto->bitsize
  186.     && tmp->pc_relative == rel->howto->pc_relative
  187.     && tmp->bitpos == rel->howto->bitpos
  188.     && tmp->src_mask == rel->howto->src_mask
  189.     && tmp->dst_mask == rel->howto->dst_mask) {
  190.       type = tmp->type;
  191.       break;
  192.     }
  193.   }
  194.   if (type == -1)
  195.     abort();
  196.  
  197.   /*
  198.    * Netware wants a list of relocs for each address.
  199.    * Format is:
  200.    *    long    offset
  201.    *    long    addend
  202.    *    char    type
  203.    * That should be it.
  204.    */
  205.  
  206.   /* The value we write out is the offset into the appropriate
  207.      segment.  This offset is the section vma, adjusted by the vma of
  208.      the lowest section in that segment, plus the address of the
  209.      relocation.  */
  210.   val = bfd_get_section_vma (abfd, sec) + rel->address;
  211.  
  212. #ifdef DEBUG
  213.   fprintf (stderr, "%s:  val = %08lx, addend = %08lx, type = %d\n",
  214.        __FILE__, val, rel->addend, rel->howto->type);
  215. #endif
  216.   bfd_put_32 (abfd, val, tmp_reloc.offset);
  217.   bfd_put_32 (abfd, rel->addend, tmp_reloc.addend);
  218.   bfd_put_8 (abfd, (short)(rel->howto->type), tmp_reloc.type);
  219.  
  220.   if (bfd_write (&tmp_reloc, 12, 1, abfd) != 12)
  221.     {
  222.       abort();
  223.     }
  224.  
  225.   return true;
  226. }
  227.  
  228. /* Mangle relocs for SPARC NetWare.  We can just use the standard
  229.    SPARC relocs.  */
  230.  
  231. static boolean
  232. nlm_sparc_mangle_relocs (abfd, sec, data, offset, count)
  233.      bfd *abfd;
  234.      asection *sec;
  235.      PTR data;
  236.      bfd_vma offset;
  237.      bfd_size_type count;
  238. {
  239.   return true;
  240. }
  241.  
  242. /* Read a NetWare sparc import record */
  243. static boolean
  244. nlm_sparc_read_import (abfd, sym)
  245.      bfd *abfd;
  246.      nlmNAME(symbol_type) *sym;
  247. {
  248.   struct nlm_relent *nlm_relocs;    /* relocation records for symbol */
  249.   bfd_size_type rcount;            /* number of relocs */
  250.   bfd_byte temp[NLM_TARGET_LONG_SIZE];    /* temporary 32-bit value */
  251.   unsigned char symlength;        /* length of symbol name */
  252.   
  253.   /*
  254.    * First, read in the number of relocation
  255.    * entries for this symbol
  256.    */
  257.   if (bfd_read ((PTR) temp, 4, 1, abfd)
  258.       != 4)
  259.     {
  260.       bfd_error = system_call_error;
  261.       return (false);
  262.     }
  263.   
  264.   rcount = bfd_get_32 (abfd, temp);
  265.   
  266.   /*
  267.    * Next, read in the length of the symbol
  268.    */
  269.   
  270.   if (bfd_read ((PTR) &symlength, sizeof (symlength), 1, abfd)
  271.       != sizeof (symlength))
  272.     {
  273.       bfd_error = system_call_error;
  274.       return (false);
  275.     }
  276.   sym -> symbol.the_bfd = abfd;
  277.   sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
  278.   
  279.   /*
  280.    * Then read in the symbol
  281.    */
  282.   
  283.   if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
  284.       != symlength)
  285.     {
  286.       bfd_error = system_call_error;
  287.       return (false);
  288.     }
  289.   sym -> symbol.flags = 0;
  290.   sym -> symbol.value = 0;
  291.   sym -> symbol.section = &bfd_und_section;
  292.   
  293.   /*
  294.    * Next, start reading in the relocs.
  295.    */
  296.   
  297.   nlm_relocs = ((struct nlm_relent *)
  298.         bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
  299.   sym -> relocs = nlm_relocs;
  300.   sym -> rcnt = 0;
  301.   while (sym -> rcnt < rcount)
  302.     {
  303.       asection *section;
  304.       
  305.       if (nlm_sparc_read_reloc (abfd, sym, §ion,
  306.                   &nlm_relocs -> reloc)
  307.       == false)
  308.     return false;
  309.       nlm_relocs -> section = section;
  310.       nlm_relocs++;
  311.       sym -> rcnt++;
  312.     }
  313.   return true;
  314. }
  315.  
  316. static boolean
  317. nlm_sparc_write_import (abfd, sec, rel)
  318.      bfd *abfd;
  319.      asection *sec;
  320.      arelent *rel;
  321. {
  322.   char temp[4];
  323.  
  324.   bfd_put_32 (abfd, (*rel->sym_ptr_ptr)->value, temp);
  325.   bfd_write ((PTR)temp, 4, 1, abfd);
  326.   bfd_put_32 (abfd, 1, temp);
  327.   bfd_write ((PTR)temp, 4, 1, abfd);
  328.   if (nlm_sparc_write_reloc (abfd, sec, rel) == false)
  329.     return false;
  330.   return true;
  331. }
  332.  
  333. /* Write out an external reference.  */
  334.  
  335. static boolean
  336. nlm_sparc_write_external (abfd, count, sym, relocs)
  337.      bfd *abfd;
  338.      bfd_size_type count;
  339.      asymbol *sym;
  340.      struct reloc_and_sec *relocs;
  341. {
  342.   int i;
  343.   bfd_byte len;
  344.   unsigned char temp[NLM_TARGET_LONG_SIZE];
  345.  
  346.   bfd_put_32 (abfd, count, temp);
  347.   if (bfd_write (temp, sizeof(temp), 1, abfd) != sizeof (temp))
  348.     {
  349.       bfd_error = system_call_error;
  350.       return false;
  351.     }
  352.  
  353.   len = strlen (sym->name);
  354.   if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd) != sizeof(bfd_byte))
  355.       || bfd_write (sym->name, len, 1, abfd) != len)
  356.     {
  357.       bfd_error = system_call_error;
  358.       return false;
  359.     }
  360.  
  361.   for (i = 0; i < count; i++)
  362.     {
  363.       if (nlm_sparc_write_reloc (abfd, relocs[i].sec,
  364.                  relocs[i].rel) == false)
  365.     return false;
  366.     }
  367.  
  368.   return true;
  369. }
  370.  
  371. #undef nlm_swap_fixed_header_in
  372. #undef nlm_swap_fixed_header_out
  373.  
  374. #include "nlmswap.h"
  375.  
  376. static const struct nlm_backend_data nlm32_sparc_backend =
  377. {
  378.   "NetWare SPARC Module   \032",
  379.   sizeof (Nlm32_sparc_External_Fixed_Header),
  380.   0,    /* optional_prefix_size */
  381.   bfd_arch_sparc,
  382.   0,
  383.   false,
  384.   0,    /* backend_object_p */
  385.   0,    /* write_prefix_func */
  386.   nlm_sparc_read_reloc,
  387.   nlm_sparc_mangle_relocs,
  388.   nlm_sparc_read_import,
  389.   nlm_sparc_write_import,
  390.   0,    /* set_public_section */
  391.   0,    /* get_public_offset */
  392.   nlm_swap_fixed_header_in,
  393.   nlm_swap_fixed_header_out,
  394.   nlm_sparc_write_external,
  395. };
  396.  
  397. #define TARGET_BIG_NAME        "nlm32-sparc"
  398. #define TARGET_BIG_SYM        nlmNAME(sparc_vec)
  399. #define TARGET_BACKEND_DATA        &nlm32_sparc_backend
  400.  
  401. #include "nlm-target.h"
  402.