projects / binutils-gdb.git / blob
? search:


14c520a1e65d7aad3ca278c060f07bfa32465929
[binutils-gdb.git] / bfd / elf32-hppa.c
1 /* BFD back-end for HP PA-RISC ELF files.
2 Copyright (C) 1990, 91, 92, 93, 94 Free Software Foundation, Inc.
3
4 Written by
5
6 Center for Software Science
7 Department of Computer Science
8 University of Utah
9
10 This file is part of BFD, the Binary File Descriptor library.
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
25
26 #include "bfd.h"
27 #include "sysdep.h"
28 #include "libbfd.h"
29 #include "obstack.h"
30 #include "bfdlink.h"
31 #include "libelf.h"
32
33 /* ELF32/HPPA relocation support
34
35 This file contains ELF32/HPPA relocation support as specified
36 in the Stratus FTX/Golf Object File Format (SED-1762) dated
37 November 19, 1992.
38 */
39
40 #include "elf32-hppa.h"
41 #include "libhppa.h"
42 #include "aout/aout64.h"
43 #include "hppa_stubs.h"
44
45 /* ELF/PA relocation howto entries */
46
47 static bfd_reloc_status_type hppa_elf_reloc
48 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
49
50 static reloc_howto_type elf_hppa_howto_table[ELF_HOWTO_TABLE_SIZE] =
51 {
52 /* 'bitpos' and 'abs' are obsolete */
53 /* type rs sz bsz pcrel bpos abs ovrf sf name */
54 /* 9.3.4. Address relocation types */
55 {R_HPPA_NONE, 0, 3, 19, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_NONE"},
56 {R_HPPA_32, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_32"},
57 {R_HPPA_11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_11"},
58 {R_HPPA_14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_14"},
59 {R_HPPA_17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_17"},
60 {R_HPPA_L21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_L21"},
61 {R_HPPA_R11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_R11"},
62 {R_HPPA_R14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_R14"},
63 {R_HPPA_R17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_R17"},
64 {R_HPPA_LS21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LS21"},
65 {R_HPPA_RS11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RS11"},
66 {R_HPPA_RS14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RS14"},
67 {R_HPPA_RS17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RS17"},
68 {R_HPPA_LD21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LD21"},
69 {R_HPPA_RD11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RD11"},
70 {R_HPPA_RD14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RD14"},
71 {R_HPPA_RD17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RD17"},
72 {R_HPPA_LR21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LR21"},
73 {R_HPPA_RR14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RR14"},
74 {R_HPPA_RR17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_RR17"},
75 /* 9.3.5. GOTOFF address relocation types */
76 {R_HPPA_GOTOFF_11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_11"},
77 {R_HPPA_GOTOFF_14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_14"},
78 {R_HPPA_GOTOFF_L21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_L21"},
79 {R_HPPA_GOTOFF_R11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_R11"},
80 {R_HPPA_GOTOFF_R14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_R14"},
81 {R_HPPA_GOTOFF_LS21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_LS21"},
82 {R_HPPA_GOTOFF_RS11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RS11"},
83 {R_HPPA_GOTOFF_RS14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RS14"},
84 {R_HPPA_GOTOFF_LD21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_LD21"},
85 {R_HPPA_GOTOFF_RD11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RD11"},
86 {R_HPPA_GOTOFF_RD14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RD14"},
87 {R_HPPA_GOTOFF_LR21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_LR21"},
88 {R_HPPA_GOTOFF_RR14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_GOTOFF_RR14"},
89 /* 9.3.6. Absolute call relocation types */
90 {R_HPPA_ABS_CALL_11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_11"},
91 {R_HPPA_ABS_CALL_14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_14"},
92 {R_HPPA_ABS_CALL_17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_17"},
93 {R_HPPA_ABS_CALL_L21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_L21"},
94 {R_HPPA_ABS_CALL_R11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_R11"},
95 {R_HPPA_ABS_CALL_R14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_R14"},
96 {R_HPPA_ABS_CALL_R17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_R17"},
97 {R_HPPA_ABS_CALL_LS21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_LS21"},
98 {R_HPPA_ABS_CALL_RS11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RS11"},
99 {R_HPPA_ABS_CALL_RS14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RS14"},
100 {R_HPPA_ABS_CALL_RS17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RS17"},
101 {R_HPPA_ABS_CALL_LD21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_LD21"},
102 {R_HPPA_ABS_CALL_RD11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RD11"},
103 {R_HPPA_ABS_CALL_RD14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RD14"},
104 {R_HPPA_ABS_CALL_RD17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RD17"},
105 {R_HPPA_ABS_CALL_LR21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_LR21"},
106 {R_HPPA_ABS_CALL_RR14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RR14"},
107 {R_HPPA_ABS_CALL_RR17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ABS_CALL_RR17"},
108 /* 9.3.7. PC-relative call relocation types */
109 {R_HPPA_PCREL_CALL_11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_11"},
110 {R_HPPA_PCREL_CALL_14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_14"},
111 {R_HPPA_PCREL_CALL_17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_17"},
112 {R_HPPA_PCREL_CALL_12, 0, 3, 12, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_12"},
113 {R_HPPA_PCREL_CALL_L21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_L21"},
114 {R_HPPA_PCREL_CALL_R11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_R11"},
115 {R_HPPA_PCREL_CALL_R14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_R14"},
116 {R_HPPA_PCREL_CALL_R17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_R17"},
117 {R_HPPA_PCREL_CALL_LS21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_LS21"},
118 {R_HPPA_PCREL_CALL_RS11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RS11"},
119 {R_HPPA_PCREL_CALL_RS14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RS14"},
120 {R_HPPA_PCREL_CALL_RS17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RS17"},
121 {R_HPPA_PCREL_CALL_LD21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_LD21"},
122 {R_HPPA_PCREL_CALL_RD11, 0, 3, 11, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RD11"},
123 {R_HPPA_PCREL_CALL_RD14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RD14"},
124 {R_HPPA_PCREL_CALL_RD17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RD17"},
125 {R_HPPA_PCREL_CALL_LR21, 0, 3, 21, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_LR21"},
126 {R_HPPA_PCREL_CALL_RR14, 0, 3, 14, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RR14"},
127 {R_HPPA_PCREL_CALL_RR17, 0, 3, 17, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PCREL_CALL_RR17"},
128
129 /* 9.3.8. Plabel relocation types */
130 {R_HPPA_PLABEL_32, 0, 3, 32, false, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_32"},
131 {R_HPPA_PLABEL_11, 0, 3, 11, false, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_11"},
132 {R_HPPA_PLABEL_14, 0, 3, 14, false, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_14"},
133 {R_HPPA_PLABEL_L21, 0, 3, 21, false, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_L21"},
134 {R_HPPA_PLABEL_R11, 0, 3, 11, false, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_R11"},
135 {R_HPPA_PLABEL_R14, 0, 3, 14, false, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_PLABEL_R14"},
136
137 /* 9.3.9. Data linkage table (DLT) relocation types */
138 {R_HPPA_DLT_32, 0, 3, 32, false, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_32"},
139 {R_HPPA_DLT_11, 0, 3, 11, false, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_11"},
140 {R_HPPA_DLT_14, 0, 3, 14, false, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_14"},
141 {R_HPPA_DLT_L21, 0, 3, 21, false, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_L21"},
142 {R_HPPA_DLT_R11, 0, 3, 11, false, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_R11"},
143 {R_HPPA_DLT_R14, 0, 3, 14, false, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_DLT_R14"},
144
145 /* 9.3.10. Relocations for unwinder tables */
146 {R_HPPA_UNWIND_ENTRY, 0, 3, 32, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_UNWIND_ENTRY"},
147 {R_HPPA_UNWIND_ENTRIES, 0, 3, 32, true, 0, complain_overflow_signed, hppa_elf_reloc, "R_HPPA_UNWIND_ENTRIES"},
148
149 /* 9.3.11. Relocation types for complex expressions */
150 {R_HPPA_PUSH_CONST, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_CONST"},
151 {R_HPPA_PUSH_PC, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_PC"},
152 {R_HPPA_PUSH_SYM, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_SYM"},
153 {R_HPPA_PUSH_GOTOFF, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_GOTOFF"},
154 {R_HPPA_PUSH_ABS_CALL, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_ABS_CALL"},
155 {R_HPPA_PUSH_PCREL_CALL, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_PCREL_CALL"},
156 {R_HPPA_PUSH_PLABEL, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_PUSH_PLABEL"},
157 {R_HPPA_MAX, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_MAX"},
158 {R_HPPA_MIN, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_MIN"},
159 {R_HPPA_ADD, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ADD"},
160 {R_HPPA_SUB, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_SUB"},
161 {R_HPPA_MULT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_MULT"},
162 {R_HPPA_DIV, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_DIV"},
163 {R_HPPA_MOD, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_MOD"},
164 {R_HPPA_AND, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_AND"},
165 {R_HPPA_OR, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_OR"},
166 {R_HPPA_XOR, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_XOR"},
167 {R_HPPA_NOT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_NOT"},
168 {R_HPPA_LSHIFT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LSHIFT"},
169 {R_HPPA_ARITH_RSHIFT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_ARITH_RSHIFT"},
170 {R_HPPA_LOGIC_RSHIFT, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_LOGIC_RSHIFT"},
171 {R_HPPA_EXPR_F, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_L"},
172 {R_HPPA_EXPR_L, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_L"},
173 {R_HPPA_EXPR_R, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_R"},
174 {R_HPPA_EXPR_LS, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_LS"},
175 {R_HPPA_EXPR_RS, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_RS"},
176 {R_HPPA_EXPR_LD, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_LD"},
177 {R_HPPA_EXPR_RD, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_RD"},
178 {R_HPPA_EXPR_LR, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_LR"},
179 {R_HPPA_EXPR_RR, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_RR"},
180
181 {R_HPPA_EXPR_32, 0, 3, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_32"},
182 {R_HPPA_EXPR_21, 0, 3, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_21"},
183 {R_HPPA_EXPR_11, 0, 3, 11, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_11"},
184 {R_HPPA_EXPR_14, 0, 3, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_14"},
185 {R_HPPA_EXPR_17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_17"},
186 {R_HPPA_EXPR_12, 0, 3, 12, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_EXPR_12"},
187 {R_HPPA_STUB_CALL_17, 0, 3, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_STUB_CALL_17"},
188 {R_HPPA_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont, NULL, "R_HPPA_UNIMPLEMENTED"},
189 };
190
191 static symext_chainS *symext_rootP;
192 static symext_chainS *symext_lastP;
193 static boolean symext_chain_built;
194
195 static unsigned long
196 hppa_elf_rebuild_insn (abfd, insn, value, r_type, r_field, r_format)
197 bfd *abfd;
198 unsigned long insn;
199 unsigned long value;
200 unsigned short r_type;
201 unsigned short r_field;
202 unsigned short r_format;
203 {
204 unsigned long const_part; /* part of the instruction that does not change */
205 unsigned long rebuilt_part;
206
207 switch (r_format)
208 {
209 case 11:
210 {
211 unsigned w1, w;
212
213 const_part = insn & 0xffffe002;
214 dis_assemble_12 (value, &w1, &w);
215 rebuilt_part = (w1 << 2) | w;
216 return const_part | rebuilt_part;
217 }
218
219 case 12:
220 {
221 unsigned w1, w;
222
223 const_part = insn & 0xffffe002;
224 dis_assemble_12 (value, &w1, &w);
225 rebuilt_part = (w1 << 2) | w;
226 return const_part | rebuilt_part;
227 }
228
229 case 14:
230 const_part = insn & 0xffffc000;
231 low_sign_unext (value, 14, &rebuilt_part);
232 return const_part | rebuilt_part;
233
234 case 17:
235 {
236 unsigned w1, w2, w;
237
238 const_part = insn & 0xffe0e002;
239 dis_assemble_17 (value, &w1, &w2, &w);
240 rebuilt_part = (w2 << 2) | (w1 << 16) | w;
241 return const_part | rebuilt_part;
242 }
243
244 case 21:
245 const_part = insn & 0xffe00000;
246 dis_assemble_21 (value, &rebuilt_part);
247 return const_part | rebuilt_part;
248
249 case 32:
250 const_part = 0;
251 return value;
252
253 default:
254 fprintf (stderr, "Relocation problem : ");
255 fprintf (stderr,
256 "Unrecognized reloc type %d (fmt=%d,fld=%d), in module %s\n",
257 r_type, r_format, r_field, abfd->filename);
258 }
259 return insn;
260 }
261
262 static unsigned long
263 hppa_elf_relocate_insn (abfd, input_sect,
264 insn, address, symp, sym_value, r_addend,
265 r_type, r_format, r_field, pcrel)
266 bfd *abfd;
267 asection *input_sect;
268 unsigned long insn;
269 unsigned long address;
270 asymbol *symp;
271 long sym_value;
272 long r_addend;
273 unsigned short r_type;
274 unsigned short r_format;
275 unsigned short r_field;
276 unsigned char pcrel;
277 {
278 unsigned char opcode = get_opcode (insn);
279 long constant_value;
280 unsigned arg_reloc;
281
282 switch (opcode)
283 {
284 case LDO:
285 case LDB:
286 case LDH:
287 case LDW:
288 case LDWM:
289 case STB:
290 case STH:
291 case STW:
292 case STWM:
293 constant_value = HPPA_R_CONSTANT (r_addend);
294 BFD_ASSERT (r_format == 14);
295
296 if (pcrel)
297 sym_value -= address;
298 sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
299 return hppa_elf_rebuild_insn (abfd, insn, sym_value, r_type, r_field, r_format);
300
301 case COMICLR:
302 case SUBI: /* case SUBIO: */
303 case ADDIT: /* case ADDITO: */
304 case ADDI: /* case ADDIO: */
305 BFD_ASSERT (r_format == 11);
306
307 constant_value = HPPA_R_CONSTANT(r_addend);
308 sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
309 return hppa_elf_rebuild_insn (abfd, insn, sym_value, r_type, r_field, r_format);
310
311 case LDIL:
312 case ADDIL:
313 BFD_ASSERT (r_format == 21);
314
315 constant_value = HPPA_R_CONSTANT (r_addend);
316 sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
317 return hppa_elf_rebuild_insn (abfd, insn, sym_value, r_type, r_field, r_format);
318
319 case BL:
320 case BE:
321 case BLE:
322 arg_reloc = HPPA_R_ARG_RELOC (r_addend);
323
324 BFD_ASSERT (r_format == 17);
325
326 /* XXX computing constant_value is not needed??? */
327 constant_value = assemble_17 ((insn & 0x001f0000) >> 16,
328 (insn & 0x00001ffc) >> 2,
329 insn & 1);
330 /* @@ Assumes only 32 bits. */
331 constant_value = (constant_value << 15) >> 15;
332 if (pcrel)
333 {
334 sym_value -=
335 address + input_sect->output_offset
336 + input_sect->output_section->vma;
337 sym_value = hppa_field_adjust (sym_value, -8, r_field);
338 }
339 else
340 sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
341
342 return hppa_elf_rebuild_insn (abfd, insn, sym_value >> 2, r_type, r_field, r_format);
343
344 default:
345 if (opcode == 0)
346 {
347 BFD_ASSERT (r_format == 32);
348 constant_value = HPPA_R_CONSTANT (r_addend);
349
350 return hppa_field_adjust (sym_value, constant_value, r_field);
351 }
352 else
353 {
354 fprintf (stderr,
355 "Unrecognized opcode 0x%02x (fmt=%x,field=%x)\n",
356 opcode, r_format, r_field);
357 return insn;
358 }
359 }
360 }
361
362 static void
363 hppa_elf_relocate_unwind_table (abfd, input_sect,
364 data, address, symp, sym_value, r_addend,
365 r_type, r_format, r_field, pcrel)
366 bfd *abfd;
367 asection *input_sect;
368 PTR data;
369 unsigned long address;
370 asymbol *symp;
371 long sym_value;
372 long r_addend;
373 unsigned short r_type;
374 unsigned short r_format;
375 unsigned short r_field;
376 unsigned char pcrel;
377 {
378 bfd_byte *hit_data = address + (bfd_byte *) (data);
379 long start_offset;
380 long end_offset;
381 long relocated_value;
382 int i;
383
384 BFD_ASSERT (r_format == 32);
385 BFD_ASSERT (r_field == e_fsel);
386 switch (r_type)
387 {
388 case R_HPPA_UNWIND_ENTRY:
389 start_offset = bfd_get_32 (abfd, hit_data);
390 relocated_value = hppa_field_adjust (sym_value, start_offset, r_field);
391 bfd_put_32 (abfd, relocated_value, hit_data);
392
393 hit_data += sizeof (unsigned long);
394 end_offset = bfd_get_32 (abfd, hit_data);
395 relocated_value = hppa_field_adjust (sym_value, end_offset, r_field);
396 bfd_put_32 (abfd, relocated_value, hit_data);
397 break;
398
399 case R_HPPA_UNWIND_ENTRIES:
400 for (i = 0; i < r_addend; i++, hit_data += 3 * sizeof (unsigned long))
401 {
402 unsigned int adjustment;
403 start_offset = bfd_get_32 (abfd, hit_data);
404 /* Stuff the symbol value into the first word */
405 /* of the unwind descriptor */
406 bfd_put_32 (abfd, sym_value, hit_data);
407 adjustment = sym_value - start_offset;
408
409 hit_data += sizeof (unsigned long);
410 end_offset = adjustment + bfd_get_32 (abfd, hit_data);
411 bfd_put_32 (abfd, end_offset, hit_data);
412
413 /* If this is not the last unwind entry, */
414 /* adjust the symbol value. */
415 if (i + 1 < r_addend)
416 {
417 start_offset = bfd_get_32 (abfd, hit_data + 3 * sizeof (unsigned long));
418 sym_value = start_offset + adjustment;
419 }
420 }
421 break;
422
423 default:
424 fprintf (stderr,
425 "Unrecognized relocation type 0x%02x (fmt=%x,field=%x)\n",
426 r_type, r_format, r_field);
427 }
428 }
429
430 /* Provided the symbol, returns the value reffed */
431 static long
432 get_symbol_value (symbol)
433 asymbol *symbol;
434 {
435 long relocation = 0;
436
437 if (symbol == (asymbol *) NULL)
438 relocation = 0;
439 else if (symbol->section == &bfd_com_section)
440 {
441 relocation = 0;
442 }
443 else
444 {
445 relocation = symbol->value +
446 symbol->section->output_section->vma +
447 symbol->section->output_offset;
448 }
449
450 return (relocation);
451 }
452
453 /* This function provides a pretty straight-forward mapping between a */
454 /* base relocation type, format and field into the relocation type */
455 /* that will be emitted in an object file. The only wrinkle in the */
456 /* mapping is that when the T, TR, TL, P, PR, or PL expression */
457 /* prefixes are involved, the type gets promoted to a *_GOTOFF_* */
458 /* relocation (in the case of T, TR, and TL) or a PLABEL relocation */
459 /* (in the case of P, PR, and PL). */
460
461 /* NOTE: XXX the T, TR, TL, P, PR, and PL expression prefixes are not */
462 /* handled yet. */
463
464 static void
465 hppa_elf_gen_reloc_error (base_type, fmt, field)
466 elf32_hppa_reloc_type base_type;
467 int fmt;
468 int field;
469 {
470 fprintf (stderr, "undefined relocation: base=0x%x,fmt=0x%x,field=0x%x\n",
471 base_type, fmt, field);
472 }
473
474 elf32_hppa_reloc_type **
475 hppa_elf_gen_reloc_type (abfd, base_type, format, field)
476 bfd *abfd;
477 elf32_hppa_reloc_type base_type;
478 int format;
479 int field;
480 {
481 #define UNDEFINED hppa_elf_gen_reloc_error(base_type,format,field)
482
483 elf32_hppa_reloc_type *finaltype;
484 elf32_hppa_reloc_type **final_types;
485 int i;
486
487 final_types = (elf32_hppa_reloc_type **) bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type *) * 2);
488 BFD_ASSERT (final_types != 0);
489
490 finaltype = (elf32_hppa_reloc_type *) bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type));
491 BFD_ASSERT (finaltype != 0);
492
493 final_types[0] = finaltype;
494 final_types[1] = NULL;
495
496 #define final_type finaltype[0]
497
498 final_type = base_type;
499
500 switch (base_type)
501 {
502 case R_HPPA:
503 switch (format)
504 {
505 case 11:
506 switch (field)
507 {
508 case e_fsel:
509 final_type = R_HPPA_11;
510 break;
511 case e_rsel:
512 final_type = R_HPPA_R11;
513 break;
514 case e_rssel:
515 final_type = R_HPPA_RS11;
516 break;
517 case e_rdsel:
518 final_type = R_HPPA_RD11;
519 break;
520
521 case e_psel:
522 final_type = R_HPPA_PLABEL_11;
523 break;
524 case e_rpsel:
525 final_type = R_HPPA_PLABEL_R11;
526 break;
527 case e_tsel:
528 final_type = R_HPPA_DLT_11;
529 break;
530 case e_rtsel:
531 final_type = R_HPPA_DLT_R11;
532 break;
533
534 case e_lpsel:
535 case e_ltsel:
536 case e_lsel:
537 case e_lrsel:
538 case e_lssel:
539 case e_rrsel:
540 default:
541 UNDEFINED;
542 final_type = base_type;
543 break;
544 }
545 break;
546 case 12:
547 UNDEFINED;
548 break;
549 case 14:
550 switch (field)
551 {
552 case e_rsel:
553 final_type = R_HPPA_R14;
554 break;
555 case e_rssel:
556 final_type = R_HPPA_RS14;
557 break;
558 case e_rdsel:
559 final_type = R_HPPA_RD14;
560 break;
561 case e_rrsel:
562 final_type = R_HPPA_RR14;
563 break;
564
565 case e_psel:
566 final_type = R_HPPA_PLABEL_14;
567 break;
568 case e_rpsel:
569 final_type = R_HPPA_PLABEL_R14;
570 break;
571 case e_tsel:
572 final_type = R_HPPA_DLT_14;
573 break;
574 case e_rtsel:
575 final_type = R_HPPA_DLT_R14;
576 break;
577
578 case e_lpsel:
579 case e_ltsel:
580
581 case e_fsel:
582 case e_lsel:
583 case e_lssel:
584 case e_ldsel:
585 case e_lrsel:
586 default:
587 UNDEFINED;
588 final_type = base_type;
589 break;
590 }
591 break;
592 case 17:
593 switch (field)
594 {
595 case e_fsel:
596 final_type = R_HPPA_17;
597 break;
598 case e_rsel:
599 final_type = R_HPPA_R17;
600 break;
601 case e_rssel:
602 final_type = R_HPPA_RS17;
603 break;
604 case e_rdsel:
605 final_type = R_HPPA_RD17;
606 break;
607 case e_rrsel:
608 final_type = R_HPPA_RR17;
609 break;
610 case e_lsel:
611 case e_lssel:
612 case e_ldsel:
613 case e_lrsel:
614 default:
615 UNDEFINED;
616 final_type = base_type;
617 break;
618 }
619 break;
620 case 21:
621 switch (field)
622 {
623 case e_lsel:
624 final_type = R_HPPA_L21;
625 break;
626 case e_lssel:
627 final_type = R_HPPA_LS21;
628 break;
629 case e_ldsel:
630 final_type = R_HPPA_LD21;
631 break;
632 case e_lrsel:
633 final_type = R_HPPA_LR21;
634 break;
635 case e_lpsel:
636 final_type = R_HPPA_PLABEL_L21;
637 break;
638 case e_ltsel:
639 final_type = R_HPPA_PLABEL_L21;
640 break;
641 case e_rsel:
642 case e_rssel:
643 case e_rdsel:
644 case e_rrsel:
645 case e_fsel:
646 default:
647 UNDEFINED;
648 final_type = base_type;
649 break;
650 }
651 break;
652 case 32:
653 switch (field)
654 {
655 case e_fsel:
656 final_type = R_HPPA_32;
657 break;
658 case e_psel:
659 final_type = R_HPPA_PLABEL_32;
660 break;
661 case e_tsel:
662 final_type = R_HPPA_DLT_32;
663 break;
664 default:
665 UNDEFINED;
666 final_type = base_type;
667 break;
668 }
669 break;
670 default:
671 UNDEFINED;
672 final_type = base_type;
673 break;
674 }
675 break;
676 case R_HPPA_GOTOFF:
677 switch (format)
678 {
679 case 11:
680 switch (field)
681 {
682 case e_rsel:
683 final_type = R_HPPA_GOTOFF_R11;
684 break;
685 case e_rssel:
686 final_type = R_HPPA_GOTOFF_RS11;
687 break;
688 case e_rdsel:
689 final_type = R_HPPA_GOTOFF_RD11;
690 break;
691 case e_fsel:
692 final_type = R_HPPA_GOTOFF_11;
693 break;
694 case e_lsel:
695 case e_lrsel:
696 case e_lssel:
697 case e_rrsel:
698 default:
699 UNDEFINED;
700 final_type = base_type;
701 break;
702 }
703 break;
704 case 12:
705 UNDEFINED;
706 final_type = base_type;
707 break;
708 case 14:
709 switch (field)
710 {
711 case e_rsel:
712 final_type = R_HPPA_GOTOFF_R14;
713 break;
714 case e_rssel:
715 final_type = R_HPPA_GOTOFF_RS14;
716 break;
717 case e_rdsel:
718 final_type = R_HPPA_GOTOFF_RD14;
719 break;
720 case e_rrsel:
721 final_type = R_HPPA_GOTOFF_RR14;
722 break;
723 case e_fsel:
724 final_type = R_HPPA_GOTOFF_14;
725 break;
726 case e_lsel:
727 case e_lssel:
728 case e_ldsel:
729 case e_lrsel:
730 default:
731 UNDEFINED;
732 final_type = base_type;
733 break;
734 }
735 break;
736 case 17:
737 UNDEFINED;
738 final_type = base_type;
739 break;
740 case 21:
741 switch (field)
742 {
743 case e_lsel:
744 final_type = R_HPPA_GOTOFF_L21;
745 break;
746 case e_lssel:
747 final_type = R_HPPA_GOTOFF_LS21;
748 break;
749 case e_ldsel:
750 final_type = R_HPPA_GOTOFF_LD21;
751 break;
752 case e_lrsel:
753 final_type = R_HPPA_GOTOFF_LR21;
754 break;
755 case e_rsel:
756 case e_rssel:
757 case e_rdsel:
758 case e_rrsel:
759 case e_fsel:
760 default:
761 UNDEFINED;
762 final_type = base_type;
763 break;
764 }
765 break;
766 case 32:
767 UNDEFINED;
768 final_type = base_type;
769 break;
770 default:
771 UNDEFINED;
772 final_type = base_type;
773 break;
774 }
775 break;
776 case R_HPPA_PCREL_CALL:
777 switch (format)
778 {
779 case 11:
780 switch (field)
781 {
782 case e_rsel:
783 final_type = R_HPPA_PCREL_CALL_R11;
784 break;
785 case e_rssel:
786 final_type = R_HPPA_PCREL_CALL_RS11;
787 break;
788 case e_rdsel:
789 final_type = R_HPPA_PCREL_CALL_RD11;
790 break;
791 case e_fsel:
792 final_type = R_HPPA_PCREL_CALL_11;
793 break;
794 case e_lsel:
795 case e_lrsel:
796 case e_lssel:
797 case e_rrsel:
798 default:
799 UNDEFINED;
800 final_type = base_type;
801 break;
802 }
803 break;
804 case 12:
805 UNDEFINED;
806 final_type = base_type;
807 break;
808 case 14:
809 switch (field)
810 {
811 case e_rsel:
812 final_type = R_HPPA_PCREL_CALL_R14;
813 break;
814 case e_rssel:
815 final_type = R_HPPA_PCREL_CALL_RS14;
816 break;
817 case e_rdsel:
818 final_type = R_HPPA_PCREL_CALL_RD14;
819 break;
820 case e_rrsel:
821 final_type = R_HPPA_PCREL_CALL_RR14;
822 break;
823 case e_fsel:
824 final_type = R_HPPA_PCREL_CALL_14;
825 break;
826 case e_lsel:
827 case e_lssel:
828 case e_ldsel:
829 case e_lrsel:
830 default:
831 UNDEFINED;
832 final_type = base_type;
833 break;
834 }
835 break;
836 case 17:
837 switch (field)
838 {
839 case e_rsel:
840 final_type = R_HPPA_PCREL_CALL_R17;
841 break;
842 case e_rssel:
843 final_type = R_HPPA_PCREL_CALL_RS17;
844 break;
845 case e_rdsel:
846 final_type = R_HPPA_PCREL_CALL_RD17;
847 break;
848 case e_rrsel:
849 final_type = R_HPPA_PCREL_CALL_RR17;
850 break;
851 case e_fsel:
852 final_type = R_HPPA_PCREL_CALL_17;
853 break;
854 case e_lsel:
855 case e_lssel:
856 case e_ldsel:
857 case e_lrsel:
858 default:
859 UNDEFINED;
860 final_type = base_type;
861 break;
862 }
863 break;
864 case 21:
865 switch (field)
866 {
867 case e_lsel:
868 final_type = R_HPPA_PCREL_CALL_L21;
869 break;
870 case e_lssel:
871 final_type = R_HPPA_PCREL_CALL_LS21;
872 break;
873 case e_ldsel:
874 final_type = R_HPPA_PCREL_CALL_LD21;
875 break;
876 case e_lrsel:
877 final_type = R_HPPA_PCREL_CALL_LR21;
878 break;
879 case e_rsel:
880 case e_rssel:
881 case e_rdsel:
882 case e_rrsel:
883 case e_fsel:
884 default:
885 UNDEFINED;
886 final_type = base_type;
887 break;
888 }
889 break;
890 case 32:
891 UNDEFINED;
892 final_type = base_type;
893 break;
894 default:
895 UNDEFINED;
896 final_type = base_type;
897 break;
898 }
899 break;
900 case R_HPPA_PLABEL:
901 switch (format)
902 {
903 case 11:
904 switch (field)
905 {
906 case e_fsel:
907 final_type = R_HPPA_PLABEL_11;
908 break;
909 case e_rsel:
910 final_type = R_HPPA_PLABEL_R11;
911 break;
912 default:
913 UNDEFINED;
914 final_type = base_type;
915 break;
916 }
917 break;
918 case 14:
919 switch (field)
920 {
921 case e_fsel:
922 final_type = R_HPPA_PLABEL_14;
923 break;
924 case e_rsel:
925 final_type = R_HPPA_PLABEL_R14;
926 break;
927 default:
928 UNDEFINED;
929 final_type = base_type;
930 break;
931 }
932 break;
933 case 21:
934 switch (field)
935 {
936 case e_lsel:
937 final_type = R_HPPA_PLABEL_L21;
938 break;
939 default:
940 UNDEFINED;
941 final_type = base_type;
942 break;
943 }
944 break;
945 case 32:
946 switch (field)
947 {
948 case e_fsel:
949 final_type = R_HPPA_PLABEL_32;
950 break;
951 default:
952 UNDEFINED;
953 final_type = base_type;
954 break;
955 }
956 break;
957 default:
958 UNDEFINED;
959 final_type = base_type;
960 break;
961 }
962 case R_HPPA_ABS_CALL:
963 switch (format)
964 {
965 case 11:
966 switch (field)
967 {
968 case e_rsel:
969 final_type = R_HPPA_ABS_CALL_R11;
970 break;
971 case e_rssel:
972 final_type = R_HPPA_ABS_CALL_RS11;
973 break;
974 case e_rdsel:
975 final_type = R_HPPA_ABS_CALL_RD11;
976 break;
977 case e_fsel:
978 final_type = R_HPPA_ABS_CALL_11;
979 break;
980 case e_lsel:
981 case e_lrsel:
982 case e_lssel:
983 case e_rrsel:
984 default:
985 UNDEFINED;
986 final_type = base_type;
987 break;
988 }
989 break;
990 case 12:
991 UNDEFINED;
992 final_type = base_type;
993 break;
994 case 14:
995 switch (field)
996 {
997 case e_rsel:
998 final_type = R_HPPA_ABS_CALL_R14;
999 break;
1000 case e_rssel:
1001 final_type = R_HPPA_ABS_CALL_RS14;
1002 break;
1003 case e_rdsel:
1004 final_type = R_HPPA_ABS_CALL_RD14;
1005 break;
1006 case e_rrsel:
1007 final_type = R_HPPA_ABS_CALL_RR14;
1008 break;
1009 case e_fsel:
1010 final_type = R_HPPA_ABS_CALL_14;
1011 break;
1012 case e_lsel:
1013 case e_lssel:
1014 case e_ldsel:
1015 case e_lrsel:
1016 default:
1017 UNDEFINED;
1018 final_type = base_type;
1019 break;
1020 }
1021 break;
1022 case 17:
1023 switch (field)
1024 {
1025 case e_rsel:
1026 final_type = R_HPPA_ABS_CALL_R17;
1027 break;
1028 case e_rssel:
1029 final_type = R_HPPA_ABS_CALL_RS17;
1030 break;
1031 case e_rdsel:
1032 final_type = R_HPPA_ABS_CALL_RD17;
1033 break;
1034 case e_rrsel:
1035 final_type = R_HPPA_ABS_CALL_RR17;
1036 break;
1037 case e_fsel:
1038 final_type = R_HPPA_ABS_CALL_17;
1039 break;
1040 case e_lsel:
1041 case e_lssel:
1042 case e_ldsel:
1043 case e_lrsel:
1044 default:
1045 UNDEFINED;
1046 final_type = base_type;
1047 break;
1048 }
1049 break;
1050 case 21:
1051 switch (field)
1052 {
1053 case e_lsel:
1054 final_type = R_HPPA_ABS_CALL_L21;
1055 break;
1056 case e_lssel:
1057 final_type = R_HPPA_ABS_CALL_LS21;
1058 break;
1059 case e_ldsel:
1060 final_type = R_HPPA_ABS_CALL_LD21;
1061 break;
1062 case e_lrsel:
1063 final_type = R_HPPA_ABS_CALL_LR21;
1064 break;
1065 case e_rsel:
1066 case e_rssel:
1067 case e_rdsel:
1068 case e_rrsel:
1069 case e_fsel:
1070 default:
1071 UNDEFINED;
1072 final_type = base_type;
1073 break;
1074 }
1075 break;
1076 case 32:
1077 UNDEFINED;
1078 final_type = base_type;
1079 break;
1080 default:
1081 UNDEFINED;
1082 final_type = base_type;
1083 break;
1084 }
1085 break;
1086 case R_HPPA_UNWIND:
1087 final_type = R_HPPA_UNWIND_ENTRY;
1088 break;
1089 case R_HPPA_COMPLEX:
1090 case R_HPPA_COMPLEX_PCREL_CALL:
1091 case R_HPPA_COMPLEX_ABS_CALL:
1092 final_types = (elf32_hppa_reloc_type **) bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type *) * 6);
1093 BFD_ASSERT (final_types != 0);
1094
1095 finaltype = (elf32_hppa_reloc_type *) bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type) * 5);
1096 BFD_ASSERT (finaltype != 0);
1097
1098 for (i = 0; i < 5; i++)
1099 final_types[i] = &finaltype[i];
1100
1101 final_types[5] = NULL;
1102
1103 finaltype[0] = R_HPPA_PUSH_SYM;
1104
1105 if (base_type == R_HPPA_COMPLEX)
1106 finaltype[1] = R_HPPA_PUSH_SYM;
1107 else if (base_type == R_HPPA_COMPLEX_PCREL_CALL)
1108 finaltype[1] = R_HPPA_PUSH_PCREL_CALL;
1109 else /* base_type == R_HPPA_COMPLEX_ABS_CALL */
1110 finaltype[1] = R_HPPA_PUSH_ABS_CALL;
1111
1112 finaltype[2] = R_HPPA_SUB;
1113
1114 switch (field)
1115 {
1116 case e_fsel:
1117 finaltype[3] = R_HPPA_EXPR_F;
1118 break;
1119 case e_lsel:
1120 finaltype[3] = R_HPPA_EXPR_L;
1121 break;
1122 case e_rsel:
1123 finaltype[3] = R_HPPA_EXPR_R;
1124 break;
1125 case e_lssel:
1126 finaltype[3] = R_HPPA_EXPR_LS;
1127 break;
1128 case e_rssel:
1129 finaltype[3] = R_HPPA_EXPR_RS;
1130 break;
1131 case e_ldsel:
1132 finaltype[3] = R_HPPA_EXPR_LD;
1133 break;
1134 case e_rdsel:
1135 finaltype[3] = R_HPPA_EXPR_RD;
1136 break;
1137 case e_lrsel:
1138 finaltype[3] = R_HPPA_EXPR_LR;
1139 break;
1140 case e_rrsel:
1141 finaltype[3] = R_HPPA_EXPR_RR;
1142 break;
1143 }
1144
1145 switch (format)
1146 {
1147 case 11:
1148 finaltype[4] = R_HPPA_EXPR_11;
1149 break;
1150 case 12:
1151 finaltype[4] = R_HPPA_EXPR_12;
1152 break;
1153 case 14:
1154 finaltype[4] = R_HPPA_EXPR_14;
1155 break;
1156 case 17:
1157 finaltype[4] = R_HPPA_EXPR_17;
1158 break;
1159 case 21:
1160 finaltype[4] = R_HPPA_EXPR_21;
1161 break;
1162 case 32:
1163 finaltype[4] = R_HPPA_EXPR_32;
1164 break;
1165 }
1166
1167 break;
1168
1169 default:
1170 final_type = base_type;
1171 break;
1172 }
1173
1174 return final_types;
1175 }
1176
1177 #undef final_type
1178
1179
1180 /* this function is in charge of performing all the HP PA relocations */
1181 static long global_value;
1182 static long GOT_value; /* XXX: need to calculate this! For HPUX, GOT == DP */
1183 static asymbol *global_symbol;
1184 static int global_sym_defined;
1185
1186 static bfd_reloc_status_type
1187 hppa_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
1188 error_message)
1189 bfd *abfd;
1190 arelent *reloc_entry;
1191 asymbol *symbol_in;
1192 PTR data;
1193 asection *input_section;
1194 bfd *output_bfd;
1195 char **error_message;
1196 {
1197 unsigned long insn;
1198 long sym_value = 0;
1199 unsigned long addr = reloc_entry->address;
1200 bfd_byte *hit_data = addr + (bfd_byte *) (data);
1201 unsigned short r_type = reloc_entry->howto->type & 0xFF;
1202 unsigned short r_field = e_fsel;
1203 boolean r_pcrel = reloc_entry->howto->pc_relative;
1204 unsigned r_format = reloc_entry->howto->bitsize;
1205 long r_addend = reloc_entry->addend;
1206
1207 if (output_bfd)
1208 {
1209 /* Partial linking - do nothing */
1210 reloc_entry->address += input_section->output_offset;
1211 return bfd_reloc_ok;
1212 }
1213
1214 /* If performing final link and the symbol we're relocating against
1215 is undefined, then return an error. */
1216 if (symbol_in && symbol_in->section == &bfd_und_section)
1217 return bfd_reloc_undefined;
1218
1219 sym_value = get_symbol_value (symbol_in);
1220
1221 /* Compute the value of $global$. */
1222 if (!global_sym_defined)
1223 {
1224 if (global_symbol)
1225 {
1226 global_value = (global_symbol->value
1227 + global_symbol->section->output_section->vma
1228 + global_symbol->section->output_offset);
1229 GOT_value = global_value;
1230 global_sym_defined++;
1231 }
1232 }
1233
1234 /* Get the instruction word. */
1235 insn = bfd_get_32 (abfd, hit_data);
1236
1237 /* Relocate the value based on one of the basic relocation types
1238
1239 basic_type_1: relocation is relative to $global$
1240 basic_type_2: relocation is relative to the current GOT
1241 basic_type_3: relocation is an absolute call
1242 basic_type_4: relocation is an PC-relative call
1243 basic_type_5: relocation is plabel reference
1244 basic_type_6: relocation is an unwind table relocation
1245 extended_type: unimplemented */
1246
1247 switch (r_type)
1248 {
1249 case R_HPPA_NONE:
1250 break;
1251
1252 /* Handle all the basic type 1 relocations. */
1253 case R_HPPA_32:
1254 r_field = e_fsel;
1255 goto do_basic_type_1;
1256 case R_HPPA_11:
1257 r_field = e_fsel;
1258 goto do_basic_type_1;
1259 case R_HPPA_14:
1260 r_field = e_fsel;
1261 goto do_basic_type_1;
1262 case R_HPPA_17:
1263 r_field = e_fsel;
1264 goto do_basic_type_1;
1265 case R_HPPA_L21:
1266 r_field = e_lsel;
1267 goto do_basic_type_1;
1268 case R_HPPA_R11:
1269 r_field = e_rsel;
1270 goto do_basic_type_1;
1271 case R_HPPA_R14:
1272 r_field = e_rsel;
1273 goto do_basic_type_1;
1274 case R_HPPA_R17:
1275 r_field = e_rsel;
1276 goto do_basic_type_1;
1277 case R_HPPA_LS21:
1278 r_field = e_lssel;
1279 goto do_basic_type_1;
1280 case R_HPPA_RS11:
1281 r_field = e_rssel;
1282 goto do_basic_type_1;
1283 case R_HPPA_RS14:
1284 r_field = e_rssel;
1285 goto do_basic_type_1;
1286 case R_HPPA_RS17:
1287 r_field = e_ldsel;
1288 goto do_basic_type_1;
1289 case R_HPPA_LD21:
1290 r_field = e_ldsel;
1291 goto do_basic_type_1;
1292 case R_HPPA_RD11:
1293 r_field = e_rdsel;
1294 goto do_basic_type_1;
1295 case R_HPPA_RD14:
1296 r_field = e_rdsel;
1297 goto do_basic_type_1;
1298 case R_HPPA_RD17:
1299 r_field = e_rdsel;
1300 goto do_basic_type_1;
1301 case R_HPPA_LR21:
1302 r_field = e_lrsel;
1303 goto do_basic_type_1;
1304 case R_HPPA_RR14:
1305 r_field = e_rrsel;
1306 goto do_basic_type_1;
1307 case R_HPPA_RR17:
1308 r_field = e_rrsel;
1309
1310 do_basic_type_1:
1311 insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
1312 symbol_in, sym_value, r_addend,
1313 r_type, r_format, r_field, r_pcrel);
1314 break;
1315
1316 /* Handle all the basic type 2 relocations. */
1317 case R_HPPA_GOTOFF_11:
1318 r_field = e_fsel;
1319 goto do_basic_type_2;
1320 case R_HPPA_GOTOFF_14:
1321 r_field = e_fsel;
1322 goto do_basic_type_2;
1323 case R_HPPA_GOTOFF_L21:
1324 r_field = e_lsel;
1325 goto do_basic_type_2;
1326 case R_HPPA_GOTOFF_R11:
1327 r_field = e_rsel;
1328 goto do_basic_type_2;
1329 case R_HPPA_GOTOFF_R14:
1330 r_field = e_rsel;
1331 goto do_basic_type_2;
1332 case R_HPPA_GOTOFF_LS21:
1333 r_field = e_lssel;
1334 goto do_basic_type_2;
1335 case R_HPPA_GOTOFF_RS11:
1336 r_field = e_rssel;
1337 goto do_basic_type_2;
1338 case R_HPPA_GOTOFF_RS14:
1339 r_field = e_rssel;
1340 goto do_basic_type_2;
1341 case R_HPPA_GOTOFF_LD21:
1342 r_field = e_ldsel;
1343 goto do_basic_type_2;
1344 case R_HPPA_GOTOFF_RD11:
1345 r_field = e_rdsel;
1346 goto do_basic_type_2;
1347 case R_HPPA_GOTOFF_RD14:
1348 r_field = e_rdsel;
1349 goto do_basic_type_2;
1350 case R_HPPA_GOTOFF_LR21:
1351 r_field = e_lrsel;
1352 goto do_basic_type_2;
1353 case R_HPPA_GOTOFF_RR14:
1354 r_field = e_rrsel;
1355
1356 do_basic_type_2:
1357 sym_value -= GOT_value;
1358 insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
1359 symbol_in, sym_value, r_addend,
1360 r_type, r_format, r_field, r_pcrel);
1361 break;
1362
1363 /* Handle all the basic type 3 relocations. */
1364 case R_HPPA_ABS_CALL_11:
1365 r_field = e_fsel;
1366 goto do_basic_type_3;
1367 case R_HPPA_ABS_CALL_14:
1368 r_field = e_fsel;
1369 goto do_basic_type_3;
1370 case R_HPPA_ABS_CALL_17:
1371 r_field = e_fsel;
1372 goto do_basic_type_3;
1373 case R_HPPA_ABS_CALL_L21:
1374 r_field = e_lsel;
1375 goto do_basic_type_3;
1376 case R_HPPA_ABS_CALL_R11:
1377 r_field = e_rsel;
1378 goto do_basic_type_3;
1379 case R_HPPA_ABS_CALL_R14:
1380 r_field = e_rsel;
1381 goto do_basic_type_3;
1382 case R_HPPA_ABS_CALL_R17:
1383 r_field = e_rsel;
1384 goto do_basic_type_3;
1385 case R_HPPA_ABS_CALL_LS21:
1386 r_field = e_lssel;
1387 goto do_basic_type_3;
1388 case R_HPPA_ABS_CALL_RS11:
1389 r_field = e_lssel;
1390 goto do_basic_type_3;
1391 case R_HPPA_ABS_CALL_RS14:
1392 r_field = e_rssel;
1393 goto do_basic_type_3;
1394 case R_HPPA_ABS_CALL_RS17:
1395 r_field = e_rssel;
1396 goto do_basic_type_3;
1397 case R_HPPA_ABS_CALL_LD21:
1398 r_field = e_ldsel;
1399 goto do_basic_type_3;
1400 case R_HPPA_ABS_CALL_RD11:
1401 r_field = e_rdsel;
1402 goto do_basic_type_3;
1403 case R_HPPA_ABS_CALL_RD14:
1404 r_field = e_rdsel;
1405 goto do_basic_type_3;
1406 case R_HPPA_ABS_CALL_RD17:
1407 r_field = e_rdsel;
1408 goto do_basic_type_3;
1409 case R_HPPA_ABS_CALL_LR21:
1410 r_field = e_lrsel;
1411 goto do_basic_type_3;
1412 case R_HPPA_ABS_CALL_RR14:
1413 r_field = e_rrsel;
1414 goto do_basic_type_3;
1415 case R_HPPA_ABS_CALL_RR17:
1416 r_field = e_rrsel;
1417
1418 do_basic_type_3:
1419 insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
1420 symbol_in, sym_value, r_addend,
1421 r_type, r_format, r_field, r_pcrel);
1422 break;
1423
1424 /* Handle all the basic type 4 relocations. */
1425 case R_HPPA_PCREL_CALL_11:
1426 r_field = e_fsel;
1427 goto do_basic_type_4;
1428 case R_HPPA_PCREL_CALL_14:
1429 r_field = e_fsel;
1430 goto do_basic_type_4;
1431 case R_HPPA_PCREL_CALL_17:
1432 r_field = e_fsel;
1433 goto do_basic_type_4;
1434 case R_HPPA_PCREL_CALL_L21:
1435 r_field = e_lsel;
1436 goto do_basic_type_4;
1437 case R_HPPA_PCREL_CALL_R11:
1438 r_field = e_rsel;
1439 goto do_basic_type_4;
1440 case R_HPPA_PCREL_CALL_R14:
1441 r_field = e_rsel;
1442 goto do_basic_type_4;
1443 case R_HPPA_PCREL_CALL_R17:
1444 r_field = e_rsel;
1445 goto do_basic_type_4;
1446 case R_HPPA_PCREL_CALL_LS21:
1447 r_field = e_lssel;
1448 goto do_basic_type_4;
1449 case R_HPPA_PCREL_CALL_RS11:
1450 r_field = e_rssel;
1451 goto do_basic_type_4;
1452 case R_HPPA_PCREL_CALL_RS14:
1453 r_field = e_rssel;
1454 goto do_basic_type_4;
1455 case R_HPPA_PCREL_CALL_RS17:
1456 r_field = e_rssel;
1457 goto do_basic_type_4;
1458 case R_HPPA_PCREL_CALL_LD21:
1459 r_field = e_ldsel;
1460 goto do_basic_type_4;
1461 case R_HPPA_PCREL_CALL_RD11:
1462 r_field = e_rdsel;
1463 goto do_basic_type_4;
1464 case R_HPPA_PCREL_CALL_RD14:
1465 r_field = e_rdsel;
1466 goto do_basic_type_4;
1467 case R_HPPA_PCREL_CALL_RD17:
1468 r_field = e_rdsel;
1469 goto do_basic_type_4;
1470 case R_HPPA_PCREL_CALL_LR21:
1471 r_field = e_lrsel;
1472 goto do_basic_type_4;
1473 case R_HPPA_PCREL_CALL_RR14:
1474 r_field = e_rrsel;
1475 goto do_basic_type_4;
1476 case R_HPPA_PCREL_CALL_RR17:
1477 r_field = e_rrsel;
1478
1479 do_basic_type_4:
1480 insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
1481 symbol_in, sym_value, r_addend,
1482 r_type, r_format, r_field, r_pcrel);
1483 break;
1484
1485 /* Handle all the basic type 5 relocations. */
1486 case R_HPPA_PLABEL_32:
1487 case R_HPPA_PLABEL_11:
1488 case R_HPPA_PLABEL_14:
1489 r_field = e_fsel;
1490 goto do_basic_type_5;
1491 case R_HPPA_PLABEL_L21:
1492 r_field = e_lsel;
1493 goto do_basic_type_5;
1494 case R_HPPA_PLABEL_R11:
1495 case R_HPPA_PLABEL_R14:
1496 r_field = e_rsel;
1497 do_basic_type_5:
1498 insn = hppa_elf_relocate_insn (abfd, input_section, insn, addr,
1499 symbol_in, sym_value, r_addend,
1500 r_type, r_format, r_field, r_pcrel);
1501 break;
1502
1503 /* Handle all basic type 6 relocations. */
1504 case R_HPPA_UNWIND_ENTRY:
1505 case R_HPPA_UNWIND_ENTRIES:
1506 hppa_elf_relocate_unwind_table (abfd, input_section, data, addr,
1507 symbol_in, sym_value, r_addend,
1508 r_type, r_format, r_field, r_pcrel);
1509 return bfd_reloc_ok;
1510
1511 /* Handle the stack operations and similar braindamage. */
1512 case R_HPPA_PUSH_CONST:
1513 case R_HPPA_PUSH_PC:
1514 case R_HPPA_PUSH_SYM:
1515 case R_HPPA_PUSH_GOTOFF:
1516 case R_HPPA_PUSH_ABS_CALL:
1517 case R_HPPA_PUSH_PCREL_CALL:
1518 case R_HPPA_PUSH_PLABEL:
1519 case R_HPPA_MAX:
1520 case R_HPPA_MIN:
1521 case R_HPPA_ADD:
1522 case R_HPPA_SUB:
1523 case R_HPPA_MULT:
1524 case R_HPPA_DIV:
1525 case R_HPPA_MOD:
1526 case R_HPPA_AND:
1527 case R_HPPA_OR:
1528 case R_HPPA_XOR:
1529 case R_HPPA_NOT:
1530 case R_HPPA_LSHIFT:
1531 case R_HPPA_ARITH_RSHIFT:
1532 case R_HPPA_LOGIC_RSHIFT:
1533 case R_HPPA_EXPR_F:
1534 case R_HPPA_EXPR_L:
1535 case R_HPPA_EXPR_R:
1536 case R_HPPA_EXPR_LS:
1537 case R_HPPA_EXPR_RS:
1538 case R_HPPA_EXPR_LD:
1539 case R_HPPA_EXPR_RD:
1540 case R_HPPA_EXPR_LR:
1541 case R_HPPA_EXPR_RR:
1542 case R_HPPA_EXPR_32:
1543 case R_HPPA_EXPR_21:
1544 case R_HPPA_EXPR_11:
1545 case R_HPPA_EXPR_14:
1546 case R_HPPA_EXPR_17:
1547 case R_HPPA_EXPR_12:
1548 fprintf (stderr, "Relocation problem: ");
1549 fprintf (stderr, "Unimplemented reloc type %d, in module %s\n",
1550 r_type, abfd->filename);
1551 return bfd_reloc_notsupported;
1552
1553 /* This is a linker internal relocation. */
1554 case R_HPPA_STUB_CALL_17:
1555 /* This relocation is for a branch to a long branch stub.
1556 Change instruction to a BLE,N. It may also be necessary
1557 to change interchange the branch and its delay slot.
1558 The original instruction stream is
1559
1560 bl <foo>,r ; call foo using register r as
1561 ; the return pointer
1562 XXX ; delay slot instruction
1563
1564 The new instruction stream will be:
1565
1566 XXX ; delay slot instruction
1567 ble <foo_stub> ; call the long call stub for foo
1568 ; using r31 as the return pointer
1569
1570 This braindamage is necessary because the compiler may put
1571 an instruction which uses %r31 in the delay slot of the original
1572 call. By changing the call instruction from a "bl" to a "ble"
1573 %r31 gets clobbered before the delay slot executes.
1574
1575 We do not interchange the branch and delay slot if the delay
1576 slot was already nullified, or if the instruction in the delay
1577 slot modifies the return pointer to avoid an unconditional
1578 jump after the call returns (GCC optimization). */
1579
1580 if (insn & 2)
1581 {
1582 insn = BLE_N_XXX_0_0;
1583 bfd_put_32 (abfd, insn, hit_data);
1584 r_type = R_HPPA_ABS_CALL_17;
1585 r_pcrel = 0;
1586 insn = hppa_elf_relocate_insn (abfd, input_section, insn,
1587 addr, symbol_in, sym_value,
1588 r_addend, r_type, r_format,
1589 r_field, r_pcrel);
1590 }
1591 else
1592 {
1593 unsigned long old_delay_slot_insn = bfd_get_32 (abfd, hit_data + 4);
1594 unsigned rtn_reg = (insn & 0x03e00000) >> 21;
1595
1596 if (get_opcode (old_delay_slot_insn) == LDO)
1597 {
1598 unsigned ldo_src_reg = (old_delay_slot_insn & 0x03e00000) >> 21;
1599 unsigned ldo_target_reg = (old_delay_slot_insn & 0x001f0000) >> 16;
1600
1601 /* If the target of the LDO is the same as the return
1602 register then there is no reordering. We can leave the
1603 instuction as a non-nullified BLE in this case. */
1604 if (ldo_target_reg == rtn_reg)
1605 {
1606 unsigned long new_delay_slot_insn = old_delay_slot_insn;
1607
1608 BFD_ASSERT(ldo_src_reg == ldo_target_reg);
1609 new_delay_slot_insn &= 0xfc00ffff;
1610 new_delay_slot_insn |= ((31 << 21) | (31 << 16));
1611 bfd_put_32 (abfd, new_delay_slot_insn, hit_data + 4);
1612 insn = BLE_XXX_0_0;
1613 r_type = R_HPPA_ABS_CALL_17;
1614 r_pcrel = 0;
1615 insn = hppa_elf_relocate_insn (abfd, input_section, insn,
1616 addr, symbol_in, sym_value,
1617 r_addend, r_type, r_format,
1618 r_field, r_pcrel);
1619 bfd_put_32 (abfd, insn, hit_data);
1620 return bfd_reloc_ok;
1621 }
1622 else if (rtn_reg == 31)
1623 {
1624 /* The return register is r31, so this is a millicode
1625 call. Do not perform any instruction reordering. */
1626 insn = BLE_XXX_0_0;
1627 r_type = R_HPPA_ABS_CALL_17;
1628 r_pcrel = 0;
1629 insn = hppa_elf_relocate_insn (abfd, input_section, insn,
1630 addr, symbol_in, sym_value,
1631 r_addend, r_type, r_format,
1632 r_field, r_pcrel);
1633 bfd_put_32 (abfd, insn, hit_data);
1634 return bfd_reloc_ok;
1635 }
1636 else
1637 {
1638 /* Check to see if the delay slot instruction has a
1639 relocation. If so, we need to change the address
1640 field of it, because the instruction it relocates
1641 is going to be moved. */
1642 arelent * next_reloc_entry = reloc_entry+1;
1643
1644 if (next_reloc_entry->address == reloc_entry->address + 4)
1645 next_reloc_entry->address -= 4;
1646
1647 insn = old_delay_slot_insn;
1648 bfd_put_32 (abfd, insn, hit_data);
1649 insn = BLE_N_XXX_0_0;
1650 bfd_put_32 (abfd, insn, hit_data + 4);
1651 r_type = R_HPPA_ABS_CALL_17;
1652 r_pcrel = 0;
1653 insn = hppa_elf_relocate_insn (abfd, input_section, insn,
1654 addr + 4, symbol_in,
1655 sym_value, r_addend, r_type,
1656 r_format, r_field, r_pcrel);
1657 bfd_put_32 (abfd, insn, hit_data + 4);
1658 return bfd_reloc_ok;
1659 }
1660 }
1661 else if (rtn_reg == 31)
1662 {
1663 /* The return register is r31, so this is a millicode call.
1664 Perform no instruction reordering in this case. */
1665 insn = BLE_XXX_0_0;
1666 r_type = R_HPPA_ABS_CALL_17;
1667 r_pcrel = 0;
1668 insn = hppa_elf_relocate_insn (abfd, input_section, insn,
1669 addr, symbol_in, sym_value,
1670 r_addend, r_type, r_format,
1671 r_field, r_pcrel);
1672 bfd_put_32 (abfd, insn, hit_data);
1673 return bfd_reloc_ok;
1674 }
1675 else
1676 {
1677 /* Check to see if the delay slot instruction has a
1678 relocation. If so, we need to change its address
1679 field because the instruction it relocates is going
1680 to be moved. */
1681 arelent * next_reloc_entry = reloc_entry+1;
1682
1683 if (next_reloc_entry->address == reloc_entry->address + 4)
1684 next_reloc_entry->address -= 4;
1685
1686 insn = old_delay_slot_insn;
1687 bfd_put_32 (abfd, insn, hit_data);
1688 insn = BLE_N_XXX_0_0;
1689 bfd_put_32 (abfd, insn, hit_data + 4);
1690 r_type = R_HPPA_ABS_CALL_17;
1691 r_pcrel = 0;
1692 insn = hppa_elf_relocate_insn (abfd, input_section, insn,
1693 addr + 4, symbol_in, sym_value,
1694 r_addend, r_type, r_format,
1695 r_field, r_pcrel);
1696 bfd_put_32 (abfd, insn, hit_data + 4);
1697 return bfd_reloc_ok;
1698 }
1699 }
1700 break;
1701
1702 default:
1703 *error_message = (char *) "Unrecognized reloc";
1704 return bfd_reloc_dangerous;
1705 }
1706
1707 /* Update the instruction word. */
1708 bfd_put_32 (abfd, insn, hit_data);
1709 return (bfd_reloc_ok);
1710 }
1711
1712 static const reloc_howto_type *
1713 elf_hppa_reloc_type_lookup (arch, code)
1714 bfd_arch_info_type *arch;
1715 bfd_reloc_code_real_type code;
1716 {
1717 if ((int) code < (int) R_HPPA_UNIMPLEMENTED)
1718 {
1719 BFD_ASSERT ((int) elf_hppa_howto_table[(int) code].type == (int) code);
1720 return &elf_hppa_howto_table[(int) code];
1721 }
1722
1723 return (reloc_howto_type *) 0;
1724 }
1725
1726 #define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
1727
1728
1729 void
1730 elf_hppa_tc_symbol (abfd, symbolP, sym_idx)
1731 bfd *abfd;
1732 elf_symbol_type *symbolP;
1733 int sym_idx;
1734 {
1735 symext_chainS *symextP;
1736 unsigned int arg_reloc;
1737
1738 /* Only functions can have argument relocations. */
1739 if (!(symbolP->symbol.flags & BSF_FUNCTION))
1740 return;
1741
1742 arg_reloc = symbolP->tc_data.hppa_arg_reloc;
1743
1744 /* If there are no argument relocation bits, then no relocation is
1745 necessary. Do not add this to the symextn section. */
1746 if (arg_reloc == 0)
1747 return;
1748
1749 symextP = (symext_chainS *) bfd_alloc (abfd, sizeof (symext_chainS) * 2);
1750
1751 symextP[0].entry = ELF32_HPPA_SX_WORD (HPPA_SXT_SYMNDX, sym_idx);
1752 symextP[0].next = &symextP[1];
1753
1754 symextP[1].entry = ELF32_HPPA_SX_WORD (HPPA_SXT_ARG_RELOC, arg_reloc);
1755 symextP[1].next = NULL;
1756
1757 if (symext_rootP == NULL)
1758 {
1759 symext_rootP = &symextP[0];
1760 symext_lastP = &symextP[1];
1761 }
1762 else
1763 {
1764 symext_lastP->next = &symextP[0];
1765 symext_lastP = &symextP[1];
1766 }
1767 }
1768
1769 /* Accessor function for the list of symbol extension records. */
1770 symext_chainS *elf32_hppa_get_symextn_chain()
1771 {
1772 return symext_rootP;
1773 }
1774
1775 static symext_entryS *symextn_contents;
1776 static unsigned int symextn_contents_real_size;
1777
1778 void
1779 elf_hppa_tc_make_sections (abfd, ignored)
1780 bfd *abfd;
1781 PTR ignored;
1782 {
1783 symext_chainS *symextP;
1784 int size;
1785 int n;
1786 int i;
1787 void hppa_elf_stub_finish (); /* forward declaration */
1788 asection *symextn_sec;
1789
1790 hppa_elf_stub_finish (abfd);
1791
1792 if (symext_rootP == NULL)
1793 return;
1794
1795 for (n = 0, symextP = symext_rootP; symextP; symextP = symextP->next, ++n)
1796 ;
1797
1798 size = sizeof (symext_entryS) * n;
1799 symextn_sec = bfd_get_section_by_name (abfd, SYMEXTN_SECTION_NAME);
1800 if (symextn_sec == (asection *) 0)
1801 {
1802 symextn_sec = bfd_make_section (abfd, SYMEXTN_SECTION_NAME);
1803 bfd_set_section_flags (abfd,
1804 symextn_sec,
1805 SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE | SEC_READONLY);
1806 symextn_sec->output_section = symextn_sec;
1807 symextn_sec->output_offset = 0;
1808 bfd_set_section_alignment (abfd, symextn_sec, 2);
1809 }
1810 symextn_contents = (symext_entryS *) bfd_alloc (abfd, size);
1811
1812 for (i = 0, symextP = symext_rootP; symextP; symextP = symextP->next, ++i)
1813 symextn_contents[i] = symextP->entry;
1814 symextn_contents_real_size = size;
1815 bfd_set_section_size (abfd, symextn_sec, symextn_contents_real_size);
1816
1817 return;
1818 }
1819
1820 /* Support for HP PA-RISC stub generation.
1821
1822 Written by
1823
1824 Center for Software Science
1825 Department of Computer Science
1826 University of Utah
1827
1828 */
1829
1830 /*
1831 HP-PA calling conventions state:
1832
1833 1. an argument relocation stub is required whenever the callee and
1834 caller argument relocation bits do not match exactly. The exception
1835 to this rule is if either the caller or callee argument relocation
1836 bit are 00 (do not relocate).
1837
1838 2. The linker can optionally add a symbol record for the stub so that
1839 the stub can be reused. The symbol record will be the same as the
1840 original export symbol record, except that the relocation bits will
1841 reflect the input of the stub, the type would be STUB and the symbol
1842 value will be the location of the relocation stub.
1843
1844 Other notes:
1845
1846 Stubs can be inserted *before* the section of the caller. The stubs
1847 can be treated as calls to code that manipulates the arguments.
1848
1849 */
1850
1851 typedef enum
1852 {
1853 HPPA_STUB_ILLEGAL,
1854 HPPA_STUB_ARG_RELOC,
1855 HPPA_STUB_LONG_BRANCH
1856 } hppa_stub_type;
1857
1858 symext_entryS
1859 elf32_hppa_get_sym_extn (abfd, sym, type)
1860 bfd *abfd;
1861 asymbol *sym;
1862 int type;
1863 {
1864 /* This function finds the symbol extension record of the */
1865 /* specified type for the specified symbol. It returns the */
1866 /* value of the symbol extension record. */
1867 symext_entryS retval;
1868
1869 switch (type)
1870 {
1871 case HPPA_SXT_NULL:
1872 retval = (symext_entryS) 0;
1873 break;
1874 case HPPA_SXT_SYMNDX:
1875 retval = (symext_entryS) 0; /* XXX: need to fix this */
1876 break;
1877 case HPPA_SXT_ARG_RELOC:
1878 {
1879 elf_symbol_type *esymP = (elf_symbol_type *) sym;
1880
1881 retval = (symext_entryS) esymP->tc_data.hppa_arg_reloc;
1882 break;
1883 }
1884 /* This should never happen. */
1885 default:
1886 abort();
1887 }
1888 return retval;
1889 }
1890
1891 typedef struct elf32_hppa_stub_name_list_struct
1892 {
1893 /* name of this stub */
1894 asymbol *sym;
1895 /* stub description for this stub */
1896 struct elf32_hppa_stub_description_struct *stub_desc;
1897 /* pointer into stub contents */
1898 int *stub_secp;
1899 /* size of this stub */
1900 unsigned size;
1901 /* next stub name entry */
1902 struct elf32_hppa_stub_name_list_struct *next;
1903 } elf32_hppa_stub_name_list;
1904
1905 typedef struct elf32_hppa_stub_description_struct
1906 {
1907 struct elf32_hppa_stub_description_struct *next;
1908 bfd *this_bfd; /* bfd to which this stub applies */
1909 asection *stub_sec; /* stub section for this bfd */
1910 unsigned relocs_allocated_cnt; /* count of relocations for this stub section */
1911 unsigned real_size;
1912 unsigned allocated_size;
1913 int *stub_secp; /* pointer to the next available location in the buffer */
1914 char *stub_contents; /* contents of the stubs for this bfd */
1915 elf32_hppa_stub_name_list *stub_listP;
1916 struct bfd_link_info *link_info;
1917 }
1918 elf32_hppa_stub_description;
1919
1920 static elf32_hppa_stub_description *elf_hppa_stub_rootP;
1921
1922 /* Locate the stub section information for the given bfd. */
1923 static elf32_hppa_stub_description *
1924 find_stubs (abfd, stub_sec)
1925 bfd *abfd;
1926 asection *stub_sec;
1927 {
1928 elf32_hppa_stub_description *stubP;
1929
1930 for (stubP = elf_hppa_stub_rootP; stubP; stubP = stubP->next)
1931 {
1932 if (stubP->this_bfd == abfd
1933 && stubP->stub_sec == stub_sec)
1934 return stubP;
1935 }
1936
1937 return (elf32_hppa_stub_description *) NULL;
1938 }
1939
1940 static elf32_hppa_stub_description *
1941 new_stub (abfd, stub_sec, link_info)
1942 bfd *abfd;
1943 asection *stub_sec;
1944 struct bfd_link_info *link_info;
1945 {
1946 elf32_hppa_stub_description *stub = find_stubs (abfd, stub_sec);
1947
1948 if (stub)
1949 return stub;
1950
1951 stub = (elf32_hppa_stub_description *) bfd_zalloc (abfd, sizeof (elf32_hppa_stub_description));
1952 if (stub)
1953 {
1954 stub->this_bfd = abfd;
1955 stub->stub_sec = stub_sec;
1956 stub->real_size = 0;
1957 stub->allocated_size = 0;
1958 stub->stub_contents = NULL;
1959 stub->stub_secp = NULL;
1960 stub->link_info = link_info;
1961
1962 stub->next = elf_hppa_stub_rootP;
1963 elf_hppa_stub_rootP = stub;
1964 }
1965 else
1966 {
1967 bfd_error = no_memory;
1968 bfd_perror ("new_stub");
1969 }
1970
1971 return stub;
1972 }
1973
1974 /* Locate the stub by the given name. */
1975 static elf32_hppa_stub_name_list *
1976 find_stub_by_name (abfd, stub_sec, name)
1977 bfd *abfd;
1978 asection *stub_sec;
1979 char *name;
1980 {
1981 elf32_hppa_stub_description *stub = find_stubs (abfd, stub_sec);
1982
1983 if (stub)
1984 {
1985 elf32_hppa_stub_name_list *name_listP;
1986
1987 for (name_listP = stub->stub_listP; name_listP; name_listP = name_listP->next)
1988 {
1989 if (!strcmp (name_listP->sym->name, name))
1990 return name_listP;
1991 }
1992 }
1993
1994 return 0;
1995 }
1996
1997 /* Locate the stub by the given name. */
1998 static elf32_hppa_stub_name_list *
1999 add_stub_by_name(abfd, stub_sec, sym, link_info)
2000 bfd *abfd;
2001 asection *stub_sec;
2002 asymbol *sym;
2003 struct bfd_link_info *link_info;
2004 {
2005 elf32_hppa_stub_description *stub = find_stubs (abfd, stub_sec);
2006 elf32_hppa_stub_name_list *stub_entry;
2007
2008 if (!stub)
2009 stub = new_stub(abfd, stub_sec, link_info);
2010
2011 if (stub)
2012 {
2013 stub_entry = (elf32_hppa_stub_name_list *)
2014 bfd_zalloc (abfd, sizeof (elf32_hppa_stub_name_list));
2015
2016 if (stub_entry)
2017 {
2018 stub_entry->size = 0;
2019 stub_entry->sym = sym;
2020 stub_entry->stub_desc = stub;
2021 /* First byte of this stub is the pointer to
2022 the next available location in the stub buffer. */
2023 stub_entry->stub_secp = stub->stub_secp;
2024 if (stub->stub_listP)
2025 stub_entry->next = stub->stub_listP;
2026 else
2027 stub_entry->next = NULL;
2028 stub->stub_listP = stub_entry;
2029 return stub_entry;
2030 }
2031 else
2032 {
2033 bfd_error = no_memory;
2034 bfd_perror("add_stub_by_name");
2035 }
2036 }
2037
2038 return (elf32_hppa_stub_name_list *)NULL;
2039 }
2040
2041 #define ARGUMENTS 0
2042 #define RETURN_VALUE 1
2043
2044 #define NO_ARG_RELOC 0
2045 #define R_TO_FR 1
2046 #define R01_TO_FR 2
2047 #define R23_TO_FR 3
2048 #define FR_TO_R 4
2049 #define FR_TO_R01 5
2050 #define FR_TO_R23 6
2051 #define ARG_RELOC_ERR 7
2052
2053 #define ARG0 0
2054 #define ARG1 1
2055 #define ARG2 2
2056 #define ARG3 3
2057 #define RETVAL 4
2058
2059 #define AR_NO 0
2060 #define AR_GR 1
2061 #define AR_FR 2
2062 #define AR_FU 3
2063 /* FP register in arg0/arg1. This value can only appear in the arg0 location. */
2064 #define AR_DBL01 4
2065 /* FP register in arg2/arg3. This value can only appear in the arg2 location. */
2066 #define AR_DBL23 5
2067
2068 #define AR_WARN(type,loc) \
2069 fprintf(stderr,"WARNING: Illegal argument relocation: %s for %s\n", \
2070 reloc_type_strings[type],reloc_loc_strings[loc])
2071
2072 static CONST char *CONST reloc_type_strings[] =
2073 {
2074 "NONE", "GR->FR", "GR0,GR1->FR1", "GR2,GR3->FR3", "FR->GR", "FR->GR0,GR1", "FR->GR2,GR3", "ERROR"
2075 };
2076
2077 static CONST char *CONST reloc_loc_strings[] =
2078 {
2079 "ARG0", "ARG1", "ARG2", "ARG3", "RETVAL"
2080 };
2081
2082 static CONST char mismatches[6][6] =
2083 { /* CALLEE NONE CALLEE GR CALLEE FR CALLEE FU CALLEE DBL01 CALLEE DBL23 */
2084 /* CALLER NONE */
2085 {NO_ARG_RELOC, NO_ARG_RELOC, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, NO_ARG_RELOC},
2086 /* CALLER GR */
2087 {NO_ARG_RELOC, NO_ARG_RELOC, R_TO_FR, ARG_RELOC_ERR, R01_TO_FR, ARG_RELOC_ERR},
2088 /* CALLER FR */
2089 {NO_ARG_RELOC, FR_TO_R, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR},
2090 /* CALLER FU */
2091 {ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR},
2092 /* CALLER DBL01 */
2093 {NO_ARG_RELOC, FR_TO_R01, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, ARG_RELOC_ERR},
2094 /* CALLER DBL23 */
2095 {NO_ARG_RELOC, FR_TO_R23, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR, NO_ARG_RELOC},
2096 };
2097
2098 static CONST char retval_mismatches[6][6] =
2099 { /* CALLEE NONE CALLEE GR CALLEE FR CALLEE FU CALLEE DBL01 CALLEE DBL23 */
2100 /* CALLER NONE */
2101 {NO_ARG_RELOC, NO_ARG_RELOC, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, NO_ARG_RELOC},
2102 /* CALLER GR */
2103 {NO_ARG_RELOC, NO_ARG_RELOC, FR_TO_R, ARG_RELOC_ERR, FR_TO_R01, ARG_RELOC_ERR},
2104 /* CALLER FR */
2105 {NO_ARG_RELOC, R_TO_FR, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR},
2106 /* CALLER FU */
2107 {ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR},
2108 /* CALLER DBL01 */
2109 {NO_ARG_RELOC, R01_TO_FR, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, ARG_RELOC_ERR},
2110 /* CALLER DBL23 */
2111 {NO_ARG_RELOC, R23_TO_FR, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR, NO_ARG_RELOC},
2112 };
2113
2114 static int
2115 type_of_mismatch (caller_bits, callee_bits, type)
2116 int caller_bits;
2117 int callee_bits;
2118 int type;
2119 {
2120 switch (type)
2121 {
2122 case ARGUMENTS:
2123 return mismatches[caller_bits][callee_bits];
2124 case RETURN_VALUE:
2125 return retval_mismatches[caller_bits][callee_bits];
2126 }
2127
2128 return 0;
2129 }
2130
2131 #define EXTRACT_ARBITS(ar,which) ((ar) >> (8-(which*2))) & 3
2132
2133 #define NEW_INSTRUCTION(entry,insn) \
2134 { \
2135 *((entry)->stub_desc->stub_secp)++ = (insn); \
2136 (entry)->stub_desc->real_size += sizeof(int); \
2137 (entry)->size += sizeof(int); \
2138 bfd_set_section_size((entry)->stub_desc->this_bfd, \
2139 (entry)->stub_desc->stub_sec, \
2140 (entry)->stub_desc->real_size); \
2141 }
2142
2143 #define CURRENT_STUB_OFFSET(entry) \
2144 ((int)(entry)->stub_desc->stub_secp \
2145 - (int)(entry)->stub_desc->stub_contents - 4)
2146
2147 static boolean stubs_finished = false;
2148
2149 void
2150 hppa_elf_stub_finish (output_bfd)
2151 bfd *output_bfd;
2152 {
2153 elf32_hppa_stub_description *stub_list = elf_hppa_stub_rootP;
2154 /* All the stubs have been built. Finish up building */
2155 /* stub section. Apply relocations to the section. */
2156
2157 if ( stubs_finished )
2158 return;
2159
2160 for (; stub_list; stub_list = stub_list->next)
2161 {
2162 if (stub_list->real_size)
2163 {
2164 bfd *stub_bfd = stub_list->this_bfd;
2165 asection *stub_sec = bfd_get_section_by_name (stub_bfd, ".hppa_linker_stubs");
2166 bfd_size_type reloc_size;
2167 arelent **reloc_vector;
2168
2169 BFD_ASSERT (stub_sec == stub_list->stub_sec);
2170 reloc_size = bfd_get_reloc_upper_bound (stub_bfd, stub_sec);
2171 reloc_vector = (arelent **) alloca (reloc_size);
2172
2173 BFD_ASSERT (stub_sec);
2174
2175 /* We are not relaxing the section, so just copy the size info */
2176 stub_sec->_cooked_size = stub_sec->_raw_size;
2177 stub_sec->reloc_done = true;
2178
2179
2180 if (bfd_canonicalize_reloc (stub_bfd,
2181 stub_sec,
2182 reloc_vector,
2183 output_bfd->outsymbols))
2184 {
2185 arelent **parent;
2186 for (parent = reloc_vector; *parent != (arelent *) NULL;
2187 parent++)
2188 {
2189 char *err = (char *) NULL;
2190 bfd_reloc_status_type r =
2191 bfd_perform_relocation (stub_bfd,
2192 *parent,
2193 stub_list->stub_contents,
2194 stub_sec, (bfd *) NULL, &err);
2195
2196
2197 if (r != bfd_reloc_ok)
2198 {
2199 struct bfd_link_info *link_info = stub_list->link_info;
2200
2201 switch (r)
2202 {
2203 case bfd_reloc_undefined:
2204 if (! ((*link_info->callbacks->undefined_symbol)
2205 (link_info,
2206 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
2207 stub_bfd, stub_sec, (*parent)->address)))
2208 abort ();
2209 break;
2210 case bfd_reloc_dangerous:
2211 if (! ((*link_info->callbacks->reloc_dangerous)
2212 (link_info, err, stub_bfd, stub_sec,
2213 (*parent)->address)))
2214 abort ();
2215 break;
2216 case bfd_reloc_overflow:
2217 {
2218 if (! ((*link_info->callbacks->reloc_overflow)
2219 (link_info,
2220 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
2221 (*parent)->howto->name,
2222 (*parent)->addend,
2223 stub_bfd, stub_sec,
2224 (*parent)->address)))
2225 abort ();
2226 }
2227 break;
2228 case bfd_reloc_outofrange:
2229 default:
2230 abort ();
2231 break;
2232 }
2233 }
2234 }
2235 }
2236
2237 bfd_set_section_contents (output_bfd,
2238 stub_sec,
2239 stub_list->stub_contents,
2240 0,
2241 stub_list->real_size);
2242
2243 free (reloc_vector);
2244 }
2245 }
2246 stubs_finished = true;
2247 }
2248
2249 void
2250 hppa_elf_stub_branch_reloc (stub_desc, /* the bfd */
2251 output_bfd, /* the output bfd */
2252 target_sym, /* the target symbol */
2253 offset) /* the offset within the stub buffer (pre-calculated) */
2254 elf32_hppa_stub_description *stub_desc;
2255 bfd *output_bfd;
2256 asymbol *target_sym;
2257 int offset;
2258 {
2259 /* Allocate a new relocation entry. */
2260 arelent relent;
2261 int size;
2262
2263 if (stub_desc->relocs_allocated_cnt == stub_desc->stub_sec->reloc_count)
2264 {
2265 if (stub_desc->stub_sec->relocation == NULL)
2266 {
2267 stub_desc->relocs_allocated_cnt = STUB_RELOC_INCR;
2268 size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
2269 stub_desc->stub_sec->relocation = (arelent *) bfd_zmalloc (size);
2270 }
2271 else
2272 {
2273 stub_desc->relocs_allocated_cnt += STUB_RELOC_INCR;
2274 size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
2275 stub_desc->stub_sec->relocation = (arelent *) realloc (stub_desc->stub_sec->relocation,
2276 size);
2277 }
2278 }
2279
2280 /* Fill in the details. */
2281 relent.address = offset;
2282 relent.addend = 0;
2283 relent.sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd, sizeof (asymbol *));
2284 BFD_ASSERT (relent.sym_ptr_ptr);
2285
2286 relent.sym_ptr_ptr[0] = target_sym;
2287 relent.howto = bfd_reloc_type_lookup (stub_desc->this_bfd, R_HPPA_PCREL_CALL_17);
2288
2289 /* Save it in the array of relocations for the stub section. */
2290
2291 memcpy (&stub_desc->stub_sec->relocation[stub_desc->stub_sec->reloc_count++],
2292 &relent,
2293 sizeof (arelent));
2294 }
2295
2296 void
2297 hppa_elf_stub_reloc (stub_desc, /* the bfd */
2298 output_bfd, /* the output bfd */
2299 target_sym, /* the target symbol */
2300 offset, /* the offset within the stub buffer (pre-calculated) */
2301 type)
2302 elf32_hppa_stub_description *stub_desc;
2303 bfd *output_bfd;
2304 asymbol *target_sym;
2305 int offset;
2306 elf32_hppa_reloc_type type;
2307 {
2308 /* Allocate a new relocation entry. */
2309 arelent relent;
2310 int size;
2311 Elf_Internal_Shdr *rela_hdr;
2312
2313 if (stub_desc->relocs_allocated_cnt == stub_desc->stub_sec->reloc_count)
2314 {
2315 if (stub_desc->stub_sec->relocation == NULL)
2316 {
2317 stub_desc->relocs_allocated_cnt = STUB_RELOC_INCR;
2318 size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
2319 stub_desc->stub_sec->relocation = (arelent *) bfd_zmalloc (size);
2320 }
2321 else
2322 {
2323 stub_desc->relocs_allocated_cnt += STUB_RELOC_INCR;
2324 size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
2325 stub_desc->stub_sec->relocation = (arelent *) realloc (stub_desc->stub_sec->relocation,
2326 size);
2327 }
2328 }
2329
2330 rela_hdr = &elf_section_data(stub_desc->stub_sec)->rel_hdr;
2331 rela_hdr->sh_size += sizeof(Elf32_External_Rela);
2332
2333 /* Fill in the details. */
2334 relent.address = offset;
2335 relent.addend = 0;
2336 relent.sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd, sizeof (asymbol *));
2337 BFD_ASSERT (relent.sym_ptr_ptr);
2338
2339 relent.sym_ptr_ptr[0] = target_sym;
2340 relent.howto = bfd_reloc_type_lookup (stub_desc->this_bfd, type);
2341
2342 /* Save it in the array of relocations for the stub section. */
2343
2344 memcpy (&stub_desc->stub_sec->relocation[stub_desc->stub_sec->reloc_count++],
2345 &relent,
2346 sizeof (arelent));
2347 }
2348
2349 asymbol *
2350 hppa_elf_build_arg_reloc_stub (abfd, output_bfd, link_info, reloc_entry,
2351 stub_types, rtn_adjust, data)
2352 bfd *abfd;
2353 bfd *output_bfd;
2354 struct bfd_link_info *link_info;
2355 arelent *reloc_entry;
2356 int stub_types[5];
2357 int rtn_adjust;
2358 unsigned *data;
2359 {
2360 asection *stub_sec = bfd_get_section_by_name (abfd, ".hppa_linker_stubs");
2361 elf32_hppa_stub_description *stub_desc = find_stubs (abfd, stub_sec);
2362 asymbol *stub_sym = NULL;
2363 asymbol *target_sym = reloc_entry->sym_ptr_ptr[0];
2364 asection *output_text_section = bfd_get_section_by_name (output_bfd, ".text");
2365 int i;
2366 char stub_sym_name[128];
2367 elf32_hppa_stub_name_list *stub_entry;
2368 unsigned insn = data[0];
2369
2370 /* Perform some additional checks on whether we should really do the
2371 return adjustment. For example, if the instruction is nullified
2372 or if the delay slot contains an instruction that modifies the return
2373 pointer, then the branch instructions should not be rearranged
2374 (rtn_adjust is false). */
2375 if (insn & 2 || insn == 0)
2376 rtn_adjust = false;
2377 else
2378 {
2379 unsigned delay_insn = data[1];
2380
2381 if (get_opcode (delay_insn) == LDO
2382 && (((insn & 0x03e00000) >> 21) == ((delay_insn & 0x001f0000) >> 16)))
2383 rtn_adjust = false;
2384 }
2385
2386 /* See if the proper stub entry has already been made. */
2387 if (!stub_sec)
2388 {
2389 BFD_ASSERT (stub_desc == NULL);
2390 stub_sec = bfd_make_section (abfd, ".hppa_linker_stubs");
2391 bfd_set_section_flags (abfd,
2392 stub_sec,
2393 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
2394 | SEC_RELOC | SEC_CODE | SEC_READONLY);
2395 stub_sec->output_section = output_text_section->output_section;
2396 stub_sec->output_offset = 0;
2397 bfd_set_section_alignment (abfd, stub_sec, 2);
2398 stub_desc = new_stub (abfd, stub_sec, link_info);
2399 }
2400
2401 /* Make the stub if we did not find one already. */
2402 if (!stub_desc)
2403 stub_desc = new_stub (abfd, stub_sec, link_info);
2404
2405 /* Allocate space to write the stub.
2406 FIXME. Why using realloc?!? */
2407 if (!stub_desc->stub_contents)
2408 {
2409 stub_desc->allocated_size = STUB_BUFFER_INCR;
2410 stub_desc->stub_contents = (char *) bfd_xmalloc (STUB_BUFFER_INCR);
2411 }
2412 else if ((stub_desc->allocated_size - stub_desc->real_size) < STUB_MAX_SIZE)
2413 {
2414 stub_desc->allocated_size = stub_desc->allocated_size + STUB_BUFFER_INCR;
2415 stub_desc->stub_contents = (char *) realloc (stub_desc->stub_contents,
2416 stub_desc->allocated_size);
2417 }
2418
2419 stub_desc->stub_secp
2420 = (int *) (stub_desc->stub_contents + stub_desc->real_size);
2421
2422 sprintf (stub_sym_name,
2423 "_stub_%s_%02d_%02d_%02d_%02d_%02d_%s",
2424 reloc_entry->sym_ptr_ptr[0]->name,
2425 stub_types[0], stub_types[1], stub_types[2],
2426 stub_types[3], stub_types[4],
2427 rtn_adjust ? "RA" : "");
2428 stub_entry = find_stub_by_name (abfd, stub_sec, stub_sym_name);
2429
2430 if (stub_entry)
2431 {
2432 stub_sym = stub_entry->sym;
2433 /* Redirect the original relocation from the old symbol (a function)
2434 to the stub (the stub calls the function). Should we need to
2435 change the relocation type? */
2436 reloc_entry->sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd,
2437 sizeof (asymbol *));
2438 reloc_entry->sym_ptr_ptr[0] = stub_sym;
2439 if (reloc_entry->howto->type != R_HPPA_PLABEL_32
2440 && (get_opcode(insn) == BLE
2441 || get_opcode (insn) == BE
2442 || get_opcode (insn) == BL))
2443 reloc_entry->howto = bfd_reloc_type_lookup (abfd, R_HPPA_STUB_CALL_17);
2444 }
2445 else
2446 {
2447 /* Create a new symbol to point to this stub. */
2448 stub_sym = bfd_make_empty_symbol (abfd);
2449 stub_sym->name = bfd_zalloc (abfd, strlen (stub_sym_name) + 1);
2450 strcpy ((char *) stub_sym->name, stub_sym_name);
2451 stub_sym->value
2452 = (int) stub_desc->stub_secp - (int) stub_desc->stub_contents;
2453 stub_sym->section = stub_sec;
2454 stub_sym->flags = BSF_LOCAL | BSF_FUNCTION;
2455 stub_entry = add_stub_by_name (abfd, stub_sec, stub_sym, link_info);
2456
2457 /* Redirect the original relocation from the old symbol (a function)
2458 to the stub (the stub calls the function). Change the type of
2459 relocation to be the internal use only stub R_HPPA_STUB_CALL_17. */
2460 reloc_entry->sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd,
2461 sizeof (asymbol *));
2462 reloc_entry->sym_ptr_ptr[0] = stub_sym;
2463 if (reloc_entry->howto->type != R_HPPA_PLABEL_32
2464 && (get_opcode (insn) == BLE
2465 || get_opcode (insn) == BE
2466 || get_opcode (insn) == BL))
2467 reloc_entry->howto = bfd_reloc_type_lookup (abfd, R_HPPA_STUB_CALL_17);
2468
2469 /* Generate common code for all stubs. */
2470
2471 NEW_INSTRUCTION (stub_entry, LDSID_31_1);
2472 NEW_INSTRUCTION (stub_entry, MTSP_1_SR0);
2473 NEW_INSTRUCTION (stub_entry, ADDI_8_SP);
2474
2475 /* Generate code to move the arguments around. */
2476 for (i = ARG0; i < ARG3; i++)
2477 {
2478 if (stub_types[i] != NO_ARG_RELOC)
2479 {
2480 switch (stub_types[i])
2481 {
2482 case R_TO_FR:
2483 switch (i)
2484 {
2485 case ARG0:
2486 NEW_INSTRUCTION (stub_entry, STWS_ARG0_M8SP);
2487 NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG0);
2488 break;
2489 case ARG1:
2490 NEW_INSTRUCTION (stub_entry, STWS_ARG1_M8SP);
2491 NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG1);
2492 break;
2493 case ARG2:
2494 NEW_INSTRUCTION (stub_entry, STWS_ARG2_M8SP);
2495 NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG2);
2496 break;
2497 case ARG3:
2498 NEW_INSTRUCTION (stub_entry, STWS_ARG3_M8SP);
2499 NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG3);
2500 break;
2501 }
2502 continue;
2503
2504 case R01_TO_FR:
2505 switch (i)
2506 {
2507 case ARG0:
2508 NEW_INSTRUCTION (stub_entry, STWS_ARG0_M4SP);
2509 NEW_INSTRUCTION (stub_entry, STWS_ARG1_M8SP);
2510 NEW_INSTRUCTION (stub_entry, FLDDS_M8SP_FARG1);
2511 break;
2512 default:
2513 AR_WARN (stub_types[i],i);
2514 break;
2515 }
2516 continue;
2517
2518 case R23_TO_FR:
2519 switch (i)
2520 {
2521 case ARG2:
2522 NEW_INSTRUCTION (stub_entry, STWS_ARG2_M4SP);
2523 NEW_INSTRUCTION (stub_entry, STWS_ARG3_M8SP);
2524 NEW_INSTRUCTION (stub_entry, FLDDS_M8SP_FARG3);
2525 break;
2526 default:
2527 AR_WARN (stub_types[i],i);
2528 break;
2529 }
2530 continue;
2531
2532 case FR_TO_R:
2533 switch (i)
2534 {
2535 case ARG0:
2536 NEW_INSTRUCTION (stub_entry, FSTWS_FARG0_M8SP);
2537 NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG0);
2538 break;
2539 case ARG1:
2540 NEW_INSTRUCTION (stub_entry, FSTWS_FARG1_M8SP);
2541 NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG1);
2542 break;
2543 case ARG2:
2544 NEW_INSTRUCTION (stub_entry, FSTWS_FARG2_M8SP);
2545 NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG2);
2546 break;
2547 case ARG3:
2548 NEW_INSTRUCTION (stub_entry, FSTWS_FARG3_M8SP);
2549 NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG3);
2550 break;
2551 }
2552 continue;
2553
2554 case FR_TO_R01:
2555 switch (i)
2556 {
2557 case ARG0:
2558 NEW_INSTRUCTION (stub_entry, FSTDS_FARG1_M8SP);
2559 NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG0);
2560 NEW_INSTRUCTION (stub_entry, LDWS_M8SP_ARG1);
2561 break;
2562 default:
2563 AR_WARN (stub_types[i],i);
2564 break;
2565 }
2566 continue;
2567
2568 case FR_TO_R23:
2569 switch (i)
2570 {
2571 case ARG2:
2572 NEW_INSTRUCTION (stub_entry, FSTDS_FARG3_M8SP);
2573 NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG2);
2574 NEW_INSTRUCTION (stub_entry, LDWS_M8SP_ARG3);
2575 break;
2576 default:
2577 AR_WARN (stub_types[i],i);
2578 break;
2579 }
2580 continue;
2581
2582 }
2583 }
2584 }
2585
2586 NEW_INSTRUCTION (stub_entry, ADDI_M8_SP_SP);
2587
2588 /* Adjust the return address if necessary. */
2589 if (rtn_adjust)
2590 {
2591 NEW_INSTRUCTION (stub_entry, ADDI_M4_31_RP);
2592 }
2593 else
2594 NEW_INSTRUCTION (stub_entry, COPY_31_2);
2595
2596 /* Save the return address. */
2597 NEW_INSTRUCTION (stub_entry, STW_RP_M8SP);
2598
2599 /* Long branch to the target function. */
2600 NEW_INSTRUCTION (stub_entry, LDIL_XXX_31);
2601 hppa_elf_stub_reloc (stub_entry->stub_desc,
2602 abfd,
2603 target_sym,
2604 CURRENT_STUB_OFFSET (stub_entry),
2605 R_HPPA_L21);
2606 NEW_INSTRUCTION (stub_entry, BLE_XXX_0_31);
2607 hppa_elf_stub_reloc (stub_entry->stub_desc,
2608 abfd,
2609 target_sym,
2610 CURRENT_STUB_OFFSET (stub_entry),
2611 R_HPPA_ABS_CALL_R17);
2612 NEW_INSTRUCTION (stub_entry, COPY_31_2);
2613
2614
2615 /* Restore the return address. */
2616 NEW_INSTRUCTION (stub_entry, LDW_M8SP_RP);
2617
2618 /* Generate the code to move the return value around. */
2619 i = RETVAL;
2620 if (stub_types[i] != NO_ARG_RELOC)
2621 {
2622 switch (stub_types[i])
2623 {
2624 case R_TO_FR:
2625 NEW_INSTRUCTION (stub_entry, STWS_RET0_M8SP);
2626 NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FRET0);
2627 break;
2628
2629 case FR_TO_R:
2630 NEW_INSTRUCTION (stub_entry, FSTWS_FRET0_M8SP);
2631 NEW_INSTRUCTION (stub_entry, LDWS_M4SP_RET0);
2632 break;
2633 }
2634 }
2635 NEW_INSTRUCTION (stub_entry, BV_N_0_RP);
2636 }
2637
2638 return stub_sym;
2639 }
2640
2641 int
2642 hppa_elf_arg_reloc_needed_p (abfd, reloc_entry, stub_types, caller_ar)
2643 bfd *abfd;
2644 arelent *reloc_entry;
2645 int stub_types[5];
2646 symext_entryS caller_ar;
2647 {
2648 /* If the symbol is still undefined, there is */
2649 /* no way to know if a stub is required. */
2650
2651 if (reloc_entry->sym_ptr_ptr[0] && reloc_entry->sym_ptr_ptr[0]->section != &bfd_und_section)
2652 {
2653 symext_entryS callee_ar = elf32_hppa_get_sym_extn (abfd,
2654 reloc_entry->sym_ptr_ptr[0],
2655 HPPA_SXT_ARG_RELOC);
2656
2657 /* Now, determine if a stub is */
2658 /* required. A stub is required if they the callee and caller */
2659 /* argument relocation bits are both nonzero and not equal. */
2660
2661 if (caller_ar && callee_ar)
2662 {
2663 /* Both are non-zero, we need to do further checking. */
2664 /* First, check if there is a return value relocation to be done */
2665 int caller_loc[5];
2666 int callee_loc[5];
2667
2668 callee_loc[RETVAL] = EXTRACT_ARBITS (callee_ar, RETVAL);
2669 caller_loc[RETVAL] = EXTRACT_ARBITS (caller_ar, RETVAL);
2670 callee_loc[ARG0] = EXTRACT_ARBITS (callee_ar, ARG0);
2671 caller_loc[ARG0] = EXTRACT_ARBITS (caller_ar, ARG0);
2672 callee_loc[ARG1] = EXTRACT_ARBITS (callee_ar, ARG1);
2673 caller_loc[ARG1] = EXTRACT_ARBITS (caller_ar, ARG1);
2674 callee_loc[ARG2] = EXTRACT_ARBITS (callee_ar, ARG2);
2675 caller_loc[ARG2] = EXTRACT_ARBITS (caller_ar, ARG2);
2676 callee_loc[ARG3] = EXTRACT_ARBITS (callee_ar, ARG3);
2677 caller_loc[ARG3] = EXTRACT_ARBITS (caller_ar, ARG3);
2678
2679 /* Check some special combinations. For */
2680 /* example, if FU appears in ARG1 or ARG3, we */
2681 /* can move it to ARG0 or ARG2, respectively. */
2682
2683 if (caller_loc[ARG0] == AR_FU || caller_loc[ARG1] == AR_FU)
2684 {
2685 caller_loc[ARG0] = AR_DBL01;
2686 caller_loc[ARG1] = AR_NO;
2687 }
2688 if (caller_loc[ARG2] == AR_FU || caller_loc[ARG3] == AR_FU)
2689 {
2690 caller_loc[ARG2] = AR_DBL23;
2691 caller_loc[ARG3] = AR_NO;
2692 }
2693 if (callee_loc[ARG0] == AR_FU || callee_loc[ARG1] == AR_FU)
2694 {
2695 callee_loc[ARG0] = AR_DBL01;
2696 callee_loc[ARG1] = AR_NO;
2697 }
2698 if (callee_loc[ARG2] == AR_FU || callee_loc[ARG3] == AR_FU)
2699 {
2700 callee_loc[ARG2] = AR_DBL23;
2701 callee_loc[ARG3] = AR_NO;
2702 }
2703
2704 stub_types[ARG0] = type_of_mismatch (caller_loc[ARG0], callee_loc[ARG0], ARGUMENTS);
2705 stub_types[ARG1] = type_of_mismatch (caller_loc[ARG1], callee_loc[ARG1], ARGUMENTS);
2706 stub_types[ARG2] = type_of_mismatch (caller_loc[ARG2], callee_loc[ARG2], ARGUMENTS);
2707 stub_types[ARG3] = type_of_mismatch (caller_loc[ARG3], callee_loc[ARG3], ARGUMENTS);
2708 stub_types[RETVAL] = type_of_mismatch (caller_loc[RETVAL], callee_loc[RETVAL], RETURN_VALUE);
2709
2710 /* Steps involved in building stubs: */
2711 /* 1. Determine what argument registers need to relocated. This */
2712 /* step is already done here. */
2713 /* 2. Build the appropriate stub in the .hppa_linker_stubs section. */
2714 /* This section should never appear in an object file. It is */
2715 /* only used internally. The output_section of the */
2716 /* .hppa_linker_stubs section is the .text section of the */
2717 /* executable. */
2718 /* 3. Build a symbol that is used (internally only) as the entry */
2719 /* point of the stub. */
2720 /* 4. Change the instruction of the original branch into a branch to */
2721 /* the stub routine. */
2722 /* 5. Build a relocation entry for the instruction of the original */
2723 /* branch to be R_HPPA_PCREL_CALL to the stub routine. */
2724
2725
2726 if (stub_types[0]
2727 || stub_types[1]
2728 || stub_types[2]
2729 || stub_types[3]
2730 || stub_types[4])
2731 {
2732 #ifdef DETECT_STUBS
2733 int i;
2734
2735 fprintf (stderr, "Stub needed for %s @ %s+0x%x: callee/caller ar=0x%x/0x%x ",
2736 reloc_entry->sym_ptr_ptr[0]->name,
2737 abfd->filename, reloc_entry->address,
2738 callee_ar, caller_ar);
2739 for (i = ARG0; i < RETVAL; i++)
2740 {
2741 if (stub_types[i] != NO_ARG_RELOC)
2742 {
2743 fprintf (stderr, "%s%d: %s ",
2744 i == RETVAL ? "ret" : "arg",
2745 i == RETVAL ? 0 : i,
2746 reloc_type_strings[stub_types[i]]);
2747 }
2748 }
2749 fprintf (stderr, "\n");
2750 #endif
2751 return 1;
2752 }
2753
2754 }
2755 }
2756 return 0;
2757 }
2758
2759 asymbol *
2760 hppa_elf_build_long_branch_stub (abfd, output_bfd, link_info, reloc_entry,
2761 symbol, data)
2762 bfd *abfd;
2763 bfd *output_bfd;
2764 struct bfd_link_info *link_info;
2765 arelent *reloc_entry;
2766 asymbol *symbol;
2767 unsigned *data;
2768 {
2769 asection *stub_sec = bfd_get_section_by_name (abfd, ".hppa_linker_stubs");
2770 elf32_hppa_stub_description *stub_desc = find_stubs (abfd, stub_sec);
2771 asymbol *stub_sym = NULL;
2772 asymbol *target_sym = reloc_entry->sym_ptr_ptr[0];
2773 asection *output_text_section = bfd_get_section_by_name (output_bfd, ".text");
2774 char stub_sym_name[128];
2775 int milli = false;
2776 int dyncall = false;
2777 elf32_hppa_stub_name_list *stub_entry;
2778 int rtn_adjust = true;
2779 int rtn_reg;
2780 unsigned insn;
2781
2782 /* Create the stub section if it does not already exist. */
2783 if (!stub_sec)
2784 {
2785 BFD_ASSERT (stub_desc == NULL);
2786 stub_sec = bfd_make_section (abfd, ".hppa_linker_stubs");
2787 bfd_set_section_flags (abfd,
2788 stub_sec,
2789 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
2790 | SEC_RELOC | SEC_CODE | SEC_READONLY);
2791 stub_sec->output_section = output_text_section->output_section;
2792 stub_sec->output_offset = 0;
2793
2794 /* Set up the ELF section header for this new section. This
2795 is basically the same processing as elf_make_sections().
2796 elf_make_sections is static and therefore not accessable
2797 here. */
2798 {
2799 Elf_Internal_Shdr *this_hdr;
2800 this_hdr = &elf_section_data (stub_sec)->this_hdr;
2801
2802 /* Set the sizes of this section. The contents have already
2803 been set up ?!? */
2804 this_hdr->sh_addr = stub_sec->vma;
2805 this_hdr->sh_size = stub_sec->_raw_size;
2806
2807 /* Set appropriate flags for sections with relocations. */
2808 if (stub_sec->flags & SEC_RELOC)
2809 {
2810 Elf_Internal_Shdr *rela_hdr;
2811 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
2812
2813 rela_hdr = &elf_section_data (stub_sec)->rel_hdr;
2814
2815 if (use_rela_p)
2816 {
2817 rela_hdr->sh_type = SHT_RELA;
2818 rela_hdr->sh_entsize = sizeof (Elf32_External_Rela);
2819 }
2820 else
2821 {
2822 rela_hdr->sh_type = SHT_REL;
2823 rela_hdr->sh_entsize = sizeof (Elf32_External_Rel);
2824 }
2825 rela_hdr->sh_flags = 0;
2826 rela_hdr->sh_addr = 0;
2827 rela_hdr->sh_offset = 0;
2828 rela_hdr->sh_addralign = 0;
2829 rela_hdr->size = 0;
2830 }
2831
2832 if (stub_sec->flags & SEC_ALLOC)
2833 {
2834 this_hdr->sh_flags |= SHF_ALLOC;
2835 /* FIXME. If SEC_LOAD is true should we do something with
2836 with sh_type? */
2837 }
2838
2839 if (!(stub_sec->flags & SEC_READONLY))
2840 this_hdr->sh_flags |= SHF_WRITE;
2841
2842 if (stub_sec->flags & SEC_CODE)
2843 this_hdr->sh_flags |= SHF_EXECINSTR;
2844 }
2845
2846 bfd_set_section_alignment (abfd, stub_sec, 2);
2847 stub_desc = new_stub (abfd, stub_sec, link_info);
2848 }
2849
2850 if (!stub_desc)
2851 stub_desc = new_stub (abfd, stub_sec, link_info);
2852
2853 /* Allocate memory to contain the stub. FIXME. Why isn't this using
2854 the BFD memory allocation routines? */
2855 if (!stub_desc->stub_contents)
2856 {
2857 stub_desc->allocated_size = STUB_BUFFER_INCR;
2858 stub_desc->stub_contents = (char *) malloc (STUB_BUFFER_INCR);
2859 }
2860 else if ((stub_desc->allocated_size - stub_desc->real_size) < STUB_MAX_SIZE)
2861 {
2862 stub_desc->allocated_size = stub_desc->allocated_size + STUB_BUFFER_INCR;
2863 stub_desc->stub_contents = (char *) realloc (stub_desc->stub_contents,
2864 stub_desc->allocated_size);
2865 }
2866
2867 stub_desc->stub_secp
2868 = (int *) (stub_desc->stub_contents + stub_desc->real_size);
2869
2870 /* Is this a millicode call? If so, the return address
2871 comes in on r31 rather than r2 (rp) so a slightly
2872 different code sequence is needed. */
2873
2874 insn = data[0];
2875 rtn_reg = (insn & 0x03e00000) >> 21;
2876 if (rtn_reg == 31)
2877 milli = true;
2878
2879 if (strcmp (symbol->name, "$$dyncall") == 0)
2880 dyncall = true;
2881
2882 /* If we are creating a call from a stub to another stub, then
2883 never do the instruction reordering. We can tell if we are
2884 going to be calling one stub from another by the fact that
2885 the symbol name has '_stub_' (arg. reloc. stub) or '_lb_stub_'
2886 prepended to the name. Alternatively, the section of the
2887 symbol will be '.hppa_linker_stubs'. */
2888
2889 if ((strncmp (symbol->name, "_stub_", 6) == 0)
2890 || (strncmp (symbol->name, "_lb_stub_", 9) == 0))
2891 {
2892 BFD_ASSERT (strcmp (symbol->section->name, ".hppa_linker_stubs") == 0);
2893 rtn_adjust = false;
2894 }
2895
2896 /* Check to see if we modify the return pointer
2897 in the delay slot of the branch. */
2898 {
2899 unsigned delay_insn = data[1];
2900
2901 /* If we nullify the delay slot, or if the delay slot contains an
2902 instruction that modifies the return pointer, then no additional
2903 modification of the return pointer is necessary. */
2904 if (insn & 2 || insn == 0)
2905 rtn_adjust = false;
2906 else
2907 {
2908 if (get_opcode (delay_insn) == LDO
2909 && (((delay_insn & 0x001f0000) >> 16) == rtn_reg))
2910 rtn_adjust = false;
2911 if (milli)
2912 rtn_adjust = false;
2913 }
2914 }
2915
2916 sprintf (stub_sym_name,
2917 "_lb_stub_%s_%s", reloc_entry->sym_ptr_ptr[0]->name,
2918 rtn_adjust ? "RA" : "");
2919 stub_entry = find_stub_by_name(abfd, stub_sec, stub_sym_name);
2920
2921 /* If a copy of this stub already exists re-use it. */
2922 if (stub_entry)
2923 {
2924 stub_sym = stub_entry->sym;
2925
2926 /* Change symbol associated with the original relocation to point
2927 to the stub.
2928
2929 FIXME. Is there a need to change the relocation type too? */
2930 reloc_entry->sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd,
2931 sizeof (asymbol *));
2932 reloc_entry->sym_ptr_ptr[0] = stub_sym;
2933 reloc_entry->howto = bfd_reloc_type_lookup (abfd, R_HPPA_STUB_CALL_17);
2934 }
2935 else
2936 {
2937 /* We will need to allocate a new stub. */
2938 stub_sym = bfd_make_empty_symbol (abfd);
2939 stub_sym->name = bfd_zalloc (abfd, strlen (stub_sym_name) + 1);
2940 strcpy ((char *) stub_sym->name, stub_sym_name);
2941 stub_sym->value
2942 = (int) stub_desc->stub_secp - (int) stub_desc->stub_contents;
2943 stub_sym->section = stub_sec;
2944 stub_sym->flags = BSF_LOCAL | BSF_FUNCTION;
2945 stub_entry = add_stub_by_name (abfd, stub_sec, stub_sym, link_info);
2946
2947 /* Change symbol associated with the original relocation to point
2948 to the stub.
2949
2950 FIXME. Is there a need to change the relocation type too? */
2951 reloc_entry->sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd,
2952 sizeof (asymbol *));
2953 reloc_entry->sym_ptr_ptr[0] = stub_sym;
2954 reloc_entry->howto = bfd_reloc_type_lookup (abfd, R_HPPA_STUB_CALL_17);
2955
2956 /* Build the stub. */
2957
2958 /* 1. initialization for the call. */
2959 NEW_INSTRUCTION (stub_entry, LDSID_31_1);
2960 NEW_INSTRUCTION (stub_entry, MTSP_1_SR0);
2961
2962 if (!dyncall)
2963 {
2964 if (!milli)
2965 {
2966 if (rtn_adjust)
2967 {
2968 NEW_INSTRUCTION (stub_entry, ADDI_M4_31_RP);
2969 }
2970 else
2971 {
2972 NEW_INSTRUCTION (stub_entry, COPY_31_2);
2973 }
2974 }
2975 else
2976 {
2977 if (rtn_adjust)
2978 {
2979 NEW_INSTRUCTION (stub_entry, ADDI_M4_31_1);
2980 }
2981 else
2982 {
2983 NEW_INSTRUCTION (stub_entry, COPY_31_1);
2984 }
2985 }
2986
2987 NEW_INSTRUCTION (stub_entry, LDIL_XXX_31);
2988 hppa_elf_stub_reloc (stub_desc,
2989 abfd,
2990 target_sym,
2991 CURRENT_STUB_OFFSET (stub_entry),
2992 R_HPPA_L21);
2993
2994 /* 2. Make the call. */
2995 if (!milli)
2996 {
2997 NEW_INSTRUCTION (stub_entry, BE_XXX_0_31);
2998 hppa_elf_stub_reloc (stub_desc,
2999 abfd,
3000 target_sym,
3001 CURRENT_STUB_OFFSET (stub_entry),
3002 R_HPPA_ABS_CALL_R17);
3003 NEW_INSTRUCTION (stub_entry, COPY_2_31);
3004 }
3005 else
3006 {
3007 NEW_INSTRUCTION (stub_entry, BE_XXX_0_31);
3008 hppa_elf_stub_reloc (stub_desc,
3009 abfd,
3010 target_sym,
3011 CURRENT_STUB_OFFSET (stub_entry),
3012 R_HPPA_ABS_CALL_R17);
3013 NEW_INSTRUCTION (stub_entry, COPY_1_31);
3014 }
3015 }
3016 else
3017 {
3018 /* 3. Branch back to the original location.
3019 (For non-millicode calls, this is accomplished with the
3020 COPY_31_2 instruction. For millicode calls, the return
3021 location is already in r2.) */
3022 if (rtn_adjust)
3023 {
3024 NEW_INSTRUCTION (stub_entry, ADDI_M4_31_RP);
3025 }
3026 NEW_INSTRUCTION (stub_entry, LDIL_XXX_31);
3027 hppa_elf_stub_reloc (stub_desc,
3028 abfd,
3029 target_sym,
3030 CURRENT_STUB_OFFSET (stub_entry),
3031 R_HPPA_L21);
3032
3033 NEW_INSTRUCTION (stub_entry, BE_XXX_0_31);
3034 hppa_elf_stub_reloc (stub_desc,
3035 abfd,
3036 target_sym,
3037 CURRENT_STUB_OFFSET (stub_entry),
3038 R_HPPA_ABS_CALL_R17);
3039 NEW_INSTRUCTION (stub_entry, COPY_2_31);
3040 }
3041 }
3042 return stub_sym;
3043 }
3044
3045 int
3046 hppa_elf_long_branch_needed_p (abfd, asec, reloc_entry, symbol, insn)
3047 bfd *abfd;
3048 asection *asec;
3049 arelent *reloc_entry;
3050 asymbol *symbol;
3051 unsigned insn;
3052 {
3053 long sym_value = get_symbol_value(symbol);
3054 int fmt = reloc_entry->howto->bitsize;
3055 unsigned char op = get_opcode(insn);
3056 unsigned raddr;
3057
3058 #define too_far(val,num_bits) ((int)(val) > (1<<(num_bits))-1) || ((int)(val) < (-1<<(num_bits)))
3059
3060 switch (op)
3061 {
3062 case BL:
3063 raddr =
3064 reloc_entry->address + asec->output_offset + asec->output_section->vma;
3065 if ( too_far(sym_value - raddr,fmt+1) )
3066 {
3067 #ifdef DETECT_STUBS
3068 fprintf(stderr,"long_branch needed on BL insn: abfd=%s,sym=%s,distance=0x%x\n",abfd->filename,symbol->name,sym_value - reloc_entry->address);
3069 #endif
3070 return 1;
3071 }
3072 break;
3073 }
3074 return 0;
3075 }
3076
3077 #define STUB_SYM_BUFFER_INC 5
3078
3079 asymbol *
3080 hppa_look_for_stubs_in_section (stub_bfd, abfd, output_bfd, asec,
3081 syms, new_sym_cnt, link_info)
3082 bfd *stub_bfd;
3083 bfd *abfd;
3084 bfd *output_bfd;
3085 asection *asec;
3086 asymbol **syms;
3087 int *new_sym_cnt;
3088 struct bfd_link_info *link_info;
3089 {
3090 int i;
3091 int stub_types[5];
3092 asymbol *new_syms = (asymbol *) NULL;
3093 int new_cnt = 0;
3094 int new_max = 0;
3095
3096 /* Relocations are in different places depending on whether this is
3097 an output section or an input section. Also, the relocations are
3098 in different forms. Sigh. Luckily, we have
3099 bfd_canonicalize_reloc() to straighten this out for us . */
3100
3101 if (asec->reloc_count > 0)
3102 {
3103 arelent **reloc_vector
3104 = (arelent **) alloca (asec->reloc_count * (sizeof (arelent *) + 1));
3105
3106 bfd_canonicalize_reloc (abfd, asec, reloc_vector, syms);
3107 for (i = 0; i < asec->reloc_count; i++)
3108 {
3109 arelent *rle = reloc_vector[i];
3110
3111 switch (rle->howto->type)
3112 {
3113 case R_HPPA_ABS_CALL_11:
3114 case R_HPPA_ABS_CALL_14:
3115 case R_HPPA_ABS_CALL_17:
3116 case R_HPPA_ABS_CALL_L21:
3117 case R_HPPA_ABS_CALL_R11:
3118 case R_HPPA_ABS_CALL_R14:
3119 case R_HPPA_ABS_CALL_R17:
3120 case R_HPPA_ABS_CALL_LS21:
3121 case R_HPPA_ABS_CALL_RS11:
3122 case R_HPPA_ABS_CALL_RS14:
3123 case R_HPPA_ABS_CALL_RS17:
3124 case R_HPPA_ABS_CALL_LD21:
3125 case R_HPPA_ABS_CALL_RD11:
3126 case R_HPPA_ABS_CALL_RD14:
3127 case R_HPPA_ABS_CALL_RD17:
3128 case R_HPPA_ABS_CALL_LR21:
3129 case R_HPPA_ABS_CALL_RR14:
3130 case R_HPPA_ABS_CALL_RR17:
3131 case R_HPPA_PCREL_CALL_11:
3132 case R_HPPA_PCREL_CALL_14:
3133 case R_HPPA_PCREL_CALL_17:
3134 case R_HPPA_PCREL_CALL_12:
3135 case R_HPPA_PCREL_CALL_L21:
3136 case R_HPPA_PCREL_CALL_R11:
3137 case R_HPPA_PCREL_CALL_R14:
3138 case R_HPPA_PCREL_CALL_R17:
3139 case R_HPPA_PCREL_CALL_LS21:
3140 case R_HPPA_PCREL_CALL_RS11:
3141 case R_HPPA_PCREL_CALL_RS14:
3142 case R_HPPA_PCREL_CALL_RS17:
3143 case R_HPPA_PCREL_CALL_LD21:
3144 case R_HPPA_PCREL_CALL_RD11:
3145 case R_HPPA_PCREL_CALL_RD14:
3146 case R_HPPA_PCREL_CALL_RD17:
3147 case R_HPPA_PCREL_CALL_LR21:
3148 case R_HPPA_PCREL_CALL_RR14:
3149 case R_HPPA_PCREL_CALL_RR17:
3150 {
3151 symext_entryS caller_ar
3152 = (symext_entryS) HPPA_R_ARG_RELOC (rle->addend);
3153 unsigned insn[2];
3154
3155 bfd_get_section_contents (abfd, asec, insn, rle->address,
3156 sizeof(insn));
3157 if (hppa_elf_arg_reloc_needed_p (abfd, rle, stub_types,
3158 caller_ar))
3159 {
3160 /* Generate a stub and keep track of the new symbol. */
3161 asymbol *r;
3162
3163 if (new_cnt == new_max)
3164 {
3165 new_max += STUB_SYM_BUFFER_INC;
3166 new_syms = (asymbol *)
3167 realloc (new_syms, new_max * sizeof (asymbol));
3168 }
3169
3170 /* The rtn_adjust argument is true here because we
3171 know that we have a branch and (with a few exceptions
3172 detailed under the relocation code for relocation type
3173 R_HPPA_STUB_CALL_17) it will be possible to perform
3174 the code reorientation. */
3175 r = hppa_elf_build_arg_reloc_stub (stub_bfd, output_bfd,
3176 link_info, rle,
3177 stub_types,
3178 true, insn);
3179 new_syms[new_cnt++] = *r;
3180 }
3181
3182 /* We need to retrieve the section contents to check for
3183 long branch stubs. */
3184 if (hppa_elf_long_branch_needed_p (abfd, asec, rle,
3185 rle->sym_ptr_ptr[0],
3186 insn[0]))
3187 {
3188 /* Generate a stub and keep track of the new symbol. */
3189 asymbol *r;
3190
3191 if (new_cnt == new_max)
3192 {
3193 new_max += STUB_SYM_BUFFER_INC;
3194 new_syms = (asymbol *)
3195 realloc (new_syms, (new_max * sizeof (asymbol)));
3196 }
3197 r = hppa_elf_build_long_branch_stub (stub_bfd, output_bfd,
3198 link_info, rle,
3199 rle->sym_ptr_ptr[0],
3200 insn);
3201 new_syms[new_cnt++] = *r;
3202 }
3203 }
3204 break;
3205
3206 case R_HPPA_PLABEL_32:
3207 case R_HPPA_PLABEL_11:
3208 case R_HPPA_PLABEL_14:
3209 case R_HPPA_PLABEL_L21:
3210 case R_HPPA_PLABEL_R11:
3211 case R_HPPA_PLABEL_R14:
3212 {
3213 /* On a plabel relocation, assume the arguments of the
3214 caller are set up in general registers.
3215 NOTE: 0x155 = ARGW0=CR,ARGW1=GR,ARGW2=GR,RETVAL=GR */
3216 symext_entryS caller_ar = (symext_entryS) 0x155;
3217 unsigned insn[2];
3218
3219 bfd_get_section_contents (abfd, asec, insn, rle->address,
3220 sizeof(insn));
3221
3222 if (hppa_elf_arg_reloc_needed_p (abfd, rle, stub_types,
3223 caller_ar))
3224 {
3225 /* Generate a plabel stub and keep track of the
3226 new symbol. */
3227 asymbol *r;
3228 int rtn_adjust;
3229
3230 if (new_cnt == new_max)
3231 {
3232 new_max += STUB_SYM_BUFFER_INC;
3233 new_syms = (asymbol *) realloc (new_syms, new_max
3234 * sizeof (asymbol));
3235 }
3236
3237 /* Determine whether a return adjustment
3238 (see the relocation code for relocation type
3239 R_HPPA_STUB_CALL_17) is possible. Basically,
3240 determine whether we are looking at a branch or not. */
3241
3242 if (rle->howto->type == R_HPPA_PLABEL_32)
3243 rtn_adjust = false;
3244 else
3245 {
3246 switch (get_opcode(insn[0]))
3247 {
3248 case BLE:
3249 case BE:
3250 rtn_adjust = true;
3251 break;
3252 default:
3253 rtn_adjust = false;
3254 }
3255 }
3256 r = hppa_elf_build_arg_reloc_stub (stub_bfd, output_bfd,
3257 link_info, rle,
3258 stub_types,
3259 rtn_adjust, insn);
3260 new_syms[new_cnt++] = *r;
3261 }
3262 }
3263 break;
3264
3265 default:
3266 break;
3267
3268 }
3269 }
3270 }
3271 *new_sym_cnt = new_cnt;
3272 return new_syms;
3273 }
3274
3275
3276 char *linker_stubs = NULL;
3277 int linker_stubs_size = 0;
3278 int linker_stubs_max_size = 0;
3279 #define STUB_ALLOC_INCR 100
3280
3281 boolean
3282 hppa_elf_set_section_contents (abfd, section, location, offset, count)
3283 bfd *abfd;
3284 sec_ptr section;
3285 PTR location;
3286 file_ptr offset;
3287 bfd_size_type count;
3288 {
3289 if ( strcmp(section->name, ".hppa_linker_stubs") == 0 )
3290 {
3291 if ( linker_stubs_max_size < offset + count )
3292 {
3293 linker_stubs_max_size = offset + count + STUB_ALLOC_INCR;
3294 linker_stubs = (char *)realloc(linker_stubs, linker_stubs_max_size);
3295 }
3296
3297 if ( offset + count > linker_stubs_size )
3298 linker_stubs_size = offset + count;
3299
3300 memcpy(linker_stubs + offset,location,count);
3301 return (true);
3302 }
3303 else
3304 return bfd_elf32_set_section_contents (abfd, section, location,
3305 offset, count);
3306 }
3307
3308 /* Get the contents of the given section.
3309
3310 This is special for PA ELF because some sections (such as linker stubs)
3311 may reside in memory rather than on disk, or in the case of the symbol
3312 extension section, the contents may need to be generated from other
3313 information contained in the BFD. */
3314
3315 boolean
3316 hppa_elf_get_section_contents (abfd, section, location, offset, count)
3317 bfd *abfd;
3318 sec_ptr section;
3319 PTR location;
3320 file_ptr offset;
3321 bfd_size_type count;
3322 {
3323 /* If this is the linker stub section, then its contents are contained
3324 in memory rather than on disk. FIXME. Is that always right? What
3325 about the case where a final executable is read in and a user tries
3326 to get the contents of this section? In that case the contents would
3327 be on disk like everything else. */
3328 if (strcmp (section->name, ".hppa_linker_stubs") == 0)
3329 {
3330 elf32_hppa_stub_description *stub_desc = find_stubs (abfd, section);
3331
3332 if (count == 0)
3333 return true;
3334
3335 /* Sanity check our arguments. */
3336 if ((bfd_size_type) (offset + count) > section->_raw_size
3337 || (bfd_size_type) (offset + count) > stub_desc->real_size)
3338 return (false);
3339
3340 memcpy (location, stub_desc->stub_contents + offset, count);
3341 return (true);
3342 }
3343
3344 /* The symbol extension section also needs special handling. Its
3345 contents might be on the disk, in memory, or still need to
3346 be generated. */
3347 else if (strcmp (section->name, ".hppa_symextn") == 0)
3348 {
3349 /* If there are no output sections, then read the contents of the
3350 symbol extension section from disk. */
3351 if (section->output_section == NULL
3352 && abfd->direction == read_direction)
3353 {
3354 return bfd_generic_get_section_contents (abfd, section, location,
3355 offset, count);
3356 }
3357
3358 /* If this is the first time through, and there are output sections,
3359 then build the symbol extension section based on other information
3360 contained in the BFD. */
3361 else if (! symext_chain_built)
3362 {
3363 int i;
3364 int *symtab_map =
3365 (int *) elf_sym_extra(section->output_section->owner);
3366
3367 for (i = 0; i < section->output_section->owner->symcount; i++ )
3368 {
3369 elf_hppa_tc_symbol(section->output_section->owner,
3370 ((elf_symbol_type *)
3371 section->output_section->owner->outsymbols[i]),
3372 symtab_map[i]);
3373 }
3374 symext_chain_built++;
3375 elf_hppa_tc_make_sections (section->output_section->owner, NULL);
3376 }
3377
3378 /* At this point we know that the symbol extension section has been
3379 built. We just need to copy it into the user's buffer. */
3380 if (count == 0)
3381 return true;
3382
3383 /* Sanity check our arguments. */
3384 if ((bfd_size_type) (offset + count) > section->_raw_size
3385 || (bfd_size_type) (offset + count) > symextn_contents_real_size)
3386 return (false);
3387
3388 memcpy (location,
3389 ((char *)symextn_contents + section->output_offset + offset),
3390 count);
3391 return (true);
3392 }
3393 else
3394 return bfd_generic_get_section_contents (abfd, section, location,
3395 offset, count);
3396 }
3397
3398 static void
3399 elf_info_to_howto (abfd, cache_ptr, dst)
3400 bfd *abfd;
3401 arelent *cache_ptr;
3402 Elf32_Internal_Rela *dst;
3403 {
3404 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_HPPA_UNIMPLEMENTED);
3405 cache_ptr->howto = &elf_hppa_howto_table[ELF32_R_TYPE(dst->r_info)];
3406 }
3407
3408 static void
3409 elf32_hppa_backend_symbol_processing (abfd, sym)
3410 bfd *abfd;
3411 asymbol *sym;
3412 {
3413 /* Is this a definition of $global$? If so, keep it because it will be
3414 needed if any relocations are performed. */
3415
3416 if (!strcmp (sym->name, "$global$")
3417 && sym->section != &bfd_und_section)
3418 {
3419 global_symbol = sym;
3420 }
3421 }
3422
3423 #define elf_backend_symbol_processing elf32_hppa_backend_symbol_processing
3424
3425 struct elf32_hppa_symextn_map_struct
3426 {
3427 int old_index;
3428 bfd *bfd;
3429 asymbol *sym;
3430 int new_index;
3431 };
3432
3433 static struct elf32_hppa_symextn_map_struct *elf32_hppa_symextn_map;
3434 static int elf32_hppa_symextn_map_size;
3435
3436 static boolean
3437 elf32_hppa_backend_symbol_table_processing (abfd, esyms,symcnt)
3438 bfd *abfd;
3439 elf_symbol_type *esyms;
3440 int symcnt;
3441 {
3442 Elf32_Internal_Shdr *symextn_hdr = bfd_elf_find_section (abfd, SYMEXTN_SECTION_NAME);
3443 int i;
3444 int current_sym_idx = 0;
3445
3446 /* If the symbol extension section does not exist, all the symbol */
3447 /* all the symbol extension information is assumed to be zero. */
3448
3449 if ( symextn_hdr == NULL )
3450 {
3451 for ( i = 0; i < symcnt; i++ )
3452 {
3453 esyms[i].tc_data.hppa_arg_reloc = 0;
3454 }
3455 return (true);
3456 }
3457
3458 /* allocate a buffer of the appropriate size for the symextn section */
3459
3460 symextn_hdr->contents = bfd_zalloc(abfd,symextn_hdr->sh_size);
3461 symextn_hdr->size = symextn_hdr->sh_size;
3462
3463 /* read in the symextn section */
3464
3465 if (bfd_seek (abfd, symextn_hdr->sh_offset, SEEK_SET) == -1)
3466 {
3467 bfd_error = system_call_error;
3468 return (false);
3469 }
3470 if (bfd_read ((PTR) symextn_hdr->contents, 1, symextn_hdr->size, abfd)
3471 != symextn_hdr->size)
3472 {
3473 free ((PTR)symextn_hdr->contents);
3474 bfd_error = system_call_error;
3475 return (false);
3476 }
3477
3478 /* parse the entries, updating the symtab entries as we go */
3479
3480 for ( i = 0; i < symextn_hdr->size / sizeof(symext_entryS); i++ )
3481 {
3482 symext_entryS *seP = ((symext_entryS *)symextn_hdr->contents) + i;
3483 int se_value = ELF32_HPPA_SX_VAL(*seP);
3484 int se_type = ELF32_HPPA_SX_TYPE(*seP);
3485
3486 switch ( se_type )
3487 {
3488 case HPPA_SXT_NULL:
3489 break;
3490
3491 case HPPA_SXT_SYMNDX:
3492 if ( se_value >= symcnt )
3493 {
3494 bfd_error = bad_value;
3495 bfd_perror("elf32_hppa_backend_symbol_table_processing -- symbol index");
3496 return (false);
3497 }
3498 current_sym_idx = se_value - 1;
3499 break;
3500
3501 case HPPA_SXT_ARG_RELOC:
3502 esyms[current_sym_idx].tc_data.hppa_arg_reloc = se_value;
3503 break;
3504
3505 default:
3506 bfd_error = bad_value;
3507 bfd_perror("elf32_hppa_backend_symbol_table_processing");
3508 return (false);
3509 }
3510 }
3511 return (true);
3512 }
3513
3514 #define elf_backend_symbol_table_processing elf32_hppa_backend_symbol_table_processing
3515
3516 static boolean
3517 elf32_hppa_backend_section_processing (abfd, secthdr)
3518 bfd *abfd;
3519 Elf32_Internal_Shdr *secthdr;
3520 {
3521 int i,j,k;
3522
3523 if ( secthdr->sh_type == SHT_HPPA_SYMEXTN )
3524 {
3525 for ( i = 0; i < secthdr->size / sizeof(symext_entryS); i++ )
3526 {
3527 symext_entryS *seP = ((symext_entryS *)secthdr->contents) + i;
3528 int se_value = ELF32_HPPA_SX_VAL(*seP);
3529 int se_type = ELF32_HPPA_SX_TYPE(*seP);
3530
3531 switch ( se_type )
3532 {
3533 case HPPA_SXT_NULL:
3534 break;
3535
3536 case HPPA_SXT_SYMNDX:
3537 for ( j = 0; j < abfd->symcount; j++ )
3538 {
3539 /* locate the map entry for this symbol, if there is one. */
3540 /* modify the symbol extension section symbol index entry */
3541 /* to reflect the new symbol table index */
3542
3543 for ( k = 0; k < elf32_hppa_symextn_map_size; k++ )
3544 {
3545 if ( elf32_hppa_symextn_map[k].old_index == se_value
3546 && elf32_hppa_symextn_map[k].bfd == abfd->outsymbols[j]->the_bfd
3547 && elf32_hppa_symextn_map[k].sym == abfd->outsymbols[j] )
3548 {
3549 bfd_put_32(abfd,
3550 ELF32_HPPA_SX_WORD (HPPA_SXT_SYMNDX, j),
3551 (char *)seP);
3552 }
3553 }
3554 }
3555 break;
3556
3557 case HPPA_SXT_ARG_RELOC:
3558 break;
3559
3560 default:
3561 bfd_error = bad_value;
3562 bfd_perror("elf32_hppa_backend_section_processing");
3563 return (false);
3564 }
3565 }
3566 }
3567 return true;
3568 }
3569
3570 #define elf_backend_section_processing elf32_hppa_backend_section_processing
3571
3572 static boolean
3573 elf32_hppa_backend_section_from_shdr (abfd, hdr, name)
3574 bfd *abfd;
3575 Elf32_Internal_Shdr *hdr;
3576 char *name;
3577 {
3578 asection *newsect;
3579
3580 if ( hdr->sh_type == SHT_HPPA_SYMEXTN )
3581 {
3582 BFD_ASSERT ( strcmp(name,".hppa_symextn") == 0 );
3583
3584 /* Bits that get saved. This one is real. */
3585 if (!hdr->rawdata)
3586 {
3587 newsect = bfd_make_section (abfd, name);
3588 if (newsect != NULL)
3589 {
3590 newsect->vma = hdr->sh_addr;
3591 newsect->_raw_size = hdr->sh_size;
3592 newsect->filepos = hdr->sh_offset; /* so we can read back the bits */
3593 newsect->flags |= SEC_HAS_CONTENTS;
3594 newsect->alignment_power = hdr->sh_addralign;
3595
3596 if (hdr->sh_flags & SHF_ALLOC)
3597 {
3598 newsect->flags |= SEC_ALLOC;
3599 newsect->flags |= SEC_LOAD;
3600 }
3601
3602 if (!(hdr->sh_flags & SHF_WRITE))
3603 newsect->flags |= SEC_READONLY;
3604
3605 if (hdr->sh_flags & SHF_EXECINSTR)
3606 newsect->flags |= SEC_CODE; /* FIXME: may only contain SOME code */
3607 else
3608 newsect->flags |= SEC_DATA;
3609
3610 hdr->rawdata = (void *) newsect;
3611 }
3612 }
3613 return true;
3614 }
3615 return false;
3616 }
3617
3618 #define elf_backend_section_from_shdr elf32_hppa_backend_section_from_shdr
3619
3620 static boolean
3621 elf32_hppa_backend_fake_sections (abfd, secthdr, asect)
3622 bfd *abfd;
3623 Elf_Internal_Shdr *secthdr;
3624 asection *asect;
3625 {
3626
3627 if ( strcmp(asect->name, ".hppa_symextn") == 0 )
3628 {
3629 secthdr->sh_type = SHT_HPPA_SYMEXTN;
3630 secthdr->sh_flags = 0;
3631 secthdr->sh_info = elf_section_data(asect)->rel_hdr.sh_link;
3632 secthdr->sh_link = elf_onesymtab(abfd);
3633 return true;
3634 }
3635
3636 if (!strcmp (asect->name, ".hppa_unwind"))
3637 {
3638 secthdr->sh_type = SHT_PROGBITS;
3639 /* Unwind descriptors are not part of the program memory image. */
3640 secthdr->sh_flags = 0;
3641 secthdr->sh_info = 0;
3642 secthdr->sh_link = 0;
3643 secthdr->sh_entsize = 16;
3644 return true;
3645 }
3646
3647 /* @@ Should this be CPU specific?? KR */
3648 if (!strcmp (asect->name, ".stabstr"))
3649 {
3650 secthdr->sh_type = SHT_STRTAB;
3651 secthdr->sh_flags = 0;
3652 secthdr->sh_info = 0;
3653 secthdr->sh_link = 0;
3654 secthdr->sh_entsize = 0;
3655 return true;
3656 }
3657
3658 return false;
3659 }
3660
3661 #define elf_backend_fake_sections elf32_hppa_backend_fake_sections
3662
3663 static boolean
3664 elf32_hppa_backend_section_from_bfd_section (abfd, hdr, asect, retval)
3665 bfd *abfd;
3666 Elf32_Internal_Shdr *hdr;
3667 asection *asect;
3668 int *retval;
3669 {
3670 if ( hdr->sh_type == SHT_HPPA_SYMEXTN )
3671 {
3672 if (hdr->rawdata)
3673 {
3674 if (((struct sec *) (hdr->rawdata)) == asect)
3675 {
3676 BFD_ASSERT( strcmp(asect->name, ".hppa_symextn") == 0 );
3677 return true;
3678 }
3679 }
3680 }
3681 else if ( hdr->sh_type == SHT_STRTAB )
3682 {
3683 if (hdr->rawdata)
3684 {
3685 if (((struct sec *) (hdr->rawdata)) == asect)
3686 {
3687 BFD_ASSERT ( strcmp (asect->name, ".stabstr") == 0);
3688 return true;
3689 }
3690 }
3691 }
3692
3693 return false;
3694 }
3695
3696 #define elf_backend_section_from_bfd_section elf32_hppa_backend_section_from_bfd_section
3697
3698 #define bfd_generic_get_section_contents hppa_elf_get_section_contents
3699 #define bfd_elf32_set_section_contents hppa_elf_set_section_contents
3700
3701 #define TARGET_BIG_SYM bfd_elf32_hppa_vec
3702 #define TARGET_BIG_NAME "elf32-hppa"
3703 #define ELF_ARCH bfd_arch_hppa
3704 #define ELF_MACHINE_CODE EM_HPPA
3705 #define ELF_MAXPAGESIZE 0x1000
3706
3707 #include "elf32-target.h"