projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
2001-01-23 Kazu Hirata <kazu@hxi.com>
[deliverable/binutils-gdb.git] / bfd / coff-mips.c
1 /* BFD back-end for MIPS Extended-Coff files.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
3 Free Software Foundation, Inc.
4 Original version by Per Bothner.
5 Full support added by Ian Lance Taylor, ian@cygnus.com.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22
23 #include "bfd.h"
24 #include "sysdep.h"
25 #include "bfdlink.h"
26 #include "libbfd.h"
27 #include "coff/internal.h"
28 #include "coff/sym.h"
29 #include "coff/symconst.h"
30 #include "coff/ecoff.h"
31 #include "coff/mips.h"
32 #include "libcoff.h"
33 #include "libecoff.h"
34 \f
35 /* Prototypes for static functions. */
36
37 static boolean mips_ecoff_bad_format_hook PARAMS ((bfd *abfd, PTR filehdr));
38 static void mips_ecoff_swap_reloc_in PARAMS ((bfd *, PTR,
39 struct internal_reloc *));
40 static void mips_ecoff_swap_reloc_out PARAMS ((bfd *,
41 const struct internal_reloc *,
42 PTR));
43 static void mips_adjust_reloc_in PARAMS ((bfd *,
44 const struct internal_reloc *,
45 arelent *));
46 static void mips_adjust_reloc_out PARAMS ((bfd *, const arelent *,
47 struct internal_reloc *));
48 static bfd_reloc_status_type mips_generic_reloc PARAMS ((bfd *abfd,
49 arelent *reloc,
50 asymbol *symbol,
51 PTR data,
52 asection *section,
53 bfd *output_bfd,
54 char **error));
55 static bfd_reloc_status_type mips_refhi_reloc PARAMS ((bfd *abfd,
56 arelent *reloc,
57 asymbol *symbol,
58 PTR data,
59 asection *section,
60 bfd *output_bfd,
61 char **error));
62 static bfd_reloc_status_type mips_reflo_reloc PARAMS ((bfd *abfd,
63 arelent *reloc,
64 asymbol *symbol,
65 PTR data,
66 asection *section,
67 bfd *output_bfd,
68 char **error));
69 static bfd_reloc_status_type mips_gprel_reloc PARAMS ((bfd *abfd,
70 arelent *reloc,
71 asymbol *symbol,
72 PTR data,
73 asection *section,
74 bfd *output_bfd,
75 char **error));
76 static bfd_reloc_status_type mips_relhi_reloc PARAMS ((bfd *abfd,
77 arelent *reloc,
78 asymbol *symbol,
79 PTR data,
80 asection *section,
81 bfd *output_bfd,
82 char **error));
83 static bfd_reloc_status_type mips_rello_reloc PARAMS ((bfd *abfd,
84 arelent *reloc,
85 asymbol *symbol,
86 PTR data,
87 asection *section,
88 bfd *output_bfd,
89 char **error));
90 static bfd_reloc_status_type mips_switch_reloc PARAMS ((bfd *abfd,
91 arelent *reloc,
92 asymbol *symbol,
93 PTR data,
94 asection *section,
95 bfd *output_bfd,
96 char **error));
97 static void mips_relocate_hi PARAMS ((struct internal_reloc *refhi,
98 struct internal_reloc *reflo,
99 bfd *input_bfd,
100 asection *input_section,
101 bfd_byte *contents,
102 size_t adjust,
103 bfd_vma relocation,
104 boolean pcrel));
105 static boolean mips_relocate_section PARAMS ((bfd *, struct bfd_link_info *,
106 bfd *, asection *,
107 bfd_byte *, PTR));
108 static boolean mips_read_relocs PARAMS ((bfd *, asection *));
109 static boolean mips_relax_section PARAMS ((bfd *, asection *,
110 struct bfd_link_info *,
111 boolean *));
112 static boolean mips_relax_pcrel16 PARAMS ((struct bfd_link_info *, bfd *,
113 asection *,
114 struct ecoff_link_hash_entry *,
115 bfd_byte *, bfd_vma));
116 static reloc_howto_type *mips_bfd_reloc_type_lookup
117 PARAMS ((bfd *, bfd_reloc_code_real_type));
118 \f
119 /* ECOFF has COFF sections, but the debugging information is stored in
120 a completely different format. ECOFF targets use some of the
121 swapping routines from coffswap.h, and some of the generic COFF
122 routines in coffgen.c, but, unlike the real COFF targets, do not
123 use coffcode.h itself.
124
125 Get the generic COFF swapping routines, except for the reloc,
126 symbol, and lineno ones. Give them ECOFF names. */
127 #define MIPSECOFF
128 #define NO_COFF_RELOCS
129 #define NO_COFF_SYMBOLS
130 #define NO_COFF_LINENOS
131 #define coff_swap_filehdr_in mips_ecoff_swap_filehdr_in
132 #define coff_swap_filehdr_out mips_ecoff_swap_filehdr_out
133 #define coff_swap_aouthdr_in mips_ecoff_swap_aouthdr_in
134 #define coff_swap_aouthdr_out mips_ecoff_swap_aouthdr_out
135 #define coff_swap_scnhdr_in mips_ecoff_swap_scnhdr_in
136 #define coff_swap_scnhdr_out mips_ecoff_swap_scnhdr_out
137 #include "coffswap.h"
138
139 /* Get the ECOFF swapping routines. */
140 #define ECOFF_32
141 #include "ecoffswap.h"
142 \f
143 /* How to process the various relocs types. */
144
145 static reloc_howto_type mips_howto_table[] =
146 {
147 /* Reloc type 0 is ignored. The reloc reading code ensures that
148 this is a reference to the .abs section, which will cause
149 bfd_perform_relocation to do nothing. */
150 HOWTO (MIPS_R_IGNORE, /* type */
151 0, /* rightshift */
152 0, /* size (0 = byte, 1 = short, 2 = long) */
153 8, /* bitsize */
154 false, /* pc_relative */
155 0, /* bitpos */
156 complain_overflow_dont, /* complain_on_overflow */
157 0, /* special_function */
158 "IGNORE", /* name */
159 false, /* partial_inplace */
160 0, /* src_mask */
161 0, /* dst_mask */
162 false), /* pcrel_offset */
163
164 /* A 16 bit reference to a symbol, normally from a data section. */
165 HOWTO (MIPS_R_REFHALF, /* type */
166 0, /* rightshift */
167 1, /* size (0 = byte, 1 = short, 2 = long) */
168 16, /* bitsize */
169 false, /* pc_relative */
170 0, /* bitpos */
171 complain_overflow_bitfield, /* complain_on_overflow */
172 mips_generic_reloc, /* special_function */
173 "REFHALF", /* name */
174 true, /* partial_inplace */
175 0xffff, /* src_mask */
176 0xffff, /* dst_mask */
177 false), /* pcrel_offset */
178
179 /* A 32 bit reference to a symbol, normally from a data section. */
180 HOWTO (MIPS_R_REFWORD, /* type */
181 0, /* rightshift */
182 2, /* size (0 = byte, 1 = short, 2 = long) */
183 32, /* bitsize */
184 false, /* pc_relative */
185 0, /* bitpos */
186 complain_overflow_bitfield, /* complain_on_overflow */
187 mips_generic_reloc, /* special_function */
188 "REFWORD", /* name */
189 true, /* partial_inplace */
190 0xffffffff, /* src_mask */
191 0xffffffff, /* dst_mask */
192 false), /* pcrel_offset */
193
194 /* A 26 bit absolute jump address. */
195 HOWTO (MIPS_R_JMPADDR, /* type */
196 2, /* rightshift */
197 2, /* size (0 = byte, 1 = short, 2 = long) */
198 26, /* bitsize */
199 false, /* pc_relative */
200 0, /* bitpos */
201 complain_overflow_dont, /* complain_on_overflow */
202 /* This needs complex overflow
203 detection, because the upper four
204 bits must match the PC. */
205 mips_generic_reloc, /* special_function */
206 "JMPADDR", /* name */
207 true, /* partial_inplace */
208 0x3ffffff, /* src_mask */
209 0x3ffffff, /* dst_mask */
210 false), /* pcrel_offset */
211
212 /* The high 16 bits of a symbol value. Handled by the function
213 mips_refhi_reloc. */
214 HOWTO (MIPS_R_REFHI, /* type */
215 16, /* rightshift */
216 2, /* size (0 = byte, 1 = short, 2 = long) */
217 16, /* bitsize */
218 false, /* pc_relative */
219 0, /* bitpos */
220 complain_overflow_bitfield, /* complain_on_overflow */
221 mips_refhi_reloc, /* special_function */
222 "REFHI", /* name */
223 true, /* partial_inplace */
224 0xffff, /* src_mask */
225 0xffff, /* dst_mask */
226 false), /* pcrel_offset */
227
228 /* The low 16 bits of a symbol value. */
229 HOWTO (MIPS_R_REFLO, /* type */
230 0, /* rightshift */
231 2, /* size (0 = byte, 1 = short, 2 = long) */
232 16, /* bitsize */
233 false, /* pc_relative */
234 0, /* bitpos */
235 complain_overflow_dont, /* complain_on_overflow */
236 mips_reflo_reloc, /* special_function */
237 "REFLO", /* name */
238 true, /* partial_inplace */
239 0xffff, /* src_mask */
240 0xffff, /* dst_mask */
241 false), /* pcrel_offset */
242
243 /* A reference to an offset from the gp register. Handled by the
244 function mips_gprel_reloc. */
245 HOWTO (MIPS_R_GPREL, /* type */
246 0, /* rightshift */
247 2, /* size (0 = byte, 1 = short, 2 = long) */
248 16, /* bitsize */
249 false, /* pc_relative */
250 0, /* bitpos */
251 complain_overflow_signed, /* complain_on_overflow */
252 mips_gprel_reloc, /* special_function */
253 "GPREL", /* name */
254 true, /* partial_inplace */
255 0xffff, /* src_mask */
256 0xffff, /* dst_mask */
257 false), /* pcrel_offset */
258
259 /* A reference to a literal using an offset from the gp register.
260 Handled by the function mips_gprel_reloc. */
261 HOWTO (MIPS_R_LITERAL, /* type */
262 0, /* rightshift */
263 2, /* size (0 = byte, 1 = short, 2 = long) */
264 16, /* bitsize */
265 false, /* pc_relative */
266 0, /* bitpos */
267 complain_overflow_signed, /* complain_on_overflow */
268 mips_gprel_reloc, /* special_function */
269 "LITERAL", /* name */
270 true, /* partial_inplace */
271 0xffff, /* src_mask */
272 0xffff, /* dst_mask */
273 false), /* pcrel_offset */
274
275 EMPTY_HOWTO (8),
276 EMPTY_HOWTO (9),
277 EMPTY_HOWTO (10),
278 EMPTY_HOWTO (11),
279
280 /* This reloc is a Cygnus extension used when generating position
281 independent code for embedded systems. It represents a 16 bit PC
282 relative reloc rightshifted twice as used in the MIPS branch
283 instructions. */
284 HOWTO (MIPS_R_PCREL16, /* type */
285 2, /* rightshift */
286 2, /* size (0 = byte, 1 = short, 2 = long) */
287 16, /* bitsize */
288 true, /* pc_relative */
289 0, /* bitpos */
290 complain_overflow_signed, /* complain_on_overflow */
291 mips_generic_reloc, /* special_function */
292 "PCREL16", /* name */
293 true, /* partial_inplace */
294 0xffff, /* src_mask */
295 0xffff, /* dst_mask */
296 true), /* pcrel_offset */
297
298 /* This reloc is a Cygnus extension used when generating position
299 independent code for embedded systems. It represents the high 16
300 bits of a PC relative reloc. The next reloc must be
301 MIPS_R_RELLO, and the addend is formed from the addends of the
302 two instructions, just as in MIPS_R_REFHI and MIPS_R_REFLO. The
303 final value is actually PC relative to the location of the
304 MIPS_R_RELLO reloc, not the MIPS_R_RELHI reloc. */
305 HOWTO (MIPS_R_RELHI, /* type */
306 16, /* rightshift */
307 2, /* size (0 = byte, 1 = short, 2 = long) */
308 16, /* bitsize */
309 true, /* pc_relative */
310 0, /* bitpos */
311 complain_overflow_bitfield, /* complain_on_overflow */
312 mips_relhi_reloc, /* special_function */
313 "RELHI", /* name */
314 true, /* partial_inplace */
315 0xffff, /* src_mask */
316 0xffff, /* dst_mask */
317 true), /* pcrel_offset */
318
319 /* This reloc is a Cygnus extension used when generating position
320 independent code for embedded systems. It represents the low 16
321 bits of a PC relative reloc. */
322 HOWTO (MIPS_R_RELLO, /* type */
323 0, /* rightshift */
324 2, /* size (0 = byte, 1 = short, 2 = long) */
325 16, /* bitsize */
326 true, /* pc_relative */
327 0, /* bitpos */
328 complain_overflow_dont, /* complain_on_overflow */
329 mips_rello_reloc, /* special_function */
330 "RELLO", /* name */
331 true, /* partial_inplace */
332 0xffff, /* src_mask */
333 0xffff, /* dst_mask */
334 true), /* pcrel_offset */
335
336 EMPTY_HOWTO (15),
337 EMPTY_HOWTO (16),
338 EMPTY_HOWTO (17),
339 EMPTY_HOWTO (18),
340 EMPTY_HOWTO (19),
341 EMPTY_HOWTO (20),
342 EMPTY_HOWTO (21),
343
344 /* This reloc is a Cygnus extension used when generating position
345 independent code for embedded systems. It represents an entry in
346 a switch table, which is the difference between two symbols in
347 the .text section. The symndx is actually the offset from the
348 reloc address to the subtrahend. See include/coff/mips.h for
349 more details. */
350 HOWTO (MIPS_R_SWITCH, /* type */
351 0, /* rightshift */
352 2, /* size (0 = byte, 1 = short, 2 = long) */
353 32, /* bitsize */
354 true, /* pc_relative */
355 0, /* bitpos */
356 complain_overflow_dont, /* complain_on_overflow */
357 mips_switch_reloc, /* special_function */
358 "SWITCH", /* name */
359 true, /* partial_inplace */
360 0xffffffff, /* src_mask */
361 0xffffffff, /* dst_mask */
362 true) /* pcrel_offset */
363 };
364
365 #define MIPS_HOWTO_COUNT \
366 (sizeof mips_howto_table / sizeof mips_howto_table[0])
367
368 /* When the linker is doing relaxing, it may change a external PCREL16
369 reloc. This typically represents an instruction like
370 bal foo
371 We change it to
372 .set noreorder
373 bal $L1
374 lui $at,%hi(foo - $L1)
375 $L1:
376 addiu $at,%lo(foo - $L1)
377 addu $at,$at,$31
378 jalr $at
379 PCREL16_EXPANSION_ADJUSTMENT is the number of bytes this changes the
380 instruction by. */
381
382 #define PCREL16_EXPANSION_ADJUSTMENT (4 * 4)
383 \f
384 /* See whether the magic number matches. */
385
386 static boolean
387 mips_ecoff_bad_format_hook (abfd, filehdr)
388 bfd *abfd;
389 PTR filehdr;
390 {
391 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
392
393 switch (internal_f->f_magic)
394 {
395 case MIPS_MAGIC_1:
396 /* I don't know what endianness this implies. */
397 return true;
398
399 case MIPS_MAGIC_BIG:
400 case MIPS_MAGIC_BIG2:
401 case MIPS_MAGIC_BIG3:
402 return bfd_big_endian (abfd);
403
404 case MIPS_MAGIC_LITTLE:
405 case MIPS_MAGIC_LITTLE2:
406 case MIPS_MAGIC_LITTLE3:
407 return bfd_little_endian (abfd);
408
409 default:
410 return false;
411 }
412 }
413 \f
414 /* Reloc handling. MIPS ECOFF relocs are packed into 8 bytes in
415 external form. They use a bit which indicates whether the symbol
416 is external. */
417
418 /* Swap a reloc in. */
419
420 static void
421 mips_ecoff_swap_reloc_in (abfd, ext_ptr, intern)
422 bfd *abfd;
423 PTR ext_ptr;
424 struct internal_reloc *intern;
425 {
426 const RELOC *ext = (RELOC *) ext_ptr;
427
428 intern->r_vaddr = bfd_h_get_32 (abfd, (bfd_byte *) ext->r_vaddr);
429 if (bfd_header_big_endian (abfd))
430 {
431 intern->r_symndx = (((int) ext->r_bits[0]
432 << RELOC_BITS0_SYMNDX_SH_LEFT_BIG)
433 | ((int) ext->r_bits[1]
434 << RELOC_BITS1_SYMNDX_SH_LEFT_BIG)
435 | ((int) ext->r_bits[2]
436 << RELOC_BITS2_SYMNDX_SH_LEFT_BIG));
437 intern->r_type = ((ext->r_bits[3] & RELOC_BITS3_TYPE_BIG)
438 >> RELOC_BITS3_TYPE_SH_BIG);
439 intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_BIG) != 0;
440 }
441 else
442 {
443 intern->r_symndx = (((int) ext->r_bits[0]
444 << RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE)
445 | ((int) ext->r_bits[1]
446 << RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE)
447 | ((int) ext->r_bits[2]
448 << RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE));
449 intern->r_type = (((ext->r_bits[3] & RELOC_BITS3_TYPE_LITTLE)
450 >> RELOC_BITS3_TYPE_SH_LITTLE)
451 | ((ext->r_bits[3] & RELOC_BITS3_TYPEHI_LITTLE)
452 << RELOC_BITS3_TYPEHI_SH_LITTLE));
453 intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_LITTLE) != 0;
454 }
455
456 /* If this is a MIPS_R_SWITCH reloc, or an internal MIPS_R_RELHI or
457 MIPS_R_RELLO reloc, r_symndx is actually the offset from the
458 reloc address to the base of the difference (see
459 include/coff/mips.h for more details). We copy symndx into the
460 r_offset field so as not to confuse ecoff_slurp_reloc_table in
461 ecoff.c. In adjust_reloc_in we then copy r_offset into the reloc
462 addend. */
463 if (intern->r_type == MIPS_R_SWITCH
464 || (! intern->r_extern
465 && (intern->r_type == MIPS_R_RELLO
466 || intern->r_type == MIPS_R_RELHI)))
467 {
468 BFD_ASSERT (! intern->r_extern);
469 intern->r_offset = intern->r_symndx;
470 if (intern->r_offset & 0x800000)
471 intern->r_offset -= 0x1000000;
472 intern->r_symndx = RELOC_SECTION_TEXT;
473 }
474 }
475
476 /* Swap a reloc out. */
477
478 static void
479 mips_ecoff_swap_reloc_out (abfd, intern, dst)
480 bfd *abfd;
481 const struct internal_reloc *intern;
482 PTR dst;
483 {
484 RELOC *ext = (RELOC *) dst;
485 long r_symndx;
486
487 BFD_ASSERT (intern->r_extern
488 || (intern->r_symndx >= 0 && intern->r_symndx <= 12));
489
490 /* If this is a MIPS_R_SWITCH reloc, or an internal MIPS_R_RELLO or
491 MIPS_R_RELHI reloc, we actually want to write the contents of
492 r_offset out as the symbol index. This undoes the change made by
493 mips_ecoff_swap_reloc_in. */
494 if (intern->r_type != MIPS_R_SWITCH
495 && (intern->r_extern
496 || (intern->r_type != MIPS_R_RELHI
497 && intern->r_type != MIPS_R_RELLO)))
498 r_symndx = intern->r_symndx;
499 else
500 {
501 BFD_ASSERT (intern->r_symndx == RELOC_SECTION_TEXT);
502 r_symndx = intern->r_offset & 0xffffff;
503 }
504
505 bfd_h_put_32 (abfd, intern->r_vaddr, (bfd_byte *) ext->r_vaddr);
506 if (bfd_header_big_endian (abfd))
507 {
508 ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_BIG;
509 ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_BIG;
510 ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_BIG;
511 ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_BIG)
512 & RELOC_BITS3_TYPE_BIG)
513 | (intern->r_extern ? RELOC_BITS3_EXTERN_BIG : 0));
514 }
515 else
516 {
517 ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE;
518 ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE;
519 ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE;
520 ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_LITTLE)
521 & RELOC_BITS3_TYPE_LITTLE)
522 | ((intern->r_type >> RELOC_BITS3_TYPEHI_SH_LITTLE
523 & RELOC_BITS3_TYPEHI_LITTLE))
524 | (intern->r_extern ? RELOC_BITS3_EXTERN_LITTLE : 0));
525 }
526 }
527
528 /* Finish canonicalizing a reloc. Part of this is generic to all
529 ECOFF targets, and that part is in ecoff.c. The rest is done in
530 this backend routine. It must fill in the howto field. */
531
532 static void
533 mips_adjust_reloc_in (abfd, intern, rptr)
534 bfd *abfd;
535 const struct internal_reloc *intern;
536 arelent *rptr;
537 {
538 if (intern->r_type > MIPS_R_SWITCH)
539 abort ();
540
541 if (! intern->r_extern
542 && (intern->r_type == MIPS_R_GPREL
543 || intern->r_type == MIPS_R_LITERAL))
544 rptr->addend += ecoff_data (abfd)->gp;
545
546 /* If the type is MIPS_R_IGNORE, make sure this is a reference to
547 the absolute section so that the reloc is ignored. */
548 if (intern->r_type == MIPS_R_IGNORE)
549 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
550
551 /* If this is a MIPS_R_SWITCH reloc, or an internal MIPS_R_RELHI or
552 MIPS_R_RELLO reloc, we want the addend field of the BFD relocto
553 hold the value which was originally in the symndx field of the
554 internal MIPS ECOFF reloc. This value was copied into
555 intern->r_offset by mips_swap_reloc_in, and here we copy it into
556 the addend field. */
557 if (intern->r_type == MIPS_R_SWITCH
558 || (! intern->r_extern
559 && (intern->r_type == MIPS_R_RELHI
560 || intern->r_type == MIPS_R_RELLO)))
561 rptr->addend = intern->r_offset;
562
563 rptr->howto = &mips_howto_table[intern->r_type];
564 }
565
566 /* Make any adjustments needed to a reloc before writing it out. None
567 are needed for MIPS. */
568
569 static void
570 mips_adjust_reloc_out (abfd, rel, intern)
571 bfd *abfd ATTRIBUTE_UNUSED;
572 const arelent *rel;
573 struct internal_reloc *intern;
574 {
575 /* For a MIPS_R_SWITCH reloc, or an internal MIPS_R_RELHI or
576 MIPS_R_RELLO reloc, we must copy rel->addend into
577 intern->r_offset. This will then be written out as the symbol
578 index by mips_ecoff_swap_reloc_out. This operation parallels the
579 action of mips_adjust_reloc_in. */
580 if (intern->r_type == MIPS_R_SWITCH
581 || (! intern->r_extern
582 && (intern->r_type == MIPS_R_RELHI
583 || intern->r_type == MIPS_R_RELLO)))
584 intern->r_offset = rel->addend;
585 }
586
587 /* ECOFF relocs are either against external symbols, or against
588 sections. If we are producing relocateable output, and the reloc
589 is against an external symbol, and nothing has given us any
590 additional addend, the resulting reloc will also be against the
591 same symbol. In such a case, we don't want to change anything
592 about the way the reloc is handled, since it will all be done at
593 final link time. Rather than put special case code into
594 bfd_perform_relocation, all the reloc types use this howto
595 function. It just short circuits the reloc if producing
596 relocateable output against an external symbol. */
597
598 static bfd_reloc_status_type
599 mips_generic_reloc (abfd,
600 reloc_entry,
601 symbol,
602 data,
603 input_section,
604 output_bfd,
605 error_message)
606 bfd *abfd ATTRIBUTE_UNUSED;
607 arelent *reloc_entry;
608 asymbol *symbol;
609 PTR data ATTRIBUTE_UNUSED;
610 asection *input_section;
611 bfd *output_bfd;
612 char **error_message ATTRIBUTE_UNUSED;
613 {
614 if (output_bfd != (bfd *) NULL
615 && (symbol->flags & BSF_SECTION_SYM) == 0
616 && reloc_entry->addend == 0)
617 {
618 reloc_entry->address += input_section->output_offset;
619 return bfd_reloc_ok;
620 }
621
622 return bfd_reloc_continue;
623 }
624
625 /* Do a REFHI relocation. This has to be done in combination with a
626 REFLO reloc, because there is a carry from the REFLO to the REFHI.
627 Here we just save the information we need; we do the actual
628 relocation when we see the REFLO. MIPS ECOFF requires that the
629 REFLO immediately follow the REFHI. As a GNU extension, we permit
630 an arbitrary number of HI relocs to be associated with a single LO
631 reloc. This extension permits gcc to output the HI and LO relocs
632 itself. */
633
634 struct mips_hi
635 {
636 struct mips_hi *next;
637 bfd_byte *addr;
638 bfd_vma addend;
639 };
640
641 /* FIXME: This should not be a static variable. */
642
643 static struct mips_hi *mips_refhi_list;
644
645 static bfd_reloc_status_type
646 mips_refhi_reloc (abfd,
647 reloc_entry,
648 symbol,
649 data,
650 input_section,
651 output_bfd,
652 error_message)
653 bfd *abfd ATTRIBUTE_UNUSED;
654 arelent *reloc_entry;
655 asymbol *symbol;
656 PTR data;
657 asection *input_section;
658 bfd *output_bfd;
659 char **error_message ATTRIBUTE_UNUSED;
660 {
661 bfd_reloc_status_type ret;
662 bfd_vma relocation;
663 struct mips_hi *n;
664
665 /* If we're relocating, and this an external symbol, we don't want
666 to change anything. */
667 if (output_bfd != (bfd *) NULL
668 && (symbol->flags & BSF_SECTION_SYM) == 0
669 && reloc_entry->addend == 0)
670 {
671 reloc_entry->address += input_section->output_offset;
672 return bfd_reloc_ok;
673 }
674
675 ret = bfd_reloc_ok;
676 if (bfd_is_und_section (symbol->section)
677 && output_bfd == (bfd *) NULL)
678 ret = bfd_reloc_undefined;
679
680 if (bfd_is_com_section (symbol->section))
681 relocation = 0;
682 else
683 relocation = symbol->value;
684
685 relocation += symbol->section->output_section->vma;
686 relocation += symbol->section->output_offset;
687 relocation += reloc_entry->addend;
688
689 if (reloc_entry->address > input_section->_cooked_size)
690 return bfd_reloc_outofrange;
691
692 /* Save the information, and let REFLO do the actual relocation. */
693 n = (struct mips_hi *) bfd_malloc (sizeof *n);
694 if (n == NULL)
695 return bfd_reloc_outofrange;
696 n->addr = (bfd_byte *) data + reloc_entry->address;
697 n->addend = relocation;
698 n->next = mips_refhi_list;
699 mips_refhi_list = n;
700
701 if (output_bfd != (bfd *) NULL)
702 reloc_entry->address += input_section->output_offset;
703
704 return ret;
705 }
706
707 /* Do a REFLO relocation. This is a straightforward 16 bit inplace
708 relocation; this function exists in order to do the REFHI
709 relocation described above. */
710
711 static bfd_reloc_status_type
712 mips_reflo_reloc (abfd,
713 reloc_entry,
714 symbol,
715 data,
716 input_section,
717 output_bfd,
718 error_message)
719 bfd *abfd;
720 arelent *reloc_entry;
721 asymbol *symbol;
722 PTR data;
723 asection *input_section;
724 bfd *output_bfd;
725 char **error_message;
726 {
727 if (mips_refhi_list != NULL)
728 {
729 struct mips_hi *l;
730
731 l = mips_refhi_list;
732 while (l != NULL)
733 {
734 unsigned long insn;
735 unsigned long val;
736 unsigned long vallo;
737 struct mips_hi *next;
738
739 /* Do the REFHI relocation. Note that we actually don't
740 need to know anything about the REFLO itself, except
741 where to find the low 16 bits of the addend needed by the
742 REFHI. */
743 insn = bfd_get_32 (abfd, l->addr);
744 vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
745 & 0xffff);
746 val = ((insn & 0xffff) << 16) + vallo;
747 val += l->addend;
748
749 /* The low order 16 bits are always treated as a signed
750 value. Therefore, a negative value in the low order bits
751 requires an adjustment in the high order bits. We need
752 to make this adjustment in two ways: once for the bits we
753 took from the data, and once for the bits we are putting
754 back in to the data. */
755 if ((vallo & 0x8000) != 0)
756 val -= 0x10000;
757 if ((val & 0x8000) != 0)
758 val += 0x10000;
759
760 insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff);
761 bfd_put_32 (abfd, insn, l->addr);
762
763 next = l->next;
764 free (l);
765 l = next;
766 }
767
768 mips_refhi_list = NULL;
769 }
770
771 /* Now do the REFLO reloc in the usual way. */
772 return mips_generic_reloc (abfd, reloc_entry, symbol, data,
773 input_section, output_bfd, error_message);
774 }
775
776 /* Do a GPREL relocation. This is a 16 bit value which must become
777 the offset from the gp register. */
778
779 static bfd_reloc_status_type
780 mips_gprel_reloc (abfd,
781 reloc_entry,
782 symbol,
783 data,
784 input_section,
785 output_bfd,
786 error_message)
787 bfd *abfd;
788 arelent *reloc_entry;
789 asymbol *symbol;
790 PTR data;
791 asection *input_section;
792 bfd *output_bfd;
793 char **error_message;
794 {
795 boolean relocateable;
796 bfd_vma gp;
797 bfd_vma relocation;
798 unsigned long val;
799 unsigned long insn;
800
801 /* If we're relocating, and this is an external symbol with no
802 addend, we don't want to change anything. We will only have an
803 addend if this is a newly created reloc, not read from an ECOFF
804 file. */
805 if (output_bfd != (bfd *) NULL
806 && (symbol->flags & BSF_SECTION_SYM) == 0
807 && reloc_entry->addend == 0)
808 {
809 reloc_entry->address += input_section->output_offset;
810 return bfd_reloc_ok;
811 }
812
813 if (output_bfd != (bfd *) NULL)
814 relocateable = true;
815 else
816 {
817 relocateable = false;
818 output_bfd = symbol->section->output_section->owner;
819 }
820
821 if (bfd_is_und_section (symbol->section)
822 && relocateable == false)
823 return bfd_reloc_undefined;
824
825 /* We have to figure out the gp value, so that we can adjust the
826 symbol value correctly. We look up the symbol _gp in the output
827 BFD. If we can't find it, we're stuck. We cache it in the ECOFF
828 target data. We don't need to adjust the symbol value for an
829 external symbol if we are producing relocateable output. */
830 gp = _bfd_get_gp_value (output_bfd);
831 if (gp == 0
832 && (relocateable == false
833 || (symbol->flags & BSF_SECTION_SYM) != 0))
834 {
835 if (relocateable != false)
836 {
837 /* Make up a value. */
838 gp = symbol->section->output_section->vma + 0x4000;
839 _bfd_set_gp_value (output_bfd, gp);
840 }
841 else
842 {
843 unsigned int count;
844 asymbol **sym;
845 unsigned int i;
846
847 count = bfd_get_symcount (output_bfd);
848 sym = bfd_get_outsymbols (output_bfd);
849
850 if (sym == (asymbol **) NULL)
851 i = count;
852 else
853 {
854 for (i = 0; i < count; i++, sym++)
855 {
856 register CONST char *name;
857
858 name = bfd_asymbol_name (*sym);
859 if (*name == '_' && strcmp (name, "_gp") == 0)
860 {
861 gp = bfd_asymbol_value (*sym);
862 _bfd_set_gp_value (output_bfd, gp);
863 break;
864 }
865 }
866 }
867
868 if (i >= count)
869 {
870 /* Only get the error once. */
871 gp = 4;
872 _bfd_set_gp_value (output_bfd, gp);
873 *error_message =
874 (char *) _("GP relative relocation when _gp not defined");
875 return bfd_reloc_dangerous;
876 }
877 }
878 }
879
880 if (bfd_is_com_section (symbol->section))
881 relocation = 0;
882 else
883 relocation = symbol->value;
884
885 relocation += symbol->section->output_section->vma;
886 relocation += symbol->section->output_offset;
887
888 if (reloc_entry->address > input_section->_cooked_size)
889 return bfd_reloc_outofrange;
890
891 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
892
893 /* Set val to the offset into the section or symbol. */
894 val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
895 if (val & 0x8000)
896 val -= 0x10000;
897
898 /* Adjust val for the final section location and GP value. If we
899 are producing relocateable output, we don't want to do this for
900 an external symbol. */
901 if (relocateable == false
902 || (symbol->flags & BSF_SECTION_SYM) != 0)
903 val += relocation - gp;
904
905 insn = (insn &~ 0xffff) | (val & 0xffff);
906 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
907
908 if (relocateable != false)
909 reloc_entry->address += input_section->output_offset;
910
911 /* Make sure it fit in 16 bits. */
912 if ((long) val >= 0x8000 || (long) val < -0x8000)
913 return bfd_reloc_overflow;
914
915 return bfd_reloc_ok;
916 }
917
918 /* Do a RELHI relocation. We do this in conjunction with a RELLO
919 reloc, just as REFHI and REFLO are done together. RELHI and RELLO
920 are Cygnus extensions used when generating position independent
921 code for embedded systems. */
922
923 /* FIXME: This should not be a static variable. */
924
925 static struct mips_hi *mips_relhi_list;
926
927 static bfd_reloc_status_type
928 mips_relhi_reloc (abfd,
929 reloc_entry,
930 symbol,
931 data,
932 input_section,
933 output_bfd,
934 error_message)
935 bfd *abfd ATTRIBUTE_UNUSED;
936 arelent *reloc_entry;
937 asymbol *symbol;
938 PTR data;
939 asection *input_section;
940 bfd *output_bfd;
941 char **error_message ATTRIBUTE_UNUSED;
942 {
943 bfd_reloc_status_type ret;
944 bfd_vma relocation;
945 struct mips_hi *n;
946
947 /* If this is a reloc against a section symbol, then it is correct
948 in the object file. The only time we want to change this case is
949 when we are relaxing, and that is handled entirely by
950 mips_relocate_section and never calls this function. */
951 if ((symbol->flags & BSF_SECTION_SYM) != 0)
952 {
953 if (output_bfd != (bfd *) NULL)
954 reloc_entry->address += input_section->output_offset;
955 return bfd_reloc_ok;
956 }
957
958 /* This is an external symbol. If we're relocating, we don't want
959 to change anything. */
960 if (output_bfd != (bfd *) NULL)
961 {
962 reloc_entry->address += input_section->output_offset;
963 return bfd_reloc_ok;
964 }
965
966 ret = bfd_reloc_ok;
967 if (bfd_is_und_section (symbol->section)
968 && output_bfd == (bfd *) NULL)
969 ret = bfd_reloc_undefined;
970
971 if (bfd_is_com_section (symbol->section))
972 relocation = 0;
973 else
974 relocation = symbol->value;
975
976 relocation += symbol->section->output_section->vma;
977 relocation += symbol->section->output_offset;
978 relocation += reloc_entry->addend;
979
980 if (reloc_entry->address > input_section->_cooked_size)
981 return bfd_reloc_outofrange;
982
983 /* Save the information, and let RELLO do the actual relocation. */
984 n = (struct mips_hi *) bfd_malloc (sizeof *n);
985 if (n == NULL)
986 return bfd_reloc_outofrange;
987 n->addr = (bfd_byte *) data + reloc_entry->address;
988 n->addend = relocation;
989 n->next = mips_relhi_list;
990 mips_relhi_list = n;
991
992 if (output_bfd != (bfd *) NULL)
993 reloc_entry->address += input_section->output_offset;
994
995 return ret;
996 }
997
998 /* Do a RELLO relocation. This is a straightforward 16 bit PC
999 relative relocation; this function exists in order to do the RELHI
1000 relocation described above. */
1001
1002 static bfd_reloc_status_type
1003 mips_rello_reloc (abfd,
1004 reloc_entry,
1005 symbol,
1006 data,
1007 input_section,
1008 output_bfd,
1009 error_message)
1010 bfd *abfd;
1011 arelent *reloc_entry;
1012 asymbol *symbol;
1013 PTR data;
1014 asection *input_section;
1015 bfd *output_bfd;
1016 char **error_message;
1017 {
1018 if (mips_relhi_list != NULL)
1019 {
1020 struct mips_hi *l;
1021
1022 l = mips_relhi_list;
1023 while (l != NULL)
1024 {
1025 unsigned long insn;
1026 unsigned long val;
1027 unsigned long vallo;
1028 struct mips_hi *next;
1029
1030 /* Do the RELHI relocation. Note that we actually don't
1031 need to know anything about the RELLO itself, except
1032 where to find the low 16 bits of the addend needed by the
1033 RELHI. */
1034 insn = bfd_get_32 (abfd, l->addr);
1035 vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
1036 & 0xffff);
1037 val = ((insn & 0xffff) << 16) + vallo;
1038 val += l->addend;
1039
1040 /* If the symbol is defined, make val PC relative. If the
1041 symbol is not defined we don't want to do this, because
1042 we don't want the value in the object file to incorporate
1043 the address of the reloc. */
1044 if (! bfd_is_und_section (bfd_get_section (symbol))
1045 && ! bfd_is_com_section (bfd_get_section (symbol)))
1046 val -= (input_section->output_section->vma
1047 + input_section->output_offset
1048 + reloc_entry->address);
1049
1050 /* The low order 16 bits are always treated as a signed
1051 value. Therefore, a negative value in the low order bits
1052 requires an adjustment in the high order bits. We need
1053 to make this adjustment in two ways: once for the bits we
1054 took from the data, and once for the bits we are putting
1055 back in to the data. */
1056 if ((vallo & 0x8000) != 0)
1057 val -= 0x10000;
1058 if ((val & 0x8000) != 0)
1059 val += 0x10000;
1060
1061 insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff);
1062 bfd_put_32 (abfd, insn, l->addr);
1063
1064 next = l->next;
1065 free (l);
1066 l = next;
1067 }
1068
1069 mips_relhi_list = NULL;
1070 }
1071
1072 /* If this is a reloc against a section symbol, then it is correct
1073 in the object file. The only time we want to change this case is
1074 when we are relaxing, and that is handled entirely by
1075 mips_relocate_section and never calls this function. */
1076 if ((symbol->flags & BSF_SECTION_SYM) != 0)
1077 {
1078 if (output_bfd != (bfd *) NULL)
1079 reloc_entry->address += input_section->output_offset;
1080 return bfd_reloc_ok;
1081 }
1082
1083 /* bfd_perform_relocation does not handle pcrel_offset relocations
1084 correctly when generating a relocateable file, so handle them
1085 directly here. */
1086 if (output_bfd != (bfd *) NULL)
1087 {
1088 reloc_entry->address += input_section->output_offset;
1089 return bfd_reloc_ok;
1090 }
1091
1092 /* Now do the RELLO reloc in the usual way. */
1093 return mips_generic_reloc (abfd, reloc_entry, symbol, data,
1094 input_section, output_bfd, error_message);
1095 }
1096
1097 /* This is the special function for the MIPS_R_SWITCH reloc. This
1098 special reloc is normally correct in the object file, and only
1099 requires special handling when relaxing. We don't want
1100 bfd_perform_relocation to tamper with it at all. */
1101
1102 static bfd_reloc_status_type
1103 mips_switch_reloc (abfd,
1104 reloc_entry,
1105 symbol,
1106 data,
1107 input_section,
1108 output_bfd,
1109 error_message)
1110 bfd *abfd ATTRIBUTE_UNUSED;
1111 arelent *reloc_entry ATTRIBUTE_UNUSED;
1112 asymbol *symbol ATTRIBUTE_UNUSED;
1113 PTR data ATTRIBUTE_UNUSED;
1114 asection *input_section ATTRIBUTE_UNUSED;
1115 bfd *output_bfd ATTRIBUTE_UNUSED;
1116 char **error_message ATTRIBUTE_UNUSED;
1117 {
1118 return bfd_reloc_ok;
1119 }
1120
1121 /* Get the howto structure for a generic reloc type. */
1122
1123 static reloc_howto_type *
1124 mips_bfd_reloc_type_lookup (abfd, code)
1125 bfd *abfd ATTRIBUTE_UNUSED;
1126 bfd_reloc_code_real_type code;
1127 {
1128 int mips_type;
1129
1130 switch (code)
1131 {
1132 case BFD_RELOC_16:
1133 mips_type = MIPS_R_REFHALF;
1134 break;
1135 case BFD_RELOC_32:
1136 case BFD_RELOC_CTOR:
1137 mips_type = MIPS_R_REFWORD;
1138 break;
1139 case BFD_RELOC_MIPS_JMP:
1140 mips_type = MIPS_R_JMPADDR;
1141 break;
1142 case BFD_RELOC_HI16_S:
1143 mips_type = MIPS_R_REFHI;
1144 break;
1145 case BFD_RELOC_LO16:
1146 mips_type = MIPS_R_REFLO;
1147 break;
1148 case BFD_RELOC_MIPS_GPREL:
1149 mips_type = MIPS_R_GPREL;
1150 break;
1151 case BFD_RELOC_MIPS_LITERAL:
1152 mips_type = MIPS_R_LITERAL;
1153 break;
1154 case BFD_RELOC_16_PCREL_S2:
1155 mips_type = MIPS_R_PCREL16;
1156 break;
1157 case BFD_RELOC_PCREL_HI16_S:
1158 mips_type = MIPS_R_RELHI;
1159 break;
1160 case BFD_RELOC_PCREL_LO16:
1161 mips_type = MIPS_R_RELLO;
1162 break;
1163 case BFD_RELOC_GPREL32:
1164 mips_type = MIPS_R_SWITCH;
1165 break;
1166 default:
1167 return (reloc_howto_type *) NULL;
1168 }
1169
1170 return &mips_howto_table[mips_type];
1171 }
1172 \f
1173 /* A helper routine for mips_relocate_section which handles the REFHI
1174 and RELHI relocations. The REFHI relocation must be followed by a
1175 REFLO relocation (and RELHI by a RELLO), and the addend used is
1176 formed from the addends of both instructions. */
1177
1178 static void
1179 mips_relocate_hi (refhi, reflo, input_bfd, input_section, contents, adjust,
1180 relocation, pcrel)
1181 struct internal_reloc *refhi;
1182 struct internal_reloc *reflo;
1183 bfd *input_bfd;
1184 asection *input_section;
1185 bfd_byte *contents;
1186 size_t adjust;
1187 bfd_vma relocation;
1188 boolean pcrel;
1189 {
1190 unsigned long insn;
1191 unsigned long val;
1192 unsigned long vallo;
1193
1194 if (refhi == NULL)
1195 return;
1196
1197 insn = bfd_get_32 (input_bfd,
1198 contents + adjust + refhi->r_vaddr - input_section->vma);
1199 if (reflo == NULL)
1200 vallo = 0;
1201 else
1202 vallo = (bfd_get_32 (input_bfd,
1203 contents + adjust + reflo->r_vaddr - input_section->vma)
1204 & 0xffff);
1205
1206 val = ((insn & 0xffff) << 16) + vallo;
1207 val += relocation;
1208
1209 /* The low order 16 bits are always treated as a signed value.
1210 Therefore, a negative value in the low order bits requires an
1211 adjustment in the high order bits. We need to make this
1212 adjustment in two ways: once for the bits we took from the data,
1213 and once for the bits we are putting back in to the data. */
1214 if ((vallo & 0x8000) != 0)
1215 val -= 0x10000;
1216
1217 if (pcrel)
1218 val -= (input_section->output_section->vma
1219 + input_section->output_offset
1220 + (reflo->r_vaddr - input_section->vma + adjust));
1221
1222 if ((val & 0x8000) != 0)
1223 val += 0x10000;
1224
1225 insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff);
1226 bfd_put_32 (input_bfd, (bfd_vma) insn,
1227 contents + adjust + refhi->r_vaddr - input_section->vma);
1228 }
1229
1230 /* Relocate a section while linking a MIPS ECOFF file. */
1231
1232 static boolean
1233 mips_relocate_section (output_bfd, info, input_bfd, input_section,
1234 contents, external_relocs)
1235 bfd *output_bfd;
1236 struct bfd_link_info *info;
1237 bfd *input_bfd;
1238 asection *input_section;
1239 bfd_byte *contents;
1240 PTR external_relocs;
1241 {
1242 asection **symndx_to_section;
1243 struct ecoff_link_hash_entry **sym_hashes;
1244 bfd_vma gp;
1245 boolean gp_undefined;
1246 size_t adjust;
1247 long *offsets;
1248 struct external_reloc *ext_rel;
1249 struct external_reloc *ext_rel_end;
1250 unsigned int i;
1251 boolean got_lo;
1252 struct internal_reloc lo_int_rel;
1253
1254 BFD_ASSERT (input_bfd->xvec->byteorder
1255 == output_bfd->xvec->byteorder);
1256
1257 /* We keep a table mapping the symndx found in an internal reloc to
1258 the appropriate section. This is faster than looking up the
1259 section by name each time. */
1260 symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
1261 if (symndx_to_section == (asection **) NULL)
1262 {
1263 symndx_to_section = ((asection **)
1264 bfd_alloc (input_bfd,
1265 (NUM_RELOC_SECTIONS
1266 * sizeof (asection *))));
1267 if (!symndx_to_section)
1268 return false;
1269
1270 symndx_to_section[RELOC_SECTION_NONE] = NULL;
1271 symndx_to_section[RELOC_SECTION_TEXT] =
1272 bfd_get_section_by_name (input_bfd, ".text");
1273 symndx_to_section[RELOC_SECTION_RDATA] =
1274 bfd_get_section_by_name (input_bfd, ".rdata");
1275 symndx_to_section[RELOC_SECTION_DATA] =
1276 bfd_get_section_by_name (input_bfd, ".data");
1277 symndx_to_section[RELOC_SECTION_SDATA] =
1278 bfd_get_section_by_name (input_bfd, ".sdata");
1279 symndx_to_section[RELOC_SECTION_SBSS] =
1280 bfd_get_section_by_name (input_bfd, ".sbss");
1281 symndx_to_section[RELOC_SECTION_BSS] =
1282 bfd_get_section_by_name (input_bfd, ".bss");
1283 symndx_to_section[RELOC_SECTION_INIT] =
1284 bfd_get_section_by_name (input_bfd, ".init");
1285 symndx_to_section[RELOC_SECTION_LIT8] =
1286 bfd_get_section_by_name (input_bfd, ".lit8");
1287 symndx_to_section[RELOC_SECTION_LIT4] =
1288 bfd_get_section_by_name (input_bfd, ".lit4");
1289 symndx_to_section[RELOC_SECTION_XDATA] = NULL;
1290 symndx_to_section[RELOC_SECTION_PDATA] = NULL;
1291 symndx_to_section[RELOC_SECTION_FINI] =
1292 bfd_get_section_by_name (input_bfd, ".fini");
1293 symndx_to_section[RELOC_SECTION_LITA] = NULL;
1294 symndx_to_section[RELOC_SECTION_ABS] = NULL;
1295
1296 ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
1297 }
1298
1299 sym_hashes = ecoff_data (input_bfd)->sym_hashes;
1300
1301 gp = _bfd_get_gp_value (output_bfd);
1302 if (gp == 0)
1303 gp_undefined = true;
1304 else
1305 gp_undefined = false;
1306
1307 got_lo = false;
1308
1309 adjust = 0;
1310
1311 if (ecoff_section_data (input_bfd, input_section) == NULL)
1312 offsets = NULL;
1313 else
1314 offsets = ecoff_section_data (input_bfd, input_section)->offsets;
1315
1316 ext_rel = (struct external_reloc *) external_relocs;
1317 ext_rel_end = ext_rel + input_section->reloc_count;
1318 for (i = 0; ext_rel < ext_rel_end; ext_rel++, i++)
1319 {
1320 struct internal_reloc int_rel;
1321 boolean use_lo = false;
1322 bfd_vma addend;
1323 reloc_howto_type *howto;
1324 struct ecoff_link_hash_entry *h = NULL;
1325 asection *s = NULL;
1326 bfd_vma relocation;
1327 bfd_reloc_status_type r;
1328
1329 if (! got_lo)
1330 mips_ecoff_swap_reloc_in (input_bfd, (PTR) ext_rel, &int_rel);
1331 else
1332 {
1333 int_rel = lo_int_rel;
1334 got_lo = false;
1335 }
1336
1337 BFD_ASSERT (int_rel.r_type
1338 < sizeof mips_howto_table / sizeof mips_howto_table[0]);
1339
1340 /* The REFHI and RELHI relocs requires special handling. they
1341 must be followed by a REFLO or RELLO reloc, respectively, and
1342 the addend is formed from both relocs. */
1343 if (int_rel.r_type == MIPS_R_REFHI
1344 || int_rel.r_type == MIPS_R_RELHI)
1345 {
1346 struct external_reloc *lo_ext_rel;
1347
1348 /* As a GNU extension, permit an arbitrary number of REFHI
1349 or RELHI relocs before the REFLO or RELLO reloc. This
1350 permits gcc to emit the HI and LO relocs itself. */
1351 for (lo_ext_rel = ext_rel + 1;
1352 lo_ext_rel < ext_rel_end;
1353 lo_ext_rel++)
1354 {
1355 mips_ecoff_swap_reloc_in (input_bfd, (PTR) lo_ext_rel,
1356 &lo_int_rel);
1357 if (lo_int_rel.r_type != int_rel.r_type)
1358 break;
1359 }
1360
1361 if (lo_ext_rel < ext_rel_end
1362 && (lo_int_rel.r_type
1363 == (int_rel.r_type == MIPS_R_REFHI
1364 ? MIPS_R_REFLO
1365 : MIPS_R_RELLO))
1366 && int_rel.r_extern == lo_int_rel.r_extern
1367 && int_rel.r_symndx == lo_int_rel.r_symndx)
1368 {
1369 use_lo = true;
1370 if (lo_ext_rel == ext_rel + 1)
1371 got_lo = true;
1372 }
1373 }
1374
1375 howto = &mips_howto_table[int_rel.r_type];
1376
1377 /* The SWITCH reloc must be handled specially. This reloc is
1378 marks the location of a difference between two portions of an
1379 object file. The symbol index does not reference a symbol,
1380 but is actually the offset from the reloc to the subtrahend
1381 of the difference. This reloc is correct in the object file,
1382 and needs no further adjustment, unless we are relaxing. If
1383 we are relaxing, we may have to add in an offset. Since no
1384 symbols are involved in this reloc, we handle it completely
1385 here. */
1386 if (int_rel.r_type == MIPS_R_SWITCH)
1387 {
1388 if (offsets != NULL
1389 && offsets[i] != 0)
1390 {
1391 r = _bfd_relocate_contents (howto, input_bfd,
1392 (bfd_vma) offsets[i],
1393 (contents
1394 + adjust
1395 + int_rel.r_vaddr
1396 - input_section->vma));
1397 BFD_ASSERT (r == bfd_reloc_ok);
1398 }
1399
1400 continue;
1401 }
1402
1403 if (int_rel.r_extern)
1404 {
1405 h = sym_hashes[int_rel.r_symndx];
1406 /* If h is NULL, that means that there is a reloc against an
1407 external symbol which we thought was just a debugging
1408 symbol. This should not happen. */
1409 if (h == (struct ecoff_link_hash_entry *) NULL)
1410 abort ();
1411 }
1412 else
1413 {
1414 if (int_rel.r_symndx < 0 || int_rel.r_symndx >= NUM_RELOC_SECTIONS)
1415 s = NULL;
1416 else
1417 s = symndx_to_section[int_rel.r_symndx];
1418
1419 if (s == (asection *) NULL)
1420 abort ();
1421 }
1422
1423 /* The GPREL reloc uses an addend: the difference in the GP
1424 values. */
1425 if (int_rel.r_type != MIPS_R_GPREL
1426 && int_rel.r_type != MIPS_R_LITERAL)
1427 addend = 0;
1428 else
1429 {
1430 if (gp_undefined)
1431 {
1432 if (! ((*info->callbacks->reloc_dangerous)
1433 (info, _("GP relative relocation when GP not defined"),
1434 input_bfd, input_section,
1435 int_rel.r_vaddr - input_section->vma)))
1436 return false;
1437 /* Only give the error once per link. */
1438 gp = 4;
1439 _bfd_set_gp_value (output_bfd, gp);
1440 gp_undefined = false;
1441 }
1442 if (! int_rel.r_extern)
1443 {
1444 /* This is a relocation against a section. The current
1445 addend in the instruction is the difference between
1446 INPUT_SECTION->vma and the GP value of INPUT_BFD. We
1447 must change this to be the difference between the
1448 final definition (which will end up in RELOCATION)
1449 and the GP value of OUTPUT_BFD (which is in GP). */
1450 addend = ecoff_data (input_bfd)->gp - gp;
1451 }
1452 else if (! info->relocateable
1453 || h->root.type == bfd_link_hash_defined
1454 || h->root.type == bfd_link_hash_defweak)
1455 {
1456 /* This is a relocation against a defined symbol. The
1457 current addend in the instruction is simply the
1458 desired offset into the symbol (normally zero). We
1459 are going to change this into a relocation against a
1460 defined symbol, so we want the instruction to hold
1461 the difference between the final definition of the
1462 symbol (which will end up in RELOCATION) and the GP
1463 value of OUTPUT_BFD (which is in GP). */
1464 addend = - gp;
1465 }
1466 else
1467 {
1468 /* This is a relocation against an undefined or common
1469 symbol. The current addend in the instruction is
1470 simply the desired offset into the symbol (normally
1471 zero). We are generating relocateable output, and we
1472 aren't going to define this symbol, so we just leave
1473 the instruction alone. */
1474 addend = 0;
1475 }
1476 }
1477
1478 /* If we are relaxing, mips_relax_section may have set
1479 offsets[i] to some value. A value of 1 means we must expand
1480 a PC relative branch into a multi-instruction of sequence,
1481 and any other value is an addend. */
1482 if (offsets != NULL
1483 && offsets[i] != 0)
1484 {
1485 BFD_ASSERT (! info->relocateable);
1486 BFD_ASSERT (int_rel.r_type == MIPS_R_PCREL16
1487 || int_rel.r_type == MIPS_R_RELHI
1488 || int_rel.r_type == MIPS_R_RELLO);
1489 if (offsets[i] != 1)
1490 addend += offsets[i];
1491 else
1492 {
1493 bfd_byte *here;
1494
1495 BFD_ASSERT (int_rel.r_extern
1496 && int_rel.r_type == MIPS_R_PCREL16);
1497
1498 /* Move the rest of the instructions up. */
1499 here = (contents
1500 + adjust
1501 + int_rel.r_vaddr
1502 - input_section->vma);
1503 memmove (here + PCREL16_EXPANSION_ADJUSTMENT, here,
1504 (size_t) (input_section->_raw_size
1505 - (int_rel.r_vaddr - input_section->vma)));
1506
1507 /* Generate the new instructions. */
1508 if (! mips_relax_pcrel16 (info, input_bfd, input_section,
1509 h, here,
1510 (input_section->output_section->vma
1511 + input_section->output_offset
1512 + (int_rel.r_vaddr
1513 - input_section->vma)
1514 + adjust)))
1515 return false;
1516
1517 /* We must adjust everything else up a notch. */
1518 adjust += PCREL16_EXPANSION_ADJUSTMENT;
1519
1520 /* mips_relax_pcrel16 handles all the details of this
1521 relocation. */
1522 continue;
1523 }
1524 }
1525
1526 /* If we are relaxing, and this is a reloc against the .text
1527 segment, we may need to adjust it if some branches have been
1528 expanded. The reloc types which are likely to occur in the
1529 .text section are handled efficiently by mips_relax_section,
1530 and thus do not need to be handled here. */
1531 if (ecoff_data (input_bfd)->debug_info.adjust != NULL
1532 && ! int_rel.r_extern
1533 && int_rel.r_symndx == RELOC_SECTION_TEXT
1534 && (strcmp (bfd_get_section_name (input_bfd, input_section),
1535 ".text") != 0
1536 || (int_rel.r_type != MIPS_R_PCREL16
1537 && int_rel.r_type != MIPS_R_SWITCH
1538 && int_rel.r_type != MIPS_R_RELHI
1539 && int_rel.r_type != MIPS_R_RELLO)))
1540 {
1541 bfd_vma adr;
1542 struct ecoff_value_adjust *a;
1543
1544 /* We need to get the addend so that we know whether we need
1545 to adjust the address. */
1546 BFD_ASSERT (int_rel.r_type == MIPS_R_REFWORD);
1547
1548 adr = bfd_get_32 (input_bfd,
1549 (contents
1550 + adjust
1551 + int_rel.r_vaddr
1552 - input_section->vma));
1553
1554 for (a = ecoff_data (input_bfd)->debug_info.adjust;
1555 a != (struct ecoff_value_adjust *) NULL;
1556 a = a->next)
1557 {
1558 if (adr >= a->start && adr < a->end)
1559 addend += a->adjust;
1560 }
1561 }
1562
1563 if (info->relocateable)
1564 {
1565 /* We are generating relocateable output, and must convert
1566 the existing reloc. */
1567 if (int_rel.r_extern)
1568 {
1569 if ((h->root.type == bfd_link_hash_defined
1570 || h->root.type == bfd_link_hash_defweak)
1571 && ! bfd_is_abs_section (h->root.u.def.section))
1572 {
1573 const char *name;
1574
1575 /* This symbol is defined in the output. Convert
1576 the reloc from being against the symbol to being
1577 against the section. */
1578
1579 /* Clear the r_extern bit. */
1580 int_rel.r_extern = 0;
1581
1582 /* Compute a new r_symndx value. */
1583 s = h->root.u.def.section;
1584 name = bfd_get_section_name (output_bfd,
1585 s->output_section);
1586
1587 int_rel.r_symndx = -1;
1588 switch (name[1])
1589 {
1590 case 'b':
1591 if (strcmp (name, ".bss") == 0)
1592 int_rel.r_symndx = RELOC_SECTION_BSS;
1593 break;
1594 case 'd':
1595 if (strcmp (name, ".data") == 0)
1596 int_rel.r_symndx = RELOC_SECTION_DATA;
1597 break;
1598 case 'f':
1599 if (strcmp (name, ".fini") == 0)
1600 int_rel.r_symndx = RELOC_SECTION_FINI;
1601 break;
1602 case 'i':
1603 if (strcmp (name, ".init") == 0)
1604 int_rel.r_symndx = RELOC_SECTION_INIT;
1605 break;
1606 case 'l':
1607 if (strcmp (name, ".lit8") == 0)
1608 int_rel.r_symndx = RELOC_SECTION_LIT8;
1609 else if (strcmp (name, ".lit4") == 0)
1610 int_rel.r_symndx = RELOC_SECTION_LIT4;
1611 break;
1612 case 'r':
1613 if (strcmp (name, ".rdata") == 0)
1614 int_rel.r_symndx = RELOC_SECTION_RDATA;
1615 break;
1616 case 's':
1617 if (strcmp (name, ".sdata") == 0)
1618 int_rel.r_symndx = RELOC_SECTION_SDATA;
1619 else if (strcmp (name, ".sbss") == 0)
1620 int_rel.r_symndx = RELOC_SECTION_SBSS;
1621 break;
1622 case 't':
1623 if (strcmp (name, ".text") == 0)
1624 int_rel.r_symndx = RELOC_SECTION_TEXT;
1625 break;
1626 }
1627
1628 if (int_rel.r_symndx == -1)
1629 abort ();
1630
1631 /* Add the section VMA and the symbol value. */
1632 relocation = (h->root.u.def.value
1633 + s->output_section->vma
1634 + s->output_offset);
1635
1636 /* For a PC relative relocation, the object file
1637 currently holds just the addend. We must adjust
1638 by the address to get the right value. */
1639 if (howto->pc_relative)
1640 {
1641 relocation -= int_rel.r_vaddr - input_section->vma;
1642
1643 /* If we are converting a RELHI or RELLO reloc
1644 from being against an external symbol to
1645 being against a section, we must put a
1646 special value into the r_offset field. This
1647 value is the old addend. The r_offset for
1648 both the RELHI and RELLO relocs are the same,
1649 and we set both when we see RELHI. */
1650 if (int_rel.r_type == MIPS_R_RELHI)
1651 {
1652 long addhi, addlo;
1653
1654 addhi = bfd_get_32 (input_bfd,
1655 (contents
1656 + adjust
1657 + int_rel.r_vaddr
1658 - input_section->vma));
1659 addhi &= 0xffff;
1660 if (addhi & 0x8000)
1661 addhi -= 0x10000;
1662 addhi <<= 16;
1663
1664 if (! use_lo)
1665 addlo = 0;
1666 else
1667 {
1668 addlo = bfd_get_32 (input_bfd,
1669 (contents
1670 + adjust
1671 + lo_int_rel.r_vaddr
1672 - input_section->vma));
1673 addlo &= 0xffff;
1674 if (addlo & 0x8000)
1675 addlo -= 0x10000;
1676
1677 lo_int_rel.r_offset = addhi + addlo;
1678 }
1679
1680 int_rel.r_offset = addhi + addlo;
1681 }
1682 }
1683
1684 h = NULL;
1685 }
1686 else
1687 {
1688 /* Change the symndx value to the right one for the
1689 output BFD. */
1690 int_rel.r_symndx = h->indx;
1691 if (int_rel.r_symndx == -1)
1692 {
1693 /* This symbol is not being written out. */
1694 if (! ((*info->callbacks->unattached_reloc)
1695 (info, h->root.root.string, input_bfd,
1696 input_section,
1697 int_rel.r_vaddr - input_section->vma)))
1698 return false;
1699 int_rel.r_symndx = 0;
1700 }
1701 relocation = 0;
1702 }
1703 }
1704 else
1705 {
1706 /* This is a relocation against a section. Adjust the
1707 value by the amount the section moved. */
1708 relocation = (s->output_section->vma
1709 + s->output_offset
1710 - s->vma);
1711 }
1712
1713 relocation += addend;
1714 addend = 0;
1715
1716 /* Adjust a PC relative relocation by removing the reference
1717 to the original address in the section and including the
1718 reference to the new address. However, external RELHI
1719 and RELLO relocs are PC relative, but don't include any
1720 reference to the address. The addend is merely an
1721 addend. */
1722 if (howto->pc_relative
1723 && (! int_rel.r_extern
1724 || (int_rel.r_type != MIPS_R_RELHI
1725 && int_rel.r_type != MIPS_R_RELLO)))
1726 relocation -= (input_section->output_section->vma
1727 + input_section->output_offset
1728 - input_section->vma);
1729
1730 /* Adjust the contents. */
1731 if (relocation == 0)
1732 r = bfd_reloc_ok;
1733 else
1734 {
1735 if (int_rel.r_type != MIPS_R_REFHI
1736 && int_rel.r_type != MIPS_R_RELHI)
1737 r = _bfd_relocate_contents (howto, input_bfd, relocation,
1738 (contents
1739 + adjust
1740 + int_rel.r_vaddr
1741 - input_section->vma));
1742 else
1743 {
1744 mips_relocate_hi (&int_rel,
1745 use_lo ? &lo_int_rel : NULL,
1746 input_bfd, input_section, contents,
1747 adjust, relocation,
1748 int_rel.r_type == MIPS_R_RELHI);
1749 r = bfd_reloc_ok;
1750 }
1751 }
1752
1753 /* Adjust the reloc address. */
1754 int_rel.r_vaddr += (input_section->output_section->vma
1755 + input_section->output_offset
1756 - input_section->vma);
1757
1758 /* Save the changed reloc information. */
1759 mips_ecoff_swap_reloc_out (input_bfd, &int_rel, (PTR) ext_rel);
1760 }
1761 else
1762 {
1763 /* We are producing a final executable. */
1764 if (int_rel.r_extern)
1765 {
1766 /* This is a reloc against a symbol. */
1767 if (h->root.type == bfd_link_hash_defined
1768 || h->root.type == bfd_link_hash_defweak)
1769 {
1770 asection *hsec;
1771
1772 hsec = h->root.u.def.section;
1773 relocation = (h->root.u.def.value
1774 + hsec->output_section->vma
1775 + hsec->output_offset);
1776 }
1777 else
1778 {
1779 if (! ((*info->callbacks->undefined_symbol)
1780 (info, h->root.root.string, input_bfd,
1781 input_section,
1782 int_rel.r_vaddr - input_section->vma, true)))
1783 return false;
1784 relocation = 0;
1785 }
1786 }
1787 else
1788 {
1789 /* This is a reloc against a section. */
1790 relocation = (s->output_section->vma
1791 + s->output_offset
1792 - s->vma);
1793
1794 /* A PC relative reloc is already correct in the object
1795 file. Make it look like a pcrel_offset relocation by
1796 adding in the start address. */
1797 if (howto->pc_relative)
1798 {
1799 if (int_rel.r_type != MIPS_R_RELHI || ! use_lo)
1800 relocation += int_rel.r_vaddr + adjust;
1801 else
1802 relocation += lo_int_rel.r_vaddr + adjust;
1803 }
1804 }
1805
1806 if (int_rel.r_type != MIPS_R_REFHI
1807 && int_rel.r_type != MIPS_R_RELHI)
1808 r = _bfd_final_link_relocate (howto,
1809 input_bfd,
1810 input_section,
1811 contents,
1812 (int_rel.r_vaddr
1813 - input_section->vma
1814 + adjust),
1815 relocation,
1816 addend);
1817 else
1818 {
1819 mips_relocate_hi (&int_rel,
1820 use_lo ? &lo_int_rel : NULL,
1821 input_bfd, input_section, contents, adjust,
1822 relocation,
1823 int_rel.r_type == MIPS_R_RELHI);
1824 r = bfd_reloc_ok;
1825 }
1826 }
1827
1828 /* MIPS_R_JMPADDR requires peculiar overflow detection. The
1829 instruction provides a 28 bit address (the two lower bits are
1830 implicit zeroes) which is combined with the upper four bits
1831 of the instruction address. */
1832 if (r == bfd_reloc_ok
1833 && int_rel.r_type == MIPS_R_JMPADDR
1834 && (((relocation
1835 + addend
1836 + (int_rel.r_extern ? 0 : s->vma))
1837 & 0xf0000000)
1838 != ((input_section->output_section->vma
1839 + input_section->output_offset
1840 + (int_rel.r_vaddr - input_section->vma)
1841 + adjust)
1842 & 0xf0000000)))
1843 r = bfd_reloc_overflow;
1844
1845 if (r != bfd_reloc_ok)
1846 {
1847 switch (r)
1848 {
1849 default:
1850 case bfd_reloc_outofrange:
1851 abort ();
1852 case bfd_reloc_overflow:
1853 {
1854 const char *name;
1855
1856 if (int_rel.r_extern)
1857 name = h->root.root.string;
1858 else
1859 name = bfd_section_name (input_bfd, s);
1860 if (! ((*info->callbacks->reloc_overflow)
1861 (info, name, howto->name, (bfd_vma) 0,
1862 input_bfd, input_section,
1863 int_rel.r_vaddr - input_section->vma)))
1864 return false;
1865 }
1866 break;
1867 }
1868 }
1869 }
1870
1871 return true;
1872 }
1873 \f
1874 /* Read in the relocs for a section. */
1875
1876 static boolean
1877 mips_read_relocs (abfd, sec)
1878 bfd *abfd;
1879 asection *sec;
1880 {
1881 struct ecoff_section_tdata *section_tdata;
1882
1883 section_tdata = ecoff_section_data (abfd, sec);
1884 if (section_tdata == (struct ecoff_section_tdata *) NULL)
1885 {
1886 sec->used_by_bfd =
1887 (PTR) bfd_alloc (abfd, sizeof (struct ecoff_section_tdata));
1888 if (sec->used_by_bfd == NULL)
1889 return false;
1890
1891 section_tdata = ecoff_section_data (abfd, sec);
1892 section_tdata->external_relocs = NULL;
1893 section_tdata->contents = NULL;
1894 section_tdata->offsets = NULL;
1895 }
1896
1897 if (section_tdata->external_relocs == NULL)
1898 {
1899 bfd_size_type external_relocs_size;
1900
1901 external_relocs_size = (ecoff_backend (abfd)->external_reloc_size
1902 * sec->reloc_count);
1903
1904 section_tdata->external_relocs =
1905 (PTR) bfd_alloc (abfd, external_relocs_size);
1906 if (section_tdata->external_relocs == NULL && external_relocs_size != 0)
1907 return false;
1908
1909 if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
1910 || (bfd_read (section_tdata->external_relocs, 1,
1911 external_relocs_size, abfd)
1912 != external_relocs_size))
1913 return false;
1914 }
1915
1916 return true;
1917 }
1918
1919 /* Relax a section when linking a MIPS ECOFF file. This is used for
1920 embedded PIC code, which always uses PC relative branches which
1921 only have an 18 bit range on MIPS. If a branch is not in range, we
1922 generate a long instruction sequence to compensate. Each time we
1923 find a branch to expand, we have to check all the others again to
1924 make sure they are still in range. This is slow, but it only has
1925 to be done when -relax is passed to the linker.
1926
1927 This routine figures out which branches need to expand; the actual
1928 expansion is done in mips_relocate_section when the section
1929 contents are relocated. The information is stored in the offsets
1930 field of the ecoff_section_tdata structure. An offset of 1 means
1931 that the branch must be expanded into a multi-instruction PC
1932 relative branch (such an offset will only occur for a PC relative
1933 branch to an external symbol). Any other offset must be a multiple
1934 of four, and is the amount to change the branch by (such an offset
1935 will only occur for a PC relative branch within the same section).
1936
1937 We do not modify the section relocs or contents themselves so that
1938 if memory usage becomes an issue we can discard them and read them
1939 again. The only information we must save in memory between this
1940 routine and the mips_relocate_section routine is the table of
1941 offsets. */
1942
1943 static boolean
1944 mips_relax_section (abfd, sec, info, again)
1945 bfd *abfd;
1946 asection *sec;
1947 struct bfd_link_info *info;
1948 boolean *again;
1949 {
1950 struct ecoff_section_tdata *section_tdata;
1951 bfd_byte *contents = NULL;
1952 long *offsets;
1953 struct external_reloc *ext_rel;
1954 struct external_reloc *ext_rel_end;
1955 unsigned int i;
1956
1957 /* Assume we are not going to need another pass. */
1958 *again = false;
1959
1960 /* If we are not generating an ECOFF file, this is much too
1961 confusing to deal with. */
1962 if (info->hash->creator->flavour != bfd_get_flavour (abfd))
1963 return true;
1964
1965 /* If there are no relocs, there is nothing to do. */
1966 if (sec->reloc_count == 0)
1967 return true;
1968
1969 /* We are only interested in PC relative relocs, and why would there
1970 ever be one from anything but the .text section? */
1971 if (strcmp (bfd_get_section_name (abfd, sec), ".text") != 0)
1972 return true;
1973
1974 /* Read in the relocs, if we haven't already got them. */
1975 section_tdata = ecoff_section_data (abfd, sec);
1976 if (section_tdata == (struct ecoff_section_tdata *) NULL
1977 || section_tdata->external_relocs == NULL)
1978 {
1979 if (! mips_read_relocs (abfd, sec))
1980 goto error_return;
1981 section_tdata = ecoff_section_data (abfd, sec);
1982 }
1983
1984 if (sec->_cooked_size == 0)
1985 {
1986 /* We must initialize _cooked_size only the first time we are
1987 called. */
1988 sec->_cooked_size = sec->_raw_size;
1989 }
1990
1991 contents = section_tdata->contents;
1992 offsets = section_tdata->offsets;
1993
1994 /* Look for any external PC relative relocs. Internal PC relative
1995 relocs are already correct in the object file, so they certainly
1996 can not overflow. */
1997 ext_rel = (struct external_reloc *) section_tdata->external_relocs;
1998 ext_rel_end = ext_rel + sec->reloc_count;
1999 for (i = 0; ext_rel < ext_rel_end; ext_rel++, i++)
2000 {
2001 struct internal_reloc int_rel;
2002 struct ecoff_link_hash_entry *h;
2003 asection *hsec;
2004 bfd_signed_vma relocation;
2005 struct external_reloc *adj_ext_rel;
2006 unsigned int adj_i;
2007 unsigned long ext_count;
2008 struct ecoff_link_hash_entry **adj_h_ptr;
2009 struct ecoff_link_hash_entry **adj_h_ptr_end;
2010 struct ecoff_value_adjust *adjust;
2011
2012 /* If we have already expanded this reloc, we certainly don't
2013 need to do it again. */
2014 if (offsets != (long *) NULL && offsets[i] == 1)
2015 continue;
2016
2017 /* Quickly check that this reloc is external PCREL16. */
2018 if (bfd_header_big_endian (abfd))
2019 {
2020 if ((ext_rel->r_bits[3] & RELOC_BITS3_EXTERN_BIG) == 0
2021 || (((ext_rel->r_bits[3] & RELOC_BITS3_TYPE_BIG)
2022 >> RELOC_BITS3_TYPE_SH_BIG)
2023 != MIPS_R_PCREL16))
2024 continue;
2025 }
2026 else
2027 {
2028 if ((ext_rel->r_bits[3] & RELOC_BITS3_EXTERN_LITTLE) == 0
2029 || (((ext_rel->r_bits[3] & RELOC_BITS3_TYPE_LITTLE)
2030 >> RELOC_BITS3_TYPE_SH_LITTLE)
2031 != MIPS_R_PCREL16))
2032 continue;
2033 }
2034
2035 mips_ecoff_swap_reloc_in (abfd, (PTR) ext_rel, &int_rel);
2036
2037 h = ecoff_data (abfd)->sym_hashes[int_rel.r_symndx];
2038 if (h == (struct ecoff_link_hash_entry *) NULL)
2039 abort ();
2040
2041 if (h->root.type != bfd_link_hash_defined
2042 && h->root.type != bfd_link_hash_defweak)
2043 {
2044 /* Just ignore undefined symbols. These will presumably
2045 generate an error later in the link. */
2046 continue;
2047 }
2048
2049 /* Get the value of the symbol. */
2050 hsec = h->root.u.def.section;
2051 relocation = (h->root.u.def.value
2052 + hsec->output_section->vma
2053 + hsec->output_offset);
2054
2055 /* Subtract out the current address. */
2056 relocation -= (sec->output_section->vma
2057 + sec->output_offset
2058 + (int_rel.r_vaddr - sec->vma));
2059
2060 /* The addend is stored in the object file. In the normal case
2061 of ``bal symbol'', the addend will be -4. It will only be
2062 different in the case of ``bal symbol+constant''. To avoid
2063 always reading in the section contents, we don't check the
2064 addend in the object file (we could easily check the contents
2065 if we happen to have already read them in, but I fear that
2066 this could be confusing). This means we will screw up if
2067 there is a branch to a symbol that is in range, but added to
2068 a constant which puts it out of range; in such a case the
2069 link will fail with a reloc overflow error. Since the
2070 compiler will never generate such code, it should be easy
2071 enough to work around it by changing the assembly code in the
2072 source file. */
2073 relocation -= 4;
2074
2075 /* Now RELOCATION is the number we want to put in the object
2076 file. See whether it fits. */
2077 if (relocation >= -0x20000 && relocation < 0x20000)
2078 continue;
2079
2080 /* Now that we know this reloc needs work, which will rarely
2081 happen, go ahead and grab the section contents. */
2082 if (contents == (bfd_byte *) NULL)
2083 {
2084 if (info->keep_memory)
2085 contents = (bfd_byte *) bfd_alloc (abfd, sec->_raw_size);
2086 else
2087 contents = (bfd_byte *) bfd_malloc ((size_t) sec->_raw_size);
2088 if (contents == (bfd_byte *) NULL)
2089 goto error_return;
2090 if (! bfd_get_section_contents (abfd, sec, (PTR) contents,
2091 (file_ptr) 0, sec->_raw_size))
2092 goto error_return;
2093 if (info->keep_memory)
2094 section_tdata->contents = contents;
2095 }
2096
2097 /* We only support changing the bal instruction. It would be
2098 possible to handle other PC relative branches, but some of
2099 them (the conditional branches) would require a different
2100 length instruction sequence which would complicate both this
2101 routine and mips_relax_pcrel16. It could be written if
2102 somebody felt it were important. Ignoring this reloc will
2103 presumably cause a reloc overflow error later on. */
2104 if (bfd_get_32 (abfd, contents + int_rel.r_vaddr - sec->vma)
2105 != 0x0411ffff) /* bgezal $0,. == bal . */
2106 continue;
2107
2108 /* Bother. We need to expand this reloc, and we will need to
2109 make another relaxation pass since this change may put other
2110 relocs out of range. We need to examine the local branches
2111 and we need to allocate memory to hold the offsets we must
2112 add to them. We also need to adjust the values of all
2113 symbols in the object file following this location. */
2114
2115 sec->_cooked_size += PCREL16_EXPANSION_ADJUSTMENT;
2116 *again = true;
2117
2118 if (offsets == (long *) NULL)
2119 {
2120 size_t size;
2121
2122 size = sec->reloc_count * sizeof (long);
2123 offsets = (long *) bfd_alloc (abfd, size);
2124 if (offsets == (long *) NULL)
2125 goto error_return;
2126 memset (offsets, 0, size);
2127 section_tdata->offsets = offsets;
2128 }
2129
2130 offsets[i] = 1;
2131
2132 /* Now look for all PC relative references that cross this reloc
2133 and adjust their offsets. */
2134 adj_ext_rel = (struct external_reloc *) section_tdata->external_relocs;
2135 for (adj_i = 0; adj_ext_rel < ext_rel_end; adj_ext_rel++, adj_i++)
2136 {
2137 struct internal_reloc adj_int_rel;
2138 bfd_vma start, stop;
2139 int change;
2140
2141 mips_ecoff_swap_reloc_in (abfd, (PTR) adj_ext_rel, &adj_int_rel);
2142
2143 if (adj_int_rel.r_type == MIPS_R_PCREL16)
2144 {
2145 unsigned long insn;
2146
2147 /* We only care about local references. External ones
2148 will be relocated correctly anyhow. */
2149 if (adj_int_rel.r_extern)
2150 continue;
2151
2152 /* We are only interested in a PC relative reloc within
2153 this section. FIXME: Cross section PC relative
2154 relocs may not be handled correctly; does anybody
2155 care? */
2156 if (adj_int_rel.r_symndx != RELOC_SECTION_TEXT)
2157 continue;
2158
2159 start = adj_int_rel.r_vaddr;
2160
2161 insn = bfd_get_32 (abfd,
2162 contents + adj_int_rel.r_vaddr - sec->vma);
2163
2164 stop = (insn & 0xffff) << 2;
2165 if ((stop & 0x20000) != 0)
2166 stop -= 0x40000;
2167 stop += adj_int_rel.r_vaddr + 4;
2168 }
2169 else if (adj_int_rel.r_type == MIPS_R_RELHI)
2170 {
2171 struct internal_reloc rello;
2172 long addhi, addlo;
2173
2174 /* The next reloc must be MIPS_R_RELLO, and we handle
2175 them together. */
2176 BFD_ASSERT (adj_ext_rel + 1 < ext_rel_end);
2177
2178 mips_ecoff_swap_reloc_in (abfd, (PTR) (adj_ext_rel + 1), &rello);
2179
2180 BFD_ASSERT (rello.r_type == MIPS_R_RELLO);
2181
2182 addhi = bfd_get_32 (abfd,
2183 contents + adj_int_rel.r_vaddr - sec->vma);
2184 addhi &= 0xffff;
2185 if (addhi & 0x8000)
2186 addhi -= 0x10000;
2187 addhi <<= 16;
2188
2189 addlo = bfd_get_32 (abfd, contents + rello.r_vaddr - sec->vma);
2190 addlo &= 0xffff;
2191 if (addlo & 0x8000)
2192 addlo -= 0x10000;
2193
2194 if (adj_int_rel.r_extern)
2195 {
2196 /* The value we want here is
2197 sym - RELLOaddr + addend
2198 which we can express as
2199 sym - (RELLOaddr - addend)
2200 Therefore if we are expanding the area between
2201 RELLOaddr and RELLOaddr - addend we must adjust
2202 the addend. This is admittedly ambiguous, since
2203 we might mean (sym + addend) - RELLOaddr, but in
2204 practice we don't, and there is no way to handle
2205 that case correctly since at this point we have
2206 no idea whether any reloc is being expanded
2207 between sym and sym + addend. */
2208 start = rello.r_vaddr - (addhi + addlo);
2209 stop = rello.r_vaddr;
2210 }
2211 else
2212 {
2213 /* An internal RELHI/RELLO pair represents the
2214 difference between two addresses, $LC0 - foo.
2215 The symndx value is actually the difference
2216 between the reloc address and $LC0. This lets us
2217 compute $LC0, and, by considering the addend,
2218 foo. If the reloc we are expanding falls between
2219 those two relocs, we must adjust the addend. At
2220 this point, the symndx value is actually in the
2221 r_offset field, where it was put by
2222 mips_ecoff_swap_reloc_in. */
2223 start = rello.r_vaddr - adj_int_rel.r_offset;
2224 stop = start + addhi + addlo;
2225 }
2226 }
2227 else if (adj_int_rel.r_type == MIPS_R_SWITCH)
2228 {
2229 /* A MIPS_R_SWITCH reloc represents a word of the form
2230 .word $L3-$LS12
2231 The value in the object file is correct, assuming the
2232 original value of $L3. The symndx value is actually
2233 the difference between the reloc address and $LS12.
2234 This lets us compute the original value of $LS12 as
2235 vaddr - symndx
2236 and the original value of $L3 as
2237 vaddr - symndx + addend
2238 where addend is the value from the object file. At
2239 this point, the symndx value is actually found in the
2240 r_offset field, since it was moved by
2241 mips_ecoff_swap_reloc_in. */
2242 start = adj_int_rel.r_vaddr - adj_int_rel.r_offset;
2243 stop = start + bfd_get_32 (abfd,
2244 (contents
2245 + adj_int_rel.r_vaddr
2246 - sec->vma));
2247 }
2248 else
2249 continue;
2250
2251 /* If the range expressed by this reloc, which is the
2252 distance between START and STOP crosses the reloc we are
2253 expanding, we must adjust the offset. The sign of the
2254 adjustment depends upon the direction in which the range
2255 crosses the reloc being expanded. */
2256 if (start <= int_rel.r_vaddr && stop > int_rel.r_vaddr)
2257 change = PCREL16_EXPANSION_ADJUSTMENT;
2258 else if (start > int_rel.r_vaddr && stop <= int_rel.r_vaddr)
2259 change = - PCREL16_EXPANSION_ADJUSTMENT;
2260 else
2261 change = 0;
2262
2263 offsets[adj_i] += change;
2264
2265 if (adj_int_rel.r_type == MIPS_R_RELHI)
2266 {
2267 adj_ext_rel++;
2268 adj_i++;
2269 offsets[adj_i] += change;
2270 }
2271 }
2272
2273 /* Find all symbols in this section defined by this object file
2274 and adjust their values. Note that we decide whether to
2275 adjust the value based on the value stored in the ECOFF EXTR
2276 structure, because the value stored in the hash table may
2277 have been changed by an earlier expanded reloc and thus may
2278 no longer correctly indicate whether the symbol is before or
2279 after the expanded reloc. */
2280 ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax;
2281 adj_h_ptr = ecoff_data (abfd)->sym_hashes;
2282 adj_h_ptr_end = adj_h_ptr + ext_count;
2283 for (; adj_h_ptr < adj_h_ptr_end; adj_h_ptr++)
2284 {
2285 struct ecoff_link_hash_entry *adj_h;
2286
2287 adj_h = *adj_h_ptr;
2288 if (adj_h != (struct ecoff_link_hash_entry *) NULL
2289 && (adj_h->root.type == bfd_link_hash_defined
2290 || adj_h->root.type == bfd_link_hash_defweak)
2291 && adj_h->root.u.def.section == sec
2292 && adj_h->esym.asym.value > int_rel.r_vaddr)
2293 adj_h->root.u.def.value += PCREL16_EXPANSION_ADJUSTMENT;
2294 }
2295
2296 /* Add an entry to the symbol value adjust list. This is used
2297 by bfd_ecoff_debug_accumulate to adjust the values of
2298 internal symbols and FDR's. */
2299 adjust = ((struct ecoff_value_adjust *)
2300 bfd_alloc (abfd, sizeof (struct ecoff_value_adjust)));
2301 if (adjust == (struct ecoff_value_adjust *) NULL)
2302 goto error_return;
2303
2304 adjust->start = int_rel.r_vaddr;
2305 adjust->end = sec->vma + sec->_raw_size;
2306 adjust->adjust = PCREL16_EXPANSION_ADJUSTMENT;
2307
2308 adjust->next = ecoff_data (abfd)->debug_info.adjust;
2309 ecoff_data (abfd)->debug_info.adjust = adjust;
2310 }
2311
2312 if (contents != (bfd_byte *) NULL && ! info->keep_memory)
2313 free (contents);
2314
2315 return true;
2316
2317 error_return:
2318 if (contents != (bfd_byte *) NULL && ! info->keep_memory)
2319 free (contents);
2320 return false;
2321 }
2322
2323 /* This routine is called from mips_relocate_section when a PC
2324 relative reloc must be expanded into the five instruction sequence.
2325 It handles all the details of the expansion, including resolving
2326 the reloc. */
2327
2328 static boolean
2329 mips_relax_pcrel16 (info, input_bfd, input_section, h, location, address)
2330 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2331 bfd *input_bfd;
2332 asection *input_section ATTRIBUTE_UNUSED;
2333 struct ecoff_link_hash_entry *h;
2334 bfd_byte *location;
2335 bfd_vma address;
2336 {
2337 bfd_vma relocation;
2338
2339 /* 0x0411ffff is bgezal $0,. == bal . */
2340 BFD_ASSERT (bfd_get_32 (input_bfd, location) == 0x0411ffff);
2341
2342 /* We need to compute the distance between the symbol and the
2343 current address plus eight. */
2344 relocation = (h->root.u.def.value
2345 + h->root.u.def.section->output_section->vma
2346 + h->root.u.def.section->output_offset);
2347 relocation -= address + 8;
2348
2349 /* If the lower half is negative, increment the upper 16 half. */
2350 if ((relocation & 0x8000) != 0)
2351 relocation += 0x10000;
2352
2353 bfd_put_32 (input_bfd, 0x04110001, location); /* bal .+8 */
2354 bfd_put_32 (input_bfd,
2355 0x3c010000 | ((relocation >> 16) & 0xffff), /* lui $at,XX */
2356 location + 4);
2357 bfd_put_32 (input_bfd,
2358 0x24210000 | (relocation & 0xffff), /* addiu $at,$at,XX */
2359 location + 8);
2360 bfd_put_32 (input_bfd, 0x003f0821, location + 12); /* addu $at,$at,$ra */
2361 bfd_put_32 (input_bfd, 0x0020f809, location + 16); /* jalr $at */
2362
2363 return true;
2364 }
2365
2366 /* Given a .sdata section and a .rel.sdata in-memory section, store
2367 relocation information into the .rel.sdata section which can be
2368 used at runtime to relocate the section. This is called by the
2369 linker when the --embedded-relocs switch is used. This is called
2370 after the add_symbols entry point has been called for all the
2371 objects, and before the final_link entry point is called. This
2372 function presumes that the object was compiled using
2373 -membedded-pic. */
2374
2375 boolean
2376 bfd_mips_ecoff_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
2377 bfd *abfd;
2378 struct bfd_link_info *info;
2379 asection *datasec;
2380 asection *relsec;
2381 char **errmsg;
2382 {
2383 struct ecoff_link_hash_entry **sym_hashes;
2384 struct ecoff_section_tdata *section_tdata;
2385 struct external_reloc *ext_rel;
2386 struct external_reloc *ext_rel_end;
2387 bfd_byte *p;
2388
2389 BFD_ASSERT (! info->relocateable);
2390
2391 *errmsg = NULL;
2392
2393 if (datasec->reloc_count == 0)
2394 return true;
2395
2396 sym_hashes = ecoff_data (abfd)->sym_hashes;
2397
2398 if (! mips_read_relocs (abfd, datasec))
2399 return false;
2400
2401 relsec->contents = (bfd_byte *) bfd_alloc (abfd, datasec->reloc_count * 4);
2402 if (relsec->contents == NULL)
2403 return false;
2404
2405 p = relsec->contents;
2406
2407 section_tdata = ecoff_section_data (abfd, datasec);
2408 ext_rel = (struct external_reloc *) section_tdata->external_relocs;
2409 ext_rel_end = ext_rel + datasec->reloc_count;
2410 for (; ext_rel < ext_rel_end; ext_rel++, p += 4)
2411 {
2412 struct internal_reloc int_rel;
2413 boolean text_relative;
2414
2415 mips_ecoff_swap_reloc_in (abfd, (PTR) ext_rel, &int_rel);
2416
2417 /* We are going to write a four byte word into the runtime reloc
2418 section. The word will be the address in the data section
2419 which must be relocated. This must be on a word boundary,
2420 which means the lower two bits must be zero. We use the
2421 least significant bit to indicate how the value in the data
2422 section must be relocated. A 0 means that the value is
2423 relative to the text section, while a 1 indicates that the
2424 value is relative to the data section. Given that we are
2425 assuming the code was compiled using -membedded-pic, there
2426 should not be any other possibilities. */
2427
2428 /* We can only relocate REFWORD relocs at run time. */
2429 if (int_rel.r_type != MIPS_R_REFWORD)
2430 {
2431 *errmsg = _("unsupported reloc type");
2432 bfd_set_error (bfd_error_bad_value);
2433 return false;
2434 }
2435
2436 if (int_rel.r_extern)
2437 {
2438 struct ecoff_link_hash_entry *h;
2439
2440 h = sym_hashes[int_rel.r_symndx];
2441 /* If h is NULL, that means that there is a reloc against an
2442 external symbol which we thought was just a debugging
2443 symbol. This should not happen. */
2444 if (h == (struct ecoff_link_hash_entry *) NULL)
2445 abort ();
2446 if ((h->root.type == bfd_link_hash_defined
2447 || h->root.type == bfd_link_hash_defweak)
2448 && (h->root.u.def.section->flags & SEC_CODE) != 0)
2449 text_relative = true;
2450 else
2451 text_relative = false;
2452 }
2453 else
2454 {
2455 switch (int_rel.r_symndx)
2456 {
2457 case RELOC_SECTION_TEXT:
2458 text_relative = true;
2459 break;
2460 case RELOC_SECTION_SDATA:
2461 case RELOC_SECTION_SBSS:
2462 case RELOC_SECTION_LIT8:
2463 text_relative = false;
2464 break;
2465 default:
2466 /* No other sections should appear in -membedded-pic
2467 code. */
2468 *errmsg = _("reloc against unsupported section");
2469 bfd_set_error (bfd_error_bad_value);
2470 return false;
2471 }
2472 }
2473
2474 if ((int_rel.r_offset & 3) != 0)
2475 {
2476 *errmsg = _("reloc not properly aligned");
2477 bfd_set_error (bfd_error_bad_value);
2478 return false;
2479 }
2480
2481 bfd_put_32 (abfd,
2482 (int_rel.r_vaddr - datasec->vma + datasec->output_offset
2483 + (text_relative ? 0 : 1)),
2484 p);
2485 }
2486
2487 return true;
2488 }
2489 \f
2490 /* This is the ECOFF backend structure. The backend field of the
2491 target vector points to this. */
2492
2493 static const struct ecoff_backend_data mips_ecoff_backend_data =
2494 {
2495 /* COFF backend structure. */
2496 {
2497 (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
2498 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
2499 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
2500 (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
2501 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
2502 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
2503 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
2504 mips_ecoff_swap_filehdr_out, mips_ecoff_swap_aouthdr_out,
2505 mips_ecoff_swap_scnhdr_out,
2506 FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, true, false, 4, false, 2,
2507 mips_ecoff_swap_filehdr_in, mips_ecoff_swap_aouthdr_in,
2508 mips_ecoff_swap_scnhdr_in, NULL,
2509 mips_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
2510 _bfd_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
2511 _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
2512 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2513 NULL, NULL
2514 },
2515 /* Supported architecture. */
2516 bfd_arch_mips,
2517 /* Initial portion of armap string. */
2518 "__________",
2519 /* The page boundary used to align sections in a demand-paged
2520 executable file. E.g., 0x1000. */
2521 0x1000,
2522 /* True if the .rdata section is part of the text segment, as on the
2523 Alpha. False if .rdata is part of the data segment, as on the
2524 MIPS. */
2525 false,
2526 /* Bitsize of constructor entries. */
2527 32,
2528 /* Reloc to use for constructor entries. */
2529 &mips_howto_table[MIPS_R_REFWORD],
2530 {
2531 /* Symbol table magic number. */
2532 magicSym,
2533 /* Alignment of debugging information. E.g., 4. */
2534 4,
2535 /* Sizes of external symbolic information. */
2536 sizeof (struct hdr_ext),
2537 sizeof (struct dnr_ext),
2538 sizeof (struct pdr_ext),
2539 sizeof (struct sym_ext),
2540 sizeof (struct opt_ext),
2541 sizeof (struct fdr_ext),
2542 sizeof (struct rfd_ext),
2543 sizeof (struct ext_ext),
2544 /* Functions to swap in external symbolic data. */
2545 ecoff_swap_hdr_in,
2546 ecoff_swap_dnr_in,
2547 ecoff_swap_pdr_in,
2548 ecoff_swap_sym_in,
2549 ecoff_swap_opt_in,
2550 ecoff_swap_fdr_in,
2551 ecoff_swap_rfd_in,
2552 ecoff_swap_ext_in,
2553 _bfd_ecoff_swap_tir_in,
2554 _bfd_ecoff_swap_rndx_in,
2555 /* Functions to swap out external symbolic data. */
2556 ecoff_swap_hdr_out,
2557 ecoff_swap_dnr_out,
2558 ecoff_swap_pdr_out,
2559 ecoff_swap_sym_out,
2560 ecoff_swap_opt_out,
2561 ecoff_swap_fdr_out,
2562 ecoff_swap_rfd_out,
2563 ecoff_swap_ext_out,
2564 _bfd_ecoff_swap_tir_out,
2565 _bfd_ecoff_swap_rndx_out,
2566 /* Function to read in symbolic data. */
2567 _bfd_ecoff_slurp_symbolic_info
2568 },
2569 /* External reloc size. */
2570 RELSZ,
2571 /* Reloc swapping functions. */
2572 mips_ecoff_swap_reloc_in,
2573 mips_ecoff_swap_reloc_out,
2574 /* Backend reloc tweaking. */
2575 mips_adjust_reloc_in,
2576 mips_adjust_reloc_out,
2577 /* Relocate section contents while linking. */
2578 mips_relocate_section,
2579 /* Do final adjustments to filehdr and aouthdr. */
2580 NULL,
2581 /* Read an element from an archive at a given file position. */
2582 _bfd_get_elt_at_filepos
2583 };
2584
2585 /* Looking up a reloc type is MIPS specific. */
2586 #define _bfd_ecoff_bfd_reloc_type_lookup mips_bfd_reloc_type_lookup
2587
2588 /* Getting relocated section contents is generic. */
2589 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2590 bfd_generic_get_relocated_section_contents
2591
2592 /* Handling file windows is generic. */
2593 #define _bfd_ecoff_get_section_contents_in_window \
2594 _bfd_generic_get_section_contents_in_window
2595
2596 /* Relaxing sections is MIPS specific. */
2597 #define _bfd_ecoff_bfd_relax_section mips_relax_section
2598
2599 /* GC of sections is not done. */
2600 #define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
2601
2602 extern const bfd_target ecoff_big_vec;
2603
2604 const bfd_target ecoff_little_vec =
2605 {
2606 "ecoff-littlemips", /* name */
2607 bfd_target_ecoff_flavour,
2608 BFD_ENDIAN_LITTLE, /* data byte order is little */
2609 BFD_ENDIAN_LITTLE, /* header byte order is little */
2610
2611 (HAS_RELOC | EXEC_P | /* object flags */
2612 HAS_LINENO | HAS_DEBUG |
2613 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2614
2615 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2616 0, /* leading underscore */
2617 ' ', /* ar_pad_char */
2618 15, /* ar_max_namelen */
2619 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2620 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2621 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2622 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2623 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2624 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2625
2626 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2627 _bfd_ecoff_archive_p, _bfd_dummy_target},
2628 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
2629 _bfd_generic_mkarchive, bfd_false},
2630 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2631 _bfd_write_archive_contents, bfd_false},
2632
2633 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2634 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2635 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2636 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2637 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2638 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2639 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2640 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2641 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2642
2643 & ecoff_big_vec,
2644
2645 (PTR) &mips_ecoff_backend_data
2646 };
2647
2648 const bfd_target ecoff_big_vec =
2649 {
2650 "ecoff-bigmips", /* name */
2651 bfd_target_ecoff_flavour,
2652 BFD_ENDIAN_BIG, /* data byte order is big */
2653 BFD_ENDIAN_BIG, /* header byte order is big */
2654
2655 (HAS_RELOC | EXEC_P | /* object flags */
2656 HAS_LINENO | HAS_DEBUG |
2657 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2658
2659 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2660 0, /* leading underscore */
2661 ' ', /* ar_pad_char */
2662 15, /* ar_max_namelen */
2663 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2664 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2665 bfd_getb16, bfd_getb_signed_16, bfd_putb16,
2666 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2667 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2668 bfd_getb16, bfd_getb_signed_16, bfd_putb16,
2669 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2670 _bfd_ecoff_archive_p, _bfd_dummy_target},
2671 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
2672 _bfd_generic_mkarchive, bfd_false},
2673 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2674 _bfd_write_archive_contents, bfd_false},
2675
2676 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2677 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2678 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2679 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2680 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2681 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2682 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2683 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2684 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2685
2686 & ecoff_little_vec,
2687
2688 (PTR) &mips_ecoff_backend_data
2689 };
2690
2691 const bfd_target ecoff_biglittle_vec =
2692 {
2693 "ecoff-biglittlemips", /* name */
2694 bfd_target_ecoff_flavour,
2695 BFD_ENDIAN_LITTLE, /* data byte order is little */
2696 BFD_ENDIAN_BIG, /* header byte order is big */
2697
2698 (HAS_RELOC | EXEC_P | /* object flags */
2699 HAS_LINENO | HAS_DEBUG |
2700 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2701
2702 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2703 0, /* leading underscore */
2704 ' ', /* ar_pad_char */
2705 15, /* ar_max_namelen */
2706 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2707 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2708 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2709 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2710 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2711 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
2712
2713 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2714 _bfd_ecoff_archive_p, _bfd_dummy_target},
2715 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
2716 _bfd_generic_mkarchive, bfd_false},
2717 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2718 _bfd_write_archive_contents, bfd_false},
2719
2720 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2721 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2722 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2723 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2724 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2725 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2726 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2727 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2728 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2729
2730 NULL,
2731
2732 (PTR) &mips_ecoff_backend_data
2733 };
GDB Binutils - Deliverables
This page took 0.118304 seconds and 5 git commands to generate.