home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / gnu / djgpp / src / binutils.2 / bfd / hppa.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-30  |  26.3 KB  |  1,054 lines
  1. /* bfd back-end for HP PA-RISC SOM objects.
  2.    Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
  3.  
  4.    Contributed by the Center for Software Science at the
  5.    University of Utah (pa-gdb-bugs@cs.utah.edu).
  6.  
  7. This file is part of BFD, the Binary File Descriptor library.
  8.  
  9. This program is free software; you can redistribute it and/or modify
  10. it under the terms of the GNU General Public License as published by
  11. the Free Software Foundation; either version 2 of the License, or
  12. (at your option) any later version.
  13.  
  14. This program is distributed in the hope that it will be useful,
  15. but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. GNU General Public License for more details.
  18.  
  19. You should have received a copy of the GNU General Public License
  20. along with this program; if not, write to the Free Software
  21. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  22.  
  23. #include "bfd.h"
  24. #include "sysdep.h"
  25.  
  26. /* @@FIXME This is not a reasonable set of conditions to permit
  27.    cross-compilation, obviously.  It also isn't enough to support hppa-elf
  28.    targets either.  Can we eliminate the HPUX or BSD dependencies, or
  29.    at least get the conditionals more localized?  */
  30. #if defined (HOST_HPPAHPUX) || defined (HOST_HPPABSD)
  31.  
  32. #include "libbfd.h"
  33. #include "libhppa.h"
  34.  
  35. #include <stdio.h>
  36. #include <sys/types.h>
  37. #include <sys/param.h>
  38. #include <sys/dir.h>
  39. #include <signal.h>
  40. #include <machine/reg.h>
  41. #include <sys/user.h>           /* After a.out.h  */
  42. #include <sys/file.h>
  43. #include <errno.h>
  44.  
  45. /* Magic not defined in standard HP-UX header files until 8.0 */
  46.  
  47. #ifndef CPU_PA_RISC1_0
  48. #define CPU_PA_RISC1_0 0x20B
  49. #endif /* CPU_PA_RISC1_0 */
  50.  
  51. #ifndef CPU_PA_RISC1_1
  52. #define CPU_PA_RISC1_1 0x210
  53. #endif /* CPU_PA_RISC1_1 */
  54.  
  55. #ifndef _PA_RISC1_0_ID
  56. #define _PA_RISC1_0_ID CPU_PA_RISC1_0
  57. #endif /* _PA_RISC1_0_ID */
  58.  
  59. #ifndef _PA_RISC1_1_ID
  60. #define _PA_RISC1_1_ID CPU_PA_RISC1_1
  61. #endif /* _PA_RISC1_1_ID */
  62.  
  63. #ifndef _PA_RISC_MAXID
  64. #define _PA_RISC_MAXID    0x2FF
  65. #endif /* _PA_RISC_MAXID */
  66.  
  67. #ifndef _PA_RISC_ID
  68. #define _PA_RISC_ID(__m_num)        \
  69.     (((__m_num) == _PA_RISC1_0_ID) ||    \
  70.      ((__m_num) >= _PA_RISC1_1_ID && (__m_num) <= _PA_RISC_MAXID))
  71. #endif /* _PA_RISC_ID */
  72.  
  73. struct container {
  74.   struct header f;
  75.   struct som_exec_auxhdr e;
  76. };
  77.  
  78. static bfd_target *
  79. hppa_object_setup (abfd, file_hdrp, aux_hdrp)
  80.      bfd *abfd;
  81.      struct header *file_hdrp;
  82.      struct som_exec_auxhdr *aux_hdrp;
  83. {
  84.   struct container *rawptr;
  85.   struct header *f;
  86.   struct hppa_data_struct *rawptr1;
  87.   asection *text, *data, *bss;
  88.  
  89.   rawptr = (struct container *) bfd_zalloc (abfd, sizeof (struct container));
  90.   if (rawptr == NULL) {
  91.     bfd_error = no_memory;
  92.     return 0;
  93.   }
  94.  
  95.   rawptr1 = (struct hppa_data_struct *) bfd_zalloc (abfd, sizeof (struct hppa_data_struct));
  96.   if (rawptr1 == NULL) {
  97.     bfd_error = no_memory;
  98.     return 0;
  99.   }
  100.   
  101.   abfd->tdata.hppa_data = rawptr1;
  102.   obj_file_hdr (abfd) = &rawptr->f;
  103.   obj_aux_hdr (abfd) = &rawptr->e;
  104.   *obj_file_hdr (abfd) = *file_hdrp;
  105.   *obj_aux_hdr (abfd) = *aux_hdrp;
  106.  
  107.   /* Set the file flags */
  108.   abfd->flags = NO_FLAGS;
  109.   if (file_hdrp->entry_offset)
  110.     abfd->flags |= HAS_RELOC;
  111.   if (file_hdrp->symbol_total)
  112.     abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
  113.  
  114.   bfd_get_start_address (abfd) = aux_hdrp->exec_entry;
  115.  
  116.   obj_pa_symbols (abfd) = (hppa_symbol_type *)NULL;
  117.   bfd_get_symcount (abfd) = file_hdrp->symbol_total;
  118.  
  119.   bfd_default_set_arch_mach(abfd, bfd_arch_hppa, 0);
  120.  
  121.   /* create the sections.  This is raunchy, but bfd_close wants to reclaim
  122.      them */
  123.  
  124.   text = bfd_make_section(abfd, ".text");
  125.   data = bfd_make_section(abfd, ".data");
  126.   bss = bfd_make_section(abfd, ".bss");
  127.  
  128.   text->_raw_size = aux_hdrp->exec_tsize;
  129.   data->_raw_size = aux_hdrp->exec_dsize;
  130.   bss->_raw_size = aux_hdrp->exec_bsize;
  131.  
  132.   text->flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS);
  133.   data->flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS);
  134.   bss->flags = SEC_ALLOC;
  135.  
  136.   /* The virtual memory addresses of the sections */                    
  137.   text->vma = aux_hdrp->exec_tmem;                          
  138.   data->vma = aux_hdrp->exec_dmem;                          
  139.   bss->vma = aux_hdrp->exec_bfill;                           
  140.                                                                         
  141.   /* The file offsets of the sections */                                
  142.   text->filepos = aux_hdrp->exec_tfile;                      
  143.   data->filepos = aux_hdrp->exec_dfile;                      
  144.                                                                        
  145.   /* The file offsets of the relocation info */                         
  146.   text->rel_filepos = 0;                  
  147.   data->rel_filepos = 0;                  
  148.                                                                         
  149.   /* The file offsets of the string table and symbol table.  */         
  150.   obj_sym_filepos (abfd) = file_hdrp->symbol_location;                  
  151.   bfd_get_symcount (abfd) = file_hdrp->symbol_total;
  152.   obj_str_filepos (abfd) = file_hdrp->symbol_strings_location;           
  153.   obj_stringtab_size (abfd) = file_hdrp->symbol_strings_size;
  154.  
  155.   return abfd->xvec;
  156. }
  157.  
  158. /* Create a new BFD section for NAME.  If NAME already exists, then create a
  159.    new unique name, with NAME as the prefix.  This exists because SOM .o files
  160.    created by the native compiler can have a $CODE$ section for each
  161.    subroutine.
  162.  */
  163.  
  164. static asection *
  165. make_unique_section (abfd, name, num)
  166.      bfd *abfd;
  167.      CONST char *name;
  168.      int num;
  169. {
  170.   asection *sect;
  171.   char *newname;
  172.   char altname[100];
  173.  
  174.   sect = bfd_make_section (abfd, name);
  175.   while (!sect)
  176.     {
  177.       sprintf(altname, "%s-%d", name, num++);
  178.       sect = bfd_make_section (abfd, altname);
  179.     }
  180.  
  181.   newname = bfd_alloc (abfd, strlen(sect->name) + 1);
  182.   strcpy (newname, sect->name);
  183.  
  184.   sect->name = newname;
  185.   return sect;
  186. }
  187.  
  188. /* Convert all of the space and subspace info into BFD sections.  Each space
  189.    contains a number of subspaces, which in turn describe the mapping between
  190.    regions of the exec file, and the address space that the program runs in.
  191.    BFD sections which correspond to spaces will overlap the sections for the
  192.    associated subspaces.  */
  193.  
  194. static int
  195. setup_sections (abfd, file_hdr)
  196.      bfd *abfd;
  197.      struct header *file_hdr;
  198. {
  199.   char *space_strings;
  200.   int space_index;
  201.  
  202. /* First, read in space names */
  203.  
  204.   space_strings = alloca (file_hdr->space_strings_size);
  205.   if (!space_strings)
  206.     return 0;
  207.  
  208.   if (bfd_seek (abfd, file_hdr->space_strings_location, SEEK_SET) < 0)
  209.     return 0;
  210.   if (bfd_read (space_strings, 1, file_hdr->space_strings_size, abfd)
  211.       != file_hdr->space_strings_size)
  212.     return 0;
  213.  
  214.   /* Loop over all of the space dictionaries, building up sections */
  215.  
  216.   for (space_index = 0; space_index < file_hdr->space_total; space_index++)
  217.     {
  218.       struct space_dictionary_record space;
  219.       struct subspace_dictionary_record subspace;
  220.       int subspace_index, tmp;
  221.       asection *space_asect;
  222.  
  223.       /* Read the space dictionary element */
  224.       if (bfd_seek (abfd, file_hdr->space_location
  225.                    + space_index * sizeof space, SEEK_SET) < 0)
  226.     return 0;
  227.       if (bfd_read (&space, 1, sizeof space, abfd) != sizeof space)
  228.     return 0;
  229.  
  230.       /* Setup the space name string */
  231.       space.name.n_name = space.name.n_strx + space_strings;
  232.  
  233.       /* Make a section out of it */
  234.       space_asect = make_unique_section (abfd, space.name.n_name, space_index);
  235.       if (!space_asect)
  236.     return 0;
  237.  
  238.       /* Now, read in the first subspace for this space */
  239.       if (bfd_seek (abfd, file_hdr->subspace_location
  240.                + space.subspace_index * sizeof subspace,
  241.         SEEK_SET) < 0)
  242.     return 0;
  243.       if (bfd_read (&subspace, 1, sizeof subspace, abfd) != sizeof subspace)
  244.     return 0;
  245.       /* Seek back to the start of the subspaces for loop below */
  246.       if (bfd_seek (abfd, file_hdr->subspace_location
  247.                + space.subspace_index * sizeof subspace,
  248.         SEEK_SET) < 0)
  249.     return 0;
  250.  
  251.       /* Setup the section flags as appropriate (this is somewhat bogus, as
  252.      there isn't a clear mapping between what's in the space record, and
  253.      what BFD can describe here). */
  254.       if (space.is_loadable)
  255.     space_asect->flags |= SEC_ALLOC;
  256.       if (space.is_defined)
  257.     space_asect->flags |= SEC_LOAD;
  258.  
  259.       /* Setup the start address and file loc from the first subspace record */
  260.       space_asect->vma = subspace.subspace_start;
  261.       space_asect->filepos = subspace.file_loc_init_value;
  262.       space_asect->alignment_power = subspace.alignment;
  263.  
  264.       /* Loop over the rest of the subspaces, building up more sections */
  265.       for (subspace_index = 0; subspace_index < space.subspace_quantity;
  266.        subspace_index++)
  267.     {
  268.       asection *subspace_asect;
  269.  
  270.       /* Read in the next subspace */
  271.       if (bfd_read (&subspace, 1, sizeof subspace, abfd)
  272.           != sizeof subspace)
  273.         return 0;
  274.  
  275.       /* Setup the subspace name string */
  276.       subspace.name.n_name = subspace.name.n_strx + space_strings;
  277.  
  278.       /* Make a section out of this subspace */
  279.       subspace_asect = make_unique_section (abfd, subspace.name.n_name,
  280.                         space.subspace_index + subspace_index);
  281.  
  282.       if (!subspace_asect)
  283.         return 0;
  284.  
  285.       if (subspace.is_loadable)
  286.         subspace_asect->flags |= SEC_ALLOC | SEC_LOAD;
  287.       if (subspace.code_only)
  288.         subspace_asect->flags |= SEC_CODE;
  289.  
  290.       subspace_asect->vma = subspace.subspace_start;
  291.       subspace_asect->_cooked_size = subspace.subspace_length;
  292.       subspace_asect->_raw_size = subspace.initialization_length;
  293.       subspace_asect->alignment_power = subspace.alignment;
  294.       subspace_asect->filepos = subspace.file_loc_init_value;
  295.  
  296.     }
  297.       /* Setup the sizes for the space section based upon the info in the
  298.      last subspace of the space. */
  299.       space_asect->_cooked_size = (subspace.subspace_start - space_asect->vma)
  300.                   + subspace.subspace_length;
  301.       space_asect->_raw_size = (subspace.file_loc_init_value
  302.                 - space_asect->filepos)
  303.                    + subspace.initialization_length;
  304.     }
  305. }
  306.  
  307. static bfd_target *
  308. hppa_object_p (abfd)
  309.      bfd *abfd;
  310. {
  311.   struct header file_hdr;
  312.   struct som_exec_auxhdr aux_hdr;
  313.  
  314.   if (bfd_read ((PTR) &file_hdr, 1, FILE_HDR_SIZE, abfd) != FILE_HDR_SIZE)
  315.     return 0;
  316.  
  317.   if (!_PA_RISC_ID (file_hdr.system_id))
  318.     {
  319.       bfd_error = wrong_format;
  320.       return 0;
  321.     }
  322.  
  323.   switch (file_hdr.a_magic)
  324.     {
  325.     case RELOC_MAGIC:    /* I'm not really sure about all of these types... */
  326.     case EXEC_MAGIC:
  327.     case SHARE_MAGIC:
  328.     case DEMAND_MAGIC:
  329. #ifdef DL_MAGIC
  330.     case DL_MAGIC:
  331. #endif
  332. #ifdef SHL_MAGIC
  333.     case SHL_MAGIC:
  334. #endif
  335.       break;
  336.     default:
  337.       bfd_error = wrong_format;
  338.       return 0;
  339.     }
  340.  
  341.   if (file_hdr.version_id != VERSION_ID
  342.       && file_hdr.version_id != NEW_VERSION_ID)
  343.     {
  344.       bfd_error = wrong_format;
  345.       return 0;
  346.     }
  347.  
  348.   if (bfd_read ((PTR) &aux_hdr, 1, AUX_HDR_SIZE, abfd) != AUX_HDR_SIZE)
  349.     bfd_error = wrong_format;
  350.  
  351.   if (!setup_sections (abfd, &file_hdr))
  352.     return 0;
  353.  
  354.   return hppa_object_setup(abfd, &file_hdr, &aux_hdr);
  355. }
  356.  
  357. static boolean
  358. DEFUN(hppa_mkobject,(abfd),
  359.       bfd *abfd)
  360. { 
  361.   fprintf (stderr, "hppa_mkobject unimplemented\n");
  362.   fflush (stderr);
  363.   abort ();
  364.   return (false);
  365. }
  366.  
  367. boolean
  368. DEFUN(hppa_write_object_contents,(abfd),
  369.       bfd *abfd)
  370. {
  371.   fprintf (stderr, "hppa_write_object_contents unimplemented\n");
  372.   fflush (stderr);
  373.   abort ();
  374.   return (false);
  375. }
  376.  
  377. static unsigned int
  378. hppa_get_symtab_upper_bound (abfd)
  379.      bfd *abfd;
  380. {
  381.   fprintf (stderr, "hppa_get_symtab_upper_bound unimplemented\n");
  382.   fflush (stderr);
  383.   abort ();
  384.   return (0);
  385. }
  386.  
  387. static unsigned int
  388. hppa_get_reloc_upper_bound (abfd, asect)
  389.      bfd *abfd;
  390.      sec_ptr asect;
  391. {
  392.   fprintf (stderr, "hppa_get_reloc_upper_bound unimplemented\n");
  393.   fflush (stderr);
  394.   abort ();
  395.   return (0);
  396. }
  397.  
  398. static unsigned int
  399. hppa_canonicalize_reloc (abfd, section, relptr, symbols)
  400.      bfd *abfd;
  401.      sec_ptr section;
  402.      arelent **relptr;
  403.      asymbol **symbols;
  404. {
  405.   fprintf (stderr, "hppa_canonicalize_reloc unimplemented\n");
  406.   fflush (stderr);
  407.   abort ();
  408. }
  409.  
  410. extern bfd_target hppa_vec;
  411.  
  412. static unsigned int
  413. hppa_get_symtab (abfd, location)
  414.      bfd *abfd;
  415.      asymbol **location;
  416. {
  417.   fprintf (stderr, "hppa_get_symtab unimplemented\n");
  418.   fflush (stderr);
  419.   abort ();
  420.   return (0);
  421. }
  422.  
  423. static asymbol *
  424. hppa_make_empty_symbol (abfd)
  425.      bfd *abfd;
  426. {
  427.   hppa_symbol_type  *new =
  428.     (hppa_symbol_type *)bfd_zalloc (abfd, sizeof (hppa_symbol_type));
  429.   new->symbol.the_bfd = abfd;
  430.  
  431.   return &new->symbol;
  432. }
  433.  
  434. static void 
  435. hppa_print_symbol (ignore_abfd, afile,  symbol, how)
  436.      bfd *ignore_abfd;
  437.      PTR afile;
  438.      asymbol *symbol;
  439.      bfd_print_symbol_type how;
  440. {
  441.   fprintf (stderr, "hppa_print_symbol unimplemented\n");
  442.   fflush (stderr);
  443.   abort ();
  444. }
  445.  
  446. static boolean
  447. hppa_new_section_hook (abfd, newsect)
  448.      bfd *abfd;
  449.      asection *newsect;
  450. {
  451.   newsect->alignment_power = 3;
  452.  
  453.   /* We allow more than three sections internally */
  454.   return true;
  455. }
  456.  
  457. static boolean
  458. hppa_set_section_contents (abfd, section, location, offset, count)
  459.      bfd *abfd;
  460.      sec_ptr section;
  461.      PTR location;
  462.      file_ptr offset;
  463.      bfd_size_type count;
  464. {
  465.   fprintf (stderr, "hppa_set_section_contents unimplimented\n");
  466.   fflush (stderr);
  467.   abort();
  468.   return false;
  469. }
  470.  
  471. static boolean
  472. hppa_set_arch_mach (abfd, arch, machine)
  473.      bfd *abfd;
  474.      enum bfd_architecture arch;
  475.      unsigned long machine;
  476. {
  477.   fprintf (stderr, "hppa_set_arch_mach unimplemented\n");
  478.   fflush (stderr);
  479.   /* Allow any architecture to be supported by the hppa backend */
  480.   return  bfd_default_set_arch_mach(abfd, arch, machine);
  481. }
  482.  
  483. static boolean
  484. hppa_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
  485.             functionname_ptr, line_ptr)
  486.      bfd *abfd;
  487.      asection *section;
  488.      asymbol **symbols;
  489.      bfd_vma offset;
  490.      CONST char **filename_ptr;
  491.      CONST char **functionname_ptr;
  492.      unsigned int *line_ptr;
  493. {
  494.   fprintf (stderr, "hppa_find_nearest_line unimplemented\n");
  495.   fflush (stderr);
  496.   abort ();
  497.   return (false);
  498. }
  499.  
  500. static int
  501. hppa_sizeof_headers (abfd, reloc)
  502.       bfd *abfd;
  503.       boolean reloc;
  504. {
  505.   fprintf (stderr, "hppa_sizeof_headers unimplemented\n");
  506.   fflush (stderr);
  507.   abort ();
  508.   return (0);
  509. }
  510.  
  511. static asection *
  512. make_bfd_asection (abfd, name, flags, _raw_size, vma, alignment_power)
  513.      bfd *abfd;
  514.      CONST char *name;
  515.      flagword flags;
  516.      bfd_size_type _raw_size;
  517.      bfd_vma vma;
  518.      unsigned int alignment_power;
  519. {
  520.   asection *asect;
  521.  
  522.   asect = bfd_make_section (abfd, name);
  523.   if (!asect)
  524.     return NULL;
  525.  
  526.   asect->flags = flags;
  527.   asect->_raw_size = _raw_size;
  528.   asect->vma = vma;
  529.   asect->filepos = bfd_tell (abfd);
  530.   asect->alignment_power = alignment_power;
  531.  
  532.   return asect;
  533. }
  534.  
  535. #ifdef HOST_HPPAHPUX
  536. static bfd_target *
  537. hppa_core_file_p (abfd)
  538.      bfd *abfd;
  539. {
  540.   core_hdr (abfd) = bfd_zalloc (abfd, sizeof (struct hppa_core_struct));
  541.   if (!core_hdr (abfd))
  542.     return NULL;
  543.  
  544.   while (1)
  545.     {
  546.       int val;
  547.       struct corehead core_header;
  548.  
  549.       val = bfd_read ((void *)&core_header, 1, sizeof core_header, abfd);
  550.       if (val <= 0)
  551.     break;
  552.       switch (core_header.type)
  553.     {
  554.     case CORE_KERNEL:
  555.     case CORE_FORMAT:
  556.       bfd_seek (abfd, core_header.len, SEEK_CUR); /* Just skip this */
  557.       break;
  558.     case CORE_EXEC:
  559.       {
  560.         struct proc_exec proc_exec;
  561.         bfd_read ((void *)&proc_exec, 1, core_header.len, abfd);
  562.         strncpy (core_command (abfd), proc_exec.cmd, MAXCOMLEN + 1);
  563.       }
  564.       break;
  565.     case CORE_PROC:
  566.       {
  567.         struct proc_info proc_info;
  568.         core_regsec (abfd) = make_bfd_asection (abfd, ".reg",
  569.                             SEC_ALLOC+SEC_HAS_CONTENTS,
  570.                             core_header.len,
  571.                             (int)&proc_info - (int)&proc_info.hw_regs,
  572.                             2);
  573.         bfd_read (&proc_info, 1, core_header.len, abfd);
  574.         core_signal (abfd) = proc_info.sig;
  575.       }
  576.       if (!core_regsec (abfd))
  577.         return NULL;
  578.       break;
  579.     case CORE_DATA:
  580.       core_datasec (abfd) = make_bfd_asection (abfd, ".data",
  581.                            SEC_ALLOC+SEC_LOAD+SEC_HAS_CONTENTS,
  582.                            core_header.len,
  583.                            core_header.addr,
  584.                            2);
  585.       if (!core_datasec (abfd))
  586.         return NULL;
  587.       bfd_seek (abfd, core_header.len, SEEK_CUR);
  588.       break;
  589.     case CORE_STACK:
  590.       core_stacksec (abfd) = make_bfd_asection (abfd, ".stack",
  591.                             SEC_ALLOC+SEC_LOAD+SEC_HAS_CONTENTS,
  592.                             core_header.len,
  593.                             core_header.addr,
  594.                             2);
  595.       if (!core_stacksec (abfd))
  596.         return NULL;
  597.       bfd_seek (abfd, core_header.len, SEEK_CUR);
  598.       break;
  599.     default:
  600.       fprintf (stderr, "Unknown HPPA/HPUX core file section type %d\n",
  601.            core_header.type);
  602.       bfd_seek (abfd, core_header.len, SEEK_CUR);
  603.       break;
  604.     }
  605.     }
  606.  
  607.   /* OK, we believe you.  You're a core file (sure, sure).  */
  608.  
  609.   return abfd->xvec;
  610. }
  611.  
  612. static char *
  613. hppa_core_file_failing_command (abfd)
  614.      bfd *abfd;
  615. {
  616.   return core_command (abfd);
  617. }
  618.  
  619. /* ARGSUSED */
  620. static int
  621. hppa_core_file_failing_signal (abfd)
  622.      bfd *abfd;
  623. {
  624.   return core_signal (abfd);
  625. }
  626.  
  627. /* ARGSUSED */
  628. static boolean
  629. hppa_core_file_matches_executable_p  (core_bfd, exec_bfd)
  630.      bfd *core_bfd, *exec_bfd;
  631. {
  632.   return true;          /* FIXME, We have no way of telling at this point */
  633. }
  634.  
  635. /* Miscellaneous Support Functions -- Control Structures and Functions
  636.    for the PA.  */
  637.  
  638. unsigned int assemble_3(x)
  639.      unsigned int x;
  640. {
  641.   return ( ( (x & 1 ) << 2 ) | ( ( x & 6 ) >> 1 ) ) & 7; 
  642. }
  643.  
  644. void dis_assemble_3(x,r)
  645.      unsigned int x;
  646.      unsigned int *r;
  647. {
  648.   *r = ( ( (x & 4 ) >> 2 ) | ( ( x & 3 ) << 1 ) ) & 7;
  649. }
  650.  
  651. unsigned int assemble_12(x,y)
  652.      unsigned int x,y;
  653. {
  654.   return ( ( ( y & 1 ) << 11 ) | ( ( x & 1 ) << 10 ) | ( ( x & 0x7fe ) >> 1) ) & 0xfff;
  655. }
  656.  
  657. void dis_assemble_12(as12,x,y)
  658.      unsigned int as12;
  659.      unsigned int *x,*y;
  660. {
  661.   *y = ( as12 & 0x800 ) >> 11;
  662.   *x = ( ( as12 & 0x3ff ) << 1 ) | ( ( as12 & 0x400 ) >> 10 );
  663. }
  664.  
  665. unsigned long assemble_17(x,y,z)
  666.      unsigned int x,y,z;
  667. {
  668.   unsigned long temp;
  669.  
  670.   temp = ( ( z &    1 ) << 16 ) |
  671.      ( ( x & 0x1f ) << 11 ) |
  672.      ( ( y &    1 ) << 10 ) |
  673.       ( ( y & 0x7fe ) >> 1);
  674.   return temp & 0x1ffff;
  675. }
  676.  
  677. void dis_assemble_17(as17,x,y,z)
  678.      unsigned int as17;
  679.      unsigned int *x,*y,*z;
  680. {
  681.  
  682.   *z =     ( as17 & 0x10000 ) >> 16;
  683.   *x =     ( as17 & 0x0f800 ) >> 11;
  684.   *y = ( ( ( as17 & 0x00400 ) >> 10 ) | ( ( as17 & 0x3ff ) << 1 ) ) & 0x7ff;
  685. }
  686.  
  687. unsigned long assemble_21(x)
  688.      unsigned int x;
  689. {
  690.   unsigned long temp;
  691.  
  692.   temp = ( ( x &        1 ) << 20 ) |
  693.      ( ( x &    0xffe ) <<  8 ) |
  694.      ( ( x &   0xc000 ) >>  7 ) |
  695.      ( ( x & 0x1f0000 ) >> 14 ) |
  696.      ( ( x & 0x003000 ) >> 12 );
  697.   return temp & 0x1fffff;
  698. }
  699.  
  700. void dis_assemble_21(as21,x)
  701.      unsigned int as21,*x;
  702. {
  703.   unsigned long temp;
  704.  
  705.  
  706.   temp  = ( as21 & 0x100000 ) >> 20;
  707.   temp |= ( as21 & 0x0ffe00 ) >> 8;
  708.   temp |= ( as21 & 0x000180 ) << 7;
  709.   temp |= ( as21 & 0x00007c ) << 14;
  710.   temp |= ( as21 & 0x000003 ) << 12;
  711.   *x = temp;
  712. }
  713.  
  714. unsigned long sign_ext(x,len)
  715.      unsigned int x,len;
  716. {
  717.   unsigned int sign;
  718.   unsigned int result;
  719.   unsigned int len_ones;
  720.   int i;
  721.  
  722.   i = 0;
  723.   len_ones = 0;
  724.   while ( i < len ) {
  725.     len_ones = (len_ones << 1) | 1;
  726.     i++;
  727.   }
  728.  
  729.   sign = (x >> (len-1)) & 1;
  730.  
  731.   if ( sign )
  732.     result = ( ~0 ^ len_ones ) | ( len_ones & x );
  733.   else
  734.     result = len_ones & x;
  735.  
  736.   return result;
  737. }
  738.  
  739. static unsigned int ones(n)
  740.      int n;
  741. {
  742.   unsigned int len_ones;
  743.   int i;
  744.  
  745.   i = 0;
  746.   len_ones = 0;
  747.   while ( i < n ) {
  748.     len_ones = (len_ones << 1) | 1;
  749.     i++;
  750.   }
  751.  
  752.   return len_ones;
  753. }
  754.  
  755. void sign_unext(x,len,result)
  756.      unsigned int x,len;
  757.      unsigned int *result;
  758. {
  759.   unsigned int len_ones;
  760.  
  761.   len_ones = ones(len);
  762.  
  763.   *result = x & len_ones;
  764. }
  765.  
  766. unsigned long low_sign_ext(x,len)
  767.      unsigned int x,len;
  768. {
  769.   unsigned int temp1,temp2;
  770.   unsigned int len_ones;
  771.  
  772.   len_ones = ones(len);
  773.  
  774.   temp1 = ( x & 1 ) << (len-1);
  775.   temp2 = ( ( x & 0xfffffffe ) & len_ones ) >> 1;
  776.   return sign_ext( (temp1 | temp2),len);
  777. }
  778.  
  779. void low_sign_unext(x,len,result)
  780.      unsigned int x,len;
  781.      unsigned int *result;
  782. {
  783.   unsigned int temp;
  784.   unsigned int sign;
  785.   unsigned int rest;
  786.   unsigned int one_bit_at_len;
  787.   unsigned int len_ones;
  788.  
  789.   len_ones = ones(len);
  790.   one_bit_at_len = 1 << (len-1);
  791.  
  792.   sign_unext(x,len,&temp);
  793.   sign = temp & one_bit_at_len;
  794.   sign >>= (len-1);
  795.  
  796.   rest = temp & ( len_ones ^ one_bit_at_len );
  797.   rest <<= 1;
  798.  
  799.   *result = rest | sign;
  800. }
  801.  
  802. /* These work when 'y' is a power of two only. */
  803.  
  804. long
  805. round_down(x,y)
  806. long x,y;
  807. {
  808.     return x & ~(y-1);
  809. }
  810.  
  811. long
  812. round(x,y)
  813. long x,y;
  814. {
  815.     return (x + y/2) & ~(y-1);
  816. }
  817.  
  818. long
  819. round_up(x,y)
  820. long x,y;
  821. {
  822.     return x - (x | ~(y-1));
  823. }
  824.  
  825. /*    L(Symbol, Addend):    */
  826. /*        round_down (Symbol + Addend, 2048)    */
  827.  
  828. long
  829. L(Symbol, Addend)
  830. {
  831.     return (round_down(Symbol + Addend, 2048)) >> 11;
  832. }
  833.  
  834. /*    R(Symbol, Addend):    */
  835. /*        Symbol + Addend - round_down (Symbol + Addend, 2048)    */
  836.  
  837. long
  838. R(Symbol, Addend)
  839. {
  840.     return Symbol + Addend - round_down (Symbol + Addend, 2048);
  841. }
  842.  
  843. /*    LS(Symbol, Addend):    */
  844. /*        round (Symbol + Addend, 2048)    */
  845.  
  846. long
  847. LS(Symbol, Addend)
  848. {
  849.     return round (Symbol + Addend, 2048);
  850. }
  851.  
  852. /*    RS(Symbol, Addend):    */
  853. /*        Symbol + Addend - round (Symbol + Addend, 2048)    */
  854.  
  855. long
  856. RS(Symbol, Addend)
  857. {
  858.     return Symbol + Addend - round (Symbol + Addend, 2048);
  859. }
  860.  
  861. /*    LD(Symbol, Addend):    */
  862. /*        round_up (Symbol + Addend, 2048)    */
  863.  
  864. long
  865. LD(Symbol, Addend)
  866. {
  867.     return (round_up (Symbol + Addend, 2048)) >> 11;
  868. }
  869.  
  870. /*    RD(Symbol, Addend):    */
  871. /*        Symbol + Addend - round_up (Symbol + Addend, 2048)    */
  872.  
  873. long
  874. RD(Symbol, Addend)
  875. {
  876.     return Symbol + Addend - round_up (Symbol + Addend, 2048);
  877. }
  878.  
  879. /*    LR(Symbol, Addend):    */
  880. /*        round_down (Symbol, 2048) + round (Addend, 8192)    */
  881.  
  882. long
  883. LR(Symbol, Addend)
  884. {
  885.     return (round_down (Symbol, 2048) + round (Addend, 8192)) >> 11;
  886. }
  887.  
  888. /*    RR(Symbol, Addend):    */
  889. /*        Symbol - round_down (Symbol, 2048) +    */
  890. /*            Addend - round (Addend, 8192)    */
  891.  
  892. long
  893. RR(Symbol, Addend)
  894. {
  895.     return Symbol
  896.         - round_down (Symbol, 2048)
  897.             + Addend - round (Addend, 8192);
  898. }
  899.  
  900. unsigned long
  901. DEFUN(hppa_field_adjust, (value,constant_value,r_field),
  902.       unsigned long value AND
  903.       unsigned long constant_value AND
  904.       unsigned short r_field)
  905. {
  906.     unsigned long init_value = value;
  907.     value += constant_value;
  908.     switch (r_field) {
  909.     case e_fsel:        /* F  : no change                      */
  910.         break;
  911.  
  912.     case e_lssel:       /* LS : if (bit 21) then add 0x800
  913.                             arithmetic shift right 11 bits */
  914.         if ( value & 0x00000400 )
  915.             value += 0x800;
  916.         value = (value & 0xfffff800) >> 11;
  917.         BFD_ASSERT(value == LS(init_value,constant_value));
  918.         break;
  919.  
  920.     case e_rssel:       /* RS : Sign extend from bit 21        */
  921.         if ( value & 0x00000400 )
  922.             value |= 0xfffff800;
  923.         else
  924.             value &= 0x7ff;
  925.         BFD_ASSERT(value == RS(init_value,constant_value));
  926.         break;
  927.  
  928.     case e_lsel:        /* L  : Arithmetic shift right 11 bits */
  929.         value = (value & 0xfffff800) >> 11;
  930.         BFD_ASSERT(value == L(init_value,constant_value));
  931.         break;
  932.  
  933.     case e_rsel:        /* R  : Set bits 0-20 to zero          */
  934.         value = value & 0x7ff;
  935.         BFD_ASSERT(value == R(init_value,constant_value));
  936.         break;
  937.  
  938.     case e_ldsel:       /* LD : Add 0x800, arithmetic shift
  939.                             right 11 bits                  */
  940.         value += 0x800;
  941.         value = (value & 0xfffff800) >> 11;    
  942.         BFD_ASSERT(value == LD(init_value,constant_value));
  943.         break;
  944.  
  945.     case e_rdsel:       /* RD : Set bits 0-20 to one           */
  946.         value |= 0xfffff800;
  947.         BFD_ASSERT(value == RD(init_value,constant_value));
  948.         break;
  949.  
  950.     case e_lrsel:       /* LR : L with "rounded" constant      */
  951.         value = value + ((constant_value + 0x1000) & 0xffffe000);
  952.         value = (value & 0xfffff800) >> 11;
  953.         BFD_ASSERT(value == LR(init_value,constant_value));
  954.         break;
  955.  
  956.     case e_rrsel:       /* RR : R with "rounded" constant      */
  957.         value = value + ((constant_value + 0x1000) & 0xffffe000);
  958.         value = (value & 0x7ff) + constant_value - ((constant_value + 0x1000) & 0xffffe000);
  959.         BFD_ASSERT(value == RR(init_value,constant_value));
  960.         break;
  961.  
  962.     default:
  963.         fprintf(stderr,"Unrecognized field_selector 0x%02x\n", r_field);
  964.         break;
  965.   }
  966.   return value;
  967.     
  968. }
  969.  
  970. /* End of miscellaneous support functions. */
  971. #endif /* HOST_HPPAHPUX */
  972.  
  973. #ifdef HOST_HPPABSD
  974.   /* All the core file code for BSD needs to be rewritten cleanly.  For
  975.      now we do not support core files under BSD.  */
  976.  
  977. #define hppa_core_file_p _bfd_dummy_target
  978. #define hppa_core_file_failing_command _bfd_dummy_core_file_failing_command
  979. #define hppa_core_file_failing_signal _bfd_dummy_core_file_failing_signal
  980. #define hppa_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
  981. #endif /* HOST_HPPABSD */
  982.  
  983. #define hppa_bfd_debug_info_start        bfd_void
  984. #define hppa_bfd_debug_info_end          bfd_void
  985. #define hppa_bfd_debug_info_accumulate   (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
  986.  
  987. #define hppa_openr_next_archived_file    bfd_generic_openr_next_archived_file
  988. #define hppa_generic_stat_arch_elt       bfd_generic_stat_arch_elt
  989. #define hppa_slurp_armap                  bfd_false
  990. #define hppa_slurp_extended_name_table    _bfd_slurp_extended_name_table
  991. #define hppa_truncate_arname              (void (*)())bfd_nullvoidptr
  992. #define hppa_write_armap                  0
  993.  
  994. #define hppa_get_lineno                   (struct lineno_cache_entry *(*)())bfd_nullvoidptr
  995. #define    hppa_close_and_cleanup               bfd_generic_close_and_cleanup
  996. #define hppa_get_section_contents          bfd_generic_get_section_contents
  997.  
  998. #define hppa_bfd_get_relocated_section_contents \
  999.  bfd_generic_get_relocated_section_contents
  1000. #define hppa_bfd_relax_section bfd_generic_relax_section
  1001. #define hppa_bfd_seclet_link bfd_generic_seclet_link
  1002. #define hppa_bfd_reloc_type_lookup \
  1003.   ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
  1004. #define hppa_bfd_make_debug_symbol \
  1005.   ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
  1006.  
  1007. bfd_target hppa_vec =
  1008. {
  1009.   "hppa",            /* name */
  1010.   bfd_target_hppa_flavour,
  1011.   true,                /* target byte order */
  1012.   true,                /* target headers byte order */
  1013.   (HAS_RELOC | EXEC_P |        /* object flags */
  1014.    HAS_LINENO | HAS_DEBUG |
  1015.    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
  1016.   (SEC_CODE|SEC_DATA|SEC_ROM|SEC_HAS_CONTENTS
  1017.    |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
  1018.  
  1019.    /* leading_symbol_char: is the first char of a user symbol
  1020.       predictable, and if so what is it */
  1021.    0,
  1022.   ' ',                /* ar_pad_char */
  1023.   16,                /* ar_max_namelen */
  1024.     3,                /* minimum alignment */
  1025. _do_getb64, _do_getb_signed_64, _do_putb64,
  1026.     _do_getb32, _do_getb_signed_32, _do_putb32,
  1027.     _do_getb16, _do_getb_signed_16, _do_putb16, /* data */
  1028. _do_getb64, _do_getb_signed_64, _do_putb64,
  1029.     _do_getb32, _do_getb_signed_32, _do_putb32,
  1030.     _do_getb16, _do_getb_signed_16, _do_putb16, /* hdrs */
  1031.   { _bfd_dummy_target,
  1032.      hppa_object_p,        /* bfd_check_format */
  1033.      bfd_generic_archive_p,
  1034.      hppa_core_file_p,
  1035.      },
  1036.   {
  1037.     bfd_false,
  1038.     hppa_mkobject, 
  1039.     _bfd_generic_mkarchive,
  1040.     bfd_false
  1041.     },
  1042.   {
  1043.     bfd_false,
  1044.     hppa_write_object_contents,
  1045.     _bfd_write_archive_contents,
  1046.     bfd_false,
  1047.   },
  1048. #undef hppa
  1049.   JUMP_TABLE(hppa),
  1050.   (PTR) 0
  1051. };
  1052.  
  1053. #endif /* HOST_HPPAHPUX || HOST_HPPABSD */
  1054.