path: root/bfd/elf32-hppa.h

/* 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 */