elfcode.h
This commit is contained in:
Ken Raeburn
parent
cef91d759c
commit
7050286db6
|
|
@ -1,3 +1,67 @@
|
|||
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'!
|
||||
|
|
|
|||
|
|
@ -0,0 +1,464 @@
|
|||
/* 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 */
|
||||
|
|
@ -54,8 +54,19 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
|
||||
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
|
||||
|
|
|
|||
531
bfd/hppa.c
531
bfd/hppa.c
|
|
@ -38,7 +38,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
#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>
|
||||
|
||||
|
|
@ -70,10 +70,11 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
((__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)
|
||||
|
|
@ -87,17 +88,19 @@ 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;
|
||||
|
|
@ -113,17 +116,17 @@ hppa_object_setup (abfd, file_hdrp, aux_hdrp)
|
|||
|
||||
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;
|
||||
|
|
@ -133,23 +136,23 @@ hppa_object_setup (abfd, file_hdrp, aux_hdrp)
|
|||
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;
|
||||
|
|
@ -174,11 +177,11 @@ make_unique_section (abfd, name, num)
|
|||
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;
|
||||
|
|
@ -199,7 +202,7 @@ setup_sections (abfd, file_hdr)
|
|||
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)
|
||||
|
|
@ -222,7 +225,7 @@ setup_sections (abfd, file_hdr)
|
|||
|
||||
/* 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;
|
||||
|
|
@ -237,15 +240,15 @@ setup_sections (abfd, file_hdr)
|
|||
|
||||
/* 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
|
||||
|
|
@ -277,7 +280,7 @@ setup_sections (abfd, file_hdr)
|
|||
|
||||
/* 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;
|
||||
|
|
@ -297,10 +300,10 @@ setup_sections (abfd, file_hdr)
|
|||
/* 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;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -311,7 +314,7 @@ hppa_object_p (abfd)
|
|||
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))
|
||||
|
|
@ -322,7 +325,7 @@ hppa_object_p (abfd)
|
|||
|
||||
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:
|
||||
|
|
@ -345,19 +348,19 @@ hppa_object_p (abfd)
|
|||
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 ();
|
||||
|
|
@ -365,8 +368,8 @@ DEFUN(hppa_mkobject,(abfd),
|
|||
}
|
||||
|
||||
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);
|
||||
|
|
@ -424,15 +427,15 @@ 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;
|
||||
}
|
||||
|
||||
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;
|
||||
|
|
@ -464,7 +467,7 @@ hppa_set_section_contents (abfd, section, location, offset, count)
|
|||
{
|
||||
fprintf (stderr, "hppa_set_section_contents unimplimented\n");
|
||||
fflush (stderr);
|
||||
abort();
|
||||
abort ();
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -477,7 +480,7 @@ hppa_set_arch_mach (abfd, arch, 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
|
||||
|
|
@ -499,8 +502,8 @@ hppa_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
|
|||
|
||||
static int
|
||||
hppa_sizeof_headers (abfd, reloc)
|
||||
bfd *abfd;
|
||||
boolean reloc;
|
||||
bfd *abfd;
|
||||
boolean reloc;
|
||||
{
|
||||
fprintf (stderr, "hppa_sizeof_headers unimplemented\n");
|
||||
fflush (stderr);
|
||||
|
|
@ -546,19 +549,19 @@ hppa_core_file_p (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;
|
||||
|
|
@ -566,9 +569,9 @@ hppa_core_file_p (abfd)
|
|||
{
|
||||
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;
|
||||
|
|
@ -578,7 +581,7 @@ hppa_core_file_p (abfd)
|
|||
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);
|
||||
|
|
@ -588,7 +591,7 @@ hppa_core_file_p (abfd)
|
|||
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);
|
||||
|
|
@ -626,93 +629,105 @@ hppa_core_file_failing_signal (abfd)
|
|||
|
||||
/* 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;
|
||||
|
|
@ -721,22 +736,32 @@ unsigned long sign_ext(x,len)
|
|||
|
||||
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;
|
||||
|
|
@ -744,40 +769,44 @@ static unsigned int ones(n)
|
|||
|
||||
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;
|
||||
|
|
@ -786,14 +815,14 @@ void low_sign_unext(x,len,result)
|
|||
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;
|
||||
|
|
@ -801,177 +830,177 @@ void low_sign_unext(x,len,result)
|
|||
|
||||
/* 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;
|
||||
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_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_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_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
|
||||
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;
|
||||
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_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_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;
|
||||
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;
|
||||
}
|
||||
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
|
||||
|
|
@ -1013,32 +1042,32 @@ 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_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,
|
||||
|
|
@ -1046,7 +1075,7 @@ _do_getb64, _do_getb_signed_64, _do_putb64,
|
|||
bfd_false,
|
||||
},
|
||||
#undef hppa
|
||||
JUMP_TABLE(hppa),
|
||||
JUMP_TABLE (hppa),
|
||||
(PTR) 0
|
||||
};
|
||||
|
||||
|
|
|
|||
71
bfd/libelf.h
71
bfd/libelf.h
|
|
@ -25,44 +25,64 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
#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
|
||||
|
||||
#ifndef NAME
|
||||
#if ARCH_SIZE==64
|
||||
#ifndef NAME
|
||||
#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 *));
|
||||
|
|
@ -76,6 +96,8 @@ extern boolean bfd_elf32_core_file_matches_executable_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));
|
||||
|
|
@ -86,7 +108,7 @@ extern asymbol *bfd_elf32_make_empty_symbol PARAMS ((bfd *));
|
|||
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));
|
||||
|
|
@ -96,9 +118,24 @@ extern boolean bfd_elf32_find_nearest_line PARAMS ((bfd *, asection *,
|
|||
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_ */
|
||||
|
|
|
|||
Loading…
Reference in New Issue