+Tue Jun 1 04:15:57 1993 Ken Raeburn (raeburn@kr-pc.cygnus.com)
+
+ * elf.c: New file, for word-size independent code.
+ * elfcode.h (elf_hash): Moved to there, renamed bfd_elf_hash.
+ * Makefile.in: Include elf.o in standard objects.
+
+ * bfd-in.h (CAT3): Define here.
+ * libaout.h, libelf.h: Not here.
+
+ * libelf.h (struct strtab): Define here.
+ (bfd_elf_locate_sh): Declare here.
+ * elfcode.h (struct strtab): Definition deleted.
+
+ * reloc.c (enum bfd_reloc_code_real): Added HPPA_PCREL_CALL_12.
+
+ * Makefile.in: Make "all", not "bfd.h", be the default target.
+ (stmp-bfd.h): New target; prevents rebuilding world if bfd.h
+ hasn't really changed.
+
+ Tue May 25 12:15:15 1993 Michael Meissner (meissner@osf.org)
+
+ * elfcode.h (elf_hash): Provide elf standard hash function.
+ (various): Key off of the machines use_rela_p field to determine
+ whether to use REL or RELA relocations.
+ (elf_swap_reloc_out, elf_swap_reloc_in): New functions.
+ (elf_make_sections): Allocate a pointer to hold all data for a
+ given section, and copy each fragment into the data region.
+ Update the section's pointer with the REL implicit addends if the
+ machine uses REL relocation.
+
+ * elf32-i386.c (elf_bfd_reloc_type_lookup): Rename to
+ elf_i386_bfd_reloc_type_lookup, and use cpp to map the name back
+ into was elf32-target.h expects.
+ (elf_info_to_howto): Rename to elf_i386_info_to_howto.
+ (elf_i386_bfd_reloc_type_lookup): Add relocation support.
+ (elf_i386_info_to_howto): Add minimal relocation support.
+
+ * libelf.h (elf_backend_data): Add use_rela_p, elf_64_p,
+ elf_info_to_howto_rel fields.
+
+ * elf32-target.h (elf_bed): Add support for new fields in
+ elf_backend_data.
+
+ Sun May 30 16:38:24 1993 Peter Hoogenboom (hoogen@fast.cs.utah.edu)
+
+ * elf32-hppa.c: Add symbol extension section support, fix
+ relocation howto table, add stub generation support.
+
+ * elf32-hppa.h: Add symbol extension section support, fix
+ relocation howto table, add stub generation support.
+
+ * elfcode.h (bfd_elf_locate_sh): New function to locate ELF
+ section header.
+ (bfd_add_to_strtab):
+ (elf_idx_of_sym):
+ (elf_compute_section_file_positions):
+ (elf_write_object_contents):
+ (elf_get_sect_thunk):
+
+ * hppa.c (sign_ext): Reimplement.
+
+ * hppa.c (round_down,round,round_up,L,R,LS,RS,LD,RD,LR,RR): Make
+ these functions static.
+
Tue Jun 1 14:40:41 1993 Per Bothner (bothner@rtl.cygnus.com)
* Makefile.in (bfd.h): Move closer to headers - and after 'all'!
--- /dev/null
+/* ELF32/HPPA relocation support
+
+ This file contains ELF32/HPPA relocation support as specified
+ in the Stratus FTX/Golf Object File Format (SED-1762) dated
+ November 19, 1992.
+*/
+
+
+/*
+ Copyright (C) 1990-1991 Free Software Foundation, Inc.
+
+ Written by:
+
+ Center for Software Science
+ Department of Computer Science
+ University of Utah
+
+This file is part of BFD, the Binary File Descriptor library.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#ifndef _ELF32_HPPA_H
+#define _ELF32_HPPA_H
+
+#include "libelf.h"
+
+/* 9.3.3. Parameter relocation information */
+
+/* As mentioned previously, relocations of calls must be accompanied */
+/* by parameter relocation information, indicating which registers the */
+/* first for parameter words, and the return value, are located in. */
+/* This information accompanies the R_HPPA_ABS_CALL.., */
+/* R_HPPA_PCREL_CALL... and R_HPPA_PUSH_PROC relocation types, */
+/* described below. The information is kept in the high-order 10 bits */
+/* of Elf32_rela.r_addend, while the low-order 22 bits are a signed */
+/* constant to be used in calculating the call target. The following */
+/* macros are used to extract and combine these data in r_addend. */
+
+#define ELF32_HPPA_R_ARG_RELOC(a) (((a) >> 22) & 0x3FF)
+#define ELF32_HPPA_R_CONSTANT(a) ((((Elf32_Sword)(a)) << 10) >> 10)
+#define ELF32_HPPA_R_ADDEND(r,c) (((r) << 22) + ((c) & 0x3FFFFF))
+
+/* ELF/HPPA relocation types */
+
+/* name expression format */
+/* -------------------------------------------------------------- */
+typedef enum
+ {
+ /* 9.3.4. Address relocation types */
+
+ /* These relocation types do simple base+offset relocations, and are */
+ /* normally used for absolute references to data. */
+
+ /* By convention, relocation type zero is always "no relocation", */
+ /* while type one is 32-bit word relocation. */
+
+ R_HPPA_NONE, /* - - */
+
+ R_HPPA_32, /* Symbol + Addend 32 */
+ R_HPPA_11, /* Symbol + Addend 11 */
+ R_HPPA_14, /* Symbol + Addend 11 */
+ R_HPPA_17, /* Symbol + Addend 11 */
+ R_HPPA_L21, /* L (Symbol, Addend) 21 */
+ R_HPPA_R11, /* R (Symbol, Addend) 11 */
+ R_HPPA_R14, /* R (Symbol, Addend) 14 */
+ R_HPPA_R17, /* R (Symbol, Addend) 17 */
+ R_HPPA_LS21, /* LS(Symbol, Addend) 21 */
+ R_HPPA_RS11, /* RS(Symbol, Addend) 11 */
+ R_HPPA_RS14, /* RS(Symbol, Addend) 14 */
+ R_HPPA_RS17, /* RS(Symbol, Addend) 17 */
+ R_HPPA_LD21, /* LD(Symbol, Addend) 21 */
+ R_HPPA_RD11, /* RD(Symbol, Addend) 11 */
+ R_HPPA_RD14, /* RD(Symbol, Addend) 14 */
+ R_HPPA_RD17, /* RD(Symbol, Addend) 17 */
+ R_HPPA_LR21, /* LR(Symbol, Addend) 21 */
+ R_HPPA_RR14, /* RR(Symbol, Addend) 14 */
+ R_HPPA_RR17, /* RR(Symbol, Addend) 17 */
+
+ /* 9.3.5. GOTOFF address relocation types */
+
+ /* The Global Offset Table (GOT) is a table of pointers to data, but */
+ /* its address can also be used as a base pointer to address data, */
+ /* similar to the way the DP is used in HP/UX. The expression */
+ /* calculation yields a signed offset of an address from the GOT. */
+
+ R_HPPA_GOTOFF_11, /* Symbol - GOT + Addend 11 */
+ R_HPPA_GOTOFF_14, /* Symbol - GOT + Addend 14 */
+ R_HPPA_GOTOFF_L21, /* L (Sym - GOT, Addend) 21 */
+ R_HPPA_GOTOFF_R11, /* R (Sym - GOT, Addend) 11 */
+ R_HPPA_GOTOFF_R14, /* R (Sym - GOT, Addend) 14 */
+ R_HPPA_GOTOFF_LS21, /* LS(Sym - GOT, Addend) 21 */
+ R_HPPA_GOTOFF_RS11, /* RS(Sym - GOT, Addend) 11 */
+ R_HPPA_GOTOFF_RS14, /* RS(Sym - GOT, Addend) 14 */
+ R_HPPA_GOTOFF_LD21, /* LD(Sym - GOT, Addend) 21 */
+ R_HPPA_GOTOFF_RD11, /* RD(Sym - GOT, Addend) 11 */
+ R_HPPA_GOTOFF_RD14, /* RD(Sym - GOT, Addend) 14 */
+ R_HPPA_GOTOFF_LR21, /* LR(Sym - GOT, Addend) 21 */
+ R_HPPA_GOTOFF_RR14, /* RR(Sym - GOT, Addend) 14 */
+
+ /* 9.3.6. Absolute call relocation types */
+
+ /* Relocations of function calls must be accompanied by parameter */
+ /* relocation information. This information is carried in the ten */
+ /* high-order bits of the addend field. The remaining 22 bits of */
+ /* of the addend field are sign-extended to form the Addend. */
+
+ R_HPPA_ABS_CALL_11, /* Symbol + Addend 11 */
+ R_HPPA_ABS_CALL_14, /* Symbol + Addend 14 */
+ R_HPPA_ABS_CALL_17, /* Symbol + Addend 17 */
+ R_HPPA_ABS_CALL_L21, /* L (Symbol, Addend) 21 */
+ R_HPPA_ABS_CALL_R11, /* R (Symbol, Addend) 11 */
+ R_HPPA_ABS_CALL_R14, /* R (Symbol, Addend) 14 */
+ R_HPPA_ABS_CALL_R17, /* R (Symbol, Addend) 17 */
+ R_HPPA_ABS_CALL_LS21, /* LS(Symbol, Addend) 21 */
+ R_HPPA_ABS_CALL_RS11, /* RS(Symbol, Addend) 11 */
+ R_HPPA_ABS_CALL_RS14, /* RS(Symbol, Addend) 14 */
+ R_HPPA_ABS_CALL_RS17, /* RS(Symbol, Addend) 17 */
+ R_HPPA_ABS_CALL_LD21, /* LD(Symbol, Addend) 21 */
+ R_HPPA_ABS_CALL_RD11, /* RD(Symbol, Addend) 11 */
+ R_HPPA_ABS_CALL_RD14, /* RD(Symbol, Addend) 14 */
+ R_HPPA_ABS_CALL_RD17, /* RD(Symbol, Addend) 17 */
+ R_HPPA_ABS_CALL_LR21, /* LR(Symbol, Addend) 21 */
+ R_HPPA_ABS_CALL_RR14, /* RR(Symbol, Addend) 14 */
+ R_HPPA_ABS_CALL_RR17, /* RR(Symbol, Addend) 17 */
+
+ /* 9.3.7. PC-relative call relocation types */
+
+ /* PC-relative relocation calculates the difference between an address */
+ /* and the location being relocated. This is most often used to */
+ /* relocate pc-relative calls. */
+
+ /* As with the ABS_CALL relocation types, the ten high-order bits of */
+ /* the addend field carry parameter relocation information, while */
+ /* the low-order 22 bits are sign-extended to form the Addend. */
+
+ R_HPPA_PCREL_CALL_11, /* Symbol - PC + Addend 11 */
+ R_HPPA_PCREL_CALL_14, /* Symbol - PC + Addend 14 */
+ R_HPPA_PCREL_CALL_17, /* Symbol - PC + Addend 17 */
+ R_HPPA_PCREL_CALL_12, /* Symbol - PC + Addend 12 */
+ R_HPPA_PCREL_CALL_L21, /* L (Symbol - PC, Addend) 21 */
+ R_HPPA_PCREL_CALL_R11, /* R (Symbol - PC, Addend) 11 */
+ R_HPPA_PCREL_CALL_R14, /* R (Symbol - PC, Addend) 14 */
+ R_HPPA_PCREL_CALL_R17, /* R (Symbol - PC, Addend) 17 */
+ R_HPPA_PCREL_CALL_LS21, /* LS(Symbol - PC, Addend) 21 */
+ R_HPPA_PCREL_CALL_RS11, /* RS(Symbol - PC, Addend) 11 */
+ R_HPPA_PCREL_CALL_RS14, /* RS(Symbol - PC, Addend) 14 */
+ R_HPPA_PCREL_CALL_RS17, /* RS(Symbol - PC, Addend) 17 */
+ R_HPPA_PCREL_CALL_LD21, /* LD(Symbol - PC, Addend) 21 */
+ R_HPPA_PCREL_CALL_RD11, /* RD(Symbol - PC, Addend) 11 */
+ R_HPPA_PCREL_CALL_RD14, /* RD(Symbol - PC, Addend) 14 */
+ R_HPPA_PCREL_CALL_RD17, /* RD(Symbol - PC, Addend) 17 */
+ R_HPPA_PCREL_CALL_LR21, /* LR(Symbol - PC, Addend) 21 */
+ R_HPPA_PCREL_CALL_RR14, /* RR(Symbol - PC, Addend) 14 */
+ R_HPPA_PCREL_CALL_RR17, /* RR(Symbol - PC, Addend) 17 *//* #69 */
+
+ /* 9.3.8. Plabel relocation types */
+
+ /* Plabels are designed to allow code pointers to be passed between */
+ /* spaces. The addend of the relocation should be either 0 (no static */
+ /* link) or 2 (static link required). These relocations correspond to */
+ /* the P%, LP% and RP% field selectors. [Description is incomplete] */
+
+ R_HPPA_PLABEL_32, /* F(Plabel(Symbol,Addend),0) 32 */
+ R_HPPA_PLABEL_11, /* F(Plabel(Symbol,Addend),0) 11 */
+ R_HPPA_PLABEL_14, /* F(Plabel(Symbol,Addend),0) 14 */
+ R_HPPA_PLABEL_L21, /* L(Plabel(Symbol,Addend),0) 21 */
+ R_HPPA_PLABEL_R11, /* R(Plabel(Symbol,Addend),0) 11 */
+ R_HPPA_PLABEL_R14, /* R(Plabel(Symbol,Addend),0) 14 */
+
+ /* 9.3.9. Data linkage table (DLT) relocation types */
+
+ /* SOM DLT_REL fixup requests are used to for static data references */
+ /* from position-independent code within shared libraries. They are */
+ /* similar to the GOT relocation types in some SVR4 implementations. */
+ /* [Prose to come] */
+
+ R_HPPA_DLT_32, /* F(DLTOFF) 32 */
+ R_HPPA_DLT_11, /* F(DLTOFF) 11 */
+ R_HPPA_DLT_14, /* F(DLTOFF) 14 */
+ R_HPPA_DLT_L21, /* L(DLTOFF) 21 */
+ R_HPPA_DLT_R11, /* R(DLTOFF) 11 */
+ R_HPPA_DLT_R14, /* R(DLTOFF) 14 */
+
+ /* 9.3.10. Relocations for unwinder tables */
+
+ /* As described above, the unwinder table consists of a series of */
+ /* four-word entries, the first two of which are a pair of code */
+ /* addresses. While it would be possible to relocate this table using */
+ /* just R_HPPA_32, the amount of relocation data resulting would be */
+ /* very large. To reduce that data, the following relocation types */
+ /* have been defined. */
+
+ /* The first, R_HPPA_UNWIND_ENTRY, merely compresses two R_HPPA_32 */
+ /* operations into one. It is designed for use in .rel-type */
+ /* relocations, where the two 32-bit addends are taken from the unwind */
+ /* section itself. */
+
+ /* The second, which is designed for use in .rela-type relocations, is */
+ /* designed to relocate an entire unwinder table with one relocation */
+ /* entry. It has the effect of multiple R_HPPA_UNWIND_ENTRY */
+ /* relocations applied to successive unwinder table entries. The */
+ /* number of entries to be relocated is given in the r_addend field of */
+ /* the relocation entry. The rest of the relocation entry is used in */
+ /* a normal way--r_offset is the offset of the first unwind entry in */
+ /* the section, while ELF32_R_SYM(r_info) is the code section that all */
+ /* the code addresses should be relocated from. */
+
+ R_HPPA_UNWIND_ENTRY, /* "128" */
+ R_HPPA_UNWIND_ENTRIES, /* Addend * "128" */
+
+ /* 9.3.11. Relocation types for complex expressions */
+
+ /* As described above, new-format SOM fixups support complex */
+ /* expressions by spreading the parts of the expression across */
+ /* multiple entries. ELF for HPPA will have a similar mechanism, */
+ /* although support for it may be optional. There are two main */
+ /* reasons for defining it: first, the need to translate complex */
+ /* SOM fixup expressions to ELF, and second, to cover combinations */
+ /* of expression, field and format not available with other */
+ /* relocation types. */
+
+ /* ELF expression relocation entries are interpreted as postfix-form */
+ /* expressions. They may be evaluated using a push-down stack. */
+
+ /* Usually, the addend field of these expression relocation entries is */
+ /* unused, with the following exceptions: */
+
+ /* R_HPPA_PUSH_CONST: The addend field contains the constant. */
+
+ /* R_HPPA_PUSH_PROC: The high-order 10 bits of the addend field */
+ /* contain parameter relocation information. The rest of */
+ /* the addend field is unused. */
+
+ /* R_HPPA_LSHIFT, R_HPPA_ARITH_RSHIFT and R_HPPA_LOGIC_RSHIFT: */
+ /* The addend field normally gives the amount to shift. */
+ /* However, if that amount is zero, the shift amount is */
+ /* popped from the top of the stack prior to popping the */
+ /* amount to be shifted. */
+
+ /* name expression fld/fmt */
+ /* ------------------------------------------------------------------- */
+ R_HPPA_PUSH_CONST, /* push Addend - - */
+ R_HPPA_PUSH_PC, /* push PC + Addend - - */
+ R_HPPA_PUSH_SYM, /* push Symbol + Addend - - */
+ R_HPPA_PUSH_GOTOFF, /* push Symbol - GOT + Addend - - */
+ R_HPPA_PUSH_ABS_CALL, /* push Symbol + Addend - - */
+ R_HPPA_PUSH_PCREL_CALL, /* push Symbol - PC + Addend - - */
+ R_HPPA_PUSH_PLABEL, /* push Plabel(Symbol) - - */
+ R_HPPA_MAX, /* pop A and B, push max(B,A) - - */
+ R_HPPA_MIN, /* pop A and B, push min(B,A) - - */
+ R_HPPA_ADD, /* pop A and B, push B + A - - */
+ R_HPPA_SUB, /* pop A and B, push B - A - - */
+ R_HPPA_MULT, /* pop A and B, push B * A - - */
+ R_HPPA_DIV, /* pop A and B, push B / A - - */
+ R_HPPA_MOD, /* pop A and B, push B % A - - */
+ R_HPPA_AND, /* pop A and B, push B & A - - */
+ R_HPPA_OR, /* pop A and B, push B | A - - */
+ R_HPPA_XOR, /* pop A and B, push B ^ A - - */
+ R_HPPA_NOT, /* pop A, push ~A - - */
+ R_HPPA_LSHIFT, /* pop A, push A << Addend - - */
+ R_HPPA_ARITH_RSHIFT, /* pop A, push A >> Addend - - */
+ R_HPPA_LOGIC_RSHIFT, /* pop A, push A >> Addend - - */
+ R_HPPA_EXPR_F, /* pop A, push A + Addend F - */
+ R_HPPA_EXPR_L, /* pop A, push L(A,Addend) L - */
+ R_HPPA_EXPR_R, /* pop A, push R(A,Addend) R - */
+ R_HPPA_EXPR_LS, /* pop A, push LS(A,Addend) LS - */
+ R_HPPA_EXPR_RS, /* pop A, push RS(A,Addend) RS - */
+ R_HPPA_EXPR_LD, /* pop A, push LD(A,Addend) LD - */
+ R_HPPA_EXPR_RD, /* pop A, push RD(A,Addend) RD - */
+ R_HPPA_EXPR_LR, /* pop A, push LR(A,Addend) LR - */
+ R_HPPA_EXPR_RR, /* pop A, push RR(A,Addend) RR - */
+
+ R_HPPA_EXPR_32, /* pop - 32 */
+ R_HPPA_EXPR_21, /* pop - 21 */
+ R_HPPA_EXPR_11, /* pop - 11 */
+ R_HPPA_EXPR_14, /* pop - 14 */
+ R_HPPA_EXPR_17, /* pop - 17 */
+ R_HPPA_EXPR_12, /* pop - 12 */
+ R_HPPA_UNIMPLEMENTED /* N/A */
+ } elf32_hppa_reloc_type;
+
+#define ELF_HOWTO_TABLE_SIZE R_HPPA_UNIMPLEMENTED + 1
+#define N_HPPA_RELOCS R_HPPA_UNIMPLEMENTED + 1
+
+/* Groups of relocations. Serves as an expression type. */
+
+#define R_HPPA R_HPPA_32
+#define R_HPPA_GOTOFF R_HPPA_GOTOFF_11
+#define R_HPPA_ABS_CALL R_HPPA_ABS_CALL_11
+#define R_HPPA_PCREL_CALL R_HPPA_PCREL_CALL_11
+#define R_HPPA_PLABEL R_HPPA_PLABEL_32
+#define R_HPPA_DLT R_HPPA_DLT_32
+#define R_HPPA_UNWIND R_HPPA_UNWIND_ENTRY
+#define R_HPPA_COMPLEX R_HPPA_PUSH_CONST
+#define R_HPPA_COMPLEX_PCREL_CALL R_HPPA_PUSH_CONST + 1
+#define R_HPPA_COMPLEX_ABS_CALL R_HPPA_PUSH_CONST + 2
+
+
+enum hppa_reloc_field_selector_type
+{
+ R_HPPA_FSEL = 0x0,
+ R_HPPA_LSSEL = 0x1,
+ R_HPPA_RSSEL = 0x2,
+ R_HPPA_LSEL = 0x3,
+ R_HPPA_RSEL = 0x4,
+ R_HPPA_LDSEL = 0x5,
+ R_HPPA_RDSEL = 0x6,
+ R_HPPA_LRSEL = 0x7,
+ R_HPPA_RRSEL = 0x8,
+ R_HPPA_PSEL = 0x9, /* P' : procedure address for shlib's */
+ R_HPPA_LPSEL = 0xa, /* LP' : L' for procedure addresses */
+ R_HPPA_RPSEL = 0xb, /* RP' : R' for procedure addresses */
+
+ R_HPPA_TSEL = 0xc, /* T' : DLT-relative offset for shlib's */
+ R_HPPA_LTSEL = 0xd, /* LT' : L' for DLT-relative offsets */
+ R_HPPA_RTSEL = 0xe /* RT' : R' for DLT-relative offsets */
+
+};
+
+#define N_HPPA_FIELD_SELECTORS 15
+
+/* for compatibility */
+enum hppa_reloc_field_selector_type_alt
+{
+ e_fsel = R_HPPA_FSEL,
+ e_lssel = R_HPPA_LSSEL,
+ e_rssel = R_HPPA_RSSEL,
+ e_lsel = R_HPPA_LSEL,
+ e_rsel = R_HPPA_RSEL,
+ e_ldsel = R_HPPA_LDSEL,
+ e_rdsel = R_HPPA_RDSEL,
+ e_lrsel = R_HPPA_LRSEL,
+ e_rrsel = R_HPPA_RRSEL,
+ e_psel = R_HPPA_PSEL, /* P' : procedure address for shlib's */
+ e_lpsel = R_HPPA_LPSEL, /* LP' : L' for procedure addresses */
+ e_rpsel = R_HPPA_RPSEL, /* RP' : R' for procedure addresses */
+
+ e_tsel = R_HPPA_TSEL, /* T' : DLT-relative offset for shlib's */
+ e_ltsel = R_HPPA_LTSEL, /* LT' : L' for DLT-relative offsets */
+ e_rtsel = R_HPPA_RTSEL /* RT' : R' for DLT-relative offsets */
+};
+
+/* PA-RISC OPCODES */
+
+#define get_opcode(insn) ((insn) & 0xfc000000) >> 26
+
+/* XXX: this list is incomplete */
+
+#define LDO 0x0d
+#define LDB 0x10
+#define LDH 0x11
+#define LDW 0x12
+#define LDWM 0x13
+#define STB 0x18
+#define STH 0x19
+#define STW 0x1a
+#define STWM 0x1b
+#define COMICLR 0x24
+#define SUBI 0x25
+#define SUBIO 0x25
+#define ADDIT 0x2c
+#define ADDITO 0x2c
+#define ADDI 0x2d
+#define ADDIO 0x2d
+#define LDIL 0x08
+#define ADDIL 0x0a
+
+#define MOVB 0x32
+#define MOVIB 0x33
+#define COMBT 0x20
+#define COMBF 0x22
+#define COMIBT 0x21
+#define COMIBF 0x23
+#define ADDBT 0x28
+#define ADDBF 0x2a
+#define ADDIBT 0x29
+#define ADDIBF 0x2b
+#define BVB 0x30
+#define BB 0x31
+
+#define BL 0x3a
+#define BLE 0x39
+#define BE 0x38
+
+#ifdef __STDC__
+elf32_hppa_reloc_type **hppa_elf_gen_reloc_type (bfd * abfd, elf32_hppa_reloc_type base_type, int format, int field);
+#else
+elf32_hppa_reloc_type **hppa_elf_gen_reloc_type ();
+#endif
+
+/*
+ * HPPA Section types
+ */
+
+#define SHT_HPPA_SYMEXTN SHT_LOPROC
+
+
+/*
+ * HPPA Symbol types
+ */
+
+#define STT_HPPA_PLABEL STT_LOPROC
+
+
+/*
+ * HPPA symbol table extension entry types
+ */
+
+#define HPPA_SXT_NULL 0x00
+#define HPPA_SXT_SYMNDX 0x01
+#define HPPA_SXT_ARG_RELOC 0x02
+
+/*
+ * These macros compose and decompose the value of a symextn entry:
+ *
+ * entry_type = ELF32_HPPA_SX_TYPE(word);
+ * entry_value = ELF32_HPPA_SX_VAL(word);
+ * word = ELF32_HPPA_SX_WORD(type,val);
+ * Se.hppa_se_info = ELF32_HPPA_SE_INFO(arg_reloc)
+ */
+
+#define ELF32_HPPA_SX_TYPE(p) ((p) >> 24)
+#define ELF32_HPPA_SX_VAL(p) ((p) & 0xFFFFFF)
+#define ELF32_HPPA_SX_WORD(type,val) (((type) << 24) + (val & 0xFFFFFF))
+
+/* The following was added facilitate implementation of the .hppa_symextn
+ section. This section is built after the symbol table is built in the
+ elf_write_object_contents routine (called from bfd_close). It is built
+ so late because it requires information that is not known until
+ the symbol and string table sections have been allocated, and
+ the symbol table has been built. */
+
+#define ELF_TC_FAKE_SECTIONS 1 /* # of "hand_made" tc-specific sections */
+#define SYMEXTN_SECTION_NAME ".hppa_symextn"
+
+extern void EXFUN (elf_hppa_tc_symbol, (bfd *, elf32_symbol_type *, int));
+extern void EXFUN (elf_hppa_tc_make_sections, (bfd *, PTR));
+
+typedef Elf32_Word symext_entryS;
+
+struct symext_chain
+{
+ symext_entryS entry;
+ struct symext_chain *next;
+};
+
+typedef struct symext_chain symext_chainS;
+
+extern symext_chainS *symext_rootP;
+extern symext_chainS *symext_lastP;
+
+#endif /* _ELF32_HPPA_H */
static CONST struct elf32_backend_data elf32_bed =
{
- elf_info_to_howto,
- ELF_ARCH,
+#ifdef USE_REL
+ 0, /* use_rela_p */
+#else
+ 1, /* use_rela_p */
+#endif
+ 0, /* elf_64_p */
+ ELF_ARCH, /* arch */
+ elf_info_to_howto, /* elf_info_to_howto */
+#ifdef elf_info_to_howto_rel
+ elf_info_to_howto_rel, /* elf_info_to_howto_rel */
+#else
+ 0, /* elf_info_to_howto_rel */
+#endif
};
#ifdef TARGET_BIG_SYM
#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>
((__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;
-};
+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:
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_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);
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
+assemble_3 (x)
unsigned int x;
{
- return ( ( (x & 1 ) << 2 ) | ( ( x & 6 ) >> 1 ) ) & 7;
+ return (((x & 1) << 2) | ((x & 6) >> 1)) & 7;
}
-void dis_assemble_3(x,r)
+void
+dis_assemble_3 (x, r)
unsigned int x;
unsigned int *r;
{
- *r = ( ( (x & 4 ) >> 2 ) | ( ( x & 3 ) << 1 ) ) & 7;
+ *r = (((x & 4) >> 2) | ((x & 3) << 1)) & 7;
}
-unsigned int assemble_12(x,y)
- unsigned int x,y;
+unsigned int
+assemble_12 (x, y)
+ unsigned int x, y;
{
- return ( ( ( y & 1 ) << 11 ) | ( ( x & 1 ) << 10 ) | ( ( x & 0x7fe ) >> 1) ) & 0xfff;
+ return (((y & 1) << 11) | ((x & 1) << 10) | ((x & 0x7fe) >> 1)) & 0xfff;
}
-void dis_assemble_12(as12,x,y)
+void
+dis_assemble_12 (as12, x, y)
unsigned int as12;
- unsigned int *x,*y;
+ unsigned int *x, *y;
{
- *y = ( as12 & 0x800 ) >> 11;
- *x = ( ( as12 & 0x3ff ) << 1 ) | ( ( as12 & 0x400 ) >> 10 );
+ *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
+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);
+ temp = ((z & 1) << 16) |
+ ((x & 0x1f) << 11) |
+ ((y & 1) << 10) |
+ ((y & 0x7fe) >> 1);
return temp & 0x1ffff;
}
-void dis_assemble_17(as17,x,y,z)
+void
+dis_assemble_17 (as17, x, y, z)
unsigned int as17;
- unsigned int *x,*y,*z;
+ unsigned int *x, *y, *z;
{
- *z = ( as17 & 0x10000 ) >> 16;
- *x = ( as17 & 0x0f800 ) >> 11;
- *y = ( ( ( as17 & 0x00400 ) >> 10 ) | ( ( as17 & 0x3ff ) << 1 ) ) & 0x7ff;
+ *z = (as17 & 0x10000) >> 16;
+ *x = (as17 & 0x0f800) >> 11;
+ *y = (((as17 & 0x00400) >> 10) | ((as17 & 0x3ff) << 1)) & 0x7ff;
}
-unsigned long assemble_21(x)
+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 );
+ 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;
+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;
+ temp = (as21 & 0x100000) >> 20;
+ temp |= (as21 & 0x0ffe00) >> 8;
+ temp |= (as21 & 0x000180) << 7;
+ temp |= (as21 & 0x00007c) << 14;
+ temp |= (as21 & 0x000003) << 12;
*x = temp;
}
-unsigned long sign_ext(x,len)
- unsigned int x,len;
+#if 0
+unsigned long
+sign_ext (x, len)
+ unsigned int x, len;
{
unsigned int sign;
unsigned int result;
i = 0;
len_ones = 0;
- while ( i < len ) {
- len_ones = (len_ones << 1) | 1;
- i++;
- }
+ while (i < len)
+ {
+ len_ones = (len_ones << 1) | 1;
+ i++;
+ }
- sign = (x >> (len-1)) & 1;
+ sign = (x >> (len - 1)) & 1;
- if ( sign )
- result = ( ~0 ^ len_ones ) | ( len_ones & x );
+ if (sign)
+ result = (~0 ^ len_ones) | (len_ones & x);
else
result = len_ones & x;
return result;
}
-static unsigned int ones(n)
+#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;
i = 0;
len_ones = 0;
- while ( i < n ) {
- len_ones = (len_ones << 1) | 1;
- i++;
- }
+ while (i < n)
+ {
+ len_ones = (len_ones << 1) | 1;
+ i++;
+ }
return len_ones;
}
-void sign_unext(x,len,result)
- unsigned int x,len;
+void
+sign_unext (x, len, result)
+ unsigned int x, len;
unsigned int *result;
{
unsigned int len_ones;
- len_ones = ones(len);
+ len_ones = ones (len);
*result = x & len_ones;
}
-unsigned long low_sign_ext(x,len)
- unsigned int x,len;
+unsigned long
+low_sign_ext (x, len)
+ unsigned int x, len;
{
- unsigned int temp1,temp2;
+ unsigned int temp1, temp2;
unsigned int len_ones;
- len_ones = ones(len);
+ len_ones = ones (len);
- temp1 = ( x & 1 ) << (len-1);
- temp2 = ( ( x & 0xfffffffe ) & len_ones ) >> 1;
- return sign_ext( (temp1 | temp2),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;
+void
+low_sign_unext (x, len, result)
+ unsigned int x, len;
unsigned int *result;
{
unsigned int temp;
unsigned int one_bit_at_len;
unsigned int len_ones;
- len_ones = ones(len);
- one_bit_at_len = 1 << (len-1);
+ len_ones = ones (len);
+ one_bit_at_len = 1 << (len - 1);
- sign_unext(x,len,&temp);
+ sign_unext (x, len, &temp);
sign = temp & one_bit_at_len;
- sign >>= (len-1);
+ sign >>= (len - 1);
- rest = temp & ( len_ones ^ one_bit_at_len );
+ rest = temp & (len_ones ^ one_bit_at_len);
rest <<= 1;
*result = rest | sign;
/* These work when 'y' is a power of two only. */
-long
-round_down(x,y)
-long x,y;
+static long
+round_down (x, y)
+ long x, y;
{
- return x & ~(y-1);
+ return x & ~(y - 1);
}
-long
-round(x,y)
-long x,y;
+static long
+round (x, y)
+ long x, y;
{
- return (x + y/2) & ~(y-1);
+ return (x + y / 2) & ~(y - 1);
}
-long
-round_up(x,y)
-long x,y;
+static long
+round_up (x, y)
+ long x, y;
{
- return x - (x | ~(y-1));
+ return x - (x | ~(y - 1));
}
/* L(Symbol, Addend): */
/* round_down (Symbol + Addend, 2048) */
-long
-L(Symbol, Addend)
+static long
+L (Symbol, Addend)
{
- return (round_down(Symbol + Addend, 2048)) >> 11;
+ return (round_down (Symbol + Addend, 2048)) >> 11;
}
/* R(Symbol, Addend): */
/* Symbol + Addend - round_down (Symbol + Addend, 2048) */
-long
-R(Symbol, Addend)
+static long
+R (Symbol, Addend)
{
- return Symbol + Addend - round_down (Symbol + Addend, 2048);
+ return Symbol + Addend - round_down (Symbol + Addend, 2048);
}
/* LS(Symbol, Addend): */
/* round (Symbol + Addend, 2048) */
-long
-LS(Symbol, Addend)
+static long
+LS (Symbol, Addend)
{
- return round (Symbol + Addend, 2048);
+ return round (Symbol + Addend, 2048);
}
/* RS(Symbol, Addend): */
/* Symbol + Addend - round (Symbol + Addend, 2048) */
-long
-RS(Symbol, Addend)
+static long
+RS (Symbol, Addend)
{
- return Symbol + Addend - round (Symbol + Addend, 2048);
+ return Symbol + Addend - round (Symbol + Addend, 2048);
}
/* LD(Symbol, Addend): */
/* round_up (Symbol + Addend, 2048) */
-long
-LD(Symbol, Addend)
+static long
+LD (Symbol, Addend)
{
- return (round_up (Symbol + Addend, 2048)) >> 11;
+ return (round_up (Symbol + Addend, 2048)) >> 11;
}
/* RD(Symbol, Addend): */
/* Symbol + Addend - round_up (Symbol + Addend, 2048) */
-long
-RD(Symbol, Addend)
+static long
+RD (Symbol, Addend)
{
- return Symbol + Addend - round_up (Symbol + Addend, 2048);
+ return Symbol + Addend - round_up (Symbol + Addend, 2048);
}
/* LR(Symbol, Addend): */
/* round_down (Symbol, 2048) + round (Addend, 8192) */
-long
-LR(Symbol, Addend)
+static long
+LR (Symbol, Addend)
{
- return (round_down (Symbol, 2048) + round (Addend, 8192)) >> 11;
+ return (round_down (Symbol, 2048) + round (Addend, 8192)) >> 11;
}
/* RR(Symbol, Addend): */
/* Symbol - round_down (Symbol, 2048) + */
/* Addend - round (Addend, 8192) */
-long
-RR(Symbol, Addend)
+static long
+RR (Symbol, Addend)
{
- return Symbol
- - round_down (Symbol, 2048)
- + Addend - round (Addend, 8192);
+ 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)
+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;
+ 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
+ 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
+ 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;
+ value += 0x800;
+ value = (value & 0xfffff800) >> 11;
+ BFD_ASSERT (value == LD (init_value, constant_value));
+ break;
- default:
- fprintf(stderr,"Unrecognized field_selector 0x%02x\n", r_field);
- 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;
-
+
}
/* End of miscellaneous support functions. */
-#endif /* HOST_HPPAHPUX */
#ifdef HOST_HPPABSD
- /* All the core file code for BSD needs to be rewritten cleanly. For
+/* 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
(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_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,
- },
+ 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
};
#include "elf/internal.h"
#include "elf/external.h"
-#ifdef __STDC__
-#define CAT3(a,b,c) a##b##c
-#else
-#define CAT3(a,b,c) a/**/b/**/c
-#endif
-
-#if ARCH_SIZE==64
#ifndef NAME
+#if ARCH_SIZE==64
#define NAME(x,y) CAT3(x,64_,y)
-#endif
#else /* ARCH_SIZE==32 */
-#ifndef NAME
#define NAME(x,y) CAT3(x,32_,y)
#endif
#endif
+#define ElfNAME(X) NAME(Elf,X)
+#define elfNAME(X) NAME(elf,X)
+
typedef struct
{
asymbol symbol;
- NAME(Elf,Internal_Sym) internal_elf_sym;
- NAME(Elf,External_Sym) native_elf_sym;
+ ElfNAME (Internal_Sym) internal_elf_sym;
+ ElfNAME (External_Sym) native_elf_sym;
/* these are used for the generation of .stabX symbols (?) */
short desc;
unsigned char type;
char other;
-} NAME(elf,symbol_type);
+ union
+ {
+ unsigned int hppa_arg_reloc;
+ PTR any;
+ }
+ tc_data;
+}
-struct NAME(elf,backend_data) {
- void (*elf_info_to_howto) PARAMS ((bfd *, arelent *,
- NAME(Elf,Internal_Rela) *));
+elfNAME (symbol_type);
+
+/* Lacking nested functions and nested types, set up for mapping over
+ BFD sections to produce ELF sections. */
+typedef struct
+{
+ ElfNAME (Internal_Ehdr) * i_ehdr;
+ ElfNAME (Internal_Shdr) * i_shdrp;
+ struct strtab *shstrtab;
+ int symtab_section;
+}
+
+elf_sect_thunk;
+
+struct elfNAME(backend_data)
+{
+ int use_rela_p;
+ int elf_64_p;
enum bfd_architecture arch;
+ void (*elf_info_to_howto) PARAMS ((bfd *, arelent *,
+ ElfNAME (Internal_Rela) *));
+ void (*elf_info_to_howto_rel) PARAMS ((bfd *, arelent *,
+ ElfNAME (Internal_Rel) *));
/* @@ I really don't think this should be here. I don't know what
global_sym is supposed to be used for, but I doubt it's something
that would be considered global, e.g., if you've got a program
reading and writing many BFDs. My hunch is that it's specific to
the output BFD. If not, put a comment here explaining why. */
- NAME(elf,symbol_type) *global_sym;
+ elfNAME (symbol_type) * global_sym;
};
extern bfd_target *bfd_elf32_object_p PARAMS ((bfd *));
extern boolean bfd_elf32_set_section_contents PARAMS ((bfd *, sec_ptr, PTR,
file_ptr,
bfd_size_type));
+
+extern boolean elf_get_sect_thunk PARAMS ((bfd *, elf_sect_thunk *));
extern unsigned int bfd_elf32_get_symtab_upper_bound PARAMS ((bfd *));
extern unsigned int bfd_elf32_get_symtab PARAMS ((bfd *, asymbol **));
extern unsigned int bfd_elf32_get_reloc_upper_bound PARAMS ((bfd *, sec_ptr));
extern void bfd_elf32_print_symbol PARAMS ((bfd *, PTR, asymbol *,
bfd_print_symbol_type));
extern void bfd_elf32_get_symbol_info PARAMS ((bfd *, asymbol *,
- symbol_info *));
+ symbol_info *));
extern alent *bfd_elf32_get_lineno PARAMS ((bfd *, asymbol *));
extern boolean bfd_elf32_set_arch_mach PARAMS ((bfd *, enum bfd_architecture,
unsigned long));
CONST char **,
unsigned int *));
extern int bfd_elf32_sizeof_headers PARAMS ((bfd *, boolean));
+extern unsigned long elf_hash PARAMS ((CONST unsigned char *));
/* If the target doesn't have reloc handling written yet: */
extern void bfd_elf32_no_info_to_howto PARAMS ((bfd *, arelent *,
Elf32_Internal_Rela *));
+#define get_elf_backend_data(abfd) \
+ ((struct elfNAME (backend_data) *) (abfd)->xvec->backend_data)
+
+struct strtab
+{
+ char *tab;
+ int nentries;
+ int length;
+};
+
+extern struct elf32_internal_shdr *
+bfd_elf_locate_sh PARAMS ((bfd *, struct strtab *,
+ struct elf32_internal_shdr *, CONST char *));
+
#endif /* _LIBELF_H_ */
projects / binutils-gdb.git / commitdiff