darlinghq/darling-gdb
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-gdb.git synced 2024-11-29 15:00:34 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
2edc8357de
darling-gdb/bfd/elf32-hppa.h
Ken Raeburn d9ad93bce5 More patches from Jeff Law, plus a little cleanup of my own. 
These changes separate PA-SOM support from PA-ELF support.
A sun4-x-hppaosf assembler can now be built.

* elf32-hppa.c (elf_hppa_howto_table): Now static.
(symext_rootP, symext_lastP, global_value, GOT_value, global_symbol,
global_sym_defined, symextn_contents, symextn_contents_real_size,
elf_hppa_stub_rootP, elf32_hppa_symextn_map, elf32_hppa_symextn_map_size): Rely
on default initialization.
(hppa_elf_gen_reloc_type): Macro "UNDEFINED" doesn't need a trailing semicolon.
(hppa_look_for_stubs_in_section): Introduce temporaries to make code more
readable in 80 columns.

* libhppa.h (all functions): Now inline under GNU C.

* elf32-hppa.c (AR_WARN): Give argument which caused the invalid argument
relocation.
(AR_UNIMP): Delete unused macro.
(hppa_elf_set_section_contents): Always return a value.
(elf32_hppa_backend_table_processing): Likewise.
(elf32_hppa_backend_section_processing: Likewise.

* som.c: New file containing SOM specific code extracted from hppa.c

* som.h: New file containing SOM specific code extracted from libhppa.h

* hppa.c: Deleted.

* libhppa.h: Delete SOM specific code.  Add generic PA code which can be shared
by both SOM and ELF backends.

* Makefile.in: Replace hppa.c with som.c.  elf32-hppa.o depends on libhppa.h
now.

* configure.in (hppa_vec): Needs som.o module instead of hppa.o.

* elf32-hppa.c: Include libhppa.h.  Do not define BYTES_IN_WORD.

* elf32-hppa.h (hppa_reloc_field_selector_type): Delete now lives in libhppa.h.
(hppa_reloc_field_selector_type_alt): Likewise.

* elf32-hppa.c (hppa_elf_relocate_unwind_table): Delete unused variables.
(elf_hppa_reloc_type_lookup): Likewise.
(elf_hppa_tc_make_sections): Likewise.
(hppa_elf_arg_reloc_needed_p): Likewise.
(hppa_elf_build_long_branch_stub): Likewise.
(elf_reloc_map): Delete, no longer used.
(elf_hppa_reloc_map): Likewise.
(elf32_hppa_symextn_map_max_size): Likewise.
(elf32_hppa_get_sym_extn): Abort if type is bogus.

* elf32-hppa.c (elf32_hppa_backend_fake_sections): Add processing
of the .hppa_unwind section.
1993-08-28 00:10:54 +00:00

419 lines
16 KiB
C
Raw Blame History

/* 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_STUB_CALL_17, /* Symbol + Addend 17 */
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
/* 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 elf_hppa_tc_symbol PARAMS ((bfd *, elf32_symbol_type *, int));
extern void elf_hppa_tc_make_sections PARAMS ((bfd *, PTR));
typedef Elf32_Word symext_entryS;
struct symext_chain
{
symext_entryS entry;
struct symext_chain *next;
};
typedef struct symext_chain symext_chainS;
#endif /* _ELF32_HPPA_H */
Reference in New Issue View Git Blame Copy Permalink