#include "bfd.h"
#include "sysdep.h"
-#ifdef HOST_HPPAHPUX
+/* @@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 <sys/dir.h>
#include <signal.h>
#include <machine/reg.h>
-#include <sys/user.h> /* After a.out.h */
+#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;
-};
+
+/* Magic not defined in standard HP-UX header files until 8.0 */
+
+#ifndef CPU_PA_RISC1_0
+#define CPU_PA_RISC1_0 0x20B
+#endif /* CPU_PA_RISC1_0 */
+
+#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;
+ };
static bfd_target *
hppa_object_setup (abfd, file_hdrp, aux_hdrp)
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_pa_symbols (abfd) = (hppa_symbol_type *)NULL;
+ 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 */
- text = bfd_make_section(abfd, ".text");
- data = bfd_make_section(abfd, ".data");
- bss = bfd_make_section(abfd, ".bss");
+ 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;
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;
+ /* 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_str_filepos (abfd) = file_hdrp->symbol_strings_location;
obj_stringtab_size (abfd) = file_hdrp->symbol_strings_size;
return abfd->xvec;
sect = bfd_make_section (abfd, name);
while (!sect)
{
- sprintf(altname, "%s-%d", name, num++);
+ sprintf (altname, "%s-%d", name, num++);
sect = bfd_make_section (abfd, altname);
}
- newname = bfd_alloc (abfd, strlen(sect->name) + 1);
+ newname = bfd_alloc (abfd, strlen (sect->name) + 1);
strcpy (newname, sect->name);
sect->name = newname;
char *space_strings;
int space_index;
-/* First, read in space names */
+ /* First, read in space names */
space_strings = alloca (file_hdr->space_strings_size);
if (!space_strings)
/* Read the space dictionary element */
if (bfd_seek (abfd, file_hdr->space_location
- + space_index * sizeof space, SEEK_SET) < 0)
+ + space_index * sizeof space, SEEK_SET) < 0)
return 0;
if (bfd_read (&space, 1, sizeof space, abfd) != sizeof space)
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)
+ + 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)
+ + space.subspace_index * sizeof subspace,
+ SEEK_SET) < 0)
return 0;
/* Setup the section flags as appropriate (this is somewhat bogus, as
/* Make a section out of this subspace */
subspace_asect = make_unique_section (abfd, subspace.name.n_name,
- space.subspace_index + subspace_index);
+ space.subspace_index + subspace_index);
if (!subspace_asect)
return 0;
/* 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;
+ + subspace.subspace_length;
space_asect->_raw_size = (subspace.file_loc_init_value
- space_asect->filepos)
- + subspace.initialization_length;
+ + subspace.initialization_length;
}
}
struct header file_hdr;
struct som_exec_auxhdr aux_hdr;
- 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))
switch (file_hdr.a_magic)
{
- case RELOC_MAGIC: /* I'm not really sure about all of these types... */
+ 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;
}
- if (bfd_read ((PTR) &aux_hdr, 1, AUX_HDR_SIZE, abfd) != AUX_HDR_SIZE)
+ 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);
+ return hppa_object_setup (abfd, &file_hdr, &aux_hdr);
}
static boolean
-DEFUN(hppa_mkobject,(abfd),
- bfd *abfd)
-{
+DEFUN (hppa_mkobject, (abfd),
+ bfd * abfd)
+{
fprintf (stderr, "hppa_mkobject unimplemented\n");
fflush (stderr);
abort ();
}
boolean
-DEFUN(hppa_write_object_contents,(abfd),
- bfd *abfd)
+DEFUN (hppa_write_object_contents, (abfd),
+ bfd * abfd)
{
fprintf (stderr, "hppa_write_object_contents unimplemented\n");
fflush (stderr);
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;
}
-static void
-hppa_print_symbol (ignore_abfd, afile, symbol, how)
+static void
+hppa_get_symbol_info (ignore_abfd, symbol, ret)
+ bfd *ignore_abfd;
+ asymbol *symbol;
+ symbol_info ret;
+{
+ bfd_symbol_info (symbol, ret);
+}
+
+static void
+hppa_print_symbol (ignore_abfd, afile, symbol, how)
bfd *ignore_abfd;
PTR afile;
asymbol *symbol;
{
fprintf (stderr, "hppa_set_section_contents unimplimented\n");
fflush (stderr);
- abort();
+ abort ();
return false;
}
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
static int
hppa_sizeof_headers (abfd, reloc)
- bfd *abfd;
- boolean reloc;
+ bfd *abfd;
+ boolean reloc;
{
fprintf (stderr, "hppa_sizeof_headers unimplemented\n");
fflush (stderr);
return asect;
}
+#ifdef HOST_HPPAHPUX
static bfd_target *
hppa_core_file_p (abfd)
bfd *abfd;
int val;
struct corehead core_header;
- val = bfd_read ((void *)&core_header, 1, sizeof core_header, abfd);
+ 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 */
+ 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);
+ bfd_read ((void *) &proc_exec, 1, core_header.len, abfd);
strncpy (core_command (abfd), proc_exec.cmd, MAXCOMLEN + 1);
}
break;
{
struct proc_info proc_info;
core_regsec (abfd) = make_bfd_asection (abfd, ".reg",
- SEC_ALLOC+SEC_HAS_CONTENTS,
+ SEC_ALLOC + SEC_HAS_CONTENTS,
core_header.len,
- (int)&proc_info - (int)&proc_info.hw_regs,
+ (int) &proc_info - (int) &proc_info.hw_regs,
2);
bfd_read (&proc_info, 1, core_header.len, abfd);
core_signal (abfd) = proc_info.sig;
break;
case CORE_DATA:
core_datasec (abfd) = make_bfd_asection (abfd, ".data",
- SEC_ALLOC+SEC_LOAD+SEC_HAS_CONTENTS,
+ SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
core_header.len,
core_header.addr,
2);
break;
case CORE_STACK:
core_stacksec (abfd) = make_bfd_asection (abfd, ".stack",
- SEC_ALLOC+SEC_LOAD+SEC_HAS_CONTENTS,
+ SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
core_header.len,
core_header.addr,
2);
/* ARGSUSED */
static boolean
-hppa_core_file_matches_executable_p (core_bfd, exec_bfd)
+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
+DEFUN (hppa_field_adjust, (value, constant_value, r_field),
+ unsigned long value AND
+ unsigned long constant_value AND
+ 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
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)
bfd_target hppa_vec =
{
(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
};
-#endif /* HOST_HPPAHPUX */
+#endif /* HOST_HPPAHPUX || HOST_HPPABSD */
projects / deliverable / binutils-gdb.git / blobdiff