/* bfd back-end for HP PA-RISC SOM objects.
- Copyright (C) 1990-1991 Free Software Foundation, Inc.
+ Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
Contributed by the Center for Software Science at the
University of Utah (pa-gdb-bugs@cs.utah.edu).
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-#ifdef hp9000s800
-
#include "bfd.h"
#include "sysdep.h"
+
+/* @@FIXME This is not a reasonable set of conditions to permit
+ cross-compilation, obviously. It also isn't enough to support hppa-elf
+ targets either. Can we eliminate the HPUX or BSD dependencies, or
+ at least get the conditionals more localized? */
+#if defined (HOST_HPPAHPUX) || defined (HOST_HPPABSD)
+
#include "libbfd.h"
#include "libhppa.h"
-/* #include "aout/hppa.h" */
-
#include <stdio.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/dir.h>
#include <signal.h>
#include <machine/reg.h>
-#ifndef hpux
-#include <aout/hppa.h>
-#include <machine/pcb.h>
-#include <sys/time.h>
-#include <hpux/hpux.h>
-#define USRSTACK 0x68FF3000
-#else
-#include <sys/user.h> /* After a.out.h */
-#endif
+#include <sys/user.h> /* After a.out.h */
#include <sys/file.h>
#include <errno.h>
-
-struct container {
- struct header f;
- struct som_exec_auxhdr e;
-};
-#undef USIZE
-#undef UPAGES
+/* Magic not defined in standard HP-UX header files until 8.0 */
-#define USIZE 3
-#define UPAGES 7
+#ifndef CPU_PA_RISC1_0
+#define CPU_PA_RISC1_0 0x20B
+#endif /* CPU_PA_RISC1_0 */
-void
-fill_spaces(abfd, file_hdr, dbx_subspace, dbx_strings_subspace)
- bfd *abfd;
- struct header *file_hdr;
- struct subspace_dictionary_record *dbx_subspace, *dbx_strings_subspace;
-{
- char *space_strings = (char *) alloca (file_hdr->space_strings_size);
- int i;
- /* for millicode games. */
- struct space_dictionary_record space;
- struct subspace_dictionary_record subspace;
- int index;
- /* indices of subspace entries for $TEXT$ and $GDB_DEBUG$ */
- int text_index = 0, gdb_debug_index = 0;
-
- /* initialize in case we don't find any dbx symbols. */
- dbx_subspace->subspace_length = dbx_strings_subspace->subspace_length = 0;
- bfd_seek (abfd, file_hdr->space_strings_location, SEEK_SET);
- if (bfd_read ((PTR) space_strings, 1, file_hdr->space_strings_size, abfd)
- != file_hdr->space_strings_size)
- {
- bfd_error = wrong_format; /* space strings table corrupted. */
- return;
- }
- bfd_seek (abfd, file_hdr->space_location, SEEK_SET);
- for (i = 0; i < file_hdr->space_total; i++)
- {
- bfd_read ((PTR) &space, 1, sizeof(space), abfd);
- index = (file_hdr->subspace_location +
- (space.subspace_index * sizeof(subspace)));
- if (!strcmp (space_strings + space.name.n_strx, "$TEXT$"))
- text_index = index;
- else if (!strcmp (space_strings + space.name.n_strx, "$GDB_DEBUG$"))
- gdb_debug_index = index;
- }
- /* search out the beginning and end if millicode */
- bfd_seek (abfd, text_index, SEEK_SET);
- for (;;)
- {
- bfd_read ((PTR) &subspace, 1, sizeof(subspace), abfd);
- if (!strcmp (space_strings + subspace.name.n_strx, "$MILLICODE$"))
- {
- millicode_start = subspace.subspace_start;
- millicode_end = (millicode_start + subspace.subspace_length);
- break;
- }
- }
- /* read symbols subspace and strings subspace in possibly arbitrary
- order. */
- bfd_seek (abfd, gdb_debug_index, SEEK_SET);
- bfd_read ((PTR) &subspace, 1, sizeof(struct subspace_dictionary_record),
- abfd);
- if (!strcmp (space_strings + subspace.name.n_strx, "$GDB_STRINGS$"))
- {
- *dbx_strings_subspace = subspace;
- bfd_read ((PTR) dbx_subspace, 1,
- sizeof(struct subspace_dictionary_record), abfd);
- }
- else
- {
- *dbx_subspace = subspace;
- bfd_read ((PTR) dbx_strings_subspace, 1,
- sizeof(struct subspace_dictionary_record), abfd);
- }
-}
+#ifndef CPU_PA_RISC1_1
+#define CPU_PA_RISC1_1 0x210
+#endif /* CPU_PA_RISC1_1 */
+
+#ifndef _PA_RISC1_0_ID
+#define _PA_RISC1_0_ID CPU_PA_RISC1_0
+#endif /* _PA_RISC1_0_ID */
+
+#ifndef _PA_RISC1_1_ID
+#define _PA_RISC1_1_ID CPU_PA_RISC1_1
+#endif /* _PA_RISC1_1_ID */
+
+#ifndef _PA_RISC_MAXID
+#define _PA_RISC_MAXID 0x2FF
+#endif /* _PA_RISC_MAXID */
+
+#ifndef _PA_RISC_ID
+#define _PA_RISC_ID(__m_num) \
+ (((__m_num) == _PA_RISC1_0_ID) || \
+ ((__m_num) >= _PA_RISC1_1_ID && (__m_num) <= _PA_RISC_MAXID))
+#endif /* _PA_RISC_ID */
+
+struct container
+ {
+ struct header f;
+ struct som_exec_auxhdr e;
+ };
-bfd_target *
-DEFUN(hppa_object_setup,(abfd, file_hdrp, aux_hdrp, dbx_subspace,
- dbx_strings_subspace),
- bfd *abfd AND
- struct header *file_hdrp AND
- struct som_exec_auxhdr *aux_hdrp AND
- struct subspace_dictionary_record *dbx_subspace AND
- struct subspace_dictionary_record *dbx_strings_subspace)
+static bfd_target *
+hppa_object_setup (abfd, file_hdrp, aux_hdrp)
+ bfd *abfd;
+ struct header *file_hdrp;
+ struct som_exec_auxhdr *aux_hdrp;
{
struct container *rawptr;
struct header *f;
struct hppa_data_struct *rawptr1;
+ asection *text, *data, *bss;
rawptr = (struct container *) bfd_zalloc (abfd, sizeof (struct container));
- if (rawptr == NULL) {
- bfd_error = no_memory;
- return 0;
- }
+ if (rawptr == NULL)
+ {
+ bfd_error = no_memory;
+ return 0;
+ }
rawptr1 = (struct hppa_data_struct *) bfd_zalloc (abfd, sizeof (struct hppa_data_struct));
- if (rawptr1 == NULL) {
- bfd_error = no_memory;
- return 0;
- }
-
+ if (rawptr1 == NULL)
+ {
+ bfd_error = no_memory;
+ return 0;
+ }
+
abfd->tdata.hppa_data = rawptr1;
obj_file_hdr (abfd) = &rawptr->f;
obj_aux_hdr (abfd) = &rawptr->e;
bfd_get_start_address (abfd) = aux_hdrp->exec_entry;
- obj_hp_symbol_entry_size (abfd) = sizeof(struct symbol_dictionary_record);
- obj_dbx_symbol_entry_size (abfd) = 12;
-
- obj_pa_symbols (abfd) = (hppa_symbol_type *)NULL;
- obj_hp_sym_count (abfd) = file_hdrp->symbol_total;
- obj_dbx_sym_count (abfd) = dbx_subspace->subspace_length /
- obj_dbx_symbol_entry_size (abfd);
- bfd_get_symcount (abfd) = obj_hp_sym_count (abfd) + obj_dbx_sym_count (abfd);
+ obj_pa_symbols (abfd) = (hppa_symbol_type *) NULL;
+ bfd_get_symcount (abfd) = file_hdrp->symbol_total;
- bfd_default_set_arch_mach(abfd, bfd_arch_hppa, 0);
+ bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 0);
/* create the sections. This is raunchy, but bfd_close wants to reclaim
them */
- obj_textsec (abfd) = (asection *)NULL;
- obj_datasec (abfd) = (asection *)NULL;
- obj_bsssec (abfd) = (asection *)NULL;
- (void)bfd_make_section(abfd, ".text");
- (void)bfd_make_section(abfd, ".data");
- (void)bfd_make_section(abfd, ".bss");
-
- abfd->sections = obj_textsec (abfd);
- obj_textsec (abfd)->next = obj_datasec (abfd);
- obj_datasec (abfd)->next = obj_bsssec (abfd);
-
- obj_datasec (abfd)->_raw_size = aux_hdrp->exec_dsize;
- obj_bsssec (abfd)->_raw_size = aux_hdrp->exec_bsize;
- obj_textsec (abfd)->_raw_size = aux_hdrp->exec_tsize;
-
- obj_textsec (abfd)->flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS);
- obj_datasec (abfd)->flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS);
- obj_bsssec (abfd)->flags = SEC_ALLOC;
-
- /* The virtual memory addresses of the sections */
- obj_datasec (abfd)->vma = aux_hdrp->exec_dmem;
- obj_bsssec (abfd)->vma = aux_hdrp->exec_bfill;
- obj_textsec (abfd)->vma = aux_hdrp->exec_tmem;
-
- /* The file offsets of the sections */
- obj_textsec (abfd)->filepos = aux_hdrp->exec_tfile;
- obj_datasec (abfd)->filepos = aux_hdrp->exec_dfile;
-
- /* The file offsets of the relocation info */
- obj_textsec (abfd)->rel_filepos = 0;
- obj_datasec (abfd)->rel_filepos = 0;
-
- /* The file offsets of the string table and symbol table. */
- obj_hp_sym_filepos (abfd) = file_hdrp->symbol_location;
- obj_hp_str_filepos (abfd) = file_hdrp->symbol_strings_location;
- obj_dbx_sym_filepos (abfd) = dbx_subspace->file_loc_init_value;
- obj_dbx_str_filepos (abfd) = dbx_strings_subspace->file_loc_init_value;
- obj_hp_stringtab_size (abfd) = file_hdrp->symbol_strings_size;
- obj_dbx_stringtab_size (abfd) = dbx_strings_subspace->subspace_length;
+
+ text = bfd_make_section (abfd, ".text");
+ data = bfd_make_section (abfd, ".data");
+ bss = bfd_make_section (abfd, ".bss");
+
+ text->_raw_size = aux_hdrp->exec_tsize;
+ data->_raw_size = aux_hdrp->exec_dsize;
+ bss->_raw_size = aux_hdrp->exec_bsize;
+
+ text->flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS);
+ data->flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS);
+ bss->flags = SEC_ALLOC;
+
+ /* The virtual memory addresses of the sections */
+ text->vma = aux_hdrp->exec_tmem;
+ data->vma = aux_hdrp->exec_dmem;
+ bss->vma = aux_hdrp->exec_bfill;
+
+ /* The file offsets of the sections */
+ text->filepos = aux_hdrp->exec_tfile;
+ data->filepos = aux_hdrp->exec_dfile;
+
+ /* The file offsets of the relocation info */
+ text->rel_filepos = 0;
+ data->rel_filepos = 0;
+
+ /* The file offsets of the string table and symbol table. */
+ obj_sym_filepos (abfd) = file_hdrp->symbol_location;
+ bfd_get_symcount (abfd) = file_hdrp->symbol_total;
+ obj_str_filepos (abfd) = file_hdrp->symbol_strings_location;
+ obj_stringtab_size (abfd) = file_hdrp->symbol_strings_size;
return abfd->xvec;
}
-bfd_target *
-DEFUN(hppa_object_p,(abfd),
- bfd *abfd)
+/* Create a new BFD section for NAME. If NAME already exists, then create a
+ new unique name, with NAME as the prefix. This exists because SOM .o files
+ created by the native compiler can have a $CODE$ section for each
+ subroutine.
+ */
+
+static asection *
+make_unique_section (abfd, name, num)
+ bfd *abfd;
+ CONST char *name;
+ int num;
+{
+ asection *sect;
+ char *newname;
+ char altname[100];
+
+ sect = bfd_make_section (abfd, name);
+ while (!sect)
+ {
+ sprintf (altname, "%s-%d", name, num++);
+ sect = bfd_make_section (abfd, altname);
+ }
+
+ newname = bfd_alloc (abfd, strlen (sect->name) + 1);
+ strcpy (newname, sect->name);
+
+ sect->name = newname;
+ return sect;
+}
+
+/* Convert all of the space and subspace info into BFD sections. Each space
+ contains a number of subspaces, which in turn describe the mapping between
+ regions of the exec file, and the address space that the program runs in.
+ BFD sections which correspond to spaces will overlap the sections for the
+ associated subspaces. */
+
+static int
+setup_sections (abfd, file_hdr)
+ bfd *abfd;
+ struct header *file_hdr;
+{
+ char *space_strings;
+ int space_index;
+
+ /* First, read in space names */
+
+ space_strings = alloca (file_hdr->space_strings_size);
+ if (!space_strings)
+ return 0;
+
+ if (bfd_seek (abfd, file_hdr->space_strings_location, SEEK_SET) < 0)
+ return 0;
+ if (bfd_read (space_strings, 1, file_hdr->space_strings_size, abfd)
+ != file_hdr->space_strings_size)
+ return 0;
+
+ /* Loop over all of the space dictionaries, building up sections */
+
+ for (space_index = 0; space_index < file_hdr->space_total; space_index++)
+ {
+ struct space_dictionary_record space;
+ struct subspace_dictionary_record subspace;
+ int subspace_index, tmp;
+ asection *space_asect;
+
+ /* Read the space dictionary element */
+ if (bfd_seek (abfd, file_hdr->space_location
+ + space_index * sizeof space, SEEK_SET) < 0)
+ return 0;
+ if (bfd_read (&space, 1, sizeof space, abfd) != sizeof space)
+ return 0;
+
+ /* Setup the space name string */
+ space.name.n_name = space.name.n_strx + space_strings;
+
+ /* Make a section out of it */
+ space_asect = make_unique_section (abfd, space.name.n_name, space_index);
+ if (!space_asect)
+ return 0;
+
+ /* Now, read in the first subspace for this space */
+ if (bfd_seek (abfd, file_hdr->subspace_location
+ + space.subspace_index * sizeof subspace,
+ SEEK_SET) < 0)
+ return 0;
+ if (bfd_read (&subspace, 1, sizeof subspace, abfd) != sizeof subspace)
+ return 0;
+ /* Seek back to the start of the subspaces for loop below */
+ if (bfd_seek (abfd, file_hdr->subspace_location
+ + space.subspace_index * sizeof subspace,
+ SEEK_SET) < 0)
+ return 0;
+
+ /* Setup the section flags as appropriate (this is somewhat bogus, as
+ there isn't a clear mapping between what's in the space record, and
+ what BFD can describe here). */
+ if (space.is_loadable)
+ space_asect->flags |= SEC_ALLOC;
+ if (space.is_defined)
+ space_asect->flags |= SEC_LOAD;
+
+ /* Setup the start address and file loc from the first subspace record */
+ space_asect->vma = subspace.subspace_start;
+ space_asect->filepos = subspace.file_loc_init_value;
+ space_asect->alignment_power = subspace.alignment;
+
+ /* Loop over the rest of the subspaces, building up more sections */
+ for (subspace_index = 0; subspace_index < space.subspace_quantity;
+ subspace_index++)
+ {
+ asection *subspace_asect;
+
+ /* Read in the next subspace */
+ if (bfd_read (&subspace, 1, sizeof subspace, abfd)
+ != sizeof subspace)
+ return 0;
+
+ /* Setup the subspace name string */
+ subspace.name.n_name = subspace.name.n_strx + space_strings;
+
+ /* Make a section out of this subspace */
+ subspace_asect = make_unique_section (abfd, subspace.name.n_name,
+ space.subspace_index + subspace_index);
+
+ if (!subspace_asect)
+ return 0;
+
+ if (subspace.is_loadable)
+ subspace_asect->flags |= SEC_ALLOC | SEC_LOAD;
+ if (subspace.code_only)
+ subspace_asect->flags |= SEC_CODE;
+
+ subspace_asect->vma = subspace.subspace_start;
+ subspace_asect->_cooked_size = subspace.subspace_length;
+ subspace_asect->_raw_size = subspace.initialization_length;
+ subspace_asect->alignment_power = subspace.alignment;
+ subspace_asect->filepos = subspace.file_loc_init_value;
+
+ }
+ /* Setup the sizes for the space section based upon the info in the
+ last subspace of the space. */
+ space_asect->_cooked_size = (subspace.subspace_start - space_asect->vma)
+ + subspace.subspace_length;
+ space_asect->_raw_size = (subspace.file_loc_init_value
+ - space_asect->filepos)
+ + subspace.initialization_length;
+ }
+}
+
+static bfd_target *
+hppa_object_p (abfd)
+ bfd *abfd;
{
struct header file_hdr;
struct som_exec_auxhdr aux_hdr;
- struct subspace_dictionary_record dbx_subspace;
- struct subspace_dictionary_record dbx_strings_subspace;
- if (bfd_read ((PTR) &file_hdr, 1, FILE_HDR_SIZE, abfd) != FILE_HDR_SIZE)
+ if (bfd_read ((PTR) & file_hdr, 1, FILE_HDR_SIZE, abfd) != FILE_HDR_SIZE)
+ return 0;
+
+ if (!_PA_RISC_ID (file_hdr.system_id))
{
bfd_error = wrong_format;
return 0;
}
- if (bfd_read ((PTR) &aux_hdr, 1, AUX_HDR_SIZE, abfd) != AUX_HDR_SIZE)
+
+ switch (file_hdr.a_magic)
{
+ case RELOC_MAGIC: /* I'm not really sure about all of these types... */
+ case EXEC_MAGIC:
+ case SHARE_MAGIC:
+ case DEMAND_MAGIC:
+#ifdef DL_MAGIC
+ case DL_MAGIC:
+#endif
+#ifdef SHL_MAGIC
+ case SHL_MAGIC:
+#endif
+ break;
+ default:
bfd_error = wrong_format;
return 0;
}
-
- fill_spaces(abfd, &file_hdr, &dbx_subspace, &dbx_strings_subspace);
- return hppa_object_setup(abfd, &file_hdr, &aux_hdr, &dbx_subspace, &dbx_strings_subspace);
-}
+ if (file_hdr.version_id != VERSION_ID
+ && file_hdr.version_id != NEW_VERSION_ID)
+ {
+ bfd_error = wrong_format;
+ return 0;
+ }
+ if (bfd_read ((PTR) & aux_hdr, 1, AUX_HDR_SIZE, abfd) != AUX_HDR_SIZE)
+ bfd_error = wrong_format;
+
+ if (!setup_sections (abfd, &file_hdr))
+ return 0;
+
+ return hppa_object_setup (abfd, &file_hdr, &aux_hdr);
+}
static boolean
-DEFUN(hppa_mkobject,(abfd),
- bfd *abfd)
-{
+hppa_mkobject (abfd)
+ bfd *abfd;
+{
fprintf (stderr, "hppa_mkobject unimplemented\n");
fflush (stderr);
abort ();
}
boolean
-DEFUN(hppa_write_object_contents,(abfd),
- bfd *abfd)
+hppa_write_object_contents(abfd)
+ bfd *abfd;
{
fprintf (stderr, "hppa_write_object_contents unimplemented\n");
fflush (stderr);
return (false);
}
-
-
-unsigned int
-DEFUN(hppa_get_symtab_upper_bound,(abfd),
- bfd *abfd)
+static unsigned int
+hppa_get_symtab_upper_bound (abfd)
+ bfd *abfd;
{
fprintf (stderr, "hppa_get_symtab_upper_bound unimplemented\n");
fflush (stderr);
return (0);
}
-unsigned int
-DEFUN(hppa_get_reloc_upper_bound,(abfd, asect),
- bfd *abfd AND
- sec_ptr asect)
+static unsigned int
+hppa_get_reloc_upper_bound (abfd, asect)
+ bfd *abfd;
+ sec_ptr asect;
{
fprintf (stderr, "hppa_get_reloc_upper_bound unimplemented\n");
fflush (stderr);
return (0);
}
-unsigned int
-DEFUN(hppa_canonicalize_reloc,(abfd, section, relptr, symbols),
- bfd *abfd AND
- sec_ptr section AND
- arelent **relptr AND
- asymbol **symbols)
+static unsigned int
+hppa_canonicalize_reloc (abfd, section, relptr, symbols)
+ bfd *abfd;
+ sec_ptr section;
+ arelent **relptr;
+ asymbol **symbols;
{
fprintf (stderr, "hppa_canonicalize_reloc unimplemented\n");
fflush (stderr);
}
extern bfd_target hppa_vec;
-unsigned int
-DEFUN(hppa_get_symtab,(abfd, location),
- bfd *abfd AND
- asymbol **location)
+
+static unsigned int
+hppa_get_symtab (abfd, location)
+ bfd *abfd;
+ asymbol **location;
{
fprintf (stderr, "hppa_get_symtab unimplemented\n");
fflush (stderr);
return (0);
}
-asymbol *
-DEFUN(hppa_make_empty_symbol,(abfd),
- bfd *abfd)
+static asymbol *
+hppa_make_empty_symbol (abfd)
+ bfd *abfd;
{
- hppa_symbol_type *new =
- (hppa_symbol_type *)bfd_zalloc (abfd, sizeof (hppa_symbol_type));
+ hppa_symbol_type *new =
+ (hppa_symbol_type *) bfd_zalloc (abfd, sizeof (hppa_symbol_type));
new->symbol.the_bfd = abfd;
return &new->symbol;
}
-
-void
-DEFUN(hppa_print_symbol,(ignore_abfd, afile, symbol, how),
- bfd *ignore_abfd AND
- PTR afile AND
- asymbol *symbol AND
- bfd_print_symbol_type how)
+static void
+hppa_print_symbol (ignore_abfd, afile, symbol, how)
+ bfd *ignore_abfd;
+ PTR afile;
+ asymbol *symbol;
+ bfd_print_symbol_type how;
{
fprintf (stderr, "hppa_print_symbol unimplemented\n");
fflush (stderr);
abort ();
}
-
-
-boolean
-DEFUN(hppa_new_section_hook,(abfd, newsect),
- bfd *abfd AND
- asection *newsect)
+static boolean
+hppa_new_section_hook (abfd, newsect)
+ bfd *abfd;
+ asection *newsect;
{
- /* align to double at least */
newsect->alignment_power = 3;
- if (bfd_get_format (abfd) == bfd_object) {
- if (obj_textsec(abfd) == NULL && !strcmp(newsect->name, ".text")) {
- obj_textsec(abfd)= newsect;
- return true;
- }
-
- if (obj_datasec(abfd) == NULL && !strcmp(newsect->name, ".data")) {
- obj_datasec(abfd) = newsect;
- return true;
- }
-
- if (obj_bsssec(abfd) == NULL && !strcmp(newsect->name, ".bss")) {
- obj_bsssec(abfd) = newsect;
- return true;
- }
- }
-
/* We allow more than three sections internally */
return true;
}
-
-
-
-boolean
-DEFUN(hppa_set_section_contents,(abfd, section, location, offset, count),
- bfd *abfd AND
- sec_ptr section AND
- PTR location AND
- file_ptr offset AND
- bfd_size_type count)
+static boolean
+hppa_set_section_contents (abfd, section, location, offset, count)
+ bfd *abfd;
+ sec_ptr section;
+ PTR location;
+ file_ptr offset;
+ bfd_size_type count;
{
fprintf (stderr, "hppa_set_section_contents unimplimented\n");
fflush (stderr);
- abort();
+ abort ();
return false;
}
-
-boolean
-DEFUN(hppa_set_arch_mach,(abfd, arch, machine),
- bfd *abfd AND
- enum bfd_architecture arch AND
- unsigned long machine)
+static boolean
+hppa_set_arch_mach (abfd, arch, machine)
+ bfd *abfd;
+ enum bfd_architecture arch;
+ unsigned long machine;
{
fprintf (stderr, "hppa_set_arch_mach unimplemented\n");
fflush (stderr);
/* Allow any architecture to be supported by the hppa backend */
- return bfd_default_set_arch_mach(abfd, arch, machine);
+ return bfd_default_set_arch_mach (abfd, arch, machine);
}
-
static boolean
-DEFUN (hppa_find_nearest_line,(abfd,
- section,
- symbols,
- offset,
- filename_ptr,
- functionname_ptr,
- line_ptr),
- bfd *abfd AND
- asection *section AND
- asymbol **symbols AND
- bfd_vma offset AND
- CONST char **filename_ptr AND
- CONST char **functionname_ptr AND
- unsigned int *line_ptr)
+hppa_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
+ functionname_ptr, line_ptr)
+ bfd *abfd;
+ asection *section;
+ asymbol **symbols;
+ bfd_vma offset;
+ CONST char **filename_ptr;
+ CONST char **functionname_ptr;
+ unsigned int *line_ptr;
{
fprintf (stderr, "hppa_find_nearest_line unimplemented\n");
fflush (stderr);
}
static int
-DEFUN (hppa_sizeof_headers, (abfd, reloc),
- bfd *abfd AND
- boolean reloc)
+hppa_sizeof_headers (abfd, reloc)
+ bfd *abfd;
+ boolean reloc;
{
fprintf (stderr, "hppa_sizeof_headers unimplemented\n");
fflush (stderr);
return (0);
}
-#ifdef hpux
-#define hppa_core_file_p _bfd_dummy_target
-#else
-bfd_target *
+static asection *
+make_bfd_asection (abfd, name, flags, _raw_size, vma, alignment_power)
+ bfd *abfd;
+ CONST char *name;
+ flagword flags;
+ bfd_size_type _raw_size;
+ bfd_vma vma;
+ unsigned int alignment_power;
+{
+ asection *asect;
+
+ asect = bfd_make_section (abfd, name);
+ if (!asect)
+ return NULL;
+
+ asect->flags = flags;
+ asect->_raw_size = _raw_size;
+ asect->vma = vma;
+ asect->filepos = bfd_tell (abfd);
+ asect->alignment_power = alignment_power;
+
+ return asect;
+}
+
+#ifdef HOST_HPPAHPUX
+static bfd_target *
hppa_core_file_p (abfd)
bfd *abfd;
{
- int val;
- struct hpuxuser u;
- unsigned int reg_offset, fp_reg_offset;
- /* This struct is just for allocating two things with one zalloc, so
- they will be freed together, without violating alignment constraints. */
- struct core_user {
- struct hppa_core_struct coredata;
- struct hpuxuser u;
- } *rawptr;
-
- val = bfd_read ((void *)&u, 1, sizeof u, abfd);
- if (val != sizeof u)
- return 0; /* Too small to be a core file */
-
- /* Sanity check perhaps??? */
- if (u.u_dsize > 0x1000000) /* Remember, it's in pages... */
- return 0;
- if (u.u_ssize > 0x1000000)
- return 0;
- /* Check that the size claimed is no greater than the file size. FIXME. */
+ core_hdr (abfd) = bfd_zalloc (abfd, sizeof (struct hppa_core_struct));
+ if (!core_hdr (abfd))
+ return NULL;
- /* OK, we believe you. You're a core file (sure, sure). */
+ while (1)
+ {
+ int val;
+ struct corehead core_header;
+
+ val = bfd_read ((void *) &core_header, 1, sizeof core_header, abfd);
+ if (val <= 0)
+ break;
+ switch (core_header.type)
+ {
+ case CORE_KERNEL:
+ case CORE_FORMAT:
+ bfd_seek (abfd, core_header.len, SEEK_CUR); /* Just skip this */
+ break;
+ case CORE_EXEC:
+ {
+ struct proc_exec proc_exec;
+ bfd_read ((void *) &proc_exec, 1, core_header.len, abfd);
+ strncpy (core_command (abfd), proc_exec.cmd, MAXCOMLEN + 1);
+ }
+ break;
+ case CORE_PROC:
+ {
+ struct proc_info proc_info;
+ core_regsec (abfd) = make_bfd_asection (abfd, ".reg",
+ SEC_ALLOC + SEC_HAS_CONTENTS,
+ core_header.len,
+ (int) &proc_info - (int) &proc_info.hw_regs,
+ 2);
+ bfd_read (&proc_info, 1, core_header.len, abfd);
+ core_signal (abfd) = proc_info.sig;
+ }
+ if (!core_regsec (abfd))
+ return NULL;
+ break;
+ case CORE_DATA:
+ core_datasec (abfd) = make_bfd_asection (abfd, ".data",
+ SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
+ core_header.len,
+ core_header.addr,
+ 2);
+ if (!core_datasec (abfd))
+ return NULL;
+ bfd_seek (abfd, core_header.len, SEEK_CUR);
+ break;
+ case CORE_STACK:
+ core_stacksec (abfd) = make_bfd_asection (abfd, ".stack",
+ SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
+ core_header.len,
+ core_header.addr,
+ 2);
+ if (!core_stacksec (abfd))
+ return NULL;
+ bfd_seek (abfd, core_header.len, SEEK_CUR);
+ break;
+ default:
+ fprintf (stderr, "Unknown HPPA/HPUX core file section type %d\n",
+ core_header.type);
+ bfd_seek (abfd, core_header.len, SEEK_CUR);
+ break;
+ }
+ }
- /* Allocate both the upage and the struct core_data at once, so
- a single free() will free them both. */
- rawptr = (struct core_user *)bfd_zalloc (abfd, sizeof (struct core_user));
- if (rawptr == NULL) {
- bfd_error = no_memory;
- return 0;
- }
-
- abfd->tdata.hppa_core_data = &rawptr->coredata;
- core_upage (abfd) = &rawptr->u;
- *core_upage (abfd) = u; /* Save that upage! */
-
- /* Create the sections. This is raunchy, but bfd_close wants to free
- them separately. */
- core_stacksec (abfd) = (asection *) zalloc (sizeof (asection));
- if (core_stacksec (abfd) == NULL) {
-loser:
- bfd_error = no_memory;
- free ((void *)rawptr);
- return 0;
- }
- core_datasec (abfd) = (asection *) zalloc (sizeof (asection));
- if (core_datasec (abfd) == NULL) {
-loser1:
- free ((void *)core_stacksec (abfd));
- goto loser;
- }
- core_regsec (abfd) = (asection *) zalloc (sizeof (asection));
- if (core_regsec (abfd) == NULL) {
-loser2:
- free ((void *)core_datasec (abfd));
- goto loser1;
- }
-
-
- core_stacksec (abfd)->name = ".stack";
- core_datasec (abfd)->name = ".data";
- core_regsec (abfd)->name = ".reg";
-
- core_stacksec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
- core_datasec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
- core_regsec (abfd)->flags = SEC_ALLOC + SEC_HAS_CONTENTS;
-
- core_datasec (abfd)->_raw_size = NBPG * u.u_dsize;
- core_stacksec (abfd)->_raw_size = NBPG * u.u_ssize;
- core_regsec (abfd)->_raw_size = NBPG * UPAGES; /* Larger than sizeof struct u */
-
- core_datasec (abfd)->vma = u.hpuxu_exdata.somexec.a_Dmem;
- core_stacksec (abfd)->vma = USRSTACK; /* from sys/param */
- /* This is tricky. As the "register section", we give them the entire
- upage and stack. u.u_ar0 points to where "register 0" is stored.
- There are two tricks with this, though. One is that the rest of the
- registers might be at positive or negative (or both) displacements
- from *u_ar0. The other is that u_ar0 is sometimes an absolute address
- in kernel memory, and on other systems it is an offset from the beginning
- of the `struct user'.
-
- As a practical matter, we don't know where the registers actually are,
- so we have to pass the whole area to GDB. We encode the value of u_ar0
- by setting the .regs section up so that its virtual memory address
- 0 is at the place pointed to by u_ar0 (by setting the vma of the start
- of the section to -u_ar0). GDB uses this info to locate the regs,
- using minor trickery to get around the offset-or-absolute-addr problem. */
- core_regsec (abfd)->vma = 0 - NBPG * USIZE; /* -u_ar0 */
-
- core_datasec (abfd)->filepos = NBPG * UPAGES;
- core_stacksec (abfd)->filepos = (NBPG * UPAGES) + NBPG * u.u_dsize;
- core_regsec (abfd)->filepos = 0; /* Register segment is the upage */
-
- /* Align to word at least */
- core_stacksec (abfd)->alignment_power = 2;
- core_datasec (abfd)->alignment_power = 2;
- core_regsec (abfd)->alignment_power = 2;
-
- abfd->sections = core_stacksec (abfd);
- core_stacksec (abfd)->next = core_datasec (abfd);
- core_datasec (abfd)->next = core_regsec (abfd);
- abfd->section_count = 3;
+ /* OK, we believe you. You're a core file (sure, sure). */
return abfd->xvec;
}
-#endif
-#ifdef hpux
-#define hppa_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
-#else
-char *
+static char *
hppa_core_file_failing_command (abfd)
bfd *abfd;
{
-#ifndef NO_CORE_COMMAND
- if (*core_upage (abfd)->u_comm)
- return core_upage (abfd)->u_comm;
- else
-#endif
- return 0;
+ return core_command (abfd);
}
-#endif
/* ARGSUSED */
-int
-hppa_core_file_failing_signal (ignore_abfd)
- bfd *ignore_abfd;
+static int
+hppa_core_file_failing_signal (abfd)
+ bfd *abfd;
{
- return -1; /* FIXME, where is it? */
+ return core_signal (abfd);
}
/* ARGSUSED */
-boolean
-hppa_core_file_matches_executable_p (core_bfd, exec_bfd)
+static boolean
+hppa_core_file_matches_executable_p (core_bfd, exec_bfd)
bfd *core_bfd, *exec_bfd;
{
- return true; /* FIXME, We have no way of telling at this point */
+ return true; /* FIXME, We have no way of telling at this point */
+}
+
+#endif /* HOST_HPPAHPUX */
+
+/* Miscellaneous Support Functions -- Control Structures and Functions
+ for the PA. */
+
+unsigned int
+assemble_3 (x)
+ unsigned int x;
+{
+ return (((x & 1) << 2) | ((x & 6) >> 1)) & 7;
+}
+
+void
+dis_assemble_3 (x, r)
+ unsigned int x;
+ unsigned int *r;
+{
+ *r = (((x & 4) >> 2) | ((x & 3) << 1)) & 7;
+}
+
+unsigned int
+assemble_12 (x, y)
+ unsigned int x, y;
+{
+ return (((y & 1) << 11) | ((x & 1) << 10) | ((x & 0x7fe) >> 1)) & 0xfff;
+}
+
+void
+dis_assemble_12 (as12, x, y)
+ unsigned int as12;
+ unsigned int *x, *y;
+{
+ *y = (as12 & 0x800) >> 11;
+ *x = ((as12 & 0x3ff) << 1) | ((as12 & 0x400) >> 10);
+}
+
+unsigned long
+assemble_17 (x, y, z)
+ unsigned int x, y, z;
+{
+ unsigned long temp;
+
+ temp = ((z & 1) << 16) |
+ ((x & 0x1f) << 11) |
+ ((y & 1) << 10) |
+ ((y & 0x7fe) >> 1);
+ return temp & 0x1ffff;
+}
+
+void
+dis_assemble_17 (as17, x, y, z)
+ unsigned int as17;
+ unsigned int *x, *y, *z;
+{
+
+ *z = (as17 & 0x10000) >> 16;
+ *x = (as17 & 0x0f800) >> 11;
+ *y = (((as17 & 0x00400) >> 10) | ((as17 & 0x3ff) << 1)) & 0x7ff;
+}
+
+unsigned long
+assemble_21 (x)
+ unsigned int x;
+{
+ unsigned long temp;
+
+ temp = ((x & 1) << 20) |
+ ((x & 0xffe) << 8) |
+ ((x & 0xc000) >> 7) |
+ ((x & 0x1f0000) >> 14) |
+ ((x & 0x003000) >> 12);
+ return temp & 0x1fffff;
+}
+
+void
+dis_assemble_21 (as21, x)
+ unsigned int as21, *x;
+{
+ unsigned long temp;
+
+
+ temp = (as21 & 0x100000) >> 20;
+ temp |= (as21 & 0x0ffe00) >> 8;
+ temp |= (as21 & 0x000180) << 7;
+ temp |= (as21 & 0x00007c) << 14;
+ temp |= (as21 & 0x000003) << 12;
+ *x = temp;
+}
+
+#if 0
+unsigned long
+sign_ext (x, len)
+ unsigned int x, len;
+{
+ unsigned int sign;
+ unsigned int result;
+ unsigned int len_ones;
+ int i;
+
+ i = 0;
+ len_ones = 0;
+ while (i < len)
+ {
+ len_ones = (len_ones << 1) | 1;
+ i++;
+ }
+
+ sign = (x >> (len - 1)) & 1;
+
+ if (sign)
+ result = (~0 ^ len_ones) | (len_ones & x);
+ else
+ result = len_ones & x;
+
+ return result;
+}
+
+#endif
+static unsigned long
+sign_ext (x, len)
+ unsigned int x, len;
+{
+ return (x << (32 - len)) >> (32 - len);
+}
+
+static unsigned int
+ones (n)
+ int n;
+{
+ unsigned int len_ones;
+ int i;
+
+ i = 0;
+ len_ones = 0;
+ while (i < n)
+ {
+ len_ones = (len_ones << 1) | 1;
+ i++;
+ }
+
+ return len_ones;
+}
+
+void
+sign_unext (x, len, result)
+ unsigned int x, len;
+ unsigned int *result;
+{
+ unsigned int len_ones;
+
+ len_ones = ones (len);
+
+ *result = x & len_ones;
+}
+
+unsigned long
+low_sign_ext (x, len)
+ unsigned int x, len;
+{
+ unsigned int temp1, temp2;
+ unsigned int len_ones;
+
+ len_ones = ones (len);
+
+ temp1 = (x & 1) << (len - 1);
+ temp2 = ((x & 0xfffffffe) & len_ones) >> 1;
+ return sign_ext ((temp1 | temp2), len);
+}
+
+void
+low_sign_unext (x, len, result)
+ unsigned int x, len;
+ unsigned int *result;
+{
+ unsigned int temp;
+ unsigned int sign;
+ unsigned int rest;
+ unsigned int one_bit_at_len;
+ unsigned int len_ones;
+
+ len_ones = ones (len);
+ one_bit_at_len = 1 << (len - 1);
+
+ sign_unext (x, len, &temp);
+ sign = temp & one_bit_at_len;
+ sign >>= (len - 1);
+
+ rest = temp & (len_ones ^ one_bit_at_len);
+ rest <<= 1;
+
+ *result = rest | sign;
+}
+
+/* These work when 'y' is a power of two only. */
+
+static long
+round_down (x, y)
+ long x, y;
+{
+ return x & ~(y - 1);
+}
+
+static long
+round (x, y)
+ long x, y;
+{
+ return (x + y / 2) & ~(y - 1);
+}
+
+static long
+round_up (x, y)
+ long x, y;
+{
+ return x - (x | ~(y - 1));
+}
+
+/* L(Symbol, Addend): */
+/* round_down (Symbol + Addend, 2048) */
+
+static long
+L (Symbol, Addend)
+{
+ return (round_down (Symbol + Addend, 2048)) >> 11;
+}
+
+/* R(Symbol, Addend): */
+/* Symbol + Addend - round_down (Symbol + Addend, 2048) */
+
+static long
+R (Symbol, Addend)
+{
+ return Symbol + Addend - round_down (Symbol + Addend, 2048);
+}
+
+/* LS(Symbol, Addend): */
+/* round (Symbol + Addend, 2048) */
+
+static long
+LS (Symbol, Addend)
+{
+ return round (Symbol + Addend, 2048);
+}
+
+/* RS(Symbol, Addend): */
+/* Symbol + Addend - round (Symbol + Addend, 2048) */
+
+static long
+RS (Symbol, Addend)
+{
+ return Symbol + Addend - round (Symbol + Addend, 2048);
}
+/* LD(Symbol, Addend): */
+/* round_up (Symbol + Addend, 2048) */
+
+static long
+LD (Symbol, Addend)
+{
+ return (round_up (Symbol + Addend, 2048)) >> 11;
+}
+
+/* RD(Symbol, Addend): */
+/* Symbol + Addend - round_up (Symbol + Addend, 2048) */
+
+static long
+RD (Symbol, Addend)
+{
+ return Symbol + Addend - round_up (Symbol + Addend, 2048);
+}
+
+/* LR(Symbol, Addend): */
+/* round_down (Symbol, 2048) + round (Addend, 8192) */
+
+static long
+LR (Symbol, Addend)
+{
+ return (round_down (Symbol, 2048) + round (Addend, 8192)) >> 11;
+}
+
+/* RR(Symbol, Addend): */
+/* Symbol - round_down (Symbol, 2048) + */
+/* Addend - round (Addend, 8192) */
+
+static long
+RR (Symbol, Addend)
+{
+ return Symbol
+ - round_down (Symbol, 2048)
+ + Addend - round (Addend, 8192);
+}
+
+unsigned long
+hppa_field_adjust (value, constant_value, r_field)
+ unsigned long value;
+ unsigned long constant_value;
+ unsigned short r_field;
+{
+ unsigned long init_value = value;
+ value += constant_value;
+ switch (r_field)
+ {
+ case e_fsel: /* F : no change */
+ break;
+
+ case e_lssel: /* LS : if (bit 21) then add 0x800
+ arithmetic shift right 11 bits */
+ if (value & 0x00000400)
+ value += 0x800;
+ value = (value & 0xfffff800) >> 11;
+ BFD_ASSERT (value == LS (init_value, constant_value));
+ break;
+
+ case e_rssel: /* RS : Sign extend from bit 21 */
+ if (value & 0x00000400)
+ value |= 0xfffff800;
+ else
+ value &= 0x7ff;
+ BFD_ASSERT (value == RS (init_value, constant_value));
+ break;
+
+ case e_lsel: /* L : Arithmetic shift right 11 bits */
+ value = (value & 0xfffff800) >> 11;
+ BFD_ASSERT (value == L (init_value, constant_value));
+ break;
+
+ case e_rsel: /* R : Set bits 0-20 to zero */
+ value = value & 0x7ff;
+ BFD_ASSERT (value == R (init_value, constant_value));
+ break;
+
+ case e_ldsel: /* LD : Add 0x800, arithmetic shift
+ right 11 bits */
+ value += 0x800;
+ value = (value & 0xfffff800) >> 11;
+ BFD_ASSERT (value == LD (init_value, constant_value));
+ break;
+
+ case e_rdsel: /* RD : Set bits 0-20 to one */
+ value |= 0xfffff800;
+ BFD_ASSERT (value == RD (init_value, constant_value));
+ break;
+
+ case e_lrsel: /* LR : L with "rounded" constant */
+ value = value + ((constant_value + 0x1000) & 0xffffe000);
+ value = (value & 0xfffff800) >> 11;
+ BFD_ASSERT (value == LR (init_value, constant_value));
+ break;
+
+ case e_rrsel: /* RR : R with "rounded" constant */
+ value = value + ((constant_value + 0x1000) & 0xffffe000);
+ value = (value & 0x7ff) + constant_value - ((constant_value + 0x1000) & 0xffffe000);
+ BFD_ASSERT (value == RR (init_value, constant_value));
+ break;
+
+ default:
+ fprintf (stderr, "Unrecognized field_selector 0x%02x\n", r_field);
+ break;
+ }
+ return value;
+
+}
+
+/* Return information about SOM symbol SYMBOL in RET. */
+
+static void
+hppa_get_symbol_info (ignore_abfd, symbol, ret)
+ bfd *ignore_abfd; /* Ignored. */
+ asymbol *symbol;
+ symbol_info *ret;
+{
+ bfd_symbol_info (symbol, ret);
+}
+
+/* End of miscellaneous support functions. */
+
+#ifdef HOST_HPPABSD
+/* All the core file code for BSD needs to be rewritten cleanly. For
+ now we do not support core files under BSD. */
+
+#define hppa_core_file_p _bfd_dummy_target
+#define hppa_core_file_failing_command _bfd_dummy_core_file_failing_command
+#define hppa_core_file_failing_signal _bfd_dummy_core_file_failing_signal
+#define hppa_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
+#endif /* HOST_HPPABSD */
+
#define hppa_bfd_debug_info_start bfd_void
#define hppa_bfd_debug_info_end bfd_void
#define hppa_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
-
-
#define hppa_openr_next_archived_file bfd_generic_openr_next_archived_file
#define hppa_generic_stat_arch_elt bfd_generic_stat_arch_elt
#define hppa_slurp_armap bfd_false
#define hppa_bfd_get_relocated_section_contents \
bfd_generic_get_relocated_section_contents
#define hppa_bfd_relax_section bfd_generic_relax_section
+#define hppa_bfd_seclet_link bfd_generic_seclet_link
+#define hppa_bfd_reloc_type_lookup \
+ ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
+#define hppa_bfd_make_debug_symbol \
+ ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
-/*SUPPRESS 460 */
bfd_target hppa_vec =
{
"hppa", /* name */
(HAS_RELOC | EXEC_P | /* object flags */
HAS_LINENO | HAS_DEBUG |
HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
- (SEC_CODE|SEC_DATA|SEC_ROM|SEC_HAS_CONTENTS
- |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
+ (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
+ | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
- /* leading_symbol_char: is the first char of a user symbol
+/* leading_symbol_char: is the first char of a user symbol
predictable, and if so what is it */
- 0,
-
-
+ 0,
' ', /* ar_pad_char */
16, /* ar_max_namelen */
- 3, /* minimum alignment */
-_do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */
-_do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */
-
- { _bfd_dummy_target,
- hppa_object_p, /* bfd_check_format */
- bfd_generic_archive_p,
- hppa_core_file_p,
- },
+ 3, /* minimum alignment */
+ _do_getb64, _do_getb_signed_64, _do_putb64,
+ _do_getb32, _do_getb_signed_32, _do_putb32,
+ _do_getb16, _do_getb_signed_16, _do_putb16, /* data */
+ _do_getb64, _do_getb_signed_64, _do_putb64,
+ _do_getb32, _do_getb_signed_32, _do_putb32,
+ _do_getb16, _do_getb_signed_16, _do_putb16, /* hdrs */
+ {_bfd_dummy_target,
+ hppa_object_p, /* bfd_check_format */
+ bfd_generic_archive_p,
+ hppa_core_file_p,
+ },
{
bfd_false,
- hppa_mkobject,
+ hppa_mkobject,
_bfd_generic_mkarchive,
bfd_false
- },
+ },
{
bfd_false,
hppa_write_object_contents,
bfd_false,
},
#undef hppa
- JUMP_TABLE(hppa)
+ JUMP_TABLE (hppa),
+ (PTR) 0
};
-#else /* notdef hp9000s800 */
-/* Prevent "empty translation unit" warnings from the idiots at X3J11. */
-static char ansi_c_idiots = 69;
-#endif /* hp9000s800 */
+#endif /* HOST_HPPAHPUX || HOST_HPPABSD */
projects / deliverable / binutils-gdb.git / blobdiff