More patches from Jeff Law, plus a little cleanup of my own.
[external/binutils.git] / bfd / elf32-hppa.h
1 /* ELF32/HPPA relocation support
2
3         This file contains ELF32/HPPA relocation support as specified
4         in the Stratus FTX/Golf Object File Format (SED-1762) dated
5         November 19, 1992.
6 */
7
8
9 /*
10         Copyright (C) 1990-1991 Free Software Foundation, Inc.
11
12         Written by:
13         
14         Center for Software Science
15         Department of Computer Science
16         University of Utah
17
18 This file is part of BFD, the Binary File Descriptor library.
19
20 This program is free software; you can redistribute it and/or modify
21 it under the terms of the GNU General Public License as published by
22 the Free Software Foundation; either version 2 of the License, or
23 (at your option) any later version.
24
25 This program is distributed in the hope that it will be useful,
26 but WITHOUT ANY WARRANTY; without even the implied warranty of
27 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
28 GNU General Public License for more details.
29
30 You should have received a copy of the GNU General Public License
31 along with this program; if not, write to the Free Software
32 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
33
34 #ifndef _ELF32_HPPA_H
35 #define _ELF32_HPPA_H
36
37 #include "libelf.h"
38
39 /* 9.3.3. Parameter relocation information      */
40
41 /* As mentioned previously, relocations of calls must be accompanied    */
42 /* by parameter relocation information, indicating which registers the  */
43 /* first for parameter words, and the return value, are located in.     */
44 /* This information accompanies the R_HPPA_ABS_CALL..,                  */
45 /* R_HPPA_PCREL_CALL...  and R_HPPA_PUSH_PROC relocation types,         */
46 /* described below.  The information is kept in the high-order 10 bits  */
47 /* of Elf32_rela.r_addend, while the low-order 22 bits are a signed     */
48 /* constant to be used in calculating the call target.  The following   */
49 /* macros are used to extract and combine these data in r_addend.       */
50
51 #define ELF32_HPPA_R_ARG_RELOC(a)       (((a) >> 22) & 0x3FF)
52 #define ELF32_HPPA_R_CONSTANT(a)        ((((Elf32_Sword)(a)) << 10) >> 10)
53 #define ELF32_HPPA_R_ADDEND(r,c)        (((r) << 22) + ((c) & 0x3FFFFF))
54
55 /* ELF/HPPA relocation types */
56
57 /*      name                            expression           format     */
58 /*      --------------------------------------------------------------  */
59 typedef enum
60   {
61     /* 9.3.4. Address relocation types */
62
63     /* These relocation types do simple base+offset relocations, and are */
64     /* normally used for absolute references to data. */
65
66     /* By convention, relocation type zero is always "no relocation", */
67     /* while type one is 32-bit word relocation. */
68
69     R_HPPA_NONE,                /*              -                       -       */
70
71     R_HPPA_32,                  /*              Symbol + Addend         32      */
72     R_HPPA_11,                  /*              Symbol + Addend         11      */
73     R_HPPA_14,                  /*              Symbol + Addend         11      */
74     R_HPPA_17,                  /*              Symbol + Addend         11      */
75     R_HPPA_L21,                 /*              L (Symbol, Addend)      21      */
76     R_HPPA_R11,                 /*              R (Symbol, Addend)      11      */
77     R_HPPA_R14,                 /*              R (Symbol, Addend)      14      */
78     R_HPPA_R17,                 /*              R (Symbol, Addend)      17      */
79     R_HPPA_LS21,                /*              LS(Symbol, Addend)      21      */
80     R_HPPA_RS11,                /*              RS(Symbol, Addend)      11      */
81     R_HPPA_RS14,                /*              RS(Symbol, Addend)      14      */
82     R_HPPA_RS17,                /*              RS(Symbol, Addend)      17      */
83     R_HPPA_LD21,                /*              LD(Symbol, Addend)      21      */
84     R_HPPA_RD11,                /*              RD(Symbol, Addend)      11      */
85     R_HPPA_RD14,                /*              RD(Symbol, Addend)      14      */
86     R_HPPA_RD17,                /*              RD(Symbol, Addend)      17      */
87     R_HPPA_LR21,                /*              LR(Symbol, Addend)      21      */
88     R_HPPA_RR14,                /*              RR(Symbol, Addend)      14      */
89     R_HPPA_RR17,                /*              RR(Symbol, Addend)      17      */
90
91     /* 9.3.5. GOTOFF address relocation types           */
92
93     /* The Global Offset Table (GOT) is a table of pointers to data, but */
94     /* its address can also be used as a base pointer to address data, */
95     /* similar to the way the DP is used in HP/UX.  The expression */
96     /* calculation yields a signed offset of an address from the GOT. */
97
98     R_HPPA_GOTOFF_11,           /*      Symbol - GOT + Addend   11      */
99     R_HPPA_GOTOFF_14,           /*      Symbol - GOT + Addend   14      */
100     R_HPPA_GOTOFF_L21,          /*      L (Sym - GOT, Addend)   21      */
101     R_HPPA_GOTOFF_R11,          /*      R (Sym - GOT, Addend)   11      */
102     R_HPPA_GOTOFF_R14,          /*      R (Sym - GOT, Addend)   14      */
103     R_HPPA_GOTOFF_LS21,         /*      LS(Sym - GOT, Addend)   21      */
104     R_HPPA_GOTOFF_RS11,         /*      RS(Sym - GOT, Addend)   11      */
105     R_HPPA_GOTOFF_RS14,         /*      RS(Sym - GOT, Addend)   14      */
106     R_HPPA_GOTOFF_LD21,         /*      LD(Sym - GOT, Addend)   21      */
107     R_HPPA_GOTOFF_RD11,         /*      RD(Sym - GOT, Addend)   11      */
108     R_HPPA_GOTOFF_RD14,         /*      RD(Sym - GOT, Addend)   14      */
109     R_HPPA_GOTOFF_LR21,         /*      LR(Sym - GOT, Addend)   21      */
110     R_HPPA_GOTOFF_RR14,         /*      RR(Sym - GOT, Addend)   14      */
111
112     /* 9.3.6. Absolute call relocation types    */
113
114     /* Relocations of function calls must be accompanied by parameter */
115     /* relocation information.  This information is carried in the ten */
116     /* high-order bits of the addend field.  The remaining 22 bits of */
117     /* of the addend field are sign-extended to form the Addend. */
118
119     R_HPPA_ABS_CALL_11,         /*      Symbol + Addend         11      */
120     R_HPPA_ABS_CALL_14,         /*      Symbol + Addend         14      */
121     R_HPPA_ABS_CALL_17,         /*      Symbol + Addend         17      */
122     R_HPPA_ABS_CALL_L21,        /*      L (Symbol, Addend)      21      */
123     R_HPPA_ABS_CALL_R11,        /*      R (Symbol, Addend)      11      */
124     R_HPPA_ABS_CALL_R14,        /*      R (Symbol, Addend)      14      */
125     R_HPPA_ABS_CALL_R17,        /*      R (Symbol, Addend)      17      */
126     R_HPPA_ABS_CALL_LS21,       /*      LS(Symbol, Addend)      21      */
127     R_HPPA_ABS_CALL_RS11,       /*      RS(Symbol, Addend)      11      */
128     R_HPPA_ABS_CALL_RS14,       /*      RS(Symbol, Addend)      14      */
129     R_HPPA_ABS_CALL_RS17,       /*      RS(Symbol, Addend)      17      */
130     R_HPPA_ABS_CALL_LD21,       /*      LD(Symbol, Addend)      21      */
131     R_HPPA_ABS_CALL_RD11,       /*      RD(Symbol, Addend)      11      */
132     R_HPPA_ABS_CALL_RD14,       /*      RD(Symbol, Addend)      14      */
133     R_HPPA_ABS_CALL_RD17,       /*      RD(Symbol, Addend)      17      */
134     R_HPPA_ABS_CALL_LR21,       /*      LR(Symbol, Addend)      21      */
135     R_HPPA_ABS_CALL_RR14,       /*      RR(Symbol, Addend)      14      */
136     R_HPPA_ABS_CALL_RR17,       /*      RR(Symbol, Addend)      17      */
137
138     /* 9.3.7. PC-relative call relocation types */
139
140     /* PC-relative relocation calculates the difference between an address */
141     /* and the location being relocated.  This is most often used to */
142     /* relocate pc-relative calls.      */
143
144     /* As with the ABS_CALL relocation types, the ten high-order bits of */
145     /* the addend field carry parameter relocation information, while */
146     /* the low-order 22 bits are sign-extended to form the Addend.      */
147
148     R_HPPA_PCREL_CALL_11,       /*      Symbol - PC + Addend    11      */
149     R_HPPA_PCREL_CALL_14,       /*      Symbol - PC + Addend    14      */
150     R_HPPA_PCREL_CALL_17,       /*      Symbol - PC + Addend    17      */
151     R_HPPA_PCREL_CALL_12,       /*      Symbol - PC + Addend    12      */
152     R_HPPA_PCREL_CALL_L21,      /*      L (Symbol - PC, Addend) 21      */
153     R_HPPA_PCREL_CALL_R11,      /*      R (Symbol - PC, Addend) 11      */
154     R_HPPA_PCREL_CALL_R14,      /*      R (Symbol - PC, Addend) 14      */
155     R_HPPA_PCREL_CALL_R17,      /*      R (Symbol - PC, Addend) 17      */
156     R_HPPA_PCREL_CALL_LS21,     /*      LS(Symbol - PC, Addend) 21      */
157     R_HPPA_PCREL_CALL_RS11,     /*      RS(Symbol - PC, Addend) 11      */
158     R_HPPA_PCREL_CALL_RS14,     /*      RS(Symbol - PC, Addend) 14      */
159     R_HPPA_PCREL_CALL_RS17,     /*      RS(Symbol - PC, Addend) 17      */
160     R_HPPA_PCREL_CALL_LD21,     /*      LD(Symbol - PC, Addend) 21      */
161     R_HPPA_PCREL_CALL_RD11,     /*      RD(Symbol - PC, Addend) 11      */
162     R_HPPA_PCREL_CALL_RD14,     /*      RD(Symbol - PC, Addend) 14      */
163     R_HPPA_PCREL_CALL_RD17,     /*      RD(Symbol - PC, Addend) 17      */
164     R_HPPA_PCREL_CALL_LR21,     /*      LR(Symbol - PC, Addend) 21      */
165     R_HPPA_PCREL_CALL_RR14,     /*      RR(Symbol - PC, Addend) 14      */
166     R_HPPA_PCREL_CALL_RR17,     /*      RR(Symbol - PC, Addend) 17      *//* #69 */
167
168     /* 9.3.8. Plabel relocation types */
169
170     /* Plabels are designed to allow code pointers to be passed between */
171     /* spaces.  The addend of the relocation should be either 0 (no static */
172     /* link) or 2 (static link required).  These relocations correspond to */
173     /* the P%, LP% and RP% field selectors.  [Description is incomplete] */
174
175     R_HPPA_PLABEL_32,           /*      F(Plabel(Symbol,Addend),0)      32      */
176     R_HPPA_PLABEL_11,           /*      F(Plabel(Symbol,Addend),0)      11      */
177     R_HPPA_PLABEL_14,           /*      F(Plabel(Symbol,Addend),0)      14      */
178     R_HPPA_PLABEL_L21,          /*      L(Plabel(Symbol,Addend),0)      21      */
179     R_HPPA_PLABEL_R11,          /*      R(Plabel(Symbol,Addend),0)      11      */
180     R_HPPA_PLABEL_R14,          /*      R(Plabel(Symbol,Addend),0)      14      */
181
182     /* 9.3.9. Data linkage table (DLT) relocation types */
183
184     /* SOM DLT_REL fixup requests are used to for static data references        */
185     /* from position-independent code within shared libraries.  They are        */
186     /* similar to the GOT relocation types in some SVR4 implementations.        */
187     /* [Prose to come]  */
188
189     R_HPPA_DLT_32,              /*      F(DLTOFF)                       32      */
190     R_HPPA_DLT_11,              /*      F(DLTOFF)                       11      */
191     R_HPPA_DLT_14,              /*      F(DLTOFF)                       14      */
192     R_HPPA_DLT_L21,             /*      L(DLTOFF)                       21      */
193     R_HPPA_DLT_R11,             /*      R(DLTOFF)                       11      */
194     R_HPPA_DLT_R14,             /*      R(DLTOFF)                       14      */
195
196     /* 9.3.10. Relocations for unwinder tables  */
197
198     /* As described above, the unwinder table consists of a series of   */
199     /* four-word entries, the first two of which are a pair of code     */
200     /* addresses.  While it would be possible to relocate this table using      */
201     /* just R_HPPA_32, the amount of relocation data resulting would be */
202     /* very large.  To reduce that data, the following relocation types */
203     /* have been defined.       */
204
205     /* The first, R_HPPA_UNWIND_ENTRY, merely compresses two R_HPPA_32  */
206     /* operations into one.  It is designed for use in .rel-type        */
207     /* relocations, where the two 32-bit addends are taken from the unwind      */
208     /* section itself.  */
209
210     /* The second, which is designed for use in .rela-type relocations, is      */
211     /* designed to relocate an entire unwinder table with one relocation        */
212     /* entry.  It has the effect of multiple R_HPPA_UNWIND_ENTRY        */
213     /* relocations applied to successive unwinder table entries.  The   */
214     /* number of entries to be relocated is given in the r_addend field of      */
215     /* the relocation entry.  The rest of the relocation entry is used in       */
216     /* a normal way--r_offset is the offset of the first unwind entry in        */
217     /* the section, while ELF32_R_SYM(r_info) is the code section that all      */
218     /* the code addresses should be relocated from.     */
219
220     R_HPPA_UNWIND_ENTRY,        /*                                      "128"   */
221     R_HPPA_UNWIND_ENTRIES,      /*                              Addend * "128"  */
222
223     /*  9.3.11. Relocation types for complex expressions        */
224
225     /* As described above, new-format SOM fixups support complex */
226     /* expressions by spreading the parts of the expression across */
227     /* multiple entries.  ELF for HPPA will have a similar mechanism, */
228     /* although support for it may be optional.  There are two main */
229     /* reasons for defining it:  first, the need to translate complex */
230     /* SOM fixup expressions to ELF, and second, to cover combinations */
231     /* of expression, field and format not available with other */
232     /* relocation types. */
233
234     /* ELF expression relocation entries are interpreted as postfix-form */
235     /* expressions.  They may be evaluated using a push-down stack. */
236
237     /* Usually, the addend field of these expression relocation entries is */
238     /* unused, with the following exceptions: */
239
240     /* R_HPPA_PUSH_CONST: The addend field contains the constant. */
241
242     /* R_HPPA_PUSH_PROC: The high-order 10 bits of the addend field */
243     /* contain parameter relocation information.  The rest of */
244     /* the addend field is unused. */
245
246     /* R_HPPA_LSHIFT, R_HPPA_ARITH_RSHIFT and R_HPPA_LOGIC_RSHIFT: */
247     /* The addend field normally gives the amount to shift. */
248     /* However, if that amount is zero, the shift amount is */
249     /* popped from the top of the stack prior to popping the */
250     /* amount to be shifted. */
251
252     /*  name                    expression                      fld/fmt */
253     /* -------------------------------------------------------------------      */
254     R_HPPA_PUSH_CONST,          /*      push Addend                     -   -   */
255     R_HPPA_PUSH_PC,             /*      push PC + Addend                -   -   */
256     R_HPPA_PUSH_SYM,            /*      push Symbol + Addend            -   -   */
257     R_HPPA_PUSH_GOTOFF,         /*      push Symbol - GOT + Addend      -   -   */
258     R_HPPA_PUSH_ABS_CALL,       /*      push Symbol + Addend            -   -   */
259     R_HPPA_PUSH_PCREL_CALL,     /*      push Symbol - PC + Addend       -   -   */
260     R_HPPA_PUSH_PLABEL,         /*      push Plabel(Symbol)             -   -   */
261     R_HPPA_MAX,                 /*      pop A and B, push max(B,A)      -   -   */
262     R_HPPA_MIN,                 /*      pop A and B, push min(B,A)      -   -   */
263     R_HPPA_ADD,                 /*      pop A and B, push B + A         -   -   */
264     R_HPPA_SUB,                 /*      pop A and B, push B - A         -   -   */
265     R_HPPA_MULT,                /*      pop A and B, push B * A         -   -   */
266     R_HPPA_DIV,                 /*      pop A and B, push B / A         -   -   */
267     R_HPPA_MOD,                 /*      pop A and B, push B % A         -   -   */
268     R_HPPA_AND,                 /*      pop A and B, push B & A         -   -   */
269     R_HPPA_OR,                  /*      pop A and B, push B | A         -   -   */
270     R_HPPA_XOR,                 /*      pop A and B, push B ^ A         -   -   */
271     R_HPPA_NOT,                 /*      pop A, push ~A                  -   -   */
272     R_HPPA_LSHIFT,              /*      pop A, push A << Addend         -   -   */
273     R_HPPA_ARITH_RSHIFT,        /*      pop A, push A >> Addend         -   -   */
274     R_HPPA_LOGIC_RSHIFT,        /*      pop A, push A >> Addend         -   -   */
275     R_HPPA_EXPR_F,              /*      pop A, push A + Addend          F   -   */
276     R_HPPA_EXPR_L,              /*      pop A, push L(A,Addend)         L   -   */
277     R_HPPA_EXPR_R,              /*      pop A, push R(A,Addend)         R   -   */
278     R_HPPA_EXPR_LS,             /*      pop A, push LS(A,Addend)        LS  -   */
279     R_HPPA_EXPR_RS,             /*      pop A, push RS(A,Addend)        RS  -   */
280     R_HPPA_EXPR_LD,             /*      pop A, push LD(A,Addend)        LD  -   */
281     R_HPPA_EXPR_RD,             /*      pop A, push RD(A,Addend)        RD  -   */
282     R_HPPA_EXPR_LR,             /*      pop A, push LR(A,Addend)        LR  -   */
283     R_HPPA_EXPR_RR,             /*      pop A, push RR(A,Addend)        RR  -   */
284
285     R_HPPA_EXPR_32,             /*      pop                             -   32  */
286     R_HPPA_EXPR_21,             /*      pop                             -   21  */
287     R_HPPA_EXPR_11,             /*      pop                             -   11  */
288     R_HPPA_EXPR_14,             /*      pop                             -   14  */
289     R_HPPA_EXPR_17,             /*      pop                             -   17  */
290     R_HPPA_EXPR_12,             /*      pop                             -   12  */
291     R_HPPA_STUB_CALL_17,        /*      Symbol + Addend                 17      */
292     R_HPPA_UNIMPLEMENTED        /*      N/A                                     */
293   } elf32_hppa_reloc_type;
294
295 #define ELF_HOWTO_TABLE_SIZE    R_HPPA_UNIMPLEMENTED + 1
296 #define N_HPPA_RELOCS           R_HPPA_UNIMPLEMENTED + 1
297
298 /* Groups of relocations.  Serves as an expression type. */
299
300 #define R_HPPA                  R_HPPA_32
301 #define R_HPPA_GOTOFF           R_HPPA_GOTOFF_11
302 #define R_HPPA_ABS_CALL         R_HPPA_ABS_CALL_11
303 #define R_HPPA_PCREL_CALL       R_HPPA_PCREL_CALL_11
304 #define R_HPPA_PLABEL           R_HPPA_PLABEL_32
305 #define R_HPPA_DLT              R_HPPA_DLT_32
306 #define R_HPPA_UNWIND           R_HPPA_UNWIND_ENTRY
307 #define R_HPPA_COMPLEX                  R_HPPA_PUSH_CONST
308 #define R_HPPA_COMPLEX_PCREL_CALL       R_HPPA_PUSH_CONST + 1
309 #define R_HPPA_COMPLEX_ABS_CALL         R_HPPA_PUSH_CONST + 2
310
311
312 /* PA-RISC OPCODES */
313
314 #define get_opcode(insn)        ((insn) & 0xfc000000) >> 26
315
316 /* XXX: this list is incomplete */
317
318 #define LDO     0x0d
319 #define LDB     0x10
320 #define LDH     0x11
321 #define LDW     0x12
322 #define LDWM    0x13
323 #define STB     0x18
324 #define STH     0x19
325 #define STW     0x1a
326 #define STWM    0x1b
327 #define COMICLR 0x24
328 #define SUBI    0x25
329 #define SUBIO   0x25
330 #define ADDIT   0x2c
331 #define ADDITO  0x2c
332 #define ADDI    0x2d
333 #define ADDIO   0x2d
334 #define LDIL    0x08
335 #define ADDIL   0x0a
336
337 #define MOVB    0x32
338 #define MOVIB   0x33
339 #define COMBT   0x20
340 #define COMBF   0x22
341 #define COMIBT  0x21
342 #define COMIBF  0x23
343 #define ADDBT   0x28
344 #define ADDBF   0x2a
345 #define ADDIBT  0x29
346 #define ADDIBF  0x2b
347 #define BVB     0x30
348 #define BB      0x31
349
350 #define BL      0x3a
351 #define BLE     0x39
352 #define BE      0x38
353
354 #ifdef __STDC__
355 elf32_hppa_reloc_type **hppa_elf_gen_reloc_type (bfd * abfd, elf32_hppa_reloc_type base_type, int format, int field);
356 #else
357 elf32_hppa_reloc_type **hppa_elf_gen_reloc_type ();
358 #endif
359
360 /*
361  * HPPA Section types
362  */
363
364 #define SHT_HPPA_SYMEXTN                SHT_LOPROC
365
366
367 /*
368  * HPPA Symbol types
369  */
370
371 #define STT_HPPA_PLABEL                 STT_LOPROC
372
373
374 /*
375  * HPPA symbol table extension entry types
376  */
377
378 #define HPPA_SXT_NULL                   0x00
379 #define HPPA_SXT_SYMNDX                 0x01
380 #define HPPA_SXT_ARG_RELOC              0x02
381
382 /*
383  * These macros compose and decompose the value of a symextn entry:
384  *
385  *      entry_type = ELF32_HPPA_SX_TYPE(word);
386  *      entry_value = ELF32_HPPA_SX_VAL(word);
387  *      word = ELF32_HPPA_SX_WORD(type,val);
388  *      Se.hppa_se_info = ELF32_HPPA_SE_INFO(arg_reloc)
389  */
390
391 #define ELF32_HPPA_SX_TYPE(p)           ((p) >> 24)
392 #define ELF32_HPPA_SX_VAL(p)            ((p) & 0xFFFFFF)
393 #define ELF32_HPPA_SX_WORD(type,val)    (((type) << 24) + (val & 0xFFFFFF))
394
395 /* The following was added facilitate implementation of the .hppa_symextn
396    section.  This section is built after the symbol table is built in the
397    elf_write_object_contents routine (called from bfd_close).  It is built
398    so late because it requires information that is not known until
399    the symbol and string table sections have been allocated, and
400    the symbol table has been built. */
401
402 #define ELF_TC_FAKE_SECTIONS 1  /* # of "hand_made" tc-specific sections */
403 #define SYMEXTN_SECTION_NAME ".hppa_symextn"
404
405 extern void elf_hppa_tc_symbol PARAMS ((bfd *, elf32_symbol_type *, int));
406 extern void elf_hppa_tc_make_sections PARAMS ((bfd *, PTR));
407
408 typedef Elf32_Word symext_entryS;
409
410 struct symext_chain
411 {
412   symext_entryS entry;
413   struct symext_chain *next;
414 };
415
416 typedef struct symext_chain symext_chainS;
417
418 #endif /* _ELF32_HPPA_H */