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


299c39546bc2329f857fac39dcb12873248cf1ba
[deliverable/binutils-gdb.git] / bfd / elf32-mips.c
1 /* MIPS-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003 Free Software Foundation, Inc.
4
5 Most of the information added by Ian Lance Taylor, Cygnus Support,
6 <ian@cygnus.com>.
7 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
8 <mark@codesourcery.com>
9 Traditional MIPS targets support added by Koundinya.K, Dansk Data
10 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
11
12 This file is part of BFD, the Binary File Descriptor library.
13
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
18
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27
28 /* This file handles MIPS ELF targets. SGI Irix 5 uses a slightly
29 different MIPS ELF from other targets. This matters when linking.
30 This file supports both, switching at runtime. */
31
32 #include "bfd.h"
33 #include "sysdep.h"
34 #include "libbfd.h"
35 #include "bfdlink.h"
36 #include "genlink.h"
37 #include "elf-bfd.h"
38 #include "elfxx-mips.h"
39 #include "elf/mips.h"
40
41 /* Get the ECOFF swapping routines. */
42 #include "coff/sym.h"
43 #include "coff/symconst.h"
44 #include "coff/internal.h"
45 #include "coff/ecoff.h"
46 #include "coff/mips.h"
47 #define ECOFF_SIGNED_32
48 #include "ecoffswap.h"
49
50 static bfd_reloc_status_type mips_elf_generic_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type mips_elf_hi16_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type mips_elf_lo16_reloc
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_reloc_status_type mips_elf_got16_reloc
57 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
58 static bfd_reloc_status_type gprel32_with_gp
59 (bfd *, asymbol *, arelent *, asection *, bfd_boolean, void *, bfd_vma);
60 static bfd_reloc_status_type mips_elf_gprel32_reloc
61 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
62 static bfd_reloc_status_type mips32_64bit_reloc
63 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
64 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
65 (bfd *, bfd_reloc_code_real_type);
66 static reloc_howto_type *mips_elf32_rtype_to_howto
67 (unsigned int, bfd_boolean);
68 static void mips_info_to_howto_rel
69 (bfd *, arelent *, Elf_Internal_Rela *);
70 static void mips_info_to_howto_rela
71 (bfd *, arelent *, Elf_Internal_Rela *);
72 static bfd_boolean mips_elf_sym_is_global
73 (bfd *, asymbol *);
74 static bfd_boolean mips_elf32_object_p
75 (bfd *);
76 static bfd_boolean mips_elf_is_local_label_name
77 (bfd *, const char *);
78 static bfd_reloc_status_type mips16_jump_reloc
79 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
80 static bfd_reloc_status_type mips16_gprel_reloc
81 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
82 static bfd_reloc_status_type mips_elf_final_gp
83 (bfd *, asymbol *, bfd_boolean, char **, bfd_vma *);
84 static bfd_boolean mips_elf_assign_gp
85 (bfd *, bfd_vma *);
86 static bfd_boolean elf32_mips_grok_prstatus
87 (bfd *, Elf_Internal_Note *);
88 static bfd_boolean elf32_mips_grok_psinfo
89 (bfd *, Elf_Internal_Note *);
90 static irix_compat_t elf32_mips_irix_compat
91 (bfd *);
92
93 extern const bfd_target bfd_elf32_bigmips_vec;
94 extern const bfd_target bfd_elf32_littlemips_vec;
95
96 /* Nonzero if ABFD is using the N32 ABI. */
97 #define ABI_N32_P(abfd) \
98 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
99
100 /* Whether we are trying to be compatible with IRIX at all. */
101 #define SGI_COMPAT(abfd) \
102 (elf32_mips_irix_compat (abfd) != ict_none)
103
104 /* The number of local .got entries we reserve. */
105 #define MIPS_RESERVED_GOTNO (2)
106
107 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
108 from smaller values. Start with zero, widen, *then* decrement. */
109 #define MINUS_ONE (((bfd_vma)0) - 1)
110
111 /* The relocation table used for SHT_REL sections. */
112
113 static reloc_howto_type elf_mips_howto_table_rel[] =
114 {
115 /* No relocation. */
116 HOWTO (R_MIPS_NONE, /* type */
117 0, /* rightshift */
118 0, /* size (0 = byte, 1 = short, 2 = long) */
119 0, /* bitsize */
120 FALSE, /* pc_relative */
121 0, /* bitpos */
122 complain_overflow_dont, /* complain_on_overflow */
123 mips_elf_generic_reloc, /* special_function */
124 "R_MIPS_NONE", /* name */
125 FALSE, /* partial_inplace */
126 0, /* src_mask */
127 0, /* dst_mask */
128 FALSE), /* pcrel_offset */
129
130 /* 16 bit relocation. */
131 HOWTO (R_MIPS_16, /* type */
132 0, /* rightshift */
133 2, /* size (0 = byte, 1 = short, 2 = long) */
134 16, /* bitsize */
135 FALSE, /* pc_relative */
136 0, /* bitpos */
137 complain_overflow_signed, /* complain_on_overflow */
138 mips_elf_generic_reloc, /* special_function */
139 "R_MIPS_16", /* name */
140 TRUE, /* partial_inplace */
141 0x0000ffff, /* src_mask */
142 0x0000ffff, /* dst_mask */
143 FALSE), /* pcrel_offset */
144
145 /* 32 bit relocation. */
146 HOWTO (R_MIPS_32, /* type */
147 0, /* rightshift */
148 2, /* size (0 = byte, 1 = short, 2 = long) */
149 32, /* bitsize */
150 FALSE, /* pc_relative */
151 0, /* bitpos */
152 complain_overflow_dont, /* complain_on_overflow */
153 mips_elf_generic_reloc, /* special_function */
154 "R_MIPS_32", /* name */
155 TRUE, /* partial_inplace */
156 0xffffffff, /* src_mask */
157 0xffffffff, /* dst_mask */
158 FALSE), /* pcrel_offset */
159
160 /* 32 bit symbol relative relocation. */
161 HOWTO (R_MIPS_REL32, /* type */
162 0, /* rightshift */
163 2, /* size (0 = byte, 1 = short, 2 = long) */
164 32, /* bitsize */
165 FALSE, /* pc_relative */
166 0, /* bitpos */
167 complain_overflow_dont, /* complain_on_overflow */
168 mips_elf_generic_reloc, /* special_function */
169 "R_MIPS_REL32", /* name */
170 TRUE, /* partial_inplace */
171 0xffffffff, /* src_mask */
172 0xffffffff, /* dst_mask */
173 FALSE), /* pcrel_offset */
174
175 /* 26 bit jump address. */
176 HOWTO (R_MIPS_26, /* type */
177 2, /* rightshift */
178 2, /* size (0 = byte, 1 = short, 2 = long) */
179 26, /* bitsize */
180 FALSE, /* pc_relative */
181 0, /* bitpos */
182 complain_overflow_dont, /* complain_on_overflow */
183 /* This needs complex overflow
184 detection, because the upper four
185 bits must match the PC + 4. */
186 mips_elf_generic_reloc, /* special_function */
187 "R_MIPS_26", /* name */
188 TRUE, /* partial_inplace */
189 0x03ffffff, /* src_mask */
190 0x03ffffff, /* dst_mask */
191 FALSE), /* pcrel_offset */
192
193 /* High 16 bits of symbol value. */
194 HOWTO (R_MIPS_HI16, /* type */
195 0, /* rightshift */
196 2, /* size (0 = byte, 1 = short, 2 = long) */
197 16, /* bitsize */
198 FALSE, /* pc_relative */
199 0, /* bitpos */
200 complain_overflow_dont, /* complain_on_overflow */
201 mips_elf_hi16_reloc, /* special_function */
202 "R_MIPS_HI16", /* name */
203 TRUE, /* partial_inplace */
204 0x0000ffff, /* src_mask */
205 0x0000ffff, /* dst_mask */
206 FALSE), /* pcrel_offset */
207
208 /* Low 16 bits of symbol value. */
209 HOWTO (R_MIPS_LO16, /* type */
210 0, /* rightshift */
211 2, /* size (0 = byte, 1 = short, 2 = long) */
212 16, /* bitsize */
213 FALSE, /* pc_relative */
214 0, /* bitpos */
215 complain_overflow_dont, /* complain_on_overflow */
216 mips_elf_lo16_reloc, /* special_function */
217 "R_MIPS_LO16", /* name */
218 TRUE, /* partial_inplace */
219 0x0000ffff, /* src_mask */
220 0x0000ffff, /* dst_mask */
221 FALSE), /* pcrel_offset */
222
223 /* GP relative reference. */
224 HOWTO (R_MIPS_GPREL16, /* type */
225 0, /* rightshift */
226 2, /* size (0 = byte, 1 = short, 2 = long) */
227 16, /* bitsize */
228 FALSE, /* pc_relative */
229 0, /* bitpos */
230 complain_overflow_signed, /* complain_on_overflow */
231 _bfd_mips_elf32_gprel16_reloc, /* special_function */
232 "R_MIPS_GPREL16", /* name */
233 TRUE, /* partial_inplace */
234 0x0000ffff, /* src_mask */
235 0x0000ffff, /* dst_mask */
236 FALSE), /* pcrel_offset */
237
238 /* Reference to literal section. */
239 HOWTO (R_MIPS_LITERAL, /* type */
240 0, /* rightshift */
241 2, /* size (0 = byte, 1 = short, 2 = long) */
242 16, /* bitsize */
243 FALSE, /* pc_relative */
244 0, /* bitpos */
245 complain_overflow_signed, /* complain_on_overflow */
246 _bfd_mips_elf32_gprel16_reloc, /* special_function */
247 "R_MIPS_LITERAL", /* name */
248 TRUE, /* partial_inplace */
249 0x0000ffff, /* src_mask */
250 0x0000ffff, /* dst_mask */
251 FALSE), /* pcrel_offset */
252
253 /* Reference to global offset table. */
254 HOWTO (R_MIPS_GOT16, /* type */
255 0, /* rightshift */
256 2, /* size (0 = byte, 1 = short, 2 = long) */
257 16, /* bitsize */
258 FALSE, /* pc_relative */
259 0, /* bitpos */
260 complain_overflow_signed, /* complain_on_overflow */
261 mips_elf_got16_reloc, /* special_function */
262 "R_MIPS_GOT16", /* name */
263 TRUE, /* partial_inplace */
264 0x0000ffff, /* src_mask */
265 0x0000ffff, /* dst_mask */
266 FALSE), /* pcrel_offset */
267
268 /* 16 bit PC relative reference. */
269 HOWTO (R_MIPS_PC16, /* type */
270 0, /* rightshift */
271 2, /* size (0 = byte, 1 = short, 2 = long) */
272 16, /* bitsize */
273 TRUE, /* pc_relative */
274 0, /* bitpos */
275 complain_overflow_signed, /* complain_on_overflow */
276 mips_elf_generic_reloc, /* special_function */
277 "R_MIPS_PC16", /* name */
278 TRUE, /* partial_inplace */
279 0x0000ffff, /* src_mask */
280 0x0000ffff, /* dst_mask */
281 TRUE), /* pcrel_offset */
282
283 /* 16 bit call through global offset table. */
284 HOWTO (R_MIPS_CALL16, /* type */
285 0, /* rightshift */
286 2, /* size (0 = byte, 1 = short, 2 = long) */
287 16, /* bitsize */
288 FALSE, /* pc_relative */
289 0, /* bitpos */
290 complain_overflow_signed, /* complain_on_overflow */
291 mips_elf_generic_reloc, /* special_function */
292 "R_MIPS_CALL16", /* name */
293 TRUE, /* partial_inplace */
294 0x0000ffff, /* src_mask */
295 0x0000ffff, /* dst_mask */
296 FALSE), /* pcrel_offset */
297
298 /* 32 bit GP relative reference. */
299 HOWTO (R_MIPS_GPREL32, /* type */
300 0, /* rightshift */
301 2, /* size (0 = byte, 1 = short, 2 = long) */
302 32, /* bitsize */
303 FALSE, /* pc_relative */
304 0, /* bitpos */
305 complain_overflow_dont, /* complain_on_overflow */
306 mips_elf_gprel32_reloc, /* special_function */
307 "R_MIPS_GPREL32", /* name */
308 TRUE, /* partial_inplace */
309 0xffffffff, /* src_mask */
310 0xffffffff, /* dst_mask */
311 FALSE), /* pcrel_offset */
312
313 /* The remaining relocs are defined on Irix 5, although they are
314 not defined by the ABI. */
315 EMPTY_HOWTO (13),
316 EMPTY_HOWTO (14),
317 EMPTY_HOWTO (15),
318
319 /* A 5 bit shift field. */
320 HOWTO (R_MIPS_SHIFT5, /* type */
321 0, /* rightshift */
322 2, /* size (0 = byte, 1 = short, 2 = long) */
323 5, /* bitsize */
324 FALSE, /* pc_relative */
325 6, /* bitpos */
326 complain_overflow_bitfield, /* complain_on_overflow */
327 mips_elf_generic_reloc, /* special_function */
328 "R_MIPS_SHIFT5", /* name */
329 TRUE, /* partial_inplace */
330 0x000007c0, /* src_mask */
331 0x000007c0, /* dst_mask */
332 FALSE), /* pcrel_offset */
333
334 /* A 6 bit shift field. */
335 /* FIXME: This is not handled correctly; a special function is
336 needed to put the most significant bit in the right place. */
337 HOWTO (R_MIPS_SHIFT6, /* type */
338 0, /* rightshift */
339 2, /* size (0 = byte, 1 = short, 2 = long) */
340 6, /* bitsize */
341 FALSE, /* pc_relative */
342 6, /* bitpos */
343 complain_overflow_bitfield, /* complain_on_overflow */
344 mips_elf_generic_reloc, /* special_function */
345 "R_MIPS_SHIFT6", /* name */
346 TRUE, /* partial_inplace */
347 0x000007c4, /* src_mask */
348 0x000007c4, /* dst_mask */
349 FALSE), /* pcrel_offset */
350
351 /* A 64 bit relocation. */
352 HOWTO (R_MIPS_64, /* type */
353 0, /* rightshift */
354 4, /* size (0 = byte, 1 = short, 2 = long) */
355 64, /* bitsize */
356 FALSE, /* pc_relative */
357 0, /* bitpos */
358 complain_overflow_dont, /* complain_on_overflow */
359 mips32_64bit_reloc, /* special_function */
360 "R_MIPS_64", /* name */
361 TRUE, /* partial_inplace */
362 MINUS_ONE, /* src_mask */
363 MINUS_ONE, /* dst_mask */
364 FALSE), /* pcrel_offset */
365
366 /* Displacement in the global offset table. */
367 HOWTO (R_MIPS_GOT_DISP, /* type */
368 0, /* rightshift */
369 2, /* size (0 = byte, 1 = short, 2 = long) */
370 16, /* bitsize */
371 FALSE, /* pc_relative */
372 0, /* bitpos */
373 complain_overflow_signed, /* complain_on_overflow */
374 mips_elf_generic_reloc, /* special_function */
375 "R_MIPS_GOT_DISP", /* name */
376 TRUE, /* partial_inplace */
377 0x0000ffff, /* src_mask */
378 0x0000ffff, /* dst_mask */
379 FALSE), /* pcrel_offset */
380
381 /* Displacement to page pointer in the global offset table. */
382 HOWTO (R_MIPS_GOT_PAGE, /* type */
383 0, /* rightshift */
384 2, /* size (0 = byte, 1 = short, 2 = long) */
385 16, /* bitsize */
386 FALSE, /* pc_relative */
387 0, /* bitpos */
388 complain_overflow_signed, /* complain_on_overflow */
389 mips_elf_generic_reloc, /* special_function */
390 "R_MIPS_GOT_PAGE", /* name */
391 TRUE, /* partial_inplace */
392 0x0000ffff, /* src_mask */
393 0x0000ffff, /* dst_mask */
394 FALSE), /* pcrel_offset */
395
396 /* Offset from page pointer in the global offset table. */
397 HOWTO (R_MIPS_GOT_OFST, /* type */
398 0, /* rightshift */
399 2, /* size (0 = byte, 1 = short, 2 = long) */
400 16, /* bitsize */
401 FALSE, /* pc_relative */
402 0, /* bitpos */
403 complain_overflow_signed, /* complain_on_overflow */
404 mips_elf_generic_reloc, /* special_function */
405 "R_MIPS_GOT_OFST", /* name */
406 TRUE, /* partial_inplace */
407 0x0000ffff, /* src_mask */
408 0x0000ffff, /* dst_mask */
409 FALSE), /* pcrel_offset */
410
411 /* High 16 bits of displacement in global offset table. */
412 HOWTO (R_MIPS_GOT_HI16, /* type */
413 0, /* rightshift */
414 2, /* size (0 = byte, 1 = short, 2 = long) */
415 16, /* bitsize */
416 FALSE, /* pc_relative */
417 0, /* bitpos */
418 complain_overflow_dont, /* complain_on_overflow */
419 mips_elf_generic_reloc, /* special_function */
420 "R_MIPS_GOT_HI16", /* name */
421 TRUE, /* partial_inplace */
422 0x0000ffff, /* src_mask */
423 0x0000ffff, /* dst_mask */
424 FALSE), /* pcrel_offset */
425
426 /* Low 16 bits of displacement in global offset table. */
427 HOWTO (R_MIPS_GOT_LO16, /* type */
428 0, /* rightshift */
429 2, /* size (0 = byte, 1 = short, 2 = long) */
430 16, /* bitsize */
431 FALSE, /* pc_relative */
432 0, /* bitpos */
433 complain_overflow_dont, /* complain_on_overflow */
434 mips_elf_generic_reloc, /* special_function */
435 "R_MIPS_GOT_LO16", /* name */
436 TRUE, /* partial_inplace */
437 0x0000ffff, /* src_mask */
438 0x0000ffff, /* dst_mask */
439 FALSE), /* pcrel_offset */
440
441 /* 64 bit subtraction. Used in the N32 ABI. */
442 HOWTO (R_MIPS_SUB, /* type */
443 0, /* rightshift */
444 4, /* size (0 = byte, 1 = short, 2 = long) */
445 64, /* bitsize */
446 FALSE, /* pc_relative */
447 0, /* bitpos */
448 complain_overflow_dont, /* complain_on_overflow */
449 mips_elf_generic_reloc, /* special_function */
450 "R_MIPS_SUB", /* name */
451 TRUE, /* partial_inplace */
452 MINUS_ONE, /* src_mask */
453 MINUS_ONE, /* dst_mask */
454 FALSE), /* pcrel_offset */
455
456 /* Used to cause the linker to insert and delete instructions? */
457 EMPTY_HOWTO (R_MIPS_INSERT_A),
458 EMPTY_HOWTO (R_MIPS_INSERT_B),
459 EMPTY_HOWTO (R_MIPS_DELETE),
460
461 /* Get the higher value of a 64 bit addend. */
462 HOWTO (R_MIPS_HIGHER, /* type */
463 0, /* rightshift */
464 2, /* size (0 = byte, 1 = short, 2 = long) */
465 16, /* bitsize */
466 FALSE, /* pc_relative */
467 0, /* bitpos */
468 complain_overflow_dont, /* complain_on_overflow */
469 mips_elf_generic_reloc, /* special_function */
470 "R_MIPS_HIGHER", /* name */
471 TRUE, /* partial_inplace */
472 0x0000ffff, /* src_mask */
473 0x0000ffff, /* dst_mask */
474 FALSE), /* pcrel_offset */
475
476 /* Get the highest value of a 64 bit addend. */
477 HOWTO (R_MIPS_HIGHEST, /* type */
478 0, /* rightshift */
479 2, /* size (0 = byte, 1 = short, 2 = long) */
480 16, /* bitsize */
481 FALSE, /* pc_relative */
482 0, /* bitpos */
483 complain_overflow_dont, /* complain_on_overflow */
484 mips_elf_generic_reloc, /* special_function */
485 "R_MIPS_HIGHEST", /* name */
486 TRUE, /* partial_inplace */
487 0x0000ffff, /* src_mask */
488 0x0000ffff, /* dst_mask */
489 FALSE), /* pcrel_offset */
490
491 /* High 16 bits of displacement in global offset table. */
492 HOWTO (R_MIPS_CALL_HI16, /* type */
493 0, /* rightshift */
494 2, /* size (0 = byte, 1 = short, 2 = long) */
495 16, /* bitsize */
496 FALSE, /* pc_relative */
497 0, /* bitpos */
498 complain_overflow_dont, /* complain_on_overflow */
499 mips_elf_generic_reloc, /* special_function */
500 "R_MIPS_CALL_HI16", /* name */
501 TRUE, /* partial_inplace */
502 0x0000ffff, /* src_mask */
503 0x0000ffff, /* dst_mask */
504 FALSE), /* pcrel_offset */
505
506 /* Low 16 bits of displacement in global offset table. */
507 HOWTO (R_MIPS_CALL_LO16, /* type */
508 0, /* rightshift */
509 2, /* size (0 = byte, 1 = short, 2 = long) */
510 16, /* bitsize */
511 FALSE, /* pc_relative */
512 0, /* bitpos */
513 complain_overflow_dont, /* complain_on_overflow */
514 mips_elf_generic_reloc, /* special_function */
515 "R_MIPS_CALL_LO16", /* name */
516 TRUE, /* partial_inplace */
517 0x0000ffff, /* src_mask */
518 0x0000ffff, /* dst_mask */
519 FALSE), /* pcrel_offset */
520
521 /* Section displacement. */
522 HOWTO (R_MIPS_SCN_DISP, /* type */
523 0, /* rightshift */
524 2, /* size (0 = byte, 1 = short, 2 = long) */
525 32, /* bitsize */
526 FALSE, /* pc_relative */
527 0, /* bitpos */
528 complain_overflow_dont, /* complain_on_overflow */
529 mips_elf_generic_reloc, /* special_function */
530 "R_MIPS_SCN_DISP", /* name */
531 TRUE, /* partial_inplace */
532 0xffffffff, /* src_mask */
533 0xffffffff, /* dst_mask */
534 FALSE), /* pcrel_offset */
535
536 EMPTY_HOWTO (R_MIPS_REL16),
537 EMPTY_HOWTO (R_MIPS_ADD_IMMEDIATE),
538 EMPTY_HOWTO (R_MIPS_PJUMP),
539 EMPTY_HOWTO (R_MIPS_RELGOT),
540
541 /* Protected jump conversion. This is an optimization hint. No
542 relocation is required for correctness. */
543 HOWTO (R_MIPS_JALR, /* type */
544 0, /* rightshift */
545 2, /* size (0 = byte, 1 = short, 2 = long) */
546 32, /* bitsize */
547 FALSE, /* pc_relative */
548 0, /* bitpos */
549 complain_overflow_dont, /* complain_on_overflow */
550 mips_elf_generic_reloc, /* special_function */
551 "R_MIPS_JALR", /* name */
552 FALSE, /* partial_inplace */
553 0x00000000, /* src_mask */
554 0x00000000, /* dst_mask */
555 FALSE), /* pcrel_offset */
556 };
557
558 /* The reloc used for BFD_RELOC_CTOR when doing a 64 bit link. This
559 is a hack to make the linker think that we need 64 bit values. */
560 static reloc_howto_type elf_mips_ctor64_howto =
561 HOWTO (R_MIPS_64, /* type */
562 0, /* rightshift */
563 4, /* size (0 = byte, 1 = short, 2 = long) */
564 32, /* bitsize */
565 FALSE, /* pc_relative */
566 0, /* bitpos */
567 complain_overflow_signed, /* complain_on_overflow */
568 mips32_64bit_reloc, /* special_function */
569 "R_MIPS_64", /* name */
570 TRUE, /* partial_inplace */
571 0xffffffff, /* src_mask */
572 0xffffffff, /* dst_mask */
573 FALSE); /* pcrel_offset */
574
575 /* The reloc used for the mips16 jump instruction. */
576 static reloc_howto_type elf_mips16_jump_howto =
577 HOWTO (R_MIPS16_26, /* type */
578 2, /* rightshift */
579 2, /* size (0 = byte, 1 = short, 2 = long) */
580 26, /* bitsize */
581 FALSE, /* pc_relative */
582 0, /* bitpos */
583 complain_overflow_dont, /* complain_on_overflow */
584 /* This needs complex overflow
585 detection, because the upper four
586 bits must match the PC. */
587 mips16_jump_reloc, /* special_function */
588 "R_MIPS16_26", /* name */
589 TRUE, /* partial_inplace */
590 0x3ffffff, /* src_mask */
591 0x3ffffff, /* dst_mask */
592 FALSE); /* pcrel_offset */
593
594 /* The reloc used for the mips16 gprel instruction. */
595 static reloc_howto_type elf_mips16_gprel_howto =
596 HOWTO (R_MIPS16_GPREL, /* type */
597 0, /* rightshift */
598 2, /* size (0 = byte, 1 = short, 2 = long) */
599 16, /* bitsize */
600 FALSE, /* pc_relative */
601 0, /* bitpos */
602 complain_overflow_signed, /* complain_on_overflow */
603 mips16_gprel_reloc, /* special_function */
604 "R_MIPS16_GPREL", /* name */
605 TRUE, /* partial_inplace */
606 0x07ff001f, /* src_mask */
607 0x07ff001f, /* dst_mask */
608 FALSE); /* pcrel_offset */
609
610 /* GNU extensions for embedded-pic. */
611 /* High 16 bits of symbol value, pc-relative. */
612 static reloc_howto_type elf_mips_gnu_rel_hi16 =
613 HOWTO (R_MIPS_GNU_REL_HI16, /* type */
614 0, /* rightshift */
615 2, /* size (0 = byte, 1 = short, 2 = long) */
616 16, /* bitsize */
617 TRUE, /* pc_relative */
618 0, /* bitpos */
619 complain_overflow_dont, /* complain_on_overflow */
620 mips_elf_hi16_reloc, /* special_function */
621 "R_MIPS_GNU_REL_HI16", /* name */
622 TRUE, /* partial_inplace */
623 0xffff, /* src_mask */
624 0xffff, /* dst_mask */
625 TRUE); /* pcrel_offset */
626
627 /* Low 16 bits of symbol value, pc-relative. */
628 static reloc_howto_type elf_mips_gnu_rel_lo16 =
629 HOWTO (R_MIPS_GNU_REL_LO16, /* type */
630 0, /* rightshift */
631 2, /* size (0 = byte, 1 = short, 2 = long) */
632 16, /* bitsize */
633 TRUE, /* pc_relative */
634 0, /* bitpos */
635 complain_overflow_dont, /* complain_on_overflow */
636 mips_elf_lo16_reloc, /* special_function */
637 "R_MIPS_GNU_REL_LO16", /* name */
638 TRUE, /* partial_inplace */
639 0xffff, /* src_mask */
640 0xffff, /* dst_mask */
641 TRUE); /* pcrel_offset */
642
643 /* 16 bit offset for pc-relative branches. */
644 static reloc_howto_type elf_mips_gnu_rel16_s2 =
645 HOWTO (R_MIPS_GNU_REL16_S2, /* type */
646 2, /* rightshift */
647 2, /* size (0 = byte, 1 = short, 2 = long) */
648 16, /* bitsize */
649 TRUE, /* pc_relative */
650 0, /* bitpos */
651 complain_overflow_signed, /* complain_on_overflow */
652 mips_elf_generic_reloc, /* special_function */
653 "R_MIPS_GNU_REL16_S2", /* name */
654 TRUE, /* partial_inplace */
655 0xffff, /* src_mask */
656 0xffff, /* dst_mask */
657 TRUE); /* pcrel_offset */
658
659 /* 64 bit pc-relative. */
660 static reloc_howto_type elf_mips_gnu_pcrel64 =
661 HOWTO (R_MIPS_PC64, /* type */
662 0, /* rightshift */
663 4, /* size (0 = byte, 1 = short, 2 = long) */
664 64, /* bitsize */
665 TRUE, /* pc_relative */
666 0, /* bitpos */
667 complain_overflow_signed, /* complain_on_overflow */
668 mips_elf_generic_reloc, /* special_function */
669 "R_MIPS_PC64", /* name */
670 TRUE, /* partial_inplace */
671 MINUS_ONE, /* src_mask */
672 MINUS_ONE, /* dst_mask */
673 TRUE); /* pcrel_offset */
674
675 /* 32 bit pc-relative. */
676 static reloc_howto_type elf_mips_gnu_pcrel32 =
677 HOWTO (R_MIPS_PC32, /* type */
678 0, /* rightshift */
679 2, /* size (0 = byte, 1 = short, 2 = long) */
680 32, /* bitsize */
681 TRUE, /* pc_relative */
682 0, /* bitpos */
683 complain_overflow_signed, /* complain_on_overflow */
684 mips_elf_generic_reloc, /* special_function */
685 "R_MIPS_PC32", /* name */
686 TRUE, /* partial_inplace */
687 0xffffffff, /* src_mask */
688 0xffffffff, /* dst_mask */
689 TRUE); /* pcrel_offset */
690
691 /* GNU extension to record C++ vtable hierarchy */
692 static reloc_howto_type elf_mips_gnu_vtinherit_howto =
693 HOWTO (R_MIPS_GNU_VTINHERIT, /* type */
694 0, /* rightshift */
695 2, /* size (0 = byte, 1 = short, 2 = long) */
696 0, /* bitsize */
697 FALSE, /* pc_relative */
698 0, /* bitpos */
699 complain_overflow_dont, /* complain_on_overflow */
700 NULL, /* special_function */
701 "R_MIPS_GNU_VTINHERIT", /* name */
702 FALSE, /* partial_inplace */
703 0, /* src_mask */
704 0, /* dst_mask */
705 FALSE); /* pcrel_offset */
706
707 /* GNU extension to record C++ vtable member usage */
708 static reloc_howto_type elf_mips_gnu_vtentry_howto =
709 HOWTO (R_MIPS_GNU_VTENTRY, /* type */
710 0, /* rightshift */
711 2, /* size (0 = byte, 1 = short, 2 = long) */
712 0, /* bitsize */
713 FALSE, /* pc_relative */
714 0, /* bitpos */
715 complain_overflow_dont, /* complain_on_overflow */
716 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
717 "R_MIPS_GNU_VTENTRY", /* name */
718 FALSE, /* partial_inplace */
719 0, /* src_mask */
720 0, /* dst_mask */
721 FALSE); /* pcrel_offset */
722
723 /* We use this instead of bfd_elf_generic_reloc because the latter
724 gets the handling of zero addends wrong. */
725 static bfd_reloc_status_type
726 mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
727 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
728 asection *input_section, bfd *output_bfd,
729 char **error_message ATTRIBUTE_UNUSED)
730 {
731 /* If we're relocating, and this is an external symbol, we don't want
732 to change anything. */
733 if (output_bfd != NULL
734 && (symbol->flags & BSF_SECTION_SYM) == 0
735 && (symbol->flags & BSF_LOCAL) != 0)
736 {
737 reloc_entry->address += input_section->output_offset;
738 return bfd_reloc_ok;
739 }
740
741 /* Just go on, nothing to see here. */
742 return bfd_reloc_continue;
743 }
744
745 /* Do a R_MIPS_HI16 relocation. This has to be done in combination
746 with a R_MIPS_LO16 reloc, because there is a carry from the LO16 to
747 the HI16. Here we just save the information we need; we do the
748 actual relocation when we see the LO16.
749
750 MIPS ELF requires that the LO16 immediately follow the HI16. As a
751 GNU extension, for non-pc-relative relocations, we permit an
752 arbitrary number of HI16 relocs to be associated with a single LO16
753 reloc. This extension permits gcc to output the HI and LO relocs
754 itself.
755
756 This cannot be done for PC-relative relocations because both the HI16
757 and LO16 parts of the relocations must be done relative to the LO16
758 part, and there can be carry to or borrow from the HI16 part. */
759
760 struct mips_hi16
761 {
762 struct mips_hi16 *next;
763 bfd_byte *addr;
764 bfd_vma addend;
765 };
766
767 /* FIXME: This should not be a static variable. */
768
769 static struct mips_hi16 *mips_hi16_list;
770
771 static bfd_reloc_status_type
772 mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
773 asymbol *symbol, void *data, asection *input_section,
774 bfd *output_bfd, char **error_message)
775 {
776 bfd_reloc_status_type ret;
777 bfd_vma relocation;
778 struct mips_hi16 *n;
779
780 /* If we're relocating, and this is an external symbol, we don't want
781 to change anything. */
782 if (output_bfd != NULL
783 && (symbol->flags & BSF_SECTION_SYM) == 0
784 && (symbol->flags & BSF_LOCAL) != 0)
785 {
786 reloc_entry->address += input_section->output_offset;
787 return bfd_reloc_ok;
788 }
789
790 ret = bfd_reloc_ok;
791
792 if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
793 {
794 bfd_boolean relocatable;
795 bfd_vma gp;
796
797 if (ret == bfd_reloc_undefined)
798 abort ();
799
800 if (output_bfd != NULL)
801 relocatable = TRUE;
802 else
803 {
804 relocatable = FALSE;
805 output_bfd = symbol->section->output_section->owner;
806 }
807
808 ret = mips_elf_final_gp (output_bfd, symbol, relocatable,
809 error_message, &gp);
810 if (ret != bfd_reloc_ok)
811 return ret;
812
813 relocation = gp - reloc_entry->address;
814 }
815 else
816 {
817 if (bfd_is_und_section (symbol->section) && output_bfd == NULL)
818 ret = bfd_reloc_undefined;
819
820 if (bfd_is_com_section (symbol->section))
821 relocation = 0;
822 else
823 relocation = symbol->value;
824 }
825
826 relocation += symbol->section->output_section->vma;
827 relocation += symbol->section->output_offset;
828 relocation += reloc_entry->addend;
829
830 if (reloc_entry->address > input_section->_cooked_size)
831 return bfd_reloc_outofrange;
832
833 /* Save the information, and let LO16 do the actual relocation. */
834 n = bfd_malloc (sizeof *n);
835 if (n == NULL)
836 return bfd_reloc_outofrange;
837 n->addr = (bfd_byte *) data + reloc_entry->address;
838 n->addend = relocation;
839 n->next = mips_hi16_list;
840 mips_hi16_list = n;
841
842 if (output_bfd != NULL)
843 reloc_entry->address += input_section->output_offset;
844
845 return ret;
846 }
847
848 /* Do a R_MIPS_LO16 relocation. This is a straightforward 16 bit
849 inplace relocation; this function exists in order to do the
850 R_MIPS_HI16 relocation described above. */
851
852 static bfd_reloc_status_type
853 mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
854 void *data, asection *input_section, bfd *output_bfd,
855 char **error_message)
856 {
857 arelent gp_disp_relent;
858
859 if (mips_hi16_list != NULL)
860 {
861 struct mips_hi16 *l;
862
863 l = mips_hi16_list;
864 while (l != NULL)
865 {
866 unsigned long insn;
867 unsigned long val;
868 unsigned long vallo;
869 struct mips_hi16 *next;
870
871 if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
872 {
873 gp_disp_relent = *reloc_entry;
874 reloc_entry = &gp_disp_relent;
875 reloc_entry->addend = l->addend;
876 }
877 else
878 {
879 /* Do the HI16 relocation. Note that we actually don't need
880 to know anything about the LO16 itself, except where to
881 find the low 16 bits of the addend needed by the LO16. */
882 insn = bfd_get_32 (abfd, l->addr);
883 vallo = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
884 /* The low order 16 bits are always treated as a signed
885 value. */
886 vallo = ((vallo & 0xffff) ^ 0x8000) - 0x8000;
887 val = ((insn & 0xffff) << 16) + vallo;
888 val += l->addend;
889
890 /* If PC-relative, we need to subtract out the address of the LO
891 half of the HI/LO. (The actual relocation is relative
892 to that instruction.) */
893 if (reloc_entry->howto->pc_relative)
894 val -= reloc_entry->address;
895
896 /* At this point, "val" has the value of the combined HI/LO
897 pair. If the low order 16 bits (which will be used for
898 the LO16 insn) are negative, then we will need an
899 adjustment for the high order 16 bits. */
900 val += 0x8000;
901 val = (val >> 16) & 0xffff;
902
903 insn &= ~ (bfd_vma) 0xffff;
904 insn |= val;
905 bfd_put_32 (abfd, insn, l->addr);
906 }
907
908 next = l->next;
909 free (l);
910 l = next;
911 }
912
913 mips_hi16_list = NULL;
914 }
915 else if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
916 {
917 bfd_reloc_status_type ret;
918 bfd_vma gp, relocation;
919
920 /* FIXME: Does this case ever occur? */
921
922 ret = mips_elf_final_gp (output_bfd, symbol, TRUE, error_message, &gp);
923 if (ret != bfd_reloc_ok)
924 return ret;
925
926 relocation = gp - reloc_entry->address;
927 relocation += symbol->section->output_section->vma;
928 relocation += symbol->section->output_offset;
929 relocation += reloc_entry->addend;
930
931 if (reloc_entry->address > input_section->_cooked_size)
932 return bfd_reloc_outofrange;
933
934 gp_disp_relent = *reloc_entry;
935 reloc_entry = &gp_disp_relent;
936 reloc_entry->addend = relocation - 4;
937 }
938
939 /* Now do the LO16 reloc in the usual way. */
940 return mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
941 input_section, output_bfd, error_message);
942 }
943
944 /* Do a R_MIPS_GOT16 reloc. This is a reloc against the global offset
945 table used for PIC code. If the symbol is an external symbol, the
946 instruction is modified to contain the offset of the appropriate
947 entry in the global offset table. If the symbol is a section
948 symbol, the next reloc is a R_MIPS_LO16 reloc. The two 16 bit
949 addends are combined to form the real addend against the section
950 symbol; the GOT16 is modified to contain the offset of an entry in
951 the global offset table, and the LO16 is modified to offset it
952 appropriately. Thus an offset larger than 16 bits requires a
953 modified value in the global offset table.
954
955 This implementation suffices for the assembler, but the linker does
956 not yet know how to create global offset tables. */
957
958 static bfd_reloc_status_type
959 mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
960 void *data, asection *input_section, bfd *output_bfd,
961 char **error_message)
962 {
963 /* If we're relocating, and this is an external symbol, we don't want
964 to change anything. */
965 if (output_bfd != NULL
966 && (symbol->flags & BSF_SECTION_SYM) == 0
967 && (symbol->flags & BSF_LOCAL) != 0)
968 {
969 reloc_entry->address += input_section->output_offset;
970 return bfd_reloc_ok;
971 }
972
973 return mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
974 input_section, output_bfd, error_message);
975 }
976
977 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
978 dangerous relocation. */
979
980 static bfd_boolean
981 mips_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp)
982 {
983 unsigned int count;
984 asymbol **sym;
985 unsigned int i;
986
987 /* If we've already figured out what GP will be, just return it. */
988 *pgp = _bfd_get_gp_value (output_bfd);
989 if (*pgp)
990 return TRUE;
991
992 count = bfd_get_symcount (output_bfd);
993 sym = bfd_get_outsymbols (output_bfd);
994
995 /* The linker script will have created a symbol named `_gp' with the
996 appropriate value. */
997 if (sym == NULL)
998 i = count;
999 else
1000 {
1001 for (i = 0; i < count; i++, sym++)
1002 {
1003 register const char *name;
1004
1005 name = bfd_asymbol_name (*sym);
1006 if (*name == '_' && strcmp (name, "_gp") == 0)
1007 {
1008 *pgp = bfd_asymbol_value (*sym);
1009 _bfd_set_gp_value (output_bfd, *pgp);
1010 break;
1011 }
1012 }
1013 }
1014
1015 if (i >= count)
1016 {
1017 /* Only get the error once. */
1018 *pgp = 4;
1019 _bfd_set_gp_value (output_bfd, *pgp);
1020 return FALSE;
1021 }
1022
1023 return TRUE;
1024 }
1025
1026 /* We have to figure out the gp value, so that we can adjust the
1027 symbol value correctly. We look up the symbol _gp in the output
1028 BFD. If we can't find it, we're stuck. We cache it in the ELF
1029 target data. We don't need to adjust the symbol value for an
1030 external symbol if we are producing relocatable output. */
1031
1032 static bfd_reloc_status_type
1033 mips_elf_final_gp (bfd *output_bfd, asymbol *symbol, bfd_boolean relocatable,
1034 char **error_message, bfd_vma *pgp)
1035 {
1036 if (bfd_is_und_section (symbol->section)
1037 && ! relocatable)
1038 {
1039 *pgp = 0;
1040 return bfd_reloc_undefined;
1041 }
1042
1043 *pgp = _bfd_get_gp_value (output_bfd);
1044 if (*pgp == 0
1045 && (! relocatable
1046 || (symbol->flags & BSF_SECTION_SYM) != 0))
1047 {
1048 if (relocatable)
1049 {
1050 /* Make up a value. */
1051 *pgp = symbol->section->output_section->vma + 0x4000;
1052 _bfd_set_gp_value (output_bfd, *pgp);
1053 }
1054 else if (!mips_elf_assign_gp (output_bfd, pgp))
1055 {
1056 *error_message =
1057 (char *) _("GP relative relocation when _gp not defined");
1058 return bfd_reloc_dangerous;
1059 }
1060 }
1061
1062 return bfd_reloc_ok;
1063 }
1064
1065 /* Do a R_MIPS_GPREL16 relocation. This is a 16 bit value which must
1066 become the offset from the gp register. This function also handles
1067 R_MIPS_LITERAL relocations, although those can be handled more
1068 cleverly because the entries in the .lit8 and .lit4 sections can be
1069 merged. */
1070
1071 bfd_reloc_status_type
1072 _bfd_mips_elf32_gprel16_reloc (bfd *abfd, arelent *reloc_entry,
1073 asymbol *symbol, void *data,
1074 asection *input_section, bfd *output_bfd,
1075 char **error_message)
1076 {
1077 bfd_boolean relocatable;
1078 bfd_reloc_status_type ret;
1079 bfd_vma gp;
1080
1081 /* If we're relocating, and this is an external symbol, we don't want
1082 to change anything. */
1083 if (output_bfd != NULL
1084 && (symbol->flags & BSF_SECTION_SYM) == 0
1085 && (symbol->flags & BSF_LOCAL) != 0)
1086 {
1087 reloc_entry->address += input_section->output_offset;
1088 return bfd_reloc_ok;
1089 }
1090
1091 if (output_bfd != NULL)
1092 relocatable = TRUE;
1093 else
1094 {
1095 relocatable = FALSE;
1096 output_bfd = symbol->section->output_section->owner;
1097 }
1098
1099 ret = mips_elf_final_gp (output_bfd, symbol, relocatable, error_message,
1100 &gp);
1101 if (ret != bfd_reloc_ok)
1102 return ret;
1103
1104 return _bfd_mips_elf_gprel16_with_gp (abfd, symbol, reloc_entry,
1105 input_section, relocatable,
1106 data, gp);
1107 }
1108
1109 /* Do a R_MIPS_GPREL32 relocation. This is a 32 bit value which must
1110 become the offset from the gp register. */
1111
1112 static bfd_reloc_status_type
1113 mips_elf_gprel32_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1114 void *data, asection *input_section, bfd *output_bfd,
1115 char **error_message)
1116 {
1117 bfd_boolean relocatable;
1118 bfd_reloc_status_type ret;
1119 bfd_vma gp;
1120
1121 /* If we're relocating, and this is an external symbol, we don't want
1122 to change anything. */
1123 if (output_bfd != NULL
1124 && (symbol->flags & BSF_SECTION_SYM) == 0
1125 && (symbol->flags & BSF_LOCAL) != 0)
1126 {
1127 *error_message = (char *)
1128 _("32bits gp relative relocation occurs for an external symbol");
1129 return bfd_reloc_outofrange;
1130 }
1131
1132 if (output_bfd != NULL)
1133 relocatable = TRUE;
1134 else
1135 {
1136 relocatable = FALSE;
1137 output_bfd = symbol->section->output_section->owner;
1138 }
1139
1140 ret = mips_elf_final_gp (output_bfd, symbol, relocatable,
1141 error_message, &gp);
1142 if (ret != bfd_reloc_ok)
1143 return ret;
1144
1145 return gprel32_with_gp (abfd, symbol, reloc_entry, input_section,
1146 relocatable, data, gp);
1147 }
1148
1149 static bfd_reloc_status_type
1150 gprel32_with_gp (bfd *abfd, asymbol *symbol, arelent *reloc_entry,
1151 asection *input_section, bfd_boolean relocatable,
1152 void *data, bfd_vma gp)
1153 {
1154 bfd_vma relocation;
1155 bfd_vma val;
1156
1157 if (bfd_is_com_section (symbol->section))
1158 relocation = 0;
1159 else
1160 relocation = symbol->value;
1161
1162 relocation += symbol->section->output_section->vma;
1163 relocation += symbol->section->output_offset;
1164
1165 if (reloc_entry->address > input_section->_cooked_size)
1166 return bfd_reloc_outofrange;
1167
1168 /* Set val to the offset into the section or symbol. */
1169 val = reloc_entry->addend;
1170
1171 if (reloc_entry->howto->partial_inplace)
1172 val += bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1173
1174 /* Adjust val for the final section location and GP value. If we
1175 are producing relocatable output, we don't want to do this for
1176 an external symbol. */
1177 if (! relocatable
1178 || (symbol->flags & BSF_SECTION_SYM) != 0)
1179 val += relocation - gp;
1180
1181 if (reloc_entry->howto->partial_inplace)
1182 bfd_put_32 (abfd, val, (bfd_byte *) data + reloc_entry->address);
1183 else
1184 reloc_entry->addend = val;
1185
1186 if (relocatable)
1187 reloc_entry->address += input_section->output_offset;
1188
1189 return bfd_reloc_ok;
1190 }
1191
1192 /* Handle a 64 bit reloc in a 32 bit MIPS ELF file. These are
1193 generated when addresses are 64 bits. The upper 32 bits are a simple
1194 sign extension. */
1195
1196 static bfd_reloc_status_type
1197 mips32_64bit_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1198 void *data, asection *input_section, bfd *output_bfd,
1199 char **error_message)
1200 {
1201 bfd_reloc_status_type r;
1202 arelent reloc32;
1203 unsigned long val;
1204 bfd_size_type addr;
1205
1206 r = mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1207 input_section, output_bfd, error_message);
1208 if (r != bfd_reloc_continue)
1209 return r;
1210
1211 /* Do a normal 32 bit relocation on the lower 32 bits. */
1212 reloc32 = *reloc_entry;
1213 if (bfd_big_endian (abfd))
1214 reloc32.address += 4;
1215 reloc32.howto = &elf_mips_howto_table_rel[R_MIPS_32];
1216 r = bfd_perform_relocation (abfd, &reloc32, data, input_section,
1217 output_bfd, error_message);
1218
1219 /* Sign extend into the upper 32 bits. */
1220 val = bfd_get_32 (abfd, (bfd_byte *) data + reloc32.address);
1221 if ((val & 0x80000000) != 0)
1222 val = 0xffffffff;
1223 else
1224 val = 0;
1225 addr = reloc_entry->address;
1226 if (bfd_little_endian (abfd))
1227 addr += 4;
1228 bfd_put_32 (abfd, val, (bfd_byte *) data + addr);
1229
1230 return r;
1231 }
1232
1233 /* Handle a mips16 jump. */
1234
1235 static bfd_reloc_status_type
1236 mips16_jump_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1237 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
1238 asection *input_section, bfd *output_bfd,
1239 char **error_message ATTRIBUTE_UNUSED)
1240 {
1241 if (output_bfd != NULL
1242 && (symbol->flags & BSF_SECTION_SYM) == 0
1243 && reloc_entry->addend == 0)
1244 {
1245 reloc_entry->address += input_section->output_offset;
1246 return bfd_reloc_ok;
1247 }
1248
1249 /* FIXME. */
1250 {
1251 static bfd_boolean warned;
1252
1253 if (! warned)
1254 (*_bfd_error_handler)
1255 (_("Linking mips16 objects into %s format is not supported"),
1256 bfd_get_target (input_section->output_section->owner));
1257 warned = TRUE;
1258 }
1259
1260 return bfd_reloc_undefined;
1261 }
1262
1263 /* Handle a mips16 GP relative reloc. */
1264
1265 static bfd_reloc_status_type
1266 mips16_gprel_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1267 void *data, asection *input_section, bfd *output_bfd,
1268 char **error_message)
1269 {
1270 bfd_boolean relocatable;
1271 bfd_reloc_status_type ret;
1272 bfd_vma gp;
1273 unsigned short extend = 0;
1274 unsigned short insn = 0;
1275 bfd_signed_vma val;
1276 bfd_vma relocation;
1277
1278 /* If we're relocating, and this is an external symbol, we don't want
1279 to change anything. */
1280 if (output_bfd != NULL
1281 && (symbol->flags & BSF_SECTION_SYM) == 0
1282 && (symbol->flags & BSF_LOCAL) != 0)
1283 {
1284 reloc_entry->address += input_section->output_offset;
1285 return bfd_reloc_ok;
1286 }
1287
1288 if (output_bfd != NULL)
1289 relocatable = TRUE;
1290 else
1291 {
1292 relocatable = FALSE;
1293 output_bfd = symbol->section->output_section->owner;
1294 }
1295
1296 ret = mips_elf_final_gp (output_bfd, symbol, relocatable, error_message,
1297 &gp);
1298 if (ret != bfd_reloc_ok)
1299 return ret;
1300
1301 if (reloc_entry->address > input_section->_cooked_size)
1302 return bfd_reloc_outofrange;
1303
1304 if (bfd_is_com_section (symbol->section))
1305 relocation = 0;
1306 else
1307 relocation = symbol->value;
1308
1309 relocation += symbol->section->output_section->vma;
1310 relocation += symbol->section->output_offset;
1311
1312 /* Set val to the offset into the section or symbol. */
1313 val = reloc_entry->addend;
1314
1315 if (reloc_entry->howto->partial_inplace)
1316 {
1317 /* Pick up the mips16 extend instruction and the real instruction. */
1318 extend = bfd_get_16 (abfd, (bfd_byte *) data + reloc_entry->address);
1319 insn = bfd_get_16 (abfd, (bfd_byte *) data + reloc_entry->address + 2);
1320 val += ((extend & 0x1f) << 11) | (extend & 0x7e0) | (insn & 0x1f);
1321 }
1322
1323 _bfd_mips_elf_sign_extend(val, 16);
1324
1325 /* Adjust val for the final section location and GP value. If we
1326 are producing relocatable output, we don't want to do this for
1327 an external symbol. */
1328 if (! relocatable
1329 || (symbol->flags & BSF_SECTION_SYM) != 0)
1330 val += relocation - gp;
1331
1332 if (reloc_entry->howto->partial_inplace)
1333 {
1334 bfd_put_16 (abfd,
1335 (extend & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0),
1336 (bfd_byte *) data + reloc_entry->address);
1337 bfd_put_16 (abfd,
1338 (insn & 0xffe0) | (val & 0x1f),
1339 (bfd_byte *) data + reloc_entry->address + 2);
1340 }
1341 else
1342 reloc_entry->addend = val;
1343
1344 if (relocatable)
1345 reloc_entry->address += input_section->output_offset;
1346 else if (((val & ~0xffff) != ~0xffff) && ((val & ~0xffff) != 0))
1347 return bfd_reloc_overflow;
1348
1349 return bfd_reloc_ok;
1350 }
1351
1352 /* A mapping from BFD reloc types to MIPS ELF reloc types. */
1353
1354 struct elf_reloc_map {
1355 bfd_reloc_code_real_type bfd_val;
1356 enum elf_mips_reloc_type elf_val;
1357 };
1358
1359 static const struct elf_reloc_map mips_reloc_map[] =
1360 {
1361 { BFD_RELOC_NONE, R_MIPS_NONE },
1362 { BFD_RELOC_16, R_MIPS_16 },
1363 { BFD_RELOC_32, R_MIPS_32 },
1364 /* There is no BFD reloc for R_MIPS_REL32. */
1365 { BFD_RELOC_64, R_MIPS_64 },
1366 { BFD_RELOC_MIPS_JMP, R_MIPS_26 },
1367 { BFD_RELOC_HI16_S, R_MIPS_HI16 },
1368 { BFD_RELOC_LO16, R_MIPS_LO16 },
1369 { BFD_RELOC_GPREL16, R_MIPS_GPREL16 },
1370 { BFD_RELOC_MIPS_LITERAL, R_MIPS_LITERAL },
1371 { BFD_RELOC_MIPS_GOT16, R_MIPS_GOT16 },
1372 { BFD_RELOC_16_PCREL, R_MIPS_PC16 },
1373 { BFD_RELOC_MIPS_CALL16, R_MIPS_CALL16 },
1374 { BFD_RELOC_GPREL32, R_MIPS_GPREL32 },
1375 { BFD_RELOC_MIPS_GOT_HI16, R_MIPS_GOT_HI16 },
1376 { BFD_RELOC_MIPS_GOT_LO16, R_MIPS_GOT_LO16 },
1377 { BFD_RELOC_MIPS_CALL_HI16, R_MIPS_CALL_HI16 },
1378 { BFD_RELOC_MIPS_CALL_LO16, R_MIPS_CALL_LO16 },
1379 { BFD_RELOC_MIPS_SUB, R_MIPS_SUB },
1380 { BFD_RELOC_MIPS_GOT_PAGE, R_MIPS_GOT_PAGE },
1381 { BFD_RELOC_MIPS_GOT_OFST, R_MIPS_GOT_OFST },
1382 { BFD_RELOC_MIPS_GOT_DISP, R_MIPS_GOT_DISP }
1383 };
1384
1385 /* Given a BFD reloc type, return a howto structure. */
1386
1387 static reloc_howto_type *
1388 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
1389 {
1390 unsigned int i;
1391 reloc_howto_type *howto_table = elf_mips_howto_table_rel;
1392
1393 for (i = 0; i < sizeof (mips_reloc_map) / sizeof (struct elf_reloc_map);
1394 i++)
1395 {
1396 if (mips_reloc_map[i].bfd_val == code)
1397 return &howto_table[(int) mips_reloc_map[i].elf_val];
1398 }
1399
1400 switch (code)
1401 {
1402 default:
1403 bfd_set_error (bfd_error_bad_value);
1404 return NULL;
1405
1406 case BFD_RELOC_CTOR:
1407 /* We need to handle BFD_RELOC_CTOR specially.
1408 Select the right relocation (R_MIPS_32 or R_MIPS_64) based on the
1409 size of addresses of the ABI. */
1410 if ((elf_elfheader (abfd)->e_flags & (E_MIPS_ABI_O64
1411 | E_MIPS_ABI_EABI64)) != 0)
1412 return &elf_mips_ctor64_howto;
1413 else
1414 return &howto_table[(int) R_MIPS_32];
1415
1416 case BFD_RELOC_MIPS16_JMP:
1417 return &elf_mips16_jump_howto;
1418 case BFD_RELOC_MIPS16_GPREL:
1419 return &elf_mips16_gprel_howto;
1420 case BFD_RELOC_VTABLE_INHERIT:
1421 return &elf_mips_gnu_vtinherit_howto;
1422 case BFD_RELOC_VTABLE_ENTRY:
1423 return &elf_mips_gnu_vtentry_howto;
1424 case BFD_RELOC_PCREL_HI16_S:
1425 return &elf_mips_gnu_rel_hi16;
1426 case BFD_RELOC_PCREL_LO16:
1427 return &elf_mips_gnu_rel_lo16;
1428 case BFD_RELOC_16_PCREL_S2:
1429 return &elf_mips_gnu_rel16_s2;
1430 case BFD_RELOC_64_PCREL:
1431 return &elf_mips_gnu_pcrel64;
1432 case BFD_RELOC_32_PCREL:
1433 return &elf_mips_gnu_pcrel32;
1434 }
1435 }
1436
1437 /* Given a MIPS Elf_Internal_Rel, fill in an arelent structure. */
1438
1439 static reloc_howto_type *
1440 mips_elf32_rtype_to_howto (unsigned int r_type,
1441 bfd_boolean rela_p ATTRIBUTE_UNUSED)
1442 {
1443 switch (r_type)
1444 {
1445 case R_MIPS16_26:
1446 return &elf_mips16_jump_howto;
1447 case R_MIPS16_GPREL:
1448 return &elf_mips16_gprel_howto;
1449 case R_MIPS_GNU_VTINHERIT:
1450 return &elf_mips_gnu_vtinherit_howto;
1451 case R_MIPS_GNU_VTENTRY:
1452 return &elf_mips_gnu_vtentry_howto;
1453 case R_MIPS_GNU_REL_HI16:
1454 return &elf_mips_gnu_rel_hi16;
1455 case R_MIPS_GNU_REL_LO16:
1456 return &elf_mips_gnu_rel_lo16;
1457 case R_MIPS_GNU_REL16_S2:
1458 return &elf_mips_gnu_rel16_s2;
1459 case R_MIPS_PC64:
1460 return &elf_mips_gnu_pcrel64;
1461 case R_MIPS_PC32:
1462 return &elf_mips_gnu_pcrel32;
1463 default:
1464 BFD_ASSERT (r_type < (unsigned int) R_MIPS_max);
1465 return &elf_mips_howto_table_rel[r_type];
1466 }
1467 }
1468
1469 /* Given a MIPS Elf_Internal_Rel, fill in an arelent structure. */
1470
1471 static void
1472 mips_info_to_howto_rel (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst)
1473 {
1474 unsigned int r_type;
1475
1476 r_type = ELF32_R_TYPE (dst->r_info);
1477 cache_ptr->howto = mips_elf32_rtype_to_howto (r_type, FALSE);
1478
1479 /* The addend for a GPREL16 or LITERAL relocation comes from the GP
1480 value for the object file. We get the addend now, rather than
1481 when we do the relocation, because the symbol manipulations done
1482 by the linker may cause us to lose track of the input BFD. */
1483 if (((*cache_ptr->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0
1484 && (r_type == (unsigned int) R_MIPS_GPREL16
1485 || r_type == (unsigned int) R_MIPS_LITERAL))
1486 cache_ptr->addend = elf_gp (abfd);
1487 }
1488
1489 /* Given a MIPS Elf_Internal_Rela, fill in an arelent structure. */
1490
1491 static void
1492 mips_info_to_howto_rela (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst)
1493 {
1494 mips_info_to_howto_rel (abfd, cache_ptr, dst);
1495
1496 /* If we ever need to do any extra processing with dst->r_addend
1497 (the field omitted in an Elf_Internal_Rel) we can do it here. */
1498 }
1499 \f
1500 /* Determine whether a symbol is global for the purposes of splitting
1501 the symbol table into global symbols and local symbols. At least
1502 on Irix 5, this split must be between section symbols and all other
1503 symbols. On most ELF targets the split is between static symbols
1504 and externally visible symbols. */
1505
1506 static bfd_boolean
1507 mips_elf_sym_is_global (bfd *abfd ATTRIBUTE_UNUSED, asymbol *sym)
1508 {
1509 if (SGI_COMPAT (abfd))
1510 return (sym->flags & BSF_SECTION_SYM) == 0;
1511 else
1512 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1513 || bfd_is_und_section (bfd_get_section (sym))
1514 || bfd_is_com_section (bfd_get_section (sym)));
1515 }
1516 \f
1517 /* Set the right machine number for a MIPS ELF file. */
1518
1519 static bfd_boolean
1520 mips_elf32_object_p (bfd *abfd)
1521 {
1522 unsigned long mach;
1523
1524 /* Irix 5 and 6 are broken. Object file symbol tables are not always
1525 sorted correctly such that local symbols precede global symbols,
1526 and the sh_info field in the symbol table is not always right. */
1527 if (SGI_COMPAT (abfd))
1528 elf_bad_symtab (abfd) = TRUE;
1529
1530 if (ABI_N32_P (abfd))
1531 return FALSE;
1532
1533 mach = _bfd_elf_mips_mach (elf_elfheader (abfd)->e_flags);
1534 bfd_default_set_arch_mach (abfd, bfd_arch_mips, mach);
1535
1536 return TRUE;
1537 }
1538 \f
1539 /* MIPS ELF local labels start with '$', not 'L'. */
1540
1541 static bfd_boolean
1542 mips_elf_is_local_label_name (bfd *abfd, const char *name)
1543 {
1544 if (name[0] == '$')
1545 return TRUE;
1546
1547 /* On Irix 6, the labels go back to starting with '.', so we accept
1548 the generic ELF local label syntax as well. */
1549 return _bfd_elf_is_local_label_name (abfd, name);
1550 }
1551 \f
1552 /* Support for core dump NOTE sections. */
1553 static bfd_boolean
1554 elf32_mips_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1555 {
1556 int offset;
1557 unsigned int raw_size;
1558
1559 switch (note->descsz)
1560 {
1561 default:
1562 return FALSE;
1563
1564 case 256: /* Linux/MIPS */
1565 /* pr_cursig */
1566 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1567
1568 /* pr_pid */
1569 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1570
1571 /* pr_reg */
1572 offset = 72;
1573 raw_size = 180;
1574
1575 break;
1576 }
1577
1578 /* Make a ".reg/999" section. */
1579 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1580 raw_size, note->descpos + offset);
1581 }
1582
1583 static bfd_boolean
1584 elf32_mips_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1585 {
1586 switch (note->descsz)
1587 {
1588 default:
1589 return FALSE;
1590
1591 case 128: /* Linux/MIPS elf_prpsinfo */
1592 elf_tdata (abfd)->core_program
1593 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
1594 elf_tdata (abfd)->core_command
1595 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
1596 }
1597
1598 /* Note that for some reason, a spurious space is tacked
1599 onto the end of the args in some (at least one anyway)
1600 implementations, so strip it off if it exists. */
1601
1602 {
1603 char *command = elf_tdata (abfd)->core_command;
1604 int n = strlen (command);
1605
1606 if (0 < n && command[n - 1] == ' ')
1607 command[n - 1] = '\0';
1608 }
1609
1610 return TRUE;
1611 }
1612 \f
1613 /* Depending on the target vector we generate some version of Irix
1614 executables or "normal" MIPS ELF ABI executables. */
1615 static irix_compat_t
1616 elf32_mips_irix_compat (bfd *abfd)
1617 {
1618 if ((abfd->xvec == &bfd_elf32_bigmips_vec)
1619 || (abfd->xvec == &bfd_elf32_littlemips_vec))
1620 return ict_irix5;
1621 else
1622 return ict_none;
1623 }
1624 \f
1625 /* Given a data section and an in-memory embedded reloc section, store
1626 relocation information into the embedded reloc section which can be
1627 used at runtime to relocate the data section. This is called by the
1628 linker when the --embedded-relocs switch is used. This is called
1629 after the add_symbols entry point has been called for all the
1630 objects, and before the final_link entry point is called. */
1631
1632 bfd_boolean
1633 bfd_mips_elf32_create_embedded_relocs (bfd *abfd, struct bfd_link_info *info,
1634 asection *datasec, asection *relsec,
1635 char **errmsg)
1636 {
1637 Elf_Internal_Shdr *symtab_hdr;
1638 Elf_Internal_Sym *isymbuf = NULL;
1639 Elf_Internal_Rela *internal_relocs = NULL;
1640 Elf_Internal_Rela *irel, *irelend;
1641 bfd_byte *p;
1642
1643 BFD_ASSERT (! info->relocatable);
1644
1645 *errmsg = NULL;
1646
1647 if (datasec->reloc_count == 0)
1648 return TRUE;
1649
1650 /* Read this BFD's symbols if we haven't done so already, or get the cached
1651 copy if it exists. */
1652 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1653 if (symtab_hdr->sh_info != 0)
1654 {
1655 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1656 if (isymbuf == NULL)
1657 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1658 symtab_hdr->sh_info, 0,
1659 NULL, NULL, NULL);
1660 if (isymbuf == NULL)
1661 goto error_return;
1662 }
1663
1664 /* Get a copy of the native relocations. */
1665 internal_relocs = _bfd_elf_link_read_relocs (abfd, datasec, NULL, NULL,
1666 info->keep_memory);
1667 if (internal_relocs == NULL)
1668 goto error_return;
1669
1670 relsec->contents = bfd_alloc (abfd, datasec->reloc_count * 12);
1671 if (relsec->contents == NULL)
1672 goto error_return;
1673
1674 p = relsec->contents;
1675
1676 irelend = internal_relocs + datasec->reloc_count;
1677
1678 for (irel = internal_relocs; irel < irelend; irel++, p += 12)
1679 {
1680 asection *targetsec;
1681
1682 /* We are going to write a four byte longword into the runtime
1683 reloc section. The longword will be the address in the data
1684 section which must be relocated. It is followed by the name
1685 of the target section NUL-padded or truncated to 8
1686 characters. */
1687
1688 /* We can only relocate absolute longword relocs at run time. */
1689 if ((ELF32_R_TYPE (irel->r_info) != (int) R_MIPS_32) &&
1690 (ELF32_R_TYPE (irel->r_info) != (int) R_MIPS_64))
1691 {
1692 *errmsg = _("unsupported reloc type");
1693 bfd_set_error (bfd_error_bad_value);
1694 goto error_return;
1695 }
1696 /* Get the target section referred to by the reloc. */
1697 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1698 {
1699 Elf_Internal_Sym *isym;
1700
1701 /* A local symbol. */
1702 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1703 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1704 }
1705 else
1706 {
1707 unsigned long indx;
1708 struct elf_link_hash_entry *h;
1709
1710 /* An external symbol. */
1711 indx = ELF32_R_SYM (irel->r_info);
1712 h = elf_sym_hashes (abfd)[indx];
1713 targetsec = NULL;
1714 /*
1715 For some reason, in certain programs, the symbol will
1716 not be in the hash table. It seems to happen when you
1717 declare a static table of pointers to const external structures.
1718 In this case, the relocs are relative to data, not
1719 text, so just treating it like an undefined link
1720 should be sufficient. */
1721 BFD_ASSERT(h != NULL);
1722 if (h->root.type == bfd_link_hash_defined
1723 || h->root.type == bfd_link_hash_defweak)
1724 targetsec = h->root.u.def.section;
1725 }
1726
1727
1728 /*
1729 Set the low bit of the relocation offset if it's a MIPS64 reloc.
1730 Relocations will always be on (at least) 32-bit boundaries. */
1731
1732 bfd_put_32 (abfd, ((irel->r_offset + datasec->output_offset) +
1733 ((ELF32_R_TYPE (irel->r_info) == (int) R_MIPS_64) ? 1 : 0)),
1734 p);
1735 memset (p + 4, 0, 8);
1736 if (targetsec != NULL)
1737 strncpy (p + 4, targetsec->output_section->name, 8);
1738 }
1739
1740 if (internal_relocs != NULL
1741 && elf_section_data (datasec)->relocs != internal_relocs)
1742 free (internal_relocs);
1743 if (isymbuf != NULL
1744 && symtab_hdr->contents != (unsigned char *) isymbuf)
1745 free (isymbuf);
1746 return TRUE;
1747
1748 error_return:
1749 if (internal_relocs != NULL
1750 && elf_section_data (datasec)->relocs != internal_relocs)
1751 free (internal_relocs);
1752 if (isymbuf != NULL
1753 && symtab_hdr->contents != (unsigned char *) isymbuf)
1754 free (isymbuf);
1755 return FALSE;
1756 }
1757 \f
1758 /* ECOFF swapping routines. These are used when dealing with the
1759 .mdebug section, which is in the ECOFF debugging format. */
1760 static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap = {
1761 /* Symbol table magic number. */
1762 magicSym,
1763 /* Alignment of debugging information. E.g., 4. */
1764 4,
1765 /* Sizes of external symbolic information. */
1766 sizeof (struct hdr_ext),
1767 sizeof (struct dnr_ext),
1768 sizeof (struct pdr_ext),
1769 sizeof (struct sym_ext),
1770 sizeof (struct opt_ext),
1771 sizeof (struct fdr_ext),
1772 sizeof (struct rfd_ext),
1773 sizeof (struct ext_ext),
1774 /* Functions to swap in external symbolic data. */
1775 ecoff_swap_hdr_in,
1776 ecoff_swap_dnr_in,
1777 ecoff_swap_pdr_in,
1778 ecoff_swap_sym_in,
1779 ecoff_swap_opt_in,
1780 ecoff_swap_fdr_in,
1781 ecoff_swap_rfd_in,
1782 ecoff_swap_ext_in,
1783 _bfd_ecoff_swap_tir_in,
1784 _bfd_ecoff_swap_rndx_in,
1785 /* Functions to swap out external symbolic data. */
1786 ecoff_swap_hdr_out,
1787 ecoff_swap_dnr_out,
1788 ecoff_swap_pdr_out,
1789 ecoff_swap_sym_out,
1790 ecoff_swap_opt_out,
1791 ecoff_swap_fdr_out,
1792 ecoff_swap_rfd_out,
1793 ecoff_swap_ext_out,
1794 _bfd_ecoff_swap_tir_out,
1795 _bfd_ecoff_swap_rndx_out,
1796 /* Function to read in symbolic data. */
1797 _bfd_mips_elf_read_ecoff_info
1798 };
1799 \f
1800 #define ELF_ARCH bfd_arch_mips
1801 #define ELF_MACHINE_CODE EM_MIPS
1802
1803 /* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
1804 a value of 0x1000, and we are compatible. */
1805 #define ELF_MAXPAGESIZE 0x1000
1806
1807 #define elf_backend_collect TRUE
1808 #define elf_backend_type_change_ok TRUE
1809 #define elf_backend_can_gc_sections TRUE
1810 #define elf_info_to_howto mips_info_to_howto_rela
1811 #define elf_info_to_howto_rel mips_info_to_howto_rel
1812 #define elf_backend_sym_is_global mips_elf_sym_is_global
1813 #define elf_backend_object_p mips_elf32_object_p
1814 #define elf_backend_symbol_processing _bfd_mips_elf_symbol_processing
1815 #define elf_backend_section_processing _bfd_mips_elf_section_processing
1816 #define elf_backend_section_from_shdr _bfd_mips_elf_section_from_shdr
1817 #define elf_backend_fake_sections _bfd_mips_elf_fake_sections
1818 #define elf_backend_section_from_bfd_section \
1819 _bfd_mips_elf_section_from_bfd_section
1820 #define elf_backend_add_symbol_hook _bfd_mips_elf_add_symbol_hook
1821 #define elf_backend_link_output_symbol_hook \
1822 _bfd_mips_elf_link_output_symbol_hook
1823 #define elf_backend_create_dynamic_sections \
1824 _bfd_mips_elf_create_dynamic_sections
1825 #define elf_backend_check_relocs _bfd_mips_elf_check_relocs
1826 #define elf_backend_adjust_dynamic_symbol \
1827 _bfd_mips_elf_adjust_dynamic_symbol
1828 #define elf_backend_always_size_sections \
1829 _bfd_mips_elf_always_size_sections
1830 #define elf_backend_size_dynamic_sections \
1831 _bfd_mips_elf_size_dynamic_sections
1832 #define elf_backend_relocate_section _bfd_mips_elf_relocate_section
1833 #define elf_backend_finish_dynamic_symbol \
1834 _bfd_mips_elf_finish_dynamic_symbol
1835 #define elf_backend_finish_dynamic_sections \
1836 _bfd_mips_elf_finish_dynamic_sections
1837 #define elf_backend_final_write_processing \
1838 _bfd_mips_elf_final_write_processing
1839 #define elf_backend_additional_program_headers \
1840 _bfd_mips_elf_additional_program_headers
1841 #define elf_backend_modify_segment_map _bfd_mips_elf_modify_segment_map
1842 #define elf_backend_gc_mark_hook _bfd_mips_elf_gc_mark_hook
1843 #define elf_backend_gc_sweep_hook _bfd_mips_elf_gc_sweep_hook
1844 #define elf_backend_copy_indirect_symbol \
1845 _bfd_mips_elf_copy_indirect_symbol
1846 #define elf_backend_hide_symbol _bfd_mips_elf_hide_symbol
1847 #define elf_backend_grok_prstatus elf32_mips_grok_prstatus
1848 #define elf_backend_grok_psinfo elf32_mips_grok_psinfo
1849 #define elf_backend_ecoff_debug_swap &mips_elf32_ecoff_debug_swap
1850
1851 #define elf_backend_got_header_size (4 * MIPS_RESERVED_GOTNO)
1852 #define elf_backend_may_use_rel_p 1
1853 #define elf_backend_may_use_rela_p 0
1854 #define elf_backend_default_use_rela_p 0
1855 #define elf_backend_sign_extend_vma TRUE
1856
1857 #define elf_backend_discard_info _bfd_mips_elf_discard_info
1858 #define elf_backend_ignore_discarded_relocs \
1859 _bfd_mips_elf_ignore_discarded_relocs
1860 #define elf_backend_mips_irix_compat elf32_mips_irix_compat
1861 #define elf_backend_mips_rtype_to_howto mips_elf32_rtype_to_howto
1862 #define bfd_elf32_bfd_is_local_label_name \
1863 mips_elf_is_local_label_name
1864 #define bfd_elf32_find_nearest_line _bfd_mips_elf_find_nearest_line
1865 #define bfd_elf32_new_section_hook _bfd_mips_elf_new_section_hook
1866 #define bfd_elf32_set_section_contents _bfd_mips_elf_set_section_contents
1867 #define bfd_elf32_bfd_get_relocated_section_contents \
1868 _bfd_elf_mips_get_relocated_section_contents
1869 #define bfd_elf32_bfd_link_hash_table_create \
1870 _bfd_mips_elf_link_hash_table_create
1871 #define bfd_elf32_bfd_final_link _bfd_mips_elf_final_link
1872 #define bfd_elf32_bfd_merge_private_bfd_data \
1873 _bfd_mips_elf_merge_private_bfd_data
1874 #define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
1875 #define bfd_elf32_bfd_print_private_bfd_data \
1876 _bfd_mips_elf_print_private_bfd_data
1877
1878 /* Support for SGI-ish mips targets. */
1879 #define TARGET_LITTLE_SYM bfd_elf32_littlemips_vec
1880 #define TARGET_LITTLE_NAME "elf32-littlemips"
1881 #define TARGET_BIG_SYM bfd_elf32_bigmips_vec
1882 #define TARGET_BIG_NAME "elf32-bigmips"
1883
1884 #include "elf32-target.h"
1885
1886 /* Support for traditional mips targets. */
1887 #define INCLUDED_TARGET_FILE /* More a type of flag. */
1888
1889 #undef TARGET_LITTLE_SYM
1890 #undef TARGET_LITTLE_NAME
1891 #undef TARGET_BIG_SYM
1892 #undef TARGET_BIG_NAME
1893
1894 #define TARGET_LITTLE_SYM bfd_elf32_tradlittlemips_vec
1895 #define TARGET_LITTLE_NAME "elf32-tradlittlemips"
1896 #define TARGET_BIG_SYM bfd_elf32_tradbigmips_vec
1897 #define TARGET_BIG_NAME "elf32-tradbigmips"
1898
1899 /* Include the target file again for this target. */
1900 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.07119 seconds and 4 git commands to generate.